Mijn buiten verlichting sturen met een Infrarood sluis.

[Atwist Profiel Privébericht]

Wil even een ander klusje doen wat opzicht redelijk is gelukt zit alleen met 3 punten waar ik momenteel geen antwoord op heb.

Ik wil graan de buiten verlichting sturen zodra ik ons erf oprij (hek is voorzien van Infrarood) dan moet de verlichting aan gaan en een timer moet gaan starten (dit werkt goed)
Als ik dan door de carport deur ga voorzien van een magneetcontact dan het licht weer uit, vraag is hoe laat ik het uitschakelen en waar zet ik die code neer.
Het wil ook wel eens gebeuren dat ik via de voordeur binnen kom dan ziet het systeem niet dat ik al binnen ben dus heb ik een waarschuwing gemaakt maar deze blijft hangen.
Een de teksten die naar de Serial monitor gezonden worden blijven maar door lopen terwijl 1x genoeg is hier kan ik niet achter komen wat verkeerd is.
Dus zouden jullie mij eens weer op het goede spoor kunnen zetten.

Code: Alles selecteren

const byte an=2;
const byte aus=3;
const byte licht=13;
const byte lichtalarm=5;
int wartezeit = 15;
int timer = wartezeit;
uint16_t prevTime = millis();

void setup()
{
 Serial.begin(9600);
  pinMode (an, INPUT_PULLUP);
  pinMode (aus, INPUT_PULLUP);
  pinMode (licht, OUTPUT);
  pinMode (lichtalarm, OUTPUT);

}

void loop()
{
 byte button1 = digitalRead(an);
  byte button2 = digitalRead(aus);
 if((millis() - prevTime >= 1000) && (button1 == LOW) && (timer >= 0))
{
   prevTime = millis();
    digitalWrite(licht, HIGH);
   Serial.println(timer);
   timer--;
}
     
 if(button1 == HIGH)
{
    digitalWrite(licht, LOW);
   timer = wartezeit;
}
   
 if(timer <= 0)
  immer_noch_an();
}


void immer_noch_an()
  {
     digitalWrite(lichtalarm, HIGH);
    Serial.println ("Licht ist immer noch an");
    for(;;);
   }

PS de Sketch is gebaseerd op "blink without delay"

[Koepel Profiel Privébericht]

Bij deze regel gaan mijn wenkbrauwen fronsen:

Code: Alles selecteren

if((millis() - prevTime >= 1000) && (button1 == LOW) && (timer >= 0))

De Blink-Without-Delay is voor een knipperend ledje, dus voor een vast interval. Wil je een eenmalige vertraging ? Dat werkt iets anders. Ik onthoud dan het moment waarop de vertraging begint, en ik zet een (boolean) variabele die aangeeft dat de vertraging bezig is.

Kun eerst beschrijven wat je wilt ? Welke ingang moet welk resultaat hebben, en hoe en wanneeer en afhankelijk van de andere ingangen ? en daarbij graag beschrijven welk pin nummer bij de carpoort hoort en zo. Als er een timer gaat lopen als het licht aan gaat, dan is er toch geen alarm nodig ? Dan gaat het licht toch wel uit met die timer.

[Atwist Profiel Privébericht]

Hallo koepel,

Dank voor het mee denken

Het was dacht ik iets simpels, maar wat ik in gedachten heb, dat is:

2 als ingang voor de lichtsluis
3 als ingang voor het magneetcontact
4 als uitgang voor de verlichting (komt een relais achter)
5 als uitgang voor de alarmbuzzer
6 als ingang om het alarm te resetten

als ik door de lichtsluis rij moet het licht aan gaan
als ik dan door de carportdeur ga moet het licht weer uitgaan
voor het geval dat ik niet door de carportdeur ga dus het licht word niet uitgeschakeld moet er een alarmsignaal komen bv 30 min.
en dan een reset knopje.

Omdat dit een soort timer is is mij telkens verteld dat ik dan "Blinck without delay" moet nemen om mee te beginnen heb ik dus ook gedaan maar liep dus tegen de eerder genoemde problemen aan.
En ik dacht dat ik nu eens op de goede weg was.

[Koepel Profiel Privébericht]

Ja, okay, dat is wel zo, maar.... de Blink-Without-Delay is de eerste stap om millis() te begrijpen. Een eenmalige vertraging is weer een stapje verder

Waarom dat alarm ? In plaats van een alarm, kun je toch ook het licht uitzetten ?
Volgens mij is je beschrijving nog niet compleet. Wanneer gaat het licht uit als de vertraging over is ? Wil je in het donker het alarm resetten ? Bij een volledige beschrijving hoort ook het benoemen van dingen die normaal niet gebeuren, zoals alle drie de knoppen tegelijkertijd indrukken

Een extra teller is niet nodig, je kunt millis() gebruiken voor een bepaalde tijd, van 1 milliseconde tot zo'n 50 dagen.
Een extra boolean variabele is wel nodig.

De loop() zou er zo uit kunnen zien:

Code: Alles selecteren

void loop()
{
  // -----------------------
  // read all inputs.
  // -----------------------
  int button lichtSluis = digitalRead( lichtSluisPin);
  ...


  // -----------------------
  // Process the data.
  // -----------------------
  if( lichtSluis == LOW)
  {
    ...
    previousMillis = millis();    // timestamp this moment
    delayActive = true;           // enable the delay
  }


  // -----------------------
  // Check the active delays.
  // -----------------------
  if( delayActive)
  {
    if( millis() - previousMillis >= delayBeforeAlarm)
    {
      ...
      delayActive = false;
    }
  }
}


Het is belangrijk dat 'previousMillis' een unsigned long is. De millis() functie zelf geeft ook een unsigned long terug.

Deze twee regels starten de vertraging:

Code: Alles selecteren

    previousMillis = millis();    // timestamp this moment
    delayActive = true;           // enable the delay


Maar die vertraging wordt dus ergens anders afgehandeld. Dat hoeft niet op die manier, maar dat is hoe ik het doe
Het deel waar de vertraging wordt getest staat dus op zichzelf in de loop(). Dat deel is alleen actief als 'delayActive' true is.

Door het lezen van de ingangen en het verwerken van de gegevens te scheiden, is het gemakkelijker om later een de-bounce library voor de knoppen toe te voegen. De sketch zou nu misschien een delay(20) onderin de loop() kunnen gebruiken, om het bouncen van de knoppen iets tegen te gaan.

Sommigen gebruiken een 'byte' voor een pin nummer. Maar dat is nergens voor nodig, dus ik gebruik gewoon een 'int'. En ik zet in de naam het woord 'Pin', anders begrijp ik zelf de sketch niet meer. De term 'aus' lijkt te veel op 'output', en het is een input, dus daar heb ik 'magnet' van gemaakt. De naam van een pin hoort te beschrijven wat het is, niet wat het uiteindelijk in de sketch gaat doen. Dus 'an' zou beter 'lichtsluis' kunnen heten. Dat mag je zelf doen. Er hoort natuurlijk ook meer commentaar in de sketch

Ik zal een poging wagen. Leg de twee sketches naast elkaar en zie de verschillen. Het is niet getest, er kan nog een foutje in zitten.

Code: Alles selecteren

// Light on and off and with alarm sketch

// Pin numbers
const int anPin = 2;          // input lichtsluis
const int magnetPin = 3;      // input magneetcontact
const int lichtPin = 13;      // output light via relay
const int lichtalarmPin = 5;  // alarm buzzer
const int resetalarmPin = 6;  // input button reset alarm 

// other variables.
const unsigned long delayBeforeAlarm = 30UL * 60UL * 1000UL;  // half an hour
unsigned long previousMillis;
boolean delayActive = false;

void setup()
{
  Serial.begin(9600);
  Serial.println( "Started");

  pinMode (anPin, INPUT_PULLUP);
  pinMode (magnetPin, INPUT_PULLUP);
  pinMode (resetalarmPin, INPUT_PULLUP);
  pinMode (lichtPin, OUTPUT);
  pinMode (lichtalarmPin, OUTPUT);

}

void loop()
{

  // -----------------------
  // read all inputs.
  // -----------------------
  int buttonAn = digitalRead(anPin);
  int buttonMagnet = digitalRead(magnetPin);
  int buttonResetAlarm = digitalRead(resetalarmPin);


  // -----------------------
  // Process the data.
  // -----------------------
  if (buttonAn == LOW)
  {
    digitalWrite(lichtPin, HIGH);
    previousMillis = millis();    // timestamp this moment
    delayActive = true;           // enable the delay
  }

  if (buttonMagnet == LOW)
  {
    // This button turns off the light,
    // even if it was just turned on by buttonAn.
    digitalWrite(lichtPin, LOW);
    delayActive = false;         // disable the delay, we don't need it anymore.
  }

  if (buttonResetAlarm == LOW)
  {
    // Turn off the alarm
    digitalWrite(lichtalarmPin, LOW);
   
    // Turn off the lights as well ?
    digitalWrite(lichtPin, LOW);
  }
 

  // -----------------------
  // Check the active delays.
  // -----------------------
  if (delayActive)
  {
    if( millis() - previousMillis >= delayBeforeAlarm)
    {
      digitalWrite(lichtalarmPin, HIGH);
      Serial.println ("Licht ist immer noch an");
      delayActive = false;      // disable the delay.
    }
  }
}


[Atwist Profiel Privébericht]

Hallo Koepel,

Dank voor jou oplossing dankzij deze met de uitleg erbij snap ik het behoorlijk wat ik zo met de schakelaars op het breadboard heb getest lijkt het helemaal goed.
Heb hier nog even een kleine vraag over, ik mag graag ook visueel zien wat er gebeurd dus gooi ik er direct overal Serial.println is om via de Serial monitor te zien wat de schakeling precies doet.
Nu mijn vraag waarom blijft de tekst doorlopen ipv 1 keer de tekstregel dus als ik de lichtsluis knop indruk heb ik al bv 50 keer de tekst "Licht aan" ik snap dat het met de loop te maken heeft doordat deze blijft doorlopen maar is hier ook een simpele oplossing voor.

Verder heb ik al een paar behoorlijke verschillen gezien zoals een alarm reset knop is niet nodig omdat als je het licht via een knop uitdoet dat is het alarm ook gereset en verder ben ik nog even aan het uitpluizen maar het is een stuk simpeler dan wat ik in gedachten en gemaakt had "een mens kan het zich ook te moeilijk maken"

Ga weer even testen.

[Koepel Profiel Privébericht]

De "int buttonAn = digitalRead(anPin)" kijkt of het HIGH of LOW aan de ingang is. Zolang de knop is ingedrukt, blijft het LOW, en zal de "if (buttonMagnet == LOW)" altijd actief blijven. Bij iedere keer dat de loop() doorlopen wordt.

Op dit moment kijkt de sketch of de knop is ingedrukt.
Je kunt ook kijken naar het moment dat de knop wordt ingedrukt. Dus het moment dat de knop begint met ingedrukt te worden. Dat is natuurlijk beter.

Kijk eens naar de StateChangeDetection : https://www.arduino.cc/en/Tutorial/StateChangeDetection.
Er is dan een variabele nodig die de vorige toestand onthoud, en als de nieuwe toestand anders is, dan is de knop ingedrukt of losgelaten.

Er is een debounce library "Bounce2" (https://github.com/thomasfredericks/Bounce2) die het bounce effect van een knop tegengaat en ook een StateChangeDetection in zich heeft met fell() and rose().

Ik had er rekening mee gehouden, dat als een knop wordt ingedrukt, dan die actie die daar bij hoort vele malen wordt gedaan, en pas stopt als de knop wordt losgelaten. Volgens mij gaat dat goed, want vele malen digitalWrite() doen dat is niet zo erg, en vele malen de vertraging opnieuw starten, dat geeft ook niet. Maar als je er een Serial.println() bij zet, dan begint die wel enorm veel naar de seriële monitor te sturen.

[Atwist Profiel Privébericht]

Hallo Koepel,

Dank voor je reactie, het debouncen kende ik al en de StateChangeDetection heb ik wel eens voorbij zien komen maar nog niets mee gedaan ga dit in de sketch inbouwen en dan eens kijken of ik het krijg zoals ik het graag zou willen of anders zo als het hoort.

Je hoort zo snel mogelijk van mij.

[Atwist Profiel Privébericht]

Okay ik denk dat de sketch er zo mee door kan het werkt na behoren, 1 ding heb ik wel ontdekt en dat is als de carportdeur (magneetcontact) open blijft staan dan ziet de Arduino de HIGH en LOW omdat de deur van dicht naar open gaat en open blijft (als ik vergeet de deur dicht te doen) maar dit kan dus ook andersom dus de deur was open en gaat nu dicht, dus gaat het licht niet uit .

Zo is het als ik dit nu test met deze sketch.
Hoe zou ik dit kunnen oplossen.

Code: Alles selecteren

    // Light on and off and with alarm sketch
#include <Bounce2.h>

    // Pin numbers
    const int anPin = 2;          // input lichtsluis
    const int magnetPin = 3;      // input magneetcontact
    const int lichtPin = 7;      // output light via relay
    const int lichtalarmPin = 5;  // alarm buzzer
    const int resetalarmPin = 6;  // input button reset alarm


    // other variables.
    //const unsigned long delayBeforeAlarm = 30UL * 60UL * 1000UL;  // half an hour
     const unsigned long delayBeforeAlarm = 15UL * 1000UL;  // 15 seconden voor testen
    unsigned long previousMillis;
    boolean delayActive = false;

    Bounce debouncer1 = Bounce();
    Bounce debouncer2 = Bounce();
    Bounce debouncer3 = Bounce();

    void setup()
    {
      Serial.begin(9600);
      Serial.println( "Started");

      pinMode (anPin, INPUT_PULLUP);
      debouncer1.attach(anPin);
      debouncer1.interval(5); // interval in ms
      pinMode (magnetPin, INPUT_PULLUP);
      debouncer2.attach(magnetPin);
      debouncer2.interval(5); // interval in ms
      pinMode (resetalarmPin, INPUT_PULLUP);
      debouncer3.attach(resetalarmPin);
      debouncer3.interval(5); // interval in ms
      pinMode (lichtPin, OUTPUT);
      pinMode (lichtalarmPin, OUTPUT);

    }

    void loop()
    {
  debouncer1.update();
  debouncer2.update();
  debouncer3.update();

  // Get the updated value :
  int value1 = debouncer1.read();
  int value2 = debouncer2.read();
  int value3 = debouncer3.read();
      // -----------------------
      // read all inputs.
      // -----------------------
      int buttonAn = digitalRead(anPin);
      int buttonMagnet = digitalRead(magnetPin);
      int buttonResetAlarm = digitalRead(resetalarmPin);
     
int buttonAnState = 0;         // current state of the button
int buttonMagnetState = 0;         // current state of the button
int buttonResetAlarmState = 0;         // current state of the button
int lastbuttonAnState = 0;     // previous state of the button
int lastbuttonMagnetState = 0;     // previous state of the button
int lastbuttonResetAlarmState = 0;     // previous state of the butto

buttonAnState = digitalRead(anPin);
buttonMagnetState = digitalRead(magnetPin);
buttonResetAlarmState = digitalRead(resetalarmPin);
      // -----------------------
      // Process the data.
      // -----------------------
      if (buttonAn == LOW)
      if (buttonAnState != lastbuttonAnState)
      if ( value1 == LOW)
      {
        digitalWrite(lichtPin, HIGH);
       Serial.println ("Licht an");
        previousMillis = millis();    // timestamp this moment
        delayActive = true;           // enable the delay
      }

      if (buttonMagnet == LOW)
      if (buttonMagnetState != lastbuttonMagnetState)
      if ( value2 == LOW)
      {
        // This button turns off the light,
        // even if it was just turned on by buttonAn.
        digitalWrite(lichtPin, LOW);
        Serial.println ("Licht aus");
        delayActive = false;         // disable the delay, we don't need it anymore.
      }

      if (buttonResetAlarm == LOW)
      if (buttonResetAlarmState != lastbuttonResetAlarmState)
      if ( value3 == LOW)
      {
        // Turn off the alarm
        digitalWrite(lichtalarmPin, LOW);
        digitalWrite(lichtPin, LOW);
        Serial.println ("reset");
      }
     

      // -----------------------
      // Check the running delays.
      // -----------------------
      if (delayActive)
      {
        if( millis() - previousMillis >= delayBeforeAlarm)
        {
          digitalWrite(lichtalarmPin, HIGH);
          Serial.println ("Licht ist immer noch an");
          delayActive = false;      // disable the delay.
        }
      }
    }


[Koepel Profiel Privébericht]

Hoe zou ik dit kunnen oplossen.

Door veel nauwkeuriger te werken.
Gebruik overal dezelfde stijl van de code (of je drukt op Ctrl+T). Gebruik het inspringen en de haakjes overal op dezelfde manier. Zorg dat iedere spatie en ieder haakje goed staat. Gebruik commentaar op de juiste manier.

Je sketch was eerst door te kijken naar de ingang, of die HIGH of LOW is.
Je hebt vervolgens de StateChangeDetection toegevoegd, maar die zit er niet goed in.
Vervolgens heb je Bounce2 toegevoegd, en nog steeds de vorige dingen laten staan.

Je gebruik van Bounce2 in setup() is goed. Daarna gaat het mis.
Hier ben ik het helemaal kwijt:

Code: Alles selecteren

      if (buttonAn == LOW)
      if (buttonAnState != lastbuttonAnState)
      if ( value1 == LOW)
      {


Heb je de "wiki" bekeken op Github ? https://github.com/thomasfredericks/Bounce2.
Daar staan de functies fell() en rose() genoemd.

Als je de Bounce2 library gebruikt, dan kun je dat niet meer combineren met de waarde van digitalRead(), omdat digitalRead() een waarde geeft die kan bouncen, terwijl Bounce2 dat er uit filtert. De combinatie van beiden zorgt voor onvoorspelbaar resultaat.

Dus als je wilt weten of een ingang HIGH of LOW is, dan gebruik je:

Code: Alles selecteren

int magnetValue = magnetDebouncer.read();

en als je wilt weten of de ingang wijzigde van LOW naar HIGH, dan gebruik je

Code: Alles selecteren

if ( magnetDebouncer.rose() )

Het voorbeeld van de Bounce2 library gebruikt value1 en value2, maar zou je daarvoor namen willen gebruiken die iets zeggen ?
Als je wilt, dan zou je de namen "value1", "value2" en "value3" kunnen gebruiken en ook "debouncer1", "debouncer2", "debouncer3". Maar zou je dan goed willen omschrijven welk nummer bij welk ding (in real life) hoort ?

Helaas is het nodig om het opnieuw te doen. De digitalRead() binnen de loop() gaan dus verdwijnen. Als je de "debouncer.fell()" gaat gebruiken dan is de "debouncer.read()" niet nodig. De "debouncer.fell()" is dus de eenmalige gebeurtenis waarbij een ingang van HIGH naar LOW gaat, en die ook nog eerst gefilterd wordt.

Kijken naar het moment dat de knop om het alarm te resetten wordt ingedrukt gaat dus zo:

Code: Alles selecteren

void loop()
{
  debouncer3.update();

  // debouncer3 is the button to reset the alarm
  if (debouncer3.fell())    // Did the signal fell from HIGH to LOW ?
  {
    // Turn off the alarm
    digitalWrite(lichtalarmPin, LOW);
    digitalWrite(lichtPin, LOW);
    Serial.println ("reset");
  }
}


Dat is alles. Dat is de Bounce2 library.

Een sketch met code waarbij het inspringen en het gebruik van haakjes consequent is en namen voor variabelen te begrijpen zijn en het juiste commentaar heeft, en ook nog de juiste indeling naar functionaliteit, dat is een goede sketch, zelfs als het (nog) niet zou werken.
Als de tekst van de code er goed uit ziet, dan is een fout gemakkelijker gevonden. Als de tekst van de code een rommeltje is, dan is het niet uit te breiden en niet te wijzigen, dus kun je er verder niets mee.

Dus even iets proberen door snel even wat code in te typen, dat werkt meestal niet. Dit is bij mij even iets proberen: https://gist.github.com/Koepel/b70f81c71a52d8d6d3da86b9fe56d50e. Daar staat heel veel commentaar bij, zodat ik later terug kan vinden waar het over gaat. Het is dus niet bedoeld om aan anderen te laten zien dat de tekst er netjes uit ziet, het is voor mezelf zodat ik later zelf nog begrijp waar ik mee bezig was.

[Atwist Profiel Privébericht]

Heb het idee dat het zo zou moeten, na het nodige vertaal werk (mijn Engels is niet meer wat het ooit was) maar ik denk dat het gelukt is.
Met de commentaren toevoegen heb ik nog wel een probleem, terwijl het wel een groot hulpmiddel is zeker voor mij.

Dit is het geworden.

PS heb er ook een waarschuwings-signaal ingezet, die helaas werkt deze cyclus maar 1 keer (maar dit komt later wel)

Code: Alles selecteren

// Light on and off and with alarm sketch
// -----------------------
//Include librarys
// -----------------------
#include <Bounce2.h>
// -----------------------
// Pin numbers
// -----------------------
const int anPin = 2;          // input lichtsluis
const int magnetPin = 3;      // input magneetcontact
const int lichtPin = 7;       // output light via relay
const int lichtalarmPin = 5;  // alarm buzzer
const int resetalarmPin = 6;  // input button reset alarm
// -----------------------
// other variables.
// -----------------------
//const unsigned long delayBeforeAlarm = 30UL * 60UL * 1000UL;  // half an hour
const unsigned long delayBeforeAlarm = 15UL * 1000UL;  // 15 seconden voor testen
unsigned long previousMillis;
boolean delayActive = false;

Bounce debouncer1 = Bounce();
Bounce debouncer2 = Bounce();
Bounce debouncer3 = Bounce();

// ----------------------- void setup -----------------------
void setup()
{
  Serial.begin(9600);
  Serial.println( "Started");

  pinMode (anPin, INPUT_PULLUP);
  debouncer1.attach(anPin);
  debouncer1.interval(5);                 // interval in ms
  pinMode (magnetPin, INPUT_PULLUP);
  debouncer2.attach(magnetPin);
  debouncer2.interval(5);                 // interval in ms
  pinMode (resetalarmPin, INPUT_PULLUP);
  debouncer3.attach(resetalarmPin);
  debouncer3.interval(5);                 // interval in ms
  pinMode (lichtPin, OUTPUT);
  pinMode (lichtalarmPin, OUTPUT);
}
// ----------------------- void loop -----------------------
void loop()
{
  debouncer1.update();
  debouncer2.update();
  debouncer3.update();
  // -----------------------
  // Process the data.
  // -----------------------
  //Debouncer1 put on the light
  if (debouncer1.fell())                //Debouncer1 put on the light
  {
    digitalWrite(lichtPin, HIGH);
    Serial.println ("Licht an");
    previousMillis = millis();            // timestamp this moment
    delayActive = true;                   // enable the delay
  }
  if (debouncer2.fell())
  {
    // Debouncer2 put off the light
    // even if it was just turned on by debouncer1.
    digitalWrite(lichtPin, LOW);
    Serial.println ("Licht aus");
    delayActive = false;                  // disable the delay, we don't need it anymore.
  }
  // debouncer3 is the button to reset the alarm
  if (debouncer3.fell())                // Did the signal fell from HIGH to LOW ?
  {
    // Turn off the alarm
    digitalWrite(lichtalarmPin, LOW);
    digitalWrite(lichtPin, LOW);
    Serial.println ("reset");
  }
  // -----------------------
  // Check the running delays.
  // -----------------------
  if (delayActive)
  {
    if ( millis() - previousMillis >= delayBeforeAlarm)
    {
      digitalWrite(lichtalarmPin, HIGH);
      Serial.println ("Licht ist immer noch an");
      playBuzzer(lichtalarmPin);
      delayActive = false;                    // disable the delay.
    }
  }
}
// ----------------------- void playbuzzer -----------------------
void playBuzzer(const int lichtalarmPin)
{
  for (int i = 0; i < 3; ++i)
  {
    tone(lichtalarmPin, 400);             // play 400 Hz tone for 500 ms
    delay(500);
    tone(lichtalarmPin, 800);             // play 800Hz tone for 500ms
    delay(500);
  }
  // -----------------------
  // Stop the buzzer
  // -----------------------
  noTone(lichtalarmPin);
}