LOCODUINO

La rétro-signalisation sur Arduino

Le 21 décembre 2015. Par : JPClaude

DIFFICULTÉ :

#include <UNO_S88.h>    // la librairie S88 pour les UNO/Nano
 
void setup() {
  S88_Setup(16);        // on donne le nombre capteur 8 ou 16
}
 
void loop() {
  S88_Loop();           // boucle sur les capteurs
}

#include <Arduino.h>
void S88_Setup(int nb_sensors);
void S88_Loop();

#include "UNO_S88.h"
#include <Arduino.h>
 
const byte clockS88 = 2;  // horloge du bus S88 pin = 2
int clockCounter=0;       // compteur de tops horloge 
const byte PSS88 = 3;     // signal PS du bus S88 pin = 3
long loopCounter=0;       // reset proper à l’ECOS
const byte dataIn=0;      // entrée des données depuis un autre Arduino dans
                          // la chaîne S88 pin = 0
const byte dataOut=1;     // sortie des données vers un autre Arduino dans
                          // la chaîne ou vers la centrale pin=1
unsigned int sensors=0;   // tampon de 16 bits pour les capteurs
unsigned int data=0xffff; // le registre à décalage
int nbsensors;            // nombre de capteurs  8 or 16
int beginPin = 4;         // première broche utilisée pour les capteurs
int endPin8 = 12;         // dernière broche pour  8 capteurs
int endPin16 = 21;        // dernière broche pour 16 capteurs
int endPin;               // variable locale
 
// routine d’interruption du signal PS
// (déclenchement d’un nouveau cycle d’horloge)
 
void PS() {
    clockCounter=0;       // on remet le compteur à zéro
    data=sensors;         // on vide le tampon des capteurs dans le
                          // registre à décalage
    sensors=0;            // on remet à zéro le tampon des capteurs
    loopCounter++;        // on incrémente le nombre de top d’horloge
}
 
// routine d’interruption de l’horloge S88
 
void clock() {
    digitalWrite(dataOut,bitRead(data,clockCounter)); // on décale 1 bit en sortie
    delayMicroseconds(16);                            // délai pour le décalage
    bitWrite(data,clockCounter,digitalRead(dataIn));  // on décale 1 bit en entrée
    clockCounter =(clockCounter +1) % nbsensors;      // modulo le nombre de capteurs
                                                      // (8 ou 16)
}
 
// le setup S88
 
void S88_Setup(int nb_sensors) {
    nbsensors = nb_sensors;         // nombre de capteurs désirés (8 ou 16)
    if (nbsensors == 8) {           // MAJ des broches concernées
      endPin = endPin8;
    }
    else {
      endPin = endPin16;
    } 
    pinMode(clockS88, INPUT_PULLUP); // init de la broche pour l’horloge
    attachInterrupt(0,clock,RISING); // horloge sur int 0 sur la broche 2 
    pinMode(PSS88, INPUT_PULLUP);    // init de la broche du signal PS
    attachInterrupt(1,PS,RISING);    // PS sur int1 sur la broche 3
    pinMode(dataIn,INPUT_PULLUP);    // pin 0 = entrée des données depuis un
                                     // autre Arduino
    pinMode(dataOut, OUTPUT);        // pin 1 = sortie des données vers la
                                     // centrale ou vers un autre Arduino
                                     // dans le chaînage S88
    for (int i = beginPin; i< endPin;i++) {
      pinMode(i,INPUT_PULLUP);       // init des broches des capteurs
    }
}
 
// la boucle
 
void S88_Loop() {
    if (loopCounter==20) {
      bitSet(sensors,0);             // reset des tampons des capteurs pour l’ECOS
    }
    for (int i = 4; i<endPin; i++) { // MAJ des capteurs
      if (!digitalRead(i)) {
        bitSet(sensors,i-4);
      }
    }
}

#include <MEGA_S88.h> // librairie S88 pour le MEGA
 
void setup()
{
  S88_Setup(2);       // on donne le nombre de modules souhaités
}
 
void loop()
{
  S88_Loop();		      // on boucle
}

#include "MEGA_S88.h"
#include <Arduino.h>
 
// Allocation des broches
 
const byte dataIn   = 0; // entrée des données depuis d’autres Arduino
const byte dataOut  = 1; // sortie vers la centrale ou vers d’autres 
                         // Arduino
const byte clockS88 = 2; // int0 pour l’horloge sur la broche 2 
const byte PSS88    = 3; // int1 pour le signal PS sur la broche 3 
 
int clockCounter = 0;    // compteur des tops horloge 
long loopCounter = 0;    // reset propre à l’ECOS
 
// nombre de modules de 16 capteurs 
 
int nbBlocs = 0; // le nombre de module souhaité
 
// registres à décalage des différents modules
 
unsigned int data1 = 0xFFFF; // register du module 1
unsigned int data2 = 0xFFFF; // register du module 2
unsigned int data3 = 0xFFFF; // register du module 3
unsigned int data4 = 0xFFFF; // register du module 4
 
// tampon des capteurs
 
unsigned int sensors1 = 0; // 16 capteurs du module 1
unsigned int sensors2 = 0; // 16 capteurs du module 2
unsigned int sensors3 = 0; // 16 capteurs du module 3
unsigned int sensors4 = 0; // 16 capteurs du module 4
 
// internal variable
 
int i,j;
 
// routine d’interruption du signal PS 
 
void PS()
{
  clockCounter = 0;  // RAZ du compteur de top horloge
  // il y a au moins un module, le premier le module 1
  data1 = sensors1;  // on vide le tampon des capteurs
                     // dans le registre à décalage
  sensors1 = 0;      // RAZ du tampon des capteurs
  switch (nbBlocs)
  {
    case 2 : { // si deux modules
      data2 = sensors2; sensors2 = 0;
      break;
    }
    case 3 : { // si 3
      data2 = sensors2; sensors2 = 0;
      data3 = sensors3; sensors3 = 0;
      break;
    }
    case 4 : { // si 4
      data2 = sensors2; sensors2 = 0;
      data3 = sensors3; sensors3 = 0;
      data4 = sensors4; sensors4 = 0;
      break;
    }
  }
  loopCounter++; // for reset management
}
 
// clock signal from S88
 
void clock()
{
  // exit bits to next S88 in chain
  digitalWrite(dataOut, bitRead(data1,clockCounter));
  switch (nbBlocs) // data buffer shift
  {	
    case 1 : {
      bitWrite(data1, clockCounter, digitalRead(dataIn));
      break;
    }
    case 2 : {
      bitWrite(data1, clockCounter, bitRead(data2,clockCounter));
      bitWrite(data2, clockCounter, digitalRead(dataIn));
      break;
    }
    case 3 : {
      bitWrite(data1, clockCounter, bitRead(data2,clockCounter));
      bitWrite(data2, clockCounter, bitRead(data3,clockCounter));
      bitWrite(data3, clockCounter, digitalRead(dataIn));
      break;
    }
    case 4 : {
      bitWrite(data1, clockCounter, bitRead(data2,clockCounter));
      bitWrite(data2, clockCounter, bitRead(data3,clockCounter));
      bitWrite(data3, clockCounter, bitRead(data4,clockCounter));
      bitWrite(data4, clockCounter, digitalRead(dataIn));
      break;
    }
  }
  clockCounter = (clockCounter + 1) % 16; // bits 0 to 15
}
 
// setup
 
void S88_Setup(int NbBlocs)
{
  nbBlocs = NbBlocs;
  for (i=4; i<20; i++) { // the first bloc
    pinMode(i,INPUT_PULLUP);
  }
  switch (nbBlocs)
  {
    case 2 : { // the second
      for (i=22; i<38; i++) {
        pinMode(i,INPUT_PULLUP);
      }
      break;
    }
    case 3 : { // the third
      for (i=22; i<54; i++) {
        pinMode(i,INPUT_PULLUP);
      }
      break;
    }
    case 4 : { // the fourth
      for (i=22; i<70; i++) {
        pinMode(i,INPUT_PULLUP);
      }
      break;
    }
  }
  pinMode(clockS88,INPUT_PULLUP);  // S88 clock in input
  attachInterrupt(0,clock,RISING); // interrupt int0
  pinMode(PSS88,INPUT_PULLUP);     // S88 PS in input
  attachInterrupt(1,PS,RISING);    // interrupt int1
  pinMode(dataOut, OUTPUT);        // init data out to other Arduino
                                   // or control board
  digitalWrite(dataOut,LOW);       // led off
  pinMode(dataIn,INPUT_PULLUP);    // data in from other Arduino
}
 
// loop
 
void S88_Loop()
{
  // reset management for ECOS
  if (loopCounter == 20) {
    bitSet(sensors1,0);
    switch (nbBlocs)
    {
      case 2 : {
        bitSet(sensors2,0);
        break;
      }
      case 3 : {
        bitSet(sensors3,0);
        break;
      }
      case 4 : {
        bitSet(sensors4,0);
        break;
      }
    }
  }
 
  // update all sensors by group
  for (i=4; i<20; i++) {
    if (!digitalRead(i)) {
      bitSet(sensors1,i-4);
    }
  }
 
  switch (nbBlocs)
  {
    case 2 : {
      for (i=22; i<38; i++) {
        if (!digitalRead(i)) {
          bitSet(sensors2,i-22);
        }
      }
      break;
    }
    case 3 : {
      for (i=22; i<38; i++) {
        if (!digitalRead(i)) {
          bitSet(sensors2,i-22);
        }
      }
      for (i=38; i<54; i++) {
        if (!digitalRead(i)) {
          bitSet(sensors3,i-38);
        }
      }
      break;
    }
    case 4 : {
      for (i=22; i<38; i++) {
        if (!digitalRead(i)) {
          bitSet(sensors2,i-22);
        }
      }
      for (i=38; i<54; i++) {
        if (!digitalRead(i)) {
          bitSet(sensors3,i-38);
        }
      }
      for (i=54; i<70; i++) {
        if (!digitalRead(i)) {
          bitSet(sensors4,i-54);
        }
      }
      break;
    }
  }
}

142 Messages

• La rétro-signalisation sur Arduino 26 décembre 2015 13:23

  Super article ! Merci.
  Juste une amélioration possible pour le détecteur d’occupation, j’utilise des optocoupleurs ACPL-8x4 (824 ou 844) permettant aussi un fonctionnement en analogique (dans les deux sens), ils disposent de 2 diodes têtes bêches… et la version 844 permet une optimisation espace et prix intéressant !

  Michel

  Répondre

• La rétro-signalisation sur Arduino 26 décembre 2015 16:16, par JPClaude

  Bonjour,
  Merci beaucoup pour cette information car effectivement c’est un vrai gain d’espace qui me manquait. Je vais en commander et tester la chose au plus vite.
  Bonnes fêtes à vous.
  Cordialement.

  Répondre

• La rétro-signalisation sur Arduino 26 décembre 2015 22:47

  Et en analogique cela pourrait donner quoi comme détecteur ? On trouve plus de montages pour le DCC que pour l’analogique.
  Merci pour l’article

  Répondre

• La rétro-signalisation sur Arduino 27 décembre 2015 16:22, par JPClaude

  Bonjour,
  pour la détection en analogique je pense que Michel (ci-dessus) donne la réponse en utilisant des ACPL-824 ou ACPL-844 (http://www.avagotech.com/docs/AV01-0475EN) en lieu des 4N35.
  En analogique je pense que le bus S88 ne sert à rien, soit on récupère le signal (nommé "entrée Arduino") pour allumer une led ou faire un autre traitement, sinon le mieux, je pense, pour la rétro-signalisation en analogique, est de considérer un bus CAN comme abordé dans l’article http://www.locoduino.org/spip.php?article130 qui permet de dissocier la traction (analogique ou digitale) des interactions avec les accessoires.

  Répondre

  • La rétro-signalisation sur Arduino 28 décembre 2015 16:49, par Pierre59

    Bonjour

    En analogique comme en digital j’utilise ce schéma, mais avec des TLP620 (simples, doubles ou quadruples) qui fonctionnent aussi dans les deux sens.

    Avec des multiplexeurs (8 ou 16 entrées) dont les sorties sont connectées au mico-contrôleur, pour gagner des pins.

    Pierre

    Répondre

• La rétro-signalisation sur Arduino 31 décembre 2015 10:37, par Gilles29

  Bonjour ,
  tout d’abord merci pour cet article .
  je viens de faire un essai avec un Nano :
  en utilisant des diodes IR , la détection fonctionne parfaitement .
  j’ai pu le vérifier sur mon ECos .
  j’ai rajouté ce Nano dans ma chaîne de S88 N par l’intermédiaire d’un adaptateur S88-RJ45 . et là il y a un problème , les S88 précédents sont parasités et indiquent des occupations qui n’existent pas . Le Nano , lui par contre, envoi de bonnes infos.
  je vais essayer de le mettre en début de chaîne pour voir .

  Gilles

  Répondre

  • La rétro-signalisation sur Arduino 31 décembre 2015 16:21, par JPClaude

    Bonjour,
    voilà une information intéressante. j’avoue que n’ai essayé qu’avec des NANO en chaînes et sans RJ45 et tout marche bien. Il faut bien préciser le nombre de détecteur (8 ou 16) par module sinon l’horloge se mélange les pinceaux.
    Tenez nous au courant de votre retour d’expérience, je vais essayé de tester avec des LDT que j’ai dans les semaines qui viennent.
    Bonne fête de réveillon.
    Cordialement.

    Répondre

  • La rétro-signalisation sur Arduino 7 janvier 2016 12:37, par JPClaude

    Bonjour,
    je reviens vers vous car j’ai testé avec une carte Arduino Nano à 16 détecteurs avec des LDT RM-DEC-88-O.
    1) si l’on n’a que des Arduino, je n’ai pas de problème.
    2) Si je place l’Arduino en tête de bus, le reset ne se fait pas sur les LDT. Cela est dû certainement au fait que l’Arduino n’utilise pas le signal Reset du S88. J’ai essayé de propager le signal Reset, mais cela ne change rien.
    3) si je place l’arduino après les LDT, cela marche très bien, mais il faut initialiser (au moins avec l’ECOS, avec une charge) un des 8 premiers détecteurs du premier LDT.
    Si quelqu’un a des idées ???
    Bien cordialement.
    Jean-Pierre

    Répondre

    • La rétro-signalisation sur Arduino 1er février 2016 15:34, par Gilles29

      Bj , après avoir reçu de nouveaux Nano , j’ai refais des essais
      avec un Arduino-S88 nano en bout de chaine , tout fonctionne correctement , il faut juste ne pas oublier de relier la Pin 12 à la masse .
      monté sur un support à vis , l’emploi est très facile .
      le schéma de connexion dans l’article est faux ,le fil data du bus est à connecté sur la Pin 13 ..
      les Pins RX et Tx sont d’ailleurs des entrées de capteur .
      En tout cas merci pour cet article et ce decodeur de rétro qui revient à trois fois rien !

      Répondre

      • La rétro-signalisation sur Arduino 1er février 2016 16:47, par JPClaude

        Bonjour,

        Très content que cela marche.
        Par contre c’est moi maintenant qui ne comprend pas pourquoi il faut relier la pin 12 à la masse et la pin 13 au data ?
        Elles sont utilisées pour la détection.
        Les pins Rx et Tx servent à transmettre les bits par registre à décalage entre les modules.
        Pourriez-vous me donner votre schéma ?
        Bien cordialement.

        Répondre

        • La rétro-signalisation sur Arduino 1er février 2016 17:50, par Gilles29

          je viens de me rendre compte que je n’ai pas charger le bon sketch

          j’ai pris celui-ci :

          Voir en ligne : RB-S88

          Répondre

          • La rétro-signalisation sur Arduino 1er février 2016 18:00, par Gilles29

            le lien ne fonctionne pas , désolé
            je l’avais trouvé ici :

            Voir en ligne : Site RB

            Répondre

            • La rétro-signalisation sur Arduino 1er février 2016 19:38, par JPClaude

              Effectivement je connais ce site, d’ailleurs en début d’article je cite que je me base sur ces travaux. J’ai simplement tenté de simplifier les choses et de rendre linéaire les broches de détection en utilisant RX et TX en place des broches 12 et 13 car je n’utilise pas la communication avec la console.
              Par contre de mettre le dernier dataIn à la masse et peut être une bonne idée.
              Cordialement.
              JP

              Répondre

• La rétro-signalisation sur Arduino 3 janvier 2016 14:32, par André Penneteau

  Bonjour,
  Je souhaiterais utiliser la première solution de détection proposée dans cet article, tout simplement pour déclencher le fonctionnement des barrières d’un PN.
  L’ensemble piloté par une carte Arduino.
  Dans quelle "entrée" dois-je connecter la liaison référencée "entrée Arduino" et comment coder la fonction du code qui identifiera l’information de cette occupation ?
  Merci pour votre aide.

  Répondre

• La rétro-signalisation sur Arduino 3 janvier 2016 17:03, par JPClaude

  Bonjour,
  Si j’ai bien compris vous souhaitez connecter directement une sortie du détecteur sur une broche Arduino. Il n’y a pas de problème vous pouvez choisir n’importe quelle broche. J’ai fait un petit test et cela marche très bien, attention aux rebonds qui peuvent survenir avec certain matériel. Voici un petit programme ou j’ai connecté "entrée vers Arduino" du détecteur sur la broche 5 de l’Arduino. :

  #define detection 5 // la broche connectee a "entree arduino" du detecteur
   
  byte etatPN;  // l'etat de la zone PN au moment du test de detection
  byte etatcourantPN = HIGH; // l'etat du PN actuel,
                             // il est ouvert initialement
  byte antirebond = 50;      // permet d'eviter les rebonds du au materiel
   
  void setup() {
    Serial.begin(9600);              // permet d'avoir l'etat sur la console
    pinMode(detection,INPUT_PULLUP); // mise en entree de la detection
                                     // en mode PULLUP
  }
   
  void loop() {
    etatPN = digitalRead(detection);  // on teste la broche de detection
    if (etatPN != etatcourantPN) {    // si il y a un changement d'etat,
                                      // sinon ne rien faire
       etatcourantPN = etatPN;        // nouvel etat du PN
       if ( etatcourantPN == LOW) fermeturePN(); // si niveau bas = occupe,
                                                 // on ferme le PN
       else ouverturePN();                       // si niveau haut = libre,
                                                 // on ouvre le PN
    }
      delay(antirebond);              // antirebond pour la detection
  }
   
  void fermeturePN() {
    Serial.println("fermeture du passage a niveau");
    // mettre ici les actions de fermeture du PN
  }
   
  void ouverturePN() {
    Serial.println("ouverture du passage a niveau");
    // mettre ici les actions d'ouverture du PN
  }

  Télécharger

  J’espère avoir répondu à votre question.
  Bien cordialement.
  JP

  Répondre

  • La rétro-signalisation sur Arduino 4 janvier 2016 14:01

    OUI, effectivement, je souhaite connecter directement sur un entrée Arduino, vous avez-donc répondu à ma question.

    Je testerai ce programme dès que j’aurais réalisé (ou fait réaliser dans mon cas, pour être honnête) la partie "électronique".

    Répondre

• La rétro-signalisation sur Arduino 16 janvier 2016 18:12, par André Penneteau

  Bonjour,

  J’ai compilé l’exemple de programme ci-dessus, sans problème.

  Je ne peux pas encore le tester en situation, le petit montage électronique confié à un ami n’est pas encore prêt.

  Cependant j’ai une petite question : pourquoi utliser une entrée numérique (digitalRead) et non analogique (analogRead) pour détecter les variations ?

  Répondre

• La rétro-signalisation sur Arduino 16 janvier 2016 19:23, par JPClaude

  Bonjour,

  tout simplement parce que l’optocoupleur est en "pullup", c’est à dire que l’on reçoit 5V s’il n’y a pas d’occupation ou 0V si le canton est occupé, donc du digital et non de l’analogique.
  Cordialement.
  Jean-Pierre

  Répondre

  • La rétro-signalisation sur Arduino 17 janvier 2016 13:23, par André Penneteau

    Merci pour votre réponse.

    Très novice en électronique je ne suis pas en mesure de comprendre ce qui "sortira" du montage proposé.

    Je peux donc utiliser n’importe quelle pin digitale (excepté 0 et 1) ou uniquement une de celles qui possédent une référence "tildée " ? Ce qui est le cas de la pin 5 utilisée dans votre exemple.

    Répondre

• La rétro-signalisation sur Arduino 17 janvier 2016 14:38, par JPClaude

  Bonjour,

  Oui vous pouvez utiliser n’importe quelle pin. Toutes les pins analogiques (avec tilda) peuvent être utilisées en digitale, mais pas l’inverse (les pins sans tilda ne peuvent être utilisées en mode analogique).
  Effectivement éviter les pins 0 et 1 qui servent à la communication.
  Cordialement.
  Jean-Pierre

  Répondre

• La rétro-signalisation sur Arduino 24 mai 2016 11:15, par Mikeul

  Bonjour,

  Je suis un petit modeliste ferroviaire, et je cherche un système de "détection de courant " et "rétrosignalisation si possible sans coupure de rail "
  Est ce possible ?

  Si non, dites moi ou je peux trouver des schémas de branchement très clairs [modules arduino ] pour que je puisse effectuer mon cablage en toute sécurité.
  Je possède une ecos 2 et je ne tiens pas à faire de mauvaises manipulations qui risqueraient de déteriorer ma centrale.

  très cordialement
  Mikeul

  Répondre

  • La rétro-signalisation sur Arduino 24 mai 2016 13:06, par JPClaude

    Bonjour,

    1) si vous connectez le bus S88 entre l’Arduino et l’ECOS comme présenté ici, il n’y a aucun risque pour l’ECOS (ou l’Arduino). Les détecteurs ne sont connectés qu’à l’Arduino et non pas à la console ECOS, en cas de fausse manipulation sur les capteurs c’est l’Arduino qui prendra. Le schéma est toujours le même :

    capteur - (opto ?) - pin - Arduino - bus S88 - ECOS

    2) la détection de courant sans coupure de rail, je ne vois pas comment faire. Le cas du détecteur de courant est présenté dans l’article et doit impérativement passer via un optocoupleur (la tension des rails est de l’ordre de 16V et de 5V pour l’Arduino). Si vous suivez le déroulement de l’article cela devrait marcher.

    3) vous pouvez sinon utiliser des capteurs optiques du type TRCT5000L (vous trouverez une référence sur le site http://forum.arduino.cc/index.php?topic=164799.0). Dans ce cas vous n’avez pas à couper les rails et vous pouvez connecter directement le capteur à une pin de l’Arduino (pour être efficace mettre un collant métallisé sous le train).

    4) Vous pouvez également utiliser des capteurs Reed ILS, qui se comportent comme un bouton poussoir et qui ne demande pas de couper les rails, mais il faut mettre un aimant sous le train. Ici aussi vous pouvez connecter directement l’ILS à une pin de l’Arduino (prendre garde cependant au rebond possible).

    En espérant avoir répondu à vos questions.

    Bien cordialement.

    Répondre

• La rétro-signalisation sur Arduino 2 août 2016 11:52, par Goupil

  Bonjour,
  Merci pour cet article très intéressant.

  Je voulais juste vous signaler que le 2e lien que vous donner n’existe plus.
  le domaine train35.com n’existe plus et est devenu train35.fr. Le lien correct est donc http://train35.fr/dcc18.html

  Bien à vous.

  Répondre

• La rétro-signalisation sur Arduino 7 octobre 2016 11:20, par jacques68

  Bonjour

  Je suis très interressé par ce projet de rétrosignalisation. Avec un arduino j’ai déjà reussi à programmer mes servos moteurs.
  Je m’attaque donc à la rétrosignalisation par arduino.
  Dans mon cas je but un peu sur la façon de relier l’arduino à ma centrale.
  En effet ma centrale est un Sprog…et je n’ai que les prises tx et rx dessus…
  Existe t’il un moyen de relier cela differement genre peut etre directement au pc (comme pour mes servos) ?
  Merci à tous pour votre super boulot !!!

  Répondre

• La rétro-signalisation sur Arduino 7 décembre 2016 15:54, par THIERRY

  Bonjour

  Possible d’avoir la rétro-signalisation sur Arduino avec la solution BUS RS DE LENZ.

  Merci

  Répondre

• La rétro-signalisation sur Arduino 7 décembre 2016 17:48, par JPClaude

  Oui très certainement.
  J’ai écrit cet article simplement parce que j’ai une ancienne centrale qui possède un bus S88 de première génération.
  Cordialement.

  Répondre

  • La rétro-signalisation sur Arduino 7 décembre 2016 18:06, par THIERRY

    Bonjour
    Merci pour votre réponse, mais comment dois-je procéder pour obtenir le programme
    pour BUS RS ainsi que le schéma du connecteur RS vers la centrale.

    Cordialement

    Répondre

    • La rétro-signalisation sur Arduino 20 juin 2020 21:01, par Bruce

      Hello
      THIERRY , did you find more information on RS BUS with Arduino
      Regards

      Répondre

• La rétro-signalisation sur Arduino 18 mai 2017 14:43, par pierre

  Bonjour,

  Merci pour cet article sur la rétro.

  Je tente d’installer cette rétro-signalisation sur mon réseau en N.

  J’ai réalisé deux détecteurs de consommation de courant qui fonctionnent bien.
  Je voudrais maintenant implémenter la rétro en liaison avec mon intellibox.
  J’ai branché le câble "S88" à l’arrière de l’intellibox, mais je ne comprend pas bien sur quelles broches de mon Arduino MEGA je dois brancher le cable "S88".
  Egalement sur quelles broches dois-je alimenter l’Arduino ?

  Merci de vos précisions et félicitation pour vos articles.

  Cordialement

  Répondre

• La rétro-signalisation sur Arduino 18 mai 2017 17:03, par pierre

  Bonjour,

  En étudiant de près les schémas, je crois que j’ai compris où brancher mon câble S88 sur mon Arduino MEGA :

   Broche 1-Data sur broche 1-TX0 du MEGA
   Broche 2-GND sur bbroche GND du MEGA
   Broche 3-Clock sur broche 2 du MEGA
   Broche 4-PS sur broche 3 du MEGA
   Broche 5-Reset non branché
   Broche 6-5V sur brocheVin du MEGA

  Correct ?

  Par contre, comment dois-je relier mes détecteurs d’occupation ?

   sur les broches 4 à 19 pour le fil marqué Entrée Arduino du schéma "détection" en tête de l’article je suppose.
   mais le +5V et masse du détecteur d’occupation sont ils reliés au +5V et masse de l’Arduino (ce qui me paraitrai logique)

  Cordialement

  Répondre

• La rétro-signalisation sur Arduino 18 mai 2017 17:46, par JPClaude

  Bonjour,
  les connexions sont les suivantes :
  Broches S88--------Broches Arduino
  1 : blanc data------broche1 (TX0)
  2 : marron GND------GND Arduino
  3 : vert clock------broche 2
  4 : jaune PS--------broche 3
  5 : violet reset----non connecté
  6 : rose V+---------Vin Arduino (sert à alimenter l’Arduino)

  J’espère avoir répondu à votre question.

  Cordialement.

  Répondre

• La rétro-signalisation sur Arduino 18 mai 2017 17:51, par JPClaude

  Rebonjour,
  oui tout à fait, les broches du Module1 sont les broches 4 à 19 et on relie tous les 5V et GND à l’Arduino.
  Cordialement.

  Répondre

  • La rétro-signalisation sur Arduino 19 mai 2017 17:09, par pierre

    Bonjour,

    Merci de vos réponse rapide qui permettent d’avancer.

    Lorsque je relie l’Arduino avec le câble S88 à l’Intellibox, la led de l’Arduino s’allume, ce qui indique qu’il est alimenté, sans doute par le +5V et le GND de l’Intellibox.

    Les détecteurs de consommation doivent donc aussi être alimenté par le +5V et le GND de l’Intellibox, je n"ai pas besoin d’autre alimentation 5V ???

    Cordialement

    Répondre

• La rétro-signalisation sur Arduino 19 mai 2017 17:34, par JPClaude

  Bonjour,
  A priori non pas besoin d’autre alimentation.
  Il est rare d’avoir tous les cantons occupés, sinon ça voudrait dire qu’il n’y a plus un seul train qui peut circuler.
  Cordialement.
  JP

  Répondre

• La rétro-signalisation sur Arduino 19 mai 2017 17:42, par pierre

  Merci de cette réponse,

  Je viens de câbler un premier canton, et effectivement sur mon Intellibox en mode S88, j’ai un petit losange noir qui m’indique que le 1° canton est occupé.

  Il ne me reste plus qu’à fabriquer mes 40 autres détecteurs d’occupation et à ler relier à mon Arduino MEGA.

  Je pense ensuite relier l’ensemble à mon PC avec "Itrain".

  L’expérience est passionnante.
  Un simple Arduino qui remplace tous les modules électroniques coûteux, c’est magique.

  Cordialement

  Répondre

• La rétro-signalisation sur Arduino 19 mai 2017 18:18, par JPClaude

  Bon courage.
  Cordialement.
  JP

  Répondre

• La rétro-signalisation sur Arduino 22 mai 2017 20:43, par DE SOUSA José

  Bonjour,
  Je suis débutant sur ARDUINO.
  Ok pas de problème pour le câblage électronique mais
  Que doit on mettre dans le programme pour téléverser dans l’ARDUINO UNO ?

  Merci de vos réponses.

  Répondre

• La rétro-signalisation sur Arduino 23 mai 2017 08:53, par Dominique

  Bonjour José,
  Vous trouverez toutes les réponses à votre question et à celles que vous allez encore vous poser dans la rubrique "pour débuter".

  Je me demande d’ailleurs pourquoi vous n’avez pas commencé par là !

  Bon courage.

  Répondre

• La rétro-signalisation sur Arduino 23 mai 2017 09:19, par JPClaude

  Bonjour,
  Je suis d’accord avec Dominique, étudier d’abord la rubrique "pour débuter".
  Sinon pour répondre à votre question le programme est fourni dans l’article : "le programme Arduino/nano".
  Cordialement.
  JP

  Répondre

  • La rétro-signalisation sur Arduino 23 mai 2017 20:33, par DE SOUSA José

    Merci à vous,
    Vous avez raison, je vais suivre votre suggestion.
    Juste pour info c’est quoi le point CCP ?
    Cdt.
    José

    Répondre

• La rétro-signalisation sur Arduino 23 mai 2017 20:39, par JPClaude

  Bonsoir,
  les points .h et .ccp sont des programmes écrits en C ou C++ qui sont appelés et utilisés par les programmes de l’Arduino (en général ce sont des bibliothèques qui cachent la complexité de programmation).
  Cordialement.
  JP

  Répondre

• La rétro-signalisation sur Arduino 5 juin 2017 09:26, par jacques68

  Bonjour

  J’ai enfin pu reprendre le montagede mon circuit de test. J’ai reussi à connecter mon arduino au pc via un module S88.
  La detection fonctionne bien sauf que….malheuresement il y a toujours chez moi un truc qui fonctionne mal….en l’occurence ici les cantons connectés sur les broches A1 à A5 ne sont pas détectés !!!
  Là je ne pige pas pourquoi. J’aifait pas mal de tests débranchés le canton de la broche A2 et le brancher sur la broche 6 par exemple, et la detection sur la broche 6 se fait mais pas sur la broche A2….
  Le soucis n’est donc pas au niveau de mon cablage.
  Sur mon arduino il est configuré pour connecter 16 broches, mais seul 12 broches sont reliées. Celaà t’il une incidence ???
  J’ai essayé avec un autre arduino, mais idem les broches A1 à A5 ne sont pas détecées…
  Une idée ???

  Répondre

• La rétro-signalisation sur Arduino 5 juin 2017 11:44, par JPClaude

  Bonjour,
  j’avoue ne pas avoir d’idée pour l’instant, cela marche avec une console ECOS mais n’ayant pas de SPROG je ne peux pas faire le test moi même.
  Peut être un problème de reset du bus S88 avec la variable loopCounter qui vaut 20 avec l’ECOS (sans vraiment comprendre pourquoi mais sa marche) ?
  Si quelqu’un a testé avec un SPROG merci de nous donner votre expérience.
  Cordialement.
  JP

  Répondre

  • La rétro-signalisation sur Arduino 5 juin 2017 11:51, par jacques68

    Merci de ta reponse. J’ai oublié de préciser que j’ai a présent une centrale z21. Je continu donc mes investigations !!

    Répondre

    • La rétro-signalisation sur Arduino 5 juin 2017 21:26, par jacques68

      Ok j’ai triouvé mon erreur…..j’ai honte…
      En fait j’ai pas fait gaffe. J’ai branché sur les bornes A5 et A4. Je ne l’ai pas vu de suite car j’ai branché un bornier sur ma carte..
      Tout est rentré dans l’ordre !!

      Répondre

• La rétro-signalisation sur Arduino 6 juin 2017 10:00, par JPClaude

  Bonjour,
  bonne nouvelle.
  Bonne continuation.
  Cordialement.
  JP

  Répondre

• La rétro-signalisation sur Arduino 5 juillet 2017 12:59, par jacques68

  Bonjour
  J’ai donc fini la construction du réseau test, juste une boucle avec 12 cantons, gérés par la rétro-signalisation présenté ici sur la base d’un arduino Uno.
  J’ai également 4 aiguillages pilotés par des servos moteurs et commandé par un arduino Uno.
  Le tout est géré par un logiciel sur Pc.
  Pour la partie aiguillage, aucun soucis mis à part l’optocoupleur permettant de transmettre les donnés. J’ai d’abord utilisé des 6N137 de differents fournisseurs et aucun n’a jamais fonctionné correctement. Je suis passé à un 4N25 (que j’avais en stock) et depuis celay fonctionne.

  Maintenant la rétro-signalisation, là j’ai encore quelques soucis…
  En testant les différentes zones avec une simple résistance les détections ne posaient aucun soucis, toutes très bien vues par le logiciel.
  J’ai enfin pu acquérir 2 locos digitalisées et installé un décodeur dans une troisième pour pouvoir tester tout mon montage sur mon circuit.
  Là je me suis aperçu que j’avais au niveau de la rétrosignalisation beaucoup de détections "sauvages" !!…
  C’est à dire que quand une loco entre dans un canton, la détection rétro-signalisation se fait bien mais j’ai aussi de ou trois autres canton qui sont détectés brièvement…Doc forcément cela me met le bazar dans la gestion de mes trains.
  Je pense que cela est du à des parasites, mais là je sais pas que faire pour les détecter.
  J’ai vérifié tout mon câblage qui apparemment est OK. J’ai partout des paires torsadées. Le seul endroit ou je pense c’est un peu le fouillis c’est les fils arrivant sur l’Arduino.
  D’autres ont ils constaté les mèmes soucis et ont ils résolus le problème ?

  Répondre

  • La rétro-signalisation sur Arduino 7 juillet 2017 07:44, par bobyAndCo

    Bonjour,

    Est-ce qu’il n’y a pas simplement un problème de résistances pull-up sur les entrées ?

    Répondre

  • La rétro-signalisation sur Arduino 7 juillet 2017 09:30, par Dominique

    Le fouillis à l’arrivée sur l’Arduino, je l’ai aussi mais sans ces problèmes qui peuvent avoir de multiples causes : voir le schéma nous ferait gagner du temps.

    Rien que de dire que ça marche mieux avec un 4N25 plutôt qu’un 6N137 est suspect et anormal. Après il y a la qualité des masses (le GND commun), l’impedance côté détecteur et la pull-up comme indique par Boby&co, etc…
    Le détecteur est peut-être trop ou pas assez sensible, l’insertion dans l’alimentation DCC des rails n’est peut être pas correcte, la section du feeder d’alimentation DCC trop petite, la liste peut être longue…

    Répondre

• La rétro-signalisation sur Arduino 6 juillet 2017 00:46, par Dominique

  Peut-être pourriez-vous fournir un schéma et présenter votre réseau sur le forum plutôt qu’ici où il n’est pas possible d’adjoindre des images.
  Mettez l’URL en réponse ici.
  cordialement.

  Répondre

• La rétro-signalisation sur Arduino 7 juillet 2017 15:13, par JPClaude

  Je suis surpris que les 6N137 ne marchent pas, tout fonctionne très bien chez moi (surtout avec un seul UNO).
  Peut être vérifier soigneusement le câblage, et en localisant les détecteurs, le plus proche de l’Arduino, le câble le plus long est alors en alternatif, ou proche du canton le câble le plus long est alors en continu, à mon avis la première solution devrait être la meilleure.
  Cordialement.

  Répondre

• La rétro-signalisation sur Arduino 1er novembre 2017 12:25, par pierre

  Bonjour,

  J’utilise un Arduino Mega 2560 relié à une Intellibox1.
  J’ai câble les 16 premières entrées de l’Arduino à mes modules de rétro-signalisation.

  Tout est détecté correctement, les rectangles noirs s’allument correctement sur mon Intellibox1

  Par contre lorsque je relie le 17° détecteur à la broche 22 de l’Arduino, aucune détection.

  Le 2° panneau de 16 indicateurs de l’Intellibox n’indique rien.

  Pourtant mon détecteur fonctionne, il passe bien de 0 à 5V en fonction de l’occupation.
  J’ai paramétré mon Intellibox en lui indiquant 2 modules de rétro-signalisation.

  Que peut-il bien se passer ?

  Cordialement

  Répondre

  • La rétro-signalisation sur Arduino 1er novembre 2017 14:26, par dominique

    Je dirais que c’est impossible de vous répondre sans voir le sketch Arduino dans sa totalité. Locoduino n’est pas non plus un site support de l’Intellibox où je pense que le problème réside si vous avez déjà réussi 16 connexions.
    Merci de continuer sur le Forum avec tous les détails nécessaires.
    Amicalement.

    Répondre

• La rétro-signalisation sur Arduino 2 novembre 2017 09:20, par Dominique

  Le sujet est exposé sur le forum, mais sans plus d’informatipn

  Voir en ligne : http://forum.locoduino.org/index.ph…

  Répondre

  • La rétro-signalisation sur Arduino 2 novembre 2017 16:34, par pierre

    Bonjour,

    A vrai dire je ne sais pas trop quoi mettre comme détail, dans la mesure où j’utilise très exactement ce qui est indiqué dans le projet.

    Je viens de poster un peu plus de détails sur le forum.

    Ce qui m’intrigue, c’est que le problème se pose justement au 1° détecteur du 2° module….

    Est-ce que je laisse passer quelque chose à partir du 2° module ???

    Cordialement

    Répondre

• La rétro-signalisation sur Arduino 2 novembre 2017 16:47, par pierre

  Bonjour,

  Ca y est j’ai trouvé !!!

  Dans le sketch S88, il faut penser à changer le nombre de module qui est indiqué par défaut à 1 et le passer à 2 dans mon cas, puis recompiler et téléverser.
  Sinon le signal S88 n’est généré que pour les 16 premiers détecteurs.

  #include <MEGA_S88.h> // librairie S88 pour le MEGA
  void setup() {
    // put your setup code here, to run once:
    S88_Setup(2);    // C'EST ICI QU'IL FAUT PENSER A METTRE 2 OU 3 OU 4 A LA PLACE DE 1!!!!
  }
   
  void loop() {
    // put your main code here, to run repeatedly:
    S88_Loop();
  }

  Cordialement

  Répondre

• La rétro-signalisation sur Arduino 2 novembre 2017 17:23, par JPClaude

  Bonjour,
  Dans le programme Arduino vous mettez bien la valeur 2 lors de l’appel S88_Setup(2) ?

  #include <MEGA_S88.h> // librairie S88 pour le MEGA
   
  void setup()
  {
    S88_Setup(2);       // on donne le nombre de modules souhaités
  }
   
  void loop()
  {
    S88_Loop();		      // on boucle
  }

  Vous déclarez bien 2 modules de 16 détecteurs (et non de 8 détecteurs) dans l’Intellibox ?
  Sinon je ne vois pas très bien le problème car ça marche très bien chez moi avec une ECOS, n’ayant pas d’Intellibox je ne peux pas tester moi même.
  Cordialement.

  Répondre

• La rétro-signalisation sur Arduino 13 novembre 2017 18:55, par nojade91

  Bonjour

  Excusez moi, une question hors sujet sans doute mais est possible de faire fonctionner ce système avec une centrale lenz lzv100. Je n’ai pas trouvé comment relier le câble S88 à la centrale.

  merci pour votre réponse.
  Cordialement

  Répondre

  • La rétro-signalisation sur Arduino 14 novembre 2017 13:03, par Dominique

    Bonjour ,

    Je ne connais pas ce type de centrale, mais je pense qu’elle ne supporte pas le S88, mais seulement l’xpressnet.

    moi, je fais ma centrale en Arduino et je n’ai pas ce genre de problème.

    Répondre

• La rétro-signalisation sur Arduino 14 novembre 2017 14:04, par nojade91

  Bonjour
  Un grand merci pour la réponse, c’est bien ce j’avais pensé.

  Cordialement

  Répondre

• La rétro-signalisation sur Arduino 9 décembre 2017 09:41, par Charles

  Bonjour,

  On m’a suggéré ce principe de RS pour réduire considérablement le coût de mon réseau.
  Je compte me procurer une centrale DIJIKEIJS DR5000 qui fonctionne avec les deux types de bus.

  A priori, cela devrait fonctionner, non ?

  Quelqu’un a-t-il déjà essayé avec ce matériel ?

  Merci d’avance.

  Charles

  Répondre

  • La rétro-signalisation sur Arduino 9 décembre 2017 16:36, par dominique

    Non, non, ici on ne discute pas sur les centrales du commerce, on les construit soi-même (do it yourself). Les articles ne manque pas.

    Répondre

    • La rétro-signalisation sur Arduino 9 décembre 2017 17:39, par Charles

      Mais il me semble pourtant que ce sujet parle bien de rétrosignalisation par l’arduino vers une centrale du commerce (ici ECOS dans le sujet, et je parle de la même chose sur une centrale DR5000)…
      Charles

      Répondre

      • La rétro-signalisation sur Arduino 10 décembre 2017 23:40, par Dominique

        Pardon, vous avez raison. J’espère que quelqu’un qui l’utilise conjointement avec le logiciel de cet article pourra vous répondre.

        Répondre

    • La rétro-signalisation sur Arduino 2 janvier 2018 23:13, par brfou65

      Bonjour

      Je vais bientot faire un test
      J ai une dr5000

      J attend de recevoir l adaptateur rj45

      Répondre

      • La rétro-signalisation sur Arduino 19 février 2018 18:36, par Rampanelli Mario

        Bonjour, vous avez fait des tests avec la dr5000 ?
        Bien à vous

        Mario

        Répondre

• La rétro-signalisation sur Arduino 29 mai 2018 16:03, par Pierre

  Bonjour,

  J’ai réalisé avec succès le montage proposé et j’ai maintenant 24 cantons rétro-signalé relié à mon Intellibox1 elle-même reliée à un PC fonctionnant avec RRTC.
  Tout fonctionne bien mais je voudrais passer à une étape supplémentaire, c’est à dire me passer de l’Intellibox (qui reboote sans raison) pour la partie S88.

  Est-il possible de relier l’Arduino au PC pour que celui-ci lise directement les occupations de canton sans passer par la centrale ?

  Cordialement

  Répondre

• La rétro-signalisation sur Arduino 26 juillet 2018 18:23, par vindry

  Bonjour,

  J’ai maintenant 24 cantons rétro-signalés avec un Arduino Mega2560.

  Ca fonctionne bien avec RRTC et une Intellibox1, mais comme le signale "jacques68" un peu plus haut dans les messages, j’ai aussi des détections sauvages avec des cantons qui clignotent sur RRTC et sur l’Intellibox.
  J’ai torsadé mes fils de partout, j’ai remplacé le câble plat qui va de l’intellibox à l’Arduino par un câble RJ45.
  J’ai rajouté un condensateur de 47µF en parallèle sur la résistance de 47kOhm pour pallier aux mauvais contacts roues-rails.
  Rien n’y fait.
  Apparemment ça ne perturbe pas trop RRTC, mais il signale tout de même le problème dans la liste des messages.

  Cordialement

  Pierre

  Répondre

• La rétro-signalisation sur Arduino 13 septembre 2018 19:39, par Pierre

  Bonjour,

  J’ai 24 cantons rétro signalés avec un Arduino Mega 2560.
  Je me rend compte à l’utilisation, que j’ai beaucoup de détection fantôme, c’est à dire que lorsqu’un train roule sur un canton, il est bien détecté, mais il fait clignoter brièvement d’autres cantons.

  J’ai pû constater que celà provient du contact roue-rail qui n’est pas toujours excellent et je suppose propage des parasites.

  Quel pourrait être le moyen de supprimer le problème :

   logiciel : le programme pourrait-il ignorer par exemple des entrées dont la durée est par exemple inférieure à 2ms.
   matériel : j’ai vérifié, ce n’est pas la led du 4N35 qui s’illumine brièvement, même des cantons déconnecté du courant traction, clignotent.
  C’est bien le 5V qui propage le problème comme si le transistor laissait passer brièvement le courant.

  J’ai peur qu’avec beaucoup de trains, mon logiciel de gestion se mette à paniquer.

  Cordialement

  Répondre

• La rétro-signalisation sur Arduino 13 septembre 2018 20:32, par Pierre

  Bonjour,

  Est-ce qu’il faudrait connecter la broche Rx à Gnd.

  En effet, dans le cas de plusieurs Arduino chainés, l’entrée Rx des Arduinos chainés est relié à la broche Tx du précédent.

  Mais pour le dernier, ou le premier si on n’en a qu’un comme dans le cas du méga, la broche Rx est en "l’air".
  Mais je ne sais pas si ça pose problème ou non

  Cordialement

  Répondre

• La rétro-signalisation sur Arduino 14 septembre 2018 15:15, par Pol

  Bonjour à toutes et tous,
  Merci pour ces articles super intéressant qui sont publié sur ce site il est génial.
  Milles excuses si c’était déjà indiqué quelque part, c’est que je suis passé au dessus trop vite. J’aimerais savoir si le détecteur d’occupation par consommation de courant présenté ci-dessus est compatible avec le 3 rails ? (Märklin dans mon cas) .
  Merci beaucoup et bon WE à toutes et tous.

  Répondre

• La rétro-signalisation sur Arduino 14 septembre 2018 15:17, par Pol

  Re-bonjour petite précision pour ma question précédente…
  3 Rails en digital je précise…
  merci

  Répondre

• La rétro-signalisation sur Arduino 11 octobre 2018 11:27, par Pierre

  Bonjour,

  Je suis toujours à la recherche des détections fantômes sur ma rétro-signalisation avec Arduino Mega2560.

  Je me suis rendu compte que à la sortie de l’Intellibox, j’avais à peine 5V, pour alimenter la carte Arduino par Vin ainsi que les cartes de détection.

  J’ai lu que sur Vin il fallait avoir minimum 6V pour que le régulateur de l’Arduino travaille correctement.

  Je me dis donc que mon 5V n’est pas très "propre" et qu’une partie du problème réside peut-être là.

  Y a t-il moyen d’alimenter l’Arduino autrement que par l’Intellibox, mais dans ce cas à quoi ressemblerait le câblage ?

  Cordialement

  Répondre

  • La rétro-signalisation sur Arduino 13 octobre 2018 09:41, par dominique

    Bonjour,
    Je vous conseille de poser votre question sur le forum où ce type de sujet est discuté. Il y a également un article sur l’alimentation de l’Arduino
    ici

    Répondre

• La rétro-signalisation sur Arduino 14 octobre 2018 00:11

  Bonjour,
   Vérifie bien que les masses sont correctes et "abondantes"
   Essayes d’alimenter ton Arduino avec une alimentation indépendante ne serait ce que pour "lever" le doute.
   Si tu as un oscilloscope, regardes les signaux et vérifies qu’il n ’y pas trop de bruits (herbes sur le signal).
   Vérifies que l’alimentation fournie par l’intellibox est assez puissante (voir notice intellibox).

  Répondre

• La rétro-signalisation sur Arduino 17 octobre 2018 18:57, par Thierry

  Bonjour tout le monde,

  Sur base de cet excellent projet, j’ai bricolé une détection de canton typique du système "3 rails".
  Pour ceux qui ne connaissent pas, il s’agit d’une détection par contact sur une portion isolée d’un des deux rails extérieurs et le rail central. Ce sont les essieux (conducteurs) qui connectent les deux rails extérieurs (dont l’un est isolé et raccordé sur l’entrée Arduino).
  Évidemment, l’entrée en question passe par un optocoupleur.
  Avantage de ce montage : pas besoin de consommation de courant. Donc, un wagon "perdu" reste détecté et bloque le canton ; ça peut être pratique dans les zones cachées ou en cas de circulation automatisée.
  Je joins un lien vers un forum sur lequel j’ai publié la chose (voir plus bas) …

  Attention :
  1) Il ne s’agit pour l’instant que d’un prototype sur breadboard, mais il fonctionne correctement dans la configuration de mes essais. J’ai fait réaliser quelques PCB mais mon réseau est loin d’être terminé ; donc le test final ce sera pour plus tard !
  2) Sur les schémas (visibles en suivant le lien fourni) il y a une petite erreur. Le Nano doit être alimenté par une tension DC comprise (idéalement) entre 7 et 12 V, et pas +5V comme indiqué.
  3) Ce montage permet 16 entrées, au choix (par bloc de quatre entrées) : "détection de canton" ou "détection de contact libre de potentiel" (par exemple un switch de position d’aiguillage) ; bref deux des informations standard pouvant être envoyée sur le bus S88.

  J’ai également "commis" un décodeur d’accessoires (là aussi sur base d’un projet préexistant), il est visible sur le même lien. Mais j’en parle peu ici vu qu’il est un peu hors sujet. En cas d’intérêt, il suffit de lire les détails :-)

  Voilà, je me suis décidé à en parler au cas où quelqu’un serait intéressé …

  Merci à JPClaude pour son excellent boulot !

  Au plaisir,
  Thierry.

  Voir en ligne : Module détection S88-N Arduino et décodeur accessoires DCC

  Répondre

• La rétro-signalisation sur Arduino 1er janvier 2019 20:19, par christophe

  bonjour

  Quel diamétre de cable utiliser pour le bus s88 ?
  Merci
  Chris

  Répondre

  • La rétro-signalisation sur Arduino 1er janvier 2019 21:16, par Dominique

    Ce site est bien documenté sur les normes AWG
    du 26, 28 est un bon choix, je pense.

    Répondre

• La rétro-signalisation sur Arduino 10 janvier 2019 19:35, par bernyca

  Bonjour,
  J’essaie de faire fonctionner ce montage de retro-signalisation avec une fiche RJ45 à 8 pin pour entrer dans une centrale Digkeijs en mode S88N . (Loconet je penses ?)
  Quelqu’un aurait-il un shema de cablage pour passer de S88 (6pin) à S88N avec une fiche RJ45 (8pin) ?
  Merci bien
  Bernyca

  Répondre

  • La rétro-signalisation sur Arduino 12 janvier 2019 11:46, par Dominique

    Regardez sur le Web, avec une recherche "S88N Arduino"
    Il y a des tas de schémas à voir.

    Répondre

• La rétro-signalisation sur Arduino 8 mars 2019 14:18, par BUSCH Christian

  Bonjour,
  j’essaie de compiler MEGA_S88, mais j’ai plein d’avertissements et la compilation ne se fait pas. ci-joint la liste des avertissements.
  .
  .
  .

  libraries\MEGA_S88\MEGA_S88.cpp.o (symbol from plugin) : In function `PS()’ :

  (.text+0x0) : multiple definition of `PS()’

  sketch\MEGA_S88.cpp.o (symbol from plugin) :(.text+0x0) : first defined here

  c :/program files (x86)/arduino/hardware/tools/avr/bin/../lib/gcc/avr/5.4.0/../../../../avr/bin/ld.exe : Disabling relaxation : it will not work with multiple definitions

  libraries\MEGA_S88\MEGA_S88.cpp.o (symbol from plugin) : In function `PS()’ :

  (.text+0x0) : multiple definition of `clockCounter’

  sketch\MEGA_S88.cpp.o (symbol from plugin) :(.text+0x0) : first defined here

  libraries\MEGA_S88\MEGA_S88.cpp.o (symbol from plugin) : In function `PS()’ :

  (.text+0x0) : multiple definition of `sensors1’

  sketch\MEGA_S88.cpp.o (symbol from plugin) :(.text+0x0) : first defined here

  libraries\MEGA_S88\MEGA_S88.cpp.o (symbol from plugin) : In function `PS()’ :

  (.text+0x0) : multiple definition of `data1’

  sketch\MEGA_S88.cpp.o (symbol from plugin) :(.text+0x0) : first defined here

  libraries\MEGA_S88\MEGA_S88.cpp.o (symbol from plugin) : In function `PS()’ :

  (.text+0x0) : multiple definition of `nbBlocs’

  sketch\MEGA_S88.cpp.o (symbol from plugin) :(.text+0x0) : first defined here

  libraries\MEGA_S88\MEGA_S88.cpp.o (symbol from plugin) : In function `PS()’ :

  (.text+0x0) : multiple definition of `sensors2’

  sketch\MEGA_S88.cpp.o (symbol from plugin) :(.text+0x0) : first defined here

  libraries\MEGA_S88\MEGA_S88.cpp.o (symbol from plugin) : In function `PS()’ :

  (.text+0x0) : multiple definition of `data2’

  sketch\MEGA_S88.cpp.o (symbol from plugin) :(.text+0x0) : first defined here

  libraries\MEGA_S88\MEGA_S88.cpp.o (symbol from plugin) : In function `PS()’ :

  (.text+0x0) : multiple definition of `sensors3’

  sketch\MEGA_S88.cpp.o (symbol from plugin) :(.text+0x0) : first defined here

  libraries\MEGA_S88\MEGA_S88.cpp.o (symbol from plugin) : In function `PS()’ :

  (.text+0x0) : multiple definition of `data3’

  sketch\MEGA_S88.cpp.o (symbol from plugin) :(.text+0x0) : first defined here

  libraries\MEGA_S88\MEGA_S88.cpp.o (symbol from plugin) : In function `PS()’ :

  (.text+0x0) : multiple definition of `sensors4’

  sketch\MEGA_S88.cpp.o (symbol from plugin) :(.text+0x0) : first defined here

  libraries\MEGA_S88\MEGA_S88.cpp.o (symbol from plugin) : In function `PS()’ :

  (.text+0x0) : multiple definition of `data4’

  sketch\MEGA_S88.cpp.o (symbol from plugin) :(.text+0x0) : first defined here

  libraries\MEGA_S88\MEGA_S88.cpp.o (symbol from plugin) : In function `PS()’ :

  (.text+0x0) : multiple definition of `loopCounter’

  sketch\MEGA_S88.cpp.o (symbol from plugin) :(.text+0x0) : first defined here

  libraries\MEGA_S88\MEGA_S88.cpp.o (symbol from plugin) : In function `PS()’ :

  (.text+0x0) : multiple definition of `clock()’

  sketch\MEGA_S88.cpp.o (symbol from plugin) :(.text+0x0) : first defined here

  libraries\MEGA_S88\MEGA_S88.cpp.o (symbol from plugin) : In function `PS()’ :

  (.text+0x0) : multiple definition of `S88_Setup(int)’

  sketch\MEGA_S88.cpp.o (symbol from plugin) :(.text+0x0) : first defined here

  libraries\MEGA_S88\MEGA_S88.cpp.o (symbol from plugin) : In function `PS()’ :

  (.text+0x0) : multiple definition of `i’

  sketch\MEGA_S88.cpp.o (symbol from plugin) :(.text+0x0) : first defined here

  libraries\MEGA_S88\MEGA_S88.cpp.o (symbol from plugin) : In function `PS()’ :

  (.text+0x0) : multiple definition of `S88_Loop()’

  sketch\MEGA_S88.cpp.o (symbol from plugin) :(.text+0x0) : first defined here

  libraries\MEGA_S88\MEGA_S88.cpp.o (symbol from plugin) : In function `PS()’ :

  (.text+0x0) : multiple definition of `j’

  sketch\MEGA_S88.cpp.o (symbol from plugin) :(.text+0x0) : first defined here

  collect2.exe : error : ld returned 1 exit status

  exit status 1
  Erreur de compilation pour la carte Arduino/Genuino Mega or Mega 2560
  .
  .
  .

  je ne sais pas quoi faire. Pouvez vous m’aider
  Cordialement
  Christian

  Répondre

  • La rétro-signalisation sur Arduino 8 mars 2019 15:31, par Jean-Luc

    Bonjour,

    libraries\MEGA_S88\MEGA_S88.cpp.o (symbol from plugin) : In function `PS()’ :
(.text+0x0) : multiple definition of `PS()’
sketch\MEGA_S88.cpp.o (symbol from plugin) :(.text+0x0) : first defined here

    Vous avez plusieurs fichiers MEGA_S88.cpp qui sont compilés. L’un réside dans une bibliothèque : libraries\MEGA_S88\MEGA_S88.cpp. L’autre dans le répertoire de votre sketch. Supprimez les MEGA_S88.xxx de votre sketch.

    Répondre

    • La rétro-signalisation sur Arduino 8 mars 2019 16:06, par BUSCH Christian

      Bonjour,
      merci pour votre prompte réponse. Cela fonctionne, erreur de débutant.
      maintenant il suffit de tester le bus S88, j’avais essayé en mode CAN, mais énormément de détections fantômes.
      Cordialement Christian

      Répondre

      • La rétro-signalisation sur Arduino 8 mars 2019 17:43, par Jean-Luc

        Si vous dites qu’avec une communication par bus CAN vous avez des détections fantômes alors que le bus CAN offre une détection d’erreurs de transmission poussée, alors votre problème se situe au niveau de votre détection ou de votre traitement des messages, pas au niveau de la communication.

        En passant au S88 sans toucher au reste, ça sera très probablement pire car le S88 n’a pas de détection d’erreur.

        Il faudrait déverminer votre système avant tout.

        Répondre

        • La rétro-signalisation sur Arduino 10 mars 2019 16:56, par BUSCH Christian

          Bonjour,
          j’ai fait mes essais avec un MEGA2560 et 60 détecteurs de consommation de courant, en S88. Aucune détection fantôme pendant plus de 4h. Les détecteurs sont actuellement manœuvrés aléatoirement par groupe de 5 à 10. Je suis satisfait pour l’instant. Maintenant, il faut passer au réseau réel.
          merci pour votre aide.
          Christian

          Répondre

• La rétro-signalisation sur Arduino 19 mai 2019 11:34, par Thierry Dussart

  Bonjour,

  Il y a deux trucs, intimement liés, que je ne saisis pas dans le sketch. Ça se passe dans S88-Loop() :

  1) D’abord on teste si loopCounter = 20. A priori, je ne vois aucun autre endroit où l’on affecte cette variable à part l’incrémentation dans PS(). La valeur 20 ne serait donc rencontrée qu’une seule fois, au début de l’exécution du programme (après 20 boucles d’exécution de PS() précisément) puis rarement par après, uniquement suite aux "bouclages par overflow" de cette variable de type long.
  2) Ensuite, si loopCounter = 20, le "reset management" met à 1 le LSB de la variable sensors.

  Pour émuler un reset total des entrées, ne faudrait-il pas mettre à 1 tous les bits de la variable sensors ? (et pas uniquement son bit 0)
  Et ne faut-il pas remettre loopCounter à zéro pour émuler le "reset" émis périodiquement par la centrale ?

  Désolé si mes questions sont absurdes, mais je coince sur la compréhension de ce bout de code …

  Cordialement,
  Thierry.

  Répondre

  • La rétro-signalisation sur Arduino 20 mai 2019 09:09, par JPClaude

    Bonjour,
    La question est loin d’être absurde car cette variable est une bizarrerie exclusivement liée à la console ECOS qui positionne les 8 premiers bits à 1 au démarrage. Lorsque l’une des entrées est modifiée tout se passe bien à partir de là, ce qui explique le changement du premier capteur (juste le bit zéro). Cette valeur de loopCounter n’est donc qu’un time out de démarrage dont la valeur est définie empiriquement. Il y a approximativement 20 impulsions PS par seconde sur l’ECOS. En mettant loopCounter à 20 on attend 20 appels à la routine PS soit 1 seconde pour initialiser. Si on veut attendre un peu plus il faut mettre loopCounter à 20 fois y, par exemple pour 30 secondes on aurait loopCounter = 20x30 = 600. Cette variable ne sert qu’à l’initialisation elle ne sert plus après, on pourrait mettre un booléen pour prévenir la routine PS que l’on ne se sert plus de cette variable après l’initialisation et donc arrêter son incrémentation. En prenant un entier long la prochaine valeur de loopCounter = 20xy n’arrivera qu’au bout d’un temps pouvant être considéré comme infini et donc simplifie la programmation, par contre il ne faut pas la remettre à zéro sinon on recommence l’initialisation.
    Je suis d’accord, ce n’est pas une réponse très scientifique mais empirique exclusivement liée à la console ECOS, mais ça marche !!!!
    Bien cordialement.

    Répondre

    • La rétro-signalisation sur Arduino 20 mai 2019 16:56, par Thierry Dussart

      Merci pour cette explication claire et complète, je comprends mieux à présent !
      Donc, puisque je n’utilise pas la centrale ECOS, je pourrais virer cette ligne du code (celle du "reset management").
      Ceci dit, je ne sais pas si la centrale que j’utilise (Desktop Station + Arduino UNO + boîtier Märklin 60113) a besoin de cette "activation" ou pas … finalement, à partir du moment où ça fonctionne bien il vaut mieux ne rien changer :-)
      Encore merci !
      Thierry.

      Répondre

• La rétro-signalisation sur Arduino 10 juin 2019 22:31, par Thierry

  Bonjour,

  Bizarrement chez moi je rencontre un bug avec une des entrées : la D13. Elle est paramétrée en input_pullup comme les autres, mais elle renvoie un signal = 0 au lieu d’un signal = 1. Ceci avec toutes les bornes déconnectées.
  Je pense que c’est lié à la Led montée sur le Nano (vous savez, celle du "Blink") mais je n’ai pas encore trouvé comment résoudre ce souci.
  Ça fonctionne bien chez d’autres utilisateurs de ce système ?

  Autre point :
  Dans le le fichier UNO_S88.cpp ligne 17 je pense qu’il faut écrire
  int endPin16 = 20 (et pas =21)

  Merci et à plus,
  Thierry.

  Répondre

  • La rétro-signalisation sur Arduino 11 juin 2019 15:13, par Jean-Luc

    Bonjour,

    Le montage de la LED 13 sur Nano diffère du montage sur Uno. Sur Uno c’est comme ceci

    

    Un ampli est intercalé entre SCK (broche 13) et la LED si bien que ce n’est pas la sortie du microcontrôleur qui fournit le courant.

    Sur le Nano c’est comme ceci :

    

    C’est le microcontrôleur quit fournit le courant et donc le simple fait de mettre la broche en INPUT_PULLUP fait que la LED est alimentée (elle doit être très faiblement éclairée) au travers de la résistance de pull-up. Comme la résistance de pull-up est d’environ 40kΩ, que la LED fixe une tension égale à sa tension de seuil (disons 2V), la tension sur D13 est autour de 2V également. Or 2V c’est dans la plage qui n’est ni un 0, ni un 1 (du moins de manière garantie par le fabricant : 0 = < 1,5V ; 1 = > 3V) et c’est interprété comme un 0 dans votre cas.

    Répondre

    • La rétro-signalisation sur Arduino 11 juin 2019 22:55

      Merci, c’est exactement le diagnostic auquel j’étais parvenu en regardant les schémas des UNO et NANO :-) Sur le NANO, on n’a malheureusement pas l’ampli op qui découple la led et sa résistance. Normal, y a pas vraiment la place pour ça …
      On peut aussi considérer l’ensemble Rpullup - Rled - Led comme un simple pont diviseur, avec Rpullup = 40k et Rled = 1k ça ne risque pas de fonctionner lorsque l’entrée D13 est hors potentiel. On aura toujours une lecture proche du 0 volt (environ 1/41ème de 5 volts).

      Je viens juste de tester une solution, j’attendais le résultat avant de poster mes conclusions.
      La solution : j’ai viré la résistance série de la Led L Yellow. De cette manière, cette entrée peut désormais fonctionner parfaitement en INPUT_PULLUP.
      Voilà. Encore merci pour votre aide !

      Répondre

      • La rétro-signalisation sur Arduino 13 juin 2019 10:32, par Jean-Luc

        Bonjour,
        Solution radicale :-) Il était sinon possible de mettre un peu d’électronique externe. Concernant la tension sur la broche D13 du Nano, vous ne pouvez pas ne pas tenir compte de la tension de seuil de la LED. La tension est bien au niveau de ce seuil, en fait V_seuil + (5-V_seuil)/41, et non 5/41 V.

        Répondre

        • La rétro-signalisation sur Arduino 13 juin 2019 21:46, par Thierry

          En effet, j’ai simplifié car la valeur de Rpullup est estimée à 40k … mais peut prendre une valeur bien différente. Quelque chose comme 40k ± 20k, ce qui rend utopique toute idée de calcul précis ! ;-)
          .
          Dans mon cas, trop tard également pour une solution électronique externe. Mes cartes sont déjà réalisées, la solution "dessoudage" est la moins contraignante.
          Sinon, j’imagine qu’il suffirait d’augmenter le courant pour obtenir une tension de 1,5V sur la "Rled" de 1k (soit un courant de 1,5 mA) ; ajouté à la tension de la Led (1,6V) on arrive à 3,1V à l’entrée qui détectera bien un état 1. Mais cette débauche énergétique serait-elle bien en phase avec la conscience écologique collective qui semble sortir de sa torpeur ? :-D
          .
          En tout cas, merci pour votre aide !

          Répondre

          • La rétro-signalisation sur Arduino 14 juin 2019 10:13, par Jean-Luc

            La résistance de pull-up est située entre 20kΩ et 50kΩ (page 259 de la datasheet). Donc l’erreur ∆V est égale à V/21 - V/51. Même en considérant V = 5V (au lieu de V = 5-V_seuil). Donc ∆V = 0,12V. C’est pas si imprécis que ça :)
            En fait il faudrait baisser le courant car il s’agirait plutôt de mettre une résistance de valeur plus élevée en série avec la LED. Finalement ce que vous avez fait c’est de mettre une résistance infinie. En mettant une résistance de 40kΩ, on aurait autour de 3,5V mais comme on a une résistance de grandeur comparable à la résistance de pull-up, le ∆V d’erreur est plus important.

            Répondre

• La rétro-signalisation sur Arduino 22 juin 2019 13:46, par Guy

  Bonjour à tous,

  Je me lance dans un projet similaire pour gérer les rétro-signalisations sur le bus S88 d’une intellibox avec le logiciel ITRAIN.
  J’utilise des ensembles de 8 arduinos NANO reliés entre eux en I2C et raccordés à un ESP8266 WiFi qui émet comme serveur vers un MEGA dont la fonction est d’être le client WiFi des différents ensembles NANO. L’autre fonction du MEGA est de servir d’interface S88 pour l’intellibox. Quelqu’un a-t’il déjà une expérience de la transmission WiFi dans un milieu perturbé tel que celui d’un réseau de modélisme ? Cordialement
  . GM

  Répondre

• La rétro-signalisation sur Arduino 7 novembre 2019 19:17, par Lefebvre Cyril

  Bonjour à tous,
  Je suis très intéressé par ce montage, mais je peine a lancer le programme arduino et a y mettre les deux fichiers du fichier .ZIP, le programme arduino se lance correctement , mais les deux fichier uno_s88.h et uno_s88.ccp, comment les mettre, je n’arrive pas trop a comprendre …. car généralement j’utilise des .ino …………… si quelqu’un pouvais m’aider cela serais super, merci d’avance
  C.Lefebvre

  Répondre

  • La rétro-signalisation sur Arduino 7 novembre 2019 20:55, par Lefebvre Cyril

    Je laisse mon adresse email pour le courageux qui voudrais bien m’aider, merci d’avance,
    cyril.lefebvre2@sfr.fr

    Répondre

    • La rétro-signalisation sur Arduino 7 novembre 2019 21:23, par msport

      Votre question relève de la mise en œuvre des bibliothèques pour l’Arduino.
      Commencez par les articles qui traitent de la "Toute première fois".
      Et pour un dépannage, passez par le forum.

      PS : vous risquez les spams en mettant votre adresse mail en clair.

      Répondre

      • La rétro-signalisation sur Arduino 8 novembre 2019 00:13, par Lefebvre Cyril

        Re Bonsoir, Je possède déjà les bibliothèques uno et mega_s88 ( peu etre mal installées ou en conflits ) , et l’arduino n’est pas une carte avec laquelle je débute, possédant trois imprimantes 3d ayant comme carte de commande des mega 2560 couplé a des shields ramps 1.4 ( le tout sur un firmware marlin … ), mais que je charge généralement avec un fichier .ino je demande simplement de l’aide pour comprendre rapidement comment téléverser, les fichiers de ce sujet qui m’intéresse vraiment, j’ai beau copier/coller, charger la bibliothèque …. ajouter les fichiers … la vérification avant le téléversement, m’affiche toujours des erreurs. j’ai cependant essayé trois version d’arduino différentes ( vers 1.0.6, 1.5.1, 1.8.1 ……. ) rien n’y fait , je souhaite juste réussir a faire ce projet, merci d’avance

        Répondre

• La rétro-signalisation sur Arduino 8 novembre 2019 09:19, par msport

  Installez correctement les bibliothèques qui sont indiquées en tête d’article, c’est tout.
  Et si vous avez des erreurs, postez les sur le forum, rubrique Débuter, avec les détails et d’éventuelles captures d’écran.

  Voir en ligne : Installer une bibliothèque

  Répondre

• La rétro-signalisation sur Arduino 26 novembre 2019 09:37, par Yves

  Bonjour,

  Concernant l’utilisation de la rétro signalisation compatible en DC et DCC avec l’utilisation de l’optocoupleur ACPL-8x4 824 ou 844, est ce que quelqu’un pourrait de dire en quoi l’utilisation de ce composant permettrait une utilisation en DC également par rapport au schéma exposé plus haut ? Quel serait le schéma à mettre en œuvre.

  Pour ma part je ne cherche pas vraiment à faire de la rétro signalisation en DC mais aimerait que ces circuits soient compatible pour que je puisse occasionnellement commuter mon réseau de DCC => DC sans tout faire griller.

  Autre question : si j’ajoute des section de freinage par diode en plus de la détection S88, est-ce que c’est toujours compatible en DC ?

  Merci d’avance pour l’aide et bravo pour ce site magnifique.

  Répondre

• La rétro-signalisation sur Arduino 26 novembre 2019 18:46, par msport

  Du point de vue électrique, le DC étant un cas particulier du DCC, il n’y a aucun risque à exploiter un réseau DCC en DC, mais aucun automatisme ne fonctionnera. Sauf OVNI qui ne supporterait pas le courant continu mais je n’en connais pas.
  De même le freinage ABC qui ne consomme que quelques 1/10 de volts, n’aura pas d’impact en DC.

  Répondre

• La rétro-signalisation sur Arduino 31 décembre 2019 17:14, par Stéphane

  Bonjour !
  Je suis en train de prendre un peu le temps d’étudier tous ces articles en détails pour avancer dans mon projet de réseau en DCC, et j’ai trouvé ce schéma de détection de consommation qui n’utilise pas un Max471, mais je n’arrive pas à comprendre comment il fonctionne. Je sais qu’on peut simplement l’adopter sans se poser de question, mais j’aime bien comprendre le montage, est-ce que quelqu’un pourrait expliquer ce qui se passe électroniquement dans ce montage faisant appel à un pont de diodes et un optocoupleur pour détecter une consommation de courant ?
  Merci !

  Répondre

• La rétro-signalisation sur Arduino 31 décembre 2019 19:22, par msport

  Bonjour,
  le MAX471 a une autre vocation que la détection de présence, c’est de détecter les courts-circuits et le retour d’information des décodeurs (via le courant du moteur).
  Ici, c’est la chute de tension dans les diodes provoquée par le courant de voie qui est détectée par la suite du montage même si ce courant est faible (de l’ordre du mA pour des essieux graphités). Voir les commentaires dans l’article suivant :

  Voir en ligne : Détecteur de présence DCC par consommation de courant

  Répondre

• La rétro-signalisation sur Arduino 15 janvier 2020 11:28, par Mario R

  Bonjour,
  J’ai testé la retrosignalisation avec 4 modules nano, donc 64 zones de détections avec une centrale Fleischmann " Twin-center" et avec le logiciel CDM Rail, tout fonctionne correctement. Cependant, je viens d’installer une nouvelle centrale digikeijs DR5000 , j’ai fait la liaison du câble S88 avec l’adaptateur Rj45 (DR60886) pour pouvoir brancher ce dernier sur la centrale Dr5000. Dans le logiciel de la centrale, j’encode 4 modules 16 inputs et la première adresse = 0 Mais je rencontre un problème, dans le monitor, toute les cases d’entrée sont cochées, et impossible de visualiser les détections dans cdm rail.
  Je remarque aussi que sur les arduino nano, les leds tx et rx ne fonctionne pas (la led power est bien allumée) , (elle étaient allumées avec la twin-center). je pense que le problème est du coté de la centrale… mais…
  Merci d’avance pour votre aide…

  Répondre

  • La rétro-signalisation sur Arduino 15 janvier 2020 21:14

    Après plusieurs recherches, le problème est résolu…
    Pour le problème du S88, j’ai inversé le brochage sur l’adaptateur… (c’est bête).
    ensuite pour CDM rail, il faut changer les adresses des détecteurs, cdm rail voit la centrale DR5000 comme un système LENZ, et les adresses doivent commencer par 513-514, etc,
    voila tout est en ordre

    Répondre

• La rétro-signalisation sur Arduino 8 février 2020 10:12, par BERTRAND

  Bonjour,

  Merci pour cet excellent article.
  Je vais débuter des tests de rétro signalisation avec la solution proposée ici et j’ai plusieurs questions.

  Mon réseau possède 21 cantons, je compte installer les capteurs de consommation de courant au plus près des voies sous le réseau et l’arduino mega près de la centrale DCC.

  J’ai prévu un feeder 5V DC sur les modules du réseau.
  Est il préférable d’utiliser ce 5V pour alimenter chaque capteur ?
  Ou l’alimentation de l’arduino suffira à alimenter tout les capteurs ?

  Ce capteur détecte t il les rames sans locomotives ? Autrement dit, un wagon équipé d’une résistance sur un essieu sera t il détecté ?

  Répondre

• La rétro-signalisation sur Arduino 8 février 2020 18:49, par BERTRAND

  Mes premiers tests sont concluants. Le montage fonctionne avec un module. J’utilise un arduino Mega.
  Par contre je souhaite utiliser 3 modules de 16 entrées et là j’ai un soucis.
  J’ai bien spécifié le nombre de module (3) dans le programme mais rien n’y fait.
  J’ai raccordé mon premier canton à la pin 4 du Mega et mon deuxième canton à la pin 38 du Mega qui correspond à la première entrée du 3ème module.
  Le canton est configuré dans RRTC mais il n’y a pas de détection. Je ne comprends pas.
  J’ai loupé quelque chose dans le programme mais quoi ?

  Répondre

  • La rétro-signalisation sur Arduino 9 février 2020 11:29, par Bertrand

    Erreur de ma part dans RRTC.
    Tout est rentré dans l’ordre.
    Ce projet est génial. Je vais me séparer de mes RMGB 8N.

    Répondre

    • La rétro-signalisation sur Arduino 9 février 2020 14:33, par Dominique

      Et c’était quoi cette erreur ( pour permettre à d’autres de l’éviter) ?

      Répondre

      • La rétro-signalisation sur Arduino 9 février 2020 17:45, par BERTRAND

        Une erreur dans l’adressage d’un canton. J’étais persuadé d’avoir paramétré mon second canton avec l’adresse 3 et l’entrée 1 correspondant à la pin 38 de l’arduino Mega sauf que j’ai indiqué l’adresse 2 entrée 1. Donc pas de lien avec le codage ou le câblage.
        Merci Dominique.

        Répondre

• La rétro-signalisation sur Arduino 12 février 2020 19:17, par gobebu

  Buenas tardes.Me da error al subir el programa.
  stray 303 in programa

  // señal de reloj desde S88

  reloj vacío ( )

  Me sale marcado reloj vacio

  Répondre

• La rétro-signalisation sur Arduino 25 mars 2020 12:41, par PatriceP

  Bonjour a tous,

  Je suis assez novice en électronique, juste les bases mais malgré çà, je suis vraiment très content de cet article qui m’a permis de réaliser le circuit.

  J’ai une centrale ESU sur laquelle je n’ai pas encore osé monter la détection de courant.

  J’ai fait mes tests via un rail isolé, un wagon éclairé et alimenté en 12V CC via un transfo. Mon problème vient lorsque je provoque un court-circuit. Evidemment, ça grille :-(

  Est-ce quelqu’un pourrait m’aider a mettre une protection contre les courts-circuits venant des cantons ? Donc sur le signal DCC ou la borne positive dans le cas d’un circuit analogique ?

  Ce serait vraiment tres utile pour mon projet.
  Un grand merci a tout ceux qui animent cette source d’informations et encore plus a ceux qui pourront m’aiguiller :-)

  Répondre

  • La rétro-signalisation sur Arduino 25 mars 2020 20:15, par Dominique

    Les centrales équipées du logiciel DCC++ ou la bibliothèque DCCpp décrites dans ce site sont toutes capables de détecter les court-circuits et d’arrrêter le courant à temps sans dommage. Je vous conseille de relire les articles et les sujets sur le Forum.

    Répondre

    • La rétro-signalisation sur Arduino 26 mars 2020 07:56, par PatriceP

      Merci
      Serait-il possible que le fait d’avoir une "masse" commune a 2 circuits soit la cause.

      J’ai ajouté un circuit de led indépendant pour signaler la détection. Ces led sont alimentées par un 12V et la masse est commune avec l’Arduino 5V

      J’ai tenté le test hier et la centrale ESU n’a pas coupé le courant pendant le court-circuit.
      Autrement elle coupe toujours le courant sur les cantons qui ne sont pas sur l’arduino

      J’ai une resistance qui a fumé, grillée.

      J’émets l’hypothèse des 2 masses "communes" comme source du probleme. Ai-je raison ?

      Répondre

      • La rétro-signalisation sur Arduino 26 mars 2020 09:09, par Dominique

        A ce stade, il faudrait exposer votre problème sur le forum avec une analyse, des schémas et des photos si nécessaire, Sans ces détails, je crains qu’on ne puisse trouver une cause et une solution.

        Répondre

• La rétro-signalisation sur Arduino 9 avril 2020 22:01, par PatriceP

  J’essaie d’avancer sur mon problème et en séparent chacun des éléments, je me rends compte que c’est le pont redresseur qui provoque le probleme. Je l’ai réalisé au moyen de 4 diodes IN5045. Et je remarque qu’il y a une chute de tension. Ca se remarque déjà au niveau eclairage d’un wagon. Quand je place le pont redresseur sur un fils venant de la centrale ECOS, un court-circuit ne déclenche plus la securité de la centrale.
  Quel type de diodes serait le plus adapté pour eviter une chute de courant ?

  Répondre

• La rétro-signalisation sur Arduino 9 avril 2020 22:17, par msport

  Bonsoir,
  comme le dit Dominique, sans schéma on a du mal à deviner. Votre problème est là, il y a une incohérence soit au niveau du schéma, soit au niveau du câblage par rapport à ce que vous voulez faire.
  Et avant d’utiliser les fonds de tiroir, regardez les spécifications de ce que vous en sortez : une 1N5045, si c’est bien cela, est une diode zener de 56V. Inadaptée pour un pont redresseur !
  Si vous avez une résistance qui a grillé, commencez par comprendre ce qui s’est passé, sinon, ce sera bientôt votre centrale ESU qui fumera.
  Cordialement

  Répondre

• La rétro-signalisation sur Arduino 22 avril 2020 11:56, par Jean-Paul CHEVRIOT

  Bonjour,

  je n’arrive pas à progammer le fichier UNO_S88.h.
  J’ai essayé de plusieurs façon avec vos exemples ci-dessus.
  il m’indique une erreur de compilation pour la carte UNO
  donc je ne peux pas continuer.

  Peut-être pouvez vous me renseigner pour pouvoir réaliser cette ptogrammation.
  Merci d’avance
  Cordialement
  JP. CHEVRIOT

  Répondre

• La rétro-signalisation sur Arduino 22 avril 2020 15:38, par msport

  Pour pouvoir vous aider, il faut que vous nous donniez les erreurs de compilation.
  Pour cela, ouvrez un sujet sur le forum potentiellement rubrique Débuter.
  Avez vous mis le répertoire UNO_S88 extrait de "la bibliothèque associée" dans votre répertoire du style C :\Users\Michel\Documents\Arduino\libraries puis compilé le programme Arduino UNO/Nano dans l’IDE ?

  Voir en ligne : Installer une bibliothèque

  Répondre

  • La rétro-signalisation sur Arduino 24 avril 2020 19:27, par Jean-Paul CHEVRIOT

    Bonjour et merci de votre aide.

    l’erreur de compilation :
    UNO_S88.h : aucun fichier ou répertoire de ce type
    je ne l’ai pas dans inclure une bibliothèque
    j’ai téléchargé arduino-nightly et _macosx et je n’ai rien trouvé.
    J’ai bien lu installer une bibliithèque mais je reste impuissant.
    Merci d’avance
    Cordialement

    J.P.CHEVRIOT

    Répondre

• La rétro-signalisation sur Arduino 24 avril 2020 22:27, par msport

  Réponse sur le forum …

  Voir en ligne : http://forum.locoduino.org/index.ph…

  Répondre

• La rétro-signalisation sur Arduino 2 mai 2020 21:28, par Mathieu

  Dans le fichier UNO_S88.cpp à la ligne 17 je pense qu’il faut écrire int endPin16 = 20 et non pas int endpin=21

  Pouvez-vous confirmer ?

  Merci,

  Répondre

• La rétro-signalisation sur Arduino 3 mai 2020 08:58, par JPClaude

  réponse : OUI
  Cordialement.

  Répondre

• La rétro-signalisation sur Arduino 15 mai 2020 11:36, par Frédéric

  Bonjour,

  Merci pour ce script. J’ai branché une Arduino Mega 2560 derrière 3 RM-GB-8 (pour la detection de courant) pour monitorer 44 contacts de position de mes moteurs Tortoise et ça fonctionne impec.

  Le tout est relié à Rocrail et/ou JMRI en Loconet via une bonne vieille Interllibox.

  @+

  Fred

  Répondre

• La rétro-signalisation sur Arduino 15 mai 2020 23:27, par JPClaude

  Très heureux que cela marche pour vous et merci de votre merci !!!
  Cordialement.

  Répondre

• La rétro-signalisation sur Arduino 17 février 2021 18:59, par BertrandCPN

  Bonjour,
  je suis en train d’effectuer plusieurs essais en vue de construire mon réseau.
  Pour cela j’ai une centrale Roco 10764 et un module interface S88xPressNetLI un Arduino uno et des détecteurs de courant .
  J’ai cablé et programmé mon Arduino comme il est indiqué dans ce merveilleux article mais rien ne remonte au niveau de mon logiciel.
  Pourriez vous me dire si il y a un moyen de voir si les informations sorte bien de l’Arduino de façon à voir si ça vient de l’Arduino ou de l’interface.
  Je vous remercie d’avance Bertrand

  Répondre

• La rétro-signalisation sur Arduino 17 février 2021 19:41, par Dominique

  La méthode classique consiste à mettre dès instruction Serial.print(une variable) là où vous voulez voir ce qui se passe dans le programme.
  il y en a peut-être deja dans le programme de cet article.
  Il faut sûrement en faire autant dans votre logiciel pour savoir s’il reçoit quelque chose et quoi…
  Bon courage.

  Répondre

• La rétro-signalisation sur Arduino 24 juillet 2021 12:30, par Guillaume

  Bonjour,

  Je n’ai pas compris grand chose,

  Est ce qu’il est possible, pour un néophyte, de trouver un tutoriel simple et claire sur la façon de monter un module de détection, qui puisse se brancher sur une centrale ?

  Et est ce que ça existe en Loconet ?

  Merci pour vos retours,

  Guillaume

  Répondre

  • La rétro-signalisation sur Arduino 24 juillet 2021 15:14, par msport

    Bonjour,

    comme il y a des dizaines de centrales et des centaines de modules de détection, il vaudrait mieux que vous précisiez votre projet dans la rubrique "Vos projets" du forum en indiquant d’où vos partez.
    Quant à Loconet, ce n’est pas la première vocation de Locoduino que de faire du support sur le matériel du commerce.
    Cordialement

    Répondre

• La rétro-signalisation sur Arduino 24 octobre 2021 09:56, par Jehan

  Bonjour,
  Tout d’abord un grand bravo pour vos articles et solution qui marche à merveilles ! Je me heurte toutefois à un petit problème : J’ai tenté d’utiliser un arduino Mega avec un S88 1module (https://locoduino.org/spip.php?article138) et d’y ajouter du DCC (https://locoduino.org/spip.php?article142 (cde_aiguillage_Nano_DCC)). Ces 2 ino marche très bien seul mais pas ensemble ! Dans la description il est indiqué "Les broches 20 et 21 sont volontairement inutilisées pour des extensions avec le DCC (interruption sur broche 20 et led de contrôle sur broche 21)" Ca doit donc être possible ? j’ai recherché mais pas trouvé d’article sur ce sujet, pouvez-vous me guider pour cette réalisation ? Mon code
  Merci beaucoup pour votre aide

  Répondre

• La rétro-signalisation sur Arduino 27 octobre 2021 10:44, par msport

  Bonjour,
  les timings du DCC sont critiques et il n’est pas évident de les faire cohabiter avec d’autres tâches dans le même sketch.
  En désespoir de cause, interfacez les deux sketch par les entrées-sorties.
  Cordialement

  Répondre

• La rétro-signalisation sur Arduino 29 novembre 2021 10:09, par Paul Sente

  J’ai lu votre article expliquant comment réaliser une interface S88 avec Arduino. Je comprends bien la façon de faire, en résumé une suite de décalages successifs dans des variables binaires. Ce qui me tracasse c’est le temps d’exécution. En effet, si certains S88 ont une horloge à 10 kHz, d’autres montreraient à 100 kHz (!) … Un programme C compilé peut-il réaliser les opérations de lecture, décalages, écriture des bits en moins de 10 microsecondes ? Et reste-t-il encore un peu de temps pour autre chose ? Merci d’avance …

  Répondre

• La rétro-signalisation sur Arduino 30 décembre 2021 11:33, par Roumain

  Bonjour,
  peut-on brancher le S88 sur le R-BUS de Roco ? Ou y a t il une autre technique ? J’ai une centrale de la z21 (blanche)…en attendant d’en fabriquer une !
  Quelqu’un a-t-il déjà fait un test avec cette centrale ?
  Cordialement

  Répondre

  • La rétro-signalisation sur Arduino 6 février 2022 17:22, par Jean-Jacques

    Bonjour

    Avez vous trouvé une solution pour la Z21,perso rien.

    Cordialement.

    Répondre

• La rétro-signalisation sur Arduino 30 décembre 2021 12:30, par msport

  Bonjour,

  mon expérience avec le S88 n’a pas été très concluante. (le 5V TTL ne tient pas la distance …)
  Votre question est d’interfacer le protocole S88 avec l’Xpressnet (qui est documenté)
  La solution qu’on trouve à coup de Google est le montage de Paco Cañada à base de PIC et non d’Arduino.
  https://usuaris.tinet.cat/fmco/lokmaus_en.html#genli
  Mais vous pouvez regarder si le montage Un TCO xpressnet peut être adapté.
  Cordialement

  Voir en ligne : Un TCO xpressnet

  Répondre

• La rétro-signalisation sur Arduino 8 janvier 18:57

  Bonjour,
  comment cablerle bus et le relier à la centrale ?
  un schéma pourrait être intéressante. Merci d’avance

  Répondre

• La rétro-signalisation sur Arduino 8 janvier 19:32, par msport

  Bonjour,
  il faut que votre centrale dispose d’une entrée S88. Ce qui est le cas de la centrale Ecos de la figure 2.
  Le schéma du bus S88 est donné Figure 4, schéma que doit respecter votre centrale.
  Et c’est la Figure 5 qui précise "Connecteur S88 vers centrale"
  Cordialement

  Répondre

• La rétro-signalisation sur Arduino 28 avril 13:56, par D. CURT

  Bonjour,
  Ce montage de rétro-signalisation est parfait, merci au concepteur. Cependant, est ce que la liaison est modifiable pour un bus type Xpressnet, centrale LENZ qui semble plus stable que le S88.
  Merci d’avance pour votre attention.
  Denis

  Répondre

• La rétro-signalisation sur Arduino 28 avril 16:49, par msport

  Bonjour,
  lisez bien l’article : si on enlève le S88, il ne reste plus que les capteurs.
  Si vous souhaitez transposer un montage Xpressnet :

  Voir en ligne : Un TCO xpressnet

  Répondre

• La rétro-signalisation sur Arduino 7 mai 18:10, par JP.Gaechter

  Bonjour, je trouve votre article très bien fait ; par contre, pourriez vous me préciser si le programme à charger dans un UNO NANO est seulement celui de 9 lignes sous le titre :"le programme Arduino UNO/NANO" figurant dans l’article et qui inclut la bibliothèque UNO_S88.h ?
  Par ailleurs, je n’arrive pas à ouvrir le dossier ZIP pour uno/nano figurant dans la conclusion, je ne suis pas un pro de l’informatique !! bien que j’arrive à bricoler qques programmes pour UNO ! Merci de votre réponse et encore félicitations
  JP.G

  Répondre

• La rétro-signalisation sur Arduino 8 mai 10:30, par msport

  Bonjour,
  vous mettez les trois modules sous "Le programme Arduino UNO/Nano" dans un même répertoire nommé UNO_S88 de votre répertoire de sketches.
  Vous nommez le module de 9 lignes UNO_S88.ino et ça devrait aller.
  Deux sont dans le fichier, à télécharger en cliquant dessus (-> téléchargement)
  Faire du copier coller pour celui de 9 lignes : attention à ne pas perdre les accolades.

  Répondre

Réagissez à « La rétro-signalisation sur Arduino »