tijdschakelaar voor wc ventilator

[wim2584 Profiel Privébericht]

wc ventilator.jpg (12.97 KiB) 7613 keer bekeken

Flowdiagram:

[shooter Profiel Privébericht]

kijk dat is een mooi schema, echter:
bijvoorbeeld de laatste de nalooptimer check, nee niet naar de nalooptimer maar direct naar de check, dus blijf dan binnen die status, want anders start je de timer telkens en dat is niet de bedoeling.
volgende stap is om elk blok een statusnummer te geven (met 10 omhoog, want dan kun je er nog blokjes tussen zetten.
Je bent heel erg netjes bezig

[wim2584 Profiel Privébericht]

ben ik zo op de goede weg?
of sla ik de plak mis?

dit werkt niet:

Code: Alles selecteren

 if (plastimer == HIGH && schakelaar == HIGH)  // kijken of plastimer is ready en of licht nog aan is
  {
    digitalWrite(ventilator, HIGH);         // ventilator starten
    currentMillis = plasMillis;             // plastimer reset
  }

Code: Alles selecteren

//WC tijschakelaar wim lemson V 1.4


const int lichtschakelaar = 8;    // pin that the light switch is attached to
const int ventilator = 3; // pin that the ventilator is attached to
const int ledlicht = 4;   // controle led of licht is aan of uit
const int plastimer = 2;
const int nalooptimer = 6;
int schakelaar;
unsigned long plasMillis = 0 ;
unsigned long naloopMillis = 0 ;


void setup() {

  pinMode(lichtschakelaar, INPUT_PULLUP);
  pinMode(ventilator, OUTPUT);
  pinMode(ledlicht, OUTPUT);
  pinMode(plastimer,OUTPUT);
  pinMode(nalooptimer,OUTPUT);
}

void loop() {

  unsigned long currentMillis = millis();
  schakelaar = digitalRead(lichtschakelaar);

  if (schakelaar == HIGH)
  {
    digitalWrite(ledlicht, HIGH);
  }
  else
  {
    digitalWrite(ledlicht, LOW);
  }


  if (currentMillis - plasMillis >= 5000UL)   // Kijken of plastimer is ready
  {
    digitalWrite(plastimer, HIGH) ;
  }
  else
  {
    digitalWrite(plastimer, LOW);
  }

  if (plastimer == HIGH && schakelaar == HIGH)  // kijken of plastimer is ready en of licht nog aan is
  {
    digitalWrite(ventilator, HIGH);         // ventilator starten
    currentMillis = plasMillis;             // plastimer reset
  }

  if (schakelaar == LOW)                  // kijken of licht uit
  {
    currentMillis = naloopMillis; //naloop timer reset
    digitalWrite(ventilator, LOW); // ventilator starten
  }

  if (currentMillis - naloopMillis >= 5000UL) // kijken of nalooptimer is ready
  {
    digitalWrite(ventilator, LOW); // ventilator stoppen
  }

  delay(100);                                   // kleine vertraging

}

[wim2584 Profiel Privébericht]

wat bedoel je met:
blok een statusnummer te geven (met 10 omhoog, want dan kun je er nog blokjes tussen zetten ?

[wim2584 Profiel Privébericht]

een "probleem"dat ik heb is in geval :

ik snap if (.....) {}

maar hoe "start" je een timer

dus is licht aan?

start timer

[wim2584 Profiel Privébericht]

ik heb nog eens een avond gegoogled en geprobeerd, voor vannavond genoeg (anders slappik slecht )

maar dit is een verhelderd stukje:

gevonden op:

https://create.arduino.cc/projecthub/Ar ... tly-833e9e

zal er nog eens goed naar gaan kijken.



//Psudocode
unsigned long Timer
// ALWAYS use unsigned long for timers, not int

(variable declaration outside setup and loop, of course)

if digitalRead == Down
then "set timer"
Timer = millis
digitalWrite ON
if "timer expired"
millis - Timer >= 15000UL
then digitalWrite Off

(the "UL" after the number is a syntax detail that is important when dealing with large numbers in millis and micros, therefore it is shown although this is pseudo code)
Result: It works just as well as the delay version, but slightly differently: The timer is constantly reset as long as the button is pushed. Thus only when releasing does it start to "count" the 15 seconds. If you push shortly inside the 15 seconds period, it starts counting from anew. Notice in particular that digitalRead is looking at the input as fast as loop() runs.

The code is doing a digitalWrite OFF, even when the LED is not lit for every loop() pass, and likewise digitalWrite ON as long as the button is pushed. Fortunately this has no ill effects (apart from taking a handful of microseconds time)

Example 2: two buttons and LEDs

This is rather simple, we just "repeat" the above code.


//Psudocode
unsigned long TimerA
"ALWAYS use unsigned long for timers..."
unsigned long TimerB

if digitalReadA==Down
then TimerA= millis() ,
digitalWriteA ON
if millis()-TimerA >= 15000UL
then digitalWriteA Off
if digitalReadB==Down
then TimerB= millis() ,
digitalWriteB ON
if millis()-TimerB >= 15000UL
then digitalWriteB Off
Result: This works! Two separate timers start and stop independently.

As shown in the single button/LED case, we are done with handling the A case in just a few tens of microseconds, whether we are counting seconds or not, and thus free to handle the B case. We thus examine and react to either buttons hundreds of times each millisecond.

Interesting side issue: The 4 if statements can be freely rearranged - the end effect is the same. There are some subtle differences only active for the few microseconds until loop() goes round again.

[shooter Profiel Privébericht]

nee jouw oplossing werkt niet want alles wordt doorlopen, uit je flow diagram kun je snel een state diagram maken, en daar zet je dan allemaal nummers bij, en die ga je vervolgens allemaal vullen met stukjes programma,
een normale loop sjeest door je programma heen,
een case doet alleen wat er op dat moment voor status is.
de engelse tekst is om tijden onafhankelijk van elkaar te maken.

[wim2584 Profiel Privébericht]

2017-02-10 12_27_14-Arduino switch case statement.jpg (37.52 KiB) 7589 keer bekeken

zoiets is dus de bedoeling?

[wim2584 Profiel Privébericht]

nu eea in een state machine gezet, hopelijk nu wel op de goede weg?

Code: Alles selecteren

// wim lemson FSM machine voor wc ventilator 10-02-2017


// PIN definitions
#define lichtschakelaar 8
#define ventilator 3
#define plastimer 2
#define nalooptimer 6
#define GREENBUTTON 12
#define BLUEBUTTON 8

// FSM states
#define plas 0
#define poep 1
#define naloop 3



// variables
int fsm_state;
int plas = 0;
int naloop = 0;
int poep = 0;

unsigned long nalooptimer;
unsigned long plastimer;



void setup() {

pinMode(lichtschakelaar, INPUT_PULLUP);
pinMode(ventilator, OUTPUT);
pinMode(plastimer, OUTPUT);
pinMode(nalooptimer, OUTPUT);

}

void loop() {

// FSM states
switch(fsm_state) {

case plas:

plas= digitalRead(lichtschakelaar);    // check schakelaar stand
if (plas == HIGH) {
plastimer = millis();                           // start plastimer
digitalWrite(plastimer,HIGH);             // indicatie plastimer loopt
}
if (millis()-plastimer >= 10000){        // plas timer klaar
digitalWrite(ventilator,HIGH);             // ventilator start
}
fsm_state =poep;                              // ga naar state poep

break;

case poep:

poep = digitalRead(lichtschakelaar);    // check status schakelaar
if (poep == HIGH) {
digitalWrite(ventilator, HIGH);            // zet ventilator aan
}
fsm_state = naloop;                          // change naar state naloop

break;

case naloop:

naloop= digitalRead(lichtschakelaar);  // check lichtschakelaar uit
if (naloop == HIGH) {
naloop = millis();                                // naloop timer start
digitalWrite(ventilator, HIGH);             // houd ventilator aan
digitalWrite(nalooptimer, HIGH)           // indicatie nalooptimer loopt
}
if (millis()-naloop >= 10000){             // naloop timer klaar?
digitalWrite(ventilator, LOW);              // zet ventilator uit
}

break;
}
}


[Koepel Profiel Privébericht]

Mijn ideeën zijn een beetje in een andere richting. Met mijn beschrijving (plus aanvulling) zou iemand snel even naar de wc kunnen zonder het nadraaien van de vorige keer te beïnvloeden. Maar dan heb ik drie verschillende statussen/states nodig.

Een software timer die als delay of eenmalige vertraging wordt gebruikt doe ik altijd met een extra variabele die de timer aan of uit zet.
Nu gebruik je de fsm_state die bepaald welke timers aktief kan zijn. Dat zou goed kunnen werken, maar ik kan nog niet overzien wat alle gevolgen zijn. Dus ik kan nu nog niet voorspellen of het uiteindelijk goed gaat werken.

Ik zou een extra 'idle' state toevoegen. Dan draait de ventilator niet na, en er is niemand op het toilet. Gaat daar de lamp aan, dan start je daar de timer, en bij de 'plas' state loopt de timer.

Bij de 'plas' state is het wel nodig om naar de lamp te kijken, want als de lamp binnen de tijd uit gaat, dan ga je terug naar 'idle'.

Dus bij fsm_state 'poep' hoef je niet de ventilator aan te zetten (die staat al aan). Als de lamp uit gaat, dan start je daar de timer en ga je over naar 'naloop'.
Waarom je bij 'naloop' kijkt naar de lamp begrijp ik niet. Het is volgens mij alleen een timer om de ventilator uiteindelijk uit te zetten. Is dat afgerond, dan ga je helemaal terug naar 'idle'.

De extra mogelijkheden dat iemand naar de wc gaat, terwijl de ventilator nog naloopt, zou ik later toevoegen. Laat de sketch eerst maar de verschillende states goed aflopen.