Pipboy gebouwd van schroot - Ajarnpa

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

Dit is mijn werkende Pipboy, opgebouwd uit willekeurige rommel uit de garage en een inval in mijn voorraad elektronische componenten. Ik vond dit een uitdagende build en het kostte me enkele maanden werk, dus ik zou dit niet als een compleet beginnersproject categoriseren. Vaardigheden die nodig zijn, zijn onder meer kunststof- en houtbewerking, elektronica en coderen. De carrosserie is opgebouwd uit verschillende stukjes schroot die aan elkaar zijn gesneden en aan elkaar zijn gelast. Ik gebruikte een Raspberry Pi 0 als microcontroller, met een display-header gemonteerd op een deel van de GPIO-pinnen. De overige pinnen worden gebruikt om LED's aan te sturen en knoppen/bedieningselementen aan te sluiten. Ik heb een gebruikersinterface in "Pipboy"-stijl geschreven met enkele demoschermen in Python om het project te voltooien.

Mijn doelen voor het project waren:

• Moest werken - d.w.z. moest echt een display hebben dat dingen deed
• Ik wilde dat het een "draaiknop" had om de verschillende schermen te selecteren, omdat dat voor mij altijd opviel als een iconisch onderdeel van de gebruikersinterface in Fallout
• De hele build moest worden voltooid met spullen die ik al in de garage of in mijn kantoor had (dit was niet helemaal gelukt, maar ik kwam in de buurt - meer dan 90% hiervan waren gevonden items of spullen die ik al had liggen)
• Moet draagbaar zijn

Een doel dat ik niet had, was om er een exacte replica van te maken van een van de in-game modellen - ik bouw liever dingen "in de stijl" van een ding, omdat het me ruimte geeft om willekeurige rommel die ik vind aan te passen, en laat ik wat creatiever zijn. Eindelijk, ja ik weet dat je deze kunt kopen, maar daar ging het ook niet om;)

Benodigdheden

Benodigdheden

• Brede doorlaatpijp (zoals een stuk afvoerpijp)
• Schrootplastic (zowel voor het creëren van het lichaam als voor decoratieve doeleinden)
• Kleine container
• Foam vloermat
• Raspberry Pi
• 3,5-inch scherm
• KY040 roterende encoder
• 3x LED's
• 2x Drukknoppen
• Powerbank
• Bedrading
• Schroeven, lijmen, verven, plamuur enz

Gereedschap

• Dremmel
• Multitool met frees en schuurhulpstukken
• Oefening
• Bestanden
• Soldeerbout
• Heet lijmpistool
• Schroevendraaier(s)
• Scherp mes
• Zaag

Stap 1: Het hart van de Pipboy bouwen

Het eerste wat ik moest doen, was ervoor zorgen dat ik een display en microcontroller kon krijgen in een vormfactor waarmee ik kon werken. Ik had toevallig een 3,5-inch scherm dat ronddraaide en dat als een HAT op de GPIO-pinnen van een Raspberry PI zit, dus ik besloot dit te gebruiken. Ik combineerde het met een Raspberry Pi 0 en zorgde ervoor dat het goed werkte, er zijn een enkele stappen om Linux het scherm te laten herkennen dat u moet doorlopen.

Zoals je op de tweede foto kunt zien, heb ik een klein platform van karton/schuim toegevoegd dat ik op de behuizing heb geplakt om het scherm te ondersteunen. Ik deed dit omdat ik wist dat ik dit onderdeel veel zou moeten hanteren en ik geen pinnen of het scherm wilde breken door gebrek aan ondersteuning. Uiteindelijk werd dit vervangen, maar het was een goede extra bescherming tijdens het bouwproces.

Het is op dit punt ook de moeite waard om op te merken dat ik later in de build prestatieproblemen met deze opstelling tegenkwam - voornamelijk de verversingssnelheid over de interface tussen de Pi en het scherm, ik zal hier later in de build meer op ingaan, maar als ik dit opnieuw deed, zou ik hier andere hardware kunnen overwegen.

Hier zijn enkele handige links hiervoor:

www.raspberrypi.org/forums/viewtopic.php?t…

www.raspberrypi.org/forums/viewtopic.php?t…

www.raspberrypi.org/forums/viewtopic.php?f…

learn.sparkfun.com/tutorials/serial-periph…

Ik zal ook in de github die hieraan is gekoppeld enkele opmerkingen opnemen over wat ik eigenlijk heb gedaan om dit te laten werken (hoewel er door mijn lezing van het onderwerp veel variabiliteit is in hoe dit werkt voor specifieke instanties / stuurprogramma's, dus uw millage kan variëren).

Stap 2: Kartonnen prototype

Ik vond een oude dakgoot / pijp die ik voor de carrosserie kon gebruiken, maar ik moest een ontwerp bedenken voor het daadwerkelijke schermgebied en het bedieningspaneel. Hiervoor heb ik gewoon kartonnen mock-ups gemaakt en plakband gebruikt om ze op de pijp te bevestigen. De eerste was een simpele "doos", maar het voelde te simpel, dus ik heb het aangepast om het schermgebied interessanter te maken en een apart bedieningspaneel toegevoegd. Dit werd min of meer het definitieve ontwerp (er waren een paar aanpassingen zoals je zult zien, maar het komt in de buurt).

Stap 3: Van prototype tot sjabloon

Nu had ik een prototype waar ik blij mee was, ik kon het karton plat maken en er een sjabloon van maken die ik vervolgens transponeerde op een deel van een oude pc-behuizing die ik had staan schoppen. Elk soortgelijk hard plastic zou werken, ik gebruikte alleen rommel die ik bij de hand had. Toen ik eenmaal was uitgelijnd, kon ik de stukken uitknippen, zodat ik kon beginnen met het monteren van het hoofdlichaam. Een handige tip hier, om het gemakkelijker te maken om het plastic te markeren en vervolgens te snijden, ik heb de gebieden die ik zou moeten snijden eerst met plakband bedekt, dit gaf me een gemakkelijkere manier om de sjabloon op het plastic te tekenen, en iets om te voorkomen dat de doorslijpschijf wegglijdt terwijl ik de eerste sneden maakte.

Stap 4: Case toevoegen voor Screen & Pi

Ik wilde dat de hoeken van het schermgebied gebogen zouden zijn en ik had iets nodig om de Pi en het display echt in te houden - mijn oplossing was om een kleine plastic container te gebruiken die ik had. Ik heb een gat uit de bovenkant van het lichaam gesneden en de container hierdoor gelijmd. Daarna heb ik alle kanten aan elkaar gelijmd. Ik heb hier superlijm gebruikt met veel zuiveringszout om de lassen te versterken. Later heb ik alles gevuld en gevijld / geschuurd om het allemaal op te ruimen en het een meer "gegoten" gevoel te geven.

Stap 5: Herhaal dit voor het Configuratiescherm

Vervolgens heb ik precies hetzelfde sjabloon getransponeerd, gesneden en gelijmd om de behuizing van het bedieningspaneel te bouwen.

Stap 6: Knip de pijp uit

Zoals je kunt zien, zit de container die ik van plan ben te gebruiken om de belangrijkste elektronische componenten te huisvesten nu trots in de zwarte plastic rand, dit betekent dat ik een opening in de pijp moet maken om erin te passen. Ik gebruikte opnieuw plakband om uit te lijnen waar ik wilde snijden en knipte een vierkant van de pijp uit zodat de onderdelen zouden passen.

Stap 7: Bezel

Een uitdaging die ik mezelf per ongeluk opdrong, was proberen een rand te bedenken die het gebied rond het scherm zou vullen tot aan de randen van de container. Helaas heeft de manier waarop het scherm is gemaakt ook niets nuttigs in zijn ontwerp (zoals gaten of iets anders) om het te helpen monteren, dus de rand moest het scherm ook op zijn plaats houden. Mijn eerste poging (hier te zien) was een mengsel van plastic en schuim. Uiteindelijk heb ik dit meerdere keren herhaald en het werd uiteindelijk een van de meer uitdagende delen van de build. Verergerd door de kleine toleranties en delicate aard van zowel de ring zelf als het scherm.

Stap 8: Batterijtest

Op dit punt bedacht ik hoe ik dit onafhankelijk van een door het lichtnet geleverde USB kon laten werken. Ik heb verschillende batterijen getest en ontdekte dat het Raspberry Pi + -scherm eigenlijk niet zoveel stroom trok en het was perfect gelukkig op zelfs een van mijn kleinere batterijpakketten (een gratis geschenk van een beurs). Dit was echt een geluk omdat het pakket perfect in een opening in de build paste (foto's later). Nu kunnen we de hoofdcomponenten van het lichaam tijdelijk aan elkaar plakken en onze eerste testrun ervan op mijn arm krijgen!

Stap 9: Fit testen

Hier kun je zien waar ik de kernpijp verder heb aangepast om toegang te krijgen tot de onderkant van de componenten. Je kunt ook zien hoe ik geluk heb gehad met de batterij die mooi in een holte aan een kant van de Pi-container paste. Eindelijk begon het proces van het opruimen van de bindingen, vullen, schuren en deed een testlaag primer om een idee te krijgen van de afgewerkte look (ik wist in dit stadium dat ik dit nog vele malen zou schuren en bijna al die primer zou verdwijnen, maar ik wilde een idee krijgen van hoe het eruit zou zien).

Stap 10: besturingselementen en detaillering toevoegen

Ik wilde een reeks rood/geel/groene LED's om een meter te vormen, evenals een draaiknop en minstens 2 drukknoppen. Deze werden allemaal op het bedieningspaneelgedeelte gemonteerd - gewoon een kwestie van alle juiste gaten boren. Ik begon ook kleine stukjes plastic afvalcomponenten toe te voegen (eigenlijk kitbashing) om details en meer interesse aan de body en het bedieningspaneel toe te voegen.

Stap 11: Bezel Rebuild No. 3"

Zoals ik eerder al zei, worstelde ik met de bezel voor deze build en heb ik deze verschillende keren opnieuw opgebouwd. Dit is de derde iteratie waar ik bij blijf. Mijn benadering hier om hardboard te gebruiken en 2 verschillende vormen te snijden, de ene denker dan de andere en ze vervolgens aan elkaar te lijmen (en vastgeklemd) om de middelste afbeelding te vormen. Door deze vormen kon het vierkante display erin zitten en vervolgens hield het het display op zijn plaats in de container (zoals in afbeelding 3). Dit gaf me net genoeg materiaal om 4 zeer kleine schroeven als bevestigingen te gebruiken - die ik gebruikte om dit stevig op zijn plaats in de behuizing te bevestigen, en het zou op zijn beurt het scherm stabiel en veilig houden. Achteraf zou ik een scherm vinden dat werd geleverd met een aantal fatsoenlijke montage-opties (of een 3D-printer gebruiken - die ik op dat moment niet had).

Stap 12: Prototyping van de elektronica

Ik gebruik een breadboard om mijn eenvoudige circuits op deze manier in te delen, en omdat ik dit deel van het project vaak in een andere ruimte doe dan de constructie van het hoofdgedeelte, heb ik het ook gekoppeld aan een andere Raspberry PI. Hier gebruikte ik een model 3, wat me wat meer kracht gaf om er daadwerkelijk rechtstreeks verbinding mee te maken en een IDE aan boord uit te voeren. Dit maakte het maken van snelle code-prototyping een beetje gemakkelijker voor mij. Er zijn tal van andere manieren om op afstand verbinding te maken / code / foutopsporing, dit is gewoon wat ik hier liever deed.

Het ontwerp hier is vrij eenvoudig, we hebben;

1. Roterende encoder - dit gebruikt een grond en een aantal GPIO-pinnen om de klikrichting en de drukknop aan te pakken.
2. Paar drukknoppen, deze gebruiken gewoon elk een enkele GPIO-pin en een gemeenschappelijke aarde
3. 3 LED's, elk met een inline-weerstand om te voorkomen dat ze knallen, allemaal naar een gemeenschappelijke basis, maar met elk een individuele GPIO-pin zodat elk afzonderlijk kan worden geadresseerd.

Dit gaf me 3 LED's voor mijn meter, een roterende encoder om door de schermen op de pipboy te draaien en 3 drukknoppen om acties aan te sturen (één op de roterende encoder en 2 afzonderlijk bedraad). Dit was ongeveer alles wat ik kon passen, en met het scherm dat een aantal pinnen in beslag neemt, verbruikt het vrijwel wat je hebt op een standaard Pi GPIO-lay-out. Maar voor mijn doeleinden was het prima.

De tweede foto toont min of meer de uiteindelijke interne lay-out waar ik mee ging. Ik heb hier enige tijd doorgebracht met het testen van manieren om de componenten aan te sturen en te verifiëren dat alles werkte voordat ik dit in de body van de build vertaalde. Alle code staat in github.

Een opmerking over roterende encoders. Ik heb veel tijd besteed aan het schrijven van mijn eigen Rotary Encoder-statusmachine om de GPIO-hoog/laag-veranderingen bij te houden en deze toe te wijzen aan roterende posities. Ik had hier wisselend succes, ik kreeg het werkend voor "de meeste" gevallen, maar er zijn altijd randgevallen en (de)bouncing enz. om mee om te gaan. Het is veel, veel gemakkelijker om een kant-en-klare bibliotheek te gebruiken en er is een geweldige voor deze beschikbaar om te installeren voor Python. Ik heb dat uiteindelijk gebruikt omdat het me in staat stelde me te concentreren op het leuke deel van het bouwen, in plaats van eeuwig bezig te zijn met het debuggen van problemen. Alle details daarvoor zijn opgenomen in de broncode.

Als Raspberry Pi, GPIO en elektronica nieuw voor je zijn, raad ik de volgende tutorials ten zeerste aan die je door alles leiden wat je nodig hebt om de bovenstaande lay-out te doen;

projects.raspberrypi.org/en/projects/physi…

thepihut.com/blogs/raspberry-pi-tutorials/…

Stap 13: De elektronica in het lichaam omzetten

Nadat ik de lay-out met een breadboard had voltooid, was het tijd om na te denken over hoe deze in de body van de pipboy te monteren. Ik besloot dat ik het zo wilde maken dat ik alle elektronische componenten kon demonteren en verwijderen voor het geval ik in de toekomst iets zou moeten repareren of veranderen. Om dit te bereiken, heb ik besloten om alle sub-onderdelen plug-able te maken met behulp van dupont-connectoren.

Voor de knoppen heb ik wat verlengdraden gesoldeerd en draadwikkel gebruikt om de uiteinden te isoleren, hierdoor kon ik deze van het lichaam monteren en demonteren (bijvoorbeeld om te testen, dan te schilderen, enz.). De Rotary Encoder had al pinnen die geschikt waren voor dupont-connectoren, dus ik moest alleen wat draden van de juiste lengte maken.

De LED's vergden wat meer werk - hiervoor besloot ik een beetje plastic afval te gebruiken dat ik had (op maat gesneden) om een verwijderbaar paneel te maken om de LED's in te monteren. Daarna heb ik ze warm op hun plaats gelijmd en de weerstanden en draden gesoldeerd. Dit maakte een verwijderingseenheid die ik kon plaatsen en verwijderen en maakte het schilderen en afwerken gemakkelijker.

Merk op dat mijn solderen verschrikkelijk is, dus ik hield dit simpel en vermeed iets dat te gedetailleerd/fijn was. Op de laatste foto kun je zien dat ik ook een paar hele kleine broadboards (5x5) had, ik gebruikte een van deze aan de binnenkant om een paneel te vormen om alles van / naar de GPIO te verbinden. Dit was met name handig om een gemeenschappelijke grondrail te maken die ik kon gebruiken en om te voorkomen dat er veel aarddraden terug naar de Pi kronkelden.

Vervolgens heb ik verschillende gaten in de container gesneden om de draden door te voeren naar de Pi en verbinding te maken met de GPIO. Met dit ontwerp kon ik alles verwijderen als dat nodig was (iets dat ik verschillende keren heb gedaan terwijl ik de bouw aan het afronden was).

Stap 14: Fijnafstemming van de pasvorm

Op dit punt kwam ik een aantal "fit"-problemen tegen. Ten eerste betekende het gebruik van dupont-connectoren voor de bedrading dat het moeilijk was om ze op de pinnen te krijgen met de display-hoed op zijn plaats, omdat er niet genoeg vrije hoogte was. Ik loste dit op door (dit is een van de weinige dingen die ik daadwerkelijk voor dit project heb gekocht) een kleine GPIO-pin-extender te kopen, zodat ik de display-hoed hoger kon laten zitten en ruimte liet om toegang te krijgen tot de resterende GPIO-pinnen met behulp van dupont-connectoren.

Ik heb ook wat kleine stukjes schuimrubberen vloermat gesneden om wat zijdelingse vulling in de container te maken, dit hielp om de Pi + Display op de juiste plaats te plaatsen en te voorkomen dat deze rondbeweegde.

Stap 15: Retro-up van de roterende encoder

Roterende encoders komen vaak (net als de mijne) met een mooie glanzende moderne "hi-fi"-stijl knop. Dit paste totaal niet bij de build, dus ik moest iets anders verzinnen. In mijn willekeurige doos met onderdelen kwam ik een oud tandwiel tegen van een boormachine die ik lang geleden had gebroken. Dit zag er goed uit, maar paste niet op de roterende encoder. Mijn oplossing hier was om verschillende muurpluggen uit te proberen totdat ik er een vond die op de draaiknop paste, en deze vervolgens in vorm te snijden, zodat ik deze als een "binnenkraag" kon gebruiken om het boortandwiel op de roterende encoder te plaatsen als een meer passend thema controle.

Stap 16: Binnenvoering

Meer foam vloertegels! Deze keer heb ik ze gebruikt om een zachte voering te maken om het een comfortabelere pasvorm te geven (zonder dat het te los zit). Door een gat uit het schuim te snijden, kon ik ook een deel van de "klont" absorberen die de container voor de Pi maakt. Over het algemeen maakte dit het veel draagbaarder. Niet weergegeven op deze foto's, maar ik heb het iets groter gemaakt dan het hoofdgedeelte, zodat het zichtbaar is aan de uiteinden, die ik later heb geverfd en het hielp allemaal om een beetje contrast en interesse toe te voegen aan het voltooide item.

Stap 17: Details toevoegen

Tijd om wat decoratie toe te voegen en het interessanter te maken. Allereerst heb ik wat stukjes plastic langs één kant toegevoegd om het een beetje visueel interessant te maken. Toen voegde ik wat nepdraden toe aan sommige terminals en duwde ze gewoon in een gat dat ik in het lichaam boorde. Dit werd later allemaal in verschillende kleuren geverfd.

Stap 18: Body Build schilderen en afwerken

Ik was niet al te bezorgd over een onberispelijke afwerking - zoals het hoort te zijn oud en toch goed gebruikt (in feite kan ik terugkomen en er op een gegeven moment nog meer verwering op doen). Maar ik wilde wel dat het eruitzag als een consistent en compleet object dat niet door willekeurige rommel in elkaar werd gegooid (hoewel dat precies was wat het was). Ik heb talloze iteraties doorlopen van schuren, vullen (milliput is mijn favoriete vulmiddel voor plastic) en herhalen. Vervolgens meerdere lagen primer en verf om alle verbindingen verder glad te strijken. Daarna nog schuren en plamuren en nog meer schilderen.

Toen ik eenmaal een look en feel had van het lichaam waar ik blij mee was, begon ik wat details toe te voegen. Ik gebruikte rub en buff op de roosters op de bedieningselementen om ze een meer gaasgevoel te geven. Ook heb ik hier en daar kleine details van verf aangebracht met acrylverf.

Ik dook in mijn verzameling willekeurige stickers en voegde er een paar toe om het effect af te maken. Daarna deed ik een verweringswas met wat gemengde verven om wat vuil en vuil toe te voegen aan de moeilijk bereikbare plaatsen die moeilijk schoon te maken zouden zijn. Dit is op dit moment misschien een beetje te subtiel, en misschien kom ik later terug en voeg er nog wat toe.

Stap 19: Coderen

Een deel van mijn ambitie voor dit project was om het te laten reageren als een echte pipboy - en voor mij is het meest iconische deel van dat in-game het draaien aan de knop om tussen verschillende schermen te schakelen. Om dit te bereiken, besloot ik een pipboy-gebruikersinterface te schrijven die een reeks schermen zou kunnen weergeven en waarmee je ertussen kunt scrollen. Ik wilde de inhoud van de schermen iets maken dat ik gemakkelijk kon veranderen, en inderdaad schermen kon toevoegen/verwijderen.

Ik heb ervoor gekozen om dit in Python te schrijven vanwege de uitstekende ondersteuning voor Raspberry Pi, GPIO enz. Python staat vrij laag op mijn lijst met talen die ik ken, dus dit was een grote leercurve voor mij, en veel van de code is rommelig tot gevolg. Ik zal dit in de loop van de tijd bijwerken omdat ik nog niet alles heb voltooid wat ik hier wilde doen - maar het is dichtbij genoeg om nu te delen, aangezien alle hoofdconcepten er zijn.

Mijn ontwerp voor de UI-code is redelijk eenvoudig, er is een Python-hoofdscript dat het display instelt, de GPIO configureert, de schermen laadt en een oneindige updatelus binnengaat, wachtend op gebruikersgebeurtenissen en het display indien nodig bijwerkt. Daarnaast zijn er verschillende ondersteuningsscripts die helpen om de UI-schermen van tevoren te genereren.

Belangrijkste gebruikte bibliotheken:

• pygame: ik gebruik dit als de motor om de gebruikersinterface uit te voeren, omdat ik hiermee willekeurige afbeeldingen kon tekenen, afbeeldingen, lettertypen kon manipuleren, op volledig scherm kon gaan, enz.
• pyky040: Dit zorgt voor de bediening van de draaiknop en heeft me veel tijd bespaard (met dank aan Raphael Yancey voor het vrijgeven hiervan.
• RPi. GPIO: Voor goed GPIO-rijden speelde ik hier met een paar opties, maar dit gaf me het juiste niveau van flexibiliteit dat ik wilde, vooral met dingen als het gebruik van een reserve GPIO als een andere 3.3v om de roterende encoder aan te drijven, enz.
• ruis: voor het genereren van perlin-ruis, zodat ik een willekeurige golfvorm voor het radioscherm kan maken die er natuurlijker uitziet
• wachtrij: ik kwam een frustrerende bug tegen met timing van gebeurtenissen van de roterende encoder die werd gedraaid en de (zeer) trage verversingssnelheid van het LCD-scherm. Uiteindelijk heb ik dit opgelost door inkomende gebeurtenissen van de roterende encoder in de wachtrij te zetten en ze een voor een uit te kiezen terwijl het scherm werd vernieuwd.
• os, sys, threading, time: allemaal gebruikt voor standaard python-functies

Een opmerking over het ontwerp van de schermbediening. Schermen worden gedefinieerd als een lijst met namen binnen de code. Elk item in de lijst kan een png- of een txt-bestand (of beide) hebben, de code bouwt een cache op voor elk scherm na het zoeken naar bestanden in de linux-directorystructuur die bij de code hoort.

De inhoud van die bestanden wordt ergens anders gegenereerd (met de hand of door andere scripts), waarvan de uitvoer wordt opgeslagen als png- of txt-bestanden die de pipboy UI vervolgens kan laden als een scherm om weer te geven. Dit houdt de belangrijkste "update" -lus relatief schoon en eenvoudig, maar geeft me ook de flexibiliteit om de inhoud van de schermen bij te werken of te wijzigen met nieuwe gegevens als ik dat wil.

Er zijn vreemde uitzonderingen waarbij een paar dingen zijn gecodeerd - zoals de golfvorm voor het willekeurige radioscherm, zoals dat in realtime wordt berekend en geanimeerd.

Als een analogie helpt, beschouw het ontwerp van de gebruikersinterface dan als een extreem ruwe en eenvoudige webbrowser - elk "scherm" is als een heel eenvoudige webpagina die slechts uit één png-, één txt-bestand of een combinatie van beide kan bestaan. De inhoud hiervan is onafhankelijk en wordt gewoon door de gebruikersinterface getekend zoals een browser een webpagina zou tekenen.

Hier zijn links naar de belangrijkste bibliotheken die ik hier heb gebruikt:

www.pygame.org/news

pypi.org/project/pyky040/

pypi.org/project/noise/

Stap 20: Stats-scherm

Geen pipboy zou compleet zijn zonder het klassieke pipboy-silhouet-statistiekenscherm. Hiervoor heeft een vriend van mij een statische-p.webp

Stap 21: Inventarisscherm

Iets dat altijd handig is bij Pi-projecten, is dat er een manier is om basisinformatie weer te geven, zoals het IP-adres dat het is DHCP, enz. Ik besloot het inventarisscherm te overbelasten als een weergave van de Pi-"inventaris" - welke CPU, geheugen, IP-adres enz. Ik heb een klein Linux-script geschreven om deze informatie te verzamelen en deze om te leiden naar een tekstbestand met de juiste naam (.txt) dat het UI-systeem vervolgens oppikt en weergeeft. Op deze manier kan ik, als ik ooit op een andere locatie ben, het script starten en een nieuw.txt-bestand ophalen met het up-to-date IP-adres enz.

Stap 22: Kaartscherm

Dit scherm was een van de complexere schermen om aan te werken. De Raspberry Pi 0 wordt niet geleverd met een GPS-module, maar ik wilde de kaart enige geldigheid geven aan waar de Pi was. Mijn oplossing hiervoor is een apart script dat het Pi-IP-adres ophaalt, gebruik maakt van https://ipinfo.io om een geschatte locatie op te zoeken. Het JSON-antwoord wordt vastgelegd en vervolgens converteer ik de coördinaten, zodat ik een openstreetmap.org-tegel naar beneden kan halen voor de locatie bij benadering.

De tegels komen in meerdere kleuren naar beneden, maar ik wilde een afbeelding op groene schaal die past bij het uiterlijk van de Pipboy en ik kon er geen precies zo vinden, dus schreef ik een groenschaalfilter in Python om de kleuren opnieuw toe te wijzen van de openstreetmap-tegel en vervolgens de nieuwe afbeelding in de cache op een png-bestand.

Tijdens het bovenstaande proces wordt een tekstbestand gegenereerd met de geschatte locatie en coördinaten, en de kaarttegel wordt gemaakt als een png. De pipboy-gebruikersinterface haalt beide bestanden op en overlapt de inhoud om een kaartscherm te creëren dat werkt (binnen de nauwkeurigheid van de IP-adresresolutie naar een locatie).

Stap 23: Gegevensscherm

Dit is slechts een testkaart (gegenereerd door een ander python-script en uitgevoerd naar een png-bestand) die wordt weergegeven om de grootte/lay-out te testen. Ik heb het erin gelaten omdat het nog steeds een beetje handig is om te controleren met hoeveel onroerend goed ik moet spelen bij het spotten van schermen.

Stap 24: Radioscherm

Samen met het kaartscherm is dit het andere scherm dat me echt veel werk heeft bezorgd. Dit is het enige scherm waar ik met animatie heb gespeeld - en het werkt meestal zoals bedoeld, maar de prestaties zijn nog steeds een probleem met de verversingsfrequenties van het LCD-scherm. De structuur van het scherm is een tekstbestand met enkele willekeurig gekozen radionamen (dit zijn slechts willekeurige reeksen en doen niets anders dan een lijst op het scherm weergeven), een png-bestand dat de as van het grafiekgebied bevat (I schreef een ander script om deze te genereren en de-p.webp

Dit is het enige scherm waar de pygame-lus echt werk doet, aangezien elke cyclus de nieuwe golfvorm moet berekenen, het deel van het scherm in dit leven moet wissen en opnieuw moet tekenen.

Stap 25: Laatste gedachten

Dit is misschien wel de meest uitdagende build die ik heb gedaan, met veel verschillende concepten en vaardigheden, maar het is ook een van de leukste met echt werken als resultaat. Ik ben nog steeds bezig met het opruimen van enkele van mijn meer technische aantekeningen, evenals de github-repo voor de code. Dit alles zal ik binnenkort beschikbaar stellen, dus kom snel weer terug voor meer details en informatie als ik tijd heb om ze toe te voegen aan de beschrijving.

Als je iets als dit kunt doen, zou ik graag de resultaten zien en als je vragen hebt, neem dan gerust contact met me op en ik zal proberen om meer informatie toe te voegen in alle stappen waarbij je wilt helpen.

Stap 26: Code openen op Github

Ik ben er eindelijk in geslaagd om de code op Github te openen. Het is beschikbaar via deze link: