sisteme Încorporate cu fpga pentru … · sisteme de control rapide, de înaltă performanţă....

UNIUNEA EUROPEANĂ GUVERNUL ROMÂNIEI

MINISTERUL MUNCII, FAMILIEI ŞI PROTECŢIEI SOCIALE

AMPOSDRU

Fondul Social European POSDRU 2007-2013

Instrumente Structurale 2007-2013

OIPOSDRU UNIVERSITATEA TEHNICĂ “GHEORGHE ASACHI”

DIN IAŞI

UNIVERSITATEA TEHNICĂ “GHEORGHE ASACHI” DIN IAŞI

Şcoala Doctorală a Facultăţii de Automatică şi Calculatoare

SISTEME ÎNCORPORATE CU FPGA PENTRU CONTROLUL PROCESELOR RAPIDE

- TEZĂ DE DOCTORAT -

Conducător de doctorat: Prof. univ. dr. ing. Alexandru Onea

Doctorand: Ing. Bogdan Alecsa

IAŞI - 2011



AMPOSDRU




DIN IAŞI

Teza de doctorat a fost realizată cu sprijinul financiar al

proiectului „Burse Doctorale - O Investiţie în Inteligenţă (BRAIN)”.

Proiectul „Burse Doctorale - O Investiţie în Inteligenţă (BRAIN)”,

POSDRU/6/1.5/S/9, ID 6681, este un proiect strategic care are ca

obiectiv general „Îmbunătăţirea formării viitorilor cercetători în cadrul

ciclului 3 al învăţământului superior - studiile universitare de doctorat

- cu impact asupra creşterii atractivităţii şi motivaţiei pentru cariera în

cercetare”.

Proiect finanţat în perioada 2008 - 2011.

Finanţare proiect: 14.424.856,15 RON

Beneficiar: Universitatea Tehnică “Gheorghe Asachi” din Iaşi

Partener: Universitatea “Vasile Alecsandri” din Bacău

Director proiect: Prof. univ. dr. ing. Carmen TEODOSIU

Responsabil proiect partener: Prof. univ. dr. ing. Gabriel LAZĂR



AMPOSDRU




DIN IAŞI

4

Cuvânt înainte Lucrarea de faţă este rezultatul a trei ani de studii în cadrul Şcolii Doctorale a Facultăţii

de Automatică şi Calculatoare, Universitatea Tehnică “Gheorghe Asachi” din Iaşi, studii sprijinite prin programul “Burse doctorale – o investiţie în inteligenţă” BRAIN.

Elaborarea acestei lucrări s-a făcut sub îndrumarea atentă şi competentă a domnului prof. dr. ing. Alexandru Onea, căruia autorul îi mulţumeşte pentru încurajarea formării unei atitudini independente şi, în acelaşi timp, direcţionarea avizată către rezultate semnificative.

Autorul se simte îndatorat în mare măsură şi faţă de colectivul Catedrei de Automatică şi Informatică Aplicată, şi în special faţă de conducătorul acestuia, domnul prof. dr. ing. Corneliu Lazăr, pentru discuţiile constructive şi trimiterile bibliografice valoroase.

O pondere importantă în această lucrare o are activitatea de cercetare desfăşurată la Anglia Ruskin University, în Cambridge, UK, la invitaţia şi sub supravegherea domnului prof. dr. ing. Marcian Cîrstea, fără a cărui implicare această lucrare ar fi fost mult mai săracă. De asemenea, atitudinea profesionistă şi prietenoasă a domnului dr. ing. Alin Tisan, din acelaşi colectiv, a făcut posibilă realizarea cu succes a experimentelor de laborator.

Atât ideea acestei lucrări, cât şi primii paşi în această direcţie, au fost rezultatul unor discuţii aprinse şi fructuoase cu domnul dr. ing. fiz. Aleodor Daniel Ioan, care a abordat anterior o direcţie de cercetare conexă.

Nu în ultimul rând, această lucrare este rezultatul unui mediu competitiv şi prietenos, pentru care autorul mulţumeşte colegilor doctoranzi.

Publicarea unora din rezultatele acestei lucrări a fost posibilă datorită eforturilor deosebite de gestionare a fondurilor grant-ului SICONA-12100/2008, în care autorul este membru, ale directorului de proiect, domnul prof. dr. ing. Corneliu Lazăr.

Autorul recunoaşte că lucrarea poate fi îmbunătăţită şi este conştient de unele stângăcii în

exprimare şi lipsuri în explicaţii. Se presupune totuşi o oarecare familiaritate a cititorului cu domeniul abordat, deşi acesta este la confluenţa dintre automatică, inginerie electrică şi ingineria calculatoarelor, care să-l ajute să treacă peste micile neajunsuri.

Pe parcursul lucrării, toate acronimele folosite au fost definite la prima utilizare. Adesea, s-a reexplicat un acronim dacă acesta a fost definit într-o secţiune anterioară mai îndepărtată. În general, s-a preferat utilizarea acronimului din limba engleză, foarte cunoscut şi în literatura de specialitate de limbă română, scăzând riscul de confuzii. Tot pentru evitarea confuziilor, termenii traduşi din limba engleză pentru care încă nu există un echivalent consacrat în literatura de specialitate de limbă română au fost specificaţi în paranteză în original. De asemenea, unii termeni au fost păstraţi în engleză pe tot parcursul lucrării, fără a se încerca traducerea (de exemplu: hardware, software).

5

Cuprins

1. Introducere .................................................................................................... 9

2. Dispozitive FPGA în controlul maşinilor electrice .................................. 17

2.1 Evoluţia dispozitivelor FPGA................................................................ 17

2.2 Arhitecturi actuale de FPGA.................................................................. 18

2.2.1 FPGA-urile Altera .............................................................................................19

2.2.2 FPGA-urile Xilinx.............................................................................................25

2.3 Metodologia de proiectare a unui sistem de control implementat în

hardware pe FPGA .......................................................................................... 30

2.3.1 Rafinarea algoritmului.......................................................................................31

2.3.2 Modularitatea şi reutilizabilitatea......................................................................32

2.3.3 Potrivirea optimă algoritm-hardware................................................................32

2.4 Sisteme de control pentru motoare electrice implementate în FPGA.... 34

2.5 Concluzii ................................................................................................ 38

3. Unelte de dezvoltare pentru dispozitive FPGA........................................ 41

3.1 Prezentare generală a uneltelor de proiectare pentru FPGA.................. 41

3.1.1 Evoluţia proiectării sistemelor bazate pe FPGA ...............................................41

3.1.2 Nuclee IP ...........................................................................................................43

3.1.3 Unelte de dezvoltare pentru sisteme încorporate în FPGA...............................43

3.1.4 Unelte de dezvoltare pentru nuclee DSP în FPGA ...........................................44

3.2 Proiectarea în mediul Simulink a structurilor hardware folosind

blockset-ul System Generator........................................................................... 46

3.2.1 Utilizarea software-ului System Generator .......................................................46

3.2.2 Blockset-ul Xilinx..............................................................................................47

3.2.3 Blocul System Generator ..................................................................................50

3.2.4 Blocurile Gateway In şi Gateway Out...............................................................53

3.2.5 Biblioteci ale blockset-ului Xilinx.....................................................................59

3.2.6 Integrarea unui modul proiectat folosind System Generator într-un proiect ....60

3.2.7 Importarea în Simulink a unui modul proiectat prin captură de schemă ..........61

3.2.8 Co-simularea Simulink-HDL a unui modul proiectat prin captură de schemă .63

3.3 Unelte de depanare pentru sisteme implementate în FPGA .................. 63

6

3.4 Studii de caz ........................................................................................... 65

3.4.1 Controlul motorului de curent continuu folosind bucla cu calare pe fază ........ 65

3.4.2 Implementarea în hardware a algoritmului de control deadbeat...................... 71

3.4.3 Proiectarea, simularea şi implementarea pe FPGA a unui sistem de control al

vitezei pentru motorul de curent continuu fără perii......................................................... 76

3.5 Concluzii ................................................................................................ 91

4. Proiectarea sistemelor cu procesoare soft încorporate în FPGA ........... 93

4.1 Consideraţii privind proiectarea de procesoare soft pentru FPGA ........ 94

4.1.1 Procesoare configurabile................................................................................... 94

4.1.2 Dificultăţi în proiectarea de procesoare implementate în FPGA ...................... 96

4.1.3 Avantaje la proiectarea de procesoare implementate în FPGA ........................ 96

4.1.4 Optimizări în proiectarea procesoarelor implementate în FPGA...................... 97

4.2 Procesorul soft Xilinx PicoBlaze. Arhitectură şi unelte de dezvoltare.105

4.2.1 Arhitectura procesorului PicoBlaze ................................................................ 106

4.2.2 Unelte de dezvoltare pentru procesorul PicoBlaze ......................................... 110

4.2.3 Simularea procesorului PicoBlaze .................................................................. 113

4.3 Co-proiectarea hardware-software în sisteme de control –

studiu de caz ................................................................................................... 117

4.3.1 Descrierea sistemului SoC .............................................................................. 118

4.3.2 Sistemul cu procesor soft I .............................................................................. 120

4.3.3 Sistemul cu procesor soft II............................................................................. 122

4.4 Concluzii .............................................................................................. 125

5. Metode moderne de modulaţie pentru controlul invertorului trifazic şi

implementarea lor în FPGA............................................................................ 127

5.1 Modulaţia PWM sinusoidală................................................................ 129

5.2 Implementarea în FPGA a modulatorului PWM sinusoidal cu injecţie de

semnal la punctul neutru (ZSS) ...................................................................... 133

5.2.1 Modulul generator controlat de semnal sinusoidal ......................................... 134

5.2.2 Modulul de calculare a valorilor de prag pentru comanda tranzistoarelor ..... 138

5.2.3 Modulul de generare a semnalului purtător şi a semnalelor de comandă a

tranzistoarelor.................................................................................................................. 141

5.2.4 Implementarea pe FPGA şi rezultate experimentale....................................... 144

5.3 Modulaţia bazată pe vectori spaţiali..................................................... 145

7

5.4 Implementarea în FPGA a modulatorului bazat pe vectori spaţiali..... 151

5.4.1 Structura modulară ..........................................................................................151

5.4.2 Implementarea pe FPGA şi rezultate experimentale.......................................153

5.5 Comparaţie între cele două modulatoare ............................................. 156

5.6 Îmbunătăţirea rezoluţiei modulatorului SVM...................................... 158

5.7 Concluzii .............................................................................................. 165

6. Proiectarea unui sistem de control al vitezei pentru motorul PMSM

implementabil în hardware pe FPGA............................................................. 167

6.1 Modelarea motorului PMSM ............................................................... 167

6.2 Proiectarea sistemului de control al vitezei pentru motorul PMSM.... 172

6.2.1 Alegerea parametrilor pentru regulatoarele de curent.....................................174

6.2.2 Alegerea parametrilor pentru regulatorul de viteză.........................................175

6.3 Validarea sistemului de control în continuu ........................................ 176

6.4 Discretizarea sistemului de control ...................................................... 181

6.5 Factorizarea şi implementarea algoritmului de control ....................... 184

6.6 Interfaţarea senzorilor .......................................................................... 188

6.6.1 Senzorii de curent............................................................................................188

6.6.2 Măsurarea unghiului şi a vitezei......................................................................189

6.7 Implementarea în FPGA şi rezultate experimentale ............................ 192

6.8 Concluzii .............................................................................................. 195

7. Concluzii generale ..................................................................................... 197

8. Bibliografie ................................................................................................ 201

Anexa A. Descrierea blocurilor bibliotecilor System Generator ................ 213

9

1. Introducere Lucrarea de faţă îşi propune cercetarea metodelor de proiectare a sistemelor încorporate

bazate pe dispozitive de tip FPGA (Field Programmable Gate Array) în vederea realizării de sisteme de control rapide, de înaltă performanţă. Prin sistem încorporat se înţelege un sistem electronic digital de dimensiuni reduse, proiectat pentru o aplicaţie specifică, lucrând sub incidenţa unor constrângeri de timp real. Termenul “încorporat”, o traducere aproximativă a mult mai cunoscutului şi acceptatului termen “embedded” din limba engleză, se poate aplica unui sistem din mai multe puncte de vedere:

• De obicei, aceste sisteme electronice sunt încorporate din punct de vedere fizic în produsul final, formând un tot unitar cu elementele electrice şi mecanice cu care interacţionează.

• Dintr-o altă perspectivă, termenul se aplică adesea cu privire la sistemul de calcul ce formează centrul sistemului digital: acesta nu este un procesor obişnuit, de tipul celor utilizate în calculatoarele personale, ci încorporează pe un singur cip şi memorie de program şi de date şi circuite periferice. De obicei, aceste cipuri sunt microcontrolere sau controlere digitale de semnal (DSC – Digital Signal Controller). Acest din urmă termen este folosit recent pentru desemnarea unor circuite complexe de tip microcontroler, dotate deci cu periferice puternice, al căror procesor este însă proiectat special pentru a realiza eficient operaţii specifice domeniului prelucrării digitale de semnal. DSC-urile sunt aşadar o combinaţie între microcontrolere şi procesoare digitale de semnal (DSP – Digital Signal Processor).

• O a treia accepţiune a termenului “încorporat” se referă la faptul că aceste sisteme sunt de obicei bazate pe un procesor, iar acesta rulează un program ce execută sarcinile sistemului. Aşadar, sistemul nu este reprezentat doar de circuitele electronice ce-l compun, ci încorporează şi software-ul ce se execută pe el.

În această lucrare, însă, se va discuta despre sisteme încorporate cu dispozitive FPGA. Aşadar, centrul sistemului va fi un FPGA, nu un microcontroler sau DSC. Deşi acest lucru poate părea în contradicţie cu punctele al doilea şi al treilea enunţate mai sus, o privire mai atentă asupra dispozitivelor FPGA va estompa această contradicţie. Aceasta deoarece FPGA-urile reprezintă actualmente platforme pentru sisteme digitale complexe şi oferă elemente computaţionale din ce în ce mai sofisticate şi mai numeroase. Termenul FPGA, tradus în româneşte prin matrice sau arie de porţi logice re-programabilă, are o conotaţie mai mult istorică, pentru că dispozitivele FPGA nu mai sunt doar circuite reconfigurabile ce pot implementa funcţii logice complexe, cum erau la apariţia lor, când se utilizau ca logică de legătură în sistemele cu procesor. Acum, pe un FPGA se integrează blocuri de memorie RAM (Random Access Memory) şi multiplicatoare hardware sau chiar celule DSP bazate pe operaţia combinată înmulţire-

10

acumulare (MAC – Multiply-Accumulate). Pe lângă faptul că densitatea de integrare a dus la construirea de FPGA-uri cu milioane de porţi logice echivalente, aceste elemente computaţionale avansate (pe un FPGA pot fi de la câteva zeci la câteva mii de celule DSP) permit transformarea FPGA-ului într-o maşină de calcul extraordinară. Aşadar, FPGA-ul poate constitui unitatea de procesare a sistemului încorporat. Aceasta se poate realiza prin implementarea algoritmului de control direct în hardware pe FPGA, deşi se poate apela şi la varianta clasică: în FPGA se poate implementa un procesor soft, iar pe acesta va rula în software algoritmul.

Faptul că dispozitivele FPGA pot constitui maşini de calcul performante a condus şi la interesul acordat acestor dispozitive în domeniul controlului automat, domeniu în care algoritmii se pretează la paralelizare şi timpii de calcul pot fi critici. Acest interes este subliniat de secţiuni speciale în IEEE Transactions on Industrial Electronics, jurnalul numărul 1 în categoria Thomson Reuters Automation & Control Systems [1], consacrate utilizării FPGA-urilor în sisteme de control industriale (volumul 54, numărul 4, august 2007 şi volumul 55, numărul 4, aprilie 2008). De asemenea, jurnalul IEEE Transactions on Industrial Informatics pregăteşte un astfel de număr pentru 2012.

Industria dispozitivelor FPGA este, în prezent, cea mai profitabilă dintre ramurile industriei electronice (conform unui studiu publicat de Forbes, cu date de la Audit Integrity, FT Interactive Data, Thomson IBES, Thomson Reuters, Worldscope, Bloomberg, Standard & Poor’s, Thomson One Analytics, Value One), două dintre cele patru companii din industria electronică din top sunt producătorii de FPGA-uri Altera şi Xilinx) [2]. Este, de asemenea, cea mai inovativă din punct de vedere tehnologic, actualmente cele mai noi procese de producţie a semiconductorilor fiind testate pe dispozitive FPGA. Succesul acestei industrii se datorează în primul rând unui nou mod de a pune problema: dispozitivele FPGA oferă elemente integrate de complexitatea celor posibile în circuitele integrate orientate pe aplicaţie (ASIC - Application Specific Integrated Circuit), cu avantajul programabilităţii, sau, mai bine zis, al configurabilităţii. Se impune precizarea acestui termen: deşi în denumirea FPGA apare cuvântul “programabil”, acesta duce cu gândul la un program software ce rulează pe un procesor şi ce poate fi modificat. Or, în ceea ce priveşte FPGA-urile, această situaţie este un caz particular nu foarte răspândit: de cele mai multe ori, sarcinile sunt executate în hardware pe FPGA. De aceea, este mai clar termenul „configurabil” în legătură cu posibilitatea de a redefini funcţionalitatea îndeplinită de circuitul FPGA.

Lucrarea este structurată pe cinci capitole şi se ocupă de conturarea unei metodologii originale de proiectare a unui sistem bazat pe FPGA pentru controlul motorului sincron cu magneţi permanenţi (PMSM – Permanent Magnet Synchronous Machine). Sunt prezentate sintetic şi informaţii conexe, de la arhitectura dispozitivelor FPGA şi software-ul System Generator la metode de optimizare a proiectării structurilor numerice ţinând cont de particularităţile dispozitivelor FPGA.

Al doilea capitol prezintă locul dispozitivelor FPGA în sistemele de control moderne pentru motoare electrice. Pentru atingerea acestui scop, se începe cu o prezentare sumară a

11

dispozitivelor FPGA, începând cu un scurt istoric şi ajungând la detaliile arhitecturale ale dispozitivelor actuale.

Astfel, în primul subcapitol este punctată istoric evoluţia dispozitivelor FPGA, împărţită în patru etape ce se pot separa pe baza apariţiei unor noi caracteristici ale dispozitivelor şi uneltelor de dezvoltare pentru ele.

Cel de-al doilea subcapitol reprezintă o trecere în revistă succintă, de sinteză, a familiilor actuale de FPGA-uri ale principalilor doi producători, Altera şi Xilinx. Se insistă pe elementele arhitecturale ale fiecărei familii, evidenţiindu-se faptul că aceste dispozitive nu sunt simple arii de porţi logice interconectabile, ci integrează elemente complexe de procesare. O concluzie a acestui subcapitol este faptul că dispozitivele FPGA actuale au “virtual” o putere de calcul fantastică. Aceasta este “virtuală” deoarece trebuie folosită prin proiectarea unui sistem care să utilizeze resursele disponibile, altfel acestea neavând nicio însemnătate. Lucrurile stau la fel cu un procesor capabil să execute un anumit număr de operaţii pe secundă: trebuie dezvoltat software-ul care să facă acest lucru. Diferenţa este însă crucială: proiectarea de software pentru un procesor este un domeniu matur, cunoscut, studiat de foarte mult timp şi stabilit în făgaşuri clare. Proiectarea de hardware pentru FPGA, deşi utilizând de foarte mult timp unelte şi metode “clasice”, ca descrierea în limbaj HDL şi proiectarea la nivel de transfer între registre, are parte de o reinventare în ultimul timp prin introducerea unor metode şi unelte noi, la un nivel de abstractizare mai înalt: limbaje de tip C sau scheme bloc în Simulink.

În al treilea subcapitol este prezentată o metodologie generală de proiectare a sistemelor de control automat implementate în FPGA. Aceasta se bazează pe trei principii fundamentale: 1) rafinarea algoritmului, 2) modularitatea şi reutilizabilitatea, 3) potrivirea optimă algoritm-hardware.

În finalul capitolului, un subcapitol este dedicat prezentării sistemelor bazate pe FPGA pentru controlul motoarelor electrice recent apărute în literatură. Această prezentare constituie un studiu al stadiului actual al cercetării, util atât pentru a sublinia originalitatea şi validitatea rezultatelor obţinute cu această teză, cât şi pentru a o înscrie în tendinţele din cercetare în domeniu la nivel internaţional.

Capitolul 3 descrie uneltele de dezvoltare disponibile pentru proiectarea sistemelor bazate pe FPGA. În primul subcapitol, după o prezentare a evoluţiei uneltelor de dezvoltare legată de evoluţia dispozitivelor FPGA, ce a fost expusă în capitolul anterior, sunt trecute în revistă principalele unelte disponibile, grupate pe trei categorii: nuclee IP, unelte pentru sisteme încorporate, unelte pentru nuclee DSP.

Al doilea subcapitol constituie un studiu mai amănunţit al software-ului System Generator produs de Xilinx, ce permite proiectarea de module hardware direct implementabile în FPGA din mediul Matlab Simulink. Sunt prezentate complet, într-o sinteză originală, o parte din bibliotecile oferite de System Generator, cele ce au fost considerate utile în implementarea de structuri hardware pentru control automat. De asemenea, sunt prezentate amănunţit blocurile indispensabile realizării unui modul hardware folosind System Generator, expunându-se setările

12

lor posibile şi uzuale. În final, este prezentată metoda de importare a unor module proiectate prin alte metode în Simulink şi co-simularea lor folosind combinaţia de unelte Simulink-ModelSim.

Cel de-al treilea subcapitol este o scurtă trecere în revistă a uneltelor de depanare pentru sisteme bazate pe FPGA.

În finalul capitolului se prezintă trei studii de caz originale, ilustrative pentru metodele de proiectare (şi combinarea lor) folosind dispozitive FPGA.

Primul dintre acestea urmăreşte proiectarea unui sistem de control al vitezei pentru motorul de curent continuu integrându-l într-o buclă cu calare pe fază. În acest sens s-a proiectat un detector de fază şi frecvenţă original, ce a fost validat prin simulare în ModelSim. Apoi s-a proiectat un filtru de buclă de tip proporţional-integrator şi s-a integrat întreg sistemul în FPGA. Proiectarea s-a realizat la nivel de schemă logică. Sistemul a fost verificat experimental, dovedind că este capabil de calare pe fază şi deci de control al vitezei.

În al doilea studiu de caz s-a proiectat un sistem de control al vitezei pentru motorul de curent continuu folosind algoritmul deadbeat. Acesta a fost proiectat ca un filtru cu răspuns infinit la impuls în Simulink, folosind blocuri System Generator. A fost validat prin simulare, folosind un model al motorului, apoi a fost implementat pe FPGA şi verificat experimental. Răspunsul sistemului experimental s-a dovedit în perfectă concordanţă cu cel al sistemului simulat. Pentru proiectare s-a folosit captura de schemă logică pentru interfaţa cu convertoarele analog-numeric şi numeric-analogic, mediul StateCAD pentru proiectarea maşinilor cu stări de control şi System Generator pentru regulator.

Cel de-al treilea studiu de caz s-a ocupat de proiectarea unui sistem de control al vitezei pentru motorul BLDC. Spre deosebire de motorul de curent continuu clasic, motorul BLDC se caracterizează prin faptul că tensiunea de comandă trebuie comutată între perechi de înfăşurări ale statorului. În acest scop s-a proiectat în FPGA un set de module originale pentru comutarea tensiunii în motor în funcţie de poziţia rotorului. Acestea, proiectate la nivel de schemă logică, au fost combinate cu un algoritm de control de tip PI, proiectat în Simulink. Întregul sistem a fost validat prin co-simulare Simulink-ModelSim şi verificat experimental.

Originalitatea şi actualitatea sistemelor de control prezentate în acest capitol au condus la redactarea şi publicarea a 6 lucrări: [102], [103], [105], [109], [110], [111].

În Capitolul 4 este abordat domeniul procesoarelor soft implementabile în FPGA. Prin procesor soft se înţelege un procesor implementat în resursele de uz general ale unui FPGA. Au existat şi FPGA-uri ce conţineau procesoare hard, adică nuclee fixe, ne-reconfigurabile, capabile să se interfaţeze uşor cu restul resurselor din FPGA.

În primul subcapitol sunt expuse câteva consideraţii teoretice cu privire la proiectarea de procesoare soft în vederea implementării pe dispozitive de tip FPGA, subliniindu-se modul în care proiectarea trebuie să ţină cont de arhitectura specifică a FPGA-ului, destul de diferită de cea a unui ASIC. Sunt prezentate dificultăţile legate de diferenţa de arhitectură, avantajele oferite de re-configurabilitatea FPGA-ului şi o serie de optimizări posibile pentru structurile numerice întâlnite adesea într-un procesor. Acestea au aplicabilitate largă, nefiind neapărat legate de

13

procesor. Subcapitolul reprezintă o sinteză originală din câteva surse bibliografice, completată cu observaţii şi comentarii proprii.

În al doilea subcapitol este descrisă pe scurt arhitectura procesorului soft PicoBlaze, produs de Xilinx pentru implementare optimă pe FPGA-urile lor. Acesta este un procesor pe 8 biţi, suficient de simplu pentru a ocupa o cantitate insignifiantă de resurse din FPGA (doar 3% dintr-un dispozitiv Spartan-3E XC3S500E), dar suficient de complex pentru a oferi o platformă completă de rulare pentru programe software simple, fără pretenţii de procesare complexă de date. Subcapitolul prezintă succint şi uneltele de dezvoltare pentru PicoBlaze, ca şi posibilităţile de simulare pentru depanarea programului.

Cum până la redactarea acestui capitol, autorul şi-a format deja o părere privind perspectivele implementării în hardware a algoritmilor de control, mult superioară din punctul de vedere al vitezei de execuţie faţă de implementarea în software, s-a găsit o nişă unde procesoarele soft prezintă interes în aplicaţiile de control: sarcinile de monitorizare. Astfel, în ultimul subcapitol se prezintă un studiu de caz original: co-proiectarea hardware-software în sisteme de control. Sistemul de control al vitezei pentru motorul BLDC, prezentat în finalul capitolului precedent, a fost completat cu sarcini de monitorizare: parametrii regulatorului sunt vizualizaţi pe un afişor alfanumeric cu cristale lichide şi sunt transmişi serial pe o interfaţă RS232 la un calculator gazdă, împreună cu valorile instantanee ale semnalelor de comandă şi de răspuns. Problema a fost partiţionată între software şi hardware: algoritmul de control se execută în hardware proiectat special pentru aplicaţie (prezentat deja), iar sarcinile de monitorizare, cu restricţii de temporizare mult mai relaxate, se execută prin software pe procesoare PicoBlaze. Sistemul de control prezentat la sfârşitul capitolului anterior a fost aşadar extins cu două sisteme cu procesor soft. Fiecare se ocupă cu una singură din cele două sarcini, uşurându-se astfel dezvoltarea software-ului şi interfaţarea fiecărui sistem cu resursele hardware. S-a obţinut astfel un sistem complex pe un singur cip, conţinând atât elemente hardware, cât şi software, originale şi proiectate pentru aplicaţia exemplificată. Sistemul s-a verificat experimental, obţinându-se pe calculatorul gazdă o interfaţă în timp real cu motorul BLDC controlat.

Sistemul a fost descris în lucrarea publicată [122]. Ultimele două capitole sunt dedicate atingerii scopului declarat al lucrării: proiectarea

unui sistem de control al vitezei pentru motorul sincron cu magneţi permanenţi. Cum acest tip de motor necesită tensiuni sinusoidale de alimentare a fazelor statorului, au fost studiate mai întâi tehnici de modulaţie pentru obţinerea eficientă a acestora.

În acest sens, în Capitolul 5 se prezintă 2 tehnici de modulaţie moderne şi eficiente pentru controlul digital al invertoarelor trifazate: modulaţia sinusoidală cu injecţie de semnal la punctul neutru şi modulaţia bazată pe vectori spaţiali.

Astfel, în primul subcapitol sunt prezentate câteva aspecte teoretice ale modulaţiei sinusoidale în lăţimea impulsurilor, pentru ca în al doilea subcapitol să se discute implementarea pe un dispozitiv FPGA a acestei tehnici de modulaţie, îmbunătăţită prin injecţia de semnal triunghiular la punctul neutru. Tehnica de injecţie de semnal la punctul neutru are rolul de a îmbunătăţi utilizarea sursei de alimentare, scăzând amplitudinea (şi forma de undă a) semnalelor

14

modulatoare fără a afecta însă semnalele diferenţiale între faze. Prin metoda de obţinere a semnalului injectat, se introduce în procesul de modulaţie şi o măsură a interacţiunii între semnalele corespunzătoare celor trei faze, acestea nemaifiind tratate ca semnale sinusoidale independente. Modulatorul prezentat a fost proiectat folosind System Generator, implementat pe FPGA şi testat experimental.

În al treilea subcapitol este prezentată modulaţia bazată pe vectori spaţiali, urmată în subcapitolul patru de proiectarea modulatorului şi implementarea sa folosind System Generator. Pentru proiectare s-a folosit o variantă a algoritmului bazată pe calcule geometrice simple şi s-au fructificat la maximum posibilităţile de paralelizare a operaţiilor, obţinându-se o implementare cu un timp de calcul foarte scurt, de doar 160ns la o frecvenţă de tact de 50MHz. Şi acest modulator a fost implementat fizic şi testat experimental.

Al cincilea subcapitol face o comparaţie între cele două modulatoare proiectate, având în vedere că din punctul de vedere al rezultatului ele sunt echivalente. Concluzia acestui studiu comparativ este că modulatorul bazat pe vectori spaţiali este mult mai potrivit pentru utilizarea într-un sistem de control pentru un motor de curent alternativ trifazat, datorită faptului că se execută mai repede, are nevoie de mai puţine multiplicatoare hardware (o resursă critică în FPGA-urile de cost redus) şi se aplică reprezentării bifazate a semnalelor de intrare, mai apropiată de reprezentarea internă într-un sistem de control decât cea trifazată.

În subcapitolul şase s-a extins rezoluţia modulatorului bazat pe vectori spaţiali prin tehnici caracteristice dispozitivelor FPGA, şi anume utilizarea de semnale de tact defazate de o unitate de gestionare a semnalelor de tact din FPGA pentru sincronizarea fronturilor impulsurilor de ieşire din modulator. Modulatorul astfel îmbunătăţit a fost testat experimental pentru controlul unui motor de inducţie, folosind tehnica în buclă deschisă V/Hz.

Prezentarea acestor tehnici se face din perspectiva implementării pe FPGA a modulatoarelor respective. Rezultatele obţinute sunt comparate cu altele din literatură. Cele două modulatoare sunt comparate între ele, în vederea alegerii celui mai potrivit pentru integrarea într-un sistem de control în timp real.

Originalitatea studiilor prezentate în acest capitol şi validitatea rezultatelor experimentale obţinute au condus la redactarea şi publicarea a 4 lucrări: [143], [144], [145], [146].

În sfârşit, în Capitolul 6 se expune proiectarea unui sistem de control al vitezei pentru motorul sincron cu magneţi permanenţi. În primul subcapitol este prezentată modelarea motorului în sistemul de coordonate rotitor sincron cu rotorul. Această abordare simplifică foarte mult modelul motorului, eliminând parametrii variabili în timp din ecuaţiile ce-l descriu, dar complică sistemul de control, ce va trebui să realizeze transformările de coordonate în timp real.

În al doilea subcapitol se prezintă proiectarea sistemului de control, folosind trei regulatoare: două regulatoare PI pentru curenţi şi un regulator combinat PI-P pentru viteză. Parametrii regulatoarelor sunt derivaţi prin metoda alocării polilor, ţinând cont de modelul motorului.

În al treilea subcapitol, sistemul de control analogic (continuu) a fost validat prin simulare în Simulink. Apoi, în cel de-al patrulea subcapitol, sistemul de control a fost discretizat

15

şi implementat folosind blocuri System Generator. În acest moment, s-a verificat că prin discretizare comportarea sistemului de control rămâne la fel cu comportarea sistemului de control continuu. În acest scop, cele două sisteme au fost simulate împreună în Simulink, iar semnalele de comandă şi cele de răspuns au fost comparate pe toată perioada simulării. S-a validat astfel lungimea aleasă a cuvântului pentru reprezentarea numerică a semnalelor (18 biţi), erorile de cuantizare fiind neglijabile în comparaţie cu erorile introduse de aproximările integratoarelor şi de extrapolatoarele de ordin 0 de pe ieşiri.

Deşi în acest stadiu sistemul de control realizat cu blocuri System Generator este direct implementabil în FPGA, el nu este utilizabil în această formă deoarece ar necesita prea multe resurse (mai multe multiplicatoare decât sunt disponibile în dispozitivul ţintă, Spartan-3E XC3S500E), şi ar avea nevoie de un semnal de tact separat, de 20kHz. De aceea, sistemul este factorizat pentru a folosi doar 4 multiplicatoare şi reproiectat pentru a fi sincron cu semnalul de tact global, de 50MHz. Acest proces de proiectare, care este şi contribuţia originală majoră a capitolului, este prezentat în subcapitolul cinci.

În subcapitolul şase sunt prezentaţi succint senzorii utilizaţi în sistem (de curent şi de poziţie/viteză) şi modulele hardware proiectate pentru interfaţarea lor, iar în ultimul subcapitol sunt descrise rezultatele experimentale după implementarea sistemului de control în FPGA. Acestea sunt în perfectă concordanţă cu rezultatele obţinute anterior prin simulare.

Aşadar, s-a realizat cu succes implementarea pe un dispozitiv FPGA de cost redus a unui sistem complet de control al vitezei pentru motorul sincron cu magneţi permanenţi. Acesta conţine patru bucle de reacţie şi se execută în doar 2.14μs, incluzând timpul necesar interfaţării cu senzorii de curent. Aşadar, s-a demonstrat că dispozitivele FPGA pot implementa foarte eficient algoritmi de control complecşi pentru procese rapide (chiar dacă motorul are un timp de răspuns de câteva ms, variaţia curenţilor prin motor este foarte rapidă, cu timpi de răspuns de ordinul zecilor de μs). În plus, paşii prezentaţi în acest capitol pentru obţinerea unui sistem implementabil dintr-un model teoretic constituie o metodologie originală de proiectare ce se poate aplica la implementarea oricărui sistem de control.

Sistemul de control prezentat în acest capitol a fost descris în lucrarea [161], acceptată spre publicare.

Fiecare capitol este încheiat cu un subcapitol de concluzii, în care se subliniază rezultatele obţinute şi contribuţiile originale. În finalul lucrării, un capitol de concluzii generale sintetizează aceste contribuţii şi lansează câteva direcţii viitoare de cercetare.

17

2. Dispozitive FPGA în controlul maşinilor electrice Prima parte a acestui capitol prezintă pe scurt evoluţia arhitecturală şi tehnologică a

dispozitivelor FPGA de la lansarea lor în 1984 [3]. Astfel, în Secţiunea 2.1 este prezentată o scurtă istorie a dezvoltării circuitelor FPGA, iar în Secţiunea 2.2 sunt discutate opţiunile arhitecturale generale ale principalilor fabricanţi de FPGA-uri. În Secţiunea 2.3 este sintetizată din literatură o metodologie de proiectare a sistemelor digitale implementate în FPGA, iar în Secţiunea 2.4 sunt prezentate câteva din multele articole ce prezintă sisteme de control pentru maşini electrice implementate în FPGA, conturând stadiul actual al cercetării în domeniu.

2.1 Evoluţia dispozitivelor FPGA Primul dispozitiv de tip FPGA a fost lansat de firma Xilinx în 1984. Acesta conţinea 64

de blocuri logice interconectate printr-o matrice de conexiuni programabile, avea 58 de pini de intrare/ieşire şi era implementat în tehnologie de 2μm, folosind 85000 de tranzistoare [4].

Avantajul acestei arhitecturi era scalabilitatea: odată cu îmbunătăţirea procesului de fabricaţie, mai multe elemente de bază puteau fi integrate pe acelaşi cip, crescând posibilităţile oferite de acesta. Astfel, de-a lungul anilor 1980, producătorii de FPGA-uri au continuat să crească numărul de blocuri logice, numărul nivelelor de interconectare şi numărul pinilor de intrare/ieşire.

Perioada 1985 – 1991 poate fi astfel considerată perioada “copilăriei” dispozitivelor FPGA. Aceasta este caracterizată prin faptul că FPGA-urile erau folosite ca logică de legătură în sisteme mai mari şi programele software ce implementau circuitele proiectate în FPGA erau relativ simple şi uşor de îmbunătăţit.

Figura 2.1. Arhitectura generală a unui dispozitiv FPGA.

18

În curând însă s-a dovedit că această abordare nu era suficientă: odată cu creşterea numărului de blocuri logice, interconexiunile lungi şi complexe dintre ele deveneau factorul limitativ al performanţelor dispozitivului. De aceea, având în vedere că tehnologia de fabricaţie permitea integrarea a tot mai multor tranzistoare, a apărut ideea încorporării de hardware dedicat. Astfel, la mijlocul anilor 1990 apar primele FPGA-uri cu blocuri de memorie RAM încorporate. Tot atunci apar primele tehnici de creştere pe cip a frecvenţei de lucru, prin integrarea de circuite cu calare pe fază (PLL – Phase Locked Loop) de multiplicare a frecvenţei.

Perioada 1992 – 1999 poate fi considerată perioada de expansiune a dispozitivelor FPGA. La începutul acestei perioade, multe firme producătoare se retrag din domeniu (Plessey, Toshiba, Motorola, IBM) pentru că arhitecturile propuse de ele nu fac faţă scalabilităţii permise de avansarea rapidă a tehnologiei de producţie. În această perioadă, creşterea rapidă a complexităţii circuitelor pune presiune pe dezvoltarea de software de sinteză automată care să permită proiectarea uşoară şi folosirea eficientă a resurselor hardware. Totodată, FPGA-urile încep să fie folosite în aplicaţii mai complexe, în domeniul comunicaţiilor şi calculelor aritmetice.

Perioada 2000 – 2007 poate fi considerată perioada de acumulare a dispozitivelor FPGA: se integrează din ce în ce mai multe şi mai sofisticate blocuri hardware: de la microprocesoare la circuite de comunicaţie rapidă, de la funcţii aritmetice specializate la blocuri dedicate procesării digitale de semnal (DSP - Digital Signal Processing), bazate pe multiplicatoare hardware şi acumulatoare. În 2000 apare primul FPGA cu procesor hardware încorporat, bazat pe arhitectura ARM. De asemenea, odată cu creşterea numărului de blocuri logice integrate, a apărut tendinţa producătorilor de FPGA-uri de a dezvolta procesoare soft, implementabile economic în blocurile logice din FPGA.

În prezent, FPGA-urile au devenit platforme sistem: ambii mari producători de FPGA-uri îşi descriu dispozitivele complexe în astfel de termeni. Familia Virtex 6 de la Xilinx este descrisă ca FPGA platformă. Familia Stratix IV de la Altera este comercializată ca FPGA high end, capabilă să implementeze un întreg sistem pe un cip (SoC - System on a Chip). Astfel, de la epoca blocurilor logice interconectate prin conexiuni programabile, s-a ajuns la dispozitive configurabile complexe, capabile să implementeze un întreg sistem digital pe un cip, sistem compus din mai multe procesoare hard sau soft, din motoare de procesare dedicate DSP, coprocesoare matematice, periferice de control al memoriei sau de comunicaţie [5], [6].

Ce rezervă viitorul? Conform [7], se pare că începând din 2007 am intrat în perioada specializării: familii diverse de FPGA-uri, bazate pe arhitecturi diferite, vor oferi dispozitive specializate pentru diferite tipuri de aplicaţii. De asemenea, programele software de sinteză la nivel înalt se vor specializa pe domenii diferite de aplicaţii.

2.2 Arhitecturi actuale de FPGA Această secţiune va prezenta pe scurt opţiunile arhitecturale şi tehnologice ale

principalilor producători actuali de dispozitive FPGA, firmele Altera şi Xilinx.

19

2.2.1 FPGA-urile Altera

Altera este unul din cei doi mari producători de FPGA-uri. Arhitectura iniţială era bazată

pe structuri PLD. Actualmente, firma dezvoltă mai multe familii de dispozitive FPGA, prezentate în Tabelul 2.1.

Tabelul 2.1 Familiile de dispozitive FPGA ale firmei Altera.

Familie Scurtă descriere Cyclone III FPGA-uri cu preţ scăzut, putere disipată mică. Stratix IV FPGA-uri high end, cu densitate mare, optimizate pentru proiectare de SoC-

uri. Arria II GX FPGA-uri cu transceiver-e integrate, optimizate pentru cele mai utilizate

protocoale de comunicaţie până la 3.125 Gbps. Arhitectura familiei Cyclone III se bazează pe elementul logic (LE - Logic Element),

prezentat în Fig. 2.2, reprodusă din [8]. Acesta este proiectat să poată implementa o funcţie logică pur combinaţională (prin tabela de căutare, LUT – Look-Up Table), o funcţie de întârziere sau deplasare (prin bistabil) sau un circuit logic secvenţial (logică combinaţională urmată de bistabili). Pe lângă logica ce permite toate aceste posibilităţi, sunt prezente elemente de interconectare şi multiplexare şi logică aritmetică pentru generarea rapidă de transport (carry). La familia Cyclone, LUT-ul are 4 intrări. Funcţii logice complexe pot fi obţinute legând în paralel mai multe LUT-uri de pe LE-uri diferite, prin matricea de interconectare. Mai multe LE-uri sunt grupate într-un bloc logic matricial (LAB – Logic Array Block).

Un LE poate opera în două moduri diferite: modul normal şi modul aritmetic. În fiecare mod, resursele LE-ului sunt folosite altfel. În ambele moduri sunt disponibile 6 intrări în LE: 4 intrări de date de la magistrala locală de interconectare a LAB-ului, semnalul de transport carry-in de la LE-ul anterior din LAB şi conexiunea de înlănţuire a bistabilului (register chain in). Sunt folosite semnale comune tuturor LE-urilor dintr-un LAB pentru semnalul de tact (clock), reset asincron şi sincron, încărcare sincronă şi validare de tact (clock enable) pentru bistabil.

20

Figura 2.2. Structura detaliată a unui LE al familiei Altera Cyclone III [8].

Figura 2.3. LE al familiei Altera Cyclone III în modul normal [8].

Modul normal este potrivit pentru implementarea de funcţii logice. Fig. 2.3, reprodusă tot

din [8], prezintă LE-ul în modul normal. În acest mod, cele 4 intrări de date sunt conectate la LUT. De asemenea, semnalul carry-in poate fi conectat direct la una din intrările LUT-ului. Ieşirea bistabilului poate fi de asemenea conectată la una din intrările LUT-ului pentru implementarea uşoară a circuitelor logice secvenţiale.

21

Modul aritmetic este potrivit pentru implementarea de sumatoare, numărătoare, acumulatoare şi comparatoare. În modul aritmetic, LE-ul implementează un sumator complet pe 2 biţi cu lanţ de propagare a transportului (carry chain). În acest mod, ieşirea LUT-ului poate fi salvată în bistabil sau rutată direct la ieşirea LE-ului. Ca şi la modul normal, ieşirea registrului poate fi conectată la intrarea LUT-ului. Figura 2.4, reprodusă din [8], prezintă LE-ul în modul de lucru aritmetic.

Aşa cum am amintit, LE-urile sunt grupate în LAB-uri. Fiecare LAB conţine 16 LE-uri cu lanţurile de transport dintre ele, lanţurile de interconectare a bistabililor (register chain), magistrala locală de interconectare şi semnalele de control ale LAB-ului.

Pe lângă LAB-uri, FPGA-urile familiei Cyclone III conţin şi blocuri de memorie de 9 kbiţi fiecare, denumite M9K, ce pot opera cu viteze de până la 315MHz. Acestea pot fi configurate ca memorie RAM, memorie ROM sau tampon (buffer) FIFO (First In First Out). Blocurile M9K pot opera în modurile port unic (single port), port dual simplu (simple dual-port) şi port dual real (true dual-port). În modul port dual simplu, memoria este prevăzută cu două porturi, dar unul poate fi folosit doar pentru scriere şi celălalt doar pentru citire. În modul port dual real, memoria este prevăzută cu două porturi total independente, putându-se executa orice combinaţie de operaţii. Memoria poate fi configurată pe 1, 2, 4, 8, 9, 16, 18, 32 sau 36 de biţi (ultimele 2 configuraţii nu sunt disponibile în modul port dual real).

În plus, familia Cyclone III are integrate blocuri multiplicatoare hardware. Fiecare bloc poate fi configurat ca un singur multiplicator pe 18x18 biţi, sau ca 2 multiplicatoare independente pe 9x9 biţi.

De asemenea, familia Cyclone III dispune de bucle cu calare pe fază (PLL – Phase Locked Loop), fiecare cu câte 5 ieşiri, pentru gestionarea şi sintetizarea semnalelor de tact.

Figura 2.4. LE al familiei Altera Cyclone III în modul aritmetic [8].

22

LAB-urile sunt interconectate prin magistrale linie şi coloană de conexiuni programabile. LAB-urile învecinate, PLL-urile, blocurile M9K, multiplicatoarele dedicate se pot conecta direct la magistrala locală de interconectare a unui LAB prin conexiuni directe de legătură (direct link connection). Acestea permit minimizarea folosirii magistralelor linie şi coloană, obţinându-se astfel performanţă şi flexibilitate. Fiecare LE se poate lega la alte 48 de LE-uri prin magistrala locală sau prin conexiuni directe de legătură.

Celulele de bază ale familiei Altera Stratix IV sunt modulele logice adaptabile (ALM –

Adaptive Logic Module), grupate în LAB-uri. Fiecare LAB conţine 10 ALM-uri, lanţuri de propagare a transportului, lanţuri de aritmetică partajată (shared arithmetic chain), semnale de control ale LAB-ului, magistrală locală de interconectare şi lanţuri de interconectare a bistabililor. Există, ca şi la familia Cyclone III, conceptul de conexiuni directe de legătură între entităţi învecinate.

La familia Stratix IV există o derivaţie a LAB-ului numită memorie LAB (MLAB – Memory LAB). MLAB-ul adaugă o memorie SRAM bazată pe LUT unui LAB obişnuit. Astfel, un MLAB oferă maximum 640 de biţi de memorie SRAM cu port dual simplu. Fiecare ALM dintr-un MLAB poate fi configurat ca un bloc de memorie 64x1 sau 32x2.

Fiecare ALM conţine două LUT-uri adaptive (ALUT – Adaptive LUT) şi doi bistabili, aşa cum se prezintă în Fig. 2.5, reprodusă din [9].

Având până la 8 intrări în ALUT-uri, un ALM poate implementa combinaţii variate de două funcţii, ceea ce permite compatibilitatea cu arhitecturile bazate pe LUT-uri cu 4 intrări. De asemenea, un ALM poate implementa orice funcţie cu 6 intrări şi chiar anumite funcţii cu 7 intrări.

Pe lângă resursele bazate pe ALUT-uri, ALM-ul conţine 2 bistabili, 2 sumatoare complete dedicate, un lanţ de propagare a transportului, un lanţ de aritmetică partajată şi un lanţ de interconectare a bistabililor.

ALM-ul poate opera în 5 moduri distincte, care nu mai sunt detaliate în această lucrare: modul normal, modul de LUT extins, modul aritmetic, modul aritmetic partajat şi modul LUT – registru.

23

Figura 2.5. ALM al familiei Altera Stratix IV [9].

Blocurile de memorie integrate în arhitectura Stratix IV sunt de trei feluri: MLAB, de 640

de biţi, deja discutat; M9K, de 9 kbiţi, acelaşi ca la familia Cyclone III; M144K, de 144 kbiţi. Fiecare bloc de memorie poate fi configurat ca RAM cu port unic sau dual, tampon FIFO, ROM sau registru de deplasare (shift register).

Familia Stratix IV conţine blocuri DSP dedicate. Fiecare bloc DSP are 288 de semnale de intrare şi 34 de control şi poate fi împărţit în 2 semi-blocuri, fiecare operând pe 144 de biţi, cu ieşirea pe 72 de biţi. Un bloc DSP constă din bancul registrelor de intrare, 4 sumatoare legate la câte 2 multiplicatoare, bancul registrelor de pipeline, 2 sumatoare de nivelul 2, 4 unităţi de logică de rotunjire şi saturare, bancul registrelor sumatoarelor de nivelul 2 şi bancul registrelor de ieşire. Arhitectura unui semi-bloc DSP este prezentată în Fig. 2.6, reprodusă din [9].

Blocurile DSP ale familiei Stratix IV pot opera în 6 moduri, rezumate în Tabelul 2.2. În unele moduri rezultatelor li se poate aplica rotunjire şi saturaţie. Sunt implementate două moduri de rotunjire a numerelor, rotunjire la cel mai apropiat întreg şi rotunjire la cel mai apropiat număr par. De asemenea, sunt implementate două moduri de saturaţie, simetrică şi asimetrică. În reprezentarea numerelor în complement faţă de 2, saturaţia simetrică presupune limitarea

numerelor negative nu la 12 −− n , ci la 12 1 +− −n , unde n este numărul de biţi ai reprezentării. În

acest fel, plaja de valori reprezentabile este simetrică, între 12 1 +− −n şi 12 1 −−n . De exemplu, pentru n=8, plaja de valori ar fi cuprinsă între -127 şi +127, în loc de -128 şi +127, cum este în mod normal.

24

Figura 2.6. Arhitectura unui semi-bloc DSP al familiei Stratix IV [9].

Tabelul 2.2. Modurile de operare ale blocurilor DSP ale familiei Stratix IV.

Mod de operare Nr. biţi de intrare Nr. de multiplicatoare

folosite

Nr. de module implementabile pe un bloc DSP

9 biţi 1 8 12 biţi 1 6 18 biţi 1 4 36 biţi 1 2

Multiplicator independent

54 biţi 1 2 Sumator cu două multiplicatoare 18 biţi 2 4 Sumator cu patru multiplicatoare 18 biţi 4 2

Acumulator cu multiplicator 18 biţi 4 2 Registru de deplasare 36 biţi 1 2

Sumator cu multiplicator de precizie 18x36 biţi 2 2

25

Familia Stratix IV are o structură ierarhică de distribuţie a semnalelor de tact, împărţită în reţele de tact globale, regionale şi periferice. În acest fel, sunt disponibile până la 236 de domenii de tact diferite. În zonele rămase nefolosite din FPGA, reţelele de tact pot fi deconectate, pentru minimizarea puterii disipate.

Diferite frecvenţe ale semnalului de tact pot fi generate cu ajutorul multiplelor circuite PLL prezente, fiecare cu câte 10 ieşiri.

Circuitele din familia Stratix IV permit interfaţarea directă cu memorii SDRAM (Synchronous Dynamic RAM) externe cu rată de transfer dublă (DDR - Double Data Rate).

Familia Stratix IV dispune şi de circuite dedicate de serializare/deserializare (SERDES), ce suportă interfaţa LVDS (Low Voltage Differential Signalling) şi permit rate de transfer de până la 1,6 Gbps. Aceste transmiţătoare/receptoare (transceivers) pot fi configurate pentru o serie de protocoale sincrone, cum ar fi Utopia, Rapid I/O, XBSI, SFI, SPI, sau asincrone, ca SGMII, Gigabit Ethernet.

Familia Arria II GX se bazează pe aceleaşi componente logice de bază (ALM, LAB),

blocuri de memorie (MLAB, M9K) şi blocuri DSP ca şi familia Stratix IV. Pe lângă acestea, sunt integrate un bloc IP (Intellectual Property) hard PCI Express şi până la 16 transceiver-e de viteză mare (până la 3,75 Gbps). Această familie reprezintă un compromis între preţul scăzut şi puterea disipată mică a familiei Cyclone III şi puterea enormă de calcul şi transfer de date a familiei Stratix IV.

2.2.2 FPGA-urile Xilinx

Ca şi Altera, şi Xilinx oferă două familii principale de dispozitive FPGA, Spartan şi

Virtex. În continuare se prezintă caracteristicile arhitecturale principale ale acestor familii. Arhitectura familiei Spartan 6 se bazează pe felii logice (slice), grupate în blocuri logice

configurabile (CLB – Configurable Logic Block). Fiecare CLB conţine 2 felii alăturate. Fiecare felie conţine 4 LUT-uri, 8 bistabili şi logică complementară. Există 3 tipuri de felii logice în arhitectura Spartan 6: SLICEM, SLICEL şi SLICEX.

Un sfert din feliile logice ale unui dispozitiv Spartan 6 sunt de tipul SLICEM. Fiecare din cele 4 LUT-uri ale unui SLICEM poate fi configurat ca un singur LUT cu 6 intrări şi o ieşire sau ca 2 LUT-uri cu câte 5 intrări şi ieşiri independente. LUT-urile pot fi folosite şi ca memorie RAM distribuită de 64 de biţi, configurată ca 64x1 sau 32x2, sau ca registre de deplasare: un registru de 32 de biţi (SRL32 – Shift Register Logic) sau 2 registre de 16 biţi (SRL16). Ieşirea fiecărui LUT poate fi salvată într-un bistabil. Pentru operaţii aritmetice, un lanţ de propagare a transportului de mare viteză leagă între ele feliile logice de pe aceeaşi coloană din FPGA.

Fig. 2.7, reprodusă din [12], prezintă structura unui SLICEM.

26

Figura 2.7. Structura unui SLICEM al familiei Spartan 6 [12].

Tot un sfert din feliile logice ale unui dispozitiv Spartan 6 sunt de tipul SLICEL. Acestea

au aceeaşi structură ca şi SLICEM, cu excepţia posibilităţii de configurare ca memorie distribuită sau registru de deplasare.

Celelalte felii logice dintr-un Spartan 6 sunt de tipul SLICEX, care elimină din structura SLICEL logica de generare a transportului şi multiplexoarele.

FPGA-urile Spartan 6 conţin şi blocuri de memorie RAM cu port dual de 18 kbiţi. Accesurile la memorie sunt sincrone cu semnalul de tact. Fiecare port poate fi configurat ca 16Kx1, 8Kx2, 4Kx4, 2Kx8 (sau x9), 1Kx16 (sau x18), sau 512x32 (sau x36). Cele două porturi

27

de acces la un bloc de memorie pot avea lăţimi diferite. Configuraţiile x9, x18 şi x36 includ biţi de paritate. Fiecare bloc de RAM poate fi configurat ca două jumătăţi de 9kbiţi independente.

Unele dispozitive ale familiei includ blocuri de control al memoriei externe (MCB – Memory Controller Block), fiecare putându-se interfaţa la un cip de memorie DRAM de tipul DDR, DDR2, DDR3 sau LPDDR (Low Power DDR) şi putând atinge rate de transfer de 800 Mb/s.

Dispozitivele Spartan 6 dispun şi de blocuri dedicate operaţiilor DSP, numite DSP48A1. Fiecare astfel de bloc este alcătuit dintr-un multiplicator dedicat 18x18, ce lucrează cu numere reprezentate în complement faţă de 2, şi un acumulator de 48 de biţi şi poate opera la o frecvenţă de lucru de 250 MHz. Arhitectura internă a unui DSP48A1 este prezentată în Fig. 2.8, reprodusă din [14].

Blocul DSP48A1 oferă posibilitatea folosirii registrelor interne pentru implementarea de pipeline-uri. De asemenea, astfel de blocuri pot fi cascadate datorită multiplelor facilităţi de înlănţuire a propagării transportului. Acumulatorul poate fi folosit şi pe post de numărător sincron, iar multiplicatorul poate fi folosit pentru implementarea unui circuit de deplasare cu pas selectabil (barrel shifter).

Dispozitivele familiei Spartan 6 dispun de circuite speciale pentru generarea semnalelor de tact. Acestea sunt numite blocuri de gestionare a tactului (CMT – Clock Management Tile) şi sunt alcătuite fiecare din câte un circuit PLL şi două circuite digitale de gestionare a tactului (DCM – Digital Clock Manager). Aceste componente pot fi conectate între ele prin trasee dedicate, dar pot opera şi independent. Circuitul PLL poate fi folosit pentru sintetizarea frecvenţelor de tact şi filtrarea fluctuaţiilor semnalelor de tact externe sau interne.

Fiecare circuit PLL are 5 ieşiri de tact. Circuitele DCM îmbunătăţesc caracteristicile semnalului de tact prin eliminarea asimetriilor sau pot fi folosite pentru generarea de semnale de tact defazate (maximum 8 faze: 0°, 45°, 90°, 135°, 180°, 225°, 270°, 315°) şi multiplicare sau divizare de frecvenţă. Circuitele DCM se bazează pe bucle cu calare pe întârziere (DLL – Delay Locked Loop).

Unele circuite din familia Spartan 6, şi anume cele din sub-familia Spartan 6 LXT, conţin circuite dedicate de transmisie/recepţie serială de mare viteză. Acestea suportă rate de transfer între 614 Mbps şi 3,125 Gbps.

28

Figura 2.8. Structura unui bloc DSP48A1 al familiei Spartan 6 [14].

Familia de dispozitive FPGA de înaltă performanţă a firmei Xilinx este numită Virtex 6.

Ca şi familia Spartan 6, şi familia Virtex 6 are la bază LUT-uri cu 6 intrări grupate în felii de tipul SLICEM sau SLICEL, grupate la rândul lor în CLB-uri. Tipul SLICEX lipseşte de la familia Virtex 6.

Blocurile de memorie RAM ale circuitelor familiei Virtex 6 sunt de 36 kbiţi, cu accesare prin port dual şi operare sincronă. Fiecare port poate fi configurat ca 32Kx1, 16Kx2, 8Kx4, 4Kx8 (sau x9), 2Kx16 (sau x18), 1Kx32 (sau x36), 512x64 (sau 72). Cele două porturi de acces ale aceluiaşi bloc pot avea lăţimi diferite. Fiecare bloc poate fi împărţit în două blocuri complet independente de 18 kbiţi. Două blocuri de 36 kbiţi pot fi cascadate pentru a forma un bloc 64Kx1 fără altă logică suplimentară.

La familia Virtex 6, în jurul blocurilor de memorie RAM sunt implementate circuite logice de control al accesului de tip FIFO. Acestea elimină nevoia ocupării de CLB-uri pentru implementarea numărătoarelor de adrese, a comparatoarelor şi logicii de generare a indicatorilor de stare (flags) pentru implementarea de tampoane de memorie FIFO. Logica FIFO dedicată poate opera sincron sau asincron, cu tact dual, separat pentru citire şi scriere. Fig. 2.9, reprodusă din [17], prezintă schema bloc a unui tampon FIFO dedicat al familiei Virtex 6.

Dispozitivele familiei Virtex 6 dispun de 200 până la 2000 de blocuri dedicate pentru operaţii DSP, numite DSP48E1. Acestea sunt grupate câte două, împreună cu magistrale locale de interconectare pentru optimizarea vitezei şi minimizarea puterii disipate. Arhitectura unui bloc DSP48E1 este prezentată în Fig. 2.10, reprodusă din [18]. Acesta este construit în jurul unui motor de multiplicare-acumulare, foarte folositor în aplicaţiile de procesare de semnal. Pe lângă operaţia de multiplicare-acumulare (MACC – multiply-accumulate), blocul DSP48E1 permite şi operaţii de multiplicare, multiplicare-adunare, adunare de 3 termeni, deplasare multiplă,

29

multiplexare de magistrală, comparaţii, funcţii logice la nivel de bit, detecţie de şablon şi numărător.

Arhitectura suportă cascadarea blocurilor DSP48E1 pentru implementarea de funcţii complexe fără ocuparea de resurse adiţionale din FPGA. Logica de detecţie de şablon poate fi folosită pentru implementarea de saturaţie în caz de depăşire (overflow). Multiplicatorul poate rămâne nefolosit, două intrări pe 48 de biţi fiind procesate de unitatea aritmetică de tip SIMD (Single Instruction Multiple Data). Fiecare intrare poate fi interpretată ca 2 operanzi independenţi pe 24 de biţi sau 4 operanzi independenţi de 12 biţi. Alternativ, celor 2 intrări de 48 de biţi li se poate aplica una din cele 10 funcţii logice posibile. Blocul DSP48E1 dispune deci de o unitate de procesare aritmetico-logică (ALU – Arithmetic Logic Unit) destul de complexă.

Figura 2.9. Schema bloc a unui tampon FIFO dedicat [17].

Figura 2.10. Arhitectura unui bloc DSP48E1 [18].

30

FPGA-urile familiei Virtex 6 dispun de blocuri pentru gestionarea semnalelor de tact (CMT – Clock Management Tile), fiecare fiind constituit din 2 circuite combinate de gestionare a tactului (MMCM – Mixed-Mode Clock Manager) bazate pe circuite PLL. Circuitul MMCM este o îmbunătăţire a combinaţiei PLL+DCM de la familia Spartan 6, servind la atingerea aceloraşi scopuri: sintetizarea frecvenţelor de tact, filtrarea fluctuaţiilor semnalelor de tact externe sau interne şi generarea de semnale de tact defazate (tot 8 posibilităţi de defazare).

Dispozitivele Virtex 6 dispun de transceiver-e integrate de mare viteză, capabile de rate de transfer între 155 Mbps şi 6,5 Gbps. De asemenea, dispun de un bloc de interfaţare pentru PCI Express integrat şi un bloc tri-mode Ethernet MAC (TEMAC) integrat. Acesta e proiectat în conformitate cu standardul IEEE Std 802.3-2005 şi suportă rate de transfer de până la 2500 Mbps.

Spre deosebire de familia predecesoare Virtex 5, la care câteva dispozitive aveau până la 2 procesoare PowerPC 440 la 550 MHz, deocamdată nici un dispozitiv Virtex 6 nu oferă procesoare hardware integrate.

Toate informaţiile prezentate în Secţiunea 2.2 au rolul de a evidenţia extraordinarele

posibilităţi oferite de circuitele FPGA actuale. Ele au caracter introductiv, şi cititorul este îndrumat către vasta bibliografie specifică firmelor producătoare: [8], [9], [10], [11], [12], [13], [14], [15], [16], [17], [18], din care s-a sintetizat aici, pentru informaţii mai detaliate.

Din cele prezentate în această secţiune se pot trage câteva concluzii: dispozitivele FPGA au devenit într-adevăr platforme pentru implementarea de sisteme complexe în întregime pe un singur cip. Chiar şi familiile cu preţ scăzut integrează destule componente complexe pentru a permite aceasta. În plus, folosirea resurselor disponibile implică cunoştinţe din multe domenii conexe, de la procesare de semnal la microcontrolere şi proiectare de software pentru sisteme încorporate, de la proiectare de structuri digitale la descriere în limbaje HDL şi simulare a acestora. De aici presiunea foarte mare asupra producătorilor de dispozitive FPGA de a aduce uneltele software de proiectare la un nivel cât mai înalt, cât mai abstract, pentru a permite dezvoltarea cât mai rapidă de proiecte complexe. Altfel, la ce bun o multitudine de resurse, dacă nimeni nu reuşeşte să le folosească în întregime?

2.3 Metodologia de proiectare a unui sistem de control implementat în hardware pe FPGA

Dispozitivele FPGA permit proiectarea de arhitecturi hardware specializate, cu avantajul

flexibilităţii mediului programabil în care se realizează implementarea. Acest lucru oferă un grad de libertate în plus în proiectarea de sisteme de control numeric faţă de folosirea microprocesoarelor, deoarece arhitectura hardware a sistemului de control nu e impusă a priori.

De multe ori, însă, proiectarea acestei arhitecturi este realizată intuitiv şi euristic şi nu este adaptată implementării de algoritmi din ce în ce mai complecşi. Din acest motiv se impune

31

folosirea unei metodologii de proiectare eficiente. O astfel de metodologie se bazează pe trei principii majore [19]: rafinarea algoritmului de control, modularitatea şi potrivirea optimă între algoritmul ce trebuie implementat şi arhitectura hardware aleasă. Aceste trei concepte sunt prezentate în cele ce urmează.

2.3.1 Rafinarea algoritmului

Rafinarea algoritmului este un pas necesar în proiectarea sistemelor de control cu FPGA.

Implementarea operaţiilor aritmetice în virgulă mobilă este posibilă în FPGA, dar utilizarea resurselor nu este optimă în acest caz, datorită arhitecturii de tip “matrice de celule logice” prezentată în Fig. 2.1. Această “matrice de celule logice” este foarte potrivită pentru implementarea de operaţii aritmetice simple de tipul sumator/scăzător pentru numere reprezentate în complement faţă de 2, dar utilizarea reprezentării în virgulă mobilă implică structuri mult mai complexe, cu căi multiple de date, logică de luare a deciziilor şi activare a anumitor căi, registre de deplasare pentru normalizare, etc. Aceste structuri complexe consumă foarte multe resurse, în vreme ce reprezentarea numerelor în virgulă fixă nu necesită niciun fel de resurse adiţionale faţă de reprezentarea numerelor întregi în complement faţă de 2. Din aceste motive s-au formulat două direcţii de lucru:

1. Simplificarea computaţională: mai ales la începutul dezvoltării dispozitivelor FPGA, când densitatea celulelor logice era limitată, au apărut algoritmi ce propuneau soluţii inteligente de evitare a folosirii operatorilor a căror implementare necesita ocuparea unui procent semnificativ din resursele disponibile (înmulţire, împărţire). Un astfel de exemplu este algoritmul CORDIC (COordinate Rotation DIgital Computer) [20], care se bazează doar pe operaţiile aritmetico-logice de adunare şi deplasare pentru a calcula o multitudine de funcţii trigonometrice, hiperbolice, liniare şi logaritmice. Un alt exemplu îl reprezintă algoritmii de aritmetică distribuită [21], ce folosesc în multe cazuri tabele de căutare şi a căror implementare este, în consecinţă, foarte potrivită arhitecturilor de FPGA-uri bazate pe LUT-uri. În general, atunci când nu se folosesc astfel de algoritmi speciali, simplificarea computaţională se poate obţine prin remodelarea algoritmului de implementat pentru a reduce numărul operaţiilor ce trebuie realizate.

2. Folosirea unui format optimizat de reprezentare a numerelor în virgulă fixă: aşa cum s-a menţionat mai sus, reprezentarea în virgulă fixă este foarte potrivită pentru implementare în FPGA, dar trebuie găsit cel mai avantajos compromis între numărul de biţi ai fiecărei variabile de control şi respectarea specificaţiilor de control. În acest sens, în [22] este prezentată o metodologie de calcul a numărului de biţi necesari pentru reprezentarea fiecărei cantităţi a sistemului de control, metodologie bazată pe normele ∞l şi 1l . A fost dezvoltat, de asemenea,

32

un toolbox Matlab pentru analiza efectelor implementării filtrelor digitale şi a sistemelor de control folosind reprezentarea numerică în virgula fixă [23], ce permite optimizarea alegerii reprezentării.

2.3.2 Modularitatea şi reutilizabilitatea

Pentru proiectarea sistemelor complexe, principiul modularităţii este esenţial. Acest

principiu se bazează pe conceptele de ierarhizare şi regularitate. Ierarhizarea împarte un sistem mare sau complex în entităţi mai uşor realizabile denumite module. Regularitatea este direcţionată spre maximizarea reutilizării modulelor deja proiectate.

O bună modelare şi ierarhizare a unui sistem, precum şi folosirea de module deja existente, poate reduce timpul de proiectare mult mai mult decât o stăpânire perfectă a uneltelor de proiectare.

Principiul modularităţii poate însemna şi folosirea de blocuri IP deja proiectate, testate şi sintetizate de alţii. În această categorie intră, de exemplu, procesoarele soft şi blocurile IP destinate operaţiilor specifice DSP.

Un modul poate fi definit ca un element al unei biblioteci, ce poate fi instanţiat direct, fără a trebui proiectat sau modificat. Astfel, reutilizabilitatea constă în folosirea elementelor de bibliotecă celor mai potrivite pentru o anumită aplicaţie. Modulele pot fi împărţite în biblioteci de diferite nivele de abstracţie, de exemplu la nivel RTL sau la nivel comportamental (behavioral). Reutilizabilitatea poate fi întâlnită la nivel de descriere HDL, la nivel de captură de schemă sau la nivele de proiectare mai abstracte, de exemplu la nivelul proiectării sistemelor DSP în Simulink.

2.3.3 Potrivirea optimă algoritm-hardware

Potrivirea optimă dintre algoritmul ce trebuie implementat şi structura hardware, mai

ales atunci când aceasta din urmă nu este fixată, este o problemă cheie. O metodologie de găsire

a acestei potriviri optime este prezentată în [24] şi numită metodologia AAA (sau 3A ). Prescurtarea AAA provine de la Algorithm Architecture Adequation, iar termenul adequation are sensul francez de potrivire eficientă, nu sensul cuvântului englezesc adequacy, ce implică doar potrivirea suficientă. Atunci când vorbim despre proiectare în FPGA, scopul metodologiei AAA este de a găsi o arhitectură hardware optimizată pentru un anumit algoritm, respectând în acelaşi timp constrângerile de timp de execuţie şi arie ocupată.

Metodologia AAA se bazează pe modelarea algoritmilor cu ajutorul grafurilor, analiza pe graf a paralelismului potenţial al algoritmului şi potrivirea acestuia pe paralelismul disponibil al arhitecturii hardware alese.

33

Pentru ilustrarea metodei se va folosi un exemplu din [19]: se consideră că trebuie implementată o operaţie matriceală simplă de forma:

⎥⎦

⎤⎢⎣

⎡⋅⎥

⎦

⎤⎢⎣

⎡−−

=⎥⎦

⎤⎢⎣

⎡

b

a

q

d

XX

AAAA

XX

)()()()(

2221

1211

θθθθ

(2.1)

Graful fluxului de date (DFG – Data Flow Graph) corespunzător ecuaţiei (2.1) este prezentat în Fig. 2.11. Fiecare nod al grafului reprezintă o operaţie şi fiecare muchie reprezintă o dependenţă de date între operaţii.

Structurile repetitive din DFG pot fi factorizate apoi conform metodologiei AAA [24], pentru a satisface constrângerile hardware. Fig. 2.12, reprodusă tot din [19], prezintă patru posibilităţi de implementare derivate din posibilităţile de factorizare ale DFG-ului. Operaţiile sunt înlocuite de circuite operatoare hardware, iar fiecare operator are un cost, deoarece consumă resurse hardware. Cele 4 posibilităţi pot fi comparate din punctul de vedere al latenţei (timpul după care rezultatele sunt disponibile, exprimat în cicli de tact), al vitezei (timpul care trece între disponibilitatea a 2 rezultate consecutive la ieşire) şi al ariei ocupate, iar cea care prezintă compromisul cel mai avantajos este aleasă.

Este evident din Fig. 2.12 că structura ALU-1 este cea mai rapidă, dar consumă şi cele mai multe resurse. De obicei, resursele critice sunt operatorii complecşi, de tipul multiplicatoarelor, şi nu registrele sau multiplexoarele. Este de asemenea evident că structura ALU-4 ocupă cele mai puţine resurse hardware, dar va avea nevoie de un timp de procesare de 4 ori mai lung decât ALU-1. ALU-2 şi ALU-3 sunt soluţii intermediare atât din punctul de vedere al costurilor hardware, cât şi al timpului de procesare.

Figura 2.11. DFG corespunzător ecuaţiei (2.1) [19].

34

Figura 2.12. Posibilităţi de implementare a operaţiilor descrise de (2.1) [19].

Aşadar, aceste trei principii ar trebui să ghideze încercările de implementare a

algoritmilor de control automat în hardware pe dispozitive FPGA.

2.4 Sisteme de control pentru motoare electrice implementate în FPGA

Această secţiune se ocupă cu trecerea în revistă a câtorva sisteme de control pentru

motoare electrice bazate pe FPGA apărute în literatură. Această trecere în revistă formează o idee cu privire la stadiul actual al cercetării în domeniu şi permite situarea rezultatelor obţinute prin această teză în contextul cercetării internaţionale.

Articolele [4], [19], [25] şi [26] sunt astfel de treceri în revistă, cu un spectru ceva mai larg. Totuşi, având în vedere că au apărut în 2007, trebuie completate cu cercetări bibliografice mai recente.

Astfel, în [27] se prezintă o abordare “integrată” a modelării şi implementării în FPGA a unui sistem de control fără senzori de viteză/poziţie pentru motorul de inducţie. Folosind un observator în spaţiul stărilor şi un sistem de control bazat pe reţele neuronale, autorii prezintă

35

modelarea întregului sistem (inclusiv a motorului, de aici termenul de modelare “integrată”) folosind limbajul VHDL. După validarea prin simulare, sistemul este verificat experimental.

În [28] este prezentat un sistem de control partiţionat între hardware şi software pentru motorul PMSM. Autorii propun o abordare combinată între un regulator adaptiv de viteză bazat pe logică fuzzy, implementat în software pe un procesor soft, şi regulatoare vectoriale de curent, implementate în hardware.

În [29] este descrisă o bibliotecă de componente dezvoltate folosind software-ul System Generator, utilizabile în proiectarea de sisteme de control pentru motoare de curent continuu şi BLDC implementabile pe FPGA. Este prezentat de asemenea un sistem de control complet, incluzând o interfaţă pentru Simulink bazată pe paradigma “hardware în buclă” (HIL – hardware in the loop).

Articolul [30] descrie un sistem de control fără senzor de poziţie pentru motorul de inducţie, folosind metoda DTC (– Direct Torque Control) şi un observator de stare. Sistemul de control a fost proiectat folosind mediul LabView FPGA şi implementat pe o placă National Instruments RIO PXI-7831R ce conţine un FPGA din familia Virtex-II.

În [31] se prezintă un sistem de control al mişcării pe două axe bazat pe co-proiectare hardware-software: buclele de curent pentru motoarele PMSM sunt implementate în hardware pe FPGA, în timp ce buclele de viteză şi generarea traiectoriei sunt realizate prin software pe un procesor soft NiosII pe acelaşi FPGA.

O aplicaţie asemănătoare este prezentată în [32]: un sistem modular de control al mişcării multi-axe. Astfel, pentru motorul de curent continuu efector de pe fiecare din cele 4 axe este proiectat câte un regulator PID (proporţional – integrator – derivator) implementat în hardware, iar traiectoria este generată prin software ce rulează pe un procesor soft în acelaşi FPGA.

La fel, în [33] mişcarea unui robot omnidirecţional este controlată de un FPGA: controlul curenţilor prin trei motoare de curent continuu este efectuat de module hardware independente, iar controlul vitezei şi al traiectoriei este realizat prin software pe un procesor Nios II.

În [34], autorii propun un sistem de control simplu pentru motorul de curent continuu fără perii (BLDC – Brushless DC). Acesta se bazează pe alternarea a doar două valori pentru factorul de umplere al semnalului modulat în lăţimea impulsurilor (PWM – Pulse Width Modulation) aplicat motorului, simplificând proiectarea şi implementarea regulatorului. Conceptul este verificat prin simulări şi experimente.

În [35] şi [36] este prezentat un sistem de control pentru un motor PMSM dotat cu un rezolver analogic de poziţie. În FPGA sunt implementate regulatoare de curent cu histerezis pentru cele 3 faze ale motorului şi un modul de procesare a semnalelor provenite de la rezolver, modul bazat pe algoritmul CORDIC. O particularitate a sistemului prezentat este faptul că foloseşte un FPGA produs de firma Actel ce integrează periferice de conversie analog-digitală: circuite analogice de scalare a semnalelor, multiplexor analogic şi convertor analog-numeric (CAN).

În [37] se prezintă un algoritm de control PID pentru un servomotor de curent continuu, implementat în software (în limbaj de asamblare) pe un procesor soft PicoBlaze. În jurul

36

procesorului s-a construit un întreg sistem de periferice descrise în VHDL şi implementate în hardware pe acelaşi FPGA: un circuit temporizator, un modul de interfaţare cu un amplificator analogic şi un CAN cu interfaţă serială SPI (Serial Peripheral Interface), un modul de generare de semnal PWM, un modul de comunicaţie serială RS232.

Articolul [38] prezintă un sistem cu procesor hard PowerPC modular şi scalabil bazat pe un FPGA XC2VP30ff896-6, aplicat pentru controlul în timp real al unui motor de curent continuu. S-au evaluat două sisteme de operare embedded de timp real, µC/OS-II şi Xilkernel.

În [39] se descrie proiectarea şi dezvoltarea unui sistem de control embedded pentru aplicaţii de robotică, bazat pe FPGA, sistemul de operare de timp real MontaVista Linux şi biblioteca specializată OROCOS (Open Robot Control Software). S-au integrat de asemenea o serie de module hardware oferite de proiectul Opencores.

Lucrarea [40] descrie un sistem de control pentru motoare PMSM reconfigurabil în timp real: în funcţie de cerinţe şi de aplicaţie, sistemul poate folosi implementări mai complete sau mai puţin complete ale algoritmului de control: control orientat după câmp (FOC – Field Orientated Control), FOC cu compensarea tensiunii electromotoare induse, FOC cu compensarea tensiunii induse şi cu decuplare între axe, control direct al cuplului (DTC). De asemenea, sistemul poate alege între implementarea pe un procesor soft sau implementarea în hardware. În funcţie de decizia sistemului, o parte din FPGA poate fi reconfigurată cu o altă implementare, aceasta este iniţializată, apoi i se dă controlul.

Articolul [41] prezintă proiectarea în Simulink, folosind software-ul DSP Builder, a unui sistem de control pentru PMSM implementabil în FPGA. Sistemul se bazează pe regulatoare cu histerezis pentru curenţi şi regulator PI de viteză. Algoritmul de control utilizează 56 de blocuri DSP de 9x9 biţi din FPGA (Altera Stratix II EP2S60F1024C4).

În [42] se propune controlul fără senzor de poziţie pentru motorul sincron folosind filtrul Kalman extins pentru estimarea poziţiei şi vitezei. Se folosesc regulatoare PI pentru curenţi, iar tensiunile trifazate se aplică prin modulaţie sinusoidală cu injecţie de semnal la punctul neutru. Cea mai complicată parte a sistemului este filtrul Kalman extins, datorită operaţiilor de înmulţire şi împărţire de matrice. De aceea, a fost optimizat în mod special, prin factorizare, ajungând totuşi să ocupe 36 de multiplicatoare hardware pe 18x18 biţi.

În [43] se prezintă un sistem de control al vitezei pentru un motor cu reluctanţă comutată (SRM – Switched Reluctance Motor) implementat pe principiul co-proiectării hardware-software: regulatorul de viteză, cu o dinamică mai înceată, este implementat prin software pe un procesor soft Nios II, iar regulatoarele de curent, cu o dinamică rapidă, sunt implementate în hardware.

Aceeaşi idee de co-proiectare hardware-software se regăseşte şi în [44], pentru implementarea unui sistem de control al vitezei pentru motorul de curent continuu. Diferenţa constă în faptul că se folosesc două procesoare hard IBM PowerPC 405, unul pentru regulatorul de viteză şi al doilea pentru emularea sistemului controlat (motorul de curent continuu). Regulatorul de curent, implementat ca modul hardware ataşat la primul procesor, este proiectat în Impulse C.

37

Articolul [45] prezintă un sistem combinat de control fără senzori de poziţie pentru motorul BLDC: startarea motorului se realizează în buclă deschisă, iar începând cu o anumită viteză se închide bucla folosind tensiunea electromotoare indusă. Pentru implementare s-a folosit un sistem combinat, bazat pe FPGA şi DSP.

În [46] este prezentat un algoritm de control fără senzor de poziţie pentru PMSM. Estimarea poziţiei se realizează cu ajutorul injecţiei unui semnal de frecvenţă înaltă în semnalul de comandă al motorului şi estimarea inductanţei momentane a statorului prin intermediul unei bucle cu calare pe fază (PLL – Phase Locked Loop). Atât bucla PLL, cât şi algoritmul de modulaţie bazat pe vectori spaţiali (SVM – Space Vector Modulation) utilizat pentru aplicarea tensiunilor pe cele 3 faze ale motorului se folosesc de algoritmi CORDIC pentru calcularea funcţiilor trigonometrice.

Lucrarea [47] realizează o comparaţie între implementarea în hardware şi cea pur software pe un procesor soft Cortex-M1 din familia ARM, a unui regulator de curent cu histerezis pentru PMSM. Pe lângă regulator şi transformările de coordonate asociate, s-a implementat şi un modul de procesare a semnalelor provenite de la un rezolver analogic pentru extragerea informaţiei de poziţie.

În [48] se prezintă o arhitectură de calcul modulară şi ierarhică bazată pe o unitate aritmetică ce realizează înmulţirea unei matrice cu un vector. Modulele alcătuiesc o bibliotecă de componente pentru controlul unui vehicul electric cu motoare de inducţie.

Articolul [49] prezintă un sistem de control fără senzor de poziţie pentru PMSM partiţionat între hardware şi software: regulatoarele PI de curent, transformările de coordonate, algoritmul SVM şi estimatorul de poziţie bazat pe un observator sliding mode sunt realizate în hardware, în timp ce estimarea vitezei şi reglarea ei sunt efectuate prin software pe procesorul soft Nios II.

În [50] este prezentat un sistem de control pentru motorul de inducţie alimentat de o punte invertoare prin intermediul unui circuit rezonant. Sistemul este descris folosind AHDL (Altera HDL) şi constă din regulatoare PI de viteză şi curent, circuit de măsurare a vitezei, circuite de transformare între sistemele de coordonate, circuit de aplicare a modulaţiei SVM modificate. Întregul sistem foloseşte 76 de multiplicatoare pe 9x9 biţi.

Se observă aşadar o multitudine de abordări pentru implementarea pe FPGA a sistemelor

de control pentru motoare electrice. Multe dintre acestea sunt dedicate motoarelor de curent alternativ, datorită complexităţii controlului acestora, şi deci a cerinţelor computaţionale pentru sistemul de timp real.

Literatura de specialitate abundă de asemenea de abordări bazate pe FPGA şi în alte domenii de control automat înrudite, cum ar fi controlul surselor de energie regenerabile [51], [52], [53], [54], [55], [56].

Scopul acestei lucrări, acela de a proiecta un sistem de control pentru motorul PMSM implementabil într-un circuit FPGA, se înscrie aşadar într-o tendinţă în cercetare la nivel internaţional. Ceea ce va particulariza sistemul proiectat va fi modul de proiectare, uneltele

38

folosite pentru proiectare şi validare, şi mai ales constrângerile de proiectare impuse de dispozitivul FPGA ţintă: acesta este unul de cost redus, din familia Xilinx Spartan-3E, cu numai 20 de multiplicatoare integrate.

După cum se poate observa din articolele [37], [40], [43], [44], [47], [49] citate mai sus, în care o parte din sistemul de control rulează în software pe microprocesoare soft sau hard, implementarea prin software este net inferioară unei implementări în hardware din punctul de vedere al vitezei de execuţie. Aceasta deoarece se pierde principalul avantaj oferit de FPGA: posibilitatea de a profita de resurse hardware multiple şi independente pentru a realiza calcule în paralel. Această concluzie se desprinde şi din [57], unde se compară implementarea în hardware pe FPGA cu o implementare în software pe un procesor DSP. În [58], comparaţia se extinde şi la o implementare prin software pe un procesor soft MicroBlaze, cu rezultate asemănătoare: implementarea software pe MicroBlaze este mai lentă decât implementarea pe DSP, iar aceasta este de 11 ori mai lentă decât implementarea în hardware.

Studierea bibliografiei a condus deci la o direcţie de urmat pentru restul tezei: sistemul de control va fi proiectat pentru implementare în hardware pe FPGA, datorită performanţelor înalte posibile. Totuşi, procesoarele soft rămân o soluţie viabilă pentru anumite sarcini greu de implementat în hardware şi fără constrângeri stringente de timp de execuţie. Astfel de sarcini sunt cele de monitorizare într-un sistem de control, care trebuie să afişeze parametrii sau să realizeze comunicaţia cu un calculator gazdă. De aceea, un capitol al tezei va fi consacrat şi sistemelor cu procesoare soft.

2.5 Concluzii Dispozitivele FPGA reprezintă o evoluţie firească a dispozitivelor logice programabile în

contextul standardizării structurii circuitelor ASIC: odată impuse pe piaţă ASIC-urile structurate, ce sunt matrice de celule de bază formate din porţi logice, LUT-uri şi multiplexoare, era normal să apară ideea unor dispozitive programabile cu o structură asemănătoare.

În prima parte a acestui capitol se punctează evoluţia în timp a dispozitivelor FPGA. Se pare că aceasta s-a derulat în mai multe epoci delimitabile: 1985-1991 – epoca apariţiei (sau “copilăriei”) FPGA-urilor, care vede definirea arhitecturii generale şi o multitudine de producători; 1992-1999 – epoca de expansiune, când încep să se integreze elemente hardware dedicate şi creşte mult capacitatea circuitelor, mulţi producători fiind eliminaţi din cauza lipsei scalabilităţii arhitecturilor propuse de ei; 2000-2007 – epoca de acumulare, când se integrează tot mai multe elemente hardware dedicate, inclusiv procesoare hard; 2007-prezent – epoca de specializare: familii diferite, bazate pe arhitecturi diferite, se adresează unor domenii diferite de aplicaţii, sprijinite de medii de proiectare specializate.

Această evoluţie impresionantă a dispozitivelor FPGA a determinat apariţia unei noi paradigme în domeniul calculatoarelor: sistemele de calcul reconfigurabile – “reconfigurable

39

computing” [59], [60], cu aplicaţii în cele mai variate domenii [61], [62], [63], [64], [65], [66], [67], [68], [69].

În secţiunea a doua sunt prezentate succint arhitecturile actuale ale FPGA-urilor principalilor 2 mari producători, Altera şi Xilinx. Secţiunea reprezintă o selecţie relevantă de informaţie din mii de pagini de documentaţie [8], [9], [10], [11], [12], [13], [14], [15], [16], [17], [18], necesară pentru a crea o imagine asupra capabilităţilor dispozitivelor FPGA actuale.

În cea de-a treia secţiune este prezentată o metodologie de proiectare a sistemelor de control bazate pe FPGA, sintetizată din [19] şi bazată pe 3 principii majore: rafinarea algoritmului de control, modularitatea şi potrivirea optimă între algoritmul ce trebuie implementat şi arhitectura hardware aleasă.

Ultima secţiune a capitolului reprezintă un studiu bibliografic extins asupra sistemelor de control pentru motoare electrice implementate în FPGA. În urma acestuia se constată:

• Implementarea algoritmilor de control în hardware pe FPGA este mult mai eficientă din punctul de vedere al timpului de execuţie decât implementarea prin software [57], [58];

• Procesoarele soft sunt totuşi utile datorită posibilităţii de a porta aplicaţii deja dezvoltate şi de a implementa mai uşor sarcini fără constrângeri stringente de timp de execuţie;

• Majoritatea algoritmilor de control prezentaţi în literatură folosesc foarte multe resurse din FPGA, trebuind revizuiţi serios pentru implementarea în dispozitive FPGA de cost redus, cu doar câteva zeci de multiplicatoare integrate;

• În majoritatea abordărilor din literatură există o ruptură între proiectarea sistemului de control şi validarea sa prin simulare şi implementarea pe FPGA şi verificarea experimentală; doar uneori (de exemplu [27], [41]) se propune o abordare “integrată” pentru simulare şi proiectare/implementare.

Aşadar, direcţia propusă pentru cercetare, de a implementa un sistem de control pentru motorul PMSM în FPGA, se înscrie în tendinţele actuale de cercetare în domeniu la nivel internaţional. De asemenea, există o nişă pe care ar putea-o acoperi: proiectarea într-un mediu de nivel înalt, care să permită validarea prin simulare, având ca ţintă un dispozitiv FPGA de cost redus, deci implicând optimizarea la maximum a arhitecturii hardware a algoritmului de control.

41

3. Unelte de dezvoltare pentru dispozitive FPGA Acest capitol prezintă o scurtă trecere în revistă a metodelor de proiectare şi a uneltelor

software disponibile pentru dezvoltarea sistemelor bazate pe dispozitive FPGA. Capitolul este împărţit în 4 subcapitole sau secţiuni. Astfel, în Secţiunea 3.1 sunt prezentate în general uneltele de dezvoltare disponibile pentru proiectarea de sisteme în FPGA: în Subsecţiunea 3.1.1 este prezentată pe scurt evoluţia proiectării de sisteme bazate pe FPGA, legată, fireşte, de evoluţia FPGA-urilor şi a domeniilor lor de aplicabilitate, prezentată în Secţiunea 2.2. În Subsecţiunea 3.1.2 sunt prezentate posibilităţile de folosire şi dezvoltare de nuclee IP, discuţia incluzând şi procesoarele soft. În Subsecţiunea 3.1.3, unelte de dezvoltare la nivel de sistem de calcul sunt prezentate, iar în Subsecţiunea 3.1.4, unelte de dezvoltare pentru sisteme de procesare digitală de semnal.

În Secţiunea 3.2 este prezentat pe larg software-ul System Generator, produs de Xilinx, ce permite proiectarea integrată în mediul Simulink a sistemelor implementabile în FPGA.

În Secţiunea 3.3 sunt prezentate pe scurt unelte software şi hardware de depanare a sistemelor proiectate în FPGA.

Capitolul se încheie cu o secţiune dedicată prezentării câtorva aplicaţii originale, dezvoltate cu uneltele prezentate pe parcursul capitolului şi implementate în FPGA.

3.1 Prezentare generală a uneltelor de proiectare pentru FPGA

3.1.1 Evoluţia proiectării sistemelor bazate pe FPGA

Evoluţia neobişnuită a dispozitivelor FPGA prezentată în Secţiunea 2.2 a influenţat

puternic atât metodologia de proiectare, cât şi cerinţele impuse uneltelor de dezvoltare. Cele 3 “epoci” diferite în istoria dezvoltării FPGA-urilor au impus epoci diferite şi în dezvoltarea de unelte de proiectare.

Epoca logicii programabile de legătură, în care FPGA-urile erau folosite pentru implementarea de funcţii logice în sisteme mai mari cu procesor, sisteme multi-procesor sau multi-ASIC nu impunea cerinţe deosebite de proiectare. Funcţiile logice implementate puteau fi de obicei descrise la nivel de poartă logică, aşa că uneltele software de proiectare se bazau pe captura de schemă la nivel de poartă logică.

Odată cu introducerea noilor generaţii de dispozitive FPGA, ca familiile Virtex de la Xilinx şi Stratix de la Altera, o nouă epocă, a logicii de densitate medie, se profilează în domeniul FPGA-urilor. Aceasta însemna că FPGA-urile nu mai erau doar logică de legătură, ci chiar dispozitive logice independente într-un sistem mai mare. Gradul mare de paralelism permis

42

de aceste dispozitive, împreună cu capabilităţile aritmetice pe care le dovedeau, permiteau implementarea de funcţii complexe, ca filtre sau transformate folosite în DSP. Aceste aplicaţii au fost susţinute şi de apariţia, în această perioadă, a blocurilor de memorie integrată şi a sumatoarelor şi multiplicatoarelor dedicate.

Astfel, epoca logicii de densitate medie a condus la dezvoltarea metodologiei de proiectare bazată pe procesarea şi transferul datelor între registre, denumită proiectare RTL – Register Transfer Level. Această metodologie a dus la dezvoltarea de unelte de proiectare specifice, ca Xilinx ISE, şi la impunerea metodei de proiectare bazată pe limbaje de descriere de hardware (HDL – Hardware Description Language). Două astfel de limbaje s-au impus în preferinţele utilizatorilor: Verilog şi VHDL. Descrierea în limbaj HDL avea în plus avantajul portabilităţii, putând fi implementată direct pe ASIC-uri folosind unelte software de sinteză specializate [70], [71].

Tot în această perioadă a apărut metodologia de proiectare bazată pe nuclee IP (Intellectual Property), care sunt blocuri funcţionale sintetizabile în FPGA, proiectate şi testate de firme specializate. Această direcţie a impus ca uneltele de dezvoltare să suporte proiectarea bazată pe interconectarea de module proprii şi nuclee IP ale altor firme în reţele de nuclee.

Odată cu integrarea de module hardware foarte complexe în FPGA, de tipul microprocesoarelor şi a transceiver-elor de mare viteză, s-a delimitat o nouă epocă a dispozitivelor FPGA: cea a sistemelor eterogene implementate pe un singur cip (SoC - System on a Chip). Acum, FPGA-urile au devenit inima sistemelor de procesare, înglobând toate funcţiile, nu doar pe cea de accelerator de tip coprocesor într-un sistem bazat pe alt procesor. Tot în această perioadă, procesoarele soft, implementate în resursele logice de uz general ale FPGA-urilor, câştigă tot mai multă popularitate. În aceste condiţii, presiunea asupra uneltelor software de dezvoltare a crescut foarte mult, ca şi complexitatea cerinţelor.

Acum apar unelte pentru dezvoltarea de software pentru procesoare încorporate hard sau soft rezidente în FPGA, de tipul Xilinx EDK (Embedded Development Kit) şi Altera SoPC Builder (SoPC - System on a Programmable Chip). Tot acum apar unelte de co-proiectare hardware-software, cum ar fi CoDeveloper de la Impulse Accelerated Technologies, Catapult C de la Mentor Graphics, Nios II C2H de la Altera, şi de proiectare şi simulare în Simulink a sistemelor hardware pentru DSP, ca Xilinx System Generator, Xilinx AccelDSP Synthesis, Altera DSP Builder.

Pentru viitor, se aşteaptă mai mult sprijin din partea producătorilor de unelte de dezvoltare în direcţia proiectării de nuclee IP şi de reţele de astfel de nuclee, a proiectării de sisteme multi-procesor, a integrării de componente diferite în sisteme, a optimizării sistemelor eterogene.

43

3.1.2 Nuclee IP

Nucleele IP sunt module dezvoltate pentru a efectua o anumită funcţie. Dezvoltarea lor

include testarea completă şi optimizarea pentru o anumită arhitectură. În acest fel, folosirea acestor nuclee predefinite reduce timpul de proiectare – sinteză – verificare. Adesea, nucleele IP sunt parametrizate, pentru a putea fi uşor folosite şi înglobate în alte proiecte.

Un număr mare de nuclee IP sunt disponibile liber sau contra cost de la firme producătoare de FPGA-uri (Xilinx, Altera), firme producătoare de unelte software de dezvoltare (Synopsys, Cadence, Mentor Graphics, Altium) sau firme specializate în anumite domenii de aplicaţii (Modelware, QuickFlex) [4]. Mediul academic este de asemenea foarte prolific în această direcţie [5]. Nucleele IP disponibile acoperă o plajă vastă de aplicaţii posibile într-o multitudine de domenii, de la telecomunicaţii (de exemplu: nucleu HDLC - High-level Data Link Control, decodor Viterbi), la procesare digitală de semnal (de exemplu: nucleu de calculare a transformatei Fourier sau wavelet, filtre FIR - Finite Impulse Response) sau produse specifice industriei auto (de exemplu: nucleu CAN - Controller Area Network).

O clasă specială de nuclee IP o reprezintă microprocesoarele soft. Acestea sunt microprocesoare proiectate pentru a putea fi implementate în dispozitive FPGA, folosind resursele logice ale acestora. Există procesoare proiectate special în acest scop, pentru a folosi cât mai economic resursele FPGA-ului (de exemplu, PicoBlaze şi MicroBlaze de la Xilinx, Nios şi Nios II de la Altera, ZPU de la Zylin AS, Mico32 de la Lattice), sau nuclee IP derivate din (şi compatibile la nivel de instrucţiune cu) procesoare disponibile de ceva timp în industrie (de exemplu, TSK80 bazat pe Z80, TSK51 bazat pe Intel 8051, TSK3000A bazat pe MIPS R3000, toate de la Altium; LEON 3 bazat pe Sparc V8, de la Aeroflex Gaisler; Cortex-M1 de la ARM, compatibil cu ARM7, ARM9, ARM11).

Nucleele IP reprezintă, împreună cu uneltele software pentru integrarea lor în proiecte complexe, unul din motoarele care împing înainte dezvoltarea soluţiilor bazate pe FPGA-uri în ritmul alert în care aceasta are loc.

3.1.3 Unelte de dezvoltare pentru sisteme încorporate în FPGA

Aşa cum am menţionat în Subsecţiunea 3.1.1, FPGA-urile actuale au devenit platforme

pentru întregi sisteme de calcul, deschizând o nouă epocă în istoria sistemelor implementate pe un singur cip (SoC - System on a Chip).

Implementarea de astfel de sisteme încorporate eterogene presupune sarcini foarte complexe pentru proiectanţii de hardware şi software [72]. Din punctul de vedere al hardware-ului, principala problemă o constituie integrarea eficientă a nucleelor IP, ceea ce înseamnă proiectare, sinteză, simulare şi verificare. Din punctul de vedere al software-ului, principala problemă o constituie depanarea sistemului software, compus din sistem de operare în timp real

44

(RTOS - Real Time Operating System), driver-e şi aplicaţie, în cadrul real al sistemului hardware proiectat.

Producătorii de FPGA-uri au dezvoltat şi unelte software pentru proiectarea de sisteme bazate pe propriile microprocesoare hard sau soft. Aceste unelte includ nuclee IP pentru periferice, unelte de modificare/adaptare a nucleului de procesare soft, unelte pentru dezvoltarea de programe software (editor, asamblor, compilator, editor de legături (linker), depanator), depanatoare hardware/software, unelte de verificare a hardware-ului, biblioteci, exemple de hardware şi software (reference designs) pentru plăci de dezvoltare. Exemple de astfel de unelte de dezvoltare sunt Xilinx EDK (Embedded Development Kit), Nios II IDE (Integrated Development Enviroment) şi SoPC Builder de la Altera, System Designer de la Atmel, QuickWorks de la QuickLogic.

O serie de unelte de dezvoltare pentru FPGA-uri provin din industria ASIC-urilor. Acestea se axează pe RTOS-uri, unelte de depanare, de co-verificare hardware/software, de proiectare folosind limbajul C.

În ceea ce priveşte RTOS-urile, câteva dintre cele mai folosite sunt: MontaVista Linux, Mentor Graphics Nucleus, Wind River VxWorks [4]. Toate oferă suport pentru procesoarele încorporate Xilinx şi Altera. Pe lângă sistemul de operare propriu-zis, pachetele de distribuţie includ şi software de modelare, unelte de prototipizare şi de dezvoltare, driver-e şi software de legătură între aplicaţii (middleware).

Sunt disponibile şi unelte de co-verificare hardware/software, ca Seamless de la Mentor Graphics şi Active-HDL de la Aldec. Seamless permite simularea procesorului încorporat la nivel de instrucţiune (ISS - Instruction Set Simulator) şi simularea componentelor hardware din jurul procesorului într-un mediu integrat. Active-HDL permite verificarea sistemelor bazate pe Nios II folosind un simulator logic pentru componentele hardware şi o placă cu FPGA conectată la depanatorul din Nios II IDE pentru simularea procesorului.

O categorie deosebită de unelte de dezvoltare pentru FPGA-uri permit proiectarea de SoC-uri în limbajul de programare C. Acestea se bazează pe diferite subseturi ale limbajului C şi pe librării specifice asociate, cum ar fi Impulse C [73] sau Handel C [74]. Exemple de unelte de dezvoltare bazate pe limbajul C: DK Design Suite de la Agility, CoDeveloper de la Impulse Accelerated Technologies, Catapult C Synthesis de la Mentor Graphics.

Aceste unelte de dezvoltare, ce permit proiectarea abstractizată la nivel înalt, de sistem, şi ascunderea detaliilor arhitecturilor fizice pe care se realizează implementarea, sunt denumite generic unelte de proiectare ESL (Electronic System Level) [75].

3.1.4 Unelte de dezvoltare pentru nuclee DSP în FPGA

Aşa cum rezultă din prezentarea arhitecturilor FPGA-urilor actuale din Secţiunea 2.2,

dispozitivele FPGA permit un înalt grad de paralelizare a operaţiilor aritmetice folosite în procesarea digitală de semnal [76]. Era normal ca pentru utilizarea acestor resurse hardware să

45

apară unelte de dezvoltare cât mai specializate. Cum Matlab este platforma favorită pentru dezvoltarea algoritmilor DSP, era firesc să se încerce realizarea unor unelte de legătură între codul scris în Matlab sau modelul realizat în Simulink şi hardware-ul disponibil în dispozitivele FPGA. Ideea a fost mai întâi implementată cu succes în cazul generării de cod pentru procesoare DSP direct din modele Simulink, de către dSPACE, cu TargetLink [77].

Astfel, ambii producători mari de FPGA-uri oferă şi software pentru generare de module IP din scheme Simulink: Xilinx oferă System Generator for DSP, iar Altera – DSP Builder. Ambele unelte preiau un model Simulink realizat cu blocuri din toolbox-uri specifice şi le translatează în descrieri hardware sintetizabile în FPGA, ce pot fi mai departe prelucrate de uneltele de implementare (Xilinx ISE, respectiv Altera Quartus II). Avantajul major al metodei constă în faptul că hardware-ul obţinut şi modelul Simulink sunt echivalente, simularea în Simulink a modelului realizat fiind exactă la nivel de bit şi ciclu (bit and cycle accurate) [19]. Un dezavantaj al acestor unelte este faptul că implementările sunt realizate folosind reprezentarea numerică în virgulă fixă. Însă pentru aplicaţiile reale de procesare de semnal gama dinamică şi amplitudinea semnalelor este suficient de limitată pentru ca o reprezentare în virgulă fixă pe destui biţi să dea rezultate mai mult decât acceptabile.

Xilinx oferă de asemenea posibilitatea explorării modalităţilor de implementare a algoritmilor DSP în FPGA prin software-ul AccelDSP. Această unealtă de sinteză preia un algoritm scris în Matlab, realizează automat conversia de la virgulă mobilă la virgulă fixă, şi generează automat o descriere hardware la nivel RTL în Verilog sau VHDL. Astfel, blocuri IP pentru procesare de semnal sau orice alte operaţii aritmetice complexe pot fi generate automat direct din Matlab. Unealta oferă de asemenea posibilitatea integrării cu System Generator, prin generarea de blocuri ce pot fi instanţiate în proiecte mai mari realizate în System Generator.

Pe lângă oferta producătorilor de FPGA-uri, există şi firme specializate în unelte de proiectare care oferă capabilităţi asemănătoare. De exemplu, Synplify DSP de la Synplicity generează cod RTL din modele Simulink. Reprezentarea numerelor este tot în virgulă fixă, dar software-ul optimizează conversia din virgulă mobilă în virgulă fixă. Un alt exemplu este Signal Processing Designer de la CoWare, care oferă un mediu de modelare şi simulare grafic bazat pe scheme bloc asemănător cu Simulink. Blocurile sunt scrise în limbajul C, dar se pot apela şi funcţii Matlab sau se pot trimite rezultatele simulării în Matlab, pentru analiză.

Şi uneltele de proiectare pentru FPGA folosind limbajul C prezentate în Secţiunea 3.1.3 pot fi folosite pentru proiectarea de nuclee de procesare de semnal, dar, nefiind unelte specializate, nu există suport (sub formă de biblioteci, de exemplu) pentru algoritmi DSP. Totuşi, aceste unelte dau posibilitatea de a testa rapid idei de algoritmi pentru explora spaţiul de proiectare, urmând ca soluţia finală să fie realizată într-un mediu de proiectare specializat.

46

3.2 Proiectarea în mediul Simulink a structurilor hardware folosind blockset-ul System Generator

În general, proiectarea structurilor numerice de control în FPGA implică realizarea unui

hardware specializat ce execută un anumit algoritm de control. Avantajul major al dispozitivelor FPGA constă în faptul că o multitudine de resurse pot fi folosite în paralel, pentru operaţii diferite. Un algoritm de control implementat în FPGA poate fi văzut ca o serie de unităţi aritmetico-logice specializate ce lucrează în paralel sau într-o anumită secvenţă. În vreme ce o unitate aritmetico-logică de uz general oferă foarte multe posibilităţi de utilizare şi configurare, fiind de obicei necesară microprogramarea pentru implementare, unităţile de calcul specializate, fiind mai simple, pot fi implementate mult mai uşor, folosind logică combinaţională sau secvenţiatoare simple.

Proiectarea acestor structuri hardware poate fi realizată şi prin metodele clasice: captură de schemă [78] sau descriere într-un limbaj de descriere hardware (HDL - Hardware Description Language) [79], [80], [81], dar şi prin metode mai noi, cum ar fi descrierea într-un limbaj de programare consacrat, ca C [73], [74] sau Matlab [5]. În vreme ce descrierea algoritmilor în C sau Matlab poate fi foarte folositoare deoarece permite un nivel înalt de detaliere, iar metodele de proiectare sunt bine cunoscute şi cercetate, proiectarea în Simulink oferă avantaje majore: un nivel de abstractizare mult mai înalt decât proiectarea la nivel de captură de schemă logică, cu păstrarea totuşi a caracterului vizual al informaţiei, foarte uşor de urmărit şi înţeles, spre deosebire de descrierile textuale în limbaje HDL sau în limbaje de programare; simularea facilă, cu generarea automată a vectorilor de test şi vizualizarea rapidă a rezultatelor, mult mai uşor decât într-un simulator clasic bazat pe limbaje HDL; posibilitatea interfaţării cu alte unelte software, cum ar fi simulatoare HDL sau asambloare/compilatoare pentru procesoare soft încorporate în FPGA. Din aceste motive, proiectarea în Simulink a structurilor hardware implementate în FPGA este foarte folosită pentru prototipizare rapidă.

Acest subcapitol prezintă pe scurt utilizarea software-ului System Generator, produs de Xilinx, pentru proiectarea de structuri hardware folosite în control automat, precum şi metode de integrare a structurilor astfel obţinute în proiecte complexe. Se prezintă de asemenea procedeul de importare în Simulink şi simulare a modulelor proiectate prin metode de nivel mai jos, cum ar fi captura de schemă logică sau descrierea HDL.

3.2.1 Utilizarea software-ului System Generator

Software-ul System Generator permite definirea de hardware specific pentru un anumit

dispozitiv fizic într-un mediu cu un nivel înalt de abstractizare. În System Generator, semnalele nu sunt doar biţi, ci numere cu semn sau fără semn, întregi sau reale reprezentate în virgulă fixă, cu lăţime variabilă. O schimbare în proiect se traduce automat în modificări ale formatelor de

47

reprezentare. Blocurile nu sunt doar reprezentări pentru elemente hardware, ci îşi modifică în funcţie de setări şi context rezultatele pe care le oferă şi hardware-ul pe care îl generează.

Software-ul System Generator poate fi folosit în mai multe moduri: se poate explora spaţiul de proiectare prin modelarea şi rafinarea algoritmului, fără a se ajunge la implementarea fizică; se poate implementa doar o parte dintr-un proiect mai complex; sau se poate implementa un întreg proiect în Simulink.

În ceea ce priveşte explorarea spaţiului de proiectare, System Generator poate fi folosit pentru definirea algoritmului, pentru prototipizare şi pentru analiza modelului matematic. În acest sens, software-ul poate fi folosit pentru schiţarea algoritmului, estimarea dificultăţilor de implementare şi estimarea resurselor hardware folosite şi a performanţelor în materie de timp de execuţie a eventualei implementări.

System Generator poate fi folosit pentru implementarea unei anumite părţi dintr-un proiect mai complex. În acest sens, System Generator este foarte potrivit pentru a implementa căi de date şi hardware de control pentru ele, dar este mai puţin potrivit pentru definirea de interfeţe externe ce au cerinţe de temporizare sofisticate. În aceste situaţii, se poate folosi System Generator pentru a implementa o porţiune din proiect, iar o altă porţiune poate fi implementată prin metode clasice, mai orientate către detalii (captură de schemă sau descriere HDL), iar apoi modulele pot fi integrate într-un întreg. În ceea ce priveşte implementarea unui întreg sistem în System Generator, din Simulink se poate obţine o descriere HDL a întregului proiect, ce poate fi apoi procesată de uneltele obişnuite de sinteză şi implementare.

3.2.2 Blockset-ul Xilinx

Un blockset Simulink reprezintă o bibliotecă de blocuri ce pot fi conectate în editorul de

scheme bloc Simulink pentru a crea modele funcţionale ale sistemelor dinamice. Pentru modelare, blocurile System Generator sunt folosite ca şi oricare alte blocuri Simulink. Blocurile oferă o reprezentare la un nivel de abstractizare mai înalt pentru funcţii matematice, funcţii tipice de procesare digitală de semnal, elemente logice, memorii, etc. De asemenea, există blocuri ce permit interfaţarea cu alte unelte software, cum ar fi ModelSim şi FDATool.

Blocurile System Generator sunt precise la nivel de bit şi ciclu (bit and cycle accurate). Precizia la nivel de bit înseamnă că valorile rezultate în Simulink sunt aceleaşi cu valorile corespunzătoare returnate de hardware. Precizia la nivel de ciclu înseamnă că valorile rezultate sunt produse la momente de timp ce corespund momentelor la care reacţionează hardware-ul (ciclu de tact).

Odată instalat System Generator, în vizualizorul de biblioteci Simulink apare blockset-ul Xilinx, cu bibliotecile corespunzătoare. Figura 3.1 prezintă o imagine ilustrativă a câtorva biblioteci.

Blockset-ul Xilinx conţine blocuri de bază ale System Generator. Unele blocuri sunt de nivel jos, permiţând instanţierea directă a unor componente hardware. Altele sunt de nivel înalt,

48

oferind implementări de funcţii şi algoritmi utilizaţi adesea în aplicaţii tip DSP. O altă categorie o reprezintă blocurile de interfaţă cu Simulink-ul şi de control al simulării şi implementării. Blocurile utilizate des sunt incluse în mai multe biblioteci, pentru găsirea mai uşoară. Toate blocurile sunt incluse în biblioteca numită Index. În Tabelul 3.1 este prezentată o descriere sumară pentru fiecare bibliotecă.

Tabelul 3.1 Bibliotecile blockset-ului Xilinx.

Biblioteca Descriere Basic Elements Blocuri de bază pentru construcţia de module de logică digitală. Communication Blocuri corectoare de erori şi modulatoare, utilizate adesea în sisteme de

comunicaţie digitale. Control Logic Blocuri pentru circuite de control şi maşini cu stări finite. Data Types Blocuri pentru conversia datelor între diferite formate şi moduri de

reprezentare. DSP Blocuri pentru funcţii de procesare digitală de semnal. Index Conţine toate blocurile din blockset-ul Xilinx. Math Blocuri pentru funcţii matematice. Memory Blocuri pentru implementarea şi accesarea memoriei. Shared Memory Blocuri pentru implementarea şi accesarea de memorii partajate. Tools Blocuri pentru controlul simulării, vizualizarea şi analiza datelor,

interfaţarea cu alte unelte. Pe lângă blockset-ul Xilinx, System Generator include şi un blockset numit Xilinx

Reference Blockset, conţinând funcţii compuse din blocuri Xilinx ce acoperă o arie largă de funcţionalităţi. Fiecare bloc din acest blockset este implementat ca un subsistem cu mască, configurabil prin intermediul parametrilor. Bibliotecile din Xilinx Reference Blockset sunt prezentate pe scurt în Tabelul 3.2.

Tabelul 3.2 Bibliotecile blockset-ului Xilinx Reference.

Biblioteca Descriere Communication Blocuri utilizate adesea în sisteme de comunicaţie digitale. Control Logic Blocuri logice pentru circuite de control şi maşini cu stări finite. DSP Blocuri pentru funcţii de procesare digitală de semnal. Imaging Blocuri pentru procesare de imagini. Math Blocuri ce implementează funcţii matematice.

49

Figura 3.1. Biblioteci din blockset-ul Xilinx.

50

3.2.3 Blocul System Generator

Fiecare schemă Simulink ce foloseşte blocuri din cele două blockset-uri prezentate mai

sus trebuie să includă neapărat şi blocul System Generator. Acesta nu se conectează la alte blocuri, fiind utilizat doar pentru a specifica software-ului System Generator parametrii necesari simulării şi generării de hardware.

Blocul System Generator se găseşte în bibliotecile Basic Elements şi Tools, ca şi în biblioteca Index, ce conţine toate blocurile Xilinx.

O schemă Simulink cu blocuri Xilinx trebuie să conţină cel puţin un bloc de acest fel, dar poate conţine şi mai multe, pe nivele diferite (câte cel mult unul pe fiecare nivel). Un bloc de pe un nivel ierarhic inferior în schemă este de tip slave. Cel de pe un nivel superior este de tip master. Domeniul unui bloc System Generator este constituit din nivelul ierarhic pe care se află şi nivelele ierarhice inferioare nivelului său.

Fereastra de dialog a blocului System Generator este prezentată în Fig. 3.2.

Figura 3.2. Fereastra de dialog a blocului System Generator.

51

Atunci când se doreşte ca schema bloc proiectată şi simulată în Simulink să fie tradusă în

hardware pe FPGA, se aleg setările dorite în această fereastră de dialog şi apoi se apasă butonul Generate. Există mai multe posibilităţi în ceea ce priveşte tipul rezultatului obţinut, selectabile din câmpul Compilation:

• HDL Netlist: se generează o descriere într-un limbaj HDL, conţinând mai multe fişiere HDL şi EDIF (Electronic Data Interchange Format), precum şi alte fişiere cu informaţii complementare pentru uneltele software ce procesează mai departe descrierea HDL. Colecţia de fişiere poate fi procesată direct de unelte de sinteză (cum ar fi Xilinx XST, Synopsis Synplify) în vederea obţinerii unui fişier de configurare pentru FPGA.

• NGC Netlist: opţiunea este similară cu cea anterioară, doar că nu se obţin fişiere HDL, ci un singur fişier NGC. Acesta este un format de fişier propriu uneltelor Xilinx.

• Bitstream: se produce direct fişierul de configuraţie pentru FPGA, traducându-se deci direct schema bloc în hardware.

• EDK Export Tool: schema bloc proiectată în Simulink este tradusă în hardware văzut ca periferic într-un sistem cu procesor MicroBlaze. Fişierele rezultate pot fi folosite de către software-ul Xilinx EDK (EDK - Embedded Development Kit). Actualmente, doar un singur procesor MicroBlaze poate fi folosit într-un proiect System Generator.

• Hardware Co-Simulation: schema bloc proiectată în Simulink este tradusă într-un modul hardware pe o platformă FPGA, modul ce poate fi folosit pentru co-simulare: nu se mai simulează de către software acel modul, ci i se transmit valorile intrărilor şi se citesc valorile ieşirilor modulului hardware, totul integrat în mediul Simulink. Acest lucru poate fi foarte folositor, deoarece simularea în Simulink a unor funcţionalităţi poate dura cu mult mai mult decât timpul de calcul efectiv în hardware al funcţiei respective. De asemenea, se pot folosi dispozitive FPGA pentru co-simulare, chiar dacă în final nu se doreşte decât validarea unui algoritm ce va fi implementat în alt mod, tocmai pentru a se profita de viteza mare de execuţie oferită de aceste dispozitive.

• Timing Analysis: pentru hardware-ul ce corespunde schemei bloc proiectate în Simulink se poate face o analiză a performanţelor legate de timpii de propagare. Într-o manieră grafică sau textuală, se pot vizualiza căile de semnal cele mai lungi ca timp de propagare şi cele ce nu respectă constrângerile de timp impuse, utilizându-se în fundal modulul software Trace din pachetul Xilinx ISE.

Restul opţiunilor din fereastra de dialog din Fig. 3.2 sunt prezentate în Tabelul 3.3. Nu toate opţiunile sunt disponibile pentru fiecare din tipurile de rezultate. Majoritatea sunt însă disponibile pentru cazul generării unei descrieri HDL, care este opţiunea cea mai frecventă pentru implementarea în hardware de algoritmi de control.

52

Tabelul 3.3 Opţiunile ferestrei de dialog asociate blocului System Generator. Câmp Descriere

Part Defineşte dispozitivul FPGA pe care se va realiza implementarea. Target Directory Specifică directorul unde System Generator va plasa fişierele

rezultate în urma compilării. Poate fi specificată o cale absolută sau una relativă la directorul ce conţine modelul Simulink.

Synthesis Tool Specifică unealta software ce va fi folosită pentru sintetizarea hardware-ului. Se poate alege între Synplify, Synplify Pro şi Xilinx XST. Doar Xilinx XST este instalat împreună cu celelalte unelte Xilinx. Dacă se doreşte folosirea uneltelor Synplify sau Synplify Pro, acestea trebuie instalate separat.

Hardware Description Language

Defineşte limbajul ce va fi folosit pentru descrierea HDL a proiectului. Se poate alege între VHDL şi Verilog.

Create Testbench System Generator creează automat un banc de test (testbench) descris în limbajul HDL selectat. Acest banc de test include vectorii generaţi de către Simulink la intrările şi ieşirile modulului proiectat şi simulat şi poate fi utilizat pentru simularea într-un mediu specializat bazat pe HDL a descrierii hardware generate de System Generator. Această posibilitate extinde foarte mult utilitatea software-ului System Generator, oferind posibilitatea creării rapide de bancuri de test complexe. De asemenea, lucrul cu un simulator HDL permite optimizarea manuală a unor porţiuni din proiect şi apoi verificarea rapidă a păstrării funcţionalităţii iniţiale.

Import as Configurable Subsystem

System Generator creează automat un bloc căruia îi asociază fişierele rezultate în urma compilării şi un subsistem configurabil ce îl conţine.

FPGA Clock Period (ns)

Defineşte durata perioadei de tact, în ns. Valoarea este transmisă uneltelor de implementare prin intermediul unui fişier de constrângeri.

Clock Pin Location Specifică pinul dispozitivului FPGA pe care se primeşte semnalul de tact. Şi această informaţie este transmisă uneltelor de implementare printr-o constrângere.

Multirate Implementation

Specifică modalitatea de implementare a sistemelor cu rate multiple de eşantionare/prelucrare. Posibilităţile sunt: Clock Enables: Se creează un circuit hardware ce va genera semnale de validare a tactului pentru fiecare din elementele sistemului care au nevoie de rate de prelucrare diferite. Un singur semnal de tact va pilota însă toate elementele. Hybrid DCM/CE: Se creează un circuit generator de tact bazat pe un dispozitiv DCM (Digital Clock Manager) existent în FPGA şi care

53

poate genera semnale de tact diferite (două semnale pentru dispozitivele din familiile Spartan, respectiv 3 semnale pentru dispozitivele din familiile Virtex) pentru elemente ale sistemului cu rate de procesare diferită. Dacă există mai multe rate de procesare, atunci restul ratelor vor fi generate utilizând metoda de validare a tactului deja prezentată mai sus. Expose Clock Ports: Modulul top al proiectului generat în Simulink va prezenta mai multe intrări de tact, corespunzătoare nevoilor interne, care trebuie să fie pilotate de semnale de tact sincrone din exterior.

DCM Input Clock Period (ns)

Dacă se alege opţiunea Hybrid DCM/CE pentru generarea ratelor multiple, atunci trebuie specificată frecvenţa semnalului de tact la intrarea în DCM.

Provide Clock Enable Clear Pin

Modulul top generat va oferi un semnal numit ce_clr cu rolul de a reseta circuitul ce generează semnalele de validare a tactului folosite intern pentru implementarea sistemelor cu rate multiple de procesare.

Override with Doubles Atunci când System Generator se foloseşte doar pentru simulare, se poate forţa folosirea reprezentării în virgulă mobilă, dublă precizie, pentru anumite blocuri. Această opţiune este dezactivată la versiunea curentă a System Generator şi probabil va fi eliminată în viitor.

Simulink System Period (sec)

Specifică durata pasului de simulare pentru partea System Generator în Simulink, în secunde. Aceasta este fixă şi trebuie să fie un divizor comun al tuturor ratelor de prelucrare din sistem.

Block Icon Display După compilare, în modelul Simulink se pot afişa informaţii suplimentare referitoare la blocuri. Posibilităţile sunt: Default: doar informaţii privitoare la direcţia semnalelor; Sample Rates: rata de eşantionare pentru fiecare port; Pipeline Stages: numărul stadiilor interne de pipeline pentru fiecare bloc; HDL Port Names: denumirea semnalelor în limbajul HDL ales; Input Data Types: tipul de date pentru porturile de intrare; Output Data Types: tipul de date pentru porturile de ieşire.

3.2.4 Blocurile Gateway In şi Gateway Out

O schemă bloc realizată în Simulink în scopul implementării în FPGA trebuie să respecte

o anumită structură. Astfel, partea a cărei implementare se doreşte trebuie să fie realizată doar cu

54

blocuri din blockset-urile Xilinx sau Xilinx Reference. De asemenea, această parte trebuie să fie cuprinsă între blocurile Gateway In şi Gateway Out. Aceste blocuri fac trecerea între reprezentarea numerelor din Simulink (implicit în virgulă mobilă cu dublă precizie – tipul double) şi reprezentarea numerelor internă în FPGA (în virgulă fixă, cu lungime definită de utilizator). De asemenea, blocul Gateway In realizează discretizarea în timp a semnalelor de intrare (eşantionarea). Rata cu care se face eşantionarea este definită de utilizator pentru fiecare bloc Gateway In şi trebuie să fie un multiplu întreg al duratei pasului de simulare Simulink, stabilită de blocul System Generator (a se vedea Secţiunea 3.2.3).

Aşadar, blocul Gateway In poate fi văzut ca un convertor analog/numeric (CAN) virtual, realizând atât o discretizare în amplitudine (cuantizare) la trecerea de la reprezentarea în virgulă mobilă cu dublă precizie, cu gamă foarte largă şi precizie foarte înaltă, la reprezentarea în virgulă fixă, cu gamă şi precizie fixe, cât şi o discretizare în timp (eşantionare), preluând eşantioane din semnalul de intrare la intervale de timp precise. Cu cât diferenţa între valoarea pasului de simulare şi rata de eşantionare este mai mare, cu atât efectul de discretizare în timp este mai vizibil.

De obicei, blocul Gateway In chiar înlocuieşte în simulare un CAN real. Astfel, se pot observa efectele fenomenelor mai sus amintite generate de un CAN real prin simularea în Simulink.

În implementarea hardware, acestor blocuri le corespund porturi de intrare, respectiv de ieşire, ale modulului rezultat.

Fig. 3.3 prezintă fereastra de dialog a unui bloc Gateway In.

Figura 3.3. Fereastra de dialog a blocului Gateway In.

55

Se observă că ieşirea blocului poate fi de tip logic (Boolean) sau numeric, cu semn

(reprezentare în complement faţă de 2) sau fără semn. Numărul de biţi al formatului folosit pentru tipurile numerice este la alegerea utilizatorului şi nu trebuie să fie neapărat o putere a lui 2. De asemenea, poziţia virgulei fixe în formatul reprezentării este la alegerea proiectantului. Prin selectarea valorii 0 în acest câmp, se ajunge la reprezentarea numerelor întregi.

Pe lângă alegerea formatului de reprezentare a numerelor, există posibilitatea setării comportamentului ieşirii în cazul imposibilităţii reprezentării exacte a valorilor prezente la intrare. Astfel, se poate alege între metoda de cuantizare prin trunchiere – Truncate (se elimină biţii aflaţi la dreapta celui mai puţin semnificativ bit (LSB – Least Significant Bit) în formatul de reprezentare ales) sau prin rotunjire – Round (se alege valoarea cea mai apropiată ce poate fi reprezentată în formatul de reprezentare ales sau, în cazul a două valori echidistante, se alege valoarea cea mai îndepărtată de 0).

În plus, dacă valorile de la intrare sunt în afara gamei de valori a formatului de reprezentare ales, se poate alege cum va fi tratată situaţia de depăşire – Overflow. Prima posibilitate este aceea de a elimina biţii aflaţi la stânga bitului cel mai semnificativ (MSB – Most Significant Bit) reprezentabil, şi este cea mai puţin folositoare, pentru că poate introduce erori catastrofale în comportarea sistemului numeric [82], deoarece în locul unui număr pozitiv puţin mai mare decât cel mai mare număr reprezentabil sistemul vede un număr negativ mic şi vice-versa. Aceasta este opţiunea Wrap în Fig. 3.3. A doua posibilitate este aceea de a satura valorile intrării: dacă numărul de la intrare este mai mare decât cel mai mare număr reprezentabil în formatul ales, atunci se va folosi această valoare, iar dacă numărul de la intrare este mai mic decât cel mai mic număr reprezentabil, atunci se va folosi cel mai mic număr reprezentabil. Această opţiune (Saturate în Fig. 3.3) este foarte utilă, deoarece comportamentul sistemului numeric este doar perturbat, şi nu total eronat. Cea de-a treia opţiune, Flag as error, este valabilă doar pentru simulare, generând o eroare Simulink.

Aceste opţiuni nu fac altceva decât să specifice felul cum trebuie tratate de către sistemul numeric implementat ulterior în hardware valorile numerice furnizate de Simulink. Ele nu afectează în niciun fel hardware-ul produs, pentru că blocului Gateway In nu îi corespunde un modul hardware propriu-zis. Aceste opţiuni se traduc totuşi în cod HDL, folosit la simularea circuitului într-un simulator HDL.

Multe blocuri System Generator oferă aceste setări pentru ieşiri, în cazul în care se doreşte o limitare a numărului de biţi ai ieşirii (de exemplu, rezultatul unei înmulţiri necesită pentru reprezentare un număr de biţi egal cu suma lăţimilor intrărilor, dar nu toţi aceşti biţi sunt reprezentativi pentru calculele ulterioare). În acest caz, limitarea normală a numărului de biţi se realizează prin trunchiere, iar depăşirea de format nu este luată în considerare. Aceasta înseamnă că opţiunile Truncate pentru Quantization şi Wrap pentru Overflow sunt cele implicite şi nu necesită hardware suplimentar. În cazul în care se aleg opţiunile Round sau Saturate, System Generator introduce module hardware suplimentare pentru realizarea conversiei. Aceasta înseamnă cost suplimentar în ceea ce priveşte resursele ocupate şi timpul de propagare. Însă, aşa

56

cum s-a menţionat, opţiunea de saturare în caz de depăşire ar trebui neapărat folosită în cazul sistemelor numerice de control automat. Opţiunea Flag as error nu are în acest caz niciun efect asupra hardware-ului generat, fiind echivalentă din acest punct de vedere cu opţiunea Wrap.

Spre exemplu, hardware-ul suplimentar necesar în cazul unui multiplicator cu semn 18x18 (cu intrările pe 18 biţi) dacă se doreşte limitarea preciziei ieşirii la 32 de biţi, cu saturaţie, este prezentat în Fig. 3.4. Acesta se compune în principal din logica de detecţie a depăşirii superioare, logica de detecţie a depăşirii inferioare şi logica de rutare la ieşire a rezultatului (constanta limită superioară, constanta limită inferioară sau ieşirea trunchiată a multiplicatorului).

Se observă aşadar că selectarea opţiunii de saturare poate introduce costuri suplimentare consistente.

În Fig. 3.3, câmpul Sample period specifică perioada de eşantionare a intrării respective. Intrări diferite în acelaşi sistem pot avea perioade de eşantionare diferite, dar toate trebuie să fie multipli întregi ai pasului de simulare setat pentru System Generator.

Fig. 3.5 prezintă fila Implementation a ferestrei de dialog din Fig. 3.3. Setările de aici afectează fişierele generate de System Generator la compilare şi deci implementarea fizică a hardware-ului. Aceste setări sunt foarte importante dacă se doreşte implementarea de hardware direct din System Generator, fără a se mai folosi şi alte unelte şi fără a integra modulul rezultat din System Generator într-un alt proiect.

Pentru implementare direct din System Generator, este necesară verificarea respectării temporizării impuse circuitului FPGA de semnalul de tact: timpii de propagare ai căilor combinaţionale trebuie să fie mai mici decât perioada semnalului de tact. De asemenea, pinii de intrare/ieşire ai circuitului FPGA şi tampoanele (buffer-ele) asociate trebuie să asigure rata de transfer a modulului proiectat. Aceste cerinţe sunt salvate de către System Generator în fişiere de constrângeri, care sunt verificate de uneltele de implementare şi analiză de temporizare.

Figura 3.4. Hardware suplimentar pentru limitarea preciziei cu saturaţie.

57

Figura 3.5. Fila Implementation a ferestrei de dialog a blocului Gateway In

Constrângerile de rată de transfer sunt scrise în fişier dacă se bifează Data rate în câmpul

IOB timing constraint. Alocarea pinilor dispozitivului FPGA semnalelor unui modul se face tot cu ajutorul

constrângerilor. Acestea sunt constrângeri de locaţie, şi pot fi scrise automat de System Generator în fişierul de constrângeri dacă se bifează opţiunea Specify IOB location constraints şi se completează corect câmpul corespunzător.

Aceste tipuri de setări apar şi la blocul Gateway Out, a cărui fereastră de dialog este prezentată în Fig. 3.6, dar nu apar la alte blocuri System Generator, deoarece doar blocurile Gateway pot fi legate la pini fizici ai dispozitivului FPGA. Celelalte blocuri lucrează cu semnale interne. Se poate ca şi blocurile Gateway să nu lucreze decât cu semnale interne, dacă modulul creat în System Generator este apoi instanţiat într-un proiect mai mare. În acest caz, fişierele de constrângeri trebuie create prin alte metode.

La blocul Gateway Out, pe lângă constrângerile legate de rata de transfer se poate opta pentru impunerea constrângerii “FAST” în ceea ce priveşte fronturile semnalului de ieşire, prin selectarea opţiunii “Data rate; set ‘FAST’ attribute”.

58

Figura 3.6. Fereastra de dialog a blocului Gateway Out.

Resursele ocupate pe FPGA de un modul hardware definit în Xilinx System Generator

pot fi estimate automat folosindu-se blocul Resource Estimator. Acesta analizează proiectul şi, ţinând cont de dispozitivul FPGA ţintă, estimează ce resurse vor fi ocupate, actualizând în acelaşi timp câmpul FPGA area [slices, FFs, BRAMs, LUTs, IOBs, emb. mults, TBUFs] al fiecărui bloc ce are corespondent hardware. Acest câmp poate fi forţat la o anumită valoare dacă se bifează Define FPGA area for resource estimation. În acest caz Resource Estimator nu va mai actualiza valoarea, ci o va folosi pe cea impusă de utilizator. Această opţiune este utilă când proiectantul optimizează manual o parte din proiect la nivel HDL şi se doreşte totuşi o estimare sau când se doreşte excluderea unei părţi din proiect la estimare.

Blocul Gateway Out poate avea sau nu un port de ieşire corespondent în modulul hardware rezultat din schema Simulink. Acest lucru se decide prin bifarea sau debifarea opţiunii “Translate into output port”. Astfel, blocuri Gateway Out pot fi folosite doar în simulare, pentru a vizualiza semnale interne folosind unelte Simulink, fără ca aceste semnale să fie făcute accesibile în implementarea hardware.

Prezentarea blocurilor System Generator, Gateway In şi Gateway Out s-a făcut mai

detaliat deoarece aceste blocuri nu pot să lipsească dintr-un proiect. În plus, unele din setările descrise la blocurile Gateway se regăsesc printre setările comune multor blocuri System Generator.

59

3.2.5 Biblioteci ale blockset-ului Xilinx

În continuare, se va face o prezentare mult mai sumară a blocurilor celor mai utile din

bibliotecile Xilinx. Cititorul este îndrumat la literatura de specialitate [83], [84], [85], pentru o informare mai aprofundată. Nu se va insista pe bibliotecile Communication, DSP, Shared Memory, acestea având aplicabilitate scăzută în cazul sistemelor de control automat.

Biblioteca Basic Elements conţine reprezentări pentru diferite configuraţii de circuite

secvenţiale (Addressable Shift Register, Counter, Delay, LFSR, Parallel to Serial, Register, Serial to Parallel, Time Division Demultiplexer, Time Division Multiplexer) sau combinaţionale (Bit Basher, Concat, Constant, Convert, Expression, Inverter, Logical, Mux, Relational, Slice). De asemenea, include diferite blocuri pentru controlul şi verificarea ratelor de prelucrare a datelor (Clock Enable Probe, Down Sample, Reset Generator, Up Sample), precum şi a formatului de reprezentare (Assert, Reinterpret). Blocul Black Box permite încorporarea unui modul HDL proiectat în alt mod (fie rezultat după captură de schemă, fie descris direct în HDL) în Simulink pentru co-simulare folosind un simulator extern bazat pe HDL.

Blocurile bibliotecii Basic Elements sunt prezentate pe scurt în Tabelul A.1 din Anexa A. Pe lângă blocurile Black Box, Constant, Counter, Expression, Inverter, Logical, Mux,

Register, Relational, Slice, deja prezentate, biblioteca Control Logic include şi blocuri pentru instanţierea de memorii (Dual Port RAM, FIFO, ROM, Single port RAM) şi de procesoare (EDK Processor, PicoBlaze Microcontroller). Blocul MCode permite executarea de cod Matlab în Simulink, iar blocul Shift realizează operaţia de deplasare.

Blocurile bibliotecii Control Logic sunt prezentate pe scurt în Tabelul A.2 din Anexa A. Cele care au fost deja prezentate, aparţinând şi bibliotecii Basic Elements, nu mai apar în tabel.

Biblioteca Data Types grupează blocuri folosite pentru manipularea semnalelor, trecerea

dintr-un format de reprezentare în altul, extragerea de biţi sau grupuri de biţi, etc. Aceste blocuri (cu o singură excepţie, Scale, prezentată în Tabelul A.3 din Anexa A) se găsesc şi în bibliotecile deja prezentate, şi au fost grupate aici pentru uşurarea găsirii lor.

Biblioteca Math permite instanţierea de operatori aritmetici (Accumulator, AddSub,

Cmult, Mult, Threshold) sau realizarea unor funcţii matematice uzuale folosind nuclee configurabile (Complex Multiplier 3.0, CORDIC 4.0, Divider Generator 2.0, SineCosine).

Blocurile bibliotecii Math sunt prezentate pe scurt în Tabelul A.4 din Anexa A. Biblioteca Memory grupează blocuri folosite pentru implementarea diverselor tipuri de

module de memorie în Simulink. Aceste blocuri (cu o excepţie, Shared Memory, prezentată în Tabelul A.5 din Anexa A) se găsesc şi în bibliotecile deja prezentate, şi au fost grupate aici pentru uşurarea găsirii lor.

60

Biblioteca Tools conţine diferite unelte de control şi verificare a simulării (Clock Probe,

Configurable Subsystem Manager, Disregard Subsystem, Indeterminate Probe, Multiple Subsystem Generator, Pause Simulation, Sample Time, Simulation Multiplexer, Single-Step Simulation, Toolbar, WaveScope), de interfaţă pentru depanare (ChipScope, ModelSim) sau proiectare (FDA Tool), de estimare a resurselor (Resource Estimator). Aceste blocuri nu au în general corespondent în hardware, fiind utile pentru simulare şi depanare la proiectare.

Blocurile bibliotecii Math sunt prezentate în Tabelul A.6 din Anexa A. Din prezentarea bibliotecilor System Generator se poate trage concluzia că această

unealtă de proiectare poate fi folosită atât pentru proiectare la nivel înalt, instanţiind nuclee IP, cât şi pentru proiectare la nivel de transfer între registre, oferind flexibilitate maximă [60], [86]. De altfel, în [87] se arată că un sistem complex proiectat cu System Generator este comparabil ca performanţe cu unul proiectat în HDL, având chiar unele avantaje în ceea ce priveşte posibilităţile de ajustare ulterioară.

3.2.6 Integrarea unui modul proiectat folosind System Generator într-un proiect

Un modul proiectat în Simulink folosind blocuri System Generator poate fi implementat

în hardware pe dispozitive FPGA. De obicei, modulul trebuie integrat într-un proiect ce conţine şi alte module, proiectate prin alte metode.

Pentru o astfel de integrare, în câmpul Compilation al blocului System Generator se alege opţiunea HDL Netlist. Astfel, la apăsarea butonului Generate se va crea automat o descriere HDL a sistemului proiectat în Simulink. Această descriere va avea ca porturi de intrare şi ieşire blocurile Gateway In, respectiv Gateway Out din schema bloc Simulink. În plus, vor mai exista încă cel puţin 2 intrări care nu sunt definite explicit în Simulink: intrarea de tact, denumită clk_1, şi intrarea de validare a tactului, denumită ce_1. Dacă schema Simulink implică rate de procesare multiple, atunci va exista câte o pereche de semnale <clk, ce> pentru fiecare rată.

Pe lângă modulul HDL top care are acelaşi nume cu modelul Simulink corespunzător, se creează şi o serie de fişiere cu extensia .ngc, ce corespund blocurilor Simulink a căror implementare a fost generată automat folosind Xilinx LogiCORE. Acestea sunt nuclee IP gata mapate şi optimizate pentru arhitectura dispozitivului FPGA în care se va face implementarea.

Pentru includerea modulului proiectat în Simulink într-o captură de schemă, toate aceste fişiere vor fi copiate în directorul de lucru al proiectului ce conţine schema şi incluse în proiect. Apoi se creează un simbol pentru modulul HDL top şi se instanţiază acesta în schemă. Se conectează intrările şi ieşirile după nevoi. Semnalul ce_1 se conectează la 1 logic. Pentru semnalul clk_1 se va genera un semnal de tact cu perioada egală cu perioada stabilită în blocul System Generator, care este pasul folosit la simulare în Simulink pentru blocurile din librăriile

61

System Generator. Acest lucru este foarte important pentru o corespondenţă corectă între modelul Simulink şi comportarea hardware-ului obţinut.

În acelaşi mod, modulul proiectat în Simulink cu System Generator poate fi integrat într-un proiect descris în HDL.

3.2.7 Importarea în Simulink a unui modul proiectat prin captură de schemă

Folosind unealta software System Generator, în mediul Simulink se pot proiecta structuri

numerice ce pot fi apoi implementate direct în hardware, pe dispozitive de tip FPGA. Această metodă de proiectare permite un nivel de abstractizare mai înalt decât metodele de proiectare obişnuite (captură de schemă sau descriere HDL) dar are dezavantajul că nu se poate aplica pentru module hardware cu pretenţii speciale de temporizare, de exemplu interfeţe externe cu memoria sau cu dispozitive periferice. De asemenea, în funcţie de experienţa proiectantului, metodele de proiectare la nivel jos pot da rezultate mai bune în ceea ce priveşte resursele ocupate şi timpii de execuţie. Din aceste motive, este foarte utilă o modalitate de combinare a metodelor de proiectare la nivel jos cu proiectarea la nivel înalt în Simulink.

Unealta System Generator permite importarea unui modul HDL într-o schemă bloc Simulink. Acest modul poate proveni fie dintr-o descriere directă în limbaj HDL, fie dintr-o traducere în limbaj HDL a unei scheme logice capturate. Prin importarea modulului, acesta poate fi simulat folosind un simulator HDL extern, apelat direct din Simulink. Avantajul este evident: simulatorul HDL primeşte la intrare vectori de test generaţi automat de Simulink, iar semnalele de ieşire pot fi vizualizate direct în mediul Simulink, împreună cu semnalele din restul schemei bloc.

Realizarea unei co-simulări Simulink-HDL presupune mai mulţi paşi, primul fiind importarea în Simulink a modulului proiectat printr-o altă metodă.

Aşa cum s-a arătat în Secţiunea 3.2.5, biblioteca Basic Elements din System Generator include un bloc denumit Black Box, ce se poate folosi pentru importarea în Simulink a unui modul descris în HDL. Software-ul ISE Project Navigator, din pachetul ISE Design Suite produs de Xilinx, oferă o interfaţă pentru proiectarea sistemelor numerice implementabile în FPGA la nivel de captură de schemă. Schema capturată este automat translată într-o descriere HDL în procesul de sinteză.

Dacă, de exemplu, se alege ca HDL limbajul Verilog, atunci fişierul creat va avea extensia “.vf”. Acest fişier poate fi recunoscut de uneltele ce lucrează cu fişiere Verilog prin modificarea manuală a extensiei la “.v”.

Trebuie ţinut cont de câteva restricţii la capturarea schemei dacă se doreşte ca acesta să poată fi importată în Simulink ca fişier Verilog:

• denumirile porturilor de intrare şi ieşire trebuie să conţină doar litere mici şi să respecte convenţia de denumire VHDL;

62

• blocul trebuie să aibă definite semnale de intrare de tact şi de validare a tactului, care să apară în pereche; denumirile acestora trebuie să conţină şirurile clk, respectiv ce (de exemplu, src_clk_1 şi src_ce_1); semnalele trebuie să nu fie de tip vector; pot exista mai multe perechi <clk, ce> dacă se doreşte ca părţi diferite din modul să funcţioneze la rate diferite de procesare a datelor; aceste semnale nu vor apărea explicit în Simulink, dar vor fi folosite implicit în simulare;

• numele entităţii nu trebuie să fie în conflict cu nume rezervate de System Generator; aceste nume încep însă cu literele xl (de exemplu, xlfir, xlregister), deci o coliziune de nume este puţin probabilă;

• porturile de tip vector trebuie ordonate începând cu MSB şi terminând cu LSB (de exemplu vector[7:0]).

Dacă schema se construieşte ierarhic, la sinteză se creează câte un fişier “.vf” pentru fiecare modul din schemă. Dacă modulele respectă constrângerile prezentate mai sus, atunci se pot importa unul câte unul în Simulink, pentru validare.

Pentru importarea unui modul descris în Verilog într-o schemă Simulink se copie fişierul “.vf” (creat din modulul de schemă la sinteză) ce descrie modulul în directorul proiectului Simulink, se redenumeşte extensia la “.v”, se instanţiază în schema Simulink un bloc Black Box. În momentul instanţierii, blocul Black Box deschide o fereastră de dialog pentru alegerea fişierului Verilog sau VHDL pe care îl reprezintă. Când se alege fişierul de intrare pentru Black Box, se creează automat un fişier MATLAB de configuraţie, denumit “nume_HDL_config.m”, unde nume_HDL.v este numele fişierului asociat blocului Black Box. Trebuie avut grijă ca fişierul de configuraţie să nu existe deja, pentru că în acest caz nu va fi suprascris şi configuraţia s-ar putea să nu corespundă cu conţinutul fişierului HDL. Fişierul de configuraţie specifică numele şi tipul porturilor blocului Black Box, numele fişierelor HDL ce trebuie compilate, cât şi ratele de prelucrare a datelor asociate semnalelor de tact.

Trebuie avut în vedere faptul că la specificarea fişierului HDL pentru blocul Black Box, acesta este verificat şi trebuie să conţină doar modulul top. Dacă fişierul creat automat din captura unei scheme conţine mai multe module (de exemplu, module mai complexe create pe baza unor componente primitive), atunci acestea trebuie eliminate manual din fişier şi salvate în fişiere proprii. Fişierele HDL rezultate trebuie incluse ca fişiere sursă pentru blocul Black Box, specificându-le în fişierul de configurare folosind construcţia:

this_block.addFile('nume_fis.v'); Dacă blocul creat este secvenţial, neconţinând nici o cale de semnal pur combinaţională

de la intrare spre ieşire, atunci se poate comenta metoda this_block.tagAsCombinational;

din fişierul de configurare. Acest lucru măreşte viteza de simulare, pentru blocurile secvenţiale comportarea nefiind simulată între momentele de activare, date de perioada semnalului de tact.

Este de importanţă crucială ca această metodă să fie apelată pentru blocurile combinaţionale (pur sau parţial combinaţionale), altfel rezultatele co-simulării fiind eronate.

63

3.2.8 Co-simularea Simulink-HDL a unui modul proiectat prin captură de schemă

După definirea modulului Black Box, acesta este în starea Inactive. Acest lucru înseamnă

că simularea Simulink nu-l va activa, deci nu se va ţine cont de el. Dacă se doreşte simularea funcţionalităţii blocului, atunci se va alege o altă opţiune pentru câmpul Simulation Mode. Dacă se alege ISE Simulator, atunci se va folosi pentru co-simulare un simulator HDL produs de Xilinx şi inclus în pachetul ISE.

O altă opţiune este folosirea unui simulator extern mai performant. În caz că se alege această opţiune, trebuie să existe instalat simulatorul ModelSim, produs de Mentor Graphics, iar în schema bloc Simulink trebuie adăugat blocul ModelSim. Dacă se foloseşte limbajul Verilog, atunci trebuie să se bifeze opţiunea Include Verilog unisim library pentru blocul ModelSim. De asemenea, biblioteca Unisim, conţinând elementele de bază pentru proiectarea de hardware în FPGA şi fiind oferită de Xilinx, trebuie compilată în simulatorul ModelSim sub numele unisims_ver. Aceasta se realizează introducând următoarea comandă în linia de comandă ModelSim:

vlog -work unisims_ver {D:\xilinx\11.1\ise\verilog\src\unisims\*.v} Desigur, porţiunea cuprinsă între { şi \ise trebuie să corespundă cu calea pe care s-a

instalat pachetul ISE pe calculatorul pe care se lucrează. Simulatorul ModelSim permite vizualizarea formelor de undă ale semnalelor de intrare şi

ieşire ale modulului simulat, dar permite şi vizualizarea semnalelor interne ale modulului, ceea ce este foarte important pentru depanare.

Pentru detalii despre modul de utilizare a simulatorului ModelSim, cititorul este îndrumat către literatura de specialitate: [88], [89], [90].

ISE Simulator nu permite vizualizarea semnalelor, simulând doar funcţionarea modulului. Se pot folosi blocuri Simulink pentru a vizualiza semnalele de ieşire (de exemplu Scope).

Este foarte important de menţionat că pentru o co-simulare corectă durata pasului de simulare Simulink, setată în câmpul Simulink system period (sec) al blocului System Generator, trebuie să fie egală cu perioada semnalului de tact şi cu perioada de eşantionare pentru blocurile Black Box. Aceasta forţează generarea unui semnal de tact pentru blocul Black Box similar cu semnalul de tact real. Desigur, acest lucru duce la prelungirea duratei în care se realizează simularea, dar avantajele utilizării co-simulării compensează acest inconvenient.

3.3 Unelte de depanare pentru sisteme implementate în FPGA Odată cu creşterea complexităţii sistemelor implementate în FPGA, creşte şi dificultatea

testării şi depanării lor. De aceea este nevoie de unelte specializate şi performante de verificare. Aceste unelte pot fi implementate în hardware, folosind resursele logice rămase neocupate ale

64

dispozitivului programabil, sau în software, folosind procesorul hard sau soft încorporat în aplicaţie. Atât subsistemele hardware, cât şi cele software, au nevoie de capabilităţi de depanare.

Componenta principală a unei unelte de depanare pentru FPGA este aparatura de măsură ce capturează valorile logice ale semnalelor în timp ce aplicaţia rulează pe sistem la viteza normală de lucru [4]. Modul de lucru este următorul: se definesc nodurile de urmărit (semnale ce nu sunt accesibile în exterior), activitatea lor este monitorizată, iar secvenţa de valori rezultată este transmisă în timp real unei aplicaţii de tip analizor logic. Atunci când se urmăresc foarte multe semnale (magistrale de mulţi biţi) cu o rată de eşantionare mare nu este posibilă transmiterea datelor în timp real. În acest caz, care este şi cel mai des întâlnit, modul de lucru se schimbă: se definesc semnalele ce trebuie analizate, se defineşte dimensiunea ferestrei de analiză (numărul de eşantioane, în strânsă legătură cu memoria disponibilă în FPGA), se defineşte un eveniment de declanşare a analizei (trigger, o condiţie ce trebuie îndeplinită de unul sau mai multe din semnalele urmărite), se defineşte perioada de eşantionare. Semnalele urmărite sunt salvate în memoria internă din FPGA (rămasă nefolosită de către aplicaţie) începând cu momentul în care condiţia de trigger este îndeplinită. Apoi sunt transferate pe un calculator gazdă, unde pot fi vizualizate şi analizate folosind programe software specializate.

Cele mai multe unelte de depanare se bazează pe blocuri IP, ce pot fi deci instanţiate de mai multe ori într-o aplicaţie. Exemple de astfel de unelte proiectate de producătorii de FPGA-uri sunt SignalTap II de la Altera, ChipScope Pro de la Xilinx, ispTRACY de la Lattice. Astfel de unelte sunt disponibile şi de la alte firme specializate: Identify de la Synplicity, FPGAView de la First Silicon Solutions. Altium Designer oferă biblioteci de instrumente virtuale pentru depanare, ce se implementează în FPGA şi sunt afişate prin interfaţa software-ului de proiectare.

Există posibilitatea folosirii blocurilor IP interne cu instrumente specializate externe. De exemplu, software-ul B4655A FPGA Dynamic Probe de la Agilent Technologies se poate combina cu ChipScope Pro sau EDK şi se poate folosi cu analizoare logice din familiile 16900, 16800, 1680, 1690 de la Agilent, pentru FPGA-urile Xilinx. Agilent oferă şi B4656A FPGA Dynamic Probe, care, în combinaţie cu Quartus II Logic Analyzer Interface şi aceleaşi familii de analizoare logice, se poate folosi pentru FPGA-urile Altera. De asemenea, Agilent oferă E9524A MicroBlaze Trace Toolset, ce, în combinaţie cu aceleaşi familii de analizoare logice, poate fi folosit pentru urmărirea fluxului de date şi program a unul sau mai multe procesoare MicroBlaze implementate în FPGA-uri Xilinx.

FPGAView de la First Silicon Solutions poate fi combinat cu Quartus II Logic Analyzer Interface şi analizoare logice Tektronix din familiile TLA600, TLA5000, TLA700, TLA7000 sau MSO4000 pentru depanarea sistemelor bazate pe FPGA-uri Altera, sau cu Logic Analyzer Core şi aceleaşi familii de analizoare logice pentru depanarea sistemelor bazate pe FPGA-uri Xilinx.

65

3.4 Studii de caz În continuare se vor prezenta trei studii de caz originale, aplicaţii de control automat

implementate pe FPGA. Acestea servesc la a exemplifica aplicarea metodologiei şi utilizarea uneltelor de proiectare prezentate. De asemenea, au avut un rol esenţial în familiarizarea autorului cu uneltele de proiectare şi dezvoltarea unor abilităţi de lucru cu dispozitivele FPGA, absolut necesare pentru a atinge obiectivul final propus al tezei.

3.4.1 Controlul motorului de curent continuu folosind bucla cu calare pe fază

Bucla cu calare pe fază (PLL – Phase Locked Loop) este probabil cel mai răspândit

exemplu de sistem de reglare automată în buclă închisă. Este folosită în aproape toate sistemele digitale actuale pentru multiplicarea frecvenţei de lucru, este folosită în televiziune pentru sincronizarea semnalelor, este folosită în telecomunicaţii (în telefonia celulară, de exemplu) pentru extragerea semnalului de tact din semnalul de date. O utilizare mai puţin răspândită, deşi introdusă în anii 1970, a buclei PLL este controlul vitezei motoarelor de curent continuu [91], [92], [93]. Şi motoarele de curent alternativ sincrone pot fi controlate prin tehnici bazate pe PLL, dacă mişcarea câmpurilor rotorului şi statorului sunt văzute ca semnale ce trebuie sincronizate prin PLL [94], [95], [96].

Bucla PLL constă dintr-un detector de fază, un filtru şi un oscilator controlat în tensiune (VCO – Voltage Controlled Oscillator). Semnalul de ieşire al oscilatorului controlat în tensiune este comparat cu un semnal de referinţă de către circuitul detector de fază. Ieşirea filtrată a acestuia comandă VCO-ul. Bucla PLL lucrează în sensul minimizării erorii de fază dintre cele două semnale.

Atunci când trebuie sincronizate semnale digitale, detectorul de fază este un circuit digital, combinaţional sau secvenţial. De obicei, filtrul şi VCO-ul sunt tot analogice, iar aceste bucle sunt cunoscute în literatura de specialitate sub denumirea de PLL-uri digitale clasice (CDPLL – Classical Digital PLL) [97]. Odată cu dezvoltarea circuitelor digitale, a apărut o nouă clasă de PLL-uri: cele total digitale (ADPLL – All Digital PLL) [97], [98], [99], [100]. Acestea constau doar din componente digitale: detectorul de fază este digital, filtrul este numeric, iar generatorul local de semnal este un oscilator controlat numeric (DCO – Digitally Controlled Oscillator). Astfel, toate semnalele din bucla de reglare sunt digitale. Avantajul acestor bucle implementate numai cu circuite digitale este evident: nu mai apar problemele comune componentelor analogice: variaţia parametrilor la producţie, capacităţi parazite, variaţii cu temperatura, îmbătrânire. Un alt avantaj al buclelor total digitale este faptul că pot fi implementate în dispozitive reconfigurabile, ceea ce uşurează proiectarea şi testarea.

În cazul controlului vitezei unui motor de curent continuu folosind bucla PLL, acesta trebuie inclus în buclă: driver-ul, motorul şi codificatorul optic de poziţie formează DCO-ul

66

buclei. Diferenţa faţă de un DCO obişnuit constă în faptul că combinaţia motor - codificator este un sistem de ordinul 2, şi acest lucru trebuie luat în consideraţie când se proiectează bucla.

Schema bloc a sistemului de control al motorului este prezentată în Fig. 3.7. Acesta constă dintr-un detector de fază şi frecvenţă (PFD – Phase Frequency Detector), un filtru de buclă şi motorul cu codificatorul de poziţie (tahometru optic).

Funcţia de transfer a motorului, incluzând proprietatea de integrator a tahometrului, este:

)1()(

m

msTs

KsH

+= , (3.1)

unde mK este amplificarea, iar mT este constanta de timp a motorului.

Dacă se foloseşte un filtru de ordinul I, cum se procedează de obicei, sistemul în buclă închisă va avea trei poli. Aceasta înseamnă că este nevoie de un filtru cu un zero. Altfel, faza funcţiei de transfer în buclă închisă va depăşi 180° la frecvenţe înalte şi sistemul va pierde stabilitatea. Din acest motiv se foloseşte un filtru de tip PI, a cărui funcţie de transfer este:

ss

sK

KsF IP

1

2 1)(

ττ +

=+= , (3.2)

unde 1

2ττ

=PK , 1

1τ

=IK .

Întreaga buclă de control a fost proiectată pentru a fi implementată în FPGA. Pentru aceasta, a fost proiectat un circuit secvenţial original detector de fază, iar filtrul a fost discretizat şi implementat prin operatori aritmetici. De asemenea, a fost proiectat un circuit generator de semnal modulat în durata impulsurilor (PWM – Pulse Width Modulation), cu rol de convertor numeric-analogic, pentru controlul tensiunii aplicate motorului.

Figura 3.7. Schema bloc a sistemului de control PLL.

67

Figura 3.8. Schema bloc a detectorului de fază.

Schema bloc a detectorului de fază este prezentată în Fig. 3.8. Semnalul de referinţă este generat dintr-un semnal de tact de 50 MHz, obţinut de la un

oscilator cu cuarţ. Semnalul de tact este divizat de un divizor programabil, ce permite modificarea uşoară a semnalului de referinţă, şi un divizor fix cu 65535, ce este un numărător binar pe 16 biţi şi reprezintă miezul detectorului de fază: valoarea numărătorului este salvată într-un registru de frontul crescător al semnalului de la ieşirea tahometrului.

În acest fel, diferenţa de fază dintre cele două semnale, cel de referinţă, dat de ieşirea de “sfârşit de numărare” (terminal count) a numărătorului, şi cel controlat, de la ieşirea tahometrului, este cuantificată numeric. Dacă valoarea salvată din numărător este interpretată ca un număr cu semn în complement faţă de 2, atunci există 2 situaţii: dacă frontul crescător al semnalului de ieşire al tahometrului apare în prima semiperioadă a semnalului de referinţă, atunci se va salva în registru un număr pozitiv, cu magnitudinea dată de întârzierea celui de-al doilea semnal faţă de primul. Dacă frontul crescător al semnalului de ieşire al tahometrului apare în a doua semiperioadă a semnalului de referinţă, atunci în registru se va salva un număr negativ, iar magnitudinea acestuia va fi proporţională cu timpul rămas până la expirarea perioadei semnalului de referinţă. Astfel, detectorul de fază semnalează magnitudinea erorii de fază, cât şi direcţia erorii (phase lead sau phase lag).

Dacă eroarea este de frecvenţă, nu de fază, sunt posibile două situaţii: dacă frecvenţa semnalului de referinţă este mai mare decât frecvenţa semnalului controlat, atunci vor trece perioade ale semnalului de referinţă în care conţinutul numărătorului nu este salvat în registru. Această situaţie este semnalată de starea unui bistabil, iar în acest caz nu valoarea din registru, ce este falsă, ci o valoare constantă corespunzătoare erorii de fază maxim pozitivă va fi prezentată la ieşirea detectorului de fază. Dacă frecvenţa semnalului controlat este mai mare decât frecvenţa semnalului de referinţă, atunci vor apărea mai multe fronturi pozitive ale semnalului controlat într-o singură perioadă a semnalului de referinţă. Ultimul front va salva în registru valoarea numărătorului, ceea ce înseamnă că valoarea va fi negativă. Acest lucru corespunde unei situaţii de eroare de fază negativă; bucla va lucra pentru minimizarea acestei erori prin scăderea tensiunii aplicate motorului, scăzând astfel frecvenţa semnalului de la tahometru. Această

68

caracteristică extinde funcţionalitatea circuitului, putând fi considerat detector de fază şi frecvenţă (PFD – Phase Frequency Detector).

Ieşirea detectorului de fază este deci liniară în intervalul [-π;+π) şi este neliniară în cazul erorii de frecvenţă. Detectorul de fază este deci un convertor analog-numeric pentru eroarea de fază, a cărui funcţie de transfer pentru intervalul [-π;+π) este:

π265536

=dK . (3.3)

Detectorul de fază proiectat oferă avantajul unei reprezentări foarte precise, pe 16 biţi, a defazajului. Este astfel superior altor circuite prezentate în literatură [101], bazate pe automate de stări.

În ceea ce priveşte filtrul de buclă, acesta este proiectat în domeniul digital pornind de la ecuaţia (3.2). Prin discretizarea acesteia, incluzând caracteristica de extrapolator de ordin 0 a detectorului de fază, se ajunge la:

⎥⎥⎦

⎤

⎢⎢⎣

⎡

−+

−−

=⎭⎬⎫

⎩⎨⎧

+−

=22 )1(1

11)(z

TzKz

zKz

zsK

sK

Zz

zzF IPIP , (3.4)

ceea ce conduce la:

1)(

−+=

zTK

KzF IP , (3.5)

unde T este perioada de eşantionare, adică perioada semnalului de referinţă.

Dacă se exprimă (3.5) în 1−z , se obţine:

1

1

1)(

−

−

−+=

zTzK

KzF IP . (3.6)

Notând ieşirea filtrului cu u[k] şi intrarea cu ε[k], atunci (3.6) conduce la o relaţie de calcul pentru u[k]:

⇒−

−+=

Ε −

−

1

1

1)(

)()(

zzKTKK

zzU PIP (3.7)

⇒−+=− −− )()()()()( 11 zEzKTKzEKzUzzU PIP (3.8)

]1[)(][]1[][ −−++−= kKTKkKkuku PIP εε . (3.9)

Ca observaţie, ecuaţia (3.9) poate fi dedusă direct din domeniul timp prin aproximarea integralei cu metoda dreptunghiului în avans.

Schema bloc a filtrului digital, adică structura hardware dedicată ce implementează ecuaţia cu diferenţe (3.9) este prezentată în Fig. 3.9.

69

Figura 3.9. Schema bloc a filtrului digital.

Filtrul este implementat folosind multiplicatoarele dedicate pe 18 biţi ale dispozitivului

FPGA Spartan-3E XC3S500E, de la Xilinx, care s-a utilizat la efectuarea experimentelor. După fiecare operator aritmetic este implementată o structură hardware de detectare a depăşirii şi saturare a rezultatului la valoarea maximum pozitivă sau maximum negativă reprezentabilă pe 16 biţi. Acest lucru permite evitarea efectelor catastrofale ale depăşirilor [82], chiar dacă saturaţia, atunci când este atinsă, introduce neliniarităţi.

Pentru determinarea factorilor de amplificare ai elementelor proporţional şi integrator s-a aplicat metoda proiectării în domeniul frecvenţă, folosind diagramele Bode, ca în [97]. Zeroul din funcţia de transfer trebuie plasat astfel încât faza să rămână sub 180° la frecvenţa unde amplificarea trece prin 0. Considerând o rezervă de 30º, frecvenţa de tăiere a termenului

)1( 2sτ+ trebuie să fie mult sub frecvenţa de tăiere mT/1 :

maT=2τ , ( 1>a ). (3.10)

Alegând un factor a=10 şi cunoscând sTm 1= pentru motorul considerat, se ajunge la

s102 =τ .

Pentru a găsi valoarea lui 1τ , trebuie ales factorul de amplificare total al buclei astfel

încât amplificarea să fie 0 la frecvenţa de tăiere mT/1=ω . Această constrângere conduce la un

factor de amplificare total al buclei K=0,14. Cunoscând valorile celorlalţi factori de amplificare ( dK , amplificarea detectorului de fază; mK , amplificarea motorului; aK , amplificarea

circuitului PWM şi a driver-ului, prezentată mai jos; zK , amplificarea tahometrului; NK ,

amplificarea divizorului programabil), s-a determinat valoarea lui 1τ :

14614.0

50160

60320

6553620

265536

1 ≈⋅⋅⋅⋅

== πτK

KKKKK Nzmad . (3.11)

Astfel, parametrii filtrului PI sunt:

068.014610

1

2 ===ττ

pK , (3.12)

70

0068.0146

11

1===

τIK . (3.13)

S-a ales o valoare a divizorului programabil N=50, ceea ce conduce la 50/1=NK .

Pentru efectuarea experimentelor, s-a considerat că viteza de referinţă a motorului variază în jurul valorii de 600 rot/min, adică o frecvenţă de 12 Hz. Semnalul de referinţă este generat în

FPGA de la semnalul oscilatorului cu cuarţ de 50 MHz prin divizare cu 222 , obţinându-se 11.92Hz. Perioada de eşantionare este deci T=0,084s, ceea ce conduce la factorul de multiplicare

0674288.0068.00005712.0 −=−=− PI KTK .

Operaţiile de înmulţire au fost implementate folosind multiplicatoarele dedicate pe 18 biţi ale dispozitivului FPGA, după scalarea intrărilor, prin deplasări la dreapta, pentru atingerea valorilor subunitare necesare. Proiectarea sistemului hardware implementat în FPGA s-a realizat prin captură de schemă logică folosind Xilinx ISE.

Pentru experimente s-a folosit un motor de curent continuu de 24V de tip Leybold Didactic 73411 Motor-Generator Set. Acesta este controlat prin aplicarea tensiunii de alimentare modulată în durata impulsurilor. Tensiunea de alimentare de 20 V este obţinută cu ajutorul a două blocuri de amplificare: Leybold Didactic 73419 Gain and Offset Adjust Block şi Leybold Didactic 73413 Power Amplifier Block. Circuitul de generare a impulsurilor PWM, împreună cu blocurile de amplificare, pot fi văzute ca un convertor numeric-analogic cu funcţia de transfer

6553620

22016 ==aK . (3.14)

În acest experiment, întreaga buclă de reglare a fost implementată numeric în FPGA, fără a fi nevoie de circuite externe de conversie analog-numerică şi numeric-analogică. Acest lucru a fost posibil datorită proiectării inteligente a detectorului de fază şi a circuitului PWM, numai cu componente logice, ce pot fi sintetizate în FPGA. Bucla proiectată diferă de alte abordări total digitale din literatură [93] prin aceea că este structural asemănătoare cu o buclă analogică, deci mult mai uşor de analizat şi modelat. Rezultatele experimentale au dovedit că se poate obţine calare pe fază, şi deci control al vitezei motorului, dacă acesta are viteză apropiată de referinţă. Dacă diferenţa dintre semnalul de referinţă şi cel controlat este mare, bucla nu reuşeşte să atingă întotdeauna calarea pe fază. Comportamentul detectorului de fază trebuie studiat mai amănunţit şi comportamentul în caz de eroare de frecvenţă trebuie îmbunătăţit.

O variantă iniţială, pe 8 biţi, a acestui studiu de caz a fost publicată în [102]. Varianta îmbunătăţită, prezentată aici, a fost publicată în [103].

71

3.4.2 Implementarea în hardware a algoritmului de control deadbeat

Algoritmul de control deadbeat este prezentat în multe lucrări internaţionale de referinţă,

ca şi în [82]. Acesta se bazează pe proiectarea în domeniul timp, impunând un anumit răspuns sistemului în buclă închisă şi folosind un model discretizat al părţii fixate.

Pentru studiul de caz, s-a ales tot controlul motorului de curent continuu, descris de:

m

mp sT

KsG

+=

1)( , (3.15)

unde mK este amplificarea, iar mT este constanta de timp a motorului.

Răspunsul dorit al sistemului la aplicarea unui semnal treaptă la intrare este impus ca:

y[T] = 0; y[2T] = 0.8; y[3T] = 1.05; y[4T] = y[5T] = ... = 1. (3.16)

În aceste condiţii, funcţia de transfer discretă a sistemului în buclă închisă este:

4

2

005.025.08.0)(

zzzzG −+

= . (3.17)

Discretizând (3.15) cu o perioadă de eşantionare 0.67108864=sT şi cunoscând

66,0=mK şi mT =1,2s se obţine:

5716.02827.0)(

−=

zzG p . (3.18)

Perioada de eşantionare s-a ales multiplu de 40ns, care este perioada de tact a sistemului implementat în FPGA, pentru a simplifica circuitul de obţinere a ei. De asemenea, perioada de eşantionare trebuie să respecte relaţia recomandată în [82]:

36.0≥Σf

sTT

, (3.19)

unde fTΣ este suma constantelor de timp ale părţii fixate.

Perioada de eşantionare influenţează şi valoarea iniţială a semnalului de comandă. S-a verificat prin simulare că, pentru sistemul propus, valoarea semnalului de comandă nu depăşeşte limitele de saturaţie ale dispozitivelor fizice folosite la experimente.

Funcţia de transfer a regulatorului se obţine din (3.17) şi (3.18) folosind relaţia:

)(1)(

)(1)(

10

10

11

−

−

−−

−=

zGzG

zGzG

pR . (3.20)

Notând cu u[k] semnalul de ieşire al regulatorului (semnalul de comandă) şi cu ε[k] semnalul de intrare al regulatorului (semnalul de eroare), obţinem:

72

432

44

33

22

110

1

1

05.025.08.01)()(

−−−

−−−−

−

−

+−−

++++=

Ε zzzzqzqzqzqq

zzU , (3.21)

unde 00 =q ; 2.82971 =q ; -0.73332 =q ; -0.68233 =q ; 0.10114 =q .

Din (3.21) se obţine o relaţie de calcul pentru u[k]:

]4-k[05.0]3-k[25.0]2-k[8.0]4-k[3]-[kq2]-[kq1]-[kq][ 4321

uuuqku

−+++++= εεεε

. (3.22)

Această ecuaţie cu diferenţe recurentă descrie un sistem cu răspuns infinit la impuls (IIR – Infinite Impulse Response). Forma directă I [104] de implementare este prezentată în Fig. 3.10. Aceasta este derivată direct din (3.22). Pentru implementarea fizică sunt posibile şi alte structuri, descrise în [104], cum ar fi: forma directă II, structura de tip cascadă, paralel, încrucişată (lattice) sau încrucişată în scară (lattice-ladder).

Având în vedere că în FPGA registrele (pentru implementarea întârzierilor numerice) nu sunt o resursă critică şi că operaţiile se fac pe suficienţi biţi pentru ca erorile de cuantizare să fie nesemnificative, s-a ales forma directă I pentru implementare. Avantajul acesteia este că stadiile de adunare şi înmulţire sunt independente. Aceasta permite precizie fixă la operaţia de înmulţire, dar precizie crescândă la operaţiile de adunare, eliminând acumularea de erori de cuantizare. La sfârşit, rezultatul este trunchiat la precizia dorită.

Datorită structurii clasice a algoritmului, nu este necesară analiza folosind graful fluxului de date. Paralelismul potenţial al algoritmului poate fi observat direct din forma prezentată în Fig. 3.10. Este evident că cea mai rapidă implementare va efectua în paralel toate înmulţirile şi cât mai multe dintre adunări. Pentru înmulţire se folosesc multiplicatoarele pe 18 biţi integrate în dispozitivele Spartan-3E. Toate operaţiile sunt realizate folosind aritmetică în virgulă fixă cu semn (reprezentare în complement faţă de 2).

Figura 3.10. Forma directă I a regulatorului deadbeat.

73

Implementarea s-a realizat în mediul Simulink, cu ajutorul utilitarului Xilinx System Generator. Avantajul metodei, aşa cum s-a menţionat în Secţiunea 3.2, este posibilitatea simulării precise a structurii hardware ce va fi apoi sintetizată automat. Fig. 3.11 prezintă implementarea regulatorului cu blocuri specifice System Generator în Simulink.

Regulatorul implementat astfel a fost simulat împreună cu un model Simulink în virgulă mobilă, dublă precizie. Schema bloc a modelului simulat este prezentată în Fig. 3.12. Rezultatele simulării au arătat că diferenţa între cele două implementări este foarte mică din punctul de vedere al valorilor ieşirilor.

În Fig. 3.12, partea de schemă cuprinsă între blocurile Gateway In şi Gateway Out reprezintă regulatorul ce va fi implementat în FPGA. Semnalul de referinţă este selectat cu ajutorul a două butoane de pe placa cu FPGA, prin intermediul unui multiplexor. Intrările multiplexorului sunt valori numerice corespunzătoare diferitor nivele ale semnalului de referinţă. Astfel, se pot introduce modificări de tip treaptă de diferite amplitudini ale semnalului de referinţă.

Figura 3.11. Implementarea regulatorului deadbeat în System Generator.

74

Figura 3.12. Simularea regulatorului deadbeat în Simulink.

Semnalul de la intrarea Gateway In va fi primit de la un convertor analog-numeric (CAN)

pe 14 biţi, cu ieşirea cu semn în complement faţă de 2. Viteza motorului fiind convertită într-o tensiune cuprinsă între 0V şi 8V, intrarea CAN-ului va fi pozitivă. De aceea, se va renunţa la bitul de semn, ca şi la bitul cel mai puţin semnificativ, interpretând valoarea de intrare Gateway In ca un număr în virgulă fixă fără semn, cu 3 biţi pentru partea întreagă şi 9 biţi pentru partea fracţionară.

Semnalul de la ieşirea Gateway Out va fi trimis unui convertor numeric-analogic (CNA) pe 12 biţi. Pentru aceasta va fi trunchiat la 12 biţi de la reprezentarea internă a motorului de calcul, de 18 biţi. Datorită faptului că semnalul de comandă se saturează la 13V din cauza amplificatoarelor fizice folosite, ieşirea Gateway Out va fi interpretată ca 4 biţi ai părţii întregi şi 8 biţi ai părţii fracţionare.

Interpretarea semnalelor de intrare şi de ieşire ca fiind numere în virgulă fixă de un anumit format este un exemplu de simplificare computaţională importantă. Aşa cum s-a menţionat în Secţiunea 2.3, primul pas în implementarea unui algoritm în hardware este rafinarea lui. Prin alegerea inteligentă a formatului reprezentării în virgulă fixă a intrărilor şi ieşirilor se evită calculele de interpretare a valorii recepţionate de la CAN (înmulţirea numărului întreg citit cu valoarea cuantei) şi cele de convertire a valorii rezultate în urma aplicării algoritmului la un număr întreg din gama de intrare a CNA-ului.

Diferenţa între implementarea în Matlab a regulatorului, în virgulă mobilă cu dublă precizie, şi implementarea în FPGA, în virgulă fixă pe 18 biţi, poate fi analizată prin simulare

urmărind valorile din Scope1. Diferenţa observată a fost de ordinul 310− şi se datorează în mare măsură erorilor de cuantizare ale CAN şi CNA, şi mai puţin erorilor de cuantizare a parametrilor regulatorului.

75

Întregul sistem de control a fost proiectat în hardware şi constă din 3 entităţi: circuitul de control al CAN, circuitul de procesare de semnal şi circuitul de control al CNA. S-au folosit convertoare cu cost scăzut, cu interfaţă serială, ceea ce complică în oarecare măsură circuitele de interfaţare. Interfeţele seriale au fost proiectate în totalitate în hardware, fără a folosi vreun procesor soft. S-a proiectat câte un automat cu stări finit (FSM – Finite State Machine) pentru fiecare din cele 3 entităţi. Comunicaţia între ele este realizată cu ajutorul semnalelor de protocol (handshake) de tip ready/strobe. Această abordare este diferită de cea prezentată în [26], unde un FSM global controla fluxul de date între diferitele entităţi.

Toate elementele de logică secvenţială sunt sincrone, fiind pilotate de un semnal de tact de 25 MHz. Fiecare entitate rămâne în starea idle până când sunt disponibile date de procesat de la entitatea anterioară. Entitatea de control al CAN-ului este activată de un semnal Ts, corespunzător perioadei de eşantionare. Aceasta este obţinută tot din semnalul de tact de 25

MHz, prin divizare cu 242 , cu ajutorul a două numărătoare binare cascadate, unul pe 16 şi celălalt pe 8 biţi. Perioada de eşantionare este aşadar aproximativ 0,6711s, respectând restricţia (3.19).

Din schema Simulink cu blocuri System Generator din Fig. 3.12 s-a generat automat un modul Verilog, ce constituie centrul entităţii de procesare de semnal.

Conversia analog-numerică şi citirea datelor din CAN durează aproximativ 80 de cicli de tact, transmiterea datelor CNA durează aproximativ 40 de cicli de tact, iar calculele pentru următorul eşantion de ieşire se realizează într-un singur ciclu de tact. Folosind în paralel multiplicatoarele integrate în FPGA, ecuaţia (3.22) este calculată în mai puţin de 40ns. Acest lucru permite obţinerea de performanţe extraordinare pentru sistemele de control digitale, limitate doar de perioada de eşantionare (performanţele CAN-ului, CNA-ului).

Pentru experimente s-a folosit un motor de curent continuu de 24 V de tip Leybold Didactic 73411 Motor Generator Set, împreună cu amplificatoare Leybold Didactic 73413 Power Amplifier Block şi Leybold Didactic 73419 Gain and Offset Adjust Block.

În Fig. 3.13 este prezentată o comparaţie între rezultatele simulării regulatorului în Simulink şi rezultatele experimentale obţinute după implementarea în FPGA. Se observă caracteristica regulatorului deadbeat şi performanţe asemănătoare ale implementării cu cele aşteptate după simulare.

Implementarea în FPGA foloseşte 7 multiplicatoare în paralel şi doar 9% din resursele logice disponibile în dispozitivul Xilinx Spartan-3E XC3S500E.

Implementarea în FPGA a algoritmului de control deadbeat a fost publicată în lucrarea [105].

76

Figura 3.13. Comparaţie între rezultatele simulării şi cele experimentale.

3.4.3 Proiectarea, simularea şi implementarea pe FPGA a unui sistem de control al

vitezei pentru motorul de curent continuu fără perii

În această secţiune se va prezenta un studiu de caz original privind implementarea în

FPGA a unui sistem de control al vitezei pentru motorul fără perii de curent continuu (BLDC – Brushless Direct Current). Pe lângă un regulator de viteză de tip PI, s-au implementat şi o serie de module hardware pentru conducerea motorului şi determinarea vitezei acestuia.

Conducerea motorului BLDC Motoarele BLDC fac parte din categoria motoarelor sincrone: câmpul magnetic generat

de stator şi câmpul magnetic generat de rotor se rotesc cu aceeaşi frecvenţă. Din punct de vedere constructiv, motoarele BLDC se încadrează în categoria motoarelor cu magneţi permanenţi. Avem aşadar de a face cu un motor sincron cu magneţi permanenţi (PMSM – Permanent Magnet Synchronous Motor).

77

Un PMSM este constituit dintr-un rotor cu magnet permanent şi un stator electromagnetic. Datorită faptului că rotorul nu trebuie alimentat electric, se elimină periile ce ar trebui să transmită curentul electric rotorului.

În funcţie de cum sunt realizate înfăşurările statorului, tensiunea electromagnetică indusă (BEMF – Back Electromotive Force) poate prezenta o formă de undă sinusoidală sau trapezoidală. Motoarele a căror BEMF este sinusoidală sunt cunoscute în literatură ca motoare BLAC (Brushless Alternative Current), în vreme ce motoarele a căror BEMF este trapezoidală sunt cunoscute ca motoare BLDC. Adesea, pentru motoarele BLAC se foloseşte termenul PMSM, deşi acesta este mai general.

Motoarele BLDC pot fi construite în configuraţii monofazice, bifazice şi trifazice. Ultima categorie este cea mai răspândită în practică [106]. Formele de undă tipice pentru un motor BLDC trifazic sunt prezentate în Fig. 3.14. Aşa cum se poate observa, tensiunea electromagnetică indusă pe fiecare înfăşurare a motorului este constantă pentru 120° şi variază liniar cu unghiul rotorului înainte şi după porţiunea constantă. Pentru ca puterea de ieşire să fie constantă, fiecare înfăşurare trebuie alimentată pe durata în care tensiunea indusă este constantă [34].

Există mai multe topologii de circuite driver folosite în aplicaţiile cu motoare BLDC. Cele mai folosite sunt convertorul trifazic de tip Buck şi puntea invertoare trifazică [34]. O punte invertoare trifazică tipică pentru conducerea unui motor BLDC este prezentată în Fig. 3.15. Puntea este alcătuită din 6 comutatoare electronice. În practică se folosesc tranzistoare cu efect de câmp construite în tehnologie metal–oxid–semiconductor (MOSFET – Metal–Oxide–Semiconductor Field–Effect Transistor) sau tranzistoare bipolare cu baza izolată (IGBT – Insulated Gate Bipolar Transistor). Tranzistoarele MOSFET au pierderi de comutaţie mai mici decât tranzistoarele IGBT, dar au rezistenţă internă (şi deci putere disipată) mai mare în conducţie. Tranzistoarele IGBT se folosesc de obicei în aplicaţiile ce implică puteri sau tensiuni mari.

Spre deosebire de motoarele de curent continuu cu perii, la motoarele BLDC comutaţia curentului prin înfăşurări nerealizându-se automat prin comutare mecanică, trebuie realizată electronic. Pentru a roti motorul, înfăşurările statorului trebuie alimentate într-o anumită secvenţă.

Figura 3.14. Forme de undă tipice pentru un motor BLDC trifazic.

78

Figura 3.15. Punte invertoare trifazică pentru conducerea unui motor BLDC.

Aşa cum s-a menţionat în paragraful anterior, fiecare fază (înfăşurare) este alimentată pe

durata celor 120° cât tensiunea indusă este constantă. Aşa cum se poate constata din Fig. 3.14, apare necesitatea unei comutaţii la fiecare 60°. Sistemul de control trebuie aşadar să dispună de informaţii cu privire la poziţia rotorului pentru a alimenta corect înfăşurările. Există două posibilităţi de a obţine aceste informaţii: citirea poziţiei rotorului cu ajutorul unor senzori cu efect Hall şi estimarea poziţiei rotorului în funcţie de trecerea prin zero a tensiunii induse. Prima metodă este mai uşor de implementat folosind doar circuite digitale, dar a doua metodă implică costuri mai scăzute, deoarece, eliminându-se necesitatea senzorilor, construcţia motorului este mai simplă.

De obicei, motorul BLDC este echipat cu 3 senzori cu efect Hall ce oferă o informaţie codificată pe 3 biţi despre poziţia rotorului la un moment dat. Pe baza acestor coduri, înfăşurările corespunzătoare sunt alimentate, controlându-se starea comutatoarelor punţii invertoare.

Tabelul 3.4 prezintă corespondenţa tipică între codurile citite de la senzorii cu efect Hall, direcţia curentului prin înfăşurări şi starea comutatoarelor pentru o rotire în direcţia acelor de ceasornic a motorului BLDC. Comutatoarele sunt identificate conform notaţiilor din Fig. 3.15. Pentru a controla viteza motorului BLDC, tensiunea aplicată înfăşurărilor trebuie variată. Variaţia tensiunii medii poate fi obţinută uşor folosind doar circuite digitale prin variaţia factorului de umplere al unui semnal dreptunghiular periodic de perioadă constantă, tehnică cunoscută sub denumirea de modulaţie în lăţimea impulsurilor (PWM – Pulse Width Modulation). De obicei semnalul PWM este injectat comutatoarelor de pe ramura de jos.

Tabelul 3.4. Secvenţa de comutaţie pentru rotirea motorului BLDC.

Intrări de la senzorii Hall Comutatoare activate Direcţia curentului prin înfăşurare1 2 3 Ramura de sus Ramura de jos A B C 1 0 0 Q1 Q4 DC+ DC- OFF 1 1 0 Q1 Q6 DC+ OFF DC- 0 1 0 Q3 Q6 OFF DC+ DC- 0 1 1 Q3 Q2 DC- DC+ OFF 0 0 1 Q5 Q2 DC- OFF DC+ 1 0 1 Q5 Q4 OFF DC- DC+

79

Controlul vitezei necesită cunoaşterea vitezei motorului la un moment dat. Semnalele provenite de la senzorii Hall pot fi folosite pentru a determina viteza motorului, dar rezoluţia este destul de redusă, având în vedere că unei rotaţii complete a motorului îi corespund doar 6 sau 12 coduri (în funcţie de numărul perechilor de poli magnetici ai rotorului). De obicei, motoarele sunt echipate cu un traductor de viteză (tahometru) cu rezoluţie mai mare. Acesta poate fi un tahogenerator, ce oferă la ieşire o tensiune proporţională cu viteza de rotaţie, sau un tahometru optic, ce furnizează la ieşire două semnale digitale codificate în cuadratură (QEP – Quadrature Encoded Pulses). Acest tip de traductor este preferat în proiectarea sistemelor de control numerice, deoarece oferă direct o interfaţă digitală. Semnalele QEP pot oferi informaţii atât despre direcţia de rotaţie, cât şi despre viteza de rotaţie. În plus, rezoluţia este mult mai înaltă decât dacă se folosesc semnalele provenite de la senzorii Hall.

Proiectarea sistemului de control şi implementarea în FPGA Din informaţiile prezentate în secţiunea precedentă se poate contura o schemă bloc a

sistemului de control. Sistemul este total digital şi se interfaţează cu motorul BLDC prin intermediul unei punţi invertoare trifazice de tipul celei din Fig. 3.15, a trei senzori Hall şi a unui tahometru optic cu ieşiri QEP. Regulatorul de viteză este de tip proporţional-integrator (PI) discret, acest tip de regulator având o utilizare de tradiţie în controlul motoarelor.

Fig. 3.16 prezintă schema bloc a sistemului de control al vitezei. Sistemul de control a fost proiectat pentru a fi implementat direct în hardware pe un

dispozitiv FPGA Spartan-3E. Sistemul este sincron, pilotat de un semnal de tact de 50MHz. Modulele logice au fost implementate prin captură de schemă, cu excepţia regulatorului PI, ce a fost implementat şi simulat în mediul Simulink, folosind software-ul Xilinx System Generator.

În continuare, fiecare din blocurile din schema din Fig. 3.16 este prezentat din punctul de vedere al implementării.

Figura 3.16. Schema bloc a sistemului de control al vitezei pentru motorul BLDC.

80

Logica de detecţie a schimbării Modulul de detecţie a schimbării semnalizează printr-un semnal activat pe durata unui

singur ciclu de tact modificarea codului generat de cei 3 senzori Hall. Pentru a realiza acest lucru modulul compară tot timpul starea curentă a ieşirilor senzorilor cu starea din ciclul de tact anterior, salvată într-o serie de bistabili de tip D.

Pentru eliminarea totală a hazardului, intrările sunt sincronizate cu semnalul de tact, prin memorarea într-o altă serie de bistabili de tip D. În acest fel se evită situaţiile când schimbarea codului de intrare apare cu câteva ns înaintea frontului crescător al semnalului de tact, iar timpul de propagare prin celulele logice este mai lung decât timpul de set-up necesar pentru funcţionarea corectă a bistabililor.

Dezavantajul faptului că sesizarea unei schimbări este întârziată cu cel mult o perioadă de tact este minor în comparaţie cu câştigul obţinut prin eliminarea hazardului. De altfel, o astfel de întârziere în preluarea unei modificări la intrare este comună perifericelor de sisteme încorporate (microcontrolere, procesoare DSC (Digital Signal Controller)).

Structura modulului de detecţie a schimbării este prezentată în Fig. 3.17. Cu DFF s-au notat bistabilii de tip D. Nu s-a mai figurat semnalul de tact, deoarece toţi

bistabilii sunt conectaţi la acelaşi semnal. Porţile SAU EXCLUSIV şi poarta SAU formează comparatorul care semnalează la ieşire modificarea poziţiei. Deoarece al doilea grup de bistabili nu face decât să copie valoarea din primul grup cu o întârziere de exact un ciclu de tact, semnalul New_pos_tick este activat pentru exact o perioadă de tact.

Figura 3.17. Modulul de detecţie a schimbării poziţiei rotorului.

81

Logica de comutaţie Pe baza Tabelului 3.4 s-a proiectat modulul ce implementează generarea secvenţei de

comutaţie. Pe lângă intrările provenite de la senzorii Hall s-a adăugat o intrare de validare folosită pentru a insera un timp mort între comutările a două tranzistoare de pe aceeaşi parte (partea de sus sau partea de jos) a punţii.

Logica de comutaţie are la ieşire 6 semnale, fiecare semnal reprezentând starea unuia din cele 6 tranzistoare ale punţii.

Logica de comutaţie este implementată prin 6 celule de memorie ROM de 16 biţi fiecare. Codul furnizat de senzorii Hall şi intrarea de validare reprezintă adresa pentru memoriile ROM. Conţinutul fiecărei memorii ROM reprezintă starea tranzistorului corespunzător pentru fiecare combinaţie posibilă de intrare. Conţinutul celulelor de memorie ROM este prezentat în Tabelul 3.5. Ordinea biţilor de adrese este (de la LSB spre MSB): HALL_1, HALL_2, HALL_3, VALID. Intrarea de validare este activă pe nivel jos.

Tabelul 3.5. Conţinutul celulelor de memorie ROM.

Celula ROM Valoarea păstrată ROM_Q1 0x080A ROM_Q2 0x1050 ROM_Q3 0x4044 ROM_Q4 0x0222 ROM_Q5 0x2030 ROM_Q6 0x040C

Trebuie observat că ieşirea corespunzătoare unui tranzistor nu este activă doar în cazul în

care intrarea VALID este activă (0 logic), ci şi în cazul în care se trece dintr-o stare în care tranzistorul respectiv era saturat într-o altă stare în care tranzistorul rămâne la fel. În acest caz, intrarea VALID este dezactivată pentru a se introduce timpul mort, dar acest timp mort se referă la tranzistorul ce comută, nu la cel ce-şi păstrează starea.

Logica de generare a timpului mort La comutarea alimentării de pe o înfăşurare a statorului pe alta trebuie inserat un timp

mort între comutările a două tranzistoare de pe aceeaşi parte (partea de sus sau partea de jos) a punţii. Acest timp mort introduce o aşteptare între comanda de blocare a unui tranzistor şi comanda de saturare a celuilalt, prevenind în acest fel apariţia unui supracurent datorat unui moment de timp în care ambele tranzistoare ar fi în conducţie. Timpul mort trebuie să acopere timpul de comutaţie al tranzistoarelor folosite. Pentru dispozitivele folosite în experimente a fost necesară inserţia unui timp mort de cel puţin 0.5μs.

Modulul de generare a timpului mort constă dintr-un numărător pe 8 biţi şi un bistabil de tip D, ambele cu reset sincron, şi ambele fiind resetate de o schimbare a stării senzorilor Hall. Începând cu acest eveniment, numărătorul se incrementează la fiecare ciclu de tact. Ieşirile

82

numărătorului sunt decodate şi o anumită combinaţie permite încărcarea bistabilului cu 1. În acest fel, ieşirea bistabilului este 0 pentru o durată de timp exactă, dată de numărul de stări ale numărătorului de la 0 până când se atinge valoarea decodificată şi de durata ciclului de tact.

În cazul sistemului proiectat, la decodificare s-a folosit doar bitul 5 al ieşirii numărătorului, timpul mort fiind astfel dat de:

snsDT μ64.02025 =⋅= . (3.23)

Logica de generare a semnalului PWM Modulul de generare a semnalului PWM constă dintr-un numărător pe 16 biţi, un bistabil

de tip D, ambele cu reset sincron, şi 2 comparatoare de egalitate. Ambele comparatoare au una din intrări conectată la ieşirea numărătorului. Acesta este pilotat de semnalul de tact global de 50MHz.

Perioada semnalului PWM este stabilită de valoarea constantă (per_val) setată la a doua intrare a primului comparator. Când comparatorul detectează că numărătorul a ajuns la valoarea stabilită, ieşirea lui va reseta numărătorul şi bistabilul. Factorul de umplere al semnalului PWM este dat de a doua intrare a celui de-al doilea comparator (dc_val). Aceasta trebuie să fie mai mică decât per_val. Când se detectează egalitatea între ieşirea numărătorului şi valoarea dc_val, bistabilul este setat. În acest fel, ieşirea negată a bistabilului este activă (1 logic) pentru o perioadă limitată de timp, dată de:

nsvaldcvalpertimeDC 20)__(_ ⋅−= . (3.24)

În cazul în care per_val şi dc_val sunt egale, comportarea corectă a circuitului este asigurată de prioritatea intrării de reset faţă de cea de setare a bistabilului. Pentru cazul în care intrarea dc_val este 0, s-a adăugat un detector al acestei situaţii (o poartă SAU între biţii intrării), un bistabil pentru sincronizarea detecţiei cazului cu perioada semnalului PWM şi o poartă ŞI între ieşirea acestui bistabil şi ieşirea negată a primului bistabil. Astfel, ieşirea este forţată în 0 de la începutul unei perioade în care intrarea dc_val este 0.

Pentru partea experimentală s-a obţinut o perioadă a semnalului PWM de 24,426kHz prin alegerea valorii 2046 pentru per_val:

snsvalperPERPWM μ94.4020)1_(_ =⋅+= . (3.25)

Logica de estimare a vitezei Schema bloc a circuitului de estimare a vitezei este prezentată în Fig. 3.18. Pentru o

rezoluţie mai bună a măsurării vitezei, atât fronturile crescătoare, cât şi cele căzătoare ale ambelor semnale QEP sunt contorizate. Se utilizează câte un circuit de detecţie pentru fiecare front. Acest circuit este un automat cu stări finit de tip Mealy, foarte simplu, implementat cu un singur bistabil, ca în [80]. Ieşirea fiecărui circuit de detecţie a frontului se activează când intrarea monitorizată şi conţinutul bistabilului, care este de fapt valoarea intrării din ciclul de tact

83

anterior, respectă secvenţa dorită (0-1 sau 1-0). Ieşirea circuitului de detecţie a frontului este activă exact un ciclu de tact. Toate ieşirile sunt trecute printr-o poartă SAU a cărei ieşire constituie intrarea de validare a tactului pentru un numărător. În acest fel, fronturile semnalelor QEP sunt contorizate prin incrementarea numărătorului la fiecare impuls de detecţie de front.

Deoarece semnalele QEP provin de la o sursă externă nesincronizată, frontul semnalului QEP ar putea apare foarte aproape de frontul crescător al semnalului de tact al elementelor sincrone. Frontul semnalului QEP ar fi în acest caz detectat (ieşirea automatului de detecţie a frontului se activează, automatul fiind de tip Mealy), dar timpul de propagare al ieşirii (prin poarta SAU) ar putea fi mai lung decât diferenţa în timp între frontul semnalului QEP şi frontul crescător al semnalului de tact. Acest hazard ar putea duce la “ratarea” incrementării numărătorului din când în când, în mod aleator, chiar dacă circuitul de detecţie a frontului funcţionează corect. Pentru a contracara această problemă s-au introdus bistabili de tip D pe semnalele QEP, sincronizându-le cu semnalul de tact.

Astfel, toate semnalele din schemă sunt sincrone cu un singur semnal de tact, eliminându-se hazardul şi uşurându-se analiza de temporizare a sistemului. Semnalul de tact este generat în FPGA de la un oscilator cu cuarţ de 50MHz. Faptul că toate circuitele folosesc acelaşi semnal de tact reprezintă un avantaj pentru proiectarea în FPGA, deoarece structura internă a dispozitivului prevede resurse speciale de rutare globală pentru semnalul de tact, asigurându-se cea mai mică asimetrie (clock skew) posibilă a semnalului de tact [5]. Pentru ca aceste resurse să fie alocate la implementare, este necesar ca proiectarea să fi fost făcută corect.

Figura 3.18. Modulul de estimare a vitezei motorului.

84

Conţinutul numărătorului este salvat într-un registru la fiecare perioadă de eşantionare. Perioada de eşantionare este obţinută prin divizarea semnalului de tact. Pentru o perioadă de tact

nsTclock 20= (3.26)

şi o perioadă de eşantionare dorită

msTs 1= , (3.27)

rata de divizare este

0xC35050000/_ === clocks TTCONSTDIV . (3.28)

Divizorul de tact e implementat printr-un numărător binar pe 16 biţi, pilotat de semnalul de tact de 50MHz. Când ieşirea numărătorului atinge o anumită combinaţie, dată de (3.28) şi detectată de un comparator de egalitate, numărătorul este resetat şi se generează un impuls TS de o perioadă de tact ce semnalizează celorlalte elemente din sistem începutul unei noi perioade de eşantionare.

După salvarea în registru a valorii ce corespunde numărului de impulsuri QEP, numărătorul acestor impulsuri trebuie resetat. Acest lucru se realizează cu o întârziere de o perioadă de tact faţă de impulsul TS ce salvează valoarea, întârziere implementată cu un bistabil de tip D ca în Fig. 3.18.

Funcţionarea circuitului de estimare a vitezei este prezentată în Fig. 3.19. Formele de undă au fost capturate folosind analizorul logic virtual ChipScope ILA (Integrated Logic Analyzer) şi modulul de comunicaţie şi control ChipScope ICON (Integrated Controller), disponibile ca nuclee IP, produse de Xilinx [107]. Acestea au fost instanţiate în schemă şi conectate la semnalele ce trebuie monitorizate. Semnalele capturate au fost vizualizate şi analizate pe un calculator gazdă folosind utilitarul ChipScope Pro Analyzer, produs tot de Xilinx.

În Fig. 3.19 se observă cele 2 semnale QEP provenind de la tahometru în funcţionarea reală. De asemenea se observă că fiecare front pe fiecare semnal QEP este detectat şi produce o incrementare a numărătorului de impulsuri QEP. La expirarea perioadei de eşantionare, semnalizată de un impuls pe linia TS_tick, numărătorul este resetat după ce valoarea a fost salvată într-un alt registru, al cărui conţinut poate fi observat pe linia CNTR_ms.

Figura 3.19. Semnalele circuitului de estimare a vitezei.

85

Regulatorul PI discret Pentru motorul folosit la partea experimentală, coeficienţii regulatorului PI s-au ales ca:

0.531_ =IK , (3.29)

004.01_ =PK . (3.30)

Aceste valori asigură un regim tranzitoriu de aproximativ 20ms şi o suprareglare minimă. Plecând de la aceste valori şi ţinând cont că unul din principiile fundamentale ale adecvării arhitecturii algoritmului pentru implementarea directă în hardware este simplificarea computaţională [24], se calculează constantele ce vor fi folosite în implementare.

Astfel, ţinându-se cont de faptul că ieşirea regulatorului nu reprezintă direct valoarea tensiunii de comandă a motorului, ci intrarea în circuitul PWM, acesta din urmă se modelează ca o amplificare în serie cu regulatorul, cu factorul de amplificare dat de:

12 −= w

sPWM

UA , (3.31)

unde sU este tensiunea de alimentare a motorului şi w este lăţimea cuvântului (numărul de biţi)

circuitului de generare a semnalului PWM. În cazul particular al echipamentului folosit tensiunea de alimentare nominală este de 19.1V. Circuitul PWM lucrează pe 11 biţi, deci

20471.19

=PWMA . (3.32)

De asemenea, ţinând cont de faptul că circuitul de estimare a vitezei nu raportează viteza motorului în RPM, ci numărul de fronturi ale semnalelor QEP contorizate într-o ms, şi acest lucru trebuie modelat ca o amplificare pe calea directă, cu factorul de amplificare:

1000*60_CPRA estspeed = , (3.33)

unde CPR este numărul de fronturi QEP generate de o rotaţie completă a motorului, iar numitorul provine din raportarea vitezei nu la minut (ca RPM), ci la ms, deoarece astfel se face măsurarea.

Motorul folosit este echipat cu un tahometru optic cu 500 de linii, deci

20004*500 ==CPR , (3.34)

ceea ce implică:

301

_ =estspeedA . (3.35)

Pentru a elimina efectul acestor amplificări pe calea directă, acestea sunt contrabalansate direct în factorii de amplificare ai regulatorului PI. Acest lucru simplifică mult calculele, nefiind

86

necesară obţinerea valorii vitezei, apoi aplicarea algoritmului de reglare, şi apoi calculul valorii de intrare în circuitul PWM.

Factorii regulatorului PI obţinuţi prin simplificarea computaţională sunt:

003.1704_

1_ ==estspeedPWM

II AA

KK , (3.36)

8604.12_

1_ ==estspeedPWM

PP AA

KK . (3.37)

Pentru implementarea regulatorului trebuie determinată o relaţie de calcul a ieşirii în funcţie de intrare, la fiecare perioadă de eşantionare.

Pornind de la reprezentarea în domeniul s a regulatorului PI:

sKK

sEsUsG I

pR +==)()()( , (3.38)

unde U(s) este ieşirea de comandă, iar E(s) este intrarea regulatorului (eroarea), şi folosind transformarea biliniară:

112

+−

=zz

Ts

s, (3.39)

se ajunge la funcţia de transfer discretă în domeniul z:

11

2)()()(

+−

+==zzTK

KzEzUzG sI

pR . (3.40)

Exprimând (3.40) în 1−z rezultă:

1

1

1

1

1

)2

()2

(

)()(

−

−

−

−

−

−++=

z

zKTK

KTK

zEzU P

sIP

sI

. (3.41)

Revenind în domeniul timp, se obţine o relaţie de calcul pentru u[k]:

]1[][)2

(][)2

(][ −+−++= kukKTK

kKTK

ku PsI

PsI εε . (3.42)

Se observă că (3.42) descrie un sistem numeric cu răspuns infinit la impuls (valoarea anterioară a ieşirii intervine în calculul valorii curente).

Regulatorul s-a implementat în Simulink, folosind blocuri System Generator. Acest lucru a permis simularea împreună cu un model în virgulă mobilă, dublă precizie, şi evaluarea erorilor introduse de procesul de cuantizare.

Pentru reprezentarea coeficienţilor regulatorului s-au folosit cuvinte de 18 biţi, cu poziţia virgulei aleasă astfel încât să permită o precizie cât mai bună ţinând cont de magnitudinea numerelor. S-au ales 18 biţi pentru a profita de precizia multiplicatoarelor dedicate în FPGA. Pentru circuitul de sumare nu s-au introdus limitări de reprezentare, lucrându-se pe 27 de biţi şi neintroducându-se niciun fel de erori. Singura limitare este impusă pentru reacţie, reintroducerea

87

în calcul a valorii anterioare a ieşirii folosind 24 de biţi. Precizia calculelor s-a dovedit foarte bună, erorile de cuantizare fiind datorate nu coeficienţilor, ci reprezentărilor intrării (pe 9 biţi, deoarece nu se contorizează mai mult de 256 de fronturi QEP într-o ms) şi ieşirii (pe 11 biţi fără semn, datorită implementării circuitului PWM). Limitările de format s-au făcut cu saturaţie la detecţia depăşirii.

Fig. 3.20 prezintă implementarea în Simulink a regulatorului. Intrarea în regulator este eroarea de viteză, calculată numeric ca diferenţa între o valoare

de referinţă şi ieşirea modulului de estimare a vitezei. Din această cauză nu este necesară interpretarea intrării ca un număr în virgulă fixă pentru simplificarea calculelor, ca în [22], acestea fiind deja optimizate.

Simularea şi integrarea sistemului Modulele sistemului proiectat au fost simulate folosind Simulink. Regulatorul PI, fiind

proiectat direct în Simulink, a fost simulat împreună cu un model al motorului BLDC şi cu un model al regulatorului în virgulă mobilă, dublă precizie. S-a putut astfel observa magnitudinea erorii introduse de procesul de cuantizare în implementarea în virgulă fixă a regulatorului.

Modulele proiectate prin captură de schemă logică au fost co-simulate folosind Simulink şi ModelSim. S-au folosit facilităţile oferite de System Generator, instanţiindu-se fiecare modul în câte un Black Box. Fig. 3.21 prezintă schema Simulink folosită la simularea modulelor de detecţie a schimbării, de comutaţie, de generare a timpului mort şi de validare a ieşirii.

Figura 3.20. Implementarea în Simulink a regulatorului PI discret.

88

Figura 3.21. Schema bloc pentru co-simularea Simulink-HDL a modulelor logice.

89

Figura 3.22. Captură din ModelSim în urma co-simulării.

Fig. 3.22 prezintă o captură din ModelSim a semnalelor rezultate în urma co-simulării. Se

observă semnalele in_hall_1, in_hall_2 şi in_hall_3, generate de modelul Simulink al motorului. Semnalele hall_1_reg, hall_2_reg şi hall_3_reg sunt semnalele Hall de intrare sincronizate cu semnalul de tact, deci întârziate cu o perioadă de tact. Se observă pulsul de 1 perioadă de tact pe linia new_pos_tick, la observarea unui nou cod pe intrările Hall. Acest puls activează circuitul de generare a timpului mort, a cărui ieşire este semnalul dead_time_valid. Se observă de asemenea semnalele de activare a tranzistoarelor punţii de comandă şi întârzierea dintre dezactivarea unuia şi activarea următorului, introdusă de circuitul de generare a timpului mort. Întârzierea, măsurată între cele 2 cursoare în Fig. 3.22, este de exact 0,64μs, ca şi valoarea teoretică din (3.23).

Deşi avantajele co-simulării Simulink-ModelSim sunt certe, oferind posibilitatea validării modulelor cu generare automată a secvenţelor de intrare probabile şi în realitate, metoda este destul de consumatoare de timp şi resurse (necesită un calculator gazdă cu mare putere de calcul).

Din această cauză se preferă adesea o depanare a sistemului în funcţionarea reală, folosind faptul că dispozitivul FPGA poate constitui el însuşi o parte a uneltei de depanare. Astfel, prin folosirea analizorului logic virtual ChipScope ILA şi a utilitarului ChipScope Pro Analyzer [107], se pot observa semnalele interne ale sistemului. Analizorul logic se implementează în partea nefolosită a dispozitivului FPGA şi permite capturarea de eşantioane de semnale interne începând cu un anumit moment de timp. Semnalul de strobare (tactul analizorului) este stabilit la implementarea analizorului, iar condiţia de începere a capturii este

90

stabilită la rulare prin interfaţa de pe calculatorul gazdă. În acest mod se poate face o depanare eficientă a sistemului proiectat.

De exemplu, Fig. 3.23 prezintă o captură a funcţionării sistemului realizată cu o perioadă de strobare de 10μs. Se observă modificarea semnalelor de la senzorii Hall şi modificarea corespunzătoare a semnalelor de validare a tranzistoarelor punţii de comandă a motorului (semnalele sunt active pe nivel 1 logic). Datorită alegerii perioadei de strobare lungi, în Fig. 3.23 nu se poate observa timpul mort inserat la comutarea tranzistoarelor. Acesta însă a fost verificat folosind o perioadă de strobare mai mică.

Este posibilă exportarea datelor din ChipScope Pro Analyzer în format ASCII şi importarea lor în Matlab ca şi vectori. În acest fel, se pot analiza datele capturate de pe sistemul hardware rulând în timp real pe FPGA. De exemplu, Fig. 3.24 prezintă un grafic, obţinut în Matlab, ce reprezintă variaţia comenzii factorului de umplere (cu albastru) şi viteza observată de sistem (în fronturi ale semnalelor QEP pe ms) la modificarea referinţei de viteză de la 50 la 100 (corespunzător în RPM: de la 1500RPM la 3000RPM).

Figura 3.23. Comanda tranzistoarelor punţii în funcţie de poziţia rotorului.

Figura 3.24. Variaţia semnalului de comandă şi a vitezei la modificarea treaptă a referinţei.

91

Pentru experimente s-a folosit un motor de 19.1V de tipul Pittman 3411, produs de Ametek, şi un circuit de comandă a motorului (punte invertoare trifazată) PM50v3.1, produs de Technosoft.

Sistemul de control pentru motorul BLDC prezentat aici diferă de cel prezentat în [108] prin faptul că logica de comutaţie este implementată foarte eficient, prin celule de memorie ROM, nu prin automate cu stări.

Metoda de validare prin co-simulare Simulink/ModelSim a mai fost folosită în literatură [32], dar metoda de proiectare în Simulink a regulatorului şi apoi integrarea acestuia într-un proiect mai mare realizat prin captură de schemă este originală.

Sistemul de control pentru BLDC a fost publicat în forma prezentată aici în [109]. O formă îmbunătăţită prin reproiectarea regulatorului PI după paradigma automat cu cale de date [80] a fost publicată în [110]. În [111] a fost publicată metoda de analizare a caracteristicilor dinamice ale motorului folosind ChipScope. Metoda este aplicabilă analizei oricăror procese rapide interfaţate prin semnale digitale, folosind analizoare logice virtuale implementate în FPGA.

3.5 Concluzii În prima secţiune a acestui capitol s-a făcut o trecere în revistă a uneltelor de dezvoltare

disponibile pentru proiectare în vederea implementării în circuite FPGA. S-au discutat nucleele IP ca module refolosibile, precum şi uneltele de dezvoltare pentru sisteme încorporate şi pentru nuclee DSP. Trecerea în revistă este destul de sumară, având rolul de a da cititorului o idee despre complexitatea sistemelor ce se pot implementa într-un dispozitiv FPGA şi despre gradul de abstractizare la care se poate face proiectarea pentru FPGA.

În continuare, în a doua secţiune, este prezentat ceva mai detaliat software-ul System Generator, produs de Xilinx, ce permite proiectarea de hardware implementabil în FPGA direct din mediul Matlab Simulink. Prezentarea este o sinteză din sute de pagini de documentaţie [83], [84], [85]. Nu are pretenţia unei prezentări exhaustive, ci insistă pe acele biblioteci ce au aplicabilitate în cazul proiectării de structuri hardware pentru control automat. Tot în această secţiune s-a prezentat modalitatea de co-simulare Simulink-HDL a unui modul proiectat prin alte metode decât folosind System Generator (captură de schemă logică sau descriere HDL). Deşi co-simularea este destul de dificilă deoarece trebuie făcută cu un pas foarte fin, deci necesită putere de calcul mare şi implică un timp lung de simulare, avantajele sunt semnificative: vectorii de test sunt generaţi automat de către Simulink; simulatorul HDL poate afişa semnalele interne ale modulului simulat, deci acesta se poate verifica amănunţit; sistemul ca întreg format din partea proiectată în Simulink cu blocuri System Generator şi partea proiectată prin alte metode poate fi validat într-un mod unitar.

Cea de-a treia secţiune reprezintă o scurtă trecere în revistă a uneltelor de depanare pentru sistemele proiectate în FPGA. Din nou, această trecere în revistă are rolul de a evidenţia

92

interesul acordat de producătorii de echipamente de testare dispozitivelor FPGA, precum şi avantajele oferite de aceste dispozitive faţă de alte alternative, ca microcontrolerele sau DSC-urile. Astfel, trebuie neapărat subliniat faptul că dispozitivul FPGA poate constitui el însuşi o platformă pentru depanare, datorită reconfigurabilităţii sale: semnalele interne pot fi rutate la pini nefolosiţi şi urmărite din exterior; în resursele din FPGA rămase nefolosite de aplicaţie se poate implementa un analizor logic “virtual” care să captureze eşantioane ale semnalelor interne; acestea pot fi apoi descărcate şi vizualizate/analizate pe un calculator gazdă sau pe un alt echipament de laborator.

În cea de-a patra secţiune a capitolului sunt prezentate trei studii de caz originale: trei sisteme de control automat implementate în FPGA:

• Un sistem de control al vitezei motorului de curent continuu folosind bucla PLL; sistemul implementat în FPGA constă dintr-un detector de fază şi frecvenţă de concepţie originală, dintr-un filtru de buclă de tip PI şi dintr-un circuit de generare de semnal PWM; sistemul a fost proiectat prin captură de schemă logică şi validat prin simulare în ModelSim, apoi verificat experimental.

• Un sistem de reglare a vitezei motorului de curent continuu bazat pe algoritmul deadbeat; s-au implementat în FPGA module de control pentru CAN şi CNA cu interfeţe seriale, proiectate la nivel de schemă logică; algoritmul deadbeat a fost proiectat ca un filtru IIR, în Simulink, folosind System Generator, şi validat prin simulare; sistemul a fost apoi integrat şi verificat experimental, obţinându-se aceeaşi comportare ca la simulare.

• Un sistem de reglare a vitezei pentru motorul BLDC. Partea de conducere a motorului a fost proiectată prin captură de schemă logică. Algoritmul de control, de tip PI, a fost proiectat în Simulink cu System Generator. Întreg sistemul a fost verificat prin simulare în Simulink, importându-se blocurile proiectate prin schemă şi folosind ModelSim pentru co-simulare Simulink-HDL. Sistemul a fost verificat experimental, folosind analizorul logic “virtual” ChipScope pentru capturarea şi vizualizarea semnalelor interne.

Aşadar, pe lângă contribuţiile teoretice legate de sistematizarea unor informaţii vaste despre unelte de proiectare pentru FPGA, acest capitol prezintă importante contribuţii aplicative ce ilustrează utilizarea acestora. Merită subliniat că toate aplicaţiile prezentate au fost realizate fizic şi verificate experimental, rezultatele obţinute fiind în concordanţă cu simulările din stadiul de validare. Deşi aplicaţiile prezentate nu reprezintă cu adevărat o provocare pentru puterea de calcul ce se poate obţine folosind dispozitivele FPGA, datorită dinamicii destul de lente a părţii fixate, ele au constituit un pas esenţial în familiarizarea autorului cu uneltele specifice şi caracteristicile dispozitivului FPGA în vederea atingerii obiectivului propus al tezei. De asemenea, au reprezentat pretexte pentru a experimenta cu diferite unelte, în vederea elaborării ulterioare a unei metodologii de lucru.

Originalitatea şi actualitatea sistemelor de control prezentate în acest capitol au condus redactarea şi publicarea a 6 lucrări: [102], [103], [105], [109], [110], [111].

93

4. Proiectarea sistemelor cu procesoare soft încorporate în FPGA Un atu al dispozitivelor FPGA este faptul că oferă suficiente resurse pentru

implementarea de procesoare soft în interiorul dispozitivului FPGA. Prin procesor soft se înţelege un procesor realizat folosind resursele generale ale unui dispozitiv programabil, spre deosebire de procesoarele hard, implementate ca nuclee hardware specifice şi ne-reconfigurabile. Aşa cum s-a menţionat şi în Secţiunea 3.1.2, atât producătorii de FPGA-uri, cât şi firme specializate în dezvoltarea de unelte de proiectare oferă procesoare optimizate pentru implementarea în FPGA, împreună cu suportul software necesar pentru programarea respectivelor procesoare. Exemple de procesoare proiectate special pentru implementare optimă în FPGA sunt: PicoBlaze şi MicroBlaze de la Xilinx, Nios şi Nios II de la Altera, ZPU de la Zylin AS, Mico32 de la Lattice; există şi nuclee IP (Intellectual Property) ce implementează procesoare derivate din cele clasice în FPGA, ca TSK80 bazat pe Z80, TSK51 bazat pe Intel 8051, TSK3000A bazat pe MIPS R3000, toate de la Altium; LEON 3 bazat pe Sparc V8, de la Aeroflex Gaisler, Cortex-M1 de la ARM, compatibil cu ARM7, ARM9, ARM11.

În vreme ce folosirea dispozitivelor FPGA pentru implementarea în hardware a algoritmilor este evident cea mai avantajoasă utilizare a resurselor, cu rezultatele cele mai bune din punctul de vedere al timpului de calcul, există aplicaţii în care utilizarea unui procesor este preferabilă. Deşi procesorul ocupă în general mai multe resurse decât un automat proiectat special pentru o aplicaţie, iar timpul de execuţie al unei secvenţe de instrucţiuni este în mod sigur mai lung decât secvenţierea operaţiilor pe o structură hardware dedicată, procesorul oferă avantajul unui flux de proiectare cunoscut, pe o platformă verificată. În plus, în unele aplicaţii timpul de procesare nu este critic. Timpul de dezvoltare a unei aplicaţii software pe o platformă cunoscută poate fi mult mai scurt decât timpul necesar proiectării unei părţi de execuţie şi a unei părţi de control implementate în hardware.

O altă nişă a sistemelor cu procesor implementate pe FPGA o constituie integrarea pe acelaşi FPGA a unui sistem ce înainte era constituit dintr-un procesor şi un dispozitiv logic programabil: datorită creşterii capabilităţilor dispozitivelor FPGA, astfel de sisteme pot fi integrate pe un singur cip, fără a fi necesare modificări majore ale software-ului.

În prima parte a acestui capitol vor fi expuse câteva consideraţii teoretice cu privire la proiectarea de procesoare soft în vederea implementării pe dispozitive de tip FPGA, subliniindu-se modul în care proiectarea trebuie să ţină cont de arhitectura specifică a FPGA-ului, destul de diferită de cea a unui ASIC (Application Specific Integrated Circuit). În al doilea subcapitol va fi prezentat pe scurt procesorul soft PicoBlaze, proiectat de firma Xilinx şi optimizat pentru FPGA-urile produse de ea, împreună cu uneltele de dezvoltare şi verificare. În final va fi prezentat studiul de caz al implementării pe microprocesoare PicoBlaze a unor aplicaţii de monitorizare într-un sistem de control implementat pe FPGA, necritice din punct de vedere al timpului de execuţie, deci pretabile la implementare prin software.

94

4.1 Consideraţii privind proiectarea de procesoare soft pentru FPGA Până spre sfârşitul anilor 1990, procesoarele soft implementate în dispozitive FPGA

prezentau interes doar în mediul academic datorită costurilor ridicate şi performanţelor scăzute: un procesor soft ocupa cam în totalitate resursele unui FPGA al acelei epoci, pe când un procesor obişnuit era mai ieftin, mai rapid şi deja proiectat.

În ziua de astăzi, un procesor soft poate ocupa mai puţin de 1% din resursele unui FPGA şi poate oferi performanţe de peste 200 DMIPS (Dhrystone Million Instructions per Second) [112]. De fapt, procesoarele soft ocupă atât de puţine resurse, încât de obicei pot fi implementate în resursele nefolosite de aplicaţia principală din FPGA, ceea ce înseamnă că practic costul lor este nul.

Eficienţa procesoarelor soft este socotită ca fiind raportul dintre performanţele oferite şi resursele ocupate. Resursele ocupate sunt diferite într-un FPGA faţă de un ASIC. Arhitectura unui FPGA se bazează pe elemente logice (LE – Logic Element) sau felii (slices), ce conţin de obicei o tabelă de căutare (LUT – Look-Up Table) implementată prin memorie RAM (Random Access Memory) şi un bistabil. Astfel, costul unui circuit implementat în FPGA se exprimă ca fiind numărul de elemente logice ocupate, pe când costul implementării unui circuit într-un ASIC se exprimă prin numărul de porţi ŞI-NU cu 2 intrări necesare. Se poate totuşi face o comparaţie între cele 2 tipuri de implementări prin convertirea elementului logic şi a porţii ŞI-NU cu 2 intrări în suprafaţa ocupată pe siliciu.

4.1.1 Procesoare configurabile

Atât procesoarele implementate în FPGA, cât şi cele implementate în ASIC, oferă

proiectanţilor posibilitatea de a configura procesorul la momentul generării structurii sale hardware. Se poate astfel alege modul de implementare a benzii de asamblare (pipeline), dimensiunea memoriei intermediare (cache), implementarea circuitelor de înmulţire şi împărţire, etc.

Faptul că dispozitivele FPGA sunt reconfigurabile oferă un mare avantaj în proiectarea de sisteme cu procesor configurate la generare: în vreme ce verificarea şi evaluarea performanţelor unui procesor implementat într-un FPGA se poate face direct pe dispozitivul FPGA ţintă, verificarea şi evaluarea unui procesor implementat într-un ASIC se face pe o simulare, necesitând mai mult timp şi fiind mai puţin precisă.

Acest avantaj este evidenţiat de faptul că producătorii de FPGA-uri oferă de obicei configuraţii multiple ale benzii de asamblare a procesorului soft, astfel încât acesta să se potrivească cât mai bine cerinţelor. Acest lucru nu se întâmplă de obicei în cazul procesoarelor

95

implementate pe ASIC-uri din cauza dificultăţii de a testa şi valida mai multe variante de bandă de asamblare.

Spre exemplu, procesorul Nios II, produs de Altera pentru FPGA-urile lor, este oferit în trei configuraţii ale benzii de asamblare: Nios II/f (fast – rapid), Nios II/s (standard) şi Nios II/e (economy – economic) [112]. Diferenţele între cele 3 tipuri de benzi de asamblare sunt de maximum 3 ori în ceea ce priveşte aria ocupată şi de maximum 9 ori în ceea ce priveşte performanţele obţinute. Varianta Nios II/f oferă o bandă de asamblare pe 6 niveluri, cu memorie cache opţională pentru instrucţiuni, memorie cache opţională pentru date şi predicţie dinamică a salturilor folosind o tabelă cu 2 biţi de istorie [113]. Varianta Nios II/s are o bandă de asamblare cu doar 5 niveluri, cu memorie cache de instrucţiuni dar fără memorie cache de date şi mecanism de predicţie statică a salturilor. Nios II/s foloseşte cu 20% mai puţine resurse decât Nios II/f, dar performanţele scad cu aproximativ 40% [113]. Varianta Nios II/e nu mai oferă paralelism la nivelul instrucţiunii, execuţia unei instrucţiuni necesitând 6 cicli de tact, nu oferă memorie cache de instrucţiuni sau date şi nici mecanism de predicţie a ramificaţiilor. Astfel, performanţele obţinute de procesor sunt foarte scăzute faţă de varianta Nios II/s, dar şi spaţiul ocupat este de două ori mai mic [113].

Fig. 4.1, preluată din [114], este reprezentativă pentru vastele posibilităţi în ceea ce priveşte aria ocupată şi performanţele obţinute de procesoarele soft implementate în FPGA. Autorii lucrării [114] au generat o serie întreagă de variante de procesor bazate pe o parte din setul de instrucţiuni al procesorului MIPS-I. În Fig. 4.1, aceste variante sunt comparate cu variantele prezentate ale procesorului Nios II.

Figura 4.1. Comparaţie între diferite variante de procesor MIPS-I şi variantele Nios II [114].

96

4.1.2 Dificultăţi în proiectarea de procesoare implementate în FPGA

Proiectarea procesoarelor implementate în FPGA este asemănătoare în multe privinţe cu

proiectarea procesoarelor implementate pe ASIC-uri. De fapt, procesoarele implementate pe ASIC-uri sunt adesea prototipizate pe FPGA-uri pe parcursul dezvoltării lor. Aceste prototipuri nu sunt însă utilizabile în aplicaţii comerciale, fiind utile doar pentru validarea şi testarea unor concepte de proiectare. Proiectarea procesoarelor implementabile în FPGA trebuie să reformuleze cerinţele de procesare astfel încât soluţiile obţinute să fie potrivite pentru implementarea în FPGA. Adoptarea soluţiilor folosite în proiectarea pentru ASIC-uri conduce rareori la rezultate satisfăcătoare la implementarea în FPGA.

O provocare a proiectării de procesoare pentru FPGA constă în a ţine cont de performanţele relative ale resurselor dispozitivului FPGA (elemente logice, memorii RAM, multiplicatoare, elemente programabile de interconectare), foarte diferite de performanţele relative ale resurselor unui ASIC (porţi logice, memorii RAM şi trasee cablate) [112]. De exemplu, performanţele memoriei RAM din FPGA sunt apropiate de performanţele memoriei RAM din ASIC, pe când performanţele elementelor logice din FPGA sunt mult mai slabe decât performanţele porţilor logice din ASIC. Din cauza diferenţelor de performanţe relative, folosirea unor tehnici utilizate pentru îmbunătăţirea performanţelor procesoarelor implementate pe ASIC-uri s-ar putea să conducă la deprecierea performanţelor procesoarelor la implementarea în FPGA. De exemplu, arhitecturile superscalare şi VLIW (Very Long Instruction Word) nu sunt potrivite pentru implementare în FPGA datorită limitărilor în ceea ce priveşte accesarea multi-port a bancurilor de registre. De asemenea, tehnica de execuţie re-ordonată a instrucţiunilor (out-of-order execution) nu este utilizabilă la implementarea în FPGA datorită performanţelor relativ scăzute ale logicii de control implementate folosind elemente logice.

O altă problemă provine din faptul că majoritatea resurselor dintr-un FPGA au performanţe mult mai scăzute decât resursele unui ASIC. Din această cauză, un procesor eficient implementat în FPGA trebuie să folosească un set de instrucţiuni simplu, pe o bandă de asamblare cu structură simplă. Îmbunătăţirea la nivel de sistem a performanţelor se poate apoi obţine prin utilizarea mai multor procesoare în paralel, prin adăugarea de instrucţiuni la setul de bază, sau prin proiectarea de acceleratoare orientate pe aplicaţie şi interfaţarea lor strânsă cu procesoarele.

4.1.3 Avantaje la proiectarea de procesoare implementate în FPGA

Deşi FPGA-urile sunt dezavantajate de costurile mai mari şi performanţele inferioare

ASIC-urilor, faptul că sunt reconfigurabile oferă avantaje nete la proiectarea de procesoare. Astfel, un procesor implementat pe FPGA poate fi uşor modificat oricând se modifică specificaţiile. Un procesor implementat într-un ASIC nu poate fi modificat decât prin construirea unui nou ASIC. Procesoarele implementate pe ASIC trebuie să compenseze această lipsă de

97

flexibilitate a suportului hardware prin adăugarea de facilităţi care să permită utilizarea flexibilă a procesorului.

Astfel, procesoarele implementate pe ASIC asigură de obicei performanţe mai bune decât necesită aplicaţia. Această margine de performanţă oferă flexibilitate în estimarea cerinţelor de performanţă şi permite potenţiale creşteri viitoare ale acestor cerinţe. Oferirea unei margini de performanţă conduce le creşterea costurilor ASIC-ului (memorii cache mai mari, banda de asamblare mai complicată). Procesoarele implementate în FPGA pot fi proiectate astfel încât să ofere o margine de performanţă foarte mică, scăzând astfel costurile. Dacă estimarea a fost greşită, se creşte performanţa procesorului prin reproiectare/reconfigurare, eventual folosind un FPGA mai mare, fără a fi nevoie să se aştepte producerea unui nou circuit integrat.

Procesoarele implementate pe ASIC au mulţi parametri configurabili la rulare prin intermediul unor registre de control, parametri ce pot fi setaţi prin software în timpul funcţionării sistemului. Procesorul oferă astfel resurse ce acoperă toate posibilităţile de comportare a unui modul, iar registrele de control definesc comportarea modulului la un moment dat. O mare parte din posibilităţile de comportare nu vor fi însă folosite dinamic, în timpul rulării sistemului. Ele vor fi configurate la iniţializarea sistemului şi îşi vor păstra aceeaşi configuraţie pe toată durata utilizării sistemului. Astfel, procesorul oferă resurse care în unele aplicaţii nu vor fi niciodată utilizate. Această risipă de resurse este evitată în cazul implementării procesoarelor pe dispozitive FPGA: parametrii configurabili la rulare care nu se schimbă dinamic în timpul utilizării sistemului pot fi transformaţi în parametri de generare ai procesorului. Astfel, procesorul oferă doar resursele necesare unei aplicaţii, ocupând mai puţin spaţiu. În cazul unei aplicaţii care are nevoie de un alt mod de utilizare a unui modul, procesorul poate fi re-generat cu alţi parametri şi reîncărcat în FPGA.

Exemple de parametri configurabili la rulare în procesoarele implementate pe ASIC-uri care pot fi transformaţi în parametri de generare pentru procesoarele implementate pe FPGA, şi care au un impact semnificativ asupra resurselor ocupate de procesor, sunt parametrii ce definesc comportarea memoriilor cache (validată/invalidată, mod de scriere pentru memoria cache de date (scriere întârziată (write-back) sau scriere directă (write-through))) şi parametrii ce definesc facilităţile de depanare oferite de procesor (execuţie pas cu pas, inserarea de puncte de suspendare a execuţiei (breakpoints), examinarea/modificarea conţinutului memoriei şi registrelor) [112].

4.1.4 Optimizări în proiectarea procesoarelor implementate în FPGA

În această secţiune vor fi prezentate o serie de tehnici de optimizare valabile pentru

proiectarea procesoarelor implementate în FPGA, sintetizate din [112], ţinând cont de caracteristicile arhitecturale ale dispozitivelor FPGA actuale, prezentate pe scurt în Secţiunea 2.2.

98

Cel mai important factor ce conduce la proiectarea de procesoare eficiente implementate în FPGA este reprezentat de înţelegerea diferenţelor relevante între resursele disponibile într-un ASIC şi cele disponibile într-un FPGA şi a modului cum aceste diferenţe afectează proiectarea. În continuare, vor fi analizate câteva din părţile componente ale unui procesor şi felul cum acestea se implementează, şi vor fi sugerate tehnici de optimizare a acestora pentru implementarea eficientă în FPGA.

Decodificarea instrucţiunilor Procesorul decodifică instrucţiunile pentru a genera semnale de control pentru unităţile

benzii de asamblare. Procesoarele RISC (Reduced Instruction Set Computer) folosesc de obicei logică combinaţională pentru decodificarea instrucţiunilor. Semnalele de control utilizate în aceeaşi unitate în care se face decodificarea pot duce la apariţia de căi critice de semnal. Aceste căi critice sunt foarte semnificative la implementarea pe FPGA, deoarece logica combinaţională implementată cu tabele de căutare are timpi de propagare mai lungi decât logica combinaţională implementată cu porţi logice pe ASIC.

Tehnici de optimizare: • Aşa cum s-a prezentat în Secţiunea 2.2, în dispozitivele FPGA memoria RAM

este de obicei organizată ca multiplu de 9 biţi şi poate fi accesată în cuvinte multiplu de 9 biţi, pentru a facilita implementarea unui circuit de verificare a conţinutului folosind memorarea unui bit de paritate. Această facilitate poate fi folosită în alt mod în cazul procesoarelor: de exemplu, în cazul unui procesor cu instrucţiuni pe 32 de biţi, pentru fiecare instrucţiune din memoria cache rămân 4 biţi nefolosiţi. Aceştia pot fi utilizaţi pentru a memora semnale de control pre-decodificate, pentru a reduce căile critice de semnal. Pre-decodificarea se realizează în momentul citirii instrucţiunii din memoria de program şi salvării ei în memoria cache. Logica de pre-decodificare nu afectează performanţele unităţii de citire a instrucţiunii (fetch).

• Decodificarea instrucţiunilor poate începe pe un nivel al benzii de asamblare anterior nivelului de decodificare propriu-zis, rezultatele parţiale fiind memorate în registre ale benzii de asamblare. Această tehnică foloseşte în plus bistabile, dar acestea nu sunt o resursă critică în FPGA.

• Pentru a permite optimizarea automată eficientă a logicii de decodificare, cât mai multe semnale de control ar trebui generate pe acelaşi nivel al benzii de asamblare. Decodificarea simultană a mai multor semnale este mult mai eficientă decât decodificarea aceluiaşi număr de semnale organizate în grupuri independente.

Logica de comandă şi control Logica de control este de fapt un automat cu stări finit (FSM - Finite State Machine)

sincron, implementat folosind logică combinaţională şi bistabile. Implementarea logicii de

99

control este mult mai puţin eficientă pe un FPGA decât pe un ASIC, atât din punctul de vedere al ariei ocupate, cât şi din punctul de vedere al timpilor de propagare. Din această cauză, procesoarele implementate pe FPGA ar trebui să folosească structuri de control cât mai simple. Acest lucru va conduce la creşterea numărului de cicluri de tact necesare execuţiei unei instrucţiuni, dar per total ar putea îmbunătăţi performanţele procesorului prin creşterea semnificativă a frecvenţei de lucru.

Multiplexoarele Într-un ASIC multiplexoarele sunt alcătuite din porţi logice, ce sunt rapide şi ocupă

spaţiu puţin. Circuitele ce conţin multe multiplexoare beneficiază de faptul că într-un ASIC densitatea traseelor de rutare poate fi foarte mare în zonele în care e nevoie, astfel că multiplexoarele pot fi grupate împreună, pentru a minimiza întârzierile cauzate de propagarea pe trasee.

Într-un FPGA, multiplexoarele sunt implementate folosind elemente logice, având timpi de propagare relativ lungi şi ocupând resurse semnificative. Din cauza faptului că traseele de rutare sunt fixe, multiplexoarele nu pot fi grupate foarte compact, ceea ce implică întârzieri semnificative datorate traseelor.

Prin natura lor, procesoarele conţin module cu densităţi mari de multiplexoare. În [115] se estimează că 30% din elementele logice ocupate de procesorul Nios II/f sunt folosite pentru implementarea de multiplexoare. Acestea sunt folosite în implementarea logicii de redirectare, a circuitelor de scriere în registrele de uz general, a circuitelor de citire din registrele de control, a circuitelor de deplasare cu pas selectabil (barrel shifter), a circuitelor de aliniere a datelor la încărcare, a circuitului de generare a valorii pentru următoarea adresă de memorie program (PC – Program Counter) [112].

Procesoarele cu bandă de asamblare folosesc multiplexoare pentru a redirecta (bypass) rezultatele de pe unele niveluri ale benzii către niveluri anterioare. Numărul intrărilor în multiplexoare este dat de numărul de niveluri ale benzii, iar lăţimea intrărilor este dată de lăţimea căii de date. De obicei, există două astfel de multiplexoare într-un procesor cu bandă de asamblare, câte unul pentru fiecare operand de intrare.

În general, operaţiile aritmetico-logice definite de instrucţiunile unui procesor (de exemplu add, subtract, and, or, xor, shift, rotate) sunt executate toate în paralel, de hardware specializat, iar rezultatul corespunzător instrucţiunii executate la momentul respectiv trebuie rutat la ieşire în vederea salvării într-un registru de uz general. Acest lucru este realizat tot prin intermediul unor multiplexoare, cu lăţimea dată de lăţimea operanzilor, iar numărul de intrări dat de complexitatea setului de instrucţiuni.

Registrele de control ale unui procesor sunt de obicei încărcate de instrucţiuni speciale în registre de uz general pentru verificare sau modificare. Această operaţie implică multiplexarea ieşirilor registrelor de control către bancul de registre de uz general, ca şi multiplexarea ieşirilor registrelor de uz general către registrele de control.

100

Toate aceste utilizări ale multiplexoarelor ţin în primul rând de flexibilitatea oferită de procesor prin completitudinea setului de instrucţiuni. Un procesor mai complex, cu un set de instrucţiuni extins, va avea nevoie de multe multiplexoare pentru a oferi cât mai multe posibilităţi de folosire a hardware-ului programului executat. Un procesor mai simplu, cu mai puţine instrucţiuni şi mai puţine facilităţi hardware, va avea nevoie de mai puţine multiplexoare la implementare, dar va necesita un program mai complicat, cu mai multe instrucţiuni pentru efectuarea unei operaţii.

Tehnici de optimizare: • Multiplexoarele de redirectare dintr-un procesor cu bandă de asamblare pot fi

simplificate dacă se omite redirectarea unor unora dintre nivelurile benzii. Acest lucru va conduce la reducerea performanţelor, deoarece banda de asamblare va trebui uneori oprită pentru a se evita situaţiile de hazard.

• O altă opţiune este redirectarea doar a unui singur operand. Această tehnică profită de faptul că de obicei în programele generate de compilatoare apare hazard în banda de asamblare doar pentru unul din operanzi. Termenul de hazard în banda de asamblare se referă la dependenţele ce pot apărea între operanzii unei instrucţiuni aflată în execuţie şi rezultatele unei alte instrucţiuni aflată într-un stadiu mai avansat de execuţie (pe un nivel posterior în banda de asamblare).

• O opţiune mai avansată, prezentată în [116], este implementarea unui procesor cu fire multiple de execuţie ce realizează schimbarea contextului/firului de execuţie la fiecare ciclu de tact. Această tehnică elimină în întregime necesitatea redirectării în banda de asamblare, fără a afecta performanţele în cazul în care aplicaţia ce rulează pe procesor are suficiente fire de execuţie.

• Semnalele de selecţie ale multiplexoarelor trebuie generate cât mai devreme în ciclul de tact, în acest fel alocându-se majoritatea ciclului propagării prin multiplexoare.

• Se poate adăuga un nivel de bandă de asamblare chiar înainte de nivelul de scriere în registrele de uz general. În acest fel, un întreg ciclu de tact va fi folosit doar pentru propagarea prin multiplexoare a valorii ce va fi scrisă în registrul de uz general.

• Instrucţiunea de citire din registrele de control poate fi implementată într-un mod mai puţin performant, folosind mai mulţi paşi de execuţie. În acest fel, multiplexarea ieşirilor registrelor de control poate fi împărţită în mai multe niveluri, scurtându-se timpul de propagare pe fiecare nivel. Acest lucru nu va afecta foarte mult performanţa per ansamblu a procesorului, deoarece timpul de execuţie al instrucţiunii de citire din registrele de control nu este de obicei critic.

Bancurile de registre Un procesor obişnuit (care nu are o arhitectură de tip superscalar) are nevoie de bancuri

de registre cu două porturi de citire şi un port de scriere. Cele două porturi de citire sunt folosite

101

pentru a accesa cei doi operanzi utilizaţi într-o instrucţiune, în timp ce portul de scriere este utilizat pentru salvarea rezultatului.

În ASIC-uri, bancurile de registre sunt implementate fie folosind memorii RAM, fie folosind multiplexoare şi bistabili. A doua soluţie nu e fezabilă la implementarea procesoarelor în FPGA din cauza resurselor consumate şi a timpilor de propagare foarte mari. Spre exemplu, un banc de 32 de registre într-un procesor pe 32 de biţi ar necesita 1024 de bistabili şi cam tot atâtea tabele de căutare (LUT-uri) pentru implementarea multiplexorului 32:1 pe 32 de biţi şi ar avea un timp de propagare inacceptabil. Singura soluţie practică constă deci în folosirea blocurilor de memorie RAM.

Tehnici de optimizare: • Se pot utiliza mai multe blocuri de memorie RAM pentru a implementa un banc

de registre cu porturi de citire multiple. Toate blocurile RAM sunt scrise în paralel, cu aceleaşi valori, deci au acelaşi conţinut. În plus, majoritatea FPGA-urilor moderne oferă blocuri de memorie RAM cu porturi de citire duale, ceea ce înseamnă că un banc de registre cu două porturi de citire şi un port de scriere poate fi implementat direct folosind un bloc RAM.

• Circuitele cu porturi de scriere multiple trebuie evitate, deoarece implementarea lor nu este posibilă folosind blocuri RAM în paralel.

Sumatoarele Un procesor implementat în FPGA poate folosi sumatoare fără niciun fel de restricţii,

deoarece acestea sunt rapide şi ocupă puţine resurse. Performanţele sumatoarelor implementate în FPGA faţă de cele implementate în ASIC sunt mult mai bune decât performanţele implementării unor funcţii logice aleatoare în FPGA faţă de ASIC. Acest lucru se datorează atât structurii regulate şi repetitive a sumatorului, cât şi legăturilor speciale prevăzute în FPGA pentru propagarea transportului între elemente logice învecinate (a se vedea Secţiunea 2.2). Fiecare element logic (LUT) din FPGA poate implementa un sumator de un bit. Astfel, un sumator pe 32 de biţi ocupă 32 de elemente logice într-un FPGA, pe când într-un ASIC va necesita sute de porţi logice.

Utilizarea în comun a aceluiaşi sumator de către mai multe circuite nu are rost într-un FPGA, deoarece costul circuitului de partajare (multiplexoare de lăţime egală cu lăţimea sumatorului) este comparabil cu cel al sumatorului.

Multiplicatoarele Majoritatea familiilor moderne de FPGA-uri conţin multiplicatoare dedicate integrate,

chiar dacă în număr mic la dispozitivele de cost redus. De obicei, procesorul implementat în FPGA va folosi registre la intrările şi ieşirea multiplicatorului, pentru a evita căile critice spre şi dinspre multiplicator. Astfel, multiplicatorul va avea o latenţă de doi cicli de tact şi o rată de o operaţie pe ciclu.

Tehnici de optimizare:

102

• În procesoarele cu performanţe ridicate implementate în FPGA, operaţiile de înmulţire se realizează cu o rată de un rezultat pe ciclu. Întârzierea iniţială de doi cicli de tact este mascată de banda de asamblare a procesorului, dacă aceasta este suficient de lungă.

• În procesoarele cu performanţe medii implementate în FPGA, operaţiile de înmulţire se realizează cu o rată de un rezultat la 3 cicli de tact. Banda de asamblare este blocată timp de doi cicli de tact în cazul instrucţiunilor de înmulţire consecutive.

• În cazul în care procesorul are nevoie de operaţii de înmulţire pe mai mulţi biţi decât oferă multiplicatoarele dedicate din FPGA, pot fi cascadate mai multe multiplicatoare. Cascadarea, folosind elemente logice, poate conduce la apariţia de căi critice. Acestea pot fi eliminate prin inserarea de registre între multiplicatoarele dedicate, cu dezavantajul creşterii latenţei. O altă metodă constă în realizarea prin cascadare a unui multiplicator asimetric (de exemplu 32x16 biţi) şi folosirea lui secvenţială timp de mai mulţi cicli de tact consecutivi pentru obţinerea unui rezultat cu lăţimea necesară (de exemplu, intrări de 32x32 biţi, ieşire de 64 biţi).

Circuitele de deplasare cu pas selectabil (barrel shifters) Operaţia de deplasare cu pas selectabil este destul de răspândită la procesoarele moderne.

Implementarea ei este însă destul de costisitoare în FPGA, fiind bazată pe mai multe niveluri de multiplexoare. De exemplu, pentru un circuit de deplasare cu pas selectabil pe 32 de biţi realizat cu multiplexoare 2:1 sunt necesare 532log2 = niveluri de multiplexare. Deşi structura

dispozitivelor FPGA permite implementarea mai uşoară a multiplexoarelor 3:1 sau 4:1, şi în acest caz circuitul de deplasare are nevoie de 3 niveluri de multiplexare. Pe lângă consumul destul de mare de resurse pentru o operaţie destul de puţin frecventă, această complexitate se reflectă şi în timpul de propagare (sau în latenţă, dacă se introduc registre între nivelurile de elemente logice).

O modalitate de a trece peste aceste inconveniente, prezentată pe larg în [115], este folosirea unui multiplicator dedicat pentru realizarea circuitului de deplasare. Astfel, deplasarea

la stânga cu n poziţii este echivalată cu o înmulţire cu n2 . Intrarea circuitului de deplasare ce trebuie deplasată va constitui una din intrările multiplicatorului, în timp ce intrarea ce specifică

numărul de poziţii n al deplasării este convertită în n2 folosind elemente logice şi va constitui a doua intrare a multiplicatorului. În cele ce urmează [115] se arată cum se poate folosi această tehnică pentru toate tipurile de operaţii de deplasare (deplasări sau rotaţii, la stânga sau la dreapta, aritmetice sau logice).

Fig. 4.2 prezintă un exemplu de realizare a operaţiilor de deplasare aritmetică la stânga şi la dreapta folosind un multiplicator dedicat pe 18 biţi, de tipul celor integrate în familia de FPGA-uri cu cost redus Xilinx Spartan-3E.

103

Figura 4.2. Realizarea operaţiilor de deplasare aritmetică la stânga şi la dreapta folosind un

multiplicator dedicat. Astfel, una din intrările multiplicatorului este reprezentată de operandul asupra căruia

trebuie efectuată deplasarea, iar cea de-a 2-a intrare este 62 , corespunzând unei deplasări la stânga cu 6 poziţii. Rezultatul înmulţirii este reprezentat pe un număr dublu de biţi (36). Dintre aceştia, cei mai puţin semnificativi 18 biţi reprezintă chiar primul operand, deplasat la stânga cu 6 poziţii. Merită observat faptul că cei mai semnificativi 18 biţi reprezintă chiar primul operand deplasat la dreapta cu 12 (18 – 6) poziţii. În cazul în care înmulţirea este efectuată cu semn, deplasarea la dreapta va fi de tip aritmetic, ca în Fig. 4.2, adică bitul de semn al primului operand va fi copiat pe toate poziţiile mai semnificative de pe care s-a făcut deplasarea. Dacă înmulţirea se realizează fără semn, atunci deplasarea la dreapta va fi de tip logic, inserându-se 0 (zero) pe poziţiile cele mai semnificative, ca în exemplul din Fig. 4.3.

Figura 4.3. Realizarea operaţiilor de deplasare logică la stânga şi la dreapta folosind un

multiplicator dedicat.

104

Aşadar, aceeaşi structură poate fi folosită atât pentru deplasarea la stânga, cât şi pentru deplasarea la dreapta, singura diferenţă fiind partea de generare a celui de-al doilea operand

folosit la înmulţire: în primul caz se utilizează n2 , iar în al doilea nN−2 , unde n este numărul de poziţii pe care se face deplasarea, iar N este numărul de biţi ai cuvântului de procesat.

Pe acelaşi principiu se poate realiza şi operaţia de rotaţie. Plecând de la rezultatul anterior, al înmulţirii fără semn, cele două jumătăţi ale rezultatului pot fi asamblate folosind operaţia logică SAU. Având în vedere că exact jumătate din biţi sunt 0 (zero), prin SAU logic rămân doar biţii din primul operand, doar că rearanjaţi: cei mai semnificativi n biţi se regăsesc pe cele n poziţii mai puţin semnificative, unde n este dat de poziţia bitului de 1 în al doilea operand

( n2 ). Rezultatul este chiar primul operand rotit la stânga cu n poziţii (sau, echivalent,rotit la dreapta cu N – n poziţii).

Realizarea operaţiei de rotaţie este prezentată în Fig. 4.4, pentru cazul concret când N = 18 şi n = 6.

Circuitele de comparaţie de egalitate Într-un ASIC, verificarea egalităţii între două variabile de n biţi se realizează folosind n

porţi de tip SAU EXCLUSIV cu câte 2 intrări şi o poartă SAU-NU cu n intrări. Într-un FPGA această abordare este foarte neeconomică. Spre exemplu, pentru n=32, într-un FPGA bazat pe LUT-uri cu 4 intrări, această implementare are nevoie de 21 de LUT-uri, organizate arborescent pe 364log4 = niveluri.

Figura 4.4. Realizarea operaţiei de rotaţie folosind un multiplicator dedicat.

105

Verificarea egalităţii între o constantă şi o variabilă, ambele pe n biţi, se realizează printr-o poartă ŞI cu n intrări. Astfel, pentru n = 32, într-un FPGA sunt necesare 11 LUT-uri, organizate arborescent pe 332log4 = niveluri.

Comparaţiile de egalitate sunt foarte folosite în procesoare, pentru evaluarea expresiilor condiţionale (ramificaţii condiţionate sau instrucţiuni de comparaţie) şi în căutarea etichetelor la memoriile intermediare (cache).

Tehnici de optimizare: • Verificarea egalităţii poate fi realizată printr-o operaţie SAU EXCLUSIV şi o

scădere. Pentru anumite valori ale lăţimii intrărilor n, această metodă poate fi mai rapidă în FPGA decât metoda clasică, prezentată mai sus. Aceasta din cauză că în acelaşi LUT cu 4 intrări se pot implementa atât funcţia SAU EXCLUSIV cu două intrări, cât şi un scăzător pe un bit. Comparaţia de egalitate între două variabile in1 şi in2 este echivalentă cu examinarea bitului de semn al următoarei expresii descrise în limbajul HDL Verilog:

{1’b0, in1 ^ in2}-1. • Deoarece căutarea etichetelor la memoriile intermediare formează de obicei căi

critice de semnal, în FPGA este recomandată folosirea de memorie intermediară (cache) cu mapare directă.

4.2 Procesorul soft Xilinx PicoBlaze. Arhitectură şi unelte de dezvoltare.

PicoBlaze este un procesor soft pe 8 biţi, proiectat special de firma Xilinx pentru

implementare foarte eficientă pe FPGA-urile sale. El este optimizat pentru familia de FPGA-uri Spartan-3, dar poate fi folosit şi pe familiile Virtex-5, Spartan-6 şi Virtex-6.

PicoBlaze ocupă doar 96 de felii logice (slice) din FPGA, adică doar 12.5% dintr-un dispozitiv FPGA XC3S50, sau 0.3% dintr-un dispozitiv XC3S5000. De obicei, PicoBlaze foloseşte o memorie program de 1024 locaţii, adică un singur bloc RAM de pe FPGA. PicoBlaze este totuşi destul de rapid, reuşind să execute între 44 şi 100 milioane de instrucţiuni pe secundă (MIPS – Million Instructions per Second), în funcţie de dispozitivul pe care este implementat [117]. Cu toate că poate fi folosit pentru procesare de date, PicoBlaze este mult mai potrivit pentru a implementa prin software maşini de stare complexe, dar care nu au restricţii de timp. De altfel, numele său de cod, KCPSM3, sugerează această utilizare: constant (K) Coded Programmable State Machine.

Microcontrolerul PicoBlaze este implementabil în totalitate într-un singur dispozitiv FPGA şi nu necesită resurse externe. Spre deosebire de un microcontroler standard, avantajul major al microcontrolerelor încorporate pe FPGA constă în faptul că funcţionalitatea de bază poate fi foarte uşor extinsă şi îmbunătăţită conectând resurse suplimentare implementate în FPGA la porturile de intrare/ieşire.

106

Datorită faptului că este oferit ca şi cod sursă VHDL, PicoBlaze poate fi uşor implementat în orice familie de dispozitive FPGA de la Xilinx, inclusiv în familii ce vor fi dezvoltate în viitor. Astfel, un proiect bazat pe PicoBlaze are garanţia că va putea fi utilizat oricând în viitor, fără a exista temerea că microcontrolerul nu va mai fi produs, ca în cazul microcontrolerelor hard.

4.2.1 Arhitectura procesorului PicoBlaze

Microcontrolerul PicoBlaze oferă următoarele facilităţi [117]:

• 16 registre de uz general de un octet; • un spaţiu al memoriei program de 1024 de instrucţiuni; memoria program este

implementată pe acelaşi cip FPGA şi este încărcată automat la configurarea dispozitivului FPGA;

• unitate aritmetico-logică (ALU – Arithmetic – Logic Unit) cu operanzi de tip octet;

• 64 de octeţi de memorie RAM internă procesorului; • 256 de porturi de intrare şi 256 de porturi de ieşire; • stivă cu gestionare automată pentru apelarea de subrutine, cu 31 de locaţii; • performanţa este predictibilă, fiecare instrucţiune durând exact 2 cicli de tact; • răspuns rapid la întreruperi, în cel mult 5 cicli de tact;

Schema bloc a procesorului PicoBlaze este prezentată în Fig. 4.5.

Figura 4.5. Schema bloc a procesorului PicoBlaze [117].

107

Registrele de uz general Cele 16 registre de uz general ale microcontrolerului, fiecare de câte 8 biţi, sunt denumite

cu s0 până la sF. Ele pot fi redenumite folosind directive de asamblor. Toate operaţiile ce folosesc registrele sunt complet interschimbabile, toate registrele putând fi folosite cu aceeaşi versatilitate. Nu există registre rezervate sau registre prioritare. Nu există un registru acumulator, oricare din cele 16 putând fi folosit atât ca operand, cât şi ca destinaţie a unei operaţii.

Memoria program Instrucţiunile PicoBlaze sunt reprezentate pe 18 biţi. Procesorul poate adresa direct, fără

mecanisme de extindere a spaţiului de memorie, maximum 1024 instrucţiuni. Memoria program este de obicei implementată într-un singur bloc RAM pe FPGA, dar acest lucru nu este obligatoriu: se poate folosi şi memorie RAM distribuită, la nevoie. Memoria program este încărcată automat la configurarea dispozitivului FPGA, dar există mecanisme prin care nu este necesară reconfigurarea întregului FPGA pentru schimbarea codului ce trebuie executat de către PicoBlaze. Acest lucru este foarte util în faza de depanare a software-ului, atunci când hardware-ul implementat în FPGA este complex, iar compilarea întregului proiect şi configurarea întregului FPGA poate dura destul de mult.

Unitatea aritmetico – logică (ALU) ALU realizează calculele necesare sistemului cu microcontroler, adică:

• operaţii aritmetice de bază, ca adunarea şi scăderea; • operaţii logice la nivel de bit, ca ŞI, SAU, SAU EXCLUSIV; • comparaţii aritmetice şi verificări de egalitate; • operaţii de deplasare şi rotaţie.

Toate operaţiile sunt executate folosind un registru de uz general (sX) ca operand şi destinaţie a rezultatului. Dacă instrucţiunea are nevoie de 2 operanzi, atunci al doilea operand poate fi un alt registru de uz general (sY) sau o constantă cu adresare de tip imediat (kk).

Indicatoarele de condiţie (flags) Operaţiile desfăşurate prin ALU afectează doi indicatori de condiţie: ZERO şi CARRY.

Indicatorul ZERO este setat când rezultatul ultimei operaţii din ALU este 0 (zero). Indicatorul CARRY poate avea diverse semnificaţii, în funcţie de tipul operaţiei efectuate prin ALU.

Indicatorul INTERRUPT_ENABLE validează intrarea de întrerupere. Memoria RAM internă de 64 de octeţi Procesorul PicoBlaze oferă o memorie internă de 64 de octeţi, adresabilă atât direct, cât şi

indirect, prin intermediul registrelor de uz general. Memoria este accesată prin intermediul instrucţiunilor STORE şi FETCH.

Instrucţiunea STORE înscrie conţinutul oricărui registru de uz general în oricare locaţie a memoriei RAM. Instrucţiunea FETCH citeşte oricare locaţie a memoriei RAM şi depune

108

rezultatul în oricare din registrele de uz general. Utilizarea acestei memorii RAM permite deci extinderea numărului de variabile accesibile direct procesorului, micşorând sau eliminând necesitatea utilizării de memorie RAM externă, mapată în spaţiul de intrare/ieşire.

Adresa memoriei RAM, pe 6 biţi, este specificată fie direct în instrucţiune, ca şi constantă imediată (ss), fie indirect, folosind conţinutul unui registru de uz general (sY). În acest caz, doar cei 6 biţi mai puţin semnificativi ai registrului sunt utilizaţi.

Spaţiul de intrare/ieşire Porturile de intrare/ieşire extind capabilităţile microcontrolerului PicoBlaze şi permit

conectarea acestuia la dispozitive periferice implementate în FPGA sau la alte resurse dedicate din FPGA. PicoBlaze poate adresa până la 256 de porturi de intrare şi 256 de porturi de ieşire. Ieşirea PORT_ID a microcontrolerului specifică adresa portului accesat. La execuţia instrucţiunii INPUT, PicoBlaze citeşte datele de pe magistrala IN_PORT într-un registru intern specificat în instrucţiune, sX. La execuţia instrucţiunii OUTPUT, PicoBlaze scoate conţinutul registrului sX specificat în instrucţiune pe magistrala OUT_PORT.

Contorul de program (PC – Program Counter) Registrul contor de program PC conţine adresa următoarei instrucţiuni ce va fi executată.

În mod normal, registrul PC este incrementat automat în timpul execuţiei unei instrucţiuni, indicând astfel locaţia următoarei instrucţiuni. Această comportare este modificată de instrucţiunile JUMP, CALL, RETURN şi RETURNI şi de apariţia unei întreruperi sau activarea semnalului de reset. Registrul PC nu poate fi modificat prin alte instrucţiuni. Instrucţiunea JUMP poate realiza doar salturi absolute, neexistând suport pentru calcularea de adrese relative.

Registrul PC este pe 10 biţi; aceasta conduce la un spaţiu al memoriei de program de maximum 1024 de locaţii, cu adrese de la 0x000 la 0x3FF. În cazul în care se ajunge la adresa maximă, 0x3FF, incrementarea PC conduce la depăşire, adică resetare la 0x000.

Execuţia secvenţială a programului poate fi alterată folosind instrucţiuni de control al execuţiei condiţionale sau necondiţionale. Acestea sunt de tip JUMP sau CALL şi specifică adresa absolută de unde se continuă execuţia programului. La execuţia instrucţiunii CALL, conţinutul curent al registrului PC este salvat în stivă. La execuţia instrucţiunii RETURN, registrul PC este încărcat cu valoarea din vârful stivei.

La apariţia unei întreruperi, dacă întreruperile sunt validate, conţinutul registrului PC este salvat în stivă, iar execuţia programului se continuă de la adresa 0x3FF, care este adresa vectorului de întrerupere. Revenirea din rutina de tratare a întreruperii trebuie realizată cu instrucţiunea RETURNI, care, pe lângă extragerea adresei de revenire din stivă, revalidează întreruperile şi reface valorile indicatorilor de condiţie ZERO şi CARRY la starea din momentul apariţiei întreruperii.

109

Stiva Stiva microprocesorului PicoBlaze este folosită doar de instrucţiunile de apelare de

subrutine şi de mecanismul de tratare al întreruperii, neputând fi accesată direct. Stiva are o adâncime de 31 de locaţii. În cazul în care se realizează secvenţe de instrucţiuni CALL imbricate, imbricarea ar trebui să aibă o adâncime maximă de 30 de niveluri dacă întreruperile sunt validate, sau 31 de niveluri dacă întreruperile nu sunt validate. În caz contrar, când stiva se umple, va suprascrie cea mai veche valoare, fiind implementată ca o memorie tampon ciclică.

Întreruperile Microprocesorul PicoBlaze are o intrare de întrerupere ce-i permite sesizarea

evenimentelor externe asincrone. Termenul “asincron” se referă aici la evenimente ce pot apărea oricând pe durata unui ciclu instrucţiune. Intrarea de întrerupere ar fi bine să fie totuşi sincronizată cu semnalul de tact al sistemului, pentru a se asigura funcţionarea corectă, fără hazard. PicoBlaze răspunde unei cereri de întrerupere în maximum 5 cicli de tact, necesari finalizării execuţiei instrucţiunii curente.

Resetul Procesorul PicoBlaze este resetat automat imediat ce s-a finalizat procesul de configurare

a FPGA-ului, prin activarea intrării RESET. Aceasta forţează iniţializarea procesorului: registrul PC este încărcat cu 0x000, indicatoarele de condiţie sunt resetate, întreruperile sunt dezactivate iar stiva este reiniţializată, marcată ca vidă.

Registrele de uz general şi memoria RAM internă nu sunt afectate de reset, păstrându-şi conţinutul.

Fig. 4.6. prezintă o captură de schemă ce instanţiază procesorul PicoBlaze şi memoria de program. Se pot observa semnalele şi magistralele de intrare şi ieşire ale procesorului. Cele de intrare sunt în partea stângă, iar cele de ieşire în partea dreaptă a simbolului ce reprezintă procesorul.

110

Figura 4.6. Procesorul PicoBlaze instanţiat în schemă.

4.2.2 Unelte de dezvoltare pentru procesorul PicoBlaze

Există trei opţiuni de unelte de dezvoltare pentru procesorul PicoBlaze [117], prezentate

în Tabelul 4.1. Două dintre acestea sunt oferite de către firma Xilinx. Tabelul 4.1. Medii de dezvoltare pentru procesorul PicoBlaze

Xilinx KCPSM3 Mediatronix pBlazeIDE

Xilinx System Generator

Asamblor Apelat din linie de comandă, în fereastră DOS.

Grafic. Apelat în linie de comandă, prin intermediul Matlab/Simulink/System Generator.

Sintaxa instrucţiunilor

KCPSM3. pBlazIDE. KCPSM3.

Simulator al setului de instrucţiuni

Sunt oferite facilităţi pentru simularea folosind HDL.

Grafic/interactiv. Grafic/interactiv.

Suport pentru puncte de

Nu. Da. Da.

111

suspendare a execuţiei (breakpoints) Suport pentru vizualizarea conţinutului registrelor.

Nu. Da. Da.

Suport pentru vizualizarea conţinutului memoriei.

Nu. Da. Da.

În continuare se vor descrie pe scurt mediile de dezvoltare KCPSM3 şi pBlazIDE. Mediul KCPSM3 KCPSM3 este un asamblor oferit ca fişier executabil DOS, împreună cu 3 fişiere şablon:

ROM_form.vhd, ROM_form.v şi ROM_form.coe. Programul pentru procesorul PicoBlaze trebuie scris în limbaj de asamblare, folosind un editor de text oarecare, şi salvat într-un fişier cu extensia PSM. Pentru a asambla programul, se va apela asamblorul dintr-o fereastră DOS, după ce se navighează în directorul de lucru ce conţine asamblorul, fişierele şablon şi fişierul sursă:

kcpsm3 <filename>[.psm] Asamblorul se opreşte la întâlnirea unei erori. Procesul de asamblare este deci iterativ,

trebuind reluat până la eliminarea tuturor erorilor. Asamblorul are nevoie de 4 fişiere ca intrări (fişierul sursă şi cele 3 fişiere şablon) şi,

dacă procesul de asamblare decurge fără erori, creează 15 fişiere de ieşire, prezentate în Fig. 4.7. Procesul de asamblare este efectuat în 5 iteraţii, iar la fiecare iteraţie se creează un fişier

de ieşire pass*.dat. Dacă nu sunt întâlnite erori în fişierul sursă, asamblorul KCPSM3 generează codul obiect corespunzător, salvându-l în mai multe formate, în fişiere distincte. Aceste fişiere pot fi folosite în diferite fluxuri de proiectare, fiind bazate pe fişierele şablon de la intrarea asamblorului. Ele sunt de fapt imagini, în diferite formate, ale memoriei program, instanţiate ca bloc de memorie RAM şi iniţializate cu codul maşină al programului ce trebuie executat de către PicoBlaze.

112

Figura 4.7. Intrările şi ieşirile asamblorului KCPSM3 [117].

Asamblorul generează de asemenea codul obiect brut şi îl salvează în format zecimal şi

hexazecimal, pentru a fi folosit eventual de alte unelte. În fişiere text se salvează echivalenţele constantelor şi etichetelor din program, iar într-un fişier .log se salvează o versiune a programului sursă completat cu adresele instrucţiunilor şi opcode-urile lor.

Mediul pBlazIDE Mediul pBlazIDE este un mediu de dezvoltare grafic pentru PicoBlaze oferit gratuit de

către firma Mediatronix. Printre facilităţile oferite de acest mediu sunt evidenţierea color a sintaxei, un simulator al setului de instrucţiuni (ISS – Instruction Set Simulator) cu posibilitatea de inserare de puncte de suspendare a execuţiei (breakpoints) şi de vizualizare şi modificare a conţinutului registrelor şi memoriei interne, un convertor de sintaxă între convenţia KCPSM3 şi cea pBlazIDE ce permite importarea de funcţii KCPSM3.

Atât mnemonicele limbajului de asamblare, cât şi directivele ce se adresează asamblorului sunt diferite la pBlazIDE faţă de KCPSM3. Acest neajuns este compensat de posibilitatea de a importa cod KCPSM3 în pBlazIDE.

Fig. 4.8 prezintă o captură de ecran cu mediul pBlazIDE. Ca şi KCPSM3, pBlazIDE poate genera o imagine a memoriei de program pe baza unui şablon ce poate fi folosită apoi de alte unelte. Principalul avantaj al pBlazeIDE este interfaţa sa grafică uşor de utilizat şi simulatorul integrat.

113

Figura 4.8. Mediul de dezvoltare pBlazIDE.

4.2.3 Simularea procesorului PicoBlaze

Tabelul 4.2 prezintă comparativ modalităţile de simulare a procesorului PicoBlaze. Fiecare dintre aceste modalităţi are puncte forte şi puncte slabe, iar proiectantul poate opta pentru oricare dintre modalităţi în funcţie de complexitatea sistemului, de experienţa sa şi de preferinţa pentru o unealtă sau un flux de proiectare.

Tabelul 4.2. Modalităţi de simulare pentru procesorul PicoBlaze

Unealtă Puncte forte Puncte slabe pBlazIDE Ideal pentru dezvoltarea rapidă de cod.

ISS precis la nivel de ciclu. Suport pentru execuţie pas cu pas. Suport pentru puncte de suspendare a execuţiei. Interacţiune uşoară cu registrele, memoria şi indicatoarele de condiţie (vizualizare şi modificare). Indicator de acoperire la verificare a

Lipsa posibilităţii de a simula resurse logice ataşate procesorului în FPGA.

114

codului. Temporizări software. Simulare a întregului sistem prin intermediul unor funcţii de intrare/ieşire.

ModelSim Simulare integrată a procesorului PicoBlaze împreună cu resursele logice ataşate acestuia în FPGA. Simulare logică şi de temporizare bazată pe limbaj HDL (VHDL sau Verilog). Precizie atât la nivel de ciclu de tact, cât şi în funcţie de temporizarea resurselor din FPGA folosite.

Necesită pregătirea simulatorului (definirea căilor spre librării şi fişiere de intrare, definirea opţiunilor la simulare). Necesită crearea de fişiere stimul. Simularea este a hardware-ului reprezentat de sistem, cu foarte multe detalii din care este greu de extras doar informaţia legată de execuţia codului şi starea procesorului.

Xilinx System Generator

Simulare la nivel de sistem în mediul Matlab/Simulink. ISS precis la nivel de ciclu. Suport pentru execuţie pas cu pas. Suport pentru puncte de suspendare a execuţiei. Suport pentru vizualizarea conţinutului registrelor şi memoriei.

Util în cazul în care întreg sistemul este proiectat folosind System Generator.

Direct pe FPGA

Depanare rapidă, în timp real. Mod de lucru ideal pentru sisteme cu interacţiune complexă. Integrat cu periferice, interfeţe seriale, etc.

Vizibilitate slabă a conţinutului registrelor.

Fiecare din modalităţile de simulare/depanare amintite are unele avantaje clare faţă de

celelalte. Din acest motiv, o combinare a acestor procedee şi unelte poate conduce la rezultate mai bune decât folosirea unei singure metode.

De exemplu, pBlazIDE ISS este cel mai potrivit pentru simularea operării procesorului PicoBlaze în faza de dezvoltare a programului, datorită facilităţilor sale de observabilitate deplină a stării procesorului (registre, indicatoare de condiţie, memorie internă) şi posibilităţii de a modifica direct această stare în procesul de simulare. De asemenea, suportul oferit pentru execuţie pas cu pas şi pentru inserarea de puncte de suspendare a execuţiei este crucial. În plus, pBlazIDE oferă suport special pentru simularea apariţiei întreruperilor, activând semnalul de întrerupere în simulare doar pentru un ciclu instrucţiune.

Totuşi, pBlazIDE nu poate simula interacţiunea procesorului cu perifericele special proiectate în contextul unui sistem complex implementat în FPGA. Se poate observa starea

115

porturilor de ieşire şi se pot simula modificări ale porturilor de intrare, dar acest lucru este insuficient în cazul unor periferice complexe. În acest caz, cea mai potrivită abordare este cea a simulării întregului sistem folosind un simulator HDL, ca ModelSim. Deşi simularea HDL este destul de laborios de realizat, atât în ceea ce priveşte pregătirea simulării (pregătirea fişierelor stimul, setarea simulatorului) cât şi în ceea ce priveşte simularea efectivă (putere de calcul mare necesară şi timp îndelungat de simulare) şi interpretarea rezultatelor (verificarea funcţionării corecte urmărind formele de undă digitale), este totuşi cea mai precisă metodă de verificare prin simulare. Fişierul HDL ce corespunde procesorului PicoBlaze, kcpsm3.vhd, oferit de Xilinx, conţine un proces denumit “simulation” proiectat special pentru a uşura simularea în ModelSim. Acest proces defineşte ca variabile elementele esenţiale ale procesorului, ceea ce face ca execuţia programului să poată fi uşor urmărită într-o simulare ModelSim. Astfel, instrucţiunea curentă poate fi vizualizată nu doar ca op-code, ci şi ca mnemonică (variabila kcpsm3_opcode). Indicatoarele de condiţie pot fi vizualizate separat, având valori simbolice (Z, NZ, C, NC) şi nu doar ca biţi (variabila kcpsm3_status). Registrele de uz general şi memoria RAM internă a procesorului pot fi vizualizate ca variabilele s0_contents până la sf_contents, respectiv spm00_contents până la spm3f_contents. O captură de ecran ce ilustrează simularea HDL procesorului PicoBlaze în ModelSim este prezentată în Fig. 4.9.

În cazul în care se foloseşte System Generator în proiectarea întregului sistem digital (lucru posibil având în vedere că bibliotecile System Generator [84] conţin şi elemente de bază, ca registre, funcţii logice, elemente aritmetice, permiţând proiectarea la nivel de transfer între registre), se poate simula şi sistemul cu procesor PicoBlaze tot în System Generator. Există suport pentru execuţia pas cu pas şi vizualizarea stării procesorului, deşi aceasta nu poate fi modificată direct.

Figura 4.9. Simularea HDL a PicoBlaze în ModelSim.

116

Figura 4.10. Proiectarea şi simularea în Simulink a unui sistem cu PicoBlaze.

Fig. 4.10 prezintă o captură de ecran ce exemplifică proiectarea şi simularea unui sistem

cu PicoBlaze în Simulink, folosind System Generator. Probabil cea mai utilizată metodă de depanare a software-ului ce rulează pe procesorul

PicoBlaze rămâne totuşi testarea directă pe FPGA. Aceasta se datorează atât vitezei mari cu care se pot realiza iteraţiile, cât şi flexibilităţii oferite de dispozitivul FPGA în sine. De asemenea, aplicaţiile în care se foloseşte acest procesor soft sunt de cele mai multe ori lente şi necritice din punctul de vedere al temporizării, de tip maşină cu stări finită, şi nu de procesare efectivă de date. Aceasta din cauză că procesarea de date poate fi realizată mult mai eficient direct în hardware pe FPGA. Datorită acestei caracteristici, o simulare HDL cu rezoluţie de ns sau ps reprezintă o folosire nejudicioasă a resurselor sistemului pe care se face simularea şi implică analiza unui volum de date considerabil pentru verificarea unei funcţionalităţi lente.

De exemplu, comunicaţia pe o interfaţă serială de tip RS232, afişarea pe un dispozitiv LCD (Liquid Crystal Display) sau funcţionarea unui ceas de timp real sunt aplicaţii extraordinar de lente faţă de semnalul de tact al sistemului, de obicei de ordinul zecilor de MHz. În aceste cazuri, simularea HDL este nerealistă.

Soluţia o reprezintă utilizarea FPGA-ului ca mediu de testare şi depanare. Deşi această abordare nu asigură o analiză de temporizare de tip “cazul cel mai defavorabil” şi nici o analiză de acoperire a codului testat, este foarte practică datorită vitezei de iterare: un proiect de dimensiuni reduse poate fi compilat şi încărcat pe FPGA în mai puţin de un minut, ceea ce face ca modificările în hardware şi software să poată fi verificate foarte rapid. De asemenea, ţinând cont de faptul că memoria program a procesorului PicoBlaze este de obicei implementată într-un bloc RAM cu port dual, este posibil să se încarce doar codul ce rulează pe PicoBlaze, folosind

117

interfaţa JTAG, făcând iteraţiile software-ului independente de modificările în hardware. Astfel, nu mai este necesară recompilarea întregului proiect la fiecare iteraţie, ci doar reconfigurarea blocului RAM ce conţine memoria program a procesorului cu o nouă versiune de software.

În plus, microcontrolerul PicoBlaze poate fi folosit el însuşi pentru generarea de vectori de test şi verificarea altor module implementate în FPGA, fie hardware sau alte procesoare soft. Astfel, software-ul ce rulează pe PicoBlaze poate genera o valoare la intrarea altui modul, poate citi ieşirea modulului şi verifica potrivirea acesteia cu o valoare prestabilită.

4.3 Co-proiectarea hardware-software în sisteme de control – studiu de caz

În acest subcapitol va fi prezentat studiul de caz al co-proiectării hardware-software a

unui sistem de control pentru motorul de curent continuu fără perii (BLDC). Sistemului de control efectiv, implementat în hardware, prezentat în Secţiunea 3.4.3, i s-a adăugat funcţionalitatea de monitorizare, constând în afişarea pe un dispozitiv LCD a parametrilor de control şi comunicarea cu un calculator gazdă folosind o interfaţă serială RS232 bidirecţională. Având în vedere că aceste funcţii de monitorizare nu sunt critice din punctul de vedere al timpului de execuţie şi, în plus, interacţionează cu elemente hardware lente, s-a dovedit oportună implementarea lor prin software pe procesoare soft.

Astfel, sistemul de control este format dintr-o parte hardware proiectată special pentru aplicaţia amintită şi din două sisteme cu procesor soft PicoBlaze, fiecare implementând o altă funcţionalitate. Astfel, problema iniţială a fost partiţionată între hardware şi software, ilustrând conceptul din ce în ce mai răspândit în proiectarea cu FPGA-uri, acela de sistem pe un singur cip (SoC - System on a Chip). Uneori, pentru a evidenţia caracterul reconfigurabil al dispozitivelor FPGA, se foloseşte terminologia de sistem pe un cip programabil (SoPC – System on a Programmable Chip).

Folosirea de procesoare PicoBlaze, în detrimentul unora cu putere de calcul superioară, ca MicroBlaze, este pe deplin justificată de funcţiile care trebuie îndeplinite: aşa cum s-a amintit, funcţia de procesare de date (algoritmul de control) este realizată în hardware. Aşadar, în software se implementează doar nişte maşini de stare care vehiculează date (parametrii algoritmului, valori instantanee de semnale) între algoritm şi dispozitive de interfaţă cu utilizatorul. Deşi aceste maşini de stare ar putea fi implementate direct în hardware, complexitatea lor şi viteza mică la care lucrează ar ridica dificultăţi în implementare şi verificare.

De asemenea, utilizarea în paralel a mai multor procesoare simple poate fi mai economică decât utilizarea unui procesor mai complex, atât din punctul de vedere al resurselor folosite, cât şi din cel al timpului de dezvoltare pentru software. De altfel, această abordare este comună [118], [119], [120], iar cazul în care procesoarele sunt conectate între ele conduce la conceptul de reţea pe un singur cip (NoC – Network on Chip).

118

4.3.1 Descrierea sistemului SoC

Sistemul pe un cip implementat în FPGA şi proiectat pentru controlul motorului BLDC

este prezentat în Fig. 4.11. SoC-ul constă din algoritmul de control implementat în hardware şi modulele logice de

suport necesare lui, analizorul logic virtual folosit pentru depanare şi verificare şi două sisteme cu procesor soft PicoBlaze. SoC-ul se interfaţează cu motorul folosind doar semnale digitale. Astfel, motorul este comandat prin intermediul unei punţi invertoare trifazice construită cu 6 tranzistoare MOSFET. Aşa cum s-a prezentat pe larg în Secţiunea 3.4.3, caracteristic controlului motorului BLDC este faptul că la un moment dat doar două tranzistoare ale punţii se află în conducţie, alimentând doar două dintre înfăşurările statorului motorului. Tensiunea de alimentare aplicată înfăşurărilor este controlată digital prin tehnica de modulaţie a lăţimii impulsurilor (PWM).

Sistemul de control trebuie să determine care dintre înfăşurări trebuie alimentate la un moment dat şi cu ce polaritate, în funcţie de poziţia rotorului. În acest scop, nu este necesară cunoaşterea precisă a poziţiei rotorului, ci doar orientarea lui faţă de înfăşurările statorului. Astfel, informaţia provenită de la 3 senzori cu efect Hall, montaţi în interiorul motorului, este suficientă pentru a determina momentele când magneţii permanenţi ai rotorului se află într-o anumită poziţie relativ la înfăşurările statorului, momente în care tensiunea de alimentare trebuie comutată pe altă pereche de înfăşurări. Senzorii Hall sunt de fapt senzori de poziţie a rotorului, însă cu o rezoluţie foarte slabă, de 60°. Ieşirile senzorilor Hall sunt digitale, putându-se deci interfaţa direct cu SoC-ul.

Figura 4.11. SoC pentru controlul BLDC.

119

Pentru controlul vitezei motorului este necesară mai întâi măsurarea acesteia. Viteza se poate determina folosind informaţia de poziţie a rotorului, prin diferenţiere, dar dacă s-ar folosi senzorii Hall pentru determinarea poziţiei precizia de măsurare a vitezei ar fi foarte scăzută. Din aceste considerente, motorul este dotat cu un codificator optic incremental de poziţie, oferind la ieşire impulsuri digitale codificate în cuadratură (QEP). Rezoluţia acestui codificator este mult superioară: este caracterizat prin construcţie de 500 de linii pe suprafaţa urmărită de detectorii optici, ceea ce conduce la o rezoluţie de 2000 de impulsuri pe revoluţie. Aceasta înseamnă că poziţia rotorului se poate determina cu o rezoluţie de 360°/2000=0.18°.

Avantajul codificatorului QEP este faptul că semnalele de ieşire sunt tot digitale, putând deci fi interfaţat direct cu SoC-ul. Pentru măsurarea vitezei, s-a proiectat un modul logic specific, implementat în FPGA, prezentat în Secţiunea 3.4.3.

Algoritmul de control, de tip proporţional-integrator (PI), a fost proiectat folosind Matlab-Simulink şi System Generator. Împreună cu algoritmul de control s-au implementat module logice pentru conducerea motorului: modulul de comutaţie, modulul de inserare de timp mort, modulul de generare de semnal PWM, precum şi modulul de estimare a vitezei, deja amintit.

Algoritmul de control a fost verificat şi performanţele lui au putut fi analizate folosind un analizor logic virtual, Xilinx ChipScope, implementat în acelaşi FPGA [111]. Acesta foloseşte memoria neutilizată din FPGA pentru a captura eşantioane ale semnalelor interne. Aceste eşantioane pot fi apoi descărcate pe un calculator gazdă folosind interfaţa JTAG şi vizualizate folosind software-ul ChipScope Pro Analyzer şi Matlab [111].

Deşi analizorul logic virtual este o unealtă foarte puternică şi utilă şi permite o analiză destul de detaliată a performanţelor sistemului de control, acesta are totuşi câteva limitări:

• Poate captura doar număr limitat de eşantioane la un moment dat; • Semnalele pot fi doar extrase şi vizualizate, nu se pot modifica valorile registrelor

în timp real; • Semnalele ce pot fi vizualizate sunt eşantioane capturate începând dintr-un anumit

moment, determinat de un eveniment (trigger), nu sunt valori observate în timp real;

• În plus, analizorul logic virtual ocupă multe din blocurile RAM din FPGA; în cazul unor proiecte complexe, aceste resurse s-ar putea să nu fie disponibile.

Din aceste motive, s-a dovedit necesară o interfaţă în timp real. Aceasta constă dintr-un afişaj, pentru vizualizarea valorilor parametrilor de control şi a valorilor semnalelor, şi o legătură serială bidirecţională de tip RS232 cu un calculator gazdă, folosită pentru vehicularea aceloraşi date.

Cele două interfeţe au fost realizate cu ajutorul a două sisteme cu microprocesor soft PicoBlaze. Acestea sunt total independente. Această abordare diferă de cea prezentată în [32], unde un singur procesor MicroBlaze controlează mai multe dispozitive periferice de comunicaţie şi afişare.

120

4.3.2 Sistemul cu procesor soft I

Primul sistem cu procesor soft, notat cu I în Fig. 4.11, are rolul de a citi parametrii

algoritmului de control din registrele acestuia şi de a-i afişa pe un LCD. De asemenea, poate afişa valoarea vitezei motorului la un moment dat. Fig. 4.12. prezintă simbolul sistemului cu procesor într-o schemă ierarhică, evidenţiind intrările şi ieşirile.

Trebuie observat că, în vederea afişării pe LCD, parametrii algoritmului de control sunt aduşi în formatul {semn, parte întreagă, parte fracţionară}, fiecare dintre câmpuri fiind de tip întreg fără semn. În acest scop, a fost proiectat în Simulink un circuit de conversie din formatul folosit în algoritmul de control, în virgulă fixă cu semn, pe 18 biţi, din care 13 biţi pentru partea fracţionară, în formatul amintit. Acest circuit este prezentat în Fig. 4.13.

Figura 4.12. Interfaţa sistemului cu procesor soft I.

Figura 4.13. Circuitul de conversie pentru afişarea parametrilor algoritmului.

121

În circuitul din Fig. 4.13., din parametrul a0 se extrage bitul de semn, care este transmis la ieşire şi este folosit ca intrare de selecţie a unui multiplexor 2:1. Multiplexorul va face selecţia între valoarea originală a parametrului a0, dacă aceasta este pozitivă, şi valoarea negată (în complement faţă de 2), dacă este negativă. Astfel, la ieşirea multiplexorului se obţine valoarea absolută a parametrului a0. Din aceasta, cei mai semnificativi 4 biţi reprezintă partea întreagă şi sunt rutaţi la ieşire. Cei mai puţin semnificativi 13 biţi trebuie convertiţi din formatul în virgulă fixă în valoarea întreagă corespunzătoare. În acest scop se fac două înmulţiri succesive. Prima, cu valoarea 1220703125, corespunzând cuantei reprezentării în virgulă fixă cu 13 biţi pentru

partea fracţionară ( 1250001220703.02/1 13 = ). Rezultatul acestei înmulţiri, reprezentat complet pe 44 de biţi, este valoarea zecimală corespunzătoare părţii fracţionare a parametrului a0.

Având în vedere că pe dispozitivul LCD se pot afişa doar un număr limitat de cifre zecimale (3 zecimale), doar cei mai semnificativi 14 biţi din această valoare vor fi folosiţi. Dacă se trunchiază pur şi simplu numărul reprezentat pe 44 de biţi şi se păstrează doar cei mai semnificativi 14 biţi, valoarea ce se va afişa nu va corespunde nicidecum valorii reale. Din această cauză, eroarea de trunchiere trebuie compensată, acest lucru realizându-se printr-o înmulţire cu o constantă dată de raportul între reprezentarea binară şi reprezentarea zecimală a

erorii de trunchiere: 073741824.1102

9

30= . Desigur, această valoare este aproximată în

reprezentarea în virgulă fixă, după cum se observă în Fig. 4.13, dar aproximarea este nesemnificativă, neafectând cele 3 zecimale afişate pe LCD.

Aceste operaţii nu sunt optimizate din punctul de vedere al folosirii multiplicatoarelor dedicate din FPGA. Ele au fost efectuate pentru că ilustrează posibilităţile de interacţiune între un sistem cu procesor soft şi hardware-ul dedicat din FPGA. Desigur, în cazul în care multiplicatoarele sunt necesare pentru algoritmul de control, ele nu vor mai fi utilizate pentru operaţii legate de funcţiile de afişare, ce au totuşi prioritate şi utilitate scăzută.

Fig. 4.14 prezintă modul de conectare a semnalelor din FPGA la portul de intrare al procesorului PicoBlaze. Folosind cei mai puţin semnificativi 3 biţi din adresa portului de intrare, se selectează una din intrările unui multiplexor de magistrală 8 la 1. Astfel, aceleaşi 8 porturi vor fi multiplicate în întreg spaţiul de intrare-ieşire al procesorului. Această metodă simplifică logica de decodificare a adresei, dar implică atenţie la dezvoltarea programului software ce accesează porturile.

122

Figura 4.14. Conectarea porturilor de intrare la PicoBlaze I.

4.3.3 Sistemul cu procesor soft II

Al doilea sistem cu procesor soft se ocupă exclusiv cu comunicaţia serială cu un

calculator gazdă pe o interfaţă RS232. În acest scop, sistemul cu procesor foloseşte 2 module UART (Universal Asynchronous Receiver/Transmitter) implementate în FPGA, unul pentru transmisie, uart_tx, şi unul pentru recepţie, uart_rx. Aceste module sunt oferite de către Xilinx ca şi descrieri HDL (sunt disponibile atât versiunea VHDL, cât şi cea Verilog) şi sunt instanţiate în schema sistemului. Aşadar, sistemul cu procesor II ilustrează conectarea unui procesor soft cu hardware implementat în FPGA şi proiectat ca şi nucleu IP reutilizabil.

Fig. 4.15 prezintă simbolul celui de-al doilea sistem cu procesor soft în schema ierarhică. Sistemul preia de la algoritmul de control valorile vitezei şi comenzii PWM pentru a le transmite serial. De asemenea, sistemul recepţionează serial noi valori pentru parametrii algoritmului de control, a0 şi a1, şi le scrie în registrele acestuia.

Fig. 4.16 prezintă instanţierea în schema sistemului II a nucleelor IP corespunzătoare receptorului şi transmiţătorului serial. Folosind un numărător binar pe post de divizor de frecvenţă, s-a generat semnalul de tact pentru comunicaţia serială din semnalul de tact al sistemului. Semnalele de stare a tampoanelor de memorie de la recepţie şi transmisie sunt monitorizate prin software prin intermediul unui port de intrare.

123

Figura 4.15. Interfaţa sistemului cu procesor soft II.

Figura 4.16. Nucleele IP de transmisie şi recepţie serială.

La fel ca la sistemul I, şi la sistemul II 5 porturi de intrare sunt conectate la procesor prin

intermediul unui multiplexor 8 la 1. Software-ul ce rulează pe procesor este responsabil cu selecţia corectă a porturilor şi asamblarea datelor citite prin intermediul mai multor porturi (de exemplu, valoarea semnalului PWM, pe 11 biţi). Magistrala portului de ieşire a PicoBlaze este legată la toate registrele în care procesorul poate scrie. O logică de decodificare selectează registrul adresat folosind magistrala PORT_ID, ca în Fig. 4.17.

Valorile parametrilor a0 şi a1 sunt asamblate de către procesor în registre externe, prin trei scrieri succesive în porturi de ieşire. A treia scriere activează şi un semnal de ready ce semnalizează algoritmului de control că valoarea parametrului este validă şi poate fi citită. Atunci când algoritmul de control preia valoarea, activează un semnal strobe, ce resetează registrul indicatorului ready.

124

Figura 4.17. Interfaţarea registrelor parametrilor algoritmului.

Sistemul cu procesor II transmite date calculatorului gazdă la fiecare perioadă de

eşantionare. În acest scop, intrarea de întrerupere a procesorului PicoBlaze este conectată la semnalul Ts_tick, ce semnalizează în întreg sistemul de control începerea unei noi perioade de eşantionare (funcţia sa principală fiind activarea algoritmului de control).

Aplicaţia ce rulează pe calculatorul gazdă a fost realizată vizual, folosind mediul LabView. De altfel, LabView este o unealtă foarte puternică şi include actualmente un modul ce permite proiectarea vizuală de sisteme hardware implementabile direct în FPGA, la un nivel de abstractizare destul de înalt. Acest lucru deschide noi posibilităţi în implementarea pe FPGA a sistemelor complexe, utilizând unelte vizuale, un exemplu fiind prezentat în [121]. Instrumentul virtual ce rulează pe calculatorul gazdă, a cărui interfaţă este prezentată în Fig. 4.18, permite observarea comportării sistemului în buclă închisă în timp real şi modificarea parametrilor de control pentru ajustarea performanţelor.

Instrumentul virtual constă din două grafice pe care se afişează în timp real valorile vitezei motorului BLDC şi ale comenzii PWM. Datele sunt afişate după asamblarea lor din octeţii recepţionaţi serial. La fiecare perioadă de eşantionare se recepţionează 6 octeţi: doi pentru sincronizare, doi ce formează valoarea vitezei şi doi ce formează valoarea comenzii. Pentru o perioadă de eşantionare în jurul valorii de 1ms, este necesară o rată de transfer serial de 115200 bps (biţi pe secundă). Datele sunt transmise de sistemul II în continuu. Dacă se doreşte îngheţarea imaginii pe grafice, pentru analiză, se întrerupe recepţia, folosind un buton de pe interfaţă. Când se doreşte reluarea afişării în timp real, se apasă butonul “continue”. Datele vor fi din nou asamblate şi afişate după recepţionarea primului set de doi octeţi de sincronizare. Aceştia au valori ce nu se pot regăsi între octeţii de date şi sunt astfel recunoscuţi de software.

125

Figura 4.18. Interfaţa instrumentului virtual ce rulează pe calculatorul gazdă.

Instrumentul virtual permite actualizarea parametrilor regulatorului. Astfel, prin editarea

valorilor unor câmpuri ce reprezintă factorul de amplificare proporţional şi factorul de amplificare integrator, şi folosind valoarea fixată pentru perioada de eşantionare, sunt calculaţi automat coeficienţii algoritmului de control (implementat ca filtru cu răspuns infinit la răspuns, a se vedea Secţiunea 3.4.3). Prin apăsarea butonului Send, aceşti coeficienţi sunt transmişi prin interfaţa RS232 sistemului de control.

Câteva dintre elementele de proiectare ale SoC-ului au fost prezentate şi în lucrarea publicată [122].

4.4 Concluzii Dispozitivele FPGA reprezintă actualmente cele mai complexe platforme integrate pentru

dezvoltarea sistemelor de calcul eterogene, cu avantajul major al programabilităţii, sau mai bine spus al configurabilităţii. Această din urmă precizare este necesară pentru a evidenţia faptul că aceste dispozitive nu sunt simple procesoare programabile, ci platforme hardware cu arhitecturi

126

bazate pe celule logice cu interconexiuni programabile, care pot fi folosite pentru implementarea de structuri hardware de calcul orientate pe aplicaţie.

Un interes deosebit în utilizarea acestor dispozitive îl reprezintă integrarea unui întreg sistem de procesare pe un singur cip, conducând la conceptul de SoC, sau chiar a unei matrice de elemente de procesare, conducând la conceptul de NoC. Din punctul de vedere al controlului automat, însă, revenirea la o structură de procesare fixă nu este un beneficiu [47], [57] decât în măsura uşurării proiectării sistemului: uneori, sistemul de control este mai uşor de implementat prin software ce rulează pe un procesor, decât direct în hardware. Acest lucru se datorează faptului că proiectarea de hardware orientat pe aplicaţie este un domeniu ce necesită cunoştinţe interdisciplinare destul de complexe, iar uneltele de dezvoltare şi metodele de lucru nu sunt încă standardizate. Proiectarea la nivele de abstractizare mai înalte, denumită proiectare ESL (Electronic System Level) [123] va impune cu siguranţă răspândirea utilizării dispozitivelor FPGA ca platforme hardware.

Totuşi, există aplicaţii în care proiectarea de hardware specific nu se justifică, în aceste cazuri implementarea unui sistem cu procesor soft şi proiectarea de software pentru el fiind mult mai avantajoasă. Aceste aplicaţii sunt cele de monitorizare şi interfaţă cu utilizatorul într-un sistem de control, care sunt necritice din punctul de vedere al timpului de execuţie. În plus, de obicei aceste aplicaţii utilizează hardware lent şi care necesită secvenţe complexe de iniţializare şi comunicaţie. Implementarea de automate hardware pentru aceste secvenţe este complicată şi nu se justifică, deoarece o scurtă rutină software poate face exact acelaşi lucru.

Prezentul capitol reprezintă un studiu al metodelor de optimizare a procesoarelor soft implementabile în FPGA, ţinând cont de diferenţele între arhitectura acestui tip de dispozitive şi arhitectura ASIC-urilor, ce sunt de obicei folosite pentru implementarea de procesoare. De asemenea, sunt prezentate pe scurt arhitectura şi uneltele de dezvoltare pentru procesorul pe 8 biţi PicoBlaze, de la Xilinx. S-a optat pentru prezentarea acestui procesor foarte simplu deoarece ocupă foarte puţine resurse din FPGA şi este perfect adaptat aplicaţiilor avute în vedere, acelea de monitorizare. Aceste aplicaţii nu presupun procesare efectivă de date, aceasta realizându-se direct în hardware, ci doar secvenţierea unor operaţii utilizând hardware extern. Procesorul PicoBlaze este alegerea potrivită pentru astfel de sarcini, fiind de fapt proiectat ca o maşină de stări programabilă.

În finalul capitolului se prezintă un sistem pe un cip cu două procesoare PicoBlaze independente, proiectate în jurul unui sistem de control hardware. Se exemplifică, aşadar, modul de co-proiectare hardware-software, prin partiţionarea proiectului în funcţionalităţi critice, executate de hardware, şi funcţionalităţi mai puţin critice, executate prin software. De asemenea, se exemplifică proiectarea unui sistem pe un cip FPGA, constând din hardware specific aplicaţiei, sisteme cu procesor soft ce funcţionează independent şi interacţionează, şi software-ul ce rulează pe procesoarele soft.

Rezultatele prezentate în acest capitol au fost publicate în [121], [122].

127

5. Metode moderne de modulaţie pentru controlul invertorului trifazic şi implementarea lor în FPGA

Invertorul trifazic, sau puntea invertoare trifazată, este o componentă cheie a sistemelor

moderne de control al motoarelor de curent alternativ (AC – Alternative Current) trifazate. Aceasta deoarece permite controlarea atât a amplitudinii, cât şi a frecvenţei tensiunii aplicate motorului. Atunci când este controlat în tensiune, invertorul este cunoscut în literatura de specialitate anglo-saxonă şi sub acronimul VSI (Voltage Source Inverter).

Răspândirea utilizării acestor dispozitive se datorează în primul rând avansării tehnologice la un grad în care atât dispozitivele de putere se pot fabrica pe scară largă, având dimensiuni destul de reduse şi caracteristici uniforme, cât şi dispozitivele de control digital permit o integrare tot mai înaltă, oferind sisteme de cost redus şi fiabilitate ridicată.

Tehnicile de control au fost dezvoltate în paralel cu evoluţia tehnologică. Fiind la început bazate pe circuite analogice, au migrat treptat spre implementări digitale, datorită avantajelor oferite de aceste circuite: insensibilitate la îmbătrânirea componentelor electronice şi la toleranţele tehnologice, adaptabilitate crescută prin reprogramare, fiabilitate crescută în medii zgomotoase din punct de vedere electromagnetic. Era digitală a condus şi la dezvoltarea unor tehnici noi, folosind reprezentări matematice complexe, cum este modulaţia bazată pe vectori spaţiali.

Un VSI trifazat, reprezentat în Fig. 5.1, este constituit din 6 elemente de comutaţie de putere. Acestea pot fi tranzistoare cu efect de câmp construite în tehnologie metal–oxid–semiconductor (MOSFET – Metal-Oxide-Semiconductor Field-Effect Transistor), în aplicaţiile de putere mică spre medie sau tranzistoare bipolare cu baza izolată (IGBT – Insulated Gate Bipolar Transistor), în aplicaţiile de putere mare.

Figura 5.1. Puntea invertoare trifazată, realizată cu MOSFET-uri.

128

În aplicaţiile industriale ale motoarelor de curent alternativ, uzual invertorul este alimentat de la o sursă de tensiune trifazică prin intermediul unei punţi redresoare cu diode. În aplicaţiile portabile, de exemplu în industria auto, invertorul este alimentat direct de la o sursă de tensiune continuă (baterie).

Deşi puntea invertoare din Fig. 5.1 (în principiu reluată din Fig. 3.15) are o structură foarte simplă, controlul precis al activării comutatoarelor ce o formează reprezintă o problemă serioasă. Acestea trebuie activate în aşa fel încât consumatorul de la ieşirea punţii să primească tensiune trifazată sinusoidală, de amplitudine şi frecvenţă reglabile. Cea mai folosită tehnică pentru controlul punţii invertoare este modulaţia PWM, realizată de obicei cu ajutorul unui procesor dotat cu periferice speciale.

Există mai multe moduri de aplicare a modulaţiei PWM la controlul invertoarelor trifazate. Lucrarea de faţă nu îşi propune prezentarea tuturor posibilităţilor, ci doar a celor două cele mai răspândite, insistând asupra avantajelor oferite de dispozitivele FPGA în implementarea acestor modulatoare.

Pentru explicaţiile ce urmează, se vor defini câţiva termeni utilizaţi ulterior. Astfel, puntea invertoare din Fig. 5.1 poate fi văzută ca fiind formată din două părţi, partea superioară, formată din tranzistoarele Q1, Q3 şi Q5, şi partea inferioară, formată din tranzistoarele Q2, Q4, Q6. În acelaşi timp, puntea poate fi văzută ca fiind alcătuită din 3 ramuri, fiecare făcând legătura între dcV şi masă. Cele 3 ramuri sunt alcătuite respectiv din tranzistoarele Q1 şi Q2, Q3 şi Q4,

Q5 şi Q6. Este evident din Fig. 5.1 că cele două tranzistoare ale aceleiaşi ramuri nu se pot afla în

conducţie în acelaşi timp, deoarece acest lucru ar conduce la scurtcircuitarea sursei de alimentare şi distrugerea tranzistoarelor. Astfel, starea invertorului poate fi descrisă complet doar de starea a trei dintre tranzistoare, cele ale părţii superioare sau cele ale părţii inferioare, considerând că celelalte trei sunt în starea complementară. În plus, deoarece tranzistoarele au un timp de răspuns ne-neglijabil, între comanda de blocare a unui tranzistor şi comanda de saturare a celuilalt de pe aceeaşi ramură ar trebui introdus un timp mort care să acopere timpii de răspuns ai tranzistoarelor.

Simplificarea amintită poate reprezenta puntea invertoare ca fiind formată din 3 comutatoare bipoziţionale. Astfel, fiecare dintre fazele consumatorului poate fi conectată la un moment dat fie la valoarea pozitivă a tensiunii continue de intrare, fie la cea negativă. Prin modulaţie PWM, impulsuri de frecvenţă fixă şi lăţime variabilă sunt aplicate la intrările de comandă ale comutatoarelor punţii. Tensiunea medie pe faza consumatorului conectată la un comutator va fi dată de lăţimea impulsurilor aplicate. De obicei, lăţimea impulsurilor este dată de un semnal cu o frecvenţă mult mai joasă decât frecvenţa impulsurilor. Aceasta din urmă este semnalul purtător, în vreme ce primul este semnalul modulat.

Pe lângă semnalul modulat, la ieşirea punţii se vor regăsi multe din armonicele superioare ale acestuia. De obicei acestea sunt filtrate de însuşi consumator, ce are o caracteristică de tip filtru trece-jos. Pentru a minimiza efectul armonicelor, frecvenţa semnalului purtător ar trebui să fie cât mai înaltă. Ea este însă limitată de unitatea de control (rezoluţia elementelor digitale) şi de

129

capabilităţile tranzistoarelor de putere (pierderi de comutaţie, distorsiuni introduse de inserarea timpilor morţi).

Există mai multe tehnici de modulaţie PWM ce se aplică punţilor invertoare. Două dintre cele mai cunoscute vor fi prezentate şi în cele ce urmează: modulaţia PWM sinusoidală şi modulaţia bazată pe vectori spaţiali. Prima tehnică poate fi implementată şi folosind doar componente analogice; a doua, însă, este apanajul sistemelor digitale.

5.1 Modulaţia PWM sinusoidală Modulaţia PWM sinusoidală constă în generarea unui tren de impulsuri de frecvenţă fixă

a cărui caracteristică este că factorul de umplere (lăţimea impulsurilor) variază după o funcţie sinusoidală. Modulaţia PWM sinusoidală se obţine prin compararea unui semnal de referinţă sinusoidal cu o purtătoare cu formă de undă triunghiulară sau dinţi de fierăstrău.

Procesul de modulaţie PWM sinusoidală este prezentat în Fig. 5.2. În practică, frecvenţa semnalului purtător trebuie să fie mult mai mare decât frecvenţa

semnalului de referinţă, modulat. În caz contrar, variaţia semnalului modulat într-o perioadă a semnalului purtător (modificarea semnalului sinusoidal între intersecţia cu segmentul crescător şi intersecţia cu segmentul descrescător al semnalului triunghiular) ar cauza distorsiuni în semnalul de ieşire. Această problemă nu apare în implementările digitale, unde semnalul sinusoidal este discretizat în timp. Totuşi, problema este translată în teorema eşantionării, deci tot trebuie luată în considerare.

Figura 5.2. Procesul de modulaţie PWM sinusoidală.

130

Atunci când se foloseşte o purtătoare cu formă de undă triunghiulară, semnalul rezultat la ieşire este simetric faţă de perioada semnalului purtător. Aceasta se datorează faptului că impulsul PWM nu este aliniat cu vârful pozitiv sau negativ al semnalului purtător, ci este simetric în jurul unuia dintre ele. De exemplu, în Fig. 5.2, impulsurile negative în semnalul rezultat sunt simetrice faţă de vârfurile pozitive ale semnalului purtător.

În cazul purtătoarei cu formă de undă dinţi de fierăstrău, impulsul PWM e aliniat cu vârful negativ al semnalului purtător. Aceasta conduce la o formă de undă asimetrică a semnalului rezultat.

De obicei, se preferă modulaţia PWM simetrică, deoarece produce mai puţine distorsiuni armonice de curent şi tensiune. Purtătoarea cu formă de undă dinţi de fierăstrău este totuşi mai întâlnită în sistemele digitale mai vechi sau de cost redus, deoarece este mai uşor de obţinut folosind periferice simple, de tip numărător binar. Producerea purtătoarei triunghiulare necesită un periferic mai special, de tip numărător binar reversibil (bidirecţional).

Aşa cum se poate observa din Fig. 5.2, amplitudinea semnalului sinusoidal de referinţă este limitată de amplitudinea semnalului purtător la 2/dcV , unde dcV este tensiunea continuă

aplicată punţii invertoare. Dacă se alege prin convenţie ca tensiunea aplicată punţii să fie bipolară, atunci tensiunea aplicată fazei consumatorului la saturarea tranzistorului superior al ramurii va fi 2/dcV+ , iar tensiunea aplicată fazei consumatorului la saturarea tranzistorului

inferior al ramurii va fi 2/dcV− .

Aşadar, dacă amplitudinea semnalului modulator (de referinţă) depăşeşte amplitudinea semnalului purtător, modulaţia nu mai funcţionează corect. De altfel, raportul dintre amplitudinea semnalului modulator, refV , şi amplitudinea semnalului purtător, purtV , reprezintă

indexul de modulaţie:

purt

ref

VV

m = . (5.1)

Pentru o modulaţie corectă, este necesar ca

1≤m . (5.2)

În cazul în care nu se respectă constrângerea (5.2), în semnalul de ieşire vor apărea armonice superioare nedorite, procesul numindu-se supra-modulaţie.

Principalul inconvenient al modulaţiei PWM sinusoidale constă în folosirea neperformantă a energiei sursei de alimentare datorită limitării amplitudinii semnalului modulator la 2/dcV . O altă problemă este faptul că pentru modulaţia trifazată, semnalele

modulatoare pe cele trei faze sunt tratate independent, ceea ce conduce la schimbări superflue ale stărilor comutatoarelor, crescând pierderile în tranzistoarele de putere şi conţinutul armonic în semnalele de ieşire.

O metodă de a îmbunătăţi folosirea energiei sursei de alimentare în cazul punţilor invertoare trifazate folosind modulaţia PWM sinusoidală se bazează pe faptul că de obicei

131

consumatorul de la ieşirea punţii (de exemplu un motor de CA trifazat) nu are nevoie de tensiuni sinusoidale pe fiecare fază în parte, ci de tensiuni sinusoidale între faze (producând curenţi sinusoidali). Semnalul modulator de pe fiecare fază poate fi aşadar modificat într-un mod convenabil, cu condiţia ca această modificare să nu afecteze semnalul diferenţial între faze.

Există mai multe metode de a obţine acest lucru, mai multe scheme de modulaţie. Acestea se bazează pe injecţia unui semnal ales potrivit în semnalul modulator al fiecărei faze. Acest semnal injectat va putea fi observat în punctul neutru al consumatorului (punctul de conectare în stea a fazelor acestuia) şi din această cauză procesul se numeşte injecţie de semnal la punctul neutru (ZSS – Zero Sequence Signal injection).

Un exemplu cunoscut de semnal ZSS este a treia armonică a semnalului sinusoidal modulator. Aceasta poate avea amplitudinea 1/4 sau 1/6 din amplitudinea semnalului iniţial. Primul caz conduce la o îmbunătăţire cu 15,5 % a amplitudinii semnalului de ieşire fără supramodulaţie, iar al doilea conduce la o îmbunătăţire cu 12 %, dar cu minimizarea conţinutului spectral al curentului în consumator [124]. Această metodă este însă destul de greu de implementat în practică datorită complexităţii.

Semnalul ZSS este de obicei extras din semnalele modulatoare de pe cele trei faze, fiind în relaţie strânsă cu acestea. Faptul că cele trei semnale modulatoare sunt folosite împreună pentru generarea semnalului ZSS va conduce la o tratare unitară a lor, eliminând şi al doilea inconvenient amintit la modulaţia PWM sinusoidală pură.

După cum se observă în Fig. 5.3, preluată din [125], există o multitudine de metode de modulaţie PWM sinusoidală cu inserţie de ZSS, fiecare oferind anumite avantaje.

Cea mai cunoscută metodă constă în injecţia unui semnal triunghiular conţinând toate armonicele de ordin 3 (a doua imagine din coloana din stânga în Fig. 5.3). Această metodă de modulaţie a fost obţinută şi prin modulaţia digitală bazată pe vectori spaţiali, şi de aceea este atât de răspândită.

Din punctul de vedere al implementării, schema de principiu a modulaţiei PWM sinusoidale cu injecţie de ZSS triunghiular este reprezentată în Fig. 5.4. Cele trei semnale modulatoare sunt semnale sinusoidale şi provin de la un generator de semnal. Din cele trei semnale, se calculează ZSS, iar acest semnal se adună la fiecare din cele trei semnale iniţiale. Semnalele rezultate vor fi de fapt semnalele modulatoare, iar modulaţia se aplică ca şi cea PWM sinusoidală simplă, cu ajutorul unor comparatoare, semnalului purtător triunghiular, acelaşi pentru toate cele trei faze. În final, semnalele modulate sunt folosite pentru a controla stările celor 6 tranzistoare ale punţii invertoare. Aşa cum s-a menţionat, este necesară inserţia unui timp mort la schimbarea stării tranzistoarelor de pe aceeaşi ramură a punţii.

132

Figura 5.3. Metode de modulaţie PWM sinusoidală cu injecţie de ZSS [125].

Figura 5.4. Schema de principiu a modulaţiei PWM sinusoidale cu injecţie de ZSS.

Pentru injecţia de semnal triunghiular, calcularea ZSS constă în determinarea semnalului

de magnitudine minimă din cele trei semnale modulatoare. Acest semnal este apoi scalat cu 0.5 şi constituie ZSS [125]. Aşadar,

133

⎪⎩

⎪⎨

⎧

===

=.),,min(,;),,min(,;),,min(,

ccbac

bcbab

acbaa

ZSS

vvvvifvvvvvifvvvvvifv

v (5.3)

Această schemă de modulaţie a fost realizată iniţial analogic, folosind o schemă cu diode pentru a colecta semnalul de magnitudine minimă şi reprezintă probabil prima metodă de modulaţie cu injecţie de ZSS raportată [125].

Pentru a uşura implementarea digitală, scutind modulatorul de a calcula valoarea absolută a magnitudinii semnalelor sinusoidale, necesară în (5.3), se poate face observaţia că pentru semnale sinusoidale trifazate echilibrate (cu defazaj egal între ele, de 120°), la orice moment dat, cele două semnale de magnitudini mai mari au semne opuse. Aşadar, semnalul ce are valoarea momentană în mijloc, nici cea mai mare, nici cea mai mică dintre cele trei, va fi cel de magnitudine minimă. Aşadar, valoarea ZSS poate fi calculată cu formula:

)).,min(),,min(),,max(min(*5.0 cbcabaZSS vvvvvvv = (5.4)

Aceasta este mult mai uşor de implementat, folosind direct valorile semnalelor şi eliminând astfel câţiva paşi din calcule. Dacă semnalele sinusoidale trifazate nu sunt echilibrate, (5.4) nu se poate folosi fără o analiză prealabilă a aplicabilităţii. În cazul cel mai general, se va căuta aplicarea formulei (5.3).

5.2 Implementarea în FPGA a modulatorului PWM sinusoidal cu injecţie de semnal la punctul neutru (ZSS)

În cele ce urmează se va prezenta implementarea în timp real pe FPGA a modulatorului

PWM sinusoidal cu injecţie de ZSS. Modulul rezultat va putea fi ulterior integrat într-un sistem de control pentru un motor de CA implementat pe FPGA.

Modulatorul a fost proiectat într-o manieră modulară, fiind constituit din: • Un modul generator controlat de semnal sinusoidal; • Un modul de calculare a valorii de prag pentru comanda tranzistoarelor, incluzând

logica de generare şi injecţie a ZSS; • Un modul de generare a semnalului purtător triunghiular, incluzând

comparatoarele PWM. Toate modulele au fost validate prin simulare individual, apoi integrate şi simulate ca

întreg. Sistemul a fost apoi implementat pe FPGA şi verificat experimental. În continuare, fiecare dintre module va fi prezentat şi explicat.

134

5.2.1 Modulul generator controlat de semnal sinusoidal

Generatorul de semnal sinusoidal se bazează pe o tabelă de căutare implementată într-o

memorie ROM (Read Only Memory). Valorile funcţiei sinus sunt păstrate în memoria ROM. Fiecare cuvânt păstrat într-o locaţie ROM are o lăţime de 18 biţi. Valorile memorate sunt reprezentate în format în virgulă fixă cu semn, cu 2 biţi pentru partea întreagă şi 16 biţi pentru partea fracţionară. Se pot reprezenta aşadar valori cuprinse între limitele -2 şi

+1.999984741210938, cu o rezoluţie de 1.52587890625* 510− . Se poate creşte rezoluţia dacă se renunţă la un bit din partea întreagă în favoarea părţii fracţionare. În acest caz, valoarea +1 nu va putea fi reprezentată, dar următoarea valoare mai mică reprezentabilă este foarte apropiată (+0.9999923706054688). S-a ales o lăţime a cuvântului de memorie de 18 biţi deoarece memoria bloc RAM din FPGA este organizată în blocuri de 18kb (kilo biţi), fiecare bloc putând fi accesat ca o memorie de 1024x18 biţi [126].

Tabela de căutare are o adâncime de 4096 ( 122 ) de valori, deci oferă o rezoluţie în timp de 12 biţi şi o rezoluţie în amplitudine de 18 biţi. Valorile păstrate în memoria ROM sunt calculate automat de interfaţa Simulink, după formula (5.5), corespunzător unei perioade a funcţiei sinus:

).4096/)4095:0(**2sin( π=ROMv (5.5)

Fig. 5.5 prezintă interfaţa Simulink a memoriei ROM folosită pentru tabela de căutare, arătând opţiunile selectate pentru implementare şi formula (5.5) folosită pentru calculul valorilor. Avantajul oferit de Simulink şi System Generator în acest caz este evident: în mod normal, valorile de păstrat în memoria ROM ar trebui calculate de un program separat, dezvoltat special în acest scop, care ar genera codul HDL corespunzător instanţierii memoriei, ca în [129].

Figura 5.5. Interfaţa Simulink a memoriei ROM ce păstrează valorile funcţiei sinus.

135

Generatorul de semnal sinusoidal este activat la fiecare perioadă a semnalului PWM. În cazul concret realizat experimental, s-a ales o frecvenţă a semnalului PWM de 20kHz. Aşadar, semnalul sinusoidal este eşantionat cu o frecvenţă de 20kHz. Pentru a găsi valoarea semnalului sinusoidal corespunzător perioadei de eşantionare curente, unghiul argument al funcţiei sinus trebuie aflat folosind frecvenţa (variabilă controlată de utilizator) şi valoarea curentă a timpului (timestamp). Aceasta din urmă este determinată folosind un numărător incrementat la fiecare perioadă de eşantionare. Deoarece numărătorul are un număr finit de biţi, valoarea curentă a timpului nu este valoarea reală, dată de un ceas de timp real, de exemplu, ci reprezintă timpul scurs de la începutul perioadei curente a funcţiei sinus. În acest scop, numărătorul ce dă valoarea curentă a timpului este reiniţializat de fiecare dată când funcţia sinus trece prin zero în sens crescător. Circuitul de detecţie a trecerii prin zero, prezentat în Fig. 5.6, monitorizează bitul de semn al adresei (trecerea prin zero a adresei coincide cu trecerea prin zero a sinusului), memorând valoarea curentă şi valoarea din perioada de eşantionare anterioară în câte un bistabil. În momentul în care valoarea curentă este 0(zero) iar valoarea anterioară a fost 1, semnalul de iniţializare a numărătorului se activează. Având în vedere că acest semnal va afecta numărătorul abia la următoarea perioadă de eşantionare, există o întârziere de 2 perioade de eşantionare între trecerea efectivă prin zero a sinusului şi observarea acesteia de către numărător. Semnalul de iniţializare a numărătorului nu va fi deci folosit pentru a-l reseta, ci pentru a încărca valoarea 2.

Adresa memoriei ROM se calculează cu formula următoare, corespunzând unghiului exprimat în radiani normalizat (prin împărţire la 2π) şi scalat corespunzător numărului de biţi din

reprezentare (prin înmulţire cu 122 ):

,22

_ 12_

πω PWMstampt TN

addrROM = (5.6)

unde ω este pulsaţia dorită a sinusului în rad/s, stamptN _ este valoarea numărătorului ce

generează timpul curent, iar PWMT este perioada semnalului PWM. Ecuaţia (5.6) necesită pentru

implementare un singur multiplicator, deoarece singura variabilă din ecuaţie este stamptN _ .

Celelalte valori sunt constante sau selectabile de către utilizator dintr-un set finit de valori constante (perioada semnalului PWM şi frecvenţa sinusului sunt controlabile, dar selectabile dintre nişte valori prestabilite).

Circuitul de calculare a adresei memoriei ROM este prezentat în Fig. 5.7, pentru o valoare constantă a perioadei de eşantionare sTPWM 00004.0= şi o valoare constantă a pulsaţiei

sinusului Hzsrad 10/63 ≈=ω .

136

Figura 5.6. Circuitul de iniţializare a numărătorului ce generează timpul curent.

Figura 5.7. Circuitul de calculare a adresei memoriei ROM.

Formele de undă pentru toate cele trei faze ale semnalului modulator sunt obţinute

folosind aceeaşi memorie ROM, accesând-o de 3 ori, la adrese diferite. Adresele diferă între ele cu valoarea 1365, corespunzând unui defazaj de 2π/3. Cele trei accese consecutive sunt secvenţiate de un automat de stări, prin intermediul unui multiplexor 3 la 1 care selectează între adrese (Fig. 5.8). De altfel, automatul de stări secvenţiază toate operaţiile din generatorul de semnal modulator.

Figura 5.8. Circuitul de acces triplu al memoriei ROM.

137

Ieşirea memoriei ROM este salvată într-un registru după multiplicarea cu o constantă. Aceasta este selectabilă de către utilizator şi va seta amplitudinea semnalului modulator. Există câte un registru de ieşire pentru fiecare dintre cele 3 faze, iar selecţia registrului potrivit este coroborată cu selecţia adresei memoriei ROM de către automatul de stări.

Acesta este un automat de tip Moore, instanţiat ca un bloc Registered Moore State Machine din librăria Xilinx Reference Blockset. Stările şi tranziţiile automatului sunt definite prin matricele stării următoare şi ieşirii, ce sunt translate automat în memorii ROM. S-ar putea folosi metode avansate de proiectare manuală mai eficientă a automatului [127], [128], însă efortul de proiectare trebuie îndreptat către calea de date, mult mai complexă şi cu un potenţial de optimizare mult mai ridicat. Automatul este destul de simplu şi deci uşor de descris prin această metodă. Automatul rămâne în starea 0 (zero) până când generatorul de semnal este activat de un semnal extern, ce semnalizează începutul unei noi perioade PWM. După activarea acestui semnal, automatul trece dintr-o stare în următoarea fără nicio condiţie, activând în fiecare stare un semnal de validare pentru un registru sau un set de registre ce salvează un pas din calculele asociate generatorului. În unele stări sunt modificate şi ieşirile de selecţie pentru multiplexorul de pe adresa memoriei ROM. Ieşirile sunt codificate sub forma “one hot”, un singur bit fiind 1 la un moment dat, cu excepţia celor de selecţie. Această codificare elimină nevoia de decodificator extern, folosindu-se doar blocuri Slice pentru a extrage biţii necesari din magistrala de ieşire, cum se poate vedea în Fig. 5.9. Fig. 5.10 prezintă definirea matricelor automatului. Tactul automatului, ca şi al tuturor elementelor sincrone din sistem (registre, numărătoare, memorii), este de 50MHz.

Figura 5.9. Automatul de stări ce secvenţiază operaţiile.

138

Figura 5.10. Matricele automatului de stări.

Automatul are 10 stări, deci modulul de generare a semnalelor modulatoare are nevoie de

10 paşi (10 perioade de tact) pentru a-şi executa sarcina. Ţinând cont de simetria formei de undă a funcţiei sinus, memoria ROM ar putea păstra doar un sfert de perioadă, iar prin calcule suplimentare asupra adresei şi ieşirii s-ar putea obţine întreaga perioadă. Această abordare este folosită în [129]. O altă abordare, descrisă în [130], foloseşte multiplicatoare şi relaţii trigonometrice pentru a minimiza şi mai mult consumul de memorie. Implementarea acestor metode ar complica structura modulului şi ar implica mai mulţi paşi de calcul. Or, numărul de paşi de calcul este foarte important într-o implementare în timp real, iar dispozitivul FPGA folosit pentru experimente are suficiente blocuri de memorie RAM.

5.2.2 Modulul de calculare a valorilor de prag pentru comanda tranzistoarelor

Acest modul este partea din sistem cea mai solicitantă din punctul de vedere al puterii de

calcul şi, în consecinţă, al resurselor folosite. Implementarea în FPGA este foarte eficientă în ceea ce priveşte timpul de execuţie atât datorită faptului că poate folosi multiplicatoarele integrate, cu un timp de propagare sub 5ns [126], cât şi din cauză că calculele pentru cele trei faze pot fi realizate în paralel, de către elemente hardware independente.

Valorile de prag calculate vor fi folosite mai departe de către comparatoarele PWM în modulul de generare a semnalului purtător triunghiular. În acest scop, cele trei semnale sinusoidale de intrare, după injecţia de ZSS, vor trebui aduse în acelaşi domeniu de valori ca şi semnalul triunghiular. Se va vedea în secţiunea următoare că acest domeniu este cuprins între 0 (zero) şi o constantă întreagă ce depinde de raportul între frecvenţa semnalului de tact al sistemului şi frecvenţa semnalului PWM. Această constantă se va nota cu cnt_scale.

139

Procesul de aducere a semnalelor modulatoare în intervalul [0;cnt_scale] se desfăşoară în mai mulţi paşi. Mai întâi, aceste semnale sunt normalizate prin multiplicare cu dcV/2 , unde dcV

este tensiunea continuă de alimentare a punţii invertoare. Semnalele, aflate acum în intervalul [-1;+1], sunt inversate (dacă în Fig. 5.2 considerăm că perioada semnalului purtător începe la atingerea vârfului negativ, atunci tranzistorul superior al braţului invertorului va fi blocat începând din momentul în care semnalul sinusoidal se intersectează cu cel triunghiular; pentru a determina momentul când tranzistorul trebuie saturat într-o perioadă a semnalului purtător, fie lucrăm în logică negativă, ca în Fig. 5.2, fie defazăm semnalul sinusoidal cu 180°, adică îl inversăm), deplasate în jurul valorii 1 şi scalate cu 1/2. După aceste operaţii, semnalele modulatoare vor avea valori în intervalul [0;+1]. Prin înmulţire cu cnt_scale, vor fi aduse în acelaşi interval ca şi semnalul purtător. Circuitul care realizează aceste operaţii este prezentat în Fig. 5.11. După cum se poate observa, circuitul foloseşte 6 multiplicatoare integrate. Fiecare pas de calcul este salvat într-un registru.

Semnalul ZSS injectat este calculat conform (5.4). În acest scop, cele 3 semnale sinusoidale sunt scăzute două câte două, iar biţii de semn ai rezultatelor sunt folosiţi pentru a selecta care dintre cele trei semnale este ZSS. Acesta este rutat mai departe prin intermediul unui multiplexor 3 la 1, este scalat cu 0.5 şi este adunat la cele 3 semnale sinusoidale. Se obţin astfel cele 3 semnale modulatoare. Decizia în privinţa cărui semnal constituie ZSS se determină conform tabelei de adevăr din Tabelul 5.1, unde

).(3);(2);(1

ca

cb

ba

vvsignsvvsignsvvsigns

−=−=−=

(5.7)

Tabelul 5.1. Tabela de adevăr pentru determinarea intrării de selecţie a multiplexorului.

s1 s2 s3 Sel a1 a0 ZSSV

0 0 0 1 0 1 bv

1 0 0 0 0 0 av

1 0 1 2 1 0 cv

1 1 1 1 0 1 bv

0 1 1 0 0 0 av

0 1 0 2 1 0 cv

140

Figura 5.11. Circuitul de translare a intervalului semnalelor modulatoare.

Din tabel lipsesc 2 combinaţii ale intrărilor s1, s2, s3, ce sunt imposibile din punct de

vedere practic, având în vedere definiţiile (5.7). De exemplu, dacă s1=0 şi s2=0, ceea ce este echivalent cu ba vv ≥ , respectiv cb vv ≥ , s3 nu poate fi 1, ceea ce ar însemna că ca vv < .

Conform Tabelului 5.1, ecuaţiile pentru obţinerea celor doi biţi ai intrării de selecţie a multiplexorului ce rutează ZSS sunt:

.3213211

;3213210

ssssssa

ssssssa

⋅⋅+⋅⋅=

⋅⋅+⋅⋅= (5.8)

Partea din circuit care determină semnalul ZSS este prezentată în Fig. 5.12. Pentru a face experimentul mai sugestiv, s-a adăugat un multiplexor ce selectează între

semnalul ZSS sau constanta 0 (zero) în funcţie de starea unui buton. Astfel, se poate observa atât modulaţia PWM sinusoidală pură, cât şi modulaţia PWM sinusoidală cu injecţie de ZSS.

Ca şi în cazul modulului generator de semnal modulator, şi modulul de calculare a valorii de prag este controlat de un automat de stări. Acesta activează în fiecare stare o ieşire de validare pentru un set de registre, salvând rezultatele unui pas din calcul. Automatul stă în starea 0 (zero) până când este activat de un semnal extern. Automatul are 9 stări, deci calcularea valorii de prag necesită 9 cicli de tact.

Toate calculele din cadrul acestui modul sunt realizate pe 18 biţi, profitând de lăţimea multiplicatoarelor integrate în FPGA [126].

Figura 5.12. Circuitul care determină semnalul ZSS.

141

Figura 5.13. Schema bloc a modulului de calculare a valorilor de prag.

O reprezentare schematică a întregului modul este prezentată în Fig. 5.13. Modulul este

proiectat după paradigma automat cu cale de date (FSMD – Finite State Machine with Datapath) [131]. Calea de date este reprezentată de fluxul orizontal de date din Fig. 5.13. Automatul de stări controlează de fapt calea de date. În Fig. 5.13, dreptunghiurile notate cu variabile reprezintă registre, iar toate registrele aliniate vertical sunt validate de acelaşi semnal al automatului.

Ultimul pas computaţional din Fig. 5.13 ajustează pragurile calculate prin adăugarea unei constante la valorile de prag ale tranzistoarelor din partea superioară a punţii şi prin scăderea unei constante din valorile de prag ale tranzistoarelor din partea inferioară a punţii. Aceste valori sunt ajustabile şi au rolul de a introduce mici întârzieri (timpi morţi) între schimbările stărilor tranzistoarelor de pe aceeaşi ramură a punţii. Necesitatea introducerii acestor timpi morţi a fost deja discutată. Prin faptul că cele două constante sunt diferite, se pot compensa asimetriile în răspunsul tranzistoarelor (de obicei, timpii de răspuns la comanda de saturare şi la cea de blocare ai tranzistoarelor de putere sunt diferiţi).

5.2.3 Modulul de generare a semnalului purtător şi a semnalelor de comandă a

tranzistoarelor

Semnalul purtător triunghiular necesar modulaţiei PWM este obţinut numeric folosind un

numărător bidirecţional. Un circuit suplimentar schimbă direcţia de numărare atunci când se ating nişte constante prestabilite. Numărarea în jos se face până la 0 (zero). Constanta limită superioară este dată de raportul dintre frecvenţa semnalului de tact al sistemului şi frecvenţa dorită pentru semnalul PWM:

.21_

PWM

clkff

scalecnt = (5.9)

142

Factorul 1/2 din (5.9) se datorează faptului că o perioadă a semnalului purtător corespunde unui ciclu complet de numărare, de la 0 (zero) la cnt_scale şi înapoi la 0 (zero). Pentru cazul particular folosit în experimente în care MHzfclk 50= şi kHzf PWM 20= , rezultă

.1250_ =scalecnt Semnalul purtător va fi chiar semnalul de la ieşirea numărătorului. Aşa cum

s-a menţionat, semnalele modulatoare sunt translate în acelaşi interval de valori, pentru a face posibile comparaţiile (intersectarea semnalelor) din Fig. 5.2.

Fig. 5.14 prezintă circuitul numărător şi cel de schimbare a direcţiei. Circuitul de schimbare a direcţiei de numărare constă dintr-un bistabil de tip D şi două

comparatoare de egalitate. Bistabilul de tip D memorează direcţia de numărare. Atunci când primul comparator detectează egalitate cu 1, bistabilul de direcţie este resetat (folosind intrarea de reset sincronă), iar începând cu următoarea perioadă de tact, numărătorul se va incrementa. Aşadar, datorită faptului că atât bistabilul, cât şi numărătorul sunt sincrone cu acelaşi semnal de tact, numărătorul va ajunge de fapt până la 0(zero) cu numărarea.

Atunci când al doilea comparator detectează egalitate cu cnt_scale-1, bistabilul D este setat (încărcat sincron cu 1), iar numărătorul se va decrementa începând cu următoarea perioadă de tact. Semnalul de la ieşirea bistabilului, cât şi complementul său, sunt folosite şi de alte circuite din modul ce au nevoie de informaţie despre panta semnalului purtător (crescătoare sau descrescătoare).

Fig. 5.15 prezintă o perioadă a semnalului purtător în simularea din mediul Simulink, putându-se observa că perioada este de exact 50μs.

Figura 5.14. Numărătorul şi circuitul de schimbare a direcţiei de numărare.

Figura 5.15. Simularea generatorului de semnal purtător.

143

Modulul de generare a semnalului purtător este responsabil şi cu generarea semnalelor de control pentru tranzistoarele punţii. În acest scop, valorile de prag calculate de modulul discutat în secţiunea anterioară sunt comparate, folosind comparatoare de egalitate, cu semnalul purtător. Pentru tranzistoarele superioare ale punţii, egalitatea dintre valoarea de prag şi semnalul purtător pe panta crescătoare a acestuia conduce la saturarea tranzistorului, iar aceeaşi egalitate pe panta negativă a semnalului purtător conduce la blocarea tranzistorului. Pentru tranzistoarele inferioare, lucrurile stau exact vice-versa. Circuitul de control pentru tranzistorul Q1 este prezentat în Fig. 5.16. Acesta constă dintr-un comparator de egalitate ce semnalizează intersecţia dintre semnalul modulator şi cel purtător. Acest semnal, condiţionat (prin porţi ŞI) de semnalele ce codifică direcţia de numărare a numărătorului generator de semnal purtător, va seta sau reseta (în funcţie de direcţie) un bistabil ce memorează starea tranzistorului. În plus, bistabilul este resetat la fiecare început de perioadă a semnalului purtător, pentru a preveni eventuala funcţionare defectuoasă în cazul în care valoarea de prag este în afara intervalului permis. În acest scop, un comparator de egalitate detectează valoarea 0 (zero) la ieşirea numărătorului şi, printr-o poartă SAU, resetează bistabilul.

Aşa cum s-a menţionat, modulul de generare a semnalelor sinusoidale şi cel de calculare a valorilor de prag sunt activate de semnale externe. Aceste semnale sunt generate din modulul de generare a semnalului purtător, fiind legate de acest semnal: astfel, modulul de generare a semnalelor sinusoidale va fi activat cu 19 cicli de tact înainte de terminarea perioadei curente a semnalului purtător, iar modulul de calculare a valorilor de prag – cu 10 cicli de tact înainte. În acest fel, toate calculele se termină exact în momentul începerii unei noi perioade a semnalului purtător, valorile de prag fiind valide pentru comparaţii pe durata acestei perioade.

Cele două semnale de activare sunt generate tot folosind comparatoare de egalitate şi ţinând cont de semnalul de direcţie a numărării.

Figura 5.16. Circuitul de control pentru intrarea de poartă a tranzistorului Q1.

144

5.2.4 Implementarea pe FPGA şi rezultate experimentale

Modulele sistemului descris au fost proiectate folosind System Generator şi validate prin

simulare folosind Simulink. Fig. 5.17 prezintă structura schematică a sistemului, evidenţiind cele 3 module.

Sistemul a fost verificat prin simulare ca întreg, apoi implementat în FPGA şi verificat experimental. Tabelul 5.2 prezintă resursele ocupate de modulator într-un dispozitiv FPGA Spartan-3E XC3S500E. Pentru experimente s-a folosit acest dispozitiv şi o punte invertoare cu tranzistoare MOSFET de tipul Technosoft PM50. Ieşirile au fost filtrate folosind filtre pasive RC trece jos pentru a elimina frecvenţele superioare datorate comutaţiei tranzistoarelor. Fig. 5.18 prezintă o captură de osciloscop cu cele trei tensiuni de fază obţinute după filtrare. În prima parte a imaginii, modulaţia a fost pur sinusoidală. Apoi, folosind un buton controlat de utilizator, s-a comutat pe modulaţie sinusoidală cu injecţie de ZSS (s-a discutat despre această posibilitate la prezentarea circuitului de injecţie de ZSS). Se observă că amplitudinea semnalului cu injecţie de ZSS este cu aproximativ 15% mai redusă decât cea a semnalului sinusoidal. Acest lucru nu afectează însă tensiunea dintre faze, calculată de osciloscop şi prezentată în partea de jos a imaginii, care rămâne sinusoidală şi îşi păstrează amplitudinea. Tot în partea de sus a imaginii se observă semnalul de punct neutru, obţinut prin conectarea celor trei faze în stea prin rezistenţe de valori mari. Acesta prezintă o formă de undă triunghiulară, în concordanţă cu aşteptările.

Figura 5.17. Structura modulară a modulatorului PWM sinusoidal cu injecţie de ZSS.

145

Figura 5.18. Semnalele sinusoidale trifazice, fără şi cu injecţie de ZSS.

Tabelul 5.2. Resursele ocupate în Spartan-3E XC3S500E de modulator.

LUT-uri cu 4 intrări

Bistabili de tip D Felii logice Multiplicatoare integrate

Blocuri de memorie RAM

698 din 9312 (7%)

511 din 9312 (5%)

478 din 4656 (10%)

8 din 20 (40%)

4 din 20 (20%)

Se poate concluziona, aşadar, că s-a proiectat cu succes un modulator sinusoidal cu

injecţie de ZSS în vederea implementării în FPGA. Resursele ocupate din FPGA sunt în jur de 10% din disponibil, ceea ce permite integrarea, alături de modulator, a unui sistem complex de control pentru un motor de CA trifazat, obiectivul final al acestei lucrări.

5.3 Modulaţia bazată pe vectori spaţiali Modulaţia bazată pe vectori spaţiali (SVM – Space Vector Modulation) este tot o tehnică

de modulaţie PWM, dar este pur digitală. Spre deosebire de tehnica de modulaţie PWM sinusoidală prezentată anterior, ce foloseşte trei modulatoare sinusoidale independente, modulaţia bazată pe vectori spaţiali tratează vectorul spaţial de referinţă complex ca întreg. Astfel este exploatată interacţiunea dintre cele trei faze, ele nefiind tratate independent. Aşa cum s-a văzut însă, injecţia de ZSS la modulaţia sinusoidală introduce o măsură a interacţiunii între faze în procesul de modulaţie. De altfel, se va arăta şi prin rezultatele experimentale că modulaţia sinusoidală cu injecţie de ZSS triunghiular (prezentată anterior) este echivalentă ca rezultat cu modulaţia bazată pe vectori spaţiali.

146

SVM se bazează pe reprezentarea folosind vectorul spaţial complex a mărimilor electrice. Aşa cum se va evidenţia în secţiunile următoare, motoarele trifazate pot fi modelate în mai multe sisteme de coordonate. În general, se preferă modelarea lor într-un sistem de două axe, echivalându-le cu motoare bifazice. Există două sisteme bifazice de coordonate, unul fix, legat de stator, şi unul rotativ, de obicei sincron cu rotorul. Această din urmă abordare este avantajoasă pentru că mărimile ce caracterizează motorul sunt constante în sistemul de coordonate rotativ.

Suprapunând sistemul staţionar de două coordonate, α/β, peste planul complex şi alegând α ca axa reală şi β ca axa imaginară, vectorul spaţial ce reprezintă tensiunea este dat de:

.θβα

jmeVjvvV =+=

r (5.10)

Se poate arăta că dacă unei maşini trifazice i se aplică o tensiune sinusoidală trifazată echilibrată de valoare medie pătratică (RMS – Root Mean Square) mV şi pulsaţie ω, atunci

vectorul spaţial Vr

va avea magnitudinea mV şi se va roti pe o orbită circulară cu viteza

unghiulară ω [124]. Şi variabilele trifazice pot fi exprimate sub formă vectorială:

),(32 2

cba vaavvV ++=r

(5.11)

unde 3/2πjea = şi 3/22 πjea −= pot fi interpretaţi ca vectori unitate aliniaţi cu axele b şi c [132]. Totuşi, se preferă modelarea în spaţiul α/β.

Atunci când se foloseşte o punte invertoare trifazată, vectorul spaţial de referinţă (dorit) trebuie obţinut printr-o combinaţie a stărilor posibile ale punţii. Aşa cum s-a menţionat, datorită faptului că starea tranzistoarelor superioare trebuie să fie complementară stării tranzistoarelor inferioare, starea punţii poate fi descrisă doar de starea tranzistoarelor superioare. Puntea se

poate afla deci în 8 ( 32 ) stări posibile, prezentate în Tabelul 5.3 împreună cu valorile corespunzătoare ale tensiunilor pe axele α/β.

Tabelul 5.3. Stările posibile ale punţii invertoare.

Starea tranzistoarelor Componentele fazorului de tensiune Starea punţii Q1 Q3 Q5 αv βv v

000 OFF OFF OFF 0 0 0 100 ON OFF OFF 3/2 dcV 0 3/2 dcV

110 ON ON OFF 3/dcV 3/dcV 3/2 dcV

010 OFF ON OFF 3/dcV− 3/dcV 3/2 dcV

011 OFF ON ON 3/2 dcV− 0 3/2 dcV

101 ON OFF ON 3/dcV 3/dcV− 3/2 dcV

111 ON ON ON 0 0 0

147

Când sunt reprezentate în planul α/β, cele 8 stări posibile ale punţii invertoare devin 8 vectori spaţiali, dintre care doi sunt nuli. Ceilalţi 6 definesc un hexagon şi îl împart în 6 sectoare, cum se poate vedea în Fig. 5.19.

Tehnica modulaţiei SVM constă în reconstruirea unui vector spaţial de referinţă dat folosind vectorii spaţiali de bază din Fig. 5.19. De fapt, doar 3 din cei 8 vectori spaţiali sunt necesari la un moment dat: cei doi vectori adiacenţi vectorului de referinţă, ce definesc sectorul în care acesta se găseşte, şi unul din vectorii nuli. De obicei, se folosesc ambii vectori nuli, pentru utilizarea simetrică a tranzistoarelor superioare şi inferioare ale punţii. Vectorii spaţiali de bază se combină folosind tehnica PWM. Din această cauză, algoritmul SVM mai este cunoscut şi sub denumirea SVPWM.

Spre exemplu, un vector spaţial cu magnitudinea şi orientarea ca în Fig. 5.20 va fi reconstruit folosind vectorii de bază 001 şi 011. Perioada de timp cât fiecare din aceşti vectori este aplicat este proporţională cu mărimea proiecţiei vectorului de referinţă pe vectorul de bază respectiv. Restul perioadei semnalului PWM este alocat vectorilor nuli. În Fig. 5.21 este prezentată reconstrucţia vectorului din Fig. 5.20 folosind tehnica PWM.

Figura 5.19. Hexagonul definit de vectorii spaţiali de bază.

Figura 5.20. Descompunerea unui vector spaţial situat în sectorul S3 în vectorii de bază.

148

Figura 5.21. Reconstrucţia vectorului din Fig. 5.20 prin PWM.

Asemănător, în Fig. 5.23 este prezentată reconstrucţia vectorului din 5.22. Ordinea în care se activează vectorii de bază într-o perioadă PWM este foarte importantă.

Aşa cum se poate observa în Fig. 5.21 şi Fig. 5.23, vectorii de bază sunt aplicaţi în aşa fel încât o singură ramură a punţii îşi modifică starea la un moment dat, minimizându-se astfel pierderile de comutaţie şi conţinutul armonic al semnalelor de ieşire.

Figura 5.22. Descompunerea unui vector spaţial situat în sectorul S6 în vectorii de bază.

Figura 5.23. Reconstrucţia vectorului din Fig. 5.22 prin PWM.

149

Algoritmul de implementare a SVM trebuie să îndeplinească următoarele sarcini: • Să determine orientarea vectorului de referinţă; de fapt, doar sectorul în care se

află vectorul este important, pentru a afla vectorii de bază adiacenţi ce vor participa la reconstrucţia lui;

• Să determine mărimea proiecţiilor vectorului de referinţă pe vectorii de bază şi, deci, factorul de umplere pentru aplicarea vectorilor de bază;

• Să determine ordinea de aplicare a vectorilor de bază; • Să genereze semnalul purtător PWM şi să aplice modulaţia.

Deşi aceste sarcini par foarte complexe, ele au fost reduse la probleme simple de geometrie plană: comparaţii de segmente şi calcularea lungimilor lor, fără a fi necesar apelul la funcţii trigonometrice. Deşi această abordare apare în diferite forme în literatură [124], [133], [134], [135] ea nu este suficient de cunoscută, dovadă fiind multitudinea de lucrări ce folosesc o abordare bazată pe funcţii trigonometrice, mai complicată: [28], [46], [48], [49]. Pornind de la componentele α/β ale vectorului de referinţă, se determină sectorul şi apoi se calculează raporturile de activare a, b şi c pentru fiecare ramură a punţii. Un raport de activare a=1 corespunde tranzistorului superior continuu saturat al primei ramuri a punţii. Valoarea a=0 implică o distribuţie egală a timpului de activare între tranzistorul superior şi cel inferior ai primului braţ., în timp ce valorii a=–1 îi corespunde situaţia în care tranzistorul inferior al primului braţ este continuu saturat (activat). Similar, valorile b şi c corespund stărilor celorlalte ramuri ale punţii, respectiv.

Pentru calcularea valorilor raporturilor de activare a, b şi c se foloseşte algoritmul schiţat în Fig. 5.24 [124]: mai întâi, în funcţie de valorile componentelor α/β ale tensiunii, se determină sectorul în care se află vectorul. Apoi se calculează valorile a, b şi c aplicând nişte formule de calcul specifice fiecărui sector. Acestea ţin cont de unghiul dintre axele α/β şi vectorii spaţiali de bază ce definesc sectorul. Datorită simetriei hexagonului, formulele de calcul pentru raporturile de activare sunt aceleaşi pentru sectoarele 1 şi 4, 2 şi 5, 3 şi 6, respectiv, şi sunt reprezentate de ecuaţiile (5.12), (5.13), (5.14).

Pentru sectoarele 1 şi 4:

.3

1

;3

3

;3

1

βα

βα

βα

vvc

vvb

vva

−−=

+−=

+=

(5.12)


.3

2

;3

2;2

β

β

α

vc

vb

va

−=

=

=

(5.13)

150

Figura 5.24. Algoritmul de calculare a valorilor raporturilor de activare.


.3

3

;3

1

;3

1

βα

βα

βα

vvc

vvb

vva

−−=

+−=

−=

(5.14)

Factorii de umplere pentru semnalele PWM se calculează apoi din valorile raporturilor de activare:

%100]2

1;2

1;2

1[,, ⋅+++

=cbadc cba . (5.15)

Pornind de la cele prezentate poate fi derivată implementarea în timp real pe FPGA a algoritmului de modulaţie SVM. Spre deosebire de implementarea pe un microcontroler sau DSP, implementarea pe FPGA e mult mai rapidă, deoarece multe operaţii se pot executa în paralel. De asemenea, operaţiile executate nu sunt limitate de o arhitectură aritmetico-logică fixată, ci pot fi definite după nevoi, ceea ce oferă multă flexibilitate la implementarea algoritmului.

În cazul algoritmului descris, se poate observa că rezultatele operaţiilor de comparaţie ce conduc la determinarea sectorului în care se află fazorul pot fi folosite după aceea: ultimele 4 condiţii de decizie din Fig.5.24 pot fi regăsite în formulele de calcul (5.12) şi (5.14). De exemplu, a doua condiţie de decizie din Fig.5.24:

151

βα vv3

1≥ (5.16)

poate fi rescrisă ca:

03

1≥− βα vv . (5.17)

La fel, cealaltă condiţie poate fi rescrisă ca:

03

1≥+ βα vv . (5.18)

Aşadar, decizia este luată în funcţie de semnul operaţiei (5.17), iar rezultatul acesteia este folosit ulterior pentru a calcula factorul a în (5.14). Se poate observa de asemenea că celelalte operaţii din (5.12) şi (5.14) sunt combinaţii liniare între termenii daţi de condiţiile de decizie, ca (5.17) şi (5.18), şi factorii b şi c din (5.13). Aşadar, odată aceşti termeni calculaţi, ei vor facilita calcularea celorlalţi.

Având în vedere disponibilitatea de resurse din FPGA, o abordare inteligentă este să se calculeze a priori toate valorile posibile pentru a, b şi c şi, în momentul în care s-a decis sectorul, adică care dintre trei-uple este cea validă, să se ruteze aceasta la ieşire. Astfel, calculele pot fi efectuate în paralel şi între ele, şi cu procesul de decizie, scurtându-se timpul de execuţie a algoritmului.

5.4 Implementarea în FPGA a modulatorului bazat pe vectori spaţiali Ca şi modulatorul sinusoidal cu injecţie de ZSS prezentat anterior, modulatorul SVM a

fost proiectat modular, având o structură asemănătoare. Este compus, aşadar, dintr-un modul generator de semnal, un modul de calculare a factorilor de umplere şi un modul generator de semnal purtător PWM.

5.4.1 Structura modulară

Modulul generator de semnal va genera un vector spaţial rotitor în planul complex,

adică va fi tot un generator controlat de semnal sinusoidal trifazat. Diferenţa faţă de generatorul de semnal sinusoidal din Secţiunea 5.2 constă în faptul că modulatorul SVM lucrează cu reprezentarea α/β a semnalului trifazat. Aşadar, modulul generator de semnal va realiza şi transformarea din sistemul de coordonate trifazat în cel bifazat:

152

⎪⎪⎩

⎪⎪⎨

⎧

−=

−−=

]).[][(33][

]);[][][2(31][

kvkvkv

kvkvkvkv

cb

cba

β

α (5.19)

Aceasta presupune un pas de calcul (adică un ciclu de tact) în plus şi utilizarea unor resurse suplimentare (multiplicatoare şi sumatoare). Implementarea transformării (5.19) în System Generator este prezentată în Fig. 5.25.

Modulul de calculare a factorilor de umplere va implementa algoritmul discutat în secţiunea anterioară şi schiţat in Fig. 5.24. Algoritmul este implementat tot folosind paradigma automat cu cale de date: paşii de calcul sunt secvenţiaţi de către un automat de stări de tip Moore, acesta generând semnale de validare pentru registrele ce memorează rezultatele intermediare.

Schema bloc a modulului de calculare a factorilor de umplere este prezentată în Fig. 5.26.

Figura 5.25. Transformarea din coordonate trifazice în coordinate bifazice.

Figura 5.26. Schema bloc a modulului de calculare a factorilor de umplere.

153

Algoritmul din Fig. 5.26 începe cu normalizarea componentelor α/β ale tensiunii trifazate. Prin înmulţire cu )*2/(3 dcV , cele două valori de intrare sunt aduse în intervalul [-

1;+1]. Trebuie observat că în toate formulele componenta de pe axa β este înmulţită cu 3/1 ,

datorită unghiului dintre vectorii spaţiali de bază şi axa β. Aşadar, normalizarea componentei βv

include şi înmulţirea cu acest factor, eliminându-se o operaţie superfluă. Următorul pas este determinarea condiţiilor (5.17) şi (5.18). Acestea se calculează

folosind sumatoare, iar rezultatele sunt salvate în registre. Vor fi utilizate ulterior pentru calculul unor termeni din formulele (5.12) şi (5.14), folosind tot sumatoare şi operaţii de negare (în complement faţă de 2), reprezentate prin “x(-1)” în Fig. 5.26.

Biţii de semn ai valorilor corespunzătoare operaţiilor (5.17) şi (5.18), împreună cu bitul de semn al componentei βv normalizată, sunt folosiţi pentru a realiza selecţia valorilor corecte

ce vor fi rutate la ieşire dintre cele calculate în paralel. Acest lucru este realizat de un circuit logic combinaţional.

În momentul în care valorile precalculate au fost selectate şi rutate la ieşire de multiplexoare, ele vor fi salvate în registrele notate a, b, c în Fig. 5.26. Acestea sunt raporturile de activare discutate în secţiunea anterioară.

În pasul următor, aceste raporturi de activare conduc la valorile factorilor de umplere pentru semnalele PWM, conform (5.15). Similar ca la modulatorul PWM sinusoidal, aceşti factori de umplere sunt transformaţi în valori de prag folosite la comparaţii cu semnalul purtător prin încă doi paşi computaţionali: primul scalează valorile factorilor de umplere, translându-i din intervalul [0;+1] în intervalul în care variază semnalul purtător. Acest lucru se realizează prin înmulţire cu constanta cntr_scale. Al doilea pas modifică uşor valorile de prag, pentru a introduce un timp mort între comutarea tranzistoarelor de pe acelaşi braţ al punţii. Această problemă a mai fost discutată în Secţiunea 5.2, iar implementarea soluţiei este exact la fel, deci nu va mai fi detaliată.

Ieşirea acestui modul este reprezentată aşadar de 6 valori de prag, fiecare corespunzând controlului semnalului de activare a unui transistor al punţii.

Modulul generator de semnal purtător PWM are exact aceeaşi structură cu modulul omonim discutat în Secţiunea 5.2.3. Semnalul purtător, tot triunghiular periodic, este comparat cu valorile de prag generate de modulul anterior, în felul acesta derivându-se semnalele de comandă pentru tranzistoare. Tot acest modul este responsabil şi cu generarea semnalelor de activare pentru celelalte două module.

5.4.2 Implementarea pe FPGA şi rezultate experimentale

Modulatorul prezentat a fost implementat într-un dispozitiv FPGA Spartan-3E. S-a folosit

reprezentarea numerelor în virgulă fixă, cu o precizie de 18 biţi la operaţiile de înmulţire (limitată de lăţimea intrărilor multiplicatoarelor încorporate în FPGA) şi 24 de biţi pentru

154

celelalte operaţii. Algoritmul de calculare a valorilor de prag se execută în 8 paşi, adică în 160ns la o frecvenţă a semnalului de tact de 50MHz.

În Tabelul 5.4 se prezintă comparativ resursele ocupate de modulatorul prezentat (doar algoritmul de modulaţie, fără generatorul de semnal de intrare) şi alte două versiuni din literatură [136], [28]. Implementările comparate sunt realizate cu dispozitive FPGA cu arhitecturi bazate pe celule logice cu LUT-uri cu 4 intrări, deci comparabile. După cum rezultă din Tabelul 5.4, modulatorul prezentat ocupă cu 45% mai multe resurse decât cel prezentat în [136], dar are o rezoluţie de 3 ori mai mare, şi este cu 32% mai economic decât cel prezentat în [28], având şi rezoluţie dublă faţă de acesta.

În plus, modulatoarele prezentate în literatură folosesc funcţii trigonometrice pentru a determina sectorul în care se află fazorul, deci au nevoie de o memorie ROM pentru a păstra eşantioanele funcţiei sinus. De asemenea, având în vedere că acele implementări folosesc forma trifazată a vectorului spaţial, în implementarea unui sistem de control orientat după câmp pentru un motor de CA modulatorul prezentat este mai avantajos, deoarece realizează modulaţia direct din reprezentarea α/β a tensiunii de comandă, folosită şi de sistemul de control. Celelalte implementări vor avea nevoie de operaţii în plus pentru realizarea transformării din spaţiul α/β în cel trifazat.

Tabelul 5.4. Resursele ocupate de modulatorul SVM. Implementare Dispozitiv FPGA Resurse ocupate:

LUT-uri/bistabili Rezoluţia

Prezentată aici Xilinx Spartan-3E / XC3S500E 830/510 24 biţi Prezentată în [136] Xilinx Spartan-2 / n.a. 573/n.a. 8 biţi Prezentată în [28] Altera Cyclone / EP1C20 1221/n.a. 12 biţi

După sinteză, mapare şi rutare, uneltele de analiză a temporizării au raportat că sistemul

prezentat este capabil să ruleze la o frecvenţă maximă de 77MHz. El a fost testat efectiv la frecvenţa de 50MHz.

Într-o primă fază, modulatorul a fost testat impunându-se un vector de referinţă fix şi capturându-se semnalele de comandă a tranzistoarelor punţii folosind un analizor logic „virtual” implementat tot în FPGA, ChipScope Pro. Modul de lucru cu acesta a fost deja prezentat. Astfel, pentru un vector de referinţă dat de componentele 60=αv şi 34=βv , cu 120=dcV , vector

situat deci la mijlocul primului sector, semnalele capturate cu ChipScope sunt prezentate în Fig. 5.27. S-a setat perioada de eşantionare pentru ChipScope egală cu perioada semnalului de tact al sistemului, 20ns. S-a ales o frecvenţă a semnalului PWM de 20kHz.

155

Figura 5.27. Semnalele de comandă a tranzistoarelor, capturate cu ChipScope.

În Fig. 5.27 se observă că între frontul căzător al semnalului g4 şi cel crescător al

semnalului g3 apare o întârziere de 5μs. Aceasta reprezintă timpul mort despre necesitatea căruia s-a discutat, setat în modulator. Se observă, de asemenea, că tranzistorul Q6 este dezactivat pentru un timp la mijlocul perioadei PWM, pregătindu-se pentru o eventuală activare a tranzistorului Q5. Chiar dacă acesta nu se activează în cazul vectorului de referinţă ales, timpul mort tot este introdus la comanda tranzistorului Q6. Se poate observa că perioada de dezactivare pentru Q6 este mai mică de 10 μs.

De asemenea, se poate observa din Fig. 5.27 că între două activări succesive ale semnalului trig, de startare a algoritmului, se scurg 50μs, ceea ce corespunde unei frecvenţe a semnalului PWM de 20kHz. Ordinea de activare a semnalelor de comandă corespunde activării secvenţei de vectori spaţiali 000-100-110-100-000, corespunzătoare primului sector, din care lipseşte vectorul 111, timpul lui de activare fiind acoperit de timpul mort.

Într-o a doua fază de testare, modulatorul a fost conectat la generatorul de semnale sinusoidale. În Fig. 5.28 este prezentată o captură de osciloscop a semnalelor de la ieşirea punţii invertoare, filtrate cu filtre trece-jos pasive. Se observă că formele de undă sunt la fel cu cele obţinute prin modulaţie sinusoidală cu injecţie de ZSS triunghiular din Fig. 5.18, evidenţiindu-se astfel prin rezultate experimentale echivalenţa celor două tehnici de modulaţie [137], [138].

156

Figura 5.28. Semnalele filtrate de la ieşirea punţii invertoare.

5.5 Comparaţie între cele două modulatoare În scopul comparării celor două modulatoare şi a alegerii celui mai potrivit pentru

integrarea în sistemul de control, ambele sisteme descrise au fost realizate cu aceeaşi precizie, de 18 biţi. Pentru rigurozitate, modulatorul sinusoidal cu injecţie de ZSS a fost realizat folosind formula (5.3), şi nu simplificarea (5.4). Acest lucru presupune un pas de calcul în plus, pentru determinarea valorii absolute. În Tabelul 5.5 sunt prezentate comparativ resursele ocupate de cele două sisteme.

Tabelul 5.5. Resursele ocupate de cele 2 sisteme cu modulator.

Sistem cu modulator Resurse

SPWM-ZSS SVM

LUT-uri cu 4 intrări 833 (8%) 957 (10%) Bistabili D 548 (5%) 585 (6%) Felii logice 560 (12%) 605 (12%)

Multiplicatoare 8 (40%) 9 (45%) Blocuri RAM 4 (20%) 4 (20%)

Frecvenţa maximă 90 MHz 124 MHz Se observă din Tabelul 5.5 că o scădere a preciziei calculelor de la 24 la 18 biţi pentru

modulatorul SVM conduce la o creştere semnificativă a frecvenţei de lucru, de la 77MHz la 124MHz.

157

Din Tabelul 5.5 rezultă, la prima vedere, că modulatorul SPWM-ZSS ar fi mai potrivit pentru implementarea în FPGA şi încorporarea într-un sistem de control datorită faptului că ocupă mai puţine resurse. Trebuie totuşi sesizat că în tabel sunt prezentate resursele ocupate de întreg sistemul, incluzând generatorul de semnal. Această observaţie este importantă, deoarece la integrarea într-un sistem de control acest modul dispare, semnalele fiind generate de către algoritmul de control. Pentru o comparaţie mai relevantă, în Tabelul 5.6 sunt prezentate comparativ doar modulatoarele, fără a include generatoarele de semnal. Se observă că cele două modulatoare ocupă cam aceleaşi resurse, modulatorul SVM fiind totuşi preferabil deoarece:

• Are nevoie de mai puţini paşi pentru a realiza calculele; • Are ca valori de intrare componentele α/β ale tensiunii trifazate; cum, în general,

sistemele de control performante pentru motoare de CA folosesc reprezentarea într-un sistem de referinţă bifazat legat de rotor, aceasta este mai apropiată de reprezentarea în sistemul bifazat legat de stator, α/β. Deci sistemul de control va avea nevoie de mai puţine operaţii pentru a trece de la reprezentarea internă la reprezentarea folosită de algoritmul SVM, decât pentru a ajunge de la reprezentarea internă la cea trifazată. Cu alte cuvinte, în cazul SPWM-ZSS va mai fi necesar cel puţin un pas de calcul, inversa transformării (5.19) din Fig. 5.25. Pe lângă timpul de calcul, această transformare implică şi utilizarea unor resurse suplimentare, inclusiv a 2 multiplicatoare.

• Foloseşte mai puţine multiplicatoare, 5 în loc de 6. Având în vedere şi punctul anterior, şi ţinând cont că multiplicatoarele sunt o resursă critică pe FPGA, acest punct este destul de important. Desigur, există metode de a multiplexa în timp folosirea resurselor hardware, în speţă a multiplicatoarelor, dar acest lucru implică complicarea sistemului şi introducerea unor paşi suplimentari de calcul.

• Funcţionează la o frecvenţă ceva mai mare. Deşi se poate îmbunătăţi frecvenţa de lucru şi pentru modulatorul SPWM-ZSS prin căutarea căilor critice şi inserarea de registre, acest lucru implică mărirea numărului de paşi ai algoritmului, deci implică un timp de calcul mai lung.

Tabelul 5.6. Resursele ocupate de cele 2 modulatore, fără modulul generator de semnal.

Modulator Resurse

SPWM-ZSS SVM

LUT-uri cu 4 intrări 737 (7%) 738 (7%) Bistabili D 439 (4%) 440 (4%) Felii logice 442 (9%) 421 (9%)

Multiplicatoare 6 (30%) 5 (25%) Blocuri RAM 0 (0%) 0 (0%)

Frecvenţa maximă 90 MHz 124 MHz Paşi de calcul 9 8

158

Este, aşadar, important de subliniat că algoritmul SVM este preferabil algoritmului SPWM-ZSS la implementarea pe FPGA. Singurul inconvenient este că dacă se doreşte o altă schemă de modulaţie, de exemplu folosind unul singur din vectorii nuli, algoritmul SVM se modifică total (se modifică formulele de calcul, deci şi calea de date). O altă schemă de modulaţie afectează doar o mică parte în algoritmul SPWM-ZSS, anume aceea de calculare a ZSS. Deci se poate considera că algoritmul SPWM-ZSS este mai flexibil.

5.6 Îmbunătăţirea rezoluţiei modulatorului SVM Problema modulatoarelor PWM, atât a celui sinusoidal cât şi a modulatorului SVM,

constă în faptul că rezoluţia cu care se pot obţine impulsurile PWM este limitată de rezoluţia numărătorului ce generează purtătoarea PWM. Aşa cum rezultă din (5.9), aceasta este invers proporţională cu frecvenţa semnalului purtător. Avem deci de-a face cu constrângeri contradictorii: pe de o parte, frecvenţa purtătoarei ar trebui să fie cât mai mare, pentru a scădea perioada de eşantionare a sistemului de control digital şi deci lăţimea sa de bandă; pe de altă parte, rezoluţia modulatorului ar trebui să fie cât mai mare, cel puţin egală cu rezoluţia senzorilor de curent şi viteză, pentru a avea un sistem de control stabil şi performant.

Din această cauză s-a căutat mereu îmbunătăţirea rezoluţiei modulatorului PWM prin alte metode decât scăderea frecvenţei purtătoarei. Cea mai simplă soluţie, vizibilă uşor şi din (5.9), constă în a creşte frecvenţa semnalului de tact aplicat numărătorului ce generează purtătoarea PWM. De obicei, această abordare nu este suficientă şi se caută îmbunătăţirea ei prin introducerea de întârzieri precise, ce reprezintă multipli ai unei fracţiuni din perioada semnalului de tact. Atunci când se utilizează dispozitive FPGA, aceste întârzieri pot fi obţinute cu precizie foarte ridicată folosind elementele de gestionare a semnalelor de tact integrate în FPGA [139], [140], [141], despre care s-a amintit în Secţiunea 2.2. Ca şi circuitele din familiile Xilinx prezentate în Secţiunea 2.2.2, şi circuitul Spartan-3E XC3S500E ce s-a folosit la experimente dispune de blocuri DCM.

În această secţiune se prezintă o generalizare a circuitului din [141], care are avantajul faţă de cele prezentate în [139] şi [140] că este sincron. Circuitul prezentat în [141] a fost modificat pentru a folosi purtătoarea PWM triunghiulară, a fost extins la 6 canale (fiecare tranzistor al punţii invertoare este controlabil independent) şi i s-a îmbunătăţit liniaritatea prin reproiectarea multiplexoarelor pentru o mai bună simetrie.

Circuitul prezentat în [141] foloseşte o purtătoare PWM cu formă de undă tip dinţi de fierăstrău, generată cu un numărător unidirecţional. Latch-ul de ieşire este setat la începutul perioadei PWM (odată cu resetarea numărătorului) şi este resetat după o anumită perioadă de timp, dată de o valoare a factorului de umplere reprezentată pe ncntr+3 biţi, unde ncntr este lăţimea ieşirii numărătorului. Circuitul foloseşte 3 blocuri DCM din dispozitivul Spartan-3E: unul pentru a multiplica frecvenţa semnalului de tact până la 200MHz, iar celelalte pentru a sincroniza impulsul de resetare a latch-ului de ieşire cu 8 semnale de tact defazate faţă de

159

semnalul de tact al sistemului, cu defazaje egal distribuite într-o perioadă a acestuia. Blocurile DCM din dispozitivele Spartan-3E oferă la ieşire, pe lângă semnalul de tact de intrare condiţionat, încă 3 semnale de tact derivate din acesta şi defazate faţă de acesta cu 90°, 180° şi respectiv 270°. În plus, semnalele de tact de ieşire pot fi defazate faţă de semnalul de intrare cu o valoare specificată printr-o constantă de 8 biţi [126]. Semnalul de reset se activează aşadar atunci când numărătorul ajunge la valoarea de prag (dată de cei mai semnificativi ncntr biţi din valoarea factorului de umplere) şi se scurge o anumită perioadă de la acest eveniment (perioada de defazaj), dată de cei mai puţin semnificativi 3 biţi din valoarea factorului de umplere. Perioada de defazaj este selectată folosind un multiplexor 8 la 1, a cărui intrare de selecţie este reprezentată de chiar cei 3 biţi.

Trebuie făcută observaţia că pentru o funcţionare corectă, în [141] semnalul de reset este trecut prin două bistabile pentru sincronizare. Aceasta implică faptul că valoarea factorului de umplere trebuie corectată prin scădere cu 8 înainte de utilizare.

Aşa cum s-a menţionat în Secţiunea 5.2.3, semnalul purtător triunghiular se obţine cu ajutorul unui numărător bidirecţional. Direcţia de numărare se schimbă atunci când se ating limitele de numărare. Limita inferioară este 0 (zero), iar limita superioară e dată de (5.9). Pentru o frecvenţă a semnalului de tact de 200MHz, limita superioară va fi 5000, numărătorul fiind pe 13 biţi.

Impulsurile PWM se obţin folosind purtătoarea triunghiulară prin compararea unei valori de prag atât cu panta crescătoare a semnalului purtător (la momentul intersecţiei se setează latch-ul de ieşire), cât şi cu panta descrescătoare (la momentul intersecţiei se resetează latch-ul). Astfel, proporţia dintre valoarea de prag şi valoarea maximă a semnalului purtător va reprezenta factorul de umplere.

Această funcţionare este combinată cu cea prezentată în [141] pentru a creşte rezoluţia modulatorului la 16 biţi. Astfel, valoarea de prag va fi constituită din cei mai semnificativi 13 biţi, iar cei mai puţin semnificativi 3 vor fi folosiţi pentru selecţia semnalului de setare sau resetare defazat.

Corecţia valorii de prag este ceva mai complicată: pentru panta crescătoare a purtătoarei, se scade 2 din valoarea de prag. Pentru panta descrescătoare a purtătoarei, însă, apar două cazuri distincte: (i) când cei mai puţin semnificativi 3 biţi sunt toţi 0 (zero), defazajul este 0(zero) şi valoarea de prag trebuie ajustată prin adunare cu 1; (ii) când cei mai puţin semnificativi 3 biţi nu sunt toţi 0(zero), valoarea de prag trebuie ajustată prin adunare cu 2, iar defazajul va avea o valoare invers proporţională cu valoarea reprezentată de cei 3 biţi.

Fig. 5.29 prezintă un exemplu concret de funcţionare, iar Fig. 5.30 prezintă circuitul proiectat.

În Fig. 5.29, semnalul SET_G_HS este activat când numărătorul atinge valoarea 4997 incrementându-se, valoare dată de cei mai semnificativi 13 biţi din valoarea de prag. Acest semnal este sincronizat cu 8 semnale de tact defazate, iar semnalul SET_G_2 este semnalul SET_G_HS sincronizat cu un semnal de tact defazat cu 90°.

160

Figura 5.29. Exemplu de funcţionare pentru o valoare de prag 39978=4997*8+2.

Semnalul RST_G_HS este activat când numărătorul atinge valoarea 4997

decrementându-se. Semnalul RST_G_6 corespunde semnalului RST_G_HS sincronizat cu semnalul de tact defazat cu 270°. Semnalele SET_G_2 şi RST_G_6 sunt selectate ca semnale de set şi reset pentru latch-ul de ieşire prin intermediul a 2 multiplexoare, selecţia acestora fiind dată de cei mai puţin semnificativi 3 biţi, având valoarea 2. Intrările în multiplexoare sunt ordonate diferit, după cum se observă din Fig. 5.30.

Semnalul G_HS este semnalul de ieşire, şi se observă întârzierile introduse de timpii de propagare prin multiplexoare. Dacă timpii de propagare sunt simetrici, nu vor afecta perioada de “ON” a tranzistorului, adică factorul de umplere al semnalului PWM. Vor introduce în schimb un defazaj între semnalul purtător şi semnalele de control ale tranzistoarelor, dar acesta nu va afecta comportarea per ansamblu a modulatorului, fiind acelaşi pe toate canalele.

161

Figura 5.30. Schema de principiu a circuitului generator de PWM cu rezoluţie înaltă. În Fig. 5.30 blocurile DCM, numărătorul şi cei 4 bistabili din partea de sus sunt pilotaţi

de acelaşi semnal de tact de 200MHz, ce nu mai este reprezentat pentru a nu încărca figura. Cei 16 bistabili din partea de jos sincronizează semnalele de set şi reset cu 8 semnale de tact defazate de către blocurile DCM. Bistabilii din FPGA permit selectarea frontului de tact la care reacţionează [126], deci s-au folosit doar câte două ieşiri din fiecare DCM. Acest lucru oferă două avantaje majore: (i) este eliminată o sursă de posibile asimetrii datorită defazajelor imperfecte; (ii) toate semnalele de tact pot folosi resurse de rutare globale speciale (numărul buffer-elor speciale de tact este redus), asigurându-se întârzieri minime pe liniile de tact.

Spre deosebire de circuitul prezentat în [141], aici atât semnalul de set, cât şi cel de reset trec prin câte un multiplexor, ceea ce ar trebui să îmbunătăţească comportarea circuitului. Cu toate acestea, măsurătorile efectuate cu osciloscopul pe circuitul implementat în FPGA au revelat

162

asimetrii semnificative, după cum se poate vedea din Tabelul 5.7. Se observă că diferenţele între valori consecutive de prag, care erau acceptabile în [141], sunt semnificative aici. De asemenea, se observă o asimetrie destul de mare în ultima coloană din tabel, ce calculează diferenţa între perioada “ON” corespunzătoare valorii de prag de pe linia respectivă şi cea de pe linia anterioară, în care valorile ar trebui să fie cât mai apropiate de rezoluţia modulatorului, de 1.3ns.

Tabelul 5.7. Măsurători ale factorului de umplere, în prima fază de proiectare.

Valoarea de prag

Perioada “ON” teoretică (ns)

Perioada “ON” măsurată (ns)

Δt “ON” (ns)

39976 35 34.973 39977 33.7 32.854 2.119 39978 32.4 31.933 0.921 39979 31.1 29.877 2.056 39980 29.8 29.552 0.325 39981 28.5 28.654 0.898 39982 27.2 27.303 1.351 39983 25.9 26.262 1.041

Această asimetrie în măsurători e cauzată de modul cum se implementează

multiplexoarele 8 la 1 în FPGA. O privire mai atentă asupra arhitecturii CLB-ului din FPGA-ul folosit [126] conduce la observaţia că multiplexorul este implementat pe două felii logice diferite, ca în Fig. 5.31. Unele intrări se propagă printr-o singură felie logică, în timp ce altele se propagă prin 2 felii şi prin interconexiunile dintre ele. La aceasta se adaugă faptul că intrările în multiplexoarele pentru set şi reset sunt ordonate diferit, deci aceste asimetrii se pot cumula sau compensa, conducând la valori şi mai eronate.

Pentru a elimina acest neajuns, s-a intervenit manual în proiectarea multiplexorului: multiplexorul 8 la 1 a fost înlocuit de o construcţie formată din 2 multiplexoare 4 la 1 şi o componentă de bibliotecă F5MUX.

Având în vedere structura feliilor logice, această mică modificare în schemă forţează implementarea simetrică pe trei felii logice, ca în Fig. 5.32. Deoarece F5MUX se află într-o felie logică la ieşirea LUT-urilor, ieşirile primelor două felii trebuie să treacă (transparent) prin LUT-urile celei de-a treia. Acest lucru introduce o întârziere în plus, dar nu afectează funcţionarea modulatorului.

163

Figura 5.31. Implementarea implicită a unui multiplexor 8 la 1 în FPGA, folosind 2 felii logice.

Figura 5.32. Forţarea implementării simetrice a multiplexorului 8 la 1 în FPGA.

Noul concept a fost implementat în FPGA. Testele efectuate, prezentate în Tabelul 5.8,

demonstrează o îmbunătăţire semnificativă a comportării circuitului. Măsurătorile din Tabelul 5.8 au fost făcute cu un singur canal PWM implementat. După implementarea tuturor celor 6 canale, măsurătorile au arătat o mică deviaţie, datorată atât propagării diferite a semnalului de

164

tact, cât şi faptului că traseele între feliile logice devin mai lungi şi mai neuniforme. Deviaţia este însă nesemnificativă.

Tabelul 5.8. Măsurători ale factorului de umplere, în a doua fază de proiectare.

Valoarea de prag

Perioada “ON” teoretică (ns)

Perioada “ON” măsurată (ns)

Δt “ON” (ns)

39976 35 35.086 39977 33.7 33.604 1.482 39978 32.4 32.379 1.225 39979 31.1 31.144 1.235 39980 29.8 29.671 1.473 39981 28.5 28.535 1.136 39982 27.2 27.407 1.128 39983 25.9 26.332 1.075

Pentru testare, circuitele prezentate, proiectate prin captură de schemă, au fost

implementate în FPGA. Folosind un osciloscop cu lăţime de bandă mare, de 500MHz, s-au efectuat măsurătorile prezentate în Tabelele 5.7 şi 5.8.

Fig. 5.33 prezintă o captură de osciloscop. Primul canal este un semnal activat când se atinge vârful semnalului purtător (valoarea

maximă în numărător), iar al doilea canal (în partea cea mai de jos) reprezintă semnalul de activare a tranzistorului pentru o valoare de prag de 39983. Celelalte două forme de undă sunt salvări ale canalului 2 pentru alte valori de prag, afişate din memoria osciloscopului.

Modulatorul SVM, îmbunătăţit cu circuitul prezentat în această secţiune, a fost testat pentru comanda simplă, în buclă deschisă, după metoda V/Hz, a unui motor de inducţie, comandat de o punte invertoare trifazată cu IGBT-uri (Fig. 5.34). S-a putut astfel verifica experimental corectitudinea funcţionării modulatorului proiectat.

165

Figura 5.33. Captură pe osciloscop a semnalului PWM de ieşire.

Figura 5.34. Standul experimental cu punte invertoare de putere şi motor de inducţie.

5.7 Concluzii În acest capitol s-au prezentat două metode de modulaţie PWM folosite în controlul

punţii invertoare trifazate: modulaţia PWM sinusoidală cu injecţie de semnal triunghiular la punctul neutru şi modulaţia bazată pe vectori spaţiali. Din punctul de vedere al rezultatului, metodele sunt echivalente. Din punctul de vedere al implementării, însă, cele două metode sunt foarte diferite: în vreme ce modulaţia PWM sinusoidală este foarte veche, fiind iniţial implementată folosind componente analogice, modulaţia bazată pe vectori spaţiali este relativ recentă, apărând odată cu evoluţia sistemelor de control digitale şi fiind apanajul acestora.

După prezentarea generală a metodelor de modulaţie, s-a făcut o analiză a lor din punctul de vedere al implementării pe FPGA. S-au proiectat, într-o manieră originală, modulatoarele corespunzătoare, ţinând cont de posibilităţile de paralelizare a operaţiilor în FPGA. Pentru

166

proiectare, s-a folosit mediul Simulink şi software-ul System Generator, ceea ce a permis validarea conceptului prin simulare.

Fiecare modulator a fost integrat într-un sistem de testare, conţinând un generator controlat de semnal trifazat, respectiv bifazat. Astfel, s-au putut verifica experimental. Experimentele au dovedit echivalenţa funcţională a celor două metode de modulaţie.

Cele două modulatoare au fost comparate din punctul de vedere al resurselor ocupate şi al vitezei de lucru. Deşi ambele modulatoare ocupă cam aceeaşi cantitate de resurse logice din FPGA, modulatorul bazat pe vectori spaţiali s-a dovedit mai potrivit pentru integrare într-un sistem de control pentru un motor de CA trifazat datorită faptului că se execută în mai puţini paşi, foloseşte mai puţine multiplicatoare dedicate (o resursă critică în FPGA-urile de cost redus) şi se aplică direct componentelor α/β ale tensiunii de intrare. Această concluzie este semnificativă, deoarece multe abordări din literatură [42], [57], [142] preferă modulaţia sinusoidală sub pretextul că este mai uşor de implementat.

În final, s-a realizat îmbunătăţirea la 16 biţi a rezoluţiei modulatorului PWM prin folosirea a trei blocuri DCM şi a unei scheme originale. Schema a fost obţinută în doi paşi, prin reproiectarea uneia prezentate în literatură astfel încât să funcţioneze cu semnal purtător triunghiular.

Modulatorul SVM prezentat aici a fost prezentat în [143]. O modificare a acestuia, cu folosirea doar a vectorului nul 000, a fost prezentată în [144]. Modulatorul SPWM-ZSS a fost prezentat în [145]. Schema pentru creşterea rezoluţiei modulatorului PWM a fost publicată în [143].

167

6. Proiectarea unui sistem de control al vitezei pentru motorul PMSM implementabil în hardware pe FPGA

Pentru a se putea proiecta un sistem de control al vitezei eficient, se va discuta mai întâi

modelarea motorului PMSM.

6.1 Modelarea motorului PMSM Motorul sincron cu magneţi permanenţi este un motor fără perii cu distribuţie sinusoidală

a înfăşurărilor statorului. Din acest motiv, mai este cunoscut în literatură sub denumirea de motor fără perii de CA, sau motor BLAC (Brushless AC). Spre deosebire de motorul BLDC, în care o tensiune continuă se comută în anumite înfăşurări ale statorului în funcţie de poziţia rotorului, într-un PMSM tensiunea în înfăşurări trebuie să fie sinusoidală. Amplitudinea şi frecvenţa acestei tensiuni este legată de viteza rotorului, iar faza sinusului trebuie să fie în concordanţă cu poziţia rotorului.

Un PMSM cu doi poli rotorici şi trei înfăşurări statorice este reprezentat în Fig. 6.1 [147], iar Fig. 6.2 prezintă circuitul electric echivalent. În Fig. 6.2, sr reprezintă rezistenţa înfăşurării

statorice, sN reprezintă numărul de spire al înfăşurării, csbsas vvv ,, reprezintă căderile de

tensiune pe înfăşurările notate cu csbsas ,, în Fig. 6.1, iar csbsas iii ,, reprezintă curenţii prin

înfăşurări. În Fig. 6.1 se observă că perpendicular pe cele 3 înfăşurări statorice se definesc 3 axe. Paralel cu polii magnetici ai rotorului, pe direcţia polului nord, se defineşte axa d, iar perpendicular pe aceasta, în direcţia acelor de ceasornic, axa q. Poziţia rotorului faţă de stator se defineşte prin unghiul dintre axele q şi as, rθ , iar viteza unghiulară a rotorului se notează rω .

168

Figura 6.1. Reprezentarea schematică a unui PMSM [147].

Figura 6.2. Circuitul electric echivalent al unui PMSM [147].

Ecuaţiile electrice ale motorului sunt:

⎥⎥⎥⎥⎥⎥

⎦

⎤

⎢⎢⎢⎢⎢⎢

⎣

⎡

+′

−′

′

+⎥⎥⎥

⎦

⎤

⎢⎢⎢

⎣

⎡

⎥⎥⎥⎥⎥⎥

⎦

⎤

⎢⎢⎢⎢⎢⎢

⎣

⎡

+−−

−+−

−−+

+⎥⎥⎥

⎦

⎤

⎢⎢⎢

⎣

⎡

⎥⎥⎥

⎦

⎤

⎢⎢⎢

⎣

⎡=

⎥⎥⎥

⎦

⎤

⎢⎢⎢

⎣

⎡

)3

2sin(

)3

2sin(

sin

21

21

21

21

21

21

000000

πθλ

πθλ

θλ

rm

rm

rm

cs

bs

as

AlsAA

AAlsA

AAAls

cs

bs

as

s

s

s

cs

bs

as

dtd

iii

LLLL

LLLL

LLLL

dtd

iii

rr

r

vvv

,

(6.1)

unde lsL este inductanţa de pierdere (leakage) a înfăşurării statorice, mλ′ este amplitudinea

legăturilor de flux stabilite de magneţii permanenţi, iar

169

grlN

L sA

02

2πμ

⎟⎠

⎞⎜⎝

⎛= , (6.2)

este definit pentru a exprima mai uşor inductanţele proprii şi mutuale ale statorului în a doua matrice din (6.1). În (6.2), 0μ este permeabilitatea magnetică a vidului (şi o aproximează pe cea

a aerului), r este raza internă a statorului, l este lungimea axială a motorului, iar g reprezintă grosimea spaţiului dintre rotor şi stator (air gap). Se presupune că spaţiul dintre rotor şi stator este uniform, adică rotorul este rotund. În caz contrar, inductanţele maşinii vor avea încă o componentă, variabilă, dependentă de unghiul dintre stator şi rotor.

Cuplul electromagnetic este dat de:

]sin)(23cos)

21

21[(

2 rcsbsrcsbsasme iiiiiPT θθλ −+−−′= , (6.3)

unde P este numărul de poli magnetici ai rotorului. Şi formula (6.3) este valabilă dacă rotorul este perfect rotund, altfel trebuind introduse

componente datorate inductanţelor variabile. Ecuaţia mecanică a motorului este dată de relaţia:

Lrre TP

Fdtd

PJT ++= ωω 22 , (6.4)

unde J este momentul de inerţie a rotorului şi a sarcinii, F este factorul de fricţiune, iar LT este

cuplul mecanic de încărcare. Relaţiile (6.1) şi (6.3), ce modelează motorul PMSM, au dezavantajul major că mărimile

electrice şi mecanice depind de poziţia rotorului. În cazul în care rotorul nu ar fi rotund, lucrurile ar fi şi mai complicate, deoarece în (6.1) şi (6.3) ar apărea şi inductanţe variabile în funcţie de poziţia rotorului. În aceste condiţii proiectarea unui sistem de control pentru PMSM este foarte dificilă.

O cale de a evita lucrul cu mărimile variabile în timp este aceea, propusă de R. H. Park încă din 1929, de a realiza o transformare de coordonate din sistemul de coordonate trifazat legat de stator în sistemul bifazat legat de rotor. Astfel, aplicând matricea de transformare

⎥⎥⎥⎥⎥⎥

⎦

⎤

⎢⎢⎢⎢⎢⎢

⎣

⎡

−−

+−

=

21

21

21

)3

2sin()3

2sin(sin

)3

2cos()3

2cos(cos

32 πθπθθ

πθπθθ

sK , (6.5)

vectorilor mărimilor trifazate se obţin reprezentările lor în sistemul de coordonate q/d:

⎥⎥⎥

⎦

⎤

⎢⎢⎢

⎣

⎡⋅=

⎥⎥⎥

⎦

⎤

⎢⎢⎢

⎣

⎡

cs

bs

as

s

s

ds

qs

vvv

Kvvv

0

, (6.6)

170

⎥⎥⎥

⎦

⎤

⎢⎢⎢

⎣

⎡⋅=

⎥⎥⎥

⎦

⎤

⎢⎢⎢

⎣

⎡

cs

bs

as

s

s

ds

qs

iii

Kiii

0

. (6.7)

Aplicând transformarea dată de (6.5) întregii ecuaţii electrice a motorului (6.1), rezultă:

⎥⎥⎥

⎦

⎤

⎢⎢⎢

⎣

⎡′+

⎥⎥⎥

⎦

⎤

⎢⎢⎢

⎣

⎡

⎥⎥⎥

⎦

⎤

⎢⎢⎢

⎣

⎡+

⎥⎥⎥

⎦

⎤

⎢⎢⎢

⎣

⎡−

′++

⎥⎥⎥

⎦

⎤

⎢⎢⎢

⎣

⎡

⎥⎥⎥

⎦

⎤

⎢⎢⎢

⎣

⎡=

⎥⎥⎥

⎦

⎤

⎢⎢⎢

⎣

⎡

0

0

000000

0000000

000

m

s

ds

qs

ls

d

q

qsq

mdsd

r

s

ds

qs

s

s

s

s

ds

qs

dtd

iii

LL

L

dtdiL

iL

iii

rr

r

vvv

λλ

ω ,

(6.8)

unde Alsq LLL23

+= este inductanţa echivalentă pe axa q, iar dL este inductanţa echivalentă pe

axa d şi este egală cu qL în cazul PMSM cu rotor rotund. Dacă rotorul nu este rotund, cele două

inductanţe echivalente nu mai sunt egale, dar sunt în orice caz invariabile. Ecuaţia (6.8) poate fi explicitată în:

qsqmrdsdrqssqs idtdLiLirv +′++= λωω , (6.9)

dsdqsqrdssds idtdLiLirv +−= ω , (6.10)

slssss idtdLirv 000 += . (6.11)

Aplicând transformarea dată de (6.5) ecuaţiei de cuplu a motorului (6.3) se obţine [147]:

))((22

3dsqsqdqsme iiLLiPT −+′= λ . (6.12)

Se observă că în cazul PMSM cu rotor rotund, cum inductanţele echivalente pe cele două axe sunt egale, (6.12) se simplifică în:

qsme iPT λ′=22

3 . (6.13)

Aşadar, lucrând în sistemul de coordonate q/d, ecuaţiile electrice ale motorului nu mai conţin mărimi dependente de poziţia rotorului. De asemenea, ecuaţia de cuplu se simplifică foarte mult. Transformarea sistemului de coordonate se dovedeşte astfel crucială pentru proiectarea unui sistem de reglare a cuplului sau vitezei motorului PMSM.

Deoarece alegerea direcţiei axelor q/d este arbitrară, este destul de răspândită în literatură şi abordarea în care axa q este aleasă opus faţă de prezentarea din Fig. 6.1. În acest caz, matricea de transformare (6.5) devine:

171

⎥⎥⎥⎥⎥⎥

⎦

⎤

⎢⎢⎢⎢⎢⎢

⎣

⎡

−−−−−

+−

=

21

21

21

)3

2sin()3

2sin(sin

)3

2cos()3

2cos(cos

32 πθπθθ

πθπθθ

sK . (6.14)

În continuare se va utiliza această formă a transformării, iar toate referirile la matricea

sK vor presupune forma din (6.14).

În literatură, transformarea din sistemul trifazat fixat pe stator în sistemul bifazat rotitor fixat pe rotor dată de (6.14) este adesea văzută ca o serie de 2 transformări succesive. Prima este transformata Clarke, din sistemul trifazat fixat pe stator într-un sistem bifazat fixat tot pe stator. Această transformare corespunde echivalării maşinii trifazate cu una bifazată, abordare foarte folosită pentru simplificarea analizei maşinii [148]. Transformata Clarke este descrisă de matricea de transformare:

⎥⎥⎥⎥⎥⎥

⎦

⎤

⎢⎢⎢⎢⎢⎢

⎣

⎡

−

−−

=

21

21

21

23

230

21

211

32C . (6.15)

Matricea este 3x3, ceea ce înseamnă că în urma transformării rezultă 3 componente, şi nu două, componentele α/β. Cea de-a treia componentă este secvenţa de zero şi este de obicei nulă, deoarece suma celor 3 curenţi din înfăşurările unui motor este nulă dacă punctul neutru al motorului (punctul de conectare în stea) este izolat.

A doua transformare, transformarea Park, conduce de la sistemul de coordonate α/β, fix, legat de stator, la un sistem de coordonate tot bifazat, dar legat de rotor, rotindu-se sincron cu acesta, q/d. Transformarea Park este dată de matricea:

⎥⎥⎥

⎦

⎤

⎢⎢⎢

⎣

⎡−=

1000cossin0sincos

θθθθ

P . (6.16)

Se observă din (6.16) că secvenţa de zero rămâne nemodificată prin transformarea Park şi nu influenţează celelalte componente.

Dacă se efectuează calculele, se poate verifica faptul că transformarea iniţială este echivalentă cu transformările Clarke şi Park efectuate succesiv, adică

CPKs ⋅= . (6.17)

Transformărilor directe le corespund transformări inverse, date de inversele matricelor prezentate:

172

⎥⎥⎥⎥⎥⎥

⎦

⎤

⎢⎢⎢⎢⎢⎢

⎣

⎡

+−+

−−−

−

=−

1)3

2sin()3

2cos(

1)3

2sin()3

2cos(1sincos

1

πθπθ

πθπθθθ

sK , (6.18)

⎥⎥⎥⎥⎥⎥

⎦

⎤

⎢⎢⎢⎢⎢⎢

⎣

⎡

−−

−=−

123

21

123

21

1011C , (6.19)

⎥⎥⎥

⎦

⎤

⎢⎢⎢

⎣

⎡ −=−

1000cossin0sincos

1 θθθθ

P . (6.20)

Din nou, se poate arăta că

111 −−− ⋅= PCKs . (6.21)

Aşadar, motorul PMSM cu rotor rotund poate fi modelat foarte convenabil în sistemul de coordonate q/d, fiind descris de ecuaţiile electrice (6.9), (6.10) (ecuaţia (6.11) poate fi ignorată, deoarece componenta secvenţă de zero este nulă), de ecuaţia de cuplu (6.13) şi de ecuaţia mecanică (6.4). Se observă că ecuaţiile (6.13) şi (6.4) sunt liniare. Ecuaţiile (6.9) şi (6.10) sunt neliniare, existând un cuplaj între componentele q şi d.

6.2 Proiectarea sistemului de control al vitezei pentru motorul PMSM Aşa cum motorul se modelează uşor în sistemul de coordonate q/d, şi sistemul de control

se modelează în acelaşi sistem. Dar din cauză că motorul este controlat prin intermediul tensiunilor aplicate pe cele trei faze, iar bucla de reacţie foloseşte senzori pentru a măsura curenţii ce trec prin cele trei înfăşurări, algoritmul de control trebuie să efectueze transformările între sistemul de coordonate trifazat fixat pe stator şi sistemul de coordonate bifazat rotitor sincron cu rotorul în timp real.

În sistemul de coordonate q/d ecuaţiile electrice ale motorului descriu funcţii de transfer de ordinul I, dacă se elimină cuplajul ce apare între cele 2 axe şi componenta datorată tensiunii electromotoare induse. Cel mai adesea sunt folosite regulatoare simple de tip PI (proporţional-integrator) pentru controlul curenţilor prin motor [149].

Conform (6.4), viteza este controlată prin intermediul cuplului electromagnetic, iar acesta este controlat, conform (6.13), controlând componenta de pe axa q a curentului. Curentul pe axa d este menţinut la 0 (zero) pentru viteze mai mici decât viteza nominală a motorului. Curenţii pe

173

axele q şi d sunt controlaţi prin intermediul tensiunilor pe axele q şi d, conform (6.9) şi (6.10). Algoritmul de control trebuie să compenseze cuplajul dintre cele două axe ce apare în aceste ecuaţii, precum şi componenta datorată tensiunii electromotoare induse ce apare în (6.9).

Din cauză că de obicei momentul de inerţie al motorului are valori mult mai mari decât factorul de fricţiune, făcându-l pe acesta din urmă practic neglijabil, partea mecanică a motorului are o comportare aproape de a unui integrator, ceea ce face dificilă alegerea parametrilor unui regulator PI pentru viteză. Din acest motiv, în literatură s-a propus utilizarea unui regulator cu buclă dublă de reacţie, de tip PI-P [150]. Această abordare îmbunătăţeşte performanţele sistemului, cu dezavantajul creşterii complexităţii algoritmului de control.

Această metodă de control a motoarelor sincrone în spaţiul q/d este cunoscută sub denumirea de control orientat după câmp (FOC – Field Orientated Control) [151] sau control vectorial [152], [153].

Fig. 6.3 prezintă schema bloc a sistemului de control al vitezei pentru motorul PMSM, aşa cum rezultă în urma discuţiei din paragrafele de mai sus. Motorul este alimentat de o punte invertoare trifazată (VSI). Aceasta este controlată prin modulaţie bazată pe vectori spaţiali (SVM sau SVPWM), iar algoritmul de modulaţie foloseşte componentele α/β ale tensiunii de referinţă.

Pentru reacţie, pe lângă curenţii ce trec prin înfăşurările motorului, se foloseşte informaţia despre poziţia rotorului derivată cu ajutorul unui codificator optic cu ieşiri digitale în cuadratură. Ieşirile acestuia (cele două semnale în cuadratură şi un impuls de index) sunt prelucrate pentru a obţine unghiul şi viteza rotorului, ambele necesare în algoritmul de control.

Figura 6.3. Schema de control al vitezei pentru motorul PMSM.

174

6.2.1 Alegerea parametrilor pentru regulatoarele de curent

Pentru ambele regulatoare de curent s-a aplicat aceeaşi metodă de proiectare analitică. Se

va prezenta aşadar detaliat doar proiectarea regulatorului pentru curentul de pe axa q. După decuplare, ce echivalează cu eliminarea termenilor ce conţin rω din ecuaţia (6.9),

aceasta devine o ecuaţie diferenţială liniară de ordinul I. Considerând curentul ca variabilă de ieşire şi tensiunea ca variabilă de intrare şi aplicând transformata Laplace, din (6.9) se derivă funcţia de transfer echivalentă părţii electrice a motorului pe axa q:

srLr

sG

s

q

sq

+=

1

1

)( . (6.22)

Punând funcţia de transfer a regulatorului PI sub forma:

ss

KsGi

iPIPI ττ 1

)(+

= , (6.23)

parametrul iτ se va alege astfel încât să compenseze polul funcţiei )(sGq :

s

qiq r

L=τ . (6.24)

Funcţia de transfer în buclă închisă se reduce la:

11

1

1)(+

=+

=s

sK

rsG

q

PIq

siqcq ττ

. (6.25)

Această funcţie de transfer descrie un element de întârziere de ordinul I şi poate fi ajustată pentru comportarea dorită a sistemului. Deşi este posibil să se aleagă o constantă de timp foarte mică, de ordinul microsecundelor, minimizând timpul de răspuns al sistemului, trebuie ţinut cont de faptul că sistemul va fi implementat digital, în timp discret. Deci constanta de timp nu trebuie să fie mai mică sau comparabilă cu perioada de eşantionare, deoarece în acest caz sistemul de control nu va putea observa comportarea sistemului controlat şi semnalul de comandă va fi eronat.

Perioada de eşantionare a sistemului este dată de către frecvenţa purtătoarei modulatorului SVM. Aceasta a fost fixată pentru experimente la 20kHz, rezultând perioada de eşantionare

sTs μ50= . (6.26)

175

Constanta de timp a sistemului în buclă închisă a fost aleasă de 4 ori mai mare decât perioada de eşantionare, rezultând pentru parametrul PIK :

s

qPIq T

LK

4= . (6.27)

În mod asemănător, pentru regulatorul de curent de pe axa d rezultă parametrii:

s

did r

L=τ , (6.28)

s

dPId T

LK

4= . (6.29)

6.2.2 Alegerea parametrilor pentru regulatorul de viteză

Considerând că motorul PMSM are rotorul rotund, iar cuplul de încărcare este constant în

regim staţionar (este văzut ca mărime de perturbaţie, nu ca mărime de intrare), din (6.13) şi (6.4) rezultă funcţia de transfer pentru partea mecanică a motorului, având la intrare curentul pe axa q şi la ieşire viteza:

11

43

)(+

=+

′=

sK

sFJFP

sGm

ω

ωω τ

λ. (6.30)

După cum se poate vedea şi din Fig. 6.3, sistemul de control al vitezei conţine două bucle de reacţie şi două regulatoare, unul de tip P şi unul de tip PI. Sistemul de control se va proiecta deci în doi paşi. Mai întâi, regulatorul de tip P va poziţiona polii sistemului în buclă închisă. Pentru alegerea factorului de amplificare al regulatorului P, notat cu ωK ′ , se pleacă de la funcţia

de transfer a sistemului în buclă deschisă, considerând pentru partea electrică funcţia de transfer din (6.25):

111)(

++′=

sK

sKsG

qo

ω

ωωω ττ

. (6.31)

Având în vedere că qττω >> (datorită faptului că momentul de inerţie al motorului este

mult mai mare decât factorul de fricţiune, ωτ are valori foarte mari), rezultă că se poate

aproxima ωω τττ ≅+ q şi funcţia de transfer în buclă închisă devine:

176

ω

ωω

ω

ωω

ω

τττ

ττ

qq

qc KK

ss

KK

sG′

++

′

=1

)(2

. (6.32)

Factorul de amplificare pentru regulatorul P se alege astfel încât funcţia de transfer în

buclă închisă să aibă un pol dublu în q

sτ21

−= :

.34 qmq P

JK

Kτλτ

τ

ω

ωω ′

==′ (6.33)

Următorul pas constă în alegerea parametrilor regulatorului PI. Ca şi la regulatorul de curent, parametrul iτ se va alege astfel încât să anuleze un pol al funcţiei )(sGcω :

qi ττ ω 2= . (6.34)

Funcţia de transfer în buclă deschisă rămasă este:

.)12(

1)(1 +=

ssKsG

qiPIo ττ ωωω (6.35)

Rezultă o funcţie de transfer în buclă închisă ce descrie un sistem de ordinul II:

.

421

14

)(

2221

q

PI

qq

PIc K

ss

KsG

τττ ω

ωω

++= (6.36)

Factorul de amplificare ωPIK se determină în funcţie de comportarea dorită a sistemului.

Se preferă de obicei alegerea unui sistem cu doi poli reali, din care unul dominant, deoarece acesta poate fi aproximat cu un sistem de ordinul I. Este posibil şi să se aleagă un sistem cu doi poli complex conjugaţi, dar acesta este caracterizat de doi parametri, pulsaţia naturală şi factorul de amortizare; de obicei, nu se pot seta convenabil ambii parametri folosind o singură variabilă,

ωPIK .

6.3 Validarea sistemului de control în continuu Sistemul de control proiectat conform secţiunii anterioare a fost implementat în Simulink

şi verificat prin simulare, folosind un model al motorului PMSM din librăria SimPowerSystems. S-au folosit parametrii motorului Pittman 3441 de 19.1V. Schema Simulink a sistemului de reglare în acest stadiu este prezentată în Fig. 6.4. Parametrii motorului sunt prezentaţi în Fig. 6.5 aşa cum apar în fereastra Simulink de configurare a modelului PMSM.

177

Figura 6.4. Schema Simulink a sistemului de reglare.

Figura 6.5. Parametrii motorului PMSM Pittman 3441.

178

Puntea invertoare ce alimentează motorul este înlocuită în acest stadiu al simulării de surse controlate de tensiune tot din librăria SimPowerSystems. Acestea primesc la intrare valori corespunzând celor trei tensiuni sinusoidale va, vb, vc. Se observă că sistemul de control realizează atât transformarea directă din sistemul de coordonate trifazat legat de stator în sistemul de coordonate bifazat rotitor sincron cu rotorul, abc2qd, pentru a putea lucra în spaţiul q/d, cât şi transformarea inversă din sistemul de coordonate q/d în sistemul trifazat, qd2abc, pentru a putea comanda motorul. Aceste transformări se folosesc de poziţia rotorului, prin funcţiile sin şi cos aplicate unghiului măsurat.

Trebuie precizat că unghiul măsurat este unghiul mecanic al rotorului ( mθ ), iar acesta

diferă de unghiul electric ( eθ ). Această diferenţă apare şi în ceea ce priveşte viteza, şi este dată

de numărul de poli magnetici ai rotorului:

,2 mePθθ = (6.37)

.2 mePωω = (6.38)

În toate ecuaţiile motorului s-au considerat mărimile electrice, deci acestea trebuie obţinute de către sistemul de control din mărimile mecanice măsurabile.

Ţinând cont de parametrii motorului, pentru regulatoarele de curent s-au obţinut următorii parametri, conform (6.24), (6.26), (6.27):

00017524.0== idiq ττ , (6.39)

.3.2== PIdPIq KK (6.40)

Factorii de amplificare pentru elementele proporţional şi integrator ale regulatoarelor rezultă:

,3.2== PdPq KK (6.41)

.13125== IdIq KK (6.42)

Într-o primă fază de validare, regulatoarele de curent au fost testate separat, prin întreruperea buclei de reglare a vitezei şi impunerea unei referinţe de curent. Schema în Simulink pentru verificarea regulatorului de curent pentru axa q este prezentată în Fig. 6.6, împreună cu răspunsul în curent la o referinţă de tip treaptă cu o valoare de 0.75A. Se observă caracteristica de sistem de ordin I, cu un timp de creştere de aproximativ 0.8ms, deci caracterizat de o constantă de timp de aproximativ 0.2ms. Aceasta este deci de 4 ori mai mare decât perioada de eşantionare ce va fi folosită pentru sistemul discret în timp, dată de (6.26). În Fig. 6.7 sunt prezentate formele de undă ale curenţilor prin cele 3 faze ale motorului. Se observă că aceştia sunt aproximativ sinusoidali în regim pseudo-staţionar (regimul nu este staţionar, deoarece viteza motorului continuă să crească atunci când curentul pe axa q este constant), iar în regimul

179

tranzitoriu reprezentat de prima 1ms de la începerea simulării, curentul prin faza a are aceeaşi comportare ca şi curentul pe axa q, iar curenţii prin fazele b şi c sunt aproximativ egali între ei, opuşi curentului prin faza a.

În a doua fază de validare, a fost simulată şi bucla de reglare a vitezei. Parametrii regulatoarelor au fost determinaţi ţinând cont de parametrii motorului. Astfel, pentru bucla internă, factorul de amplificare al regulatorului de tip P rezultă conform (6.33):

.0.0571=′ωK (6.43)

Pentru bucla externă, parametrul ωτ i rezultă conform (6.34):

00035048.0=ωτ i . (6.44)

Figura 6.6. Schema Simulink pentru verificarea regulatorului de curent pe axa q.

Figura 6.7. Curenţii prin cele trei faze ale motorului în regim pseudo-staţionar şi tranzitoriu.

180

Parametrul ωPIK se alege astfel încât sistemul în buclă închisă rezultat să aibă un timp

de creştere de aproximativ 15ms la o comandă de tip treaptă. În aceste condiţii, sistemul rezultat este de ordin II, având poli reali în s=-330 şi s=-2523, deci cu un pol dominant.

.1024.0=ωPIK (6.45)

Rezultă pentru regulatorul PI parametrii:

,1024.0=ωPK (6.46)

.256=ωIK (6.47)

Răspunsul la treaptă al sistemului rezultat teoretic, plotat din Matlab, este prezentat în Fig. 6.8, alături de răspunsul sistemului de reglare a vitezei simulat în Simulink. Se observă concordanţa între comportarea sistemului de reglare în buclă închisă, bazat pe modelul SimPowerSystems al motorului PMSM, şi comportarea modelului teoretic.

Sistemul de reglare proiectat se caracterizează şi printr-un răspuns rapid la perturbaţiile de cuplu. În Fig. 6.9 este prezentată comportarea sistemului la aplicarea unei perturbaţii de tip treaptă de cuplu, cu valoarea 0.03Nm, aproape de cuplul maxim dezvoltat de motor. Se poate observa că perturbaţia este respinsă în aproximativ 20ms.

Figura 6.8. Răspunsul sistemului teoretic şi al celui simulat la o comandă de tip treaptă.

181

Figura 6.9. Răspunsul sistemului la o perturbaţie de cuplu de 0.03Nm.

6.4 Discretizarea sistemului de control Deoarece sistemul de control va fi implementat numeric pe un dispozitiv FPGA, acesta

trebuie discretizat în timp, iar semnalele din sistem vor trebui discretizate în amplitudine. Aşa cum s-a menţionat, pentru perioada de eşantionare a sistemului a fost aleasă valoarea sTs μ50= ,

în concordanţă cu frecvenţa semnalului purtător PWM. Aceasta nu poate fi foarte înaltă, fiind limitată de frecvenţa de comutaţie a tranzistoarelor de putere din componenţa punţii invertoare.

Regulatoarele PI au fost discretizate folosind aproximarea de tip trapez (metoda Tustin), fiind descrise în timp discret de ecuaţia cu diferenţe:

]1[]1[)2

(][)2

(][ −+−−++= kukKTK

kKTK

ku PsI

PsI εε , (6.48)

unde ε este intrarea regulatorului, iar u este ieşirea. Deoarece sistemul de control are acces la curenţii prin cele 3 înfăşurări statorice, dar

controlul se realizează pe baza curenţilor în sistemul de coordonate q/d, acesta trebuie să realizeze transformările de coordonate din sistemul trifazat fixat pe stator în sistemul bifazat rotitor sincron cu rotorul. Acestea sunt implementate prin două transformări succesive, a/b/c la α/β şi α/β la q/d, conform celor prezentate în capitolul precedent:

⎪⎪⎩

⎪⎪⎨

⎧

−=

−−=

]),[][(33][

]);[][][2(31][

kikiki

kikikiki

cb

cba

β

α (6.49)

⎩⎨⎧

−=+=

].[])[cos(][])[sin(][];[])[sin(][])[cos(][

kikkikkikikkikki

eed

eeq

βα

βα

θθθθ

(6.50)

182

Deoarece sistemul de control aplică comanda motorului prin intermediul tensiunilor de pe cele 3 faze, acesta trebuie să realizeze şi transformarea inversă, din sistemul de coordonate q/d în sistemul trifazat. Cum tensiunile trifazate se aplică prin SVM (SVPWM), iar algoritmul de modulaţie foloseşte reprezentarea bifazată α/β a vectorului spaţial ca intrare, sistemul de control nu trebuie să realizeze decât transformarea de la q/d la α/β. Aceasta este exact la fel cu transformarea directă, de la α/β la q/d, dată de (6.50), doar că se aplică tensiunilor:

⎩⎨⎧

−=+=

].[])[cos(][])[sin(][];[])[sin(][])[cos(][

kvkkvkkvkvkkvkkv

deqe

deqe

θθθθ

β

α (6.51)

Blocul de decuplare a dependenţei între curenţii pe cele două axe şi de compensare a tensiunii electromotoare induse realizează următoarele operaţii:

⎩⎨⎧

−=

′+=.][][][

;][][][][

_

_

qqedecd

meddedecq

LkikkvkLkikkv

ωλωω

(6.52)

Ecuaţiile discrete ale regulatoarelor PI şi P, precum şi transformările (6.49)-(6.51) şi operaţia de decuplare (6.52) au fost implementate folosind blocuri System Generator. S-a folosit reprezentarea în virgulă fixă, cu limitare la 18 biţi pentru intrările multiplicatoarelor şi 24 de biţi pentru celelalte operaţii. Toate limitările s-au făcut cu hardware suplimentar pentru saturaţie în caz de depăşire, asigurându-se comportarea corectă a sistemului chiar şi atunci când se ating limitele reprezentării numerice.

Sistemul simulat în acest stadiu este reprezentat în Fig. 6.10. Blocurile reprezentate cu galben sunt implementate folosind blocuri din librăriile System Generator. În acest stadiu, algoritmul SVM a fost înlocuit cu transformarea de coordonate de la α/β la a/b/c. Partea de comandă a motorului s-a păstrat la fel ca la simularea în continuu. Prin simulare, s-au obţinut rezultate asemănătoare cu cele obţinute la simularea sistemului continuu. Totuşi, pentru a se valida procesul de discretizare, sistemul discret a fost simulat împreună cu sistemul continuu, calculându-se diferenţa între semnalele din sistemul continuu şi cele din sistemul discret. Astfel, s-au evaluat erorile de discretizare (datorate erorilor de cuantizare, aproximării integratoarelor prin metoda Tustin şi extrapolatoarelor de ordin 0 (zero) de pe ieşiri), iar acestea s-au dovedit acceptabile. Spre exemplu, pentru o schimbare de tip treaptă a referinţei de viteză de la 0rad/s la 200rad/s şi o durată a simulării de 0.5s, suficientă pentru a se atinge regimul staţionar, abaterea rădăcină medie pătratică (RMSD – Root Mean Square Deviation) de viteză (între viteza motorului controlată de sistemul discret şi viteza controlată de sistemul continuu) este de aproximativ 0.25rad/s. Abaterea RMSD pentru curentul pe axa q este de aproximativ 0.008A.

De altfel, precizia structurii numerice de calcul este mult superioară rezoluţiei convertoarelor analog-numerice folosite pentru achiziţia curenţilor (de 12 biţi) şi a codificatorului folosit pentru măsurarea vitezei şi unghiului.

183

Figura 6.10. Simularea sistemului discretizat, implementat cu blocuri System Generator.

S-au efectuat simulări cu diferite formate de reprezentare pentru semnalele interne, cu

precizii diferite. S-a constatat faptul că creşterea preciziei la mai mult de 18 biţi nu aduce avantaje vizibile, erorile de cuantizare fiind mult sub celelalte efecte ale procesului de discretizare. Scăderea perioadei de eşantionare ar îmbunătăţi comportarea sistemului discret, însă aceasta este limitată datorită pierderilor de comutaţie din puntea invertoare.

Deşi blocurile System Generator sunt direct sintetizabile în hardware pe FPGA, iar sistemul de control rezultat în FPGA ar avea exact aceeaşi comportare ca şi cel simulat (simularea fiind precisă la nivel de bit şi ciclu de tact), algoritmul nu poate fi implementat direct în această formă din două motive:

• Algoritmul are nevoie de un semnal de tact cu frecvenţa de 20kHz, obţinut din semnalul de tact global al sistemului de 50MHz; valorile de ieşire ale algoritmului sunt verificate să fie valide sincron cu acest semnal de tact. Desigur, rezultatele sunt valide mult mai repede, în funcţie de timpul de propagare pe nivelurile de logică combinaţională ce implementează algoritmul, dar restul sistemului (în speţă, algoritmul de modulaţie SVM) ar trebui să se asigure că citeşte date valide. În plus, nu este recomandat să se folosească mai multe semnale de tact într-un sistem digital implementat pe FPGA, atât din cauza problemelor de sincronizare, cât, mai ales, din cauza structurii dispozitivului FPGA, ce prevede trasee globale de rutare a tactului (în cazul în care există mai multe semnale de tact, doar unul va putea folosi traseele speciale, celelalte trebuind să folosească trasee de uz general, nepotrivite pentru această utilizare).

• În această formă, algoritmul de control va utiliza resurse hardware independente pentru toate operaţiile. În vreme ce acest lucru nu reprezintă o problemă majoră în ceea ce priveşte operaţiile logice sau cele de adunare/scădere, este un inconvenient serios atunci când vine vorba despre resurse hardware limitate, ca

184

multiplicatoarele integrate sau blocurile de memorie RAM. În plus, multe operaţii depind de rezultatele altor operaţii, deci ar putea folosi secvenţial acelaşi hardware.

Din aceste motive, algoritmul a fost factorizat şi transformat într-un automat sincron pilotat de semnalul de tact global, păstrând totuşi un grad înalt de paralelism pentru a asigura un timp de execuţie foarte scurt.

6.5 Factorizarea şi implementarea algoritmului de control Scopul procesului de factorizare este acela de a reorganiza algoritmul astfel încât să se

utilizeze doar 4 multiplicatoare. Celelalte operaţii vor fi efectuate de circuite hardware independente, dar multiplicatoarele reprezintă o resursă critică în dispozitivele FPGA de cost scăzut.

De obicei, factorizarea se realizează folosind graful de fluenţă a datelor (DFG – Data Flow Graph). Pentru algoritmul prezentat, graful de fluenţă este foarte complex, aşa că această metodă este greu de aplicat. S-a folosit în schimb o metodă mai simplă şi intuitivă: multiplicatoarele din fiecare bloc funcţional implementat cu resurse System Generator (blocurile galbene din Fig. 6.10) au fost reprezentate şi aliniate vertical în funcţie de fluxul de date din bloc, iar blocurile au fost aliniate în funcţie de dependenţa de date dintre ele. Astfel, a rezultat reprezentarea din Fig. 6.11.

Înmulţirile din blocul de decuplare între axe au fost aliniate cu cele din blocul regulatorului de viteză pentru a sublinia posibilitatea grupării lor împreună. Din Fig. 6.11 este evident că algoritmul poate folosi eficient 4 multiplicatoare, păstrând un grad înalt de paralelism.

Figura 6.11. Reprezentarea grafică pentru factorizarea înmulţirilor.

185

Deşi regulatorul de viteză nu are nevoie de valorile curenţilor, ieşirea lui nu poate fi folosită înainte ca acestea să fie disponibile. Aşadar, înmulţirile din regulatorul PI-P pot fi grupate împreună cu cele din blocul de decuplare între axe fără a afecta timpul total de execuţie.

Problema principală asociată cu utilizarea în comun a multiplicatoarelor de către mai multe blocuri funcţionale constă în creşterea complexităţii căii de date şi a circuitului de control al ei. Astfel, fiecare din cele 2 intrări ale fiecărui multiplicator va fi conectată la un multiplexor 6 la 1. Cele 6 intrări corespund celor 6 utilizări posibile ale multiplicatorului. Circuitul de control al căii de date va controla intrările de selecţie ale multiplexoarelor şi va salva valorile selectate în registrele de intrare ale multiplicatoarelor. Fiecare celulă de multiplicare va avea deci structura din Fig. 6.12.

Ieşirea multiplicatorului se distribuie la toate blocurile funcţionale ce-l utilizează. Circuitul de control al căii de date este responsabil cu salvarea rezultatului înmulţirii în blocul funcţional potrivit prin validarea registrului corespunzător.

Ca şi în cazul modulatoarelor prezentate în primele secţiuni, circuitul de control al căii de date este o maşină de stări de tip Moore. Aceasta rămâne în starea 0 (zero) până când este activată, apoi trece necondiţionat dintr-o stare în alta. În fiecare stare se activează una sau două variabile de stare şi se setează o anume combinaţie de selecţie pentru multiplexoarele celulelor de multiplicare. Circuitul de control nu face decât să secvenţieze operaţiile din blocurile funcţionale conturate în Fig. 6.10. Operaţii asociate cu unele blocuri se suprapun cu operaţii asociate altor blocuri, executându-se în paralel de către resurse hardware independente.

Figura 6.12. Celula de multiplicare ce permite utilizarea în comun a multiplicatorului.

186

Blocurile funcţionale din Fig. 6.10 au fost transformate prin inserarea de registre după fiecare operaţie. Registrele sunt controlate prin intermediul intrării de validare de către circuitul de control al căii de date. Astfel, fluxul de date al algoritmului este controlat sincron cu semnalul de tact global al sistemului.

În Fig. 6.13 este prezentată diagrama de stări a circuitului de control al căii de date. În fiecare stare este reprezentată printr-o haşurare specifică legătura cu un anumit bloc funcţional, pe care variabilele de stare îl controlează. Se observă în Fig. 6.13 că în 7 din cele 25 de stări ale automatului apar suprapuneri între blocuri, deci paralelism în execuţie.

Figura 6.13. Diagrama de stări a circuitului de control al căii de date.

187

Figura 6.14. Implementarea în Simulink a regulatorului PI-P de viteză.

Pentru exemplificare, în Fig. 6.14 este prezentat regulatorul de viteză PI-P. Se observă

(cu magenta) legăturile (de tip „go to”) către şi de la celulele de multiplicare 1 şi 2. Aşa cum rezultă din Fig. 6.11, celulele de multiplicare 3 şi 4 (şi 2 în pasul secund) sunt folosite în acelaşi timp de către blocul de decuplare între axe. Se mai observă semnalele (tot de tip „go to”, cu albastru deschis) de la circuitul de control al căii de date.

În Fig. 6.14 sunt două căi de date orizontale. Cea de mai jos se află din punct de vedere al fluxului de date în continuarea celei de mai sus. Cea mai de sus reprezintă regulatorul PI şi implementează (6.48). Semnalul de intrare de eroare este calculat ca diferenţa între semnalul de referinţă pentru viteză şi valoarea măsurată a vitezei. Apoi, valoarea actuală a erorii şi valoarea de la momentul anterior de eşantionare sunt înmulţite cu factorii corespunzători din (6.48) folosind celulele de multiplicare 1 şi 2. Se folosesc blocuri de tip “Reinterpret” pentru a face reprezentarea numerelor transparentă pentru multiplicatoare, deoarece reprezentarea numerelor (poziţia virgulei fixe) diferă între blocurile funcţionale ce folosesc aceleaşi celule de multiplicare. De aceea, fiecare bloc trebuie să transmită celulelor de multiplicare numere întregi fără virgulă şi să reinterpreteze rezultatul înmulţirii poziţionând corect virgula. Rezultatele înmulţirilor sunt adunate între ele, iar rezultatului i se adună valoarea ieşirii de la momentul anterior de eşantionare. În final, ieşirea regulatorului PI, având însemnătatea fizică de viteză intermediară, este salvată în registrul Reg6.

Calea de date din partea de jos este regulatorul P. Acesta calculează eroarea de viteză intermediară folosind viteza măsurată şi ieşirea regulatorului PI, apoi o înmulţeşte cu factorul de amplificare şi o salvează în registrul Reg8. Regulatorul P foloseşte tot celula de multiplicare 1.

Toate operaţiile sunt secvenţiate de semnalele provenite de la circuitul de control al căii de date, grupate în partea din stânga a Fig. 6.14.

Aceeaşi idee este folosită în toate blocurile funcţionale. Aşadar, algoritmul de control al vitezei pentru motorul PMSM se execută în doar 25 cicli

de tact (diagrama din Fig. 6.13 are 25 de stări). În această fază, sistemul de control din Simulink poate fi implementat direct în FPGA,

fiind sincron cu semnalul de tact global. Sistemul de control poate fi şi simulat, rezultatele

188

simulării validând corectitudinea paşilor de factorizare şi conceptul cale de date/automat de control. Totuşi, simularea în acest caz va dura foarte mult şi va fi imposibilă urmărirea unui număr mare de semnale, datorită pasului de simulare foarte fin, impus de perioada semnalului de tact global. Cum însă factorizarea nu afectează în niciun fel precizia algoritmului, nu ar trebui să existe diferenţe în comportarea sistemului faţă de pasul anterior.

6.6 Interfaţarea senzorilor

6.6.1 Senzorii de curent

Schema de măsurare a curenţilor folosită în standul experimental se bazează pe

măsurarea căderii de tensiune pe rezistoare înseriate cu tranzistoarele inferioare ale punţii invertoare trifazate. Deşi simplă şi economică din punctul de vedere al hardware-ului, ea necesită o sincronizare precisă între momentele de măsurare şi starea punţii invertoare. Pe scurt, algoritmul trebuie să se asigure că, în momentul eşantionării, curenţii prin partea inferioară a punţii sunt chiar curenţii ce trec prin înfăşurările motorului. Aceasta înseamnă că ar trebui să se măsoare curenţii exact în timpul aplicării vectorului spaţial nul 000 de către modulatorul SVM. Cel mai potrivit moment de eşantionare ar fi chiar vârful de jos al semnalului purtător PWM (triunghiular) utilizat în SVM.

Sincronizarea exactă cu vârful de jos al semnalului PWM este posibilă doar dacă eşantionarea se realizează în perioada de eşantionare anterioară celei în care se execută algoritmul de control. Această metodă este preferată în cazul implementării algoritmului de control pe procesoare (microcontroler sau DSP), deoarece durata de execuţie a algoritmului este comparabilă cu perioada de eşantionare. În cazul implementării pe FPGA, datorită eficienţei crescute a structurii de calcul proiectate special pentru aplicaţie, timpul de calcul este foarte mic în comparaţie cu perioada de eşantionare. Se va căuta deci folosirea în algoritm a valorilor curenţilor din aceeaşi perioadă de eşantionare. Acest lucru se poate realiza impunând o mică limitare amplitudinii vectorului spaţial, pentru a asigura o durată de timp suficientă în care se aplică vectorul nul 000.

Schema de măsurare a curentului printr-o fază a motorului este prezentată în Fig. 6.15. Căderea de tensiune pe rezistenţă este amplificată, apoi polarizată şi scalată pe placa

punţii trifazate. Apoi este achiziţionată cu ajutorul unui convertor analog/numeric (CAN) cu interfaţă serială rapidă de tipul ADCS7476. S-a folosit un automat de stări pentru a implementa interfaţa serială cu convertorul şi pentru a secvenţia operaţiile aritmetice necesare transformării codului citit de la CAN în valoarea corespunzătoare a curentului.

189

Figura 6.15. Schema de măsurare a curentului printr-o fază a motorului.

6.6.2 Măsurarea unghiului şi a vitezei

Măsurarea unghiului şi a vitezei se realizează prin intermediul unui codificator cu ieşiri în

cuadratură (QEP – Quadrature Encoded Pulse). Acesta se bazează pe doi detectori optici ce urmăresc o bandă cu 500 de linii. Numărul de linii stabileşte rezoluţia codificatorului. Avantajul codificatorului cu ieşiri QEP constă în faptul că se interfaţează direct cu circuite digitale şi oferă o rezoluţie destul de bună, cu costuri mai mici decât un codificator absolut sau decât un rezolver analogic. Totuşi, extragerea informaţiei de unghi şi viteză este ceva mai complicată. Aceasta se realizează însă eficient prin proiectarea de hardware dedicat implementat în FPGA.

Cele două intrări QEP sunt filtrate digital de un circuit „voter 2 din 3”. Acesta are rolul de a elimina posibilele tranziţii false din semnalele de intrare, având o comportare destul de bună şi introducând o întârziere de doar 2 cicli de tact.

După filtrare, cele 2 intrări QEP sunt trecute prin circuite de detecţie a fronturilor. Ieşirile acestora sunt active pentru un ciclu de tact, în cazul unei detecţii. Se folosesc atât fronturile crescătoare, cât şi cele căzătoare, deci rezultă 4 semnale. Acestea sunt mai departe trecute printr-un circuit de validare, prezentat în Fig. 6.16, cu rolul de a se asigura că semnalele sunt într-adevăr codificate în cuadratură. Se elimină astfel tranziţiile false ţinând cont de caracteristicile semnalelor QEP, deci se face o filtrare euristică. Circuitul funcţionează astfel: fiecare semnal de front QEP este validat, printr-o poartă ŞI, de ieşirea (negată a) unui bistabil. Acesta este setat de semnalul de front QEP în discuţie şi este resetat de unul din fronturile celuilalt semnal QEP. Se asigură astfel că un semnal de front QEP apare numai după ce a apărut un front pe celălalt canal QEP.

În final, cele patru semnale filtrate, trecute printr-o poartă SAU, creează un semnal ce se activează pentru un singur ciclu de tact în cazul apariţiei unui front pe oricare din canalele QEP. Acest semnal este utilizat mai departe de circuitele de măsurare a vitezei şi unghiului.

190

Figura 6.16. Circuitul de validare a fronturilor semnalelor QEP.

Cum algoritmul de control nu necesită cunoaşterea unghiului (poziţiei) rotorului, ci

foloseşte valorile funcţiilor trigonometrice sin şi cos aplicate unghiului pentru realizarea transformărilor de coordonate, ieşirile circuitului de măsurare a unghiului sunt de fapt valorile pentru sin şi cos. Acestea sunt determinate folosind o singură memorie ROM ce păstrează eşantioane ale funcţiei sin.

Problema măsurării unghiului se reduce la acumularea numărului de impulsuri QEP folosind un numărător reversibil (bidirecţional). Cum codificatorul QEP are 500 de linii, la o rotaţie completă vor apărea 2000 de impulsuri QEP, deci aceasta este valoarea maximă a numărătorului. Semnalul de index de la codificator este folosit pentru resetarea numărătorului, evitând astfel acumularea erorii. Ieşirea numărătorului, după anumite prelucrări numerice, este folosită pentru adresarea memoriei ROM.

Direcţia de numărare este dată de un circuit de detecţie a direcţiei de rotaţie a motorului. Acesta stabileşte direcţia de rotaţie în funcţie de direcţia defazajului între cele două canale QEP. Astfel, apariţia unui front pe un canal QEP este coroborată cu starea celuilalt canal QEP pentru a determina direcţia defazajului.

Cum motorul folosit în experimente are 2 perechi de poli, unghiul electric folosit în transformări va fi dublul unghiului mecanic măsurat, conform (6.37). Aşadar, ultimul bit al ieşirii numărătorului ce dă unghiul este ignorat la adresarea memoriei, aceasta necesitând un număr înjumătăţit de eşantioane. Deci, ţinând cont de rezoluţia codificatorului, memoria ROM necesită doar 1000 de locaţii, fiind implementată într-un singur bloc de memorie RAM pe FPGA. Rezoluţia eşantioanelor s-a ales de 18 biţi, ţinând cont de organizarea memoriei RAM în FPGA.

191

Circuitul de măsurare a unghiului este controlat de un automat Moore ce secvenţiază operaţiile necesare extragerii atât a eşantionului pentru sin, cât şi pentru cos. Memoria este accesată de două ori, mai întâi folosind o adresă derivată direct din ieşirea numărătorului, şi apoi folosind adresa modificată prin adunarea valorii 500, corespunzătoare unui defazaj de 90°. O serie de alte operaţii aritmetico-logice asigură comportarea corectă a circuitului şi atunci când apare depăşire la operaţia de obţinere a adresei pentru cos.

Măsurarea vitezei se bazează pe metoda măsurării perioadei dintre două fronturi

consecutive ale semnalelor QEP. Această metodă este cunoscută în literatură [154] sub denumirea de metoda T, spre deosebire de metoda măsurării frecvenţei semnalelor QEP (metoda M) prin numărarea fronturilor ce apar într-o unitate de timp. Metoda M, folosită în studiul de caz din Subcapitolul 3.4.3 este mai puţin potrivită aici datorită faptului că perioada de eşantionare a sistemului de control este destul de mică, comparabilă cu perioada semnalelor QEP, ceea ce conduce la erori semnificative de măsurare [155]. La metoda T, erorile de măsurare sunt acceptabile pe întreaga plajă a vitezei motorului, ce este limitată la aproximativ 7000 de rotaţii pe minut (RPM).

Pentru măsurarea perioadei dintre două fronturi QEP consecutive se foloseşte un numărător. Conţinutul acestuia este salvat într-un registru la apariţia unui front QEP, apoi numărătorul este reiniţializat. Datorită faptului că detecţia frontului şi salvarea valorii numărătorului durează 2 cicli de tact, numărătorul este de fapt încărcat cu valoarea 2, nu resetat. Valoarea din registru este apoi folosită pentru determinarea vitezei după formula:

,2clk

linesfrontsf

nNNπω = (6.53)

unde 500=linesN este numărul de linii al codificatorului, n este valoarea salvată în registru, iar

frontsN este numărul de fronturi ale semnalelor QEP ce se folosesc. Dacă se folosesc atât

fronturile crescătoare, cât şi cele căzătoare de pe ambele canale QEP, atunci 4=frontsN ,

deoarece fiecărei linii a codificatorului îi corespund 4 fronturi. Această abordare este foarte potrivită la valori mici ale vitezei, când perioada dintre două fronturi succesive este lungă şi greu de măsurat. Cu creşterea vitezei, însă, imperfecţiunile din construcţia codificatorului, în principal defazajul asimetric între canalele QEP, conduc la erori mari de măsurare [156]. Din acest motiv s-a optat pentru combinarea dinamică a două abordări: la viteze mici, se folosesc toate cele 4 fronturi ale semnalelor QEP; când viteza depăşeşte o anumită valoare, se trece la măsurarea perioadei pe un singur canal QEP, eliminându-se total efectele asimetriilor. În acest caz,

1=frontsN în (6.53).

Ecuaţia (6.53) necesită o operaţie de împărţire pentru calcularea vitezei. Aceasta a fost implementată folosind un nucleu IP din System Generator, Divider Generator 3.0. Operaţia de împărţire este destul de costisitoare în ceea ce priveşte timpul de execuţie, necesitând 30 de cicli de tact la o precizie a rezultatului de 18 biţi. Această latenţă nu va afecta însă timpul de execuţie

192

al algoritmului de control, deoarece calcularea vitezei se realizează sincron cu apariţia fronturilor semnalelor QEP, nu cu începerea unei noi perioade de eşantionare pentru algoritmul de control. S-ar putea folosi un alt circuit, mai rapid, pentru operaţia de împărţire [157], [158], [159], însă Divider Generator 3.0 are avantajul integrării uşoare în restul sistemului proiectat cu System Generator şi al adaptării rapide la necesităţile computaţionale (număr de biţi ai operanzilor).

Circuitul de măsurare a vitezei include un circuit ce scoate la ieşire valoarea 0 (zero) în cazul în care apare depăşire la numărătorul ce măsoară timpul scurs între două fronturi QEP, ceea ce înseamnă că perioada este prea lungă pentru a putea fi măsurată. De asemenea, următoarea măsurătoare după un astfel de eveniment este invalidată, pentru că nu reflectă realitatea.

Valoarea calculată a vitezei este apoi negată (în complement faţă de doi) dacă direcţia de rotaţie, determinată de circuitul descris în paragrafele anterioare, este negativă. De asemenea, circuitul păstrează valoarea vitezei neschimbată în cazul primului front QEP ce apare după o schimbare a direcţiei de rotaţie, deoarece în acest caz timpul scurs între două fronturi este scurt şi nu reflectă viteza motorului.

Circuitul de măsurare a vitezei, precum şi cel de calculare a funcţiilor trigonometrice asociate cu poziţia rotorului au fost implementate folosind tot Simulink şi System Generator şi verificate prin simulare separat, înainte de a fi integrate cu algoritmul de control.

6.7 Implementarea în FPGA şi rezultate experimentale Sistemul de control prezentat în paragrafele de mai sus a fost integrat cu modulatorul

SVM, sintetizat şi implementat într-un FPGA Spartan-3E XC3S500E. Pe lângă algoritmul de control şi hardware-ul de interfaţare cu senzorii, în FPGA s-a implementat şi un analizor logic virtual ChipScope, folosit pentru a captura semnalele interne ale sistemului. Nucleul ChipScope este pilotat de un semnal de tact cu frecvenţa de 20kHz, astfel că semnalele capturate pot fi folosite pentru a observa comportarea sistemului de control în perioadele de eşantionare.

Sistemul de control proiectat este sincron, folosind un semnal de tact de 50MHz. Algoritmul de control are nevoie de 25 de cicli de tact pentru a-şi termina execuţia, iar algoritmul SVM de 8 cicli de tact. Aceasta înseamnă că toate calculele, începând cu transformările de axe, continuând cu regulatoarele şi sfârşind cu modulaţia SVM, sunt efectuate în doar 33 de cicli de tact, adică în 0.66μs.

Totuşi, ţinând cont că achiziţia valorilor curenţilor se face folosind un CAN cu interfaţă serială, iar citirea acestuia necesită 74 de cicli de tact, timpul total de execuţie a unei iteraţii a algoritmului este de 107 cicli de tact, adică 2.14μs. Acesta este totuşi foarte scurt faţă de perioada de eşantionare de 50μs.

Datorită timpului foarte scurt de execuţie a algoritmului de control, achiziţia datelor, prelucrarea şi aplicarea comenzii se pot efectua în aceeaşi perioadă de eşantionare. Acest lucru este cu deosebire important datorită metodei de măsurare a curenţilor prin motor. Aşa cum s-a

193

amintit, curenţii pot fi măsuraţi doar pe perioada aplicării vectorului nul 000 de către modulatorul SVM. Aşadar, pentru a putea executa algoritmul de control în aceeaşi perioadă de eşantionare cu achiziţia curenţilor, vectorul nul 000 trebuie aplicat pe întreaga durată a acestor operaţii. Datorită faptului că operaţiile durează foarte puţin (mai puţin de 5% din perioada de eşantionare) limitarea impusă amplitudinii vectorului spaţial (astfel încât durata aplicării vectorului nul 000 să acopere timpul de efectuare a operaţiilor) este foarte mică, neafectând comportarea per ansamblu a sistemului de reglare a vitezei.

Resursele ocupate de către sistemul de control implementat pe FPGA sunt prezentate în Tabelul 6.1.

Tabelul 6.1. Resursele ocupate în Spartan-3E XC3S500E de sistemul de control al

vitezei. LUT-uri cu 4

intrări Bistabili de tip D Felii logice Multiplicatoare

integrate Blocuri de

memorie RAM 2679 din 9312

(28%) 2655 din 9312

(29%) 2211 din 4656

(48%) 11 din 20

(55%) 1 din 20

(5%) Frecvenţa maximă la care poate lucra circuitul este de 77MHz. După implementare, sistemul de control a fost testat experimental folosind o punte

invertoare trifazată Technosoft PM50 şi un motor PMSM Pittman 3441 de 19.1V. Ca şi validarea prin simulare, testarea experimentală s-a efectuat în 2 paşi. Mai întâi s-a verificat comportarea regulatoarelor de curent prin întreruperea buclei de control a vitezei şi impunerea unei referinţe de curent. Răspunsul sistemului la o schimbare de tip treaptă a referinţei de curent pe axa q, de la 0A la 0.75A este prezentat în Fig. 6.17, aşa cum a fost capturat de analizorul ChipScope pe FPGA şi reprezentat grafic pe calculator folosind software-ul ChipScope Pro Analyzer. Se observă răspunsul caracteristic unui sistem de ordinul I, cu un timp de creştere de aproximativ 0.8ms, în perfectă concordanţă cu rezultatele obţinute la simulare (a se vedea Fig. 6.6 şi Fig. 6.7).

În Fig. 6.18 este prezentată comportarea sistemului de reglare a curentului la o schimbare a referinţei de la +0.25A la -0.5A. Se observă că curentul controlat, cel de pe axa q, reprezentat cu verde, urmăreşte referinţa (reprezentată cu roşu). Curenţii prin cele trei înfăşurări au forme de undă sinusoidale. Se observă că forţarea unei valori negative a curentului pe axa q provoacă schimbarea direcţiei de rotaţie a motorului, deductibilă din formele de undă ale curenţilor pe cele 3 faze.

După ce s-a verificat funcţionarea corectă a regulatoarelor de curent, s-a închis bucla de control al vitezei şi s-a testat întregul sistem. În Fig. 6.19 este prezentată comportarea sistemului la aplicarea unei trepte pe semnalul de referinţă a vitezei de la 200rad/s la 400rad/s.

194

Figura 6.17. Răspunsul sistemului la o treaptă de curent.

Figura 6.18. Curenţii pe cele trei faze şi curentul pe axa q la o schimbare treaptă negativă a

referinţei.

Figura 6.19. Răspunsul sistemului la o treaptă de viteză.

195

Se observă caracteristica unui sistem de ordin II cu poli reali, cu un timp de creştere de aproximativ 15ms, în perfectă concordanţă cu rezultatele obţinute prin simulare (a se vedea Fig. 6.8).

Aşadar, sistemul de control implementat fizic respectă întru totul comportarea sistemului modelat şi simulat în Simulink. Acest lucru confirmă validitatea metodei de proiectare propusă de această lucrare: proiectarea în Simulink, folosind blocuri System Generator, a sistemelor de control implementate în FPGA.

6.8 Concluzii Acest capitol conferă o finalitate celor precedente. Prin latura mai mult aplicativă

justifică prezentarea metodelor de proiectare din capitolele anterioare, utilizându-le în cel mai înalt grad. Prin complexitatea aplicaţiei alese şi rezultatele experimentale obţinute, justifică afirmaţiile emise privind locul dispozitivelor FPGA în proiectarea sistemelor de control automat moderne.

Meritele acestui capitol nu sunt legate doar de partea aplicativă, originală şi performantă. Trebuie subliniat faptul că paşii urmaţi în proiectarea sistemului de control al vitezei motorului PMSM constituie o metodologie de proiectare pentru orice sistem automat implementat în FPGA. Proiectarea în mediul Simulink a sistemului de reglare, apoi implementarea lui cu blocuri System Generator, factorizarea algoritmului şi proiectarea sistemului sincron după paradigma automat cu cale de date conduc în mod cert la obţinerea unui sistem de control funcţional şi performant. Avantajul principal al metodei este viziunea de ansamblu a sistemului ca întreg. Astfel, sistemul de control implementat în FPGA se poate simula împreună cu modele verificate, de librărie, ale proceselor controlate. Rafinarea algoritmului de control poate fi validată faţă de o implementare la nivel de principiu. Iar sistemul de control implementat în hardware pe FPGA se va comporta exact ca şi cel simulat.

Prin exemplele prezentate, s-au pus în evidenţă clar avantajele folosirii dispozitivelor FPGA faţă de sistemele cu procesor (microcontroler sau DSP):

• În FPGA se pot implementa circuite hardware specifice aplicaţiei, care să efectueze eficient anumite operaţii (de exemplu, circuitele de interfaţare cu semnalele QEP, de măsurare a vitezei, de obţinere a funcţiilor trigonometrice).

• În FPGA se poate profita din plin de paralelismul inerent algoritmului de implementat, scurtându-se la minimum timpul de execuţie.

• În FPGA, precizia cu care se efectuează calculele este la latitudinea proiectantului, nefiind supusă constrângerilor legate de o arhitectură fixă de procesare.

De altfel, chiar atunci când se foloseşte un procesor DSP pentru implementarea algoritmului de control, acesta trebuie de obicei asistat de un circuit logic programabil, adesea CPLD, pentru implementarea unor structuri hardware complementare, a căror funcţionalitate nu

196

poate fi obţinută prin software. De exemplu, în [160] se foloseşte un CPLD pentru inserarea timpului mort în comanda tranzistoarelor.

Aşa cum rezultă din exemplul sistemului de control al vitezei motorului PMSM, timpul de execuţie obţinut pentru algoritm este extraordinar de scurt, valoarea mărimii de comandă fiind obţinută aproape instantaneu. Acest lucru conduce la posibilitatea creşterii frecvenţei de eşantionare, deci a lăţimii de bandă a sistemului de control. Totuşi, frecvenţa de eşantionare se poate să fie limitată de alţi factori din sistem, cum este frecvenţa de comutaţie a tranzistoarelor de putere în aplicaţia prezentată. Chiar în acest caz, timpul de execuţie scurt se dovedeşte extraordinar de avantajos.

Aplicaţia prezentată, cu 4 bucle de reglare, funcţionând toate la aceeaşi frecvenţă de eşantionare şi aplicând comanda aproape instantaneu constituie un exemplu de control analogic efectuat cu mijloace digitale (dacă erorile de cuantizare pot fi neglijate).

Deşi există numeroase alte implementări ale unor algoritmi asemănători în FPGA, după cum se poate vedea din Secţiunea 2.4, cea prezentată aici este originală şi avantajoasă din mai multe puncte de vedere:

• Foloseşte un număr redus de multiplicatoare; spre exemplu, abordările prezentate în [41], [42], [50] utilizează numere de ordinul zecilor de multiplicatoare pentru implementarea algoritmului, în vreme ce sistemul dezvoltat aici foloseşte doar 4;

• Propune o abordare integrată în Simulink pentru proiectare, validare şi definitivare a conceptului după paradigma FSMD;

• Foloseşte o versiune optimizată din punctul de vedere al cerinţelor computaţionale a algoritmului de modulaţie SVM, foarte eficientă la implementare în FPGA;

• Foloseşte o schemă hardware avantajoasă din punctul de vedere al costurilor pentru măsurarea curenţilor, impunând o mică limitare algoritmului SVM.

Sistemul de control al vitezei motorului PMSM va fi publicat în [161].

197

7. Concluzii generale Această lucrare abordează domeniul proiectării sistemelor de control pentru motoare

electrice folosind dispozitive FPGA, domeniu de mare actualitate, situat la confluenţa dintre automatică, inginerie electrică şi ingineria calculatoarelor. Pe parcursul elaborării lucrării s-au încercat diferite unelte şi metode de proiectare pentru FPGA, începând de la metodele clasice bazate pe captură de schemă logică şi descriere în limbaj HDL şi terminând cu metodele moderne bazate pe mediul Simulink. De asemenea, s-au combinat aceste metode de proiectare şi s-au utilizat unelte de simulare multiple. S-au definit şi abordat diferite studii de caz în controlul motoarelor electrice, de complexităţi diferite, folosind ca pretexte pentru explorarea spaţiului de proiectare. Toate problemele de proiectare propuse au fost finalizate prin realizarea de bancuri experimentale (cu unelte de laborator didactic, de performanţe şi costuri reduse, dar perfect valide) şi verificarea prin experimente reale a rezultatelor. Această multitudine de studii de caz rezolvate, culminând cu cel al controlului orientat după câmp al motorului sincron cu magneţi permanenţi, a condus la formularea unei metodologii de proiectare şi validare a sistemelor de control bazate pe FPGA, folosind mediul Simulink.

Deşi lucrarea are un pronunţat caracter aplicativ, ea aduce şi o serie de contribuţii teoretice:

• Prezentarea sintetică a arhitecturilor familiilor de dispozitive FPGA actuale ale principalilor 2 mari producători, Altera şi Xilinx;

• Realizarea unei treceri în revistă concludente a sistemelor de control pentru motoare electrice bazate pe FPGA din literatura recentă din domeniu;

• Prezentarea succintă a uneltei software Xilinx System Generator, ce permite proiectarea în mediul Simulink de structuri hardware implementabile în FPGA;

• Derivarea de structuri de tip filtru digital cu răspuns infinit la impuls pentru algoritmii de control deadbeat şi PI, structuri uşor de implementat în hardware;

• Sintetizarea din mai multe surse bibliografice a unor consideraţii privind optimizarea de structuri hardware pentru proiectarea de procesoare soft în FPGA;

• Analiza modulaţiei PWM sinusoidale cu injecţie de semnal triunghiular la punctul neutru din punctul de vedere al implementării în hardware;

• Analiza algoritmului de modulaţie bazată pe vectori spaţiali din punctul de vedere al implementării în hardware;

• Prezentarea succintă a modelării motorului sincron cu magneţi permanenţi în sistemul de coordonate rotitor sincron cu rotorul;

• Proiectarea unui sistem de control orientat după câmp pentru motorul PMSM, incluzând alegerea parametrilor regulatoarelor de curent şi viteză prin metoda alocării polilor;

198

• Proiectarea originală a algoritmului de control după paradigma automat cu cale de date;

• Trasarea unei metodologii de proiectare a sistemelor de control bazate pe FPGA urmărind paşii următori: modelarea în continuu, discretizarea şi evaluarea abaterii faţă de modelul continuu, factorizarea algoritmului de control, reproiectarea acestuia după paradigma automat cu cale de date, verificarea experimentală folosind un analizor logic “virtual”.

Dintre contribuţiile aplicative, merită amintite: • Realizarea unui sistem de control al vitezei motorului de curent continuu prin

includerea acestuia într-o buclă cu calare pe fază proiectată în mod original pe un dispozitiv FPGA;

• Realizarea în FPGA a unui sistem pentru controlul vitezei motorului de curent continuu bazat pe algoritmul deadbeat;

• Realizarea a diferite module hardware pentru controlul motorului de curent continuu fără perii, validarea acestora prin combinarea mai multor metode de simulare şi integrarea într-un sistem funcţional pe FPGA;

• Realizarea unui sistem pe un cip FPGA conţinând atât elemente hardware, cât şi software rulând pe procesoare soft;

• Realizarea pe FPGA a unui modulator PWM sinusoidal cu injecţie de semnal triunghiular la punctul neutru; s-a respectat principiul modularităţii, unele module fiind reutilizate ulterior;

• Realizarea pe FPGA a unui modulator bazat pe vectori spaţiali, optimizat din punctul de vedere al complexităţii computaţionale, toate calculele executându-se în doar 160ns;

• Reproiectarea etajului de ieşire al modulatorului astfel încât să se atingă o rezoluţie de 16 biţi;

• Validarea prin simulare a sistemului de control orientat după câmp pentru motorul PMSM atât în continuu, cât şi după discretizare;

• Factorizarea algoritmului de control şi implementarea sa ca automat cu cale de date;

• Proiectarea în FPGA de interfeţe originale pentru senzorii de curent şi de poziţie/viteză;

• Realizarea în FPGA a sistemului de control orientat după câmp pentru motorul PMSM, conţinând 4 bucle de reglare şi executându-se în doar 2.14µs.

Rezultatele obţinute au fost diseminate prin publicarea a 14 lucrări: [102], [103], [105], [109], [110], [111], [121], [122], [143], [144], [145], [146], [157], [161].

S-a atins, aşadar, prin rezultatele conexe acestei teze, scopul enunţat în titlul ei: acela de proiectare de sisteme de control încorporate pentru procese rapide folosind dispozitive FPGA. Deşi motorul electric nu are o dinamică foarte rapidă, având un timp de răspuns de ordinul milisecundelor, procesele electrice din motor sunt foarte rapide, cu timpi de răspuns de ordinul

199

zecilor de microsecunde. La fel de importantă ca şi realizarea propriu-zisă a unui sistem de control performant este şi formularea unei metodologii de proiectare a sistemelor de control cu FPGA, metodologie bazată pe utilizarea software-ului System Generator pentru validare şi pe reproiectarea algoritmului de control după paradigma automat cu cale de date.

Având în vedere că dispozitivele FPGA evoluează mereu, puterea lor “virtuală” de calcul fiind fantastică, s-ar putea formula câteva direcţii de cercetare pe viitor:

• Abordarea unor metode de reglare bazate pe algoritmi şi mai complecşi, de exemplu algoritmi adaptivi pentru estimarea unor parametri necunoscuţi;

• Abordarea unor procese mai rapide, pur electrice, cum ar fi controlul convertoarelor DC-DC;

• Controlul multi-sistem; • Folosirea unor tehnici care să crească cantitatea de date procesate, cum ar fi

supraeşantionarea (oversampling).

201

8. Bibliografie [1] Highlights of IEEE Trans. on Industrial Electronics, available online:

http://tie.ieee-ies.org/tie/Highlights2.pdf. [2] De Carlo S., Reifman S.Z., Wang J.I., Zajac B., “Cele mai bune companii din

lume”, Forbes România, nr. 4, mai 2009. [3] Maxfield C., The design warrior’s guide to FPGAs, Newnes Elsevier, 2004. [4] Rodriguez-Andina J.J., Moure M.J., Valdes M.D., “Features, design tools and

application domains of FPGAs”, IEEE Transactions on Industrial Electronics, vol. 54, no. 4, august 2007.

[5] Woods R., McAllister J., Lightbody G., Yi Y., FPGA-based implementation of signal processing systems, John Wiley and Sons, 2008.

[6] Cofer R.C., Harding B.F., Rapid system prototyping with FPGAs, Newnes Elsevier, 2006.

[7] Trimberger S., “Redefining the FPGA for the next generation”, International Conference on Field Programmable Logic and Applications, FPL 2007, Amsterdam, Olanda, august 2007.

[8] Cyclone III device handbook, Altera, iulie 2009. [9] Stratix IV device handbook, Altera, iunie 2009. [10] Arria II GX device handbook, Altera, iunie 2009. [11] Spartan 6 family overview, Xilinx, iunie 2009. [12] Spartan 6 FPGA configurable logic block user guide, Xilinx, iunie 2009. [13] Spartan 6 FPGA block RAM resources user guide, Xilinx, iunie 2009. [14] Spartan 6 FPGA DSP48A1 slice user guide, Xilinx, august 2009. [15] Virtex 6 family overview, Xilinx, iunie 2009. [16] Virtex 6 FPGA configurable logic block user guide, Xilinx, iunie 2009. [17] Virtex 6 FPGA memory resources user guide, Xilinx, iunie 2009. [18] Virtex 6 FPGA DSP48E1 slice user guide, Xilinx, august 2009. [19] Monmasson E., Cirstea M.N., “FPGA design methodology for industrial control

systems – a review”, IEEE Transactions on Industrial Electronics, vol. 54, no. 4, august 2007. [20] Andraka R., “A survey of CORDIC algorithms for FPGA based computers”,

Proceedings of ACM/SIGDA International Symposium on Field Programmable Gate Arrays, FPGA ’98, Monterey, Caligornia, SUA, februarie 1998.

[21] White S.A., “Applications of distributed arithmetic to digital signal processing: a tutorial review”, IEEE ASSP Magazine, vol. 6, no. 3, iulie 1989.

[22] Fang Z., Carletta J.E., Veillette R.J., “A methodology for FPGA-based control implementation”, IEEE Transactions on Control Systems Technology, vol. 13, no. 6, noiembrie 2005.

202

[23] Hilaire T., Menard D., Sentieys O., “Bit accurate roundoff noise analysis of fixed point linear controllers”, IEEE International Symposium on Computer-Aided Control System Design, CACSD 2008, San Antonio, Texas, SUA, septembrie 2008.

[24] Grandpierre T., Lavarenne C., Sorel Y., “Optimized rapid prototyping for real-time embedded heterogeneous multiprocessors”, Proceedings of International Workshop on Hardware/Software Co-Design, CODES ’99, Roma, Italia, mai 1999.

[25] Dubey R., Agarwal P., Vasantha M.K., “Programmable logic devices for motion control – a review”, IEEE Transactions on Industrial Electronics, vol. 54, no. 1, februarie 2007.

[26] Naouar M.-W., Monmasson E., Naassani A.A., Slama-Belkhodja I., Patin N., “FPGA-based current controllers for AC machine drives – a review”, IEEE Transactions on Industrial Electronics, vol. 54, no. 4, august 2007.

[27] Cirstea M.N., Dinu A., “A VHDL holistic modeling approach and FPGA implementation of a digital sensorless induction motor control scheme”, IEEE Transactions on Industrial Electronics, vol. 54, no. 4, august 2007.

[28] Kung Y.-S., Tsai M.-H., “FPGA-based speed control IC for PMSM drive with adaptive fuzzy control”, IEEE Transactions on Power Electronics, vol. 22, no. 6, noiembrie 2007.

[29] Mic D., Oniga S., Micu E., Lung C., “Complete hardware / software solution for implementing the control of the electrical machines with programmable logic circuits”, Proceedings of the 11th International Conference on Optimization of Electrical and Electronic Equipment, OPTIM 2008, Braşov, Romania, mai 2008.

[30] Lis J., Kowalski C.T., Orlowska-Kovalska T., “Sensorless DTC control of the induction motor using FPGA”, Proceedings of the 2008 IEEE International Symposium on Industrial Electronics, ISIE 2008, Cambridge, UK, iunie-iulie 2008.

[31] Kung Y.-S., Fung R.-F., Tai T.-Y., “Realization of a motion control IC for x-y table based on novel FPGA technology”, IEEE Transactions on Industrial Electronics, vol. 56, no. 1, ianuarie 2009.

[32] Astarloa A., Lazaro J., Bidarte U., Jimenez J., Zuloaga A., “FPGA technology for multi-axis control systems”, Mechatronics, vol. 19, no. 2, martie 2009.

[33] Huang H.-C., Tsai C.-C., “FPGA implementation of an embedded robust adaptive controller for autonomous omnidirectional mobile platform”, IEEE Transactions on Industrial Electronics, vol. 56, no. 5, mai 2009.

[34] Sathyan A., Milivojevic M., Lee Y.-J., Krishnamurthy M., Emadi A., “An FPGA-based novel digital PWM control scheme for BLDC motor drives”, IEEE Transactions on Industrial Electronics, vol. 56, no. 8, august 2009.

[35] Idkhajine L., Prata A., Monmasson E., Naouar M.-W., “System on chip controller for electrical actuator”, Proceedings of the 2008 IEEE International Symposium on Industrial Electronics, ISIE 2008, Cambridge, UK, iunie-iulie 2008.

203

[36] Idkhajine L., Monmasson E., Naouar M.W., Prata A., Bouallaga K., “Fully integrated FPGA-based controller for synchronous motor drive”, IEEE Transactions on Industrial Electronics, vol. 56, no. 10, octombrie 2009.

[37] Das A., Banerjee K., “Fast prototyping of a digital PID controller on a FPGA based soft-core microcontroller for precision control of a brushed DC servo motor”, Proceedings of the 35th Annual Conference of the IEEE Industrial Electronics Society, IECON 2009, Porto, Portugalia, noiembrie 2009.

[38] Ben Salem A.K., Ben Othman S., Ben Saoud S., Litayem N., “Servo drive system based on programmable SoC architecture”, Proceedings of the 35th Annual Conference of the IEEE Industrial Electronics Society, IECON 2009, Porto, Portugalia, noiembrie 2009.

[39] Litayem N., Ghrissi M., Ben Salem A.K., Ben Saoud S., “Designing and building embedded environment for robotic control application”, Proceedings of the 35th Annual Conference of the IEEE Industrial Electronics Society, IECON 2009, Porto, Portugalia, noiembrie 2009.

[40] Paiz C., Hagemeyer J., Pohl C., Porrmann M., Rueckert U., Schulz B., Peters W., Boecker J., “FPGA-Based Realization of Self-Optimizing Drive-Controllers”, Proceedings of the 35th Annual Conference of the IEEE Industrial Electronics Society, IECON 2009, Porto, Portugalia, noiembrie 2009.

[41] Carbone S., Delli Colli V., Di Stefano R., Figalli G., Marignetti F., “Design and implementation of high performance FPGA control for permanent magnet synchronous motor”, Proceedings of the 35th Annual Conference of the IEEE Industrial Electronics Society, IECON 2009, Porto, Portugalia, noiembrie 2009.

[42] Idkhajine L., Monmasson E., Maalouf A., “Fully FPGA-based sensorless control for AC drive using an Extended Kalman Filter”, Proceedings of the 35th Annual Conference of the IEEE Industrial Electronics Society, IECON 2009, Porto, Portugalia, noiembrie 2009.

[43] Hilairet M., Hannoun H., Marchand C., “Design of an optimized SRM control architecture based on a hardware/software partitioning”, Proceedings of the 35th Annual Conference of the IEEE Industrial Electronics Society, IECON 2009, Porto, Portugalia, noiembrie 2009.

[44] Ben Othman S., Ben Salem A.K., Ben Saoud S., “Hw acceleration for FPGA-based drive controllers”, Proceedings of the 2010 IEEE International Symposium on Industrial Electronics, ISIE 2010, Bari, Italia, iulie 2010.

[45] Ungurean A., Coroban-Schramel V., Boldea I., “Sensorless control of a BLDC PM motor based on I-f starting and Back-EMF zero-crossing detection”, Proceedings of the 12th International Conference on Optimization of Electrical and Electronic Equipment, OPTIM 2010, Braşov, Romania, mai 2010.

[46] Maragliano G., Marchesoni M., Vaccaro L., “FPGA Implementation of a Sensorless PMSM Drive Control Algorithm Based on Algebraic Method”, Proceedings of the 2010 IEEE International Symposium on Industrial Electronics, ISIE 2010, Bari, Italia, iulie 2010.

204

[47] Bahri I., Monmasson E., Verdier F., Ben Khelifa M.E.-A., “SoPC-based current controller for permanent magnet synchronous machines drive”, Proceedings of the 2010 IEEE International Symposium on Industrial Electronics, ISIE 2010, Bari, Italia, iulie 2010.

[48] de Castro R., Araujo R.E., Feitas D., “Reusable IP cores library for EV propulsion systems”, Proceedings of the 2010 IEEE International Symposium on Industrial Electronics, ISIE 2010, Bari, Italia, iulie 2010.

[49] Kung Y.-S., Huang C.-C., Huang L.-C., “FPGA-realization of a sensorless speed control IC for IPMSM drive”, Proceedings of the 36th Annual Conference of the IEEE Industrial Electronics Society, IECON 2010, Phoenix, Arizona, SUA, noiembrie 2010.

[50] Kedarisetti J., Mutschler P., “FPGA based control of quasi resonant DC-link inverter and induction motor drive”, Proceedings of the 2011 IEEE International Symposium on Industrial Electronics, ISIE 2011, Gdansk, Polonia, iunie 2011.

[51] Ghadedo A., Cirstea M., Cirstea S., “A high level language approach to matrix converter modelling and FPGA controller design”, Proceedings of IEEE International Conference on Mechatronics, ICM2009, Malaga, Spania, aprilie 2009.

[52] Parera-Ruiz A., Cirstea M.N., Ilea D.N., “Rapid development of an FPGA controller for a wind / photovoltaic power system”, Proceedings of the 2008 IEEE International Symposium on Industrial Electronics, ISIE 2008, Cambridge, UK, iunie-iulie 2008.

[53] Petrinec K., Cirstea M., Seare K., Marinescu C., “A novel FPGA fuel cell system controller design”, Proceedings of the 11th International Conference on Optimization of Electrical and Electronic Equipment, OPTIM 2008, Braşov, Romania, mai 2008.

[54] Parera-Ruiz A., Cirstea M.N., Cirstea S.E., Dinu A., “Integrated renewable energy system modelling with direct FPGA controller prototyping”, Proceedings of the 35th Annual Conference of the IEEE Industrial Electronics Society, IECON 2009, Porto, Portugalia, noiembrie 2009.

[55] Tisan A., Cirstea M., Buchman A., Parera A., Oniga S., Ilea D., “Holistic modeling, design and optimal digital control of a combined renewable power system”, Proceedings of the 2010 IEEE International Symposium on Industrial Electronics, ISIE 2010, Bari, Italia, iulie 2010.

[56] Cirstea M., Parera-Ruiz A., “An FPGA controller for a combined solar / wind power system”, Proceedings of the 12th International Conference on Optimization of Electrical and Electronic Equipment, OPTIM 2010, Braşov, Romania, mai 2010.

[57] Idkhajine L., Monmasson E., Maalouf A., “Extended Kalman filter for AC drive sensorless speed controller - FPGA-based solution or DSP-based solution”, Proceedings of the 2010 IEEE International Symposium on Industrial Electronics, ISIE 2010, Bari, Italia, iulie 2010.

[58] Monmasson E., Idkhajine L., Cirstea M.N., Bahri I., Tisan A., Naouar M.W., “FPGAs in industrial control applications”, IEEE Transactions on Industrial Informatics, vol. 7, no. 2, mai 2011.

205

[59] Gokhale M., Graham P.S., Reconfigurable computing: accelerating computation with field-programmable gate arrays, Dordrecht: Springer, 2005.

[60] Hauck S., DeHon A. (editori), Reconfigurable computing: the theory and practice of FPGA-based computation, Morgan Kaufman Publishers, Elsevier, 2008.

[61] Satake S., Hiroi Y., Suzuki Y., Masuda N., Ito T., ”Special-purpose computer for two-dimensional FFT”, Computer Physics Communications, vol. 179, no. 6, septembrie 2008.

[62] Morales-Velazquez L., Romero-Troncoso R.J., Osornio-Rios R.A., Herrera-Ruiz G., Santiago-Perez J.J., “Special purpose processor for parameter identification of CNC second order servo systems on a low-cost FPGA platform”, Mechatronics, vol. 20, no. 2, martie 2010.

[63] Beletti F. et al., “Simulating spin systems on IANUS, an FPGA-based computer”, Computer Physics Communications, vol. 178, no. 3, februarie 2008.

[64] Abderazek B.A., Canedo A., Yoshinaga T., Sowa M., “The QC-2 parallel queue processor architecture”, Journal of Parallel and Distributed Computing, vol. 68, no. 2, februarie 2008.

[65] Bhattacharyya K., Biswas R., Dhar A.S., Banerjee S., “Architectural design and FPGA implementation of radix-4 CORDIC processor”, Microprocessors and Microsystems, vol. 34, no. 2-4, martie-iunie 2010.

[66] Kornaros G., “A soft multi-core architecture for edge detection and data analysis of microarray images”, Journal of Systems Architecture, vol. 56, no. 1, ianuarie 2010.

[67] Jovanovic S., Tanougast C., Bobda C., Weber S., “CuNoC: a dynamic scalable communications structure for dynamically reconfigurable FPGAs”, Microprocessors and Microsystems, vol. 33, no. 1, februarie 2009.

[68] Perez-Vidal C., Gracia L., “High speed filtering using reconfigurable hardware”, Journal of Parallel and Distributed Computing, vol. 69, no. 11, noiembrie 2009.

[69] Poucki V.M., Zemva A., Lutovac M.D., Karcnik T., “Elliptic IIR filter sharpening implemented on FPGA”, Digital Signal Processing, vol. 20, no. 1, ianuarie 2010.

[70] Kaeslin H., Digital integrated circuit design: from VLSI architectures to CMOS fabrication, Cambridge: Cambridge University Press, 2008.

[71] Munden R., ASIC and FPGA verification: a guide to component modeling, Morgan Kaufman Publishers, Elsevier, 2005.

[72] Dubey R., Introduction to embedded system design using field programmable gate arrays, London: Springer Verlag, 2009.

[73] Pellerin D., Thibault S., Practical FPGA programming in C, Prentice Hall, 2005. [74] Kamat R.K., Shinde S.A., Shelake V.G., Unleash the system on chip using

FPGAs and Handel C, Springer, 2009. [75] Burton M., Morawiec A. (editori), Platform based design at the electronic system

level, Dordrecht: Springer, 2006. [76] Meyer-Baese U., Digital signal processing with field programmable gate arrays,

3rd edition, Springer, 2007.

206

[77] Hansselmann H., Kiffmeier U., Koester L., Meyer M., Ruekgauer A., “Production quality code generation from Simulink block diagrams”, Proceeding of the 1999 IEEE International Symposium on Computer Aided Control System Design, CACSD 1999, Kohala Coast, Hawaii, SUA, august 1999.

[78] Grout I., Digital systems design with FPGA and CPLD, Newnes Elsevier, 2008. [79] Chu P.P., FPGA prototyping by VHDL examples, John Wiley and Sons, 2008. [80] Chu P.P., FPGA prototyping by Verilog examples, John Wiley and Sons, 2008. [81] Pedroni V.A., Circuit design with VHDL, Cambridge: MIT Press, 2004. [82] Onea A., Prelucrarea semnalelor, Politehnium, 2006. [83] System Generator for DSP getting started guide, v11.4, Xilinx, decembrie 2009. [84] System Generator for DSP user guide, v11.4, Xilinx, decembrie 2009. [85] System Generator for DSP reference guide, v11.4, Xilinx, decembrie 2009. [86] Maxfield C., FPGAs: world class designs, Newnes Elsevier, 2009. [87] Costas L., Colodron P., Rodriguez-Andina J.J., Farina J., Chow M.-Y., “Analysis

of two FPGA design methodologies applied to an image processing system”, Proceedings of the 2010 IEEE International Symposium on Industrial Electronics, ISIE 2010, Bari, Italia, iulie 2010.

[88] ModelSim SE tutorial, v6.6b, Mentor Graphics, 2010. [89] ModelSim SE user’s manual, v6.6b, Mentor Graphics, 2010. [90] ModelSim SE reference manual, v6.6b, Mentor Graphics, 2010. [91] Moore A.W., “Phase-locked loops for motor speed control”, IEEE Spectrum,

aprilie 1973. [92] Geiger D., Phaselock loops for DC motors, John Wiley and Sons, 1981. [93] Machida H., Kobayashi F., “PLL/PID motor control system by using time-domain

operation of PWM signal”, Proceedings of the International Conference on Instrumentation, Control and Information Technology, SICE Annual Conference 2007, Kagawa, Japonia, septembrie 2007.

[94] Hsieh G.C., Hung J.C., “Phase-locked loops techniques – a survey”, IEEE Transactions on Industrial Electronics, vol. 43, no. 6, decembrie 1996.

[95] Pan C.-T., Fang E., “A phase-locked-loop-assisted internal model adjustable-speed controller for BLDC motors”, IEEE Transactions on Industrial Electronics, vol. 55, no. 9, septembrie 2008.

[96] Amano Y., Tsuji T., Takahashi A., Ouchi S., Hamatsu K., Iijima M., “A sensorless drive system for brushless DC motors using a digital phase-locked loop”, Electrical Engineering in Japan, vol. 142, no. 1, 2003.

[97] Best R.E., Phase-locked loops: design, simulation and applications, McGraw-Hill, 5th Edition, 2003.

[98] Al-Araji S.R., Hussain Z.M., Al-Qutayri M.A., Digital phase lock loops: architectures and applications, Dordrecht: Springer, 2006.

207

[99] Gardner F.M., Phaselock techniques, 3rd Edition, Hoboken: John Wiley and Sons, 2005.

[100] Abramovitch D., “Phase-locked loops: a control centric tutorial”, Proceedings of the American Control Conference, ACC 2002, Anchorage, Alaska, SUA, mai 2002.

[101] Adkins C.A., Marra M.A., Walcott B.L., “Modified phase-frequency detector for improved response of PLL servo controller”, Proceedings of the 2002 American Control Conference, Anchorage, Alaska, SUA, mai 2002.

[102] Alecsa B., Onea A., “An FPGA implementation of an all digital phase locked loop for control applications”, Proceedings of IEEE 5th International Conference on Intelligent Computer Communication and Processing, ICCP 2009, Cluj-Napoca, România, august 2009.

[103] Alecsa B., Onea A., “A FPGA implementation of a phase locked loop for DC motor control”, Buletinul Institutului Politehnic din Iaşi, Tomul LV(LIX), Fasc. 1, 2009, Secţia Automatică şi Calculatoare.

[104] Proakis J., Manolakis D., Digital signal processing: principles, algorithms, and applications, 3rd Edition, Prentice-Hall, 1996.

[105] Alecsa B.C., Onea A., “An FPGA implementation of the time domain deadbeat algorithm for control applications”, Proceedings of IEEE Norchip 2009, Trondheim, Norvegia, noiembrie 2009.

[106] Emadi A., Handbook of automotive power electronics and motor drives, CRC Press, 2005.

[107] ChipScope Pro 12.1 software and cores user guide, Xilinx, aprilie 2010. [108] Mic D., Contribuţii la dezvoltarea unui mediu integrat hardware-software pentru

controlul motoarelor electrice cu circuite logice programabile, teză de doctorat, Universitatea “Transilvania” din Braşov, 2007.

[109] Alecsa B., Onea A., “An FPGA implementation of a brushless DC motor speed controller”, Proceedings of 2010 IEEE 16th International Symposium for Design and Technology in Electronic Packaging, SIITME 2010, Piteşti, România, septembrie 2010.

[110] Alecsa B., Onea A., “Design, validation and FPGA implementation of a brushless DC motor speed controller”, Proceedings of the 17th IEEE International Conference on Electronics, Circuits, and Systems, ICECS2010, Atena, Grecia, decembrie 2010.

[111] Alecsa B., Onea A., “Output analysis of digital interface plants based on FPGA rapid prototyping”, Proceedings of the 14th International Conference on System Theory and Control, ICSTC 2010, Sinaia, România, octombrie 2010.

[112] Nurmi J. (editor), Processor design: system-on-chip computing for ASICs and FPGAs, Dordrecht: Springer, 2007.

[113] Nios II Processor Reference Handbook, Altera, 2010. [114] Yiannacouras P., Steffan J. G., Rose J., “Application-specific customization of

soft processor microarchitecture”, Proceedings of 14th International Symposium on Field-Programmable Gate Arrays, FPGA’06, Monterey, California, SUA, februarie 2006.

208

[115] Metzgen P., “Optimizing a high performance 32-bit processor for programmable logic”, Proceedings of 2004 Symposium on System-on-Chip, SoC 2004, Tampere, Finland, noiembrie 2004.

[116] Fort B., Capalija D., Vranesic Z.G., Brown S.D., “A multithreaded soft processor for SoPC area reduction”, Proceedings of 14th Annual IEEE Symposium on Field-Programmable Custom Computing Machines, FCCM’06, Napa, California, SUA, 2006.

[117] PicoBlaze 8-bit embedded microcontroller user guide, Xilinx, 2010. [118] Yu P., Schaumont P., “Executing hardware as parallel software for PicoBlaze

networks”, Proceedings of International Conference on Field Programmable Logic and Applications, FPL‘06, Madrid, Spania, august 2006.

[119] Oniga S., Tisan A., Lung C., Buchman A., Orha I., “Adaptive hardware-software co-design platform for fast prototyping of embedded systems”, Proceedings of the 12th International Conference on Optimization of Electrical and Electronic Equipment, OPTIM2010, Braşov, România, mai 2010.

[120] Lung C., Sabou S., Orha I., Buchman A., “ZigBee smart sensors networks”, Proceedings of 2010 IEEE 16th International Symposium for Design and Technology in Electronic Packaging, SIITME 2010, Piteşti, România, septembrie 2010.

[121] Alecsa B., Radu B., Onea A., Bârleanu A., “A FPGA implementation of an active noise cancellation system”, Proceedings of the 14th International Conference on System Theory and Control, ICSTC 2010, Sinaia, România, octombrie 2010.

[122] Alecsa B., Onea A., “Combined hardware-software approach for BLDC motor speed controller design”, Proceedings of the International Conference on Mechanical Engineering, Robotics and Aerospace, ICMERA 2010, Bucureşti, România, decembrie 2010.

[123] Coussy P., Morawiec A. (editori), High-level synthesis: from algorithm to digital circuit, Springer, 2008.

[124] Teroerde G., Electrical drives and control techniques, Leuven: Academische Cooperative Vennootschap, 2004.

[125] Hava A., Kerkman R., Lipo T., “Simple analytical and graphical methods for carrier-based PWM-VSI drives”, IEEE Transactions on Power Electronics, vol. 14, no. 1, ianuarie 1999.

[126] Spartan-3E family: complete data sheet, Xilinx, 2008. [127] Ioan A.D., Contribuţii la implementarea structurilor hardware cu circuite

numerice programabile CPLD şi FPGA, teză de doctorat, Universitatea Tehnică “Gheorghe Asachi” din Iaşi, 2010.

[128] Ioan A.D., “New techniques for implementation of hardware algorithms inside FPGA circuits”, Advances in Electrical and Computer Engineering, Vol. 10, No. 2, 2010.

[129] Cirstea M.N., Dinu A., Khor J.G., McCormick M., Neural and fuzzy logic control of drives and power systems, Elsevier, 2002.

[130] Cardarilli G.C., D’Alessio M., Di Nunzio L., Fazzolari R., Murgia D., Re M., “FPGA implementation of a low-area/high-SFDR DDFS architecture”, Proceedings of the 10th

209

International Symposium on Signals, Circuits and Systems, ISSCS 2011, Iaşi, România, iunie-iulie 2011.

[131] Schaumont P.R., A practical introduction to hardware/software codesign, Springer, 2010.

[132] Bose B.K., Modern power electronics and AC drives, Upper Saddle River: Prentice Hall PTR, 2002.

[133] Quang N.P., Dittrich J.-A., Vector control of three-phase AC machines, Berlin: Springer, 2008.

[134] Filho N.P., Pinto J.O.P., Silva L.E.B., Bose B.K., “A simple and ultra-fast DSP-based space vector PWM algorithm and its implementation on a two-level inverter covering undermodulation and overmodulation”, Proceedings of the 30th Annual Conference of the IEEE Industrial Electronics Society, IECON 2004, Busan, Coreea de Sud, noiembrie 2004.

[135] Toliyat H.A., Campbell S., DSP-based electromechanical motion control, Boca Raton: CRC Press, Taylor and Francis Group, 2004.

[136] Pongiannan R.K., Yadaiah N., “FPGA based space vector PWM control IC for three phase induction motor drive”, Proceedings of 2006 IEEE International Conference on Industrial Technology, ICIT 2006, Mumbai, India, decembrie 2006.

[137] Kazmierkowski M.P., Krishnan R., Blaabjerg F. (editori), Control in power electronics: selected problems, San Diego: Academic Press, Elsevier Science, 2002.

[138] Zhou K., Wang D., “Relationship between space-vector modulation and three-phase carrier-based PWM: a comprehensive analysis”, IEEE Tansactions on Industrial Electronics, vol. 49, no. 1, februarie 2002.

[139] Quintero J., Sanz M., Barrado A., Lazaro A., “FPGA based digital control with high-resolution synchronous DPWM and high-speed embedded A/D converter”, Proceedings of 24th Annual IEEE Applied Power Electronics Conference and Exposition, APEC 2009, Washington, DC, SUA, februarie 2009.

[140] Scharrer M., Halton M., Scanlan T., “FPGA-based digital pulse width modulator with optimized linearity”, Proceedings of 24th Annual IEEE Applied Power Electronics Conference and Exposition, APEC 2009, Washington, DC, SUA, februarie 2009.

[141] Navarro D., Barragan L.A., Artigas J.I., Urriza I., Lucia O., Jimenez O., “FPGA-based high resolution synchronous digital pulse width modulator”, Proceedings of IEEE International Symposium on Industrial Electronics, ISIE 2010, Bari, Italia, iulie 2010.

[142] Idkhajine L., Fully FPGA-based sensorless control for synchronous AC drive using an extended Kalman filter, teză de doctorat, Universitatea Cergy Pontoise, Franţa, 2010.

[143] Alecsa B, Onea A., Cirstea M., “An efficient FPGA implementation of the space vector modulation algorithm”, Proceedings of the 10th International Symposium on Signals, Circuits and Systems, ISSCS2011, Iaşi, România, iunie-iulie 2011.

[144] Alecsa B., Onea A., “An optimized FPGA implementation of the modified space vector modulation algorithm for AC drives control”, Proceedings of 21st International

210

Conference on Field Programmable Logic and Applications, FPL2011, Chania, Grecia, septembrie 2011.

[145] Alecsa B., Ioan A., “FPGA implementation of a sinusoidal PWM generator with zero sequence insertion”, Proceedings of the 7th International Symposium on Advanced Topics in Electrical Engineering, ATEE2011, Bucureşti, România, mai 2011.

[146] Alecsa B., Tisan A., Cirstea M., “High resolution 6 channels pulse width modulator for FPGA-based AC motor control”, Proceedings of 2011 International Conference on Applied Electronics, AE2011, Pilsen, Cehia, septembrie 2011.

[147] Krause P., Wasynczuk O., Sudhoff S., Analysis of electrical machinery and drive systems, 2nd Edition, IEEE Press, 2002.

[148] Chiasson J., Modeling and high-performance control of electric machines, IEEE Press, John Wiley and Sons, 2005.

[149] Krishnan R., Permanent magnet synchronous and brushless DC motor drives, Boca Ratorn: CRC Press, Taylor and Francis Group, 2010.

[150] Naouar W., Naasani A., Monmasson E., Slama Belkhodja I., “FPGA-based speed control of synchronous machine using a P-PI controller”, Proceedings of 2006 IEEE International Symposium on Industrial Electronics, ISIE’06, Montreal, Canada, iulie 2006.

[151] Leonhard W., Control of electrical drives, 3rd edition, Berlin: Springer Verlag, 2001.

[152] Bose B., Power electronics and motor drives: advances and trends, San Diego: Academic Press, Elsevier, 2006.

[153] Boldea I., Nasar S.A., Electric drives, 2nd edition, Boca Raton: CRC Press, Taylor and Francis Group, 2006.

[154] Tsuji T., Hashimoto T., Kobayashi H., Mizuoki M., Ohnishi K., “A wide-range velocity measurement method for motion control”, IEEE Transactions on Industrial Electronics, vol. 56, no. 2, februarie 2009.

[155] Petrella R., Tursini M., Peretti L., Zigliotto M., “Speed measurement algorithms for low-resolution incremental encoder equipped drives: a comparative analysis”, Proceedings of 2007 International Aegean Conference on Electrical Machines and Power Electronics, ACEMP’07, Bodrum, Turkey, septembrie 2007.

[156] Kavanagh R.C., “Improved digital tachometer with reduced sensitivity to sensor nonideality”, IEEE Transactions on Industrial Electronics, vol. 47, no. 4, August 2000.

[157] Alecsa B.C., Ioan A.D., “FPGA implementation of a matrix structure for integer division”, Proceedings of the 3rd International Symposium on Electrical and Electronics Engineering, Galaţi, România, septembrie 2010.

[158] Deschamps J.P., Bioul G.J.A., Sutter G.D., Synthesis of arithmetic circuits: FPGA, ASIC, and embedded systems, John Wiley & Sons, 2006.

[159] Kilts S., Advanced FPGA design: architecture, implementation, and optimization, Hoboken: John Wiley & Sons, 2007.

211

[160] Răţoi M.C., Contribuţii la perfecţionarea comenzii sistemelor de acţionare electrică cu motoare de curent alternativ, teză de doctorat, Universitatea Tehnică “Gheorghe Asachi” din Iaşi, 2010.

[161] Alecsa B., Cirstea M., Onea A., “Holistic modeling and FPGA implementation of a PMSM speed controller”, Proceedings of the 37th Annual Conference of the IEEE Industrial Electronics Society, IECON 2011, Melbourne, Australia, noiembrie 2011, acceptată spre prezentare.

213

Anexa A. Descrierea blocurilor bibliotecilor System Generator Tabelul A.1 Blocurile bibliotecii Basic Elements

Bloc Descriere Addressable Shift Register

O grupare de lungime variabilă de registre conectate în serie în care fiecare registru poate fi adresat direct şi citit pe portul de ieşire. Se foloseşte pentru implementarea lanţurilor de întârziere digitală. Implementarea în hardware se realizează folosind memorie RAM. O schemă simplificată:

Assert Se foloseşte pentru a verifica sau specifica formatul de reprezentare sau rata

de eşantionare. Blocul nu are corespondent în hardware, poate doar modifica felul în care System Generator produce hardware-ul.

Bit Basher Realizează operaţii de manipulare a grupurilor de biţi sau biţilor individuali din semnalele de intrare. Operaţiile sunt specificate folosind sintaxa Verilog. Se pot ruta la ieşiri (maximum 4) combinaţii de biţi reordonaţi sau regrupaţi din intrări şi valori constante. Acest bloc nu foloseşte resurse în FPGA, fiind vorba doar despre rutarea unor semnale.

Black Box Permite încorporarea unui modul HDL proiectat în alt mod (fie rezultat după captură de schemă, fie descris direct în HDL) în Simulink. Modulul poate fi co-simulat folosind un simulator extern bazat pe HDL. Codul HDL este

încorporat în proiect, pentru a fi translat în hardware. Clock Enable Probe

Oferă posibilitatea de a determina semnalele de validare a tactului (Clock Enable) asociate anumitor căi de date. Blocul este util pentru verificarea sistemelor cu rate de eşantionare multiple implementate prin validarea tactului.

Concat Realizează concatenarea vectorilor de intrare (maximum 1024) într-unul singur. Semnalele de intrare trebuie să fie de tip întreg (virgula fixă pe poziţia 0) fără semn.

Constant Reproduce la ieşire o valoare constantă, similar cu blocul omonim din Simulink. Când sunt necesare constante numerice, se poate introduce orice valoare reală, aceasta fiind convertită automat (cu rotunjire şi saturaţie) în formatul setat pentru ieşirea blocului. Ieşirea poate fi şi de tip Boolean sau

214

instrucţiune DSP48. Convert Converteşte valoarea de la intrare într-un alt format de reprezentare. Oferă

opţiunile de tratare a situaţiilor de nepotrivire exactă la cuantizare şi de depăşire prezentate detaliat la blocul Gateway In.

Counter Implementează un numărător binar, oferind opţiunile de limitare a numărării la o valoare, de alegere a direcţiei de numărare (incrementare, decrementare sau ambele), de încărcare a unei anumite valori de pe un port de intrare.

Delay Implementează o întârziere digitală de valoare selectabilă, dar fixă. Dacă se doreşte modificarea întârzierii în timpul funcţionării, se poate folosi blocul Addressable Shift Register, deja menţionat.

Down Sample Scade rata de eşantionare a semnalului de intrare. Un eşantion (selectabil, fie primul, fie ultimul dintr-un cadru alcătuit din numărul de eşantioane egal cu rata de subeşantionare) este păstrat la ieşire un număr de cicluri dat de rata de subeşantionare. Implementarea fizică depinde de care eşantion se doreşte din cadru şi de latenţa setată. Pentru primul eşantion din cadru, latenţa poate fi setată 0, şi implementarea este:

. Dacă se alege latenţă mai mare de 0, implementarea este mai eficientă ca timp de propagare:

. Dacă se alege ultimul eşantion din cadru, implementarea este cea mai eficientă, atât ca timp de propagare, cât şi ca resurse folosite:

. Expression Permite introducerea unei expresii logice pe biţi formată cu operatorii logici ~

(NU), & (ŞI), | (SAU), ^ (SAU EXCLUSIV). Intrările trebuie să aibă aceeaşi poziţie a virgulei sau vor fi aliniate de bloc, completându-se cu 0 atât poziţiile cele mai puţin semnificative, cât şi cele mai semnificative.

215

Inverter Realizează complementarea la nivel de bit a intrării. LFSR Implementează un registru de deplasare cu reacţie liniară (Linear Feedback

Shift Register). Se poate selecta între structura Galois şi structura Fibonacci, se pot alege porţi SAU EXCLUSIV sau SAU-NU EXCLUSIV pentru reacţie, se poate opta pentru intrare de încărcare a registrului, iar ieşirea şi intrarea pot fi seriale sau paralele.

Logical Realizează la nivel de bit o funcţie logică selectabilă între intrări (maximum 1024). Posibilităţile sunt ŞI, ŞI NU, SAU, SAU NU, SAU EXCLUSIV, SAU-NU EXCLUSIV. Ca şi la blocul Expression, intrările trebuie să fie aliniate sau vor fi aliniate de bloc după poziţia virgulei.

Mux Implementează un multiplexor de magistrale cu o intrare de selecţie şi până la 32 intrări de date.

Parallel to Serial

Împarte o valoare de intrare în N câmpuri de biţi, scoase la ieşire multiplexate în timp, N fiind raportul (întreg) între numărul de biţi ai intrării şi numărul de biţi ai ieşirii. Ordinea datelor la ieşire este selectabilă: transmisia începe fie cu cel mai puţin semnificativ câmp, fie cu cel mai semnificativ câmp. Un efect secundar al blocului este supraeşantionarea: eşantioanele apar la ieşire cu o rată de N ori mai mare decât la intrare.

Register Reprezintă un registru bazat pe bistabile de tip D. Introduce o întârziere digitală de o perioadă de eşantionare.

Reinterpret Impune un nou format de reprezentare numerică unui semnal, fără a afecta valoarea în binar. Se poate comuta între reprezentarea cu semn şi cea fără semn şi se poate muta poziţia virgulei. Nu consumă resurse hardware la implementare.

Relational Implementează un comparator. Ieşirea este de tip logic (Boolean), iar intrările pot fi de orice tip şi chiar de tipuri diferite. Tipul de comparaţie este selectabil (egal, diferit, mai mic, mai mare, mai mic sau egal, mai mare sau egal).

Reset Generator

Implementează un automat ce generează semnale de reset sincronizate cu diferite rate de eşantionare mai joase, folosind semnalul de reset pentru rata de eşantionare nominală.

Serial to Parallel

Transformă o secvenţă (de lungime N selectabilă) de eşantioane de intrare într-un singur eşantion de ieşire, prin concatenarea biţilor. Ordinea asamblării datelor de intrare este selectabilă. Un efect secundar al blocului este subeşantionarea: eşantioanele apar la ieşire cu o rată de N ori mai mică decât la intrare.

Slice Permite extragerea unui grup de biţi dintr-un semnal. Semnalul de ieşire este de tip întreg (virgula fixă în poziţia 0) fără semn. Grupul de biţi extras poate fi specificat prin mai multe metode, această versatilitate fiind foarte utilă în proiectele în care tipurile semnalelor se modifică dinamic, la rulare.

Time Preia eşantioane de intrare şi le transmite pe rând, cu o rată de N ori mai mică,

216

Division Demultiplexer

la maximum N ieşiri, realizând o demultiplexare în timp. Odată cu demultiplexarea se pot şi elimina eşantioane. Se poate realiza doar eliminarea de eşantioane prin selectarea modului cu ieşire pe un singur canal (single channel).

Time Division Multiplexer

Eşantioanele preluate de la N intrări (maximum 32) sunt transmise serial la o singură ieşire. Un efect secundar al blocului este supraeşantionarea: eşantioanele apar la ieşire cu o rată de N ori mai mare decât la intrări. Toate intrările trebuie să aibă aceeaşi rată de eşantionare.

Up Sample Realizează supraeşantionarea unui semnal prin una din cele 2 metode selectabile: replicarea valorii aceluiaşi eşantion sau inserarea de eşantioane de valoare 0. Prima metodă nu implică nici un fel de cost în hardware. Cea de-a doua este implementată ca mai jos:

.

Tabelul A.2 Blocurile bibliotecii Control Logic Bloc Descriere

Dual Port RAM Implementează o memorie cu acces aleator (RAM – Random Access Memory) cu port dual. Aceasta înseamnă că există 2 porturi independente ce accesează aceeaşi zonă de memorie, lucru foarte util când se doreşte scrierea şi citirea în acelaşi timp în locaţii diferite. Modul de acces de către ambele porturi al aceleiaşi locaţii este stabilit după cum urmează: - o coliziune citire-citire nu reprezintă o problemă, pe ambele porturi de ieşire se transmite valoarea cerută; - o coliziune scriere-scriere invalidează ambele ieşiri; - o coliziune scriere-citire ţine cont de setările blocului: - dacă portul pe care se face scrierea are bifată opţiunea Read before write, atunci pe portul de ieşire va fi prezentă vechea valoare din locaţia respectivă de memorie; - dacă portul pe care se face scrierea are bifată una din opţiunile Read after write sau No read on write, atunci datele de ieşire sunt invalidate. Portul B poate avea lăţime mai mare (multiplu întreg) decât portul A, accesându-se astfel diferit zona de memorie. Dacă cele două porturi au aceeaşi lăţime, atunci pot avea formate de reprezentare diferite, accesându-

217

se în moduri diferite aceleaşi date. Memoria poate fi implementată în FPGA fie folosind blocuri RAM, fie folosind tabele de căutare (LUT – Look-Up Table) din celulele logice (RAM distribuit).

EDK Processor Permite integrarea de module hardware definite în Simulink cu un sistem cu procesor dezvoltat în mediul Xilinx EDK.

FIFO Implementează o memorie de tip coadă, cu acces FIFO (First In First Out). Datele sunt scrise la activarea unui semnal de validare a scrierii şi sunt extrase în ordine cu ajutorul unui semnal de validare a citirii. Blocul oferă şi două semnale de stare a cozii (goală sau plină), precum şi un semnal numeric ce prezintă procentul aproximativ de ocupare a cozii. Implementarea poate fi făcută folosind blocuri de memorie RAM sau RAM distribuit.

MCode Oferă posibilitatea execuţiei de cod Matlab din Simulink. La simulare în Simulink, blocul calculează valorile ieşirilor executând funcţia Matlab asociată. La implementare, codul Matlab este tradus în descriere comportamentală HDL. Doar un subset al limbajului Matlab poate fi folosit într-un bloc MCode, fiind suportate următoarele construcţii: asignare, construcţii if/else, construcţii switch, expresii aritmetice bazate doar pe adunare şi scădere, operaţiile de adunare, scădere, înmulţire, împărţire la o putere a lui 2, operatori relaţionali (<, <=, >, >=, ==, ~=), operatori logici ( &, |, ~), câteva funcţii specifice Xilinx şi câteva din funcţiile Matlab standard. Pentru suport total al limbajului Matlab în proiectarea pentru FPGA există unelte software speciale, cum ar fi AccelDSP.

PicoBlaze Microcontroller

Implementează un microcontroler PicoBlaze pe 8 biţi. Sunt disponibile 2 versiuni, PicoBlaze 2, implementabil pe FPGA-uri Virtex-II, şi PicoBlaze 3, implementabil pe Spartan 3 şi Virtex 4. PicoBlaze 3 dispune de 53 de instrucţiuni, 16 registre de uz general pe 8 biţi, 256 de porturi adresabile direct sau indirect, o întrerupere mascabilă şi 64 de octeţi de memorie RAM internă.

ROM Implementează o memorie cu acces doar pentru citire (ROM – Read Only Memory). Memoria poate fi implementată fizic fie folosind blocuri de memorie RAM, fie RAM distribuit.

Shift Realizează o deplasare a biţilor semnalului de intrare. Se poate selecta direcţia deplasării (stânga sau dreapta) şi numărul de poziţii cu care se face deplasarea. Dacă nu se limitează numărul de biţi ai ieşirii, acest bloc nu ocupă niciun fel de resurse la implementare, fiind doar o problemă de reconectare a unor semnale.

Single port RAM

Implementează o memorie RAM cu un port de date de intrare şi unul de ieşire, adresate de aceeaşi magistrală de adrese. Când semnalul de validare

218

a scrierii nu este activat, atunci pe portul de ieşire e disponibil conţinutul locaţiei adresate. Dacă semnalul de validare a scrierii este activat, atunci valoarea prezentă pe portul de intrare este scrisă în locaţia de memorie adresată. În acest caz, comportarea portului de ieşire este selectabilă între opţiunile: - Read after write: la ieşire se transmite valoarea de la intrare; - Read before write: la ieşire se transmite valoarea anterioară scrierii din locaţia adresată; - No read on write: la ieşire se păstrează ultima valoare citită înainte de activarea semnalului de validare a scrierii. Memoria poate fi implementată fizic fie folosind blocuri de memorie RAM, fie RAM distribuit.

Tabelul A.3 Blocul bibliotecii Data Types ce nu aparţine şi bibliotecilor Basic Elements

sau Control Logic. Bloc Descriere

Scale Scalează valoarea de la intrare cu un factor putere a lui 2 prin ajustarea poziţiei virgulei fixe în reprezentare. Valoarea cu care se face scalarea trebuie să se încadreze în limitele impuse de poziţionarea virgulei fixe între cel mai semnificativ şi cel mai puţin semnificativ bit (nu se realizează deplasări pentru înmulţiri/împărţiri cu puteri ale lui 2). La implementare nu ocupă resurse, scalarea fiind doar o problemă de interpretare.

Tabelul A.4 Blocurile bibliotecii Math.

Bloc Descriere Accumulator Implementează un acumulator cu scalare a reacţiei bazat pe un circuit sumator

sau scăzător. Factorul de scalare este stabilit de un parametru al blocului, ca şi operaţia aritmetică. Implementarea se poate realiza prin descriere HDL (lăsând posibilităţi nelimitate de optimizare uneltei de sinteză) sau prin utilizarea unui nucleu IP. Acesta poate la rândul lui să fie implementat în celule logice (fabric) sau într-o celulă DSP48, dacă sunt disponibile în FPGA.

AddSub Implementează un circuit sumator sau scăzător. Operaţia aritmetică este selectabilă fie static, la definire, fie dinamic, printr-o intrare suplimentară. Există şi opţiunile de intrare şi ieşire suplimentare de transport. Ca şi la blocul Accumulator, implementarea se poate realiza prin descriere HDL (lăsând posibilităţi nelimitate de optimizare uneltei de sinteză) sau prin utilizarea unui nucleu IP. Acesta poate la rândul lui să fie implementat în celule logice (fabric) sau într-o celulă DSP48, dacă sunt disponibile în FPGA. Există de asemenea opţiunea implementării folosind o bandă de asamblare (pipeline) pentru optimizarea performanţelor. Precizia ieşirii poate fi limitată şi există opţiunea

219

adăugării de hardware suplimentar pentru rotunjire şi tratarea depăşirii. Cmult Implementează un circuit de înmulţire cu o constantă. Aceasta poate fi

specificată şi printr-o expresie Matlab ce se evaluează la o valoare constantă. Implementarea fizică este realizată ca o tabelă de căutare şi poate folosi fie blocuri de memorie RAM, fie RAM distribuit. Există şi posibilitatea lăsării implementării în seama software-ului de sinteză, prin bifarea opţiunii “Use behavioral HDL (otherwise use core)”, ceea ce poate duce la implementări mai eficiente ce folosesc multiplicatoarele dedicate, dacă acestea există în FPGA.

Complex Multiplier 3.0

Multiplică două numere complexe, reprezentate ca parte reală şi parte imaginară. Intrările şi ieşirea trebuie să fie reprezentate ca numere cu semn. Se poate opta între o implementare bazată pe multiplicatoare dedicate şi una bazată pe LUT-uri. Se poate stabili numărul de biţi ai ieşirii prin stabilirea MSB şi LSB, iar în cazul în care se mută LSB se poate opta pentru rotunjire prin trunchiere sau aleatoare.

CORDIC 4.0

Implementează un algoritm generalizat de calcul numeric bazat pe rotaţia coordonatelor (CORDIC – Coordinate Rotation Digital Computer). Se poate folosi pentru a calcula rădăcina pătrată, rotaţia unui vector cu un unghi, arctangenta unghiului unui vector, funcţiile sinus şi cosinus pentru un unghi, funcţiile sinus hiperbolic şi cosinus hiperbolic pentru un unghi hiperbolic, arctangenta hiperbolică pentru un vector. Se poate selecta între o implementare serială (folosind mai puţine resurse hardware) sau paralelă (mai rapidă), precum şi între implementare combinaţională sau bazată pe bandă de asamblare. Se pot alege diferite formate de reprezentare a datelor. Se pot seta şi parametri ai algoritmului: numărul de iteraţii, precizia, rotaţia spre primul cadran, scalarea de compensare.

Divider Generator 2.0

Creează un circuit de împărţire pentru numere întregi. Se poate selecta algoritmul folosit dintre împărţirea fără refacere a restului parţial în baza 2 şi împărţirea într-o bază superioară cu pre-scalare (se implementează folosind blocuri DSP48, deci opţiunea este disponibilă numai pentru dispozitive FPGA ce conţin astfel de resurse). Algoritmul în baza doi se poate executa în 1, 2, 4 sau 8 cicluri de tact, opţiunea aleasă afectând resursele ocupate la implementare (mai puţine cicluri de tact înseamnă mai multe resurse hardware necesare). Algoritmul în bază superioară poate fi implementat în bandă de asamblare cu latenţă selectabilă sau aleasă automat şi poate evita împărţirea la 0.

Mult Implementează un multiplicator, calculând produsul a două intrări. Se poate seta latenţa pentru optimizarea vitezei prin intermediul unei benzi de asamblare. Implementarea poate fi făcută la nivel de descriere comportamentală HDL (prin bifarea opţiunii “Use behavioral HDL (otherwise use core)”) sau la nivel de bloc IP. În acest caz se poate selecta între optimizare

220

pentru viteză de execuţie sau resurse ocupate, se poate opta pentru utilizarea blocurilor DSP48 (dacă sunt disponibile) sau a aritmeticii implementate în celule logice, se poate verifica dacă latenţa poate fi optimizată. Pentru a folosi multiplicatoarele dedicate ale familiei Spartan-3 trebuie aleasă implementarea la nivel HDL.

SineCosine Generează funcţiile sinus şi/sau cosinus pentru un unghi dat. Intrarea reprezintă de fapt o adresă într-o tabelă de căutare în care este memorată o perioadă a funcţiei. Implementarea poate fi bazată pe blocuri RAM sau memorie RAM distribuită.

Threshold Testează semnul semnalului de intrare. Dacă acesta este negativ, ieşirea este -1, altfel ieşirea este +1. Ieşirea este de tip întreg, cu semn, pe 2 biţi.

Tabelul A.5 Blocul bibliotecii Memory ce nu apare în bibliotecile deja prezentate.

Bloc Descriere Shared Memory

Implementează o memorie RAM ce poate fi partajată între mai multe proiecte sau secţiuni ale aceluiaşi proiect. Memoria partajată este identificată printr-un nume şi instanţele din acelaşi proiect sau chiar din proiecte diferite având acelaşi nume folosesc aceeaşi memorie fizică. Implementarea fizică se realizează cu blocuri de memorie RAM cu acces dual. Aşadar, pot exista maximum 2 instanţe în acelaşi proiect sau maximum 2 proiecte ce partajează aceeaşi memorie. Se poate selecta modul de protecţie la acces a memoriei, opţiunile fiind “Lockable” (accesul este permis pe baza unui protocol bazat pe semnale request/grant) sau “Unprotected” (fiecare instanţă are portul propriu de acces, cu opţiunile de comportare în caz de coliziune descrise la blocul Dual Port RAM). Memoria partajată poate fi folosită în co-simulări hardware, caz în care se specifică o durată de timeout pentru acces.

Tabelul A.6. Blocurile bibliotecii Tools.

Bloc Descriere ChipScope Permite inserarea în hardware de blocuri pentru captură de semnale interne

din FPGA pentru descărcare şi vizualizare cu utilitarul ChipScope Pro Analyzer. Se implementează astfel un analizor logic virtual în dispozitivul FPGA. Se pot alege numărul de porturi declanşatoare (maximum 16), numărul de unităţi de potrivire şi felul lor pentru fiecare astfel de port, numărul de porturi de date (se pot captura maximum 256 de biţi la un eşantion, deci numărul de porturi de date este limitat de lăţimile adunate ale porturilor), adâncimea memoriei tampon de captură (numărul de eşantioane salvate la o declanşare).

Clock Probe Generează un semnal de tact cu perioada dată de perioada simulării din Simulink. Este util la simularea sistemului şi nu se translează în hardware.

221

Configurable Subsystem Manager

Se foloseşte pentru a permite unui subsistem Simulink să fie selectat şi pentru generare de hardware, nu numai pentru simulare. Se pot crea blocuri de bibliotecă Simulink ce pot fi traduse în hardware, folosindu-se System Generator.

Disregard Subsystem

Elimină din generarea de cod subsistemul în care este plasat. Se foloseşte pentru a adăuga unui modul un model de simulare diferit de modelul de implementare.

FDA Tool Oferă o interfaţă către unealta FDATool din toolbox-ul MATLAB Signal Processing. Aceasta permite proiectarea rapidă a filtrelor digitale complexe, dispunând şi de o interfaţă grafică.

Indeterminate Probe

Semnalizează când intrarea are o valoare nedeterminată (valoarea NaN în MATLAB sau X în VHDL/Verilog). Se foloseşte în simulare şi nu are corespondent în hardware.

ModelSim Permite blocurilor BlackBox să folosească utilitarul ModelSim (dacă este instalat) pentru co-simularea Simulink/HDL.

Multiple Subsystem Generator

Încorporează două sau mai multe proiecte System Generator într-o singură componentă HDL ce conţine domenii de tact diferite. Comunicaţia între domenii se realizează cu blocuri de memorie partajată.

Pause Simulation

Introduce o pauză în simulare atunci când intrarea are o valoare diferită de 0. Simularea poate fi continuată ca şi cum s-ar fi apăsat butonul “Pause” în Simulink. Nu are corespondent hardware, fiind folosit doar la simulare.

Resource Estimator

Face o estimare rapidă a resurselor folosite pentru implementarea unui model creat în System Generator.

Sample Time Raportează perioada normalizată de eşantionare a semnalului conectat la intrare, ca factor de multiplicare pentru durata pasului de simulare.

Simulation Multiplexer

Permite asocierea a două blocuri, unul pentru implementare şi altul pentru simulare. Blocul nu mai este folosit în prezent, fiind mai avantajoasă folosirea subsistemelor configurabile.

Single-Step Simulation

Rulează simularea pas cu pas, cu durata pasului stabilită de blocul System Generator. După fiecare pas simularea trebuie continuată manual, prin apăsarea butonului “Continue Simulation” în Simulink. Blocul permite selectarea modului “Continous”, care lasă simularea să ruleze normal.

Toolbar Oferă acces rapid la câteva utilităţi de vizualizare şi desenare pentru schemele bloc System Generator: “Zoom”, “Undo”, “Reroute”, “Auto Layout”, “Add Terms”, “Help”.

WaveScope Oferă o unealtă puternică şi uşor de folosit de vizualizare a formelor de undă pentru analiza şi depanarea proiectelor System Generator, utilizabilă doar în simulare.

sisteme Încorporate cu fpga pentru … · sisteme de control rapide, de înaltă performanţă....

Documents