/*History Version 1.0 Variablen aus Ebene 0 (SBH) angelegt Funktioniert! Lichtschranke unterbrochen gleich High Potenzial 1.1 Daten direkt in CAN Data 0 schreiben Also ohne Variable Data00 für Nachricht 1 & 2 1.2 Nachricht 3 von Modul 4 hinzugefügt - Funktioniert 1.3 Nachricht 4 von Modul 5 hinzugefügt - funktioniert 1.4 Nachricht 5 von Modul 6 hinzugefügt - funktioniert 1.5 Nachricht 6 von Modul 8 hinzugefügt - funktioniert 1.6 LCD ANzeige hinzugefügt und State maschine für Display LCD Anzeige bis Modul3 programiert 1.7 Modul 4,5,6,7,8,9,10 und 11 hinzugefügt.--- Funktioniert 1.8 Code verschönert, leerzeichen usw gelöscht - Funktioniert Bis hier nur nachrichten Empfangen ---------------------------------------------------------------- 2.0 Sendesequenz zu Modul 2/ 3 und4 implementiert Funtioniert - 2.1 Nachricht von Zentrale an 2, 3 4 funktioniert (2 nachrichten) ! 2.2 Nachrichtenstrukturt in eine pro Modul geändert 2.3 Modul 5, 6 und 8 eingepflegt Funktioniert! 2.4 Sendeintervall auf 500 mS gelegt und nachricht zu Modul 9 erstellt - Funktioniert 2.5 Nachricht an Modul 10 implementiert --- funktioniert -- -- Nachrichten Empfangen und senden. 2.6 AUsgaenge für LCD geändert ---------------------------------------------------------------- 3.0 Programm für SBH Sued hinzugefügt begin 3.1 Variable für Einschaltsequenz hinzu gefügt State Mashine für Einschaltsequenz begonnen (Programmstart der einzelnen Bereiche um 2 Sekunden verzögertamit nicht alle bereiche gleichzeitig schalten) State von SBH SUD programiert: Start 0 & Start 1 --- funktioniert 3.2 Abschalten Strom im Einfahrtsbereich bei CAN Nachricht 0x10009 hinzugefügt 3.3 Fehler in variablen für weichen Gleis1ger.... ersetzt mit Gleis1Ger Geradeaus in Großschreibung! Verarbeitung dre CAN Test Eingänge gelöscht State von SBH SUD programiert: SBHSUDGLEIS - funktioniert 3.4 Variablenen für FahrstromSBHSudGleis1State in zahlen umwandel und je eine leitung Data bei CAN zur übertragung Nachricht 0x10011 & Nachricht 0x10014 - Funktioniert 3.5 States für die Restlichen Gleise erstellt -- Funktioniert Nächster Schritt, zurückschalten dre einfahrtsweichen wenn Gleis besetzt State Maschine SBH Gleissteuerung fertig - funktioniert 3.6 Nachricht 0x100010 und 0x10009 geändert, da LSVmax und Weiche SBH Einfahrt von modul 2 auf Modul 3 verlegt worden sind Sendeintervall für Zeitkritsiche nachrichten auf 250mS geändert variable ist Interval 1 Änderung fahrstrom auf abstellgleisen schalten nicht regeln, ebenfalls bei Kreuzungen. Immer wenn gestoppt werden muß 3.7 3.8 berechnen und einstellen Fahrstrom allgemein FahrstromSBHWestAllgemeinState für die Abstellgleise in FahrstromSBHWestAbstellState geändert Somit gilt Allgemein nur drumherum state Mashine VMAX erstellt. Anscheinen Funktionstüchtig! ---------------------------------------------------------------- 4.0 Automatikbetrieb implementiert State Gleis 1 von Automatik erstellt, nächster Schritt ist bei Nächster! Einfahrt in den SPBA umschalten Fehler in State Maschine Vmax entfernt größer als zeichen mit kleiner als Zeichen bei 80 ersetzt Zur Fehlersuche die state Maschine zur eigentlichen Steuerung des SBH Süd (verteilug auf die Gleise) auskommentiert State Maschine Automatik funktioniert soweit bis auf, das wenn LSSBHSÜD EIN High ist und LSPOS im aktuellen gleis frei wird, wird nächstes Gleis losgeschickt. 4.1 ANstelle von LSVMAx nun State maschine für Automatik mit LSSBHSUd ein schalten-- funktioniert Sonderfall: wird automatikbetrieb ausgeschaltet während das aktuelle Gleis noch nicht frei ist (Enpos High. Wird fahrstrom für dieses Gleis nicht abgeschaltet (dies wird durch die State maschine SBH Sud Gleissteuerung aber behoben sobald ein Zug in eben dieses Gleis einfährt Fehler in CAN die Variable LSVmaxSudState wurde aus der Falschen Nachricht gelesen - korregiert 4.2 N/A 4.3 Kommunikation und Setzten der Variablen für die Anzeige SBH Sud implementiert --- Funktioniert 4.4 Feher in CAN Übertragung CAN MSG war in Klammern! beseitigt. Funktioniert ---------------------------------------------------------------- 5.0 Neues Konzept (State mashine) für SBH Süd erstellt State Initialisierung 1 und Initialisierung2 erstellt Abfrage nach Weichenstellung bei Start - funktioniert 5.1 State Bereit in SBHSued erstellt und funktioniert Hier müssen später noch die abfrage der taster für die Gleisausfahrt programiert werden 5.2 Stats Gleiseinfahrt erstellt 5.3 State Bereit geändert und State Weichenschalt eingeführt funktioniert 5.4 State Einfahrt funktioniert 5.5 Automatik betrieb integriert 5.6 Festgestellt das Fahrstrom SBH SÜd einfahr von Modul 2 auf Modul 3 gelegt werden muss (CAN MSG geändert) Automatikbetrieb scheint zu funktionieren (Test auf Anlage steht noch aus) 5.7 Taster zur ausfahrt aus Gleisen SBH hinzugefügt -- funktioniert Testboard 5.8 Geschwindigkeitsregelung programiert 5.9 Abschalten der Zufahrt Haupt und Zufahrt zum DSBH ninzigefügt. Die Daten zu CAN MSG hinzugefügt Neue state in State maschine für SBH eingefügt (Gleis 1- 5) 5.10 Modul 1 hinzugefügt 5.11 Tasten, die für die Steuerung des SBH (Glais ausfahrt) entfernt und CAN nachricht zum empfangen hinzugefügr ---------------------------------------------------------------- 6.0 Zentrale als eigenständige Einheit Programiert, tasten zur Steuerung Von Ebene 0 ab jetzt auf Stellwerk Digital Read und Definition der Ein und ausgänge herausgenommen, Ebenso Programmteil für das LCD - funktioniert auf Testbrett und in ANlage 6.1 Geschwindigkeitsstufen VMax auf Langsame lok angepasst. Schaltzeit für zeitraum ABstellgleis (wie lange braucht die Lok? angepasst Erster Test auf Anlage Ok 6.2 CAN Teil aufgeräumt, alle noch nicht verwendetetn CAN Nachrichten Senden gelöscht ---------------------------------------------------------------- 7.0 SBH West integriert - CAN Nachrichten & variablen für SBH West Eingefügt - kompelieren OK. 7.1 Bei VMAX SUD state Mashicne bei den States SUD ergänzt - kompelieren OK 7.2 State Maschine für West und Programmablauf hinzugefügt - kompelieren OK 7.3 uswerten von LSUMfahr SBH West und abschalten von Fahrstrom Umfahr SBH West und Fahrstrom Ausfahrt SBH West hinzu genommen 7.4 Fehlersuche loks fahren nicht in SBH West 7.5 Anfang der neuprogramierung der Module 7.6 Variablen für neues Modul 1 hinzugefügt sowie CAN Nachricht an Modul 1 bis 3angepasst 7.7 CAN nachrichten Modul 4 & 5 angepasst & alles zu VMAX entfernt ---------------------------------------------------------------- 8.0 Aufteilung auf meherere Taben - funktioniert 8.1 LCD zur Überprüfung der Einzelnen Module hier an Zentrale angehangen Werte für SBH sued zum Anzeigen auf LCD Programiert. Funktioniert auf Brett 8.2 Fahrstromdaten für tests angepasst (Geschwindigkeiten 8.3 LCD ANzeige für Wrte Ufahr geändert ---------------------------------------------------------------- 9.0 Bezeichnung zum Unterscheiden von Fahrspannung abschalten (Fahrstromxx) und Regelung via PWM (UFahrxxx) eingeführt Module 1 - 5 (SBHSued fertig gemacht ---------------------------------------------------------------- 9.1 CAN Nachrichten für Module 6 -11 angepasst 9.2 LCD Anzeige geändert für tests auf Testbrett ---------------------------------------------------------------- 10.1 Kreuzung programiert - Funktioniert auf Testbrett 10.2 Modul 9 bis 11 Hinzugefugt bzw gesetet 10.3 Geschwindigkeit für Ebene 0 an schnelle Loks angepasst 10.4 Bei Automatikbetrieb standzeit in SBHEinf verlängern 10.5 Geschwindigkeit wieder angepasset für SBH allgemein und Abstell 10.6 nicht genutzte CAN Nachrichten auskommentiert Status State Maschine und LS auf Display anzeigen ---------------------------------------------------------------- 11.0 CAN senden in die einzelnen State maschines gelegt in dre Tabe CAN nach nur nuch CAN Nachricht empfangen 11.1 CAN Nachricht CANMSG0x100009() an Modul 2 in die State mashine geschrieben 11.2 restlichen CAN Nachrichten als Funktion geschrieben */ // -------------------------------------- Umbenenen der STM Pins // Bliotheken //------------------------------------------------------------------------------------------------------------Testweise auskommentiert #include #include "stm32f103.h" // Bei selbst erstellten Bibliotheken der name immer in Anführungszeichen!! Nicht in größer kleiner als Zeichen! #include // Eingaenge const int AnzeigeWeiter = PB12; uint8_t AnzeigeWeiterState = 0; // Ausgaenge // LCD Ausgänge const int rs = PA6, en = PA7, d4 = PB0, d5 = PB1, d6 = PB10, d7 = PB11; LiquidCrystal lcd(rs, en, d4, d5, d6, d7); // Variablen // Variablen für system uint32_t SystemzeitEisenbahn = 0; // CAN uint8_t counter_msg = 0; // Zahler für nachricht wurde x mal versand erste nachricht uint8_t counter_msg1 = 0; // Zahler für nachricht wurde x mal versand zweite nachricht uint8_t counter_msg2 = 0; // Zahler für nachricht wurde x mal versand dritte nachricht uint8_t counter_msg3 = 0; // Zahler für nachricht wurde x mal versand 4 nachricht uint8_t counter_msg4 = 0; // Zahler für nachricht wurde x mal versand 5 nachricht uint8_t counter_msg5 = 0; // Zahler für nachricht wurde x mal versand 6 nachricht uint8_t counter_msg6 = 0; // Zahler für nachricht wurde x mal versand 7 nachricht uint8_t counter_msg7 = 0; // Zahler für nachricht wurde x mal versand 8 nachricht uint8_t frameLength = 0; // framelegth ist die länge der nachricht hier kann man auch im Sendeteil eine Zahl angeben unsigned long Zeit_Speicher0 = 0; // stores last time output was updated erste nachricht unsigned long Zeit_Speicher1 = 0; // stores last time output was updated zweite nachricht unsigned long Zeit_Speicher2 = 0; // stores last time output was updated dritte nachricht unsigned long Zeit_Speicher3 = 0; // stores last time output was updated 4 nachricht unsigned long Zeit_Speicher4 = 0; // stores last time output was updated 5 nachricht unsigned long Zeit_Speicher5 = 0; // stores last time output was updated 6 nachricht unsigned long Zeit_Speicher6 = 0; // stores last time output was updated 7 nachricht unsigned long Zeit_Speicher7 = 0; // stores last time output was updated 8 nachricht unsigned long Zeit_Speicher8 = 0; // stores last time output was updated 9 nachricht unsigned long Zeit_Speicher9 = 0; // stores last time output was updated 24 nachricht unsigned long Zeit_Speicher10 = 0; // stores last time output was updated 20 nachricht unsigned long Zeit_Speicher11 = 0; // stores last time output was updated 14 nachricht unsigned long Zeit_Speicher12 = 0; // stores last time output was updated 25 nachricht unsigned long Zeit_Speicher13 = 0; // stores last time output was updated 15 nachricht unsigned long Zeit_Speicher14 = 0; // stores last time output was updated 16 nachricht unsigned long Zeit_Speicher15 = 0; // stores last time output was updated 13 nachricht const long interval = 500; // transmission interval (milliseconds) Intervall in dem gesendet wird const long interval1 = 250; // transmission interval (milliseconds) Intervall in dem gesendet wird bool CANMSGGesendet = 0; // Einmaliges senden aller CAN Nachrichten CAN_msg_t CAN_TX_msg; // Initialisierung Senden CAN_msg_t CAN_RX_msg; // Initialisierung EMPFANGEN //-------------------------------------------------------Variablen der Module // Alle Farspannungen via PWM uint8_t UFahrSBHSudEinfahrtState = 110; // Verwendet: Modul 1, 2, 3, 4, 5 uint8_t UFahrKreuzungWendelSudState = 110; // Verwendet: Modul 2, 3, 4, 5 uint8_t UFahrSBHSudAusfahrtState = 110; // Verwendet: Modul 4, 5 uint8_t UFahrWendelSud1nach0State = 110; // Verwendet: Modul 1 uint8_t UFahrWendelWest1nach0State = 110; // Verwendet: Modul 11 uint8_t UFahrSBHWestAusfahrtState = 110; // Verwendet: Modul 6, 8 uint8_t UFahrSBHWestEinfahrtState = 110; // Verwendet: Modul 8, 9, 10 uint8_t UFahrSBHWestAbstellState = 110; // Verwendet: Modul 8 // modul 1 Wendel SBH Sued Ebene 0 uint8_t FahrstromHauptSBHSudState = 0; bool FahrstromFehlerModul1 = 0; // Modul 2 SBH Sued Einfahrt uint8_t LSEinfahrtSBHSudState = 0; uint8_t LSEinfahrtWendelSudUState = 0; uint8_t FahrstromEinzahrtWendelSudState = 0; uint8_t WeicheEinfahrtSBHSudGeradeausState = 0; uint8_t WeicheEinfahrtSBHSudAbbiegenState = 0; uint8_t LSUmfahrSBHSudState = 0; bool FahrstromFehlerModul2 = 0; uint8_t M2Ein = 0; // Zaehler für LSEinfahrt SBH Sud zum Testen bool LSEeingezahlt = 0; uint8_t ZentraleEin = 0; // Modul 3 SBH Süd rechts uint8_t LSEinfahrtSBHSudGleis1State = 0; uint8_t LSEinfahrtSBHSudGleis2State = 0; uint8_t LSEinfahrtSBHSudGleis3State = 0; uint8_t LSEinfahrtSBHSudGleis4State = 0; uint8_t LSEinfahrtSBHSudGleis5State = 0; uint8_t FahrstromEinfahrtSBHSudState = 0; // An Abschalten uint8_t WeicheSBHSudGleis1GeradeausState = 0; // schalten uint8_t WeicheSBHSudGleis1AbbiegenState = 0; // schalten uint8_t WeicheSBHSudGleis2GeradeausState = 0; // schalten uint8_t WeicheSBHSudGleis2AbbiegenState = 0; // schalten uint8_t WeicheSBHSudGleis3GeradeausState = 0; // schalten uint8_t WeicheSBHSudGleis3AbbiegenState = 0; // schalten uint8_t WeicheSBHSudGleis4GeradeausState = 0; // schalten uint8_t WeicheSBHSudGleis4AbbiegenState = 0; // schalten bool FahrstromFehlerModul3 = 0; // An Abschalten // Modul 4 SBH süd links uint8_t LSEndposSBHSudGleis1State = 0; uint8_t LSEndposSBHSudGleis2State = 0; uint8_t LSEndposSBHSudGleis3State = 0; uint8_t LSEndposSBHSudGleis4State = 0; uint8_t LSEndposSBHSudGleis5State = 0; uint8_t FahrstromSBHSudGleis1State = 0; // An Abschalten uint8_t FahrstromSBHSudGleis2State = 0; // An Abschalten uint8_t FahrstromSBHSudGleis3State = 0; // An Abschalten uint8_t FahrstromSBHSudGleis4State = 0; // An Abschalten uint8_t FahrstromSBHSudGleis5State = 0; // An Abschalten uint8_t UFahrWendelSudKreuzungState = 0; // An Abschalten uint8_t UFahrSBHSudAbstellState = 0; // Regelung PWM bool FahrstromFehlerModul4 = 0; // Modul 5 SBH Süd Kehrschleife uint8_t LSEinfahrtKehrschleifeSBHSudState = 0; uint8_t FahrstromSBHSudWendelSudState = 0; uint8_t WeicheKehrschleifeSBHSudGeradeausState = 0; uint8_t WeicheKehrschleifeSBHSudAbbiegenState = 0; bool FahrstromFehlerModul5 = 0; // Anzeige SBH Sud uint8_t StateGleis1SBHSud = 0; // 0 = keine Daten / 1 = Frei / 2 = Belegt / 3 = Fehler / 4 = Einfahrt uint8_t StateGleis2SBHSud = 0; uint8_t StateGleis3SBHSud = 0; uint8_t StateGleis4SBHSud = 0; uint8_t StateGleis5SBHSud = 0; uint8_t StateSBHSud = 0; // 0 = Keine daten / 1 = Bereit / 2 = Belegt / 3 = Automatik // Modul 6 Kreuzung uint8_t LSEinfahrtSBHWestWendelSudState = 0; uint8_t LSEinfahrtSBHWestWendelWestState = 0; uint8_t LSEinfahrtSBHSudWendelWestState = 0; uint8_t FahrstromSBHSudWendelWestState = 0; uint8_t FahrstromSBHWestWendelWestState = 0; uint8_t FahrstromSBHWestWendelSudState = 0; // uint8_t FahrstromKreuzungAllgemeinState = 0; uint8_t WeicheKehrschleifeSBHWestGeradeausState = 0; uint8_t WeicheKehrschleifeSBHWestAbbiegenState = 0; bool FahrstromFehlerModul6 = 0; // Modul 8 SBH West rechts uint8_t LSEndposSBHWestGleis1State = 0; uint8_t LSEndposSBHWestGleis2State = 0; uint8_t LSEndposSBHWestGleis3State = 0; uint8_t LSEndposSBHWestGleis4State = 0; uint8_t LSEndposSBHWestGleis5State = 0; uint8_t LSUmfahrSBHWestState = 0; uint8_t FahrstromSBHWestGleis1State = 0; uint8_t FahrstromSBHWestGleis2State = 0; uint8_t FahrstromSBHWestGleis3State = 0; uint8_t FahrstromSBHWestGleis4State = 0; uint8_t FahrstromSBHWestGleis5State = 0; uint8_t FahrstromUmfahrSBHWestState = 0; uint8_t FahrstromAusfahrtSBHWestState = 0; bool FahrstromFehlerModul8 = 0; // Modul 9 SBH West Links uint8_t LSEinfahrtSBHWestGleis1State = 0; uint8_t LSEinfahrtSBHWestGleis2State = 0; uint8_t LSEinfahrtSBHWestGleis3State = 0; uint8_t LSEinfahrtSBHWestGleis4State = 0; uint8_t LSEinfahrtSBHWestGleis5State = 0; uint8_t WeicheSBHWestGleis1GeradeausState = 0; uint8_t WeicheSBHWestGleis1AbbiegenState = 0; uint8_t WeicheSBHWestGleis2GeradeausState = 0; uint8_t WeicheSBHWestGleis2AbbiegenState = 0; uint8_t WeicheSBHWestGleis3GeradeausState = 0; uint8_t WeicheSBHWestGleis3AbbiegenState = 0; uint8_t WeicheSBHWestGleis4GeradeausState = 0; uint8_t WeicheSBHWestGleis4AbbiegenState = 0; bool FahrstromFehlerModul9 = 0; // Modul 10 Einfahrt SBH West uint8_t LSEinfahrtSBHWestState = 0; uint8_t FahrstromEinfahrtSBHWestState = 0; uint8_t WeicheEinfahrtSBHWestGeradeausState = 0; uint8_t WeicheEinfahrtSBHWestAbbiegenState = 0; bool FahrstromFehlerModul10 = 0; // Modul 11 Wendel West Ebene 0 uint8_t LSEinfahrtWendelWest0State = 0; uint8_t FahrstromHauptSBHWestState = 0; bool FahrstromFehlerModul11 = 0; // Variablen Stellpult Ebene 0 uint8_t TastSBHSudGleis1State = 1; // Da Schalter und Taster Low (0) aktiv sind müssen diese Variablen auf 1 gesetzt werden. Sonst würde bei ausfall der Nachricht immer losgefahren werden uint8_t TastSBHSudGleis2State = 1; uint8_t TastSBHSudGleis3State = 1; uint8_t TastSBHSudGleis4State = 1; uint8_t TastSBHSudGleis5State = 1; uint8_t SchaltSBHSudAutomatikState = 1; uint8_t SchaltSBHSudWendeState = 1; uint8_t SchaltSBHSudDurchfahrtState = 1; uint8_t SchaltSBHSudVorbeifahrtState = 1; uint8_t SchaltWendel0WestSudState = 1; uint8_t SchaltWendel0WestWestState = 1; uint8_t SchaltWendel0SudWestState = 1; uint8_t SchaltWendel0SudSudState = 1; uint8_t TastSBHWestGleis1State = 1; // Da Schalter und Taster Low (0) aktiv sind müssen diese Variablen auf 1 gesetzt werden. Sonst würde bei ausfall der Nachricht immer losgefahren werden uint8_t TastSBHWestGleis2State = 1; uint8_t TastSBHWestGleis3State = 1; uint8_t TastSBHWestGleis4State = 1; uint8_t TastSBHWestGleis5State = 1; uint8_t SchaltSBHWestAutomatikState = 1; uint8_t SchaltSBHWestWendeState = 1; uint8_t SchaltSBHWestDurchfahrtState = 1; uint8_t SchaltSBHWestVorbeifahrtState = 1; // Variablen für Programteil SBH Sued Steuerung unsigned long ZeitspeicherSBHSud1 = 0; // Zeitspeicher für State Maschine SBH Sued unsigned long SchaltZeitSBHSud1 = 1500 ; // Schaltzeiten für State Maschine in SBU Sued unsigned long SchaltZeitSBHSud2 = 10000; // Schaltzeit 1 innerhalb der Lok Gleisende vom ABstellgleis erreicht haben muß unsigned long ZeitspeicherEinschaltSequenzSud = 0; // Zeitspeicher für State Maschine SBH Sued unsigned long SchaltZeitEinschaltseqenzSud = 2000 ; // Schaltzeiten für State Maschine in SBU Sued unsigned long ZeitMesstreckeSud = 2500; // Zeitspanne die eine Lok für die messtrecke brauchen sollte unsigned long ZeitspeicherSBHSud2 = 0; // Zeitspeicher für State Maschine SBH SUd VMAX unsigned long ZeitspeicherAUTOSBHSUD = 0; // Zeitspeicher für State Maschine SBH SUd Automatik unsigned long SchaltZeitAUTOSBHSUD = 1000; // Anschaltzeit für Abstellgleis bei Automatikbetrieb uint8_t FahrstromSBHSudAbstellZwischenspeicher = 0; // Zwischenspeicher für Fahrstrom in den ABstellgleisen bool SBHSudOn = false; // Variable um die einzelnen Abschnitte nach und nach einzuschalten (Stromstoß im Einschaltmoment bool EinFahrtSBHSudGleis1 = false; // bool VARSBHSudVollState = false; // SBH Süd voll int AutoaktSudGleis = 0; // Variable welches Gleis zuletzt ausgefahren ist bei Automatikbetrieb unsigned long SBHSUDaktGleis = 0; // Anzeige naechstes freies Gleis in SBH Sued bool LSEinfahrtSBHSudStateGeschaltet = false; // Variable um LS auch bei kurzen Zugen lange genug zu halten uint8_t SBHSudStatus = 0; // Statusanzeige für SBH Sued bool VARSBHSudFehlerState = 0; // Fehler in SBH Süd // Variablen für Programteil SBH West Steuerung unsigned long ZeitspeicherSBHWest1 = 0; // Zeitspeicher für State Maschine SBH West unsigned long SchaltZeitSBHWest1 = 1500 ; // Schaltzeiten für State Maschine in SBU West unsigned long SchaltZeitSBHWest2 = 10000; // Schaltzeit 1 innerhalb der Lok Gleisende vom ABstellgleis erreicht haben muß unsigned long ZeitspeicherEinschaltSequenzWest = 0; // Zeitspeicher für State Maschine SBH West unsigned long SchaltZeitEinschaltseqenzWest = 2000 ; // Schaltzeiten für State Maschine in SBU West unsigned long ZeitMesstreckeWest = 2500; // Zeitspanne die eine Lok für die messtrecke brauchen sollte unsigned long ZeitspeicherSBHWest2 = 0; // Zeitspeicher für State Maschine SBH SUd VMAX unsigned long ZeitspeicherAUTOSBHWEST = 0; // Zeitspeicher für State Maschine SBH SUd Automatik unsigned long SchaltZeitAUTOSBHWEST = 4000; // Anschaltzeit für Abstellgleis bei Automatikbetrieb uint8_t FahrstromSBHWestAbstellState = 0; // Variable Fahrstrom der Abstellgleise wird durch die Geschwindigkeit der Lok im SBH bestimmt uint8_t FahrstromSBHWestAbstellZwischenspeicher = 0; // Zwischenspeicher für Fahrstrom in den ABstellgleisen bool SBHWestOn = false; // Variable um die einzelnen Abschnitte nach und nach einzuschalten (Stromstoß im Einschaltmoment bool EinFahrtSBHWestGleis1 = false; // bool VARSBHWestVollState = false; // SBH Süd voll int AutoaktWestGleis = 0; // Variable welches Gleis zuletzt ausgefahren ist bei Automatikbetrieb unsigned long SBHWESTaktGleis = 0; // Anzeige naechstes freies Gleis in SBH West bool LSEinfahrtSBHWestStateGeschaltet = false; // Variable um LS auch bei kurzen Zugen lange genug zu halten uint8_t SBHWestStatus = 0; // Statusanzeige für SBH West bool VARSBHWestFehlerState = 0; // Fehler in SBH Sued // Variablen für Programteil Steuerung Kreuzung unsigned long ZeitspeicherKreuzungModul6A = 0; uint8_t KREUZUNGMODUL6AState = 0; // --------------- State Maschine Einschaltsequenz enum EINSCHALTSEQUENZ { EINSTART0, EINSTART1, EINSBHSUD, EINKREUZUNG0, EINSBHWEST, }; EINSCHALTSEQUENZ akt_state_EINSCHALTSEQUENZ = EINSTART0; EINSCHALTSEQUENZ next_state_EINSCHALTSEQUENZ = EINSTART1; // ----------------- State Mashine zur Steuerung von Schattenbahnhof Sud enum SBHSUD { SBHSUDINITIALISIERUNG1, SBHSUDINITIALISIERUNG2, SBHSUDBEREIT, SBHSUDWEICHENSCHALT, SBHSUDEINFAHRT, SBHSUDAUTOMATIK, SBHSUDAUSFAHRT, SBHSUDAUSFAHRTMANUELL, SBHSUDGLEIS1, SBHSUDGLEIS2, SBHSUDGLEIS3, SBHSUDGLEIS4, SBHSUDGLEIS5 }; SBHSUD akt_state_SBHSUD = SBHSUDBEREIT; SBHSUD next_state_SBHSUD = SBHSUDINITIALISIERUNG1; // ----------------- State Mashine zur Steuerungvon SBH Sued Ende // ----------------- State Mashine zur Steuerung von Schattenbahnhof West enum SBHWEST { SBHWESTINITIALISIERUNG1, SBHWESTINITIALISIERUNG2, SBHWESTBEREIT, SBHWESTWEICHENSCHALT, SBHWESTEINFAHRT, SBHWESTAUTOMATIK, SBHWESTAUSFAHRT, SBHWESTAUSFAHRTMANUELL, SBHWESTGLEIS1, SBHWESTGLEIS2, SBHWESTGLEIS3, SBHWESTGLEIS4, SBHWESTGLEIS5 }; SBHWEST akt_state_SBHWEST = SBHWESTBEREIT; SBHWEST next_state_SBHWEST = SBHWESTINITIALISIERUNG1; // ----------------- State Mashine zur Steuerungvon SBH West Ende // ----------------- State Mashine zur Steuerung vom LCD An Zentrale enum LCDZENTRALE { TEST1, TEST2, TEST3, TEST6, STATEMASCHKREUZUNG, }; LCDZENTRALE akt_state_LCDZENTRALE = TEST1; LCDZENTRALE next_state_LCDZENTRALE = TEST1; // ----------------- State Mashine zur Steuerung der Kreuzung auf Modul 6 enum KREUZUNGMODUL6A { KREUZUNGBEREIT, SBHWESTWENDELSUD, SBHWESTWENDELWEST, SBHSUDWENDELWEST, SBHSUDWENDELSUD, KREUZUNGEBENE0WARTEN }; KREUZUNGMODUL6A akt_state_KREUZUNGMODUL6A = KREUZUNGBEREIT; KREUZUNGMODUL6A next_state_KREUZUNGMODUL6A = KREUZUNGBEREIT; void setup() { // -------------------------------------- pinMode pinMode(LED_BUILTIN, OUTPUT); //LED auf Arduino Blinken um programierung zu bestätigen delay(1500); digitalWrite(PC13, HIGH); delay(500); digitalWrite(PC13, LOW); delay(500); digitalWrite(PC13, HIGH); delay(500); digitalWrite(PC13, LOW); delay(500); digitalWrite(PC13, HIGH); // CAN aktivieren { Serial.begin(115200); bool ret = CANInit(CAN_500KBPS, 0); // CAN_RX mapped to PA11, CAN_TX mapped to PA12 if (!ret) while (true); } { // LCD initialisieren { lcd.begin(20, 4); lcd.print("Tach Kay!"); delay(1000); } } } void loop() { //------------- Begin Testzwecke // ------------------ Systemreferenzen SystemzeitEisenbahn = SystemzeitEisenbahn + 1; // Variable zur syncronisation der kompletten Anlage // ------------------------------------------------------------ Einschaltsequenz { //------------------------------ Begin State Machine Einschaltsequenz if (next_state_EINSCHALTSEQUENZ != akt_state_EINSCHALTSEQUENZ) // Hat sich der State geändert ? { switch (next_state_EINSCHALTSEQUENZ) // State Mashine für Wechselzwischen den Sates { case EINSTART0: { ZeitspeicherEinschaltSequenzSud = millis(); break; } case EINSTART1: { ZeitspeicherEinschaltSequenzSud = millis(); break; } case EINSBHSUD: { ZeitspeicherEinschaltSequenzSud = millis(); break; } } akt_state_EINSCHALTSEQUENZ = next_state_EINSCHALTSEQUENZ; // -----------------Zustand Next in Zustand aktuell schreiben } switch (akt_state_EINSCHALTSEQUENZ) // Eigentliche State mschine für SBH Sued { case EINSTART0: { break; } case EINSTART1: { // Sicherstellen das Programme in dre Zentrale nach und nach schalten if (millis() - SchaltZeitEinschaltseqenzSud > ZeitspeicherEinschaltSequenzSud) { next_state_EINSCHALTSEQUENZ = EINSBHSUD; } break; } case EINSBHSUD: { SBHSudOn = true; break; } } //------------------------------ Ende State Machine Einschaltsequenz } // ----------------------------- Ende Programm zur Steuerung der Einschaltsequenz // ---------- Aufrufen der Taben CAN(); SBHSUD(); KREUZUNG(); SBHWEST(); // Einmaliges Versenden aller CAN Nachrichten if (CANMSGGesendet == 0) { CANMSGSBHSUD(); CANMSGGesendet = 1; } //Auslesen der Eingaenge AnzeigeWeiterState = digitalRead(AnzeigeWeiter); // LCD Anzeige an Zentrale if (next_state_LCDZENTRALE != akt_state_LCDZENTRALE) // Hat sich der State geändert ? { switch (next_state_LCDZENTRALE) // State Mashine für Wechselzwischen den Sates { case TEST1: { lcd.clear(); break; } case TEST2 : { lcd.clear(); break; } case TEST3: { lcd.clear(); break; } case TEST6 : { lcd.clear(); break; } case STATEMASCHKREUZUNG: { lcd.clear(); break; } } akt_state_LCDZENTRALE = next_state_LCDZENTRALE; // -----------------Zustand Next in Zustand aktuell schreiben } switch (akt_state_LCDZENTRALE) // Eigentliche State mschine für SBH Sued { case TEST1: { lcd.setCursor(0, 0); if (SBHSudStatus == 1) { lcd.print("St.Masch = Bereit "); } if (SBHSudStatus == 2) { lcd.print("St.Masch = Ausfahrt"); } if (SBHSudStatus == 3) { lcd.print("St.Masch = W-schalt"); } if (SBHSudStatus == 4) { lcd.print("St.Masch = Einfahrt"); } if (SBHSudStatus == 5) { lcd.print("St.Masch = Ausf-man "); } lcd.setCursor(0, 1); lcd.print("Aktuelles Gleis = "); lcd.print(SBHSUDaktGleis); lcd.setCursor(0, 2); lcd.print("G1 Ein = "); lcd.print(LSEinfahrtSBHSudGleis1State); lcd.print("Endpo = "); lcd.print(LSEndposSBHSudGleis1State); lcd.setCursor(0, 3); lcd.print("UFahrAbst. = "); lcd.print(UFahrSBHSudAbstellState); if (AnzeigeWeiterState == 0) { next_state_LCDZENTRALE = TEST2; } break; } case TEST2: { lcd.setCursor(0, 0); lcd.print("LSEinZentrale ="); lcd.print(ZentraleEin); lcd.setCursor(0, 1); lcd.print("LSEinModul2 ="); lcd.print(M2Ein); lcd.setCursor(0, 2); lcd.print("M6 Sued -> West = "); lcd.print(LSEinfahrtSBHSudWendelWestState); lcd.setCursor(0, 3); lcd.print("M3 Sued -> Sued = "); lcd.print(LSEinfahrtKehrschleifeSBHSudState ); if (AnzeigeWeiterState == 0) { next_state_LCDZENTRALE = TEST3; } break; } case TEST3: { lcd.setCursor(0, 0); lcd.print("M8 LSEndPosG1 = "); lcd.print(LSEndposSBHWestGleis1State); lcd.setCursor(0, 1); lcd.print("M9 LSEinfG1 = "); lcd.print(LSEinfahrtSBHWestGleis1State); lcd.setCursor(0, 2); lcd.print("M10 LSEinfWest = "); lcd.print(LSEinfahrtSBHWestState); lcd.setCursor(0, 3); lcd.print("M11 Fehler = "); lcd.print(FahrstromFehlerModul11); if (AnzeigeWeiterState == 0) { next_state_LCDZENTRALE = STATEMASCHKREUZUNG; } break; } case STATEMASCHKREUZUNG: { lcd.setCursor(0, 0); lcd.print("Zustand State Masch."); lcd.setCursor(0, 1); lcd.print("Kreuzung = "); lcd.print(KREUZUNGMODUL6AState); lcd.setCursor(0, 2); if (KREUZUNGMODUL6AState == 0) // Zustand der State maschine angeigen { lcd.print("----Keine Daten----"); } if (KREUZUNGMODUL6AState == 1) // Zustand der State maschine angeigen { lcd.print("-------Bereit------"); } if (KREUZUNGMODUL6AState == 2) // Zustand der State maschine angeigen { lcd.print("-SBHWest->WendelSud-"); } if (KREUZUNGMODUL6AState == 3) // Zustand der State maschine angeigen { lcd.print("-SBHWest->WendelWest"); } if (KREUZUNGMODUL6AState == 4) // Zustand der State maschine angeigen { lcd.print("-SBHSud->WendelWest-"); } if (KREUZUNGMODUL6AState == 5) // Zustand der State maschine angeigen { lcd.print("-SBHSud->WendelSud--"); } if (KREUZUNGMODUL6AState == 6) // Zustand der State maschine angeigen { lcd.print("------Warten--------"); } if (AnzeigeWeiterState == 0) { next_state_LCDZENTRALE = TEST1; } break; } } // ----------------- Tests if (LSEinfahrtSBHSudState == 1) { if (LSEeingezahlt == 0) { ZentraleEin = ZentraleEin + 1; LSEeingezahlt = 1; } } else { LSEeingezahlt = 0; } }