Vorige week heb ik een LED-kubus gebouwd. Hoe maak ik een pulserende Arduino LED-kubus die eruit ziet alsof hij uit de toekomst is gekomen Hoe maak je een pulserende Arduino LED-kubus die eruit ziet alsof hij uit de toekomst kwam? Heb je wat ingewikkeld Arduino-projecten gedaan?, maar zijn op zoek naar iets een beetje permanent en op een heel ander niveau van geweldig, dan is de nederige 4 x 4 x 4 LED-kubus ... Lees meer - 64 LED's die je kunt programmeren om fantastische futuristische lichtshows te maken - en ik Ik hoop dat je het ook gedaan hebt, want het is een geweldig project om je te motiveren en je Arduino skillset uit te breiden. Ik liet je achter met een paar basis-apps om je aan het denken te zetten, maar vandaag zal ik een paar stukjes software presenteren die ik voor de kubus heb gemaakt, samen met code-uitleg. Het doel hiervan is zowel om je wat meer mooie lichtshows te laten zien, maar ook om meer te leren over enkele van de beperkingen van het programmeren van de kubus, en een aantal nieuwe programmeerconcepten in het proces te leren.
Dit is een behoorlijk geavanceerde codering; je moet echt al mijn vorige Arduino-tutorials en onze Arduino-beginnersgids hebben gelezen voordat je de verstrekte code aanpast.
App 1: Mini Snake
In plaats van een reeks slangachtige patroonsequenties uit te voeren, wilde ik een slang programmeren - een kunstmatige - die zijn eigen willekeurige keuzes zou maken en volledig onvoorspelbaar zou zijn. Het is beperkt tot slechts 2 segmenten, die ik later zal uitleggen, en je kunt de demo hieronder bekijken. Download de volledige code hier.
Als u te maken hebt met 3D-ruimte, hebt u 3 coördinaten nodig voor één punt: X, Y en Z.
In onze kubus worden de X- en Z-vlakken echter weergegeven met LED-pinnen, terwijl de Y rechtstreeks wordt toegewezen aan de kathodevlakken. Om het werken met deze coördinaten te vergemakkelijken en bewegingen rond de kubus uit te vinden, heb ik daarom een nieuw datatype gemaakt (met behulp van struct) om een enkel punt op de kubus weer te geven - dat ik "xyz" noemde. Het bestaat uit slechts twee gehele getallen: "xz" en "y". Met deze structuur zou ik dan ook een richting kunnen weergeven, hieronder aangegeven in ons speciale (xz, y) coördinatensysteem:
Y-verplaatsing (omhoog, omlaag) : (xz, y + 1), (xz, y-1)
Z- beweging (vooruit, achteruit) : (xz-1, y), (xz + 1, y)
X-verplaatsing (links, rechts) : (xz + 4, y), (xz-4, y)
Om bijvoorbeeld de LED in positie (0, 0) één naar links te verplaatsen, passen we (xz + 4, y) toe en eindigen met (0, 4) .
Er zijn bepaalde limieten die worden gesteld aan beweging - namelijk dat Y-coördinaten alleen een mogelijke 0 tot 3 kunnen zijn (waarbij 0 de onderste laag is, waarbij 3 de top is) en XZ-coördinaten alleen 0 tot 15 kunnen zijn . Er wordt nog een limiet op de Z-beweging geplaatst om te voorkomen dat er van de achterkant naar de voorkant van de kubus wordt "gesprongen" en vice versa. In dit geval gebruiken we de modulusfunctie om te testen op veelvouden van 4 en die bewegingspoging te ontkennen. Dit is de logica die wordt weergegeven in de geldige functie (), die een waarde oplevert als de voorgestelde richting een acceptabele zet is en anders niet waar. Ik heb nog een functie toegevoegd om te controleren of er een inverse richting is - dat wil zeggen, als de slang in de ene richting gaat, we willen niet dat deze zelf achteruit gaat, ook al is het anders een geldige locatie om naartoe te gaan - en een verplaats () functie, die een coördinaat, een richting neemt en de nieuwe coördinaat retourneert.
De XYZ- datatype-, geldige (), verplaats () en inverse () -functies zijn allemaal te vinden in het xyz.h- bestand in de downloads. Als je je afvraagt waarom dit in een apart bestand is geplaatst in plaats van het hoofdprogrammabestand, dan komt dit door een aantal gecompliceerde Arduino-compilerregels die voorkomen dat functies aangepaste datatypes retourneren ; ze moeten in hun eigen bestand worden geplaatst en vervolgens worden geïmporteerd aan het begin van het hoofdbestand.
Terug in het hoofdruntime-bestand slaat een reeks richtingen alle mogelijke bewegingen op die de slang kan maken; we kunnen eenvoudig een willekeurig arraylid kiezen om een nieuwe richting te krijgen. Variabelen worden ook gemaakt om de huidige locatie (nu), de vorige richting en de vorige locatie op te slaan. De rest van de code zou voor u vrij duidelijk moeten zijn; gewoon f o r loops en het in- en uitschakelen van LED's. In de hoofdlus controleren we of de voorgestelde richting geldig is en als dat het geval is, gaan we die kant op. Zo niet, dan kiezen we een nieuwe richting.
Het enige dat in de hoofdlus moet worden aangegeven, is een aantal controles om een fout te herstellen die ik bij multiplexen tegenkwam: als de nieuwe locatie zich op hetzelfde kathodevlak of dezelfde anodepen bevond, zou het uitschakelen van de vorige LED resulteren in beide uitgangen. Het is ook op dit punt dat ik me realiseerde dat verder gaan dan een slang met 2 segmenten onmogelijk zou zijn met mijn huidige implementatie: probeer 3 LED's in een hoekopstelling op te lichten. Dat kun je niet, omdat met 2 lagen en 2 LED's pins geactiveerd zijn, 4 LED's zouden branden, niet 3. Dit is inherent aan ons beperkte gemultiplexeerde kubusontwerp, maar maak je geen zorgen: we moeten gewoon de kracht van persistentie gebruiken van visie om de trekkingsmethode te herschrijven.
Persistentie van zicht houdt in dat wanneer het licht sequentieel in onze ogen komt - sneller dan we het kunnen verwerken - het lijkt een enkel beeld te zijn. In ons geval moeten we in plaats van alle vier lagen tegelijk te tekenen, de eerste tekenen, deactiveren, de tweede tekenen en deactiveren: sneller dan we kunnen zien dat er zelfs maar iets verandert. Dit is het principe waarop berichtenschrijvers werken, zoals deze:
Nieuwe tekenmethode met behulp van Persistence of Vision
Allereerst een nieuwe tekenroutine. Ik heb een 4 x 16 tweedimensionale array van bits (true of false) gemaakt om een letterlijke weergave te zijn van de toestand van de LED-kubus. De trekkingsroutine implementeert persistentie van het gezichtsvermogen door dit eenvoudig te herhalen en elke laag even uit te spoelen naar de kubus. Hij blijft zichzelf in de huidige status tekenen totdat de verversingstijd is verstreken, waarna we de besturing weer teruggeven aan de hoofdlus (). Ik heb dit gedeelte van de code in dit LED_cube_POV-bestand opgeslagen, dus als je gewoon wilt beginnen met het programmeren van je eigen games en dergelijke, voel je dan vrij om dit als basis te gebruiken.
App 2: Game of Life
Laten we dit voorlopig ontwikkelen tot een basisversie van Conway's Game Of Life. Voor degenen onder jullie die onbekend zijn (probeer Googlen om een geweldige paasei-animatie te vinden), het Game of Life is een voorbeeld van cellulaire automaten die een fascinerend patroon van emergent gedrag creëren, gegeven slechts een paar eenvoudige regels.
http://www.youtube.com/watch?v=XcuBvj0pw-E
Dit is bijvoorbeeld hoe mieren lijken te bewegen met intelligentie en een bijenkorfgeest, ondanks het biologische feit dat ze feitelijk gewoon heel basale hormonale regels volgen. Hier is de volledige code om te downloaden: druk op de resetknop om opnieuw te starten. Als je merkt dat je steeds hetzelfde patroon krijgt, probeer dan de rustknop langer ingedrukt te houden.
http://www.youtube.com/watch?v=iBnL8pulJ
Hier zijn de regels van het spel van het leven:
- Elke levende cel met minder dan twee live buren sterft, alsof veroorzaakt door onderpopulatie.
- Elke levende cel met twee of drie levende buren leeft voort op de volgende generatie.
- Elke levende cel met meer dan drie live buren sterft als door overbevolking.
- Elke dode cel met precies drie levende buren wordt een levende cel, als door reproductie.
Voer de code uit. U zult merken dat binnen 5 tot 10 "generaties" de automaten waarschijnlijk tot rust zijn gekomen, zich stabiliserend op een bepaalde positie; soms verandert dit stabiele patroon van locatie en verschuift het over het bord. In zeldzame gevallen kunnen ze zelfs volledig zijn uitgestorven. Dit is een beperking van het hebben van alleen 4x4x4 LED's om mee te werken, maar het is sowieso een goede leeroefening.
Om de code uit te leggen:
- Mogelijk bent u niet vertrouwd met de functie memcpy () . Ik heb dit gebruikt om de vorige spelstatus op te slaan, omdat arrays niet zomaar aan elkaar kunnen worden toegewezen als normale variabelen - je moet de geheugenruimte daadwerkelijk kopiëren (in dit geval 64 bits).
- howManyNeighbours () functie moet voor zichzelf spreken, maar voor het geval dat niet het geval is - deze methode neemt een enkele coördinaat en loopt door elke mogelijke buur (dezelfde reeks richtingen die we eerder in de snake-app hebben gebruikt) om te controleren of ze geldig zijn . Vervolgens wordt gecontroleerd of die buren-LED's in de vorige spelstatus 'aan' waren en telt het aantal.
- De hoofdfunctie van deze Game of Life-app is progressGame (), die de automataregels toepast op de huidige spelstatus.
Verbeteringen : ik heb er tot nu toe veel te lang over gedaan, maar misschien wil je proberen een cheque toe te voegen die automatisch het bord reset na 5 generaties van hetzelfde patroon. laat het me dan weten! Ik zou ook voorstellen om de POV-methode toe te voegen aan het slangenspel om hopelijk een langere slang mogelijk te maken.
Dat is het vandaag van mij. Ik zou op een later tijdstip nog een aantal Arduino LED-kubus-apps kunnen bezoeken, maar hopelijk zou je in staat moeten zijn mijn code aan te passen en je eigen spelregels te maken: laat ons weten wat je verzint in de reacties, zodat we allemaal kunnen downloaden jouw creaties! Zoals altijd zal ik hier zijn om je vragen te beantwoorden en mijn verschrikkelijke codeervaardigheden te verdedigen.
Beeldcredits: cartesische coördinaten - Wikimedia-gebruiker Sakurambo