Een LED-sfeerlamp van $ 1 met ATtiny13 en WS2812 - Ajarnpa

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

Door arduinocelentanoVolg meer door de auteur:

Dit is een voordelige sfeerlamp met vier standen.

1. Regenboogvonk. Een vonk licht beweegt keer op keer omhoog en verandert geleidelijk van kleur.

2. Regenbooggloed. Een stabiele gloed die geleidelijk van kleur verandert.

3. Simulatie van kaarsvuur.

4. Uit.

U kunt van modus wisselen door op een aanraakknop bovenaan te tikken. De huidige modus wordt na het uitschakelen opgeslagen in het EEPROM-geheugen.

Hoe klein is ATtiny13?

Het idee was om maximale functies uit minimale hardware te halen, iets complexer dan een geautomatiseerde schakelaar of thermometer, een project dicht bij de rand van deze kleine microcontroller. Beperkingen zetten je tenslotte creatief aan het denken, toch? Nou, daar leek het in het begin wel op.

De grootste uitdaging in dit project was om alle code in ATtiny13 te schuiven. De microcontroller heeft 1K bytes flash en slechts 64 bytes RAM. Ja, als ik "bytes" zeg, bedoel ik die bestaande uit acht bits. 64 bytes voor voor al uw lokale variabelen en call-stack. Om het duidelijk te maken, bedenk dat we 8 RGB-LED's moeten aansturen. Elk van hen wordt gedefinieerd door 3 bytes (respectievelijk één voor rood, groen en blauw kanaal). Dus, alleen om de status van 8 LED's op te slaan, moeten we een array van 8 structuren van elk 3 bytes implementeren en een aanwijzer naar het begin van deze array zou nog een byte kosten. Er zijn dus 25 van 64 bytes op. We hebben zojuist 39% RAM gebruikt en zijn nog niet echt begonnen. Om zeven basiskleuren voor de regenboog op te slaan, heb je bovendien 7 × 3 = 21 bytes nodig, dus 72% van het RAM-geheugen is op. Welnu, wat de basiskleuren betreft, overdrijf ik: we hebben ze niet allemaal tegelijk nodig in RAM en ze veranderen nooit, dus ze kunnen worden geïmplementeerd als een constante array die in flash wordt opgeslagen in plaats van RAM. Het geeft in ieder geval een algemene indruk over gebruikte hardware.

Ik herinnerde me de uitspraak van Knuth over voortijdige optimalisatie en begon met het maken van een prototype van drie lampmodi afzonderlijk om te zien wat er gebeurt. Ik heb ze afzonderlijk getest om er zeker van te zijn dat ze goed werken en dat ze allemaal op mijn microcontroller passen. Het kostte een paar avonden om het voor elkaar te krijgen en alles ging goed … totdat ik probeerde ze samen te voegen in de schakelaarverklaring. Het hulpprogramma avr-size rapporteerde een tekstsectiegrootte van 1,5 Kb (met de vlag -s van avr-gcc). Op dat moment was mijn oorspronkelijke bedoeling om wat ATtiny25 met 2Kb flitser te pakken en dat had het happy end van dit verhaal kunnen zijn.

Maar op de een of andere manier had ik het gevoel dat ik na een aanzienlijke optimalisatie erin kon slagen die waardeloze code tot 1Kb te verkleinen. Het kostte echter nog een week om te beseffen dat het onmogelijk is en nog een week om het toch te bereiken. Ik moest een regenboog knippen tot vijf basiskleuren (zonder significant visueel verschil). Ik heb case-statements verwijderd en een keten van if-then-if gebruikt om de grootte van de binaire code te verkleinen. Fire-animatie heeft een pseudo-willekeurige nummergenerator nodig die behoorlijk omvangrijk is, dus ik heb een vereenvoudigde versie van LFSR geïmplementeerd met een constante beginwaarde. Ik geef niet om de volledige cycluslengte van PRNG en ben gewoon op zoek naar een afdalingsbalans tussen codegrootte en "realistische vuuranimatie". Ik heb ook veel kleine optimalisaties geïmplementeerd die ik me nu niet kan herinneren en ben er zelfs in geslaagd om alle modi behalve vuur in de chip te flashen. Toen ik geen ideeën meer had, was mijn totale code ongeveer 1200 bytes.

Ik nam een time-out en had veel gelezen over het optimaliseren van AVR-code. Ik stond op het punt het op te geven en alles in assembler te herschrijven, maar gaf het de laatste kans. Tijdens de laatste optimalisatie-rush heb ik een regenboog tot drie basiskleuren gesneden en andere direct berekend, ik heb alles geïnspecteerd en de AVR-optimalisatie-aanbevelingen gevolgd en tot slot…

avrdude: flash schrijven (1004 bytes):

Schrijven | ################################################## | 100% 0.90s

Het is niet nodig om te zeggen dat ik bijna al het RAM-geheugen en slechts één byte EEPROM heb gebruikt om de huidige modus op te slaan. Ik wil niet zeggen dat dit een ideale en ultieme implementatie is. Het werkt gewoon en past op de microcontroller. Ik weet zeker dat je het beter zou kunnen doen. Ik ben echt. Ik wil gewoon het plezier delen van het oplossen van een schijnbaar onpraktisch probleem dat u in het begin bijna onmogelijk acht. "Hacken betekent dus de grenzen verkennen van wat mogelijk is…" --Richard Stallman.

Benodigdheden:

1x ATtiny13 MCU ($ 0,28 = $ 0,24 voor MCU in SOP-8-pakket en $ 0,04 voor DIP8-adapter)

8x WS2812 RGB-LED's (ik raad een bord of een stuk LED-streep aan) ($ 0,42)

1x TTP223 Touch-knop ($ 0,10)

1x Micro USB naar DIP-adapter ($ 0,14)

1x 10kΩ weerstand (<$0,01)

1x 100nF keramische condensator (<$0,01)

1x 10–47µF elektrolytische condensator (<$0,01)

Totaal <$0,97

Stap 1: Software-installatie

Je hebt avr-gcc toolchain nodig voor het compileren van de broncode en avrdude-hulpprogramma voor het uploaden van het ROM van de microcontroller. Het installatieproces is vrij eenvoudig en duidelijk, maar het hangt af van uw besturingssysteem. Als je een soort GNU/Linux gebruikt, heb je waarschijnlijk al de juiste pakketten in je repositoryboom. De broncode van dit project kan hier worden gedownload:

github.com/arduinocelentano/t13_ws2812_lamp

Je hebt ook een light_ws2812-bibliotheek nodig:

github.com/cpldcpu/light_ws2812

Zodra u avr-gcc toolchain en projectbronnen hebt, voert u uw terminal uit en typt u de volgende code:

cd pad/naar/project

maken

Stap 2: Programmeren van de microcontroller

Als je een soort USBASP-programmeur hebt, sluit deze dan gewoon aan op Attiny volgens de pinout. Meestal ziet het er zo uit, maar ik raad ten zeerste aan om uw werkelijke pinout te bekijken!

Als alternatief kunt u een Arduino-bord als programmeur gebruiken. Open Arduino IDE en zoek het Arduino ISP-voorbeeld in het menu "Bestand → Voorbeelden". Na het uploaden van de schets fungeert je Arduino-bord als programmeur. De opmerkingen in de schetscode zouden u een idee geven om te pinnen.

Nu rennen

maak flits

om de MCU te flashen en

zekering maken

om zekeringbits in te stellen.