Les SATELLITES AUTONOMES : Une solution simple pour la gestion de réseaux.

[rNe]

Bonjour theodami
Bienvenue dans le monde des satellites autonomes

Avant toute chose il est bon de vous assurer de la (non/)conformité du PCB; car j'ignore à quel moment vous avez téléchargé les fichiers GERBER.
Pour cela un ohm-mètre suffit :
Enlever l'ESP32 de son support
Vérifier la continuité entre la broche Signal du servo 0 et le port IO19 de l'ESP32
Vérifier la continuité entre la broche Signal du servo 2 et le port IO2 de l'ESP32
Si cette vérification est correcte vous avez le bon PCB. Vous n'avez aucune modification à apporter.
Si les liaisons entre ces deux servos et les port de l'ESP sont inversées, alors il suffit de modifier le fichier config.h, tout en bas du fichier :
Au lieu de lire #define AIG_PIN_SIGNAL_0 GPIO_NUM_19 modifier par #define AIG_PIN_SIGNAL_0 GPIO_NUM_2
Au lieu de lire #define AIG_PIN_SIGNAL_2 GPIO_NUM_2 modifier par #define AIG_PIN_SIGNAL_0 GPIO_NUM_19
Ceci afin que la sérigraphie du PCB soit juste.

Autre solution, plus pragmatique, inverser le raccordement des servos 0 et 2 et se rappeler que la sérigraphie est inexacte...

Mais en aucun cas (config.h modifié ou non) le fonctionnement du satellite est altéré.

Surtout avant de sauter sur le clavier pour faire des modifications assurez vous de la conformité du PCB par rapport au schéma de principe actuel (celui qui est maintenant en ligne) et éventuellement identifiez exactement les écarts...
Enfin, et pour bien appréhender le fonctionnement des satellites autonomes je vous encourage à relire la série d'articles les présentant sur le site éditorial.

[theodami]

Bonsoir,

J'ai bien la mauvaise version. Merci pour les solutions.

Christophe.

[bobyAndCo]

J'ai déplacé ici le post de phenixpopol  car il concerne les satellites autonomes :

Bonjour Christophe et merci pour la réponse,
J’ai essayé de comprendre le bus CAN car je m’intéresse aux satellites et j’avoue que malgré plusieurs lectures de tes différents articles sur les satellites autonomes, je ne comprends pas grand-chose. J’ai vu ’il y a quelques mois sur le forum que LocoFred avait essayé de démarrer les satellites autonomes, il me semblait aussi perdu que moi. Ou en est-il ?
Pour l’instant, j’ai un réseau que j’ai cantonné, Je commande mes locomotives par « la box » soit en WI FI par une tablette avec l’application Z21 ou, je trouve que c’est plus commode par une ou plusieurs manettes avec des HC12.
Mes aiguillages ont des micro moteurs MP5 de chez mtb-model avec retour d’info, que je commande manuellement.
J’attends la nouvelle box pour avoir un cut out et la possibilité d’utiliser rail com. Pour l’instant j’ai « bricolé » des détecteurs de présence.
Je vais un peu dans tous les sens et je ne sais pas par ou prendre le problème pour arriver à installer les satellites autonomes et j’ai du mal à voir la relation entre les satellites et les commandes DCC des locos.
En résumé, j’ai besoin d’une marche à suivre ; Dois-je commencer par un TCO alors que théoriquement les satellites peuvent s’en passer ? L’automne arrivant, je vais avoir du temps pour travailler !

[phenixpopol]

Suite du post précédent :
Bonjour Christophe,
Je vais essayer d’expliciter mes problèmes à l’aide la vidéo qui illustre l’article «  les satellites autonomes (1) « .
D’où vient la trame DCC de la loco 1 qui démarre la séquence.
J’ai bien compris que le satellite détecte l’occupation du canton et l’adresse de la loco 1 ; Comment et sous quelle forme renvoie-t-il l’information qui ralenti et arrête cette loco.
En résumé, ce qui me pose problème c’est la relation entre les satellites et la centrale DCC, d’où mon intérêt pour le bus CAN, j’ai hâte de voir les relations entre les satellites et la future box qui intégrera le CAN.
Cordialement.

[bobyAndCo]

Ok, je comprends mieux.

Je suppose que ce que tu appelles "la trame DCC" est en fait l'adresse de la locomotive, c'est bien cela ?

A chaque satellite est-associé une carte Railcom. Cette carte lit donc l'adresse de la locomotive et en fonction de l'état des satellites environnants actionne la signalisation qui va bien et adresse les ordres à la centrale pour la locomotive du canton.

C'est du code que l'utilisateur n'a pas normalement pas besoin de connaitre et l'on comprendra facilement pourquoi à la simple lecture, mais puisque tu me le demandes, c'est dans le fichier GestionReseau.cpp à partir de la ligne 264 : https://github.com/BOBILLEChristophe/Satellites_autonomes_client/blob/main/src/GestionReseau.cpp

Je répète bien que, heureusement pour l'utilisateur, il n'a pas besoin de comprendre ce code !!!

Code: [Sélectionner]

if (node->nodeP[index] != nullptr)
            {
                if (node->nodeP[index]->acces()) // Le canton SP1/SM1 est accessible
                {
                    // debug.printf("[GestionReseau %d] Le canton %s est accessible\n", __LINE__, cantonName);
                    if (node->nodeP[index]->busy()) // Le canton SP1/SM1 est occupé
                    {
                        // debug.printf("[GestionReseau %d] Le canton %s est accessible mais occupe\n", __LINE__, cantonName);
                        signalValue[i] = Rouge;
                    }
                    else // Le canton SP1/SM1 est accessible et libre
                    {
                        // debug.printf("[GestionReseau %d] Le canton %s est accessible et libre\n", __LINE__, cantonName);
                        signalValue[i] = Vert;

                        if (access) // Le canton SP2 est-il accessible ?
                        {
                            // debug.printf("[GestionReseau %d] SP2 accessible\n", __LINE__);
                            if (busy) // Le canton SP2 est-il occupé ?
                            {
                                // debug.printf("[GestionReseau %d] SP2 occupe\n", __LINE__);
                                signalValue[i] = Ralentissement;
                            }
                            else // Le canton SP2 n'est pas occupé
                            {
                                // debug.printf("[GestionReseau %d] SP2 libre\n", __LINE__);
                                signalValue[i] = Vert;
                            }
                        }
                        else // Le canton SP2 n'est pas accessible
                        {
                            // debug.printf("[GestionReseau %d] SP2 non accessible\n", __LINE__);
                            signalValue[i] = Ralentissement;
                        }
                    }
                }
                else // Le canton SP1/SM1 est n'est pas accessible
                {
                    // debug.printf("[GestionReseau %d] Le canton %s n'est pas accessible\n", __LINE__, cantonName);
                    signalValue[i] = Carre;
                }
            }
            else // Le canton SP1/SM1 n'existe pas
            {
                // debug.printf("[GestionReseau %d] Le canton %s n'existe pas\n", __LINE__, cantonName);
                signalValue[i] = Carre;
            }

            // debug.printf("[GestionReseau %d] node->loco.sens() %d\n", __LINE__, node->loco.sens());

            switch (signalValue[i])
            {
            case Carre:
            case Rouge:
                if (node->sensor[sens0].state())
                    node->loco.stop();
                else if (node->sensor[sens1].state())
                    node->loco.speed(30);
                break;
            case Ralentissement:

                break;
            }
        }

        // Envoi des commandes à la loco
        if (node->loco.address() > 0)
        {
            // if (node->loco.address() != oldLocAddress || node->loco.speed() != oldLocSpeed || node->loco.sens() != oldLocSens)
            if (node->loco.speed() != oldLocSpeed)
                comptCmdLoco = 0;

            if (comptCmdLoco < 5)
            {
                CanMsg::sendMsg(1, 0xF0, node->ID(), CENTRALE_DCC_ID, 0,
                                (node->loco.address() & 0xFF00) >> 8,
                                node->loco.address() & 0x00FF,
                                node->loco.speed(),
                                node->loco.sens()); // Message à la centrale DCC++
#ifdef debug
                debug.printf("[GestionReseau %d] Loco %d vitesse %d\n", __LINE__, node->loco.address(), node->loco.speed());
#endif

[bobyAndCo]

Le message CAN, ordre adressé à la locomotive vu dans le code précédent, est reçu par la centrale (laBox) dans le fichier CanMarklin que Thierry a justement ajouté et qui agit sur la centrale laBox.

Voici le code côté centrale (dont je ne garanti pas non plus une compréhension aisée !)

Code: [Sélectionner]


/*

  CanMsg.cpp

 */

#include "CanMarklin.h"

#ifdef ENABLE_CANMARKLIN

// - Config, voir lignes 184 à 186 de config.h
gpio_num_t CanMarklin::RxPin = GPIO_NUM_4;
gpio_num_t CanMarklin::TxPin = GPIO_NUM_5;
uint32_t CanMarklin::DESIRED_BIT_RATE = 1000ul * 1000ul;
uint8_t CanMarklin::thisId = 100;
bool CanMarklin::SendCommands = false;

uint8_t CanMarklin::getId() { return thisId; }

QueueHandle_t xQueue; // Queue pour stocker les messages retour

/************************************************************************
Retour de LaBox pour les commandes de traction, la fonction emergency stop
la fonction power on / power off et plus generalement par la suite, toutes
les fonctions qui emettent une confirmation dans DCC-Ex
*************************************************************************/

void ackTask(void *pvParameters)
{
  BaseType_t status;
  CANMessage frame;
  //frame.ext = true;

  for (;;)
  {
    status = xQueueReceive(xQueue, &frame, pdMS_TO_TICKS(100));
    if (status == pdPASS)
    {
      frame.id &= ~ 0x18000000;
      frame.id |= 3 << 27;               // Priorite 0, 1, 2 ou 3
      frame.id &= ~ 0x7F800;
      frame.id |= CanMarklin::getId() << 11; // ID expediteur
      frame.id &= ~ 0x04;
      frame.id |= 1 << 2;                // Réponse
      CanMarklin::sendMsg(frame);
    }
    vTaskDelay(pdMS_TO_TICKS(100));
  }
}

void CanMarklin::begin()
{
DIAG(F("Configure ESP32 CAN"));

if (DESIRED_BIT_RATE < 1000000UL)
DIAG(F("CAN id = %d  Bitrate = %d Kb/s  CANH:%d  CANL:%d"), thisId, DESIRED_BIT_RATE / 1000UL, RxPin, TxPin);
else
DIAG(F("CAN id = %d  Bitrate = %d Mb/s  CANH:%d  CANL:%d"), thisId, DESIRED_BIT_RATE / 1000000UL, RxPin, TxPin);

  ACAN_ESP32_Settings settings(DESIRED_BIT_RATE);
  settings.mRxPin = RxPin;
  settings.mTxPin = TxPin;

  uint32_t errorCode;

  // with filter
  const ACAN_ESP32_Filter filter = ACAN_ESP32_Filter::singleExtendedFilter(
      ACAN_ESP32_Filter::data, 0xF << 23, 0x187FFFFB);
  errorCode = ACAN_ESP32::can.begin(settings, filter);

  // without filter
  //errorCode = ACAN_ESP32::can.begin(settings);
  //Serial.printf("[CanMsg %d] : config without filter\n", __LINE__);

  if (errorCode == 0)
    DIAG(F("CAN Configuration OK !"));
  else
  {
    DIAG(F("CAN Configuration error 0x%x"), errorCode);
    return;
  }
  xQueue = xQueueCreate(50, sizeof(CANMessage));
  xTaskCreate(ackTask, "ackTask", 2 * 1024, NULL, 0, NULL);
}

/*--------------------------------------
  Reception CAN
  --------------------------------------*/

void CanMarklin::loop()
{
  CANMessage frameIn;
  if (ACAN_ESP32::can.receive(frameIn))
  {
    const uint8_t cmde = (frameIn.id & 0x7F80000) >> 19; // Commande
    const uint8_t exped = (frameIn.id & 0x7F800) >> 11;  // Expéditeur
    const uint8_t resp = (frameIn.id & 0x04) >> 2;       // Commande = 0 / Reponse = 1

    char cmdName[20];
    switch(cmde)
    {
      case CAN_LOCO_THROTTLE:        strcpy(cmdName, "Loco Throttle");        break;
      case CAN_LOCO_FUNCTION:        strcpy(cmdName, "Loco Function");        break;
      case CAN_LOCO_WRITECV_MAIN:    strcpy(cmdName, "Loco WriteCv main");    break;
      case CAN_POWERON:              strcpy(cmdName, "Power");                break;
      case CAN_EMERGENCY_STOP:       strcpy(cmdName, "Emergency Stop");       break;
    }

    if (Diag::CANDIAG) DIAG(F("[CanMarklin]------ Sender %d : Command 0x%0X %s"), exped, cmde, cmdName);

    if (frameIn.rtr) // Remote frame
      ACAN_ESP32::can.tryToSend(frameIn);
    else
    {
      uint16_t loco = 0;
      if (cmde < CAN_FIRST_NOTLOCO_COMMAND)
        loco = (frameIn.data[0] << 8) + frameIn.data[1];

      switch (cmde) // Fonction appelée
      {
      case CAN_LOCO_THROTTLE:
        DCC::setThrottle(loco, frameIn.data[2], frameIn.data[3]);
        xQueueSendToBack(xQueue, &frameIn, 0);
        break;
      case CAN_LOCO_FUNCTION:
        DCC::setFn(loco, frameIn.data[2], frameIn.data[3]); // frame.data[2] = fonction, frame.data[3] : 'on' ou 'off'
        break;
      case CAN_LOCO_WRITECV_MAIN:
        // WRITE CV on MAIN <w CAB CV VALUE>
        DCC::writeCVByteMain(loco, frameIn.data[2], frameIn.data[3]);
        break;
      case CAN_POWERON:
        TrackManager::setMainPower(frameIn.data[0] ? POWERMODE::ON : POWERMODE::OFF);
        xQueueSendToBack(xQueue, &frameIn, 0);
        break;
      case CAN_EMERGENCY_STOP:
        DCC::setThrottle(0, 1, 1); // emergency stop
        xQueueSendToBack(xQueue, &frameIn, 0);
        break;
      }
    }
  }

  /*--------------------------------------
    Envoi mesure de courant
    --------------------------------------*/
// #define MESURE_COURANT
#ifdef MESURE_COURANT
  static uint64_t millisRefreshData = 0;
  if (millis() - millisRefreshData > 1000)
  {
    CANMessage frameOut;
    MotorDriver *mainDriver = NULL;
    for (const auto &md : TrackManager::getMainDrivers())
      mainDriver = md;
    if (mainDriver == NULL || !mainDriver->canMeasureCurrent())
      return;

    POWERMODE mode = TrackManager::getMainPower();
    if (mode == POWERMODE::ON)
    {
      uint16_t current = mainDriver->getCurrentRaw();
      sendMsg(0, 0xFD, CanMsg::getId(), 0, 1, (current & 0xFF00) >> 8, current & 0x00FF);
    }
    else if (mode == POWERMODE::OVERLOAD)
      sendMsg(0, 0xFD, CanMsg::getId(), 0, 1, 2);
    else
      sendMsg(0, 0xFD, CanMsg::getId(), 0, 1, 0);
    millisRefreshData = millis();
  }
#endif
}

void CanMarklin::setPower(bool isOn)
{
    CanMarklin::sendMsg(2, CAN_POWERON, CanMarklin::getId(), thisId, 0, isOn);
}

void CanMarklin::setThrottle(uint16_t cab, uint8_t tSpeed, bool tDirection)
{
if (tSpeed == 1) // Emergency_stop !
CanMarklin::emergency();
else
    CanMarklin::sendMsg(2, CAN_LOCO_THROTTLE, CanMarklin::getId(), thisId, 0, (cab & 0xFF00) >> 8, cab & 0x00FF, tSpeed, tDirection);
}

void CanMarklin::setFunction(int cab, int16_t functionNumber, bool on)
{
    CanMarklin::sendMsg(2, CAN_LOCO_FUNCTION, CanMarklin::getId(), thisId, 0, (cab & 0xFF00) >> 8, cab & 0x00FF, functionNumber, on);
}

void CanMarklin::emergency()
{
    CanMarklin::sendMsg(0, CAN_EMERGENCY_STOP, CanMarklin::getId(), thisId, 0);
}

/*--------------------------------------
  Envoi CAN
  --------------------------------------*/

void CanMarklin::sendMsg(CANMessage &frame)
{
  if (0 == ACAN_ESP32::can.tryToSend(frame))
    DIAG(F("[CanMarklin]------ Send error"));
}

auto formatMsg = [](CANMessage &frame, byte prio, byte cmde, byte thisNodeId, byte destNodeId, byte resp) -> CANMessage
{
  frame.id |= prio << 27;       // Priorite 0, 1, 2 ou 3
  frame.id |= cmde << 19;       // commande appelée
  frame.id |= thisNodeId << 11; // ID expediteur
  frame.id |= destNodeId << 3;  // ID destinataire
  frame.id |= resp << 2;        // Réponse
  frame.ext = true;
  return frame;
};

void CanMarklin::sendMsg(byte prio, byte cmde, byte thisNodeId, byte destNodeId, byte resp)
{
  CANMessage frame;
  frame = formatMsg(frame, prio, cmde, thisNodeId, destNodeId, resp);
  frame.len = 0;
  CanMarklin::sendMsg(frame);
}

void CanMarklin::sendMsg(byte prio, byte cmde, byte thisNodeId, byte destNodeId, byte resp, byte data0)
{
  CANMessage frame;
  frame = formatMsg(frame, prio, cmde, thisNodeId, destNodeId, resp);
  frame.len = 1;
  frame.data[0] = data0;
  CanMarklin::sendMsg(frame);
}

void CanMarklin::sendMsg(byte prio, byte cmde, byte thisNodeId, byte destNodeId, byte resp, byte data0, byte data1)
{
  CANMessage frame;
  frame = formatMsg(frame, prio, cmde, thisNodeId, destNodeId, resp);
  frame.len = 2;
  frame.data[0] = data0;
  frame.data[1] = data1;
  CanMarklin::sendMsg(frame);
}

void CanMarklin::sendMsg(byte prio, byte cmde, byte thisNodeId, byte destNodeId, byte resp, byte data0, byte data1, byte data2)
{
  CANMessage frame;
  frame = formatMsg(frame, prio, cmde, thisNodeId, destNodeId, resp);
  frame.len = 3;
  frame.data[0] = data0;
  frame.data[1] = data1;
  frame.data[2] = data2;
  CanMarklin::sendMsg(frame);
}

void CanMarklin::sendMsg(byte prio, byte cmde, byte thisNodeId, byte destNodeId, byte resp, byte data0, byte data1, byte data2, byte data3)
{
  CANMessage frame;
  frame = formatMsg(frame, prio, cmde, thisNodeId, destNodeId, resp);
  frame.len = 4;
  frame.data[0] = data0;
  frame.data[1] = data1;
  frame.data[2] = data2;
  frame.data[3] = data3;
  CanMarklin::sendMsg(frame);
}
#endif


[phenixpopol]

Merci des 2 réponses :
Préambule : J’aime bien comprendre et réécrire du code pour faire des applications simplifiées, mais là, je crois que ce ne sera pas possible.
Sous réserve d’approfondissement voila ce que j’ai compris :
Au niveau du satellite, il recueille 2 types d’informations ; l’adresse de la loco et l’état du canton suivant qui peut être  (schématiquement) rouge vert ou ralenti. Le satellite envoie un message CAN à la box qui est : l’adresse, la vitesse ( idem, ralenti à 30 ou stop) et le sens.
Au niveau de la box :
Réception du message CAN après filtre, renvoi d’un message CAN dont pour l’instant je ne vois pas l’utilité et envoi d’un ordre DCC à la loco de type <t1 8 30 1> pour un ralentissement.
Je crois que je progresse. Pour l’instant je vérifie mes cantons, je fais un plan et étudie le système découverte. Ensuite réalisation de la nouvelle box puis des cartes satellites lorsque les PCB seront sortis définitivement. Je te tiens au courant et j’aurais sûrement besoin d’autres conseils.
Cordialement.

[bobyAndCo]

Oui tu as bien compris le principe général.

Au niveau du satellite, il recueille 2 types d’informations ; l’adresse de la loco et l’état du canton suivant qui peut être  (schématiquement) rouge vert ou ralenti.

Très exactement, et cela est possible grâce au CAN, le satellite envoie toutes les 100 ms ses propres informations et reçoit des informations de ses satellites voisins (occupé, libre) mais aussi les voisins de ses voisins il peut déduire le comportement de la signalisation et des locomotives et donc effectivement envoyer les bonnes commandes à la centrale.

C'est un très bel exemple de l'intérêt de ce que permet le CAN

Le code pour l'envoi de ces informations sur le bus CAN est à partir de la ligne 158 dans https://github.com/BOBILLEChristophe/Satellites_autonomes_client/blob/main/src/GestionReseau.cpp

Code: [Sélectionner]

/*************************************************************************************
         * Envoi sur le bus CAN des informations concernant ce satellite
         ************************************************************************************/

        // SM1
        uint8_t nodeP_SM1_ID = 0;
        bool nodeP_SM1_ACCES = false;
        bool nodeP_SM1_BUSY = false;

        if (node->nodeP[node->SM1_idx()] != nullptr)
        {
            nodeP_SM1_ID = node->nodeP[node->SM1_idx()]->ID();
            if (node->nodeP[node->SM1_idx()]->acces())
                nodeP_SM1_ACCES = true;
            if (node->nodeP[node->SM1_idx()]->busy())
                nodeP_SM1_BUSY = true;
        }

        uint8_t nodeP_SP1_ID = 0;
        bool nodeP_SP1_ACCES = false;
        bool nodeP_SP1_BUSY = false;

        if (node->nodeP[node->SP1_idx()] != nullptr)
        {
            nodeP_SP1_ID = node->nodeP[node->SP1_idx()]->ID();
            if (node->nodeP[node->SP1_idx()]->acces())
                nodeP_SP1_ACCES = true;
            if (node->nodeP[node->SP1_idx()]->busy())
                nodeP_SP1_BUSY = true;
        }

        // debug.printf("[GestionReseau %d ] nodeP_SM1_ID : %d\n", __LINE__, nodeP_SM1_ID);
        // debug.printf("[GestionReseau %d ] nodeP_SP1_ID : %d\n", __LINE__, nodeP_SP1_ID);
        // debug.printf("[GestionReseau %d ] this node busy : %d\n", __LINE__, node->busy());

        // debug.printf("[GestionReseau %d ] SP2_acces : %d\n", __LINE__, node->SP2_acces());
        // debug.printf("[GestionReseau %d ] SP2_busy : %d\n", __LINE__, node->SP2_busy());

        CanMsg::sendMsg(1, 0xE0, node->ID(), 0xE0, 0,
                        node->busy(),
                        nodeP_SP1_ID,
                        nodeP_SM1_ID,
                        nodeP_SP1_ACCES,
                        nodeP_SP1_BUSY,
                        nodeP_SM1_ACCES,
                        nodeP_SM1_BUSY);


[hubin25]

Bonjour, pour moi qui souhaite me lancer dans le digital sans être un pro de la programmation, ces cartes satellites paraissent très intéressantes (l'idée étant de sécuriser mon réseau, tout en jouant manuellement, sans trop de programmation : je pense faire partie du public cible ! ).


Plusieurs questions me viennent :


1/ est-ce compatible avec des aiguillages à solénoïdes ? Je crois comprendre que non... le programme est-il adaptable ou faut-il que j'adapte mes aiguillages ?
2/ ne connaissant pas la signalisation ferroviaire, pouvez vous m'expliquer quels sont les differents signaux générés automatiquement (et éventuellement leur signification) ?
3/ y a t-il des schémas de cablage disponibles ?
4/ je crois comprendre que labox n'est pas (encore) compatible railcom et qu'on ne peut donc pas utiliser les satellites à leur plein potentiel... la montée de version labox est elle prévue dans un futur proche ? Est-ce une question hardware ou software ? En d'autres termes est-ce que j'attends une future version de labox, cherche une autre centrale, ou construit celle ci en espérant la faire évoluer?


En espérant ne pas avoir posé de questions trop bêtes...
Je vous remercie pour vos réponses.

[bobyAndCo]

Bonjour Hubin,

Merci tout d’abord pour l’intérêt que tu portes aux satellites autonomes. Je vais répondre en partant de la fin.

En espérant ne pas avoir posé de questions trop bêtes...

Il n’y a pas de questions bêtes ! Il y a juste des modélistes qui ont un niveau de connaissance de l’ouvrage plus ou moins avancé. Ce qui serait stupide c’est de se censurer en pensant cela.

je crois comprendre que labox n'est pas (encore) compatible railcom

La Box est compatible Railcom !

y a t-il des schémas de cablage disponibles ?

Pour les schémas de câblage, il n’en existe pas vraiment mais je pense que LocoFred se fera un plaisir de s’y atteler !

ne connaissant pas la signalisation ferroviaire, pouvez vous m'expliquer quels sont les differents signaux générés automatiquement (et éventuellement leur signification) ?

Pour la signalisation, sémaphore, carré (avec œilleton), ralentissement, rappel de ralentissement (avec œilleton également). Pour la signification, tu peux voir ici : https://www.nitrathor.fr/fiches/signaux-sncf

est-ce compatible avec des aiguillages à solénoïdes ? Je crois comprendre que non... le programme est-il adaptable ou faut-il que j'adapte mes aiguillages ?

Le programme peut être adapté pour les aiguillages à solénoïdes. Ce n’est qu’un signal « sec », donc assez simple. Il faudra cependant prévoir l’électronique (relais ?) qui va bien car l’ESP32 ne pourra fournir ni le courant, ni la tension suffisante.

Merci pour tes questions. Si tu le souhaite, on pourra t'associer au petit groupe (3 !) qui discute en "off" sur des choses qui ne justifient pas d'être sur le forum et qui sont plus souvent pratiques.

Christophe

[hubin25]

Merci Christophe pour ta réponse.

La Box est compatible Railcom !

Super, il n'y a donc plus rien qui me retient pour me lancer.

Pour les schémas de câblage, il n’en existe pas vraiment mais je pense que LocoFred se fera un plaisir de s’y atteler !

Eh bien ce serait grand de sa part  !

Pour la signalisation

Merci pour le lien. Je comprends que c'est le satellite qui "choisit" la signalisation adéquate en fonction de la situation ? Techniquement ce sont donc des sorties tor qui passent à 1 permettant d'allumer les bonnes leds ?

Le programme peut être adapté pour les aiguillages à solénoïdes.

Je suis encore loin d'être confronté à cette question, mais ça me rassure de me lancer en sachant que c'est possible.

Si tu le souhaites, on pourra t'associer au petit groupe (3 !) qui discute en "off" sur des choses qui ne justifient pas d'être sur le forum et qui sont plus souvent pratiques.

Oui avec plaisir mais dans l'ordre je pense qu'il faut que je :
1/ construise la centrale (s'il y a un groupe pour ça, ce serait le plus adapté dans un premier temps pour moi)   
2/ digitalise la première de mes locos (j'ai trouvé un tuto sur le forum 3rails qui correspond à mon matériel, en étant minutieux ça me parait faisable sans trop de problème)
3/ me penche sur le fonctionnement et la réalisation des satellites (et c'est là que je serai vraiment intéressé par ta proposition, mais tu peux déja m'y intégrer)

Robin

[rNe]

Bonjour à tous.

Sur les conseils de laurent j'ai appliqué une petite modification au schéma de principe des satellites autonomes. Cela consiste à relier la broche 5 (V_IO) du MCP2562 au +3,3V de l'ESP32. Cette modification n'impacte absolument pas les fonctionnalités du satellite, simplement elle évite d'avoir un décalage de tension entre les niveaux de commandes et l'alimentation du transceiver CAN. Si vous avez déjà réalisé mon PCB en version 2.1 vous n'avez aucune inquiétude à vous faire tout est compatible.
Ci-joint les fichiers de la version 2.2
Je rappelle que les numéros de versions que je donne à mes réalisations ne concernent que les PCB, autrement dit le hardware. Pour le soft il faut s'en remettre à Christophe qui est le père de ce système.

Encore une fois j'ai inversé les prises Servo 0 et Servo 2. Si vous avez téléchargé le fichier GERBER et que vous ne l'avez pas encore mis en production, mettez le à la corbeille et téléchargez à nouveau les fichiers ci-joint. Dans le cas contraire rien de grave il suffit soit de modifier le fichier config.h (voir mon post précédent avec la même erreur) ou alors de se rappeler que les deux prises sont inversées.

Demain j'arrête le rhum 

[bk4nt]

Je commençais à me demander si cela intéressait quelqu’un !

Bonjour Christophe,

Les gens ne disent peut-être pas ce qu'ils font. Je viens de passer plus de 8 heures à lire des pages et des pages sur ces satellites, dont je compte bien m'inspirer 

Je me permets juste deux simples commentaires.

Je suis resté sur ma faim en lisant les 5 articles sur les satellites car ils ne disent pas grand chose de la carte main et du watchdog. Quelque chose m'a échappé au cours de mes lectures? Ce n'est qu'en arrivant ici, en lisant les discussions, que j'ai enfin pu trouver des liens vers les codes sources pour en savoir plus sur leur fonctionnement. Et je n'ai pas l'impression que les codes ont été transférés sur le github de Locoduino, où je ne trouve que facilement les sources pour le satellite...

Alors soit j'ai trop papillonné pendant mes lectures, en ce cas, désolé, soit il manquerait quelque chose concernant main et watchdog. Au moins pour trouver facilement les codes sources.


Sinon, quelque part dans les sujets sur le satellite, vous vous demandiez si la carte Railcom pourrait servir aussi à une détection de présence par courant. Avec quelques modifications, probablement.

Hors cutout Railcom, s'il y a une présence, et au moins 10mA de consommation (c'est beaucoup), du fait du DCC, il y a des transitions à la sortie de IC2B. Elles pourraient être détectées par l'ESP32 (via un optocoupleur et un circuit R/C simple, pour du 0/1).

Il devrait être possible de modifier les seuils et le minimum de courant détectable. Selon la norme, on pourrait tolérer jusqu'à 200mV de perte pour 34mA. Si on remplace R3 par une résistance de 4,7 Ohm (et en ajustant les seuils Railcom +/-18mV en conséquence), un courant de 2mA via la voie générerait 9,4mV aux bornes de R3. 2mA pouvant correspondre à une résistance de 4k7 ou 5k6 environ sur un essieu de wagon (avec 2 essieux, un wagon consommerait 4mA).

Pour Railcom, il faudrait alors recalculer les résistances pour des seuils à 47mv au lieu des 18mV. Je ne sais pas comment ça pourrait altérer les signaux (délais et rise/fall time).

Une option simple avec R3 à 4,7 Ohm et des 4k7 sur les essieux consisterait alors à ajouter un comparateur avec un seuil à environ 8mV, pour détecter la présence d'un essieu au moins.

Ce serait limité par le comparateur qu'on ajouterait. Du fait de son offset et de son hystérésis. Je pense à augmenter la valeur de R3 car le LM339 a une valeur d'offset assez élevée, 5mV au minimum. Ou je pense à utiliser un TS3021A, qui a un offset max de 2 à 4mV... Il n'existe pas beaucoup de comparateurs rapides avec un très faible offset.

Le TS3021A: https://www.st.com/en/amplifiers-and-comparators/ts3021a.html

Peut-être une alternative: https://www.analog.com/media/en/technical-documentation/data-sheets/ADCMP391_392_393.pdf

En tous cas, je réfléchis à changer la valeur de R3, et même à utiliser le même comparateur IC2B en lui changeant le seuil hors cutout Railcom, via un optocoupleur. Pour à la sortie de IC2B, du Railcom, et hors cutout, un signal s'il y a une présence sur la voie concernée...

PS: pour le moment, j'ai tout en cartons et en sachets. Le fer à souder, je n'y arriverais que plus tard 

[bobyAndCo]

Bonsoir,

Merci pour l'intérêt.

La carte main sert de compteur d'enregistrement pour les nouveaux satellites qui n'ont jamais été identifiés. Elle centralise par ailleurs, au travers d'une interface web, des fonctions qui concernent tous les satellites comme la commande de sauvegarde en RAM des paramètres pous tous les satellites ou encore la commande de bascule entre le mode discovery ou utilisation ou encore, réactiver le wifi pour chaque satellite.

La carte watchdog ne fait qu'une seule chose (pour la faire bien), s'assurer en permanence que tous les satellites communiquent et si toute fois un seul n'adresse plus d'info, d'arreter le système pour éviter tout accident.

Les codes sont sur mon github : https://github.com/BOBILLEChristophe?tab=repositories

Pour la question de la détection par consommation de courant, j'ai finalement créé un système qui donne beaucoup plus satisfaction et gère aussi les courts-circuits en local : https://www.locoduino.org/spip.php?article359

Au plaisir d'échanger sur ce sujet (et d'autres)

Christophe
 

[bk4nt]

Merci pour l'intérêt.

Un intérêt réel. Par contre, les solutions telles que présentées ne seront pas adaptées à mes besoins.

J'ai du Minitrix, du N, pas du HO ni du G. Même monter des 0603 sur certains de mes essieux serait compliqué. De votre réponse et lien, je retiens qu'il serait possible de graphiter, pour que ça puisse encore tourner facilement 

Quant à la solution pour détecter une présence et un CC par canton, c'est pareil, c'est beaucoup trop grand pour mon petit espace. J'ai un projet avec du N dans 2m² pour le réseau, avec environ 50 aiguilles et 80 cantons au moins dans cette surface. 80 satellites et autant de grandes cartes en plus pour détecter les CC, ça ne va pas être possible, ça ne rentrerait pas dans une boite à chaussures 

Mais c'est un intérêt réel. J'y ai bien passé 8 heures, et je relirais encore.

J'ai commandé de petits ESP32 S3 Zero plutôt que de gros ESP: des cm² gagnés.

Je compte effectivement tenter de modifier le récepteur Railcom pour qu'il serve aussi à une détection de présence: des cm² gagnés.

Quant au satellite, j'espère pouvoir densifier avec les ESP S3 Zero pour qu'il puisse gérer 4 cantons avec Railcom au moins... voire 8. Car une dizaine de cartes électroniques, ce serait déjà assez encombrant sous un réseau de 2m²