LOCODUINO

Forum de discussion
Dépôt GIT Locoduino
Flux RSS

lundi 21 août 2017

25 visiteurs en ce moment

Une horloge à échelle H0

. Par : petitrain

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.

Le temps à l’échelle HO

Tout d’abord, il faut mettre le temps à l’échelle :

  • 1 journée de 24 h vaut 1440mn et au 1/87ème : 1440/87 = 16 mn donc :
  • 1 journée est égale à 16mn.
  • 1 heure est égale à 40 s.
  • 1 minute est égale à 666 millisecondes (Hé oui, Arduino travaille en milliseconde)

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.

La liste des courses

il vous faut réunir :
- 1 microcontrôleur ATméga328p ( le même que sur les platines Arduino Uno)
- 1 socket 28 broches
- 1 Quartz 16 Mhz
- 2 condensateurs de 22pf
- 1 résistance de 220 ohms
- 4 résistances de 150 ohms
- 1 bornier pour l’alimentation
- 1 Afficheur 4 digits, 7 segments (anode ou cathode commune)
- et 1 plaquette de circuit imprimé percée à bande.

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.

Les afficheurs 7 segments

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.

Le programme

  1. // Créer une horloge à l'échelle HO. Une heure vaut 40 secondes,
  2. // ce qui permet d'avoir une journée de 24h en 16mn.
  3.  
  4. #include "SevSeg.h"
  5.  
  6. //Créer une instance de l'objet.
  7. SevSeg sevseg;
  8.  
  9. //Créer les variables globales.
  10. unsigned long timer;
  11. int minute=0;
  12.  
  13. // Initialisations
  14. void setup() {
  15.  
  16. /*le premier chiffre représente anode ou cathode commune: cathode=0,anode=1.
  17.   Les chiffres 2,4,3 et 13 sont les broches de sortie de l'Arduino
  18.   pour les broches communes des afficheurs en partant de la gauche vers la droite.
  19.   Les chiffres suivants représentent les broches de sortie de l'Arduino
  20.   pour les segments a,b,c,d,e,f,g et dp des afficheurs.*/
  21.  
  22. sevseg.Begin(0,2,4,3,13,10,9,7,6,5,11,12,8);
  23.  
  24. //Régler la luminosité (0 to 100);
  25.  
  26. sevseg.Brightness(90);
  27.  
  28. // initialisation de la variable timer
  29.  
  30. timer=millis();
  31. }
  32.  
  33. void loop() {
  34.  
  35. // Affiche les différentes sorties
  36. sevseg.PrintOutput();
  37.  
  38. // Vérifier si la minute HO est écoulé...666 milliseconde pour 1mn.
  39. unsigned long temps=millis();
  40. if (temps-timer>=666) {
  41. timer=temps;
  42. minute++;
  43. if (minute==1440) { // Remet à 0 après 24h*60=1440, soit une journée complète.
  44. minute=0;
  45. }
  46. int x=minute/60*100;
  47. // On divise par 60 pour avoir le nombre d'heure
  48. int y=minute%60;
  49. // et on le multiplie par 100 pour le positionner sur l'afficheur n°2.
  50. int z=x+y;
  51. //y est le modulo de la division précédente (le reste des minutes)
  52. sevseg.NewNum(z,(byte) 2);
  53. //z est mis sur les afficheurs, 2 représente le point.
  54. }
  55. }

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.

La partie DIY   (bricolage en français)

Coté composants

Coté pistes

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.

7 Messages

Réagissez à « Une horloge à échelle H0 »

Qui êtes-vous ?
Votre message

Pour créer des paragraphes, laissez simplement des lignes vides.

Lien hypertexte

(Si votre message se réfère à un article publié sur le Web, ou à une page fournissant plus d’informations, vous pouvez indiquer ci-après le titre de la page et son adresse.)

Rubrique « Projets »

Un chenillard de DEL

Enseigne de magasin

Feux tricolores

Multi-animations lumineuses

L’Arduino et le système de commande numérique DCC

Un décodeur d’accessoire DCC versatile basé sur Arduino

Un moniteur de signaux DCC

Une barrière infrarouge

Un capteur RFID

Un TCO xpressnet

Une animation sonore

L’Arduino au coeur des systèmes de pilotage analogiques ou numériques

Calcul de la vitesse d’un train miniature avec l’Arduino

La génèse d’un réseau 100% Arduino

Une horloge à échelle H0

Simulateur de soudure à arc

Un automatisme de Passage à Niveau

La rétro-signalisation sur Arduino

Décodeur pour aiguillage à solénoïdes sur Arduino

Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO

Etude d’un passage à niveau universel

Réalisation pratique d’un système de mesure de vitesse à l’échelle N

Une Passerelle entre le bus S88 et le bus CAN pour la rétro signalisation

Un décodeur DCC pour 16 feux tricolores

Block Automatique Lumineux avec la carte shield "Arduino 4 relays"

Réalisation d’un affichage de gare ARRIVEE DEPART

Comment piloter trains et accessoires en DCC avec un Arduino (1)

Comment piloter trains et accessoires en DCC avec un Arduino (2)

Comment piloter trains et accessoires en DCC avec un Arduino (3)

Comment piloter trains et accessoires en DCC avec un Arduino (4)

SGDD : Système de Gestion DD (1)

SGDD : Système de Gestion DD (2)

SGDD : Système de Gestion DD (3)

La PWM : Qu’est-ce que c’est ? (1)

La PWM : Qu’est-ce que c’est ? (2)

La PWM : Qu’est ce que c’est ? (3)

La PWM : Qu’est ce que c’est ? (4)

Mise en oeuvre du Bus CAN entre modules Arduino (1)

Mise en oeuvre du Bus CAN entre modules Arduino (2)

Un gestionnaire en C++ pour votre réseau (1)

Un gestionnaire en C++ pour votre réseau (2)

Un gestionnaire en C++ pour votre réseau (3)

Un gestionnaire en C++ pour votre réseau (4)

Réalisation de centrales DCC avec le logiciel libre DCC++ (1)

Réalisation de centrales DCC avec le logiciel libre DCC++ (2)

Réalisation de centrales DCC avec le logiciel libre DCC++ (3)

Contrôleur à télécommande infrarouge pour centrale DCC++

Gestion d’une gare cachée (1)

Gestion d’une gare cachée (2)

Gestion d’une gare cachée (3)

Les derniers articles

La PWM : Qu’est ce que c’est ? (4)


Jean-Luc

Block Automatique Lumineux avec la carte shield "Arduino 4 relays"


Christian Bézanger

Réalisation d’un affichage de gare ARRIVEE DEPART


Gilbert

Contrôleur à télécommande infrarouge pour centrale DCC++


Daniel

La PWM : Qu’est ce que c’est ? (3)


Jean-Luc

Réalisation de centrales DCC avec le logiciel libre DCC++ (3)


bobyAndCo

Un gestionnaire en C++ pour votre réseau (4)


Pierre59

Un décodeur DCC pour 16 feux tricolores


Dominique, JPClaude, Thierry

Réalisation de centrales DCC avec le logiciel libre DCC++ (2)


bobyAndCo

Réalisation de centrales DCC avec le logiciel libre DCC++ (1)


Dominique

Les articles les plus lus

La PWM : Qu’est-ce que c’est ? (1)

Comment piloter trains et accessoires en DCC avec un Arduino (3)

L’Arduino et le système de commande numérique DCC

Un moniteur de signaux DCC

L’Arduino au coeur des systèmes de pilotage analogiques ou numériques

Comment piloter trains et accessoires en DCC avec un Arduino (1)

Feux tricolores

Réalisation de centrales DCC avec le logiciel libre DCC++ (3)

La rétro-signalisation sur Arduino

Un chenillard de DEL