Interactief omgevingslicht: 8 stappen

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

Dit is mijn eerste instructable! Heb alsjeblieft geduld met me terwijl ik worstel om goed Engels te schrijven. Corrigeer me gerust! Ik ben met dit project begonnen net nadat de wedstrijd 'Let it glow' was begonnen. Ik wou dat ik nog veel meer had gemaakt en af had gemaakt wat ik wilde maken. Maar tussen school en werk heb ik niet zoveel tijd meer gehad als ik had gewild. Desalniettemin laat ik hier een verslag van mijn experimenten achter als een instructable, zodat iedereen kan proberen wat ik deed. Dit instructable is niet bedoeld om als gids te dienen en te leren hoe dit ding te maken. Het is geen gids voor beginners in elektronica. Het is meer als het delen van één idee en doel dat ik wil nastreven. Als je een beginner bent / totaal onwetend bent in elektronica en zoiets wilt maken, dan spijt het me! Maar we kunnen proberen je altijd te helpen. Zie de laatste stap. We hebben al veel omgevingslichtprojecten gezien. De meeste gebruiken RGB-LED's: - Om een kamer met één kleur te verlichten, een sfeer in te stellen die bij uw stemming past - Om lichteffecten te creëren op basis van kleur van TV/Monitor of van audio. Er zijn er zelfs een paar op instructables.com. Ik heb altijd al iets willen maken dat lijkt op deze sfeerverlichting en de muren in mijn kamer vullen met RGB-LED's. Maar nog een stap verder gaan, waardoor ze allemaal en elk beheersbaar zijn. Dit project zal hopelijk resulteren in een open-source elektronicakit voor hobbyisten en elektronische knutselaars, die hardware/software hacking en sensorische integratie mogelijk maakt. Hier is een kleine preview van wat ik heb gemaakt:

Stap 1: Het idee verkennen

Ik wil de muren in mijn kamer kunnen vullen met RGB-LED's, waarbij ik de kleur en helderheid voor elke led regel. Ik ga een microcontroller gebruiken voor het gebruiksgemak en de flexibiliteit die geboden wordt. Helaas kan ik geen honderden LED's bedienen met de weinige pinnen die beschikbaar zijn op microcontrollers. Het zou zelfs moeilijk zijn om de besturing van zoveel LED's te coderen. Dus besloot ik dat ik alle LED's in verschillende kleinere balkjes moest verdelen en voor elke balk zou ik een microcontroller kunnen gebruiken. Dan zou ik de communicatiemogelijkheden van microcontrollers gebruiken om informatie tussen hen te delen. Deze informatie kan de kleur en helderheid van LED's zijn, patronen/reeksen van kleuren en sensorische informatie. Voor elke balk besloot ik 16 RGB-LED's te gebruiken. Dit resulteert in een niet te grote en niet te kleine balk. Op deze manier gebruik ik een acceptabel aantal bronnen voor elke led, waardoor de kosten voor elke balk lager zijn. Niettemin zijn 16 RGB-leds 48 leds (3*16=48) voor de microcontroller om te besturen. Met het oog op de kosten heb ik besloten om de goedkoopste microcontroller die ik kon gebruiken. Dit betekent dat de microcontroller maximaal 20 I/O-pinnen zal hebben, niet genoeg voor 48 LED's. alternatief dat ik zou kunnen bedenken is het gebruik van een soort vergrendeld schuifregister! Hervatten: - Maak en interactief omgevingslicht - Maak een standaard balk van regelbare LED's - Mogelijkheid om meerdere staven aan te sluiten om een kamer te vullen - Laat gebruikersaanpassing / configuratie en sensorische integratie toe

Stap 2: Hardware

Zoals gezegd in de vorige stap, wil ik meerdere staven maken om één kamer te verlichten. Dit roept de kostenkwestie op. Ik ga proberen elke reep op de meest kosteneffectieve manier mogelijk te maken. De microcontroller die ik gebruikte was een AVR ATtiny2313. Deze zijn vrij goedkoop en ik had er een paar liggen. ATtiny2313 heeft ook één universele seriële interface en één USART-interface die in de volgende stappen goed van pas zullen komen. Ik had ook drie MCP23016 - I2C 16bit I/O-poortuitbreidingen rondslingeren, precies de juiste telling! Ik heb elke poortuitbreiding gebruikt om één kleur van de 16 LED's te bedienen. De LED's… waren helaas de goedkoopste die ik kon vinden. Ze zijn 48 rood, groen en blauw ~10000mcd 5 mm met een hoek van 20 graden. Dit zou voor nu niet uit moeten maken, aangezien dit slechts één prototype is. Ondanks dit feit is het resultaat best mooi! Ik draai de microcontroller op 8 MHz. De I2C-bus is geklokt op 400 kHz. De schakelfrequentie van de LED is ongeveer 400 Hz. Op deze manier, als ik in staat ben om 48 LED's aan te sturen zonder tot het uiterste te gaan, heb ik later ruimte voor meer!

Stap 3: Montage

Nadat ik het circuit had ontworpen, bouwde ik het in verschillende breadboards, voor prototyping-doeleinden. Na enkele uren draden doorknippen en het circuit in elkaar zetten, kreeg ik dit resultaat: een gigantisch breadboard met 48 LED's en tonnen draad!

Stap 4: Controle?

Dit is het meest uitdagende deel van het project. Ik wilde één besturingsalgoritme generiek genoeg maken voor het verwerken van patronen/reeksen en ook voor het regelen van de helderheid en kleur van elke LED. Om de LED's te bedienen, moet ik een frame van 4 bytes naar de MCP23016 sturen (1 byte = 8 bits). Eén byte met het adres van het IC correspondent met de kleur, 1 byte met het commando "write" en 2 bytes met de waarde van de 16bits (LED's). Het IC is als "sink" met de LED's verbonden, wat betekent dat één logische waarde 0 op de pin de LED zal verlichten. En nu het uitdagende deel, hoe PWM-besturing voor 48 LED's te maken? Laten we PWM voor één LED bestuderen! PWM uitgelegd @ Wikipedia. Als ik de helderheid van de LED op 50% wil, is mijn PWM-waarde 50%. Dit betekent dat de LED in een bepaalde periode even lang aan moet zijn als uit. Laten we een periode van 1 seconde nemen. PWM van 50% betekent dat in deze 1 seconde de aan-tijd 0,5 seconden is en de uit-tijd 0,5 seconden. PWM van 80%? 0,2 seconden uit, 0,8 seconden aan! Makkelijk, toch? In de digitale wereld: bij een periode van 10 klokcycli betekent 50% dat gedurende 5 cycli de LED aan is en voor nog eens 5 cycli de LED uit is. 20%? 2 cycli aan, 8 cycli uit. 45%? Nou, we kunnen niet echt 45% krijgen… Aangezien de periode in cycli is en we maar 10 cycli hebben, kunnen we de PWM alleen in stappen van 10% verdelen. Dit betekent dat de evolutie van de pin voor 50% zou moeten zijn: 1, 1, 1, 1, 1, 0, 0, 0, 0, 0; Of zelfs 1, 0, 1, 0, 1, 0, 1, 0, 1, 0; Bij het programmeren kunnen we deze volgorde maken van het in- en uitschakelen van een array. Voor elke cyclus voeren we naar de pin de waarde van de index waar de cyclus is. Begreep ik het tot nu toe? Als we LED0 50% en LED1 20% willen maken, kunnen we beide arrays toevoegen. Voor het aansturen van de LED0-pin: 1, 1, 1, 1, 1, 0, 0, 0, 0, 0;Voor het aansturen van de LED1 pin: 2, 2, 0, 0, 0, 0, 0, 0, 0, 0;Resulterend in LED0 +LED0: 3, 3, 1, 1, 1, 0, 0, 0, 0, 0; Als we deze reeks getallen in het poortuitbreidings-IC uitvoeren, krijgen we de LED0 met 50% helderheid en LED1 met 20%!! Simpel voor 2 LED's, toch? Nu moeten we dit maken voor 16 LED's, voor elke kleur! Voor elk van deze arrays hebben we een combinatie van helderheid voor elke kleur (16 LED's) Elke keer dat we een andere combinatie van kleuren willen, moeten we deze array veranderen.

Stap 5: Maak het gemakkelijk

De vorige stap is te veel werk om een eenvoudige reeks te maken… Dus besloot ik een programma te maken, waarin we de kleuren van elke LED in één stap van de reeks vertellen en we de drie arrays van de stap krijgen. Ik heb dit programma gemaakt in LabView vanwege tijdgebrek.

Stap 6: Eerste experimenten

Het laden van verschillende stappen in de microcontroller en we krijgen zoiets als dit: Sorry voor de slechte kwaliteit van de video's! Ik heb het maximale aantal stappen van een reeks gedefinieerd tot 8 en de PWM beperkt tot 20% sprongen. Deze beslissing is gebaseerd op het soort controle dat ik gebruik en hoeveel EEPROM de ATtiny2313 heeft. In deze experimenten heb ik geprobeerd te zien wat voor soort effecten ik kon maken. Ik moet zeggen dat ik tevreden ben met het resultaat!

Stap 7: Realtime controle

Zoals vermeld in de vorige stappen, wil ik communiceren met alle microcontrollers die de LED's in mijn kamer besturen. Dus gebruikte ik de beschikbare USART-interface in ATtiny2313 en verbond deze met mijn computer. Ik heb ook een programma gemaakt in LabView om de LED-balk te besturen. In dit programma kan ik de microcontroller vertellen hoe lang de reeks is, de kleur van elke LED en de tijd tussen de stappen van een reeks. In de volgende video zal ik demonstreren hoe ik de kleur van LED's kan veranderen en sequenties kan definiëren.

Stap 8: Conclusies

Ik denk dat ik succesvol was in deze eerste benadering van mijn project. Ik kan 16 RGB-LED's aansturen met weinig middelen en beperkingen. Het is mogelijk om elke LED apart aan te sturen, waardoor elke gewenste volgorde ontstaat.

Toekomstwerk:

Als ik positieve feedback van mensen krijg, kan ik dit idee verder uitwerken en een volledige DIY Electronics Kit maken, met printplaten en montage-instructies.

Voor mijn volgende versie zal ik: -Verander de microcontroller in een met ADC -Verander de MCP23016 voor een ander soort serieel-in parallel-out die meer stroom van LED's kan afleiden -Maak open-source software om te communiceren met de microcontroller en controle van de LED's -Ontwikkel de communicatie tussen verschillende microcontrollers.

Heeft u een suggestie of vraag? Of laat een reactie achter!

Finalist in de Let It Glow!