API tools faq
paste
KGBRUS

State_Maschdef

KGBRUS
Jan 6th, 2025
387
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 10.66 KB | Fixit | 0 0
raw download clone embed print report
  1. /*History Version 1.0 Ein & AUsgänge definiert 19.05.23 sowie CAN Nachrit senden
  2. 1.2 Leerzeilen gelöscht und CANmsg noch oben verschoben ungetestet
  3. 2.0 Empfangen von nachricht von Zentrale ausgänge Fahrgfleise 1 - 5 SBH - funktioniert
  4. Nachricht 0x100011 für Fahrstöme geändert - funktioniert
  5. 3.0 Für Abstellgkleise das abschalten auf an/ aus gestellt
  6. Bei test auf Anlage festgestellt, das LSPOS ständig zwischen High & LOW wechselt (Fehler behoben!)
  7. 3.1 Ausgang PWM Fahrstrom SBHSüdAllgemein auf PB0 geändert sowie
  8. 3.2 PWM Frequenz für Fahrstom auf 100HZ geändert
  9. 4.0 Neue Fahrspannungen PWM hinzugefügt und CAN nachrichten bearbeitet
  10. 5.0 Bezeichnung zum Unterscheiden von Fahrspannung abschalten (Fahrstromxx) und Regelung via PWM (UFahrxxx) eingeführt
  11. 5.1 Sendeintervall CAN auf 100ms
  12. 5.2 CAN nachricht in funktion geschrieben, ebnso Eingaenge auslesen und state Maschine zum CAN senden
  13.  
  14.  
  15.  
  16. */
  17. // -------------------------------------- Umbenenen der STM Pins
  18. // Bliotheken
  19. //------------------------------------------------------------------------------------------------------------Testweise auskommentiert #include <assert.h>
  20. #include "stm32f103.h" // Bei selbst erstellten Bibliotheken der name immer in Anfuehrungszeichen!! Nicht in <> kleiner als Zeichen!
  21.  
  22. // EIngaenge
  23. // Lichtschranke
  24. const int LSEndposSBHSudGleis1 = PB12;
  25. const int LSEndposSBHSudGleis2 = PB13;
  26. const int LSEndposSBHSudGleis3 = PB14;
  27. const int LSEndposSBHSudGleis4 = PB15;
  28. const int LSEndposSBHSudGleis5 = PA8;
  29. const int SensorFahrstrom = PA2;
  30.  
  31. uint8_t LSEndposSBHSudGleis1State = 0;
  32. uint8_t LSEndposSBHSudGleis2State = 0;
  33. uint8_t LSEndposSBHSudGleis3State = 0;
  34. uint8_t LSEndposSBHSudGleis4State = 0;
  35. uint8_t LSEndposSBHSudGleis5State = 0;
  36. uint8_t SensorFahrstromState = 0;
  37.  
  38.  
  39. // Ausgaenge
  40.  
  41. const int FahrstromSBHSudGleis1 = PA0; // An Abschalten
  42. const int FahrstromSBHSudGleis2 = PA1; // An Abschalten
  43. const int FahrstromSBHSudGleis3 = PB11; // An Abschalten
  44. const int FahrstromSBHSudGleis4 = PA5; // An Abschalten
  45. const int FahrstromSBHSudGleis5 = PA4; // An Abschalten
  46. const int UFahrSBHSudEinfahrt = PB0; // Regelung PWM
  47. const int UFahrKreuzungWendelSud = PA3; // Regelung PWM
  48. const int UFahrSBHSudAbstell = PA6; // Regelung PWM für alle Abstellgleise
  49. const int UFahrSBHSudAusfahrt = PB1; // Regelung PWM ausfahrtsgleis aus SBH Sued
  50. const int FahrstromModulNotHalt = PA7; // An Abschalten
  51. const int FahrstromWendelSudKreuzung = PB10; // An Abschalten
  52.  
  53.  
  54.  
  55. uint8_t FahrstromSBHSudGleis1State = 0;
  56. uint8_t FahrstromSBHSudGleis2State = 0;
  57. uint8_t FahrstromSBHSudGleis3State = 0;
  58. uint8_t FahrstromSBHSudGleis4State = 0;
  59. uint8_t FahrstromSBHSudGleis5State = 0;
  60. uint8_t UFahrSBHSudEinfahrtState = 0;
  61. uint8_t UFahrKreuzungWendelSudState = 0;
  62. uint8_t UFahrSBHSudAbstellState = 0;
  63. uint8_t UFahrSBHSudAusfahrtState = 110;
  64. uint8_t FahrstromModulNotHaltState = 0;
  65. uint8_t FahrstromWendelSudKreuzungState = 0;
  66.  
  67.  
  68.  
  69. // Variablen
  70. // CAN
  71. uint8_t counter = 0; // Zahler für nachricht wurde x mal versand
  72. uint8_t frameLength = 0; // framelegth ist die länge der nachricht hier kann man auch im Sendeteil eine Zahl angeben
  73. unsigned long previousMillis = 0; // stores last time output was updated
  74. const long interval = 100; // transmission interval (milliseconds) Intervall in dem gesendet wird
  75. CAN_msg_t CAN_TX_msg; // Initialisierung Senden
  76. CAN_msg_t CAN_RX_msg; // Initialisierung EMPFANGEN
  77. // Sonstige Variablen
  78.  
  79. bool FahrstromFehlerModul4 = 0;
  80.  
  81.  
  82. // ----------------------------- Funktionen
  83. // CAN senden
  84.  
  85. void CANMSG0x100003()
  86. {
  87. // Auslesen der Sensoren
  88. // AUSLESENSENSOREN();
  89. // ---------------------------- CAN Nachricht 0x10003 senden
  90. // eigentliche Daten werden eingefüllt
  91.  
  92. bitWrite (CAN_TX_msg.data[0], 0, LSEndposSBHSudGleis1State); // mit bitwrite lassen sich einzelne bits innerhalb eines Bytes beschreiben. Hier Zustand TasterState in Erstes (ganz rechtes) Bit von Data0 schreiben
  93. bitWrite (CAN_TX_msg.data[0], 1, LSEndposSBHSudGleis2State);
  94. bitWrite (CAN_TX_msg.data[0], 2, LSEndposSBHSudGleis3State);
  95. bitWrite (CAN_TX_msg.data[0], 3, LSEndposSBHSudGleis4State);
  96. bitWrite (CAN_TX_msg.data[0], 4, LSEndposSBHSudGleis5State);
  97. bitWrite (CAN_TX_msg.data[0], 5, FahrstromFehlerModul4);
  98. CAN_TX_msg.len = 1;
  99. unsigned long currentMillis = millis(); // Senden alle x millisekunden
  100. if (currentMillis - previousMillis >= interval)
  101. {
  102. previousMillis = currentMillis;
  103. if ( ( counter % 2) == 0)
  104. { // Rest der Nachricht wird befüllt
  105. CAN_TX_msg.type = DATA_FRAME;
  106. if (CAN_TX_msg.len == 0) CAN_TX_msg.type = REMOTE_FRAME;
  107. CAN_TX_msg.format = EXTENDED_FORMAT;
  108. CAN_TX_msg.id = 0x100003; // nachrichten ID
  109. }
  110. CANSend(&CAN_TX_msg); // Übergabe der Nachricht an die Hardware
  111. }
  112. }
  113. void AUSLESENSENSOREN()
  114. {
  115. LSEndposSBHSudGleis1State = digitalRead (LSEndposSBHSudGleis1);
  116. LSEndposSBHSudGleis2State = digitalRead (LSEndposSBHSudGleis2);
  117. LSEndposSBHSudGleis3State = digitalRead (LSEndposSBHSudGleis3);
  118. LSEndposSBHSudGleis4State = digitalRead (LSEndposSBHSudGleis4);
  119. LSEndposSBHSudGleis5State = digitalRead (LSEndposSBHSudGleis5);
  120.  
  121. }
  122.  
  123.  
  124. enum MODUL4ENDPOS
  125. {
  126. BEREIT, SENDEN1, WARTEN, SENDEN2,
  127. };
  128. MODUL4ENDPOS akt_state_MODUL4ENDPOS = BEREIT;
  129. MODUL4ENDPOS next_state_MODUL4ENDPOS = BEREIT;
  130. void setup()
  131. {
  132. pinMode(LED_BUILTIN, OUTPUT); //LED auf Arduino Blinken um programierung zu bestätigen
  133. delay(1500);
  134. digitalWrite(PC13, HIGH);
  135. delay(500);
  136. digitalWrite(PC13, LOW);
  137. delay(500);
  138. digitalWrite(PC13, HIGH);
  139. delay(500);
  140. digitalWrite(PC13, LOW);
  141. delay(500);
  142. digitalWrite(PC13, HIGH);
  143.  
  144. // CAN aktivieren
  145. {
  146. Serial.begin(115200);
  147. bool ret = CANInit(CAN_500KBPS, 0); // CAN_RX mapped to PA11, CAN_TX mapped to PA12
  148. if (!ret) while (true);
  149. }
  150. // -------------------------------------- pinMode
  151. pinMode(LSEndposSBHSudGleis1, INPUT);
  152. pinMode(LSEndposSBHSudGleis2, INPUT);
  153. pinMode(LSEndposSBHSudGleis3, INPUT);
  154. pinMode(LSEndposSBHSudGleis4, INPUT);
  155. pinMode(LSEndposSBHSudGleis5, INPUT);
  156. pinMode(SensorFahrstrom, INPUT);
  157.  
  158. pinMode(FahrstromSBHSudGleis1, OUTPUT);
  159. pinMode(FahrstromSBHSudGleis2, OUTPUT);
  160. pinMode(FahrstromSBHSudGleis3, OUTPUT);
  161. pinMode(FahrstromSBHSudGleis4, OUTPUT);
  162. pinMode(FahrstromSBHSudGleis5, OUTPUT);
  163. pinMode(UFahrSBHSudEinfahrt, OUTPUT);
  164. pinMode(UFahrKreuzungWendelSud, OUTPUT);
  165. pinMode(UFahrSBHSudAbstell, OUTPUT);
  166. pinMode(UFahrSBHSudAusfahrt, OUTPUT);
  167. pinMode(FahrstromModulNotHalt, OUTPUT);
  168. pinMode(FahrstromWendelSudKreuzung, OUTPUT);
  169.  
  170. CANMSG0x100003(); // CAN Nachricht einmalig versenden
  171.  
  172. }
  173.  
  174. void loop()
  175. {
  176. // ---------------------------- Begin CAN Empfangen
  177. // ---------------------------- CAN Nachricht 0x100011 Daten Fahrgeschwindigkeit SBH Sud und allgemein
  178. if (CANMsgAvail())
  179. {
  180. CANReceive(&CAN_RX_msg); // Prüfen ob neue Nachricht empfangen werden kann (liegt eine neue Nachricht zum abholen bereit?)
  181. if (CAN_RX_msg.type == DATA_FRAME)
  182. {
  183. if (CAN_RX_msg.id == 0x100011) // Empfang der nachricht 0x100011 von von Zentrale (alle Variabelen zu SBH Sued)
  184. {
  185. FahrstromSBHSudGleis1State = bitRead (CAN_RX_msg.data[0], 0);
  186. FahrstromSBHSudGleis2State = bitRead (CAN_RX_msg.data[0], 1);
  187. FahrstromSBHSudGleis3State = bitRead (CAN_RX_msg.data[0], 2);
  188. FahrstromSBHSudGleis4State = bitRead (CAN_RX_msg.data[0], 3);
  189. FahrstromSBHSudGleis5State = bitRead (CAN_RX_msg.data[0], 4);
  190. UFahrSBHSudEinfahrtState = CAN_RX_msg.data[1];
  191. UFahrSBHSudAbstellState = CAN_RX_msg.data[2];
  192. UFahrKreuzungWendelSudState = CAN_RX_msg.data[3];
  193. UFahrSBHSudAusfahrtState = CAN_TX_msg.data[4];
  194. }
  195. }
  196. }
  197. //------------------------ ENDE CAN
  198. // ----------------------- State Maschine
  199. {
  200. if (next_state_MODUL4ENDPOS != akt_state_MODUL4ENDPOS)
  201. {
  202. switch (next_state_MODUL4ENDPOS)
  203. {
  204. case BEREIT:
  205. {
  206. break;
  207. }
  208. case SENDEN1:
  209. {
  210. break;
  211. }
  212. case WARTEN:
  213. {
  214. break;
  215. }
  216. case SENDEN2:
  217. {
  218. break;
  219. }
  220. }
  221. akt_state_MODUL4ENDPOS = next_state_MODUL4ENDPOS; // Zustand in akt zustand schreiben
  222. }
  223. switch (akt_state_MODUL4ENDPOS)
  224. {
  225. case BEREIT:
  226. {
  227. AUSLESENSENSOREN();
  228. // if (LSEndposSBHSudGleis1State == HIGH || LSEndposSBHSudGleis2State == HIGH || LSEndposSBHSudGleis3State == HIGH || LSEndposSBHSudGleis4State == HIGH || LSEndposSBHSudGleis5State == HIGH)
  229. {
  230. // next_state_MODUL4ENDPOS = SENDEN1;
  231. }
  232. }
  233. case SENDEN1:
  234. {
  235. digitalWrite(FahrstromSBHSudGleis1, HIGH);
  236. CANMSG0x100003();
  237. next_state_MODUL4ENDPOS = BEREIT;
  238. break;
  239. }
  240.  
  241. }
  242.  
  243. }
  244. // Ausgaenge schalten
  245. {
  246. //--------------------------- begin PWM Ausgaenge setzten
  247. analogWriteFrequency(100);
  248. analogWrite(UFahrSBHSudAbstell, UFahrSBHSudAbstellState);
  249. analogWrite(UFahrSBHSudEinfahrt, UFahrSBHSudEinfahrtState);
  250. analogWrite(UFahrKreuzungWendelSud, UFahrKreuzungWendelSudState);
  251. analogWrite(UFahrSBHSudAusfahrt, UFahrSBHSudAusfahrtState);
  252.  
  253.  
  254. // ------------------------- Begin An bzw Abschalten Abstellgleise
  255. digitalWrite(FahrstromSBHSudGleis1, FahrstromSBHSudGleis1State);
  256. digitalWrite(FahrstromSBHSudGleis2, FahrstromSBHSudGleis2State);
  257. digitalWrite(FahrstromSBHSudGleis3, FahrstromSBHSudGleis3State);
  258. digitalWrite(FahrstromSBHSudGleis4, FahrstromSBHSudGleis4State);
  259. digitalWrite(FahrstromSBHSudGleis5, FahrstromSBHSudGleis5State);
  260.  
  261. // ------------------------- Begin An bzw Abschalten der Zufahrten
  262. digitalWrite(UFahrSBHSudAbstell, UFahrSBHSudAbstellState);
  263. digitalWrite(FahrstromModulNotHalt, FahrstromModulNotHaltState);
  264. digitalWrite(FahrstromWendelSudKreuzung, FahrstromWendelSudKreuzungState);
  265.  
  266. }
  267. }
Tags: State_Maschine
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!