RPi 3 stuurboord / deeltjesgenerator - Ajarnpa

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

Verveel je je met je Raspberry Pi? Ben je klaar om de zeer elementaire krachten van het universum te besturen en naar believen fotonen op te roepen en te ontslaan? Wil je gewoon iets interessants om in je woonkamer te hangen, of een mooi project om op facebook te plaatsen om Denise te laten zien dat het goed met je gaat tegenwoordig, heel erg bedankt? Zit je gevangen in een computersimulatie en breng je de uren door tot je wordt bevrijd of verwijderd? Als een of meer van deze u beschrijven, dan [omroeperstem] Welkom!

Deze tutorial laat je zien hoe je een deeltjesgeneratordisplay monteert en instelt met behulp van een Raspberry Pi 3 en enkele RGB-matrixpanelen. Het zou tussen een en twee uur moeten duren, en het eindproduct zal ongeveer 30 "x8" zijn (exclusief de Pi) en aan de muur te bevestigen. Het is een behoorlijk coole decoratie voor een woonkamer, kantoor, speelkamer of waar je het ook maar wilt neerzetten.

Voordat u aan de slag gaat, heeft u het volgende nodig en wat de geschatte kosten zijn:

• Rpi 3 + SD-kaart + hoes + voeding: $ 70 (van Canakit, maar je kunt de onderdelen waarschijnlijk goedkoper krijgen als je ze apart koopt.)
• 4x 32x32 RGB LED Matrix (bij voorkeur p6 indoor met 1/16 scan): $80-$100 verzonden op Alibaba of Aliexpress; $ 160 op Adafruit of Sparkfun.
• Adafruit RGB Matrix-hoed: $ 25
• 5V 4A-voeding: $ 15
• 3D-geprinte clips: $ 1ish (deze zijn om de panelen aan te sluiten en aan de muur te hangen; als je geen toegang hebt tot een 3D-printer, kun je een furring-strip gebruiken om ze bij elkaar te houden en enkele beugels van de ijzerhandel om hang het aan de muur. Ik heb geprobeerd de ontwerpbestanden of de.stls hiervoor te vinden, maar ze lijken van de aarde te zijn verdwenen. De clips zijn echter vrij eenvoudig te modelleren.)
• 14x M4x10 bouten: $ 5ish
• Vier 4x8 IDC-kabels en drie voedingskabels voor de RGB-matrices (ik weet niet hoe deze heten!). Deze hadden bij uw LED-panelen moeten zitten.
• Totaal: ongeveer $ 200, geven of nemen.

Voor het project hoef je niet te solderen of specifieke programmeerkennis te hebben; het gaat ervan uit dat je weet hoe je een afbeelding naar een microSD-kaart moet schrijven. Als je niet zeker weet hoe je dat moet doen, heeft de Raspberry Pi-stichting hier een goede tutorial.

Het gaat er ook van uit dat je een basiskennis hebt van hoe je dingen moet doen vanaf de opdrachtregel in Linux, en de code-walkthrough gaat ervan uit dat je de basis van Python kent (maar - je hoeft de code-walkthrough niet te volgen om te kunnen bouwen en voer de deeltjesgenerator uit.) Als je vastloopt bij een van de stappen, stel dan gerust een vraag of post in /r/raspberry_pi (wat ook, naar ik aanneem, het belangrijkste publiek is voor deze instructable)

Stap 1: Monteer het LED-bord

Eerst ga je de individuele 32x32 LED panelen samenvoegen tot één groot 128x32 paneel. Je moet naar je borden kijken en de kleine pijlen vinden die de verbindingsvolgorde aangeven; op de mijne bevinden ze zich vlak bij de HUB75 / 2x8 IDC-connectoren. Zorg ervoor dat de pijlen wijzen vanaf waar de Rpi wordt aangesloten (naar rechts in de bovenstaande foto) langs de lengte van het bord.

U moet ook de stroomkabels aansluiten. De meeste van deze kabels hebben twee vrouwelijke connectoren die aan de kaarten worden bevestigd en één set spade-aansluitingen die aan de stroombron wordt bevestigd. De panelen waar ik mee werk hebben de indicatoren voor 5V en GND bijna volledig verborgen onder de connectoren zelf, maar de kabels worden maar in één richting aangesloten. Je moet ervoor zorgen dat je alle 5V's met elkaar verbindt en alle GND's met elkaar, want als je deze achteruit aanstuurt, ga je ze vrijwel zeker bakken.

Omdat de stroomkabels die bij mijn boards waren geleverd zo kort waren, moest ik er een verlengen door de uitsteeksels van de spade-terminal in de connector van een andere te steken (dit is vrij eenvoudig - je moet de spade-terminals misschien iets naar binnen buigen, maar ik' heb een foto bijgevoegd voor het geval dat). Ik eindigde met twee sets spade-terminals en een 2x8 IDC-connector aan de rechterkant van mijn nu langwerpige LED-bord.

Je zult ook merken dat ik aan beide uiteinden van het bord twee bouten heb die nergens aan zijn bevestigd; deze bevinden zich aan de bovenkant zodra het hele ding wordt omgedraaid en worden gebruikt om het aan de muur te bevestigen.

Dus - zodra u alle panelen met clips, 2x8 IDC-kabels en stroomkabels aan elkaar hebt verbonden, bent u klaar om door te gaan naar de volgende stap!

Stap 2: Bereid de Raspberry Pi voor

Vervolgens leg je het LED-bord opzij (voorlopig) en maak je de Pi 3 klaar om het te gebruiken. We gebruiken Raspbian Stretch Lite en de RGB-matrixbibliotheek van hzeller (in plaats van de matrixbibliotheek van Adafruit, die ouder en niet onderhouden is).

Eerst wil je de Raspbian Lite-afbeelding naar een SD-kaart schrijven; als je dit eenmaal hebt gedaan, ga je gang en sluit je een monitor en toetsenbord aan op de pi en start je deze op. (Je kunt dit ook zonder hoofd doen, via ssh of een seriële connector, maar als dat de manier is waarop je gaat, heb ik je waarschijnlijk niet nodig om je te vertellen hoe je het moet doen.) Je hebt hiervoor een internetverbinding nodig; Als je wifi hebt, verbind je de Pi met je draadloze netwerk door /etc/wpa_supplicant/wpa_supplicant.conf te bewerken en wpa_cli -i wlan0 reconfigure uit te voeren. (Als je dit nog nooit hebt gedaan, kun je hier instructies krijgen).

Zodra u verbonden bent met internet, werken we de instellingen van de dpkg-repository bij en downloaden we de bibliotheken die we nodig hebben door de volgende opdrachten uit te voeren:

sudo apt-get update

sudo apt-get install git python-dev python-pil

git clone

Nu moeten we de matrixcode compileren en installeren. U gaat dus naar de map met de bibliotheek:

cd rpi-rgb-led-matrix

en compileer het (dit kan even duren):

maak && maak build-python

en installeer de python-bindingen:

sudo make install-python

Als je fouten krijgt tijdens het compileren van de bibliotheekcode, ga dan terug en zorg ervoor dat je python-dev en python-pil correct hebt geïnstalleerd! De python-bindingen kunnen niet worden gecompileerd zonder dat beide pakketten zijn geïnstalleerd.

Je moet ook de geluidsuitvoer van je Pi uitschakelen (het ingebouwde geluid interfereert met de matrixcode) door /boot/config.txt te bewerken. Zoek naar de regel met de tekst dtparam=audio=on en verander deze in dtparam=audio=off.

Als alles goed is gecompileerd (je krijgt een paar waarschuwingen over Wstrict-protoypes), zou je pi klaar moeten zijn om het matrixbord te gebruiken. Ga je gang en sluit het af (sudo shutdown nu), koppel het los en we zullen het lichtbord in de volgende stap op de pi aansluiten.

Stap 3: Verbind Pi + Matrix Hat + LED-bord

Dus, nu je Pi uit en losgekoppeld is, laten we de matrix-hoed verbinden met de pi en het LED-bord met de matrix-hoed. Als je Pi er nog niet in zit, is dit een goed moment om hem erin te plaatsen.

Installeer de matrixhoed door deze op één lijn te brengen met de GPIO-pinnen op de Pi en deze aan beide kanten zachtjes met gelijkmatige kracht naar beneden te duwen. Zorg ervoor dat de pinnen correct zijn uitgelijnd, zodat de vrouwelijke headers op de hoed precies de GPIO-pinnen op de pi bedekken. Als je het verkeerd uitlijnt, is het geen catastrofe; trek het gewoon voorzichtig terug en maak eventuele verbogen pinnen recht.

Zodra je de hoed op hebt, plaats je de Pi rechts van het gemonteerde LED-bord (controleer nogmaals de stroomaansluitingen en zorg ervoor dat de pijlen vanaf de Pi langs de lengte van het bord wijzen) en sluit de IDC aan kabel naar de matrixhoed.

Vervolgens wilt u de spade-aansluitingen voor de stroom aansluiten op het aansluitblok van de matrixhoed. Je hebt twee spade-connectoren per kant, maar ze zouden er allebei goed in moeten passen. Draai eerst de schroeven los en - dit zou vanzelfsprekend moeten zijn - zorg ervoor dat u de 5V-aansluitingen in de kant met het label + plaatst (deze moeten rood zijn, maar - nogmaals - controleer uw connectoren en ga er niet vanuit dat ze correct zijn vervaardigd) en de GND-aansluitingen (deze moeten zwart zijn) aan de kant met het label -. Zodra ze daar zijn, draait u de schroeven bovenop het aansluitblok vast en u zou iets moeten hebben dat lijkt op de kopafbeelding voor deze stap.

Nu - je hebt misschien gemerkt dat deze specifieke configuratie de helft van de schoppenterminal aan weerszijden blootlegt, slechts enkele millimeters boven de matrixhoed (en niet erg veel verder van elkaar). EN - de schoppenterminals zullen zeer binnenkort worden met zowel verschillende volt als verschillende ampères van Raw Power. Is dit (hoor ik je aan de andere kant van het scherm vragen) echt de juiste manier om het te doen? Is het, (je leunt dichterbij en fluistert), een goed idee?

En het antwoord is (antwoord ik, mijn schouders ophalend) - nee, dat is het niet. De juiste manier om dit te doen, is door de klemmen van de stroomkabels te strippen en ze opnieuw in de juiste connector voor dat aansluitblok te krimpen (of om ze als blote draden te laten en ze zonder connector in het blok aan te sluiten). Als dat niet lukt, kunt u wat krimpkous rond de blootgestelde kant van de spadeconnector plaatsen of deze gewoon in isolatietape wikkelen. Maar de wereld is gevallen en de mens is lui en ijdel, dus dat heb ik niet gedaan.

Maar - ingepakt of uitgepakt - de spade-terminals zijn verbonden met het terminalblok en we zijn klaar om door te gaan naar de volgende stap.

Stap 4: Test de RGB-matrix

Nu je Pi is aangesloten op het lichtbord, draai je het bord om en zet je de Pi weer aan. Je kunt de matrix-hoed van stroom voorzien nadat de Pi is aangesloten; als je de hoed echter vóór de Pi aanzet, zal de Pi proberen op te starten met niet genoeg stroom, en bitter klagen (en je een kernel panic geven en helemaal niet opstarten.)

Als je problemen hebt om de Pi op te starten met de matrix-hoed op, zorg er dan voor dat je een krachtige voeding voor de Pi gebruikt (2A+ zou goed moeten zijn) en probeer zowel de voeding voor de hoed als voor de Pii in dezelfde stekkerdoos of verlengsnoer en zet ze samen aan.

Zodra de Pi is opgestart, zijn we klaar om de matrices te testen. Ga naar waar de python bindingsvoorbeelden zijn (cd /rpi-rgb-led-matrix/bindings/python/samples) en probeer de roterende blokgenerator uit met het volgende commando:

sudo./rotating-block-generator.py -m adafruit-hat --led-chain 4

Je moet het als sudo uitvoeren omdat de matrixbibliotheek bij initialisatie low-level toegang tot hardware nodig heeft. De -m specificeert de manier waarop de panelen zijn verbonden met de pi (in dit geval een adafruit-hoed) en de --led-chain specificeert - je raadt het al - hoeveel panelen we aan elkaar hebben geketend. Rijen en kolommen per paneel staan beide standaard op 32, dus daar zitten we goed.

Nu - als je het programma eenmaal hebt uitgevoerd, zal een van de twee (of eigenlijk een van de drie) dingen gebeuren:

• Niks gebeurt
• Je krijgt een mooi roterend blok in het midden van je lichtbord.
• Het lichtbord werkt, uh, denk ik, maar het ziet er… raar uit (de helft is groen, sommige rijen lichten niet op, enz.)

Als er niets gebeurt, of als het paneel er raar uitziet, druk dan op ctrl+c om het voorbeeldprogramma af te sluiten, sluit de pi af en controleer al je verbindingen (IDC-kabel, voeding, zorg dat beide voedingen zijn aangesloten, enz.) Zorg er ook voor dat de hoed correct is aangesloten; als dat het probleem niet oplost, breng het dan naar één paneel (zorg ervoor dat u --led-chain 1 gebruikt bij het testen) en kijk of een van de panelen slecht is. Als DAT niet werkt, bekijk dan de tips voor probleemoplossing van hzeller. als DAT NOG STEEDS niet werkt, probeer dan een bericht te plaatsen op /r/raspberry_pi (of de Adafruit-forums, als je je panels van Adafruit hebt gekregen, of stack-uitwisseling, etc, etc.)

Als het een beetje werkt maar er nog steeds raar uitziet (misschien zoals de kopafbeelding voor deze sectie) nadat je de verbindingen hebt gecontroleerd, is het mogelijk dat je alles correct hebt aangesloten, dat de panelen goed werken, maar dat er iets anders aan de hand is Aan. Dat brengt ons bij onze volgende stap - meer een afleiding dan een stap - op multiplex- en scansnelheden. (Als uw led-bord goed werkt en u niet geïnteresseerd bent in de werking van deze panelen, kunt u de volgende stap overslaan.)

Stap 5: Multiplex- en scansnelheden (of: een tijdelijke omleiding op de weg naar het graf)

Dus een van de fouten die ik maakte toen ik mijn eerste set panelen bij Alibaba bestelde, is dat ik buitenpanelen kreeg (waarom niet, dacht ik - ze zijn waterdicht en helderder!). En toen ik ze aan mijn matrixhoed verbond, zag het er… niet goed uit.

Om te begrijpen waarom dat zo is, nemen we even de tijd om naar Phil Burgess te kijken uit Adafruit's beschrijving van hoe deze panelen werken. U zult merken dat Burgess erop wijst dat de panelen niet al hun LED's tegelijk verlichten - ze lichten reeksen rijen op. De relatie tussen paneelhoogte in pixels en het aantal rijen dat tegelijk oplicht, wordt scansnelheid genoemd. Dus bijvoorbeeld - Op een 32x32 paneel met 1/16 scan worden twee rijen (1 en 17, 2 en 18, 3 en 19, enz.) tegelijk verlicht, helemaal onderaan het bord, en dan herhaalt de controller. De meeste bibliotheken die RGB-matrices aansturen, zijn gebouwd voor panelen waar de scansnelheid 1/2 van de hoogte in pixels is - dat wil zeggen, ze sturen twee rijen LED's tegelijk aan.

Buitenpanelen (en sommige binnenpanelen - zorg ervoor dat u de specificaties bekijkt voordat u bestelt) hebben scansnelheden die 1/4 van de hoogte in pixels zijn, wat betekent dat ze verwachten dat vier lijnen tegelijk worden aangedreven. Dit maakt ze helderder (wat goed is), maar zorgt ervoor dat veel standaardcode er niet mee werkt (wat slecht is). Bovendien hebben ze de neiging om de pixels intern niet in orde te hebben, waardoor de x- en y-waarden in software moeten worden getransformeerd om de juiste pixels aan te pakken. Waarom zijn ze op deze manier gemaakt? Ik heb geen idee. Weet je? Als dat zo is, vertel het me dan alsjeblieft. Anders moet het gewoon een mysterie blijven.

Dus als je een van deze rare buitenpanelen hebt, heb je (waarschijnlijk) geluk! hzeller heeft onlangs ondersteuning voor veelvoorkomende configuraties van dit soort panelen aan zijn bibliotheek toegevoegd. Je kunt er meer over lezen op de github-pagina van het project, maar je kunt --led-multiplexing={0, 1, 2, 3} doorgeven aan de voorbeeldcode (je moet misschien ook doen alsof je een dubbele lengte ketting van halflange panelen) en het zou moeten werken.

Er zijn echter enkele pixeltransformatiepatronen die niet worden ondersteund - en (raad eens) mijn panelen hebben er een! Dus ik moest mijn eigen transformatiecode schrijven (ik moet ook - om welke reden dan ook - de bibliotheek vertellen om te doen alsof ik acht 16x32 panelen aan elkaar heb geketend). die is als volgt:

def transformPixels(j, k): effJ = j % 32

effK = k % 32

modY = k

modX = j

#modX en modY zijn de gewijzigde X en Y;

#effJ en effK zorgen ervoor dat we transformeren binnen een 32x32 matrix voordat we gaan pushen

als ((effJ) > 15):

modX = modX + 16

als ((effK) > 7):

modY = modY - 8

modX = modX + 16

als ((effK) > 15):

modX = modX - 16

als ((effK) > 23):

modY = modY - 8

modX = modX + 16

#Vervolgens duwen we ze naar de juiste locatie (elke x+32 beweegt één paneel)

als (j > 31):

modX += 32

als (j > 63):

modX += 32

als (j > 95):

modX += 32

retour (modX, modY)

Als je een paneel zoals het mijne hebt, kan dit ervoor werken. Als dat niet het geval is, moet je je eigen schrijven - dus, je weet wel, veel geluk en godspeed.

Stap 6: Het Starboard-programma (of: Back on Track en Ready to Pixel)

Nu je matrices operationeel en klaar voor gebruik zijn, hoef je alleen maar het stuurboordprogramma op je Pi te zetten en klaar te maken voor gebruik. Zorg ervoor dat u zich in de homedirectory van de pi-gebruiker bevindt (cd /home/pi) en voer de volgende opdracht uit:

git clone

je zou een nieuwe map moeten hebben, stuurboord, die drie bestanden bevat: LICENSE.md, README.md en starboard_s16.py. Probeer het stuurboordprogramma uit door het door python te laten lopen:

sudo python./starboard_s16.py

en je zou een stel deeltjes moeten krijgen die met verschillende snelheden bewegen en met verschillende snelheden vervallen. Elke 10.000 tikken of zo (je kunt naar het python-script gaan om dit te bewerken/wijzigen) zal het van modus veranderen (er zijn er vier: RGB, HSV, Rainbow en Greyscale).

Dus het enige wat je nu nog hoeft te doen is de stuurboordcode te laten draaien bij het opstarten. We doen dat door (met sudo) /etc/rc.local te bewerken. Wat u wilt doen, is de volgende regel toevoegen vlak voor "exit 0" in het script:

python /home/pi/starboard/starboard_s16.py &

Nadat je dat hebt gedaan, start je de pi opnieuw op - zodra deze de opstartvolgorde heeft doorlopen, zou het starboard_s16.py-script meteen moeten starten!

Als je in het script wilt rondneuzen, voel je dan vrij om dat te doen - het is gelicentieerd onder de GNU GPL 3.0. Als het script niet voor je werkt, of als je er problemen mee hebt, laat het me dan weten of dien een bug in op github, en ik zal zien wat ik kan doen om het te repareren!

Het (aller)laatste dat u misschien wilt doen, is SSH op de pi instellen, zodat u op afstand kunt inloggen en het veilig kunt afsluiten. Je zult /zeker/ je wachtwoord willen wijzigen (via het passwd commando), en je kunt hier instructies vinden om ssh in te schakelen (ook vanaf de commandoregel).