Messages récents

91

Vos projets / Re : Identification des trains par infrarouge

« Dernier message par CATPLUS le mai 10, 2025, 09:16:38 pm »

Bonsoir Christophe
Bravo pour cette réalisation
Marcel

92

Vos projets / Re : Identification des trains par infrarouge

« Dernier message par bobyAndCo le mai 10, 2025, 04:42:08 pm »

Bonjour à tous,

J'ai embarqué dans un wagon le TSAL6400 + Arduino Nano + pont de diode + régulateur 5V + capa et diverses résistances.

J'avais un peu la flemme de programmer un ATtiny. De cette manière, ceux qui peuvent être rebutés par l’ATtiny constatent que c’est tout à fait réalisable avec un Nano.









Je crois que la vidéo parle d’elle-même. Je doute qu’aucun train ne circule jamais à cette vitesse et vous constaterez qu’il y a de la marge avec le nombre de captures à chaque passage !

Bon week-end à tous et bon train

Christophe

93

Vos projets / Re : Projet partagé d'un gestionnaire de réseau

« Dernier message par Pierre59 le mai 10, 2025, 10:59:08 am »

La version pure Json du gestionnaire paramètré par un fichier Json n'ayant pas fait l'unanimité, je vous propose une version objets. Le fichier Json est converti en objets et le gestionnaire fonctionne complètement en programmation objets. Le fichier Json est quasiment le même que pour la version précédente, seule la gestion des bretelles a été rajoutée. Le réseau géré est le Locoduinodrome2.

Dans les fichiers accompagnant il y a deux applications Processing, le gestionnaire "GestJA" et un TCO pour pouvoir faire des essais "GestTCO3". Pour essayer il faut d'abord lancer l'application GestTCO3, puis sur la même machine l'application GestJA (la communication entre les deux applications se faisant en TCP/IP il est possible d'utiliser deux machines en réseau). Il y a aussi une notice PDF décrivant l'organisation du gestionnaire et le fonctionnement du TCO (commandes des itinéraires, des trains, ...).

Il y a encore vraisemblablement des bugs dans le gestionnaire, notamment dans les itinéraires permanents et les signaux. D'autres versions suivrons.

Pierre

94

Vos projets / Re : Identification des trains par infrarouge

« Dernier message par Dominique le mai 09, 2025, 11:55:02 pm »

Pour l’alimentation à partir du DCC, un bout fil dénudé enroulé autour de l’essieu avant, côté + avec une diode en série; un autre bout de fil dénudé autour de l’essieu arrière retourné côté -; une capa de stockage et un regulateur : ça doit le faire !

95

Vos projets / Re : Identification des trains par infrarouge

« Dernier message par bobyAndCo le mai 09, 2025, 08:09:43 pm »

Merci Dominique.

De mon côté, je veux remercier Jean-Pierre (JPM06) d'avoir apporté ce sujet sur un autre outil d'identification à côté de Railcom et du RFID. Il y a beaucoup de côtés positifs dont la fiabilité et le cout très raisonnable.

Deux petites ombres au tableau toutefois : l'encombrement qui oblige à placer l'ensemble dans un wagon "suiveur" et la nécessité de s'alimenter sur la voie (DCC ou DC).

Christophe

96

Vos projets / Re : Identification des trains par infrarouge

« Dernier message par Dominique le mai 09, 2025, 07:51:18 pm »

👏 Bravo !

97

Vos projets / Re : Identification des trains par infrarouge

« Dernier message par bobyAndCo le mai 09, 2025, 07:35:43 pm »

Bonsoir à tous,

Heureusement pour moi, la journée se termine sur une note beaucoup plus positive que la presque totalité de ma journée. J'ai en effet passé de nombreuses heures à tenter de faire fonctionner la réception sur un ESP32 sans jamais parvenir à quelque chose de fiable. L'ESP me renvoyant de nombreuses erreurs de lecture sur les interruptions renvoyant donc des valeurs erronées.

Jusqu'à ce que je me décide à passer sur un Raspberry Pi Pico. Et là, oh merveille, tout c'est mis à fonctionner parfaitement du premier coup !!!



Jusqu'ici je n'avais réalisé que quelques projets avec le Raspberry. Ayant un peu la flemme de changer ma façon de coder. Mais là, je vais revoir mon approche et chercher à systématiser le Raspberry, plus puissant, moins cher, disposant de plus de broches qu'un ESP32 et au final plus fiable.

Voici le code (de test) du récepteur qui ne cherche qu'à afficher la valeur transmise au travers de la led et du TSOP.

Code: [Sélectionner]

#include <Arduino.h>
#include "pico/multicore.h"
#include "pico/util/queue.h"

volatile uint32_t duration = 0;

constexpr byte pinIn = 15;  // Broche du TSOP

bool receiving = false;
uint8_t currentByte = 0;
int8_t bitIndex = 7;

// File pour les bits détectés
queue_t durationQueue;

enum DecodeState {
  IDLE,
  RECEIVING
};
DecodeState currentState = IDLE;

void handleIR() {
  static uint32_t lastTime = 0;
  uint32_t now = micros();
  uint32_t duration = now - lastTime;
  lastTime = now;
  queue_try_add(&durationQueue, &duration);
}

void setup() {
  Serial.begin(115200);
  pinMode(pinIn, INPUT);
  // Initialisation de la queue pour 16 durées
  queue_init(&durationQueue, sizeof(duration), 16);
  attachInterrupt(digitalPinToInterrupt(pinIn), handleIR, RISING);
}

void loop() {
  uint32_t duration = 0;
  if (queue_try_remove(&durationQueue, &duration)) {
   
    switch (currentState) {

      case IDLE:
        if (duration > 1600 && duration < 2400) {
          // Début de trame détecté
          currentByte = 0;
          bitIndex = 7;
          currentState = RECEIVING;
        }
        break;

      case RECEIVING:

        if (duration >= 400 && duration <= 700) {
          // Bit 1
          currentByte |= (1 << bitIndex);
          bitIndex--;
        } else if (duration >= 800 && duration <= 1200) {
          // Bit 0
          currentByte &= ~(1 << bitIndex);
          bitIndex--;
        } else {
          // Durée invalide
          currentState = IDLE;
          break;
        }

        if (bitIndex < 0) {
          Serial.printf("Octet reçu : 0x%02X\n", currentByte);
          currentState = IDLE;
        }
        break;
    }
  }
}


Je n'ai aucune erreur et donc je ne pense pas nécessaire de mettre en place un mécanisme de contrôle. (checksum)

Je vais maintenant passer le code de l'emetteur sur un ATTiny (25/45/85) et dessiner des PCB pour toute la partie emission et réception. Je communiquerai les schémas dès que je les aurai réalisés.

Christophe

98

Vos projets / Re : Identification des trains par infrarouge

« Dernier message par bobyAndCo le mai 08, 2025, 08:03:25 pm »

Bonjour à tous,

Aujourd’hui, travail sur le codage des bits. J’ai retenu le principe qui est que un bit est toujours constitué d’un front montant et d’un front descendant de même durée (comme pour le DCC).



Un bit 1 a une durée de 560µs (2 x 280µs).



Un bit 0 a une durée de 1000µs (2 x 500µs).



Ls bits de synchro qui séparent les octets de données ont une durée de 2000µs environ (2 x 1 ms)



Voici par exemple représenté l’octet de data 0xAA qui est une alternance de 0 et de 1 10101010 pour une durée moyenne de 6 ms ce qui fait avec le bit de synchro plus de 100 envois par seconde.

Je précise que les copies d’écran correspondent à des mesures en sortie du TSOP4838. Vous pouvez constater que le signal est très propre.

Le code définitif pour l'émetteur, qui sera sur un ATTiny (25, 45 ou 85) est très simple mais j'ai repris le fichier IRTimer.hpp de IRremeote :

Code: [Sélectionner]


```cpp
#include <Arduino.h>

// Configuration du timer pour PWM IR
#define IR_USE_AVR_TIMER2              // Utilise Timer2 pour l'envoi (pin D3)
#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.

#define IR_SEND_PIN 3                   // Broche utilisée
constexpr uint8_t DATA = 0xAA;          // Octet à envoyer
constexpr uint16_t BIT_DURATION = 500;  // Durée d’un bit en µs

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

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

void loop() {
  sendManchesterByte(DATA);
}

```


Reste à tester maintenant avec le code sur le récepteur (ESP32) ce que j'espère pouvoir terminer rapidement. Cela permettra de voir s'il faudra ajouter un checksum pour vérifier la conformité de l'envoi.

Christophe

99

Vos projets / Re : Identification des trains par infrarouge

« Dernier message par bobyAndCo le mai 07, 2025, 07:10:38 pm »

Bonjour à tous,

Premiers tests aujourd’hui avec les composants tout juste reçus. Pour les leds émettrices, j’ai pris des TSAL6400 de VISHAY 5mm (0,31€ pièce) et comme récepteur le TSOP4838 de chez VISHAY également.

Premier constat, les performances sont assez stupéfiantes, aucun problème de distance et l’angle dans lequel le faisceau est actif est également assez stupéfiant ce qui peut permettre des mesures sur une durée assez longue.

Les signaux mesurés à l’oscillo à la sortie du TSOP4838 sont très propres. Pour les fronts les plus courts, je mesure environ 600µS ce qui devrait me permettre d’allonger les alternances telles que je les avais envisagées au départ (13µs !!!). Il y a de la marge.

Premiers résultats encourageants donc… à suivre

Christophe

100

JMRI et Arduino / Re : erreur 308 sur decoderpro

« Dernier message par nopxor le mai 06, 2025, 06:51:18 am »

Bonjour,
Pour DCC-EX et les problèmes de décodeur,il y a les diagnostics commands:
https://dcc-ex.com/support/troubleshooting-decoders.html#gsc.tab=0
Qui génèrent un log que tu peux fournir au discord de DCC-EX