Transcript
Cuprins
1
Cuprins
1. Obiective şi specificaŃii ................................................................................................. 3
2. Fundamente teoretice. Studiu bibliografic................................................................... 4
2.1. Structuri hardware reconfigurabile .......................................................................... 4
2.1.1. Prezentare generală ......................................................................................... 4
2.1.2. Placa de dezvoltare Digilent Nexys2[4].............................................................. 7
2.2. Limbajul de descriere hardware VHDL[5][12]............................................................ 8
2.2.1. Structura unui fişier sursă VHDL...................................................................... 9
2.3. Limbajul Visual C# ................................................................................................ 12
2.4. Algoritmi de gesenare a primitivelor grafice .......................................................... 15
2.4.1. Linia[7][8] ........................................................................................................ 15
2.4.2. Cercul[9] ......................................................................................................... 17
2.4.3. Elipsa[10] ......................................................................................................... 22
2.5. Sisteme de reprezentare a culorilor în echipamente video ...................................... 25
2.5.1. Sistemul RGB – Red, Green, Blue (roşu, verde, albastru)[17] ........................... 25
2.5.2. Sisteme luminanŃă-crominanŃă – YCrCb, YPbPr, YDbDr, YUV[19] .................. 28
2.5.3. Sisteme nuanŃă-saturaŃie – HSV, HSL[16] ........................................................ 29
2.6. Algoritmi de prelucrare a imaginii ......................................................................... 32
2.6.1. Negativul imaginii .......................................................................................... 33
2.6.2. Controlul luminozităŃii imaginii[13] ................................................................. 34
2.6.3. Controlul contrastului imaginii[15] .................................................................. 35
2.6.4. Controlul saturaŃiei imaginii[14] ...................................................................... 36
2.7. InterfeŃele seriale RS-232 şi PS/2 ........................................................................... 37
2.7.1. InterfaŃa serială RS-232[11][18] ........................................................................ 37
2.7.2. InterfaŃa serială PS/2[1] .................................................................................. 39
2.8. Protocolul de transfer între mouse şi sistem[1]........................................................ 41
3. Analiza, proiectarea şi implementarea hardware a aplicaŃiei pentru FPGA ........... 44
3.1. Premise de proiectare – Analiza problemei ............................................................ 44
3.2. Proiectarea structurii hardware – Schema bloc ..................................................... 51
3.3. Proiectarea şi implementarea generatorului semnalelor de ceas ............................ 51
3.4. Scanarea stării butoanelor – modulul debouncer ................................................... 52
3.5. Proiectarea şi implementarea memoriei video ....................................................... 53
3.6. Proiectarea şi implementarea controlerului LCD-ului ........................................... 55
Proiect de diplomă
2
3.6.1. Sincronizarea ................................................................................................. 55
3.6.2. Preluarea datelor din memoria video.............................................................. 56
3.6.3. Generarea interfeŃei grafice ............................................................................ 57
3.6.4. InterfaŃa grafică OSD de control a LCD-ului .................................................. 58
3.6.5. Generarea semnalului PWM pentru controlul luminozitătii LCD-ului ............. 61
3.7. Modulul de modificare a parametrilor funcŃie de evenimentele mouse-ului ............ 62
3.8. Selectorul modului de funcŃionare .......................................................................... 64
3.9. Generarea primitivelor grafice .............................................................................. 65
3.10. Procesarea imaginii în timp real ........................................................................ 69
3.11. Controlul interfeŃei RS-232 - comunicaŃia cu PC-ul ........................................... 71
3.12. Modulul principal – schema sintetizată a structurii ............................................ 73
4. Analiza, proiectarea şi implementarea aplicaŃiei software pentru PC ..................... 74
4.1. Premise de proiectare – Analiza problemei ............................................................ 74
4.2. Proiectare – Structurarea pe clase ......................................................................... 74
4.3. Proiectare – InterfaŃa grafică ................................................................................ 75
4.4. Premise de implementare ....................................................................................... 76
4.5. Implementarea interfeŃei grafice ............................................................................ 77
4.6. Implementarea clasei pentru simularea unui buffer video ...................................... 83
4.7. Implementarea clasei şi metodelor pentru gesenarea primitivelor grafice .............. 83
4.8. Implementarea clasei şi metodelor pentru filtrele punctuale .................................. 85
4.9. Implementarea comunicaŃiei seriale....................................................................... 85
5. Testare şi validare ....................................................................................................... 87
5.1. Testarea modulelor VHDL implementate ............................................................... 87
5.1.1. Tehnici de testare folosite ............................................................................... 87
5.1.2. Simulări ale modulelor implementate .............................................................. 87
5.2. Testarea aplicaŃiei software pentru PC .................................................................. 92
5.2.1. Planul de testare ............................................................................................. 92
5.2.2. Rezultate ale testării ....................................................................................... 93
6. Concluzii ..................................................................................................................... 97
6.1. Probleme întâmpinate şi soluŃionarea lor .............................................................. 97
6.2. Realizări şi direcŃii de dezvoltare ........................................................................... 98
Bibliografie ....................................................................................................................... 100
Anexe ................................................................................................................................ 101
Capitolul 1 - Obiective şi specificaŃii
3
1. Obiective şi specificaŃii
Tema proiectului de faŃă presupune realizarea unui sistem hardware pentru generarea
primitivelor grafice pe un afişor LCD de dimensiuni mici sau medii şi pentru aplicarea asupra
imaginii rezultate a unor procesări de bază. Modulul respectiv trebuie să ofere posibilitatea
conectării la un calculator personal şi să fie capabil de a recepŃiona şi executa comenzi primite
de la o aplicaŃie software aferentă.
Figura 1.1. Schema de principiu a sistemului dorit.
Se doreşte o procesare a imaginii rezultate în timp real cu minimum de întârzieri ale
semnalului de culoare trimis afişorului. OperaŃiile de desenare şi de procesare vor fi
implementate atât în structura hardware, cât şi în aplicaŃia software de comandă.
Tema proiectului este total motivată de cererea actuală din ce în ce mai mare de sisteme
de tip CAD portabile care pot lucra de sine stătătoare, dar totodată oferind posibilitatea
conectării şi trasferului de informaŃie cu un calculator (figura 1.2). În acest sens proiectul
atinge o fază incipientă a unui astfel de sistem, oferind elementele de bază pentru dezvoltări
ulterioare.
Figura 1.2. Sistem CAD embedded.
Proiect de diplomă
4
2. Fundamente teoretice. Studiu bibliografic
2.1. Structuri hardware reconfigurabile
2.1.1. Prezentare generală
Structurile programabile se găsesc în literatura de specialitate sub denumirea de FPD
(field programmable device) în care sunt incluse module digitale ce pot fi configurate de către
proiectant pentru anumite operaŃii. Ele reprezintă un tip aparte de circuite VLSI (Very-large-
scale integration). O structură programabilă este numită reconfigurabilă datorită faptului că
schimbarea interconexiunilor din aceasta conduce la o altă configuraŃie a FPD-ului.
ConfiguraŃia FPD-ului este reŃinută într-o memorie înternă a acestuia. În funcŃie de tipul
de memorie folosită există următoarele tipuri de tehnologii de programare: ROM, RAM,
EPROM, E2ROM şi FLASH.[5]
În funcŃie de complexitatea structurilor reconfigurabile acestea sunt clasificate astfel:
1. PLD – Programmable Logic Devide – din aceastp categorie fac parte următoarele
tipuri de structuri reconfigurabile: PLA (Programmable Logic Array), PAL
(Programmable Array Logic), GAL (Generic Array Logic).
2. CPLD – Complex Programmable Logic Array - pentru scopuri practice aceste
circuite pot fi vizualizate ca PLD-uri multiple într-un singur circuit integrat.
3. FPGA – Field Programmable Gate Array – sunt cele mai complexe structuri
hardware reconfigurabile; în acestea se poate implementa aproape orice tip de circuit;
Structurile CPLD sunt formate dintr-un număr definit de blocuri de tip MacroCell care se
găsesc pe o singură capsulă. Acestea reprezintă o complexitate plasată între PLA şi FPGA.
Din punct de vedere tehnologic sunt implementate pe o tehnologie nevolatilă, dar în prezent
se gasesc în mare parte şi în tehnologie FLASH. Intern, numărul de porŃi logice ajunge la sute
de mii dând posibilitatea unor aplicaŃii mai complexe în comparaŃie cu PLA. În plus, spre
deosebire de PLA, deŃin blocuri logice interne între macrocelule şi functii logice specializate
pentru cele utilizate des în digital. Circuitul CPLD este format din blocuri de tip I/O şi blocuri
logice configurate prin matrici logice de interconectare. Blocurile logice ale unui CPLD au o
structură destul de apropiată celor ale circuitelor PLD.
Capitolul 2 - Fundamente teoretice. Studiu bibliografic
5
Figura 2.1.1.1. Structura internă a unui CPLD.[5]
Principalii producătorii de structuri hardware reconfigurabile sunt: Xilinx, Altera,
Cypress, Atmel şi Lattice.
În circuitele de tip CPLD interconectările se găsesc sub două tipuri:[5]
1. Interconectări bazate pe matrici (array based interconnect).
Acestea leagă semnalele dintre matricea de interconectare către blocurile logice. Fiecare
linie din matricea de interconectare este reprezentată printr-un fir vertical şi este atribuită ca
intrare unui bloc logic dat. Pentru fiecare intrare din matricea de interconectare dată către un
bloc logic prezintă câte un termen produs. Ieşirea unui bloc logic poate fi conectată la un
termen produs prin intermediul unei celule (de tip EPROM) sau un pin de ieşire. Acest tip de
rutare este relativ scump, consumă mult şi ocupă o suprafaŃă fizică destul de mare, dar
prezintă o flexibilitate de implementare destul de bună.
Figura 2.1.1.2. Modul de interconectare bazat pe matrici.
���������
���������
…
…
…
…
…
…
Matrice de
interco-nectare
Blocurile logice
I/O
Blocurile logice
I/O
Blocurile logice
Blocurile logice
Blocurile logice
Blocurile logice
Proiect de diplomă
6
2. Interconectări bazate pe mutiplexoare programabile.
Acestea au o eficienŃă sporită atunci când blocurile logice au un număr mic de intrări.
Practic, matricea de interconectare este conectată cu blocurile logice printr-un număr de
multplexoare finit. Prezintă avantajul că poate ruta orice semnal de intrare către un bloc logic.
Figura 2.1.1.3. Modul de interconectare bazat pe multiplexoare finite.
FPGA-urile sunt un şir de celule conŃinând elemente logice şi de memorie, configurabile.
Celulele pot fi interconectate folosind un număr mare de switch-uri (întrerupătoare)
programabile, într-o varietate de moduri de construcŃie virtuală a oricărui sistem digital.
Matricile de elemente logice şi switch-uri pot fi configurate extern prin intermediul unui "bit
stream" reprezentând respectiva funcŃie sau sistem digital. Sistemele apărute oferite de
producatorii de FPGA-uri generează "bit stream"-ul folosind o descriere sistematică sau de
nivel înalt a sistemului digital, descriere realizată în Veriolg sau în limbajul VHDL. Design-ul
poate fi simulat înainte de configurarea FPGA-ului. Cele mai multe FPGA-uri sunt re-
programabile şi astfel pot fi modificate foarte uşor. Acest lucru oferă flexibilitate şi reduce
riscurile în comparatie cu ASIC-urile care nu pot fi reprogramate. Din ce în ce mai multe
aplicaŃii folosesc tot mai des FPGA-urile din diverse motive. Înalta performanŃâ, schimbările
de situaŃie tot mai rapide şi costurile scăzute sunt sunt doar câteva din aceste motive. Acum
FPGA-urile sunt foarte complexe şi implică multe scheme pentru îmbunătăŃirea
performanŃelor, reducerea numărului de componente şi a costurilor. De exemplu, majoritatea
FPGA-urilor oferă în prezent mai multe standarde diferite de I/O, dar la fel de bine şi elimină
rezistorii terminali de pe placă. Există mult mai multe avantaje pe care le au FPGA-urile, iar
producatorii sunt într-o continuă muncă de îmbunătăŃire a lor.
���������
���������
…
…
…
…
…
…
Capitolul 2 - Fundamente teoretice. Studiu bibliografic
7
2.1.2. Placa de dezvoltare Digilent Nexys2[4]
Placa de dezvoltare aleasă pentru implementarea proiectului a fost Digilent Nexys2. Placa
deŃine o serie de avantaje în comparaŃie cu alte plăci similare. A fost construită în jurul unui
FPGA Xilinx Spartan 3E-500 FG320 care are aproximativ 500000 de porŃi şi poate lucra
sincron cu un ceas de 50MHz. Programarea se realizează foarte uşor prin intermediul unei
interfeŃe JTAG implementate pe un port USB 2.0.
Figura 2.1.2.1. Placa de dezvoltare Digilent Nexys 2
După cum se poate observa în figura 2.1.2.1, placa Nexys2 este deja echipată cu toate
interfeŃele necesare pentru dezvoltarea proiectului şi alte interfeŃe adiŃionale:
- 1 port serial RS-232.
- 1 port serial PS/2.
- 4 porturi Pmod – echivalentul porturilor paralele pe 8 biŃi.
- 1 port VGA limitat 256 de culori (RGB 8 biŃi, format 3:3:2).
- 1 port USB – folosit atât pentru programare cât şi pentru transferul de date.
- 1 port FX2 de viteză mare – magistrală paralelă.
- 8 comutatoare şi 4 butoane cu revenire.
- 1 afişor pe patru digiŃi.
Totodată această placă este compatibilă cu mediile de dezvoltare oferite de Xilinx, printre
care şi WebPack 9.2i, mediul în care am dezvoltat sistemul. Placa include şi două module de
memorie externă, una de tip RAM, iar alta de tip FLASH, fiecare având o dimensiune de 16
MB.
Proiect de diplomă
8
Pe de altă parte, FPGA-ul Spartan 3E-500 are implementate în interiorul cipului un
număr de 20 de module de memorii Block RAM dual-port (biport) de care pot fi configurate
în funcŃie de necesităŃile proiectului având în total o dimensiune de 360 KbiŃi şi încă 20 de
multiplicatori cu operanzi (intrări) pe 18 biŃi.
2.2. Limbajul de descriere hardware VHDL[5][12]
VHDL este unul dintre limbajele standard folosite în industrie la ora actuală, pentru a
descrie sistemele numerice. VHDL înseamnă VHSIC (Very High Speed Integrated Circuits)
Hardware Description Language adică un limbaj pentru descriere hardware a circuitelor
integrate de foarte mare viteză. IniŃial, acest limbaj foarte asemănător cu limbajul ADA, a fost
destinat doar modelării şi simulării unor circuite ASIC complexe şi numai ulterior a fost
utilizat pentru sinteza şi implementarea logicii corespunzătoare.
Un sistem numeric poate fi reprezentat la diferite nivele de abstractizare. Acest lucru
facilitează mai ales descrierea şi proiectarea sistemelor complexe. Cel mai înalt nivel de
abstractizare este nivelul de descriere al comportării (funcŃionării) numit în engleză
behavioral. La acest nivel de abstractizare un sistem este descris prin ceea ce face, adică
modul cum se comportă şi nu prin componentele sale şi conexiunile dintre acestea. O
descriere de acest tip specifică relaŃiile dintre semnalele de intrare şi ieşire. Descrierea poate fi
o expresie booleană sau o descriere mai abstractă, la nivelul transferului între registre sau la
nivelul algoritmilor. Ca un exemplu tipic să considerăm un circuit simplu care avertizează
pasagerul atunci când uşa automobilului este deschisă sau centura nu este folosită, de fiecare
dată când se introduce cheia în contact. Descrierea la nivel funcŃional s-ar putea face în modul
următor : „Avertizare utilizator = Contact AND (Usa_deschisa OR Nu_Centura)”
Nivelul structural, spre deosebire de nivelul 'behavioral', descrie un sistem ca o colecŃie
de porŃi şi componente care sunt conectate între ele pentru a realiza funcŃia dorită. O
reprezentare structurală poate fi comparată cu o schemă de porŃi logice conectate între ele.
Aceasta este o reprezentare care se apropie mai mult de realizarea fizică a sistemului.
Limbajul VHDL permite reprezentarea sistemelor la nivel funcŃional (behavioral) sau
structural. Nivelul behavioral poate fi împărŃit în două stiluri de reprezentare: al fluxului de
date (Data Flow) şi algoritmic. Reprezentarea de tip Data Flow descrie modul cum circulă
datele prin sistem, aceasta realizându-se în termenii transferului de date între registre (RTL).
Această descriere foloseşte instrucŃiuni concurente, care se execută în paralel în momentul în
care datele sunt prezente la intrare. Pe de altă parte în reprezentarea de tip algoritmic
Capitolul 2 - Fundamente teoretice. Studiu bibliografic
9
instrucŃiunile sunt secvenŃiale şi se execută în ordinea specificată. VHDL permite atribuirea
semnalelor în ambele moduri (secvenŃial şi concurent).
2.2.1. Structura unui fişier sursă VHDL
Un sistem numeric este descris ca o entitate (entity) principală care, la rândul ei, poate
conŃine alte entităŃi, acestea fiind considerate componente ale entităŃii principale. Fiecare
entitate este modelată de o declaraŃie a entităŃii şi de corpul arhitectural. DeclaraŃia entităŃii se
poate considera o interfaŃă cu mediul extern care defineşte semnalele de intrare şi de ieşire, pe
când corpul arhitectural conŃine descrierea entităŃii şi este compus din alte entităŃi, procese şi
componente interconectate, toate funcŃionând în acelaşi timp.
La fel ca orice alt limbaj VHDL, foloseşte cuvinte cheie, iar acestea nu pot fi folosite ca
nume de semnale sau identificatori (simboluri definite de utilizator).
O linie de comentariu, care va fi ignorată de sintetizator, începe cu “--„.
Declararea entităŃii defineşte numele entităŃii şi specifică porturile de intrare şi de ieşire.
Forma generală este următoarea :
entity NUME_ENTITATE is [ generic declaratii_generice);]
port ( nume_semnale : mode tip ;
nume_semnale : mode tip ;
:
nume_semnale : mode tip;
end [NUME_ENTITATE] ;
O entitate începe întotdeauna cu cuvântul cheie entity (entitate) urmat de numele entităŃii
şi de cuvântul cheie is (este). În continuare sunt declaraŃiile porturilor cu cuvântul cheie port.
DeclaraŃia entităŃii se termină întotdeauna cu cuvântul cheie end.
- NUME_ENTITATE este un identificator (simbol) ales de utilizator;
- nume_semnale constă într-o listă de identificatori separaŃi prin virgulă care specifică
semnaleleinterfeŃei externe;
- mode este un cuvânt rezervat care indică sensul semnalelor;
- in - semnal de intrare;
- out - semnal de ieşire, valoarea poate fi citită decât de alte entităŃi;
- buffer - semnal este ieşire, dar valoarea poate fi citită în arhitectura entităŃii
- inout - semnal ce poate fi ieşire sau intrare (bi-direcŃional);
Proiect de diplomă
10
- tip este tipul de semnal; exemple de tipuri sunt: bit, bit_vector, boolean, character,
std_logic, std_ulogic
Corpul arhitectural specifică modul în care funcŃionează şi în care este implementată o
entitate. După cum am spus mai devreme, o entitate sau circuit poate fi specificat în modul
funcŃional sau cel structural dar şi de o combinaŃie dintre cele două. Generalizând, corpul
arhitectural arată în felul următor:
architecture nume_arhitectura of NAME_ENTITATE is
-- declaratii ale componentelor
-- declaratii de semnale, constante, functii, proceduri, tipuri
begin
-- Instructiuni
end nume_arhitectura;
Descrierea funcŃională (behavioral) a arhitecturii pentru exemplul amintit mai sus, în care
avertizarea s-ar realiza prin intermediul semnalului BUZZER este:
architecture behavioral of BUZZER is
begin
Avertizare <= (not Usa AND Contact) OR (not Centura AND Contact);
end behavioral;
Descrierea structurală a aceluiaşi circuit, bazată pe utilizarea unor porŃi AND, OR cu
două intrări şi a inversorului NOT va fi următoarea:
architecture structural of BUZZER is
component AND2
port (in1, in2: in std_logic; out1: out std_logic);
end component;
component OR2
port (in1, in2: in std_logic; out1: out std_logic);
end component;
component NOT1
port (in1: in std_logic; out1: out std_logic);
end component;
signal USA_NOT, CENTURA_NOT, B1, B2: std_logic;
begin
U0: NOT1 port map (USA, USA_NOT);
U1: NOT1 port map (CENTURA, CENTURA_NOT);
U2: AND2 port map (CONTACT, USA_NOT, B1);
U3: AND2 port map (CONTACT, CENTURA_NOT, B2);
U4: OR2 port map (B1, B2, AVERTIZARE);
end structural;
Capitolul 2 - Fundamente teoretice. Studiu bibliografic
11
În partea de declaraŃii se precizează componentele ce urmează a fi folosite în descrierea
circuitelor. În exemplul nostru folosim o poartă ŞI cu două intrări, două porŃi SAU cu două
intrări şi un inversor. Aceste porŃi trebuie definite în prealabil, adică vor avea nevoie de
declararea entităŃii şi de un corp arhitectural aşa cum s-a arătat mai sus. Acestea pot fi păstrate
într-unul din package-uri după cum se va arăta în continuare.
InstrucŃiunile de după cuvântul cheie begin creează instanŃieri ale componentelor şi
descriu modul cum acestea sunt conectate între ele. Definirea unei instanŃe creează un nou
nivel ierarhic. Fiecare linie începe cu numele (de exemplu U0) urmat de două puncte, numele
componentei şi cuvântul cheie port map. Acest cuvânt cheie defineşte modul în care sunt
conectate componentele. În exemplul de mai sus, aceasta se face prin asocierea poziŃiei:
semnalul USA corespunde intrării in1 a porŃii NOT1, iar USA_NOT corespunde ieşirii. La fel
este şi pentru poarta AND2 unde primele două semnale, CONTACT şi USA_NOT, corespund
intrărilor in1 şi in2, iar semnalul B1 corespunde ieşirii out1.
Se poate folosi şi un mod alternativ de asociere a porturilor, astfel eticheta:
numele componentului port map (port1 => semnal1, port2 => semnal2,…
portn => semnaln);
Modelarea structurală impune o proiectare ierarhizată în care se pot defini componente
care sunt folosite de mai multe ori. Odată ce au fost definite, aceste componente pot fi folosite
ca blocuri, celule sau macro-uri într-o entitate la un nivel mai înalt. Aceasta poate reduce în
mod semnificativ complexitatea proiectelor mari. La fel ca la orice aplicaŃie software
proiectele ierarhizate sunt preferate întotdeauna în locul celor pe un singur nivel.
Biblioteci (library) şi package-uri; cuvintele cheie library şi use. O bibliotecă poate fi
considerată ca un loc unde sintetizatorul păstrează informaŃii despre un proiect.
Un package VHDL este un fişier sau un modul care conŃine: declaraŃiile obiectelor
folosite în mod curent, tipuri de date, declaraŃii de componente, semnale, proceduri şi funcŃii
care pot fi folosite de diferite modele VHDL. Spre exemplu std_logic este definit în package-
ul ieee.std_logic_1164 din biblioteca ieee. Pentru a folosi std_logic trebuie specificată
biblioteca şi package-ul. Aceasta se face la începutul fişierului VHDL folosind cuvintele cheie
library şi use după cum urmează :
library ieee;
use ieee.std_logic_1164.all;
Extensia .all indică faptul că se foloseşte tot package-ul ieee.std_logic_1164.
Luând ca exemplu mediul Xilinx ISE biblioteca ieee conŃine următoarele package-uri:
- std_logic_1164; defineşte tipurile de date standard
Proiect de diplomă
12
- std_logic_arith; pune la dispoziŃie funcŃii aritmetice, de conversie şi comparaŃie
pentru tipurile de date signed, unsigned, integer, std_ulogic, std_logic şi
std_logic_vector
- std_logic_unsigned
- std_logic_misc; defineşte tipuri suplimentare, subtipuri, constante şi funcŃii pentru
package-ul std_logic_1164 .
2.3. Limbajul Visual C#
Limbajul C# este un limbaj simplu, modern, orientat pe obiecte conceput pentru a
dezvolta aplicaŃii care să ruleze pe platforma .Net Framework. Combină productivitatea
limbajelor de dezvoltare rapidă a aplicaŃiilor cu puterea brută a limbajului C++.
Codul C# este compilat ca şi cod de bază, ceea ce înseamnă că beneficiază de serviciile CLR.
Aceste servicii includ interoperabilitea limbajelor, garbage collection, securitate ridicată şi
suportul versiunilor imbunătăŃite.
În .NET (şi, implicit, în C#), tipurile de date se împart în două categorii principale: tipuri
valoare şi tipuri referinŃă. DiferenŃa dintre ele este că variabilele de tip referinŃă conŃin
referinŃe (pointeri) spre datele propriu-zise, care se află în heap, pe când variabilele de tip
valoare conŃin valorile efective. Această deosebire se observă, de exemplu, la atribuiri sau la
apeluri de funcŃii. La o atribuire care implică tipuri referinŃă, referinŃa spre un obiect din
memorie este duplicată, dar obiectul în sine este unul singur (are loc fenomenul de aliasing –
mai multe nume pentru acelaşi obiect). La o atribuire care implică tipuri valoare, conŃinutul
variabilei este duplicat în variabila destinaŃie. Tipurile valoare sunt structurile (struct) şi
enumerările (enum). Tipuri referinŃă sunt clasele (class), interfeŃele (interface), tablourile şi
delegările (delegate). Poate părea surprinzător, dar unele din tipurile \"primitive\" cu care
suntem obişnuiŃi din C (int, de exemplu), sunt tot structuri. Altele, cum ar fi string, sunt clase.
Singurul lucru care le face mai speciale în C# este faptul că, la compilare, textul din codul
sursă este identificat şi convertit automat în instanŃe ale acestor tipuri. În plus, pentru aceste
tipuri, există cuvinte cheie C# prin care sunt descrise, dar şi clase .NET care reprezintă
implementarea propriu-zisa.
O clasă este o structură de date care poate conŃine date (variabile şi constante) şi cod
(metode, proprietăŃi, evenimente, operatori, constructori şi destructori). Clasele pot fi derivate
din alte clase, prin acest mecanism clasele derivate putând extinde, specializa sau modifica
comportamentul clasei de bază. Clasele reprezintă piatra de temelie a programării pe obiecte.
Capitolul 2 - Fundamente teoretice. Studiu bibliografic
13
Acest concept porneşte de la aserŃiunea că datele sunt strâns legate de codul care le
prelucrează şi că gruparea lor într-o structură comună (spre deosebire de limbajele
procedurale, în care datele sunt separate de cod) duce la o proiectare, implementare, testare şi
întreŃinere mai simplă. Membrii unei clase pot fi statici; în acest caz, există o singură instanŃă
a lor care este accesibilă din toate instanŃele clasei respective; în situaŃia în care membri statici
sunt şi publici, ei vor fi accesibili din alte clase fără a avea nevoie de o instanŃă a clasei
respective. Mai mult, ei nu pot fi accesaŃi prin intermediul unor instanŃe, ci numai folosind
numele clasei. De asemenea, pot fi definite metode statice. Acestea aparŃin clasei şi nu
instanŃelor acesteia şi pot fi apelate folosind numele clasei.
Încapsularea reprezintă un aspect esenŃial al programării pe obiecte şi înseamnă, pe scurt,
posibilitatea de a separa implementarea unui obiect de funcŃionalitatea pe care acesta o pune
la dispoziŃie utilizatorilor săi. Prin implementarea unui obiect ne referim, în general, la
variabilele membru ale obiectului respectiv şi la metodele interne, care contribuie la realizarea
funcŃionalităŃii obiectului, dar care nu sunt necesare utilizatorilor obiectului respectiv.
Drepturile de acces reprezintă modalitatea prin care putem ascunde de utilizatorii clasei
detaliile de implementare ale acesteia. Cei cinci specificatori de acces în C# şi semnificaŃia lor
sunt:
- private – membrii privaŃi sunt accesibili numai din clasa în care sunt declaraŃi.
- internal – membrii interni sunt accesibili numai din clase care fac parte din acelaşi
assembly cu clasa în care sunt declaraŃi.
- protected – membrii protejaŃi sunt accesibili din clasa în care sunt declaraŃi şi din
clasele derivate din aceasta.
- protected internal – membrii interni şi protejaŃi sunt accesibili din clasa în care sunt
declaraŃi, din clasele care fac parte din acelaşi assembly şi din clasele derivate,
indiferent în ce assembly sunt acestea.
- public – membrii publici sunt accesibili din orice clasă.
Dacă specificatorul de acces lipseşte, membrii unei clase sunt implicit privaŃi.
O clasă este alcătuită din membrii moşteniŃi din clasa de bază şi din membrii declaraŃi în
corpul clasei. Datele pot fi variabile, constante, sau variabile read-only. Diferenta dintre
constante si variabile read-only este ca valoarea constantelor poate fi calculata la compilare si
plasată în fişierul executabil ca atare, pe când valoarea variabilelor read-only este calculată la
rulare. Implicit, pot fi declarate doar constante apartinând tipurilor recunoscute de compilator
Proiect de diplomă
14
ca „primitive”. Variabilele read-only pot fi de orice tip si pot avea valori care nu sunt
cunoscute la compilare.
Constructorul este o metodă care implementează acŃiunile care au loc la crearea şi
iniŃializarea unei instanŃe a clasei. Are acelaşi nume ca şi clasa din care face parte şi nu
returnează nici o valoare, nici măcar void. Poate apela un alt constructor al aceleiaşi clase sau
un constructor al clasei de bază. Poate avea orice nivel de acces. Moştenirea se referă la
crearea unei clase derivate care conŃine implicit toŃi membrii (mai puŃin constructorii,
constructorul static şi destructorul) unei alte clase, numite de bază. Moştenirea se mai
numeşte şi derivare sau, mai rar, specializare. În C#, moştenirea se realizează punând „:” după
numele clasei, urmat de numele clasei de bază. O clasă poate avea o singură clasă de bază.
Dacă o clasă nu este derivată explicit din nici o clasă, compilatorul o face implicit să fie
derivată din object. Object este rădăcina ierarhiei de clase din .NET. Moştenirea este
tranzitivă, în sensul că dacă A este derivată din B şi B este derivată din C, implicit A va
conŃine şi membrii lui C (şi, evident, pe cei ai lui B). Prin moştenire, o clasă derivată extinde
clasa de bază. Clasa derivată poate adăuga noi membri, dar nu îi poate elimina pe cei
existenŃi. Deşi clasa derivată conŃine implicit toŃi membrii clasei de bază, acest fapt nu
înseamnă ca îi şi poate accesa. Membrii privaŃi ai clasei de baza există şi în clasa derivată, dar
nu pot fi accesaŃi. În acest fel, clasa de bază îşi poate schimba la nevoie implementarea internă
fără a distruge funcŃionalitatea claselor derivate existente.
Polimorfismul este a treia piatră de temelie a programării pe obiecte. Dacă încapsularea
afectează în mod direct uşurinŃa de implementare şi utilizare a claselor prin separarea
implementării de funcŃionalitate, iar moştenirea reprezintă o modalitate simplă de reutilizare a
codului, polimorfismul reprezintă componenta esenŃială când vine vorba despre
extensibilitate. O metodă virtuală este o metodă care poate fi suprascrisă într-o clasă derivată.
În .NET, memoria ocupată de obiecte este automat recuperata de un garbage collector în
momentul când nu mai este folosită. Uneori, însă, un obiect este asociat cu resurse care nu
depind de .NET şi care trebuie dealocate explicit, într-un fel sau altul. Un exemplu de astfel
de resurse îl reprezintă conexiunile TCP/IP, care nu pot fi lăsate la voia întâmplarii.
De obicei, este bine să se elibereze astfel de resurse în momentul când nu mai sunt necesare şi
vom vedea puŃin mai încolo cum se face acest lucru. Există însă şi o plasă de siguranŃă oferită
de compilator, reprezentată de destructori. Destructorii sunt metode care au acelaşi nume cu
clasă din care fac parte, precedat de semnul ~. Nu au drepturi de acces, nu au argumente şi nu
permit nici un fel de specificatori. Nu pot fi invocaŃi explicit, ci numai de librariile .NET
Capitolul 2 - Fundamente teoretice. Studiu bibliografic
15
specializate pe recuperarea memoriei. În C#, este posibil, ca şi în C++ sau Java să avem mai
multe metode cu acelaşi nume în cadrul aceleiaşi clase. În C#, la supraîncarcare se Ńine cont
de numele metodei, de tipul argumentelor, de categoria lor (de intrare, intrare-iesire, iesire),
de numărul şi de ordinea lor. Semnătura unei metode nu include tipul returnat, numele
argumentelor sau argumentele variabile de la sfârşitul listei de argumente. Supraîncărcarea
metodelor şi operatorilor se mai numeşte şi polimorfism static, deoarece putem obŃine
comportamente diferite prin acelaşi apel de funcŃie, dar comportamentul este totuşi bine
determinat la compilare.
ProprietăŃile sunt membri care oferă acces la atributele unui obiect. Exemple de
proprietăŃi includ lungimea unui şir de caractere, lungimea unui tablou, mărimea unui font,
titlul unei ferestre etc. ProprietăŃile diferă de variabilele membru prin faptul că nu reprezintă
spaŃii de memorie, ci funcŃii de acces. Aceste funcŃii de acces sunt executate când utilizatorii
clasei încearcă să obŃină sau să modifice aceste atribute. Ele sunt similare cu modelul get/set
din alte limbaje de programare (aşa şi sunt implementate intern), dar oferă o modalitate mai
coerenta de lucru împreună cu aceleaşi.
2.4. Algoritmi de gesenare a primitivelor grafice
2.4.1. Linia[7][8]
Se cunosc o multitudine de algoritmi de desenare a segmentelor de dreaptă pe un afişor
unde suprafaŃa pe care se desenează este formată dintr-un număr discret de puncte sau pixeli.
Când se lucrează cu astfel de dispozitive de afişare este util să se evite folosirea calculelor cu
numere reale. Una dintre primele publicaŃii care aborda un astfel de algortim de desenare a
segmentelor de dreaptă a fost scrisă de Josh Bresenham în 1965. Ideea principală în algoritm e
să se analizeze şi manipuleze ecuaŃiile liniare astfel încât numai numere întregi sunt utilizate
în toate calculele. Aritmetica numerelor întregi deŃine avantajul vitezei şi preciziei; lucrul cu
numere reale necesită mai mult timp şi memorie şi asemenea valori ar avea nevoie să fie
oricum rotunjite la numere întregi în momentul afişării pixelilor.
Se va porni de la � � � �, ecuaŃia cu variabile reale a unei drepte care este trasată
folosind o matrice de pixeli unde cele două puncte �� ��� şi �� ��� au coordonate întregi şi
reprezintă două punte cunoscute pe dreaptă care vor fi conectate printr-un segment de dreaptă
simulat în desen. În figura 2.2.1.1 de mai jos cele două puncte sunt reprezentate spre
exemplificare în colŃurile jos-stânga, respectiv sus-dreapta ale matricii de pixeli.
Proiect de diplomă
16
Figura 2.4.1.1. O linie reală dispusă pe o matrice de pixeli
Algoritmul ales pentru implementarea desenării dreptei din pixeli este algoritmul lui Josh
Bresenham. Presupunem că pe orizontală coodonatele cresc deplasându-ne către dreapta, iar
pe verticală coordonatele � cresc deplasându-ne înspre partea superioară. Aşadar pentru acest
exemplu, presupunem că � � � şi �� � ��. Aceste restricŃii sunt necesare pentru a descrie
organizarea exemplului necesar explicării algoritmului, dar în nici un caz nu impun limitări
implementării efective a algoritmului.
O altă presupunere este că panta este definită în intervalul �����. Această presupunere ne
asigură faptul că pe parcursul deplasării punct cu punct din stânga către dreapta de-a lungul
graficului, coordonata � nu va creşte niciodată cu mai mult de un pixel şi că � creşte
concomitent cu . De asemenea această presupunere este necesară doar pentru explicarea ideii
care stă la baza algoritmului. Practic se limitează pentru exemplificare la prezentarea
algoritmului într-un singur octant al cercului trigonometric şi anume în cel în care se află
dreapta din figură.
După cum se ştie panta unei drepte determinată de două puncte în plan este determinată
de ecuaŃia:
� ���
În continuare ne vom referi la pantă prin această fracŃie. Pentru a realiza o desenare
precisă, se va contoriza eroarea acumulată în variabila �. Dat fiind faptul că primul punct
desenat este chiar �� ���, variabila care păstrează valoare erorii pe � ar trebui iniŃializată cu
valoarea 0. Pe decursul deplasării de la stânga la dreapta, se va incrementa valoarea lui � cu 1
doar dacă valoarea erorii depăseste ��. În această manieră se vor desena doar puncte a căror
coordonate pe verticală diferă fată de coordonatele reale cu maxim 1 pixel. Eroarea acumulată
pe � este o valoare reală cu semn care contorizează eroarea reală dintre � desenat şi � real
pentru un curent.
Capitolul 2 - Fundamente teoretice. Studiu bibliografic
17
De menŃionat faptul că se presupune că toate coordonatele pe orizontală sunt exacte.
Aşadar totdeauna în acest caz se incremenează valoarea lui cu 1 atunci când se încearcă să
se calculeze următorul punct pe dreaptă prin deplasarea de la stânga la dreapta. Astfel singura
eroare care va fi contorizată este asociată variabilei �. În fapt, eroarea acumulată pe � indică
cum să se corecteze valoarea curentă a variabilei � pentru a obŃine valoarea reală.
Având în vedere ecuaŃia generală a dreptei în plan, se poate observa că la fiecare
incrementare a lui cu 1, � ar trebui incrementat cu valoarea pantei, . Dacă � nu este
incrementat când este incrementat cu 1 atunci valaorea erorii acumulare pentru � ar trebui
incrementată cu . In momentul în care � este incrementat cu 1, dar rămâne staŃionar,
eroarea acumulată trebuie decrementată cu 1.
Transpunerea în pseudocod a celor spuse este următoarea:
eroare ← 0 x_curent ← x0 y_curent ← y0 x_final ← x1 repeta punct(x_curent, y_curent) x_curent ← x_curent + 1
eroare ← eroare + ����
daca eroare > �� atunci
y_curent ← y_curent + 1 eroare ← eroare – 1 sfarsit daca pana cand x_curent > x_final Este uşor de verificat că în această descriere a algorimului la începutul şi sfâşitul unei
bucle eroarea se încadrează în următorul interval:
��� � ��� �� � ��
fapt care este încă un indiciu că pe verticală coordonatele punctelor sunt totdeauna calculate
spre cel mai apropiat pixel.
2.4.2. Cercul[9]
Pornim de la � � �� � ��, ecuaŃia cu numere reale a cercului cu centrul în origine care
va fi desenat pe o matrice de puncte discrete unde fiecare pixel are coordonate intregi. Nu
există nici o degradare a gereralităŃii problemei din moment ce punctele astfel determinate
pot fi translatate relativ la oricare alt centru diferit de origine după cum se poate observa în
figura 2.4.2.1.
Proiect de diplomă
18
Figura 2.4.2.1. Translatarea cercului cu centrul în origine
Se vor compara erorile asociate coordonatelor şi � ale punctelor care vor fi desenate.
Deşi se vor desena puncte de forma ! " � �"� , aceste puncte de obiecei nu satisfac cu
exactitate ecuaŃia cercului. Presupunând că " este exact, coordonata � reală a punctului !
este #�� � "�.
Cantitatea $� � �� � %�� reprezintă abaterea punctului ! de la valoarea reală. Dacă
această cantitate este negativă înseamnă că punctul ! se află în interiorul cercului real, iar
dacă respectiva cantitate este pozitivă punctul ! este în exteriorul cercului real. BineînŃeles
dacă este 0 (ceea ce poate să apară foarte rar), punctul ! se află exact pe cerc.
Expresia &"� � �"� � ��& este mai degrabă o măsurătoare a erorii. Valoarea absolută va fi necesară când se ajunge la
compararea a două astfel de erori şi această nouă cantitate ajută la evitarea calculului
rădăcinilor pătrate care necesită mult timp de calcul. Aşadar se va defini variabila ��'� ( în
care va fi memorată valoarea erorii a fiecărui punct desenat. ��'� ( � &"� � �"� � ��& Strategia de desenare presupune începerea cu urmatoarele valori: � � � şi �� � �. În
acest caz: ��'� ( � &"� � �"� � ��& � )�� � � � ��) � �
Aşadar primul punct este desenat exact pe cercul real.
�
* � �*�
+� �+�
�
�
Capitolul 2 - Fundamente teoretice. Studiu bibliografic
19
Cercul va fi desenat în aceeaşi ordine ca şi cea dată de ecuaŃile parametrice ale cercului � ,-.� /� şi � � .01� /� în care / începe la 0 şi creşte. Prin urmare cercul este desenat în
sens contrar acelor de ceas începănd pe axa orizontală pozitivă. Pe zona de început a desenării
coordonatele � cresc sau îşi schimbă valoarea mult mai repede decât coordonatele . Prin
urmare la fiecare iteraŃie se va decide să se incrementeze �, dar va fi nevoie să se testeze când
trebuie decrementat . �"2� � �" � �� 3��/�4�5 � ����6�7
FuncŃie de rezultatul testului dacă trebuie sau nu decrementată valoarea lui , se va
obŃine:
"2� � 8 " � ��(49/ /���: /5;" � �� ��(49/ /�3�(5/5;< Decizia de a decrementa sau nu valoarea lui este luată pe baza a două valori ale erorii:
pentru ! " � �� �" � ��, respectiv pentru ! " � �" � ��. Apoi se va alege dacă " � � sau " va fi noua valoare pentru coordonata funcŃie de
care dintre cele două valori ale erorii este mai mică.
La orice moment trebuie să se cunoască cum se schimbă valoarea erorii pentru orice
schimbare a coordonatelor, de exemplu dacă " scade sau �" creşte. Altfel spus, valoarea
erorii nu trebuie calculată iar pentru fiecare nou punct dacă se monitorizează cum se schimbă
valoarea în momentul în care se schimbă coordonatele.
Dacă tocmai a fost desenat punctul ! "� �"� , în continuare va trebui să se ia în
considerare desenarea fie a punctului ! " � �� �" � �� , fie a punctului ! " � �" � �� şi
decizia să fie bazată pe compararea erorilor care ar aparea în fiecare dintre cazuri.
Pentru punctul ! " � �� �" � �� eroarea este: ��'� ( " � �� �" � �� � ) " � ��� � �" � ��� � ��) � � &"� � �" � � � �"� � ��" � � � ��& � � &"� � �"� � �� � � � �"� � ��" � ��& Iar pentru punctul ! "� �" � �� eroarea este: ��'� ( "� �" � �� � &"� � �" � ��� � ��& � � &"� � �"� � ��" � � � ��& � � &"� � �"� � �� � ��" � ��& În continuare trebuie simplificată inegalitatea: ��'� ( " � �� �" � �� � ��'� ( " � �" � �� =
Proiect de diplomă
20
&"� � �"� � �� � � � �"� � ��" � ��& � &"� � �"� � �� � ��" � ��& =
#>�"� � �"� � �� � ��" � ��� � � � �"�?� � #�"� � �"� � �� � ��" � ���� =
>�"� � �"� � �� � ��" � ��� � � � �"�?� � �"� � �"� � �� � ��" � ���� =
�"� � �"� � �� � ��" � ���� � ��"� � �"� � �� � ��" � ��� � � �"� � � � �"��� �"� � �"� � �� � ��" � ���� =
��"� � �"� � �� � ��" � ��� � � �"� � � � �"�� � � =
��"� � �"� � �� � ��" � ��� � � � �"� @ �
Ultima echivalenŃă este datoră presupunerii că valoarea � � �" este negativă, adică " este cel puŃin 1.
Aşadar, dacă ��"� � �"� � �� � ��" � ��� � � � �"� @ � atunci valoarea lui trebuie
decrementată pentru desenarea următorului punct ! "2�� �"2��. Realizând această analiză se poate observa utilitatea definirii a încă două noi cantităŃi şi
anume: A5B � � � �" �A5B � ��" � �
Având în vedere faptul că în momentul în care " şi �" îşi schimbă valoarea, diferenŃa
dintre valoarea îniŃială şi cea curentă este de C�, valorile variabilelor A5B şi �A5B se vor
modifica exact cu C�. Aşadar aceste valori sunt totdeauna impare. DA5B începe cu o valoare
negativă � � �� şi creşte către 0. EA5B reŃine valori impare începând cu 1 şi de asemenea
creşte. În timpul procesului de desenare, valoarea eroarii ��'� ( poate fi fie pozitivă, fie
negativă. Aşadar nu este nevoie şi nici nu este folosită valoarea absolută menŃionată anterior.
Conform explicaŃiilor oferite, în cele ce urmează este evidenŃiat în pseudocod algoritmul
de desenare a cercului cu centrul în origine:
x ← r y ← 0 xdif ← 1-2r ydif ← 1 er_raza ← 0 cât timp x≥y repetă
Capitolul 2 - Fundamente teoretice. Studiu bibliografic
21
deseneazăpuncte(x,y) y ← y + 1 er_raza ← er_raza + xdif ydif ← ydif + 2 dacă (2*er_raza+xdif>0) atunci x ← x – 1 er_raza ← er_raza + xdif xdif ← xdif + 2 sfârşit dacă sfârşit repetă
Datorită simetriei cercului este necesar calculul coordonatelor punctelor doar pentru
primele FGH ale cercului. De aici rezultă condiŃia de stop a buclei şi anume � � . Prin
subrutina deseneazăpuncte se profită de avantajele simetriei. La fiecare iteraŃie sunt calculate
coordonatele unui punct, dar afişate prin simtrie 8 puncte conform celor patru axe de simetrie
ale cercului evidenŃiate în figura 2.4.2.2.
Figura 2.4.2.2. Axele de simetrie ale cercului şi cele 8 puncte desenate la o iteraŃie
După cum rezultă din figura 2.4.2.2 subrutina deseneazăpuncte v desena 8 puncte astfel:
deseneazăpuncte(x,y) punct(x,y); punct(-x,y);
punct(x,-y); punct(-x,-y); punct(y,x); punct(-y,x); punct(y,-x); punct(-y,-x);
sfârşit deseneazăpuncte
Proiect de diplomă
22
2.4.3. Elipsa[10]
Similar algoritmului de desenare a cercului se va pornii de la ecuaŃia cu variabile reale a
elipsei cu centrul în origine şi anume: � � � ���� � � = ��� � ��� � �� �
De asemenea trebuie menŃionat că nu există nici o degradare a gereralităŃii problemei din
moment ce punctele astfel determinate pot fi translatate relativ la oricare alt centru diferit de
origine după cum se poate observa în figura 2.4.3.1.
Figura 2.4.3.1. Translatarea elipsei cu centrul în origine
Se va compara eroarea asociată coordonatelor şi � ale punctelor desenate. Deşi sunt
desenate puncte de forma ! "� �"�, aceste puncte nu satisfac cu exactitate ecuaŃia elipsei.
Pentru a evita folosirea operaŃiei de împărŃire se va folosi cea de-a doua formă a ecuaŃiei
elipsei. ��� � ��� � �� �
Pentru un punct ! "� �"� dat, cantitatea ��"� � ��"� � �� �
reprezintă abaterea punctului ! de la valoarea reală. Dacă această cantitate este negativă,
punctul este în interiorul elipsei reale, iar dacă este pozitivă respectivul punct este în
exteriorul elipsei reale. Când se obŃine o cantitate nulă (ceea ce, ca şi la cerc, se întâmplă
foarte rar) punctul ! este exact pe elipsa reală. Expresia: &��"� � ��"� � �� �&
* � �*�
+� �+�
�
Capitolul 2 - Fundamente teoretice. Studiu bibliografic
23
este o măsură mult mai practică a erorii. Valoarea absolută este necesară când sunt comparate
două astfel de erori. Această valoare va fi reŃinută în variabila ��'�953. ��'�953 "� �"� � &��"� � ��"� � �� �& Algoritmul de desenare a elipsei diferă de cel al cercului prin faptul că elipsa are două
axe de simetrice. Prin urmare la fiecare iteraŃie vor fi desenate 4 puncte. Este necesară
calcularea coordonatelor punctelor doar din primul cadran (aşadar calculul trebuie să acopere
un unghi de 90º - figura 2.4.3.2). În fapt, momentul modificării coordonatelor este determinat
de panta dreptei tangente la elipsă.
Figura 2.4.3.2. Axele de simetrie ale cercului şi cele 4 puncte desenate la o iteraŃie
În primul cadran panta dreptei tangente este totdeauna negativă. Începând pe axa şi
continuând în sens contrar acelor de ceas panta este mare şi negativă ceea ce subliniază
creşterea mult mai rapidă a valorilor coordonatelor verticale decât a celor orizontale. Dar
odată ce tangenta trece prin valoare �� valorile coordonatelor orizontale sevor modifica mult
mai repid decat cele verticale.
Aşadar se vor calcula două seturi de puncte în primul cadran. Primul set începe pe axa
orizontală pozitivă avansând în sens contrar acelor de ceas până când panta tangentei devine ��. Al doilea set de puncte va porni pe axa verticală pozitivă în sensul acelor de ceas şi se va
opri când panta tangentei devine din nou �� (figura 2.4.3.2).
Proiect de diplomă
24
Pentru primul set de puncte � este totdeauna incrementat şi se testează cînd să fie
decrementat . Acest proces este similar cu cel de la desenarea cercului. Pentru al doilea set
de puncte se va incrementa totdeauna şi se va decide când să fie decrementat �.
Decizia de decrementare a lui pentru primul set de puncte se bazează pe compararea
erorii apărute pentru punctele ! " � �� �"� şi ! "� �" � ��. Se va alege fie " � �, fie " ca
noua coordonată pe orizontală având în vedere care dintre cele două erori este mai mică.
Oricare ar fi decizia, trebuie cunoscută fluctuaŃia valorii variabilei ��'�953 la orice
fluctuaŃie a coordonatelor. Valoarea nu trebuie să fie calculată din nou dacă se urmăreşte
modul în care aceasta se schimbă funcŃie de coordonate.
Pentru primul set de puncte, ��'�953 " � �� �" � �� � )�� " � ��� � � �" � ��� � �� �) � &��"� � ���" � �� � ��"� � � ��" � � � �� �& � &��"� � ��"� � �� � � �� � � �"� � � ��" � ��& în timp ce ��'�953 "� �" � �� � )��"� � � �" � ��� � �� �) � &��"� � ��"� � � ��" � � � �� �& � &��"� � ��"� � �� � � � ��" � ��&
Analiza următoarei inegalităŃi este aproximativ identică cu cea apărută în fundamentarea
algoritmului pentru desenarea cercului cu excepŃia faptului că factorul de fluctuaŃie este
multiplicat fie cu �, fie cu ��. Rezultatul este: ��'�953 " � �� �" � �� � ��'�953 " � �" � �� = ����"� � ��"� � �� � � � ��" � ��� � �� � � �"� @ �
Când această ultimă inegalitate este îndeplinită coordonata va trebui decrementată
pentru afişarea punctului ! "2� � �"2��. Finalizând această analiză se poate observa utilitatea definirii a două noi variabile: A5B � �� � � �"� �A5B � � ��" � �� Având în vedere că şi � se modifică de la iteratie la iteratie cu C� se poate observa că A5B, respectiv �A5B totdeauna se modifică cu C��� , respectiv C� � . Valoarea iniŃială a
variabilei A5B este � � � � �, iar a variabilei �A5B este � . Similar algoritmului pentru
desenarea cercului, în realitate nu este folosită valoarea absolută pentru calculul erorii.
Poate fi analizată panta dreptei tangente la elipsă prin derivarea implicită a ecuaŃei:
Capitolul 2 - Fundamente teoretice. Studiu bibliografic
25
��� � ��� � �� � ��� � � ���I � �
Rezolvând după �J se obŃine
�I � ����� ��� Deşi ar fi de aşteptat ca în mod normal să se reducă fracŃia de mai sus prin împarŃirea atât
a numitorului, cât şi a numărătorului la 2, reiese totuşi că este mai eficient să nu se facă
această reducere.
Acum se poate determina unde să se separe cele două seturi de puncte calculate în primul
cadran. Primul set corespunde porŃiunii în care �I @ ��. Aşa că se va lua în considerare
inegalitatea
����� �� @ ��
şi se vor afişa puncte din primul set până când ��� @ � ��
Pentru a evita realizarea de înmultiri în această inegalitare la fiecare iteraŃie, se profită din
nou de avantajul faptului că la fiecare reactualizare, şi � se modifică cu o unitate. Astfel se
vor defini încă două noi variabile, K/�3 şi �K/�3: K/�3 � ��� �K/�3 � � �
Când se desenează primul set de puncte, valorile iniŃiale ale variabilelor vor fi: K/�3 ���� şi �K/�3 � �. Pentru primul set de puncte descreşte cu 1 la fiecare iteraŃie, astfel că K/�3 are o descreştere corespunzătoare de ���, în timp ce �K/�3 creşte cu � �.
La desenarea celui de-al doilea set de puncte valorile iniŃiale ale variabilelor vor fi: K/�3 � � şi �K/�3 � � ��. Pentru acest set de puncte creşte cu 1 la fiecare iteraŃie, astfel
încât K/�3 are o creştere corespunzătoare de ��� , în timp ce �K/�3 descreşte cu � � de
fiecare dată când � descreşte cu 1.
2.5. Sisteme de reprezentare a culorilor în echipamente video
2.5.1. Sistemul RGB – Red, Green, Blue (roşu, verde, albastru)[17]
Modelul de culoare RGB este un model aditiv de culoare în care cele trei componente
(roşie, verde şi respectiv albastră) sunt suprapuse în diferite moduri pentru a reproduce o
Proiect de diplomă
26
paletă variată de culori. Numele modelului provine de la iniŃialele celor trei componente
aditive primare (figura 2.5.1.1).
Figura 2.5.1.1. Modelul aditiv RGB
Principalele scopuri ale modelului RGB este detectarea, reprezentarea şi afişarea
imaginilor în sisteme electronice dintre care amintim: televizoare, calculatoare; totodată a fost
folosit şi în tehnica fotografică. Chiar dinaintea epocii electronice acest model avea o
fundamentare teoretică solidă bazată pe modul în care omul percepe culorile.
Acest model reprezintă un spaŃiu de culori dependent de echipament: diferite
echipamente detectează sau reproduc o anumită valoare RGB diferit, dat fiind faptul că
elementele culorii şi răspunsul lor la nivele individuale de R, G, B variază de la producător la
producător sau chiar în timp la acelaşi echipament. Aşadar o valoare RGB nu defineşte
aceeaşi culoare la echipamente diferite fără a avea o metodă de gestionare a culorii.
Pentru a forma o culoare cu RGB trei fascicule luminoase colorate (unul roşu, unul verde,
iar ultimul albastru) trebuie să fie suprapuse. Fiecare dintre cele trei fascicule este denumit
componentă a acelei culori, iar fiecare dintre ele poate avea o anumită intensitate, de la total
închis până la total deschis, în respectiva mixtură.
Modelul de culoare RGB este aditiv în sensul că cele trei fascicule sunt însumate
împreună, iar sprectrul lor luminos este însumat pentru a realiza spectrul final al culorii.
Cea mai scăzută intensitate pentru fiecare componentă va reda cea mai închisă culoare
(considerată negru), iar cea mai ridicată intensitate va reda culoarea alb. Calitatea albului
redat depinde de natura surselor primare de lumină, dar dacă sunt echilibrate corect rezultatul
este un alb neutru. Când intensitătile celor trei componente sunt identice dar nu minime sau
maxime se va obŃine o nuanŃă de gri mai deschisă sau mai închisă funcŃie de intensitate.
Capitolul 2 - Fundamente teoretice. Studiu bibliografic
27
Când una dintre componente are intensitatea cea mai puternică, culoarea obŃinută este o
nuanŃă apropiată de componenta respectivă, iar când două dintre cele trei componente au
intensităŃi puternice atunci culoarea obŃinută este o nuanŃă apropiată de una dintre culorile
secundare (culori obŃinute prin combinarea a două componente la intensităŃi maxime).
Modelul RGB în sine nu defineşte ceea ce înseamnă colorimetric roşu, verde, respectiv
albastru şi astfel rezultatele combinărilor nu sunt specificate absolut, ci relativ la culorile
primare. Când componentele primare sunt definite exact atunci modelul devine un spaŃiu
absolut de culoare (de exemplu sRGB sau Adobe RGB).
Alegerea culorilor primare este în stransă legătură cu fiziologia ochiului uman. Culori
primare bune sunt stimuli care maximizează diferenŃa între răspunsul celulelor conice ale
retinei ochiului uman la lumină de lungimi de undă diferite şi prin urmare realizează un
triunghial culorilor mult mai acoperitor (figura 2.3.1.2).
Figura 2.5.1.2. Triunghiul de culoare pentru spaŃiu de culoare sRGB
Cele trei tipuri normale de celule fotoreceptoare ale ochiului (celule conice) răspund cel
mai mult la următoarele lungimi de undă ale luminii: galben, verde, violet. DiferenŃa în
semnalele recepŃionate de la cele trei tipuri de celule permite creierului sa diferenŃieze o largă
gamă de culori distincte, fiind cel mai senzitiv la lumină verde-gălbuie şi la diferenŃe de
nuanŃe în zona verde-portocaliu.
Totuşi utilizarea celor trei culori primare nu este suficientă pentru reproducerea tuturor
culorilor, ci doar a celor aflate în triughiul culorilor (figura 2.5.1.2).
Proiect de diplomă
28
2.5.2. Sisteme luminanŃă-crominanŃă – YCrCb, YPbPr, YDbDr, YUV[19]
Toate aceste sisteme sunt folosite în transmisia şi procesarea semnalului video.
Majoritatea afişoarelor (cu tub catodic, cristale lichide etc.) au la bază semnale de control a
intensităŃii componentelor RGB, dar aceste semnale nu sunt la fel de eficiente ca o
reprezentare pentru stocarea şi transmisia datelor video.
Sistemele luminanŃă-crominanŃă reprezintă o aproximare practică pentru procesarea
culorii şi uniformitatea perceptuală, unde culorile primare aproximativ corespunzătoare
componentelor de bază ale RGB sunt procesate într-o formă de informaŃie cu semnificaŃie
perceptuală. Prin aceasta, procesarea video, transmisia şi stocarea pot realiza operaŃii şi pot
introduce erori în forme cu semnificatie perceptuală.
Modelele YCrCb, YprPb, YdrDb sunt folosite pentru a separa luminanŃa care poate fi
transmisă la o rezoluŃie mai mare şi viteze mai mari şi două componente de crominanŃă care
pot fi reduse ca rezoluŃie, ca număr de eşantioane, compresate sau chiar tratate separat pentru
mărirea eficienŃei sistemului.
Un exemplu practic ar fi reducerea lungimii de bandă sau a rezoluŃiei alocate culorii în
comparaŃie cu alb-negru ca o urmare a faptului că ochiul uman este oricum mult mai sensibil
la informaŃia alb-negru (figura 2.5.2.1).
Cele patru spaŃii de culoare sunt adese confundate, diferenŃele între ele fiind relativ mici.
Cronologic termenul YUV era folosit pentru o codare specifică a culorii în semnale analogice
în sistemele de televiziune, pe când YCrCb era folosit pentru o codare digitală a semnalului
video şi a imaginilor statice în fişiere de tip MPEG şi JPEG.
Figura 2.5.2.1. Imagine color şi componentele Y, Cr, Cb separate
Capitolul 2 - Fundamente teoretice. Studiu bibliografic
29
EcuaŃiile de conversie între sistemul LMNOLJMJNJ şi sistemele luminanŃă-crominanŃă sunt
prezentate în cele ce urmează:
PQRQSE � TU V LI � � � TU � TW� V MI � TW V NJ!� � �� V XYZ[Y�Z\]!� � �� V ^YZ[I�Z\_
<, unde TW � �`��F şi TU � �`�aa
PQRQSEI � b^ V L � bc V M � bX V Nd � �`F6e V XZ[Y�Zf]g � �`e�G V ^Z[Y�Zf_
<, unde h bU � �`�aabW � �`��Fbi � � �bU �bW � �`Gjk< Unul dintre principalele avantaje ale transmisiei semnalului video în format luminanŃă-
crominanŃă este păstrarea compatibilităŃii cu sistemele de televiziune alb-negru. Canalele de
transmisie E păstrează aproximativ toate datele înregistrate de camerele alb-negru, astfel
producând un semnal adecvat pentru recepŃia pe vechile afişoare monocrom. În acest caz,
semnalele d � g sau �� � �� sunt pur şi simplu ignorate.
Un alt avantaj al acestor sisteme este faptul că anumite informaŃii pot fi ignorate sau
reduse pentru a micşora cerinŃa de lăŃime de bandă. Ochiul uman are o sensitivitate relativ
mică la culori: acurateŃea informaŃiei de luminozitate a canalului de luminanŃă are un inpact
mult mai mare decât informaŃia de crominanŃă a celorlalte două canale. Prin înŃelegerea
acestor limitări umane s-au dezvoltat standarde de transmisie mult mai eficiente lăsând
creierul uman sa extrapoleze o mare parte din informaŃia de culoare. Aşadar informaŃia de
crominanŃă poate fi substanŃial redusă.
Pe de altă parte trebuie menŃionat faptul că o conversie dintr-un spaŃiu/sistem de culoare în
altul se face cu pierdere de informaŃie. Prin urmare ecuaŃiile de conversie prezentate anterior
nu au un caracter total bijectiv, constantele care apar fiind stabilite experimental.
2.5.3. Sisteme nuanŃă-saturaŃie – HSV, HSL[16]
Sistemele HSL şi HSV reprezintă două modele de reprezentăre a culorilor într-un spaŃiu
general RGB care încearcă să descrie relaŃiile dintre culorile perceptuale cu o mai mare
acurateŃe decât RGB, în acelaşi timp rămânând simple de calculat. HSL/HSV sunt acronime
pentru nuanŃă, saturaŃie, luminozitate/valoare.
Ambele sisteme descriu culorile ca puncte într-un cilindru a cărui axă centrală merge de
la negru în partea de jos până la alb în partea de sus având culori neutre între ele, unde
Proiect de diplomă
30
unghiul în jurul axei corespunde nuanŃei, distanŃa de la axă corespunde saturaŃiei, iar distanŃa
de-a lungul axei corespunde luminozităŃii sau valorii (figura 2.3.3.1).
Cele două reprezentări sunt similare ca scop, dar diferă într-o oarecare măsură ca mod de
abordare. Matematic ambele sisteme descriu un cilindru, dar în timp ce HSV poate fi
considerat conceptual ca un con al culorilor inversat, HSL reprezintă conceptual un con dublu
sau o sferă (figura 2.5.3.2).
Figura 2.5.3.1. Cilindrul HSV
Figura 2.5.3.2. HSL reprezentat ca un con dublu
Trebuie remarcat faptul că deşi “nuanŃa” se referă la acelaşi atribut pentru ambele
sisteme, în cazul “saturaŃiei” definiŃile diferă dramatic.
Din cauza faptului că sistemele HSL şi HSV sunt simple transformări ale unui sistem
RGB dependent de echipament, culorile definite de astfel de triplete depind de culorile
primare folosite. Fiecare echipament are un sistem unic RGB, prin urmare şi un sistem unic
HSL sau HSV corespunzător. Pe de altă parte un triplet sau devine definit în
momentul în care este legat de un spaŃiu de culoare RGB, cum ar fi sRGB.
Conversia din RGB în HSL sau HSV se face conform următoarelor ecuaŃii:
Pentru HSL:
Capitolul 2 - Fundamente teoretice. Studiu bibliografic
31
K �PQRQS �� A l � � 5� �5� �5� � �5��9 � A l �9 � �� �5�� � � 5�� � �5�� � �9 � A l �9 @ ��
< Pentru HSV: ; �
K � m �� A l � � � �5� � � � 5� � A l � n �<
Conversia din HSL în RGB este prezentată în cele ce urmează plecând de la următoarele
premise: o p ���6e��, K� 9 p �����, iar rezultatul �� :� � p �����. De remarcat faptul că în cazul
în care saturaŃia este 0 culoarea rezultată este acromatică, adică un gri. În acest caz valorile
componentelor �� :� � sunt egale cu valoarea 9, aşadar valoarea o este ignorată şi poate fi chiar
nedefinită. Indiferent dacă K � � va fi respectată următoarea secvenŃă de conversie:
q � r 9 s � � K�� A l �9 � ��9 � K � 9 s K� A l �9 t ��<
3 � � s 9 � q
ou � o6e� � o���� 95( / /^ � ou � �6 v �/c � ouv � /X � ou � �6
/w � 8/w � �� /w � �/w � �� /w @ �� � p >L� M� N?<
LMNw �PQQQRQQQS 3 � x q � 3� s e s /wy� A l �/w � �eq�A l �e � /w � ��3 � z q � 3� s e s {�6 � /w|} � A l �� � /w � �63� A l �/w t �6
< � � p >L� M� N?
Proiect de diplomă
32
Conversia din HSV în RGB se realizează similar:
o" � ~ oe���e
B � oe� � ~ oe�� 3 � ; s � � K� q � ; s � � B s K� / � ; s � � � � B� s K� �� :� �� �
PQQRQQS ;� /� 3�� A l �o" � � q� /� 3�� A l �o" � � 3� ;� /�� A l �o" � � 3� q� ;�� A l �o" � 6 /� 3� ;�` A l �o" � F ;� 3� q�� A l �o" � G
<
2.6. Algoritmi de prelucrare a imaginii
În ingineria electronică şi în stiinŃa calculatoarelor, procesarea imagnii reprezintă orice
formă de procesare a semnalelor unde intrarea în sistemul de procesare este o imagine (desen,
fotografie, cadru video, etc.), iar ieşirea poate fi reprezentată fie de o imagine, fie de un set de
caracteristici sau paramentri ai imaginii iniŃiale. Tehnologia digitală modernă a făcut posibilă
prelucrarea semnalelor multidimensionale în sisteme de diferite complexităŃi, de la simple
circuite digitale până la calculatoare paralele. Scopurile acestor prelucrări pot fi împărŃite în
trei categorii:
a. Procesarea imaginii pentru îmbunătăŃirea sau modificarea calităŃii acesteia.
b. Procesarea şi analiza imaginii pentru obŃinerea de măsurători asupra acesteia.
c. Procesarea imaginii cu scopul înŃelegerii conŃinutului şi formării unor descrieri de
nivel înalt ale acesteia.
Procesarea imaginilor de orice natură este realizată cu ajutorul filtrelor implementate fie
hardware (circuite dedicate, procesoare de semnal, filtre implementate în hardware
reconfigurabil de tip FPGA), fie software (aplicaŃii de procesare şi/sau editare a imaginilor).
După modul în care sunt tratate imaginile, filtrele implementate pot fi clasificate astfel:
a. Filtre punctuale – filtre aplicate asupra fiecărui punct/pixel în parte; prezintă
următoarele avantaje: viteză mare de calcul (pot fi organizate în structuri de tip
pipeline, practic se ajunge la o paralelizare a calculului), întârzieri minime ale
Capitolul 2 - Fundamente teoretice. Studiu bibliografic
33
semnalului prin sistemul de procesare; principalul dezavantaj este acela că nu pot
implementa decât funcŃii de procesare simple, cum ar fi: controlul luminozităŃii,
contrastului, saturaŃiei, nuanŃei, obŃinerea negativului, etc.
b. Filtre bidimensionale – filtre mult mai complexe implementate pe baza a matrici
de conversie; se pot realiza o multitudine de funcŃii complexe de procesare a
imaginilor, cum ar fi: înceŃoşarea sau netezirea imaginii, detectarea muchiilor
(edge-detect), eliminarea zgomotului, efectul de embossing, omogenizarea
culorilor, etc. Principalul dezavantaj îl constituie efectiv construcŃia lor bazată pe
matrici, prin faptul că aplicarea acestor filtre asupra streamurilor video este mai
dificilă, necesită mult mai multă memorie (au nevoie de un volum iniŃial de date,
practic o porŃiune din cadrul) şi structuri specializate pentru aplicarea funcŃiei de
convoluŃie între matricea de pixeli şi matricea filtrului.
În continuare vor fi prezentate principiile teoretice a unui set de filtre punctuale după cum
va urma: negativul imaginii, ajustarea luminozităŃii, saturaŃiei, respectiv contrastului.
2.6.1. Negativul imaginii
O imagine pozitivă este practic imaginea normală. Imaginea negativă este formată prin
inversarea tonurilor. Din punct de vedere al luminanŃei, suprafeŃele deschise devin închis sşi
invers, iar din punct de vedere al cromaticii, nuanŃele culorilor primare devin nuanŃe ale
culorilor secundare (roşu devine turcoaz, verde devine violet, albastru devine galben).
Algoritmul pentru fiecare pixel din imaginea sursă:
- Se extrag componentele �, :, � ale pixelului.
- Valorile binare ale componentelor �, :, � sunt negate (inversate) obŃinând �J, :J, �J. - Se vor înlocui cu valorile r', g', b' componentele pixelului destinaŃie.
Figura 2.6.1.1. Imagine color si negativul acesteia (A-B); imagine alb-negru şi negativul acesteia (C-D)
Proiect de diplomă
34
Pentru imaginile în tonuri de gri se aplică aceeaşi procedură de mai sus, cu menŃiunea că
în loc de cele trei valori �, : şi � avem una singură – nivelul de gri.
2.6.2. Controlul luminozităŃii imaginii[13]
Luminozitatea este un atribut al percepŃiei vizuale în care o sursă pare a radia sau reflecta
lumină. În alte cuvinte, luminozitatea este percepŃia realizată de luminanŃa obiectului
vizualizat.
Luminozitatea este un termen folosit formal pentru a marca sinonimul din fotometrie,
luminanŃă. După cum a fost definit în Catalogul american de termeni în telecomunicaŃii,
termenul de luminozitate ar trebui folosit doar pentru referinŃe necantitative ale senzaŃilor şi
percepŃilor fiziologice ale luminii. De remarcat faptul că luminanŃa unei surse poate oferi
diferite percepŃii de luminozitate în diferite contexte. În spaŃiul de culo RGB, luminozitatea
poate fi considerată chiar o medie aritmetică a celor trei coordonate (componente) de culoare,
deşi nu toate cele trei componente au efecte similare asupra percepŃiei luminii.
� � L � M � N6
Luminozitatea este de asemenea o componentă a spaŃilor de culoare HSL şi HSV.
O imagine cu luminozitate slabă este o imagine subexpusă, iar o imagine cu luminozitate
exagerată este o imagine spupraexpusă.
Figura 2.6.2.1. Imagine la diferite nivele de luminozitate.
Ajustarea luminozităŃii poate fi aplicată atât imaginilor RGB cât şi imaginilor în tonuri de
gri. Ea presupune deplasarea valorilor fiecărui pixel, cu un delta precizat.
Algoritmul pentru imaginile RGB:
Se determină cele trei valori delta: �� , �: , respectiv �� . Pentru fiecare pixel din
imaginea sursă:
- Se extrag componentele �, :, � ale pixelului.
Capitolul 2 - Fundamente teoretice. Studiu bibliografic
35
- Se calculează �J, :J, �J prin adunarea ��, �:, şi �� la �, :, respectiv �.
- Se vor înlocui cu valorile �J, :J, �J componentele pixelului destinaŃie.
Ca şi în cazul negativizării, pentru imaginile în tonuri de gri este necesară o singură
valoare delta şi se va lucra cu o singură componentă.
2.6.3. Controlul contrastului imaginii[15]
Contrastul este diferenŃa între proprietăŃile vizuale care constituie un obiect (sau
reprezentarea sa într-o imagine) care pot fi distinse de alte obiecte sau fundal. În percepŃia
vizuală a lumii reale, contrastul determină diferenŃă în culoare şi luminozitate a unui obiect
faŃă de alte obiecte aflate în acelaşi câmp vizual. Datorită faptului că sistemul vizual uman
este mai sensibil la contrast decât la luminanŃa absolută, omul poate percepe lumea similar
indiferent de diferenŃele mari de iluminare deŃa lungul zilei sau de la un loc la altul.
Un fenomen demostrat experimental este inhibarea albatrului periferic în condiŃiile în
care lumina albastră este afişată pe un fundal alb, fapt ce are ca rezultat o margine galbenă.
Galbenul este derivat prin inhibarea albastrului pe margini, fapt explicabil în spaŃiul RGB
astfel: alb este format prin combinarea celor trei componente, dar prin inhibarea albastrului
rezultă doar roşu şi verde care prin combinare formează galben.
Există mult posibile definiŃii ale contrastului. Unele includ culoarea, altele nu. Diferitele
definiŃii ale contrastului sunt folosite în diferite situaŃii. Spre exemplu, contrastul luminanŃei
este definit prin următoarea formulă:
�� � ���� � 4�A���� � 945� �/ ��A5�
Logica de la baza acestei formule este că diferenŃe mici de luminanŃă la o luminanŃă
medie mare sunt neglijabile, pe când aceleaşi diferenŃe la o luminanŃă medie slabă contează.
Un alt tip de constrast este contrastul Weber care este definit ca:
�f � � � �W�W
unde � şi �W reprezintă luminanŃele trăsăturilor şi respectiv ale fundalului. Este utilizat în
cazurile în care trăsături mini sunt prezente pe un fundal mare uniform.
Contrastul de tip Michelson este folosit des pentru cadrele în care atât trăsăturile
luminoase cât şi trăsăturile închise sunt echivalente şi ocupă fracŃiuni similare de suprafaŃă.
Acest tip de contrast este definit astfel:
Proiect de diplomă
36
�� � ���� � ��"����� � ��"�� unde �����şi ��"� reprezintă nivelele extreme ale luminanŃei.
Un al patrulea tip de contrast este contrastul RMS. Acesta nu depinde de frevenŃa spaŃială
a conŃinutului sau de distribuŃia spaŃială a contrastului în imagine. Contrastul RMS este definit
ca deviaŃia standard a intensităŃilor pixelilor din imagine:
�^�� � � �� � �� �" � � ����"��
unde intensităŃile �" sunt normalizate la o valoare maximă de 1, � este numărul total de pixeli
din imagine, iar � � reprezintă intensitatea medie a pixelilor din imagine.
Figura 2.6.3.1. Imagine la diferite nivele de contrast.
2.6.4. Controlul saturaŃiei imaginii[14]
În teoria culorilor, saturaŃia, croma şi coloratura sunt în legătura una cu cealaltă, dar
totodată sunt concepte distincte referitoare la intensitatea perpepută a unei culori. Coloratura
este definită ca diferenŃa dintre o culoare şi gri. Croma e definită ca diferenŃa unei culori faŃă
de luminozitatea altei culori se confundă cu alb în condiŃii similare de vizare. SaturaŃia este
practic diferenŃa culorii faŃă de propria sa luminozitate. Aşadar conceptul general este intuitiv,
termenii fiind deseori folosiŃi pentru a definii acelaşi lucru.
Un stimul foarte colorat este intens şi viu, pe când un stimul mai puŃin colorat pare a fi
estompat, mai apropiat de gri. Fără coloratură deloc, o imagine sau o culoare devine un gri
„neutru” (o imagine fără coloratură în nici una dintre culori este denumită o imagine în tonuri
de gri).
Capitolul 2 - Fundamente teoretice. Studiu bibliografic
37
SaturaŃia este una din coordonatele sistemelor de culoare HSL şi HSV. De notat este
faptul că toate calculatoarele în care este implementat acest sistem de culoare folosesc o
aproximare brută pentru a calcula ceea ce se presupune a fi saturaŃia.
SaturaŃia unei culori este determinată de o combinaŃie de intensitate de lumină şi cât de
mult este distribuită de-a lungul sperctrului vizual pe lungimi de undă diferite. Cea mai pură
culoare este obŃinută prin folosirea unei singure lungimi de undă la intensitate mare
asemănător luminii laser. Dacă intensitatea scade, scade şi saturaŃia. Pentru a desatura o
culoare într-un sistem substractiv, se adaugă alb, negru gri sau complementul nuanŃei.
Figura 2.6.4.1. Imagine la diferite nivele de saturaŃie.
2.7. InterfeŃele seriale RS-232 şi PS/2
2.7.1. InterfaŃa serială RS-232[11][18]
În telecomunicaŃii, RS-232 (Recommended Standard 232) este un standard pentru
semnale transmise serial între două echipamente DTE (Data Terminal Equipment – de fel un
modem) şi DCE (Data Circuit-terminating Equipment). Este folosit în mod în mod special
pentru porturile seriale ale calculatoarelor personale.
Detaliile despre formatul caracterelor şi ratei de trasfer sunt controlate de hardware-ul
portului serial, de obicei un singur circuit integrat denumit UART care realizează conversia
din paralel în forma asincronă serialp start-stop. Detaliile despre nivelele de tensiune,
comportamentul la scurt-circuit sunt controlate de un driver de linie care converteşte nivelele
logice ale UART-ului în nivele ale semnalului compatibile RS-232.
Proiect de diplomă
38
În RS-232, datele sunt trimise ca o serie de biŃi în timp. Ambele moduri de transfer,
sincron şi asincron, sunt suportate de standard. În plus faŃă de circuitul de date, stadardul
defineşte o serie de circuite de control pentru a gestiona conexiunea între DCE şi DTE.
Avantajele transmisiei seriale faŃă de transmisia paralelă sunt următoarele:
- Cablurile seriale pot fi mai lungi decât cablurile paralele. Portul serial transmite un
„1” logic în intervalul -3 până la -25V şi „0” logic în intervalul +3 până la 25V, în
vreme ce portul paralel transmite „0” ca 0V şi „1” ca 5V. Prin urmare portul serial
are diferenŃa maximă de semnal de 50V comparativ cu portul paralel la care aceasta
este de maxim 5V. Prin urmare pierderile de semnal sunt o problemă mai mică
pentru cablul serial decât pentru cablul paralel.
- Pentru transmisia serială nu sunt necesare atât de multe fire pentru transmisie
comparativ cu transmisia paralelă. Dacă dispozitivul care trebuie conectat este la
mare distanŃă, 3 fire sunt mai ieftine şi mai uşor de manevrat decât 19 sau 25 de fire.
Totuşi trebuie luat în considerare şi costul interfaŃării de la fiecare capăt.
Porturile seriale pot avea două tipuri de conectori: de tip D25 şi de tip D9. SemnificaŃia
pinilor este prezentată în tabelul 2.7.1.
Tabel ul 2.7.1. Plasarea pinilor portului serial RS-232 pe conectori
Conector D25 Conector D9 Abreviere Nume complet Pin 2 Pin 3 TD Transmit Data Pin 3 Pin 2 RD Receive Data Pin 4 Pin 7 RTS Request To Send Pin 5 Pin 8 CTS Clear To Send Pin 6 Pin 6 DSR Data Set Ready Pin 7 Pin 5 SG Signal Ground Pin 8 Pin 1 CD Carrier Detect Pin 20 Pin 4 DTR Data Terminal Ready Pin 22 Pin 9 RI Ring Indicator
FuncŃiile pinilor sunt prezentate în tabelul următor:
Tabelul 2.7.1.2. SemnificaŃia pinilor portului serial RS-232
Abreviere Nume complet SemnificaŃie TD Transmit Data Ieşirea serială de date (TXD) RD Receive Data Intrarea serială de date (RXD) RTS Request To Send AtenŃionează DCE că UART e gata pentru transfer CTS Clear To Send Indică faptul că DCE este gata pentru transfer DSR Data Set Ready Către UART: DCE e gata de stabilirea unei legături DTR Data Terminal Ready Către DCE: UART e gata de stabilirea unei legaturi RI Ring Indicator Activ când DCE detectează semnal de sonerie de la
PSTN (comunicaŃie pe linie telefonică prin modem).
Capitolul 2 - Fundamente teoretice. Studiu bibliografic
39
Fiecare caracter este încapsulat într-un cadru şi trasferat bit cu bit. Cadrul are o formă
standard fiind constituit din patru portiuni, după cum se observă şi în figura 2.7.1.1:
a. Bit de start – când nu sunt transmise datem, linia este menŃinută în “1” logic; la
începerea trasferului fiecărui caracte linia este trecută în “0” logic.
b. BiŃi de date – standardul suportă transferul de caractere reprezentate pe 6, 7, respectiv
8 biŃi.
c. Bit de paritate – bitul de paritate este calculat la iniŃierea transferului fiecărui
caracter; se poate lucra cu paritate pară sau impară.
d. BiŃi de stop – indică sfârşitul unui cadru şi pot fi 1, 1.5, respectiv 2.
Figura 2.7.1.1. Cadrul unui caracter.
2.7.2. InterfaŃa serială PS/2[1]
InterfaŃa fizică PS/2 (Personal System/2) foloseşte un protocol serial bidirecŃional pentru
a transmite date despre mişcarea (în cazul mouse-ului) sau apăsarea butoanelor (în cazul
tastaturii sau mouseului). Pe de altă parte calculatorul poate trimite un număr de comenzi
pentru configurarea acestor interfete cu utilizatorul.
Poate avea două tipuri de conectori: cu DIN cu 5 pini şi mini-DIN cu 6 pini. Sistemul la
care este conectat un mouse sau o tastatură trebuie să ofere pe doi pini ai interfeŃei o sursă cu
protecŃie la suprasarcină de 5V. InterfaŃa indiferent de conectorul folosit mai prezintă încă doi
pini utili în plus faŃă de cei doi de alimentare: pinul de date şi pinul de ceas, ceilalŃi pini fiind
neutilizaŃi. Liniile de date, respectiv ceas sunt implementate fizic ca linii open-collector.
Magistrala PS/2 este în stare inactivă când când ambele linii (de date şi de ceas) sunt în starea
high. Aceasta este singura stare în care se permite trasferul de date de la tastatură sau mouse
către sistem. Sistemul totdeauna trebuie să genereze semnalul de ceas. Dacă se doreşte
transferul de date de la sistem la echipament, trebuie iniŃial oprită comunicaŃia în sens invers
prin setarea semnalului de ceas la nivel jos (low). Apoi gazda va seta şi linia de date la nivel
jos. Acestă stare reprezintă starea de cerere de transfer.
01234567 DDDDDDDD
Bit START Biti
STOP
Bit PARITATE
1 1 t 0
Proiect de diplomă
40
Datele sunt transmise similar standardului RS-232. Fiecare octet trimis este încapsulat
într-un cadru format din: un bit de start, 8 biŃi de date (octetul respectiv), un bit de paritate (se
foloseste doar paritate pară), un bit de stop şi un bit de înştiinŃare, ack (apare doar în transferul
de la gazdă către dispozitiv).
Figura 2.7.2.1. ComunicaŃia dispozitiv-gazdă (SR –bit start, P – bit paritate, ST – bit stop).
Mouse-ul sau tastura trimite un bit pe linia de date când semnalul de ceas este high, iar
gazda citeşte când semnalul de ceas este low.
FrecvenŃa de ceas este de 10 până la 16.7 KHz. Gazda poate să oprească transferul în
orice moment prin setarea semnalului de ceas în starea low pentru un minim de 100 µs. Dacă
gazda opreşte comunicaŃia înainte ca dispozitivul să transmită un cadru complet, respectivul
dispozitiv trebuie sa anuleze transferul şi să retransmită în momentul în care gazda elibereaza
linia. Dacă totuşi gazda opreşte comunicaŃia în perioada în care semnalul de ceas este low,
dispozitivul nu mai trebuie sp retransmită respectivul cadru. Pe de altă parte, dacă trebuie
retransmis respectivul cadru şi între timp mai apare un eveniment, acest ultim eveniment va fi
memorat în bufferul dispozitivului. Atât tastatura, cât şi mouse-ul pe PS/2 sunt prevăzute cu
un buffer de 16 biŃi pentru această situaŃie. În caz că apar alte evenimente când bufferul este
plin, acestea vor fi ignorate. Mouse-ul memorează doar cel mai recent cadru pentru transfer.
Figura 2.7.2.2. ComunicaŃia gazdă-dispozitiv.
a – timpul scurs până la începerea generării semnalelor de ceas.
b – timpul necesar pentru transmiterea datelor.
După cum se observă din formele de undă după transmiterea datelor de la gazdă la
dispozitiv este recepŃionat imediat bitul ack.
Capitolul 2 - Fundamente teoretice. Studiu bibliografic
41
2.8. Protocolul de transfer între mouse şi sistem[1]
Mouse-ul PS/2 standard suportă următoarele întrări: deplasare pe axa x (stânga-dreapta),
deplasare pe axa y (sus-jos), stările butoanele standard (stanga, dreapta, mijloc). Mouse-ul
citeşte aceste intrări la o anumită frecvenŃă şi reactualizează contorii şi indicatorii
corespunzători. Există multe alte dispozitive PS/2 care au intrări adiŃionale şi pot trimite
datele diferit decât în modul standard.
Când mouse-ul detectează deplasare, acesta incrementează sau decrementează
numărătoarele corespunzător cu deplasarea detectată. Acestea sunt valori de 9 biŃi în
complement faŃă de 2 şi fiecare are asignat un indicator de depăşire. Parametrul care
determină cantitatea prin care sunt incrementate sau decrementate numărătoarele este
rezoluŃia. RezoluŃia standard este de 4 numărări per milimetru şi gazda poate să o modifice
folosind comanda de setare a rezoluŃiei.
AdiŃional mai există un paramentru care nu afectează modificarea valorii numărătoarelor,
ci valoare raportată sistemului. Acest parametru se numeşte scalare. Standard mouse-ul are o
scalare de 1:1 care nu are nici un efect asupra valorii, dar gazda poate seta o scalare de 2:1
printr-o comandă specifică. Dacă scalarea este setată la 2:1, mouse-ul va raporta valoarea
conform următorului tabel:
Tabel ul 2.8.1. Valori raportate de mouse în cazul unei scalări de 2:1
Valoare numărător Valoare raportată 0 0 1 1 2 1 3 3 4 6 5 9
n>5 2n
Mouse-ul PS/2 standard trimite informaŃia de deplasare şi de stare a butoanelor într-un
pachet de 3 octeti după cum este evidenŃiat în figura 2.8.1.
Bit 7 Bit 6 Bit 5 Bit 4 Bit 3 Bit 2 Bit 1 Bit 0
Octet 1 Depăşire Y
Depăşire X
Semn Y
Semn X
“1” Buton Mijloc
Buton Dreapta
Buton Stanga
Octet 2 Deplasare X Octet 3 Deplasare Y
Figura 2.8.1. Pachetul trimis de un mouse PS/2 standard.
Proiect de diplomă
42
InformaŃia de deplasare este reprezentată pe 9 biŃi în complement faŃă de 2, astfel cel mai
semnificativ bit apare ca un bit de semn în octetul 1. Numărătoarele sunt actualizate cand
mouse-ul citeşte intrările şi determină că a fost realizată o deplasare. Valorile acestora
reprezintă cantitatea deplasării care s-a realizat de la ultima citire. Valoarea exprimată de
numărătoarele de deplasare se încadrează între -255 şi 255. Dacă valoarea este depăşită, bitul
indicator de depăşire va fi activat. Numărătoarele sunt resetate după fiecare transfer complet,
dar şi la primirea comenzii de retrimitere de la gazdă.
Mouse-ul PS/2 standard poate opera în patru moduri:
- Reset – mod în care intră automat la pornire sau la primirea comezii de resetare; după
intrarea în acest mod mouse-ul realizează un autotest BAT (Basic Assurance Test) şi
setează: rata de eşantionare 100 per secunda, rezoluŃia 4 per mm, scalarea 1:1 şi
dezactivează trimiterea de date. Apoi trimite rezultatul testului către gazdă. În
următorul pas mouse-ul trimite codul identificator. După trimiterea codului mouse-ul
intră în modul stream.
- Stream – modul implicit în care lucrează mouse-ul după ce s-a terminat de executat
rutina iniŃială de reset.
- Remote – mod util în anumite situaŃii; se intră în acest mod prin trimiterea către
mouse a comenzii de setare mod remote şi se iese prin trimiterea comenzii de setare
mod stream; în acest mo mouse-ul citeşte intrările şi reactualizează numărătoarele şi
indicatorii la rata de eşantionare curentă, dar nu trimite automat pachete de date când
este detectată deplasare. În schimb gazda trebuie să citească datele folosind comanda
de citire date. După recepŃionarea respectivei comenzi, mouse-ul trimite un singur
pachet şi resetează numărătoarele şi indicatorii.
- Wrap – modul este util doar pentru testarea conexiunii intre gazdă şi mouse; se intră
în acest mod prin trimiterea comenzii de setare mod wrap şi se iese prin trimiterea fie
a comenzii de resetare, fie a comenzii de resetare mod wrap. Dacă este primită
comanda de resetare, mouse-ul se va reiniŃializa, iar dacă este primită comanda de
resetare mod wrap, mouse-ul va intra în modul anterior. În acest mod, care este un
mod de tip ecou, fiecare octet trimis de gazdă este retrimis inapoi de mouse, chiar
dacă respectivul octet reprezintă o comandă validă mouse-ul nu va răspunde la ea.
Există doar cele două excepŃii menŃionate anterior.
O extensie populară a mouse-ul PS/2 standard este mouse-ul Microsoft Intellimouse.
Acesta include suport pentru un număr de 5 butoane şi 3 axe de deplasare (stânga-dreapta,
Capitolul 2 - Fundamente teoretice. Studiu bibliografic
43
sus-jos, rotiŃa de derulare). Aceste caracteristici adăugate necesită împreună cu cele standard
un pachet de 4 octeŃi. Având în vedere că gazdele PS/2 standard nu pot să recunoască acest
format de pachet, acest tip de mouse a fost realizat astfel încât să opereze ca un mouse
standard în cazul în care gazda nu confirmă recunoaşterea tipului de mouse. Astfel acest
mouse poate fi utilizat pe sisteme care nu recunosc respectivele funcŃii ca un mouse normal.
După etapa de resetare mouse-ul Intellimouse operează ca un mouse standard. Pentru a
intra în modul scrolling wheel gazda trebuie să trimită următoarea secvenŃă către mouse:
setare rată eşantionare 200, setare rată eşantionare 100, setare rată eşantionare 80. După
această rutină gazda emite o comandă de receŃionare identificator mouse. Dacă mouse-ul este
standard va trimite inapoi identificatorul 00h,iar în caz contrar 03h. Pachetul de date în acest
mod este prezentat în figura 2.8.2.
Bit 7 Bit 6 Bit 5 Bit 4 Bit 3 Bit 2 Bit 1 Bit 0
Octet 1 Depăşire Y
Depăşire X
Semn Y
Semn X
“1” Buton Mijloc
Buton Dreapta
Buton Stanga
Octet 2 Deplasare X Octet 3 Deplasare Y Octet 4 Deplasare Z
Figura 2.8.2. Pachetul trimis de un Intellimouse în modul scrolling wheel.
Pentru a intra în modul scrolling wheel+5 gazda trimite următoare secvenŃă: setare rată
eşantionare 200, setare rată eşantionare 200, setare rată eşantionare 80. Mouse-ul va raspunde
la comanda de trimitere identificator cu 04h. Pachetul de date care va fi trimis de un
Intellimouse în acest mod este similar având tot 4 octeŃi (figura 2.8.3).
Bit 7 Bit 6 Bit 5 Bit 4 Bit 3 Bit 2 Bit 1 Bit 0
Octet 1 Depăşire Y
Depăşire X
Semn Y
Semn X
“1” Buton Mijloc
Buton Dreapta
Buton Stanga
Octet 2 Deplasare X Octet 3 Deplasare Y Octet 4 “0” “0” Buton 5 Buton 4 Z3 Z2 Z1 Z0
Figura 2.8.3. Pachetul trimis de un Intellimouse în modul scrolling wheel+5.
Proiect de diplomă
44
3. Analiza, proiectarea şi implementarea hardware a aplicaŃiei
pentru FPGA
3.1. Premise de proiectare – Analiza problemei
Conform temei de proiectare sistemul hardware trebuie să genereze primitivele grafice pe
un afişor de dimensiuni mici şi să aplice asupra imaginii rezultate a unor efecte vizuale de
bază, practic o procesare primară a semnalului trimis către afişor.
Afişorul este în fapt un LCD TFT Ampire AM-480272ATMQW-00H de 4 Ńoli cu o
rezoluŃie de 480*272 pixeli (figura 3.1.1). LCD-ul are nevoie de o sursă de alimentare tipică
de 3,3V/150mA şi primeşte ca intrare de culoare 18 semnale digitale reprezentând un format
RGB cu 6 biŃi per componentă, astfel fiind posibilă conectarea directă la placa de dezvoltare
fără circuite suplimentare de alimentare sau adaptare a tensiunilor şi/sau curenŃilor.[2]
Figura 3.1.1. Modulul LCD utilizat şi semnalele de comanda.
A fost totuşi necesară realizarea unei plăci adaptoare pin la pin pentru a fi conectat la
porturile Pmod ale plăcii Nexys2 (figura 3.1.2).
Capitolul 3 - Analiza, proiectarea şi implementarea hardware a aplicaŃiei pentru FPGA
45
Figura 3.1.2. Adaptorul pin-la-pin pentru conectarea modulului LCD.
LCD-ul folosit prezintă o serie de avantaje care uşurează modul de control şi anume:
- Are nevoie doar de un singur semnal de sincronizare de tip data-enable; acest semnal
este activ doar pe durata afişarii, în rest fiind inactiv (figura 3.1.3).
- Are un consum redus, astfel fiind posibilă alimentarea directă prin interfeŃele Pmod
ale placii Nexys2.
- Controlul luminii de fundal pe un singur pin prin modulaŃie în lungime de puls
(PWM).
Figura 3.1.3. Comanda LCD-ului în modul data-enable[2].
Proiect de diplomă
46
Am ales să implementez sistemul hardware pe o placă de dezvoltare cu FPGA pentru că
această structură este avantajoasă în acest caz pentru procesarea paralelă în timp real a datelor
de culoare trimise către afişor. Totodată posibilitatea de a implementa structuri care lucrează
în paralel în interiorul FPGA-ului îmi oferă libertatea de a modulariza foarte mult întregul
sistem şi de a integra toate controlerele necesare fără a periclita timpul de procesare.
Totodată implementarea pe un FPGA presupune descrierea de module total specializate
astfel diminuând ocuparea inutilă de resurse şi simplificând mult logica întregului sistem.
În cazul în care apelam la o placă bazată pe microprocesor sau microcontroler problema
paralelizării rămânea încâ valabilă având cel puŃin trei procese principale distincte de
gestionat: preluarea comenzilor, desenarea primitivelor, afişarea. Aşadar în cazul unei
proiectări bazate pe procesor trebuia implementat un mecanism de pseudoparalelizare a
funcŃiilor respective. Pe de altă parte sistemul astfel proiectat trebuia să lucreze la o frecvenŃă
de cel putin N*25MHz, unde N este numărul de procese pseudoparalele, pentru a asigura o
afişare corectă şi sincronizată a imaginii. Aşadar era nevoie de un microprocesor relativ rapid
ceea ce practic rezulta în consum de energie şi costuri mai mari ale sistemului.
Schema bloc a sistemului este prezentată în figura 3.1.3:
Figura 3.1.3. Schema bloc de principiu a sistemului complet.
Conform celor propuse aplicaŃia software pentru microsistemul cu FPGA trebuie să ofere
următoarele funcŃionalităŃi:
- Afişarea pe modulul LCD a unei interfeŃe grafice şi a rezultatului.
Capitolul 3 - Analiza, proiectarea şi implementarea hardware a aplicaŃiei pentru FPGA
47
- Preluarea şi interpretarea comenzilor primite pe interfaŃa serială RS-232.
- Preluarea informaŃilor de deplasare şi stare de la mouse pe interfaŃa PS/2.
- Asigurarea unei memorii tampon video pentru păstrarea imaginii rezultate.
- Generarea primitivelor grafice apelate.
- Procesarea imaginii înainte de a fi afişată.
În proiectarea acestei aplicaŃii am avut în vedere faptul că microsistemul va avea două
moduri de funcŃionare: de sine stătător, respectiv comandat.
Modul de funcŃionare de sine stătător presupune următoarele: interfaŃa de comandă este
asigurată prin intermediul mouse-ului şi butoanelor prezente pe placa Nexys2; interfaŃa
grafică este afişată pe modulul LCD. Utilizatorul poate seta cu ajutorul mouse-ului primitiva
grafică dorită, culoarea de desenare şi parametrii de aplicare a efectelor. Primul punct care
defineşte figura se setează prin apăsarea butonului din stânga al mouse-ului, iar cel de-al
doilea prin apăsarea butonului dreapta. În cazul desenării unui punct doar prima acŃiune este
luată în considerare. Pentru celelalte primitive grafice desenarea este activată la stabilirea
celui de-al doilea punct. Astfel apare un efect secundar al acestei opŃiuni de proiectare şi
anume desenarea cu un punct fix: se stabileşte primul punct, iar apoi prin diferite setări ale
celui de-al doilea punct figurile apar desenate în jurul primului punct selectat.
Modul de funcŃionare comandat presupune aşteptarea comenzilor de la calculator prin
intermediul interfeŃei seriale RS-232. O comandă presupune trimiterea codului comenzii şi a
parametrilor acesteia. La recepŃionarea completă a codului comenzii sistemul o va executa.
Comenzile pot fi de desenare, de actualizare a valorii unei componente cromatice sau de
actualizare a parametrului unui filtru punctual. În acest mod valorile setate cu ajutorul mouse-
ului de către utilizator nu mai au efect asupra modulelor de desenare şi procesare a imaginii.
Sunt folosite doar valorile primite de la calculator pe interfaŃa serială.
InterfaŃa grafică rămâne neschimbată ca organizare indiferent de modul de lucrul activ la
un moment dat. Am decis implementarea unei citiri multiplexate a stării butoanelor plăcii
Nexys2 pentru a evita apariŃia a două evenimente de tip „buton apăsat” simultan. Controlerul
pentru LCD va include şi modulele de generare a interfeŃei grafice dat fiind faptul că acestea
sunt dependente de semnalele de sincronizare.
Pentru acest proiect voi utiliza următoarele interfeŃe (porturi) ale plăcii de devoltare
Nexys2:
- Portul serial RS-232 – pentru receptarea comenzilor de la aplicaŃia software.
Proiect de diplomă
48
- Portul serial PS/2 – pentru utilizarea unui mouse util în modul de funcŃionare de sine-
stătător.
- Porturile Pmod – pentru conectarea modulului de afişare.
- 2 comutatoare şi cele 4 butoane pentru controlul diferitelor funcŃii implementate.
FPGA-ul Spartan 3E-500 are implementate în interiorul cipului un număr de 20 de
module de memorii Block RAM dual-port (biport) de care pot fi configurate funcŃie de
necesătăŃile proiectului având în total o dimensiune de 360 KbiŃi şi încă 20 de multiplicatori
cu operanzi (intrări) pe 18 biŃi (figura 3.1.4).
Figura 3.1.4. Plasarea fizică memoriilor BRAM şi a multiplicatorilor în FPGA-ul Spartan 3E[20].
Avantajul memoriei BRAM este că are din construcŃie două porturi de citire şi scriere,
din acest punct de vedere fiind cea mai bună alegere pentru formarea unei memorii video
tampon. În plus fiecare bloc de memorie este împărŃit în două porŃiuni: memorie de date şi
memorie de paritate. PorŃiunea de paritate poate păstra practic bitul de paritate calculat pentru
fiecare octet de date scris. În cazul în care nu se doreşte verificarea corectitudinii datelor, biŃii
de paritate fie pot fi lasaŃi neutilizaŃi, fie pot fi utilizaŃi ca biti de date (figura 3.1.6).
Folosirea unui modul de memorie BRAM presupune instanŃierea acestuia
corespunzătoare configuraŃiei dorite (tabelul 3.1.1).
Capitolul 3 - Analiza, proiectarea şi implementarea hardware a aplicaŃiei pentru FPGA
49
Tabelul 3.1.1. Modele de organizare a blocurilor BRAM şi instanŃierea corespunzătoare[20].
Port A
16Kx1 8Kx2 4Kx4 2Kx9 1Kx18 512x36
Port B
16Kx1 _S1_S1 8Kx2 _S1_S2 _S2_S2 4Kx4 _S1_S4 _S2_S4 _S4_S4 2Kx9 _S1_S9 _S2_S9 _S4_S9 _S9_S9 1Kx18 _S1_S18 _S2_S18 _S4_S18 _S9_S18 _S18_S18 512x36 _S1_S36 _S2_S36 _S4_S36 _S9_S36 _S18_S36 _S36_S36
Modulul de memorie pentru reŃinerea imaginii desenate (buffer video) trebuie să ofere
accesul concomitent la scriere şi citire pentru două module: modulul de generare a
primitivelor grafice şi modulul de afişare pe ecranul LCD. Datorită acestei particularităŃi am
ales să folosesc cele 20 de blocuri de memorie BRAM intergrate în FPGA-ul plăcii Nexys 2
folosind al treilea mod de utilizare al acestui tip de memorie (figura 3.1.5): pe portul A se
realizează scrierea, iar pe portul B se realizează citirea.
Figura 3.1.5. Moduri de utilizare a bloruilor BRAM[20].
Proiect de diplomă
50
Figura. 3.1.6. Modele de organizare a blocurilor de memorie BRAM[20].
Capitolul 3 - Analiza, proiectarea şi implementarea hardware a aplicaŃiei pentru FPGA
51
3.2. Proiectarea structurii hardware – Schema bloc
Conform premiselor stabilite în etapa de analiză a problemei am conceput următoarea
schemă bloc de principiu a structurii hardware pe care o voi implementa în FPGA:
Figura 3.2.1. Schema bloc a structurii hardware.
3.3. Proiectarea şi implementarea generatorului semnalelor de ceas
Reprezentat de modulul generator_ceas, acesta generează toate semnalele de ceas
necesare funcŃionării întregii structuri hardware după cum urmează (figura 3.3.1):
- Semnal de ceas cu frecvenŃa de 25 MHz – este necesar afişării sincronizate pe
modulul LCD, numit în continuare ceas de pixel; reprezentat de semnalul de ieşire
c25mhz.
- Semnal de ceas cu frecvenŃa de 64 KHz – este necesar generării semnalelor PWM
pentru controlul luminozităŃii luminii de fundal a LCD-ului; reprezentat de semnalul
de ieşire c64khz..
- Semnal de ceas cu frecvenŃa de 20 Hz – semnalul de ceas după care sunt interpretate
evenimentele apărute de la butoanele plăcii Nexys2; reprezentat de semnalul de ieşire
c20hz.
Controler Interfata RS-232
Controler Interfata
PS/2
Controler Mouse
Interpretor comenzi
Interpretor evenimente
mouse Selector Mod de lucru
Primitive Grafice
Buffer Video
Aplicare Efecte
Controler LCD
PC
Mouse LCD
COMUTATOR
Scanare Butoane
Butoane
Proiect de diplomă
52
Fiecare semnal de ceas este generat pe baza unui proces de numărare şi divizare a
semnalului de bază al sistemului (50 MHz).
Figura 3.3.1. Blocul de generare a semnalelor de ceas.
3.4. Scanarea stării butoanelor – modulul debouncer
Reglarea luminozităŃii ecranului LCD şi poziŃionarea imaginii watermark (imagine
suprapusă peste interfaŃa grafică afişată pe LCD) sunt realizate printr-o interfaŃă grafică de tip
OSD (on-screen display) controlată prin intermediul butoanelor prezente pe placa de
dezvoltare Nexys2.
Tabelul 3.4.1. Descrierea intrărilor şi ieşirilor blocului BUT_INT
Nume Tip DirecŃie SemnificaŃie
Clock Std_logic Intrare Semnalul de ceas Reset Std_logic Intrare Semnalul de reset asincron Buttons Std_logic_vector Intrări Semnale conectate la intrările
pentru butoane Sel Std_logic_vector Ieşire Semnalele indică evenimentul de
„apăsare buton” apărut.
Pentru a contracara efectele stărilor tranzitorii care apar la apăsarea unui buton am
implementat un modul debouncer care elimină aceste stări. Totodată pentru a elimina apariŃia
stărilor neconcludente la apăsarea a două sau mai multe butoane simultan am recurs la
prioritizarea evenimentelor (figura 3.4.1). Astfel dacă apare evenimentul „buton apăsat”
(definit prin stare intrării în „1” logic) la butonul cu prioritatea cea mai mare, atunci stările
celorlalte butoane sunt neglijate, iar ieşirea va primi valoarea corespunzătoare. În cazul în care
nu apare nici un eveniment de acest tip, pinii ieşirii vor fi setaŃi în „0” logic.
Capitolul 3 - Analiza, proiectarea şi implementarea hardware a aplicaŃiei pentru FPGA
53
Figura 3.4.1. Schema sintetizată a modulului de citire a stării butoanelor.
Principiul de funcŃionare a unui modul debouncer pentru o intrare cu stări tranzitorii este
următorul: este citită starea intrării, iar, dacă intrarea este validă (în acest caz, „buton apăsat”,
adică „1” logic), această valoare a intrării este trimisă către ieşire; apoi se aşteaptă o perioadă
de timp (în cazul de faŃă am ales 20 ms), după care ieşirea este resetată şi se realizează o nouă
citire. În cazul apariŃiei semnalului reset activ, procesul este reluat, contorul fiind reiniŃializat.
Tabelul 3.4.2. Descrierea intrărilor şi ieşirilor blocului DEBOUNCER
Nume Tip DirecŃie SemnificaŃie
Clock Std_logic Intrare Semnalul de ceas Reset Std_logic Intrare Semnalul de reset asincron B Std_logic Intrare Semnal conectat la intrarea
butonulul. Bev Std_logic Ieşire Semnalul de stare a butonului fără
perioade transzitorii.
3.5. Proiectarea şi implementarea memoriei video
Conform premiselor de proiectare stabilite, am implementat memoria video utilizând cele
20 de blocuri BRAM. Având în vedere faptul că modulul LCD suportă date de culoare
definite pe 18 biŃi am ales să configurez blocurile BRAM ca memorii 1024x(16+2) biŃi prin
instanŃierea RAMB16_S18_S18, folosind şi biŃii de paritate pe post de biŃi de date.
A rezultat un total de 360 KbiŃi pentru a reprezenta o imagine de 160 x 128 pixeli. Aşadar
fiecare bloc de memorie va avea 1024 de locaŃii a câte 18 biŃi ceea ce presupune o magistrală
de 10 biŃi pentru adresarea unui bloc pentru fiecare port al BRAM-ului. Fiindcă folosesc toate
cele 20 de blocuri de memori am nevoie de încă 5 linii de magistrală pentru a realiza
adresarea completă (�� � �� � ��).
Activarea unui anumit bloc de memorie este realizată pentru fiecare port cu ajutorul unui
demultiplexor 1:20, iar preluarea datelor de la un bloc de memorie este realizată cu ajutorul
unui multiplexor 20:1 de magistrale de 18 biŃi. Toate cele trei blocuri menŃionate au ca intrări
de selecŃie cele 5 linii adiŃionale ale magistralelor de adresare.
Proiect de diplomă
54
Tabelul 3.5.1. Descrierea intrărilor şi ieşirilor blocului VIDEO_MEM
Nume Tip DirecŃie SemnificaŃie
Clk_a Std_logic Intrare Semnalul de ceas după care se face scrierea pe portul A.
En_a Std_logic Intrare Semnalul de activare a scrierii pe portul A.
Adr_a Std_logic_vector Intrare Adresa de memorie la care este realizată scrierea pe portul A
Di_a Std_logic_vector Ieşire Datele scrise. Clk_b Std_logic Intrare Semnalul de ceas după care se
face citirea pe portul B. En_b Std_logic Intrare Semnalul de activare a citirii pe
portul A. Adr_b Std_logic_vector Intrare Adresa de memorie la care este
realizată citirea pe portul A Do_b Std_logic_vector Ieşire Datele citite.
Astfel implementată, memoria video include următoarele blocuri (figura 3.5.1) :
- Cele 20 de blocuri de memorie BRAM fiecare organizate sub forma a 1024x18biŃi.
- Două demultiplexoare pentru activarea blocurilor corespunzătoare pentru scriere,
respectiv citire.
- Un multiplexor (de magistrale, adică o serie de multiplexoare de acelaşi tip cu
intrările de selecŃie comune) pentru selecŃia datelor la ieşire (operaŃia de citire).
Figura 3.5.1. Schema bloc a memoriei video implementate.
DMUX 1:20
DMUX 1:20
MUX 18 x 20:1
BRAM
0
BRAM 1
BRAM 2
BRAM 19
10 10
20 20 5 5
18
360 18
A / "� A��*U"�U�15
A / +��
A�*"�"U�
15
SCRIERE CITIRE
18
5
18
��� ���
Capitolul 3 - Analiza, proiectarea şi implementarea hardware a aplicaŃiei pentru FPGA
55
3.6. Proiectarea şi implementarea controlerului LCD-ului
3.6.1. Sincronizarea
LCD-ul folosit are nevoie de un singur semnal de sincronizare de tip data-enable.
Modulul de sincronizare, sync_ctrl, are la bază două numărătoare, unul pentru orizontală,
desemnat de semnalul hc, iar celălalt pentru verticală, desemnat de semnalul vc.
În momentul în care valorile celor două semnale sunt mai mici decât valorile care
determină rezoluŃia ecranului (480 pixeli pe orizontală, respectiv 272 pixeli pe verticală),
semnalul de sincronizare de este activat. Similar modulului de sincronizare pentru un ecran cu
tub catodic cu interfaŃă VGA, există atât pe orizontală, cât şi pe verticală o perioadă de
aşteptare (perioadă de blank) în care nu sunt transmise date de culoare către LCD, iar
semnalul de sincronizare este dezactivat.
Tabelul 3.6.1.1. Descrierea intrărilor şi ieşirilor blocului SYNC_CTRL
Nume Tip DirecŃie SemnificaŃie Clock Std_logic Intrare Ceasul de pixel 25 MHz. Reset Std_logic Intrare Semnalul de reset asincron. De Std_logic Ieşire Semnalul de sincronizare a
afişării pe LCD. Ho Std_logic_vector Ieşiri Contorul poziŃiei curente pe
orizontală. Vo Std_logic_vector Ieşiri Contorul poziŃiei curente pe
verticală.
Acest modulul lucreză sincron cu ceasul de pixel de 25 MHz furnizat de generatorul de
semnale de ceas. La fiecare front crescător al ceasului contorul pe orizontală este incrementat.
Dacă acest contor atinge valoarea 599 (adică s-a realizat desenarea unei linii şi s-a aşteptat
perioada de blank pe orizontală), el va fi resetat la valoare 0 şi va fi incrementat contorul pe
verticală trecând la o nouă linie. Similar în momentul în care contorul pe verticală atinge
valoare maximă specificat, 522, acesta va fi resetat reluând întregul proces.
Am realizat modulul astfel încât să furnizeze la ieşire şi valorile celor două contoare,
fiind necesare în modulele de generare a interfeŃei şi de accesare a memoriei (figura 3.6.1.1).
Proiect de diplomă
56
Figura 3.6.1.1. Modulul de generare a semnalului de sincronizare.
3.6.2. Preluarea datelor din memoria video
Pentru a prelua imaginea generată în memoria BRAM am realizat un modul de acces
direct la memorie (modul DMA). Acest modul va genera funcŃie de valoarea contorilor
generaŃi de modulul de sincronizare adresa corespunzătoare şi va activa citirea din memorie
(figura 3.6.2.1).
Figura 3.6.2.1. Modulul DMA.
Generarea adresei este realizată în doi paşi: generez coordonatele de afişare � �� în
interiorul chenarului, apoi generez adresa de memorie corespuzătoare acestor coordonate.
Pentru a realiza dublarea pixelilor am generat adresa funcŃie de jumătatea valorii
coordonatelor.
Tabelul 3.6.2.1. Descrierea intrărilor şi ieşirilor blocului DMA_INT
Nume Tip DirecŃie SemnificaŃie Clock Std_logic Intrare Ceasul de pixel 25 MHz. Reset Std_logic Intrare Semnalul de reset asincron. H Std_logic_vector Intrări Contorul poziŃiei curente pe
orizontală. V Std_logic_vector Intrări Contorul poziŃiei curente pe
verticală. Addr Std_logic_vector Ieşiri Adresa de memorie generată. Enable Std_logic Ieşiri Semnalul de activare a citirii.
Capitolul 3 - Analiza, proiectarea şi implementarea hardware a aplicaŃiei pentru FPGA
57
Adresa unei locaŃii de memorie este generată corform formulei: A� � � � ��� �
Valoarea ��� reprezintă numărul de pixeli ai unei linii a imaginii (în acest caz 160).
Pentru a evita folosirea operaŃiei de înmulŃire care presupune apariŃia întârzierilor de calcul,
am rescris valoare ��� sub forma unei sume de puteri ale lui 2 şi anume: ��� � �e� � ��j� 6� � �� � ��
Prin urmare formula de calcul a adresei a devinit: A� � � � �� � � � �� � � � � k� � � � G� �
OperaŃile de deplasare la stânga se traduc în limbajul VHDL ca simple concatenări la
dreapta ale valorii lui y repezentată ca vector de biŃi cu un vector de biŃi „0” de lungime 7,
respectiv 5. Astfel generarea adresei este realizată prin operaŃii simple ale căror rezultate apar
în perioada unui singur semnal de ceas. De precizat faptul că şi acest modul lucrează sincron
cu semnalul de ceasului de pixel.
addr<=(py(8 downto 1)&"0000000")+(py(8 downto 1)&"00000")+px(8 downto 1);
Pentru a preîntâmpina întârzierile datorate parcurgerii pipeline-ului de procesare al
filtrelor punctuale, am recurs la generarea în avans a adreselor. Astfel generarea adreselor
începe cu 5 semnale de ceas înainte de fi preluate datele de către modulul de generare a
interfeŃei grafice. Valoarea respectivă am stabilit-o empiric prin verificări succesive ale
rezultatului.
3.6.3. Generarea interfeŃei grafice
Modulul de generare a interfeŃei grafice lucrează sincron cu ceasul de pixel şi generează
nuanŃei de culori funcŃie de valorile contorilor primite de la modulul de sincronizare.
Pictogramele afişate sunt preluate din constante de tip matrice de biŃi. Matricile de biŃi au
număr de coloane multiplu de 4 pentru a fi reprezentate restrâns în hexazecimal. Constantele
de tip matrice implementează practic memorii de tip ROM (read-only memory) în interiorul
circuitului FPGA.
Proiect de diplomă
58
Tabelul 3.6.3.1. Descrierea intrărilor şi ieşirilor blocului GRAFIC_INT
Nume Tip DirecŃie SemnificaŃie
Clock Std_logic Intrare Ceasul de pixel 25 MHz. Reset Std_logic Intrare Semnalul de reset asincron. H Std_logic_vector Intrări Contorul poziŃiei curente pe
orizontală. V Std_logic_vector Intrări Contorul poziŃiei curente pe
verticală. Ri, Gi, Bi Std_logic_vector Intrări Culoarea citită din memorie. Rc, Gc, Bc Std_logic_vector Intrări Culoarea curentă de desenare. Bv Std_logic_vector Intrări Nivelul de luminozitate al
imaginii. Cv Std_logic_vector Intrări Nivelul contrastului imaginii. Sv Std_logic_vector Intrări Nivelul saturaŃiei imaginii. Ro, Go, Bo Std_logic_vector Ieşiri Culoarea generată la ieşire.
În momentul parcurgerii unei zone determinate de o pictogramă, valoarea „1” logic
regăsită în matrice la poziŃia corespuzătoare va determina afişarea unui pixel de o anumită
culoare; în cazul în care bitul este „0” pixelul respectiv va fi negru. Pentru a diminua
dimensiunea ROM-urilor sintetizate în FPGA am recurs la dublarea dimensiunii de afişare a
pictogramelor (figura 3.6.3.1).
Figura 3.6.3.1. InterfaŃa grafică generată pe ecranu LCD.
3.6.4. InterfaŃa grafică OSD de control a LCD-ului
Pentru vizualizarea şi modificarea valorii intensităŃii luminii de fundal a LCD-ului am
realizat o interfaŃă grafică de tip OSD (on-screen display) care, la apăsarea unui buton al
plăcii Nexys2, apare suprapusă peste interfaŃa grafică actuală (figura 3.6.4.1).
AdiŃional acestor funcŃii am realizat în acest modul şi afişarea unei imagini de tip
watermark, adică o imagine suprapusă totdeauna interfeŃei grafice.
Capitolul 3 - Analiza, proiectarea şi implementarea hardware a aplicaŃiei pentru FPGA
59
Modulul este constituit din 4 procese şi două submodule. Submodulele sunt implementări
de memorii ROM similare celor pentru pictogramele folosite în generarea interfeŃei grafice.
Memoria ROM semnatura conŃine imaginea monocrom a numelui, iar memoria upit_pic
conŃine sigla universităŃii reprezentată printr-o imagine monocrom.
Primul proces interpretează semnalele primite de la modulul de citire a stării butoanelor.
Corespunzător valorii acestor semnale sunt setate opŃiunea curentă, reprezentată prin semnalul
opt, respectiv direcŃia de modificare a parametrilor (incrementare sau decrementare)
reprezentată prin semnalul dir (figura 3.6.4.2).
Figura 3.6.4.2. Organigrama de funcŃionare a primului proces.
Al doilea proces realizează setarea parametrului indicat de semnalul opt şi testarea
atingerii limitelor inferioară şi superioară. De precizat faptul că atât poziŃia interfeŃei OSD
(semnalele ox, oy), cât şi poziŃia imaginii watermark (semnalele pic_x, pic_y) pot fi
modificate.
Figura 3.6.4.1. InterfaŃa OSD şi watermark-ul.
Proiect de diplomă
60
Al treilea proces generează efectiv interfaŃa OSD în momentul în care este activă şi
imaginea watermark. InterfaŃa OSD este constituită din două zone: meniul care afişează
valorile curente ale parametrilor şi a cărui poziŃii poate fi modificată şi zona de afişare a
numelui şi prenumelui. Imaginea watermark am generat-o prin setarea culorii pixelilor activi
(locaŃia din matrice este „1” logic) cu valoarea negată a culorii pixelilor corespuzători ai
interfeŃei grafice furnizate de modulul grafic_int, practic afişarea negativului imaginii de
fundal.
InterfaŃa OSD este afişată pe ecran atât timp cât este apăsat un buton, apoi dispărând după
5 secunde de la eliberarea butonului. Temporizarea este realizată de al patrulea pronces prin
care am implementat un numărător cu resetare. În momentul în care un buton este apăsat,
numărătorul este resetat şi semnalul de activare a afişării interfeŃei OSD este activat. La
eliberarea butonului, numărătorul devine activ. În momentul atingerii limitei, numărătorul
rămâne blocat, iar interfaŃa OSD este dezactivată prin setarea semnalului de activare în „0”
logic (figura 3.6.4.3).
Figura 3.6.4.3. Organigrama de funcŃionare a ultimului proces.
Capitolul 3 - Analiza, proiectarea şi implementarea hardware a aplicaŃiei pentru FPGA
61
Tabelul 3.6.4.1. Descrierea intrărilor şi ieşirilor blocului LCD_OSD
Nume Tip DirecŃie SemnificaŃie
Clock Std_logic Intrare Ceasul de pixel 25 MHz. C20 Std_logic Intrare Ceasulde 20 Hz pentru procesul
de interpretare a evenimentelor butoanelor.
Reset Std_logic Intrare Semnalul de reset asincron. H Std_logic_vector Intrări Contorul poziŃiei curente pe
orizontală. V Std_logic_vector Intrări Contorul poziŃiei curente pe
verticală. Ri, Gi, Bi Std_logic_vector Intrări Culoarea generată de modulul de
grafic_int. Ro, Go, Bo Std_logic_vector Ieşiri Culoarea generată la ieşire. V_l Std_logic_vector Ieşiri Nivelul luminozitate al LCD-ului.
3.6.5. Generarea semnalului PWM pentru controlul luminozităŃii LCD-ului
LCD-ul utilizat suportă controlul intensităŃii luminii de fundal printr-un singur pin de
intrare prin generarea unui semnal modulat în lăŃime de puls (PWM – pulse width
modulation).
Tabelul 3.6.5.1. Descrierea intrărilor şi ieşirilor blocului LIGHT_CTRL
Nume Tip DirecŃie SemnificaŃie Clock Std_logic Intrare Ceasul de pixel 25 MHz. Reset Std_logic Intrare Semnalul de reset asincron. Load Std_logic_vector Intrări Nivelul luminozităŃii LCD-ului. Pwm_out Std_logic Intrări Semnalul PWM generat.
Am implementat un modul de generare a semnalului PWM care are la bază un numărător
desemnat de semnalul cnt şi primul proces din interiorul modulului. Al doilea proces
realizează generarea efectivă a impulsurilor PWM corform următoarei logici: dacă valoarea
contorului este mai mică decât valoarea parametrului de intrare, atunci semnalul PWM va fi
setat în „1” logic; în caz contrar, acesta va fi setat în „0” logic (figura 3.6.6.1).
Modulul implementat lucrează sincron cu ceasul de 64KHz. Aşadar fiecare porŃiune de
semnal PWM se repetă cu frecvenŃa de 1KHz dat fiind faptul că sunt generate 64 de nivele de
luminozitate.
Proiect de diplomă
62
Figura 3.6.5.1. Schema sintetizată a circuitului.
3.7. Modulul de modificare a parametrilor în funcŃie de evenimentele
mouse-ului
Evenimentele mouse-ului (apăsare butoane, deplasare pe axa x, deplasare pe axa y) sunt
preluate de la modulul de control al mouse-ului oferit de firma producătoare a plăcii Nexys2
împreună cu modulul de control al interfeŃei PS/2.
Tabelul 3.6.7.1. Descrierea intrărilor şi ieşirilor blocului INTERPRETOR_MOUSE
Nume Tip DirecŃie SemnificaŃie Clock Std_logic Intrare Ceasul de pixel 25 MHz. Reset Std_logic Intrare Semnalul de reset asincron. Mx, My Std_logic_vector Intrări Coordonatele cursorului mouse. M_lmr Std_logic_vector Intrări Stările butoanelor mouse-ului. Tp Std_logic_vector Ieşiri Tipul primitivei grafice alese. X0, Y0 Std_logic_vector Ieşiri Coordonatele primului punct setat X1, Y1 Std_logic_vector Ieşiri Coordonatele celui de-al doilea
punct setat. Rz Std_logic_vector Ieşiri Raza calculată – distanŃa între
cele două puncte. Rv, Gv, Bv Std_logic_vector Ieşiri Componentele culorii de desenare
setate. Vb Std_logic_vector Ieşiri Nivelul de luminozitate a
imaginii. Vc Std_logic_vector Ieşiri Nivelul contrastului imaginii. Vs Std_logic_vector Ieşiri Nivelul saturaŃiei imaginii.
Date fiind necesităŃile aplicaŃiei pentru microsistem am modificat modulul de control al
mouse-ului, eliminând atât intrările, cât şi secvenŃele de instrucŃiuni necesare pentru setarea
Capitolul 3 - Analiza, proiectarea şi implementarea hardware a aplicaŃiei pentru FPGA
63
rezoluŃiei, scalării, poziŃiei curente a cursorului şi a ariei maxime în care poate fi deplasat
cursorul, setând aria maximă încă de la iniŃializare ca fiind aria ecranului LCD, 480x272
pixeli.
Modulul de modificare a parametrilor funcŃie de evenimentele mouse-ului este utilizat în
momentul în care aplicaŃia funcŃionează în modul de sine stătător, adică atunci când
microsistemul nu este conectat la PC. Acest modul are două funcŃii: pe de o parte
interpretarea evenimentelor mouse-ului care apar, iar pe de altă parte, setarea parametrilor
(practic a ieşirilor) funcŃie de aceste eveniment, dar şi iniŃializarea lor în momentul pornirii
microsistemul sau în momentul în care apare un semnal reset activ (figura 3.7.1).
Figura. 3.7.1. Modulul de interpretare a evenimentelor mouse-ului.
FuncŃie de poziŃia cursorului şi starea butoanelor mouse-ului preluate de la modulul de
control al mouse-ului se decide parametrul care va fi modificat şi cuantumul acestei
actualizări. Am definit în interfaŃa grafică suprafeŃe active indicate pe ecran sub forma unor
pictograme sau a unor bări de derulare.
Există două evenimente ale mouse-ului tratate în momentul în care cursorul se află pe una
dintre aceste suprafeŃe active: dacă s-a apăsat butonul din stânga al mouse-ului („click
stânga”), respectiv dacă s-a apăsat butonul din dreapta al mouse-ului („click dreapta”). Ca şi
în cazul preluării stării butoanelor de pe placa Nexys2, am optat la prioritizarea
evenimentelor. Aşadar, am ales ca eveniment prioritar „click stânga”.
Proiect de diplomă
64
Pentru evenimentul „click stânga”, în cazul în care apare în momentul în care cursorul se
află pe una dintre pictograme biŃii variabilei care indică primitiva grafică vor fi setaŃi
corespunzător selecŃiei făcute.
3.8. Selectorul modului de funcŃionare
Sistemul hardware va avea două moduri de funcŃionare: de sine stătător, respectiv
conectat la calculator. Practic funcŃionalitatea de bază nu se schimbă, doar sursa comenzilor.
Dat fiind faptul că intrările de comenzi sunt identice pentru ambele moduri de funcŃionare, am
implementat selectorul folosind o serie de multiplexoare 2:1, obŃinând un multiplexor de
magistrale.
Tabelul 3.6.8.1. Descrierea intrărilor şi ieşirilor blocului MUX_MOD
Nume Tip DirecŃie SemnificaŃie
Sel Std_logic Intrare Semnal de selecŃie. Tpm0, Tpm1, Tp Std_logic_vector Ieşiri Tipul primitivei grafice alese. (X0m0, Y0m0), (X0m1, Y0m1), (X0, Y0)
Std_logic_vector Ieşiri Coordonatele primului punct setat
(X1m0, Y1m0), (X1m1, Y1m1), (X1, Y1)
Std_logic_vector Ieşiri Coordonatele celui de-al doilea punct setat.
Rzm0, Rzm1, Rz Std_logic_vector Ieşiri Raza calculată – distanŃa între cele două puncte.
(Rvm0, Gvm0, Bvm0) (Rvm1, Gvm1, Bvm1) (Rv, Gv, Bv)
Std_logic_vector Ieşiri Componentele culorii de desenare setate.
Vbm0, Vbm1, Vb Std_logic_vector Ieşiri Nivelul de luminozitate a imaginii.
Vcm0,Vcm1, Vc Std_logic_vector Ieşiri Nivelul contrastului imaginii. Vsm0, Vsm1, Vs Std_logic_vector Ieşiri Nivelul saturaŃiei imaginii.
Intrarea de selecŃie comună pentru toate multiplexoarele implementate este concatată la
un comutator al plăcii Nexys2 (figura 3.8.1).
Capitolul 3 - Analiza, proiectarea şi implementarea hardware a aplicaŃiei pentru FPGA
65
Figura 3.8.1. SelecŃia modului de lucru.
3.9. Generarea primitivelor grafice
În modulul de generare a primitivelor grafice am realizat implementarea algoritmilor
propuşi de Josh Bressenham sub forma unui automat cu stări finite. În fiecare stare a FSM-
ului sunt realizate secvenŃe de operaŃii corespunzătoare etapelor algoritmilor.
Implementarea acestui automat cu stări finite a pornit de la premisa că o primitivă grafică
mai complexă poate fi generată dintr-o mulŃime de primitive grafice mai simple. Aşadar am
considerat următoarele:
- Linia, cercul şi elipsa sunt mulŃimi de puncte.
- Dreptunghiul este format din 4 linii.
- Cercul colorat şi elipsa colorată sunt mulŃimi de linii.
Fiecare algoritm l-am implementat sub forma unor succesiuni de stări de tipul:
iniŃializare, calcul, aşteptare, desenare. Stările de aşteptare apar în cazul generării elipselor
datorită înmulŃirilor care apar în calculul de iniŃializare şi care necesită întârzieri ale
procesului de generare (figura 3.9.1).
Interpretor comenzi
de la PC
Interpretor evenimente mouse
Comutator
Selector Mod de lucru
N x MUX2:1
Proiect de diplomă
66
Figura 3.9.1. Diagrama de stări a automatului care descrie algoritmii de generare a primitivelor grafice.
Datorită faptului că linia este folosită şi pentru generarea altor primitive grafice, am
împărŃit starea de iniŃializare în două: în prima stare de iniŃializare se asignează valorile celor
două puncte car definesc capetele liniei, iar în cea de-a doua stare sunt calculate valorile
iniŃiale ale variabilelor necesare în procesul de generare. Astfel algoritmul de generare a liniei
este reprezentat de 3 stări: line_init0_st, line_init1_st şi line_calc_st. În ultima stare
Capitolul 3 - Analiza, proiectarea şi implementarea hardware a aplicaŃiei pentru FPGA
67
menŃionată sunt calculate coordonatele următorului punct şi este decisă continuarea sau nu a
algoritmului.
Generarea dreptunghiului este reprezentată de două stări: drept_init_st, drept_calc_st. În
starea de iniŃializare este setat contorul numărului de linii rămase de generat. În starea
drept_calc_st este realizată iniŃializarea capetelor liniei curente.
Generarea dreptunghiului plin este reprezentată de două stări: bara_init_st şi
bara_calc_st. În prima stare sunt iniŃializate punctele care definesc aria de desenare. În a doua
stare este realizată parcurgerea ariei respective.
Tabelul 3.9.1. Descrierea intrărilor şi ieşirilor blocului PRIMITIVE_GRAFICE
Nume Tip DirecŃie SemnificaŃie Clock Std_logic Intrare Ceasul de pixel 25 MHz. Reset Std_logic Intrare Semnalul de reset asincron. X0, Y0 Std_logic_vector Intrări Coordonatele primului punct. X1, Y1 Std_logic_vector Intrări Coordonatele celui de-al doilea
punct. Raza Std_logic_vector Intrări Raza calculată. Mem_en Std_logic_vector Ieşire Activarea scrierii locaŃiei de
memorie. Mem_addr Std_logic_vector Ieşiri Adresa de memorie la care se
realizează scrierea.
Generarea cercului este reprezentată de trei stări ale FSM-ului: cerc_init_st, cerc_draw_st
şi cerc_calc_st. În starea cerc_init_st fie sunt iniŃializate variabilele necesare algoritmului de
generare a cercului, fie este iniŃializată desenare unui punct în cazul în care raza calculată este
egală cu 0. Starea cerc_draw_st determină generarea celor 8 puncte generate la fiecare iteraŃie
a algoritmului. În ultima stare se calculează coordonatele următorului punct al octanului
principal.
Pentru generarea elipsei am implementat o versiune optimizată a algoritmului care
relaizează generarea punctelor printr-o singură parcurgere[3]. Practic la fiecare iteraŃie a
algoritmului sunt generate două puncte în primul cadran. Generarea elipsei este reprezentată
de următoarele stări ale automatului: elip_init0_st, elip_draw0_st, elip_wait1_st, elip_init1_st,
elip_wait2_st, elip_init2_st, elip_draw1_st şi elip_calc_st.
A fost necesară segmentarea stării de iniŃializare datorită operaŃilor de înmulŃire care apar
în calcule. Astfel după iniŃializarea unui set de variabile necesare algoritmului şi iniŃierea
operaŃilor de calcul a patratelor razelor (rx2, ry2) este necesară trecerea într-o stare de
aşteptare , elip_wait1_st, până la finalizarea operaŃilor de înmulŃire. Totodată după această
Proiect de diplomă
68
primă etapă de iniŃializare se vor genera primele două puncte ale elipsei, etapă definită de
stare elip_draw0_st, de aceea am inserat acestă stare în trecerea de la starea elip_init0_st la
elip_wait1_st.
Starea elip_init1_st reprezintă o a doua etapă a iniŃializării în care sunt calculate dublul
valorilor pătratelor razelor şi valoarea iniŃială a eroarii. ApariŃia unei operaŃii de înmulŃire în
calcul determină necesitatea trecerii într-o două stare de aşteptare, elip_wait2_st.
Starea elip_init2_st finalizează iniŃilizarea prin calculul valorii iniŃiale a variabilei xdif.
După finalizarea acestei stări se trece la calcularea şi generarea efectivă a punctelor elipsei. În
stare elip_calc_st este realizat calculul coordonatelor, urmând ca în starea elip_draw_st să fie
generate punctele conforn axelor de simetrie.
Tabelul 3.9.1. Codarea stărilor automatului implementat.
Nume stare Abreviere
în diagramă Codificare
binară SemnificaŃie
nop_st NOP 00000
Starea de aşteptare în care nu se execută operaŃii şi se testează valoarea intrării tp pentru luarea deciziei de trecere în altă stare corespunzătoare.
pixel_init_st PI 00001 IniŃializarea coordonatelor punctului.
pixel_draw_st PD 00010 Desenarea punctului.
line_init0_st LI0 00011 IniŃializarea coordonatelor capetelor liniei.
line_init1_st LI1 00100 IniŃializara variabilelor necesare algoritmulului de generare a liniei.
line_draw_st LD 00101 Generarea efectivă a punctelor liniei.
drept_init_st DI 00110 IniŃializarea coordonatelor punctelor care definesc dreptunghiul.
drept_draw_st DD 00111 Generarea dreptunghiului cu ajutorul a 4 linii.
cerc_init_st CI 01000 IniŃializarea variabilelor necesare algoritmului de generare a cercului.
cerc_draw_st CD 01001 Generarea celor 8 puncte sau 4 linii pentru fiecare iteraŃie a algoritmului.
cerc_calc_st CC 01010 Calculul coordonatelor următorului punct din primul octan al cercului.
elip_init0_st EI0 01011 Prima fază de iniŃializare.
elip_draw0_st ED0 01100 Generarea primelor două puncte ale elipsei sau a liniei mediane a elipsoidului.
elip_wait1_st EW1 01101 Prima stare de aşteptare.
elip_init1_st EI1 01110 A doua fază a iniŃializării.
elip_wait2_st EW2 01111 A doua stare de aşteptare.
elip_init2_st EI2 10000 Ultima fază a iniŃializării.
elip_draw1_st ED1 10001 Desenarea celor 4 punte sau 2 linii pentru fiecare iteraŃie a algoritmului.
elip_calc_st EC 10010 Calculul următoarelor coordonate.
bara_init_st BI 10011 IniŃializarea coordonatelor punctelor ce definesc aria.
bara_draw_st BC 10100 Generarea dreptunghiului colorat.
Capitolul 3 - Analiza, proiectarea şi implementarea hardware a aplicaŃiei pentru FPGA
69
3.10. Procesarea imaginii în timp real
Modulul de procesare a imaginii l-am implementat sub forma unui pipeline de trei filtre
punctuale (figura 3.10.1). După încărcarea pipeline-ului (după primele trei semnale de ceas)
modulul va procesa în paralel informaŃia de culoare a trei pixeli.
Figura 3.10.1. Pipeline-ul de procesare a semnalului RGB.
Filtrele punctuale le-am implementat în submodule cu o structură similară: sunt realizate
preluarile datelor de intrare şi calculele iniŃiale, apoi modificarea proporŃională cu parametru
de intrare (operaŃie de înmulŃire), finalizând cu prelucrarea datelor obŃinute în urma înmulŃirii
şi transmiterea lor la ieşire către blocul următor.
Tabelul 3.10.1. Descrierea intrărilor şi ieşirilor blocului EFECTE
Nume Tip DirecŃie SemnificaŃie
Clock Std_logic Intrare Ceasul de pixel 25 MHz. Reset Std_logic Intrare Semnalul de reset asincron. Bv Std_logic_vector Intrări Nivelul de luminozitate al
imaginii. Cv Std_logic_vector Intrări Nivelul contrastului imaginii. Sv Std_logic_vector Intrări Nivelul saturaŃiei imaginii. (Ri, Gi, Bi) Std_logic_vector Intrări Componentele culorii neprocesate
a pixelului. (Ro, Go, Bo) Std_logic_vector Ieşiri Componentele culorii procesate a
pixelului.
Fiecare filtru este descris secvenŃial printr-un proces. În proces datele parcurg trei faze
până la obŃinerea rezultatelor finale. La primirea valorilor componentelor cromatice pentru
fiecare pixel şi a valorii parametrului filtrului, aceste date sunt pregătite pentru procesare
(calculul diferenŃelor cromatice fată de componentele cromatice ale culorilor de referinŃă,
normalizarea valorii parametrului). Apoi datele sunt procesate (calcularea noilor valori
Control luminozitate
Control contrast
Control saturaŃie
Nivel luminozitate
Nivel contrast
Nivel saturaŃie
18
l� K�"�� 18 18 18
Proiect de diplomă
70
proporŃional cu valoarea parametrului). În final datele sunt readuse în intervalul de bază [0,
63] (figura 3.10.2).
Figura 3.10.2. Logica generală de procesare a fiecarui filtru.
După cum am menŃionat, filtrele presupun modificarea valorilor celor trei componente
ale culorii reprezentate pe 18 biŃi. Pentru a diminua numărul de multiplicatoare utilizate per
filtru am concatenat informaŃia de culoare cu spaŃieri formate din biŃi de „0” realizând
înmulŃirea simultan pentru cele valori ale componentelor de culoare.
drgb := db & "00000" & dg & "00000" & dr;
p := drgb * c;
Astfel am redus utilizarea în sinteză a multiplicatoarelor de la 6, la 2 per submodul,
totodată reducând şi timpul de procesare fiindcă după cum am mai menŃionat fiecare operaŃie
de înmulŃire presupune o întârziere întârziere cu 4 semnale de ceas a datelor de ieşire obŃinute.
Folosind o implementare de tip pipeline şi gruparea operaŃilor de înmulŃire am obŃinut o
întârziere totală a datelor prin structura de procesare de 6 semnale de ceas (figura 3.10.2).
Figura 3.10.2. Reducerea timpului de procesare prin structuri de tip pipeline.
Timp procesare secvenŃială
DI DO
DI DO
DI DO
DI DI
DI
DO
DO
DO
Timp procesare pipeline
FILTRU PUNCTUAL
Pregătirea datelor pentru
procesare
Procesarea funcŃie de parametru
Readucerea valorilor în
domeniul de bază
Faza 1 Faza 2 Faza 3
RGB intrare
RGB ieşire
Capitolul 3 - Analiza, proiectarea şi implementarea hardware a aplicaŃiei pentru FPGA
71
3.11. Controlul interfeŃei RS-232 - comunicaŃia cu PC-ul
Modulul de comunicaŃie UART RS-232 este oferit gratuit de firma producătoare Digilent
a plăcii Nexys2. Modulul oferă o comunicaŃie bidirecŃională pe portul serial RS-232 al plăcii,
cât şi posibilitatea setării vitezei de tranfer şi al parităŃii utilizate. De interes sunt semnalele de
ieşire dbout şi rda necesare preluării datelor primite pe portul serial (figura 3.11.1).
Figura 3.11.1. Modulul de comunicaŃie RS-232.
Comenzile primite de la aplicaŃia software sunt reprezentate sub forma unor şiruri de
octeŃi. Pentru interpretarea comenzilor am implementat modulul interpretor_comenzi. În
momentul recepŃiei unui octet (semnalul rda activ), modulul verifică validitatea acestuia: în
cazul în care este primul octet din comandă se verifică dacă acesta reprezintă o comandă
validă conform tabelului 3.11.2. Dacă acesta reprezintă o comandă se aşteaptă primirea
parametrilor, în caz contrar fiind neglijat.
La primirea fiecărui parametru este actualizată ieşirea corespunzătoare. În cazul
comenzilor de desenare, tipul primitivei alese este actualizat după primirea tuturor
parametrilor pentru că setarea tipului presupune totodată şi activarea desenării acesteia.
În cazul recepŃionării unui număr incorect de parametri şi neefectuării comezii, modulul
are implementată o logică de reset asincron pentru revenirea la starea iniŃială a contorilor
interni.
Proiect de diplomă
72
Tabelul 3.6.11.1. Descrierea intrărilor şi ieşirilor blocului INTERPRETOR_MOUSE
Nume Tip DirecŃie SemnificaŃie
Clock Std_logic Intrare Ceasul de pixel 25 MHz. Reset Std_logic Intrare Semnalul de reset asincron. D_in Std_logic_vector Intrări Datele recepŃionate. D_stb Std_logic Intrări Indicator date recepŃionate. rdSig Std_logic Ieşire Necesare iniŃierii citirii, respectiv
scrierii pe portul RS-232 wrSig Std_logic Ieşire Tp Std_logic_vector Ieşiri Tipul primitivei grafice alese. X0, Y0 Std_logic_vector Ieşiri Coordonatele primului punct setat X1, Y1 Std_logic_vector Ieşiri Coordonatele celui de-al doilea
punct setat. Rz Std_logic_vector Ieşiri Raza calculată – distanŃa între
cele două puncte. Rv, Gv, Bv Std_logic_vector Ieşiri Componentele culorii de desenare
setate. Vb Std_logic_vector Ieşiri Nivelul de luminozitate a
imaginii. Vc Std_logic_vector Ieşiri Nivelul contrastului imaginii. Vs Std_logic_vector Ieşiri Nivelul saturaŃiei imaginii.
Tabelul 3.11.2. Codificarea comenzilor transmise pe portul serial.
Nume comandă Octet transmis (haxazecimal)
Număr parametri SemnificaŃie
Desenare punct 08h 2 � �� - - Desenare linie 09h 4 � �� � �� Desenare dreptunghi 0Ah 4 � �� � �� Desenare cerc 0Bh 3 � �� raza - Desenare elipsă 0Ch 4 � �� � �� Desenare dreptunghi colorat
0Dh 4 � �� � ��
Desenare cerc colorat 0Eh 3 � �� raza - Desenare elipsă colorată
0Fh 4 � �� � ��
Setare valoare componentă cromatică R
10h 1 R - - -
Setare valoare componentă cromatică G
11h 1 G - - -
Setare valoare componentă cromatică B
12h 1 B - - -
Setare parametru luminozitate
13h 1 L - - -
Setare parametru contrast
14h 1 C - - -
Setare parametru saturaŃie
15h 1 S - - -
Capitolul 3 - Analiza, proiectarea şi implementarea hardware a aplicaŃiei pentru FPGA
73
3.12. Modulul principal – schema sintetizată a structurii
Modulul principal este descris structural şi conŃine toate submodulele prezentate anterior
şi semnalele de legătură aferente (figura 3.12.1).
Figura 3.12.1. Schema RTL sintetizată a structurii descrise de modulele implementate.
Proiect de diplomă
74
4. Analiza, proiectarea şi implementarea aplicaŃiei software
pentru PC
4.1. Premise de proiectare – Analiza problemei
AplicaŃia software pentru calculator trebuie să ofere următoarele funcŃionalităŃi
utilizatorului:
- O interfaŃă deductibilă şi uşor de utilizat.
- Realizarea tuturor primitivelor şi a filtrelor implementate în microsistem.
- Detectare şi accesul la o interfaŃă serială RS-232 a calculatorului.
- Generarea şi trimiterea comenzilor către microsistem.
Pentru realizarea unei comparări a rezultatelor primitivelor grafice implementate în
microsistem cu rezultate preexistente, am decis să nu folosesc funcŃile predefinite ale
mediului de programare pentr desenare, ci să implementez algoritmi similari cu cei
implementaŃi în microsistem. Dorind să simulez prin aplicaŃia software pe calculator o mare
parte din funcŃionalitatea microsistemului, am hotărât să implementez şi filtrele punctuale ca
funcŃii.
4.2. Proiectare – Structurarea pe clase
Structurarea pe clase a aplicaŃiei am stabilit-o în strânsă legătură cu premisele de
proiectare, dar şi cu nivelul de utilitate şi respectarea unor principii de programare orientată pe
obiecte, cum ar fi: protejarea variabilelor interne ale unei clase la accesul direct din altă clasa
prin blocarea acestuia şi folosirea unui acces indirect prin proceduri şi funcŃii speciale numite
seter, respectiv geter.
Am organizat aplicaŃia în următoarele clase (figura 3.2.1.2.1):
- Clasa InterfaŃă – această clasă derivată din clasa Form conŃine practic toate
variabilele şi metodele necesare interfeŃei grafice şi interfeŃei cu portul RS-232.
- Clasa MatriceCulori – clasa simulează comportamentul unui buffer video salvat ca o
variabilă matrice de culori.
- Clasa PrimitiveGrafice – în interiorul acestei clase sunt implementate toate metodele
pentru desenarea primitivelor grafice.
Capitolul 4 - Analiza, proiectarea şi implementarea aplicaŃiei software pentru PC
75
- Clasa Efecte – clasa poate fi considerată ca un container pentr metodele filtrelor
punctuale implementate; am construit această clasă doar din considerente de o mai
bună organizare şi separare a funcŃionalităŃii codului sursă.
Figura 4.2.1. Diagrama UML de principiu a claselor aplicaŃiei şi relaŃiile funcŃionale dintre acestea.
4.3. Proiectare – InterfaŃa grafică
După cum am menŃionat, am dorit ca aplicaŃia software să copieze funcŃionalitatea
aplicaŃiei implementate pe microsistem. Aşadar am încercat să proiectez o interfaŃă grafică
similară cu cea afişată pe ecranul LCD al microsistemului.
Am considerat că sunt necesare următoarele zone în interfaŃa grafică (figura 4.3.1):
a. Zona de selectare a primitivei grafice.
b. Zona de afişare a imaginii rezultate.
c. Zona indicatorilor coordonatelor.
d. Zona de modificareşi afişare a parametrilor.
e. Zona de selectare a portului serial.
Clasa InterfaŃă
Componente de interfaŃă Componente de comunicaŃie serială Metode de tratare a evenimentelor
Clasa Matrice
Metode de setare Metode de preluare
Clasa Efecte
Luminozitate Constrast SaturaŃie
Clasa PrimitiveGrafice
Metode de setare Metode de preluare Metode de generare a primitivelor grafice
Proiect de diplomă
76
Figura 4.3.1. Schemă sumară a interfeŃei grafice.
4.4. Premise de implementare
Luând în considerare necesităŃile aplicaŃiei software am hotărât să o implementez cu
ajutorul mediului de programare Microsoft Visual C# Express Edition folosind Framework-ul
.NET 2.0.
În urma studiului bibliografic am constatat că numai framework-urile .NET 2.0 şi
superioare suportă un acces simplificat la porturile calculatorului.
Implementarea aplicaŃiei a decurs în mai mulŃi paşi, pornind de la implementarea
interfeŃei grafice şi finalizându-se cu implementarea comunicaŃiei seriale RS-232, diagrama
UML completă a claselor aplicaŃiei fiind următoarea (figura 4.1.2):
Zona De Selectare A Primitivei
Grafice
Zona Indicatorilor
Coordonatelor
Zona de afişare a imaginii rezultate
Zona de modificare şi afişare a parametrilor Zona de selectare a
portului serial
Fereastra
Capitolul 4 - Analiza, proiectarea şi implementarea aplicaŃiei software pentru PC
77
Figura 4.4.1. Diagrama UML completă a claselor implementate ale aplicaŃiei.
4.5. Implementarea interfeŃei grafice
InterfaŃa grafică este reprezentată de clasa Interfata care este practic o clasă moştenită din
clasa standard Form. Aceasta include instanŃierile, iniŃializările şi metodele de tratare a
evenimentelor tuturor componentelor necesare.
O primă zonă a interfeŃei o reprezintă zona pentru selectarea primitivei grafice dorite. Am
ales realizarea acestei selectări prin componente de tip radiobutton grupate pe un suport de tip
groupbox (figura 4.5.1). Butoanele de acest tip au o caracteristică standard utilă pentru această
funcŃie şi anume: dacă sunt grupate, selectarea unuia dintre ele determină delesectarea
Proiect de diplomă
78
celorlalte. Gruparea este realizată prin inglobarea pe un suport comun, în cazul de faŃă
componenta de tip groupbox.
Figura 4.5.1. Zona pentru selectarea primitivei grafice.
Pentru a diminua numărul de linii de cod şi pentru a uşura realizarea unei singure metode
de tratare a evenimentului de „bifare” pentru tot grupul de butoane, am renunŃat la generarea
automată a componentelor de către designerul de interfeŃe vizuale al mediului de programare
C# şi le-am instanŃiat ca un vector de obiecte în cadrul clasei Interfata. Am realizat
iniŃializarea acestora în cadrul metodei apelate la încărcarea ferestrei, Form1_Load. Numele
butoanelor vor fi preluate dintr-un vector de şiruri de caractere pe care l-am declarat ca o
constantă în interiorul clasei.
private readonly string[] nume_rb = new string[] { "Punct", "Linie", "Dreptunghi", "Cerc", "Elipsa", "Dreptunghi colorat", "Cerc colorat", "Elipsa colorata"}; private RadioButton[] rb;
Metoda radiobuttons_handler reprezintă metoda apelată în momentul apariŃiei unui
eveniment de tip „bifare”. Apelarea respectivei metode este datorată includerii ei ca metodă
de tratare a evenimentului în momentul iniŃializării butoanelor.
this.rb[i].CheckedChanged += new System.EventHandler( this. radiobuttons_handler);
Această metodă va actualiza variabila de tip byte pri_sel care desenează tipul primitivei
grafice alese funcŃie de componenta corespuzătoare bifată şi va reactualiza starea
componentelor de tip textbox care indică valorile coordonatelor prin apelarea metodei
ActualizareTextBoxValori. Această metodă dezactivează textbox-urile care indică
coordonatele celui de-al doilea punct în cazul în care primitiva grafică seletată este „Punct”,
adică în cazul în care pri_sel=0.
Capitolul 4 - Analiza, proiectarea şi implementarea aplicaŃiei software pentru PC
79
Următoarea zonă implementată din cadrul interfeŃei grafice a fost zona de desenare care
este reprezentată de o componentă de tipul picturebox, denumit desen. Această componentă
are asignate două metode de tratare a evenimentelor, una pentru tratarea evenimentului de
„click pe suprafaŃă”, ClickSuprafata, iar a doua pentru tratarea evenimentului de „desenare”,
Desenare.
Metoda ClickSuprafata determină dacă a fost apasat buton din stanga al mouse-ului.
Dacă da, în cazul în care primitiva grafică aleasă este diferită de „Punct”, iar primul punct a
fost setat, va seta cel de-al doilea punct, va apela metoda corespunzătoare desenării primitivei
respective, metoda pentru trimiterea comenzii către modulul hardware (TrimiteComanda) şi
metoda de reactualizare a picturebox-ului (desen.Refresh); în cazul în care primul punct nu a
fost setat, va seta coordonatele primului punct. Dacă pri_sel=0, adică primitiva aleasă este
„Punct”, va seta primul punct şi va apela metodele pentru desenarea punctului, trimiterea
comenzii şi reactualizarea picturebox-ului. Setarea coordonatelor punctelor presupune
totodată şi actualizarea conŃinutului textbox-urilor indicatoare. Logica acestei metode am
descris-o în următoarea organigramă (figura 4.5.2).
Figura 4.5.2. Organigrama metodei ClickSuprafata.
Metoda Desenare este apelată automat fie la redesenarea întregii ferestre (eveniment care
este realizat în cazul mutării sau aducerii în prim-plan a ferestrei), fie la apelarea în program a
metodei de reactualizare a conŃinutului componentei de tip picturebox, desen.Refresh. Acestă
Proiect de diplomă
80
metodă realizează desenarea imaginii salvate în matricea de pixeli, fiecare pixel fiind dublat
atât pe orizontală cât şi pe verticală.
Zona pentru indicatorii coordonatelor celor doua puncte este practic formată din
componente de tip label pentru afişarea semnificaŃiei valorilor şi componente de tip textbox
pentru afişarea valorilor în sine (figura 4.5.3). După cum am menŃionat, acestea sunt
modificate prin apelarea metodei ClickSuprafata. Am ales ca după iniŃializare să afişeze
literele „F”, „P”, „G” şi respectiv „A” doar din motive estetice fără a avea o semnificaŃie în
program. La prima setare a pixelului, textbox-urile vor fi actualizate afişând coordonatele
pixelului.
Figura 4.5.3. Zona indicatorilor.
Zona pentru modificarea parametrilor pentru componentele cromatice, luminozitate,
contrast şi saturaŃie este formată din 6 componente de tip trackbar, două componente textbox
şi un picturebox (figura 4.5.4).
Valoarea fiecărui trackbar determină valoarea unuia dintre parametri enumeraŃi. Astfel
am ales lungimea maximă a trackbar-urilor 63 de pixeli care coincide cu valoarea maximă pe
care o poate avea fiecare parametru.
Componentele textbox ca şi în cazul zonei indicatorilor de coordonate au rolul de a afişa
valorile parametrilor setaŃi, cea superioară afişând valorile componentelor cromatice, iar cea
inferioară afişând valorile parametrilor pentru filtrele punctuale.
Figura 4.5.4. Zona de modificare a parametrilor.
Cu ajutorul primelor trei componente de tip trackbar se poate modifica nuanŃa culorii de
desenare. Culoarea de fundal a fiecărei componente este corelată cu valoarea acesteia.
Toate componentele trackbar au asignată o metodă de tratare a evenimentului de
„derulare”, altfel spus a evenimentului de modificare valoare, denumită trackbar_handler. În
Capitolul 4 - Analiza, proiectarea şi implementarea aplicaŃiei software pentru PC
81
momentul în care valoarea unui trackbar desemnată prin poziŃia bării de derulare este
modificată, această metodă este apelată automat. Metoda verifică originea apelantului funcŃie
de care apelează în continuare metoda de trimitere a comenzii către microsistem, iar apoi
apelează metoda ActualizareCuloare.
În metoda ActualizareCuloare am implementat reactualizarea culorii de fundal a
trackbar-urilor funcŃie de valoarea curentă a acestora, reactualizarea celor două componente
textbox care indică valorile curente şi a culorii curente afişate în picturebox. Dat fiind faptul
că în momentul iniŃializării trackbar-urilor pentru modificarea parametrilor cromatici (R, G,
B) este nevoie de o actualizare a culorilor de fundal, am adaugat un parametru de tip obiect
numit sender metodei. În cazul în care acest parametru este null însemnă că funcŃia a fost
apelată la pornirea aplicaŃie în procesul de iniŃializare şi va actualiza toate componentele
menŃionate (culori de fundal, textul afişat, culoare picturebox). Dacă parametrul este diferit de
null, fie va actualiza culorile şi textbox-ul superior în cazul în care sender este unul dintre
primele 3 trackbar-uri, fie textbox-ul inferior în caz contrat. Logica acestei metode este
descrisă în următoarea organigramă (figura 4.5.5).
Figura 4.5.5. Organigrama metodei ActualizareCulori.
Totodată cele şase trackbar-uri au asignată încă o metodă de tratate a evenimentului de
„click dreapta” numită resetarevalori. Această metodă readuce valoarea trackbar-ului la
Proiect de diplomă
82
valoare iniŃială şi anume 31 şi apelează metoda TrimiteComanda pentru a actualiza parametri
şi în microsistem.
Valorile următoarelor trei componente de tip trackbar desemnează valorile parametrilor
filtrelor punctuale. Acestea au asignat încă o metodă pentru tratarea evenimentului de „buton
mouse ridicat”. Altfel spus în momentul în care valoarea trackbar-ului este fixată şi butonul
mouse-ului eliberat este apelată metoda redesenare. Metoda respectiva apelează metoda de
reactualizare a imaginii afişate. Astfel am eliminat reactualizarea excesivă a imaginii la orice
modificare a valorilor trackbar-urilor respective.
Ca şi în cazul butoanelor de tip radiobutton, trackbar-urile sunt instanŃiate ca obiecte ale
clasei Interfata şi iniŃializate în metoda Form1.Load pentru a evita generarea automată de cod
suplimentar şi pentru a simplifica adăugarea metodelor de tratare a evenimentelor.
Ultima zonă a interfeŃei grafice este reprezentată de o componentă combobox pentru
afişarea şi selectarea porturilor seriale RS-232 disponibile pe calculator. Eticheta alăturată
indică doar semnificaŃia textului afişat în combobox. Comboboxul este populat la pornirea
aplicaŃiei cu numele porturilor seriale RS-232 detectate pe calculator prin apelarea metodei
DetectarePorturiSeriale.
Metoda DetectarePorturiSeriale apelează funcŃia GetPortNames care returnează un
vector de siruri de caractere. Dacă lungimea acestui vector este 0 atunci însemnă că pe
sistemul PC nu există porturi seriale RS-232 şi comboboxul va fi dezactivat. În caz contrar,
comboboxul este populat cu numele porturilor returnate. Datorită acestei funcŃii de detectare a
porturilor seriale este necesară folosirea cel putin a Framework-ul .NET 2.0. Framework-uri
anterioare nu suportă această funcŃie.
Figura 4.5.6. InterfaŃa grafică a aplicaŃiei software pentru PC.
Capitolul 4 - Analiza, proiectarea şi implementarea aplicaŃiei software pentru PC
83
4.6. Implementarea clasei pentru simularea unui buffer video
Imaginea desenată trebuie păstrată într-o memorie pentru a fi redesenată la apelarea
automată sau manuală a funcŃiei de reactualizare a componentei picturebox.
Am ales implementarea acestei memorii sub forma unei matrici de obiecte de tipul
culoare (Color) pe care am inglobat-o în clasa MatriceCulori. Pentru a putea accesa valorile
acestei matrici am implementat metode de tip seter şi geter.
private Color[,] matrice;
Metodele de tip seter actualizează valoarea unui element al matricii. Am implementat
două metode seter, una cu parametru de tip culoare, iar cealaltă cu trei parametrii de tip byte
reprezentând componentele cromatice ale unei culori.
Metodele de tip geter returnează valoarea unui element al matricii. Metoda geter
implementată returnează un obiect de tip culoare corespunzător elementului adresat al
matricii.
4.7. Implementarea clasei şi metodelor pentru gesenarea primitivelor
grafice
În privinŃa implementării metodelor de desenare a primitivelor grafice am ales o abordare
similară celei aplicate pentru microsistemul cu FPGA. Prin urmare coordonarele punctelor
care determină primitiva grafică şi culoarea de desenare nu sunt trimise ca parametri la
apelarea metodei de desenare, ci le setez inaintea acestei apelări.
Prin urmare clasa PrimitiveGrafice care include toate metodele de desenare a primitivelor
grafice, include totodată şi valorile punctelor şi culorii care determină desenarea, dar şi
metodele seter şi geter corespunzătoare. În momentul apelării unei metode de desenare, aceste
valori sunt preluate din variabilele interne ale clasei.
Metodele de desenare a primitivelor grafice le-am implementat pe baza algoritmilor lui
Josh Bresenham. Pentru desenarea punctului am apelat la desenarea unui pătrat de 2x2 pixeli
pentru a realiza dublarea pixelilor, această desenare realizându-se în momentul apelării
funcŃiei de reactualizare a picturebox-ului.
Pentru a desena o figură trebuie realizaŃi următorii paşi de apelare: se setează valorile
coordonatelor punctelor prin apelarea metodelor seter corespunzătoare (SetX0, SetX1, SetY0,
Proiect de diplomă
84
SetY1), se setează culoarea de desenare prin apelarea metodei seter SetColor şi se apelează
metoda de desenare corespunzătoare primitivei grafice dorite.
Desenare presupune în fapt generarea coordonatelor fiecărui punct care defineşte figura,
modificarea elementului de tip culoare din matricea de culori determinat de aceste coordonate
şi în final reactualizarea imaginii din componenta picturebox desen.
Conform algoritmului, generarea coodonatelor punctelor liniei (metoda linie) se reduce la
calculul în primele două octane în sens trigonometric prin iniŃializarea variabilele stepx şi
stepy cu direcŃiile de înaintare a coordonatelor pe orizontală, respectiv verticală funcŃie de
semnul diferenŃelor coordonatelor capetelor pe orizontală, respectiv pe verticală. Decizia
apartenenŃei la unul dintre cele două octane se ia funcŃie de modulul diferenŃelor ()A), respectiv )A�)). Eroarea cumulată este reprezentată de variabila eroare care este actualizată la
fiecare iteraŃie.
Pentru generarea dreptunghiului, am implementat o metodă simplă care presupune două
parcurgeri, una pe orizontală, iar cealaltă pe verticală desenând simultan două linii.
În cazul cercului (metoda cerc), generarea coordonatelor punctelor se reduce la calculul
în primul octan. La fiecare iteraŃie sunt generate 8 puncte ale cercului datorită celor patru axe
de simetrie prin apelarea metodei punctecerc pentru cerc sau a metodei punctedisc pentru
disc. Definim prin disc un cerc cu suprafaŃa interioară de aceeaşi culoare cu marginea.
Eroarea acumulată este păstrată în variabila er_raza, iar variabilele xdif, ydif păstrează
valorile calculate conform algoritmului. Pentru a selecta între desenarea unui cerc sau a unui
disc se apelează metoda cerc cu parametrul boolean plin setat fals pentru cerc, respectiv true
pentru disc.
Pentru generarea elipsei (metoda elipsa), am ales implementarea unei versiuni optimizate
a algoritmului lui Josh Bressenham care generează coodonatele punctelor printr-o singură
trecere[3]. La fiecare iteraŃie sunt generate 4 puncte conform celor 2 axe de simetrie. Astfel se
reduce complexitatea algoritmului la jumătate din valoarea iniŃială. Această versiune a
algoritmului are totuşi un deficit, cazul în care coordonatele pe axa verticală ale celor două
puncte care definesc elipsa sunt egale trebuie tratat separat (caz în care este generată o linie
centrată pe verticală faŃă de centrul elipsei). Ca şi în cazul cercului, parametrul plin al metodei
de generare a elipsei determină desenarea unei elipse coloarate în interior sau nu.
Generarea dreptunghiului umplut (metoda dreptunghiplin) presupune întreaga parcurgere
a ariei definite de cele două puncte. Este cea mai lentă metodă, având practic o complexitate a
algoritmului de ¡ ���.
Capitolul 4 - Analiza, proiectarea şi implementarea aplicaŃiei software pentru PC
85
4.8. Implementarea clasei şi metodelor pentru filtrele punctuale
Filtrele punctuale le-am implementat ca metode în cadrul clasei Efecte. Aceste metode
primesc ca paramentri culoarea de intrare ca obiect de tip Color şi valoarea care defineşte
nivelul de aplicare a efectului respectiv asupra culorii şi returnează un obiect de tip Color care
reprezintă culoarea modificată a pixelului.
Metodele sunt apelate consecutiv în cadrul metodei de desenare a imaginii din clasa
Interfata care conŃine un obiect de tip Efecte.
4.9. Implementarea comunicaŃiei seriale
Transferul datelor pe porturile RS-232 l-am realizat prin intermediul clasei SerialPort.
Pentru a putea folosi obiecte de tip serialport acestea trebuiesc iniŃializate cu infomaŃiile
despre numele portului serial care va fi utilizat, viteza de comunicaŃie (în acest caz, 9600 bps),
tipul parităŃii folosite (paritate impară) şi numărul de biŃi de stop (1 bit). În cazul în care există
porturi seriale în sistem, la iniŃializarea aplicaŃiei, prin apelarea metodei
DetectarePorturiSeriale, numele portului va fi iniŃializat cu valoarea primului element al
listei. Trimiterea unui şir de octeŃi după instanŃierea şi iniŃializarea obiectului de tip serialport
presupune următoarele: verificarea dacă portul este deschis; în cazul în care este deschis,
acesta va fi închis şi redeschis pentru noul transfer, în caz contrar va fi doar deschis; aceste
operaŃii sunt realizate prin apelarea metodelor SerialPort.IsOpen, SerialPort.Open,
SerialPort.Close; după deschiderea portului se realizeaza transferul efectiv prin apelarea
metodei SerialPort.Write. Această metodă are două forme de apelare: cu un singur parametru
de tip şir de caractere şi va trimite întregul şir de caractere pe portul serial, iar a doua cu trei
parametri, un vector de octeŃi, indexul octetului de început şi numărul de octeŃi care vor fi
trimişi. După trimiterea datelor portul trebuie închis prin apelarea metodei SerialPort.Close.
În cadrul acestei aplicaŃii am implementat metoda TrimiteComanda care este apelată de
metodele de tratare a evenimentelor corespunzătoare şi care realizează următoarele funcŃii:
verifică dacă au fost detectate porturi seriale pe sistem; dacă exită încearcă trimiterea octetului
care defineşte comanda urmat de un număr de octeŃi pe post de parametri; dacă deşi există
port serial pe sistem dar nu este reuşită transmisia va fi apelată afişarea unei ferestre de mesaj
de eroare. Codificarea comenzilor şi numărul de parametri trimişi şi semnificaŃia lor sunt
Proiect de diplomă
86
prezentate în tabelul 3.11.1, unde R, G, B reprezintă componentele culorii, �� ��� şi �� ��� coordonatele punctelor, iar L, C, S reprezintă nivelul de luminozitate, contrast, respectiv
saturaŃie al imaginii.
Capitolul 5 - Testare şi validare
87
5. Testare şi validare
5.1. Testarea modulelor VHDL implementate
5.1.1. Tehnici de testare folosite
Pentru testarea modulelor implementate în VHDL am folosit următoarele tipuri de testări:
a. Testarea funcŃională, numită şi testarea cutiei negre - presupune că se folosesc numai
cunoştinŃe despre natura programului, despre proprietăŃile datelor de intrare şi
proprietăŃile sau criteriile datelor de ieşire. Un test este o mulŃime de eşantioane: ¢ � > �K���7 � �K��?. Eşantioanele trebuie să verifice ca fiecare modul este realizat
corect şi complet.
b. Testarea structurală - presupune analizarea structurii modulului, iar eşantioanele
sunt concepute astfel încât să testeze toate parŃile modulului.
c. Testarea de integrare - presupune testarea respectivului modul în cadrul unui proiect
de test.
Testele pe care le-am realizat sunt fie sub forma unor simulări pe baza unor date de
intrare, fie sub forma de proiecte de test. Alegerea uneia dintre cele două opŃiuni a depins de o
comparaŃie ipotetică a complexităŃii fiecăreia, dar şi de cantitatea de informaŃii obŃinută în
urma celor două tipuri de teste asupra corectitudinii şi validităŃii implementărilor modulelor
testate. Empiric s-au dovedit a fi mult mai utile simulările modulelor decât testarea de
integrare a acestora.
5.1.2. Simulări ale modulelor implementate
Am ales simularea modulelor reprezentative şi ale căror valori de ieşire pot fi imediat
validate după cum urmează:
? �K" L�( ? Corespunde
cerintelor
Proiect de diplomă
88
1. Modulul de verificare a stării butoanelor – citire_butoane
Figure 5.1.2.3. Simularea diferitelor evenimente de apăsare a butoanelor.
După cum se poate observa din simulare la apăsarea mai multor butoane simultan (de
exemplu d=”1010” sau d=”0111”) ieşirea va indicat evenimentul butonului prioritar
(s=”101”, respective s=”100”).
2. Modulul de interpretare a comenzilor – interpretor_comenzi
Figura 5.1.2.2. Simularea primirii comezii de desenare a unui punct la coordonatele (42, 59).
La recepŃionarea completă a comenzii, modulul va trimite căttre ieşirile corespuzătoare
valorile primite ale parametrilor şi, în cazul comenzilor de desenare, codul primitivei alese.
Ieşirea pentr codul primitivei este ultima ieşire actualizată pentru că determină iniŃializarea
algoritmului de desenare implementat (practic trecerea automatului din stara de aşteptare în
starea de iniŃializare).
Capitolul 5 - Testare şi validare
89
3. Modulul de interpretate a evenimentelor mouse – interpretor_mouse
Figura 5.1.2.3. Simularea intepretării evenimentelor mouse.
După cum se poate observa din simulare, funcŃie de poziŃia cursorului şi stările
butoanelor mouse-ului sunt actualizate ieşirile corespunzătoare modulului.
4. Modulul de generare a primitivelor grafice – primitive_grafice
Figura 5.1.2.4.a. Simularea generării unei linii între punctele de coordonate (20,10), (1, 3).
Simularea confirmă modul de generare a liniei implementat. Automatul trece ]n starea de
iniŃializare a punctelor care determină linia (pst=3), apoi în starea de iniŃializare a celorlalte
variabile neceare (pst=4), urmând generarea liniei punct cu punct prin desenarea punctului
curent (pst=2), continuată de calculul coodonatelor următorului punct (pst=5).
Proiect de diplomă
90
Figura 5.1.2.4.b. Simularea generării unui cerc cu centrul în punctul de coordonate (5, 5) şi raza 4.
Capitolul 5 - Testare şi validare
91
5. Modulul DMA pentru citirea memoriei – dma_int
Figura 5.1.2.5. Simularea adresării memoriei la diferite valori ale contorilor pentru orizontală şi verticală.
În simulare se poate observa generarea adresei locaŃiei de memorie corespuzătoare
valorilor contoarelor pentru orizontală, resectiv verticală.
6. Modulul de generare a semnalului PWM – light_ctrl
Figura 5.1.2.6. Simularea generării unui semnal PWM.
Semnalul PWM este generat în 64 de tacturi ale semnalului de ceas de la intrare în care
lungimea blocului de biŃi „1” logic este aceeaşi cu valoarea parametrului load.
7. Modulul de reglare a luminozităŃii imaginii – lum_ctrl
Figura 5.1.2.7. Simularea reglării luminozităŃii.
Proiect de diplomă
92
8. Modulul de reglare a constrastului imaginii – con_ctrl
Figura 5.1.2.8. Simularea reglării contratului.
Modului de reglare a saturaŃiei imaginii – sat_ctrl
Figura 5.1.2.9. Simularea reglării saturaŃiei.
5.2. Testarea aplicaŃiei software pentru PC
5.2.1. Planul de testare
Pentru a realiza testarea aplicaŃiei software am conceput un plan de testare ai cărui paşi i-
am urmărit şi executat atât de-a lungul procesului de implementare, cât şi după realizarea
implementării, moment în care am reluat toŃi paşii.
Etapele planului de testare conceput sunt următoarele:
1. Verificare bunei funcŃionări a interfeŃei grafice – a presupus testarea fiecărei
componente active de interfaŃă; prin componentă activă a se înŃelege o componentă
ale cărei evenimente au ataşate metode de tratare a evenimentelor respective.
Capitolul 5 - Testare şi validare
93
2. Compararea vizuală a rezultatelor fiecărei metode de gesenare a unei primitive
grafice – această etapă presupune adăugarea la aplicaŃia curentă a unei modalităŃi de a
suprapune fie rezultatul generat pe baza ecuaŃiilor matematice generale ale fiecărei
primitive, fie rezultatul generat de funcŃii predefinite ale framework-ului .NET 2.0
deasupra rezultatului generat de algoritmii implementaŃi pentru efectuarea unei
comparaŃii vizuale.
3. Utilizarea unor aplicaŃii de simulare şi monitorizare a porturilor seriale RS-232
pentru verificarea transferului corect al comenzilor – pentru a realiza această testare
am folosit variantele demonstrative ale următoarelor programe: Eltima Virtual Serial
Port Driver şi Eltima Serial Port Monitor. Primul software activează două porturi
seriale virtuale conectate în buclă, iar cel de-al doilea software monitorizează un port
serial fizic sau virtual.
5.2.2. Rezultate ale testării
Primul pas de testare l-am aplicat încă de la finalul etapei de implementare a interfeŃei
grafice. Am realizat metodele de tratare a evenimentelor astfel încât să returneze atenŃionări
sub forma unor fereste de masaj în cazul în care a fost tratat evenimentul respectiv (figura
5.2.2.1). Aceste atenŃionări au fost dezactivate după realizarea testării prin comentarea codului
de apelare.
Figura 5.2.2.1. Semnalizarea apariŃiei evenimentului de „buton apăsat”.
Proiect de diplomă
94
Al doilea pas al testării l-am aplicat după implementarea fiecărei primitive în parte. Am
adăgat metodei de reactualizare a imaginii afişate desenarea ultimei primitive cu ajutorul
funcŃiei corespuzătoare oferite de framework-ul .NET (figura 5.2.2.2).
Figura 5.2.2.2. Compararea rezultatului generat de algoritm cu rezultatul obŃinut cu ajutorul funcŃiilor oferite de
framework; în acest caz, elipsa colorată albastru comparată cu elipsa verde.
Monitorizarea comuniŃiei seriale pentru realizarea ultimei etape de testare presupune
activarea unei perechi de porturi virtuale, monitorizarea unuia dintre cele două porturi şi
transferul de comenzi pe cel de-al doilea port. Rezultatele obŃinute în urma testelor validează
transmiterea corectă a comenzilor de către aplicaŃie (figurile 5.2.2.3 a, b, respectiv c).
Capitolul 5 - Testare şi validare
95
Figura 5.2.2.3.a. Verificarea transferului pentru comanda de desenare punct.
Figura 5.2.2.3.a. Verificarea transferului pentru comanda de desenare linie.
Proiect de diplomă
96
Figura 5.2.2.3.a. Verificarea transferului pentru comanda de desenare cerc colorat.
Capitolul 6 - Concluzii
97
6. Concluzii
6.1. Probleme întâmpinate şi soluŃionarea lor
Placa de dezvoltare Digilent Nexys2 are la bază un circuit intergrat VLSI FPGA Xilinx
Spartan3E FG500 care, după cum am prezentat anterior, este relativ limitat din punct de
vedere al resurselor oferite. Reamintim faptul că în interiorul cipului sunt implementate fizic
20 de module de multiplicare şi 20 de module de memorie BRAM dual-port care pot fi
configurate şi conectate conform necesităŃilor sistemului implementat.
Probleme privind resursele folosite au apărut încă din etapa de proiectare a structurii
hardware în momentul în care, conform matematicii care stă la baza filtrelor punctuale, era
nevoie de realizarea a 21 de operaŃii de înmulŃire în care operanzii pot fi diferiŃi de puteri ale
lui 2 (în cazul în care un operand este o putere a lui 2, operaŃia de înmulŃire este sintetizată
sub forma unei operaŃii de deplasare). Pe de altă parte erau necesare încă 3 operaŃii de
înmulŃire în cadrul etapelor de iniŃializare a algoritmului de generare a elipsei şi o operaŃie de
înmulŃire în cadrul modulului de acces direct la memorie pentru calculul adresei de memorie
funcŃie de coordonatele punctului. Aşadar numărul aparent de multiplicatoare necesare se
ridica la 25 depăşind resursele disponibile.
Pentru a reduce numărul de multiplicatoare folosite am recurs la următoarele optimizări:
- Pentru calculul adresei de memorie în cadrul modulului de acces direct la memorie
am recurs la rescrierea formulei într-o formă echivalentă care implică doar operaŃii
de deplasare şi adunare. Practic s-a rezumat la scrierea constantei 160 ca sumă de
puteri ale lui 2. A� � � � ��� � ��� � �e� � ��j� 6� � �� � �� A� � � � �� � � � �� � � � � k� � � � G� �
- În cazul calculului luminanŃei necesar pentru aplicarea filtrului de saturaŃie, am
folosit o formulă aproximativă de calcul pentru a reduce din nou calculul la operaŃii
de deplasare, adunare şi scădere. E � �`�aa V L � �`Gjk V M � �`��F V N £ £ �`�GL � �`e�GM � �`��GN � � �`�GL � � � �`�G � �`��G�M � �`��GN � � L ¤ �� � M � M ¤ �� � M ¤ 6� � N ¤ 6�
Proiect de diplomă
98
- Pentru fiecare filtru în parte am redus numărul de multiplicatoare folosite prin
reorganizarea ordinii în care sunt realizate calculele şi prin gruparea mai multor
operaŃii de înmulŃire care aveau un operand comun (valoarea parametrului).
drgb := db & "00000" & dg & "00000" & dr;
p := drgb * c;
Astfel s-a redus numărul de multiplicatori folosiŃi la 9.
O a doua problemă constatată în etapa de testare a structurii hardware a fost apariŃia
întârzierilor în afişarea imaginii rezultate în urma procesării. Întârzierile erau datorate
operaŃilor de înmulŃire care duraumai mult de o perioadă de ceas. Pentru a contracara acest
efect am recurs la citirea în avans a memoriei cu un număr de pixeli egal cu numărul de
întârzieri ale semnalelor RGB.
6.2. Realizări şi direcŃii de dezvoltare
În urma implementării realizate am reuşit pe de o parte să acopăr obiectivele temei de
proiectare, iar pe de altă structura hardware obŃinută în urma sintetizării s-a încadrat în
numărul de resurse disponibile pe placa de dezvoltare Nexys2.
Tabelul 6.2.1. Rezultate în urma sintetizării circuitelor descrise privind resursele folosite.
Tip resursă Număr total
utilizate Număr total disponibile
Procent de utilizare
Slice-uri 3093 4656 66% Bistabili ai slice-ului 1165 9312 12% LUT-uri de 4 intrări 5806 9312 62% Blocuri IO conectaete
32 232 13%
Memorii BRAM 20 20 100% Multiplicatoare 9 20 45% GCLK 5 24 20%
Totodată am obŃinut o structură hardware de procesare a semnalului video care poate
lucra până la frecvenŃe de ceas de aproximativ 32 MHz conform rezultatelor sintezei
circuitelor descrise (tabelul 6.2.2), astfel acoperind şi frecvenŃa ceasului de pixel de 25 MHz.
Capitolul 6 - Concluzii
99
Tabelul 6.2.2. Rezultate în urma sintetizării circuitelor descrise privind viteza maximă de lucru.
Perioada minimă 30.530 ns FrecvenŃa maximă de lucru 32.755 MHz Timpul minim de sosire a intrărilor inaintea semnalului de ceas 25.292 ns Timpul maxim de reŃinere a ieşirilor după apariŃia semnalului de ceas 27.502 ns Întârzierea maximă prin circuitele combinaŃionale 12.447 ns
Din punct de vedere al direcŃilor de dezvoltare, proiectul de faŃă poate fi adaptat pentru
plăci de dezvoltare cu module FPGA mai performate şi cu mult mai multe resurse disponibile
atât pe placa de dezvoltare, cât şi în interiorul cipului. De exemplu, se poate folosi o placă de
dezvoltarea cu FPGA Virtex2 şi posibilitatea conectării de module externe de memorie DDR,
astfel acoperind necesităŃile de resurse pentru dimensiuni mari ale imaginii şi chiar adăugând
posibilitatea folosirii tehnicii de paginare a memoriei video.
O altă direcŃie de dezvoltare poate presupune folosirea modulului de procesare a imaginii
în proiecte de procesare video în timp real. Astfel având o sursă de decodare a semnalului
video, filtrele punctuale implementate pot fi aplicate cu succes înainte de a afişa sau a
transmite în continuare semnalul video.
Proiect de diplomă
100
Bibliografie
Capitolul 6 - Concluzii
101
Anexe
top related