Proiect STRD

Modulator-Demodulator Discrete Multi-Tone (DMT) ce foloseste procesorul de semnal ADSP

Blackfin

Masterand:Adrian TudoranTheodora-Andreea Pascu

prof. dr. ing Sorin Zoican

-2013-

1

2

1. MODULATIA DMT (DISCRETE MULTI TONE)

1.1. Modulaţia Discrete Multi-Tone (DMT)

Principiul DMT:

Transmisie cu purtatoare unicaFaţă de transmisia cu purtătoare unică, unde fluxul de date se transmite serie pe o

singură purtătoare, iar durata bitului este T, într-o transmisie OFDM pe N subpurtatoare fluxul de date se distribuie în paralel pe cele N subpurtatoare, prin această operaţie durata bitului transmis pe o subpurtatoare crescând de N ori la valoarea NT.

Transmisie multipurtatoareVariantele OFDM implică fie folosirea de spectre limitate ca bandă prin filtrare, pe

fiecare subpurtatoare, care nu se suprapun, fie spectre cu suprapunere care sunt mai eficiente din punct de vedere al utilizării benzii. În acest din urmă caz, separarea canalelor fără interferenţe intercanal se face utilizând proprietatea de ortogonalitate a subpurtatoarelor. Un prim avantaj al tehnicii OFDM este acela că utilizează în mod eficient banda avuta la dispoziţie, având în vedere că spectrele componente se suprapun, dar semnalele pot fi separate datorită ortogonalităţii subpurtatoarelor.

Canalele radio, datorită fenomenelor de multi-path , Doppler , fading, jitter de fază şi zgomotelor puternice, oferă adeseori transmisiei digitale o calitate slabă. Soluţia tehnică actuală privind modularea semnalului astfel ca sistemul să lucreze efficient cu semnale afectate de distorsiuni puternice este OFDM.Principiul de bază este acela al divizării informaţiei de viteză mare în fluxuri de viteză mică şi transmiterea acestora utilizând un număr mare de subpurtatoare ortogonale. Se urmăreşte asigurarea unor viteze de transmisie ridicate, simplificând cerinţele impuse circuitelor de egalizare, acolo unde este posibil. Această tehnică este cunoscută şi sub denumirile de purtătoare multiple ( multi-carrier) sau modulaţie DMT ( Discrete Multi-Tone modulation).

3

Figure 1-1 Schema de principiu a unui modem DMT

1.2. Implementarea unui modulator DMT

Un sistem tipic de comunicaţii primeşte date, realizează câteva procesări şi translatări de frecvenţă, transmite datele şi realizează operaţiunile inverse la recepţie. Într-un sistem de comunicaţie digital, semnalul de intrare în modem este un semnal digital de la o sursă digitală sau de la un codor de canal. Dacă, totuşi, semnalul de intrare în modem este generat de o sursa analogică de informaţie, semnalul trebuie mai întâi limitat într-o bandă B înainte ca eşantionarea să aibă loc. Conform teoriei fundamentale a lui Nyquist frecvenţa de eşantionare trebuie să fie mai mare sau egală cu dublul lărgimii benzii B, fs≥2B. Dacă această condiţie este îndeplinită, semnalul original cu bandă limitată poate fi refăcut din eşantioanele sale cu ajutorul unui filtru trece-jos având frecvenţa de tăiere de valoare B.

1.2.1. Conversia analog-digitală

Convertorul analog-digital preia semnalul cu spectru limitat ce se doreşte a fi transmis şi îl digitizează prin coversia nivelului fiecărui eşantion la un nivel discret. De exemplu, într-un convertor pe 8 biţi. Fiecare nivel discret este reprezentat de opt biţi de ieşire. Acest lucru furnizează o rezoluţie de 256 de niveluri digitale distincte. Comportamentul ADC-ului este prezentat în figura 1.8, unde un semnal analogic tipic este desenat în paralel cu echivalentul său digitizat, folosind un număr mic de biţi de cuantizare.

Figure 1-2 Semnal analogic - Semnal digital

4

Diferenţa majoră dintre sistemele de comunicaţie digitală şi sistemele tradiţionale analogice este tehnica transmisiei semnalului. Într-un sistem radio analog, semnalul ce va fi transmis este modulat direct, de obicei printr-o simplă multiplicare a semnalului de date cu purtătoarea. Pe de altă parte, sistemele digitale trebuie să incorporeze metoda de modulaţie care pot să mapeze datele de intrare cu o purtătoare. Avantajul folosirii tehnicii digitale mai sofisticate este că legătura digitală poate fi realizată fără erori prin intermediul procesării de semnal, în timp ce sistemele analogice zgomotul termic inerent echipamentelor întotdeauna cauzează erori şi, astfel, pierderi de informaţie.

1.2.2. Maparea

Procesul de mapare între biţii de informaţie şi simbolurile ce vor modula purtătoarele I şi Q joacă un rol fundamental în determinarea proprietăţilor modemului. Maparea poate fi realizată cu ajutorul digramei de constelaţie.

Constelaţia este reprezentarea grafică bidimensională într-un sistem de axe cartezian a nivelurilor I şi Q corespunzătoare fiecărui punct ce poate fi transmis. Pentru o modulaţie simplă binară de amplitudine, constelaţia ar fi formată din două puncte, ambele plasate pe axa x pozitivă. Pentru o modulaţie BPSK (Binary Phase Shift Keying), constelaţia ar consta de asemenea din două puncte pe axa x, dar de această data plasate la distanţe echidistante de origine, unul în partea stângă şi unul în partea dreaptă. Punctul situat în stânga corespunde unei defazări cu 180o . Dacă permitem defazări diferite de 0 şi 180 de grade, atunci punctele constelaţiei „sar” de pe axa x. Aceste puncte sunt considerate a avea şi amplitudine şi fază, amplitudinea reprezentând mărimea purtătoarei transmise şi faza reprezentând defazarea purtătoarei faţă de oscilatorul local al transmiţătorului. Punctele din constelaţie au coordonate carteziene, sau complexe, care sunt de fapt componentele în fază (I) şi în cuadratură (Q), corespunzătoare axelor x şi respectiv y.

Figure 1-3 Maparea 16-QAM

5

În constelaţia pătrată din figura 1.3, fiecare fazor este reprezentat de un simbol format din 4 biţi, constituit din biţii în fază i1,i2 şi biţii în cuadratură q1,q2, care sunt întreţesuţi pentru a rezulta secvenţa i1,q1,i2,q2.

Observaţi din figura 1.9 că distanţa Hamming dintre punctele constelaţiei, care sunt „cele mai învecinenate” cu distanţa euclidiană 2d, este întotdeauna 1.

Distanţa Hamming – Distanţa Hamming dintre oricare două puncte ale constelaţiei, este numărul de diferenţe dintre poziţiile biţilor corespunzători celor două puncte. Spre exemplu, punctele 0101 şi 0111 au o distanţă Hamming 1, iar punctele 0101 şi 0011 au o distanţă Hamming 2.

Codarea Gray – Componentele I şi Q sunt codate Gray prin asignarea biţilor 01, 00, 10 şi 11 nivelurilor 3d,d, -d şi respectiv -3d. Această constelaţie este utilizată foarte des deoarece are puncte echidistante aranjate în aşa fel încât energia medie e fazorilor este maximizată. Principala caracteristică a codării Gray este aceea că asigură faptul că atunci când orice fazor transmis este afectat de zgomot suficient de mult încât să fie incorect identificat la recepţie ca un punct vecin din constelaţie, eroarea sa fie asupra unui singur bit. Codarea Gray minimizează probabilitatea de eroare.

1.2.3. Transformata Fourier Inversa

Algoritmul FFTEste esenţial, pentru început, să fie subliniat faptul că algoritmul FFT pentru calculul transformatei Fourier discrete a unei secvenţe este punctul nodal al procesării semnalelor digitale. El este aplicat în filtrare, convoluţie, calculul răspunsului la frecvenţă, ca şi în aplicaţii referitoare la estimarea spectrului de putere.

Cele două funcţii care urmează implementează perechea transformata Fourier – transformata Fourier inversă dată:

X(k+1)= X(n+1)= , (3.1)

unde -j2n şi N=lungime(x)

6

2. PROCESORUL DE SEMNAL BLACKFIN

2.1. Procesoare de semnal

2.1.1. Structura generală a unui procesor de semnal

În figura 2.1 este prezentată o configuraţie generică a unui procesor de semnal constituit din: unitatea de procesare memorie unitatea de transfer a datelor procesorul de intrare / ieşire procesorul de control

Figure 2-4 Procesor de semnal generic

În structură pot exista mai multe unităţi de prelucrare distribuite, cu memorii private sau comune. Transferul datelor şi conflictele de acces la memorie pot constitui elemente de reducere a vitezei globale de operare a procesorului. Pentru evitarea acestui fenomen se utilizează proiectarea modularizată, cu partajarea sarcinilor între unităţile de prelucrare. Acest lucru este valabil atît pentru procesoarele de semnal nou create cât şi pentru structurile de prelucrare cu mai multe procesoare integrate interconectate.

Procesorul de intrare - iesire (I /O) asigură preluarea semnalului de intrare şi generarea semnalului de ieşire (filtrare de bandă, conversii, stocare a datelor, protocolul de comunicaţie cu exteriorul).

7

Memoria este caracterizată prin: capacitatea de stocare a datelor, lărgimea cuvântului de date, modurile de adresare a datelor, timpul de acces).Reţeaua de transfer a datelor asigură transmiterea datelor către toate unitătile funcţionale ale procesorului de semnal (transmisie de date, rutarea datelor, controlul asupra erorilor ).

Procesorul de control este caracterizat de: capacitatea de stocare a instrucţiunilor, viteza de execuţie , setul de instrucţiuni.

Unitatea de prelucrare asigură efectuarea operaţiilor de bază (operaţii aritmetice, logice) şi este caracterizată de: timpul de execuţie a intrucţiunilor, gradul de flexibilitate.Funcţiile procesorului de control sînt: interpretarea comenzilor primite din exterior, controlul transferului de date, controlul unităţilor de prelucrare şi controlul interfeţelor de intrare-ieşire.Aceste funcţii pot fi distribuite şi către alte elemente ale sistemului. De exemplu unităţile de prelucrare au posibilitatea de a controla local transferul datelor şi funcţiile aritmetice – logice proprii.Procesorul de control poate efectua prelucrări complementare aplicaţiei DSP (de uz general care nu au cerinte critice de timp : monitorizare , întreţinere etc. )Resursele procesorului de control includ capacitatea de stocare a datelor şi instrucţiunilor, setul de instrucţiuni, capabilitatea aritmetică.Elementele de prelucrare execută algoritmul DSP în timp real . Aceste elemente sînt specializate în efectuarea prelucrărilor specifice algoritmilor DSP.Reţeaua de transfer a datelor reprezintă un bloc esenţial în sistem; acest bloc poate avea influenţe majore în viteza de prelucrare global a sistemului.

Resursele reţelei de transfer a datelor includ: căile de rutare a datelor, lărgimea busurilor de transfer a datelor, viteza de transmisie, posibilitatea de transfer pe blocuri de date.

Cerinţele de control a reţelei de transfer includ protocoalele de comunicaţie şi modurile de adresare. Numărul de busuri reprezintă o problem care diminuează capacitatea de transfer a datelor între blocurile din figura 2.1; nu este convenabilă realizarea unei interconectări totale între blocuri datorită complexităţii tehnologice şi a necesităţii introducerii unor blocuri suplimentare de arbitare a cererilor de acces multiple.

Resursele memoriilor includ: capacitatea de stocare , lărgimea cuvântului de date, modurile de adresare controlul general al memoriei ( decodificare , comenzi ).

8

2.2. Procesorul ADSP Blackfin BF533

2.2.1. Arhitectura

Procesoarele Blackfin întruchipează un nou tip de procesoare integrate, pe 32 biţi proiectate special pentru a satisface nevoile de calcul si constrângerile puterii consumate ale aplicaţiilor integrate audio, video, pentru comunicaţii, industriale actuale.

Aceste procesoare oferă atingerea cu succes a performanţelor ridicate de procesare a semnalelor şi eficienţă a utilizării puterii cu ajutorul modelului de programare RISC (Reduced Instruction Set Computer), şi prezintă totodată target-uri softwere omogene care permit alocarea flexibilă a resurselor intre funcţiile real-time şi cele non real-time ale DSP-ului. De asemenea, procesoarele includ un management avansat al memoriei care suportă sisteme integrate de operare cu memorie protejată şi neprotejată cum sunt μCLinux, ThreadX® (Express Logic), INTEGRITY® andvelOSity™ (Green Hills Software), Nucleus® (Accelerated Technology), Fusion™ (Unicoi Systems), and RTXC Quadros™ (Quadros Systems) etc.Una din cele mai importante funcţionalităţi ale procesoarelor Blackfin este posibilitatea de a lucra atât ca microcontroller (MCU) cât şi ca DSP într-o arhitectură nedefinită, permiţând partiţionarea flexibilă între nevoile de control şi procesare a semnalului. Deci, dacă aplicaţia o cere procesorul poate lucra fie 100% ca un MCU, fie 100% ca un DSP fie ca o combinaţie dintre cele două.Perifericele unui procesor Blackfin au capacitatea de a suporta viteze ridicate ale datelor serial şi paralel. Astfel, procesoarele Blackfin au fost proiectate pentru a suporta atât controllere DMA cât şi Cache memory pentru a muta datele prin sistem. Toate perifericele cu excepţia ceasului în timp real (Real-Time Clock) şi Temporizatoarele, sunt suportate de o structura DMA flexibilă. Există de asemenea şi două canale separate de memorie DMA dedicate transferurilor de date între zonele de memorie ale procesorului, care includ SDRAM extern şi memoria asincronă. Magistralele multiple asigură destulă largime de bandă pentru a menţine procesorul în stare de execuţie chiar şi atunci când există activitate pe toate perifericele on-chip sau externe.

Figura nr. 2.7 Schema bloc a procesoarelor din gama Blackfin

9

Arhitectura procesorului Blackfin BF533

Procesorul ADSP-BF533 este membru al familiei Blackfin, şi oferă performanţe semnificativ ridicate şi un consum mai mic de putere faţă de toate cele anterioare, menţinând însă atât facilitatea ease-of-use cât şi beneficiile compatibilităţii codului.Arhitectura procesorului conţine două multiplicatoare pe 16 biţi, două acumulatoare pe 40 de biţi, două unităţi logice aritmetice de calcul (ALUs), patru unităţi video ALU pe 8 biţi şi o unitate de deplasare pe 40 de biţi.Procesorul conţine un set de opt registre computaţionale pe 32 de biţi. Când se realizează operaţiuni de calcul cu operanzi pe 16 biţi, setul de registre se comporta ca 16 registre de 16 biţi.

ADSP-BF533 este un procesor combinat pe 16 şi 32 biţi care combină comenzi RISC pe 32 de biţi şi procesare de date pe 16 biţi. Unităţile de procesare pe 16 biţi sunt capabile sa proceseze multiplicări pe 16 biţi cu rezultat pe 40 numai într-o singură perioadă de ceas. Aceste multiplicări pot fi atât multiplicări de numere întregi, cât şi in format fracţionar 1.15. În al doilea caz, rezultatul poate fi rotunjit la 1.15 fără altă operaţie adiţională.

Unitatea logico-arimtetică poate efectua un set tradiţional de operaţii aritmetice şi logice pe 16 sau 32 de biţi. Multe instrucţiuni speciale sunt incluse pentru a accelera diferite sarcini de procesare a semnalului. Acestea includ operaţii la nivel de bit precum extragere, multiplicare modulo 232 , primitive de divizare, saturare şi rotunjire şi detecţie de semn nau exponent. Setul de instrucţiuni video includ aliniament de octet şi operaţiuni de împachetare, adunări pe 16 sau 8 biţi, operaţiuni de mediere pe 8 biţi. Sunt de asemenea disponibile instrucţiuni de comparare-selectare şi cautare de vector. Pentru anumite instrucţiuni, operaţiunile ALU pe 16 biţi pot fi efectuate simultan în perechi de registre (o jumătate superioară de 16 biţi şi o jumătate inferioară de 16 biţi ale unui registru computaţional). De asemenea, utilizând cel de-al doilea ALU, sunt posibile şi operaţii quad pe 16 biţi.

Shifter-ul pe 40 de biţi poate să stocheze date şi să efectueze deplasări stânga-dreapta, rotaţii, normalizări şi operaţiuni de extragere.

Un secvenţiator de program (Sequencer) controlează ordinea de execuţie a instrucţiunilor, incluzând alinierea instrucţiunilor şi decodarea. Pentru controlul derulării programelor, secvenţiatorul conţine salturi condiţionate relative la contoru de program sau indirecte şi chemări de subrutine. Hardware-ul este realizat în aşa fel încât să suporte buclele cu overhead 0.

10

Figura nr 2.8 Arhitectura procesorului Blackfin BF533

Unitatea aritmetică de adrese oferă două adrese pentru executarea a două fetch-uri simultane din memorie. Conţine un set de registe alcătuit la rândul său din patru seturi de registre pe 32 de biţi numite: Index, Modify, Length şi Base (utilizat pentru buffering circular) şi opt registre indicatoare (pointer register) adiţionale, pe 32 de biţi, pentru manipularea stivei (pentru compatibilatea cu limbajul C).

Procesoarele Blackfin sunt realizate pe baza unei arhitecturi Harvard în combinaţie cu o structură de memorie ierarhică. Memoriile de nivel 1 (Level 1 sau L1) operează de obicei la viteza maximă a procesorului cu latenţă mică sau chiar fără latenţă. La nivelul L1, memoria de instrucţiuni reţine doar instrucţiuni. Cele două memorii de date conţin date, şi o zonă de memorie dedicată numită „scratchpad” unde sunt reţinute variabilele locale şi stiva.Unitatea de management a memoriei (MMU) oferă protecţie la memorie pentru sarcinile individuale care pot opera pe core şi pot proteja registrele de sistem de acces neintenţionat.

Arhitectura oferă trei moduri de operare: Utilizator, Supervizor şi Emulator. Modul utilizator are acces restricţionat la un subset de resurse de sistem, astfel realizându-se un mediu software protejat. Modurile Supervizor şi Emulator au acces nerestricţionat la sistem şi resurse.

Procesorul Blackfin BF533 are un set de instrucţiuni optimizat, astfel încât codurile pe 16 biţi sa fie cele mai utilizate. Instrucţiunile DSP complexe sunt codate în coduri-operaţie (opcodes) pe 32 de biţi ca instrucţiuni multifuncţie. Procesorul utilizează un limbaj de asamblare cu sintaxă algebrică. Arhitectura este optimizată pentru folosirea compilatorului C.

11

Figura nr. 2.9 Diagrama bloc a procesorului Blackfin BF533

Arhitectura memoriei

Arhitectura procesorului Blackfin structurează memoria ca un singur spaţiu de adrese unificat de dimensiune 4Giga octeţi utilizând adrese pe 32 de biţi. Toate resursele, incluzând memoria internă, memoria externă şi registrele de control ale dispozitivelor de intrare/ieşire, ocupă secţiuni separate ale acestui spaţiu comun de adrese. Porţiunile de memorie ale acestui spaţiu de adrese sunt aranjate într-o structură ierarhică pentru a oferi un bun raport cost/performanţă pentru memoriile foarte rapide, cu latenţă mică de pe chip precum memoria cache sau SRAM şi sistemele de memorie lente, cu performanţe scăzute şi costuri mici precum memoriile externe.

Sistemul de memorie L1 este memoria cu cea mai înaltă performanţă. Sistemul de memorie externă (off-chip), accesata cu ajutorul Unităţii de Interfaţă cu Magistrala Externă (EBIU – External Bus Interface Unit), oferă expansiune cu SDRAM, memorie flash si SRAM ajungând să acceseze, opţional, un spaţiu de 132 Mega octeţi de memorie fizică.

Controlerul de Acces Direct la Memorie (DMA - Direct Memory Access) oferă capabilităţi de mutare a datelor de lărgime de bandă mare. Poate realiza transferuri de blocuri de cod sau de date între spaţiile de memorie internă şi externă.

12

Memoria internăProcesorul are trei blocuri de memorie pe chip : Memoria L1 de instrucţiuni, constituită din SRAM şi un cache cu mapare asociativă pe seturi cu 4 direcţii. Acest bloc este accesat la viteza maximă a procesorului. Memoria L1 de date, cosntituită din SRAM şi/sau un cahe cu mapare asociativă pe seturi cu 2 direcţii. Acest bloc este accesat la viteza maximă a rocesorului. Memoria „scratchpad” RAM, este accesibilă doar ca date SRAM şi nu poate configurată ca şi cache.

Memoria externă Memoria externă este accesată prin intermediul Unităţii de Interfaţă cu Magistrala

Externă (EBIU – External Bus Interface Unit). Această interfaţă de 16 biţi oferă o conexiune stabilă la un grup de memorii simcrone DRAM (SDRAM) şi până la 4 dispozitive de memorie asincronă incluzând memorie flash, EPROM, ROM, SRAM şi dispozitive de intrare/ieşire.

Spaţiul de memorie pentru dispozitivele de intrare/ieşireProcesorul Blackfin nu defineşte un spaţiu separat pentru memoriile I/O. Toate

resursele sunt mapate în spaţiul de adrese de 32 de biţi. Registrele de control pentru dispozitivele de intrare/ieşire de pe chip sunt mapate în Registrii de Mapare a Memoriei (MMRs – Memory Mapped Registers). Adresele corespunzătoare lor se află aproape de vârful spaţiului de adrese de 4 Giga octeţi. Acestea sunt împărţite în două blocuri mai mici: unul conţinând registrele de control pentru toate funcţiunile core-ului şi celălalt conţinând registrele necesare pentru controlul şi iniţializarea perifericelor de pe chip din afara core-ului. Registrele MMR sunt accesibile doar în modul Supervizor şi apar ca spaţiu rezervat pentru perifericele on-chip.

2.2.2. Componente

Din perifericele procesorului fac parte:• Parallel Peripheral Interface (PPI)• Serial Ports (SPORTs)• Serial Peripheral Interface (SPI)• Timere scop general• Universal Asynchronous Receiver Transmitter (UART)• Real-Time Clock (RTC)• Watchdog timer• I/O (programmable flags) scop general

Toate perifericele, cu excepţia general-purpose I/O, Real-Time Clock şi Timere sunt suportate de structură flexibilă DMA(Direct Memory Access).Există, de asemenea doua canale separate de memorie DMA dedicate transferurilor de date dintre spaţiul de memorie al procesorului, care include SDRAM extern şi memoria asincronă.

13

Multiplele magistrale on-chip asigură o bandă suficientă pentru a menţine procesorul într-o stare de funcţionare optimă chiar şi atunci când toate perifericele on-chip şi externe îndeplinesc simultan sarcini.

Controlerul DMA

Procesorul ADSP-BF533 utilizează Accesul Direct la Memorie (DMA – Dict Memory Access) pentru a transfera datele între locaţii de memorie sau între memorie şi periferice. Procesorul poate specifica operaţiunile de transfer de date şi apoi să se întoarcă la procesarea norală în timp de controlerul DMA se ocupă de transferul de date indepedent de activitatea procesorului.

Controlerul DMA poate realiza câteva tipuri de transferuri de date: între memorie şi memorie (MDMA) între memorie şi interfaţa serială cu perifericele (SPI – Serial Peripheral Interface) între memorie şi porturile seriale (SPORT – Serial Pot) între memorie şi portul UART între memorie şi interfaţa paraleă cu perifericele (PPI – Parallel Peripheral Interface )

În modulatorul implementat de mine am folosit controlerul DMA în două scopuri : pentru a iniţializa codecul AD1836 printr-un transfer de date memorie-SPI şi pentru a prelua datele de la SPORT0 către memorie şi viceversa.

Sistemul include şase periferice capabile de acces direct la memorie, incluzând controlerul DMA de memorie MDMA. Următoarele douăsprezece canale suportă aceste periferice:• PPI Receive/Transmit DMA Controller• SPORT0 Receive DMA Controller• SPORT0 Transmit DMA Controller• SPORT1 Receive DMA Controller• SPORT1 Transmit DMA Controller• SPI Receive/Transmit DMA Controller• UART Receive DMA Controller• UART Transmit DMA Controller• MDMA Stream 1 Transmit (Destination)• MDMA Stream 1 Receive (Source)• MDMA Stream 0 Transmit (Destination)• MDMA Stream 0 Receive (Source)

Transferurile DMA sunt setate de procesor cu ajutorul descrptorilor sau a registrelor de control. Întrucât am utilizat pentru realizarea practică numai registrele de control, voi omite săprezint aici funcţionalitatea descriptorilor şi mă voi axa pe prezentarea registrelor de control. Acestea permit procesorului să programeze direct controlerul DMA pentru transferul de date. După completarea transferului, registrele de control pot fi updatate automat cu valorile iniţiale pentru un transfer cotinuu de date.

14

Pentru a înţelege cum se setează un registru de control al DMA voi exemplifica pentru registrul de mapare cu perifericele (DMAx_PERIPHERAL_MAP – unde x este numărul canalului). Acest registru mapează canalul cu un periferic specific şi identific dacă acest canal este un canal DMA cu periferic sau cu memoria.

Figura nr 2.10 Registrul de mapare cu perifericeleSpre exemplu, dacă doresc să mapez canalul DMA1 cu perifericul SPORT0 RX

trebuie doar sa scriu în DMA1_PERIPHERAL_MAP valoarea 0x1000.

Controlerul SPI

SPI (Serial Peripheral Interface – Intefaţa Serială cu Perifericele) furnizează o interfaţă de intrare ieşire către o varietate de dispozitive periferice compatibile cu SPI. SPI este o interfaţă pe patru fire dintre care doi pini de date, un pin pentru selecţia dispozitivului şi un pin pentru ceas. SPI este o interfaţă serială sincronă full-duplex ce suportă moduri master, moduri slave şi moduri multi-master.

Dispozitivele periferice compatibile cu SPI tipice includ: alte unitetăţi centrale de prelucrare sau microcontrolere codec-uri convertoare analog-numerice convertoare numeric-analogice display-uri LCD transmiţătoare şi receptoare audio SP/DIF registre de deplasare FPGA-uri cu emulare de SPI

După cum am afirmat mai sus voi utiliza controlerul SPI pentru a iniţializa codecul AD1836.

Figura 2.11 prezintă diagrama bloc a SPI. Interfaţa este esenţialmente un registru de deplasare care transmite şi recepţionează în mod serial biţi de date, bit cu bit, la frecvenţa SCK, de la şi către dispozitivele periferice compatibile SPI. Datele SPI sunt transmise şi recepţionate în acelaşi timp datorită unui registru de deplasare. Când are loc un transfer, datele sunt transmise (deplasate serial în afara registrului) pe moment ce date noi sunt primite (introduse în celălalt capăt al registrului).

15

Figura nr 2.11 Diagrama bloc a SPISetarea unui SPI se realizează prin intermediul unor registre de control. Mai jos puteţi observa structura registrului SPI_CTL.

Figura nr 2.12 registrul de control al SPI

16

Porturile seriale

Procesorul are două porturi seriale identice numite SPORT0 şi SPORT1. Porturile seriale furnizează o interfaţă de intrare-ieşire către o varietate de dispozitive periferice seriale. Porturile seriale realizează doar transfer de date serial. Fiecare SPORT are un set de pini (date primare, date secundare, ceas şi sincronizare de cadru) pentru transmitere şi încă un set de pini pentru recepţie. Funcţiile de transmitere şi recepţie sunt programate separat. Fiecare SPORT este un dispozitiv full-duplex, capabil să transfere date simultan în ambele direcţii. Porturile seriale pot fi programate pentru a seta rata de biţi (bit rate), sincronizarea cadrelor şi numărul de biţi per cuvânt prin scrierea unor registre mapate în memorie

Ambele porturi seriale, SPORT0 şi SPORT1 au aceleaşi capabilităţi şi sunt programate în acelaşi mod. Fiecare SPORT are propriul set de registre de control şi propriile buffere de date.

SPORT-urile utilizează impulsuri de sincronizare a cadrelor pentru a indica începutul fiecărui cuvânt de date, şi ceasul de bit marchează începutul fiecărui bit.

17

3. PLACA DE EVALUARE EZ-KIT LITE BF533

Sistemul va fi construit pentru rulare pe placa de evaluare Ez-KIT Lite BF533. Aceasta placa a fost realizata special pentru a demonstra capabilitatile procesoruluide semnal ADSP BlackfinBF533.

Placa de evaluare este folosita impreuna cu mediul de dezvltare VisualDSP++ pentru a testa capabilitatile procesoarelor Blackfin BF533.

3.1. Arhitectura sistemului

Aceasta sectiune descrie configuratia procesorului pe placa de evaluare EZ-Kit Lite.

Figure 4-5 Arhitectura de sistem a placii de evaluare Ez-Kit Lite BF533

3.2. EBIU

Memoria externă este accesată prin intermediul Unităţii de Interfaţă cu Magistrala Externă (EBIU – External Bus Interface Unit). Această interfaţă de 16 biţi oferă o conexiune stabilă la un grup de memorii simcrone DRAM (SDRAM) şi până la 4 dispozitive de memorie asincronă incluzând memorie flash, EPROM, ROM, SRAM şi dispozitive de intrare/ieşire.

3.3. Interfata SPORT

Portul serial SPORT0 conecteaza codecul audio AD1836. Acest codec utilizeaza ambii pini de transmisie si receptie pentru a primii si transmite date de la intrarile si iesiriile audio.

18

3.4. Fanioane programabile

Procesorul are 15 fanioane programabile (PF – Programmable Flags). In tabelul de mai jos se pot observa functiile fiecarui PF:

3.5. Portul UART

Portul universal de transmisie/receptie asincrona (UART – Universal Asynchronous Receiver/Transmitter) al procesorului se conecteaza la driveruk ADM3202 RS-232. Driverul

19

RS-232 se conecteaza la un capat DB-9 de tip „tata” oferind o interfata catre calculatorul personal.

3.6. Codecul AD1836

Codecul AD1836 ofera trei canale stereo de iesire si doua canale de intrare cu o frecventa de esantionare de 96kHz. Portul SPORT0 al procesorului se conecteaza cu pinii de intrare si iesire stereo ai codecului AD1836.

Registrii de configurare interni ai codecului sunt setati prin intermediul portului SPI al procesorului. Pentru a selecta acest discpozitiv este utilizat fanionul programabil PF4.

Figure 4-6Diagrama bloc functionala a codecului

O vedere a blocurilor functionale ale codecului este prezentata in figura de mai jos.

Figure 4-7 Blocurile functionale ale codecului

20

Figure 4-8 Configuratia pinilor

21

4. IMPLEMENTAREA MODEMULUI

Modemul va functiona in ca transmitator sau ca receptor. Modul de functionare se poate selecta prin apasarea butonului SW4 de pe placa de evaluare.

Pentru realizarea modulatiei DMT modemul poate selecta doua mapari 4QAM si 16QAM prin apasarea butonului SW5 . Selectia se realizeaza prin apasari multiple in mod ciclic.

Modulatia DMT permite selectia mai multor seturi de frecvente subpurtatoare. Prin apasarea butonului SW5 se pot selecta seturile de frecvente subpurtatoare.

4.1. Schema generala de principiu

Modemul va fi construit pe placa de evaluare Ez-Kit Lite si va utiliza elementele de pe placa prezentate in capitolul precedent.

Schema generala a unei comunicatii cu ajutorul acestui modem este prezentata in figura de mai jos:

Figure 5-9 Comunicatie intre 2 calculatoare

Comunicatia intre calculator si modem va fi realizata prin intermediul unui cablu RS-232. Driverul ADM de pe placa va prelua datele si le va transmite cu ajutorul UART catre procesor pentru prelucrarea datelor. Dupa prelucrare procesorul va trimite datele catre codecul audio AD1836 in vederea transmiterii lor pe cablu audio.

Schema generala a modemului este in figura de mai jos:

Figure 5-10 Schema generala a modemului

22

5. PROGRAMUL IN LIMBAJ CProgramul urmăreşte structura unui modem DMT. Transmitatorul si receptorul sunt

implementate ca 2 functii C intitulate modulator() si demodulator(). Fiecare functie primeste ca parametru semnalele s[n] respectiv r(t) si scriu iesirile in variabile globale. Cele doua functii implementeaza blocurile sistemului.

Figure 6-11 Transmitator DMT

Figure 6-12 Receptor DMT

Programul contine 2 fisiere: Fisierul main.c ce contine toate functiile si blocurile sistemului Fisierul constante.h – header cu definitiile vectorilor si constantelor

23

5.1. Considerente generale

Pentru optimizarea programului am realizat aproape toate variabilele în tipul de date fracţionar pe 16 biţi fract16, tipul nativ de date al procesorului BlackFin BF533, şi toate funcţiile de prelucrare a semnalului folosite au fost corespunzătoare acestui tip de date.

N N/6 Fract16-Hexa Macro

3 0.5 0x4000 trei2 0.3333 0x2AAA doi1 0.1666 0x1555 unu-1 -0.1666 0xEAAB m_unu-2 -0.3333 0xD556 m_doi-3 -0.5 0xC000 m_trei

Tabelul nr 1 Valorile funcţiilor macro #define trei 0x4000#define doi 0x2aaa#define unu 0x1555 #define m_unu 0xeaab#define m_doi 0xd556#define m_trei 0xc000

Pentru a reduce timpul de calcul am folosit tablouri de 512 elemente care să reţină valorile purtătoarei în format fract16. Astfel, pentru produsul de modulaţie nu se mai calculează pentru fiecare pas valoarea purtătoarei, ci pur şi simplu este căutată această valoare în tabloul funcţiei.

De asemenea şi valorile coeficienţilor filtrului trece-jos necesare la demodulare au fost introduse în tablouri de variabile fract16.În continuare voi prezenta funcţiunile fiecărui bloc din organigrama programului.

5.2. Functia main

Functia main() preia bitii in variabila intrare, apeleaza functiile modulator() si demodulator() si printeaza valorile de intrare si iesire pentru comparare. Datele sunt citite dintr-un fişier extern şi introduse de către mediul de dezvoltare VisualDSP++ în zona de memorie protejată a procesorului 0xFFD00000-0xFFD00FFF.

void main()

{

short int *p = &(*(short int *)input_p);

intrare = *p;

printf("intrare=0x%x\n",intrare);

modulator(intrare);

demodulator(out_r);

printf("iesire =0x%x\n",iesire);

}

24

Modulatorul

5.2.1. Conversia Serie-Paralel

Conversia serie-paralel este realizata cu un SI la nivel de bit intre variabila input si o masca. In functie de numarul de biti pe simbol selectat masca filtreaza 2 sau 4 biti.

/////////////////////////////////////////////////////

//Conversie serie-paralel -> sp[]

/////////////////////////////////////////////////////

for (i=0;i<N;i++)

{

sp[i]=input & mask;

input=input >> 2;

}

5.2.2. Blocul de mapare

Programul foloseşte o structura switch-case pentru a mapa sirul de biti in simboluri. Fiecarui simbol ii corespunde o frecventa complexa ce va fi introdusa in vectorul de frecvente.

switch(sp[i])

{

case 0: {map[start_f+band*i].re=unu;map[start_f+band*i].im=unu;};break;

case 1: {map[start_f+band*i].re=m_unu;map[start_f+band*i].im=unu;};break;

case 2: {map[start_f+band*i].re=unu;map[start_f+band*i].im=m_unu;};break;

case 3: {map[start_f+band*i].re=m_unu;map[start_f+band*i].im=m_unu;};break;

}

5.2.3. Constructia semnalului in domeniul frecventa

Acest vector de frecvente va fi introdus in blocul IFFT prin apelarea functiei ifft(). Este necesara constructia simetrica a acestui vector pentru a obtine la iesirea blocului IFFT doar o componenta reala in timp.

map[N_FFT-(start_f+band*i)].re = map[start_f+band*i].re;

if(map[start_f+band*i].im == unu)

map[N_FFT-(start_f+band*i)].im = m_unu;

else

map[N_FFT-(start_f+band*i)].im = unu;

25

5.2.4. Calcul IFFTtwidfftrad2_fr16(twid, N_FFT);//functie pt tabela twiddle

ifft_fr16(map,sgn,twid,1,N_FFT,0,0);

5.2.5. Calculul produselor de modulaţie

Pentru calculul produselor de modulaţie am apelat la funcţiile din librăria fract_math.h specifice procesoarelor BlackFin pentru a profita de toată puterea de calcul a procesorului.

Funcţiile static fract16 mult(fract16 _x, fract16 _y) şi static fract16 add(fract16 _x, fract16 _y) realizează înmulţirea, respectiv adunarea a două numere fracţionare într-un număr de ciclii redus faţă de orice altă modalitate de calcul.

Semnalul DMT este calculat într-o singură linie de cod.

for(i=0;i<N_FFT;i++)

{

out_r[i] = mult(sgn[i].re,cosinus[i%8]);

}

5.2.6. Ieşirea modulatorului

Semnalul DMT calculat anterior este salvat sub forma a 512 eşantioane ale vectorului out_r[]. Aceste valori sunt scrise în zona de memorie protejată de unde VisualDSP++ le va salva într-un fişier extern.

5.3. Demodulatorul

5.3.1. Achiziţionarea eşantioanelor

Simulatorul achiziţionează eşantioanele prin umplerea unui buffer numit intrare_demod[] , care este de fapt un vector de elemente de tip fract16.

fract16 *pinput_d = (fract16 *) input_d;

for(k=0;k<NR_ES;k++)

{

intrare_demod[k] = *pinput_d;

}

26

5.3.2. Înmulţirea cu purtătoarea

Acest pas se realizează asemănător cu modul de înmulţire al modulatorului, utilizând aceeaşi funcţie mult().

/////////////////////////////////////////////////////

//Inmultire cu purtatoarea -> sgn_r[]

/////////////////////////////////////////////////////

for (i=0;i<N_FFT;i++)

{

sgn_r[i]=mult(input[i],cosinus[i%8]);

}

5.3.3. Filtrarea Trece-Jos

Relaţia în timp discret care caracterizează structura unui filtru FIR este

unde :- y[n] este semnalul de la ieşirea filtrului- x[n] este semnalul de la intrarea filtrului- hi reprezintă coeficienţii filtrului care depind de tipul acestuia (FTB,FTJ, oarecare, etc.) -N este ordinul filtrului

Aşa cum se poate observa, eşantionul semnalului de la ieşire la momentul de timp curent se calculează prin combinaţia liniară a eşantioanelor semnalului de la intrare. Deci, la fiecare moment de timp, trebuie calculată o sumă de produse, adică trebuiesc executate N înmulţiri şi N adunări, operanzii constând în istoria semnalului de la intrare pe de o parte şi coeficienţii filtrului pe de altă parte.

Coeficienţii filtrului au fost obţinuţi cu ajutorul programului Matlab utilizând următorul cod salvat în fişierul scrie_coef_dat.m.

% Proiectare filtru FTJ-FIRfe=128; %frecventa de esantionareft=[0.01 10] ; % Banda (Hz)l_coef=64; % Ordinul filtrului (Numarul de coeficienti)b=fir1(l_coef-1,ft/(fe/2)); %implementarea filtruluisir=b; % Normare pentru a evita depasirea gamei [-1 1]if max(abs(sir))>1 sir=sir/max(abs(sir));end % Salvarea intr-un fisier de datefid1=fopen('FIR_FTJ.dat','w'); % Deschidere fisierfor i=1:length(sir) if (sir(i)>=1) % Evitarea depasirii sir(i)=0.9999; end % Tiparire in fisier fprintf(fid1,'%1.15f\n',sir(i));endfclose(fid1); % Inchidere fisier

27

%Afisarea rezultatelorA=1; % Numitorul functiei de transferNp=2048; % Numarul de puncte in care se calculeaza transformata in frecventa[H,F]=freqz(b,A,Np,fe); % Întoarce raspunsul în frecventa;%Afisarea coeficientilor filtruluisubplot(3,1,1); stem(b);% Afisarea modulului functiei de transfer în frecventasubplot(3,1,2); plot(F,abs(H/max(H)));zoom on;

Odată rulat, acest program scrie coeficienţii filtrului, în format fracţionar 1.15 , într-un fişier de date coef.dat, şi afişează atât coeficienţii, cât şi răspunsul filtrului în frecvenţă.

Figura nr. 4.3 Filtrul Trece Jos – Răspunsul la impuls şi Caracteristica de transfer

Filtrul cu răspuns finit la impuls a fost realizat în program cu ajutorul funcţiei fir_fr16(). Funcţia generează răspunsul filtrat al intrării şi stochează rezultatul într-un vector de ieşire. Funcţia se regăseşte în librăria filter.h.

#include <filter.h>

void fir_fr16(const fract16 input[],

fract16 output[],

int length,

fir_state_fr16 *filter_state);

//Funcţia foloseşte următoarea structură pentru a menţine starea filtrului:

typedef struct

{

fract16 *h, /* filter coefficients */

fract16 *d, /* start of delay line */

fract16 *p, /* read/write pointer */

28

int k; /* number of coefficients */

int l; /* interpolation/decimation index */

} fir_state_fr16;

Numărul de eşantioane la intrare şi lungimea vectorului de ieşire sunt date de argumentul length.

Funcţia menţine starea filtrului în variabilele structurii filter_state , care trebuie declarată şi iniţializată înainte de chemarea funcţiei. Funcţia macro fir_init , definită în filter.h poate să iniţializeze structura.

Un pointer către coeficienţi este stocat în filter_state->h, iar filter_state->k reţine numărul de coeficienţi. Fiecare filtru are o linie de întârziere care este de fapt un vector de tip fract16 şi a cărui lungime este egală cu numărul de coeficienţi. Vectorul trebuie iniţializat cu valori nule şi nu mai trebui modificat de către program. Membrul structurii filter_state->d este setat la startul liniei de întârziere, iar funcţia foloseşte filter_state->p pentru a ţine minte poziţia curentă în vector.

Exemplu de filtru trece jos pentru traseul componenei în fază la recepţie (pentru componenta în cuadratură structura este similară):

filter_state->h = coeff; //pointer catre coeficienti

filter_state->k = NR_COEFF; //nr de coef

filter_state->d = delay;

filter_state->p = delay;

for (i=0;i<2*N_FFT;i++)

{

delay[i]=0;

}

fir_fr16(sgn_r,sgn_rf,N_FFT,filter_state);

5.3.4. Transformata Fourier Directa

Transformata Fourier directa a fost realizata cu ajutorul functiei cfft(), apelata in mod asemanator cu functia ifft():

for (i=0;i<N_FFT;i++)

{

sgn_d[i].re=sgn_rf[i];

sgn_d[i].im=0;

}

twidfftrad2_fr16(twid, N_FFT);

cfft_fr16(sgn_d, map_d, twid, 1, N_FFT, 0, 0);

29

5.3.5. Estimare si Demapare

Funcţia de decizie a fost construită în limbajul C cu ajutorul blocurilor if şi a funcţiilor macro descrise mai sus.

/////////////////////////////////////////////////////

//Estimare+Demapare

/////////////////////////////////////////////////////

for (i=0;i<N;i++)

{

if( (map_d[start_f+band*i].re>0) && (map_d[start_f+band*i].im>0)) sp_d[i]=0;

else if( (map_d[start_f+band*i].re<0) && (map_d[start_f+band*i].im>0)) sp_d[i]=1;

else if( (map_d[start_f+band*i].re<0) && (map_d[start_f+band*i].im<0)) sp_d[i]=3;

else if( (map_d[start_f+band*i].re>0) && (map_d[start_f+band*i].im<0)) sp_d[i]=2;

}

5.3.6. Conversia Paralel-Serie

/////////////////////////////////////////////////////

//Conversie Paralel-Serie

/////////////////////////////////////////////////////

iesire=0x0;

for (i=N-1;i>=0;i--)

{

iesire=4*iesire+sp_d[i];

}

30

6. ANEXE

6.1. Anexa 1 : Listing-urile programului#include <stdio.h>#include <filter.h>#include <fract_math.h>#include <math.h>#include "constante.h"

int nr_biti; //nr bitishort int intrare; //intrareshort int iesire; //iesireshort int mask = 0x3; //masca pentru conversie serie-paralelshort int sp[N]; //vector date dupa conversia serie_paralelshort int sp_d[N]; //vector date dupa conversia serie_paralelint i; //variabila auxiliaracomplex_fract16 map[N_FFT]; //vector date dupa mapare QAMcomplex_fract16 sgn[N_FFT]; //vector date dupa transformata Fourier inversacomplex_fract16 twid[N_FFT];//necesar pt calcul ifftfract16 out_r[N_FFT]; //vector date dupa inmultirea cu purtatoarea - semnal transmisfract16 out_rfft[N_FFT]; //pt graficefract16 out_ifft[N_FFT]; //pt graficefract16 sgn_r[N_FFT]; //semnal receptionat dupa inmultirea cu purtatoareafract16 sgn_rf[N_FFT]; //semnalul filtrat Rfract16 delay[2*N_FFT]; //vectorul de intarziere al filtruluifir_state_fr16 *filter_state; //starea filtruluicomplex_fract16 map_d[N_FFT]; //vector date dupa demapare QAMcomplex_fract16 sgn_d[N_FFT]; //vector date dupa transformata Fourier

//--------------MODULATORUL------------------------------------------------------------

void modulator(short int input){

///////////////////////////////////////////////////////Conversie serie-paralel -> sp[]/////////////////////////////////////////////////////

for (i=0;i<N;i++){

sp[i]=input & mask;input=input >> 2;

}

///////////////////////////////////////////////////////Mapare QAM -> map[]/////////////////////////////////////////////////////

for (i=0;i<N;i++){

switch(sp[i]){

case 0: {map[start_f+band*i].re=unu;map[start_f+band*i].im=unu;};break;case 1:

{map[start_f+band*i].re=m_unu;map[start_f+band*i].im=unu;};break;case 2:

{map[start_f+band*i].re=unu;map[start_f+band*i].im=m_unu;};break;case 3:

{map[start_f+band*i].re=m_unu;map[start_f+band*i].im=m_unu;};break;}

map[N_FFT-(start_f+band*i)].re = map[start_f+band*i].re;

if(map[start_f+band*i].im == unu) map[N_FFT-(start_f+band*i)].im = m_unu;

31

else map[N_FFT-(start_f+band*i)].im = unu;

}

///////////////////////////////////////////////////////IFFT -> sgn[]/////////////////////////////////////////////////////

twidfftrad2_fr16(twid, N_FFT); //functie de populare a tabelei twiddle

ifft_fr16(map,sgn,twid,1,N_FFT,0,0);

for(i=0;i<N_FFT;i++) //doar pentru grafice{

out_rfft[i]=sgn[i].re;out_ifft[i]=sgn[i].im;

}

///////////////////////////////////////////////////////Inmultire cu purtatoarea -> out[]/////////////////////////////////////////////////////

for(i=0;i<N_FFT;i++){

out_r[i] = mult(sgn[i].re,cosinus[i%8]);}

}

//--------------DEMODULATORUL------------------------------------------------------------

void demodulator(short int* input){

///////////////////////////////////////////////////////Inmultire cu purtatoarea -> sgn_r[]/////////////////////////////////////////////////////

for (i=0;i<N_FFT;i++){

sgn_r[i]=mult(input[i],cosinus[i%8]);}

///////////////////////////////////////////////////////Filtrare Trece Jos -> map_r[]/////////////////////////////////////////////////////

filter_state->h = coeff; //pointer catre coeficientifilter_state->k = NR_COEFF; //nr de coefffilter_state->d = delay;filter_state->p = delay;

for (i=0;i<2*N_FFT;i++){

delay[i]=0;}

fir_fr16(sgn_r,sgn_rf,N_FFT,filter_state);

for (i=0;i<N_FFT-35;i++){

sgn_rf[i]=sgn_rf[i+34];}

32

for (i=0;i<36;i++){

sgn_rf[N_FFT-i]=sgn_rf[N_FFT/2-i];}

///////////////////////////////////////////////////////Transformata Fourier Directa/////////////////////////////////////////////////////

for (i=0;i<N_FFT;i++){

sgn_d[i].re=sgn_rf[i];sgn_d[i].im=0;

}

twidfftrad2_fr16(twid, N_FFT);

cfft_fr16(sgn_d, map_d, twid, 1, N_FFT, 0, 0);

///////////////////////////////////////////////////////Estimare+Demapare/////////////////////////////////////////////////////

for (i=0;i<N;i++){

if( (map_d[start_f+band*i].re>0) && (map_d[start_f+band*i].im>0)) sp_d[i]=0;else if( (map_d[start_f+band*i].re<0) && (map_d[start_f+band*i].im>0))

sp_d[i]=1;else if( (map_d[start_f+band*i].re<0) && (map_d[start_f+band*i].im<0))

sp_d[i]=3;else if( (map_d[start_f+band*i].re>0) && (map_d[start_f+band*i].im<0))

sp_d[i]=2;

}

///////////////////////////////////////////////////////Conversie Paralel-Serie/////////////////////////////////////////////////////

iesire=0x0;

for (i=N-1;i>=0;i--){

iesire=4*iesire+sp_d[i];}

}

void main(){

////////////////////////////////////////////////////////Introducere date -> intrare////////////////////////////////////////////////////////short int *p = &(*(short int *)input_p);//intrare = *p;

intrare = 0x1a4f;printf("intrare=0x%x\n",intrare);

modulator(intrare);demodulator(out_r);

printf("iesire =0x%x\n",iesire);

}

33

6.2. Anexa 2: Schema electrica

6.2.1. UART

34

6.2.2. Blackfin BF533

35

6.2.3. BF533-AD1836

6.2.4. Legaturi cu memoria

36