Beleuchtungssteuerung für einen Leuchttum

Hallo zusammen,

ich habe da ein kleines Problem und hoffe das mir jemand helfen kann.

Mein Schwiegervater hat sich einen Leuchtturm für den Garten gebaut, den er gerne beleuchtet haben möchte. Der Leuchtturm besitzt 8 Fenster, die nach einander eingeschaltet werden sollen (Fenster 1 an -> 1min- >aus ->Fenster2 an -> 1min -> aus....) gleichzeitig soll oben im Turm das "Rundumlicht" die ganze zeit Faden.

Hinbekommen das die Lampen nacheinander angehen, habe ich hinbekommen auch den Fade der einzelen LED. Leider klappt dies nicht gleichzeitig. LED´s gehen nacheinander an dann wir die LED nach jedem durchlauf heller. Logisch da ich ja leider mit Delays gearbeitet habe.

Gibt es eine Möglichkeit, dies gleichzeitig laufen zu lassen? Oder kann der Arduino Uno das nicht weil 2Funktionen? I

Mit freundlichen Grüßen Tim

(deleted)

Gibt es eine Möglichkeit, dies gleichzeitig laufen zu lassen? Oder kann der Arduino Uno das nicht weil 2Funktionen? I

"Gleichzeitig" nicht, aber so schnell - sehr schnell - dass es so aussieht, als liefe das gleichzeitig.

Du musst auf jedes "delay" verzichten und nach dem Muster "BlinkWithoutDelay" arbeiten. Auch tiefe-Forschleifen oder Whiles in Verbindung mit Delay müssen aufgelöst werden.

Schau dir das BlinkWithoutDelay an, bringe zwei LED's unabhängig voneinander zum Blinken, dann hast du das Konzept verstanden.

Wenn du wirklich mehr Hilfe benötigst, solltest du einen Schaltplan und den jetzigen Sketch hier posten. Auch ein Zeitdiagramm aus dem der Zusammenhang der überschneidenden PWM Werte ersichtlich ist, würde die Helfer unterstützen damit du schneller an das Ziel kommst.

Da ein Uno zu wenig PWM pins hat solltest du genau schreiben welches Board du verwendest und wenn es ein Exot ist - auch verlinken.

edit: wenn ich mir das so überlege, habe ich da sogar was ähnliches fertiges (Stichwort Larson Scanner), aber schau'ma mal, was von dir so kommt.

Du könntest es auch mit den MobaTools versuchen. Beim MotoTimer ist ein Beispiel dabei, wie man Led’s unabhängig voneinander steuert. Und auch faden geht damit. Wobei dei Frage ist, wie langsam das Faden sein soll. Da gibt es Grenzen.
Installierbar sind die MobaTools direkt über den Bibliotheksmanager.

Hallo, danke erstmal für die Antworten. Anbei die Boardinfos: BN: Arduino Uno VID: 2341 PID: 0043 SN: 55732323630351014061

Welches Board es genau ist, kann ich leider nicht sagen hab ihn bei Ebaykleinanzeigen gekauft schätze der R3.

Ich hoffe die Bilder sind aussagekräftig,

Zeit.png|1416x672

Pin.png|1416x672

asooo, nur oben faden. ok - dann versteh ich das mit dem UNO.

in welchem Intervall fadet die Topleuchte? Sketch? (und langfristig - verwende 0 und 1 nur für Serial Output, als mach lieber 3..12 und die 9 für PWM)

Wenn es ein Uno ist (Bild posten), dann ist die Verwendung der Pins D0 und D1 nicht zu empfehlen. Da ist üblicherweise der onboard USB-Adapter angeschlossen.

(deleted)

Wenn Du die Übergänge zwischen den 8 1Min. LED's auch 'weich' mit fadeOut/FadeIn haben willst, wären die MobaTools perfekt, da sie für das faden keine PWM-Pins benötigen. Das geht an allen digitalen Pins.

so als Grundgerüst mit unsyncronisierter Top-Leuchte

// Lighthouse with 8 LEDs and one top PWM
// https://forum.arduino.cc/index.php?topic=711838
// by noiasca

#define DEBUG_UART 1

const uint8_t pwmPin = 3; // UNO PWM pins 3, 5, 6, 9, 10, 11
const uint8_t ledPin[] = {2, 4, 5, 6, 7, 8, 9, 10};
const size_t totalNoLeds = sizeof(ledPin);

uint32_t currentMillis = 0;

void doRunning()                              // switch on / off one LED after the other
{
  static uint8_t actual = totalNoLeds - 1;    // start with the last LED
  static uint32_t previousMillis = 0;
  const uint8_t myIntervall = 5;              // intervall in seconds
  
  if (currentMillis - previousMillis >= myIntervall * 1000UL)
  {
    previousMillis = currentMillis;
    digitalWrite(ledPin[actual], LOW);
    actual++;
    if (actual >= totalNoLeds) actual = 0;
    digitalWrite(ledPin[actual], HIGH);
#if DEBUG_UART
    Serial.print("actual Pin=");
    Serial.println(ledPin[actual]);
#endif
  }
}

void doPWM()
{
  static uint32_t previousMillis = 0;
  const uint16_t myIntervall = 10;             // speed of PWM
  static int8_t dir = 1;                       // direction upwards(1) or downwards (-1)
  static uint8_t newPwm;

  if (millis() - previousMillis >= myIntervall)
  {
    previousMillis = millis();
    if (dir == 1 && newPwm >= 254)        // end of scale
      dir = -1;                           // go downwards
    if (dir == -1 && newPwm <= 54)        // lower end of pwm scale
      dir = 1;                            // go upwards
    newPwm += dir;
    analogWrite(pwmPin, newPwm);
#if DEBUG_UART
    Serial.print("newPwm=");
    Serial.println(newPwm);
#endif
  }
}

void setup() {
#if DEBUG_UART
  Serial.begin(115200);
#endif
  for (uint8_t i = 0; i < totalNoLeds; i++) {
    pinMode(ledPin[i], OUTPUT);
  }
  pinMode(pwmPin, OUTPUT);
}

void loop() {
  currentMillis = millis();
  doPWM();                  // check, if PWM needs to be changed
  doRunning();              // check, if one of the running LEDs need to be changed
  // do what ever you want unblocked here
}

noiasca: so als Grundgerüst mit unsyncronisierter Top-Leuchte

// Lighthouse with 8 LEDs and one top PWM
// https://forum.arduino.cc/index.php?topic=711838
// by noiasca

define DEBUG_UART 1

const uint8_t pwmPin = 3; // UNO PWM pins 3, 5, 6, 9, 10, 11 const uint8_t ledPin[] = {2, 4, 5, 6, 7, 8, 9, 10}; const size_t totalNoLeds = sizeof(ledPin);

uint32_t currentMillis = 0;

void doRunning()                              // switch on / off one LED after the other {  static uint8_t actual = totalNoLeds - 1;    // start with the last LED  static uint32_t previousMillis = 0;  const uint8_t myIntervall = 5;              // intervall in seconds    if (currentMillis - previousMillis >= myIntervall * 1000UL)  {    previousMillis = currentMillis;    digitalWrite(ledPin[actual], LOW);    actual++;    if (actual >= totalNoLeds) actual = 0;    digitalWrite(ledPin[actual], HIGH);

if DEBUG_UART

   Serial.print("actual Pin=");    Serial.println(ledPin[actual]);

endif

 } }

void doPWM() {  static uint32_t previousMillis = 0;  const uint16_t myIntervall = 10;             // speed of PWM  static int8_t dir = 1;                       // direction upwards(1) or downwards (-1)  static uint8_t newPwm;

 if (millis() - previousMillis >= myIntervall)  {    previousMillis = millis();    if (dir == 1 && newPwm >= 254)        // end of scale      dir = -1;                           // go downwards    if (dir == -1 && newPwm <= 54)        // lower end of pwm scale      dir = 1;                            // go upwards    newPwm += dir;    analogWrite(pwmPin, newPwm);

if DEBUG_UART

   Serial.print("newPwm=");    Serial.println(newPwm);

endif

 } }

void setup() {

if DEBUG_UART

 Serial.begin(115200);

endif

 for (uint8_t i = 0; i < totalNoLeds; i++) {    pinMode(ledPin[i], OUTPUT);  }  pinMode(pwmPin, OUTPUT); }

void loop() {  currentMillis = millis();  doPWM();                  // check, if PWM needs to be changed  doRunning();              // check, if one of the running LEDs need to be changed  // do what ever you want unblocked here }

Grundgerüst? Das ist genau die Funktion die ich brauche vielen dank, jetzt muss ich es nur noch verstehen. :D

einfach mit dem Finger Zeiler für Zeile durchgehen. aufkommende Fragen notieren.

Bei der aller letzten schließenden Klammer die Fragen googeln. Wenn google nichts bringt - hier fragen.

Hallo Tim, das wäre mein Vorschlag mit MobaTools und weichem Überblenden der Minuten-Leds:

#include 

const byte ledPins[] = { 2,3,4,5,6,7,8,9 }; // muss byte sein wg. sizeof
const byte ledZahl = sizeof(ledPins);
const byte fadePin = 10;
MoToTimebase minuteTime;        // Zeitbasis für die Minuten-Leds
MoToTimebase fadeTime;          // Zeitbasis für die einzelne Fade-Led

MoToSoftLed minuteLeds[ledZahl];
MoToSoftLed fadeLed;

byte minuteIx = 0;          // aktive Minuten-Led

void setup() {
    // Minuten-Leds initiieren:
    for ( byte i=0; i= ledZahl ) minuteIx = 0;
        minuteLeds[minuteIx].on();      // nächste Led einschalten
    }
    // Fade-Led umschalten
    if ( fadeTime.tick() ) fadeLed.toggle();

}

(deleted)

timsieberg: Mein Schwiegervater hat sich einen Leuchtturm für den Garten gebaut, den er gerne beleuchtet haben möchte.

Hat der Leuchtturm ein Vorbild? Hat Dein Schwiegervater einen Bezug zu diesem Vorbild?

Wenn "ja" sollte der Leuchtturm, wie schon angedeutet, nicht einfach nur blinken, sondern die Blinkfolge des Vorbilds nachahmen. Wer sich einen Leuchtturm baut, legt da wahrscheinlich Wert drauf, vermute ich mal.

Hast Du ein Foto?

Hier ein Bild des Leuchtturms, den Turm gibt es nicht mehr.

Vielen danke erstmal für eure Antworten, das hat mir schon sehr weitergeholfen. Jetzt habe ich gestern nochmal mit ihm telefoniert.

Er möchte es jetzt gerne wie folgt haben: - Einschalten bei Dämmerung Habe einen passenden Lichtsensor. Ich habe bei den Programmen von noiasca und MicroBahner auch hinbekommen, dass die LED´s erst angehen, wenn ein bestimmter Wert-X unterschritten ist. Leider ist es jetzt so, dass sobald der Wert-X wieder überschritten wird also Tag, das Programm gestoppt wird und nicht weiterläuft. Wird der Wert wieder unterschritten, wird das Programm an der Stelle fortgesetzt.

Als "Leuchtfeuer" sollte die LED sehr hell sein und sich "drehen": Habe jetzt an eine 230V G9 LED-Lampe gedacht die dauerhaft über ein Relaismodul eingeschaltet wird. Mithilfe eines Schrittmotors, soll dich der "Spiegel" mit ca. 1U/min um die LED drehen, sodass eine Art Lichtkegel erscheint. Dies soll natürlich unabhängig von der Fensterbeleuchtung laufen. Auch hier soll bei Überschreiten von Wert-X die Lampe und der Motor ausgehen.

ce4936b4-d994-40d6-8f1c-6f3eff91ac8a.jpg|768x1024

timsieberg: Hier ein Bild des Leuchtturms,

Gruß an den Schwiegervater, meine Hochachtung!

Da lohnt sich jede Anstrengung für eine gute Beleuchtung!

timsieberg: den Turm gibt es nicht mehr.

Du meinst in der Realität, weshalb es für die Blinkfolge kein Vorbild gibt?

timsieberg: Leider ist es jetzt so, dass sobald der Wert-X wieder überschritten wird also Tag, das Programm gestoppt wird und nicht weiterläuft. Wird der Wert wieder unterschritten, wird das Programm an der Stelle fortgesetzt.

Du benötigst eine Hysterese: Bei Wert X einschalten, bei Wert Y ausschalten, wobei X "dunkler" ist als Y.

timsieberg: Als "Leuchtfeuer" sollte die LED sehr hell sein ...

Nach meinen Erfahrungen besser nicht. Niemand möchte nachts im Garten mit Sonnenbrille sitzen 8)

Ich habe zwei Leuchttürme, die mit Kühlschrankbirnen 230 V 5 W betrieben wurden. Ich habe die dann auf 12 V 15 W umgerüstet, was mir aber zu hell war, weshalb ich sie auf 12 V 5 W rediziert habe. Bei LEDs verhält es sich dann noch etwas anders.

timsieberg: Habe jetzt an eine 230V G9 LED-Lampe ...

Die 230 V sind mir für Gartenbeleuchtung zu gefährlich, ein Kabel mit 12 V kann man gefahrlos durchhacken.

timsieberg: Mithilfe eines Schrittmotors, soll dich der "Spiegel" mit ca. 1U/min um die LED drehen, sodass eine Art Lichtkegel erscheint. Dies soll natürlich unabhängig von der Fensterbeleuchtung laufen.

Mechanik im Garten ist beispielsweise wegen Frost nicht ganz unproblematisch. Außerdem genügt ein kleiner DC-Getriebemotor für den gleichmäßigen Antrieb, da wird ja nichts positioniert.

agmue: Du meinst in der Realität, weshalb es für die Blinkfolge kein Vorbild gibt?

Ja genau.

agmue: Du benötigst eine Hysterese: Bei Wert X einschalten, bei Wert Y ausschalten, wobei X "dunkler" ist als Y.

Ok, werde ich mal probieren, jetzt ist es so: eingebaut in den Sketch von noisca. sensorWert = analogRead(eingang); Serial.print("Sensorwert = " ); Serial.println(sensorWert); if (sensorWert < 30){ {currentMillis = millis(); doPWM(); doRunning(); Einschaltung funktioniert, Wenn der Wert überschritten wird funktioniert es ja auch, nur nicht richtig es geht nicht aus sondern stoppt nur.

agmue: Nach meinen Erfahrungen besser nicht. Niemand möchte nachts im Garten mit Sonnenbrille sitzen 8) Ich habe zwei Leuchttürme, die mit Kühlschrankbirnen 230 V 5 W betrieben wurden. Ich habe die dann auf 12 V 15 W umgerüstet, was mir aber zu hell war, weshalb ich sie auf 12 V 5 W rediziert habe. Bei LEDs verhält es sich dann noch etwas anders. Die 230 V sind mir für Gartenbeleuchtung zu gefährlich, ein Kabel mit 12 V kann man gefahrlos durchhacken

Die 230V hat er schon verlegt ;-). Okay das mit der Helligkeit werde ich mal im Hinterkopf behalten. Ärger bekommt wenn dann er mit den Nachbarn.

agmue: Mechanik im Garten ist beispielsweise wegen Frost nicht ganz unproblematisch. Außerdem genügt ein kleiner DC-Getriebemotor für den gleichmäßigen Antrieb, da wird ja nichts positioniert.

Bekomme ich Getriebemotoren mit so kleiner Übersetzung? Das Getriebe ist ja auch Mechanik, aber ich verstehe was du meinst.

Leider ist es jetzt so, dass sobald der Wert-X wieder überschritten wird also Tag, das Programm gestoppt wird und nicht weiterläuft. Wird der Wert wieder unterschritten, wird das Programm an der Stelle fortgesetzt.

bezogen auf das "Leider": das hättest du programmatisch aber auch anders machen können.

Kleingetriebe findet man sicher im Modellbau. Den Motor hat mir google ausgespuckt: https://at.rs-online.com/web/p/dc-getriebemotor/8347644/.

Andererseits wer sowas baut, der baut sich dann auch eine Untersetzung von 1,5 auf 1, oder 4 auf 1 ... sogesehen alles lösbar.

edit: es ist ja jetzt dein Sketch aber so hätte ich das nicht gemacht.

Mach dir eine globale Funktion die ein istNacht = true oder false zurückgibt und frag das in den Funktionen doRunning bzw. doPWM ab. bei false schaltest du explizit die LEDs ab, bei true führst du durch so wie jetzt auch.

Einschaltung funktioniert, Wenn der Wert überschritten wird funktioniert es ja auch, nur nicht richtig es geht nicht aus sondern stoppt nur.

Das zeigt dein Code-Schnipsel leider nicht.

Zusätzlich ist evtl. sinnvoll, eine Verzögerung einzubauen, damit nicht eine kurze Helligkeitsänderung gleich den Leuchtturm an- bzw. abschaltet.
(Zum Testen kann man diese Verzögerung ja kürzer einstellen als hinterher im echten Betrieb)