Stellpult für Modellbahn

soli2014 · June 8, 2024, 12:19pm

Hallo Leute,

ich bin relativer Neuling in diesem Bereich habe jedoch schon einige Grundkenntnisse...

Ich wollte mich jetzt an mein EIGENES Projekt wagen und arbeite jetzt schon seit Wochen daran. Jedoch bekomme ich es nicht genau so hin wie ich es möchte.

Folgendes Szenario:

Wenn ich Zentraltaster links und Gleis 1 gemeinsam drücke, sollen die Neopixels zu Blinken beginnen. gleichzeitig sollen sich die Weichen 6 und 5 nacheinander stellen.... wenn dies passiert ist und die Endlagen beider Weichen passen dann soll das blinken in Dauerlicht übergehen.... ich habe es jetzt schon mal geschafft, dass es halbwegs funktioniert, ABER es stellt sich zuerst die erste Weiche und dann irgendwann fängt es zu blinken an .... dann sind alle Weichen in der Endlage aber es dauert sehr lange bis das Dauerlicht kommt...... bin echt am Verzweifeln ... vielleicht kann mir jemand helfen.


//------------------------------------------ Steuerung Stellpult Mariazellerbahn --------------------------------------------------------------
#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
  #include <avr/power.h>
#endif

int LEDs  =  6;                        //Anschluss Led Streifen
int numPixels =  93;                    //Anzahl der Leds
int pixelFormat = NEO_GRB + NEO_KHZ800;
Adafruit_NeoPixel *pixels;

#define DELAYVAL 100

//--------------------------------------------Taster am Stellpult------------------------------------------------------------
int zentraltaster_links = 2;                 //zentraler Taster linke Seite an Pin A0 angeschlossen
int zentraltaster_rechts = 3;                //zentraler Taster rechte Seite an Pin A6 angeschlossen

int taster_Gleis_1 = A0;                      //Taster Gleis 1, alle Weichen schalten MIT zugehörigem Zentraltaster von rechts oder links
int taster_Gleis_2 = A1;                      //Taster Gleis 2, alle Weichen schalten MIT zugehörigem Zentraltaster von rechts oder links
int taster_Gleis_3 = A2;                      //Taster Gleis 3, alle Weichen schalten MIT zugehörigem Zentraltaster von rechts oder links
int taster_Gleis_4 = A3;                      //Taster Gleis 4, alle Weichen schalten MIT zugehörigem Zentraltaster von rechts oder links
int taster_Gleis_5 = A4;                      //Taster Gleis 5, alle Weichen schalten MIT zugehörigem Zentraltaster von rechts oder links

//--------------------------------------------Weichen RECHTE SEITE-------------------------------------------------------------------
const int Weiche_1 = 22;                      //Relais (8fachModul) für Weiche 1 rechte Seite
const int Weiche_2 = 23;                      //Relais (8fachModul) für Weiche 2 rechte Seite
const int Weiche_3 = 24;                      //Relais (8fachModul) für Weiche 3 rechte Seite
const int Weiche_4 = 25;                      //Relais (8fachModul) für Weiche 4 rechte Seite

//--------------------------------------------Weichen LINKE SEITE---------------------------------------------------------------------
const int Weiche_5 = 50;                      //Relais (8fachModul) für Weiche 4 linke Seite
const int Weiche_6 = 51;                      //Relais (8fachModul) für Weiche 4 linke Seite
const int Weiche_7 = 52;                      //Relais (8fachModul) für Weiche 4 linke Seite
const int Weiche_8 = 53;                      //Relais (8fachModul) für Weiche 4 linke Seite

//--------------------------------------------Endlagen Weichen (Polarisiereungsanschlüsse am Motor)----------------------------------------
int Endlage_Weiche_1_links  = 26;             //wird wie Taster INPUT_PULLUP geschaltet (ist für Schalten der nächsten Weiche und wenn alle Weichen Endlage haben dann Leds)
int Endlage_Weiche_1_rechts = 27;                    
int Endlage_Weiche_2_links  = 28;
int Endlage_Weiche_2_rechts = 29;
int Endlage_Weiche_3_links  = 30;
int Endlage_Weiche_3_rechts = 31;
int Endlage_Weiche_4_links  = 32;
int Endlage_Weiche_4_rechts = 33;
int Endlage_Weiche_5_links  = 34;
int Endlage_Weiche_5_rechts = 35;
int Endlage_Weiche_6_links  = 36;
int Endlage_Weiche_6_rechts = 37;
int Endlage_Weiche_7_links  = 38;
int Endlage_Weiche_7_rechts = 39;
int Endlage_Weiche_8_links  = 40;
int Endlage_Weiche_8_rechts = 41;

//-----------------------------------------------Zeitdefinition--------------------------------------------------------------------
unsigned long currentMillis;
unsigned long previousMillis;
unsigned long CycleMillis;

//-----------------------------------------------Farbdefinition--------------------------------------------------------------------
uint32_t schwarz = pixels->Color(0, 0, 0);
uint32_t gelb = pixels->Color(5, 2, 0);
uint32_t gelb_blink = pixels->Color(2, 1, 0);
uint32_t rot = pixels->Color(10,0,0);


//--------------------------------------Fahrstrassen rechts blinken (einlaufen)---------------------------------------------------
bool Gleis_1_rechts_blinken = false; //Ein Aus interner Schalter
bool Gleis_2_rechts_blinken = false;
bool Gleis_3_rechts_blinken = false;
bool Gleis_4_rechts_blinken = false;
bool Gleis_5_rechts_blinken = false;

//--------------------------------------Fahrstrassen rechts Dauerlicht-----------------------------------------------------------
bool Gleis_1_rechts_dauer = false;
bool Gleis_2_rechts_dauer = false;
bool Gleis_3_rechts_dauer = false;
bool Gleis_4_rechts_dauer = false;
bool Gleis_5_rechts_dauer = false;

//--------------------------------------Fahrstrassen links blinken (einlaufen)-----------------------------------------------------
bool Gleis_1_links_blinken = false;
bool Gleis_2_links_blinken = false;
bool Gleis_3_links_blinken = false;
bool Gleis_4_links_blinken = false;
bool Gleis_5_links_blinken = false;

//-------------------------------------Fahrstrassen links Dauerlicht--------------------------------------------------------------
bool Gleis_1_links_dauer = false;
bool Gleis_2_links_dauer = false;
bool Gleis_3_links_dauer = false;
bool Gleis_4_links_dauer = false;
bool Gleis_5_links_dauer = false;

//--------------------------------------Fahrstrassen links------------------------------------------------------------------------
bool Fahrstrasse_Gleis_1_links = false;
bool Fahrstrasse_Gleis_2_links = false;
bool Fahrstrasse_Gleis_3_links = false;
bool Fahrstrasse_Gleis_4_links = false;
bool Fahrstrasse_Gleis_5_links = false;

//---------------------------------------------------Besetztmelder----------------------------------------------------------------
int reed_Gleis_1_ein = A5;
int reed_Gleis_1_aus = A6;
int reed_Gleis_2_ein = A7;
int reed_Gleis_2_aus = A8;
int reed_Gleis_3_ein = A9;
int reed_Gleis_3_aus = A10;
int reed_Gleis_4_ein = A11;
int reed_Gleis_4_aus = A12;
int reed_Gleis_5_ein = A13;
int reed_Gleis_5_aus = A14;

bool Gleis_1_besetzt = false;
bool Gleis_2_besetzt = false;
bool Gleis_3_besetzt = false;
bool Gleis_4_besetzt = false;
bool Gleis_5_besetzt = false;


void setup() {

  digitalWrite(Weiche_5, HIGH);
  digitalWrite(Weiche_6, HIGH);

  //--------------------------- Taster ----------------------------------------
  pinMode(zentraltaster_links, INPUT_PULLUP);
  pinMode(taster_Gleis_1, INPUT_PULLUP); //Taster ist immer HIGH und muss beim Drücken gegen GND gebrückt werden
  pinMode(taster_Gleis_2, INPUT_PULLUP);
  pinMode(taster_Gleis_3, INPUT_PULLUP);
  pinMode(taster_Gleis_4, INPUT_PULLUP);
  pinMode(taster_Gleis_5, INPUT_PULLUP);
  pinMode(zentraltaster_rechts, INPUT_PULLUP);

//-------------------------- Relais Weichen ---------------------------------
  pinMode(Weiche_1, OUTPUT);
  pinMode(Weiche_2, OUTPUT);
  pinMode(Weiche_3, OUTPUT);
  pinMode(Weiche_4, OUTPUT);
  pinMode(Weiche_5, OUTPUT);
  pinMode(Weiche_6, OUTPUT);
  pinMode(Weiche_7, OUTPUT);
  pinMode(Weiche_8, OUTPUT);

//------Endlagen der Weichen zum Weiterschalten nächste Weiche und zum Schluss Ausleuchtung ------
  pinMode(Endlage_Weiche_1_links, INPUT_PULLUP);
  pinMode(Endlage_Weiche_1_rechts, INPUT_PULLUP);
  pinMode(Endlage_Weiche_2_links, INPUT_PULLUP);
  pinMode(Endlage_Weiche_2_rechts, INPUT_PULLUP);
  pinMode(Endlage_Weiche_3_links, INPUT_PULLUP);
  pinMode(Endlage_Weiche_3_rechts, INPUT_PULLUP);
  pinMode(Endlage_Weiche_4_links, INPUT_PULLUP);
  pinMode(Endlage_Weiche_4_rechts, INPUT_PULLUP);
  pinMode(Endlage_Weiche_5_links, INPUT_PULLUP);
  pinMode(Endlage_Weiche_5_rechts, INPUT_PULLUP);
  pinMode(Endlage_Weiche_6_links, INPUT_PULLUP);
  pinMode(Endlage_Weiche_6_rechts, INPUT_PULLUP);
  pinMode(Endlage_Weiche_7_links, INPUT_PULLUP);
  pinMode(Endlage_Weiche_7_rechts, INPUT_PULLUP);
  pinMode(Endlage_Weiche_8_links, INPUT_PULLUP);
  pinMode(Endlage_Weiche_8_rechts, INPUT_PULLUP);

//---------------------------alle Weichen Grundstellung ----------------------


//--------------------------------Reed Kontakte------------------------------
  pinMode(reed_Gleis_1_ein, INPUT_PULLUP);
  pinMode(reed_Gleis_1_aus, INPUT_PULLUP);
  pinMode(reed_Gleis_2_ein, INPUT_PULLUP);
  pinMode(reed_Gleis_2_aus, INPUT_PULLUP);
  pinMode(reed_Gleis_3_ein, INPUT_PULLUP);
  pinMode(reed_Gleis_3_aus, INPUT_PULLUP);
  pinMode(reed_Gleis_4_ein, INPUT_PULLUP);
  pinMode(reed_Gleis_4_aus, INPUT_PULLUP);
  pinMode(reed_Gleis_5_ein, INPUT_PULLUP);
  pinMode(reed_Gleis_5_aus, INPUT_PULLUP);

//-----------------------------Neopixel Streifen im Stellpult----------------
  
  pixels = new Adafruit_NeoPixel(numPixels, LEDs, pixelFormat);
  pixels->begin(); 
}

void loop() {

  //------------------------------Fahrstrasse Gl. 1 links----------------------------

  if((digitalRead(zentraltaster_links) == LOW) && (digitalRead(taster_Gleis_1) == LOW))
  { 
    Fahrstrasse_Gleis_1_links = true;
    Fahrstrasse_Gleis_2_links = false;
  }

  if(Fahrstrasse_Gleis_1_links == true)
  {
    Gleis_1_links_blinken = true;
    delay(2000);
    digitalWrite(Weiche_6, LOW);
         delay(2000);
          digitalWrite(Weiche_5, LOW);
        
  
    if((digitalRead(Endlage_Weiche_5_links) == LOW) && (digitalRead(Endlage_Weiche_6_links) == LOW))
     {
      Gleis_1_links_blinken = false;
      Gleis_1_links_dauer = true;
      Gleis_2_links_dauer = false;
      Gleis_3_links_dauer = false;
      Gleis_4_links_dauer = false;
      Gleis_5_links_dauer = false;
     }
  }  

  if((Gleis_1_links_blinken == true) && (Gleis_1_besetzt == false))//---------nicht besetzt----------
    { 
      for(int i=0; i<3; i++)
       {
        delay(750);
        pixels->fill(gelb, 90, 3);
        pixels->fill(gelb, 81, 2);
        pixels->fill(gelb, 67, 12);
        pixels->show();
        
        
        delay(750);
        pixels->fill(schwarz, 90, 3);
        pixels->fill(schwarz, 81, 2);
        pixels->fill(schwarz, 67, 12);
        pixels->show();
       }
      }

    
    
  if((Gleis_1_links_blinken == false) && (Gleis_1_besetzt == false))
      {
        pixels->fill(schwarz, 90, 3);
        pixels->fill(schwarz, 81, 2);
        pixels->fill(schwarz, 67, 12);
        pixels->show();
      }

  if((Gleis_1_links_blinken == true) && (Gleis_1_besetzt == true)) //-------besetzt---------
    {
      for(int i=0; i<5 ; i++)
        {
        delay(750);
        pixels->fill(gelb, 90, 3);
        pixels->fill(gelb, 81, 2);
        pixels->show();
        
        
        delay(750);
        pixels->fill(schwarz, 90, 3);
        pixels->fill(schwarz, 81, 2);
        pixels->show();
        }
      }
      
    if((Gleis_1_links_blinken == false) && (Gleis_1_besetzt == true))
      {
        pixels->fill(schwarz, 90, 3);
        pixels->fill(schwarz, 81, 2);
        pixels->show();
      }
       
    if((Gleis_1_links_dauer == true) && (Gleis_1_besetzt == true)) //-------besetzt---------
      {
        for(int i=0; i<5; i+0)
        {
        pixels->fill(gelb, 90, 3);
        pixels->fill(gelb, 81, 2);
        pixels->show();
        }
      }
         
    if((Gleis_1_links_dauer == false) && (Gleis_1_besetzt == true))
      {
        pixels->fill(schwarz, 90, 3);
        pixels->fill(schwarz, 81, 2);
        pixels->show();
      }

    if((Gleis_1_links_dauer == true) && (Gleis_1_besetzt == false))
      {
        for(int i=0; i<5; i+0)
        {
        pixels->fill(gelb, 90, 3);
        pixels->fill(gelb, 81, 2);
        pixels->fill(gelb, 67, 12);
        pixels->show();
        }
      } 
        
    if((Gleis_1_links_dauer == false) && (Gleis_1_besetzt ==false))
      {
        
        pixels->fill(schwarz, 90, 3);
        pixels->fill(schwarz, 81, 2);
        pixels->fill(schwarz, 67, 12);
        pixels->show();
        
      }
       
  
//------------------------------Fahrstrasse Gl. 2 links----------------------------
  if((digitalRead(zentraltaster_links) == LOW) && (digitalRead(taster_Gleis_2) == LOW))
  {
    Fahrstrasse_Gleis_2_links = true;
    Fahrstrasse_Gleis_1_links = false;
  }
  if(Fahrstrasse_Gleis_2_links == true)
  {
    Gleis_2_links_blinken = true;
    delay(2000);
    digitalWrite(Weiche_7, HIGH);

          if(digitalRead(Endlage_Weiche_7_links) == LOW)
        {
          delay(2000);
          digitalWrite(Weiche_6, HIGH);
        }

      if(digitalRead(Endlage_Weiche_6_rechts) == LOW)
        {
          delay(2000);
          digitalWrite(Weiche_5, LOW);
        }

        if((digitalRead(Endlage_Weiche_6_rechts) == LOW) && (digitalRead(Endlage_Weiche_5_links) == LOW)  && (digitalRead(Endlage_Weiche_7_links) == LOW))
         {   
          Gleis_1_links_dauer = false;
          Gleis_2_links_dauer = true;
          Gleis_3_links_dauer = false;
          Gleis_4_links_dauer = false;
          Gleis_5_links_dauer = false;

          Gleis_2_links_blinken = false;

        
         }
  }

    if((Gleis_2_links_blinken == true) && (Gleis_2_besetzt == false))//---------nicht besetzt----------
     {
        for(int i=0; i<numPixels; i++)
        {
        delay(750);
        pixels->fill(gelb, 90, 3);
        pixels->fill(gelb, 79, 4);
        pixels->fill(gelb, 51, 12);
        pixels->show();
        
        
        delay(750);
        pixels->fill(schwarz, 90, 3);
        pixels->fill(schwarz, 79, 4);
        pixels->fill(schwarz, 51, 12);
        pixels->show();
        }
      }
     
    if((Gleis_2_links_blinken == false) && (Gleis_2_besetzt == false))
      {
        pixels->fill(schwarz, 90, 3);
        pixels->fill(schwarz, 79, 4);
        pixels->fill(schwarz, 51, 12);
        pixels->show();
      }

     if((Gleis_2_links_blinken == true) && (Gleis_2_besetzt == true)) //-------besetzt---------
      {
        for(int i=0; i<numPixels; i++)
        {
        delay(750);
        pixels->fill(gelb, 90, 3);
        pixels->fill(gelb, 79, 4);
        pixels->show();
        
        
        delay(750);
        pixels->fill(schwarz, 90, 3);
        pixels->fill(schwarz, 79, 4);
        pixels->show();
        }
      }
      
      if((Gleis_2_links_blinken == false) && (Gleis_2_besetzt == true))
      {
        pixels->fill(schwarz, 90, 3);
        pixels->fill(schwarz, 79, 4);
        pixels->show();
      }



      if((Gleis_2_links_dauer == true) && (Gleis_2_besetzt == true)) //-------besetzt---------
      {
        delay(750);
        pixels->fill(gelb, 90, 3);
        pixels->fill(gelb, 79, 4);
        pixels->show();
      }
          
      if((Gleis_2_links_dauer == false) && (Gleis_2_besetzt == true))
      {
        pixels->fill(schwarz, 90, 3);
        pixels->fill(schwarz, 79, 4);
        pixels->show();
      }

      if((Gleis_2_links_dauer == true) && (Gleis_2_besetzt == false))
      {
        pixels->fill(gelb, 90, 3);
        pixels->fill(gelb, 79, 4);
        pixels->fill(gelb, 51, 12);
        pixels->show();
      }
               
      if((Gleis_2_links_dauer == false) && (Gleis_2_besetzt == false))
      {
        pixels->fill(schwarz, 90, 3);
        pixels->fill(schwarz, 79, 4);
        pixels->fill(schwarz, 51, 12);
        pixels->show();
      }
}

agmue · June 8, 2024, 12:23pm

Kurze Antwort: delay ist Dein Feind, nutze millis.

soli2014 · June 8, 2024, 12:24pm

auch die for schleife verstehe ich nicht.... es soll so lange blinken bis die Endlagen der Weichen eingegangen sind .... wie gesagt bin am verzweifeln... ich weiss nicht wie ich der for schleife sage: wenn die Weichen Endlage haben dann von blinken auf Dauerlicht...

soli2014 · June 8, 2024, 12:25pm

könntest du mir hier bitte auf die Sprünge helfen?
wie setze ich das hier ein? .... bitte seid mir nicht böse ...

noiasca · June 8, 2024, 12:43pm

wenn ich dir einen Tipp geben darf:
Dupliziere keine Codezeilen.
Schreibe Code EINMAL. Nicht mit STRG-C / STRG-V
Lies dich zu Arrays ein.

vor einem Monat gabs hier ein ähnliches Thema.

wenn du Zeit hast geh das mal durch.

@schanderl hat sich auch überzeugen lassen, vieleicht klappts bei dir auch.

Das BlingBling mit Neopixel kann man entsprechend erweiteren.

Tommy56 · June 8, 2024, 12:45pm

Auch die for-Schleife ist in dieser Verwendung Dein Feind.
Schaue Dir zuerst das Beispiel BlinkWithoutDelay an und verstehe es. Das kann keiner für Dich erledigen. Es geht dabei nicht in erster Linie um das Blinken, sondern das Verständnis, dass loop() Dein einziges Wiederholungskonstrukt sein sollte.

Ein weiteres Suchstichwort sotlte "endlicher Automat" sein.

Du könntest auch mit den MoBaTools arbeiten, aber auf dem von mir skizzierten Weg verstehst Du erst mal die Grundlagen der Abläufe.

Wie erkennst Du übrigens, wann eine Weche welche Endlage erreicht hat?

Gruß Tommy

soli2014 · June 8, 2024, 12:50pm

da habe ich die "Polarisierungsausgänge" des Weichenantriebes genommen ... heißt wenn die Weiche eine Endlage hat dann ist das wie bei einem Schalter der den GND durch lässt....

soli2014 · June 8, 2024, 12:50pm

werde ich sofort mal machen ... vielen dank

MicroBahner · June 8, 2024, 1:46pm

Du hüpfst in deiner Beschreibung irgendwo mitten in dein Projekt. Bedenke, dass wir nicht wissen, was Du vorhast, und was Du die letzten Wochen gemacht hast. Du solltest also erstmal dein Stellpult als Ganzes beschreiben, evtl. auch ein Bild davon machen. Dann einen Schaltplan, wie Du derzeit alles verdrahtet hast ( bzw. was Du bisher verdrahtet hast ). Wo sind die Neopixel verbaut? Müssen es wirklich NeoPixel sein? Die Ansteuerung hat durchaus so ihre Tücken - vor allem wenn es auch noch viel anderes zu tun gibt. Was sind das für Weichenantriebe? Brauchen die zum Stelle so viel Zeit, dass sich ein Blinken lohnt?
Fragen über Fragen ... Ich glaube, Du hast dich viel zu früh in Details gestürzt.

P.S. mein Avatar zeigt einen (kleinen) Ausschnitt meines (ehemaligen) Stellpults War in Funktionalität und Bedienung an ein elektromechanisches Stellwerk der Bahn angelehnt. Mit so einem kleinen AVR kann man ein ganze Menge machen

soli2014 · June 8, 2024, 5:44pm

Schön und gut jedoch verstehe ich es immer noch nicht hab mir nun YouTube reingezogen mit millis usw aber ich komme nicht darauf, wie ich meinen Code ändern könnte dass es passt

michael_x · June 8, 2024, 8:03pm

Es wird nicht delay() durch millis() ersetzt .

Wenn du denkst, ein loop-Durchlauf stellt einen Programmdurchlauf von Tasterdruck bis Fahrstraße umgestellt dar, musst du komplett umdenken:

Ein loop-Durchlauf dauert gar keine Zeit, wird nur unendlich oft wiederholt. Bei einigen wenigen der unendlich vielen Durchläufen wird festgestellt, dass sich etwas verändert hat.

Das ist ein komplett anderer Denk-Ansatz, an den du dich erstmal gewöhnen musst.

Beim BlinkWithoutDelay Beispiel ist die einzige Veränderung, dass die Zeit, während der die blinkende LED an war, so lange vorbei ist, dass die LED nun erstmal eine Zeitlang aus sein sollte (wieviel Zeit vergangen ist, und um die neue Zeit für die nachste Phase zu merken, wird millis gebraucht). Auf lange Sicht führt dies dazu, dass die LED blinkt und in dieser Zeit in den "unendlich" vielen loop-Durchläufen gleichzeitig beliebig viel anderes --nach dem gleichen Verfahren-- gemacht werden kann.

In der Realität sind es weniger als unendlich viele Durchläufe Wenn es um Taster und mechanische Kontakte von Weichen geht, ist es evtl. sogar einfacher, nicht soo schnell zu sein dass das Prellen (2..5 ms) stört. Aber der Denkansatz dass loop() nur ein Moment des Programms ist, muss sich bei dir erstmal durchsetzen.

paulpaulson · June 9, 2024, 3:27am

Hallo soli2014

Als Denkhilfe kommt hier meine Unterstützung:

Unterteile dein Projekt in kleine Module, die einzeln programmiert und getestet werden können.

Und dann kannst du diese Module über Steuerfunktionen zum Gesamtprojekt zusammenlöten.

Immer beachten: ARRAY´s, STRUCT`s, ENUMS´s usw. sind dabei deine Freunde.

Ich wünsche Ihnen einen schönen Tag und viel Spaß beim Programmieren in C++.

MicroBahner · June 9, 2024, 7:14am

Ich würde sagen, vergiss erstmal deinen Code und fang neu an. Wie schon geschrieben wurde, musst Du dir eine andere 'Denke' erarbeiten, um dein Stellpult ( von dem wir immer noch fast nichts wissen ) zu realisieren.
In einem Modellbahnforum habe ich mal vor längerer Zeit für die Kollegen dort ein Tutorial geschrieben, um diese Programmiertechnik anhand eines Modellbahnkreises zu verdeutlichen. Da ging es zwar um einen Bü mit Wechselblinker und eine Ampel, die unabhängig voneinander von einem Arduino gesteuert werden sollten. Aber das Programmierprinzip ist immer das gleiche.
Vielleicht wäre das auch was für dich. @Tommy56 hat das Tutorial freundlicherweise als PDF-Datei auf seiner Webseite gehostet. Auch die Beispielsketche des Tutorials sind auf seiner Seite zu finden.

agmue · June 9, 2024, 5:31pm

Das ist einfacher gefragt, als beantwortet, da Du Dir für den Anfang gleich ein Projekt vorgenommen hast, daß für Deine Programmierfähigkeiten grenzwertig ist. Nach den vorhergehenden Beiträgen dürfte Dich meine Aussage nicht überraschen.

Leider bin ich mit meinem Versuch, Dein bestehendes Programm zu ändern, grandios gescheitert, da mir Deine Hardware fehlt, um vernüftig testen zu können.

Eine Idee habe ich aber, die möchte ich Dir in einem kleinen Testprogramm zeigen. Dabei lasse ich einen Merker im Blinkrhythmus true und false werden, um an den Stellen, an denen Du delay verwendest, die Pixel ein und aus zu schalten.

Programm

//------------------------------------------ Steuerung Stellpult Mariazellerbahn --------------------------------------------------------------
#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
#include <avr/power.h>
#endif

const byte LEDs  =  6;                         //Anschluss Led Streifen
const byte numPixels =  93;                    //Anzahl der Leds
const int pixelFormat = NEO_GRB + NEO_KHZ800;
Adafruit_NeoPixel *pixels;

#define DELAYVAL 500

//-----------------------------------------------Eingänge--------------------------------------------------------------------------
const byte blinken = A0;
const byte dauer   = A1;

//-----------------------------------------------Zeitdefinition--------------------------------------------------------------------
unsigned long jetzt;
unsigned long vorhin;
bool blinkAn;

//-----------------------------------------------Farbdefinition--------------------------------------------------------------------
const uint32_t schwarz = pixels->Color(0, 0, 0);
const uint32_t gelb = pixels->Color(5, 2, 0);
const uint32_t gelb_blink = pixels->Color(2, 1, 0);
const uint32_t rot = pixels->Color(10, 0, 0);

void setup()
{
  pinMode(blinken, INPUT_PULLUP);
  pinMode(dauer, INPUT_PULLUP);

  //-----------------------------Neopixel Streifen im Stellpult----------------
  pixels = new Adafruit_NeoPixel(numPixels, LEDs, pixelFormat);
  pixels->begin();
}

void loop()
{
  jetzt = millis();
  if (jetzt - vorhin >= DELAYVAL)
  {
    vorhin = jetzt;
    blinkAn = !blinkAn;
  }

  //------------------------------Fahrstrasse Gl. 1 links----------------------------

  if (!digitalRead(blinken))
  {
    if (blinkAn)
    {
      pixels->fill(gelb_blink, 90, 3);
      pixels->fill(gelb_blink, 81, 2);
      pixels->fill(gelb_blink, 67, 12);
    } else {
      pixels->fill(rot, 90, 3);
      pixels->fill(rot, 81, 2);
      pixels->fill(rot, 67, 12);
    }
  } else if (!digitalRead(dauer))
  {
    pixels->fill(gelb, 90, 3);
    pixels->fill(gelb, 81, 2);
    pixels->fill(gelb, 67, 12);
  } else
  {
    pixels->fill(schwarz, 90, 3);
    pixels->fill(schwarz, 81, 2);
    pixels->fill(schwarz, 67, 12);
  }
  pixels->show();
}

Rot verwende ich nur, um es vom ausgeschalteten Zustand zu unterscheiden.

Durchblickst Du mein Programm?

Es juckt mir in den Fingern, weitere Änderungen vorzunehmen, das habe ich aber auf den nächsten Schritt verschoben.

Ich habe den

Deklarationsteil

//------------------------------------------ Steuerung Stellpult Mariazellerbahn --------------------------------------------------------------
#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
#include <avr/power.h>
#endif

const byte LEDs  =  6;                        //Anschluss Led Streifen
const byte numPixels =  93;                    //Anzahl der Leds
const int pixelFormat = NEO_GRB + NEO_KHZ800;
Adafruit_NeoPixel *pixels;

#define DELAYVAL 750

//--------------------------------------------Taster am Stellpult------------------------------------------------------------
const byte zentraltaster_links = 2;                 //zentraler Taster linke Seite an Pin A0 angeschlossen
const byte zentraltaster_rechts = 3;                //zentraler Taster rechte Seite an Pin A6 angeschlossen

const byte taster_Gleis_1 = A0;                      //Taster Gleis 1, alle Weichen schalten MIT zugehörigem Zentraltaster von rechts oder links
const byte taster_Gleis_2 = A1;                      //Taster Gleis 2, alle Weichen schalten MIT zugehörigem Zentraltaster von rechts oder links
const byte taster_Gleis_3 = A2;                      //Taster Gleis 3, alle Weichen schalten MIT zugehörigem Zentraltaster von rechts oder links
const byte taster_Gleis_4 = A3;                      //Taster Gleis 4, alle Weichen schalten MIT zugehörigem Zentraltaster von rechts oder links
const byte taster_Gleis_5 = A4;                      //Taster Gleis 5, alle Weichen schalten MIT zugehörigem Zentraltaster von rechts oder links

//--------------------------------------------Weichen RECHTE SEITE-------------------------------------------------------------------
const int Weiche_1 = 22;                      //Relais (8fachModul) für Weiche 1 rechte Seite
const int Weiche_2 = 23;                      //Relais (8fachModul) für Weiche 2 rechte Seite
const int Weiche_3 = 24;                      //Relais (8fachModul) für Weiche 3 rechte Seite
const int Weiche_4 = 25;                      //Relais (8fachModul) für Weiche 4 rechte Seite

//--------------------------------------------Weichen LINKE SEITE---------------------------------------------------------------------
const int Weiche_5 = 50;                      //Relais (8fachModul) für Weiche 4 linke Seite
const int Weiche_6 = 51;                      //Relais (8fachModul) für Weiche 4 linke Seite
const int Weiche_7 = 52;                      //Relais (8fachModul) für Weiche 4 linke Seite
const int Weiche_8 = 53;                      //Relais (8fachModul) für Weiche 4 linke Seite

//--------------------------------------------Endlagen Weichen (Polarisiereungsanschlüsse am Motor)----------------------------------------
const byte Endlage_Weiche_1_links  = 26;             //wird wie Taster INPUT_PULLUP geschaltet (ist für Schalten der nächsten Weiche und wenn alle Weichen Endlage haben dann Leds)
const byte Endlage_Weiche_1_rechts = 27;
const byte Endlage_Weiche_2_links  = 28;
const byte Endlage_Weiche_2_rechts = 29;
const byte Endlage_Weiche_3_links  = 30;
const byte Endlage_Weiche_3_rechts = 31;
const byte Endlage_Weiche_4_links  = 32;
const byte Endlage_Weiche_4_rechts = 33;
const byte Endlage_Weiche_5_links  = 34;
const byte Endlage_Weiche_5_rechts = 35;
const byte Endlage_Weiche_6_links  = 36;
const byte Endlage_Weiche_6_rechts = 37;
const byte Endlage_Weiche_7_links  = 38;
const byte Endlage_Weiche_7_rechts = 39;
const byte Endlage_Weiche_8_links  = 40;
const byte Endlage_Weiche_8_rechts = 41;

//-----------------------------------------------Zeitdefinition--------------------------------------------------------------------
unsigned long jetzt;
unsigned long vorhin;
bool blinkAn;

//-----------------------------------------------Farbdefinition--------------------------------------------------------------------
const uint32_t schwarz = pixels->Color(0, 0, 0);
const uint32_t gelb = pixels->Color(5, 2, 0);
const uint32_t gelb_blink = pixels->Color(2, 1, 0);
const uint32_t rot = pixels->Color(10, 0, 0);

//--------------------------------------Fahrstrassen rechts blinken (einlaufen)---------------------------------------------------
bool Gleis_1_rechts_blinken = false; //Ein Aus interner Schalter
bool Gleis_2_rechts_blinken = false;
bool Gleis_3_rechts_blinken = false;
bool Gleis_4_rechts_blinken = false;
bool Gleis_5_rechts_blinken = false;

//--------------------------------------Fahrstrassen rechts Dauerlicht-----------------------------------------------------------
bool Gleis_1_rechts_dauer = false;
bool Gleis_2_rechts_dauer = false;
bool Gleis_3_rechts_dauer = false;
bool Gleis_4_rechts_dauer = false;
bool Gleis_5_rechts_dauer = false;

//--------------------------------------Fahrstrassen links blinken (einlaufen)-----------------------------------------------------
bool Gleis_1_links_blinken = false;
bool Gleis_2_links_blinken = false;
bool Gleis_3_links_blinken = false;
bool Gleis_4_links_blinken = false;
bool Gleis_5_links_blinken = false;

//-------------------------------------Fahrstrassen links Dauerlicht--------------------------------------------------------------
bool Gleis_1_links_dauer = false;
bool Gleis_2_links_dauer = false;
bool Gleis_3_links_dauer = false;
bool Gleis_4_links_dauer = false;
bool Gleis_5_links_dauer = false;

//--------------------------------------Fahrstrassen links------------------------------------------------------------------------
bool Fahrstrasse_Gleis_1_links = false;
bool Fahrstrasse_Gleis_2_links = false;
bool Fahrstrasse_Gleis_3_links = false;
bool Fahrstrasse_Gleis_4_links = false;
bool Fahrstrasse_Gleis_5_links = false;

//---------------------------------------------------Besetztmelder----------------------------------------------------------------
const byte reed_Gleis_1_ein = A5;
const byte reed_Gleis_1_aus = A6;
const byte reed_Gleis_2_ein = A7;
const byte reed_Gleis_2_aus = A8;
const byte reed_Gleis_3_ein = A9;
const byte reed_Gleis_3_aus = A10;
const byte reed_Gleis_4_ein = A11;
const byte reed_Gleis_4_aus = A12;
const byte reed_Gleis_5_ein = A13;
const byte reed_Gleis_5_aus = A14;

bool Gleis_1_besetzt = false;
bool Gleis_2_besetzt = false;
bool Gleis_3_besetzt = false;
bool Gleis_4_besetzt = false;
bool Gleis_5_besetzt = false;

Deines Programm überarbeitet.

soli2014 · June 9, 2024, 6:01pm

Hello und vielen vielen Dank für deine Mühe....

Also es handelt sich um ein selbst 3d gezeichnetes und gedrucktes Stellpult mit Neopixels 93stk...

es ist eine eingleisige Strecke jedoch gibt es 5 verschiedene Bahnhofsgleise, die mit motorischen Weichen gestellt werden .... weiters habe ich reed Kontakte im Gleis verbaut, dass ich eben eine Besetztmeldung am Stellpult erhalte... das Stellpult ist mir meiner Meinung nach sehr gut gelungen. verbaut ist ein Arduino mega, ein 8fach Relaismodul (weil ich ja die 15v Wechselspannung am Weichenmotor brauche... Hardwaremässig kann ich NICHTS mehr ändern, da alles mit Landschaft gestaltet ist (Fotos im Anhang). folgendes Szenario. ich möchte mit Taste (Zentraltaster links oder rechts UND Taster des jeweiligen Gleises) eine Fahrstrasse einlaufen lassen. Bin selbst Lokführer bei den ÖBB und sehe immer wieder, dass sich die Weichen nach und nach stellen. Auch hier sollte immer eine kleine Pause sein da ja erst mal die Rückmeldung der Endlage ins Stellpult eingehen soll und erst dann stellt sich die nächste Weiche usw... während des Stellvorganges soll die gewählte Fahrstrasse am Stellpult blinken. Erst wenn ALLE Weichen an den Arduino eine Endlage melden soll die Fahrsstrasse in Dauerlicht übergehen. Das Dauerlicht soll aber wiederum abhängig von der Besetztmeldung sein.

So soll das im Groben für alle 5 Gleise passieren abhängig links und rechts... weil ich ja von beiden Seiten in den Bahnhof einfahren kann.... Ideen schweben mir noch viele vor, jedoch denke ich mal Step by Step...

Ich habe jetzt mal versucht einen neuen Code mit millis zu erstellen. Einzig die variablen hab ich belassen da ich ansonsten vielleicht nicht mehr weiß, was wo am arduino angeschlossen ist..

//------------------------------------------ Steuerung Stellpult Mariazellerbahn --------------------------------------------------------------
#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
  #include <avr/power.h>
#endif

int LEDs  =  6;                        //Anschluss Led Streifen
int numPixels =  93;                    //Anzahl der Leds
int pixelFormat = NEO_GRB + NEO_KHZ800;
Adafruit_NeoPixel *pixels;

#define DELAYVAL 100

//--------------------------------------------Taster am Stellpult------------------------------------------------------------
int zentraltaster_links = 2;                 //zentraler Taster linke Seite an Pin A0 angeschlossen
int zentraltaster_rechts = 3;                //zentraler Taster rechte Seite an Pin A6 angeschlossen

int taster_Gleis_1 = A0;                      //Taster Gleis 1, alle Weichen schalten MIT zugehörigem Zentraltaster von rechts oder links
int taster_Gleis_2 = A1;                      //Taster Gleis 2, alle Weichen schalten MIT zugehörigem Zentraltaster von rechts oder links
int taster_Gleis_3 = A2;                      //Taster Gleis 3, alle Weichen schalten MIT zugehörigem Zentraltaster von rechts oder links
int taster_Gleis_4 = A3;                      //Taster Gleis 4, alle Weichen schalten MIT zugehörigem Zentraltaster von rechts oder links
int taster_Gleis_5 = A4;                      //Taster Gleis 5, alle Weichen schalten MIT zugehörigem Zentraltaster von rechts oder links

//--------------------------------------------Weichen RECHTE SEITE-------------------------------------------------------------------
const int Weiche_1 = 22;                      //Relais (8fachModul) für Weiche 1 rechte Seite
const int Weiche_2 = 23;                      //Relais (8fachModul) für Weiche 2 rechte Seite
const int Weiche_3 = 24;                      //Relais (8fachModul) für Weiche 3 rechte Seite
const int Weiche_4 = 25;                      //Relais (8fachModul) für Weiche 4 rechte Seite

//--------------------------------------------Weichen LINKE SEITE---------------------------------------------------------------------
const int Weiche_5 = 50;                      //Relais (8fachModul) für Weiche 4 linke Seite
const int Weiche_6 = 51;                      //Relais (8fachModul) für Weiche 4 linke Seite
const int Weiche_7 = 52;                      //Relais (8fachModul) für Weiche 4 linke Seite
const int Weiche_8 = 53;                      //Relais (8fachModul) für Weiche 4 linke Seite

//--------------------------------------------Endlagen Weichen (Polarisiereungsanschlüsse am Motor)----------------------------------------
int Endlage_Weiche_1_links  = 26;             //wird wie Taster INPUT_PULLUP geschaltet (ist für Schalten der nächsten Weiche und wenn alle Weichen Endlage haben dann Leds)
int Endlage_Weiche_1_rechts = 27;                    
int Endlage_Weiche_2_links  = 28;
int Endlage_Weiche_2_rechts = 29;
int Endlage_Weiche_3_links  = 30;
int Endlage_Weiche_3_rechts = 31;
int Endlage_Weiche_4_links  = 32;
int Endlage_Weiche_4_rechts = 33;
int Endlage_Weiche_5_links  = 34;
int Endlage_Weiche_5_rechts = 35;
int Endlage_Weiche_6_links  = 36;
int Endlage_Weiche_6_rechts = 37;
int Endlage_Weiche_7_links  = 38;
int Endlage_Weiche_7_rechts = 39;
int Endlage_Weiche_8_links  = 40;
int Endlage_Weiche_8_rechts = 41;

//-----------------------------------------------Zeitdefinition--------------------------------------------------------------------
unsigned long currentMillis;
unsigned long previousMillis;
unsigned long CycleMillis;


long T_blinken_gelb_Gleis_1_rechts = 1000;
long HT_blinken_gelb_Gleis_1_rechts = T_blinken_gelb_Gleis_1_rechts;
long T_blinken_schwarz_Gleis_1_rechts = 1000;
long HT_blinken_schwarz_Gleis_1_rechts = T_blinken_schwarz_Gleis_1_rechts;

long T_blinken_gelb_Gleis_2_rechts = 1000;
long HT_blinken_gelb_Gleis_2_rechts = T_blinken_gelb_Gleis_2_rechts;
long T_blinken_schwarz_Gleis_2_rechts = 1000;
long HT_blinken_schwarz_Gleis_2_rechts = T_blinken_schwarz_Gleis_2_rechts;

long T_blinken_gelb_Gleis_3_rechts = 1000;
long HT_blinken_gelb_Gleis_3_rechts = T_blinken_gelb_Gleis_3_rechts;
long T_blinken_schwarz_Gleis_3_rechts = 1000;
long HT_blinken_schwarz_Gleis_3_rechts = T_blinken_schwarz_Gleis_3_rechts;

long T_blinken_gelb_Gleis_4_rechts = 1000;
long HT_blinken_gelb_Gleis_4_rechts = T_blinken_gelb_Gleis_4_rechts;
long T_blinken_schwarz_Gleis_4_rechts = 1000;
long HT_blinken_schwarz_Gleis_4_rechts = T_blinken_schwarz_Gleis_4_rechts;

long T_blinken_gelb_Gleis_5_rechts = 1000;
long HT_blinken_gelb_Gleis_5_rechts = T_blinken_gelb_Gleis_5_rechts;
long T_blinken_schwarz_Gleis_5_rechts = 1000;
long HT_blinken_schwarz_Gleis_5_rechts = T_blinken_schwarz_Gleis_5_rechts;



long T_blinken_gelb_Gleis_1_links = 1000;
long HT_blinken_gelb_Gleis_1_links = T_blinken_gelb_Gleis_1_links;
long T_blinken_schwarz_Gleis_1_links = 1000;
long HT_blinken_schwarz_Gleis_1_links = T_blinken_schwarz_Gleis_1_links;

long T_blinken_gelb_Gleis_2_links = 1000;
long HT_blinken_gelb_Gleis_2_links = T_blinken_gelb_Gleis_2_links;
long T_blinken_schwarz_Gleis_2_links = 1000;
long HT_blinken_schwarz_Gleis_2_links = T_blinken_schwarz_Gleis_2_links;

long T_blinken_gelb_Gleis_3_links = 1000;
long HT_blinken_gelb_Gleis_3_links = T_blinken_gelb_Gleis_3_links;
long T_blinken_schwarz_Gleis_3_links = 1000;
long HT_blinken_schwarz_Gleis_3_links = T_blinken_schwarz_Gleis_3_links;

long T_blinken_gelb_Gleis_4_links = 1000;
long HT_blinken_gelb_Gleis_4_links = T_blinken_gelb_Gleis_4_links;
long T_blinken_schwarz_Gleis_4_links = 1000;
long HT_blinken_schwarz_Gleis_4_links = T_blinken_schwarz_Gleis_4_links;

long T_blinken_gelb_Gleis_5_links = 1000;
long HT_blinken_gelb_Gleis_5_links = T_blinken_gelb_Gleis_5_links;
long T_blinken_schwarz_Gleis_5_links = 1000;
long HT_blinken_schwarz_Gleis_5_links = T_blinken_schwarz_Gleis_5_links;

long T_schalten_Gleis_1_rechts = 2000;
long HT_schalten_Gleis_1_rechts = T_schalten_Gleis_1_rechts;

long T_schalten_Gleis_1_links = 2000;
long HT_schalten_Gleis_1_links = T_schalten_Gleis_1_links;

long T_schalten_Gleis_2_rechts = 2000;
long HT_schalten_Gleis_2_rechts = T_schalten_Gleis_2_rechts;

long T_schalten_Gleis_2_links = 2000;
long HT_schalten_Gleis_2_links = T_schalten_Gleis_2_links;

long T_schalten_Gleis_3_rechts = 2000;
long HT_schalten_Gleis_3_rechts = T_schalten_Gleis_3_rechts;

long T_schalten_Gleis_3_links = 2000;
long HT_schalten_Gleis_3_links = T_schalten_Gleis_3_links;

long T_schalten_Gleis_4_rechts = 2000;
long HT_schalten_Gleis_4_rechts = T_schalten_Gleis_4_rechts;

long T_schalten_Gleis_4_links = 2000;
long HT_schalten_Gleis_4_links = T_schalten_Gleis_4_links;

long T_schalten_Gleis_5_rechts = 2000;
long HT_schalten_Gleis_5_rechts = T_schalten_Gleis_5_rechts;

long T_schalten_Gleis_5_links = 2000;
long HT_schalten_Gleis_5_links = T_schalten_Gleis_5_links;




//-----------------------------------------------Farbdefinition--------------------------------------------------------------------
uint32_t schwarz = pixels->Color(0, 0, 0);
uint32_t gelb = pixels->Color(5, 2, 0);
uint32_t gelb_blink = pixels->Color(2, 1, 0);
uint32_t rot = pixels->Color(10,0,0);

//--------------------------------------Fahrstrassen rechts blinken (einlaufen)---------------------------------------------------
bool Gleis_1_rechts_blinken = false; //Ein Aus interner Schalter
bool Gleis_2_rechts_blinken = false;
bool Gleis_3_rechts_blinken = false;
bool Gleis_4_rechts_blinken = false;
bool Gleis_5_rechts_blinken = false;

bool Gleis_1_rechts_schalten = false;
bool Gleis_2_rechts_schalten = false;
bool Gleis_3_rechts_schalten = false;
bool Gleis_4_rechts_schalten = false;
bool Gleis_5_rechts_schalten = false;

//--------------------------------------Fahrstrassen rechts Dauerlicht-----------------------------------------------------------
bool Gleis_1_rechts_dauer = false;
bool Gleis_2_rechts_dauer = false;
bool Gleis_3_rechts_dauer = false;
bool Gleis_4_rechts_dauer = false;
bool Gleis_5_rechts_dauer = false;

//--------------------------------------Fahrstrassen links blinken (einlaufen)-----------------------------------------------------
bool Gleis_1_links_blinken = false;
bool Gleis_2_links_blinken = false;
bool Gleis_3_links_blinken = false;
bool Gleis_4_links_blinken = false;
bool Gleis_5_links_blinken = false;

bool Gleis_1_links_schalten = false;
bool Gleis_2_links_schalten = false;
bool Gleis_3_links_schalten = false;
bool Gleis_4_links_schalten = false;
bool Gleis_5_links_schalten = false;

//-------------------------------------Fahrstrassen links Dauerlicht--------------------------------------------------------------
bool Gleis_1_links_dauer = false;
bool Gleis_2_links_dauer = false;
bool Gleis_3_links_dauer = false;
bool Gleis_4_links_dauer = false;
bool Gleis_5_links_dauer = false;

//--------------------------------------Fahrstrassen links------------------------------------------------------------------------
bool Fahrstrasse_Gleis_1_links = false;
bool Fahrstrasse_Gleis_2_links = false;
bool Fahrstrasse_Gleis_3_links = false;
bool Fahrstrasse_Gleis_4_links = false;
bool Fahrstrasse_Gleis_5_links = false;

//---------------------------------------------------Besetztmelder----------------------------------------------------------------
int reed_Gleis_1_ein = A5;
int reed_Gleis_1_aus = A6;
int reed_Gleis_2_ein = A7;
int reed_Gleis_2_aus = A8;
int reed_Gleis_3_ein = A9;
int reed_Gleis_3_aus = A10;
int reed_Gleis_4_ein = A11;
int reed_Gleis_4_aus = A12;
int reed_Gleis_5_ein = A13;
int reed_Gleis_5_aus = A14;

bool Gleis_1_besetzt = false;
bool Gleis_2_besetzt = false;
bool Gleis_3_besetzt = false;
bool Gleis_4_besetzt = false;
bool Gleis_5_besetzt = false;


void setup() {

  //--------------------------- Taster ----------------------------------------
  pinMode(zentraltaster_links, INPUT_PULLUP);
  pinMode(taster_Gleis_1, INPUT_PULLUP); //Taster ist immer HIGH und muss beim Drücken gegen GND gebrückt werden
  pinMode(taster_Gleis_2, INPUT_PULLUP);
  pinMode(taster_Gleis_3, INPUT_PULLUP);
  pinMode(taster_Gleis_4, INPUT_PULLUP);
  pinMode(taster_Gleis_5, INPUT_PULLUP);
  pinMode(zentraltaster_rechts, INPUT_PULLUP);

//-------------------------- Relais Weichen ---------------------------------
  pinMode(Weiche_1, OUTPUT);
  pinMode(Weiche_2, OUTPUT);
  pinMode(Weiche_3, OUTPUT);
  pinMode(Weiche_4, OUTPUT);
  pinMode(Weiche_5, OUTPUT);
  pinMode(Weiche_6, OUTPUT);
  pinMode(Weiche_7, OUTPUT);
  pinMode(Weiche_8, OUTPUT);

//------Endlagen der Weichen zum Weiterschalten nächste Weiche und zum Schluss Ausleuchtung ------
  pinMode(Endlage_Weiche_1_links, INPUT_PULLUP);
  pinMode(Endlage_Weiche_1_rechts, INPUT_PULLUP);
  pinMode(Endlage_Weiche_2_links, INPUT_PULLUP);
  pinMode(Endlage_Weiche_2_rechts, INPUT_PULLUP);
  pinMode(Endlage_Weiche_3_links, INPUT_PULLUP);
  pinMode(Endlage_Weiche_3_rechts, INPUT_PULLUP);
  pinMode(Endlage_Weiche_4_links, INPUT_PULLUP);
  pinMode(Endlage_Weiche_4_rechts, INPUT_PULLUP);
  pinMode(Endlage_Weiche_5_links, INPUT_PULLUP);
  pinMode(Endlage_Weiche_5_rechts, INPUT_PULLUP);
  pinMode(Endlage_Weiche_6_links, INPUT_PULLUP);
  pinMode(Endlage_Weiche_6_rechts, INPUT_PULLUP);
  pinMode(Endlage_Weiche_7_links, INPUT_PULLUP);
  pinMode(Endlage_Weiche_7_rechts, INPUT_PULLUP);
  pinMode(Endlage_Weiche_8_links, INPUT_PULLUP);
  pinMode(Endlage_Weiche_8_rechts, INPUT_PULLUP);

//---------------------------alle Weichen Grundstellung ----------------------


//--------------------------------Reed Kontakte------------------------------
  pinMode(reed_Gleis_1_ein, INPUT_PULLUP);
  pinMode(reed_Gleis_1_aus, INPUT_PULLUP);
  pinMode(reed_Gleis_2_ein, INPUT_PULLUP);
  pinMode(reed_Gleis_2_aus, INPUT_PULLUP);
  pinMode(reed_Gleis_3_ein, INPUT_PULLUP);
  pinMode(reed_Gleis_3_aus, INPUT_PULLUP);
  pinMode(reed_Gleis_4_ein, INPUT_PULLUP);
  pinMode(reed_Gleis_4_aus, INPUT_PULLUP);
  pinMode(reed_Gleis_5_ein, INPUT_PULLUP);
  pinMode(reed_Gleis_5_aus, INPUT_PULLUP);

//-----------------------------Neopixel Streifen im Stellpult----------------
  
  pixels = new Adafruit_NeoPixel(numPixels, LEDs, pixelFormat);
  pixels->begin(); 
}

void loop() {
//--------------------------------SCHALTEN STELLPULT--------------------------------

//---------------------------------Zeitdefinition-----------------------------------
//millis() ist die interne Uhr welche bei 0 startet und jede Millisekunde eins nach oben Zählt
  currentMillis = millis();                      //hier sichern wir die aktuelle "Zeit"                    
  CycleMillis = currentMillis - previousMillis;  //berechnen der Zykluszeit
  previousMillis = currentMillis;                //Duplizieren der aktuellen "Zeit" für die Berechnung im nächsten Zyklus

//--------Besetztmelder Gleis 1-----------
if(digitalRead(reed_Gleis_1_ein) == LOW)
  {
   Gleis_1_besetzt = true;
  }
    if(Gleis_1_besetzt == true)
      {
        pixels->fill(rot, 67, 12);
        pixels->show();
      }
    else
      {
        pixels->fill(schwarz, 67, 12);
        pixels->show();
      }

if(digitalRead(reed_Gleis_1_aus) == LOW)
  {
    Gleis_1_besetzt = false;
  }

//--------Besetztmelder Gleis 2-----------

if(digitalRead(reed_Gleis_2_ein) == LOW)
  {
   Gleis_2_besetzt = true;
  }
    if(Gleis_2_besetzt == true)
      {
        pixels->fill(rot, 51, 12);
        pixels->show();
      }
    else
      {
        pixels->fill(schwarz, 51, 12);
        pixels->show();
      }

if(digitalRead(reed_Gleis_2_aus) == LOW)
  {
    Gleis_2_besetzt = false;
  }

//--------Besetztmelder Gleis 3-----------

if(digitalRead(reed_Gleis_3_ein) == LOW)
  {
   Gleis_3_besetzt = true;
  }
    if(Gleis_3_besetzt == true)
      {
        pixels->fill(rot, 37, 12);
        pixels->show();
      }
    else
      {
        pixels->fill(schwarz, 37, 12);
        pixels->show();
      }

if(digitalRead(reed_Gleis_3_aus) == LOW)
  {
    Gleis_3_besetzt = false;
  }

//--------Besetztmelder Gleis 4-----------

if(digitalRead(reed_Gleis_4_ein) == LOW)
  {
   Gleis_4_besetzt = true;
  }
    if(Gleis_4_besetzt == true)
      {
        pixels->fill(rot, 21, 14);
        pixels->show();
      }
    else
      {
        pixels->fill(schwarz, 21, 14);
        pixels->show();
      }

if(digitalRead(reed_Gleis_4_aus) == LOW)
  {
    Gleis_4_besetzt = false;
  }

//--------Besetztmelder Gleis 5-----------

if(digitalRead(reed_Gleis_5_ein) == LOW)
  {
   Gleis_5_besetzt = true;
  }
    if(Gleis_5_besetzt == true)
      {
        pixels->fill(rot, 7, 12);
        pixels->show();
      }
    else
      {
        pixels->fill(schwarz, 7, 12);
        pixels->show();
      }

if(digitalRead(reed_Gleis_5_aus) == LOW)
  {
    Gleis_5_besetzt = false;
  }

//------------------------Fahrstrasse Gl. 1 rechts schalten Weichen----------------------------
//-------------------------immer von der letzten Weiche anfangen--------------------
  if((digitalRead(zentraltaster_rechts) == LOW) && (digitalRead(taster_Gleis_1) == LOW))
  
     {
      Gleis_1_rechts_blinken = true;  // bool Schalter (interner Schalter im Arduino)
      Gleis_1_rechts_schalten = true;                            
      digitalWrite(Weiche_4, HIGH);
     }

    if((Gleis_1_rechts_blinken == true) && (Gleis_1_besetzt == false))//---------nicht besetzt----------
     {

      if(pixels->getPixelColor(65) == schwarz)
        {
          HT_blinken_gelb_Gleis_1_rechts = HT_blinken_gelb_Gleis_1_rechts - CycleMillis;
            if(HT_blinken_gelb_Gleis_1_rechts <=0)
             {
              HT_blinken_gelb_Gleis_1_rechts = T_blinken_gelb_Gleis_1_rechts;
              pixels->fill(gelb, 0, 3);
              pixels->fill(gelb, 35, 2);
              pixels->fill(gelb, 63,16);
              pixels->show(); 
             }
        }

      if(pixels->getPixelColor(65) == gelb)
         { 
          HT_blinken_schwarz_Gleis_1_rechts = HT_blinken_schwarz_Gleis_1_rechts - CycleMillis;
           if(HT_blinken_schwarz_Gleis_1_rechts <=0)
             {
              HT_blinken_schwarz_Gleis_1_rechts = T_blinken_schwarz_Gleis_1_rechts;
              pixels->fill(schwarz, 0, 3);
              pixels->fill(schwarz, 35, 2);
              pixels->fill(schwarz, 63,16);
              pixels->show(); 
             }
         }               
     }
      
      if((Gleis_1_rechts_blinken == false) && (Gleis_1_besetzt == false))
      {
        pixels->fill(schwarz, 0, 3);
        pixels->fill(schwarz, 35, 2);
        pixels->fill(schwarz, 63, 16);
        pixels->show();
      }

     if((Gleis_1_rechts_blinken == true) && (Gleis_1_besetzt == true)) //-------besetzt---------
     {
       if(pixels->getPixelColor(65) == schwarz)
        {
          HT_blinken_gelb_Gleis_1_rechts = HT_blinken_gelb_Gleis_1_rechts - CycleMillis;
            if(HT_blinken_gelb_Gleis_1_rechts <=0)
             {
              HT_blinken_gelb_Gleis_1_rechts = T_blinken_gelb_Gleis_1_rechts;
              pixels->fill(gelb, 0, 3);
              pixels->fill(gelb, 35, 2);
              pixels->fill(gelb, 63, 4);
              pixels->show(); 
             }
        }

      if(pixels->getPixelColor(65) == gelb)
         { 
          HT_blinken_schwarz_Gleis_1_rechts = HT_blinken_schwarz_Gleis_1_rechts - CycleMillis;
           if(HT_blinken_schwarz_Gleis_1_rechts <=0)
             {
              HT_blinken_schwarz_Gleis_1_rechts = T_blinken_schwarz_Gleis_1_rechts;
              pixels->fill(schwarz, 0, 3);
              pixels->fill(schwarz, 35, 2);
              pixels->fill(schwarz, 63, 4);
              pixels->show(); 
             }  
         }           
      }

      if((Gleis_1_rechts_blinken == false) && (Gleis_1_besetzt == false))
      {
        pixels->fill(schwarz, 0, 3);
        pixels->fill(schwarz, 35, 2);
        pixels->fill(schwarz, 63, 14);
        pixels->show();
      }
     
          
      if(digitalRead(Endlage_Weiche_4_rechts) == LOW)
        {
          digitalWrite(Weiche_3, LOW);
        }
    
          if((digitalRead(Endlage_Weiche_3_rechts) == LOW) && (digitalRead(Endlage_Weiche_4_rechts) == LOW))
            {
              digitalWrite(Weiche_1, HIGH);
            }

             if((digitalRead(Endlage_Weiche_1_rechts) == LOW) && (digitalRead(Endlage_Weiche_3_rechts) == LOW) && (digitalRead(Endlage_Weiche_4_links) == LOW))
             {
              Gleis_1_rechts_dauer = true;
              Gleis_2_rechts_dauer = false;
              Gleis_3_rechts_dauer = false;
              Gleis_4_rechts_dauer = false;
              Gleis_5_rechts_dauer = false;

              Gleis_1_rechts_blinken = false;
             }

              if((Gleis_1_rechts_dauer == true) && (Gleis_1_besetzt == false))
                {
                  pixels->fill(gelb, 0, 3);
                  pixels->fill(gelb, 35, 2);
                  pixels->fill(gelb, 63, 16);
                  pixels->show();
                }
              else
                {
                  pixels->fill(schwarz, 0, 3);
                  pixels->fill(schwarz, 35, 2);
                  pixels->fill(schwarz, 63, 16);
                  pixels->show();
                }

              if((Gleis_1_rechts_dauer == true) && (Gleis_1_besetzt == true))
                {
                  pixels->fill(gelb, 0, 3);
                  pixels->fill(gelb, 35, 2);
                  pixels->fill(gelb, 63, 4);
                  pixels->show();
                }
              else
                {
                  pixels->fill(schwarz, 0, 3);
                  pixels->fill(schwarz, 35, 2);
                  pixels->fill(schwarz, 63, 4);
                  pixels->show();

     }

//------------------------------Fahrstrasse Gl. 2 rechts----------------------------
//-------------------------immer von der letzten Weiche anfangen--------------------
  if((digitalRead(zentraltaster_rechts) == LOW) && (digitalRead(taster_Gleis_2) == LOW))
   {
    Gleis_2_rechts_blinken = true;
    Gleis_2_rechts_schalten = true;
    digitalWrite(Weiche_4, LOW);
   }
    if((Gleis_2_rechts_blinken == true) && (Gleis_2_besetzt == false))//---------nicht besetzt----------
     {

      if(pixels->getPixelColor(65) == schwarz)
        {
          HT_blinken_gelb_Gleis_2_rechts = HT_blinken_gelb_Gleis_2_rechts - CycleMillis;
            if(HT_blinken_gelb_Gleis_2_rechts <=0)
             {
              HT_blinken_gelb_Gleis_2_rechts = T_blinken_gelb_Gleis_2_rechts;
              pixels->fill(gelb, 0, 3);
              pixels->fill(gelb, 35, 2);
              pixels->fill(gelb, 63,16);
              pixels->show(); 
             }
        }

      if(pixels->getPixelColor(65) == gelb)
         { 
          HT_blinken_schwarz_Gleis_1_rechts = HT_blinken_schwarz_Gleis_1_rechts - CycleMillis;
           if(HT_blinken_schwarz_Gleis_1_rechts <=0)
             {
              HT_blinken_schwarz_Gleis_1_rechts = T_blinken_schwarz_Gleis_1_rechts;
              pixels->fill(schwarz, 0, 3);
              pixels->fill(schwarz, 35, 2);
              pixels->fill(schwarz, 63,16);
              pixels->show(); 
             }
         }               
     }

}

soli2014 · June 9, 2024, 6:03pm

soli2014 · June 9, 2024, 6:06pm

blöde frage aber warum const byte und nicht int?

soli2014 · June 9, 2024, 6:29pm

Tommy56 · June 9, 2024, 6:33pm

Weil Du nicht mehr als 256 Pins hast und auch keine negativen Pinnummern (Speicher sparen: 1 int braucht 2 Bytes)

Gruß Tommy

soli2014 · June 9, 2024, 6:38pm

ok ich lerne und lerne und lerne gggg seit einem Monat beschäftige ich mich damit ... youtube rauf und runter usw... vielen dank

Topic		Replies	Views
Millis Befehl, Steuerung Schattenbahnof. Deutsch	169	9248	May 6, 2021
Nach Tastendruck Drehschalter auswerten Deutsch	48	4497	May 6, 2021
Weichensteuerung Schritt für Schritt Deutsch	51	7925	September 1, 2021
Gleisbildstellwerk Deutsch	55	8384	May 6, 2021
Anfänger!!! Schrittkette ohne ext. Input Deutsch	137	7970	May 6, 2021

Stellpult für Modellbahn

Related topics