[MicroBahner]

Hallo Bernd,
ich habe mir deinen Sketch nochmal angesehen, und ich denke das Problem liegt darin, dass Du zwar die Variable 'bsoll' mit dem Wert 255 initiierst, aber nicht die Variable 'b'. Damit ist 'b' beim Start des Sketches 0 was zum Starten des Ablaufes der Relais führt.
Du müsstest also nicht nur die Sollwerte, sondern auch die aktuellen Werte initiieren. 'b' muss beim Start des Sketches mit einem Wert >= 50 initiiert werden, damit die Relais nicht loslaufen.

[Behagen]

Hallo

@ Franz-Peter
Genau das war es
Jetzt läuft es so wie ich das gerne hätte, Super
Ich danke Dir !!
Ich habe alle Variablen für die Zimmerbeleuchtung(also w, r, g, b) auf 255 gestellt.
Dadurch leuchten sie sofort "volle Pulle" und das Programm läuft vom ersten Tastendruck an sauber.
Das war vorher auch nicht unbedingt so, es konnte passieren das beim anfahren des Nachtmodus
erstmal ein grüner "Sonnenuntergang" gemacht wurde. Beim zweiten Versuch war es dann korrekt.
Nun wird auch beim ersten Versucht alles richtig abgearbeitet.
Auf die Idee, die Variablen so einzustellen wäre ich nie gekommen, ich ging davon aus wSoll, rSoll, gSoll, bSoll
würden dafür reichen die LED einzustellen.

Nochmals vielen Dank für die Hilfe, echt Klasse.
Das gilt natürlich auch für alle anderen die versucht haben mir zu helfen.

Gruß Bernd

[MicroBahner]

Hallo Bernd,

freut mich, dass ich Dir helfen konnte. Viel Spaß damit

[Instandsetzung]

Hallo,

habe dafür zu wenig Ahnung

und halte es daher mit Dieter Nuhr : Einfach mal ....

Nu(h)r eine Frage habe ich noch:
Werden die Unterprogramme wirklich gleichzeitig abgearbeitet, wenn die so:

dimmen();
schalten();
Ablaufplan();
flimmernPwmPin();

aufgerufen werden ?
( voraus gesetzt es gibt keine delays darin )

MFG
Oliver

[MicroBahner]

Zitat von Instandsetzung

---

Werden die Unterprogramme wirklich gleichzeitig abgearbeitet,

---

Hallo Oliver,
Ein Microprozessor kann nie wirklich mehrere Dinge gleichzeitig abarbeiten. Er macht das immer nacheinander. Entscheidend ist, ob er in dem Unterprogramm wartet bis etwas zu tun ist, oder ob er nur nachschaut ob etwas zu tun ist, und wenn nicht, das Programm gleich wieder beendet.
Das ist so, als wenn Du gleichzeitig Eier kochen, und Schnitzel braten willst. Für beides hast Du eine Sanduhr, die mit der jeweiligen Zeit abläuft. Wenn Du dich jetzt starr vor die Sanduhr des Eierkochens setzt, und sie solange beobachtest bis sie abgelaufen ist (=delay() ) ist das Schnitzel inzwischen schwarz.
Du musst also abwechselnd immer wieder auf beide Sanduhren schauen (beide Unterprogramme im loop aufrufen). Sobald eine abgelaufen ist, kannst Du aktiv werden - z.B. Das Ei aus dem Kochtopf nehmen, und das nächste hineintun und die Sanduhr wieder rumdrehen. Das geht so schnell, dass das Schnitzel nicht währenddessen schwarz werden kann. Jetzt schaust Du wieder auf die Schnitzel-Sanduhr. Ist die noch nicht abgelaufen, gleich wieder zur Eier-Sanduhr. Wenn die nicht abgelaufen ist, gleich wieder zu Schnitzelsanduhr. Aha, jetzt ist die abgelaufen. Also Schnitzel wenden, Sanduhr rumdrehen und wieder zur Eier-Sanduhr schauen.. u.s.w.
Ok, ist vielleicht ein bescheuertes Beispiel, aber so ähnlich läuft das ab. In den Unterprogrammen wird immer nur nachgeschaut, ob die Zeit abgelaufen ist und etwas getan werden muss. Wenn nicht, wird das Unterprogramm sofort beendet, und das nächste kann aufgerufen werden um zu schauen ob dort etwas getan werden muss. Das geht alles so schnell, dass es wie 'gleichzeitig' wirkt.

[Behagen]

Hallo

Ich habe nun noch einige kleine "Schönheitskorrekturen" an dem Programm vorgenommen.
Als erstes wurde natürlich das setzen der Variablen w, r, g, b, auf 255 eingefügt, so das nach dem Starten des Prozessors
die LED der Zimmerbeleuchtung sofort auf volle Leistung gehen.
Des weiteren habe ich nun insgesamt neun flimmerHelligkeitswerte definiert, dadurch lassen sich nun gleiche Farbverläufe besser verhindern.
Außerdem werden nun alle Relais nach dem Programmstart ausgeschalten, bisher gingen sie ja sofort an.
Wie man im Programm sehen kann, habe ich inzwischen auch den random Wert der Flimmerdauer auf 5000 erhöht, damit gefällt mir das
"Fernsehen" sehr gut. Es ist ein ruhigeres Erscheinungsbild, aber trotzdem sehr unregelmäßig.
Hier dann mal das Programm.

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
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
 

// Programm auf dem MEGA2560 vom 12.01.2017
// Einstellungen Zimmerbeleuchtung
// LED
const byte WHITE = 5; // Weiße LED an Pin 5
const byte RED   = 2; // Rote  LED an Pin 2
const byte GREEN = 3; // Grüne LED an Pin 3
const byte BLUE  = 4; // Blaue LED an Pin 4
int FadeZeit = 150;     // höherer Wert verlangsamt den Farbwechsel
byte w,r,g,b;         // Variablen für Weiß, Rot, Grün, Blau
// Relais
const byte REL1 = 31; // Relais1 an Pin 31
const byte REL2 = 33; // Relais2 an Pin 33
const byte REL3 = 35; // Relais3 an Pin 35
const byte REL4 = 37; // Relais4 an Pin 37
byte c,d,e,f;         // Variablen für die Relais der Zimmerbeleuchtung
// Taster
const byte pin1 = 25;  // Taster Tag
const byte pin2 = 23;  // Taster Nacht
const byte pin3 = 27;  // Taster Mond
// eventuell weitere
byte Schalter1;
byte Schalter2;
byte Schalter3;
// eventuell weitere
unsigned long FadeMillis;
byte wSoll,rSoll,gSoll,bSoll;
byte cSoll,dSoll,eSoll,fSoll;
byte state;
// Einstellungen für Fernsehen und acht zeitgesteuerte Relais
// Relais
byte rels[] = {22, 24, 26, 28, 30, 32, 34, 36}; // Pins der Relais festlegen
// Zeiten für die Relais in Millisekunden festlegen
long reltakt[] = {360000, 420000, 300000, 360000, 480000, 460000, 720000, 540000}; // Minuten eingestellt
// merken der Schaltzeiten
long reltime[sizeof(rels)];
// Pins der LED für die Fernsehprogramme festlegen
byte pwmLED1 =  6;  // Rot  1
byte pwmLED2 =  7;  // Grün 1
byte pwmLED3 =  8;  // Blau 1
byte pwmLED4 =  9;  // Rot  2
byte pwmLED5 = 10;  // Grün 2
byte pwmLED6 = 11;  // Blau 2
byte pwmLED7 = 44;  // Rot  3
byte pwmLED8 = 45;  // Grün 3
byte pwmLED9 = 46;  // Blau 3
//*************************************************************************************
void setup() {
  // Zimmerbeleuchtung einstellen
  // LEDs an
  w = 255;
  r = 255;
  g = 255;
  b = 255;
  
  wSoll = 255;
  rSoll = 255;
  gSoll = 255;
  bSoll = 255;
 
 
  // Taster und Relais einstellen
  pinMode(pin1, INPUT_PULLUP);
  pinMode(pin2, INPUT_PULLUP);
  pinMode(pin3, INPUT_PULLUP);
  pinMode(REL1, OUTPUT);
  digitalWrite(REL1, LOW);
  pinMode(REL2, OUTPUT);
  digitalWrite(REL2, LOW);
  pinMode(REL3, OUTPUT);
  digitalWrite(REL3, LOW);
  pinMode(REL4, OUTPUT);
  digitalWrite(REL4, LOW);
  
  
  // alle Pins für Fernsehen und acht Relais auf Ausgang setzen
  pinMode(pwmLED1, OUTPUT);
  pinMode(pwmLED2, OUTPUT);
  pinMode(pwmLED3, OUTPUT);
  pinMode(pwmLED4, OUTPUT);
  pinMode(pwmLED5, OUTPUT);
  pinMode(pwmLED6, OUTPUT);
  pinMode(pwmLED7, OUTPUT);
  pinMode(pwmLED8, OUTPUT);
  pinMode(pwmLED9, OUTPUT);
 
   for (long i=0;i<sizeof(rels);i++)
    { pinMode(rels[i], OUTPUT);
      digitalWrite(rels[i], HIGH);
     
    }
  
  
}
// Berechnen der verwendeten Zeiten
boolean milliSekundenTakt(long dauer, long &alterWert){
// Parameter "dauer": Dauer einer Einschaltphase
// Parameter "alterWert": speichert die Variale millis() Timer
// Rückgabewert: true wenn die Zeit bis zum nächsten Umschalten abgelaufen ist, sonstfalse
  if (millis() - alterWert < dauer) return false;
  while (millis() - alterWert >= dauer) alterWert+=dauer;
  return true;  
}
// Relais nach Zeit schalten
void Ablaufplan() {
 
// Alle Relais folgen ihrem Ablaufplan
  for (long i=0;i<sizeof(rels);i++)                // Relais in Schleife durchgehen
  {
    if (milliSekundenTakt(reltakt[i],reltime[i]))  // Takt für dieses Relais abgelaufen?
    {
     if (b<65) digitalWrite(rels[i],!digitalRead(rels[i])); // Relais schalten
     else digitalWrite(rels[i],HIGH);
     }
   
  }
}
// Berechnen des flackern der Fernsehprogramme 
void flimmernPwmPin() {
   static long alterWert;
   static int  flimmerDauer = 200;
   static byte flimmerHelligkeit1;
   static byte flimmerHelligkeit2;
   static byte flimmerHelligkeit3;
   static byte flimmerHelligkeit4;
   static byte flimmerHelligkeit5;
   static byte flimmerHelligkeit6;
   static byte flimmerHelligkeit7;
   static byte flimmerHelligkeit8;
   static byte flimmerHelligkeit9;
   if (milliSekundenTakt(flimmerDauer,alterWert)) 
   {
    flimmerDauer = 1+random(5000);  // Flimmerdauer als Zufallswert
    flimmerHelligkeit1=random(65);  // Rot
    flimmerHelligkeit2=random(76);  // Grün
    flimmerHelligkeit3=random(56);  // Blau
    flimmerHelligkeit4=random(26);  // Rot
    flimmerHelligkeit5=random(36);  // Grün
    flimmerHelligkeit6=random(66);  // Blau
    flimmerHelligkeit7=random(46);  // Rot
    flimmerHelligkeit8=random(26);  // Grün
    flimmerHelligkeit9=random(56);  // Blau
    analogWrite(pwmLED1, flimmerHelligkeit1);
    analogWrite(pwmLED2, flimmerHelligkeit2);
    analogWrite(pwmLED3, flimmerHelligkeit3);
    analogWrite(pwmLED4, flimmerHelligkeit4);
    analogWrite(pwmLED5, flimmerHelligkeit5);
    analogWrite(pwmLED6, flimmerHelligkeit6);
    analogWrite(pwmLED7, flimmerHelligkeit7);
    analogWrite(pwmLED8, flimmerHelligkeit8);
    analogWrite(pwmLED9, flimmerHelligkeit9);
   }
 }
void dimmen(){
  if(millis()-FadeMillis>FadeZeit){
   FadeMillis=millis();
   if(wSoll<w) w--;
   if(wSoll>w) w++;
   analogWrite(WHITE,w);
   if(bSoll<b) b--;
   if(bSoll>b) b++;
   analogWrite(BLUE,b);
   if(gSoll<g) g--;
   if(gSoll>g) g++;
   analogWrite(GREEN,g);
   if(rSoll<r) r--;
   if(rSoll>r) r++;
   analogWrite(RED,r);
   
  }
}
void schalten(){
  if(cSoll>0) c=LOW;
   else c=HIGH; 
  digitalWrite(REL1,c);
  if(dSoll>0) d=LOW;
   else d=HIGH;
  digitalWrite(REL2,d);
  if(eSoll>0) e=LOW;
   else e=HIGH;
  digitalWrite(REL3,e);
  if(fSoll>0) f=LOW;
   else f=HIGH;
  digitalWrite(REL4,f);   
}
 //*************************************************************
 
void loop() {
  // Programmaufrufe in der Dauerschleife
  Schalter1 = digitalRead(pin1); // wertet Zustand des Tasters aus
  Schalter2 = digitalRead(pin2);
  Schalter3 = digitalRead(pin3);
  
  if(Schalter1==LOW) state=1;
  if(Schalter2==LOW) state=2;
  if(Schalter3==LOW) state=3;
  
 
  switch(state){
   case 1:
    //"Dunkelheit"
    wSoll=0;  //weiß wird dunkler
    if(w<64) bSoll=0; //Blau beginnt abzudimmen wenn weiß bei 25%
    if(b<128) gSoll=0; //Grün beginnt abzudimmen wenn Blau bei 50%
    if(g<196) rSoll=0; //Rot beginnt abzudimmen wenn grün bei 75%
    if(b<50) cSoll=1;
    if(b<20) dSoll=1;
    if(g<20) eSoll=1;
    if(r<50) fSoll=1;
    break;
    
   case 2:
    //"Tag"
    rSoll=255; //Rot beginnt heller zu werden
    if(r>50) fSoll=0;
    if(r>64) gSoll=255, eSoll=0;  //wenn rot bei 25% beginnt Grün heller zu werden
    if(r>80) bSoll=255, dSoll=0;  //kurz darauf wird auch Blau heller
    if(b>150) cSoll=0;
    if(r>150) wSoll=255; // und jetzt startet auch Weiß
    
    break;
    
   case 3:
    //"Mondschein"
    bSoll=64;  //Blau auf 25% stellen
    
    
   
    break; 
  }
  
  
   //wenn am Analogport A0 ein Poti angeschlossen ist, folgende beiden Zeilen aktivieren
   //FadeZeit = analogRead(A0);
   //FadeZeit = map(FadeZeit,0,1023,20,300);
   //Die Werte 20 und 300 geben den Regelbereich an und müssen dem eigenen Geschmack angepasst werden.
   
   dimmen();
   schalten();
   Ablaufplan();  
   flimmernPwmPin();
}
 

 

Sollte es dazu noch Anmerkungen oder Verbesserungen von Euch geben, dann immer her damit.

Gruß Bernd