Zynq-beeldverbeteringssysteem: 7 stappen

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:18

Zoals je waarschijnlijk uit de titel kunt opmaken, is het doel van dit project om een Image Enhancement System te maken met behulp van de ZYNQ ApSOC. Meer specifiek willen we een systeem bouwen dat de mist uit beeld of video kan verwijderen. Dit systeem neemt in slechte omstandigheden visuele gegevens als invoer, verwerkt deze met behulp van beeldverbeteringstechnieken en voert vervolgens het resultaat uit.

Het project is gebouwd en getest op het Digilent Zybo Board, maar andere ZYNQ-apparaten zouden ook moeten werken.

We splitsen dit project op in 3 delen:

1) INPUT = beeld invoeren via ethernet van computer/camera

2) PROCES = Verwerk de afbeelding

3) OUTPUT = Voer het beeld uit via een HDMI-interface

Op een zeer contra-intuïtieve manier zullen we beginnen met het uitvoergedeelte van het project (dit geeft ons onderweg betere foutopsporingsmogelijkheden), doorgaan met de invoer en eindigen met het verwerkingsgedeelte.

Stap 1: Materialen

Om dit project te voltooien heb je nodig:

HARDWARE

- elk ZYNQ-bord met HDMI en Ethernet zou moeten werken / ik gebruik de Digilent Zybo

- USB A naar micro B USB-kabel

- HDMI kabel

- Ethernetkabel

- Display met HDMI-ingang

SOFTWARE

- Xilinx Vivado

- Xilinx SDK

Stap 2: OUTPUT - VGA-controller deel 1

We zullen onze visuele gegevens uitvoeren met behulp van de HDMI-poort die op het bord aanwezig is. De HDMI-poort is aangesloten op de PL (Programmable Logic = FPGA) kant van de ZYNQ en we zullen er een controller in VHDL voor moeten ontwerpen. Als je ooit een VGA-controller hebt ontworpen, zul je deze zeer vergelijkbaar vinden. De timings voor HDMI en VGA zijn eigenlijk hetzelfde, in feite kunt u voortbouwen op een bestaande VGA-controller om een HDMI-controller te verkrijgen.

Voor een beter begrip van wat er werkelijk gebeurt zullen we eerst een VGA-controller ontwerpen

We willen weergeven met een resolutie van 1920x1080.

De VGA-controller is verantwoordelijk voor het achtereenvolgens pixel voor pixel verzenden van de pixelgegevens (in RGB-formaat) naar het beeldscherm. Buiten het werkelijke weergavegebied van 1920x1080 zijn er ook enkele "grens"-gebieden, namelijk: voorporch, achterporch en retrace. De grootte in pixels van deze gebieden is standaard en specifiek voor elke resolutie. Deze gebieden verschijnen NIET op het scherm, maar zijn verplicht en de kleur van de pixels in dit gebied moet zwart zijn. Een geldige vraag zou zijn waarom deze extra gebieden nodig zijn. Deze vraag tart het doel van deze instructable, maar als je nieuwsgierig bent, zou ik je willen aanmoedigen om verder online onderzoek te doen.

Dit is een goede video waarin de VGA-interface wordt uitgelegd

In ons geval willen we weergeven met een resolutie van 1920*1080, en dit zijn de timings:

Horizontaal weergavegebied = 1920 pixels

Horizontale veranda = 88 pixels

Horizontale achterportiek = 148 pixels

Horizontaal terugtrekken =44 pixels

Verticaal weergavegebied = 1080 pixels

Verticale veranda = 4 pixels

Verticale achterporch = 36 pixels

Verticale terugloop = 5 pixels

(Hier vindt u timings voor andere resoluties

Dus onze werkelijke resolutie zal 2200 x 1125 zijn. We willen 60 fps (frames per seconde), dus onze pixelklok zal 60 * 2200 * 1125 = 148,5 MHz zijn. Op het Zybo Board is een 125 Mhz klok voorzien. We zullen een MMCM IP gebruiken om de 148,5 MHz Pixel Clock te genereren die we nodig hebben.

Stap 3: OUTPUT - VGA-controller deel 2

Met de theoretische achtergrond uit de vorige stap zou je in staat moeten zijn om je eigen VGA-controller te ontwerpen. Ik zal je voorzien van een Vivado-project dat dat doet, maar ik raad je aan om in ieder geval eerst te proberen het zelf te maken.

De meeste VGA-poorten geven je geen 8 bits per kleurkanaal per pixel (zie afbeelding hierboven), dus je zult het ontwerp moeten aanpassen aan het aantal pinnen per kleur dat het bord biedt (dit is echter geen probleem voor de HDMI).

Het ontwerp zal het hele scherm blauw schilderen, behalve de pixel linksboven die rood is. Opgemerkt moet worden dat dit project de beperkingen voor het ZYBO-bestuur gebruikt. Dus als u dit project op een ander bord wilt uitvoeren, moet u het bestand met beperkingen bijwerken en het aantal pinnen per kleur aanpassen.

Kijk eens naar figuur nr. 2. Onthoud dat terwijl onze VGA-controller 5/6 bits per kleur uitvoert, die bits worden omgezet in één analoog signaal voor elk kleurkanaal (rood, groen en blauw) voordat ze door de kabel gaan.

Stap 4: OUTPUT - HDMI-controller deel 1

Nu we weten hoe de VGA-controller werkt en we een werkend ontwerp hebben kunnen we verder met de HDMI-controller. De HDMI-controller zal eigenlijk alle code gebruiken die we in de VGA-controller hebben ontwikkeld. De HDMI en VGA gebruiken dezelfde timings en dezelfde signalen. Het verschil verschijnt op de uitgangspinnen.

Terwijl VGA voor elke kleur één draad gebruikt en er een analoog signaal over verzendt, verzendt HDMI de gegevens digitaal 1 bit tegelijk voor elke kleur en gebruikt het differentiële signalering. Differentiële signalering betekent dat voor elke bit de HDMI 2 pinnen heeft met de ene tegenover de andere. Dus als we een signaal '1' zouden willen verzenden, zouden we '1' op een draad verzenden en '1' genegeerd op de andere draad. Dit zorgt voor signaalintegriteit en u kunt er hier meer over lezen https://goo.gl/6CPCzB. We hebben een van deze kanalen voor elke kleur, ROOD, GROEN en BLAUW en een voor de klok. Vanwege de specifieke kenmerken van differentiële signalering moeten de signalen die we via HDMI verzenden DC-gebalanceerd zijn, wat betekent dat het aantal enen en nullen in een bepaald tijdsbestek ongeveer gelijk moet zijn. Om dit te bereiken zullen we 8b/10b-codering gebruiken. U kunt veel leren over hoe differentiële signalering en 8b/10b-codering werken van de DVI-specificatie hier https://goo.gl/hhh8Ge (DVI en HDMI gebruiken dezelfde videosignalen).

Stap 5: OUTPUT - HDMI-controller deel 2

Genoeg theorie, laten we naar ons project gaan. Terwijl we in de VGA-controller wegkwamen met een 148,5 MHz-kloksnelheid, zullen we hier 10 keer die frequentie moeten bieden omdat we 8 bits voor elke kleur willen verzenden en de 8b/10b-codering gebruiken die zich vertaalt naar 10 bits per pixel en 10 *148.5MHz = 1485MHz. Dat is een enorme frequentie die niet op het Zybo-bord kan worden verkregen. Gelukkig hebben we een paar trucjes achter de hand. We kunnen 5*148.5MHz = 742.5MHz beheren en we zullen een OSERDES (serializer) IP gebruiken om gegevens te verzenden, zowel op de stijgende als de dalende flank van de 742.5Mhz-klok, dus we zullen de gegevens daadwerkelijk ontvangen op 1485MHz. Vivado zal ons wat timingwaarschuwingen geven en je zou altijd voor een lagere resolutie kunnen gaan met een kleinere klok, maar aangezien het werkt, vinden we het voorlopig niet erg (de waarschuwingen hebben te maken met het feit dat de klokbuffers officieel niet ondersteuningsfrequenties hoger dan 464 MHz).

Dus wat we moeten doen, is de gegevens van onze VGA-controller-uitgang coderen in 8b/10b-formaat en deze vervolgens serialiseren zoals hierboven vermeld. We zullen ook nog een MMCM aan het project moeten toevoegen om de 742,5 MHz-klok voor de serialisatie te genereren.

Ik heb hieronder de vhdl-bestanden voor de encoder en serializer bevestigd. U moet eerst de RGB-kanalen coderen en vervolgens serialiseren.

Voorbeeld voor het rode kanaal:

TMDS_encoder_RED: TMDS_encoder

poortkaart (clk148, red_channel_8bits, c_red, video_on, encoded_red_10bits);

Serialiser_RED: Serialiser10_1

poortkaart (clk148, clk742, encoded_red_10bits, reset, red_serial_1bit);

De "c"-invoer naar de TMDS_encoder is "00" voor rood en groen en "vsync & hsync" voor blauw (dit maakt deel uit van de DVI-specificatie

Stap 6: Afbeeldingen uit RAM weergeven

Het doel van de HDMI-controller is om de verwerkte beelden weer te geven. Nu de controller is geïmplementeerd en klaar voor gebruik, moeten we nadenken over het voeden van deze controller met gegevens. Aangezien een groot deel van het beeldverbeteringsproces zal plaatsvinden in de PS (Processing System = ARM Processor) en de resulterende beelden zich in het DDR RAM bevinden. We hebben dus een manier nodig om de gegevens van het RAM naar de HDMI-controller te krijgen.

Om dit te bereiken heb je 3 IP's nodig:

1) VDMA (Video Directe Geheugentoegang)

2) VTC (Videotimingcontroller)

3) Stream naar Video Out (we zullen het vanaf nu S2VO noemen)

S2VO levert feitelijk een RGB 24BIT-signaal aan de uitgang en de benodigde HSYNC- en VSYNC-signalen. Dat deel van de HDMI-controller kunnen we dus weglaten.

U moet deze IP's toevoegen aan uw ontwerp, ze configureren en de juiste verbindingen maken.

Eindelijk zou je iets moeten krijgen dat lijkt op het bovenstaande schema.

Stap 7: OUTPUT - SDK EINDE

Nu alle hardware is ingesteld en klaar voor gebruik, moeten we nu de software in de PS bouwen. We zullen de hardware en de bitstream exporteren en de SDK starten.

1) Bestand -> Exporteren -> Hardware exporteren -> Schakel Bitstream opnemen in en druk op OK

2) Bestand -> SDK starten

Maak in de SDK een nieuw toepassingsproject.

3) Bestand -> Nieuw -> Toepassingsproject

4) Kies een naam voor uw project en druk op Volgende

5) Selecteer de sjabloon "Hello World" en druk op Voltooien

De applicatie in de SDK zal de VDMA moeten programmeren. Er zijn enkele standaardfuncties die worden gebruikt om dit te bereiken (ik zal in details treden als ik tijd heb).

Om ons ontwerp te testen, gebruiken we de functie SDK Restore (Xilinx Tools -> Dump/Restore) om een afbeelding in het DDR RAM-geheugen te plaatsen en deze weer te geven met onze HDMI-controller. U kunt de afbeelding overal laden waar u maar wilt (behalve enkele kleine beperkte gebieden aan het begin van het geheugen). Voor ons voorbeeld kozen we adres 16777216 en de bestandsgrootte 8294400 = 1920*1080*4 (4 kanalen = RGB + alpha).

Het werkt !

Wordt vervolgd