G2A Many GEOs
SHARE
TWEET

Untitled

a guest Jun 13th, 2017 246 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
Ledger Nano X - The secure hardware wallet
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