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