UNIUNEA EUROPEANĂ GUVERNUL ROMÂNIEI Fondul Social European Instrumente Structurale OIPOSDRU UNIVERSITATEA TEHNICĂ

MINISTERUL MUNCII, FAMILIEI ŞI POSDRU 2007-2013 2007-2013 “GHEORGHE ASACHI”

PROTECŢIEI SOCIALE DIN IAŞI
AMPOSDRU

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
UNIUNEA EUROPEANĂ GUVERNUL ROMÂNIEI Fondul Social European Instrumente Structurale OIPOSDRU UNIVERSITATEA TEHNICĂ
MINISTERUL MUNCII, FAMILIEI ŞI POSDRU 2007-2013 2007-2013 “GHEORGHE ASACHI”
PROTECŢIEI SOCIALE DIN IAŞI
AMPOSDRU

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

UNIUNEA EUROPEANĂ GUVERNUL ROMÂNIEI Fondul Social European Instrumente Structurale OIPOSDRU UNIVERSITATEA TEHNICĂ
MINISTERUL MUNCII, FAMILIEI ŞI POSDRU 2007-2013 2007-2013 “GHEORGHE ASACHI”
PROTECŢIEI SOCIALE DIN IAŞI
AMPOSDRU
 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).

4
 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
5
 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
6
 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

7
8
 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-

9
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

10
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

11
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

12
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

13
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

14
ş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.

15
16
 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.

17
 Î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.

18
 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.

19
 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.

20
 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].

21
 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.

22
 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 − 2 n −1 , ci la − 2 n −1 + 1 , unde n este numărul de biţi ai reprezentării. În
acest fel, plaja de valori reprezentabile este simetrică, între − 2 n −1 + 1 şi 2 n −1 − 1 . 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.

23
 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 Nr. de module
multiplicatoare implementabile
folosite pe un bloc DSP
9 biţi 1 8
12 biţi 1 6
Multiplicator independent 18 biţi 1 4
36 biţi 1 2
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

24
 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.

25
 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

26
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.

27
 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ă,

28
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].

29
 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

30
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 l1 . A fost dezvoltat, de asemenea,

31
 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 A3 ).
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.

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

⎡ X d ⎤ ⎡ − A11 (θ ) A12 (θ ) ⎤ ⎡ X a ⎤
⎢X ⎥ = ⎢ ⋅ (2.1)
⎣ q ⎦ ⎣− A21 (θ ) A22 (θ )⎥⎦ ⎢⎣ X b ⎥⎦

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].

33
 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ă

34
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

35
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.

36
 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

37
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

38
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.

39
40
 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

41
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.

42
 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

43
(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ă

44
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.

45
 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

46
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,

47
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.

48
Figura 3.1. Biblioteci din blockset-ul Xilinx.

49
 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.

50
 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.

51
 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 Defineşte limbajul ce va fi folosit pentru descrierea HDL a
Language 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 System Generator creează automat un bloc căruia îi asociază
Subsystem fişierele rezultate în urma compilării şi un subsistem configurabil ce
îl conţine.
FPGA Clock Period Defineşte durata perioadei de tact, în ns. Valoarea este transmisă
(ns) 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 Specifică modalitatea de implementare a sistemelor cu rate multiple
Implementation 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

52
 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 Dacă se alege opţiunea Hybrid DCM/CE pentru generarea ratelor
Period (ns) multiple, atunci trebuie specificată frecvenţa semnalului de tact la
intrarea în DCM.
Provide Clock Enable Modulul top generat va oferi un semnal numit ce_clr cu rolul de a
Clear Pin 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 Specifică durata pasului de simulare pentru partea System Generator
Period (sec) î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

53
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.

54
 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

55
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.

56
 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”.

57
 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.

58
 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.

59
 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

60
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;

61
 • 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.

62
 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

63
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.

64
 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

65
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:

Km
H ( s) = , (3.1)
s (1 + sTm )

unde K m este amplificarea, iar Tm 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:

K I τ 2s +1
F (s) = K P + = , (3.2)
s τ 1s

τ2 1
unde K P = , KI = .
τ1 τ1
Î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.

66
 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ă

67
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:

65536
Kd = . (3.3)
2π

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:

z −1 ⎧KP KI ⎫ z −1 ⎡KP z K I Tz ⎤
F ( z) = Z⎨ + ⎬ = ⎢ + ⎥, (3.4)
z ⎩ s s2 ⎭ z ⎢⎣ z − 1 ( z − 1) 2 ⎦⎥

ceea ce conduce la:

KIT
F ( z) = K P + , (3.5)
z −1

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

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

K I Tz −1
F ( z) = K P + . (3.6)
1 − z −1

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]:

U ( z ) K P + ( K I T − K P ) z −1
= ⇒ (3.7)
Ε( z ) 1 − z −1

U ( z ) − z −1U ( z ) = K P E ( z ) + ( K I T − K P ) z −1 E ( z ) ⇒ (3.8)

u[k ] = u[k − 1] + K P ε [k ] + ( K I T − K P )ε [k − 1] . (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.

68
 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 + τ 2 s ) trebuie să fie mult sub frecvenţa de tăiere 1 / Tm :

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

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

τ 2 = 10 s .
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 ω = 1 / Tm . Această constrângere conduce la un
factor de amplificare total al buclei K=0,14. Cunoscând valorile celorlalţi factori de amplificare
( K d , amplificarea detectorului de fază; K m , amplificarea motorului; K a , amplificarea
circuitului PWM şi a driver-ului, prezentată mai jos; K z , amplificarea tahometrului; K N ,
amplificarea divizorului programabil), s-a determinat valoarea lui τ 1 :

65536 20 320 1
⋅ ⋅ ⋅ 60 ⋅
Kd Ka KmK z K N
τ1 = = 2π 65536 60 50 ≈ 146 . (3.11)
K 0.14

Astfel, parametrii filtrului PI sunt:

τ 2 10
Kp = = = 0.068 , (3.12)
τ 1 146

69
 1 1
KI = = = 0.0068 . (3.13)
τ1 146

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

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 2 22 , obţinându-se
11.92Hz. Perioada de eşantionare este deci T=0,084s, ceea ce conduce la factorul de multiplicare
K I T − K P = 0.0005712 − 0.068 = −0.0674288 .
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

20 20
Ka = = . (3.14)
216 65536

Î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].

70
 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:

Km
G p ( s) = , (3.15)
1 + sTm

unde K m este amplificarea, iar Tm 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:

0.8 z 2 + 0.25 z − 0.05

G0 ( z ) = . (3.17)
z4

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

K m = 0,66 şi Tm =1,2s se obţine:

0.2827
G p ( z) = . (3.18)
z − 0.5716

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]:

Ts
≥ 0.36 , (3.19)
TΣf

unde TΣf 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 G0 ( z −1 )
G R ( z −1 ) = . (3.20)
G p ( z −1 ) 1 − G0 ( z −1 )

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:

71
 U ( z −1 ) q 0 + q1 z −1 + q 2 z −2 + q3 z −3 + q 4 z −4
= , (3.21)
Ε( z −1 ) 1 − 0.8 z − 2 − 0.25 z −3 + 0.05 z −4

unde q0 = 0 ;  q1 = 2.8297 ;  q 2 = -0.7333 ;  q3 = -0.6823 ; q 4 = 0.1011 .

Din (3.21) se obţine o relaţie de calcul pentru u[k]:
u[k ] = q1ε [k - 1] + q 2ε [k - 2] + q 3ε [k - 3] + q 4ε [k - 4]
. (3.22)
+ 0.8u[k - 2] + 0.25u[k - 3] − 0.05u[k - 4]

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.

72
 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.

73
 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 10 −3 şi se datorează în mare
măsură erorilor de cuantizare ale CAN şi CNA, şi mai puţin erorilor de cuantizare a parametrilor
regulatorului.

74
 Î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 2 24 , 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].

75
 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).

76
 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.

77
 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ăşurare
1 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+
78
 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.

79
 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.

80
 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

81
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:

DT = 2 5 ⋅ 20ns = 0.64 μs . (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:

DC _ time = ( per _ val − dc _ val ) ⋅ 20ns . (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:

PWM _ PER = ( per _ val + 1) ⋅ 20ns = 40.94μs . (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

82
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.

83
 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

Tclock = 20ns (3.26)

şi o perioadă de eşantionare dorită

Ts = 1ms , (3.27)

rata de divizare este

DIV _ CONST = Ts / Tclock = 50000 = 0xC350 . (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.

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

K I _ 1 = 0.53 , (3.29)

K P _ 1 = 0.004 . (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:

Us
APWM = , (3.31)
2w −1

unde U s 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

19.1
APWM = . (3.32)
2047

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:

CPR
Aspeed _ est = , (3.33)
60 *1000

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

CPR = 500 * 4 = 2000 , (3.34)

ceea ce implică:

1
Aspeed _ est = . (3.35)
30

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

85
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:

K I _1
KI = = 1704.003 , (3.36)
APWM Aspeed _ est

K P _1
KP = = 12.8604 . (3.37)
APWM Aspeed _ est
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:

U ( s) K
G R (s) = = Kp + I , (3.38)
E (s) s

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

2 z −1
s= , (3.39)
Ts z + 1

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

U ( z) K T z −1
GR ( z) = = Kp + I s . (3.40)
E ( z) 2 z +1
Exprimând (3.40) în z −1 rezultă:
K I Ts K T
(+ K P ) + ( I s − K P ) z −1
U ( z −1 ) 2 2
−1
= −1
. (3.41)
E(z ) 1− z
Revenind în domeniul timp, se obţine o relaţie de calcul pentru u[k]:

K I Ts K T
u[k ] = ( + K P )ε [k ] + ( I s − K P )ε [k ] + u[k − 1] . (3.42)
2 2

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
86
î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.

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

88
 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

89
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.

90
 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

91
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].

92
 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.

93
 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

94
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].

95
 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

96
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.

97
 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

98
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.

99
 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

100
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:

101
 • Î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 log 2 32 = 5 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 2 n . 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 2 n 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.

102
 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 2 6 , 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.

103
 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ă 2 n , iar în al doilea 2 N −n , 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
( 2 n ). 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 log 4 64 = 3 niveluri.

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

104
 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 log 4 32 = 3 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.
105
 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].

106
 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

107
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.

108
 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.

109
 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 Xilinx System Generator
pBlazeIDE
Asamblor Apelat din linie de Grafic. Apelat în linie de
comandă, în comandă, prin intermediul
fereastră DOS. Matlab/Simulink/System
Generator.
Sintaxa KCPSM3. pBlazIDE. KCPSM3.
instrucţiunilor
Simulator al Sunt oferite facilităţi Grafic/interactiv. Grafic/interactiv.
setului de pentru simularea
instrucţiuni folosind HDL.
Suport pentru Nu. Da. Da.
puncte de

110
 suspendare a
execuţiei
(breakpoints)
Suport pentru Nu. Da. Da.
vizualizarea
conţinutului
registrelor.
Suport pentru Nu. Da. Da.
vizualizarea
conţinutului
memoriei.

Î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.

111
 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.

112
 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. Lipsa posibilităţii de a simula resurse
ISS precis la nivel de ciclu. logice ataşate procesorului în FPGA.
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

113
 codului.
Temporizări software.
Simulare a întregului sistem prin
intermediul unor funcţii de
intrare/ieşire.
ModelSim Simulare integrată a procesorului Necesită pregătirea simulatorului
PicoBlaze împreună cu resursele logice (definirea căilor spre librării şi fişiere de
ataşate acestuia în FPGA. intrare, definirea opţiunilor la simulare).
Simulare logică şi de temporizare Necesită crearea de fişiere stimul.
bazată pe limbaj HDL (VHDL sau Simularea este a hardware-ului
Verilog). reprezentat de sistem, cu foarte multe
Precizie atât la nivel de ciclu de tact, cât detalii din care este greu de extras doar
şi în funcţie de temporizarea resurselor informaţia legată de execuţia codului şi
din FPGA folosite. starea procesorului.
Xilinx Simulare la nivel de sistem în mediul Util în cazul în care întreg sistemul este
System Matlab/Simulink. proiectat folosind System Generator.
Generator 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.
Direct pe Depanare rapidă, în timp real. Vizibilitate slabă a conţinutului
FPGA Mod de lucru ideal pentru sisteme cu registrelor.
interacţiune complexă.
Integrat cu periferice, interfeţe seriale,
etc.

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

114
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.

115
 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

116
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).

117
 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.

118
 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.

119
 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.

120
 Î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ă ( 1 / 213 = 0.0001220703125 ). 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
2 30
erorii de trunchiere: = 1.073741824 . Desigur, această valoare este aproximată în
10 9
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.

121
 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.

122
 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.

123
 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.
124
 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

125
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].

126
 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.

127
 Î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 Vdc ş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

128
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ă.

129
 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 Vdc / 2 , unde Vdc 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 + Vdc / 2 , iar tensiunea aplicată fazei consumatorului la saturarea tranzistorului
inferior al ramurii va fi − Vdc / 2 .
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, Vref , şi amplitudinea semnalului purtător, V purt , reprezintă
indexul de modulaţie:

Vref
m= . (5.1)
V purt

Pentru o modulaţie corectă, este necesar ca

m ≤ 1. (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 Vdc / 2 . 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

130
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.

131
 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,

132
 ⎧v a , if min( v a , vb , vc ) = v a ;
⎪
v ZSS = ⎨vb , if min( v a , vb , vc ) = vb ; (5.3)
⎪ v , if min( v , v , v ) = v .
⎩ c a b c c

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:

v ZSS = 0.5 * max(min(v a , vb ), min(v a , vc ), min(vb , vc )). (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.

133
 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* 10 −5 . 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 ( 212 ) 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:

ROMv = sin(2 * π * (0 : 4095) / 4096). (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.
134
 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 212 ):

ωN t _ stampTPWM
ROM _ addr = 212 , (5.6)
2π

unde ω este pulsaţia dorită a sinusului în rad/s, N t _ stamp este valoarea numărătorului ce
generează timpul curent, iar TPWM este perioada semnalului PWM. Ecuaţia (5.6) necesită pentru
implementare un singur multiplicator, deoarece singura variabilă din ecuaţie este N t _ stamp .
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 TPWM = 0.00004 s şi o valoare constantă a pulsaţiei
sinusului ω = 63rad / s ≈ 10 Hz .

135
 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.

136
 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.

137
 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.

138
 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 2 / Vdc , unde Vdc
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

s1 = sign(v a − vb );
s 2 = sign(vb − vc ); (5.7)
s3 = sign(v a − vc ).

Tabelul 5.1. Tabela de adevăr pentru determinarea intrării de selecţie a multiplexorului.

s1 s2 s3 Sel a1 a0 VZSS
0 0 0 1 0 1 vb
1 0 0 0 0 0 va
1 0 1 2 1 0 vc
1 1 1 1 0 1 vb
0 1 1 0 0 0 va
0 1 0 2 1 0 vc

139
 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 v a ≥ vb , respectiv vb ≥ vc , s3 nu poate fi 1, ceea ce ar însemna că v a < vc .
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:

a0 = s1 ⋅ s 2 ⋅ s3 + s1 ⋅ s 2 ⋅ s3;
(5.8)
a1 = s1 ⋅ s 2 ⋅ s3 + s1 ⋅ s 2 ⋅ s3.

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.

140
 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:

1 f clk
cnt _ scale = . (5.9)
2 f PWM

141
 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 f clk = 50 MHz şi f PWM = 20kHz , rezultă
cnt _ scale = 1250. 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.

142
 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.

143
 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.

144
 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 Bistabili de tip D Felii logice Multiplicatoare Blocuri de
intrări integrate memorie RAM
698 din 9312 511 din 9312 478 din 4656 8 din 20 4 din 20
(7%) (5%) (10%) (40%) (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.
145
 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:
r
V = vα + jv β = Vm e jθ . (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) Vm şi pulsaţie ω, atunci
r
vectorul spaţial V va avea magnitudinea Vm şi se va roti pe o orbită circulară cu viteza
unghiulară ω [124].
Şi variabilele trifazice pot fi exprimate sub formă vectorială:
r 2
V = (v a + avb + a 2 vc ), (5.11)
3

unde a = e j 2π / 3 şi a 2 = e − j 2π / 3 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 ( 2 3 ) 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 Starea tranzistoarelor Componentele fazorului de tensiune
punţii Q1 Q3 Q5 vα vβ v
000 OFF OFF OFF 0 0 0
100 ON OFF OFF 2Vdc / 3 0 2Vdc / 3
110 ON ON OFF Vdc / 3 Vdc / 3 2Vdc / 3
010 OFF ON OFF − Vdc / 3 Vdc / 3 2Vdc / 3
011 OFF ON ON − 2Vdc / 3 0 2Vdc / 3
101 ON OFF ON Vdc / 3 − Vdc / 3 2Vdc / 3
111 ON ON ON 0 0 0

146
 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ă.

147
 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.

148
 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:

1
a = vα + vβ ;
3
3
b = −vα + vβ ; (5.12)
3
1
c = −vα − vβ .
3

Pentru sectoarele 2 şi 5:

a = 2vα ;
2
b= vβ ; (5.13)
3
2
c=− vβ .
3

149
 Figura 5.24. Algoritmul de calculare a valorilor raporturilor de activare.

Pentru sectoarele 3 şi 6:

1
a = vα − vβ ;
3
1
b = −vα + vβ ; (5.14)
3
3
c = −vα − vβ .
3

Factorii de umplere pentru semnalele PWM se calculează apoi din valorile raporturilor de
activare:

a +1 b +1 c +1
dc a,b,c = [ ; ; ] ⋅ 100% . (5.15)
2 2 2

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:

150
 1
vα ≥ vβ (5.16)
3

poate fi rescrisă ca:

1
vα − vβ ≥ 0 . (5.17)
3

La fel, cealaltă condiţie poate fi rescrisă ca:

1
vα + vβ ≥ 0 . (5.18)
3

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:

151
 ⎧ 1
⎪⎪vα [k ] = 3 (2v a [k ] − vb [k ] − vc [k ]);
⎨ (5.19)
⎪ v β [k ] = 3 (vb [k ] − vc [k ]).
⎪⎩ 3

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.

152
 Algoritmul din Fig. 5.26 începe cu normalizarea componentelor α/β ale tensiunii
trifazate. Prin înmulţire cu 3 /(2 * Vdc ) , 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 1 / 3 ,

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

153
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: Rezoluţia
LUT-uri/bistabili
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 vα = 60 şi v β = 34 , cu Vdc = 120 , 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.

154
 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].

155
 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.

Resurse Sistem cu modulator
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.

156
 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.
Resurse Modulator
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

157
 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

158
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°.

159
 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.

160
 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

161
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 Perioada “ON” Perioada “ON” Δt “ON” (ns)
de prag teoretică (ns) măsurată (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.

162
 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

163
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 Perioada “ON” Perioada “ON” Δt “ON” (ns)
de prag teoretică (ns) măsurată (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.

164
 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

165
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].

166
 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, rs reprezintă rezistenţa înfăşurării
statorice, N s reprezintă numărul de spire al înfăşurării, v as , vbs , vcs reprezintă căderile de
tensiune pe înfăşurările notate cu as, bs, cs în Fig. 6.1, iar ias , ibs , ics 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 .

167
 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:

⎡ 1 1 ⎤ ⎡ ⎤
⎢ Lls + L A −
2
LA −
2
LA ⎥ i ⎢ λ ′ sin θ ⎥
⎡v as ⎤ ⎡rs 0 0 ⎤ ⎡ias ⎤
⎥ ⎡ as ⎤ d ⎢
m r
⎢v ⎥ = ⎢ 0 d ⎢ 1 1 2π ⎥
⎢ bs ⎥ ⎢ rs 0 ⎥⎥ ⎢⎢ibs ⎥⎥ + ⎢ − L A Lls + L A − LA ⎥ ⎢ibs ⎥ + ⎢λm′ sin(θ r − )⎥ ,
dt ⎢ 2 2 ⎥ ⎢ ⎥ dt ⎢ 3 ⎥
⎢⎣ vcs ⎥⎦ ⎢⎣ 0 0 rs ⎥⎦ ⎢⎣ics ⎥⎦ ⎢⎣ics ⎥⎦
⎢ −1L −
1
LA Lls + L A ⎥ ⎢λ ′ sin(θ + 2π )⎥
⎢⎣ 2 A 2 ⎥⎦ ⎣⎢
m r
3 ⎦⎥
(6.1)

unde Lls 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

168
 2
⎛ N ⎞ πμ 0 rl
LA = ⎜ s ⎟ , (6.2)
⎝ 2 ⎠ g

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:

P 1 1 3
Te = λm′ [(ias − ibs − ics ) cos θ r + (ibs − ics ) sin θ r ] , (6.3)
2 2 2 2

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:

2 d 2
Te = J ω r + F ω r + TL , (6.4)
P dt P

unde J este momentul de inerţie a rotorului şi a sarcinii, F este factorul de fricţiune, iar TL 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

⎡ 2π 2π ⎤
⎢cos θ cos(θ −
3
) cos(θ + )
3 ⎥
2⎢ 2π 2π ⎥
K s = ⎢ sin θ sin(θ − ) sin(θ − )⎥ , (6.5)
3⎢ 3 3 ⎥
⎢ 1 1 1 ⎥
⎢⎣ 2 2 2 ⎥⎦

vectorilor mărimilor trifazate se obţin reprezentările lor în sistemul de coordonate q/d:

⎡v qs ⎤ ⎡v as ⎤
⎢v ⎥ = K ⋅ ⎢v ⎥ , (6.6)
⎢ ds ⎥ s ⎢ bs ⎥
⎢⎣v0 s ⎥⎦ ⎢⎣ vcs ⎥⎦
169
 ⎡iqs ⎤ ⎡ias ⎤
⎢i ⎥ = K ⋅ ⎢⎢ibs ⎥⎥ . (6.7)
⎢ ds ⎥ s
⎢⎣i0 s ⎥⎦ ⎢⎣ics ⎥⎦

Aplicând transformarea dată de (6.5) întregii ecuaţii electrice a motorului (6.1), rezultă:

⎡v qs ⎤ ⎡rs 0 0 ⎤ ⎡iqs ⎤ ⎡ Ld ids + λm′ ⎤ ⎡ Lq 0 0 ⎤ ⎡iqs ⎤ ⎡0⎤

⎢v ⎥ = ⎢ 0 ⎥ ⎢ ⎥ ⎢ ⎥ d ⎢ ⎥ ⎢ ⎥ d ⎢ ⎥
⎢ ds ⎥ ⎢ rs 0 ⎥ ⎢ids ⎥ + ω r ⎢ − Lq iqs ⎥ + ⎢ 0 Ld 0 ⎥ ⎢ids ⎥ + ⎢λm′ ⎥ ,
dt dt
⎢⎣v0 s ⎥⎦ ⎢⎣ 0 0 rs ⎥⎦ ⎢⎣i0 s ⎥⎦ ⎢⎣ 0 ⎥⎦ ⎢⎣ 0 0 Lls ⎥⎦ ⎢⎣i0 s ⎥⎦ ⎢⎣ 0 ⎥⎦

(6.8)

3
unde Lq = Lls + L A este inductanţa echivalentă pe axa q, iar Ld este inductanţa echivalentă pe
2
axa d şi este egală cu Lq î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:

d
v qs = rs iqs + ω r Ld ids + ω r λ m′ + Lq iqs , (6.9)
dt

d
v ds = rs ids − ω r Lq iqs + Ld ids , (6.10)
dt

d
v0 s = rs i0 s + Lls i0 s . (6.11)
dt

Aplicând transformarea dată de (6.5) ecuaţiei de cuplu a motorului (6.3) se obţine [147]:

3P
Te = (λ m′ iqs + ( Ld − Lq )iqs ids ) . (6.12)
22

Se observă că în cazul PMSM cu rotor rotund, cum inductanţele echivalente pe cele două
axe sunt egale, (6.12) se simplifică în:

3P
Te = λm′ iqs . (6.13)
22

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:

170
 ⎡ 2π 2π ⎤
⎢ cos θ cos(θ −
3
) cos(θ + )
3 ⎥
2⎢ 2π 2π ⎥
K s = ⎢− sin θ − sin(θ − ) − sin(θ − )⎥ . (6.14)
3⎢ 3 3 ⎥
⎢ 1 1 1 ⎥
⎢⎣ 2 2 2 ⎥⎦

În continuare se va utiliza această formă a transformării, iar toate referirile la matricea

K s 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:

⎡ 1 1 ⎤
⎢1 − −
2 2 ⎥
⎢ ⎥
2⎢ 3 3⎥
C= 0 − . (6.15)
3⎢ 2 2 ⎥
⎢1 1 1 ⎥
⎢2 2 2 ⎥⎦
⎣

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:

⎡ cos θ sin θ 0⎤
P = ⎢⎢− sin θ cos θ 0⎥⎥ . (6.16)
⎢⎣ 0 0 1⎥⎦

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ă

Ks = P ⋅C . (6.17)

Transformărilor directe le corespund transformări inverse, date de inversele matricelor

prezentate:

171
 ⎡ ⎤
⎢ cos θ − sin θ 1⎥
⎢ 2π 2π ⎥
K s−1 = ⎢cos(θ − ) − sin(θ − ) 1⎥ , (6.18)
⎢ 3 3 ⎥
⎢cos(θ + 2π ) − sin(θ + 2π ) 1⎥
⎢⎣ 3 3 ⎥⎦

⎡ ⎤
⎢ 1 0 1⎥
⎢ 1 3 ⎥
C −1 = ⎢− 1⎥ , (6.19)
⎢ 2 2 ⎥
⎢ 1 3 ⎥
⎢− − 1⎥
⎣ 2 2 ⎦

⎡cos θ − sin θ 0⎤
P −1 = ⎢⎢ sin θ cos θ 0⎥⎥ . (6.20)
⎢⎣ 0 0 1⎥⎦

Din nou, se poate arăta că

K s−1 = C −1 ⋅ P −1 . (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
172
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.

173
 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:

1
rs
Gq ( s) = . (6.22)
Lq
1+ s
rs

Punând funcţia de transfer a regulatorului PI sub forma:

τis +1
G PI ( s ) = K PI , (6.23)
τis

parametrul τ i se va alege astfel încât să compenseze polul funcţiei Gq (s ) :

Lq
τ iq = . (6.24)
rs

Funcţia de transfer în buclă închisă se reduce la:

1 1
Gcq ( s ) = = . (6.25)
τ iq rs τ qs +1
s +1
K PIq

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

Ts = 50 μs . (6.26)

174
 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 K PI :

Lq
K PIq = . (6.27)
4Ts

În mod asemănător, pentru regulatorul de curent de pe axa d rezultă parametrii:

Ld
τ id = , (6.28)
rs

Ld
K PId = . (6.29)
4Ts

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:
3P
λm′ Kω
Gω ( s ) = 4 F = . (6.30)
J
s +1
τ ω s +1
F

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):

1 Kω
Goω ( s ) = K ω′ . (6.31)
τ qs +1τω s +1

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:

175
 K ω′ K ω
τ qτ ω
Gcω ( s ) = . (6.32)
2 1 K ω′ K ω
s + s+
τq τ qτ ω

Factorul de amplificare pentru regulatorul P se alege astfel încât funcţia de transfer în

1
buclă închisă să aibă un pol dublu în s = − :
2τ q

τω J
K ω′ = = . (6.33)
4 K ωτ q 3Pλ m′ τ q

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 Gcω (s ) :

τ iω = 2τ q . (6.34)

Funcţia de transfer în buclă deschisă rămasă este:

1
Goω1 ( s ) = K PIω . (6.35)
τ iω s (2τ q s + 1)

Rezultă o funcţie de transfer în buclă închisă ce descrie un sistem de ordinul II:

K PIω 1
Gcω1 ( s ) = . (6.36)
4τ q2 s 2 + 1 s + K PIω
2τ q 4τ q2

Factorul de amplificare K PIω 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ă,
K PIω .

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.

176
Figura 6.4. Schema Simulink a sistemului de reglare.

Figura 6.5. Parametrii motorului PMSM Pittman 3441.

177
 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:

P
θe = θm , (6.37)
2

P
ωe = ωm . (6.38)
2

Î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):

τ iq = τ id = 0.00017524 , (6.39)

K PIq = K PId = 2.3. (6.40)

Factorii de amplificare pentru elementele proporţional şi integrator ale regulatoarelor

rezultă:

K Pq = K Pd = 2.3, (6.41)

K Iq = K Id = 13125. (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
178
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):

K ω′ = 0.0571. (6.43)

Pentru bucla externă, parametrul τ iω rezultă conform (6.34):

τ iω = 0.00035048 . (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.
179
 Parametrul K PIω 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.

K PIω = 0.1024. (6.45)

Rezultă pentru regulatorul PI parametrii:

K Pω = 0.1024, (6.46)

K Iω = 256. (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ă.

180
 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 Ts = 50 μs ,
î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:

K I Ts K T
u[k ] = ( + K P )ε [k ] + ( I s − K P )ε [k − 1] + u[k − 1] , (6.48)
2 2

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:

⎧ 1
⎪⎪iα [k ] = 3 (2ia [k ] − ib [k ] − ic [k ]);
⎨ (6.49)
⎪ iβ [k ] = 3 (ib [k ] − ic [k ]),
⎪⎩ 3

⎧iq [k ] = cos(θ e [k ])iα [k ] + sin(θ e [k ])i β [k ];

⎨ (6.50)
⎩id [k ] = sin(θ e [k ])iα [k ] − cos(θ e [k ])i β [k ].

181
 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:

⎧vα [k ] = cos(θ e [k ])v q [k ] + sin(θ e [k ])v d [k ];

⎨ (6.51)
⎩v β [k ] = sin(θ e [k ])v q [k ] − cos(θ e [k ])v d [k ].

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:

⎧v q _ dec [k ] = ω e [k ]id [k ]Ld + ω e [k ]λ m′ ;

⎨ (6.52)
⎩ v d _ dec [k ] = −ω e [k ]iq [k ]Lq .

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.

182
 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
183
 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.

184
 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.

185
 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.

186
 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

187
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.

188
 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.

189
 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.

190
 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:

2π
ω= f clk , (6.53)
N fronts N lines n

unde N lines = 500 este numărul de linii al codificatorului, n este valoarea salvată în registru, iar
N fronts 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 N fronts = 4 ,
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,
N fronts = 1 î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

191
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

192
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 Bistabili de tip D Felii logice Multiplicatoare Blocuri de
intrări integrate memorie RAM
2679 din 9312 2655 din 9312 2211 din 4656 11 din 20 1 din 20
(28%) (29%) (48%) (55%) (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.

193
 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ă.

194
 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

195
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].

196
 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;

197
 • 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
198
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).

199
200
 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.

201
 [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.

202
 [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.

203
 [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.

204
 [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.

205
 [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-
th
Hill, 5 Edition, 2003.
[98] Al-Araji S.R., Hussain Z.M., Al-Qutayri M.A., Digital phase lock loops:
architectures and applications, Dordrecht: Springer, 2006.

206
 [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.

207
 [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

208
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

209
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.

210
 [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.

211
212
 Anexa A. Descrierea blocurilor bibliotecilor System Generator

Tabelul A.1 Blocurile bibliotecii Basic Elements

Bloc Descriere
Addressable O grupare de lungime variabilă de registre conectate în serie în care fiecare
Shift Register 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 Oferă posibilitatea de a determina semnalele de validare a tactului (Clock
Probe 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

213
 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.
214
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 Împarte o valoare de intrare în N câmpuri de biţi, scoase la ieşire multiplexate
Serial î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 Implementează un automat ce generează semnale de reset sincronizate cu
Generator diferite rate de eşantionare mai joase, folosind semnalul de reset pentru rata
de eşantionare nominală.
Serial to Transformă o secvenţă (de lungime N selectabilă) de eşantioane de intrare
Parallel î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ă,

215
Division la maximum N ieşiri, realizând o demultiplexare în timp. Odată cu
Demultiplexer 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 Eşantioanele preluate de la N intrări (maximum 32) sunt transmise serial la o
Division singură ieşire. Un efect secundar al blocului este supraeşantionarea:
Multiplexer 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-

216
 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 Implementează un microcontroler PicoBlaze pe 8 biţi. Sunt disponibile 2
Microcontroller 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 Implementează o memorie RAM cu un port de date de intrare şi unul de
RAM ieşire, adresate de aceeaşi magistrală de adrese. Când semnalul de validare

217
 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

218
 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 Multiplică două numere complexe, reprezentate ca parte reală şi parte
Multiplier imaginară. Intrările şi ieşirea trebuie să fie reprezentate ca numere cu semn. Se
3.0 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 Implementează un algoritm generalizat de calcul numeric bazat pe rotaţia
4.0 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 Creează un circuit de împărţire pentru numere întregi. Se poate selecta
Generator algoritmul folosit dintre împărţirea fără refacere a restului parţial în baza 2 şi
2.0 î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

219
 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 Implementează o memorie RAM ce poate fi partajată între mai multe proiecte
Memory 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.

220
Configurable Se foloseşte pentru a permite unui subsistem Simulink să fie selectat şi pentru
Subsystem generare de hardware, nu numai pentru simulare. Se pot crea blocuri de
Manager bibliotecă Simulink ce pot fi traduse în hardware, folosindu-se System
Generator.
Disregard Elimină din generarea de cod subsistemul în care este plasat. Se foloseşte
Subsystem 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 Semnalizează când intrarea are o valoare nedeterminată (valoarea NaN în
Probe 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 Încorporează două sau mai multe proiecte System Generator într-o singură
Subsystem componentă HDL ce conţine domenii de tact diferite. Comunicaţia între
Generator domenii se realizează cu blocuri de memorie partajată.
Pause Introduce o pauză în simulare atunci când intrarea are o valoare diferită de 0.
Simulation 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 Face o estimare rapidă a resurselor folosite pentru implementarea unui model
Estimator 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 Permite asocierea a două blocuri, unul pentru implementare şi altul pentru
Multiplexer simulare. Blocul nu mai este folosit în prezent, fiind mai avantajoasă
folosirea subsistemelor configurabile.
Single-Step Rulează simularea pas cu pas, cu durata pasului stabilită de blocul System
Simulation 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.

221