[Behagen]

Hallo

Ich habe nun erstmal mit meinem vorhandenen Arduino Uno geübt eine Farbfernseh-Simulation zu erstellen.
Herausgekommen ist dabei dieser Sketch:

// Bernds Fernsehfunk
// 3 LED sollen je ein Farbfernsehprogramm simulieren.
int pwmLEDPin1 = 3;
int pwmLEDPin2 = 5;
int pwmLEDPin3 = 6;
int pwmLEDPin4 = 9;
int pwmLEDPin5 = 10;
int pwmLEDPin6 = 11;


void setup() {
// alle Flimmerled auf Output setzen
pinMode(pwmLEDPin1, OUTPUT);
pinMode(pwmLEDPin2, OUTPUT);
pinMode(pwmLEDPin3, OUTPUT);
pinMode(pwmLEDPin4, OUTPUT);
pinMode(pwmLEDPin5, OUTPUT);
pinMode(pwmLEDPin6, OUTPUT);
}
// ab hier wird geflimmert
void flimmernPwmPin() {
static byte flimmerHelligkeit1;
static byte flimmerHelligkeit2;
static byte flimmerHelligkeit3;
static byte flimmerHelligkeit4;
{
flimmerHelligkeit1=random(256);
// Werte über 256 scheinen keinen Sinn zu machen
flimmerHelligkeit2=random(256);
delay(5);
flimmerHelligkeit3=random(256);
flimmerHelligkeit4=random(256);
analogWrite(pwmLEDPin1, flimmerHelligkeit1);
delay(10);
analogWrite(pwmLEDPin2, flimmerHelligkeit2);
analogWrite(pwmLEDPin3, flimmerHelligkeit4);
delay(15);
analogWrite(pwmLEDPin4, flimmerHelligkeit4);
delay(5);
analogWrite(pwmLEDPin5, flimmerHelligkeit3);
analogWrite(pwmLEDPin6, flimmerHelligkeit2);
}
}
void loop() {
flimmernPwmPin();


}
Ob das nun das tollste mögliche Programm ist weiß ich nicht, aber es macht erstmal ein recht unregelmäßiges Geflimmer.
Trotzdem würde ich gerne noch probieren die eingefügten delays durch Zufallswerte zu ersetzen.
Daran beiße ich mir aber im Moment die Zähne aus.
Was ich mir bisher im Internet zu den einzelnen Befehlen und Funktionen durchgelesen habe, hat mir nicht wirklich die
nötige Erleuchtung gebracht.
Da der für den Einsatz in der Anlage vorgesehene Arduino Mega 2560 ja noch etliche frei Anschlüsse haben wird und ich die mit einem
sinnvollen Nutzen versehen möchte, bin ich auf die Idee gekommen Relais daran anzuschließen.
Diese sollen ebenfalls nach dem Zufallsprinzip, allerdings für mehrere Minuten, eingeschalten werden.
Nun frage ich mich wie ich das mache ohne das ich dabei das "Fernsehprogramm" beeinflusse?

Wenn mir bei den beiden Problemen jemand mit Hinweisen helfen könnte und (falls nötig) Hinweise zu dem bisherigen Programm
hätte, wäre ich sehr dankbar.

Gruß Bernd

[melior]

Hallo Bernd,

anstatt mit delay(10) 10 ms zu warten, merkst Du Dir die mit millis() ausgegebene Anzahl Millisekunden in einer Variablen. Nun prüfst Du regelmäßig mit weiteren Aufrufen von millis(), ob der neue Wert größer als der gemerkte Wert + 10 ist.

Tschüß André

[Behagen]

Hallo André

Das verschieben in den richtigen Forenbereich hat zwar etwas gedauert, aber nun ist der Beitrag wieder da und ich kann Dir antworten.
Erstmal vielen Dank für Deinen Hinweis.
Inzwischen hat sich etwas verändert.
Ich habe nun einen Arduino Mega 2560 und zwei RGB-LED gekauft und seit Heute in Betrieb.
Das Programm habe ich inzwischen auch verändert, der Effekt gefällt mir nun schon ganz gut.
Ich füge es mal hier an.
// Bernds Fernsehfunk
// 3 LED sollen je ein Farbfernsehprogramm simulieren.
int pwmLEDPin1 = 3;
int pwmLEDPin2 = 5;
int pwmLEDPin3 = 6;
int pwmLEDPin4 = 9;
int pwmLEDPin5 = 10;
int pwmLEDPin6 = 11;
int randNumber;
int randNumber1;
void setup() {
// alle Flimmerled auf Output setzen
pinMode(pwmLEDPin1, OUTPUT);
pinMode(pwmLEDPin2, OUTPUT);
pinMode(pwmLEDPin3, OUTPUT);
pinMode(pwmLEDPin4, OUTPUT);
pinMode(pwmLEDPin5, OUTPUT);
pinMode(pwmLEDPin6, OUTPUT);
}
// ab hier wird geflimmert
void flimmernPwmPin() {
static byte flimmerHelligkeit1;
static byte flimmerHelligkeit2;
static byte flimmerHelligkeit3;
static byte flimmerHelligkeit4;
{
flimmerHelligkeit1=random(randNumber1);
// Werte über 256 scheinen keinen Sinn zu machen
flimmerHelligkeit2=random(randNumber1);
delay(randNumber);
flimmerHelligkeit3=random(randNumber1);
flimmerHelligkeit4=random(randNumber1);
analogWrite(pwmLEDPin1, flimmerHelligkeit1);
delay(randNumber);
analogWrite(pwmLEDPin2, flimmerHelligkeit2);
analogWrite(pwmLEDPin3, flimmerHelligkeit4);
delay(randNumber);
analogWrite(pwmLEDPin4, flimmerHelligkeit4);
delay(randNumber);
analogWrite(pwmLEDPin5, flimmerHelligkeit3);
analogWrite(pwmLEDPin6, flimmerHelligkeit2);
}
}
void loop() {
flimmernPwmPin();

randomSeed(millis());
randNumber = random(50);
randNumber1 = random(256);

}

Um ehrlich zu sein weiß ich nicht wirklich ob Du Deinen Hinweis so gemeint hast wie ich es nun gemacht habe.
Aber wie gesagt das Ergebnis gefällt mir im Moment ganz gut.
Nun muss ich noch darüber nachdenken wie ich acht Relais Zeitgesteuert(mehrere Minuten an, dann wieder aus) in das Programm
integrieren kann. Natürlich sollen sich beide Funktionen möglichst nicht gegenseitig stören.
Aber da werde ich mich in den nächsten Tagen mit beschäftigen.

Gruß Bernd

[Dirk63]

Hallo Bernd,
als Übungsprojekt sicher großartig geeignet, aber ansonsten ziemliche Kanone für den kleinen Spatz !
Was spricht denn gegen Farbwechsel-LEDs? Gibt's schnell und langsam; davon je eine ins "Moba-Wohnzimmer" und Du brauchst Dich nur noch um das Einschalten zu kümmern.

Das soll Deine Arbeit keinesfalls herabsetzen, wie gesagt, zum Üben großartig!
Aber der 2560 langweilt sich zu Tode...

Gruß,
Dirk

[Behagen]

Hallo Dirk

Prinzipiell hast Du sicher Recht --- aber, einerseits sollen die "Fernsehprogramme" auf mehrere "Wohnungen" verteilt werden.
Damit sollen dann mehrere "Wohnungen" BFF1 "sehen" andere wieder "BFF2" und andere wiederum "Westfernsehen"
Damit sich der Gute nicht ganz so langweilt, soll er ja auch noch eine achtfach Relaiskarte steuern.
Damit wiederum sollen dann mehrere ATTiny 44 und 45 ein und ausgeschaltet werden, die wiederum ein eigenes Programm
für ihr Haus, bzw. ihre Wohnung haben werden.
Naja und letztlich hat mich der Mega2560 nun zehn Euro gekostet --- das ist mir der Spaß aber auch wert.
Wobei ich zugeben muss, das im Moment das ganze etwas ins stocken geraten ist --- andere --- größere Probleme haben sich in
den Vordergrund gedrängt.
Allerdings muss ich auch sagen, nachdem ich mir in den letzten Tagen Abends Fenster angesehen habe in denen ein Fernseher lief,
erscheint mir meine Simulation doch etwas zu "Wild" . Wenn ich wieder den Kopf frei habe für dieses Projekt, werde ich das wohl
nochmal anders machen(langsamere Farb- und Helligkeitswechsel --- möglichst ohne delay)

Gruß Bernd

[PhilippJ_YD]

Ja, in Anbetracht dessen, was für Rechenleistungen heute in quasi jedem Mobiltelefon stecken, ist man doch immer wieder erstaunt, was die Mikrocontroller mit ihren 8bit und 16MHz schon alles können und sich nebenbei noch zu tode langweilen. Effiziente Struktur und Hardware machen es möglich.

Wenn du darüber nachdenkst, mehrere Häuser jeweils mit eigenem Prozessor auszustatten, würde ich vorschlagen auch darüber nachzudenken, ob man das ganze nicht mittels eines Bus Systems aufbaut. Du benutzt dann einen Uno/Mega als zentrale Steuereinheit, (je nachdem, wie viel Speicher benötigt wird, das Rechenwerk bleibt das Gleiche!) und bindest die einzelnen Unterstationen zum Beispiel mittels des TWI an. Vorteil: Du brauchst nur zwei Busleitungen + Stromversorgung die zu allen angeschlossenen Verbrauchern gehen. Auf Wunsch kann man natürlich noch die zentrale Versorgung der Fernsehgeräte in Betracht ziehen

Das macht am Anfang natürlich erstmal mehr Programmierarbeit, um den Bus einzubinden, spart aber hinterher Zeit beim Aufbau und bei entsprechend kleinen Strömen auch noch Relais und die damit verbundenen Kosten, auch wenn diese ebenfalls erstaunlich günstig aus China kommen.

Am TWI sollten sich je nach räumlicher Ausdehnung mehrere Dutzend Häuser anbinden lassen.

[Behagen]

Hallo

Da es scheinbar nicht offensichtlich genug ist, worum es bei diesem Projekt geht, möchte ich das noch mal genauer darlegen.
Um es vorweg zu nehmen, diese Erklärung hat nichts mit den bereits getätigten Beiträgen zu tun, sondern soll nur dafür sorgen
das dieses Thema im Bereich Software verbleibt und nicht in die Tagesthemen verbannt wird.
Der Grund für diese Erklärung ist die Einschätzung der Moderation, das es in diesem Thema nicht um die Modellbahn geht,
oder dieses nicht gut genug erkennbar ist.
Die Aufgabenstellung hinter diesem Projekt ist einen Arduino Mega2560 so zu programmieren das er:
1. je drei Ausgänge mit einem Signal versorgt das durch eine RGB-LED als eine Fernsehsimulation war genommen werden kann.
Dieses Funktion soll insgesamt dreifach auf dem Prozessor zur Verfügung gestellt werden.
Die Ausgänge des Prozessors sollen anschließend über eine Verstärkerschaltung mehrere RGB-LED betreiben.
Diese LED werden dann in meinen Modellhäuschen auf meiner Modellbahn verbaut und sollen den Eindruck eines laufenden
Fernsehers erwecken.
2. soll der Prozessor eine achtfach Relaiskarte Zeitgesteuert ein und ausschalten.
An den Relaisausgängen sollen mehrere ATTiny Prozessoren angeschlossen werden die mit einem ähnlichen Programm, wie dem
im Thread "belebtes Haus zum Schnäppchenpreis" beschriebenen arbeiten. Diese sollen die Lichtsteuerung in den einzelnen Modellhäusern
auf meiner Modellbahnanlage steuern. Dadurch erhoffe ich mir(nein, ich bin mir sicher) einen möglichst abwechslungsreichen
Lichtablauf auf meiner Anlage.
Ich hoffe der Bezug zur Modellbahn ist damit ausreichend belegt und das Thema kann wieder in den Bereich Software.

Ich würde dieses Thema gern erfolgreich zu einem Abschluss bringen, das kann aber leider etwas dauern.
Da ich nicht sicherstellen kann demnächst regelmäßig am Forum teilnehmen zu können, würde ich wenigstens gern
nach meinem Krankenhausaufenthalt damit weitermachen können.

Gruß Bernd

[Erich Müller]

Ich hänge mich dran, weil mich das Thema interessiert und ich der Ansicht bin, es gehört durchaus nach "Hardware und Software". Bitte, liebes Team, nicht hier verschwinden lassen.

[Behagen]

Hallo

Vielen Dank, das mein Thema nun doch nicht im Nirvana verschwunden ist.
Ich hatte schon nicht mehr damit gerechnet, das es erhalten bleibt.
@Erich
Dank Deines Interesses scheint es ja dann gerettet worden zu sein.

Es gibt Neuigkeiten.
Ich habe nun das Programm soweit das sowohl acht Relais Zeitgesteuert funktionieren, als auch gleichzeitig die LEDs flimmern.
Aber !
Die Delays wurden im Programm ersatzlos gestrichen, somit gibt es im Moment keine Unterbrechungen .
Das heißt dann aber auch das die LEDs nicht mehr so ungleichmäßig flimmern wie ich es eigentlich haben möchte.
Ich füge mal das Sketch hier an, dabei ist zu beachten das ich die Zeiten in den einstelligen Sekundenbereich gestellt habe.
Das ist nur zum Zwecke des Testens so und wird im endgültigen Programm dann durch Werte für den zweistelligen Minuten Bereich ersetzt.

achtRelais_Fernsehen_Probe

byte rels[] = {22, 24, 26, 28, 30, 32, 34, 36}; //Anschlüsse acht Relais
//Zeiten für die Relais in Millisekunden
long reltakt[] = {3600, 4200, 3000, 3600, 4800, 4600, 7200, 5400}; // Schaltzeit der Relais merken

long reltime[sizeof(rels)];
// Pins der LED festlegen
byte pwmLED1 = 2;
byte pwmLED2 = 3;
byte pwmLED3 = 4;
byte pwmLED4 = 5;
byte pwmLED5 = 6;
byte pwmLED6 = 7;
byte pwmLED7 = 8;
byte pwmLED8 = 9;
byte pwmLED9 = 10;
void setup() {
// alle verwendeten Pins auf Output 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);
pinMode(rels, OUTPUT);
for (long i=0;i<sizeof(rels);i++)
pinMode(rels[i], OUTPUT);

}
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 LEDs 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?
{
digitalWrite(rels[i],!digitalRead(rels[i])); // Relais schalten
}

}
}
// ab hier wird geflimmert
void flimmernPwmPin() {
static byte flimmerHelligkeit1;
static byte flimmerHelligkeit2;
static byte flimmerHelligkeit3;
static byte flimmerHelligkeit4;
{
flimmerHelligkeit1=random(256);
flimmerHelligkeit2=random(256);
flimmerHelligkeit3=random(256);
flimmerHelligkeit4=random(256);
analogWrite(pwmLED1, flimmerHelligkeit1);
analogWrite(pwmLED2, flimmerHelligkeit2);
analogWrite(pwmLED3, flimmerHelligkeit1);
analogWrite(pwmLED4, flimmerHelligkeit4);
analogWrite(pwmLED5, flimmerHelligkeit3);
analogWrite(pwmLED6, flimmerHelligkeit2);
analogWrite(pwmLED7, flimmerHelligkeit1);
analogWrite(pwmLED8, flimmerHelligkeit4);
analogWrite(pwmLED9, flimmerHelligkeit3);
}
}
void loop() {
Ablaufplan();
flimmernPwmPin();
}

Sicher wird der eine oder andere Teile seiner hier im Forum veröffentlichten Programme wiedererkennen.
Ich hoffe aber das es in Ordnung ist das ich sie mitverwendet habe, da sie ja hier öffentlich gemacht wurden.

Jetzt bleibt für mich die Frage wie ich das flimmern der LED nach dem Zufallsprinzip für kurze Zeiten unterbrechen kann,
ohne dabei delay zu benutzen.

Gruß Bernd

[MicroBahner]

Hallo Bernd,
ein kleiner Tip: Deine Posts werden übersichtlicher, wenn Du die Programme in 'Code' Tags einschliesst. Das sieht dann so aus:

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
 

achtRelais_Fernsehen_Probe
 
byte rels[] = {22, 24, 26, 28, 30, 32, 34, 36}; //Anschlüsse acht Relais
//Zeiten für die Relais in Millisekunden
long reltakt[] = {3600, 4200, 3000, 3600, 4800, 4600, 7200, 5400}; // Schaltzeit der Relais merken
 
long reltime[sizeof(rels)];
// Pins der LED festlegen
byte pwmLED1 = 2;
byte pwmLED2 = 3;
byte pwmLED3 = 4;
byte pwmLED4 = 5;
byte pwmLED5 = 6;
byte pwmLED6 = 7;
byte pwmLED7 = 8;
byte pwmLED8 = 9;
byte pwmLED9 = 10;
void setup() {
// alle verwendeten Pins auf Output 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);
pinMode(rels, OUTPUT);
for (long i=0;i<sizeof(rels);i++)
pinMode(rels[i], OUTPUT);
 
}
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 LEDs 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?
{
digitalWrite(rels[i],!digitalRead(rels[i])); // Relais schalten
}
 
}
}
// ab hier wird geflimmert
void flimmernPwmPin() {
static byte flimmerHelligkeit1;
static byte flimmerHelligkeit2;
static byte flimmerHelligkeit3;
static byte flimmerHelligkeit4;
{
flimmerHelligkeit1=random(256);
flimmerHelligkeit2=random(256);
flimmerHelligkeit3=random(256);
flimmerHelligkeit4=random(256);
analogWrite(pwmLED1, flimmerHelligkeit1);
analogWrite(pwmLED2, flimmerHelligkeit2);
analogWrite(pwmLED3, flimmerHelligkeit1);
analogWrite(pwmLED4, flimmerHelligkeit4);
analogWrite(pwmLED5, flimmerHelligkeit3);
analogWrite(pwmLED6, flimmerHelligkeit2);
analogWrite(pwmLED7, flimmerHelligkeit1);
analogWrite(pwmLED8, flimmerHelligkeit4);
analogWrite(pwmLED9, flimmerHelligkeit3);
}
}
void loop() {
Ablaufplan();
flimmernPwmPin();
}
 
 

Wenn Du es direkt aus der IDE so reinkopierst, bleiben dann auch die Einrückungen erhalten, was die Übersicht wesentlich erhöht.

Zitat von Behagen

---

Jetzt bleibt für mich die Frage wie ich das flimmern der LED nach dem Zufallsprinzip für kurze Zeiten unterbrechen kann,
ohne dabei delay zu benutzen.

---

Könnte man so ähnlich machen wie das Ein- Ausschalten der Relais. Statt einem Ausgangsport wird ein interner Merker gesetzt. Dann mit einer if-Abfrage die flimmer-Aufrufe nur ausführen wenn der Merker gesetzt ist.

N.B. warum treibst Du den Aufwand mit den Relais? Wenn dir die schon vorgeschlagene Variante mit dem Bus zu aufwändig ist, kannst Du doch einfach die Ausgänge statt an das Relais direkt mit einem Eingang des AtTiny verbinden. Und der führt dann sein Programm nur aus, wenn der Eingang gesetzt ist. (Ich gehe mal davon aus, dass Du die Programme dort auch etwas anpassen kannst? )

[Behagen]

Hallo

@Franz-Peter
Danke für Deine Hinweise, das mit den Code Tags war mir nicht bewusst, aber jetzt werde ich es gleichmal probieren.

Ich habe in der Zwischenzeit weitergemacht und bin nun bei diesem Ergebnis angekommen.

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
 

byte rels[] = {22, 24, 26, 28, 30, 32, 34, 36}; //Anschlüsse acht Relais
//Zeiten für die Relais in Millisekunden
long reltakt[] = {3600, 4200, 3000, 3600, 4800, 4600, 7200, 5400};
// Schaltzeit der Relais merken
long reltime[sizeof(rels)];
// Pins der LED festlegen
byte pwmLED1 = 2;
byte pwmLED2 = 3;
byte pwmLED3 = 4;
byte pwmLED4 = 5;
byte pwmLED5 = 6;
byte pwmLED6 = 7;
byte pwmLED7 = 8;
byte pwmLED8 = 9;
byte pwmLED9 = 10;
void setup() {
  // alle verwendeten Pins auf Output 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);
  pinMode(rels, OUTPUT);
  for (long i=0;i<sizeof(rels);i++)
     pinMode(rels[i], OUTPUT);
 
}
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 LEDs 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?
    {
      digitalWrite(rels[i],!digitalRead(rels[i])); // Relais schalten
     }
   
  }
}
// ab hier wird geflimmert
void flimmernPwmPin() {
   static long alterWert;
   static int  flimmerDauer = 100;
   static byte flimmerHelligkeit1;
   static byte flimmerHelligkeit2;
   static byte flimmerHelligkeit3;
   static byte flimmerHelligkeit4;
   if (milliSekundenTakt(flimmerDauer,alterWert)) 
   {
    flimmerDauer = 1+random(100);  // Flimmerdauer als Zufallswert
    flimmerHelligkeit1=random(65);
    flimmerHelligkeit2=random(76);
    flimmerHelligkeit3=random(156);
    flimmerHelligkeit4=random(26);
    analogWrite(pwmLED1, flimmerHelligkeit1);
    analogWrite(pwmLED2, flimmerHelligkeit2);
    analogWrite(pwmLED3, flimmerHelligkeit1);
    analogWrite(pwmLED4, flimmerHelligkeit4);
    analogWrite(pwmLED5, flimmerHelligkeit3);
    analogWrite(pwmLED6, flimmerHelligkeit2);
    analogWrite(pwmLED7, flimmerHelligkeit1);
    analogWrite(pwmLED8, flimmerHelligkeit4);
    analogWrite(pwmLED9, flimmerHelligkeit3);
   }
 }
void loop() {
  // put your main code here, to run repeatedly:
   Ablaufplan();  
   flimmernPwmPin();
}
 
 

Das ganze funktioniert nun so wie ich mir das ungefähr vorstelle.
Etwas feinschliff bei den Helligkeitswerten und das Ergebnis sollte passen.

Ich danke allen die mir mit Tips zur Seite gestanden haben.
Was die Frage Bus etc. betrifft --- seit mir nicht böse aber --- ich hab ja so schon kaum den Durchblick in dieser Sache
und dann wollt ihr das ich noch kompliziertere Aufgaben löse.
Die Relais habe ich gewählt weil ich zum einen nicht nur einen Attiny pro Anschluss schalten möchte und zum anderen
damit auch die Möglichkeit habe eventuell andere Spannungen zu schalten.

Gruß Bernd

[MicroBahner]

Hallo Bernd,
ist doch super, wenn der Arduino jetzt das tut was Du dir vorgestellt hast .

Zitat von Behagen

---

Was die Frage Bus etc. betrifft --- seit mir nicht böse aber --- ich hab ja so schon kaum den Durchblick in dieser Sache
und dann wollt ihr das ich noch kompliziertere Aufgaben löse.

---

Da ist dir sicher keiner böse. Ist doch klar, das eine Lösung auch immer am eigenen momentanten Kenntnisstand ausgerichtet sein muss (oder ein bisschen darüber hinaus, man will ja dazulernen ).

Zitat von Behagen

---

weil ich zum einen nicht nur einen Attiny pro Anschluss schalten möchte

---

Die Lösung mit der Direktverbindung zu einem Attiny Eingang erlaubt natürlich auch, einen UNO-Ausgang mit mehreren Attiny Eingängen zu verbinden. Voraussetzung natürlich, dass Du das Attiny Programm so ändern kannst, dass er auch auf den Eingang reagiert.

Zitat von Behagen

---

zum anderen damit auch die Möglichkeit habe eventuell andere Spannungen zu schalten.

---

Das ist ein nachvollziehbares Argument

[Behagen]

Hallo

Ich möchte nun dem Mega2560 noch etwas mehr Arbeit aufbürden, habe aber ein wenig Probleme damit wie ich das umsetzen kann.
Ich hatte im Januar 2015 bereits eine Zimmerbeleuchtung mit dem Arduino Uno in Arbeit.
Damals konnte ich das Projekt mit Hilfe des Forums, insbesondere der Hilfe von Uli (Spielbahn) erfolgreich umsetzen.
Hier der Link in den damaligen Thread: http://stummiforum.de/viewtopic.php?f=7&...ung+mit+Arduino
Nun würde ich gerne dieses Programm auch noch auf dem Mega laufen lassen.
Allerdings habe ich inzwischen dieses Programm erweitert, es schaltet nun vier Relais je nach Helligkeitswert aus und ein.
Diese Relais sollen z.B. dazu dienen die Straßenbeleuchtung und die Beleuchtung von öffentlichen Gebäuden zu steuern.
Ich stelle mal das veränderte Programm hier ein.

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
 

//Zimmerbeleuchtung mit Relais
//***********************************************************************************************
//DECLARATIONS
 
const byte WHITE = 9;  // Weiße LED an Pin 9
const byte BLUE = 6;  // Blaue LED an Pin 6
const byte GREEN = 5; // Grüne LED an Pin 5
const byte RED = 3;  // Rote LED an Pin 3
int FadeZeit = 150;  // ein höherer Wert verlangsamt den Farbwechsel
byte w,b,g,r; // Variablen Rot, Grün, Blau, Weiß
//
const byte REL1 = 2; // Anschluss Relais1
const byte REL2 = 10; //Anschluss Relais2
const byte REL3 = 11; //Anschluss Relais3
const byte REL4 = 12; //Anschluss Relais4
 
byte c,d,e,f; // Variablen für Relais
//
const byte pin1 = 7;
const byte pin2 = 8; // Anschluss Taster
const byte pin3 = 4;
// evtl. weitere
 
byte Schalter1;
byte Schalter2;
byte Schalter3;
//evtl. weitere
 
unsigned long FadeMillis;
byte wSoll,bSoll,gSoll,rSoll;
byte cSoll,dSoll,eSoll,fSoll;
byte state;
 

//***********************************************************************************************
//SETUP
 
void setup()
{
  // LEDs an
  wSoll=255;
  bSoll=255;
  gSoll=255;
  rSoll=255;
   // Relais aus
 
  dimmen();
  schalten();
  
  // Taster und Relais festlegen
  pinMode(pin1, INPUT_PULLUP);
  pinMode(pin2, INPUT_PULLUP);
  pinMode(pin3, INPUT_PULLUP);
  pinMode(REL1, OUTPUT);
  pinMode(REL2, OUTPUT);
  pinMode(REL3, OUTPUT);
  pinMode(REL4, OUTPUT);
  //evtl. weitere
  
}
 
//***********************************************************************************************
//MAIN
 
void loop()
{
  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();
}  
 
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=HIGH;
   else c=LOW; 
  digitalWrite(REL1,c);
  if(dSoll>0) d=HIGH;
   else d=LOW;
  digitalWrite(REL2,d);
  if(eSoll>0) e=HIGH;
   else e=LOW;
  digitalWrite(REL3,e);
  if(fSoll>0) f=HIGH;
   else f=LOW;
  digitalWrite(REL4,f);   
}
 

 

Zur Erläuterung was bei diesem Programm passiert:
Nach dem einschalten werden alle LED( ein Strip mit warmweißen LED und zwei Strips mit RGB LED) auf volle Leistung gestellt.
Mit dem Taster 1 kann der "Nachtmodus" angewählt werden, dadurch werden alle LED nach Programm heruntergeregelt.
Ist nun ein bestimmter Helligkeitswert erreicht werden die entsprechenden Relais geschalten.
Mit dem Taster 2 passiert das ganze dann in umgekehrter Reihenfolge.
Der Taster 3 dimmt die blauen LED auf einen Wert der Mondschein simulieren soll, auf die Relais hat er keinen Einfluss.

Nun möchte ich das je nach Helligkeit auch noch die Progammfunktionen des anderen Programms(ich nenne es mal 8-Relais mit Fernsehen)
angesteuert werden.
Die Frage die ich dabei habe ist: wie kann ich bei einem bestimmten Helligkeitswert einen Sprung in ein anderen Programmteil auslösen
Also z.B. if(b<50) zum Unterprogramm Ablaufplan.
-- Natürlich weiß ich das ich dazu den Programmcode erstmal in das Gesamtprogramm einarbeiten muss, aber ich verstehe im Moment auch
nicht was die Unterschiedliche Struktur der Programme bedeutet.
Im Programm "8-Relais mit Fernsehen" wird der void(loop) am Ende des Programms ausgeführt, im Programm "Zimmerbeleuchtung mit Relais"
jedoch schon viel eher und danach folgen einzelne Programmabläufe.
Was bewirkt diese unterschiedliche Form der Programmstruktur, oder hat sie garkeinen Einfluss?
Es wäre schön wenn mir da jemand helfen könnte.

Gruß Bernd

[Instandsetzung]

Hallo zusammen,

möchte auch noch meinen Senf dazu geben, kann aber außer Worten momentan nichts groß dazu beitragen, da ich momentan mehrere Umzüge zu stemmen habe :

Bei mir werkelt zwar auch ein MEGA, aber nicht weil er so viel zu erledigen hat,

sondern zum einen, da der Programm Code schon so viel geworden ist, da er die Tag und Nacht Steuerung des Raumes mit allen möglichen Effekten ( Gewitter, Nebel, Mond, Sonnenuntergang, Wandern der Sonne und der Wolken ) zu erledigen hat

und zum Anderen viele PWM Ausgänge für die unterschiedlichsten ( Farb- ) Effekte benötigt werden.

Da ich nun mal kein Programmierer bin, sehen die Sketche bei mir natürlich mittelmäßig chaotisch aus.
Das ist mir aber so was von egal, wie der Sketch aussieht - sieht ja hinterher niemand. Man sieht ja am Ende nur das Ergebnis – wie die Beleuchtung der Häuser und Fenster an und aus geht.

Vor Ort werkeln dann die Unos und Nanos.
Bei mir : Eine Aufgabe – Ein Arduino.
Die Teile sind bei Onkel Wu so billig, da baue ich keine Platinen mehr.
Ich vergeude auch keine Zeit mit Überlegungen, wie ein Arduino mehrere Aufgaben übernehmen kann.

Allerdings sind die nicht per Datenbus verbunden, sondern nur per Steuerleitung die ihnen sagt ob Tag oder Nacht ist.

Es gibt allerdings bei mir 2 Steuerleitungen.
Einmal für Hausbeleuchtung und einmal für Straßenbeleuchtung.

Eine Steuerleitung reicht bei mir für die Häuserbeleuchtung völlig, da ich mir da den Ablauf wie folgt ausgetüftelt habe:
Abends wenn es dunkel wird, geht die Haussteuerleitung auf High.
Dann gehen peu a peu in den Wohnungen die Lichter an.
Teilweise auch in Abhängigkeit:
Erst geht der Hausflur an danach die Wohnungsbeleuchtung. Nach einer Minute geht die Hausflurbeleuchtung wieder aus. Da ist also gerade jemand nach Hause gekommen.
Andere Fenster gehen dann auch an. Zwischendurch geht dann halt mal der Hausflur oder die Baderzimmerbeleuchtung an.
Nach einiger Zeit erlöschen die ganzen Beleuchtungen. Nur ab und zu geht noch mal eine Baderzimmerbeleuchtung an.
( Ich gehe spät abends immer noch mit dem Hund raus. Manche Häuserzeilen, besonders wo alte Menschen wohnen, sind dann komplett dunkel )

Am morgen, wenn die Haussteuerleitung auf Low geht, gehen verschiedene Wohnungen und die Badezimmer an. Dann geht die Hausflurbeleuchtung wieder ab und zu für einige Zeit an und ein paar Wohnungen werden nun dunkel ( Die gehen zur Arbeit ). Manche Wohnungsbeleuchtungen bleiben länger an.
Büros bleiben für eine bestimmte Zeit an. Geschäfte und Firmen entweder auch, oder sie gehen aus, wenn am Abend die Haussteuerleitung wieder auf High geht.

Ich überlege noch folgendes für die Bürobeleuchtung: Messung der Länge des Tages,
um dann die Bürobeleuchtung ( am nächsten Tag ) 2/3 der Länge des Tages leuchten zu lassen.

Der Vorteil von insgesamt 2 Steuerleitungen ist aber auch, daß man damit später – falls man es doch mal braucht - eine einfache und störungsfreie Datenübertragung realisieren kann:
Steuerleitung 1 einschalten
Steuerleitung 2 mehrmals ein- und ausschalten
Steuerleitung 1 wieder ausschalten

Und wenn dann die Übertragung größerer Zahlen eine ganze Sekunde dauert, so ist das bei diesem Thema doch so was von egal. Unregelässigkeiten im Ablauf sind ja sogar gewollt.


Dann noch ein paar Gedanken zum Fernsehen:
Das ist auch ein Punkt auf meiner Beleuchtungsagenda, der irgendwann mit integriert werden soll.

Inspiriert wurde ich ebenfalls durch Beobachtungen meiner abendlichen Spaziergänge mit dem Hund.
Bernd, Du hast ja anscheinend eine Katze und mit der geht man ja nicht Gassi.
Da fehlt Dir echt Lebenserfahrung

Ich finde Deine Idee, der verschiedenen Programme vollkommen richtig.
Ich konnte abends, wo wir früher gewohnt haben, an einem Wohnblock immer genau sehen, welche Wohnungen das gleiche Programm geschaut haben.

Da unser Umzug noch nicht komplett vollendet ist, kann ich Deinen Sketch momentan nicht testen und nichts dazu sagen, außer:
Ich finde flackern nicht realistisch. Es kommt selten beim Fernsehbild vor, außer natürlich bei Musikclips und ab und zu bei Actionszenen.
Je nachdem welches Bild zu sehen ist schwenken die Farben meist nur um.
Interessanter weise waren zumindest abends Grüntöne selten.

Grüße von jemandem, der auch meint, daß dieser Fred hier genau goldrichtig ist, denn hier geht es um die Modellbahn. Und zwar um Modellbahn auf ganz hohem Niveau – Dank der Beleuchtung

Oliver

[ThomasR]

Und wenn der Zug / Bus in der Haltestelle gehalten hat, gehen in den umliegenden Häusern auch noch mal die Hausflurbeleuchtungen an. Je weiter weg, desto später, weil ja der Weg länger ist.

Nur mal so als Anregung

[Behagen]

Hallo und ein gesundes neues Jahr

Zitat von Instandsetzung

---

Inspiriert wurde ich ebenfalls durch Beobachtungen meiner abendlichen Spaziergänge mit dem Hund.
Bernd, Du hast ja anscheinend eine Katze und mit der geht man ja nicht Gassi.
Da fehlt Dir echt Lebenserfahrung
Das finde ich dann doch eine gewagte These

Ich finde Deine Idee, der verschiedenen Programme vollkommen richtig.
Ich konnte abends, wo wir früher gewohnt haben, an einem Wohnblock immer genau sehen, welche Wohnungen das gleiche Programm geschaut haben.

Oliver

---

@ Oliver
Ich hatte es ja schon weiter oben angedeutet, das geflimmer ist nicht wirklich optimal, durch die von mir eingefügten Unterbrechungen wird es
etwas besser, aber es besteht noch Verbesserungspotential.
Ich mag mich täuschen, aber ich glaube das die heutigen Flachbildschirme die Zimmer "ruhiger" ausleuchten, als es die Röhrenfernseher getan haben.
Sollte ich keine Lösung dafür finden, meine beiden Programme auf dem Mega gleichzeitig laufen zu lassen, werde ich auf meinen Ursprünglichen
Plan zurückgreifen und die Zimmerbeleuchtung im UNO weiterbetreiben und eines der daran angeschlossenen Relais wird dann den Mega
ein und aus schalten. Also ähnlich wie Du es machst.
Neugierig bin ich aber was Deine Simulation von Nebel und Wolken betrifft --- wie geht das denn?
Meine Häuser sollen dann auch einen "sinnvollen" Lichtablauf bekommen, das finde ich schon schön.
Ich bin mir aber bei den Zeiten noch nicht sicher, also wieviel Minuten die Zimmer beleuchtet sein sollen.
Andererseits --- ob ich immer Lust habe eine "Nacht" dreißig Minuten lang sein zu lassen(als Beispiel) oder auch mal nur zwanzig ?
Naja, mal sehen ob ich den "Aufwand" weiter in die Höhe treibe oder doch lieber bei einer einfacheren Variante bleibe.

Gruß Bernd

[Instandsetzung]

Hallo zusammen im neuen Jahr,

noch ein paar Worte vorweg:
Es gab bei mir mehrere Umzüge: Wir, die Tochter, die Firma und Abriss der Anlage, für das das alles gedacht war.
Ich habe noch kein eigenes Telefon und hänge noch am Router des Nachbarn.
So wie es hier aussieht könnte man glatt meinen, das hier wäre ein Fall für den Trödel-Trupp.
Ich weiß nicht wo meine Kamera ist und das Handy ist mehr ein Scherbenhaufen.
Auf dem Rechner hier läuft die Arduino IDE nicht und die Internetverbindung per WLan ist aufgrund der Entfernung des Routers grenzwertig.

Normaler Weise schreibe ich auch nicht so viel, aber am 31. war ich so was von erleichtert . . . Jetzt kommen nur noch die ganzen Nacharbeiten .
( einen Teil des Textes aus dem Beitrag davor hatte ich aber auch schon mal in einem anderen Forum geschrieben und habe es nur kopiert )

Wie gesagt die Großanlage existiert nicht mehr. Bei der Größe der Anlage wäre es kein Problem gewesen die Wolken und die Sonne “wandern“ zu lassen und es gab auch eine große Wand am Ende, wo man mittels gelbem und rotem Licht an der Wand einen Sonnenuntergang hätte darstellen können. Ebenso sollten an dieser Wand mittels LED Stripes die Blitze eines Gewitters dargestellt werden.
Alles nun Geschichte. Ich habe jetzt nur noch ein Diorama an dem ich alles entwickelt und ausprobiert habe.

Zum Wetter:
Ich habe über dem Diorama mehrere LED Stripes. Kalt- und warm-Weiss für die Helligkeit, blau für die Nacht und rot um das LED Licht wärmer zu machen. Hinter dem Diorama ist unterhalb ein roter und ein gelber Stripe für den Sonnenuntergang.
Neben den Stripes über dem Diorama gibt es noch einen LED Spot.
Nichts weiter als ein Brettchen mit ein paar sehr hellen Stripes drauf.

Die kaltweißen LEDs geben ja nun ein sehr schäbiges leicht schmuddeliges Licht ab.
Nebel ist da vielleicht etwas übertrieben – diesig würde es wohl besser treffen.
Dafür dimme ich einfach das warmweiße und das rote Licht runter und man hat ein schmuddeligeres Licht.

Der “Spot“ sorgt für Schattenwurf an sonnigen Tagen. Wenn nun eine Wolke vor die Sonne zieht, dimmt dieser Spot runter und wenn die Wolke weg ist, dimmt er wieder hoch.
Bei der Anlage war eine Reihe dieser Spots vorgesehen. Die sollten nun der Reihe nach runter und dann wieder hoch dimmen und damit die Wolken vorbeiziehen lassen.


Noch ein Nachtrag dazu, daß ich einen roten Stripe auch für die Beleuchtung habe:
Allen weißen LEDs ist gemein, daß ihnen der Rotanteil fehlt.
Ich hatte das aus einem Bericht des MIWULAs, den ich mal gelesen hatte.
Daher muss auch ein zusätzlicher roter Streifen mit unter die Decke, um die Lichtfarbe aufzuwärmen und den Grünstich zu minimieren. Extrem kann man diese Farbunterschiede dann auf Fotos sehen.

Mit freundlichen Grüßen
Oliver

PS: Mir ist dann doch noch was eingefallen.
Da hatte in Punkto Farbwechsel beim Fernseher auch schon mal jemand was zu gebastelt. viewtopic.php?f=21&t=120444

[Behagen]

Hallo

@ Oliver
Ich habe mir mal die in Deinem Link vorgestellte Lösung angesehen und getestet.
Ja, das wirkt schon anders. Aber so wie ich das verstanden habe, ist dort im Programm immer der selbe "Film" abgelegt.
Wenn man also einen zweiten oder dritten haben möchte, müsste man selbst eine Liste mit Werten erstellen.
Dann würde aber auch dabei immer wieder der selbe "Film" ablaufen.
Ich habe jetzt nochmals mit meiner "Fernsehsimulation" gespielt und den Wert für die Flimmerdauer erhöht.
Nun sind dort 1000 millis eingetragen und das Ergebnis sieht für mich sehr stimmig aus.
Ich hätte nicht gedacht das so ein großer Wert passt, deswegen hatte ich erst so kleine gesetzt.
Wenn man dann noch in den Werten der Flimmerhelligkeit aufpasst welcher für welche Farbe zuständig ist
kann man die Farbanteile nach Geschmack einrichten. Zur Zeit habe ich ja vier Flimmerhelligkeitswerte eingerichtet,
das kann man natürlich auch bis auf neun erhöhen oder auch auf drei verringern, wie es beliebt.

Dein Beleuchtungskonzept war ja auch sehr ausgeklügelt.
Die Idee mit den gelben und roten Strips hinter dem Diorama klingt auch sehr gut, werde ich aber bei mir nicht anwenden.
Zum einen wegen der Gestaltung der Anlage und zum zweiten habe ich ja in meiner "Lampe" RGB LED verwendet und lasse
im Programm damit einen Sonnenuntergang simulieren. Das mag nicht ganz so Effektvoll sein, aber es muss eben reichen.

Mit dem zusammenführen der beiden Programme bin ich leider noch nicht weitergekommen.

Gruß Bernd

[MicroBahner]

Hallo Bernd

Zitat von Behagen

---

-- Natürlich weiß ich das ich dazu den Programmcode erstmal in das Gesamtprogramm einarbeiten muss, aber ich verstehe im Moment auch
nicht was die Unterschiedliche Struktur der Programme bedeutet.
Im Programm "8-Relais mit Fernsehen" wird der void(loop) am Ende des Programms ausgeführt, im Programm "Zimmerbeleuchtung mit Relais"
jedoch schon viel eher und danach folgen einzelne Programmabläufe.
Was bewirkt diese unterschiedliche Form der Programmstruktur, oder hat sie garkeinen Einfluss?

---

Den eigentlichen Ablauf deines Programms bestimmt allein das, was in der loop-Funktion steht. Ob ein innerhalb der loop-Funktion aufgerufenes Unterprogramm vor oder hinter dem loop-Code steht, spielt keine Rolle.
Wenn Du die Sketche zusammenführen willst, must du zum einen alle definierten Variablen und Unterprogramme/Funktionen in einem Sketch zusammenfassen, wobei die Reihenfolge wie gesagt eigentlich egal ist. Dann musst Du die beiden loop-Funktionen zusammenführen - im einfachsten Fall alle loop-Programmzeilen aus den beiden Sketchen in einem loop hintereinander schreiben.

Voraussetzung ist allerdings, dass Du komplett auf delay() verzichtest. Im derzeitigen Programm ist das ja schon so, in der 'Zimmerbeleuchtung mit Relais' werden aber noch eifrig delay() Aufrufe verwendet. Das müsstest Du zuerst umschreiben. Eventuelle Überschneidungen bei Variablennamen oder Portnummern musst Du natürlich auch noch bereinigen.

[Behagen]

Hallo

@ Franz-Peter
Danke für die Erklärung und Hinweise.
Mein Problem beim zusammenfügen ist die Tatsache das es nicht so funktioniert wie ich möchte.
Die acht Relais werden nachdem Start im entsprechenden Zeit Intervall angesprochen, ich möchte aber das dieses Zeit Intervall
erst zu laufen beginnt wenn ein bestimmter Helligkeitswert unterschritten wird und wieder beendet wird wenn der Helligkeitswert
wieder überschritten wird.
Eine andere Frage: wo sind in meinem Programm" Zimmerbeleuchtung mit Relais" noch delay Aufrufe?
Ich verwende das im Beitrag 13 eingestellte Programm, ältere Versionen sind nicht mehr in Gebrauch.

Gruß Bernd

[MicroBahner]

Hallo Bernd,
sorry, ich hatte mir nur das Programm in dem verlinkten Beitrag angesehen.
Da muss ich den Sketch aus Post #13 nochmal genauer unter die Lupe nehmen . Wenn ich dich richtig verstehe, hast Du dort schon beides zusammengeführt ?

[Behagen]

Hallo

@ Franz-Peter

Nein im Beitrag 13 sind beide noch nicht zusammengefügt.
Den aktuellen, aus beiden Teilen bestehenden Sketch stelle ich jetzt hier mal mit dazu.

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
 

// Zimmer-Fernsehen-zusammen
// Programm auf dem MEGA2560
// 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[] = {3600, 4200, 3000, 3600, 4800, 4600, 7200, 5400}; // Achtung zum testen nur Sekunden 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
  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);
  pinMode(REL2, OUTPUT);
  pinMode(REL3, OUTPUT);
  pinMode(REL4, OUTPUT);
  
  
  // 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);
  pinMode(rels, OUTPUT);
  for (long i=0;i<sizeof(rels);i++)
     pinMode(rels[i], OUTPUT);
 // dimmen();
 // schalten();   
  
}
// 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?
    {
      digitalWrite(rels[i],!digitalRead(rels[i])); // Relais schalten
     }
   
  }
}
// Berechnen des flackern der Fernsehprogramme 
void flimmernPwmPin() {
   static long alterWert;
   static int  flimmerDauer = 1700;
   static byte flimmerHelligkeit1;
   static byte flimmerHelligkeit2;
   static byte flimmerHelligkeit3;
   static byte flimmerHelligkeit4;
   if (milliSekundenTakt(flimmerDauer,alterWert)) 
   {
    flimmerDauer = 1+random(1700);  // Flimmerdauer als Zufallswert
    flimmerHelligkeit1=random(65);
    flimmerHelligkeit2=random(76);
    flimmerHelligkeit3=random(56);
    flimmerHelligkeit4=random(26);
    analogWrite(pwmLED1, flimmerHelligkeit1);
    analogWrite(pwmLED2, flimmerHelligkeit2);
    analogWrite(pwmLED3, flimmerHelligkeit1);
    analogWrite(pwmLED4, flimmerHelligkeit4);
    analogWrite(pwmLED5, flimmerHelligkeit3);
    analogWrite(pwmLED6, flimmerHelligkeit2);
    analogWrite(pwmLED7, flimmerHelligkeit1);
    analogWrite(pwmLED8, flimmerHelligkeit4);
    analogWrite(pwmLED9, flimmerHelligkeit3);
   }
 }
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=HIGH;
   else c=LOW; 
  digitalWrite(REL1,c);
  if(dSoll>0) d=HIGH;
   else d=LOW;
  digitalWrite(REL2,d);
  if(eSoll>0) e=HIGH;
   else e=LOW;
  digitalWrite(REL3,e);
  if(fSoll>0) f=HIGH;
   else f=LOW;
  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();
}
 

 

Mit diesem Sketch laufen sofort die acht Relais los, das soll so aber nicht sein.
Diese Relais sollen erst ihr Zeitintervall abarbeiten wenn die Helligkeit der Zimmerbeleuchtung einen bestimmten Wert unterschreitet.

Im Bereich des Fernsehprogramms habe ich die Zeit nun auch auf 1700 Millis erhöht, sieht auch gut aus.
Dort kann man also mit größeren Zeiten einen realistischeren Effekt erzielen, Vorteil bei meiner Variante ist das die Farbwechsel
zufällig erfolgen und sich nicht immer der selbe "Film" wiederholt. Nachteil ist der eventuell nicht 100%ige Realismus.

Gruß Bernd

[Instandsetzung]

Hallo,

da sollten dann doch die Fachleute dran .

Noch ein “Nachtrag“ von mir:

Was ich bis heute auch nicht verstanden habe, ist das “blink without delay“.
Ich verstehe den Hintergrund, damit Sachen unabhängig voneinander funktionieren können.
Ich verstehe auch wie es funktionieren soll.
Ich verstehe aber bis heute nicht was welche Befehle wie ausführen sollen und wo sie hinkommen.

Ich habe bisher alles mit delay hinbekommen.
Ich kann trotzdem alles Benötigte gleichzeitig laufen lassen.
Entweder gleichzeitig, versetzt, gleich- oder gegenläufig, man muss es nur entsprechend verschachteln.
Vielleicht habe ich auch eine andere Logik. Mir sagte mal jemand, als er mein Chaos sah:
Hier sieht es so aus wie in Ihrem Kopf flaster: .

Es nützt mir ja nichts, wenn ich mir beim Stammtisch das von denen, die das können, so umschreiben lasse und dann, wenn ich es wieder verändern will, nicht weiß wie es geht.

Nur: Fernseher und Tag- und Nacht-Steuerung gleichzeitig, würde ich auch nicht hinbekommen.

Mit freundlichen Grüßen
Oliver

[MicroBahner]

Zitat von Instandsetzung

---

Ich habe bisher alles mit delay hinbekommen....
...Nur: Fernseher und Tag- und Nacht-Steuerung gleichzeitig, würde ich auch nicht hinbekommen.

---

So wie ich das sehe, hat Bernd das schon hinbekommen. Der Schlüssel dazu ist es eben, kein delay() zu verwenden.
Ihm geht es doch nur noch darum Abhängigkeiten zu realisieren.

Zitat von Behagen

---

Die Frage die ich dabei habe ist: wie kann ich bei einem bestimmten Helligkeitswert einen Sprung in ein anderen Programmteil auslösen
Also z.B. if(b<50) zum Unterprogramm Ablaufplan.

---

Ja, genau so sollte das funktionieren. Rufe den Ablaufplan eben in einer if - Abfrage auf. Evtl. solltest Du im else-Zweig der Abfrage dann noch die Ausgänge abschalten, damit die Lichter auch sicher aus sind.
in loop():

1
2
3
4
5
6
7
8
9
10
11
 

...
if ( b<50 ) {
  Ablaufplan();
} else {
  for (byte i=0;i<sizeof(rels);i++)	  {	// Relais in Schleife durchgehen
    digitalWrite(rels[i],LOW);		// Relais ausschalten
  }
}
...
 
 

Eine Alternative wäre, das Umschalten der Relais in der Funktion Ablaufplan() von der Bedingung abhängig zu machen. Dann würden die Lichter auch nicht alle gleichzeitig an bzw ausgehen wenn der Schwellwert erreicht ist, sondern erst wenn die jeweilige Relaiszeit abgelaufen ist.
in ablaufplan():

1
2
3
4
5
6
7
8
 

...
    if (milliSekundenTakt(reltakt[i],reltime[i]))  // Takt für dieses Relais abgelaufen?
    {
      if (b<50) digitalWrite(rels[i],!digitalRead(rels[i])); // Relais schalten
      else digitalWrite(rels[i],LOW );
     }
...
 
 

Sind alles nur theoretische Überlegungen, ausprobieren kann ich es nicht

[Behagen]

Hallo

@ Oliver
Das Du bisher keine Probleme mit dem delay bekommen hast, könnte mit Deinen Programmen zutun haben.
Bei meinem Programm sollen ja dann die Relaisschaltzeiten mehrere Minuten betragen, wenn dann im Programm noch
ein oder mehrere delay sind kann das wohl die Ausführung im Programm extrem verlängern.
(vorausgesetzt ich habe das richtig verstanden, was ich zum delay gelesen habe)

@ Franz-Peter
Dein erster Vorschlag funktioniert leider nicht, auch damit laufen die acht Relais sofort los.
Aber Dein zweiter Vorschlag funktioniert --- fast!
Auch hier laufen die Relais nach dem einschalten der Betriebsspannung sofort los.
Aber nur einen Durchlauf, dann schalten sie sich aus und warten den Programmaufruf ab.
Das macht jetzt mit den kurzen Zeiten(die ich zum testen eingetragen habe) noch keine Probleme,
aber später im fertigen Zustand werden dann zweistellige Minutenwerte eingetragen sein, da dürfte es
schon etwas störend sein.
Ein anderes Problem lässt sich leichter lösen.
Durch die Verwendung von if (b<50) wird beim drücken der Taste für den Mondschein der Ablauf unterbrochen.
Alle Relais schalten sich dann wieder ab.
Aber das wird durch verwenden einer anderen Variable, bzw. durch das anheben des Wertes auf 65, gelöst.

Anmerken muss ich noch -- nach dem einschalten der Betriebsspannung werden sowieso alle Relais eingeschalten
und bleiben es auch, bis das Programm einen Schaltbefehl für sie ausführt. Somit muss man eigentlich die Aussagen zum
Zustand der Relais im vorhergehenden Text umdrehen.
Nun könnte man auf die Idee kommen am Anfang des Programms die Pins für die Relais mit einem LOW zu belegen,
aber alle meine Versuche das hinzubekommen haben nicht funktioniert.
Entweder lassen sich dann die Relais gar nicht mehr schalten, oder ich belasse es so wie es jetzt ist.

Gruß Bernd