LOCODUINO

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

mardi 19 mars 2024

Visiteurs connectés : 35

Une horloge à échelle H0

.
Par : petitrain

DIFFICULTÉ :

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

// 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.

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.

27 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 »

LaBox, Une Centrale DCC polyvalente et abordable (1)

LaBox, Une Centrale DCC polyvalente et abordable (2)

LaBox, Une Centrale DCC polyvalente et abordable (3)

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)

La carte Satellite V1 (1)

La carte Satellite V1 (2)

La carte Satellite V1 (3)

La carte Satellite V1 (4)

La carte Satellite V1 (5)

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

Automatisation du pont FLEISCHMANN 6152 (HO) avec un ESP32 (1)

Identifier et localiser vos trains avec le RFID/NFC et un bus CAN.

Etude d’un passage à niveau multivoies

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

Ménage à trois (Ordinateur, Arduino, réseau)

Réalisation d’un va-et-vient automatique et réaliste

Souris et centrale sans fil

Communications entre JMRI et Arduino

Annonces en gare avec la RFID

Une croix de pharmacie animée avec Arduino UNO

Réalisation d’un wagon de mesure (distance et vitesse)

Passage à niveau géré par Arduino (1)

Passage à niveau géré par Arduino (2)

Passage à niveau géré par Arduino (3)

Passage à niveau géré par Arduino (4)

Passage à niveau géré par Arduino (5)

Une manette simple et autonome pour LaBox

Éclairer le réseau (1)

Éclairer le réseau (2)

Block Automatique Lumineux à 8 cantons analogiques

Un décodeur DCC pour les plaques tournantes Fleischmann et Roco

Éclairer le réseau (3)

Éclairer le réseau (4)

Éclairer le réseau (5)

JMRI pour Ma première centrale DCC

Rocrail pour Ma première centrale DCC

CDM-Rail pour Ma première centrale DCC (1)

CDM-Rail pour Ma première centrale DCC (2)

Banc de test pour les décodeurs DCC

Ma première manette pour les aiguillages DCC

Mon premier décodeur pour les aiguillages DCC

Boitier 3D pour la station DCC minimale

Va-et-vient pour deux trains

Un programme pour régler facilement les servos moteurs avec un ESP32

Affichage publicitaire avec Arduino (1)

Affichage publicitaire avec Arduino (2)

TCO Web interactif avec des ESP32 et des ESP8266 (1)

TCO Web interactif avec des ESP32 et des ESP8266 (2)

TCO Web interactif avec des ESP32 et des ESP8266 (3)

TCO Web interactif avec des ESP32 et des ESP8266 (4)

TCO Web interactif avec des ESP32 et des ESP8266 (5)

Les derniers articles

LaBox, Une Centrale DCC polyvalente et abordable (3)


Thierry

LaBox, Une Centrale DCC polyvalente et abordable (1)


Thierry

LaBox, Une Centrale DCC polyvalente et abordable (2)


Dominique, msport, Thierry

Un programme pour régler facilement les servos moteurs avec un ESP32


bobyAndCo

TCO Web interactif avec des ESP32 et des ESP8266 (5)


utpeca

TCO Web interactif avec des ESP32 et des ESP8266 (4)


utpeca

TCO Web interactif avec des ESP32 et des ESP8266 (3)


utpeca

TCO Web interactif avec des ESP32 et des ESP8266 (2)


utpeca

TCO Web interactif avec des ESP32 et des ESP8266 (1)


utpeca

Affichage publicitaire avec Arduino (2)


catplus, Christian

Les articles les plus lus

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

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

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

Mon premier décodeur pour les aiguillages DCC

La rétro-signalisation sur Arduino

Chenillard de DEL

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

Souris et centrale sans fil

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

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