LOCODUINO

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

mardi 19 mars 2024

Visiteurs connectés : 94

Un automatisme de Passage à Niveau

Avec un simple Pro Mini

.
Par : Dominique, JPClaude

DIFFICULTÉ :

Un éminent membre de mon club butait depuis un certain temps sur un automatisme de passage à niveau à partir d’une logique à relais.

Il faut dire que ce passage supporte une double voie, dont une branche est en "Y". Le cahier des charges impose de ne lever les barrières que lorsque toute la zone est libre de trains.

J’ai décidé de relever le défi avec un Arduino et d’ajouter un ultime raffinement : le clignotement réaliste des feux rouges (coté route) à leds.

Voici les détails de la réalisation que vous pourrez certainement adapter à votre réseau.

<

Le cahier des charges

Le passage à niveau doit protéger une double voie, dont l’une des branches est en "Y". Il y a donc 5 sections de voies de part et d’autre du passage à niveau.

Sur chaque branche, sont disposés 2 détecteurs de type interrupteur à lame souple, "ILS".
Il y en a donc 10 au total.

Le plus proche du passage à niveau doit déclencher la fermeture des barrières lorsque le train va vers le passage.
Le plus éloigné du passage à niveau doit déclencher l’ouverture des barrières lorsque le train s’éloigne du passage. Attention toutefois, les barrières ne doivent pas s’ouvrir tant qu’il reste un autre train dans la zone comprise entre tous les détecteurs éloignés.

Tant que les barrières ne sont pas complètement ouvertes, les feux rouges de chaque coté, sur la route doivent clignoter. Comme dans la réalité, ce sont des lampes à incandescence qui s’allume et s’éteignent avec une certaine inertie, on reproduira cette inertie sur des Leds rouges, gräce aux commandes analogiques.

Enfin, l’ouverture et la fermeture des barrières est opéré par un moteur Fulgurex livré avec le passage à niveau. Ce moteur devra donc être alimenté dans un sens ou dans l’autre pendant 4 à 5 secondes environ. Les feux restent donc en service pendant cette manoeuvre.

Le matériel nécessaire

Compte tenu de ce cahier des charges, un Arduino Mini suffira. L’absence de port USB est compensée par le fait que je dispose d’interface "Bob" d’Elektor qui se raccordent facilement sur le Mini dont les pins sont sur un des petits cotés. On trouve également sur le web des interfaces USB-serie pour presque rien. Dernièrement j’ai même trouvé un Arduino Mini avec l’interface USB-série séparée, le tout pour 6€ environ (avec le chip original FT232 de FTDI).

Attention : il faut bien relier la sortie TxD de l’interface USB avec l’entrée RxD du Mini, ainsi que la sortie TxD du Mini avec l’entrée RxD de l’interface USB. Ensuite on relie le Vcc au Vcc, le Gnd au Gnd et la sortie DTR de l’interface USB à la patte marquée GRN sur le Mini (c’est ce qui permet à l’IDE Arduino de passer le Mini en mode programmation).

Arduino Pro-Mini

Les ILS sont raccordés directement sur 10 pins de l’Arduino, les communs des ILS étant regroupés sur le 0V.

Les feux sont réalisés avec 2 Leds rouges en série, sur une pin analogique (à sortie en PWM) du Mini.

Les commandes du moteur sont faites avec une carte à 2 relais qui se pilote par 2 sorties du Mini. J’ai choisi 2 pins analogiques, utilisées en digital.

Une extension à 2 relais unipolaires

Pour alimenter l’Arduino, les Leds et les relais, j’ai réalisé une petite alimentation régulée par un 7805, avec un pont de diode et quelques condensateurs. J’ai préféré cela au régulateur embarqué dans le Mini, qui me semble un peu sous-dimensionné pour alimenter les relais et les Leds.

Au total, on peut s’en sortir avec 10€ de matériel, sans les ILS ni le passage à niveau.

Le schéma

Sur ce schéma, la carte à 2 relais est représentée par seulement 2 relais, n’ayant pas le dessin de l’élément acheté qui se raccorde par 4 contacts : relai 1, relai 2, 5V et 0V.

Schéma du Passage à Niveau

La source d’alimentation est prise sur celle du moteur Fulgurex. Comme sa tension peut être comprise entre 8 et 15 volts, le régulateur externe 7805 tiendra bien le choc (la tension maximum est de 40V au lieu de 12V pour un Arduino Mini).

La réalisation

Une planchette en bois sert de support direct aux composants. Elle permet un étiquetage clair des connexions.

Les ingrédients sur une planchette

Petite anecdote : Lors d’un essai précédent, avant l’ajout de la petite alimentation 5V, j’avais utilisé le régulateur intégré de l’Arduino Mini. Résultat d’une erreur : le régulateur intégré est parti en fumée. Mais tout le reste de l’Arduino est intact : quel chance, mais aussi quelle robustesse ! C’est pour cela qu’on peut voir une zone noircie sur le Mini. Depuis, j’ai refait le montage avec un Mini tout neuf.

Les dominos ordinaires aurait pu être avantageusement remplacés par cette superbe plaque à borniers.

Le programme

C’est la partie la plus intéressante du projet !
Je précise tout de suite que ce n’est pas le meilleur programme possible : il ne couvre pas tous les cas possibles. Ca se coince parfois lors de manoeuvres spéciales.
Mais c’est un programme convenable pour les cas ordinaires et assez simple à comprendre pour les débutants.

Nous verrons plus loin que cet article aura une suite, justement pour explorer un peu plus cet automate qui n’est pas si trivial que ça en a l’air.

On commence donc par la déclaration des ports d’entrée et sortie :

// Pins utilisées pour les connexions aux detecteurs Reed
#define ReedA1    2  //RA1 = O1-29G
#define ReedB1    3  //RB1 = F1-29G
#define ReedC1    4  //RB2 = F1-29D
#define ReedD1    5  //RD2 = O1-29D
#define ReedA2    6  //RA2 = O2-30G
#define ReedB2    7  //RB2 = F2-30G
#define ReedC2    8  //RC2 = F2-3031D
#define ReedD2    9  //RD2 = O2-3031D
#define ReedA3   A2  //RA3 = O2-31G
#define ReedB3   A3  //RB3 = F2-31G

// Pins utilisées pour la Led et le PAN
#define LED      13    // on board
#define Feux     11    // PWM ou digital OUT
#define PANPWM   12    // not used
#define PAN1     A0    //digital OUT IN2 relai
#define PAN2     A1    //digital OUT IN1 relai
#define PANMOVE  5000  // duree d'activation du moteur Fulgurex

Puis, pour éviter tout problème de contact au niveau des ILS, on utilise intensivement la bibliothèque Bounce.

#include <Bounce2.h>  // librairie de gestion des contacts Reed

// Instantie 8 objets Bounce avec une durée de 10 millisecond de debounce
Bounce bounceA1 = Bounce(); 
Bounce bounceB1 = Bounce(); 
Bounce bounceC1 = Bounce(); 
Bounce bounceD1 = Bounce(); 
Bounce bounceA2 = Bounce(); 
Bounce bounceB2 = Bounce(); 
Bounce bounceC2 = Bounce(); 
Bounce bounceD2 = Bounce(); 
Bounce bounceA3 = Bounce();
Bounce bounceB3 = Bounce();

Petit programme, donc peu de variables :

// Variables
boolean RA1, RA2, RB1, RB2, RC1, RC2, RD1, RD2, RA3, RB3 = false;
int etat1, etat2 = 0;  // libre
boolean dir1, dir2 = false;
boolean etat_PAN = true;  // true=ouvert, false=fermé
unsigned long TimerFeux, TimerPAN;
int fadeValue;  // valeur variable de la durée du fading des feux
int fading = 10;  // 10 croit/decroit ou 1000 allume/eteint
int cycle = 0;   // 0 eteint, 1 croit, 2 allumé, 3 decroit
int panValue = PANMOVE; //durée impulsion ouverture et fermeture pour Fulgurex
boolean Fulgurex = false;  // true seulement pour envoyer le courant au moteur

A ce stade, j’avoue que la déclaration de plusieurs variables de même type sur la même ligne avec la dernière = 0, n’entraine pas nécessairement que la première (et les autres) soient aussi = 0

Le Setup

// SETUP
void setup() {
  // entrées
  pinMode(ReedA1,INPUT_PULLUP);
  pinMode(ReedB1,INPUT_PULLUP);
  pinMode(ReedC1,INPUT_PULLUP);
  pinMode(ReedD1,INPUT_PULLUP);
  pinMode(ReedA2,INPUT_PULLUP);
  pinMode(ReedB2,INPUT_PULLUP);
  pinMode(ReedC2,INPUT_PULLUP);
  pinMode(ReedD2,INPUT_PULLUP);
  pinMode(ReedA3,INPUT_PULLUP);
  pinMode(ReedB3,INPUT_PULLUP);
  // sorties
  pinMode(LED,OUTPUT);
  pinMode(Feux,OUTPUT);
  pinMode(PAN1,OUTPUT);
  pinMode(PAN2,OUTPUT);
  digitalWrite(PAN1, HIGH);
  digitalWrite(PAN2, HIGH);
  //définition des objets bounce
  bounceA1.attach(ReedA1); 
  bounceB1.attach(ReedB1);
  bounceC1.attach(ReedC1);
  bounceD1.attach(ReedD1);
  bounceA2.attach(ReedA2);
  bounceB2.attach(ReedB2);
  bounceC2.attach(ReedC2);
  bounceD2.attach(ReedD2);
  bounceA3.attach(ReedA3);
  bounceB3.attach(ReedB3);
  bounceA1.interval(50);
  bounceB1.interval(50);
  bounceC1.interval(50);
  bounceD1.interval(50);
  bounceA2.interval(50);
  bounceB2.interval(50);
  bounceC2.interval(50);
  bounceD2.interval(50);
  bounceA3.interval(50);
  bounceB3.interval(50);
  
  TimerFeux = millis(); 
}

La boucle Loop contient 4 types d’actions :

  • La détection des ILS
  • La gestion de l’automate de clignotement des feux
  • La gestion du moteur Fulgurex (ouverture ou fermeture) pendant le temps défini par PANMOVE

Détections des ILS

Chaque détection est faite par la bibliothèque Bounce et entraîne une action spécifique à chaque ILS.

 // Update the debouncer
  bounceA1.update ( );
  bounceB1.update ( );
  bounceC1.update ( );
  bounceD1.update ( );
  bounceA2.update ( );
  bounceB2.update ( );
  bounceC2.update ( );
  bounceD2.update ( );
  bounceA3.update ( );
  bounceB3.update ( );
 
   // Une transition de HIGH à LOW entraine une action (fonction)
   if ( bounceA1.fell() ) {
     action1();    
   }  
   if ( bounceB1.fell() ) {
     action2();    
   }  
   if ( bounceC1.fell() ) {
     action3();    
   }
   if ( bounceD1.fell() ) {
     action4();    
   }  
   if ( bounceA2.fell() ) {
     action5();    
   }  
   if ( bounceA3.fell() ) {
     action5();    
   }  
   if ( bounceB2.fell() ) {
     action6();    
   }  
   if ( bounceB3.fell() ) {
     action6();    
   }
  if ( bounceC2.fell() ) {
     action7();    
   }  
   if ( bounceD2.fell() ) {
     action8();    
   }

On notera que les actions pour la branche déviée de l’"Y" sont les même que celles de la branche droite.

On verra le contenu de ces actions un peu plus loin.

L’automate des feux

Il est bien évidemment interdit d’utiliser l’instruction delay().

L’astuce consiste à détecter l’écoulement d’un laps de temps défini par la variable "fading" et à invoquer le fonction FeuxON(). C’est cette dernière qui réalise l’automate par une série d’états associés chacun à une valeur particulière de"fading", ce que nous verrons plus loin.

   digitalWrite(LED, etat_PAN );
   if ((TimerFeux + fading) < millis())
   {
     TimerFeux = TimerFeux + fading;
     if (!etat_PAN)
     {
       FeuxON();
     }
   }

Cette petite partie fait simplement avancer l’automate FeuxON() à chaque période définie par la variable fading dont la valeur change dans l’automate.

On peut obtenir ainsi un comportement sophistiqué de manière simple.

L’automate du moteur de barrière

Du même principe, il stoppe le moteur à la fin d’une tempo initialisée dans une des actions liées aux détections d’ILS.

 // commande de barrière (impulsion de duree panValue)  
   if (Fulgurex)
   {
     FeuxON();                      // le feu reste allume pendant la manoeuvre
     if ((TimerPAN + panValue) < millis())  // depassement timer
     {
       Fulgurex = false;
       digitalWrite(PAN2, HIGH);       // arret relais Fulgurex
       digitalWrite(PAN1, HIGH);
       if (etat_PAN) 
       {
         FeuxOFF();                  // extinction feu à la fin de l'ouverture
       }
     }
   }

On notera que le feu rouge pour les voitures doit rester allumé pendant la manœuvre de la barrière.

Les actions en réponse aux détections ILS

L’état libre ou occupé des voies est représenté par les variables état1 et état2.
Pour tenir compte de la possibilité de la présence de plusieurs trains dans la zone, chaque entrée de train se traduit par l’incrémentation de la variable étatx.

La sortie des trains, par symétrie, se fait par décrémentation de cette variable.

Il faut qu’elle passe à zéro pour constater que la zone est libre !

void action1()    // detecteur loin a gauche du PaN voie 1
{
/*- RA1 - O1-29G   
           -> si etat1=false, alors etat1=true, dir1=ADroite (entrée par la gauche de la voie 1, direction vers droite)
           -> si etat1=true, alors etat1=false,  (sortie par la gauche de la voie 1)
              et -> si etat2=false (voie 2 libre), alors etat_PAN=ouvert (ouverture PAN autorisée)
*/

  if (etat1 == 0)   // etat libre, entrée par la gauche voie 1
  {
    etat1++;     // voie 1 occupée
    dir1=true;  // vers la droite
  } else {        // sinon pas libre donc c'est une sortie vers la gauche
                  // ou une autre entree par la gauche
    if (!dir1)    // sortie
    {
      if (etat1 > 0) 
      {
        etat1--;  // voie 1 libre
      }
    } else {      // entree
      etat1++;
      dir1=true;
    }
    
    if ((etat1 == 0) && (etat2 == 0))  // si voies 1 et 2 libres
    {
      etat_PAN=true;  // ouverture si l'autre voie est libre
      FeuxON();
      OuvreBarriere();
    }
  }  
}
/////////////////////
void action2()    // detecteur pres à gauche du PaN voie 1
{
// RB1 - F1-29G   
//            -> si etat1>0 et dir1=ADroite alors etat_PAN = ferme (fermeture PAN)

  if (etat1 && dir1 && etat_PAN) // vers la droite 2e détecteur à gauche du PaN
  {
    etat_PAN=false; // fermeture 
    FeuxON();
    FermeBarriere();
  }  
}
/////////////////////
void action3()    // detecteur près à droite du PaN voie 1
{
//- RC1 - F1-29D   
//             -> si etat1>0 et dir1=AGauche alors etat_PAN = ferme (fermeture PAN)

  if (etat1 && !dir1 && etat_PAN)  // vers la gauche 2e détecteur à droite du PaN
  {
    etat_PAN=false; // fermeture
    FermeBarriere();
    FeuxON();
  }  
}
/////////////////////
void action4()    // detecteur loin a droite du PaN voie 1
{
/*- RD1 - O1-29D  
           -> si etat1=false, alors etat1=true, dir1=AGauche (entrée par la droite de la voie 1, direction vers gauche)
           -> si etat1=true,  alors etat1=false (sortie par la droite de la voie 1)
              et si etat2=false (voie 2 libre), alors etat_PAN=ouvert (ouverture PAN)
*/
              
  if (etat1 == 0)    // etat libre, entrée par la droite voie 1
  {
    etat1++;         // voie 1 occupee
    dir1=false;      // vers la gauche
  } else {           // sinon pas libre donc c'est une sortie vers la droite
                     // ou une nouvelle entree par le droite
    if (dir1)        // sortie
    {
      if (etat1 > 0)
      {
        etat1--;
      }
    } else {        // sinon  entree
      etat1++;
      dir1=false;
    }
    if ((etat1==0) && (etat2==0))
    {
      etat_PAN=true;
      FeuxON();
      OuvreBarriere();
    }
  }  
}
/////////////////////
void action5()
{
/*- RA2 ou RA3
- O2-30G   -> si etat2=false, alors etat2=true, dir2=ADroite (entrée par la gauche de la voie 2, direction vers droite)
- O2-31G   -> si etat2=true alors etat2=false (sortie par la gauche de la voie 2)
              et -> si etat1=false (voie 1 libre), alors etat_PAN=ouvert (ouverture PAN)
*/
              
  if (etat2 == 0)    // voie 2 libre, entree par la gauche
  {
    etat2++;
    dir2=true;
  } else {         // sinon pas libre donc c'est une sortie vers la gauche
                   // ou nouvelle entree par la gauche
    if (!dir2)      // sortie
    {
      if (etat2 > 0)
      {
        etat2--;
      }
    } else {      // sinon entree
      etat2++;
      dir2=true;
    }
    if ((etat1==0) && (etat2==0))
    {
      etat_PAN=true;
      OuvreBarriere();
    }
  }   
}
/////////////////////
void action6()
{
//- RB2 ou RB3 - F2-30G ou F2-31G   
//            -> si etat2=true et dir2=ADroite alors etat_PAN = ferme (fermeture PAN)

  if (etat2 && dir2 && etat_PAN)
  {
    etat_PAN=false;
    FeuxON();
    FermeBarriere();
  }  
}
/////////////////////
void action7()
{
//- RC2 - F2-3031D 
//          -> si etat2=true et dir2=AGauche alors etat_PAN = ferme (fermeture PAN)

  if (etat2 && !dir2 && etat_PAN)
  {
    etat_PAN=false;
    FeuxON();
    FermeBarriere();
  }     
}
/////////////////////
void action8()
{
/*- RD2 
- O2-3031D 
          -> si etat2=0, alors etat2=true, dir2=AGauche (entrée par la droite de la voie 2, direction vers gauche)
           -> si etat2=true  alors etat2=false (sortie par la droite de la voie 2 et )
              et -> si etat1=false (voie 1 libre), alors etat_PAN=ouvert (ouverture PAN)
*/
              
  if (etat2 == 0)    //entree par la droite, direction vers gauche
  {
    etat2++;
    dir2=false;
  } else {          // sinon sortie vers la droite
                    // ou nouvelle entree 
    if (dir2)
    {
      if (etat2 > 0)
      {
        etat2--;
      }
    } else {
      etat2++;
      dir2=false;
    }
    if ((etat1==0) && (etat2==0))
    {
      etat_PAN=true;
      FeuxON();
      OuvreBarriere();
    }
  }      
}

Les fonctions d’ouverture et fermeture de la barrière

Le fait de passer la variable Fulgurex à true va démarrer le décomptage du temps dans la loop.

void OuvreBarriere()
{
  digitalWrite(PAN1, LOW);  // commande relai sens ouvrir
  TimerPAN = millis();
  Fulgurex = true;
}

void FermeBarriere()
{
  digitalWrite(PAN2, LOW);  // commande relai sens ouvrir
  TimerPAN = millis();
  Fulgurex = true;
}

Le clignotement réaliste des feux

Cette partie peut être réutilisée dans beaucoup d’animations lumineuses réalistes.

On considère 4 phases dans l’allumage des feux :

  • une phase de luminosité croissante pendant 1/10e de seconde
  • une phase de luminosité maximum pendant 1 seconde
  • une phase de luminosité décroissante pendant 1/10e de seconde
  • une phase de luminosité nulle pendant 1/2 seconde

On passe d’une phase à l’autre à l’écoulement de la variable fading, initialisée à la phase précédente et testée avec le temps système dans la loop.

void FeuxON()
{
  switch (cycle)
  {
    case 0: //éteint >> démarrage croissance 
    cycle = 1;
    fading = 10;
    fadeValue = 10;
    break;
    //
    case 1: //croissance
    analogWrite(Feux, fadeValue);
    fadeValue = fadeValue + 10;
    if (fadeValue > 255)
    {
      fading = 1000;
      cycle = 2;
    }
    break;
    //
    case 2: //allumé >> démarrage décroissance
    cycle = 3;
    fading = 10;
    fadeValue = 255;
    break;
    //
    case 3: // decroissance
    analogWrite(Feux, fadeValue);
    fadeValue = fadeValue - 10;
    if (fadeValue < 0)
    {
      fading = 500;
      cycle = 0;
    }
    break;
  }
}

L’extinction des feux

void FeuxOFF()
{
  analogWrite(Feux, 0);    // éteint
}

Le code complet

On trouvera dans le document joint le code complet du passage à niveau.

Dans ce code j’ai ajouté une fonction de DEBUG qui utilise la console de l’IDE Arduino pour afficher un message à chaque événement et l’état des principales variables.

Il y a aussi une possibilité de simuler les détections d’ILS en tapant des chiffres au clavier.

On peut faire disparaître du code l’ensemble de la fonction de DEBUG en mettant la définition au début en commentaire.

//#define DEBUG      // a mettre en commentaire pour enlever les echanges avec la console
Le sketch du Passage à Niveau (version 0.9 du 1/03/2015)

L’installation in situ a eu lieu et le montage fonctionne bien... dans presque tous les cas... sauf quelques uns ;(.
Comme toujours dans un projet, il y a quelques améliorations que je ne manquerai pas de vous donner dans un prochain article.

Mais en réalité c’est une nouvelle manière de raisonner et un nouvel automate qui vous sera présenté par Jean-Pierre très prochainement, car le passage à niveau est un cas d’école !!!

Ensuite, nous y ajouterons l’incontournable sonnerie qui accompagne toujours la fermeture de la barrière. Le tout dans notre Mini, avec un lecteur de carte SD en plus : OUI il arrive à tout faire !

Enfin, nous espérons vous proposer une nouvelle réalisation avec un circuit imprimé.

Donc ne ratez pas les prochains articles !

24 Messages

Réagissez à « Un automatisme de Passage à Niveau »

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)

Mon premier décodeur pour les aiguillages DCC

La rétro-signalisation sur Arduino

Chenillard de DEL

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

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

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

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

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