Premier pas avec l'ATTiny841

Comme précisé en introduction, l'objectif à terme est de remplacer l'encombrant Arduino Nano par une puce du même fabriquant de référence ATTiny841. Cette puce présente toutes les caractéristiques nécessaires pour un encombrement minimal.

Programmation du ATTiny841

Sur la photo ci-dessus on voit bien la différence d'encombrement; à gauche un Arduino Nano et à droite le µC ATTiny841 soudé sur un petit bout de circuit imprimé.

Le montage ci-dessus doit servir à programmer le ATTiny841. En effet, après avoir déporté tout le superflu (prise USB, régulateur de tension, contrôleur série, ...), il faut néanmoins assurer les fonctions !

Le Arduino Nano est donc utilisé comme programmateur et permet d'assurer l'interface entre le PC et l'ATTiny841.

Programmation du Nano en programmateur

Il est nécessaire de charger le programme "programmateur" dans l'Arduino Nano, celui-ci est fourni dans l'IDE (environnement de développement Arduino, en téléchargement sur le site officiel) standard (Fichier -> Exemples -> ArduinoISP). Ouvrir l'exemple et téléverser le programme.

A ce stade le Nano est programmé pour assurer l'interface.

Prérequis logiciel

Coté logiciel il est nécessaire d'installer un noyau permettant la gestion de l'ATTiny841 à l'IDE standard. Pour cela deux étapes:

• Ajouter cette adresse " http://drazzy.com/package_drazzy.com_index.json " dans Fichier -> Préférences -> "Additional oards Manager URLs"
• Ajouter le noyau "ATTinyCore" à l'aide du Board Manager (Outils->Type de carte->Boards Manager)

Note : Il est recommandé d'utiliser l'IDE 1.6.5

Câblage

En plus de l'alimentation (masse et 5v), quatre liaisons sont à câbler, tout est détaillé dans les commentaires du programme ArduinoISP que l'on complète avec le pinout du ATTiny841:

• Reset : D10 du nano sur pin 4 du ATTiny841;
• MOSI : D11 du Nano sur pin 7 du ATTiny841;
• MISO : D12 du Nano sur pin 8 du ATTiny841;
• SCK : D13 du Nano sur pin 9 du ATTiny841.

Le programme génère également trois signaux qu'il peut être intéressant de visualiser à l'aide de trois leds + résistances pour aider au diagnostic en cas d'erreur.

A ce stade il est possible d'écrire le "système d'exploitation" Arduino sur l'ATTiny841 qui est pour l'instant vierge de tout bit.

Cela se fait en passant par Outils -> Graver la séquence d'initialisation après avoir réglé la bonne carte et sa fréquence.

A ce stade je rencontrait une erreur retournée par l'IDE : "avrdude: stk500_getsync(): not in sync: resp=0x15". 

Une rapide recherche plus tard, le problème vient du fait que le Nano est sujet à un auto-reset dans ces conditions, un petit condensateur entre la masse et l'entrée reset permet de régler le problème. On le voit sur la photo du dessus (la petite boule jaune en bas à droite du Nano). Tout les Nano n'y seront pas sujet, mais c'est le cas de ma copie chinoise. Problème en tout cas vite résolu avec ce condo.

Si cette étape réussie on peut désormais passer à la programmation de l'ATTiny841 à proprement parler.

Programmation du ATTiny841

Je ne suis pas allé bien loin, j'ai juste branché une led sur la sortie 0 (pin 2) avec une résistance pour faire un blink test. Attention, il est nécessaire d'utiliser "Téléverser avec un programmateur" et non "Téléverser" pour écrire le programme sur l'ATTiny841.

J'ai encore eu un petit soucis à ce stade, mon installation de ATTinycore était peut être incomplète. Quoi qu'il en soit j'ai du rajouter au fichier avrdude.conf (qui définit toute les cartes programmables par l'IDE, situé quelque part dans le répertoire d'installation de l'IDE) les infos trouvables ici (à copier/coller en fin de fichier). Lien alternatif

Et après téléversement ... tada, ça clignote (la led verte au premier plan, l'autre étant le diagnostic du Nano)

Prochaine étape, connecter le driver A6211 et les boutons à l'ATTiny841 pour reproduire l'exemple précédent.

Structure du programme

Le fonctionnement du Arduino est principalement monotâche et séquentiel, on ne peut donc par exemple pas imaginer une tâche de fond qui surveille le niveau de batterie (ou alors au moyen d'une interruption mais il faudrait un comparateur externe et une référence de tension car l’interruption fonctionne sur entrée numérique, en général sur des fronts montants ou descendants).

Le fonctionnement est donc basé sur une boucle permanente qui s'exécute après une fonction setup() qui s'exécute une seule fois à la mise sous tension. En générale on initialise les variables et on déclare les entrées/sorties dans cette phase. 

Dans notre cas on lira également les niveaux de puissance stockés dans la mémoire EEPROM (une mémoire non volatile) du µC. En effet, si l'on veux pouvoir modifier les niveau de puissance en direct ils ne peuvent pas être stockés dans le programme sinon ils seraient réinitialisés à chaque coupure d'alimentation.

Deux variables de types int (integer : nombre entier) seront principalement utilisées.

Variable mode

La première définira le mode d'éclairage en cours. Deux tableaux lui seront associés pour les leds spot et wide. Ils contiennent les puissances pour chaque mode et c'est eux que l'on sauvegardera dans l'EEPROM. Le mode 0 correspondra à l'extinction totale, c'est dans ce mode que l'on démarrera à la mise sous tension. Il faut bien comprendre que le µC fonctionne dès la mise sous-tension pour scruter les actions sur les boutons + et -. La lampe branchée et éteinte consomme donc légèrement mais cette consommation reste epsilonesque.

On aura donc deux tableaux de type:

spotPower = [0 n n ... n] et widePower = [0 n n ... n]

avec un nombre d'éléments égal au nombre de mode (y compris l'arrêt total donc). Cette variable mode sera mise à jour à chaque tour de la boucle principale en fonction des appuis sur les boutons + et -, et de la mesure batterie. Voila les modes envisagés dans un premier temps:

Mode	widePower	spotPower	Commentaire
0	0%	0%	Lampe éteinte
1	10%	0%	Éclairage de secours
2	25%	15%	Mode progression 1
3	40%	25%	Mode progression 2
4	80%	80%	Mode grand volume
5	30%	100%	Mode longue portée
6	100%	100%	Mode "qui a la plus longue"

Les modes classiques sont les 1 à 4. 5 et 6 seront uniquement accessibles sur des combinaisons "exotiques" type double-click. Je n'ai pas trop d'expérience de l'utilisation de double faisceau donc j'ajusterais au besoin. Il est à noter que si les intensités seront programmables en live sur la lampe, l'ajustement du nombre de mode et de la façon de naviguer entre eux nécessite le branchement au PC et la modification de quelques lignes de code.

Variable niveau de batterie

La seconde variable définie le niveau de batterie, elle aussi codée sur un int avec à priori les valeurs suivantes:

Valeur inférieure	Valeur supérieure	Niveau
	<3v	0
3v	10%	1
10%	25%	2
25%	50%	3
50%	75%	4
75%	100%	5

Elle sera également mise à jour à chaque tour de boucle, au début de la boucle puisqu'en cas de niveau batterie 0 la suite de la boucle n'a pas lieu de s'exécuter.

Le niveau 0 interdit l'allumage, le niveau 1 le limite au mode 1.

Variable mode programmation

Une troisième variable d'état est l'état du mode programmation des niveaux. Il s'agit ici d'un booléen (vrai ou faux) initialisé à faux au début du programme. Je verrais par la suite si la possibilité de potarder les niveaux en live présente un intérêt vis-à-vis de la complexité de programmation.

Pilotage par bouton plus et moins

Une petite vidéo avant de partir en weekend, j'ai utilisé un bout de script trouvé sur internet ici (merci à la communauté Arduino !) qui permet la gestion de 4 actions par bouton (click, double click, appui long & appui très long).

Après modification pour qu'il fonctionne avec deux boutons j'obtient le résultat suivant:

La vidéo ne rend pas très bien les variations de lumière car le capteur s'adapte automatiquement mais il y a bien variation ! Pour l'instant je ne gère que les fonctions click plus et click moins sur 4 niveaux d'intensité (0, 10%, 30% et full) mais la programmation est assez aisée et toute les combinaisons devraient permettre une utilisation agréable.

Premier bout de code sous Arduino

Premier bout de code sous Arduino, pas bien compliqué juste une boucle qui fait varier le PWM de 0 à 100% (toujours bridé à 1A) mais ça fait plaisir de le voir fonctionner !

Premier essai du driver

Après avoir reçu les quelques composants nécessaires au fonctionnement du driver j'ai pu procéder à un premier essai.

Le montage est alimenté par une source continue en 7.2V, soit la tension nominale de deux éléments lithium en série. 

Une diode protège l'inversion de polarité et deux condensateurs (un gros électrolytique et un plus petit céramique) lissent cette alimentation. Ce filtrage sera conservé sur la lampe finale bien que l'alimentation soit beaucoup plus propre que mon alim chinoise à 2€75 ! néanmoins le driver est a découpage et peut de ce fait pourrir pas mal l'environnement soit par réjection dans son alim soit par rayonnement sur les pistes environnantes.

Un petit régulateur pour créer du 3.3V est également implanté, ce n'est pas nécessaire à ce stade mais cela me permet de vérifier que cette tension qui sera la tension de commande du µC est suffisante pour valider l'entrée PWM du driver.

Schéma de l'alimentation

Le montage autour du driver est quasiment le même que celui proposé dans la datasheet. J'ai cependant modifié la résistance de mesure afin de limiter le courant à 1A au lieu de 3A, en effet j'utilise une breadboard et de petits fils de routage et je n'ai pas envie de tester leur tenue sous 3A !

Régulateur A6211

La LED utilisé est une XM-L T6 4C. Les micros contrôleurs visible sur la platine de câblage sont actuellement inutilisés. Il y a a gauche un Arduino Nano qui servira au développement et a droite du driver un ATTiny841 qui prendra place dans la version finale.

Photo du montage

 Et la photo qui fait plaisir :

Lumière !

Prochaines étapes:

Pilotage par le Arduino Nano

La prochaine étape consistera à piloter l'entrée PWM du driver actuellement fixé à 100% pour moduler l'éclairage. L'objectif est de me faire la main avec le code Arduino que je ne connais pas du tout et je me bornerais surement à faire une gradation par palier de 10% toute les secondes en boucle.

Gestion des boutons poussoir

Toujours à propos de la programmation, la suite consistera à gérer les deux boutons poussoir du rototo, click simple, doucle click et appui prolongé au programme

Démarrage du ATTiny841

Ce µC doit tout d'abord recevoir un bootloader Arduino pour être utilisable, cela se fait en utilisant l'Arduino Nano à ma disposition comme programmateur ISP avant d'écrire le programme final qu'il faudra d'ici là développer.