RE: Arduino: Ablaufsteuerung mit Bordmitteln

#1 von Running.Wolf , 01.08.2020 20:13

Moin
ja, ich weiss, es gibt mehrere MOBA.LIBS, die ich auch gern nutze.
Aaaaber ich möchte hier eine mögliche Lösung mit "Bordmitteln" vorstellen, die also mit der standardmäßigen Umgebung der Arduino IDE funktioniert.
Ich denke, dass könnte die Nutzer anregen, die mehr über die Programmierung verstehen möchten und nicht nur eine LIBRARY anwenden wollen, ohne im Detail zu verstehen, was da abläuft.

In dieser Lösung gehe ich davon aus, dass bis zu 14 Digitalpins des Arduino genutzt werden sollen, über die
- direkt LEDs über Vorwiderstande
- andere Lasten (z.B. 12 V LED Strips) über ein Darlington Array
angesteuert werden.

Wie soll das ablaufen:
* In der Programmschleife läuft später eine Variable über all 14 Pins
* Die Digitalausgänge spreche ich in verschiedenen Feldern an, alle enthalten im Namen "crtl_Pin"
* Die Nummern der Arduino Digitalausgänge stehen im Feld num_crtl_Pin
* Zuordnen fester ON/OFF Zeiten in Feld actual_on_off_Time.
* Das wäre eigentlich schon genug, dann gehen eben "Lampen an und aus" nach festgelegten Zeiten.
* Anmerkung: zum schnellen testen habe ich hier relativ kurze Zeiten gewählt
* in der Anwendung möchte ich eher 1 - 30 Minuten haben. Damit sich diese nicht im gleichen Takt bewegen, sollten
* keine "gemeinsamen Vielfache" auftreten, also 3 * 10 Minuten sind identisch mit 2 * 15 Minuten
* Also: wähle Zeiten die a) Primzahlen sind und b) einen "spürbaren" Abstand voneinander haben
*
* Damit die Zeiten sich zufällig ändern können, gibt es folgende Option:
* Wenn die ON/OFF Zeiten für den Ausgangs-Pin per Zufall ("random") geändert werden sollen
* schreibe eine 1 statt einer 0 an seine Stelle in Feld rdm_crtl_Pin
* Um die Random Möglichkeit je Ausgangs-Pin zu nutzen, schreibt das Programm in der Schleife
* die Start (ON) Zeiten an seine Stelle in Feld limits_on_Time
* schreibe die Ende (OFF) Zeiten an seine Stelle in Feld limits_off_Time

* Damit ein Ausgangspin auch anderweitig genutzt werden kann, wird sein Zustand in der Schleife nur nach den Zeiten (fest oder zufällig)
* geändert. Also kann man z.B. ein Zeitfenster vorgeben, in dem etwas anderes abläuft
* Also z.B. : alle 15 minuten soll für 30 Sekunden ein Auto blinken
* Wenn ein Ausgangs-Pin in der Schleife geändert werden soll (HIGH-LOW oder an/aus) dann
* schreibe eine 1 an seine Stelle in Feld use_crtl_Pin
* ansonsten (also andere Aufgabe wie Blinken an diesem Ausgang) schreibe dort eine 0 hinein

Das Programm ist in jeder Zeile kommentiert und sollte damit nachzuvollziehen sein. Wenn nicht, einfach nachfassen. Auch Verbesserungsvorschläge sind sehr willkommen.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
 
/*    
* Arduino Digitalausgänge nutzen als crtl_Pin
* Programmschleife läuft über all 14 Pins
* Zuordnen der Arduino Pin Nummern in Feld num_crtl_Pin
* Zuordnen fester ON/OFF Zeiten in Feld actual_on_off_Time
* Optionen:
* Wenn Pin in der Schleife geändert werden soll dann
* schreibe eine 1 in Feld use_crtl_Pin
* Wenn Zeiten in Pin per random geändert werden sollen
* schreibe eine 1 in Feld rdm_crtl_Pin
* Um Random zu nutzen
* schreibe die Start (ON) Zeiten in Feld limits_on_Time
* schreibe die Ende (OFF) Zeiten in Feld limits_off_Time
*/
//
//
int number_Pin = 14; // Anzahl benutzter Digital Pins
//
// Flicker parameter - genutzt für unregelmässige Blitze, z.B. Fotografen-Blitzgeräte
//
int flick_currentMillis = 0 ; // merke aktuelle Zeit
int flick_previousMillis = 0 ; // merke vergangene Zeit
boolean flick_State = LOW; // Status des Flicker Pins
int flick_interval_Off = 1000 ; // Intervall für Blinken AUS
int flick_Time = 50 ; // Zeit für Flicker ON
//
// Digital Pins
//
int num_crtl_Pin[14] = { 9,8,7,6,5,4,3,2,10,11,12,1,0,13} ; // Digital Ausgänge zuordnen
int previous_Millis[14] ; // Merke Zeit jeder Pin
int actual_on_off_Time[14][2] = { // On / OFF Zeit je Pin
{ 1100, 1100 }, // Pin D9
{ 2200, 2200 }, // Pin D8
{ 3200, 3200 }, // Pin D7
{ 7700, 7700 }, // Pin D6
{ 20000, 20000 }, // Pin D5
{ 30000, 30000 }, // Pin D4
{ 40000, 40000 }, // Pin D3
{ 45000, 45000 }, // Pin D2
{ 1000, 2000 }, // Pin D10
{ 2000, 1000 }, // Pin D11
{ 1000, 2000 }, // Pin D12
{ 2000, 1000 }, // Pin D1
{ 1000, 2000 }, // Pin D0
{ 2000, 1000 } // Pin D13
}; // ON / OFF Zeit pro Pin
//
int limits_on_Time [14][2] = { // Random ON Grenzen je Pin
{ 1000, 2000 },
{ 2000, 2500 },
{ 3000, 3500 },
{ 7000, 80000 },
{ 15000, 25000 },
{ 25000, 35000 },
{ 35000, 45000 },
{ 40000, 50000 },
{ 1000, 3000 },
{ 1000, 3000 },
{ 1000, 3000 },
{ 2000, 4000 },
{ 1000, 3000 },
{ 2000, 4000 } }; // Random limits pro Pin
//
int limits_off_Time[14][2] = { // Random OFF Grenzen je Pin
{ 1000, 2000 },
{ 2000, 2500 },
{ 3000, 3500 },
{ 7000, 80000 },
{ 15000, 25000 },
{ 25000, 35000 },
{ 35000, 45000 },
{ 40000, 50000 },
{ 1000, 3000 },
{ 1000, 3000 },
{ 1000, 3000 },
{ 2000, 4000 },
{ 1000, 3000 },
{ 2000, 4000 } }; // Random limits pro Pin
// Random limits
 
int rdm_crtl_Pin[14] = { 1,1,1,1,0,0,0,0,0,0,0,0,0,0} ; // Random Option zuordnen
// 1 = per Random ändern
// 0 = bleiben wie gesetzt
int use_crtl_Pin[14] = { 0,0,1,1,1,1,1,1,1,1,1,1,1,1} ; // Nutzungs Option zuordnen
// 1 = Pin in Schleife nutzen
// 0 = Pin nicht nutzen
boolean crtl_Pin [14] ; // Pin Status ON/OFF pro Pin
boolean pin_State = LOW ; // Merker für pin_Status
// starte LOW
//
 

void setup() // Set Up Bereich
{
for (int i = 0; i < number_Pin ;i++) // gehe über alle Pins
{
crtl_Pin[i] = LOW ; // alle Pins auf aus
previous_Millis[i] = 0 ; // Startposition
pinMode(num_crtl_Pin[i] , OUTPUT); // definiere als Ausgang
}
}
//
void loop() // Start Programmschleife
{
unsigned long currentMillis = millis(); // Nehme aktuelle Zeit
 
for (int i = 0; i < number_Pin ;i++) { // Gehe über alle Pins
pin_State = crtl_Pin[i] ; // wie war der aktuelle Pin?
// checke aktuellen Pin auf ON
if((pin_State == HIGH) && (currentMillis - previous_Millis[i] >= actual_on_off_Time[i][0]))
{ // checke aktuellen Pin auf ON
pin_State = LOW; // Schalte um auf OFF
previous_Millis[i] = currentMillis; // Merke aktuelle Zeit aktueller Pin
crtl_Pin [i] = pin_State ; // Merke aktueller Status aktueller Pin
if (use_crtl_Pin[i] == HIGH) { // diesen Pin ändern ?
digitalWrite(num_crtl_Pin[i], pin_State); } // Schreibe Status in aktuellen Pin
} // Ende für ON
else if ((pin_State == LOW) && (currentMillis - previous_Millis[i] >= actual_on_off_Time[i][1]))
{ // checke aktuellen Pin auf OFF
pin_State = HIGH; // Schalte um auf ON
previous_Millis[i] = currentMillis; // Merke aktuelle Zeit aktueller Pin
crtl_Pin [i] = pin_State ; // Merke aktueller Status aktueller Pin
if (use_crtl_Pin[i] == HIGH) { // diesen Pin ändern ?
digitalWrite(num_crtl_Pin[i], pin_State); } // USchreibe Status in aktuellen Pin
if (rdm_crtl_Pin[i] ) // Soll Zeit per random geändert werden?
{ // ändere ON/OFF in random Grenzen
actual_on_off_Time[i][0] = random(limits_on_Time[i][0], limits_on_Time[i][1]) ;
actual_on_off_Time[i][1] = random(limits_off_Time[i][1], limits_off_Time[i][1]) ;
} // Ende für Zeitänderung
} // Ende für OFF

} // Ende FOR Schleife über alle Pins
//
flicker_Pin(num_crtl_Pin[0]) ; // Soll Blitzen
flicker_Pin(num_crtl_Pin[1]) ; // Soll Blitzen
//
//
} // Ende Programmschleife
//
//
void flicker_Pin(int p_Flick) // Prozedur für Blitzen
{
unsigned flick_currentMillis = millis(); // merke aktuelle Zeit
if (flick_currentMillis - flick_previousMillis >= flick_interval_Off)
{ // OFF Zeit abgelaufen?
flick_State = HIGH; // Blitz Pin Status ON
digitalWrite(p_Flick, flick_State); // Schreibe Status in ON Blitz Pin
delay (flick_Time); // warte kurz
flick_State = LOW; // Blitz Pin Status OFF
digitalWrite(p_Flick, flick_State); // Schreibe Status in OFF Blitz Pin
flick_previousMillis = flick_currentMillis; // Merke latzte Blitzzeit
flick_interval_Off = random(300, 800); // Ändere die OFF Zeit des Blitzens
} // Ende Zeit Abfrage
} // EndeProzedur für Blitzen
//
 

 
 


Gruss Wolfgang

All that the young can do for the old is to shock them and keep them up to date. George Bernhard Shaw


 
Running.Wolf
EuroCity (EC)
Beiträge: 1.089
Registriert am: 15.01.2006
Homepage: Link
Ort: Isernhagen
Gleise C-Gleis / M-Gleis
Spurweite H0
Steuerung CS 2
Stromart Digital


RE: Arduino: Ablaufsteuerung mit Bordmitteln

#2 von MicroBahner , 02.08.2020 09:02

Hallo Wolfgang,
was mir bei deinem Sketch aufgefallen ist: In den Arrays für die Zeiten stehen Werte, die für den Datentyp int zu groß sind. Sollen es dann mal nicht nur Zeiten für den Test, sondern realistische Zeiten sein, gilt dies umso mehr.
Alle Arrays und Variable für Zeitwerte und millis() Vergleiche musst Du mit 'unsigned long' definieren.
Wenn Du in der IDE die Compiler-warnings aktiviert, macht er dich auch darauf aufmerksam.

P.S. Alternative wäre, in die Arrays die Zeiten in Sekunden reinzuschreiben, und diese beim Vergleich mit millis zu (unsigned long) casten, und mit 1000L multiplizieren.


viele Grüße
Franz-Peter
Ein 'elektromechanisches' Stellwerk
Der 'Eisberg'


 
MicroBahner
Metropolitan (MET)
Beiträge: 2.775
Registriert am: 28.11.2012
Ort: Mittelfranken
Gleise Tillig Elite
Steuerung Eigenbau
Stromart Analog


RE: Arduino: Ablaufsteuerung mit Bordmitteln

#3 von PATs in 1zu87 , 02.08.2020 10:08

Moin

Ja das stimme ich meinen Vorrednet zu
Die Werte für INT sind zu gross.

Wenn man einen Echtzeitschleife mit was auch immer Programmieren will, würde ich das ganze so nicht lösen.
Zeiten Blockieren den Microcontroller.

Wenn in meinem Programmen eine Zeit läuft, wird das bei mir mit der Taktzeit des MC Sycronisiert und ein Zähler auf oder abwärts gezählt.
Blockiert das Programm nicht und man kann alles andere nebenbei noch weiter laufen lassen

Grüsse
Pat


Irgendwo im Ruhrgebiet

- Moderner Hauptstreckenverkehr für Nah/Güterverkehr
- Industrieanbindung
- SpDrS60-Stellwerk

Meine HO-Anlage: https://stummiforum.de/viewtopic.php?f=64&t=179346
YouTube: https://www.youtube.com/channel/UCfgRbZ06vRHmpR5I5hvN3wQ


 
PATs in 1zu87
CityNightLine (CNL)
Beiträge: 1.586
Registriert am: 06.05.2017


RE: Arduino: Ablaufsteuerung mit Bordmitteln

#4 von MicroBahner , 02.08.2020 10:16

Zitat

Wenn man einen Echtzeitschleife mit was auch immer Programmieren will, würde ich das ganze so nicht lösen.
Zeiten Blockieren den Microcontroller.

So wie das realisiert ist ( über die millis() Funktion ), blockiert da nichts.


viele Grüße
Franz-Peter
Ein 'elektromechanisches' Stellwerk
Der 'Eisberg'


 
MicroBahner
Metropolitan (MET)
Beiträge: 2.775
Registriert am: 28.11.2012
Ort: Mittelfranken
Gleise Tillig Elite
Steuerung Eigenbau
Stromart Analog


RE: Arduino: Ablaufsteuerung mit Bordmitteln

#5 von Running.Wolf , 02.08.2020 18:23

Moin

@ Franz-Peter
Ja stimmt, ursprünglich sollte es in den arrays unsigned long sein,

    dann wollte ich wegen der angepeilten Zeiten von 20 bis 40 Minuten auf Werte für Minuten umschalten und habe unsigned long rausgenommen

    Dann wollte ich die Division durch 1000 eben noch schnell einbauen

    Dann fingen die Nachrichten an und ich habe schnell auf hochladen gedrückt


Tja

Schande über mich.

Delay() gibt es bei mir in dem Sketch nur einmal bei der Blitzerfunktion, wenn es das Blitzlicht kurz blitzt.
Sonst laufen alle Abfragen über millis().


Gruss Wolfgang

All that the young can do for the old is to shock them and keep them up to date. George Bernhard Shaw


 
Running.Wolf
EuroCity (EC)
Beiträge: 1.089
Registriert am: 15.01.2006
Homepage: Link
Ort: Isernhagen
Gleise C-Gleis / M-Gleis
Spurweite H0
Steuerung CS 2
Stromart Digital


RE: Arduino: Ablaufsteuerung mit Bordmitteln

#6 von Running.Wolf , 02.08.2020 20:32

Moin

Dieser Beitrag richtet sich an Arduino Interessierte, hat als technisches Ziel die Steuerung von bis zu 14 Verbrauchern. Es ist also kein Hightech und kein zeitkritisches Programm.
Die Hardware sieht üblicherweise so aus



Und passt damit locker in ein (größeres) Häuschen (da stammt das Foto her).
Es ist ein Mini Pro mit einem Darlington Array für 8 Ausgänge sowie 4 LED Ausgänge mit Vorwiderstand.

Ich habe aber die beiden Anregungen aufgegriffen und
- lasse pro Ausgang jetzt individuell Millisekunden oder Sekunden zu
- straffe die Loop

Morgen werde ich noch einmal testen und dann die aktualisierte Version hochladen.


Gruss Wolfgang

All that the young can do for the old is to shock them and keep them up to date. George Bernhard Shaw


 
Running.Wolf
EuroCity (EC)
Beiträge: 1.089
Registriert am: 15.01.2006
Homepage: Link
Ort: Isernhagen
Gleise C-Gleis / M-Gleis
Spurweite H0
Steuerung CS 2
Stromart Digital


RE: Arduino: Ablaufsteuerung mit Bordmitteln

#7 von Running.Wolf , 07.08.2020 18:13

Moin
ich habe das Programm überarbeitet und getestet.
Standardvergleichswerte für Zeiten sind nunmehr Sekunden.
Es können jedoch auch Minuten eingegeben werden, die Kommentierung sollte zeigen, wie und wo.
In Feld
- actual_on_off_Time[14][2] kommen die Zahlenwerte für die Zeiten an und aus
- uni_crtl_Pin[14] kommt eine 0 für Sekunden und eine 1, wenn an diesem Pin zuvor Minuten eingegeben wurden
- rdm_crtl_Pin kommt eine 1, wenn die an/aus Werte per Zufall geändert werden sollen (Grenzen im entsprechenden Feld)
- use_crtl_Pin[14] kommt eine 1, wenn dieser Pin zur errechneten Zeit umgesteuert werden soll

Das letzte Feld ist ganz nützlich, wenn man andere Aktionen zeitweise anstossen möchte. Im Programm ist dort ein Beispiel, wonach während des
HIGH Status des Pins eine dort angeschlossene LED zufällig blitzen soll.

Kommentare werden immer noch gern entgegen genommen.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
 

/*
* Arduino Digitalausgänge nutzen als crtl_Pin
* Da Modellbahn: Basiszeiten sind Sekunden
* Programmschleife läuft über alle 14 Pins
* Zuordnen der Arduino Pin Nummern in Feld num_crtl_Pin
* Zuordnen fester ON/OFF Zeiten in Feld actual_on_off_Time
* Optionen:
* Wenn Pin in der Schleife geändert werden soll dann
* schreibe eine 1 in Feld use_crtl_Pin
* Wenn Zeiten in Pin per random geändert werden sollen
* schreibe eine 1 in Feld rdm_crtl_Pin
* Um Random zu nutzen
* schreibe die Start (ON) Zeiten in Feld limits_on_Time
* schreibe die Ende (OFF) Zeiten in Feld limits_off_Time
*
* Für das Zeitgefühl
* 1000 = 1 Sekunde
* 60000 = 1 Minute
* 1 800 000 = 1 Stunde
*
* Minuten
* 30 = 1800 Sekunden
* = 1 800 000 Millisekunden
*
* daher empfiehlt es sich, bei den Modellbahnabläufen in Sekunden oder gar Minuten zu planen
*/
//
//
int number_Pin = 14; // Anzahl benutzter Digital Pins
unsigned long current_Millis = 0 ; // aktuell laufende Milli-Sekunde
unsigned long current_Secs = 0 ; // aktuell laufende Sekunde
int this_Time = 0 ; // wählt ON/OFF Spalte aus
//
// Flicker parameter - genutzt für unregelmässige Blitze, z.B. Fotografen-Blitzgeräte
//
unsigned long flick_currentMillis = 0 ; // merke aktuelle Zeit in ms
unsigned long flick_previousMillis = 0 ; // merke vergangene Zeit in ms
boolean flick_State = LOW; // Status des Flicker Pins
int flick_interval_Off = 1000 ; // Intervall für Blinken AUS
int flick_Time = 50 ; // Zeit für Flicker ON
//
// Digital Pins
//
int num_crtl_Pin[14] = { 9,8,7,6,5,4,3,2,10,11,12,1,0,13} ; // Digital Ausgänge zuordnen
int uni_crtl_Pin[14] = { 0,0,0,0,1,1,1,1,0,0,0,0,0,0} ; // Einheit der Zeit zuordnen
// 0 = Sekunden
// 1 = Minuten
int rdm_crtl_Pin[14] = { 0,1,0,0,0,0,0,0,0,0,0,0,0,0} ; // Random Option zuordnen
// 1 = per Random ändern
// 0 = bleiben wie gesetzt
int use_crtl_Pin[14] = { 0,1,1,1,1,1,1,1,1,1,1,1,1,1} ; // Nutzungs Option zuordnen
// 1 = Pin in Schleife nutzen
// 0 = Pin nicht nutzen
//
unsigned long previous_Secs[14] ; // Merke Zeit jeder Pin in Sekunden
unsigned long actl_pin_Time ; // behandelt in Sekunden
unsigned long actual_on_off_Time[14][2] = // Eingabe in Sekunden / Minuten
{ // On / OFF Zeit je Pin
// Duo LED ON = rot / OFF = grün
{ 20, 10 }, // Pin D9 in Sekunden
{ 10, 20 }, // Pin D8 in Sekunden
{ 32, 64 }, // Pin D7 in Sekunden
{ 43, 86 }, // Pin D6 in Sekunden
{ 1, 1 }, // Pin D5 in Minuten
{ 2, 2 }, // Pin D4 in Minuten
{ 3, 3 }, // Pin D3 in Minuten
{ 4, 4 }, // Pin D2 in Minuten
{ 13, 15 }, // Pin D10 LED in Sekunden
{ 14, 14 }, // Pin D11 LED in Sekunden
{ 15, 13 }, // Pin D12 LED in Sekunden
{ 21, 21 }, // Pin D1 in Sekunden
{ 22, 22 }, // Pin D0 in Sekunden
{ 23, 23 } // Pin D13 in Sekunden
}; // ON / OFF Zeit pro Pin
//
unsigned long limits_on_Time [14][2] =
{ // Random ON Grenzen je Pin
{ 8, 15 },
{ 8, 15 },
{ 28, 71 },
{ 38, 95 },
{ 1, 3 },
{ 2, 4 },
{ 3, 5 },
{ 3, 6 },
{ 10, 18 },
{ 10, 19 },
{ 10, 20 },
{ 20, 21 },
{ 20, 22 },
{ 20, 23 } }; // Random limits pro Pin
//
unsigned long limits_off_Time[14][2] =
{ // Random OFF Grenzen je Pin
{ 8, 15 },
{ 18, 25 },
{ 28, 71 },
{ 38, 95 },
{ 1, 3 },
{ 2, 4 },
{ 3, 5 },
{ 3, 6 },
{ 10, 18 },
{ 10, 19 },
{ 10, 20 },
{ 20, 21 },
{ 20, 22 },
{ 20, 23 } }; // Random limits pro Pin
//

boolean crtl_Pin [14] ; // Pin Status ON/OFF pro Pin
boolean pin_State = LOW ; // Merker für pin_Status
// starte LOW
//
 

void setup() // Set Up Bereich
{
for (int i = 0; i < number_Pin ;i++) // gehe über alle Pins
{
crtl_Pin[i] = LOW ; // alle Pins auf aus
previous_Secs[i] = 0 ; // Startposition
pinMode(num_crtl_Pin[i] , OUTPUT); // definiere als Ausgang
digitalWrite(num_crtl_Pin[i], HIGH); // Schreibe LOW in aktuellen Pin
}
for (int i = 0; i < number_Pin ;i++) // gehe über alle Pins
{
delay(1000) ;
digitalWrite(num_crtl_Pin[i], LOW); // Schreibe LOW in aktuellen Pin
}
}
//
void loop() // Start Programmschleife
// alle Zeitvergleiche in Sekunden
{
current_Millis = millis(); // Nehme aktuelle Zeit in Millisekunden
 
for (int i = 0; i < number_Pin ;i++) { // Gehe über alle Pins number_Pin
//
this_Time = 0; // ON / OFF Spalte wählen ;
actl_pin_Time = actual_on_off_Time[i][this_Time] ; // Annahme: Sekunden
current_Secs = millis() / 1000 ; // Nehme aktuelle Zeit in Sekunden
//
if (uni_crtl_Pin[i]== 1) // 1: also Minuten
{
actl_pin_Time = 60 * actl_pin_Time; // rechne um in Sekunden
}
pin_State = crtl_Pin [i] ; // aktueller Pin Status
//
if (pin_State == HIGH && (current_Secs - previous_Secs[i]) >= actl_pin_Time) // nun prüfen ob Pin an der Reihe ist
{
pin_State = !pin_State; // ändere Status
previous_Secs[i] = current_Secs ; // Merke aktuelle Zeit aktueller Pin
// immer in Sekunden
crtl_Pin [i] = pin_State ; // Merke aktueller Status aktueller Pin
if (use_crtl_Pin[i] == 1) // diesen Pin ändern ?
{
digitalWrite(num_crtl_Pin[i], pin_State); // Schreibe Status in aktuellen Pin
}
anpass_Zeit(i) ; // hier RANDOM Anpassung
//
} // Ende wenn pin HIGH
//
this_Time = 1 - this_Time ; // wähle ON/OFF Spalte
actl_pin_Time = actual_on_off_Time[i][this_Time] ; // OFF Time in Sekunden
//
if (uni_crtl_Pin[i]== 1) // 1: Minuten
{
actl_pin_Time = 60 * actl_pin_Time; // umrechnen in Sekunden
}
//
pin_State = crtl_Pin [i] ; // aktueller Pin Status
if (pin_State == LOW && (current_Secs - previous_Secs[i]) >= actl_pin_Time) // nun prüfen ob Pin an der Reihe ist
{
pin_State = !pin_State; // ändere Status
previous_Secs[i] = current_Secs ; // Merke aktuelle Zeit aktueller Pin
// immer in Sekunden
crtl_Pin [i] = pin_State ; // Merke aktueller Status aktueller Pin
if (use_crtl_Pin[i] == 1) // diesen Pin ändern ?
{
digitalWrite(num_crtl_Pin[i], pin_State); // Schreibe Status in aktuellen Pin
}
anpass_Zeit(i) ; // hier RANDOM Anpassung
//
} // Ende wenn Pin LOW
//

} // Ende FOR
// ----------------------------------
 
if (crtl_Pin[0] == HIGH) // solange dieser Pin HIGH
{ // weitere Aktion
flicker_Pin(num_crtl_Pin[0]) ; // z.B. soll Blitzen
} // kann jeder Pin sein
//
// Ende Programmschleife
} // ---------- Ende LOOP ---------------
//
//
void flicker_Pin(int p_Flick) // Prozedur für Blitzen
{
flick_currentMillis = millis(); // merke aktuelle Zeit
if (flick_currentMillis - flick_previousMillis >= flick_interval_Off)
{ // OFF Zeit abgelaufen?
flick_State = HIGH; // Blitz Pin Status ON
digitalWrite(p_Flick, flick_State); // Schreibe Status in ON Blitz Pin
delay (flick_Time); // warte kurz
flick_State = LOW; // Blitz Pin Status OFF
digitalWrite(p_Flick, flick_State); // Schreibe Status in OFF Blitz Pin
flick_previousMillis = flick_currentMillis; // Merke latzte Blitzzeit
flick_interval_Off = random(300, 800); // Ändere die OFF Zeit des Blitzens
} // Ende Zeit Abfrage
} // Ende Prozedur für Blitzen
//
void anpass_Zeit (int dieser_Pin)
{
if (rdm_crtl_Pin[dieser_Pin] == 1 ) // Soll Zeit per random geändert werden?
{ // ändere ON/OFF in random Grenzen
digitalWrite (11,!digitalRead(11)); // nur temporär zur Kontrolle
actual_on_off_Time[dieser_Pin][0] = random(limits_on_Time[dieser_Pin][0], limits_on_Time[dieser_Pin][1]) ;
actual_on_off_Time[dieser_Pin][1] = random(limits_off_Time[dieser_Pin][1], limits_off_Time[dieser_Pin][1]) ;
} // Ende für RANDOM
//
}
 
 


Gruss Wolfgang

All that the young can do for the old is to shock them and keep them up to date. George Bernhard Shaw


 
Running.Wolf
EuroCity (EC)
Beiträge: 1.089
Registriert am: 15.01.2006
Homepage: Link
Ort: Isernhagen
Gleise C-Gleis / M-Gleis
Spurweite H0
Steuerung CS 2
Stromart Digital


RE: Arduino: Ablaufsteuerung mit Bordmitteln

#8 von Running.Wolf , 11.08.2020 11:52

Moin

Es ist vollbracht.
Schön im Schatten auf der Terrasse gesessen und den Arduino für Gießerei und Garage eingerichtet.



Der Arduino sitzt in der Gießerei, sodass nur 12 V DC zugeführt werden müssen.



Mit einem 7805 werden die 5 V DC für den Arduino in der Gießerei erzeugt.



Die Deckenleuchten und Autos laufen dann auf 12 V DC.

In der Gießerei wird auch geschweißt, alle 10 bis 15 Minuten flackert es hinter dem Fenster.

Die Neonröhren (LED Strips) flackert erst einmal, bevor angehen.

Die Autos blinken oder leuchten in größeren Abständen.

Im THW Truck geht das Licht in der Fahrerkabine ab und zu an. Wenn ich einen Tag mit ruhigen Händen erwische, kommen noch zwei blaue SMD LED in das entsprechende Leuchtengehäuse auf das Dach.

Nun kann die Hartfaserplatte auf die Anlage gesetzt werden und mittels Stecker an die 12 V DC angeschlossen werden.


Gruss Wolfgang

All that the young can do for the old is to shock them and keep them up to date. George Bernhard Shaw


 
Running.Wolf
EuroCity (EC)
Beiträge: 1.089
Registriert am: 15.01.2006
Homepage: Link
Ort: Isernhagen
Gleise C-Gleis / M-Gleis
Spurweite H0
Steuerung CS 2
Stromart Digital


   


  • Ähnliche Themen
    Antworten
    Zugriffe
    Letzter Beitrag
Xobor Einfach ein eigenes Forum erstellen
Datenschutz