Auteur Sujet: Comptage des essieux  (Lu 9349 fois)

bobyAndCo

  • Global Moderator
  • Hero Member
  • *****
  • Messages: 1080
  • HO avec DCC++
    • Voir le profil
Comptage des essieux
« le: mai 12, 2024, 06:25:15 pm »
J'ouvre ce nouveau fil sur ce sujet qui a été lancé ailleurs par Brunotoutsimple mais qui mérite à mon avis d'être plus mis en avant et en lumière.

Je rappelle ici le lien sur la vidéo :



Il faut également regarder les autres vidéos de ce youtubeur elles aussi intéressantes et parfois complémentaires à la première.

La technique qui est proposée est certainement délicate mais réalisable par un modéliste aguerrit. De ce que j’en vois, c’est que la détection est parfaite et rapide.

Personnellement je ne vois pas pourquoi la technique du comptage des essieux, plus complexe, serait plus satisfaisante que la technique par détection de consommation de courant avec des wagons équipés de résistances ! Mais il ne s’agit pas d’une critique, juste de l’ignorance de ma part.

Au-delà de faire connaitre cette technique, ce fil aura le mérite de discuter de ce point et je l’espère, d’apporter des éclairages.

N’hésitez donc pas à faire par de vos expériences et commentaires.

Et merci à Bruno (Brunotoutsimple) pour cette très belle trouvaille.

Christophe
« Modifié: mai 12, 2024, 07:01:01 pm par bobyAndCo »

Dominique

  • Global Moderator
  • Hero Member
  • *****
  • Messages: 3037
  • 100% Arduino et N
    • Voir le profil
Re : Comptage des essieux
« Réponse #1 le: mai 13, 2024, 10:16:32 am »
Existe-t-il une version texte+images ?
Car le format vidéo n’est pas pratique pour comprendre cette technique.

Ça a l’air performant mais pour du HO seulement, ou je n’ai pas tout compris..
Cordialement,
Dominique

bobyAndCo

  • Global Moderator
  • Hero Member
  • *****
  • Messages: 1080
  • HO avec DCC++
    • Voir le profil
Re : Comptage des essieux
« Réponse #2 le: mai 13, 2024, 10:41:34 am »
Effectivement, c’est déjà minuscule pour le HO donc en N cela sera très difficile voire impossible.

J’ai un peu cherché mais je n’ai pas vu d’autres sources donc pas de version texte.

Il faut aussi regarder ses autres vidéos, il y a d’autres solutions proposées qui elles sont peut-être adaptables pour d’autres échelles.

J’ai noté qu’il détectait le sens de roulage selon que l’un ou l’autre des capteurs des activé en premier et qu’il décrémente le comptage si roulage en sens inverse.

Je profite pour reposer la question de savoir quels avantages particuliers y a-t-il à compter les essieux que les autres techniques de détection ne permettraient pas ?

Christophe

Jeje_12_34

  • Jr. Member
  • **
  • Messages: 95
  • Double ovale N
    • Voir le profil
Re : Comptage des essieux
« Réponse #3 le: mai 13, 2024, 10:56:38 am »
Bonjour Christophe

Je suis toujours néophyte .
Mais je consulte le forum quotidiennement, en sous marin, depuis 3 ans  :)
Et l'envie de m y remettre pour de bon me titille.

Pour répondre a ta question : peut être  parce que pour un parc matériel important, il serait fastidieux d'équiper tous les wagons ou de graphiter les essieux ?

Je pense a ca parce que ca m'effraie de le faire pour mes quelques matériel en N . Je n'ai pas trouvé de solution qui  me semble suffisamment facile.

Bonne Journée !
Le néophyte de service !
Adhérent AFAN

bobyAndCo

  • Global Moderator
  • Hero Member
  • *****
  • Messages: 1080
  • HO avec DCC++
    • Voir le profil
Re : Comptage des essieux
« Réponse #4 le: mai 13, 2024, 11:02:37 am »
@Jeje_12_34

Oui c’est une réponse intéressante. Néanmoins, il faut équiper chaque canton avec cette technique, ce qui est aussi assez lourd.

J’ai un article en cours qui va bientôt faire un petit tour d’horizon sur la pose de résistance sur des essieux. Ce n’est pas très fastidieux, même en N. Il n’est pas nécessaire d’équiper tous les wagons, seulement ceux qui peuvent se situer en fin de convoi.

Christophe

Dominique

  • Global Moderator
  • Hero Member
  • *****
  • Messages: 3037
  • 100% Arduino et N
    • Voir le profil
Re : Comptage des essieux
« Réponse #5 le: mai 13, 2024, 11:04:46 am »
A mon humble avis, le comptage des essieu n’est sert qu’à vérifier si un train à tous ses wagons ou en a perdu. Encore faut-il avoir enregistré le décompte attendu quelque part.

Ce n’est pas adapté à la détection de présence à cause des multiples détections.

Cela peut aussi servir à initialiser un train juste après sa composition en sortie d’une gare de triage.

C’est dommage qu’il n’existe pas de composant tout fait mais je n’ai pas regardé n’ayant pas vu les détails techniques de la chose.
Cordialement,
Dominique

bobyAndCo

  • Global Moderator
  • Hero Member
  • *****
  • Messages: 1080
  • HO avec DCC++
    • Voir le profil
Re : Comptage des essieux
« Réponse #6 le: mai 13, 2024, 11:17:16 am »
Oui je suis d’accord avec toi Dominique et c’est en cela que je trouve que c’est une technique lourde d’enregistrer le nombre d’essieux pour chaque convoi. Peu souple en cas de modification de compositions de convois. Cela nécessite aussi de maintenir une petite base de données, bref, je crois pas très souple.

Pour détecter si un ou des wagons se sont décrochés, la détection par consommation de courant du wagon de queue et cette technique apportent les mêmes réponses satisfaisantes.

Christophe

CATPLUS

  • Sr. Member
  • ****
  • Messages: 435
    • Voir le profil
Re : Comptage des essieux
« Réponse #7 le: mai 13, 2024, 05:28:52 pm »
Bonjour

Effectivement j'ai cherché un montage complet, hélas rien, uniquement l'émetteur & le receveur, c'est le montage qu'il a fabriqué.

Il me semble que l'un d'entre vous avait suggéré le comptage des roues en cas de perte ou de décrochage.
Cela peut être intéressant comme le souligne Dominique.

La chose que je trouve  impressionnante c'est la rapidité de l'ESP32 à traiter le calcul surtout à la vitesse ou train roule (dans d'autre vidéo le test est réalisé avec un Nano et cela fonctionne)

Christophe tu as raison rien ne peut remplacer la détection par consommation de courant.

Je continu à jeter un œil, il me semble qu'il faut creuser.






Best Regards

Dominique

  • Global Moderator
  • Hero Member
  • *****
  • Messages: 3037
  • 100% Arduino et N
    • Voir le profil
Re : Comptage des essieux
« Réponse #8 le: mai 13, 2024, 05:55:58 pm »
Il y a un bout de schéma dans sa vidéo mais c’est pas commode d’en tirer quelque chose.

Je ne comprends pas cette mode des tutos video qui pèsent beaucoup plus lourd en Mo qu’un article Locoduino bien plus instructif 😬
Bientôt sur TikTok ? 🤮
Cordialement,
Dominique

Brunotoutsimple

  • Jr. Member
  • **
  • Messages: 69
    • Voir le profil
Re : Comptage des essieux
« Réponse #9 le: mai 14, 2024, 02:24:42 am »
Bonjour à vous tous.
Je suis entrain de récupère les textes, les images, les schémas.
Donc voici déjà le code:
/*
Ce code concerne un compteur d'essieux ferroviaire miniature. Il y a quatre capteurs qui surveillent l'état des axes.
Chaque capteur lit une valeur analogique et vérifie si cette valeur est supérieure à 1000. Si oui, l'état du capteur est mis à 1, sinon à 0.
Lorsque l'état d'un capteur change, il est vérifié si le nouvel état correspond à celui du capteur suivant.
Si oui, le compteur de l'axe correspondant est décrémenté, sinon il est incrémenté.
La différence entre les compteurs des axes est calculée et si cette différence est nulle, la broche de sortie est réglée sur HIGH, sinon sur LOW.
Cela pourrait par exemple être utilisé pour envoyer un signal lorsque tous les axes d'un modèle ferroviaire ont dépassé le capteur.
*/

#include <Arduino.h>

// Voici le code commenté :

// Initialisation des variables
int a=0; // Etat du premier capteur
int b=0; // État du deuxième capteur
int c=0; // État du troisième capteur
int d=0; // État du quatrième capteur
int z1=0; // Compteur pour le premier axe
int z2=0; // Compteur pour le deuxième axe
int D1=0; // Différence entre le nombre d'essieux
int lastAl=1; // État précédent du premier capteur
int lastB1=1; // État précédent du second capteur
int lastC1=1; // État précédent du troisième capteur
int lastD1=1; // État précédent du quatrième capteur
int output=5; // Broche de sortie

void setup()
{
    // Définition des broches en entrée
    pinMode(36, INPUT); // premier capteur
    pinMode(39, INPUT); // deuxième capteur
    pinMode(34, INPUT); // troisième capteur
    pinMode(35, INPUT); // quatrième capteur

    // Définition des broches en sortie
    pinMode(5, OUTPUT); // Broche de sortie
}

void loop()
{
    // Lire les valeurs des capteurs
    int w1=analogRead(36); // Valeur du premier capteur
    int w2=analogRead(39); // Valeur du second capteur
    int w3=analogRead(34); // Valeur du troisième capteur
    int w4=analogRead(35); // Valeur du quatrième capteur
}

// Vérifie si la valeur du capteur est supérieure à 1 000 et définissez l'état en conséquence.
a=(w1<1000) ?0:1;
b=(w2<1000) ?0:1;
c=(w3<1000) ?0:1;
d=(w4<1000) ?0:1;

// Vérification si l'état du premier capteur a changé
if(a != lastA1)
    {
        if(a == b)
            {
                z1--; // Si l'état est égal à celui du deuxième capteur, décrémente le compteur
            }
        else
            {
                z1++; // Autrement, incrémentez le compteur
            }
        lastA1=a; // Mise à jour de l'état précédent
    }
lastB1=b: // Mise à jour de l'état précédent

// Vérifiez si l'état du troisième capteur a changé
if(c != lastC1)
    {
        if (c == d)
            {
                z2--; // Si l'état est égal à celui du quatrième capteur, décrémenter le compteur
            }
        else
            {
                z2++; // Ansonsten inkrementiere den Zähler
            }
        lastC1=c; // Mise à jour de l'état précédent
    }

lastD1=d; // Mise à jour de l'état précédent

D1=z1-z2; // Calcul la différence entre les compteurs d'axes

// Vérifie si la différence est nulle
if((D1) == 0)
    {
        digitalWrite(5,HIGH); // Si oui, réglez la broche de sortie sur HIGH
    }
else
    {
        digitalWrite(5,LOW); // Sinon, réglez la broche de sortie sur LOW
    }

Cordialement
Bruno
« Modifié: mai 14, 2024, 08:00:38 am par Brunotoutsimple »
Cordialement
Bruno

bobyAndCo

  • Global Moderator
  • Hero Member
  • *****
  • Messages: 1080
  • HO avec DCC++
    • Voir le profil
Re : Comptage des essieux
« Réponse #10 le: mai 14, 2024, 07:53:38 pm »
Je découvre une chose intéressante en lisant le code posté par Bruno. Dans ce code, on voit qu’il y a un comptage des essieux en entrée de zone et un autre comptage en sortie. Cela nécessite par contre deux doubles capteurs soit quatre en tout.

Il n’est donc pas nécessaire de connaitre à l’avance le nombre d’essieux du convoi. Le système détecte simplement si le nombre d’essieux en sortie est égal ou non avec le nombre calculé en entrée.

En cas de différence, le système envoie une alerte.

C’est assez astucieux !

Christophe

Brunotoutsimple

  • Jr. Member
  • **
  • Messages: 69
    • Voir le profil
Re : Re : Comptage des essieux
« Réponse #11 le: mai 15, 2024, 09:42:42 am »
Je découvre une chose intéressante en lisant le code posté par Bruno. Dans ce code, on voit qu’il y a un comptage des essieux en entrée de zone et un autre comptage en sortie. Cela nécessite par contre deux doubles capteurs soit quatre en tout.

Il n’est donc pas nécessaire de connaitre à l’avance le nombre d’essieux du convoi. Le système détecte simplement si le nombre d’essieux en sortie est égal ou non avec le nombre calculé en entrée.

En cas de différence, le système envoie une alerte.

C’est assez astucieux !

Christophe

Bonjour
 Non il faut juste un capteur de chaque extrémité d'un canton.
je suis entrain de dessiner cela.

Cordialement
Bruno

bobyAndCo

  • Global Moderator
  • Hero Member
  • *****
  • Messages: 1080
  • HO avec DCC++
    • Voir le profil
Re : Comptage des essieux
« Réponse #12 le: mai 15, 2024, 09:56:10 am »
Il y a en effet un capteur à chaque extrémité mais chaque capteur à bien deux leds comme on peut le voir sur la photo ou sur le schéma.

C'est aussi visible dans le code :


// Initialisation des variables
int a=0; // Etat du premier capteur
int b=0; // État du deuxième capteur
int c=0; // État du troisième capteur
int d=0; // État du quatrième capteur

« Modifié: mai 15, 2024, 10:01:48 am par bobyAndCo »

Brunotoutsimple

  • Jr. Member
  • **
  • Messages: 69
    • Voir le profil
Re : Re : Comptage des essieux
« Réponse #13 le: mai 15, 2024, 11:11:46 am »
Il y a en effet un capteur à chaque extrémité mais chaque capteur à bien deux leds comme on peut le voir sur la photo ou sur le schéma.

C'est aussi visible dans le code :


// Initialisation des variables
int a=0; // Etat du premier capteur
int b=0; // État du deuxième capteur
int c=0; // État du troisième capteur
int d=0; // État du quatrième capteur

Vu comme cela exactement. J'aurai dû ecrire comme ceci:
// Initialisation des variables
int a=0; // Etat de la Led 1 du premier capteur
int b=0; // Etat de la Led 2 du premier capteur
int c=0; // Etat de la Led 1 du Second capteur
int d=0; // Etat de la Led 2 du Second capteur
Voici le schéma du Capteur ainsi que le calcul de la résistance R1.
Après, il peut être fait autrement, je suis pas électronicien. Exemple donné pour un ESP32 mais vous pouvez mettre un autre microprocesseur type ATtiny414 ou autre
« Modifié: mai 15, 2024, 03:55:52 pm par Brunotoutsimple »
Cordialement
Bruno

Brunotoutsimple

  • Jr. Member
  • **
  • Messages: 69
    • Voir le profil
Re : Comptage des essieux
« Réponse #14 le: mai 15, 2024, 01:07:17 pm »
Bonjour à vous
Voici un autre programme pour faire fonctionner ce montage avec écran LCD pour vérifier le fonctionnement. Je n'ai pas le matériel pour le faire.

#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 20, 4);  // Initialisation de l'afficheur LCD - 20 chiffres 4 lignes
int Impulse;                         // Impulsions au point de lecture
int Axles;                          // sont des essieux / 4 ou des aimants

// Définir les broches pour les entrées analogiques
const int analogl = A0;
const int analog2 = A1;
const int analog3 = A2;
const int analog4 = A3;

int counter1 = 0;      // Compteur1 des valeurs incrémentales
int lastEncoded1 = 0;  // Dernière valeur encodée
int counter2 = 0;      // Compteur2 pour les valeurs incrémentales
int lastEncoded2 = 0;  // Dernière valeur encodée

// Barrières photoélectriques de 1-4
int LS1;
int LS2;
int LS3;
int LS4;

void setup() {
  Wire.begin();  // Initialise le bus I2C
  lcd.init();    // Initialise l'écran LCD
  lcd.backlight();
  Serial.begin(9600);  // Démarre la communication série
  pinMode(7, OUTPUT);  // La LED s'allume lorsqu'elle est occupée
  pinMode(8, OUTPUT);  // La LED s'allume lorsqu'elle est libre
}

void loop() {
  updateEncoder();
  // Lire la valeur entre 0 et 1023 sur l'entrée analogique A0
  // si plus petit à 20 => alors LS1 actif
  int Value1 = analogRead(analog1);
  if (Value1 < 20) LS1 = 1;
  else LS1 = 0;
  // Lire la valeur entre 0 et 1023 sur l'entrée analogique A1
  // si plus petit à 20 => alors LS2 actif
  int Value2 = analogRead(analog2);
  if (Value2 < 20) LS2 = 1;
  else LS2 = 0;
  // Lire la valeur entre 0 et 1023 sur l'entrée analogique A2
  // si plus petit à 20 => alors LS3 actif
  int Value3 = analogRead(analog3);
  if (Value3 < 20) LS3 = 1;
  else LS3 = 0;
  // Lire la valeur entre 0 et 1023 sur l'entrée analogique A3
  // si plus petit à 20 => alors LS4 actif
  int Value4 = analogRead(analog4);
  if (Value4 < 20) LS4 = 1;
  else LS4 = 0;

  if (Impulse != 0) {
    digitalWrite(7, LOW);
  } else {
    digitalWrite(7, HIGH);
  }
  if (Impulse == 0) {
    digitalWrite(8, LOW);
  } else {
    digitalWrite(8, HIGH);
  }
  Impulse = counter1 - counter2;  // Différence entre les Impulsions des capteurs
  Axles = Impulse / 4;           // Essieux ou magnette
  lcd.setCursor(0, 0);
  lcd.print("A0");
  lcd.print("   ");
  lcd.print("Al");
  lcd.print("   ");
  lcd.print("A2");
  lcd.print("   ");
  lcd.print("A3");
  lcd.setCursor(0, 1);
  lcd.print("   ");
  lcd.print(Value1);
  lcd.print("   ");
  lcd.print(Value2);
  lcd.print("   ");
  lcd.print(Value3);
  lcd.print("   ");
  lcd.print(Value4);
  lcd.setCursor(0, 2);
  lcd.print("Impulse  ");
  lcd.print(Impulse);
  lcd.print("   ");
  lcd.setCursor(0, 3);
  lcd.print("Axles   ");
  lcd.print(Axles);
  lcd.print("   ");
  Serial.println(Impulse);  // Affiche la lecture actuelle du compteur
  Serial.println(Axles);   // Affiche les essieux actuels
}

void updateEncoder()  // Mise à jour du compteur
{
  int encoded1 = (LS1 << 1) | LS2;  // Encode les deux signaux en une seule valeur << est l'opérateur de décalage de bit gauche
  int encoded2 = (LS3 << 1) | LS4;
  int sum1 = (lastEncoded1 << 2) | encoded1;                                             // Somme 1 de la valeur codée actuelle
  int sum2 = (lastEncoded2 << 2) | encoded2;                                             // Somme 1 de la valeur codée actuelle
  if (sum1 == 0b1101 || sum1 == 0b0100 || sum1 == 0b0010 || sum1 == 0b1011) counter1++;  // Compter
  if (sum1 == 0b1110 || sum1 == 0b0111 || sum1 == 0b0001 || sum1 == 0b1000) counter1--;  // Décompter
  if (sum2 == 0b1101 || sum2 == 0b0100 || sum2 == 0b0010 || sum2 == 0b1011) counter2++;  // Compter
  if (sum2 == 0b1110 || sum2 == 0b0111 || sum2 == 0b0001 || sum2 == 0b1000) counter2--;  // Décompter
  lastEncoded1 = encoded1;                                                               // Sauvegarde la valeur codée 1 actuelle
  lastEncoded2 = encoded2:                                                               // Sauvegarde la valeur codée 2 actuelle
}

/*
En mode comptage, les lignes responsables de l'affichage et de la sortie série doivent être verrouillées avec //.
Ils sont supprimés à des fins de tests.
*/

« Modifié: mai 18, 2024, 03:57:38 pm par Brunotoutsimple »
Cordialement
Bruno