. Par : . URL : https://www.locoduino.org/spip.php?article105
Sur mon réseau, je voudrais commander l’éclairage et l’extinction de mes bâtiments, ainsi que l’éclairage public avec une platine Arduino. S’il pouvait aussi gèrer l’éclairage général du réseau, me faire de beaux levers de soleil et la pleine lune, ce serait magnifique. Mais pour cela, il me faudrait une horloge qui me donne le temps à l’échelle de la maquette.
C’est ce que je vais vous présenter.
Tout d’abord, il faut mettre le temps à l’échelle :
Ces chiffres ne sont pas impératifs, si vous préférez une journée plus longue ou plus courte, il suffit de refaire le calcul.
il vous faut réunir :
J’ai fait tous les tests sur une plaque d’essai avec une platine Arduino, puis, quand le programme était au point, j’ai transféré le microcontrôleur de ma platine Arduino sur mon nouveau circuit.
ATTENTION : les pattes des ATméga sont fragiles, il faut agir avec précaution....
Variante : Vous pouvez aussi utiliser une platine Arduino toute faite type Uno ou Nano.
Il en existe de toutes sortes, séparés ou d’un seul bloc, vert, rouge blanc ou bleu,
à anode ou cathode commune, prenez celui qui vous plait, tous iront.
Pour faire apparaître un chiffre sur l’afficheur, il faut alimenter les segments correspondants via la broche qu’ils ont en commun. Pour notre microcontrôleur, il doit donc gérer 7+1 broches + 1 broche supplémentaire pour le point séparateur, soit 9 broches au total. Si on multiplie par 4, cela nous fait 36 broches !!!
C’est beaucoup trop pour notre microcontrôleur... Heureusement il y a une méthode pour réduire tout cela :
Le Multiplexage.
On va relier chaque segment de chaque afficheur ensemble ( les a ensemble, les b ensemble...etc.) et on garde un commun séparé pour chaque afficheur.
Comme on travaille avec des leds, il convient de les protéger, on met en série une résistance de 150 ohms sur les communs.
Cela ne nous fait plus que 7+1 broches + 4 communs = 12 broches . C’est tout à fait acceptable pour notre petit ATméga328 !
Voilà mes branchements avec l’Arduino et mes afficheurs. Si les vôtres sont différents, il faudra modifier les branchements en conséquence.
N’hésitez pas à travailler sur le logiciel FRITZING, c’est gratuit ; très facile à prendre en main et ça rend de nombreux services.
On comprend bien que si l’on choisit un chiffre à afficher sur chaque digit et qu’on active tout ça, on va obtenir un désordre indescriptible sur les afficheurs.
Comment faire donc pour afficher des chiffres différents sur les 4 digits reliés ensemble....
En allumant et en éteignant successivement les 4 digits à tour de rôle, et suffisamment rapidement pour que l’on ne s’aperçoive de rien...
C’est ce qu’on appelle le multiplexage. Mais c’est un travail de programmation important, fastidieux et répétitif. Nous allons donc le confier à une librairie dédiée.
On en trouve plusieurs sur le Net. Moi j’ai utilisé SevSeg.h, vous pouvez la télécharger ici.
// Créer une horloge à l'échelle HO. Une heure vaut 40 secondes,
// ce qui permet d'avoir une journée de 24h en 16mn.
#include "SevSeg.h"
//Créer une instance de l'objet.
SevSeg sevseg;
//Créer les variables globales.
unsigned long timer;
int minute=0;
// Initialisations
void setup() {
/*le premier chiffre représente anode ou cathode commune: cathode=0,anode=1.
Les chiffres 2,4,3 et 13 sont les broches de sortie de l'Arduino
pour les broches communes des afficheurs en partant de la gauche vers la droite.
Les chiffres suivants représentent les broches de sortie de l'Arduino
pour les segments a,b,c,d,e,f,g et dp des afficheurs.*/
sevseg.Begin(0,2,4,3,13,10,9,7,6,5,11,12,8);
//Régler la luminosité (0 to 100);
sevseg.Brightness(90);
// initialisation de la variable timer
timer=millis();
}
void loop() {
// Affiche les différentes sorties
sevseg.PrintOutput();
// Vérifier si la minute HO est écoulé...666 milliseconde pour 1mn.
unsigned long temps=millis();
if (temps-timer>=666) {
timer=temps;
minute++;
if (minute==1440) { // Remet à 0 après 24h*60=1440, soit une journée complète.
minute=0;
}
int x=minute/60*100;
// On divise par 60 pour avoir le nombre d'heure
int y=minute%60;
// et on le multiplie par 100 pour le positionner sur l'afficheur n°2.
int z=x+y;
//y est le modulo de la division précédente (le reste des minutes)
sevseg.NewNum(z,(byte) 2);
//z est mis sur les afficheurs, 2 représente le point.
}
}Explications
#include "SevSeg.h" permet d’inclure la bibliothèque.
La fonction sevseg.Begin(cathode ou anode commune, les 4 communs,les broches de l’Arduino correspondants aux différents segments) est à mettre dans le setup().
Dans le setup() on initialise aussi la variable timer avec millis().
Dans la loop() on crée une variable locale de type unsigned long nommé temps et qui prend la valeur de millis() à chaque tour.
Puis on fait la différence entre temps et timer et on regarde si le résultat est supérieur ou égal à 666.
On actualise timer en ajoutant temps et on incrémente la variable minute.
Pourquoi 666 me direz-vous ? Rappelez-vous le résultat de notre calcul du début, on trouvait bien 666 millisecondes : Si vous avez fait un calcul différent, c’est ici qu’il faut mettre votre résultat.
Bon, on a une variable qui compte les minutes HO. On va la tester avec le if().
Si elle dépasse 1440 ( 24h=1440mn), elle retourne à 0 et une nouvelle journée commence !
Après, c’est le même calcul que l’on faisait en CM2 ( les trains en retard et les correspondances ratées)....
int y=minute%60 ; renvoie le reste (modulo) de la division minute/60.
Sur le côté piste, les croix rouges représentent les endroits ou il faut couper les pistes.
Côté composants, on commence à souder tous les straps, puis les résistances, le bornier, le quartz et les condensateurs, le support pour le micro et enfin les afficheurs.
Quatre trous permettent de fixer la platine dans un beau boitier qui trônera sur le réseau.
N’hésitez pas à laisser vos commentaires, je me ferais un plaisir de vous répondre.