timer starten met knop ?

[dirk ambu Profiel Privébericht]

beste Nico

ik denk dat het me is gelukt

Code: Alles selecteren


    /**
     * @mainpage Timerswitch program
     * \n This program has relays that can be switched on and off based on
     * a switch status or time limit.
     * \n The time limit is currently set for 1 hour but my be extended with
     * 15 minutes under the condition that a button corresponding to a relay is
     * not pressed for longer than 5 seconds. If the button is pushed for more than
     * 5 seconds, the timer is reset and switched off.
     * @author Nico Verduin
     * @date 21-6-2013
     */

    /**
     * Revision control
     * Revision   : $Revision$
     * Author   : $Author$
     * Date      : $Date$
     *
     */



    //
    // global variables
    //
    unsigned long    timer1Counter;              // timer 1
    unsigned long    timer2Counter;              // timer 2
    unsigned long    temp1Counter;               // timer 1 for temperature
    unsigned long    temp2Counter;               // timer 2 for temperature
    float            temperatureSensor1;         // temperature sensor 1
    float            temperatureSensor2;         // temperature sensor 2
    unsigned int     setTemperature1;            // set temperature 1
    unsigned int     setTemperature2;            // set temperature 2
    //
    // arduino pins
    //
    #define RELAY1             7            // pin 4
    #define RELAY2             6             // pin 5
    //#define RELAY3             5             // pin 6
    //#define RELAY4             4             // pin 7
    #define LEDPIN1            9             //pin 9
    #define LEDPINN2           10             // pin 10
    #define LEDPIN3           11             //pin 11
    #define LEDPINN4           12             //pin 12
    #define SWITCH1            2             // pin 2
    #define SWITCH2            3             // pin 3
    #define TEMP_SENSOR1       A0            // analog pin A0 Sensor1
    #define TEMP_SENSOR2       A1            // analog pin A1 Sensor2
    #define TEMP_SET1          A2            // analog pin A2 set temp 1
    #define TEMP_SET2          A3            // analog pin A3 set temp 2
    //
    // other settings
    //
    #define ON                    LOW       // on/off
    #define OFF                  HIGH
    #define TIME_TO_PRESS       3000L       // time to push button for reset 5000L
    #define HOUR               36000L       // 3.6 million milliseconds in hour 3600000L
    #define QUARTER           900000L       // 900000 millsecs in 15 minutes 900000L
    #define FIVESECONDS        5000L       // 5 minutes period 300000L 100000L
    #define DEBOUNCE_TIME        100        // 100 mSec debounce time 100

    /**
     * @name setup()
     * Initializes the IO ports and resets any variables
     */

    void setup()
    {
       //
       // set pins input output. analog pins do not need to be setup
       //
       pinMode(RELAY1, OUTPUT);
       pinMode(RELAY2, OUTPUT);
       //pinMode(RELAY3, OUTPUT);
      // pinMode(RELAY4, OUTPUT);
       pinMode(LEDPIN1, OUTPUT);
       pinMode(LEDPINN2, OUTPUT);
       pinMode(LEDPIN3, OUTPUT);
       pinMode(LEDPINN4, OUTPUT);
       pinMode(SWITCH1, INPUT);
       pinMode(SWITCH2, INPUT);
       //
       // pull up resistors
       //
       digitalWrite(SWITCH1, HIGH);
       digitalWrite(SWITCH2, HIGH);
       //
       // make sure relays are switched off
       //
       digitalWrite(RELAY1, LOW);
       digitalWrite(RELAY2, LOW);
       //digitalWrite(RELAY3, LOW);
       //digitalWrite(RELAY4, LOW);
       //
       // test led,s
       //
       digitalWrite(LEDPIN1, HIGH);                         //make sure led works
       delay (200);
       digitalWrite(LEDPIN1, LOW);                          //make sure led works
       delay (200);
       digitalWrite(LEDPINN2, HIGH);                        //make sure led works
       delay (200);
       digitalWrite(LEDPINN2, LOW);                         //make sure led works
       delay (200);
       digitalWrite(LEDPIN3, HIGH);                         //make sure led works
       delay (200);
       digitalWrite(LEDPIN3, LOW);                          //make sure led works
       delay (200);
       digitalWrite(LEDPINN4, HIGH);                        //make sure led works
       delay (200);
       digitalWrite(LEDPINN4, LOW);                         //make sure led works
       delay (200);
       digitalWrite(LEDPIN1, HIGH);                         //make sure led works
       delay (200);
       digitalWrite(LEDPIN1, LOW);                          //make sure led works
       delay (200);
       digitalWrite(LEDPINN2, HIGH);                        //make sure led works
       delay (200);
       digitalWrite(LEDPINN2, LOW);                         //make sure led works
       delay (200);
       digitalWrite(LEDPIN3, HIGH);                         //make sure led works
       delay (200);
       digitalWrite(LEDPIN3, LOW);                          //make sure led works
       delay (200);
       digitalWrite(LEDPINN4, HIGH);                        //make sure led works
       delay (200);
       digitalWrite(LEDPINN4, LOW);                         //make sure led works
       delay (1000);
       
       //
       // other variables
       //
       timer1Counter = 0L;      // timer counters
       timer2Counter = 0L;
       //
       // serial controlen uitlezing
       //
         Serial.begin(9600);
         Serial.print("temperatuur uitlezen ter controle");
         Serial.println();
       
       
    }

    /**
     * @name Loop()
     * continues to loop through this routine until Arduino is switched off
     * This routine just processes each timer in sequence
     */
    void loop()
    {

       //
       // read temperature settings from potmeters
       //
       setTemperature1 = map(analogRead(TEMP_SET1), 0, 1023, 15,35);
       setTemperature2 = map(analogRead(TEMP_SET2), 0, 1023, 15,35);
       //
       // process timers
       //
       timer1Counter = processTimer(SWITCH1, RELAY1, LEDPIN1, LEDPINN2, timer1Counter);
       timer2Counter = processTimer(SWITCH2, RELAY2, LEDPIN3, LEDPINN4, timer2Counter);
       //
       // process temperature
       //
       temp1Counter   = processTemperature(RELAY1, LEDPIN1, LEDPINN2, TEMP_SENSOR1, setTemperature1, temp1Counter, timer1Counter);
       temp2Counter   = processTemperature(RELAY2, LEDPIN3, LEDPINN4, TEMP_SENSOR2, setTemperature2, temp2Counter, timer2Counter);
    }

    /**
     * @name long procesTimer(int button, int relay, int setTemp, long counter)
     * @param button    button to process
     * @param relay      relay to process
     * @param counter   timer value to compare to millis
     * @return          long with new timer value
     *
     * this routine receives the timer value, button and relay.
     * \n It tests if the button is pressed. If so:
     * \n a) it just keeps counting time until the button is released.
     * \n b) it checks how long the button was pressed:
     * \n    - if more (or equal to) than TIME_TO_PRESS, rest counter and relay
     * \n    - if not check if the counter was running:
     * \n      * if so  Add 15 minutes
     * \n      * if not start the timer at one hour
     * \n If button not pressed:
     * \n a) if current time is greater(or equal to) timer value:
     * \n    - Reset the timer
     * \n    - Switch relay off
     *
     */

    long processTimer(int button, int relay, int ledpin, int ledpinn, unsigned long counter){

       unsigned long returnCounter;   // return value
       unsigned long localCounter;      // counter for pressed time

       returnCounter = counter;      // if unchanged we have the right value

       //
       // check if a button is pressed
       // if so check if it is a TIME_TO_PRESS press
       //
       if (deBounce(button) == ON){
          //
          // button is pressed. No see for how long
          //
          localCounter = millis();
          //
          // now wait until button is released so don't forget to let go :)
          //
          while(1) {
             //
             // check if button is released
             //
             if (deBounce(button) == OFF){
                //
                // yes so quit this loop
                //
                break;
             }
          }
          //
          // the button is released check if we are passed the time limit
          // the time is corrected for 2 x the DEBOUNCE_TIME as this time is
          // already lost in the deBounce routine.
          //
          if ((millis() - localCounter) >= (TIME_TO_PRESS - (DEBOUNCE_TIME * 2))) {
             //
             // yes so switch the relay off
             //
             returnCounter = 0L;
             digitalWrite(relay, LOW);
             digitalWrite(ledpinn,LOW);
          } else {
             //
             // The time pressed was less than the TIME_TO_PRESS so check
             // if we have to switch the relay on for one hour or add 15 minutes
             //
             if (returnCounter == 0L) {
                //
                // No it wasn't so switch the relay on and set the timer
                //
                returnCounter = millis() + HOUR;
                //
             } else {
                //
                // it was already running so just add 15 minutes
                //
                returnCounter += QUARTER;
             }
          }
       } else {
          //
          // no button was pressed so just check the timer
          //
          if (millis() >= returnCounter) {
             //
             // yes so switch off the relay and the timer
             //
             returnCounter = 0L;
             digitalWrite(relay, LOW);
             digitalWrite(ledpinn, HIGH);
             digitalWrite(ledpin, LOW);
          }
       }
       return returnCounter;
   
   
    }

   
   
   
    /**
     * @name deBounce(int button)
     * @param button button pin to read and do debouncing
     * @returns state of button
     *
     * Reads a button and waits DEBOUNCE_TIME mSec and tests again
     * Returns read if value unchanged and zero if it has changed for
     * DEBOUNCE_TIME time
     */
    int deBounce(int button) {
       int state;               // value of pin
       //
       // read the button
       //
       state = digitalRead(button);
       delay(DEBOUNCE_TIME);      // now wait a little time
       //
       // now check if it has changed
       //
       if (digitalRead(button) != state) {
          return OFF;            // the state has changed so consider it off
                            // if it went on halfway this routine it will
                            // have stabilized by the next time we read here
       } else {
          //
          // return the button value
          //
          return state;
       }
    }
    /**
     * @name long processTemperature(int relay , int sensor, int tempSet, long tempCtr, long timerCtr)
     * @param relay      relay pin
     * @param sensor   sensor pin
     * @param tempSet   Set temperature as int value
     * @param tempCtr   5 minute counter for temp readings
     * @param timerCtr   Main timer counter. If not 0 this timer is active
     * @return          long with new timer value for temperature readings
      *
     * this routine checks the timer counter. If non zeroe this timer is active.
     * next check if the temp ctr has passed 5 minutes. If so check the temperature.
     * \n Next check if the temperature is higher than the set temperature. If so
     * switch the relay on. If it is below then the relay will be switched off.
     */

    long processTemperature(int relay , int ledpin , int ledpinn, int sensor, int tempSet, unsigned long tempCtr, unsigned long timerCtr){

       unsigned int      tempReading;         // temperature from LM35
       float          convertedTemp;         // temperature in degrees
       


       //
       // first check if a counter is running and if not if it should be running
       //
       if (timerCtr != 0L) {
          //
          // there is a timer running so let's see if we need to read the temperature
          //
          if (millis() >= tempCtr) {
             //
             // yes so let's read the sensor
             //
             tempReading = analogRead(sensor);
             //
             // and convert it to a temperature
             //
             convertedTemp = (5.0 * tempReading *35.0)/1023.0;
             //
             // serial print ter controlen
             //
             Serial.print("convertedTemp  ");
             Serial.println(convertedTemp);
             Serial.print("tempReading  ");
             Serial.println(tempReading);
             //
             // now check if we are above the set temperature
             //
             if (convertedTemp > tempSet) {
               //
               //serial print de set temperatuur
               //
               Serial.print("tempset  ");
               Serial.println(tempSet);
               
                //
                // switch the relay on
                //
                digitalWrite(relay, HIGH);     // relay is aan
                digitalWrite(ledpinn, LOW);    // rode led is uit
                digitalWrite(ledpin, HIGH);    // groene led is aan
             } else {
                //
                // switch the relay off
                //
                digitalWrite(relay, LOW);       // relay is uit
                digitalWrite(ledpinn, HIGH);    // rode led is aan
                digitalWrite(ledpin, LOW);      // groene led is aan 
             }
             //
             // set the temperature for the next sensing period
             //
             tempCtr = millis() + FIVESECONDS;
          }
       } else {
          //
          // no activity so reset the tempCtr timer
          //
          tempCtr = 0L;
       }
       //
       // and hand the timer back
       //
       return tempCtr;
    }



voor als nog lijkt het te werken
het enige wat mij nu opvalt is dat ik niet kan zien of de timer nog loopt
omdat ik ervoor heb gekozen om een ledje groen te laten branden als het relay niet bekrachtigd is lijkt het nu als of de instalatie uit staat en er geen regeling is
ik moet dus even gaan zoeken hoe ik het groene ledje kan koppelen aan de timer maar dat is weer voor morgen avond

groet dirk ambu

[nicoverduin Profiel PrivéberichtWebsite]

Dan moet je gewoon een led gebruiken voor de timer en een led voor de temperatuur..... Aan = hij doet het, Uit = hij doet het niet.... Andere formule dus?

[dirk ambu Profiel Privébericht]

hoi nico

ledjes werken nu ook zoals ik het graag zou willen hebben
laatst had jij het over class wat is dat ? of wat kan je er mee ?
verder ben ik nog wat aan het stoeien met de hardware ik kom eigenlijk wat inputs te kort
en ik zou graag een deel van de hardware in de afstandbediening (kasje aan de muur ) willen bouwen
en het andere deel bij de relais hiervoor zou ik graag gebruik willen maken van 2 arduino bordjes die met elkaar communiceren is dit redelijk te maken ?

wat ik denk te willen hebben
arduino bord 1 is voorzien van 2 X switch 4 maal led 2 maal lm35 2 maal potmeter 1 maal lcd 4x20 en knopjes voor instellen week programma

arduino bord 2 is voorzien van 4 maal relais 1 maal rtc

de code zoals hij nu is

Code: Alles selecteren



    /**
     * @mainpage Timerswitch program
     * \n This program has relays that can be switched on and off based on
     * a switch status or time limit.
     * \n The time limit is currently set for 1 hour but my be extended with
     * 15 minutes under the condition that a button corresponding to a relay is
     * not pressed for longer than 5 seconds. If the button is pushed for more than
     * 5 seconds, the timer is reset and switched off.
     * @author Nico Verduin
     * @date 21-6-2013
     */

    /**
     * Revision control
     * Revision   : $Revision$
     * Author   : $Author$
     * Date      : $Date$
     *
     */



    //
    // global variables
    //
    unsigned long    timer1Counter;              // timer 1
    unsigned long    timer2Counter;              // timer 2
    unsigned long    temp1Counter;               // timer 1 for temperature
    unsigned long    temp2Counter;               // timer 2 for temperature
    float            temperatureSensor1;         // temperature sensor 1
    float            temperatureSensor2;         // temperature sensor 2
    unsigned int     setTemperature1;            // set temperature 1
    unsigned int     setTemperature2;            // set temperature 2
    //
    // arduino pins
    //
    #define RELAY1             7            // pin 4
    #define RELAY2             4             // pin 5
    //#define RELAY3             5             // pin 6
    //#define RELAY4             4             // pin 7
    #define LEDPIN1            9             //pin 9
    #define LEDPINN2          10             // pin 10
    #define LEDPIN3           11             //pin 11
    #define LEDPINN4          12             //pin 12
    #define SWITCH1            2             // pin 2
    #define SWITCH2            3             // pin 3
    #define TEMP_SENSOR1       A0            // analog pin A0 Sensor1
    #define TEMP_SENSOR2       A1            // analog pin A1 Sensor2
    #define TEMP_SET1          A2            // analog pin A2 set temp 1
    #define TEMP_SET2          A3            // analog pin A3 set temp 2
    //
    // other settings
    //
    #define ON                    LOW       // on/off
    #define OFF                  HIGH
    #define TIME_TO_PRESS       3000L       // time to push button for reset 5000L
    #define HOUR               36000L       // 3.6 million milliseconds in hour 3600000L
    #define QUARTER           900000L       // 900000 millsecs in 15 minutes 900000L
    #define FIVESECONDS        5000L       // 5 minutes period 300000L 100000L
    #define DEBOUNCE_TIME        100        // 100 mSec debounce time 100

    /**
     * @name setup()
     * Initializes the IO ports and resets any variables
     */

    void setup()
    {
       //
       // set pins input output. analog pins do not need to be setup
       //
       pinMode(RELAY1, OUTPUT);
       pinMode(RELAY2, OUTPUT);
       //pinMode(RELAY3, OUTPUT);
      // pinMode(RELAY4, OUTPUT);
       pinMode(LEDPIN1, OUTPUT);
       pinMode(LEDPINN2, OUTPUT);
       pinMode(LEDPIN3, OUTPUT);
       pinMode(LEDPINN4, OUTPUT);
       pinMode(SWITCH1, INPUT);
       pinMode(SWITCH2, INPUT);
       //
       // pull up resistors
       //
       digitalWrite(SWITCH1, HIGH);
       digitalWrite(SWITCH2, HIGH);
       //
       // make sure relays are switched off
       //
       digitalWrite(RELAY1, LOW);
       digitalWrite(RELAY2, LOW);
       //digitalWrite(RELAY3, LOW);
       //digitalWrite(RELAY4, LOW);
       //
       // test led,s
       //
       digitalWrite(LEDPIN1, HIGH);                         //make sure led works
       delay (200);
       digitalWrite(LEDPIN1, LOW);                          //make sure led works
       delay (200);
       digitalWrite(LEDPINN2, HIGH);                        //make sure led works
       delay (200);
       digitalWrite(LEDPINN2, LOW);                         //make sure led works
       delay (200);
       digitalWrite(LEDPIN3, HIGH);                         //make sure led works
       delay (200);
       digitalWrite(LEDPIN3, LOW);                          //make sure led works
       delay (200);
       digitalWrite(LEDPINN4, HIGH);                        //make sure led works
       delay (200);
       digitalWrite(LEDPINN4, LOW);                         //make sure led works
       delay (200);
       digitalWrite(LEDPIN1, HIGH);                         //make sure led works
       delay (200);
       digitalWrite(LEDPIN1, LOW);                          //make sure led works
       delay (200);
       digitalWrite(LEDPINN2, HIGH);                        //make sure led works
       delay (200);
       digitalWrite(LEDPINN2, LOW);                         //make sure led works
       delay (200);
       digitalWrite(LEDPIN3, HIGH);                         //make sure led works
       delay (200);
       digitalWrite(LEDPIN3, LOW);                          //make sure led works
       delay (200);
       digitalWrite(LEDPINN4, HIGH);                        //make sure led works
       delay (200);
       digitalWrite(LEDPINN4, LOW);                         //make sure led works
       delay (1000);
       
       //
       // other variables
       //
       timer1Counter = 0L;      // timer counters
       timer2Counter = 0L;
       //
       // serial controlen uitlezing
       //
         Serial.begin(9600);
         Serial.print("temperatuur uitlezen ter controle");
         Serial.println();
       
       
    }

    /**
     * @name Loop()
     * continues to loop through this routine until Arduino is switched off
     * This routine just processes each timer in sequence
     */
    void loop()
    {

       //
       // read temperature settings from potmeters
       //
       setTemperature1 = map(analogRead(TEMP_SET1), 0, 1023, 15,35);
       setTemperature2 = map(analogRead(TEMP_SET2), 0, 1023, 15,35);
       //
       // process timers
       //
       timer1Counter = processTimer(SWITCH1, RELAY1, LEDPIN1, LEDPINN2, timer1Counter);
       timer2Counter = processTimer(SWITCH2, RELAY2, LEDPIN3, LEDPINN4, timer2Counter);
       //
       // process temperature
       //
       temp1Counter   = processTemperature(RELAY1, LEDPIN1, LEDPINN2, TEMP_SENSOR1, setTemperature1, temp1Counter, timer1Counter);
       temp2Counter   = processTemperature(RELAY2, LEDPIN3, LEDPINN4, TEMP_SENSOR2, setTemperature2, temp2Counter, timer2Counter);
    }

    /**
     * @name long procesTimer(int button, int relay, int setTemp, long counter)
     * @param button    button to process
     * @param relay      relay to process
     * @param counter   timer value to compare to millis
     * @return          long with new timer value
     *
     * this routine receives the timer value, button and relay.
     * \n It tests if the button is pressed. If so:
     * \n a) it just keeps counting time until the button is released.
     * \n b) it checks how long the button was pressed:
     * \n    - if more (or equal to) than TIME_TO_PRESS, rest counter and relay
     * \n    - if not check if the counter was running:
     * \n      * if so  Add 15 minutes
     * \n      * if not start the timer at one hour
     * \n If button not pressed:
     * \n a) if current time is greater(or equal to) timer value:
     * \n    - Reset the timer
     * \n    - Switch relay off
     *
     */

    long processTimer(int button, int relay, int ledpin, int ledpinn, unsigned long counter){

       unsigned long returnCounter;     // return value
       unsigned long localCounter;      // counter for pressed time

       returnCounter = counter;         // if unchanged we have the right value

       //
       // check if a button is pressed
       // if so check if it is a TIME_TO_PRESS press
       //
       if (deBounce(button) == ON){
          //
          // button is pressed. No see for how long
          //
          localCounter = millis();
          //
          // now wait until button is released so don't forget to let go :)
          //
          while(1) {
             //
             // check if button is released
             //
             if (deBounce(button) == OFF){
                //
                // yes so quit this loop
                //
                break;
             }
          }
          //
          // the button is released check if we are passed the time limit
          // the time is corrected for 2 x the DEBOUNCE_TIME as this time is
          // already lost in the deBounce routine.
          //
          if ((millis() - localCounter) >= (TIME_TO_PRESS - (DEBOUNCE_TIME * 2))) {
             //
             // yes so switch the relay off
             //
             returnCounter = 0L;
             digitalWrite(relay, LOW);
             digitalWrite(ledpinn,LOW);
           
          } else {
             //
             // The time pressed was less than the TIME_TO_PRESS so check
             // if we have to switch the relay on for one hour or add 15 minutes
             //
             if (returnCounter == 0L) {
                //
                // No it wasn't so switch the relay on and set the timer
                //
                returnCounter = millis() + HOUR;
                //
             } else {
                //
                // it was already running so just add 15 minutes
                //
                returnCounter += QUARTER;
             }
          }
       } else {
          //
          // no button was pressed so just check the timer
          //
          if (millis() >= returnCounter) {
             //
             // yes so switch off the relay and the timer
             //
             returnCounter = 0L;
             digitalWrite(relay, LOW);
             digitalWrite(ledpin, LOW);
          }
       }
       return returnCounter;
   
    }
    /**
     * @name deBounce(int button)
     * @param button button pin to read and do debouncing
     * @returns state of button
     *
     * Reads a button and waits DEBOUNCE_TIME mSec and tests again
     * Returns read if value unchanged and zero if it has changed for
     * DEBOUNCE_TIME time
     */
    int deBounce(int button) {
       int state;               // value of pin
       //
       // read the button
       //
       state = digitalRead(button);
       delay(DEBOUNCE_TIME);      // now wait a little time
       //
       // now check if it has changed
       //
       if (digitalRead(button) != state) {
          return OFF;            // the state has changed so consider it off
                            // if it went on halfway this routine it will
                            // have stabilized by the next time we read here
       } else {
          //
          // return the button value
          //
          return state;
       }
    }
    /**
     * @name long processTemperature(int relay , int sensor, int tempSet, long tempCtr, long timerCtr)
     * @param relay      relay pin
     * @param sensor   sensor pin
     * @param tempSet   Set temperature as int value
     * @param tempCtr   5 minute counter for temp readings
     * @param timerCtr   Main timer counter. If not 0 this timer is active
     * @return          long with new timer value for temperature readings
      *
     * this routine checks the timer counter. If non zeroe this timer is active.
     * next check if the temp ctr has passed 5 minutes. If so check the temperature.
     * \n Next check if the temperature is higher than the set temperature. If so
     * switch the relay on. If it is below then the relay will be switched off.
     */

    long processTemperature(int relay , int ledpin , int ledpinn, int sensor, int tempSet, unsigned long tempCtr, unsigned long timerCtr){

       unsigned int      tempReading;         // temperature from LM35
       float          convertedTemp;         // temperature in degrees
       


       //
       // first check if a counter is running and if not if it should be running
       //
       if (timerCtr != 0L) {
          //
          // there is a timer running so let's see if we need to read the temperature
          //
          if (millis() >= tempCtr) {
             //
             // yes so let's read the sensor
             //
             tempReading = analogRead(sensor);
             //
             // and convert it to a temperature
             //
             convertedTemp = (5.0 * tempReading *35.0)/1023.0;
             //
             // serial print ter controle
             //
             Serial.print("convertedTemp  ");
             Serial.println(convertedTemp);
             //
             // now check if we are above the set temperature
             //
             if (convertedTemp > tempSet) {
               //
               //serial print de set temperatuur
               //
               Serial.print("tempset  ");
               Serial.println(tempSet);
               
                //
                // switch the relay on
                //
                digitalWrite(relay, HIGH);     // relay is aan
                digitalWrite(ledpinn, LOW);    // rode led is uit
                digitalWrite(ledpin, HIGH);    // groene led is aan
             } else {
                //
                // switch the relay off
                //
                digitalWrite(relay, LOW);       // relay is uit
                digitalWrite(ledpinn, HIGH);    // rode led is aan
                digitalWrite(ledpin, LOW);      // groene led is uit 
             }
             //
             // set the temperature for the next sensing period
             //
             tempCtr = millis() + FIVESECONDS;
          }
       } else {
          //
          // no activity so reset the tempCtr timer
          //
          tempCtr = 0L;
       }
       //
       // and hand the timer back
       //
       return tempCtr;
    }



groet dirk ambu

[nicoverduin Profiel PrivéberichtWebsite]

Dirk
Ik snap dat je nog veel meer wilt maar nut mag je het verder weer zelf doen. Een klasse zal ik morgen nog wel ff uitleggen. Anders ben ik zo ongeveer alles voor je aan het schrijven en het is wel mijn brood.
Nico

[dirk ambu Profiel Privébericht]

beste nico

dat begrijp ik uiteindelijk wil ik het ook zelf kunnen
ik wist overigs niet dat je je brood ermee verdient
ik wil je alleen nog een ding vragen

ik heb nog iets dat niet helemaal goed werkt
de timer is afhankelijk van de ingestelde temperatuur
wat lijkt er nu te gebeuren
ik druk op SWITCH1 de timer voor 1 uur gaat aftellen mocht in die tijd de temperatuur bereikt zijn waardoor de fan uitgaat
dan stopt ook de timer met tellen gaat de fan weer aan dan gaat het tellen van de timer ook weer verder
dat is eigenlijk niet wat ik wilde hebben

kan je mij hier nog even mee helpen dan ga ik zelf proberen er een lcd aan toe te voegen en de 2 arduinos proberen te laten samen werken
als je het leuk vind zal ik het wel blijven posten dan kan je lachen over de fouten die ik maak

en top dat je mij zover heb willen helpen

groet dirk ambu

[nicoverduin Profiel PrivéberichtWebsite]

Dirk
Ik zou niet weten hoe dat kan:
- processTemperature past de timerCounter NIET aan. Hij kijkt alleen maar of hij loopt.
- In de loop wordt processCounter keurig doorlopen. Ook geen loop.
Dus ik weet niet hoe je dat constateert?
Ga maar een zooi prints inbouwen en laat het hier maar zien. Wat je wel krijgt is hier en daar wat vertraging agv. prints, leds aanzetten en een uur als 36 seconden instellen. Het kan zijn dat het dan "lijkt" of hij stil staat. Kijk een paar seconden op een uur is niets. Op 36 seconden doorloop enorm

[nicoverduin Profiel PrivéberichtWebsite]

Nog even over de klasse. Ik had verwacht dat je zou piepen dat je als je een functie uitbreidt met een parameter, dat je dat dan overal moet doorvoeren. En daar is een alternatief voor namelijk een object (=Class). Objecten kun je zien als op zichzelf staande entiteiten (bijv. een autowiel). Maar objecten kunnen weer bestaan uit andere objecten (autowiel bestaat uit velg, wielbouten, band, lagers). Elk object heeft zijn eigen specifieke eigenschappen die meegenomen worden als ze onderdeel worden van een ander object (een ijzeren velg blijft een ijzeren velg als we het over een wiel hebben). Ik ga hier absoluut niet de theorie rondom object georienteerdheid beschrijven. Daar zijn zat mooie oplossingen voor (tutorials, boeken enz).

Als we nu naar jouw timer switch programma kijken, kun je stellen dat je eigenlijk 2 identieke theromostaten hebt die alleen maar andere pinnen op de arduino gebruiken. Bijgaand de code voor Thermostat.h

Code: Alles selecteren

/**
 * Thermostat.h
 *
 *  Created on   : 28 jun. 2013
 *  Author      : Nico Verduin
 *  Email           : info@verelec.com
 *  Website   : www.verelec.nl
 *
 * Revision Control
 *
 * Latest Revsion
 * ____________________
 *
 * Revision   : $Revison$
 * Date   : $Date$
 * Author   : $Author$
 *
 */

#ifndef THERMOSTAT_H_
#define THERMOSTAT_H_

#include "Arduino.h"
//
// definitions
//
#define TIME_TO_PRESS       5000L         // time to push button for reset
#define HOUR            3600000L              // 3.6 million milliseconds in hour
#define QUARTER         900000L         // 900000 millsecs in 15 minutes
#define FIVESECONDS         5000L         // 5 seconds period
#define DEBOUNCE_TIME      100            // 100 mSec debounce time
#define ON            LOW            // button pressed
#define OFF            HIGH                 // button not pressed

class thermostat {
private:
   //
   // Arduino pins
   //
   unsigned int _ledPin1;      // led pin saying relay is on
   unsigned int _ledPin2;      // led pin saying relay is off
   unsigned int _relayPin;      // pin corresponding to relay
   unsigned int _switchPin;      // pin corresponding to switch
   unsigned int _sensorPin;      // pin corresponding to temperature sensor
   unsigned int _adjustPin;      // pin corresponding to temperatur adjustmentn
   //
   // variables
   //
   unsigned long _timerCounter;   // counter for timer
   unsigned long _tempCounter;   // counter for temperature measuring
   unsigned int  _setTemperature;   // temperature set
   float        _Temperature;   // last temperature reading
   //
   // private functions
   //
   void SwitchRelay(unsigned int);
   int deBounce();

public:
   thermostat(unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int);
   void processTimer();
   void processTemperature();
   void setTemperature();
   float getTemperature();
   unsigned int getTemperatureSetting();
};


#endif /* THERMOSTAT_H_ */


en Thermostat.cpp

Code: Alles selecteren

/**
 * Thermostat.cpp
 *
 * @file Thermostat.cpp
 * __________________________
 * Class designed to respond to a temperature setting to switch a relay.
 * Signaling is performed through 2 LEDs (on and standby).
 * Through a pushbutton (switch)a timer can be set for one (1) hour with
 * increments of 15 minutes. Temperature measurements are taken every 5 minutes.
 *
 *  Created on   : 28 jun. 2013
 *  Author      : Nico Verduin
 *   Email      : info@verelec.com
 *  Website      : www.verelec.nl
 *
 * Revision Control
 *
 * \n Latest Revsion
 * \n Revision   : $Revison$
 * \n Date      : $Date$
 * \n Author   : $Author$
 *
 */

#include "Thermostat.h"

/**
 * @name thermostat(unsigned int relay, unsigned int ledPin1, unsigned int ledPin2, unsigned int switchPin, unsigned int sensorPin, unsigned int adjustPin)
 * @param relay    pin number of relay
 * @param ledPin1   pin number for "on" led
 * @param ledPin2   pin number for "standby"led
 * @param switchPin   pin number for switch
 * @param sensorPin   pin number of analog port for sensor
 * @param adjustPin   pin number of analog port for temperature adjustment
 *
 * Constructor for thermostat class. Creates the class wit pins set for Arduino
 *
 */
thermostat::thermostat(unsigned int relayPin, unsigned int ledPin1, unsigned int ledPin2, unsigned int switchPin, unsigned int sensorPin, unsigned int adjustPin) {
   //
   // save pin numbers in this object
   //
   _relayPin   = relayPin;
   _ledPin1    = ledPin1;
   _ledPin2    = ledPin2;
   _switchPin   = switchPin;
   _sensorPin   = sensorPin;
   _adjustPin   = adjustPin;
   //
   // reset all counters
   //
   _timerCounter    = 0L;
   _tempCounter   = 0L;
   //
   // setup all input / output pins
   //
   pinMode(_relayPin   , OUTPUT);
   pinMode(_ledPin1   , OUTPUT);
   pinMode(_ledPin2   , OUTPUT);
   pinMode(_switchPin   , OUTPUT);
   pinMode(_sensorPin   , INPUT);
   pinMode(_adjustPin   , INPUT);
   //
   // pull up resistors
   //
   digitalWrite(_switchPin, HIGH);
   //
   // reset relay
   //
   SwitchRelay(LOW);
}
/**
 * @name void procesTimer()
 * this routine checks the timerCounter value, switch and relay.
 * \n It tests if the switch is pressed(ON). If so:
 * \n a) it just keeps counting time (localCounter) until the switch is released.
 * \n b) it checks how long the switch was pressed:
 * \n    - if more (or equal to) than TIME_TO_PRESS, reset localCounter and relay
 * \n    - if not check if the timerCounter was running:
 * \n      * if so  Add 15 minutes
 * \n      * if not start the timerCounter for one (1) hour
 * \n If switch not pressed:
 * \n a) if current time is greater(or equal to) timerCounter value:
 * \n    - Reset the timerCounter
 * \n    - Switch relay off
 *
 */

void thermostat::processTimer(){

   unsigned long localCounter;      // counter for pressed time

   //
   // check if switch is pressed
   // if so check if it is a TIME_TO_PRESS press
   //
   if (deBounce() == ON){
      //
      // switch is pressed. No see for how long
      //
      localCounter = millis();
      //
      // now wait until switch is released so don't forget to let go :)
      //
      while(1) {
         //
         // check if switch is released
         //
         if (deBounce() == OFF){
            //
            // yes so quit this loop
            //
            break;
         }
      }
      //
      // the switch is released check if we are passed the time limit
      // the time is corrected for 2 x the DEBOUNCE_TIME as this time is
      // already lost in the deBounce routine.
      //
      if ((millis() - localCounter) >= (TIME_TO_PRESS - (DEBOUNCE_TIME * 2))) {
         //
         // yes so switch the relay off
         //
         _timerCounter = 0L;
         SwitchRelay(LOW);
      } else {
         //
         // The time pressed was less than the TIME_TO_PRESS so check
         // if we have to switch the relay on for one hour or add 15 minutes
         //
         if (_timerCounter == 0L) {
            //
            // No it wasn't so switch the relay on and set the timer
            //
            _timerCounter = millis() + HOUR;
            //
         } else {
            //
            // it was already running so just add 15 minutes
            //
            _timerCounter += QUARTER;
         }
      }
   } else {
      //
      // no switch was pressed so just check the timer
      //
      if (millis() >= _timerCounter) {
         //
         // yes so switch off the relay and the timer
         //
         _timerCounter = 0L;
         SwitchRelay(LOW);
      }
   }
}

/**
 * @name void processTemperature()
 * this routine checks the timerCounter. If non zero this object is active.
 * next check if the tempCounter has passed 5 minutes. If so check the temperature.
 * \n Next check if the temperature is higher than the set temperature. If so
 * switch the relay on. If it is below then the relay will be switched off.
 */

void thermostat::processTemperature(){

   unsigned int      tempReading;         // temperature from LM35
   float          convertedTemp = 0.0;   // temperature in degrees

   //
   // first check if a counter is running and if not if it should be running
   //
   if (_timerCounter != 0L) {
      //
      // there is a timer running so let's see if we need to read the temperature
      //
      if (millis() >= _tempCounter) {
         //
         // yes so let's read the sensor
         //
         tempReading = analogRead(_sensorPin);
         //
         // and convert it to a temperature
         //
         convertedTemp = (5.0 * tempReading *100.0)/1024.0;
         //
         // now check if we are above the set temperature
         //
         if (convertedTemp > float(_setTemperature)) {
            //
            // switch the relay on
            //
            SwitchRelay(HIGH);
         } else {
            //
            // switch the relay off
            //
            SwitchRelay(LOW);
         }
         //
         // set the temperature for the next sensing period
         //
         _tempCounter = millis() + FIVESECONDS;
      }
   } else {
      //
      // no activity so reset the tempCtr timer
      //
      _tempCounter = 0L;
   }
   _Temperature = convertedTemp;
}
/**
 * @name void setTemperature()
 *
 * reads the analog port with the potmeter for setting the temperature
 */
void thermostat::setTemperature(){
   //
   // read the analog value and map it to a range 15-35
   //
   _setTemperature = map(analogRead(_adjustPin), 0, 1023, 15,35);
}

/**
 * @name void deBounce()
 * @returns state of switch
 *
 * Reads a switch and waits DEBOUNCE_TIME mSec and tests again
 * Returns read if value unchanged and zero if it has changed for
 * DEBOUNCE_TIME time
 */
int thermostat::deBounce() {
   int state;               // value of pin
   //
   // read the button
   //
   state = digitalRead(_switchPin);
   delay(DEBOUNCE_TIME);      // now wait a little time
   //
   // now check if it has changed
   //
   if (digitalRead(_switchPin) != state) {
      return OFF;            // the state has changed so consider it off
                        // if it went on halfway this routine it will
                        // have stabilized by the next time we read here
   } else {
      //
      // return the button value
      //
      return state;
   }
}

/**
 * @name void SwitchRelay(unsigned int state)
 * @param state   HIGH or LOW
 *
 * Switches the relay in defined state and switches the leds based on that state
 */
void thermostat::SwitchRelay(unsigned int state){
   digitalWrite(_relayPin, state);
   if (state == HIGH) {
      digitalWrite(_ledPin1, HIGH);
      digitalWrite(_ledPin2, LOW);
   } else {
      digitalWrite(_ledPin1, LOW);
      digitalWrite(_ledPin2, HIGH);
   }
}

/**
 * @name float getTemperature()
 * @returns last read temperature from sensor
 *
 * Returns the value of the last converted temperature reading from the LM35
 */

float thermostat::getTemperature(){
   return _Temperature;
}

/**
 * @name unsigned int getTemperatureSetting()
 * @returns last read value from the temperature setting
 *
 * Returns the last setting of the temperature adjustment pot
 */
unsigned int thermostat::getTemperatureSetting(){
   return _setTemperature;
}


In de .h file zie je private en public variablene (de _xxxx notatie is een gewoonte van mij voor private variabelen).
Private variabelen en functies zijn NIET benaderbaar buiten het object om. Dus alleen de functies binnen thermostat.cpp kunnen aan die variabelen komen. Public betekent dat ze ook buiten het object benaderbaar zijn. Reden om het zo op te zetten is dat je in feite een black box krijgt met een aantal deuren naar buiten waardoor je iets kan doorgeven aan het object of terugkrijgen van het object.

Het voordeel is afscherming van niet relevante stukken in je hoofd programma en je hoeft nu niet meer alle variabelen door te geven. Het enige wat je doet is bij de creatie alle pinnen doorgeven en daarna kan je gewoon de public functies aanroepen.

Het hoofdprogramma ziet er nu zo uit:

Code: Alles selecteren

/**
 * @mainpage Timerswitch program
 * \n This program has relays that can be switched on and off based on
 * a switch status or time limit.
 * \n The time limit is currently set for 1 hour but my be extended with
 * 15 minutes under the condition that a button corresponding to a relay is
 * not pressed for longer than 5 seconds. If the button is pushed for more than
 * 5 seconds, the timer is reset and switched off.
 * @author Nico Verduin
 * @date 21-6-2013
 */

/**
 * Revision control
 * \n Revision   : $Revision$
 * \n Author   : $Author$
 * \n Date      : $Date$
 *
 */

#include "timerswitch.h"
#include "thermostat.h"
//
// arduino pins
//
#define RELAY1             3             // pin 3
#define RELAY2             4            // pin 4
#define SWITCH1            5            // pin 5
#define SWITCH2          6            // pin 6
#define LEDPIN_1         7            // led pin 1
#define LEDPIN_2         8            // led pin 2
#define LEDPIN_3         9            // led pin 3
#define LEDPIN_4         10            // led pin 4
#define TEMP_SENSOR1      0            // analog pin A0 Sensor1
#define TEMP_SENSOR2      1            // analog pin A1 Sensor2
#define TEMP_SET1         2            // analog pin A2 set temp 1
#define TEMP_SET2         3            // analog pin A3 set temp 2

//
// thermostats
//
thermostat thermostat1(RELAY1, LEDPIN_1, LEDPIN_2, SWITCH1, TEMP_SENSOR1, TEMP_SET1);
thermostat thermostat2(RELAY2, LEDPIN_3, LEDPIN_4, SWITCH2, TEMP_SENSOR2, TEMP_SET2);

/**
 * @name setup()
 * Initializes the IO ports and resets any variables
 */

void setup()
{
}

/**
 * @name Loop()
 * continues to loop through this routine until Arduino is switched off
 * This routine just processes each thermostat in steps in sequence
 */
void loop()
{
   //
   // read temperature settings from potmeters
   //
   thermostat1.setTemperature();
   thermostat2.setTemperature();
   //
   // process timers
   //
   thermostat1.processTimer();
   thermostat2.processTimer();
   //
   // process temperature
   //
   thermostat1.processTemperature();
   thermostat2.processTemperature();
}


De formule van de geconverteerde temperatuur is nog de oude. Die mag je zelf aanpassen.
Je zou zelfs nog verder kunnen gaan door van Thermostat een library te maken door beide Thermostat bestanden in een subfolder in je libraries folder van de Arduino IDE te zetten. En dan hou je een eenvoudig programma over.

[dirk ambu Profiel Privébericht]

hoi nico

en toen was ik je echt kwijt
ik ga er vanavond en morgen avond mee aan de slag om te kijken of ik het begrijp
op de vraag hoe ik constateer dat de timer lijkt te stopen heb ik het volgende antwoord

als de timer loopt van 1 uur ( verlaagt naar 36 seconden tijdelijk anders moet ik zo lang wachten ) en de temperatuur is boven de ingestelde temperatuur van de potmeter dan draait de fan
komt de temperatuur eronder dan gaat de fan uit en komt hij er weer boven dan gaat de fan aan dit werkt goed
ook de ledjes werken goed als de fan draait is de led rood als hij niet draait dan is de led groen is de timer niet actief dan brand er geen led dit werkt dus ook goed

maar wat gaat er fout
als de fan draait en de temperatuur is boven de ingestelde temperatuur en ik draai de potmeter zo ver dat de temperatuur van de potmeter boven de temperatuur komt van de sensor
dan gaat de fan uit en gaat het groene ledje branden dat de timer actief is echter blijft hij dan zo staan ook na een 1 uur staat hij dan nog in deze stand
draai ik dan de potmeter zodat de fan weer aangaat dan schakelt de fan even aan en vervolgens stop de timer en gaat alles weer uit

het lijkt erop dat de timer er nu voor zorgt dat de fan 36 seconden draait en als de fan uit gaat de timer stopt om weer verder te tellen zodra de fan weer draait

op de vraag of ik het kan laten zien dat kan
ik kan een filmpje maken en mailen

groet dirk ambu

[nicoverduin Profiel PrivéberichtWebsite]

Wat voor relais hangt er aan? of zit er een transistor tussen? En hoe heb jij de leds aangesloten? met een weerstand ertussen? rond de 250-300 ohm? Want ik kan niets fout vinden in de source. Of het is programmeurs blindheid......

[dirk ambu Profiel Privébericht]

Wat voor relais hangt er aan? of zit er een transistor tussen? En hoe heb jij de leds aangesloten? met een weerstand ertussen? rond de 250-300 ohm? Want ik kan niets fout vinden in de source. Of het is programmeurs blindheid......

hoi nico


ik maak gebruik van een (http://seeedstudio.com/wiki/Relay_Shield_V1.0) dit lijkt goed te werken
verder zit er een weerstand tussen van 300 ohm
als de timer van switch 1 gestopt lijkt te zijn dan kan ik nog steeds timer 2 starten en stoppen
hij loopt dus niet vast of zo

voor mij is het nu 1 groot ?

groet dirk ambu