SHARE
TWEET

Untitled

a guest Jun 13th, 2017 172 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. // libraries
  2.  
  3.  
  4. #include <SimpleTimer.h>                     // load the SimpleTimer library to make timers, instead of delays & too many millis statements
  5.  
  6.  
  7. // print debug messages or not to serial
  8. const boolean SerialDisplay = true; //true or false
  9.  
  10. /*
  11. * Copyright 2016, David Naves (http://daveworks.net, http://davenaves.com)
  12. *
  13. * This program is free software; you can redistribute it and/or
  14. * modify it under the terms of the GNU General Public License
  15. * as published by the Free Software Foundation; either version 3
  16. * of the License, or (at your option) any later version.
  17. *
  18. * This program is distributed in the hope that it will be useful,
  19. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  21. * GNU General Public License for more details.
  22. *
  23. * You should have received a copy of the GNU General Public License
  24. * along with this program; if not, see
  25.  
  26. */
  27.  
  28.  /*
  29. * I'm hoping that if you use/modify this code, you will share your
  30. * coop project with me and the world (pictures, whatever)
  31. * I'm big on sharing.
  32. * Cheers,
  33. * //D
  34. */
  35.  
  36.  
  37.  
  38. // pins assignments
  39.  
  40. // temperature chip i/o
  41. const int photocellPin = A0;                 // photocell connected to analog 0
  42. const int enableCoopDoorMotorB = 4;          // enable motor b - pin 4
  43. const int directionCloseCoopDoorMotorB = 2;  // direction close motor b - pin 2
  44. const int directionOpenCoopDoorMotorB = 3;   // direction open motor b - pin 3
  45. const int bottomSwitchPin = 8;              // bottom switch is connected to pin 8
  46. const int topSwitchPin = 9;                 // top switch is connected to pin 9
  47. const int relayInteriorLight = 12   ;           // interior lights relay set to digital pin 12
  48.  
  49.  
  50. // variables
  51.  
  52.  
  53. // photocell
  54. int photocellReading;                            // analog reading of the photocel
  55. int photocellReadingLevel;                       // photocel reading levels (dark, twilight, light)
  56.  
  57. // reed switches top and bottom of coop door
  58.  
  59. // top switch
  60.  
  61. int topSwitchPinVal;                   // top switch var for reading the pin status
  62. int topSwitchPinVal2;                  // top switch var for reading the pin delay/debounce status
  63. int topSwitchState;                    // top switch var for to hold the switch state
  64.  
  65. // bottom switch
  66.  
  67. int bottomSwitchPinVal;                // bottom switch var for reading the pin status
  68. int bottomSwitchPinVal2;               // bottom switch var for reading the pin delay/debounce status
  69. int bottomSwitchState;                 // bottom switch var for to hold the switch state
  70.  
  71. // SimpleTimer objects
  72. SimpleTimer coopPhotoCellTimer;
  73.  
  74.  
  75. // debounce delay
  76. long lastDebounceTime = 0;
  77. long debounceDelay = 100;
  78.  
  79.  
  80.  
  81. // interior lights twighlight delay
  82. long lastTwilightTime = 0;
  83. long TwilightDelay = 300000;           // 5 minutes
  84.  
  85.  
  86.  
  87. // ************************************** the setup **************************************
  88.  
  89. void setup(void) {
  90.  
  91.   Serial.begin(9600); // initialize serial port hardware
  92.  
  93.  
  94.   // welcome message
  95.   if(SerialDisplay){
  96.     Serial.println(" Processes running:");
  97.     Serial.println(" Timer readPhotoCell every 10 minutes - light levels: open or close door");
  98.   }
  99.  
  100.   // coop door  
  101.  
  102.   // coop door motor
  103.   pinMode (enableCoopDoorMotorB, OUTPUT);           // enable motor pin = output
  104.   pinMode (directionCloseCoopDoorMotorB, OUTPUT);   // motor close direction pin = output
  105.   pinMode (directionOpenCoopDoorMotorB, OUTPUT);    // motor open direction pin = output
  106.  
  107.   // coop door switches
  108.   // bottom switch
  109.   pinMode(bottomSwitchPin, INPUT);                  // set bottom switch pin as input
  110.   digitalWrite(bottomSwitchPin, HIGH);              // activate bottom switch resistor
  111.  
  112.   // top switch
  113.   pinMode(topSwitchPin, INPUT);                     // set top switch pin as input
  114.   digitalWrite(topSwitchPin, HIGH);                 // activate top switch resistor  
  115.  
  116.   // interior lights relay
  117.   pinMode(relayInteriorLight, OUTPUT);
  118.   digitalWrite(relayInteriorLight, HIGH);
  119.  
  120.   // timed actions setup
  121.   coopPhotoCellTimer.setInterval(600000, readPhotoCell);   // read the photocell every 10 minutes
  122.  
  123.  
  124.  
  125. }
  126.  
  127. // ************************************** functions **************************************
  128. // operate the coop door
  129.  
  130. // photocel to read levels of exterior light
  131.  
  132. void readPhotoCell() { // function to be called repeatedly - per coopPhotoCellTimer set in setup
  133.  
  134.   photocellReading = analogRead(photocellPin);
  135.   if(SerialDisplay){
  136.     Serial.print(" Photocel Analog Reading = ");
  137.     Serial.println(photocellReading);
  138.   }
  139.  
  140.  
  141.   //  set photocel threshholds
  142.   if (photocellReading >= 0 && photocellReading <= 445) {
  143.     photocellReadingLevel = '1';
  144.  
  145.     if(SerialDisplay){
  146.       Serial.print(" Photocel Reading Level:");
  147.       Serial.println(" - Dark");
  148.     }
  149.   }  
  150.   else if (photocellReading  >= 450 && photocellReading <= 595){
  151.     photocellReadingLevel = '2';
  152.     if(SerialDisplay){
  153.       Serial.print(" Photocel Reading Level:");
  154.       Serial.println(" - Twilight");
  155.     }
  156.   }  
  157.   else if (photocellReading  >= 600 ) {
  158.     photocellReadingLevel = '3';
  159.     if(SerialDisplay){
  160.       Serial.print(" Photocel Reading Level:");
  161.       Serial.println(" - Light");
  162.     }
  163.   }
  164. }
  165.  
  166. //debounce bottom reed switch
  167.  
  168. void debounceBottomReedSwitch() {
  169.  
  170.   //debounce bottom reed switch
  171.   bottomSwitchPinVal = digitalRead(bottomSwitchPin);       // read input value and store it in val
  172.   // delay(10);
  173.  
  174.   if ((millis() - lastDebounceTime) > debounceDelay) {    // delay 10ms for consistent readings
  175.  
  176.     bottomSwitchPinVal2 = digitalRead(bottomSwitchPin);    // read input value again to check or bounce
  177.  
  178.     if (bottomSwitchPinVal == bottomSwitchPinVal2) {       // make sure we have 2 consistant readings
  179.       if (bottomSwitchPinVal != bottomSwitchState) {       // the switch state has changed!
  180.         bottomSwitchState = bottomSwitchPinVal;
  181.       }
  182.       if(SerialDisplay){
  183.         Serial.print (" Bottom Switch Value: ");           // display "Bottom Switch Value:"
  184.         Serial.println(digitalRead(bottomSwitchPin));      // display current value of bottom switch;
  185.       }
  186.     }
  187.   }
  188. }
  189.  
  190.  
  191.  
  192. // debounce top reed switch
  193. void debounceTopReedSwitch() {
  194.  
  195.   topSwitchPinVal = digitalRead(topSwitchPin);             // read input value and store it in val
  196.   //  delay(10);
  197.  
  198.   if ((millis() - lastDebounceTime) > debounceDelay) {     // delay 10ms for consistent readings
  199.  
  200.     topSwitchPinVal2 = digitalRead(topSwitchPin);          // read input value again to check or bounce
  201.  
  202.     if (topSwitchPinVal == topSwitchPinVal2) {             // make sure we have 2 consistant readings
  203.       if (topSwitchPinVal != topSwitchState) {             // the button state has changed!
  204.         topSwitchState = topSwitchPinVal;
  205.       }
  206.       if(SerialDisplay){
  207.         Serial.print (" Top Switch Value: ");              // display "Bottom Switch Value:"
  208.         Serial.println(digitalRead(topSwitchPin));         // display current value of bottom switch;
  209.       }
  210.     }
  211.   }
  212. }
  213.  
  214.  
  215. // stop the coop door motor
  216. void stopCoopDoorMotorB(){
  217.   digitalWrite (directionCloseCoopDoorMotorB, LOW);      // turn off motor close direction
  218.   digitalWrite (directionOpenCoopDoorMotorB, LOW);       // turn on motor open direction
  219.   analogWrite (enableCoopDoorMotorB, 0);                 // enable motor, 0 speed
  220. }
  221.  
  222.  
  223.  
  224. // close the coop door motor (motor dir close = clockwise)
  225. void closeCoopDoorMotorB() {  
  226.   digitalWrite (directionCloseCoopDoorMotorB, HIGH);     // turn on motor close direction
  227.   digitalWrite (directionOpenCoopDoorMotorB, LOW);       // turn off motor open direction
  228.   analogWrite (enableCoopDoorMotorB, 255);               // enable motor, full speed
  229.   if (bottomSwitchPinVal == 0) {                         // if bottom reed switch circuit is closed
  230.     stopCoopDoorMotorB();
  231.     if(SerialDisplay){
  232.       Serial.print(" Coop Door Closed - no danger");
  233.     }
  234.   }
  235. }
  236.  
  237.  
  238.  
  239. // open the coop door (motor dir open = counter-clockwise)
  240. void openCoopDoorMotorB() {
  241.   digitalWrite(directionCloseCoopDoorMotorB, LOW);       // turn off motor close direction
  242.   digitalWrite(directionOpenCoopDoorMotorB, HIGH);       // turn on motor open direction
  243.   analogWrite(enableCoopDoorMotorB, 255);                // enable motor, full speed
  244.   if (topSwitchPinVal == 0) {                            // if top reed switch circuit is closed
  245.     stopCoopDoorMotorB();
  246.     if(SerialDisplay){
  247.       Serial.print(" Coop Door open - danger!");
  248.     }
  249.   }
  250. }
  251.  
  252.  
  253. //  turn on interior lights at dusk and turn off after door shuts
  254.  
  255. void doCoopInteriorLightDusk() {
  256.  
  257.   if ((millis() - lastTwilightTime) > TwilightDelay) {     // delay 5 mins
  258.  
  259.     readPhotoCell();
  260.     bottomSwitchPinVal = digitalRead(bottomSwitchPin);
  261.     if (bottomSwitchPinVal == 1 && photocellReading  >= 4 && photocellReading <= 445) {   // if bottom reed switch circuit is open and it's twilight
  262.       digitalWrite (relayInteriorLight, HIGH);
  263.       if (SerialDisplay) {
  264.         Serial.println(" Interior Light: On");
  265.       }
  266.     }
  267.     else if (bottomSwitchPinVal == 0) {
  268.       digitalWrite (relayInteriorLight, LOW);
  269.       if (SerialDisplay) {
  270.         Serial.println(" Interior Light: Off");
  271.       }
  272.     }
  273.   }
  274. }
  275.  
  276.  
  277.  
  278.  
  279. // do the coop door
  280. void doCoopDoor(){
  281.   if (photocellReadingLevel  == '1') {              // if it's dark
  282.     if (photocellReadingLevel != '2') {             // if it's not twilight
  283.       if (photocellReadingLevel != '3') {           // if it's not light
  284.         debounceTopReedSwitch();                    // read and debounce the switches
  285.         debounceBottomReedSwitch();
  286.         closeCoopDoorMotorB();                      // close the door
  287.       }
  288.     }
  289.   }
  290.   if (photocellReadingLevel  == '3') {              // if it's light
  291.     if (photocellReadingLevel != '2') {             // if it's not twilight
  292.       if (photocellReadingLevel != '1') {           // if it's not dark
  293.         debounceTopReedSwitch();                    // read and debounce the switches
  294.         debounceBottomReedSwitch();
  295.         openCoopDoorMotorB();                       // Open the door
  296.       }
  297.     }
  298.   }
  299. }
  300.  
  301.  
  302.  
  303.  
  304.  
  305. // ************************************** the loop **************************************
  306.  
  307. void loop() {
  308.   coopPhotoCellTimer.run();      // timer for readPhotoCell
  309.   doCoopDoor();
  310.   doCoopInteriorLightDusk();
  311. //delay(2000);      
  312. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top