LED´s blinken zu beginnt der PWM Ansteuerung einmal auf

Hallo Leute,

ich habe folgendes Problem.

Ich hab mehrere LED`s über einen Transistor mit PWM angesteuer.

Ziel der Ansteuerung soll mal eine Tag Nacht Simulation werden. Vorerst nur mit weißen LED. Später mehr farbig.

Also: 1 Morgens langsam hell werden

2 Tag Hell

3 Abend langsam dunkel werden

4 Nacht LED aus

Diese habe ich jetzt auch für die weißen LED fertig und läuft auch. Aber folgendes Problem.

Wenn der Abschnitt Hell werden startet blinken die LED einmal auf. Beim Übergang in den Bereich Tag blinken die LED einmal. Beim Übergang in den Bereich Dinkel werden blinken sie einmal. Bei Übergang Dunkel werden zu Nacht funktioniert es. An dieser stelle ist die LED aber auch aus.

Hat jemand eine Idee wo das Problem liegt?

Gruß Bernd

Du hast einen Fehler im Sketch.

Posten den Sketch und wir können dir helfen.

Den Sketch bitte in Code-Tags setzen. Schaltfläche </> oben links im Editor verwenden.

bernie0: Wenn der Abschnitt Hell werden startet blinken die LED einmal auf. Beim Übergang in den Bereich Tag blinken die LED einmal. Beim Übergang in den Bereich Dinkel werden blinken sie einmal. Bei Übergang Dunkel werden zu Nacht funktioniert es. An dieser stelle ist die LED aber auch aus.

Hat jemand eine Idee wo das Problem liegt?

Gruß Bernd

Gemäß Deiner Beschreibung funktioniert die Hardwareschaltung und der Sketch enthält mehrere Fehler in der Programmlogik.

bernie0: Hat jemand eine Idee wo das Problem liegt?

Ja: Dein Sketch ist fehlerhaft :-)

Sorry, der ging auf Deine Kosten. Aber den Sketch, mit dem Du Probleme hast, solltest Du schon zeigen.

Gruß

Gregor

Hallo alle,

erstmal Danke für die Antworten.
Wie gewünscht der Sketch .
An dem Sketch gibt es sicher einiges zu verbessern.
Bin halt noch recht am Anfang.
Genau so sollen halt später auch die anderen Farben noch genutzt werden.

int ledtag = 8; // PWM Pin fuer die LED TAG
int itag=0; // Variabele helligkeit Tag
int izeittag=0; // Variable Zeit Tag
int ledrot = 7; // PWM PIN für RGB LED ret
int irot=0; // Variabele helligkeit RGB Rot
int ledblau = 6; // PWM Pin für die RGB LED blau
int iblau = 0; // Variabele helligkeit blau
int ledguen = 5; // PWM Pin für die RGB LED Grün

void setup(){} // Kein Setup notwendig

void loop()
{

// Morgens hellwerden
for (;itag<=255; itag++) // aufsteigender Wert für itag
{
analogWrite(ledtag, itag); // setzt den Helligkeitswert auf itag
delay(285); // Pause fuer 285ms
}

// Tag hell

for (;izeittag <= 255; izeittag++)
{
delay (285); // Hell Tag
}

// Nacht dunkel werden
for (;itag>=0; itag–) // absteigender Wert fuer i
{
analogWrite(ledtag, itag); // setzt den Helligkeitswert auf i
delay(285); // Pause fuer 285ms
}

// Nacht dunkel
for (;izeittag >= 0; izeittag–) // Nacht
{
delay (285); // Nacht
}
}

Schön mal Danke für eure Hilfe.

Gruß
Bernd

itag hört mit -1 auf. Das gibt eine helle Anzeige am Anfang von loop.

int ist nicht der optimale Datentyp, die Art deiner for-Schleifen ist auch nicht gut.

Ausserdem: rate mal, warum loop() loop heisst. (Weil man eigentlich gar keine for- Schleifen braucht. )
Aber das stört dich erst später.

bernie0: Wie gewünscht der Sketch . An dem Sketch gibt es sicher einiges zu verbessern.

Und bitte setze den Sketch in Code-Tags, so ist er fas nicht zu lesen. Auf Mobil-Geräten überhaupt nicht.

Schön mal Danke für eure Hilfe.

Gruß Bernd [/quote]

Was soll denn das werden, wenn es fertig ist?

"Es wird heller in blockierender Schleife,gefolgt von es wird dunkler in blockierender schleife und das "es s wird heller" gefolgt von "es wird dunkler" immer wieder und wieder und wieder, pausenlos?

Und das ist die einzige Aufgabe des gesamten Sketeches, es gibt keine zweite oder dritte Aufgabe?

Wobei jedesAbdimmen und Aufdimmen 256*285 Millisekunden = gute 72 Sekunden dauert?

Also keine Sensoren und keine reale Zeit zur Nachbildung eines normalen Tagesverlaufs?

In dem Fall brauchst Du doch einfach nur einen Sinus über die Zeitdauer seit dem /Einschalten/Reset laufen lassen, der periodisch die Helligkeit im Sinusverlauf bestimmt, mal Heller, mal dunkler.

Oder wenn Dir sinusförmige Änderungen (mit sehr geschmeidigen und kaum wahrnehmbarer Änderung en der Helligkeitan den Maxima/Minima nicht gefällt, dann vielleicht trapezförmig, die Helligkeit im Zeitverlauf linear zunehmend und danach wieder linear abnehmend, das ist glaube ich eher das, was Du machen möchtest. pder?

Aber endlos heller und dunkler und sonst nichts?

Hallo nochmal,

also mit dem -1 hat Michael recht. habe den Sketch etwas abgeändert und mein Blinken ist weg.
Hier nochmal der geänderte Sketch.
Hoffe ich habe das mit dem Code-Tags jetzt richtig gemacht sonst erkläre mir das bitte jemand.

int ledtag = 8; // PWM Pin fuer die LED TAG
int itag=0;     // Variabele helligkeit Tag
int izeittag=0; // Variable Zeit Tag
int ledrot = 7; // PWM PIN für RGB LED ret
int irot=0;     // Variabele helligkeit RGB Rot
int ledblau = 6; // PWM Pin für die RGB LED blau
int iblau = 0;  // Variabele helligkeit blau
int ledguen = 5; // PWM Pin für die RGB LED Grün

void setup(){} // Kein Setup notwendig

void loop()
{

// Morgens hellwerden
for (;itag<=254; itag++) // aufsteigender Wert für itag
{
analogWrite(ledtag, itag); // setzt den Helligkeitswert auf itag
delay(285); // Pause fuer 285ms
}

// Tag hell

for (;izeittag <= 254; izeittag++)
{
delay (285); // Hell Tag
}

// Nacht dunkel werden
for (;itag>=1; itag--) // absteigender Wert fuer i
{
analogWrite(ledtag, itag); // setzt den Helligkeitswert auf i
delay(285); // Pause fuer 285ms
}

// Nacht dunkel
for (;izeittag >= 1; izeittag--) // Nacht
{
delay (285); // Nacht
}
}

Dabei habe ich jetzt aber festgestellt das die LED nicht mehr ganz aus geht bei Nacht.

Jurs Grundlegend macht die Schleife nur endlos hell und dunkel. Dieses ist aber erst der Anfang der Arduino soll später mal die gesamte Beleuchtung meiner Mobelbahnanlage steuern. Sprich morgen mit einem Orangeton Sonne aufgehen die Beleuchtung der Häuser nach einander ausgehen . Tag Umgebungsbeleuchtung an und eventual ein Blaulicht. Abends halt wieder dunkler werden und Straßenbeleuchtung etc. an dieses soll Endlos in einer Schleife von ca. 10 Min sich wieder holen.

Wie gesagt dieses hell und dunkel ist erst der Anfang. Aber so kann ich ja einfacher Fehler suchen als in einem langen Sketch wo ich nachher viele Fehler suchen muss.

Wenn also jemand vorschlage hat sowas einfacher umzusetzen dann bitte gerne machen.

Ich habe mir einiges durchgelesen und meistens wurde das Dimmen über eine ähnliche Schleife gemacht.

Gruß
Bernd

bernie0: Wie gesagt dieses hell und dunkel ist erst der Anfang. Aber so kann ich ja einfacher Fehler suchen als in einem langen Sketch wo ich nachher viele Fehler suchen muss.

Also später soll sich das hell und dunkel irgendwann vielleicht nach einem abzufragenden "Helligkeitssensor richten, der dem Programm "sagt", wann es hell und wann es dunkel ist? Und Deine Beleuchtung soll dann zur Umgebungshelligkeit gleichlaufend gesteuert werden? Also wenn das Umgebnungslicht hell ist, sollen Deine LEDs langsam aufdimmen, bis sie auch hell leichten? Und wenn das Umgebungslicht dunkel ist, dann sollen Deine LEDs langsam runterdimmen, bis auch sie ganz dunkel sind?

Oder umgekehrt Helle Umgebung/dunkle LEDs und dunkle Umgebung / helle LEDs?

Hallo jurs,

nein dieses wir auch Später nur nach zeit passieren.

Die Anlage steht ja im Keller. Wo es immer dunkel ist wenn ich nicht Licht an mache.
Diese LED die ich zur Zeit dimme im Sketch soll später mal LED Bänder unter der Decke werden.
So das im ganzen Raum im wechsel Tag und nach wird. Dazu kommen dann halt die entsprechenden
Gebäude etc…
Eventual soll nochmal 2 Schalter rein um ein Signal für dauer Tag oder dauer Nacht geben.

Ich hoffe es wird verständlich was ich mal bewirken will.

Gruß
Bernd

bernie0: Ich hoffe es wird verständlich was ich mal bewirken will.

OK, also ein "Sketch ohne Sensoren", der einen PWM-Pin zuerst alle 285ms um eine Stufe heller ansteuert bis zur maximalen Helligkeit erreicht ist, dann immer alle 285ms eine Stufe dunkler bis "aus". Und dann wieder von vorne. Und wieder, und wieder, und wieder...

Was hältst Du davon!

enum {HELLER,DUNKLER};

 const byte ledtag = 8;
byte helligkeit=0;
byte mode=HELLER;
unsigned long lastChangeTime;

void setup() {
  Serial.begin(9600);

}

void loop() 
{
  long now=millis();
  if (now-lastChangeTime>=285)
  {
    lastChangeTime=now;
     if (mode==HELLER) helligkeit++;
     if (mode==DUNKLER) helligkeit--;
     if(helligkeit==255) mode=DUNKLER;
     if(helligkeit==0) mode=HELLER;
Serial.println(helligkeit);
 analogWrite(ledtag,helligkeit); 
  }

}

Rückmeldung willkommen!

Hinweis: Diese "lineare PWM-Steuerung" ist NICHT dem Helligkeitsempfinden des menschlichen Auges angepaßt, sondern bei hoher Helligkeit emfpindet das menschliche Auge die verschiedenen Stufen als absolut gleich hell. Zwischen PWM 250 und 255 istkaum ein Unterschied feststellbar. Aber am unteren Ende treten Sprünge auf, zwischen PWM 0 und 5 ist jedesmal ein deutlicher Helligkeitssprung wahrnehmbar.

Ein dem Helligkeitsempfinden angepaßtes Dimmen muss anders gemacht werden: Geringe/langsame Änderungen im unteren Helligkeitsbereich und stärkere/schnellere Änderungen im oberen Helligkeitsbereich.

Eventual soll nochmal 2 Schalter rein um ein Signal für dauer Tag oder dauer Nacht geben.

Dann wirst du eventuell merken, was für ein Murks deine jetzige Funktion ist: Entweder du wartest meherere Minuten bis eine Schalter-Änderung erkannt wird, Oder du musst das gleiche Schalter-Einlesen zig mal in loop wiederholen, Oder du schaust dir jurs' Gegenvorschlag an. (Verstehst den grundlegenden Unterschied, und ergänzt ihn um deine Phasen konstanter Helligkeit.)

Aber bis dahin kannst du natürlich deinen Sketch so lassen wie er ist, wenn es dir gefällt. Dass andere deine "Simulation" anders lösen würden, braucht dich nicht zu stören, wenn du zufrieden bist. Dass das Ganze mit weniger Programmspeicher zu realisieren ist, der gleiche Arduino zusätzlich noch erheblich mehr Sachen machen könnte, die Übergänge weicher und evtl. "realistischer" sein könnten, kann dir natürlich egal sein. Und uns anderen auch, jurs ;)


Das mit dem Code -Tag hast du leider zur Zeit noch nicht hingekriegt. 
Kannst aber jederzeit deine eigenen Beiträge modifzieren. ( s. "More / Modify" ). 
Es ist nie zu spät, nur irgendwann egal. ;)

Ach ja: Willkommen im Forum 8)

Hallo Jurs,

habe deinen Sketch eben aufgespielt und getestet. So weit läuft er und vieles ist klar. Ein paar Fragen habe ich aber. Manche mögen jetzt lachen ich möchte aber gerne verstehen warum manche Ansätze besser oder einfacher sind wie meiner.

  1. Wo für wird des Enum oben benötigt?

  2. Warum ist eine byte Variable besser als eine Int?

  3. Wie funktioniert das mit “last Change Time” und long ?

  4. Wofür ist die Serial Kommonikation?

Kannst du mir einen Tip geben welche Literatur oder Web Seite gut ist im erklären der Befehle?

Danke schon mal für deine Hilfe.

Gruß
Bernd

bernie0: 1. Wo für wird des Enum oben benötigt?

Das ist nur eine Aufzählung (Enumeration) der verschiedenen Betriebszustände. Das gepostete Beispielprogramm kennt nur zwei Betriebszustände: HELLER und DUNKLER, und die sollten eigentlich selbsterklärend sein, was in dem jeweiligen Betriebszustand passiert. Am Ende einesDimvorgangs wird jeweils automatisch in den anderen Zustand umgeschaltet.

Mein Programm ist quasi ein "endlicher Zustandsautomat (Finite State Machine), wobei das "endlich" dafür steht, dass es eine abzählbare "endliche Anzahl an Betriebszuständen für diesen Automaten gibt, in meinem Beispielprogramm genau zwei Stück.

Bei Erweiterungen könnte es sein, dass es neben den Betriebszuständen "HELLER" und "DUNKLER" noch weitere Betriebszustände gibt, wie z.B. "MORGENDÄMMERUNG,, TAG, NACHT oder SCHLAFENSZEIT, in denen denen dann andere Dinge gesteuert werden als immer nur eine weiße LED per analogRead in wechselnder Heligkeit.

bernie0: 2. Warum ist eine byte Variable besser als eine Int?

Byte ist nicht an sich besser oder schlechter. Byte braucht beispielsweise halb so viel RAM-Speicher wie int, und hat einen anderen Wertebereich.

  1. Wie funktioniert das mit "last Change Time" und long ? Mein Programm merkt sich "wann etwas passiert", also die Helligkeit sich ändert, und merkt sich die Zeit in dieser Variablen. Durch Vergleich mit dem aktuellen Stand von millis() kann dann einfach festgestellt werden, wann wieder etwas passieren soll. Nämlich immer nach 285 Millisekunden in dem HELLER/DUNKLER Task.

Wenn das Programm um weitere Tasks ergänzt werden soll, also z.B. auf das Betätigen von Schaltern irgendwelche Aktionen gestartet oder Betriebszustände umgeschaltet werden sollen, und die Tasks sollen unterschiedlich schnell laufen, dann braucht man für jeden der asynchron laufenden Tasks wieder eine eigene Variable, um sich den Zeitpunkt von einer Aktion zu merken.

Das wird benötigt, um eine "kooperative" Zeitsteuerung zu realisieren, bei der ein Task die anderen Tasks nicht behindert oder gar blockiert, so wie es bei Verwendung von "delay() der Fall wäre: Mit delay() kann man kein kooperatives Multitasking mehrer asynchron laufender Tasks realisieren. Denn delay() ist nicht kooperativ, sondern "blockiert" das Programm und den Ablauf für eine feste Zeit.

  1. Wofür ist die Serial Kommonikation?

Die Ausgaben auf Serial sind "Debug-Ausgaben", die dienen nur dem Programmentwickler, damit er einfach nachvollziehen kann, was das Programm gerade macht.

Viele andere Möglichkeiten als "serielles Debugging", also dass man sich vom Programm auf Serial anzeigen läßt, was es gerade macht, gibt es für die Atmega-Arduinos ja nicht.

Kannst du mir einen Tip geben welche Literatur oder Web Seite gut ist im erklären der Befehle?

Die "Befehle" stehen in der Arduino-Referenz drin: https://www.arduino.cc/en/Reference/HomePage

Und beim Programmieren ist es die Aufgabe des Programmierers, geeignete Datenstrukturen, Algorithmen und "Befehle" auszuwählen und sinnvoll zu kombinieren, damit das Programm am Ende das macht, was es soll.

Hallo jurs,

Danke erstmal für die vielen Tips und Informationen. Werde erstmal einiges ausprobieren und testen und mich dann nochmal melden.

Wünsche dir einen guten Rutsch ins neue Jahr.

Gruß Bernd