Sujets

1

Les réseaux / décodeur LOCONET pour moteurs MP1

« le: février 10, 2025, 01:46:52 pm »

Bonjour ,
le but de ce projet est de donner un retour d'info , sur le déroulement de la commande du moteur d'aiguille : notamment , si cela s'est mal passé , d'en tirer immédiatement les conséquences
cette info est dispo de 3 façons :
- une batterie d'une led rouge et vert , pour chacune des 8 aiguilles , soit 16 leds
- un message dans le réseau loconet , qui pourrait être un arrêt général d'urgence
- un détail des choses , sur la prise USB , en mode débogage (moniteur Arduino , par exemple

J'ai choisi loconet car j'avais déjà des manettes pour ce bus (le CAN est bien meilleur , mais n'est compatible avec rien)
Le décodeur fabriqué , ressemble à ceci :

2

Vos projets / fredix

« le: novembre 13, 2024, 12:16:25 pm »

Bonjour ,
Un devoir de vacances sans internet , j'ai commencé ce projet où pour dessiner le pcb il faut autant mesurer que router
La base c'est les contrôleurs simples Loconet (donc pas CAN) du FREMO , le FRED , il y a ... 20 ans , puis le FREDI (Incremental) , il y a 10 ans
Il y a eu entre temps le WiFred , (wifi) , mais c'est une autre histoire
Je me suis demandé si on ne pouvait pas faire quelque chose en augmentant le nombre de boutons et de leds , pour pouvoir saisir directement une adresse , et j'ai cherché
Les bibliothèques existantes étant pour des AVR , je suis parti sur une base d'arduino mini : suite au manque de broches , il fallait trouver des trucs à base de charlieplexing pour les leds , et d'échelle de résistances sur entrée analogique pour les boutons ; c'était compliqué à router , cela m'a coûté 3 soirs de "labeur"
La solution , c'est d'utiliser une "vieille" connaissance , que j'avais déjà pour un décodeur de signaux : c'est un nano à rallonge , à base de clone lgt8f328p ; son microcontrôleur et sa carte sont optimisés , ce qui me permet de disposer d'un maximum de broches ; les boutons sont directement connectés à une broche , on utilise le pull-up interne ; pour les leds il faut ajouter une résistance ; j'ai aussi pu utiliser le comparateur analogique interne au  lgt8f328p , ce comparateur est nécessaire à Loconet , il ne manquait plus qu'à ajouter quelques résistances ; vous pouvez voir cet arduino spécial en violet sur le dessin

La face dessous comprend l'arduino et les composants (cms , qui seront mis par jlcpcb) ; la face dessus comprend ce qui est nécessaire à l'homme , cad. le rotatif incrémental (que l'on devine en haut , ainsi que son bouton) , des boutons et des leds ; il y a notamment une colonne de 10 leds (0 à 9) , associée à  une colonne d'autant de boutons , c'est le fondement du projet : les leds 0 à 9 représentent les dizaines , les boutons 0 à 9 , les unités
Le fonctionnement serait le suivant :
- au début , on est en mode normal (ou vitesse) , avec l'adresse courante , la led S , à droite , est allumée ; on fait varier la vitesse avec l'incrémental ; il n'y a pas de bouton de changement de sens , c'est l'incrémental qui le fait , en passant par la vitesse 0 ; une des 2 leds F ou R , de part et d'autres de l'incrémental , donne le sens de marche ; les leds 0 à 9 forment une jauge qui permet de visualiser approximativement la vitesse ; les fonctions de 0 à 9 sont directement accessibles dans ce mode , en appuyant sur le bouton correspondant
- si l'on veut activer des fonctions supérieures à 9 , on passe en mode fonction , en appuyant sur le bouton M , à droite ; la led F s'allume à la place de la led S , la led 1 s'allume pour indiquer la dizaine 1 ; si on appuie par exemple sur le bouton 7 , on active la fonction 17 ; l'incrémental permet d'atteindre les dizaines 2 à 9 , en allument la led correspondante , on peut donc théoriquement activer jusqu'à la fonction 99 ; la manette repasse automatiquement en mode vitesse , après envoi de la fonction
- il y a un mode aiguillage , qu'on active en appuyant 2 fois sur le bouton mode ; la led Y s'allume ; on sélectionne la led de dizaine avec l'incrémental comme précédemment , puis on fait basculer en appuyant sur le bouton correspondant à l'unité ; on reste en mode aiguillage , ou on s'en échappe en ré-appuyant sur le bouton mode
- le mode adresse est obtenu par un appui long sur le bouton mode , les leds S et F s'allument ; on sélectionne l'adresse de 0 à 99 comme précédemment ; je pense réserver l'adresse 0 au mode FRED (dispatch get de Loconet) , où l'adresse du fredix lui sera donnée par une manette évoluée , permettant cette opération

voici pour l'instant ; pj. pour ceux qui préfèrent les (beaux ?) dessins

3

Les réseaux / décodeur modulaire pour réseau modulaire , à commande d'ag par micro-moteurs PAP

« le: septembre 25, 2024, 05:49:38 pm »

j'ai remarqué ce type de micro-moteur PAP sur un site express , et je me suis demandé s'il était possible de s'en servir comme moteur d'aiguille , à déployer sur mon futur réseau
les inconvénients  :
- nécessite 4 broches d'arduino au lieu de 2
- disponibilité à terme ?
- endurance ?
- fixation et raccordement : je n'ai pas de solution évidente à ce stade
les avantages :
- prix
- dimension
- pas de réglage : on envoie un nombre majoré de pas , à la fin le moteur bute et saute tout simplement  les pas en trop
.
j'ai réalisé un test avec un nano et un petit module avec ponts en H , le fonctionnement me paraît bon : il a la force qui va bien , et il est suffisamment rapide pour un moteur lent

4

Modélisation, Architectures logicielles et matérielles / DCC : Détection Railcom

« le: mars 17, 2024, 10:02:11 pm »

bonsoir , juste une courte récréation , si vous voulez bien
j'avais dessiné ceci , une carte de rétro-signalisation pour occupation et identification railcom , à 8voies
mais comme je ne l'ai (toujours) pas essayée , je n'en dirai pas +

5

Composants / WeAct Studio STM32G431CBU6

« le: octobre 04, 2023, 04:26:57 pm »

c'est un nouvel "arduino" , petit mais très costaud !
il s'achète  ici :
https://fr.aliexpress.com/item/1005005303669884.html?spm=a2g0o.home.15002.8.1a6a7065ZZJjl5&gps-id=pcJustForYou&scm=1007.13562.357122.0&scm_id=1007.13562.357122.0&scm-url=1007.13562.357122.0&pvid=33a72d53-2fe0-420c-8306-637c0d662aa7&_t=gps-id:pcJustForYou,scm-url:1007.13562.357122.0,pvid:33a72d53-2fe0-420c-8306-637c0d662aa7,tpp_buckets:668%232846%238114%231999&pdp_npi=4%40dis%21EUR%214.91%213.24%21%21%2136.76%21%21%40211b812f16964173512867833ef736%2112000032557636496%21rec%21FR%21140969751%21&curPageLogUid=S0SS7fpdciTR

j'en parle ici
https://forum.arduino.cc/t/stm32g431cbu6-de-weact-studio/1142729

on en parle là
https://hackaday.io/project/192562-weact-duino-cheap-and-powerful

et là
https://cc.bingj.com/cache.aspx?q=eevblog+forum+stm32g431cbu6&d=5034913158154360&mkt=fr-FR&setlang=en-GB&w=MfJw5tP0woHxnUFT2kPJuymF0sx9EFRg

et donc j'ai un projet pour ceci dans le forum locoduino
https://forum.locoduino.org/index.php?topic=1601.msg17068;boardseen#new

6

Vos projets / centrale DCC / analogique modulaire

« le: octobre 03, 2023, 06:22:44 pm »

un projet ambitieux dont je n'ai que franchi le seuil
le but est d'alimenter indépendamment chaque canton d'un réseau , avec un signal dcc ou analogique , en fonction de la circulation qui s'y trouve ; je n'ai aucune idée du logiciel PC qui pourra commander cela , mais je m'attaque gaillardement au hardware
il y aura une centrale avec toutes les interfaces (wifi , loconet) et la voie de programmation , et à côté , des boosters au nombre égal à celui des cantons
l'idée originale provient du club de Salzbourg , que j'avais vue à l'époque , et que je peux envisager de mettre en oeuvre avec les moyens d'aujourd'hui
cela ressemble à ça (la centrale à gauche n'est pas représentée)

7

Modélisation, Architectures logicielles et matérielles / TCO Web interactif avec un ESP32

« le: janvier 09, 2023, 11:31:15 am »

Bonjour et bonne année
pour commencer les discussions relatives à ce projet, je propose la modification suivante, consistant à utiliser une fonction html/css pour faire pivoter les éléments du TCO
le but est de réduire d'une bonne moitié le nombre d'éléments de base, mais surtout d'orienter facilement les aiguillages, sans devoir en tenir compte dans le code ; j'ai ainsi pu ajouter un aiguillage triple vertical, sans disposer du dessin
il faut pour cela compléter la classe de style ".im1" par 3 autres classes, selon la rotation voulue

Code: [Sélectionner]

    .img1 {border: 0px; width: 64px; height=64px;}
    .img1_090 { border: 0px; width: 64px; height=64px;
            -webkit-transform: rotate(90deg);
            -moz-transform: rotate(90deg);
            -ms-transform: rotate(90deg);
            -o-transform: rotate(90deg);
            transform: rotate(90deg);  }
    .img1_180 { border: 0px; width: 64px; height=64px;
            -webkit-transform: rotate(180deg);
            -moz-transform: rotate(180deg);
            -ms-transform: rotate(180deg);
            -o-transform: rotate(180deg);
            transform: rotate(180deg); }
    .img1_270 { border: 0px; width: 64px; height=64px;
            -webkit-transform: rotate(-90deg);
            -moz-transform: rotate(-90deg);
            -ms-transform: rotate(-90deg);
            -o-transform: rotate(-90deg);
            transform: rotate(-90deg); }
le paramètre "angApp" des fonctions "ChangeAig..." n'est plus nécessaire (je ne l'ai pas modifié)
je joins le fichier "Mon_TCO_No04" modifié, à titre d'illustration ; on doit obtenir ceci :

 

8

Vos projets / décodeur dcc pour signaux sncf complexes, avec arduino nano (et pcb)

« le: juillet 24, 2022, 10:21:38 am »

Bonjour,
le décodeur pour signaux sncf à 4 feux, dont j'ai pu écrire un .ino qui fonctionne, est adapté à beaucoup de situations, et économise aux mieux les adresses
il lui manque la gestion des signaux complexes, du clignotement et de la gradation
je me lance dans ce projet dans le but de remplacer les décodeurs sncf LDT d'un ami : c'est pénible (pour moi) à configurer, je ne suis pas parvenu à les faire fonctionner à partir de sa centrale ECOS
l'avantage de l'arduino (entre autres), c'est le moniteur, on pourra depuis le moniteur, regarder ce que la centrale envoie aux addresses du décodeur, et faire un petit menu qui permettra de configurer confortablement le décodeur
en tant qu'homme du hardware (autoproclamé) , j'ai commencé par dessiner un petit pcb, que je vous joins, si vous aimez les images

9

Vos projets / décodeur dcc à mosfets pour aiguilles à solénoïdes, et extension à 74hc595

« le: juin 29, 2022, 04:10:31 pm »

Bonjour,
de me suis finalement décidé à dessiner ce décodeur
la base est la même que que le décodeur à uln2003 https://forum.locoduino.org/index.php?topic=1431.0
les uln2003 sont remplacés par de petits mosfets en boitier double sot23-6 ; les caractéristiques de ces mosfets sont 30v, 2A5 continu et 10A pulsé
cela suffit peut-être pour du peco ou du seep, mais je l'ai plutôt prévu pour des solénïdes de roco, fleischmann, trix ...
le dispositif de protection prévu pour les mosfets utilise des NUP2105L, normalement faits pour protéger les lignes CAN, est ambitieux, optimiste ou raisonnable, en tous cas pas encore évalué, on est donc sur de l'expérimental pour cette partie
je ne conçois pas de commande de solénoïde sans dispositif CDU, même si les moteurs sont munis de fin de course ; il vaut même mieux, amha, mettre les fins de course hors service et utiliser le cdu
ici, le cdu est un peu particulier : l'alim se fait en 10-12v, et les tensions nécessaires aux solénoïdes sont 16v, voire 24v pour du peco ; on a donc un convertisseur dcdc boost qui charge la capa cdu à la tension voulue ; l'arduino peut choisir cette tension entre 2 valeurs (par ex 16v ou 24v), on peut donc panacher les moteurs d'aiguille ; le CI convertisseur dcdc est aussi en boitier sot23-6 : c'est un MT3608
le cdu doit stopper la charge de la capa cdu tant qu'il y a une consommation au niveau des solénoïdes : c'es le rôle de l'électronique de contrôle située à droite de la capa cdu (on intervient "simplement" sur la broche enable du CI convertisseur dcdc)
l'arduino mesure aussi la tension de la capa cdu, le but c'est d'attendre qu'elle doit rechargée avant de commander la décharge suivante
en pj, un dessin du décodeur avec l'identification des différentes parties
bien entendu, il y a aussi les cartes d'extensions, visibles en situation sur la 2ème pj

10

Vos projets / décodeur dcc à uln2003 pour moteurs d'aiguille type mtb, et extensions à 74hc595

« le: juin 26, 2022, 08:15:03 pm »

Bonjour,
j'avais dessiné des modules d'extension qui permettent de commander des moteurs type mtb (à la rigueur, ça peut marcher avec des solénoïdes à faible consommation genre fleischmann)
emporté par mon élan, j'ai aussi dessiné un décodeur dcc qui peut servir de maître pour ces modules : la capacité est impressionnante

(j'ai aussi sous le coude des modules à mosfets costauds (pour peco), ou moyens (pour tous solénoïdes raisonnables), le tout commandé par "ma" centrale
je dessinerai peut-être un décodeur maître pour ceux-cis, (s'il y a une demande), un peu moins simple car j'y ajouterai une cdu à xl6007)
édit : le décodeur dcc pour solénoïdes courants (roc, flesichmann, trix ...) est dessiné, voir l'article https://forum.locoduino.org/index.php?topic=1433.msg15526#msg15526

une image, en attendant :

11

Shields et Modules / "extension 4 feux pour le décodeur de signaux à 2 ou 3 feux"

« le: juin 24, 2022, 10:35:48 am »

suite à la demande de Pierrre sur https://www.locoduino.org/spip.php?article161#forum6190

Code: [Sélectionner]

/*
   Decoder for traffic light with three or two /// or 4 leds on ARDUINO NANO

   by default the red leds are switched on
   pin 2 receives DCC interrupts

   TRAFFIC LIGHT WITH THREE leds (GREEN, RED, YELLOW)
   5 decoders of traffic lights with three leds on Arduino NANO/UNO
   the leds are controlled by pins 3 to A3 by triplet
   traffic light 1 : 3,4,5
   traffic light 2 : 6,7,8
   traffic light 3 : 9,10,11
   traffic light 4 : 12,13,A0
   traffic light 5 : A1,A2,A3
   two addresses by traffic light
   even addresses for green and red lights
   odd addresses for yellow light

   /// TRAFFIC LIGHT WITH 4 leds (green, red, yellow, carre))
   4 decoders of traffic lights with 4 leds on Arduino NANO/UNO
   the leds are controlled by pins 3 to A4 by quadruplets
   traffic light 1 : 3,4,5,6
   traffic light 2 : 7,8,9,10
   traffic light 3 : 11,12,13,A0
   traffic light 4 : A1,A2,A3,A4
   two addresses by traffic light
   even addresses for green and red lights
   /// odd addresses for yellow and carre indications

   TRAFFIC LIGHT WITH TWO leds (GREEN, RED)
   8 decoders of traffic lights with two leds on Arduino NANO/UNO
   the leds are controlled by pins 3 to A4 by pair
   traffic light 1 : 3,4
   traffic light 2 : 5,6
   traffic light 3 : 7,8
   traffic light 4 : 9,10
   traffic light 5 : 11,12
   traffic light 6 : 13,A0
   traffic light 7 : A1,A2
   traffic light 8 : A3,A4
   one address by traffic light

   CONFIGURATION
   MODE : determined by the common of the led, LOW if common = HIGH, HIGH if common = LOW
   FIRST_ID_DCC : DCC address of the first traffic light
   NB_TRAFFIC_LIGHT : determined by the kind of traffic light, BICOLOR for two leds, TRICOLOR for three leds

*/

/// modifs / ajouts pour 4 feux
//// dégobage pour modifs pour 4 feux : supprimer la ligne

/***************************************************************************************
              CONFIGURATION SETTING

 ****************************************************************************************/

#define CONSOLE                             // output console, comment this line after checking the soft
#define MODE   LOW                          // LOW or HIGH
#define FIRST_ID_DCC   90                   // first DCC address, DCC_CODE
#define NB_TRAFFIC_LIGHT  FOURCOLOR         //  TRICOLOR or BICOLOR /// ou FOURCOLOR

/**********************************************************************************
     DON'T CHANGE THE FOLLOWING
 *********************************************************************************/

/******************************************************************************
      INTERNAL PARAMETERS

 ********************************************************************************/

//  DCC

#include "DCC_Decoder.h"                // Minabay library /// "DCC_Decoder.c" must be present too in the folder
#define kDCC_INTERRUPT    0             // pin 2 receives DCC interrupts
int previous_address = 0;               // avoids multiple DCC addresses
int previous_position = 2;              // avoids multiple DCC orders
volatile boolean update_light;          // set if an update should be processed after DCC control

// traffic light

#define BICOLOR  8                     // 8 traffic lights with two leds
#define TRICOLOR 5                     // 5 traffic lights with three leds
#define FOURCOLOR 4                    /// 4 traffic lights with 4 leds
#define FIRST_PIN         3            // pin of the first traffic light
#define GREEN             0            // address DCC/0
#define RED               1            // address DCC/1
#define YELLOW            2            // address DCC+1/0
#define CARRE             3            /// address DCC+1/1

// traffic light definition

struct light {
  int address;                    // its DCC address
  int current_position;           // green / red / yellow /// carre
  int green;                      // pin of the green led
  int red;                        // pin of the red led
  int yellow;                     // pin of the yellow led
  int carre;                      /// pin of the carre led
  boolean activation_request;     // request of activation
};
light traffic_light[NB_TRAFFIC_LIGHT];    // the set of traffic light

/********************************************************************
   method called if a request is made by the DCC

 *******************************************************************/

void activation_traffic_light() {
  for (int i = 0; i < NB_TRAFFIC_LIGHT; i++)                 // for all traffic lights
  {
    if (traffic_light[i].activation_request == true)  // if the traffic_light is waiting for activation
    {
      switch (traffic_light[i].current_position)           // we look the current position
      {
        case GREEN : {                                         /// indication GREEN
            digitalWrite(traffic_light[i].green, MODE);        // switch on green
            digitalWrite(traffic_light[i].red, !MODE);         // switch off red
            if ( NB_TRAFFIC_LIGHT == TRICOLOR || NB_TRAFFIC_LIGHT == FOURCOLOR) {
              digitalWrite(traffic_light[i].yellow, !MODE);    // switch off yellow
            }
            if ( NB_TRAFFIC_LIGHT == FOURCOLOR) {         ///
             digitalWrite(traffic_light[i].carre, !MODE);     /// switch off carre
            }
            /**/#ifdef CONSOLE
            Serial.print("active -> signal "); Serial.print(i); Serial.println(" : green led");
            /**/#endif
            break;
          }
        case RED : {                                         /// indication RED
            digitalWrite(traffic_light[i].green, !MODE);     // switch off green
            digitalWrite(traffic_light[i].red, MODE);        // switch on red  /// incomplet ?
            if ( NB_TRAFFIC_LIGHT == TRICOLOR || NB_TRAFFIC_LIGHT == FOURCOLOR) {
              digitalWrite(traffic_light[i].yellow, !MODE);  // switch off yellow
            }
            if ( NB_TRAFFIC_LIGHT == FOURCOLOR) {       ///
              digitalWrite(traffic_light[i].carre, !MODE);   /// switch off carre
            }
            /**/#ifdef CONSOLE
            Serial.print("active -> signal "); Serial.print(i); Serial.println(" : red led");
            /**/#endif
            break;
          }
        case YELLOW : {                                         /// indication YELLOW
            digitalWrite(traffic_light[i].green, !MODE);        // switch off green
            digitalWrite(traffic_light[i].red, !MODE);          // switch off red
            digitalWrite(traffic_light[i].yellow, MODE);        // switch on yellow
            if ( NB_TRAFFIC_LIGHT == FOURCOLOR) {               ///
              digitalWrite(traffic_light[i].carre, !MODE);      /// switch off carre
            }
            /**/#ifdef CONSOLE
            Serial.print("active -> signal "); Serial.print(i); Serial.println(" : yellow led");
            /**/#endif
            break;
          }
        case CARRE : {                                          /// indication CARRE
            digitalWrite(traffic_light[i].green, !MODE);        // switch off green
            digitalWrite(traffic_light[i].red, MODE);           /// switch on red  // incomplet ?
            digitalWrite(traffic_light[i].yellow, !MODE);       // switch off yellow
            digitalWrite(traffic_light[i].carre, MODE);         /// switch on carre
            /**/#ifdef CONSOLE
            Serial.print("active -> signal "); Serial.print(i); Serial.println(" : carre + red led");
            /**/#endif
            break;
          }
      }
    }
    traffic_light[i].activation_request = false;            // the traffic light is updated
  }
  update_light = false;                                        // all updates are made
}

/*************************************************************************************
    DCC method

 ***********************************************************************************/

void BasicAccDecoderPacket_Handler(int address, boolean activate, byte data)
{
  address -= 1; address *= 4; address += 1; address += (data & 0x06) >> 1;    // DCC address decoding
  int led = (data & 0x01) ? GREEN : RED;                                      // DCC/0 or DCC/1
  int traffic_light_index = address;                                          // index of a traffic light
  int color = led;                                                            // the color of the led
  boolean activation = false;
  if ((address != previous_address) || ((led != previous_position) && (address == previous_address))) { // if we change the address or the led
    switch (NB_TRAFFIC_LIGHT) {
      case BICOLOR : {      // if the address is in our range for traffic light with two leds
          if ((address >= FIRST_ID_DCC) && (address < FIRST_ID_DCC + NB_TRAFFIC_LIGHT)) {
            traffic_light_index = address - FIRST_ID_DCC;                                  // index of the traffic light
            activation = true;
          }
          break;
        }
      case TRICOLOR : {     // if the address is in our range for traffic light with three leds
          if ((address >= FIRST_ID_DCC) && (address < FIRST_ID_DCC + (2 * NB_TRAFFIC_LIGHT))) {
            if (address % 2 != 0) {
              traffic_light_index = address - 1;  // if odd address => yellow led
              color = YELLOW;
            }
            traffic_light_index = (traffic_light_index - FIRST_ID_DCC) / 2;                  // index of the traffic light
            activation = true;
          }
          break;
        }
      case FOURCOLOR : {     /// if the address is in our range for traffic light with 4 leds
          if ((address >= FIRST_ID_DCC) && (address < FIRST_ID_DCC + (2 * NB_TRAFFIC_LIGHT))) {
            if (address % 2 != 0) {
              traffic_light_index = address - 1;  // if odd address => yellow led
              if (data & 0x01) color = CARRE; else color = YELLOW; /// en fonction du poids faible
            }
            traffic_light_index = (traffic_light_index - FIRST_ID_DCC) / 2;                  // index of the traffic light
            activation = true;
            /**/#ifdef CONSOLE
            Serial.print("s"); Serial.print(traffic_light_index); Serial.print(" a"); Serial.print(address); Serial.print("/"); Serial.print(data & 0x01); Serial.print(" ");
            /**/#endif
          }
          break;
        }
    }
    traffic_light[traffic_light_index].activation_request =  activation;    // activation is requested
    traffic_light[traffic_light_index].current_position = color;            // state is requested (color of the led)
    update_light = activation;                                              // traffic light update is requested
  }
  previous_address = address; previous_position = led;                     // the current activation is saved
}
/**********************************************************************************************
    setup

 ******************************************************************************************/

void setup() {
#ifdef CONSOLE
  Serial.begin(115200);
#endif
  delay(1500); /// compatible debogage promicro

  int pin_jump = 0;                                                    // a jump for traffic light pins
  int traffic_light_jump = 0;                                          // a jump for traffic light number
  for (int i = 0; i < NB_TRAFFIC_LIGHT; i++) {                         // for all the traffic lights
    traffic_light[i].activation_request = false;                       // no activation request
    traffic_light[i].green = pin_jump + FIRST_PIN;                     // pin number of the green led
    pinMode(traffic_light[i].green, OUTPUT);                           // green led in output(ID DCC/0)
    digitalWrite(traffic_light[i].green, !MODE);                       // green led switch off
    traffic_light[i].red = 1 + pin_jump + FIRST_PIN;                   // pin number of the red led
    pinMode(traffic_light[i].red, OUTPUT);                             // red led in output  (ID DCC/1)
    digitalWrite(traffic_light[i].red, MODE);                          // red led switch on
    if (NB_TRAFFIC_LIGHT == TRICOLOR || NB_TRAFFIC_LIGHT == FOURCOLOR ) {   // if 3 leds /// or 4 leds
      traffic_light[i].address = traffic_light_jump + FIRST_ID_DCC + i;   // its DCC ID
      traffic_light[i].yellow = 2 + pin_jump + FIRST_PIN;              // pin number of the yellow led
      pinMode(traffic_light[i].yellow, OUTPUT);                        // yellow led in output  (ID DCC+1/0)
      digitalWrite(traffic_light[i].yellow, !MODE);                    // yellow led switch off
      traffic_light_jump++;                                            // the following traffic light
      pin_jump += 3;                                                   // the following pin for three leds
      if (NB_TRAFFIC_LIGHT == FOURCOLOR) {                             /// if 4 leds
        traffic_light[i].carre = pin_jump + FIRST_PIN;
        pinMode(traffic_light[i].carre, OUTPUT);                       // carre led in output  (ID DCC+1/1)
        digitalWrite(traffic_light[i].carre, MODE);                    // carre led switch on
        pin_jump += 1;                                                 /// the following pin for 4 leds
      }
    }
    else {                                                             // if two leds
      traffic_light[i].address = FIRST_ID_DCC + i;                     // its DCC ID
      pin_jump += 2;                                                   // the following pin for two leds
    }

  }

  DCC.SetBasicAccessoryDecoderPacketHandler(BasicAccDecoderPacket_Handler, true);   // instanciate the DCC
  DCC.SetupDecoder( 0x00, 0x00, kDCC_INTERRUPT );                                   // its IT
  update_light = false;                                                             // no update

#ifdef CONSOLE
  //// Serial.begin(115200);
  Serial.println(""); Serial.println(""); Serial.println(""); ///
  for (int i = 0; i < NB_TRAFFIC_LIGHT; i++) {
    Serial.print("traffic light "); Serial.println(i);
    Serial.print("\t green led on pin : "); Serial.print(traffic_light[i].green); Serial.print(" , DCC address : "); Serial.print(traffic_light[i].address); Serial.println("/0");
    Serial.print("\t red led on pin : "); Serial.print(traffic_light[i].red); Serial.print(" , DCC address : "); Serial.print(traffic_light[i].address); Serial.println("/1");
    if (NB_TRAFFIC_LIGHT == TRICOLOR) {
      Serial.print("\t yellow led on pin : "); Serial.print(traffic_light[i].yellow); Serial.print(" , DCC address : "); Serial.print(traffic_light[i].address + 1); Serial.println("/0");
    }
    else   if (NB_TRAFFIC_LIGHT == FOURCOLOR) { ///
      Serial.print("\t yellow led on pin : "); Serial.print(traffic_light[i].yellow); Serial.print(" , DCC address : "); Serial.print(traffic_light[i].address + 1); Serial.println("/0");
      Serial.print("\t carre led on pin : "); Serial.print(traffic_light[i].carre); Serial.print(" , DCC address : "); Serial.print(traffic_light[i].address + 1); Serial.println("/1");
    }
  }
#endif
}

/*************************************************************************
   loop

 ************************************************************************/

void loop() {
  DCC.loop();                   // Is there a DCC command ?

   delay(2000) ; ////
   BasicAccDecoderPacket_Handler(24, 1, 2); ////

  if (update_light) {
    activation_traffic_light(); // if yes, activation of traffic lights
  }

   delay(2000) ; ////
   BasicAccDecoderPacket_Handler(24, 1, 5); ////

   if (update_light) { ////
    activation_traffic_light(); // if yes, activation of traffic lights ////
   }    ////



}

édits : regarder svp. la date du dernier Modifié pour s'assurer d'avoir la dernière version

12

Vos projets / les centrales dcc à esp32 de trimarco232

« le: mai 20, 2022, 12:29:54 pm »

Bonjour,
ça fait un bail que j'ai ça sous mon coude gauche volumineux, c'est le moment d'en parler un peu
les choses à l'envers ? j'ai commencé par dessiner et réaliser le pcb, puis j'ai attaqué le soft de la génération et de l'envoi des bits dcc
actuellement j'en suis à l'étape suivante : le scheduler (ou planificateur de l'envoi des packets dcc), défi au niveau de l'analyse et de la programmation
ce que j'ai fait c'est la chose suivante, assez simple
les packets dcc créés sont classés prioritaires ou pas, selon leur nature ; par exemple les packets constituant un message de freinage, ou une commande d'accessoire dont le timing est critique, seront prioritaires, les autres non
les packets prioritaires sont placées dans des queues qui seront répétées, et exécutées avant la queue non prioritaire ; ça donne un truc de ce genre :
p3 /// queue fifo où sont mis, donc d'où sont envoyés, les nouveaux packets prioritaires
p2 /// queue fifo de la 1ère répétition des packets prioritaires
p1 /// queue fifo de la 2nde et dernière répétition des packets prioritaires, suite à quoi les packets ex prioritaires sont définitivement placée dans la queue p0
p0 /// queue qui envoie en boucle tous les packets existants, sans notion de priorité
la queue p0 ne fonctionne que si les 3 autres ont été vidées de leur packet(s)
un même packet ne peut être envoyé 2x directement à sa suite : par exemple un packet prioritaire x, qui passe de p3 à p2, attendra qu'un autre packet y soit envoyé, avant que ce packet x soit envoyé de p2 à son tour
ça, ça marche

reste quelques questions au niveau de l'analyse
- chaque packet de vitesse doit rester dans la boucle p0, dans laquelle ils sera (normalement) remplacé par un nouveau packet de vitesse qui a la même adresse
- les packets d'accessoires n'ont pas lieu de rester ni même de figurer dans la boucle p0 ?
- les packets de fonction doivent-ils rester dans la boucle p0 ? lesquels (je pense l'éclairage) ? pourquoi ?

13

Shields et Modules / module d'entrées à 74hc165, pour TCO ou autres

« le: mai 08, 2022, 08:53:15 pm »

Bonjour,
j'ai dessiné ceci (sans savoir si je vais l'adopter)

c'est un module de 16 entrées par registre à décalage 74hc165 ; on peut donc les chaîner pour augmenter le nombre d'entrées
il faut 3 broches de l'arduino, idéalement les miso et sck du périphérique spi, mais des io ordinaires le font aussi avec une bibliothèque qui va bien
il y a 16 résistances de pull-up placées de part et d'autres des 74hc165 : il faut donc que les boutons faisant l'objet des entrées donnent un GND
les résistances situées à droite ne sont placées que sur le dernier module, elles donnent une certaine immunité vis à vis des parasites
la connectique représentée est du jst xh au pas de 2.5mm, mais des bornes à visser au pas de 2.54, ou des fil directement soudés le font aussi
j'ai aussi dessiné ce module avec un seul 74hc165 (8 entrées)
à noter qu'alternativement j'ai aussi mis en oeuvre des modules du commerce i2c à mcp23017
avantages du module à 74hc595 trimarco :
- pas besoin de mettre d'adresse, chainage "illimité"
- disponibilité et prix en période de pénurie
- connectique ad hoc permettant un raccordement nickel
avantages du module i2c mc23017 du commerce :
- pas besoin de résistance de pull-up
- existe tout fait
- peut aussi servir en sortie

le pcb comprend 2 autres modules curieux, qui ne comportent pas de cuivre ... c'est en fait des supports pour les modules
le 2ème dessin reprend la silhouette du 1er, mais les trous de fixation font 3mm au lieu de 2 ; il est prévu à être collé sur la face intérieure du tco ; dans le trou de 3mm, il y aura des canons-écrous qui seront emmanchés à force (ou collés) : le vrai module prendra donc place sur ce support, maintenu par des vis de 2mm vissées dans les canons ; cette solution permet de faire propre et démontable
le 3ème module ne correspond pas aux 2 autres, mais sert de support, selon le même principe, à un module du commerce à tlc5947, pour la commande de 24 leds ; à noter que la connectique aux extrémités du module à 74hc165 permet d’insérer les modules à tlc5947 avec la même élégance au niveau du câblage ; j'ai choisi les modules à tlc5947 principalement parce qu'il n'y a pas besoin de résistances pour les leds
à suivre, peut-être ...

14

Discussions ouvertes / S88 et S88-N : pourquoi c'est si compliqué ?

« le: janvier 27, 2022, 05:07:52 pm »

Bonjour,
ces bus de rétrosignalisation sont toujours largement utilisés
ils sont d'origine maerklin, il me semble - ça ne rajeunit personne -
l'utilité, c'est par exemple de remonter des occupations de zones, ou de lire des boutons sur le tco
les 2 avantages sont ;
- la simplicité et le bas coût de l'électronique, faite à partir d'ics simples et courants
- la non nécessité de fixer l'adresse des modules, c'est le rang du module dans la chaîne qui donne l'adresse ; ainsi, on peut substituer un module à un autre sans autre forme de procès ; certains y voient par contre un inconvénient : si dans le cadre d'un agrandissement on rajoute un module dans la chaîne, il faut renuméroter, dans le soft, les modules existants qui se trouvent en aval du nouveau ... mais perso, je trouve + avantageux de ne pas avoir à strapper ou programmer d'adresse ...

en observant la façon dont sont faits ces modules, on y voit des registres à décalage du type 4044, ça c'est indispensable, mais aussi et des bascules rs de type 4014, pilotées par le signal reset, et dont le rôle me parait obscur ... peut-être était-ce pour garder en mémoire un contact temporaire, genre bouton pression, en attendant que le microcontrôleur ait le temps de procéder à la lecture, ce qui est compréhensible, tant à l'époque ils étaient lents et assez occupés par ailleurs
peut-être aussi le fait que le S88 est considéré comme un (mauvais) bus de terrain, et que, pour pouvoir ménager une certaine distance entre modules, la vitesse de transmission doit être réduite, et par conséquent tous les délais sont rallongés

donc naguère les microcontrôleur faisaient 1Mhz, avaient 64 octets de ram ; aujourd'hui (depuis 5 ans en fait) ils font 240Mhz sur 32 bits, ont 2 cœurs et bézef de ram et de flash : ce n'est, logiquement, plus du tout le même monde
donc amha, on devrait pouvoir construire des bus de genre S88, en enlevant les 4014, soit 2/3 de l'électronique, tout en améliorant la fiabilité des transmissions

15

Discussions ouvertes / pilotage des cantons en analogique : synchro des pwm par 74hc595

« le: janvier 27, 2022, 03:01:22 pm »

Bonjour,
dans le cadre de l'article https://forum.locoduino.org/index.php?topic=1097.0
nous avions vu ;
- l'impossibilioté de synchroniser les horloges de plusieurs pca9685
- comment pallier, si on sait, pour un canton de transition, faire la sélection entre les 2 paca9685 encadrants
- la possibilité d'une alternative aux pca9685 (donc pertinente si le nombre de cantons excède 16) à bases de célèbres 74hc595, disponibles en modules tout-fait

les posts qui suivent ont été transférés du sujet "Problème pour utiliser l'horloge externe du PCA9685"