Arduino Chicken Coop Controller

Wow!! I just found this stream. It’s like another person called Mark Cummins that went on and on. I don’t remember what I was thinking then. Sorry Stroke does that. I sent you an email recently including my current code. All is running very well for almost a year. I include the current code here. I am rebuilding my coop emulator here in my home I will rewrite the code to remove the current way we control the door. I hope it will remove the desire to always control the door and some implied fail modes and I want to move the door sensor from the door. Currently the door position for the lock on the door to latch requires the motor to continue to run after the bottom switch is made. This causes several issues. I am working on them now.

This current code supports;
1. two temperature probes (inside, outside)
2. two access door detectors( main area, egg hatch)
3. two push button control panel ( green, red)
4. two LED (green, red) status panel
5. 4 relay outputs (main light, egg hatch light, inside heat, water heat)
6. one chicken access door
7. 16 x 2 LCD display
8. Enhanced debouncing on switch inputs
9. Long term integration of digital thermometer inputs (produces better door control)
10. Watchdog timer output once every two passes. (great debug tool to trouble shoot with)
11. Control panel control of auto of manual control of door ( press three times in three seconds to access)
12. Control USB console of coop status.
13. Very important to run console at highest speed to decrease pass time.
14. Nothing is done while the chicken door is moving except watch those limit switches.

Current code; (hope this is readable)

/*
CoopControl_V2.0.0 written by Mark Cummins

This code is for the “ChickenCoopControl” system that I have been building to use for my Son’s coop.

Part of this code came from a program with permission copyrighted 2013 by David Naves (http://daveworks.net, http://davenaves.com)

Also note the code to run the DS18S20 tempature came from with permission bildr.org/2011/07/ds18b20-arduino/

I have also used some code that is public domain to service some devices.

V2.0.0 takes V1.5.3 and adds Web Page Serving.
1. Added “listenForEthernetClients()” function
2. added new function for time reporting “reportTimeStr()” and “str2digits(int number)”

V2.0.1
1. convert rewrite coopDoor() add manual mode control implemented.
2. Rewrite PhotoCellInputAverageCtl() removed control from there. Cleared up
issue with LCD message reporting wrong sky conditions.

V2.0.2 rewrite reportTimeStr()

V2.0.3 add to web page
1. Version of software running
2. inside heater and water heate status on web page
3. Change trigger of photocell readings to variable takePCread time in miliseconds to sample photocell

V2.0.4 adds Status indications and logging to SD card.
1. adds alarmControlSys(), determines if door is moving and limit swithes are evaluated for “change” mode
2. fixed readTemp() added string field results vis dtostrf()
3. fixed lcdMsg() got rid of float issues with sprint()
4. added logSystem() logging system to SD chip on ethernet board added enable chip control
5. fixed chip enable issues with w5100 ethernet system… web page works
6. added suspension of operations of lcdMsg() and logSystem() when door is moving.
7. added disable lcdMsq when chicken door is moving.

V2.0.7 remove SD and Ethernet operations

*/

// libraries

#include // load the SimpleTimer library for supporting timer operation
#include // load the Wire library to support operation on the LCD system
#include // load the display library
#include // load the one wire library for the support of thermometer systems DS18S20
#include // load the time library to support RTC
#include // load the RTC library

// pins assignments
// i/o
const int photocellPin = A0; // photocell connected to analog 0
const int thermometerPin = 2; // thermometer DS18S20 on digital pin 2
const int enableCoopDoorMotorA = 5; // enable motor a – pin 5
const int greenPushButtonPin = 18; // Green push button on CMD panel(int.5)
const int redPushButtonPin = 19; // Red push button on CMD panel(int.4)
const int redLEDpin = 24; // Green led set to digital pin 24
const int greenLEDpin = 25; // Red led set to digital pin 25
const int topSwitchPin = 26; // top switch is connected to pin 26
const int bottomSwitchPin = 27; // bottom switch is connected to pin 27
const int mainDoorSwitchPin = 28; // main door switch entry is connected to pin 28
const int eggDoorSwitchPin = 29; // egg door switch enty is connected to pin 39
const int mainLightPin = 40; // main lamp relay set to digital pin 40
const int eggLightPin = 41; // egg lamp relay set to digital pin 41
const int insideHeatPin = 42; // inside heat lamp relay set to digital pin 42
const int waterHeatPin = 43; // water heat lamp relay set to digital pin 43
const int directionOpenCoopDoorMotorA = 44; // direction close motor a – pin 44
const int directionCloseCoopDoorMotorA = 45; // direction open motor a – pin 45
const int loopPassTImePin = 46; // digital output for loop pass timing on pin 46

// variables

// version of code
const String cccCode = “v2.0.7”;

// alarmControlSys
boolean chickenDoorMotorEngaged; // chicken door motor status flag
boolean doorMovingFlag; // flag when true means the door is moving

// Logging
unsigned long logLastTimeRun; // last time log made an output
const unsigned long logSystemPeriod = 60000; // how often to run a log of photocell
char bufLog[80];
boolean doorOpen;

// CMD operation
const long enterHold_time = 3000; // enter “hold mode” timer value in milliseconds
boolean goHoldRed = false; // “go hold” flag for red push button
boolean goHoldGreen = false; // “go hold” flag for green push button
boolean holdSkyControl = false; // flag for control of door. false = automatic “based on sky readings”. true = means freeze door operation.
boolean holdSkyControl_Last = true; // last value of “holdSkyControl” for determining if srtate has changed
boolean holdOpen; // true means door is in up position, false means down.
unsigned long first_RedButtonPressed = 0; // counter to hold time “First time Red was pressed in “enterHold_Time” frame
unsigned long first_GreenButtonPressed = 0; // counter to hold time “First time Red was pressed in “enterHold_Time” frame
int redPushButtonCount = 0; // counter to hold “How many times red button is pressed in “enterHold_Time” frame
int greenPushButtonCount = 0; // counter to hold “How many times green button is pressed in “enterHold_Time” frame
boolean CMDholdState = false; // flag to indicate current state of LED while in hold mode

// photocell
int photocellReading; // analog reading of the photocel
int photocellReadingLevel = 50; // photocel reading levels (dark(1)(Ascii49), twilight(2)(Ascii50), light(3)(Ascii51))
// since at start time the doors position is unknown set to 50 at system start or reset.
// photocell averaging
const int numReadingsPC = 1000; // number of photocell readings to average
int readingsPC[numReadingsPC]; // the readings from the analog input
int indexPC = 0; // the index of the current reading
unsigned long int totalPC = 0; // the running total
unsigned long int lastPCtime; // time last photocell reading was made
int takePCread = 10; // time interval in milliseconds to take reading of photocell

// all switches
const int debounce_count = 10; // number of millis/samples to consider before decllaring a debounced input.

// top switch
int topSwitchCounter; // how many times we have seen new value
int topSwitchReading; // main door switch current value reading input pin.
int topSwitchCurrent_State = HIGH; // main door switch Debounced input value
long topSwitchTime = 0; // last time the main door was sampled

// bottom switch
int bottomSwitchCounter; // how many times we have seen new value
int bottomSwitchReading; // main door switch current value reading input pin.
int bottomSwitchCurrent_State = HIGH; // main door switch Debounced input value
long bottomSwitchTime = 0; // last time the main door was sampled

// Main Door Switch
int mainDoorCounter; // how many times we have seen new value
int mainDoorReading; // main door switch current value reading input pin.
int mainDoorCurrent_State = HIGH; // main door switch Debounced input value
long mainDoorTime = 0; // last time the main door was sampled
int flagMainDoorLight;

// Egg Door Switch
int eggDoorCounter; // how many times we have seen new value
int eggDoorReading; // main door switch current value reading input pin.
int eggDoorCurrent_State = HIGH; // main door switch Debounced input value
long eggDoorTime = 0; // last time the main door was sampled
int flagEggDoorLight;

// Green Command Switch
int greenCMDCounter; // how many times we have seen new value
int greenCMDReading; // main door switch current value reading input pin.
int greenCMDCurrent_State = HIGH; // main door switch Debounced input value
boolean greenCMDChange_State = HIGH; // true means state has changed
long greenCMDTime = 0; // last time the main door was sampled

// Red Command Switch
int redCMDCounter; // how many times we have seen new value
int redCMDReading; // main door switch current value reading input pin.
int redCMDCurrent_State = HIGH; // main door switch Debounced input value
boolean redCMDChange_State = HIGH; // true means state has changed
long redCMDTime = 0; // last time the main door was sampled
int burpTimebegin;

// light status var
int cmdLEDgreen; // status var to indicate current LED condition, “0” means LED is on,
// “1” means LED is off, “-1_” means door is intransition
int cmdLEDred; // status var to indicate current LED condition, “0” means LED is on,
// “1” means LED is off, “-1_” means door is intransition

// temperature sensor variables
OneWire ds(thermometerPin); // OneWire buss on pin 2
#define MAX_DS1820_SENSORS 2 // declare two temprature sensors
byte addr[MAX_DS1820_SENSORS][8]; // setup byte array 2 by 8 bytes
int HighByte; // word buffer for temp store high byte
int LowByte; // word buffer for temp store low byte
int TReading; // word buffer to build complete data word from device
float tempFah0; // result location for outside temperature sensor
float tempFah1; // result location for inside temperature sensor
char tempFahStr0[6];
char tempFahStr1[6];

// heating demand variables
float insideHeatTrig = 45.0; // trigger temperature for inside heating demand
int insideHeatStatus;
float waterHeatTrig = 36.0; // trigger temperature for outside water heating demand
int waterHeatStatus;

// RTC var
char bufTime[21];

// only need 1 SimpleTimer object
SimpleTimer timer;

// loop pass timing vars
boolean loopPassTImevalue = false;
const boolean testLoopTime = true; // TRUE turns on loop timme measuing

// LCD variables
#define BACKLIGHT_PIN 3 // Define Backlight pin for LCD
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7); //LCD support and declations
char buf0[17];
char buf1[17];
int long lcd_Disp_Inteval = 1000; // time in milliseconds
int long lcd_Disp_Last; // time of last LCD update

// ************************************** the setup **************************************

void setup (void) {

lcd.begin(16, 2); // setup 16 character by 2 line display
lcd.setBacklightPin(BACKLIGHT_PIN, POSITIVE); // setup backlight interface
lcd.setBacklight(HIGH); // turn on backlight in display
Serial.begin(115200);
reportTimeSerial();
Serial.print(“**************************Running Setup********************************”);
Serial.println (cccCode);

// test output to measure pass times
pinMode (loopPassTImePin, OUTPUT); // out pin to sample pass times externally
digitalWrite(loopPassTImePin, loopPassTImevalue); // initialize

// chicken coop door motor
pinMode (enableCoopDoorMotorA, OUTPUT); // enable motor pin = output
pinMode (directionCloseCoopDoorMotorA, OUTPUT); // motor close direction pin = output
pinMode (directionOpenCoopDoorMotorA, OUTPUT); // motor open direction pin = output

// chicken coop door switches
// bottom switch
pinMode(bottomSwitchPin, INPUT); // set bottom switch pin as input
digitalWrite(bottomSwitchPin, HIGH); // turn on the internal pull up 10K resistor
readDebounceBottomReedSwitch(); // read bottom switch and set state

// top switch
pinMode(topSwitchPin, INPUT); // set top switch pin as input
digitalWrite(topSwitchPin, HIGH); // turn on the internal pull up 10K resistor
readDebounceTopReedSwitch(); // read top switch and set state

// Stop servo system abd Init door operation
stopCoopDoorMotorA();

// Setup CMD push buttons
pinMode (redPushButtonPin, INPUT); // set pin for input
digitalWrite(redPushButtonPin, HIGH); // enable pull up resistor
pinMode (greenPushButtonPin, INPUT); // set pin for input
digitalWrite(greenPushButtonPin, HIGH); // enable pull up resistor
holdSkyControl = false; // set mode to automatic
holdSkyControl_Last = false; // inverse last state to initate first pass run

// setup main and egg room lights and detection switches
pinMode(mainLightPin, OUTPUT);\
pinMode(eggLightPin, OUTPUT);
pinMode(mainDoorSwitchPin, INPUT);
pinMode(eggDoorSwitchPin, INPUT);

// heating demands
pinMode(insideHeatPin, OUTPUT); // set inside heating relay output
digitalWrite(insideHeatPin, HIGH); // turn off heat lamp relay (“off” = HIGH)
pinMode(waterHeatPin, OUTPUT); // set outside water heat relay output
digitalWrite(waterHeatPin, HIGH); // turn off heat lamp relay (“off” = HIGH)

// setup CMD panel LEDs
pinMode(greenLEDpin, OUTPUT); // HIGH means on, LOW means off
pinMode(redLEDpin, OUTPUT); // HIGH means on, LOW means off

// temperature sensor setup
if (!ds.search(addr[0])) // see if outside temp device is there
{
reportTimeSerial();
Serial.println(“Outside temp sensor not found”); // status host message to indicate outside device is not there
ds.reset_search(); // reset OneWire buss get attension of all devices
delay(250); // wait for power to stabilize
return;
}
else
{
reportTimeSerial();
Serial.println(“Outside temp sensor found”); // also send to host
}
if ( !ds.search(addr[1])) // see if inside device is there
{
reportTimeSerial();
Serial.print(“Inside temp sensor not found”); // status host message to indicate inside device is not there
ds.reset_search(); // reset OneWire buss
delay(250); // wait for power to stabilize
return;
}
else
{
reportTimeSerial();
Serial.println(“Inside temp sensor found”); // also send to host
}
// timed actions setup
readTemp(); // get first reading
timer.setInterval(60000, readTemp); // setup timer to read the temperature sensors once a minute
setHeating(); // set fist reading controls
timer.setInterval(60000, setHeating); // setup timer to read the temperatures and contol heat demands
timer.setInterval(600, doCMDledHold); // setup timer to handle CMD LEDs state change

// initialize all the photocell readings to 0:
for (int thisReadingPC = 0; thisReadingPC logSystemPeriod) { // is it time to run?
memset(bufLog, 0, sizeof(bufLog));
reportTimeStr(); // get current time and build bufLog topSwitchCurrent_State
sprintf(bufLog, “%s,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%s,%s\r”, bufTime, photocellReading,topSwitchCurrent_State,bottomSwitchCurrent_State,doorOpen, holdSkyControl, holdOpen,
!mainDoorCurrent_State, !eggDoorCurrent_State, insideHeatStatus, waterHeatStatus, tempFahStr0, tempFahStr1 );
Serial.println(bufLog);
logLastTimeRun = millis();
} // end of logLastTimeRun
} // end of !doorMovingFlag
} // end of logSystem()

void loopPassTesting() { // function to measure loop pass timing via ditital output pin
if (testLoopTime) { // can we do testing?
digitalWrite(loopPassTImePin, loopPassTImevalue); // yes, write new state
loopPassTImevalue = !loopPassTImevalue; // reverse state for wave form generation.
}
/*
Loop pass time base is about 5 microseconds

*/
} // end of loopPassTesting() function

void alarmControlSys() { // function to set alarm and status variables
if (topSwitchCurrent_State == 1) { // is top limit switch open(“1”)?
if (bottomSwitchCurrent_State == 1) { // is bottom limit switch open(“1″)?
if (!chickenDoorMotorEngaged) { // is door motor not engaged?
doorMovingFlag = LOW; // set door moving flag to LOW
// digitalWrite(onBoardLEDStatusPIN, LOW);
} else { // else
// digitalWrite(onBoardLEDStatusPIN, HIGH);
doorMovingFlag = HIGH; // set door moving flag to HIGH
}
}
}
if (topSwitchCurrent_State == 0) {
if (bottomSwitchCurrent_State == 1) {
doorMovingFlag = LOW;
doorOpen = true;
// digitalWrite(onBoardLEDStatusPIN, LOW);
}
}
if (topSwitchCurrent_State == 1) {
if (bottomSwitchCurrent_State == 0) {
doorMovingFlag = LOW;
doorOpen = false;
// digitalWrite(onBoardLEDStatusPIN, LOW);
}
}
} // end of alarmControlSys()

void PhotoCellInputAverageCtl() { // function to to input and average photocell readings
if (millis() – lastPCtime >= takePCread) {
totalPC = totalPC – readingsPC[indexPC]; // subtract the last reading:
readingsPC[indexPC] = analogRead(photocellPin); // read from the sensor:
totalPC = totalPC + readingsPC[indexPC]; // add the reading to the total:
indexPC = indexPC + 1; // advance to the next position in the array:
if (indexPC >= numReadingsPC) // if we’re at the end of the array…
indexPC = 1; // …wrap around to the beginning:
photocellReading = totalPC / numReadingsPC; // calculate the average:
if (photocellReading >= 0 && photocellReading =40 && photocellReading = 275) {
photocellReadingLevel = ‘3’; // day time
}
lastPCtime = millis();
}
} // end of PhotoCellInputAverageCtl()

void readCMDinput() {
readDebounce_greenCMDSwitch(); // fetch read of push button
if (greenCMDChange_State == HIGH) { // has there been a change in input?
if (greenCMDCurrent_State == LOW) {
if (greenPushButtonCount == 0) { // if the press count time = 0 then this is a new hold time frame
first_GreenButtonPressed = millis(); // set first green button pressed time in milliseconds
greenCMDChange_State = LOW;
}
if (greenPushButtonCount == 1) {
greenCMDChange_State = LOW;
if (millis() – first_GreenButtonPressed > enterHold_time)
{
greenPushButtonCount = 0; // reset counter of green button pressed events
goHoldGreen = false;
}
}
if (greenPushButtonCount == 2) { // is this the third time(count 0 to 2) red button is pressed?
greenCMDChange_State = LOW;
if (millis() – first_GreenButtonPressed enterHold_time)
{
redPushButtonCount = 0; // reset counter of green button pressed events
goHoldRed = false;
}
}
if (redPushButtonCount == 2) { // is this the third time(count 0 to 2) red button is pressed?
redCMDChange_State = LOW;
if (millis() – first_RedButtonPressed enterHold_time) { // reset red pressed count if hold time is exceeded
redPushButtonCount = 0; // exceeded so reset
}
}

if (goHoldGreen == true) { // has the hold door status control been signaled by the green push button?
holdSkyControl = !holdSkyControl; // revert state of automatic operation of the door
holdOpen = true; // door should be in the open or up position
greenPushButtonCount = 0; // reset the counting of the red push button actuations
goHoldGreen = !goHoldGreen; // reset the flag indicating a hold operation change by the green push button
}
else { // No change loop execution
if (millis() – first_GreenButtonPressed > enterHold_time) {// reset red pressed count if hold time is exceeded
greenPushButtonCount = 0; // exceeded so reset
}
}
if (holdSkyControl != holdSkyControl_Last) { // has holdSkyControl state changed?
reportTimeStr();
Serial.print(bufTime);
//reportTimeSerial();
Serial.print(” holdSkyControl state changed, “); // yes send status message
if (holdSkyControl == true) { // is the door control status in the hold state?
if (holdOpen == true) { // should the door be up?
Serial.println(” Held door set open, ‘Manual Mode'”); // Yes… print status
}
else { // No… print Status
Serial.println(“Held door set closed, ‘Manual Mode'”);
}
}
else { // Not in hold state… run automatically
Serial.println(“Hold control is off, ‘Auto mode'”); // status message
}

holdSkyControl_Last = holdSkyControl; // update last value flag
}
} // end of execCMDControl()

void lcdMsg() {
if (!doorMovingFlag) { // do not run if door is in motion
if ((millis() – lcd_Disp_Last) >= lcd_Disp_Inteval) {
//Serial.print(“LCD”);
memset(buf0, 0, sizeof(buf0));
memset(buf1, 0, sizeof(buf1));
if (photocellReadingLevel == ‘1’) {
sprintf(buf0, “%sNight I:%s”, holdSkyControl ? “Man ” : “Auto “, tempFahStr0 );
}
else if (photocellReadingLevel == ‘2’) {
sprintf(buf0, “%sTwili I:%s”, holdSkyControl ? “Man ” : “Auto “, tempFahStr0 );
}
else if (photocellReadingLevel == ‘3’) {
sprintf(buf0, “%sDay I:%s”, holdSkyControl ? “Man ” : “Auto “, tempFahStr0 );
}
if (topSwitchCurrent_State == 1) {
if (bottomSwitchCurrent_State == 1) {
sprintf(buf1, “Change %s%s0:%s”, insideHeatStatus ? “H ” : ” “, waterHeatStatus ? “W ” : ” “, tempFahStr1 );
}
}
if (topSwitchCurrent_State == 0) {
if (bottomSwitchCurrent_State == 1) {
sprintf(buf1, “Open %s%s0:%s”, insideHeatStatus ? “H ” : ” “, waterHeatStatus ? “W ” : ” “, tempFahStr1 );
}
}
if (topSwitchCurrent_State == 1) {
if (bottomSwitchCurrent_State == 0) {
sprintf(buf1, “Closed %s%s0:%s”, insideHeatStatus ? “H ” : ” “, waterHeatStatus ? “W ” : ” “, tempFahStr1 );
}
}

//lcd.setCursor(0, 0);
lcd.clear();
lcd.print(buf0);
lcd.setCursor(0, 1);
lcd.print(buf1);
lcd_Disp_Last = (millis());
} // end of time to run
} // end of door flag
} // end of lcdMsg()

void reportTimeStr() { // routine to read and create string object of current TOY from RTC module
memset(bufTime, 0, sizeof(bufTime));
tmElements_t tm;
if (RTC.read(tm)) {
sprintf(bufTime, “%02d/%02d/%02d %02d:%02d:%02d”, tm.Day, tm.Month, tmYearToCalendar(tm.Year), tm.Hour, tm.Minute, tm.Second );
}
} // end of reportTimeStr()

void reportTimeSerial() { // routine to read and print current TOY from RTC module
tmElements_t tm;

if (RTC.read(tm)) {
print2digits(tm.Day);
Serial.write(‘/’);
print2digits(tm.Month);
Serial.write(‘/’);
Serial.print(tmYearToCalendar(tm.Year));
Serial.print(” “);
print2digits(tm.Hour);
Serial.write(‘:’);
print2digits(tm.Minute);
Serial.write(‘:’);
print2digits(tm.Second);
Serial.print(” “);
} else {
if (RTC.chipPresent()) {
Serial.println(“The DS1307 is stopped. Please run the SetTime”);
Serial.println(“example to initialize the time and begin running.”);
Serial.println();
} else {
Serial.println(“DS1307 read error! Please check the circuitry.”);
Serial.println();
}
delay(4000);
}
} // end of reportTimeSerial()

void print2digits(int number) {
if (number >= 0 && number < 10) {
Serial.write('0');
}
Serial.print(number);
} // end of print2digits()

void setHeating() { // set heating demands based on temperatures derrived from
if (tempFah1 <= insideHeatTrig) { // deal with inside temp and heating outlet
digitalWrite(insideHeatPin, LOW); // turn on heat outlet relay
insideHeatStatus = HIGH; // set inside heating outlet status
}
else
{
digitalWrite(insideHeatPin, HIGH); // turn off heat lamp relay
insideHeatStatus = LOW; // set inside heating outlet status
}
if (tempFah0 <= waterHeatTrig) { // deal with outside temp and water heater outlet
digitalWrite(waterHeatPin, LOW); // turn on heat outlet relay
waterHeatStatus = HIGH; // set water heater status
}
else
{
digitalWrite(waterHeatPin, HIGH); // turn off heat lamp relay
waterHeatStatus = LOW; // set water heater status
}
} // end of setHeating()

void readTemp() { // read two sensors and return reading in "tempFag0" and "tempFah1"

byte i, sensor; // local byte var pointer to counting (i), and the current sensor
byte present = 0; // local byte var to indicate sensor is present set to zero to start with
byte data[12]; // local 12 byte var to hold data that is read from sensor unter test
for (sensor = 0; sensor < MAX_DS1820_SENSORS; sensor++) // start scanning sensors start with the first one
{
if ( OneWire::crc8( addr[sensor], 7) != addr[sensor][7]) // check that we read and generate a valid CRC
{
reportTimeSerial();
Serial.println("CRC is not valid"); // status message to LCD
return;
}
if ( addr[sensor][0] != 0x10) // check to see if it is the correct device type
{
reportTimeSerial();
Serial.println("Device is not a DS18S20 family device.");
return;
}
ds.reset(); // reset buss
ds.select(addr[sensor]); // select sensor
ds.write(0x44, 1); // start conversion, with parasite power on at the end
delay(100); // maybe 750ms is enough, maybe not
// we might do a ds.depower() here, but the reset will take care of it.
present = ds.reset();
ds.select(addr[sensor]); // reselect sensor
ds.write(0xBE); // tell selected device we want to read the conversion from the selected device's scratchpad
for ( i = 0; i < 9; i++) // 9 step read of data from device
{ // we need 9 bytes
data[i] = ds.read(); // read in 9 bytes to array "data(12) using first 9 bytes
}
LowByte = data[0]; // word "LowByte" = first byte
HighByte = data[1]; // word "HighByte" = second byte
TReading = (HighByte < 0?
&& bottomSwitchCounter > 0) {
bottomSwitchCounter –; // yes then decrement counter value
}
if (bottomSwitchReading != bottomSwitchCurrent_State) { // is current reading different then known current state?
bottomSwitchCounter ++; // yes so increment counter
}
if (bottomSwitchCounter >= debounce_count) { // have we reached a decision state?
bottomSwitchCounter = 0; // yes so reset counter
bottomSwitchCurrent_State = bottomSwitchReading; // declare
}
bottomSwitchTime = millis(); // set last change time
}
} // end of readDebounceBottomReedSwitch()

void readDebounceTopReedSwitch() { // de-bounce top reed switch cof hicken door
if (millis() != topSwitchTime)
{
topSwitchReading = digitalRead(topSwitchPin); // read the state into local variable
if (topSwitchReading == topSwitchCurrent_State // is there any change in state and a counter value > 0?
&& topSwitchCounter > 0) {
topSwitchCounter –; // yes then decrement counter value
}
if (topSwitchReading != topSwitchCurrent_State) { // is current reading different then know current state?
topSwitchCounter ++; // yes so increment counter
}
if (topSwitchCounter >= debounce_count) { // have we reached a decision state?
topSwitchCounter = 0; // yes so reset counter
topSwitchCurrent_State = topSwitchReading; // declare
}
topSwitchTime = millis(); // set last change time
}
} // end of readDebounceTopReedSwitch()

void readDebounceMainDoorSwitchPin() { // de-bounce main door reed switch
if (millis() != mainDoorTime)
{
mainDoorReading = digitalRead(mainDoorSwitchPin); // read the state into local variable
if (mainDoorReading == mainDoorCurrent_State // is there any change in state and a counter value > 0?
&& mainDoorCounter > 0) {
mainDoorCounter –; // yes then decrement counter value
}
if (mainDoorReading != mainDoorCurrent_State) { // is current reading different then know current state?
mainDoorCounter ++; // yes so increment counter
}
if (mainDoorCounter >= debounce_count) { // have we reached a decision state?
mainDoorCounter = 0; // yes so reset counter
mainDoorCurrent_State = mainDoorReading; // declare
}
mainDoorTime = millis(); // set last change time
}
} // end of readDebounceMainDoorSwitchPin()

void readDebounceEggDoorSwitch() { // debounce egg door reed switch
if (millis() != eggDoorTime)
{
eggDoorReading = digitalRead(eggDoorSwitchPin); // read the state into local variable
if (eggDoorReading == eggDoorCurrent_State // is there any change in state and a counter value > 0?
&& eggDoorCounter > 0) {
eggDoorCounter –; // yes then decrement counter value
}
if (eggDoorReading != eggDoorCurrent_State) { // is current reading different then know current state?
eggDoorCounter ++; // yes so increment counter
}
if (eggDoorCounter >= debounce_count) { // have we reached a decision state?
eggDoorCounter = 0; // yes so reset counter
eggDoorCurrent_State = eggDoorReading; // declare
}
eggDoorTime = millis(); // set last change time
}
} // end of readDebounceEggDoorSwitch()

void readDebounce_greenCMDSwitch() { // debounce green CMD push button switch
if (millis() != greenCMDTime)
{ //
greenCMDReading = digitalRead(greenPushButtonPin); // read the state into local variable
if (greenCMDReading == greenCMDCurrent_State // is there any change in state and a counter value > 0?
&& greenCMDCounter > 0) {
greenCMDCounter –; // yes then decrement counter value
}
if (greenCMDReading != greenCMDCurrent_State) { // is current reading different then current state?
greenCMDCounter ++; // yes so increment counter
}
if (greenCMDCounter >= debounce_count) { // have we reached a decision state?
greenCMDCounter = 0; // yes so reset counter
greenCMDCurrent_State = greenCMDReading; // greenCMDCurrent_State is debounced condition of switch
greenCMDChange_State = true; // set flag indicating a change in greenCMDCurrent_State
} else {
greenCMDChange_State = false;
}
greenCMDTime = millis(); // set last change time
}
} // end of readDebounce_greenCMDSwitch()

void readDebounce_redCMDSwitch() { // debounce red CMD push button switch
if (millis() != redCMDTime)
{
redCMDReading = digitalRead(redPushButtonPin); // read the state into local variable
if (redCMDReading == redCMDCurrent_State // is there any change in state and a counter value > 0?
&& redCMDCounter > 0) {
redCMDCounter –; // yes then decrement counter value
}
if (redCMDReading != redCMDCurrent_State) { // is current reading different then current state?
redCMDCounter ++; // yes so increment counter
}
if (redCMDCounter >= debounce_count) { // have we reached a decision state?
redCMDCounter = 0; // yes so reset counter
redCMDCurrent_State = redCMDReading; // redCurrent_State is debounced condition of switch
redCMDChange_State = true; // set flag indicating a change in greenCMDCurrent_State
} else {
redCMDChange_State = false;
}
redCMDTime = millis(); // set last change time
}
} // end of readDebounce_redCMDSwitch()

void setMainDoorLight() { // set main light to current state of main door state
digitalWrite (mainLightPin, !mainDoorCurrent_State);
} // end of setMainDoorLight()

void setEggDoorLight() { // set egg access light to current state of main door state
digitalWrite (eggLightPin, !eggDoorCurrent_State);
} // end of setEggDoorLight()

void stopCoopDoorMotorA() { // stop the coop door
digitalWrite (directionCloseCoopDoorMotorA, LOW); // turn off motor close direction
digitalWrite (directionOpenCoopDoorMotorA, LOW); // turn on motor open direction
digitalWrite (enableCoopDoorMotorA, LOW); // enable motor, 0 speed
chickenDoorMotorEngaged = 0; // sete motor on flag to off
} // end of stopCoopDoorMotorA()

void closeCoopDoorMotorA() { // close the coop door
digitalWrite (directionCloseCoopDoorMotorA, HIGH); // turn on motor close direction normally HIGH
digitalWrite (directionOpenCoopDoorMotorA, LOW); // turn off motor open direction
digitalWrite (enableCoopDoorMotorA, HIGH); // enable motor, full speed
chickenDoorMotorEngaged = 1; // sete motor on flag to on
if (bottomSwitchCurrent_State == 0) { // if bottom reed switch circuit is close
stopCoopDoorMotorA();
}

} // end of closeCoopDoorMotorA()

void openCoopDoorMotorA() { // open the coop door
digitalWrite(directionCloseCoopDoorMotorA, LOW); // turn off motor close direction
digitalWrite(directionOpenCoopDoorMotorA, HIGH); // turn on motor open directionnormally HIGH
digitalWrite(enableCoopDoorMotorA, HIGH); // enable motor, full speed
chickenDoorMotorEngaged = 1; // sete motor on flag to on
if (topSwitchCurrent_State == 0) { // if top reed switch circuit is closed
stopCoopDoorMotorA();
}
} // end of openCoopDoorMotorA()

void coopDoor() {
if (holdSkyControl == true) { // are we in manual mode?
if (holdOpen == true) { // yes, are we in hold open state
readDebounceTopReedSwitch(); // read and debounce the limit switches
readDebounceBottomReedSwitch(); // read and debounce the limit switches
openCoopDoorMotorA(); // yes, so opend the chicken door
} else { // else
readDebounceTopReedSwitch(); // read and debounce the limit switches
readDebounceBottomReedSwitch(); // read and debounce the limit switches
closeCoopDoorMotorA(); // close the coop door

}
} else {
if (photocellReadingLevel == ‘1’) { // is it dark?
readDebounceTopReedSwitch(); // read and debounce the limit switches
readDebounceBottomReedSwitch(); // read and debounce the limit switches
closeCoopDoorMotorA(); // close the door
}
if (photocellReadingLevel == ‘2’) { // is it twilite?
stopCoopDoorMotorA(); // close the door
}
if (photocellReadingLevel == ‘3’) { // is it daylight?
readDebounceTopReedSwitch(); // read and debounce the limit switches
readDebounceBottomReedSwitch(); // read and debounce the limit switches
openCoopDoorMotorA(); // open the door
}
}
} // end of coopDoor()

void coopLights() { // set lights in coop based on door switches and sky conditions
readDebounceMainDoorSwitchPin();
setMainDoorLight();
//flagMainDoorLight;
readDebounceEggDoorSwitch();
setEggDoorLight();
//flagMainDoorLight;
} // end of coopLights()

void setLEDLights() { // function to control CMD LEDs when not in hold mode
if (holdSkyControl == false) { // are we not in hode mode?
if (topSwitchCurrent_State == 1) { // is top door switch open?
if (bottomSwitchCurrent_State == 1) { // and bottom doorswitch is open then door is in motion
cmdLEDred = -1; // status flag for usb messages meaning in motion
digitalWrite(redLEDpin, LOW); // turn off red LED
cmdLEDgreen = -1; // status flag for usb messages meaning in motion
digitalWrite(greenLEDpin, LOW); // turn off green LED
}
}
if (topSwitchCurrent_State == 0) { // is top switch closed?
if (bottomSwitchCurrent_State == 1) { // and bottom switch open?
cmdLEDred = 1; // status flag for usb messages meaning red LED is on
digitalWrite(redLEDpin, LOW); // turn on red LED
cmdLEDgreen = 0; // status flag for usb messages meaning green LED is off
digitalWrite(greenLEDpin, HIGH); // turn off green LED
}
}
if (topSwitchCurrent_State == 1) { // is top switch open?
if (bottomSwitchCurrent_State == 0) { // and bottom switch closed?
cmdLEDred = 0; // status flag for usb messages meaning red LED is off
digitalWrite(redLEDpin, HIGH); // turn off red LED
cmdLEDgreen = 1; // status flag for usb messages meaning green LED is on
digitalWrite(greenLEDpin, LOW); // turn on green LED
}
}
}
else
{
if (holdOpen == true) { // Is hold mode open?
digitalWrite(greenLEDpin, CMDholdState); // change state of green LED every seconf
digitalWrite(redLEDpin, LOW);
}
else { // holdOpen is false so door is held down
digitalWrite(redLEDpin, CMDholdState);
digitalWrite(greenLEDpin, LOW);
}
}
} // end of setLEDLights()

void doCMDledHold() { // timer function to control LEDs while doors are in hold mode
CMDholdState = !CMDholdState;
} // end of doCMDledHold)