Une lampe d'ambiance à LED à 1 $ avec ATtiny13 et WS2812 : 7 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:05

Par arduinocelentanoSuivez plus par l'auteur:

Il s'agit d'une lampe d'ambiance à faible coût avec quatre modes.

1. Étincelle arc-en-ciel. Une étincelle de lumière monte à chaque fois et change progressivement de couleur.

2. Lueur arc-en-ciel. Une lueur stable qui change progressivement de couleur.

3. Simulation de feu de bougie.

4. Désactivé.

Vous pouvez changer de mode en appuyant sur un bouton tactile en haut. Le mode actuel est enregistré dans la mémoire EEPROM après la mise hors tension.

Quelle est la taille d'ATtiny13 ?

L'idée était d'obtenir un maximum de fonctionnalités à partir d'un minimum de matériel, quelque chose de plus complexe qu'un commutateur ou un thermomètre automatisé, un projet proche de la périphérie de ce minuscule microcontrôleur. Après tout, les restrictions vous font penser à la créativité, n'est-ce pas ? Eh bien, ça y ressemblait au début.

Le plus difficile dans ce projet était de pousser tout le code dans ATtiny13. Le microcontrôleur a 1K octets de flash et seulement 64 octets de RAM. Oui, quand je dis "octets", je veux dire ceux constitués de huit bits. 64 octets pour toutes vos variables locales et votre pile d'appels. Pour être clair, considérons que nous devons contrôler 8 LED RVB. Chacun d'eux est défini par 3 octets (un pour le canal rouge, vert et bleu respectivement). Donc, juste pour stocker l'état de 8 LED, nous devrons implémenter un tableau de 8 structures de 3 octets chacune et un pointeur vers le début de ce tableau prendrait un octet de plus. Ainsi, 25 des 64 octets sont sortis. Nous venons d'utiliser 39% de RAM et n'avons pas encore vraiment commencé. De plus, pour stocker sept couleurs arc-en-ciel de base, vous aurez besoin de 7 × 3 = 21 octets, donc 72 % de la RAM est épuisée. Bon, en ce qui concerne les couleurs de base, j'exagère: nous n'avons pas besoin de toutes en même temps en RAM et elles ne changent jamais, elles peuvent donc être implémentées comme un tableau constant à stocker en flash au lieu de RAM. Quoi qu'il en soit, cela donne une impression globale sur le matériel utilisé.

Me souvenant de la déclaration de Knuth sur l'optimisation prématurée, j'ai commencé par prototyper trois modes de lampe séparément pour voir ce qui se passe. Je les ai testés séparément pour m'assurer qu'ils fonctionnent correctement et que chacun s'adapte à mon microcontrôleur. Il a fallu quelques soirées pour l'accomplir et tout s'est bien passé… jusqu'à ce que j'essaie de les assembler dans la déclaration de commutateur. L'utilitaire avr-size a signalé une taille de section de texte de 1,5 Ko (avec l'indicateur -s de avr-gcc). À ce moment-là, mon intention initiale était de récupérer des ATtiny25 avec un flash de 2 Ko et cela aurait pu être la fin heureuse de cette histoire.

Mais d'une manière ou d'une autre, j'ai senti qu'après une optimisation considérable, je pouvais réussir à réduire ce code de merde à 1 Ko. Cependant, il a fallu une semaine de plus pour se rendre compte que c'est impossible et une semaine de plus pour l'accomplir de toute façon. J'ai dû découper un arc-en-ciel à cinq couleurs de base (sans différence visuelle significative). Je me suis débarrassé des instructions case et j'ai utilisé une chaîne de if-then-if pour réduire la taille du code binaire. L'animation de feu a besoin d'un générateur de nombres pseudo-aléatoires qui est assez volumineux, j'ai donc implémenté une version simplifiée de LFSR avec une valeur initiale constante. Je ne me soucie pas de la durée du cycle complet de PRNG et je cherche juste un équilibre de descente entre la taille du code et "l'animation de feu réaliste". J'ai également mis en œuvre de nombreuses optimisations mineures dont je ne me souviens pas pour le moment et j'ai même réussi à faire clignoter tous les modes, à l'exception du feu, dans la puce. Quand j'ai manqué d'idées, mon code total était d'environ 1200 octets.

J'ai pris un temps mort et j'avais beaucoup lu sur l'optimisation du code AVR. J'étais sur le point d'abandonner et de tout réécrire en langage assembleur, mais je lui ai donné la dernière chance. Lors de la ruée vers l'optimisation finale, j'ai coupé un arc-en-ciel en trois couleurs de base et en ai fait d'autres à calculer à la volée, j'ai tout inspecté et suivi les recommandations d'optimisation AVR et enfin…

avrdude: écriture flash (1004 octets):

Écriture | ##################################################### | 100% 0.90s

Inutile de dire que j'ai utilisé presque toute la RAM et un seul octet d'EEPROM pour stocker le mode actuel. Je ne veux pas dire qu'il s'agit d'une mise en œuvre idéale et ultime. Cela fonctionne et s'adapte au microcontrôleur. Je suis sûr que vous pourriez faire mieux. Je suis vraiment. Je veux juste partager le plaisir de résoudre un problème apparemment peu pratique que vous considérez presque impossible au début. "Ainsi, le piratage signifie explorer les limites de ce qui est possible…" --Richard Stallman.

Fournitures:

1x MCU ATtiny13 (0,28 $ = 0,24 $ pour le MCU dans le package SOP-8 et 0,04 $ pour l'adaptateur DIP8)

8x LED RGB WS2812 (je recommande une carte ou un morceau de bande LED) (0,42 $)

1x bouton tactile TTP223 (0,10 $)

1x adaptateur micro USB vers DIP (0,14 $)

1x résistance 10kΩ (<0,01)

1x condensateur céramique 100nF (< 0,01 $)

1x condensateur électrolytique 10-47µF (<0,01 $)

Total <0,97 $

Étape 1: configuration du logiciel

Vous aurez besoin de la chaîne d'outils avr-gcc pour compiler le code source et de l'utilitaire avrdude pour télécharger la ROM du microcontrôleur. Le processus d'installation est assez simple et direct, mais cela dépend de votre système d'exploitation. Si vous utilisez une sorte de GNU/Linux, vous avez probablement déjà les packages appropriés dans votre arborescence de référentiels. Le code source de ce projet peut être téléchargé ici:

github.com/arduinocelentano/t13_ws2812_lamp

Vous aurez également besoin d'une bibliothèque light_ws2812:

github.com/cpldcpu/light_ws2812

Une fois que vous avez la chaîne d'outils avr-gcc et les sources du projet, exécutez votre terminal et tapez le code suivant:

chemin/vers/projet du cd

Fabriquer

Étape 2: Programmation du microcontrôleur

Si vous avez une sorte de programmeur USBASP, connectez-le simplement à Attiny en fonction de son brochage. Habituellement, cela ressemblerait à ceci, mais je vous recommande fortement de vérifier votre brochage réel !

Alternativement, vous pouvez utiliser une carte Arduino comme programmeur. Ouvrez Arduino IDE et recherchez l'exemple Arduino ISP dans le menu "Fichier → Exemples". Après avoir téléchargé le croquis, votre carte Arduino agit comme un programmeur. Les commentaires dans le code d'esquisse vous donneraient un indice pour le brochage.

Maintenant, cours

faire flash

pour flasher le MCU et

faire un fusible

pour régler les bits de fusible.