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;
      }
  }
}