lampjes in huizen willekeurig schakelen

[Ronald Schreuder]

Goedemorgen Bert,

Ben vanmorgen met je eerste sketch bezig geweest, voor de lantaarns.
Leuk, leuk, nog leuker!
Het werkt goed, heb 4 lantaarns in serie aangesloten op 12 V, en dat gaat goed! Beetje knipperen, beetje faden en dan vol aan, perfect!
Ik kan geen video uploaden, maar ben heel tevreden.
Alleen de herhaling mag eruit, als ik opstart kan hij gewoon aanblijven totdat de 'enablepin' wordt uitgezet. Dat doe ik dan met een on/off contact op een schakeldecoder.
Ik vindt dit zo leuk, wist niet dat dit allemaal mogelijk was, en met heel weinig middelen. nu nog dieper induiken op het zelf programmeren, want ik heb nog veel meer ideeën! (ophaalbrug met brugseinen en stappenmotor) Dat gaat allemaal goed komen.
Ik moet zo werken, late dienst, maar ga morgen of overmorgen verder met de tweede sketch, om het totaal te testen, maar ben nu al heel erg tevreden.
Bedankt (Bas ook) dat jullie mij hiermee zo goed helpen.

[Bert55]

Graag gedaan, leuk dat het inspireert.
De herhaling haal ik er vanavond of morgen voor je uit.

[Bert55]

Hierbij de aangepaste sketch.

Nog even over nagedacht, om de loop er helemaal uit te laten lijkt me voor testdoeleinden niet handig maar je kunt best van mening verschillen.
Ik heb een flag toegevoegd die je zelf op 0 (geen loop) of 1 (wel loop) kunt zetten.
Zie regel 18:
const int enableLoop = 1;  // enables the restart, set to 1 to enable loop, 0 to disable loop.

Code: [Selecteer]

// next lines for randomLeds
// Configuratie
const int numLeds = 5;                           // Aantal LED's
const int ledPins[numLeds] = { 3, 4, 5, 6, 7 };  // Pinnen waar de LED's op aangesloten zijn, pins 2 & 9 reserved for LedFlash
// Min en max aan-tijden in milliseconden voor elke LED
const unsigned long minTimes[numLeds] = { 10000, 20000, 30000, 40000, 50000 };   // Minimale aan-tijd per LED
const unsigned long maxTimes[numLeds] = { 20000, 40000, 60000, 80000, 100000 };  // Maximale aan-tijd per LED

// Variabelen voor timing
unsigned long previousTimes[numLeds];  // Laatste keer dat elke LED veranderde
unsigned long intervals[numLeds];      // Huidige interval voor elke LED
bool ledStates[numLeds];               // Huidige staat van elke LED

// next lines for ledFlash
// Flikkeren -> Halve helderheid -> Fade-up -> Pauze -> Herstart (depending on enable loop)
const int pwmPin = 9;      // PWM output pin voor Led
const int enablePin = 2;   // Enable pin met pull-up, start de sequentie bij schakelen naar 0
const int enableLoop = 1;  // enables the restart, set to 1 to enable loop, 0 to disable loop

//  parameters
const int minBrightness = 10;          // minimale helderheid
const int maxBrightness = 255;         // maximale helderheid
const int warmupDuration = 5000;       // flikkertijd
const int fullBrightnessPause = 3000;  // Na flikkeren en fade up start de sequentie na de ingesteld tijd opnieuw
int fadeDuration = 5000;               // na flikkeren start de Led op 50% helderheid en gaat in de ingeschakelde tijd naar max

// Status variabelen
enum LightState { OFF,
                  FLICKER,
                  HALF,
                  FADE_UP,
                  PAUSE };
LightState currentState = OFF;
unsigned long stateStartTime;
int currentBrightness = 0;
bool isEnabled = false;

void setup() {
  Serial.begin(9600);
  // next lines for randomLeds
  // Stel alle LED-pinnen in als OUTPUT
  // Initialiseer LED pinnen als OUTPUT
  for (int i = 0; i < numLeds; i++) {
    pinMode(ledPins[i], OUTPUT);
    ledStates[i] = LOW;
    // digitalWrite(ledPins[i], ledStates);
    digitalWrite(ledPins[i], LOW);
    previousTimes[i] = 0;
    intervals[i] = random(minTimes, maxTimes);
  }
  // next lines for ledFlash
  pinMode(pwmPin, OUTPUT);
  pinMode(enablePin, INPUT_PULLUP);
  analogWrite(pwmPin, 0);
}

void loop() {

  randomLeds();  // switch random leds on and off, put // in front of line to switch off
  ledFlash();    // switch led on  with flikkering effect, put // in front of line to switch off
}
void randomLeds() {
  unsigned long currentTime = millis();

  for (int i = 0; i < numLeds; i++) {
    // Controleer of het tijd is om de LED te schakelen
    if (currentTime - previousTimes[i] >= intervals[i]) {
      // Schakel de LED
      digitalWrite(ledPins[i], ledStates[i]);  // write current Ledstate
      ledStates[i] = !ledStates[i];            // change Ledstate


      // Update de vorige schakeltijd
      previousTimes[i] = currentTime;

      // Bepaal een nieuw random interval voor de volgende schakeling
      if (ledStates[i] == HIGH) {
        // LED gaat aan - gebruik aan-tijd interval
        intervals[i] = random(minTimes[i], maxTimes[i]);
      } else {
        // LED gaat uit - gebruik een korte uit-tijd (of pas aan-tijd aan)
        // Hier gebruiken we de helft van de minimale aan-tijd als uit-tijd
        // intervals[i] = minTimes[i] / 2;
        intervals[i] = minTimes[i];
      }

      // Debug output (optioneel)
      Serial.print("ledPins ");
      Serial.print(ledPins[i]);
      Serial.print("LED ");
      Serial.print(i);
      Serial.print(": ");
      Serial.print(ledStates ? "AAN" : "UIT");
      Serial.print(", Volgende schakeling in: ");
      Serial.println(intervals[i]);
    }
  }
}
void ledFlash() {
  unsigned long currentTime = millis();
  unsigned long stateTime = currentTime - stateStartTime;

  // Schakelaar logica
  if (!digitalRead(enablePin) && !isEnabled) {
    isEnabled = true;
    currentState = FLICKER;
    stateStartTime = currentTime;
  } else if (digitalRead(enablePin) && isEnabled) {
    isEnabled = false;
    currentState = OFF;
    analogWrite(pwmPin, 0);
  }

  if (!isEnabled) return;

  // State machine voor laslicht gedrag
  switch (currentState) {
    case FLICKER:
      if (stateTime < warmupDuration) {
        // *** fase
        // currentBrightness = random(minBrightness, maxBrightness * 0.7); // origineel
        currentBrightness = random(minBrightness, maxBrightness);
        analogWrite(pwmPin, currentBrightness);
        delay(50);
      } else {
        currentState = HALF;
        stateStartTime = currentTime;
        currentBrightness = maxBrightness / 2;
        analogWrite(pwmPin, currentBrightness);
      }
      break;

    case HALF:
      if (stateTime >= 1000) {
        currentState = FADE_UP;
        stateStartTime = currentTime;
      }
      break;

    case FADE_UP:
      {
        float progress = min(1.0, (float)stateTime / fadeDuration);
        currentBrightness = maxBrightness / 2 + (maxBrightness / 2) * progress;
        analogWrite(pwmPin, currentBrightness);

        if (progress >= 1.0) {
          currentState = PAUSE;
          stateStartTime = currentTime;
        }
        break;
      }

    case PAUSE:
      if (stateTime >= fullBrightnessPause & enableLoop == 1) {
        // Herstart de hele sequentie
        currentState = FLICKER;
        stateStartTime = currentTime;
      }
      break;
  }
}

Uiteraard kun je ook de loop in zijn geheeld inactief maken of verwijderen.
Dat zijn deze regels:

Code: [Selecteer]

case PAUSE:
    //   if (stateTime >= fullBrightnessPause & enableLoop == 1) {
    //     // Herstart de hele sequentie
    //     currentState = FLICKER;
    //     stateStartTime = currentTime;
    //   }
    //   break;
Er was nog iets wat mij niet zinde. Bij opstarten gaan alle random leds meteen aan, ik heb zelf liever dat de uitgangspositie allemaal uit is.

Dit heb ik gedaan door de volgende regels met elkaar te wisselen. Naar wens kun je dat terug draaien:
      digitalWrite(ledPins, ledStates);  // write current Ledstate
      ledStates = !ledStates;            // change Ledstate

[Bert55]

Nu ik toch bezig ben, ik had nog een delay in de sketch staan, vaak niet zo'n probleem, maar ben er toch wat allergisch voor indien er meerdere processen tegelijk lopen.
Het delay vervangen door millis.

Hierbij de recente sketch, het deel met de // ervoor kun je wissen. Regel 119 ™ 133.

Code: [Selecteer]

// next lines for randomLeds
// Configuratie
const int numLeds = 5;                           // Aantal LED's
const int ledPins[numLeds] = { 3, 4, 5, 6, 7 };  // Pinnen waar de LED's op aangesloten zijn, pins 2 & 9 reserved for LedFlash
// Min en max aan-tijden in milliseconden voor elke LED
const unsigned long minTimes[numLeds] = { 10000, 20000, 30000, 40000, 50000 };   // Minimale aan-tijd per LED
const unsigned long maxTimes[numLeds] = { 20000, 40000, 60000, 80000, 100000 };  // Maximale aan-tijd per LED

// Variabelen voor timing
unsigned long previousTimes[numLeds];  // Laatste keer dat elke LED veranderde
unsigned long intervals[numLeds];      // Huidige interval voor elke LED
unsigned long lastFlickerTime;         // vertraging in FlickterTime
bool ledStates[numLeds];               // Huidige staat van elke LED

// next lines for ledFlash
// Flikkeren -> Halve helderheid -> Fade-up -> Pauze -> Herstart (depending on enable loop)
const int pwmPin = 9;      // PWM output pin voor Led
const int enablePin = 2;   // Enable pin met pull-up, start de sequentie bij schakelen naar 0
const int enableLoop = 1;  // enables the restart, set to 1 to enable loop, 0 to disable loop

//  parameters
const int minBrightness = 10;          // minimale helderheid
const int maxBrightness = 255;         // maximale helderheid
const int warmupDuration = 5000;       // flikkertijd
const int fullBrightnessPause = 3000;  // Na flikkeren en fade up start de sequentie na de ingesteld tijd opnieuw
int fadeDuration = 5000;               // na flikkeren start de Led op 50% helderheid en gaat in de ingeschakelde tijd naar max

// Status variabelen
enum LightState { OFF,
                  FLICKER,
                  HALF,
                  FADE_UP,
                  PAUSE };
LightState currentState = OFF;
unsigned long stateStartTime;
int currentBrightness = 0;
bool isEnabled = false;

void setup() {
  Serial.begin(9600);
  // next lines for randomLeds
  // Stel alle LED-pinnen in als OUTPUT
  // Initialiseer LED pinnen als OUTPUT
  for (int i = 0; i < numLeds; i++) {
    pinMode(ledPins[i], OUTPUT);
    ledStates[i] = LOW;
    // digitalWrite(ledPins[i], ledStates);
    digitalWrite(ledPins[i], LOW);
    previousTimes[i] = 0;
    intervals[i] = random(minTimes, maxTimes);
  }
  // next lines for ledFlash
  pinMode(pwmPin, OUTPUT);
  pinMode(enablePin, INPUT_PULLUP);
  analogWrite(pwmPin, 0);
}

void loop() {

  randomLeds();  // switch random leds on and off, put // in front of line to switch off
  ledFlash();    // switch led on  with flikkering effect, put // in front of line to switch off
}
void randomLeds() {
  unsigned long currentTime = millis();

  for (int i = 0; i < numLeds; i++) {
    // Controleer of het tijd is om de LED te schakelen
    if (currentTime - previousTimes[i] >= intervals[i]) {
      // Schakel de LED
      digitalWrite(ledPins[i], ledStates[i]);  // write current Ledstate
      ledStates[i] = !ledStates[i];            // change Ledstate


      // Update de vorige schakeltijd
      previousTimes[i] = currentTime;

      // Bepaal een nieuw random interval voor de volgende schakeling
      if (ledStates[i] == HIGH) {
        // LED gaat aan - gebruik aan-tijd interval
        intervals[i] = random(minTimes[i], maxTimes[i]);
      } else {
        // LED gaat uit - gebruik een korte uit-tijd (of pas aan-tijd aan)
        // Hier gebruiken we de helft van de minimale aan-tijd als uit-tijd
        // intervals[i] = minTimes[i] / 2;
        intervals[i] = minTimes[i];
      }

      // Debug output (optioneel)
      Serial.print("ledPins ");
      Serial.print(ledPins[i]);
      Serial.print("LED ");
      Serial.print(i);
      Serial.print(": ");
      Serial.print(ledStates ? "AAN" : "UIT");
      Serial.print(", Volgende schakeling in: ");
      Serial.println(intervals[i]);
    }
  }
}
void ledFlash() {
  unsigned long currentTime = millis();
  unsigned long stateTime = currentTime - stateStartTime;

  // Schakelaar logica
  if (!digitalRead(enablePin) && !isEnabled) {
    isEnabled = true;
    currentState = FLICKER;
    stateStartTime = currentTime;
  } else if (digitalRead(enablePin) && isEnabled) {
    isEnabled = false;
    currentState = OFF;
    analogWrite(pwmPin, 0);
  }

  if (!isEnabled) return;

  // State machine voor laslicht gedrag
 
  // switch (currentState) {
  //   case FLICKER:
  //     if (stateTime < warmupDuration) {
  //       // *** fase
  //       // currentBrightness = random(minBrightness, maxBrightness * 0.7); // origineel
  //       currentBrightness = random(minBrightness, maxBrightness);
  //       analogWrite(pwmPin, currentBrightness);
  //       delay(50);
  //     } else {
  //       currentState = HALF;
  //       stateStartTime = currentTime;
  //       currentBrightness = maxBrightness / 2;
  //       analogWrite(pwmPin, currentBrightness);
  //     }
  //     break;

  switch (currentState) {
    case FLICKER:
      if (stateTime < warmupDuration) {
        // *** fase
        if (currentTime - lastFlickerTime >= 50) {  // Replaces delay(50)
          lastFlickerTime = currentTime;
          // currentBrightness = random(minBrightness, maxBrightness * 0.7); // origineel
          currentBrightness = random(minBrightness, maxBrightness);
          analogWrite(pwmPin, currentBrightness);
        }
      } else {
        currentState = HALF;
        stateStartTime = currentTime;
        currentBrightness = maxBrightness / 2;
        analogWrite(pwmPin, currentBrightness);
      }
      break;

    case HALF:
      if (stateTime >= 1000) {
        currentState = FADE_UP;
        stateStartTime = currentTime;
      }
      break;

    case FADE_UP:
      {
        float progress = min(1.0, (float)stateTime / fadeDuration);
        currentBrightness = maxBrightness / 2 + (maxBrightness / 2) * progress;
        analogWrite(pwmPin, currentBrightness);

        if (progress >= 1.0) {
          currentState = PAUSE;
          stateStartTime = currentTime;
        }
        break;
      }
  }
}


[Ronald Schreuder]

Bert, ik heb de laatste sketch getest, en ik ben uitermate tevreden. Ontzettend bedankt (Bas ook) voor alle moeite en tijd die jullie in mij hebben gestoken.
Ik ga er zeker verder mee, want ik vind het niet alleen leuk, maar ik leer hier ook veel van.
Volgende project is een ophaalbrug besturen, dat doe ik nu nog met een servo (schokkerig) met brugseinen erbij. Ben al aan het kijken voor een stappenmotor.

Nogmaals bedankt!
Gr Ronald

[Ronald Schreuder]

Bert, als je nog een keer tijd hebt, zou jij nog 1 ding voor mij willen doen?
De sketch in tweeën splitsen?
Dus 1 sketch met 7 outputs voor random aan/uit
en 1 sketch met 7 outputs voor de straatlantaarns?

Heeft geen haast, en als je er geen zin in hebt ook prima, maar als je wel zin en tijd hebt....

Gr Ronald

[Bert55]

Geen probleem Ronald, doe ik 1 dezer dagen.

[Bert55]

Ronald, alvast de eerste voor de random leds, de tijden kun je vast zelf aanpassen?

Code: [Selecteer]

// Configuratie
const int numLeds = 7;              // Aantal LED's
const int ledPins[numLeds] = {2, 3, 4, 5, 6, 7, 8}; // Pinnen waar de LED's op aangesloten zijn
// Min en max aan-tijden in milliseconden voor elke LED
const unsigned long minTimes[numLeds] = {1000, 1000, 1000, 1000, 1000, 1000, 1000};  // Minimale aan-tijd per LED
const unsigned long maxTimes[numLeds] = {3000, 3000, 3000,3000, 3000, 3000, 3000 }; // Maximale aan-tijd per LED

// Variabelen voor timing
unsigned long previousTimes[numLeds]; // Laatste keer dat elke LED veranderde
unsigned long intervals[numLeds];     // Huidige interval voor elke LED
bool ledStates[numLeds];              // Huidige staat van elke LED

void setup() {
  // Initialiseer seriële communicatie (optioneel voor debugging)
  Serial.begin(9600);
 
  // Initialiseer LED pinnen als OUTPUT
  for (int i = 0; i < numLeds; i++) {
    pinMode(ledPins[i], OUTPUT);
    ledStates[i] = LOW;
    digitalWrite(ledPins[i], ledStates);
    previousTimes[i] = 0;
    intervals[i] = random(minTimes, maxTimes);
  }
}


[Ronald Schreuder]

Hoi Bert, ja dat lukt!
Fijn, bedankt!

[Bert55]

Hier dan de sketch voor de 7 uitgangen, "TL" met inschakel verschijnsel.

Paar opmerkingen:
Led 7 kan niet faden, de Nano's en ook Uno's hebben 6 PWM uitgangen. In de sketch gaat led 7 van 0 naar max en omgekeerd.
Je kunt led 7 verwijderen door het laatste getal in de arrays te verwijderen.
Vervang dan regel 5 door 6, 9 door 10 en 13/14 door 17/18.

Code: [Selecteer]

// 7 LEDs met flikkeren -> halve helderheid -> fade-up -> pauze -> herstart (afhankelijk van enableLoop)
const int numLeds = 7;

// PWM output pins voor LEDs
const int pwmPins[] = { 3, 5, 6, 9, 10, 11, 13 };  // 7 outputs
//const int pwmPins[] = { 3, 5, 6, 9, 10, 11 };    // 6 outputs

// Enable pins met pull-up, start de sequentie bij schakelen naar GND
const int enablePins[] = { 2, 4, 7, 8, 12, A0, A1 };  // 7 outputs
// const int enablePins[] = { 2, 4, 7, 8, 12, A0, };  // 6  outputs

// Enables de restart voor elke LED (0 = geen loop, 1 = loop)     // 7 outputs
const int enableLoop[] = { 1, 1, 1, 1, 1, 1, 1 };  // Loop enabled. Pas aan per LED indien nodig
// const int enableLoop[] = { 0, 0, 0, 0, 0, 0, 0 };  // Loop disabled. Pas aan per LED indien nodig

// Enables de restart voor elke LED (0 = geen loop, 1 = loop)     // 6 outputs
// const int enableLoop[] = { 1, 1, 1, 1, 1, 1 };  // Loop enabled. Pas aan per LED indien nodig
// const int enableLoop[] = { 0, 0, 0, 0, 0, 0 };  // Loop disabled. Pas aan per LED indien nodig

// Parameters voor alle LEDs (kan per LED verschillend gemaakt worden)
const int minBrightness = 10;          // minimale helderheid
const int maxBrightness = 255;         // maximale helderheid
const int warmupDuration = 5000;       // flikkertijd
const int fullBrightnessPause = 3000;  // Pauze na fade-up
const int fadeDuration = 5000;         // duur van fade-up

// Status variabelen per LED
enum LightState { OFF,
                  FLICKER,
                  HALF,
                  FADE_UP,
                  PAUSE };
LightState currentState[numLeds] = { OFF };
unsigned long stateStartTime[numLeds];
unsigned long lastFlickerTime[numLeds];
int currentBrightness[numLeds] = { 0 };
bool isEnabled[numLeds] = { false };

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

  // Initialiseer alle pins
  for (int i = 0; i < numLeds; i++) {
    pinMode(pwmPins[i], OUTPUT);
    pinMode(enablePins[i], INPUT_PULLUP);
    analogWrite(pwmPins[i], 0);
  }
}

void loop() {
  for (int i = 0; i < numLeds; i++) {
    ledFlash(i);  // Verwerk elke LED afzonderlijk
  }
}

void ledFlash(int ledIndex) {
  unsigned long currentTime = millis();
  unsigned long stateTime = currentTime - stateStartTime[ledIndex];

  // Schakelaar logica
  if (!digitalRead(enablePins[ledIndex]) && !isEnabled[ledIndex]) {
    isEnabled[ledIndex] = true;
    currentState[ledIndex] = FLICKER;
    stateStartTime[ledIndex] = currentTime;
    Serial.print("LED ");
    Serial.print(ledIndex);
    Serial.println(" geactiveerd");
  } else {
    if (digitalRead(enablePins[ledIndex])) {
      isEnabled[ledIndex] = false;
      currentState[ledIndex] = OFF;
      analogWrite(pwmPins[ledIndex], 0);
    }
  }

  if (!isEnabled[ledIndex]) return;

  switch (currentState[ledIndex]) {
    case FLICKER:
      if (stateTime < warmupDuration) {
        // *** fase
        if (currentTime - lastFlickerTime[ledIndex] >= 50) {
          lastFlickerTime[ledIndex] = currentTime;
          currentBrightness[ledIndex] = random(minBrightness, maxBrightness);
          analogWrite(pwmPins[ledIndex], currentBrightness[ledIndex]);
        }
      } else {
        currentState[ledIndex] = HALF;
        stateStartTime[ledIndex] = currentTime;
        currentBrightness[ledIndex] = maxBrightness / 2;
        analogWrite(pwmPins[ledIndex], currentBrightness[ledIndex]);
        Serial.print("LED ");
        Serial.print(ledIndex);
        Serial.println(" halve helderheid");
      }
      break;

    case HALF:
      if (stateTime >= 1000) {
        currentState[ledIndex] = FADE_UP;
        stateStartTime[ledIndex] = currentTime;
        Serial.print("LED ");
        Serial.print(ledIndex);
        Serial.println(" start fade-up");
      }
      break;

    case FADE_UP:
      float progress = min(1.0, (float)stateTime / fadeDuration);
      currentBrightness[ledIndex] = maxBrightness / 2 + (maxBrightness / 2) * progress;
      analogWrite(pwmPins[ledIndex], currentBrightness[ledIndex]);

      if (progress >= 1.0) {
        currentState[ledIndex] = PAUSE;
        stateStartTime[ledIndex] = currentTime;
        Serial.print("LED ");
        Serial.print(ledIndex);
        Serial.println(" volle helderheid bereikt");
      }
      break;


    case PAUSE:
      if (stateTime >= fullBrightnessPause && enableLoop[ledIndex] == 1) {
        // Herstart de hele sequentie
        currentState[ledIndex] = FLICKER;
        stateStartTime[ledIndex] = currentTime;
        Serial.print("LED ");
        Serial.print(ledIndex);
        Serial.println(" herstart sequentie");
      }
      break;
  }
}