Modulo S88 Locoduino


No puedo empezar este entrada del blog sin antes agradecer a Juan G. por su magnifica información y paciencia para todas las pruebas que hemos hecho para poder publicar esta entrada.

¿Que es un retromodulo?:

El retromodulo es el encargado de decirle a la central que pasa en la maqueta. Consta de unas entradas con detectores, que pueden ser por consumo en la red DCC con cantones, o por activación de una barrera infrarroja o un pulsador.

Mi experiencia con este tipo de módulos era nula, así que he tenido que empezar a entenderlos desde 0.


El bus S88:

El bus S88 consiste en encadenar los módulos entre sí. Funciona con un voltaje entre 4,5 y 5v (por lo tanto, completamente compatible con Arduino).

La longitud máxima entre dos módulos no debe exceder los 5 m, aún así es necesario asegurarse de que el cable del bus no esté demasiado cerca de ambientes perturbadores (corriente de tracción, 220v).

La cantidad máxima de sensores en un bus S88 está limitada a 512. El direccionamiento de sensores es simple. Cada módulo tiene 8 o 16 sensores. Comenzamos la numeración con el primer módulo (valor = 1) y su primer sensor (dirección 1:1), luego incrementamos en 1 en cada sensor siguiente en el encadenamiento hasta el valor 16 (1:16), luego pasamos a 2 (2:1) y así sucesivamente módulo 16. La siguiente foto deLDT-infoCenter presenta el principio de este encadenamiento.

Red de retromodulos

Red de retromodulos S88


Los módulos S88 transmiten mediante 6 pines de conexión y generalmente se utiliza un conector como los del teléfono (RJ12) o ethernet (RJ45). Para poder alimentar el módulo S88 la alimentación también va incluida en estos cables teniendo esta disposición final:

Significado de las 6 conexiones del bus S88:

    pin 1: datos (blanco) - salida de datos a otro módulo o a la unidad de control

    pin 2: GND (marrón) - GND

    pin 3: reloj (verde) – parte superior del reloj

    pin 4: PS (amarillo) – señal de inicio del reloj PS

    pin 5: Reinicio (púrpura) - reinicio de conteo

    pin 6: V+ (rosa) – Alimentación de 4,5 a 5V

Conexión S88

Bus S88

Fuente: Locoduino.org

Conexión RJ45

Cable RJ45 para S88

Fuente: Lormedy.free.fr/S88

Bus S88 con Arduino

En la web de Locoduino, el usuario Ruud Boer propone lo siguiente:

cada Arduino corresponde a un módulo que puede tener 16 sensores para un UNO/Nano o 64 sensores para un MEGA.

El encadenamiento de Arduinos se realiza de la siguiente manera:

  • El primer Arduino conecta su pin 1 al pin 1 del bus S88
  • Otros Arduinos conectan su pin 1 al pin 0 del Arduino anterior.

La interfaz con el bus S88 se realiza en los pines 0 a 3, Gnd y Vin de la siguiente manera:

  • Pin 0 (rx): Entrada de otro Arduino
  • Pin 1 (tx): Salida a la estación de control o a otro Arduino
  • Pin 2 (int0): Interrupción del reloj del bus S88 (en todos los Arduinos de la cadena)
  • Pin 3 (int1): Interrupción de la señal PS del bus S88 (en todos los Arduinos de la cadena)
  • Gnd: Masa común (en todos los Arduinos en el encadenamiento)
  • Vin: Fuente de alimentación S88 (en todos los Arduinos de la cadena)


Los comandos que maneja el módulo


‹Y N F› con N = grupos de 8 sensores a leer sin pasar de 64 (2x32x8=512)


F = 0 -> Para una respuesta binaria <y 000000000.....00>
F = 1 -> Para una respuesta en hexadecimal 3 veces más rápida <y 0A0147405801CE..40>
F = 2 -> Para una respuesta binaria (MSB primero), La respuesta será ‹y XXXXX......>
F = 3 -> para una respuesta del tipo SENSOR utilizada por JMRI.La respuesta será ‹Q ID› si el sensor está activo (1), ‹q ID› si el sensor está inactivo (0). ID es el número del sensor.

Respuestas es caso de error:

<x Bad Argument count>
<x Bad Argument value>
<x S88 disconnected>

Si el bus S88 está totalmente desconectado, todos los bits leídos están a 1.

Si lee módulos esclavos que no están conectados a sensores, los bits correspondientes estarán en 0.

Estas son las lineas que cargaremos en el módulo Arduino NANO o UNO

#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
}

Y estas son las lineas para la biblioteca UNO_S88.h

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

Y para el archivo UNO_S88.cpp


#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);
      }
    }
}


Descargar biblioteca para placa NANO/UNO

También existe una biblioteca especifica para la placa MEGA que aunque no tocare en esta entrada Descargar biblioteca para placa MEGA



Imágenes de Locoduino

Fuente original: La rétro-signalisation sur Arduino (Frances)

Fuente original: Le bus S88 (Frances)