Tout d’abord, pour démontrer que l’idée de base décrite dans l’article Projet – Bougies électriques pour lanternes – Idées est techniquement valable, j’ai crée un prototype sur une platine d’expérimentation.

Circuit principal

Le circuit principal est très simple. J’ai pris les composants de plusieurs sets de composants achetés chez Reichelt.

Bougie éléctrique circuit proto

Bougie électrique circuit proto

L’alimentation se trouve en haut à gauche (“Power”). Sur SV1-1 et SV1-3 (le connecteur vers le contrôleur) se trouve la tension d’alimentation de 5 à 6V. La diode D1 sert à protéger le processeur d’une alimentation inversée. Les capas C3 et C4 servent à stabiliser la tension d’alimentation VCC.

Le processeur IC1 (un ATtiny85) dispose d’une connexion ICSP (in-circuit serial programming) qui sert à reprogrammer la flash du processeur. C’est le connecteur JP1. En réalité, sur la platine d’expérimentation ce connecteur n’existe pas, car la platine est directement connecté à un Arduino (cf. paragraphe plus loin).

La résistance R2 sert à définir l’état de la ligne de reset.

En bas à droite se trouve le filtre de l’entrée série “Data”. L’entrée “Data” se trouve sur le même connecteur que l’alimentation (SV1-2). Le filtre est un simple filtre passe bas (constante de temps 1ms) qui a pour but de filtrer des perturbations sur la ligne de données et de protéger l’entrée du processeur de surintensités (via la résistance série R1).

L’étage de sortie se trouve en bas à droite du circuit. Le NFET T1 pilote le pôle moins de la lampe. La résistance de série sur le gate (R100) sert à atténuer la pente de la commutation (pour comportement CEM). La résistance R3 garantit que le NFET s’éteint correctement.

La platine d’expérimentation montée ressemble à ça :

Bougie électrique - prototype

Bougie électrique – prototype

Note: J’ai mis quelques LEDs en plus, elles me servent de “débogeur du pauvre”.

Circuit de programmation

Pour programmer le Attiny85, j’utilise un Arduino, car il connecte parfaitement sur le PC et l’interface Arduino IDE permet de programmer des Attiny85 utilisant les librairies Arduino et l’Arduino en tant qu’ICSP (in-circuit serial programmer).

J’ai fait appel au site allemand suivant pour réaliser cette partie : arduinospielwiese.de.

Il faut connecter la platine d’expérimentation avec l’Arduino comme suit :

Arduino en tant que ICSP

Dans mon cas, le tout ressemble à cela :

Bougie électrique - Ensemble prototype et programmateur

Bougie électrique – Ensemble prototype et programmateur

Le premier programme

Tout d’abord, je voudrais bien savoir si l’étage de sortie fonctionne bien et si on arrive à obtenir un comportement similaire à une bougie avec l’ampoule.

Avec l’Arduino IDE, je programme le bootloader dans l’Attiny pour mettre les fuses (fusibles) dans les bonnes configurations (horloge de 8MHz par le résonateur interne).

Le programme minimum est le suivant :

void setup() {
  pinMode(0, OUTPUT);    //pwm lamp
}

void loop() {
  byte pwm_dc = 0;
  pwm_dc = random(128,255);
  analogWrite(0,pwm_dc);
  delay(100);
}

Dans la partie “setup” se trouve l’initialisation de la sortie de la lampe (gate drive). C’est une sortie PWM (modulation de largeur d’impulsion) qui est piloté à la fréquence de 490Hz (défini par les librairies Arduino). Le rapport cyclique de la sortie peut être ajusté utilisant la fonction analogWrite(pin,rapport) avec une valeur de 0 à 255 pour des rapports cycliques entre 0 et 100%.

Dans la partie “loop”, exécuté infiniment, se trouve un simple appel à la librairie de génération de nombre pseudo-aléatoires de l’Arduino. Une valeur entre 128 et 255 est généré à peu près 10 fois par seconde (random(128,255)) et appliqué en tant que rapport cyclique sur la sortie de la lampe. Le résultat est un signal PWM de 490Hz avec des rapports cycliques pseudo-aléatoires allant de 50 à 100%. La valeur du rapport cyclique change ca. 10 fois par seconde, ce qui imite à mon sens assez bien une bougie :

Vue directe

Vue indirecte

Ce qui manque … chalenge

Le programme présenté dans le dernier paragraphe est fonctionnel, gourmand en mémoire et temps de calcul, mais très rapidement implémenté (ça m’a pris 20 minutes au total). Mais, il ne sais que faire une simulation de bougie, ce qui ne remplit pas mon “cahier des charges”.

Malheureusement, il n’y a pas de libraire pour faire du Attiny85 un récepteur de données série fiable. On trouve des librairies “soft serial” qui font de la réception de données par “polling”, donc en regardant l’état de l’entrée de données en permanence. Le problème avec cette méthode est que le processeur ne fait plus que cela !

Ce que je veux faire, c’est d’utiliser l’entrée d’interruption externes de l’Attiny pour capturer un changement d’état sur la ligne de données série et de faire l’interprétation de la trame en utilisant une base de temps existante.

A creuser.