Voir les contributions

Cette section vous permet de consulter les contributions (messages, sujets et fichiers joints) d'un utilisateur. Vous ne pourrez voir que les contributions des zones auxquelles vous avez accès.


Messages - bobyAndCo

Pages: [1] 2 3 ... 76
1
Vos projets / Re : Commande de servo pour sémaphore avec ATtiny13
« le: juin 13, 2025, 07:34:55 pm »
Absolument génial !!!

Eric, tu es un champion.

Plein de bonnes idées, un vrai projet ferroviaire complet et utile. Comme toi je m'intéresse de plus en plus aux ATTiny qui permettent de faire plein de choses et qui sont très économiques. Tu démontres par ailleurs qu'il n'y a pas à s'effrayer des versions CMS.

Et alors le coup de faire réaliser ses plaques de laiton en République Tchèque, chapeau !!! Là aussi tu apportes une vraie nouveauté pour nos réseaux.

Ca mériterait d'être reproduit sous forme d'article pour améliorer la lisibilité et que cela soit également plus exposé. Les fils du forum ont tendance à être plus vite oubliés.

Encore bravo

Christophe


2
Vos projets / Re : Identification des trains par infrarouge
« le: juin 08, 2025, 05:05:48 pm »
Bonjour à tous,

J'ai reçu des PCB en quantités industrielles puisque j'ai fait la panélisation à partir de 100 x 100 !

Je peux céder à qui est intéressé des pcb nus ou avec les composants montés selon vos souhaits.

Contactez-moi en MP.

Christophe








3
Vos projets / Re : Identification des trains par infrarouge
« le: juin 05, 2025, 08:40:48 pm »
Merci Fantasio pour ton appréciation.

Pourquoi constexpr ? Tout d'abord, le c++ est un langage vivant et qui évolue contrairement à ce que pensent certains. l'utilisation de constexpr apparue avec c++11 (je crois) et peut maintenant répondre à plusieurs usages. Mais dans le cas où je l'ai utilisé, c'est principalement pour le substituer aux #define. C'est plus performant, tout d'abord pacque la constante est typée contrairement au #define.

constexpr vs const ? : Dans le premier cas, est évalué à la compilation (comme #define) alors que const est évalué à l'execution. Il est possible d'écrire const uint16_t a = getTaille();

Dans mon cas, je l'utilise à 99% des cas pour remplacer #define.

Christophe

4
Vos projets / Re : Identification des trains par infrarouge
« le: juin 02, 2025, 02:09:34 pm »
Bonjour à tous,

Pour info, j'ai publié un article assez exhaustif sur ce sujet : https://www.locoduino.org/spip.php?article370

Les questions ou les compléments f'information peuvent continuer à être publiés sur ce fil.

Christophe

5
Vos projets / Re : Projet partagé d'un gestionnaire de réseau
« le: mai 28, 2025, 12:17:40 pm »
Bonjour Dominique,

J'ai regardé le code que tu as mis à disposition juste avant.

Je comprends bien que cela correspond aux premières ébauches de code et que tout cela sera affiné au fur et à mesure. Je pense par exemple à "struct Train" qui pourrait facilement être transformée en classe, placée dans un fichiers spécifique. Tu gagneras en longueur de code et en lisibilité.

J'ai deux erreurs de compilation (bloquantes chez moi) :

La première, : warning: 'DynamicJsonDocument' is deprecated: use JsonDocument instead semble dire que tu as recours à une syntaxe qui est dépréciée.

La seconde : warning: iteration 3 invokes undefined behavior. Cela concerne
for (int i = 0; i < MAX_AIGUILLAGES; i++) {
    aiguillages.nom[i][0] = '\0';
}

Probablement un problème d'allocation mémoire ou de pointeur. Ne faudrait-il pas plutot utiliser String (qui dispose de ses mécanismes internes de contrôle) que char.

C'est un bon début, je te souhaite bonne chance pour la suite.

Christophe



6
Présentez vous ! / Re : presentation
« le: mai 27, 2025, 05:21:22 pm »
Oui on peut concevoir soi-même une nouvelle motorisation surtout avec de trains Lego. Il y a de l'espace. Par ailleurs, il y a un nombre considèrable des moteurs qui peuvent donner totale staisfaction et pour des prix raisonnables.

Christophe.

7
Vos projets / Re : Identification des trains par infrarouge
« le: mai 20, 2025, 08:55:51 pm »
J'ai eu envie de me faire plaisir en cherchant à réduire autant que possible la taille de l'émetteur embarqué.

Du coup, je suis passé par l'option composants CMS et montage par JLCPCB (sauf l'ATtyny pour pouvoir le programmer).

La taille du composant est de 22 mm x 19 mm.

La led est minuscule et trouvera facilement sa place sous la locomotive ou un wagon.





J'ai aussi réalisé le code pour Raspberry Pi Pico pour lire jusqu'à 16 capteurs sous interruption et envoyer les données à Rocrail :

https://github.com/BOBILLEChristophe/identification_de_trains_infrarouge_38Khz/blob/main/IdTrainIr38KhzPicoRecepteur_multiInter/IdTrainIr38KhzPicoRecepteur_multiInter.ino



Christophe

8
Bonjour Gillou,

Le programme ne pose aucun problème. Il faut chercher du côté du matériel.

As-tu respecté le brochage spécifique sur un ATtiny ? Mais il devrait tout de même y avoir quelque chose en sortie.

| Broche physique | Nom ATtiny |
| ------------------ | ------------- |
| 5                      | PB0             |
| 6                      | PB1             |
| 7                      | PB2             |
| 2                      | PB3             |
| 3                      | PB4             |




Tu ne t'es pas trompé avec le câblage de l'ULN2803, la pin 9 est à la masse ?

L'ULN2803 inverse le signal :

INx = HIGH → OUTx = LOW (courant passe)
INx = LOW → OUTx = ouvert (pas de courant)

Essaye de brancher une seule led en direct sur une broche de l'ATtiny (hors ULN) pour voir si ça fonctionne. N'oublie pas de mettre une résistance toute fois. Au moins 200Ω et même 1KΩ si tu n'as que ça, il doit y avoir suffisamment de luminosité pour des tests.

D'une manière générale, il faut reprendre les tests pas à pas.

Christophe

9
Vos projets / Re : Identification des trains par infrarouge
« le: mai 13, 2025, 11:00:54 pm »
Bonsoir à tous,

En intégrant le fichier IRTimer.hpp (et juste celui là), le code de l'emetteur pour le Nano et pour l'ATtiny est maintenant le même.

J'ai fait les tests avec un ATtiny 45, les résultats sont là encore assez bluffants. Je crois que la qualité des composants VISHAY y est pour beaucoup et la modulation à 38 Khz aussi. J'ai regardé la datasheet du TSOP4838. C'est vraiment complet à l'intérieur pour filtre au mieux les signaux et garantir la qualité du traitement.

J'ai fait le Gerber pour l'ATtiny



Voici le code de l'emetteur qui est le même pour le Nano ou les ATtiny

#include <Arduino.h>

// Configuration du timer pour PWM IR
#  if defined(__AVR_ATmega328P__) || defined(__AVR_ATmega328PB__) || defined(__AVR_ATmega168__)
#define IR_USE_AVR_TIMER2  // Utilise Timer2 pour l'envoi (pin D3)
#define IR_SEND_PIN 3                   // Broche utilisée
#  elif defined(__AVR_ATtiny25__) || defined(__AVR_ATtiny45__) || defined(__AVR_ATtiny85__)
#define IR_SEND_PIN 4                   // Broche utilisée
#define IR_USE_AVR_TIMER_TINY1 // send pin = (pin 4) ATtiny25 / 45 / 85
#  endif

#define SEND_PWM_BY_TIMER  // Active le mode PWM matériel

#include "IRTimer.hpp"  // Part of Arduino-IRremote https://github.com/Arduino-IRremote/Arduino-IRremote.


constexpr uint8_t ID = 0xA5;            // Identifiant à envoyer
constexpr uint16_t BIT_DURATION = 250;  // Durée minimale d'un front en µs

// Envoie un octet codé via LED IR
void sendByte(uint8_t value) {
  for (int i = 7; i >= 0; i--) {        // MSB
    bool bit = (value >> i) & 0x01;
    if (bit) {
      // 1
      disableSendPWMByTimer();
      delayMicroseconds(BIT_DURATION);
      enableSendPWMByTimer();
      delayMicroseconds(BIT_DURATION);
    } else {
      // 0
      disableSendPWMByTimer();
      delayMicroseconds(BIT_DURATION * 2);
      enableSendPWMByTimer();
      delayMicroseconds(BIT_DURATION * 2);
    }
  }
  // Fin de trame
    disableSendPWMByTimer();
    delayMicroseconds(BIT_DURATION * 4);
    enableSendPWMByTimer();
    delayMicroseconds(BIT_DURATION * 4);
}

void setup() {
  pinMode(IR_SEND_PIN, OUTPUT);
  timerConfigForSend(38);   // Fréquence IR : 38 kHz
  disableSendPWMByTimer();  // Démarre éteint
}

void loop() {
  sendByte(ID);
}


Le Gerber est téléchargeable ci-dessous.

Christophe

10
Vos projets / Re : Identification des trains par infrarouge
« le: mai 12, 2025, 10:18:00 pm »
Voici le Gerber du récepteur.


11
Dans la dernière version de laBox (ou l'une des dernières) 0.3 c3, la sérigraphie des broches reportées sur le bord de la carte est complètement fausse. On se fait ch.er avec Catplus depuis 8 jours à comprendre pourquoi un montage fonctionnait chez moi et pas chez lui !!! La pin 35 sur le bord de la carte n'est absolument pas reliée à la pin 35 de l'ESP. Et il en va de même pour toutes les autres broches.

Grosse colère !





Christophe

12
Euuuh, là il faut me parler plus clair car je n'ai rien compris à ta question.

J'imagine qu'il faut reprendre le schéma de l'article "Détection RailCom© avec ESP32 (ou Arduino)" ?

De quel schéma parle t'on ? le schéma de la carte de détection Railcom ? Si tu souhaites réaliser des décodeurs Railcom, oui c'est mieux de repartir sur ce schéma en effet.

On peut intégrer directement un ESP32 sur la carte (1 ESP32 correspond à 1 détecteur avec ce sketch) ?

Une fois encore, de quelle carte parles tu ? De la carte de détection Railcom ? Si c'est le cas, ce n'est pas vraiment le bon principe. Sachant qu'un ESP32 peut collecter les données de 3 détecteurs, il faudrait alors redessiner une carte à 3 détecteurs et 1 ESP pour le traitement.

Pour moi, le meilleur concept est de considérer le détecteur Railcom comme un détecteur comme un autre, IR, effet Hall, etc.. et d'utiliser les satellites comme organe central de collecte de toutes les infos. C'est le cas sur les satellites autonome qui font plein d'autres choses que de collecter Railcom. https://www.locoduino.org/spip.php?article348

Sur quelle broche UART doit être connectée la sortie Railcom avec ce sketch ?

Comme dit sur le tableau ci-dessous, l'un ou l'autre des 3 UART peuvent être utilisés, ce pourquoi j dis qu'il est possible d'implanter jusqu'à 3 détecteurs Railcom sur un seul ESP. Voici le programme qui permet cela : https://github.com/BOBILLEChristophe/Railcom-detector-freeRtos-inClass/blob/main/railcom_freeRtos_inClass.ino

UART Port   TX   RX   Remarks
UART0   GPIO 1   GPIO 3   Used for Serial Monitor and uploading code; Can be assigned to other GPIOs;
UART1   GPIO 10   GPIO 9   Must be assigned to other GPIOs
UART2   GPIO 17   GPIO 16   Can be assigned to other GPIOs

Christophe

13
Vos projets / Re : Identification des trains par infrarouge
« le: mai 11, 2025, 11:21:11 am »
Bonjour à tous,

J'ai lancé la fabrication chez JLCPCB pour 20 ex de la carte en version Nano, en choisissant la panélisation soit 5X4. Il y aura du rab pour ceux qui souhaitent essayer !



Voici les Gerber en PJ

Christophe

14
Bonjour Jean-Baptiste,

La réponse à ta question sur le retour d'infos Railcom dans Rocrail :

https://forum.locoduino.org/index.php?topic=1895.msg20936#msg20936

Christophe

15
Bonjour à tous,

Ce fil est principalement une réponse à Jean-Baptiste à sa question posée sur un autre fil.

Retour Railcom ou RFID ou IR dans Rocrail.

Faire remonter à Rocrail une information de détection à partir du réseau est assez simple. Mais on parle ici d’identification, on ne parle plus de données binaires comme dans le cas d’un capteur (HIGH – LOW) mais de plusieurs bits pouvant former 1 ou 2 octets dans le cas de l’adresse d’une locomotive. Car c’est bien l’adresse d’une locomotive que retourne le détecteur Railcom.

Dans Rocrail, on commence par créer un nouveau contrôleur

 

On choisit le protocole lan

 

Dans les réglages du protocole, on choisit un port ou on laisse le port proposé par défaut 8051,


 
Il faut redémarrer Rocrail pour qu’il prenne en compte la création de ce contrôleur

C’est tout côté Rocrail.

Le protocole lan de Rocrail est un peu verbeux et à mon sens un peu vieillot, mais bon ! Il utilise une syntaxe xml.

Voici un programme testé sur ESP32 (mais qui doit aussi fonctionner avec un Raspberry Pi WiFi ou un Arduino + Ethernet ou WiFi).

/*

   Programme de test pour envoi d'une adresse Railcom à Rocrail

   christophe.bobille 05/2025 - LOCODUINO - www.locoduino.org

*/


#include <WiFi.h>
#include <WiFiClient.h>
 
// === Configuration Wi-Fi ===
const char* ssid = "SSID";
const char* password = "PASSWORD";
 
// Adresse de Rocrail
const char* serverIP = "192.168.xxx.xxx";  // IP du PC avec Rocrail
const uint16_t serverPort = 8051;       // Port LAN configuré dans Rocrail
 
WiFiClient client;
 
void sendFB(const char* fbMsg) {
  String header = String("<xmlh><xml size="") + String(strlen(fbMsg)) + ""/></xmlh>";
  String fullMessage = header + String(fbMsg);
 
  client.print(fullMessage);
  Serial.println("Message envoyé :");
  Serial.println(fullMessage);
}
 
void setup() {
  Serial.begin(115200);
  delay(500);
 
  // === Connexion Wi-Fi ===
  Serial.print("Connexion à : ");
  Serial.println(ssid);
  WiFi.begin(ssid, password);
 
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("\nWi-Fi connecté !");
  Serial.print("Adresse IP : ");
  Serial.println(WiFi.localIP());
 
  // === Connexion à Rocrail ===
  Serial.print("Connexion à Rocrail : ");
  Serial.print(serverIP);
  Serial.print(":");
  Serial.println(serverPort);
 
  if (client.connect(serverIP, serverPort)) {
    Serial.println("Connexion TCP OK");
 
    // Activation du capteur avec RailCom
    const char* msgOn = "<fb id="sb2e" identifier="78" state="true" bididir="1" actor="user"/>";
    sendFB(msgOn);
 
    delay(2000);  // 2 secondes
 
    // Désactivation du capteur
    const char* msgOff = "<fb id="sb1e" identifier="0" state="false"/>";
    sendFB(msgOff);
 
    client.stop();
    Serial.println("Connexion fermée");
  } else {
    Serial.println("Connexion échouée");
  }
}
 
void loop() {}

Au début du programme, on renseignera les infos pour se connecter à notre box internet

// === Configuration Wi-Fi ===
const char* ssid = "SSID";
const char* password = "PASSWORD";

puis l’adresse IP de l’ordinateur qui héberge Rocrail puis le port d’écoute renseigné plus haut : 8051

const char* serverIP = "192.168.yyy.yyy";  // IP du PC avec Rocrail
const uint16_t serverPort = 8051;       // Port LAN configuré dans Rocrail

Ligne 59 du programme, c’est ici qu’il faut renseigner l’identifiant que l’on veut communiquer à Railcom

const char* msgOn = "<fb id="sb1e" identifier="78" state="true" bididir="1" actor="user"/>";
id est l’identifiant du capteur sur le tracé Rocrail
identifier l’adresse de la locomotive.
state indique bien sûr que le capteur est actif

Une fois le programme lancé, il doit se connecter au serveur lan de Rocrail et l’on doit voir apparaitre sur le plan le nom de la locomotive dans le block à droite l’identifiant du block dans la partie gauche juste après l’adresse de la locomotive.


 
N'hésitez pas pour toutes questions.

Christophe




 

Pages: [1] 2 3 ... 76