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.
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
//
