Achszähler von Gerd Kruse

[fbstr]

Entwurf - Bitte noch nicht auf diesen Post antworten!
Das wird noch ein paar Tage/ Wochen dauern bis ich alles hier zusammengetragen habe.
Also bitte erstmal die Füße stillhalten


Achszähler von Gerd Kruse

Es begann beim Grillfest 2020 vom Stummi-Treff in Winnenden, wo Andreas seine super restaurierte Händleranlage präsentierte.


Beim Beobachten des funktionierenden Bahnübergangs bekam ich Mitleid mit den Preiserleins, die nur den Bruchteil einer Sekunde Zeit haben das ganze zu überleben...


Ich habe ja selber keine Anlage, aber das Interesse war geweckt eine Lösung zu finden wie man das umsetzen könnte: Die Schranken früher zu schließen, aber nach dem Passieren diese sofort zu öffnen, damit die Preiserleins nicht unnötig ihre Lebenszeit vergeuden müssen.

Was ich so bei anderen Anlagen beobachtete waren symmetrische Rückmeldeabschnitte, wodurch die Schranken unnötigerweise unten blieben während der Zug schon längst an der Schranke vorbei war.

Zwei Jahre später bin ich auf den Youtube-Kanal von Gerhard Kruse gestoßen ( https://www.youtube.com/@Modellbahn-Achszaehler )
wo er am 20.11.2020 das erste Video zu dem Thema gepostet hat und inzwischen auf stolze 65 Beiträge gewachsen ist.

Der Achszähler besteht aus 3 Komponenten:

1. Achszählpunkt: Das Gleis mit der Gabellichtschranke (oder ähnlichem), welches ein analoges Signal erzeugt.
2. Achszählkreis: Die Platine "AZPOpto" welche die analogen in digitale Signale umwandelt.
3. Achszählrechner: Der Arduino Nano - die Version "Arduino2" hat 2 Quadraturzähler und auch einen Differenzzähler integriert.

-----------

Im Dezember 2022 ging es dann bei mir los. Zuerst mittels Gabellichtschranke (Sharp GP1S097HCZ0F) je einen Achszählpunkt in zwei Trix C-Gleise gebastelt.


Mit RP25 Radsätzen hatte ich Probleme. Das vorsichtige Abschleifen der 2 zusammengeklebten Gabellichtschranken brachte eine Verbesserung:


Mit 2 Arduinos von Gerd, 3 Achszählpunkte und damit 2 Achszählkreise wurde hiermit erstmal getestet:


Dies war der Zwischenstand vor 3 Jahren und nur für 1 Richtung. Man kann hier im Video erkennen, dass es während den gesamten 7 Minuten keine einzige Fehlzählung gab.


Beim LTE 2023 wurde das dann präsentiert.


Die Umsetzung des eingleisigen Bahnübergangs für beliebige Richtungen stelle ich mir damit folgendermaßen vor:

Ich benötige also 3 Arduino Nanos, 4 Gleise mit Gabellichtschranken und die 2 AZPOpto-Platinen.


Und was soll das ganze hier im MobaLedLib-Forum?

Nun, hier wartet das neue Achszähler-Brett incl. Rangierschalter für den eingleisigen Bahnübergang seit Anfang 2023.





Ich denke man kann erkennen warum...

more to follow

[fbstr]

Arduino Uno Sketch mit LCD Anzeige

Code: Alles auswählen

#include <LiquidCrystal_I2C.h>        	// benutzt externe Software-Bibliotheken Programm einzubinden                                    
#include <Wire.h>                     	// Wire.h – Library für I2C
  LiquidCrystal_I2C lcd(0x27,16,2);   	// 16 Zeichen in 2 Zeilen und der HEX-Adresse 0x27  
#include <EEPROM.h>                   	// benutzt externe Software-Bibliotheken Programm einzubinden                              
  int z1;                    			// Variablenkennzeichen  Zähler1   AZP 1
  int z2;                    			// Variablenkennzeichen  Zähler2   AZP 2
  int a;                     			// Achsen im Bereich 
  int r=0;                   			// Richtung 
  int s=0;                   			// Schalter für 12+13
  int x=10;                 			// Speicher Adresse Zähler 1
  int y=11;                 			// Speicher Adresse Zähler 2
  int z=12;                 			// Speicher Schalter
  const int ledPin1 =  5;				// die Nummer des LED-Pins: Blinklicht
  const int ledPin2 =  6;
  int ledState1 = LOW;             
  int ledState2 = HIGH;
  unsigned long previousMillis = 0;     // speichert das letzte Mal, als die LED aktualisiert wurde
  const long interval = 800;            // Intervall zum Blinken (Millisekunden)
     
  void setup()
  {
// Serial.begin(9600);
 z1 = EEPROM.read(x);                   // Speicher Adresse 0         
 z2 = EEPROM.read(y);                   // Speicher Adresse 1 
  s =  EEPROM.read(z);  
  r=0;                                  // Variable für Richtungsanzeige
   
  lcd.init();                           // Programmstart einmal ausgeführt enthält alle Initialisierungen
  lcd.backlight();    
  pinMode(2, INPUT);                    // Eingang Interrupt 1   AZP 1-A
  pinMode(3, INPUT);                    // Eingang Interrupt 2   AZP 2-A
  pinMode(4, INPUT);                    // Für manuelle Rückstellung
  pinMode(5, OUTPUT);                   // LED Warnblinklicht
  pinMode(6, OUTPUT);                   // LED Warnblinklicht
  pinMode(7, OUTPUT);                   // Freimeldung
  pinMode(8, OUTPUT);                   // Belegtmeldung – auch bei Minus Achsen (!=0) ungleich 0
  pinMode(9, OUTPUT);                   // Bezugsrichtung falsch – Minus Achsen
  pinMode(10, INPUT);                   // Eingang               AZP 1-B
  pinMode(11, INPUT);                   // Eingang               AZP 2-B
  pinMode(12, OUTPUT);                  // Richtungsausgang
  pinMode(13, OUTPUT);                  // Richtungsausgang

  
  attachInterrupt(digitalPinToInterrupt(2),Funktion1,CHANGE);   //Interrupt Pin 2
  attachInterrupt(digitalPinToInterrupt(3),Funktion2,CHANGE);   //Interrupt Pin 3
  
    }
  void loop()
  {
 
  unsigned long currentMillis = millis();
  if (currentMillis - previousMillis >= interval)
  {
  previousMillis = currentMillis;
  if (ledState1 == LOW)
  {
   ledState1 = HIGH;
   ledState2 = LOW;
   } 
   else
   {
   ledState1 = LOW;
   ledState2 = HIGH;
   }
   }  

  //Serial.print(a);Serial.print("    ");Serial.print(a/2);Serial.print("    ");Serial.print(z1);Serial.print("    ");Serial.println(z2);

  if(a/2 != 0) 
  digitalWrite(ledPin1, ledState1);     	//Setzen Sie die LED mit dem LED-Status der Variablen
  if(a/2 != 0)
  digitalWrite(ledPin2, ledState2);
  if(a/2 ==0) 
  digitalWrite(5,LOW);                      // kein Blinken
  if(a/2 ==0) 
  digitalWrite(6,LOW);                      // kein Blinken
  if(a/2 == 0)
  digitalWrite(7,HIGH);                     //Ausgang Freimeldung
  else
  digitalWrite(7,LOW);  
  if(a/2 !=0)                               // auch Belegtmeldung bei Ungleich-Minusachsen-Störung
  digitalWrite(8,HIGH);                     // Ausgang Belegtmeldung
  else
  digitalWrite(8,LOW);
  if(a/2 <0)    
  digitalWrite(9,HIGH);                     // Ausgang Bezugsrichtung Fehler Störung  Minusachsen
  else
  digitalWrite(9,LOW); 
  if(s==1)    
  digitalWrite(12,HIGH);                     //A usgang Schaltsignal rechts
  else
  digitalWrite(12,LOW);
  if(s==2)    
  digitalWrite(13,HIGH);                     // Ausgang Schaltsignal links
  else
  digitalWrite(13,LOW);
 

  a=z1-z2;                                    // Achsen zwischen AZP1 und AZP2
 if((a)==0) r=(0);                            // Richtung löschen bei 0 Achsen
   
  if (digitalRead(4) == HIGH)                 // Wenn auf der Eingangsleitung des Tasters HIGH anliegt 
  {(z1=-1000);(z2=-1000);(r=0);}              // z1 und z2 auf -1000 setzen  warum ?????

  
 lcd.setCursor(0,0);                          // Zeile 1  Stelle 1
 lcd.print(" Achsz\341hlkreis  ");            // \341  ist ein ä                          
 lcd.setCursor(0,1);                          // Zeile 2  Stelle 1 


if(a<0)                                       // Wenn a kleiner 0 Minusachsen dann schreibe Störung
 lcd.print("    St\357rung             ");

                    
 lcd.print("   ");                            // Leerzeichen 
 lcd.print(a/2);                              // Achsen im Zählkreis   
 lcd.print("    ");                           // Leerzeichen  
if(r==1)    
 lcd.print("links");                          // Richtung 1 rechts -- 2  links 
 if(r==2)    
 lcd.print("rechts");                                                              
if(r==0)    
 lcd.print("      "); 


lcd.print("    ");                            // Leerzeichen  

 EEPROM.update(x, z1);                        // Eprom beschreiben bei Änderung von Zähler1 
 EEPROM.update(y, z2);                        // Eprom beschreiben bei Änderung von Zähler2  
 EEPROM.update(z, s);                         // Änderung von Schalter
   
                       
 }
     void Funktion1()
   {
   if(digitalRead(2) != digitalRead(10))
   {(z1--);(r=2);(s=2);}                      // r=Richtung   s=Schalter
   else
   {(z1++);(r=1);(s=1);}
   
 a=z1-z2;                                     // Achsen zwischen AZP1 und AZP2
 if((a/2)==0) r=(0); 
   
   } 
    
   void Funktion2()
   {
   if(digitalRead(3) != digitalRead(11))
   {(z2--);(r=2);(s=2);}
   else
   {(z2++);(r=1);(s=1);}

   a=z1-z2;                                   // Achsen zwischen AZP1 und AZP2
 if((a/2)==0) r=(0); 
 
   }     

[fbstr]

AZPOptoIn_2 Platine





Bauteile:
Reichelt Warenkorb: https://www.reichelt.de/my/2333599

Bauteil	Wert	Reichelt Bezeichnung
R1, R2, R6, R7	100k	METALL 100K
R3, R4, R5, R8, R9, R10	1K	METALL 1,00K
C1, C2	100nF	Z5U-5 100N
D1, D3	LED 3mm rot	LED 3MM RT
D2, D4	LED 3mm grün	LED 3MM GN
4x 3mm LED-Abstandshalter Höhe 5mm		MEN 2818.3045
IC1, IC3	Inverter	MOS 40106
IC2, IC4	Optokoppler	LTV 827
2x IC Fassungen 14pol		GS 14
2x IC Fassungen 8pol		GS 8
J1, J4	Stiftleiste + Steckbare Schraubklemme 3-pol (statt 4pol) RM 3,5mm,	CTB922HD-3 + CTB932HD-3
J2, J3, J5	5x Leiterplattenklemme 2 polig, RM 3,5 mm	DG350 3,5-2

[fbstr]

Gabellichtschranke Sharp GP1S097HCZ0F



Pro Trix C-Gleis mit Achszählpunkt
https://www.reichelt.de/my/2338709

Bauteil	Wert	Reichelt Bezeichnung
2x Gabellichtschranke	Sharp GP1S097HCZ0F	GP1S097HCZ0F
R	1k	METALL 1,00K
C	33µF, 35V	RAD LXZ 35/33
D	1N4001	1N 4001

[fbstr]

Gabellichtschranke TCUT1300X01

https://www.digikey.de/de/products/deta ... 01/1681174
Ali 7.2.2023

[fbstr]

Gabellichtschranke PT17-21B-L41-TR8
Ali (30 Stück) 7.11.2023

[fbstr]

ESP32 Sketch mit LCD Display

Code: Alles auswählen

#include <LiquidCrystal_I2C.h>       // benutzt externe Software-Bibliotheken Programm einzubinden           
#include <Wire.h>                    // Wire.h – Library für I2C
LiquidCrystal_I2C lcd(0x27,20,4);    // 16 Zeichen in 2 Zeilen und der HEX-Adresse 0x27 
     
long z11 = 0;                      //  Variablenkennzeichen  Quadraturzähler 1   E1 E2
long z12 = 0;                      //  Variablenkennzeichen  Quadraturzähler 2   E1 E2
int a1=0;                          //  Achsen im Zählkreis 1  
  
long z21 = 0;                      //  Variablenkennzeichen  Quadraturzähler 1   E1 E2
long z22 = 0;                      //  Variablenkennzeichen  Quadraturzähler 2   E1 E2
int a2=0;                          //  Achsen im Zählkreis 2      

long z31 = 0;                      //  Variablenkennzeichen  Quadraturzähler 1   E1 E2
long z32 = 0;                      //  Variablenkennzeichen  Quadraturzähler 2   E1 E2
int a3=0;                          //  Achsen im Zählkreis 3  
  
long z41 = 0;                      //  Variablenkennzeichen  Quadraturzähler 1   E1 E2
long z42 = 0;                      //  Variablenkennzeichen  Quadraturzähler 2   E1 E2
int a4=0;                          //  Achsen im Zählkreis 4 

void setup()

{
lcd.init();                          // Programmstart einmal ausgeführt enthält alle Initialisierungen
lcd.backlight();                     // Display Hintergrundbeleuchtung aktivieren

pinMode(16,INPUT_PULLDOWN);          // 3 Eingänge für 4 manuelle Rückstellungen           
pinMode(4,INPUT_PULLDOWN);           // 4 Taster mit 3 Dioden schalten an +
pinMode(2,INPUT_PULLDOWN);           // die Eingänge haben 10K  Pulldown an GND

// Zählkreis 1 
pinMode(36,INPUT);                                  // Eingang        E2  kein int. PULLUP möglich
pinMode(39,INPUT);                                  // Eingang        E1  kein int. PULLUP möglich
pinMode(34,INPUT);                                  // Eingang        E2  kein int. PULLUP möglich
pinMode(35,INPUT);                                  // Eingang        E1  kein int. PULLUP möglich
pinMode(1, OUTPUT);                                 // Belegtmeldung               
attachInterrupt(digitalPinToInterrupt(36),Funktion1,CHANGE); 
attachInterrupt(digitalPinToInterrupt(34),Funktion2,CHANGE); 

// Zählkreis 2
pinMode(32,INPUT_PULLUP);                           // Eingang                          E2   
pinMode(33,INPUT_PULLUP);                           // Eingang                          E1 
pinMode(25,INPUT_PULLUP);                           // Eingang                          E2          
pinMode(26,INPUT_PULLUP);                           // Eingang                          E1          
pinMode(0, OUTPUT);                                 // Belegtmeldung                          
attachInterrupt(digitalPinToInterrupt(32),Funktion3,CHANGE); 
attachInterrupt(digitalPinToInterrupt(25),Funktion4,CHANGE);

// Zählkreis 3 
pinMode(27,INPUT_PULLUP);                           // Eingang                          E2   
pinMode(14,INPUT_PULLUP);                           // Eingang                          E1 
pinMode(23,INPUT_PULLUP);                           // Eingang                          E2        
pinMode(13,INPUT_PULLUP);                           // Eingang                          E1        
pinMode(12,OUTPUT);                                 // Belegtmeldung                          
attachInterrupt(digitalPinToInterrupt(27),Funktion5,CHANGE); 
attachInterrupt(digitalPinToInterrupt(23),Funktion6,CHANGE); 

// Zählkreis 4
pinMode(19,INPUT_PULLUP);                           // Eingang                          E2   
pinMode(18,INPUT_PULLUP);                           // Eingang                          E1 
pinMode(5,INPUT_PULLUP);                            // Eingang                          E2         
pinMode(17,INPUT_PULLUP);                           // Eingang                          E1         
pinMode(15,OUTPUT);                                 // Belegtmeldung    mit ext.10KOhm PULLUP                  
attachInterrupt(digitalPinToInterrupt(19),Funktion7,CHANGE); 
attachInterrupt(digitalPinToInterrupt(5),Funktion8,CHANGE);
}
void loop()
{

// Zählkreis 1
if(a1/2 !=0)    
digitalWrite(1,LOW);                                //Ausgang Belegtmeldung
else
digitalWrite(1,HIGH);
a1=z11-z12;                                         // Achsen zwischen AZP1 und AZP2
if (z11==z12) {z11=0; z12=0;}                       // Rückstellung nach Durchlauf der beiden AZP
if ((digitalRead(16) == HIGH)and (digitalRead(4) == LOW) and(digitalRead(2) == LOW))                             
{(z11=0);(z12=0);}                                  // z11 und z12 auf 0 setzen 

// Zählkreis 2
if(a2/2 !=0)    
digitalWrite(0,LOW);                                //Ausgang Belegtmeldung
else
digitalWrite(0,HIGH);
a2=z21-z22;                                         // Achsen zwischen AZP1 und AZP2
if (z21==z22) {z21=0; z22=0;}                       // Rückstellung nach Durchlauf der beiden AZP
if ((digitalRead(16) == LOW)and (digitalRead(4) == HIGH)and (digitalRead(2) == LOW))                             
{(z21=0);(z22=0);}                                  // z21 und z22 auf 0 setzen 

// Zählkreis 3
if(a3/2 !=0)    
digitalWrite(12,LOW);                               //Ausgang Belegtmeldung
else
digitalWrite(12,HIGH);
a3=z31-z32;                                         // Achsen zwischen AZP1 und AZP2
if (z31==z32) {z31=0; z32=0;}                       // Rückstellung nach Durchlauf der beiden AZP
if ((digitalRead(16) == HIGH)and (digitalRead(4) == HIGH)and (digitalRead(2) == LOW))                             
{(z31=0);(z32=0);}                                  // z31 und z32 auf 0 setzen 

// Zählkreis 4
 if(a4/2 !=0)    
 digitalWrite(15,LOW);                                         //Ausgang Belegtmeldung
 else
 digitalWrite(15,HIGH);
 a4=z41-z42;                                                        // Achsen zwischen AZP1 und AZP2
 if (z41==z42) {z41=0; z42=0;}                             // Rückstellung nach Durchlauf der beiden AZP
 if ((digitalRead(16) == HIGH)and (digitalRead(4) == HIGH)and  (digitalRead(2) == HIGH))                            
 {(z41=0);(z42=0);}                                               // z41 und z42 auf 0 setzen 

  
 lcd.setCursor(0,0);                                   // Zeile 1  Stelle 1
 lcd.print("  Z\xE1\hlkreise");        // \xE1\  ist ein ä
 lcd.setCursor(0,1);                                  // Zeile 2  Stelle 1 
 lcd.print("");                                            // Leerzeichen 
 

if((a1/2) >=(0))                   // wenn größer oder 0 schreibe Wert der Achsen
 lcd.print(a1/2);                               
 else
 lcd.print("X");                  // schreibe X   Störung 
 lcd.print("   ");

if((a2/2) >=(0))                   // wenn größer oder 0 schreibe Wert
 lcd.print(a2/2);                               
 else
 lcd.print("X");                  // schreibe X   Störung 
 lcd.print("   ");

 if((a3/2) >=(0))                   // wenn größer oder 0 schreibe Wert
 lcd.print(a3/2);                               
 else
 lcd.print("X");                  // schreibe X  Störung 
 lcd.print("   ");

if((a4/2) >=(0))                   // wenn größer oder 0 schreibe Wert
 lcd.print(a4/2);                               
 else
 lcd.print("X");                  // schreibe X   Störung 
 lcd.print("   ");
                    
 }

  
    void Funktion1()
   {
   if(digitalRead(36) != digitalRead(39))
   z11--;
   else
   z11++;
   } 
    
   void Funktion2()
   {
   if(digitalRead(34) != digitalRead(35))
   z12--;
   else
   z12++;
   } 
       
 void Funktion3()
   {
   if(digitalRead(32) != digitalRead(33))
   z21--;
   else
   z21++;
   } 
    
   void Funktion4()
   {
   if(digitalRead(25) != digitalRead(26))
   z22--;
   else
   z22++;
   }     

void Funktion5()
   {
   if(digitalRead(27) != digitalRead(14))
   z31--;
   else
   z31++;
   } 
    
   void Funktion6()
   {
   if(digitalRead(23) != digitalRead(13))
   z32--;
   else
   z32++;
   }     
void Funktion7()
   {
   if(digitalRead(19) != digitalRead(18))
   z41--;
   else
   z41++;
   } 
    
   void Funktion8()
   {
   if(digitalRead(5) != digitalRead(17))
   z42--;
   else
   z42++;
   }