Raspberry Pi Pico Video Uitgang

TL;DR

De Raspberry Pi Pico is een ongelooflijke kleine microcontroller. Hoewel hij geen ingebouwde video-uitgang heeft, zoals zijn grotere broers Raspberry Pi Zero / 1 / 2 / 3 / 4 / 400 (HDMI / dubbele HDMI in hun geval), het is mogelijk om een video-uitgang aan de Pico toe te voegen! (Als VGA of DVI over een HDMI-aansluiting, lees verder voor meer informatie)

In deze post leggen we uit waarom een video-uitgang een heel speciale functie is voor microcontrollers en welke soorten video-uitgangen je kunt bouwen of kopen voor je Pico. We laten je ook wat voorbeeldcode zien - al voorgecompileerd voor je, zodat je het direct kunt downloaden, en dan bespreken we wat je moet aanpassen om het te laten werken.

Onze zusterwinkel, buyzero.de, verkoopt een verscheidenheid aan Pico-accessoires, waaronder de DVI-soken de VGA-dragerbord voor de Pico.

Opmerking: de Pico heeft geen Linux-besturingssysteem zoals de Raspberry Pi Zero W bijvoorbeeld. Je zult dus waarschijnlijk wat dieper moeten duiken in het leren coderen en uploaden van je applicaties naar de Pico. Als dat niet je ding is, de Pi Zero W misschien beter passen om mee te gaan spelen 🙂

Als het je gelukt is om je eigen videoproject te doen met de Raspberry Pi Pico, laat het ons dan weten in de comments!

Waarom is het toevoegen van een Raspberry Pi Pico Video-uitgang een uitdaging?

De Raspberry Pi 400is bijvoorbeeld gebaseerd op de BCM2711 SoC. Dit systeem-op-een-chip heeft gespecialiseerde hardware die zorgt voor de video-uitvoer, door deze perfect voor te bereiden in het formaat dat is gespecificeerd voor de specifieke video-interface(s), twee HDMI-poorten in het geval van de Pi 400. Het heeft ook een enorm geheugen (van 4 GB), waarin de video-uitvoergegevens worden opgeslagen.

Om dit beter te begrijpen moeten we kijken naar enkele basisprincipes van computer video-uitvoer:

Videoweergave en -transmissie

We zien het scherm "in één keer". Onze hersenen hebben een massaal parallelle bedrading, waarbij ze informatie van alle beschikbare netvliescellen tegelijk binnenkrijgen (kegel- en staafcellen).

(* het mechanisme van overdracht naar de hersenen integreert informatie over verschillende netvliescellen, maar het blijft een feit dat veel informatie parallel wordt overgedragen. Kijk naar bipolaire cellen als je meer wilt weten)

De hersenen hebben echter latenties - ze zijn niet in staat om veranderingen in visuele stimuli sneller dan 13 ms. (dat is ongeveer 1 op 75 beelden per seconde).

Voor ons betekent dit dat als we een echt vloeiende animatie willen weergeven, we ongeveer 60 verschillende statische beelden per seconde moeten laten zien. Onze hersenen zullen deze statische beelden interpreteren als een vloeiende en levensechte weergave.

Meestal willen we dat deze foto's in kleur zijn.

We hebben drie verschillende fotoreceptoren voor kleur, dus het scherm toont alleen deze drie verschillende kleuren met verschillende helderheid. Opnieuw synthetiseren onze hersenen de tussenliggende kleuren uit de informatie die ze krijgen. (Terzijde, paars bestaat niet echt als een eigen golflengte - het is een mengsel van rood en blauw).

Er zijn drie primaire kleuren:

• rood
• groen
• blauw

Samen staan ze bekend als RGB. Als je ze alle drie optelt, krijg je wit. Als je rood bij groen optelt, krijg je geel, als je groen bij blauw optelt, krijg je cyaan, als je blauw bij rood optelt, krijg je magenta.

Dus wat we echt willen uitvoeren zijn:

• drie verschillende kleuren,
• elk met een andere helderheidswaarde
• idealiter ongeveer 60 verschillende waarden per seconde (60 Hz)
• een bepaalde schermresolutie - bijvoorbeeld 640 x 480

Laten we eens berekenen hoeveel gegevens dit per seconde zijn:

• 3 kleuren
• x 8-bits kleurdiepte
• x 60
• x 640 x 480

= 442.368.000 bits per seconde = ca. 422 MBit/s

(Bedenk dat bijvoorbeeld de USB v1.1 interface op de Pico ongeveer 10 Mbit/s heeft - ongeveer 40 keer minder doorvoer!)

Om deze informatie uit te voeren, zou je idealiter ook deze informatie als een bitmap in je RAM willen bewaren - één deel van je applicatie zal de afbeelding in het RAM bijwerken, terwijl een ander deel zorgt voor het leveren van de gegevens in een formaat waar een monitor mee kan werken. Dit moet RAM zijn, omdat we met hoge snelheden werken en in staat moeten zijn om dit betrouwbaar te lezen met kleine latenties - wat Flash geheugen niet zou bieden.

Laten we berekenen hoeveel RAM we nodig hebben:

• 640 x 480 (resolutie)
• x 3 (kleuren)
• x 8 bits (kleurdiepte)

= 7372800 bits = 900 kBytes (let op 1 byte = 8 bits)

Hoewel 900 kBytes vele malen passen in het RAM-geheugen van een Raspberry Pi 400, de Pico heeft slechts 264 KB RAM.

Zoals je ziet, zullen we sommige parameters moeten verlagen (bijv. resolutie, kleurdiepte, ...) als we een bitmap in het RAM willen passen, of we moeten slimme ideeën bedenken om het te laten werken zonder alles op te slaan!

Pico's RP2040 PIO maakt uitvoer van videogegevens mogelijk

Tot slot, terwijl de Raspberry Pi 400 en andere Raspberry Pi-modellen speciale hardwareschakelingen hebben om al deze informatie te verwerken en op een betrouwbare manier uit te voeren, heeft de Pico geen speciale schakelingen voor video-uitvoer.

Maar hij heeft een truc achter de hand! De RP2040 ondersteunt PIO (programmeerbare IO). De PIO is bedoeld voor het emuleren van verschillende interfaces met precieze timing, en het is heel erg krachtig! Hij kan worden geprogrammeerd om met hoge snelheden uit het RAM te lezen en uit te voeren.

We zullen de PIO gebruiken om video uit te voeren naar enkele GPIO-pinnen en zullen wat extra schakelingen (weerstanden) gebruiken om het signaal in de gewenste toestand te brengen, afhankelijk van de video-uitgangsinterface waarop we de Pico willen aansluiten.

Geschiedenis video-uitvoerformaat

Voordat we dieper ingaan op hoe je een video-uitgang kunt toevoegen aan je Raspberry Pi Pico, kijken we eerst even naar de geschiedenis van video-uitvoerformaten.

Zoals reeds besproken is het menselijk oog niet in staat om veranderingen in beelden sneller dan ongeveer 13 ms waar te nemen. Een van de eerste benaderingen om computermonitoren te bouwen was daarom de CRT (kathodestraalbuis) monitor.

De CRT heeft drie straalkanonnen die pixel voor pixel, lijn voor lijn, vegen. (en dan enige tijd nodig hebben om terug te keren naar het beginpunt). Het scherm heeft kleurrijke fosforen die nog een tijdje licht blijven uitzenden nadat de straal er doorheen is gegaan. Bij de volgende beweging van het straalpistool over deze specifieke pixel kan de intensiteit van de straal veranderd zijn, wat we zullen zien als een donkerdere pixel. Onze hersenen smelten de aangrenzende kleurrijke fosforpixels samen tot één pixel en zijn niet in staat om de helderheidsveranderingen tussen de stralen door op te merken.

Op deze manier wordt de illusie van een bewegend beeld gecreëerd.

In feite hoeven niet alle gegevens aanwezig te zijn aan het begin van de afbeelding - maar alleen de huidige waarde van de pixelbrigthness. De intensiteit van de straal wordt overeenkomstig aangepast. We kunnen hiervoor een analoog signaal gebruiken - door bijvoorbeeld de spanning te verhogen zal de helderheid toenemen.

We hebben drie verschillende draden nodig voor de verschillende kleuren (om elk straalpistool afzonderlijk aan te sturen) en we moeten een manier hebben om de monitor te laten weten wanneer een nieuwe lijn moet worden gestart en wanneer een nieuw beeld moet worden gestart (wanneer alle lijnen zijn getoond).

VGA (video graphics array)

VGA werd ontworpen met deze CRT-monitoren in gedachten. Het is nog steeds redelijk gebruikelijk als ingang op monitoren, hoewel het steeds meer verouderd raakt naarmate we overstappen op volledig digitale transmissie (waarover later meer).

Dit is ook de eenvoudigste video-uitvoerstandaard om de Pico aan de praat te krijgen.

Naast een specificatie (met standaard resolutiemodi) specificeerde het een connector, de VGA connector:

Hij heeft 15 pinnen:

1. RED (rode video)
2. GROEN (groene video)
3. BLAUW (blauwe video)
4. ID2/RES (gereserveerd)
5. GND (Ground HSync)
6. RED_RTN (rode retour, analoge aarde voor rood)
7. GREEN_RTN (groene retour, analoge aarde voor groen)
8. BLUE_RTN (blauwe retour, analoge aarde voor blauw)
9. KEY/PWR (+5 V DC voedt EDID EEPROM-chip op sommige monitoren)
10. GND (Ground VSync, DDC)
11. ID0/RES (gereserveerd)
12. ID1/SDA (I2C-gegevens sinds DDC2)
13. HSync (horizontale synchronisatie)
14. VSync (verticale synchronisatie)
15. ID3/SCL (I2C-klok sinds DDC2)

Opmerking: VGA-kabels kunnen verschillende resoluties, kleurdiepten en vernieuwingsfrequenties ondersteunen, terwijl het woord "VGA" bij het verwijzen naar de resolutie meestal 640 x 480 betekent.

Zoals je ziet, zijn er drie draden met de beeldgegevens, één voor elke kleur. Het signaal wordt verzonden met een piek (maximum) spanning van 0,7 V. De verzonden signalen voor de kleuren zijn analoog van aard - hogere spanningen verhogen de helderheid, een spanning van 0 betekent dat de pixel donker / uit is.

VGA-uitvoer laten werken op de Pico

Dit betekent dat de Pico, met zijn 3,3V digitale uitgang, hoog genoeg is om deze RGB-pinnen in de VGA-kabel te sturen (die spanningen van 0 - 0,7V verwacht). We moeten eigenlijk de spanning verlagen door weerstanden te gebruiken.

We kunnen een eenvoudige DAC (digitaal-analoge omzetter) bouwen door verschillende weerstanden en GPIO-pinnen te combineren. Afhankelijk van de combinatie van GPIO-pinnen die op een bepaald moment actief zijn, hebben we verschillende spanningsniveaus (= helderheidsniveaus):

Zoals je in bovenstaande afbeelding kunt zien, sturen vijf GPIO's (0 -4) één kanaal aan (rood in dit geval), wat ons een diepte van vijf bits geeft. De weerstanden zijn gewogen 1:2:4:8:16, bijvoorbeeld het minst significante bit (LSB) van rood heeft een weerstand van 8.06K.

Als je dit circuit probeert te bouwen, moet je gaan voor 1 % tolerantieweerstanden om een goed beeld te krijgen.

Raadpleeg "Hardwareontwerp met de RP2040" om te begrijpen hoe de weerstandswaarden zijn berekend. Kortom, als we ze allemaal tegelijk aansturen, hebben we een spanning van 0,74 V, wat OK is voor onze doeleinden.

Meer specifiek stelt dit referentieontwerp voor om een veelgebruikt 16-bits RGB-gegevensformaat (RGB-565) te ondersteunen, dat 5 bits gebruikt voor rood en blauw, en 6 voor groen. We kunnen de daadwerkelijke fysieke uitvoer naar groen terugbrengen tot 5 GPIO-pinnen, net als voor de andere kleuren, om één pin te besparen.

Daarnaast zijn er nog 2 pinnen nodig voor horizontale en verticale blanking timing (HSYNC en VSYNC).

Dit brengt ons op een totaal van 17 GPIO-pinnen om een VGA-uitgang aan te sturen. Gelukkig heeft de Pico 26 beschikbare GPIO-pinnen, waardoor we de VGA-uitgang kunnen aansturen.

Zoals eerder vermeld, is de Pico ook in staat om deze pinnen op de benodigde frequenties en met nauwkeurige timing aan te sturen, dankzij de RP2040 PIO-functie (programmeerbare I/O).

Raspberry Pi Pico VGA-video-uitgangshardware

Raspberry Pi heeft een draagkaart voor de Pico ontworpen en open-sourced die verschillende functies laat zien:

• VGA-uitgang
• knoppen
• microSD-sleuf
• audio-uitgangen (analoog PWM, digitaal I2S)

Koop de Pico VGA / Audio / microSD-kaart

Wij (buyzero.de) zijn momenteel bezig om dit referentieontwerpbord voor ons te laten bouwen en assembleren. Neem contact met ons op als je op de hoogte wilt worden gebracht zodra het bord kan worden gekocht.!

De Pico VGA-kaart is nu verkrijgbaar bij ons, beperkte eerste voorraad!

In de tussentijd heeft Pimoroni ook een versie van dit bord gemaakt, ze noemen het de Pimoroni Pico VGA demobasis.

Kanttekening: elke pin van de 15 rgb-uitgangspinnen moet nog steeds worden aangestuurd op ongeveer 17,58 Mbit/s, wat nog steeds een indrukwekkend - maar veel beter hanteerbaar - getal is!

Software die nodig is om de VGA-uitvoer aan te sturen

Aangezien we op de Pico werken, zijn er geen "grafische stuurprogramma's" die we gewoon kunnen installeren. We moeten de code zelf schrijven... of niet 🙂 .

Gelukkig leveren de mensen die het hardwarebord voor ons hebben ontworpen al wat code die we kunnen gebruiken, zodat we ons op ons project kunnen richten.

Voorbeeldcode die je kunt gebruiken is te vinden in de pico-playground Repository:

• https://github.com/raspberrypi/pico-playground

In dit archief staat een eenvoudige filmspeler genaamd popcorn (die films in een aangepast formaat afspeelt). A big buck bunny, 1,6 GB groot, kan hier worden gedownload. Merk op dat dit raw disk images zijn die naar een SD-kaart geschreven moeten worden - dit voorbeeld gaat ervan uit dat je het VGA demo-bord hebt, dat een SD-sleuf heeft. Instructies voor films converteren worden ook gegeven.

De code gebruikt de pico_scanvideo bibliotheek (pico/scanvideo.h) van de pico_extra's archief. Bekijk die repository ook voor voorbeeldcode voor audio!

• pico_scanvideo - bevat uitgebreide documentatie!

De API voert parallelle RGB-gegevens en synchronisatiesignalen uit op pinnen voor DPI VGA (met behulp van weerstand-DAC's, zoals hierboven beschreven).

Een mooi punt:

• Het standaard PIO scanline programma accepteert run-length gecodeerde data - dit betekent dat je RAM kunt besparen om vlakke kleurvlakken te genereren (ik denk hier aan spelletjes!).

Over het algemeen zou je de pico_scanvideo-bibliotheek in plaats van VGA-uitvoercode vanaf nul te ontwikkelen 🙂

goede codeerpraktijken

Meer demo's

Bekijk de scanvideo map van het pico-playground archief:

• mandelbrot: een mandelbrot generator met een 320x240x16 framebuffer
• sprite_demo: stuiterende Ebenkoppen (video bovenaan onze pagina!)
• testpatroon: Kleurbalken weergeven

De VGA-kaart gebruiken

Je moet een extra parameter doorgeven aan CMake tijdens het compileren:

-DPICO_BOARD=vgaboard

• https://forums.pimoroni.com/t/pico-vga-demo-board-instructions-information/16296/8

TBD: Stapsgewijze gidsen toevoegen

DVI: Digitale visuele interface

Technologie gaat verder. Het leven gaat verder. CRT's raakten steeds meer verouderd en werden vervangen door modernere platte schermen met digitale interfaces. Geen bewegende balken, alleen pixels.

Een tijdlang bleven signalen analoog - maar dit is niet erg wenselijk, omdat we iets digitaals moeten nemen, het moeten omzetten in iets analoogs en het dan weer moeten omzetten in iets digitaals. Het beeld zal minder precies zijn en we hebben extra schakelingen die we achterwege zouden kunnen laten.

DVI deed zijn intrede. Het bood slim genoeg een optie om ook analoge signalen door te geven, zodat eenvoudige DVI naar VGA adapters / kabels gebouwd konden worden. Natuurlijk moest de grafische kaart zowel analoge als digitale gegevens uitvoeren. Maar dit hielp om de standaard geaccepteerd te krijgen en wijdverspreid te maken.

We zijn hier geïnteresseerd in de digitale signalen (DVI-D), omdat we ze willen bit-bangen vanaf de Raspberry Pi Pico.

Met DVI-D worden de beeldgegevens serieel verzonden.

Een "single link" (meest elementaire) DVI-verbinding bestaat uit vier zogenaamde TMDS-verbindingen (transition minimized differential signaling):

• rood
• groen
• blauw
• pixelklok

Differentiële signalering wordt gebruikt om interferentie te minimaliseren (omdat

We hebben in totaal 24 bits per pixel (8 bits x 3 kleuren) en coderen de gegevens met 8b10b codering (8 bits worden toegewezen aan 10-bits symbolen op de fysieke lijn om onder andere DC-balans te bereiken).

DVI behandelt de pixels op dezelfde manier als VGA: alles wordt opnieuw verzonden telkens als het beeld opnieuw "start" en de gegevens worden nauwkeurig geklokt. Dit is zoals een telefoonlijn, waar de lijn constant in gebruik is wanneer twee mensen praten.

Opmerking: in tegenstelling tot dit, DisplayPort behandelt de gegevens als pakketten - wat een aantal voordelen heeft.

In tegenstelling tot het hierboven besproken VGA-voorbeeld, worden de gegevens digitaal verzonden in plaats van analoge helderheidswaarden.

Luke Wren, een ingenieur met Raspberry Pi, geloofde dat de RP2040 (in het hart van de Pico) ook in staat zou zijn om DVI output aan te sturen, wederom met behulp van PIO.

Het resultaat is de PicoDVI opslagplaats & projecten, en de Pico DVI Sok.

Luke Wren berekende dat ongeveer 252 Mbps seriële gegevens moet worden aangestuurd via de digitale GPIO-pads - differentieel serieel, dat wordt geëmuleerd met twee single-ended pads.

Hierboven zie je het circuit dat wordt gebruikt om de DVI-uitgang aan te sturen (met behulp van een HDMI-connector, waarover hieronder meer) - zijn eenvoudigweg een aantal 270 Ohm weerstanden.

Luke Wren is zelfs nog verder gegaan en heeft een dubbele DVI-uitgang toegevoegd aan zijn PicoDVI layout door middel van een plugin-board:

HDMI: neerwaarts compatibel met DVI

HDMI is de volgende evolutie van connectoren (en concurreert met DisplayPort). Het is volledig neerwaarts compatibel met de digitale DVI signalen - je kunt dus eenvoudige, puur passieve DVI / HDMI converters gebruiken.

Pico DVI Sok

De Pico DVI Sock is een eenvoudige en goedkope oplossing om digitale video-output aan je Pi toe te voegen. Het is ontworpen door Luke Wren (zie beschrijving hierboven). Het is een DVI-uitgang met een HDMI-connector. Omdat HDMI neerwaarts compatibel is met DVI, kun je een HDMI kabel gebruiken om je Pico aan te sluiten op HDMI schermen:

De Pico DVI Sock programmeren

TL;DR

U kunt onze picodvi-test.zip en ga aan de slag met de .UF2 voorbeeldcompilaties die erin staan. Het bevat ook een PDF met een stap-voor-stap handleiding.

Code-voorbeelden

Luke Wren biedt codevoorbeelden in zijn repository. Om ze echter te gebruiken met de Pico DVI Sock, moet je de juiste configuratie instellen om te gebruiken. In deze mini-tutorial laten we je zien hoe.

Vereisten voor installatie

sudo apt install cmake gcc-arm-none-eabi libnewlib-arm-none-eabi build-essential

Kloon PicoDVI repo van Luke Wren:

cd ~
mkdir pico
cd pico 
git clone https://github.com/raspberrypi/pico-sdk
cd pico-sdk
git submodule update --init
cd ~/pico
git clone https://github.com/Wren6991/PicoDVI.git

Om de codevoorbeelden met de Pico DVI Sock te gebruiken, moet je de optie juiste pin-configuratie te gebruiken. Voeg de volgende regel toe aan common_dvi_pin_configs.h gewoon voor de eerste #ifndef

#define DEFAULT_DVI_SERIAL_CONFIG pico_sock_cfg

De voorbeelden bouwen

cd PicoDVI/software/
mkdir build
cd build
export PICO_SDK_PATH=~/pico/pico-sdk
make -j$(nproc)

Installeer de voorbeelden op de Pico

De gebouwde voorbeelden staan in de map software/build/apps.

Houd de BOOTSEL-toets op de Pico ingedrukt en sluit het bord vervolgens aan op je PC via de microUSB-connector. Kopieer en plak het juiste .uf2-bestand dat je wilt proberen - bijvoorbeeld sprite_bounce.uf2 - naar de Pico.

De Pico zal automatisch herstarten en je zou uitvoer moeten kunnen zien op de HDMI-connector (onthoud dat het eigenlijk DVI is :-)).

Download

U kunt onze picodvi-test.zip en ga aan de slag met de .UF2 voorbeeldcompilaties die erin staan. Het bevat ook een PDF met een stap-voor-stap handleiding. Als de sprite_stuiteren.uf2 voorbeeld niet werkt, probeer dan een andere monitor - mogelijk zijn niet alle monitoren compatibel met deze video-uitgang.

Als je al zo ver bent, laat ons dan in de reacties weten hoe het voor jou werkte en welke projectideeën je hebt opgedaan!

Koop een Pico DVI Sok

Onze zusterpagina, buyzero.de, verkoopt de Pico DVI Sok in twee varianten:

• Alleen Pico DVI-sok (voor zelf solderen) @ 6,58 € momenteel
• Pico DVI Sock op Pico, met voorgesoldeerde headers @ 17,89 € momenteel

Sidenote: DBI & DSI-schermen

• https://github.com/raspberrypi/pico-extras/tree/master/src/common/pico_scanvideo

Terzijde: de Raspberry Pi Pico Extras repository heeft plaatshouders voor DBI (16 bit MIPI DBI displays - waarbij gegevens parallel worden doorgegeven) en DSI (MIPI seriële displays), dus mogelijk zien we in de toekomst ook ondersteuning voor deze displays.