How to build an Arduino Automatic Chicken Coop Door | Arduino code, parts, pictures, wiring diagram and videos included.

 

I wanted a small door to open automatically (via Arduino / morning/night) to the outside world. Doing this would relieve us from worrying if the chickens were safe at night and to be able to leave the house when we wanted) This door will be located on the side of the coop and will slide open (vertically) so the girls can up & down their ladder about 18″ to the ground level. (although ladders are really not needed as my chickens can fly straight up to the door without trouble)

I’ve lived with the chickens and the coop for some time now and have learned quite a bit… especially about their habits. This is important, because no matter how much I’d like to automate this coop via my Arduino Control Center, the chickens will ultimately dictate how it’s made and how it will operate.

The Installed Arduino Chicken Door

How I built the Automated Chicken Coop Door

Testing the door with the Arduino

The Elements

The Photocell


Photocell

When I first started this coop project I wanted to use a real-time clock and an Arduino library called Time Lord, but since I was a newbie to Arduino and struggled with the implementation of Time Lord I decided to go with using a photocell resistor instead. I’m actually glad I did since chickens come home to roost based on light, (not time) and with a photocell I won’t have to worry about a real time clock resetting due to power outages or battery failure, I think it will be less prone to problems.

Photocell application and installation
I first soldered the photocell to my cable, applied heat shrink tubing and encased the connection within a 1/4 inch plastic audio connector case. I filled the casing with silicone and capped the very tip with clear plexiglass to project the photocell from the elements. then I simply drilled a hole above the coop door monitor, and finished the outside with a brass grommet.

[Click thumbnails for detailed images]

The Door

Auto chicken door - interior view of locks/mechanics

Auto chicken door – back view (from interior of coop)

Auto chicken door - front view

Auto chicken door – front view (from exterior of coop)

As you can see, the door construction is fairly straightforward. I began framing out the door with 2 x 2s, capped with 2x4s and screwed everything together with 1/2 inch galvanized deck screws. The door itself is a 1/8 inch birch, sandwiching in OSB plywood door locks ~and in the pictures (below)~ is the 1/8th inch acrylic. Note: I have since swapped out the acrylic with more 1/8 inch birch because I cracked the acrylic… being too rough with all the testing. =(

I cut 1/2 inch grooves into the backsides of the 2x2s so the door could slide easily. I gave myself enough room for 1/4″ of play. You can see in the pictures I’ve also rubbed a bar of soap over the edges all moving parts to ensure that they will move freely. If you’re taking on this project I’m assuming you have basic carpentry skills and can simply take a look at the pictures below to come up with similar ideas to build your own. ( which of course is my way of saying I didn’t do a great job documenting this exact process with plans or dimensions) =)

[Click thumbnails for detailed images]

Door Rough Dimensions:

Exterior Front Finished Entrance: 10″ X 10″ (made it a bit small, so chickens wouldn’t want to hang out in the doorway and prevent others from coming in or out)
Interior Housing

The Switches

At first I was going to use micro switches for this build, but after testing them I felt they would wear out over time, being mechanical-type switches. So instead I chose to use Reed Switches, which are essentially magnets that when you get close in proximity throw an electromagnetic field thereby becoming a switch with open or closed values. ( high/low | 0/1)

The Door Motor

Chicken Coop - 24 Volt Door Motor


I chose a 25 RPM model, but you can certainly buy a different speed (just not *too* fast) Here’s the motor I purchased (linked to saved search of similar motors at Amazon.com)


Here’s a saved search of a DC 24V 25 RPM 6mm Dia Shaft Magnetic Gearbox Electric Motor 37mm at Amazon[Click thumbnails for detailed images]

The Installation

[Click thumbnails for detailed images]

Coop Door Status LEDs

I created a visual aid for checking the status of the door from the house. (red for open, green for closed) It works like a charm. It’s triggered by the status of the top and bottom switch of the door.

Parts Used

(my affiliate links)

Arduino MEGA 2560 Board R3 – by Arduino
(The Arduino Micro Controller to control the entire coop, including the door)

NEOMART L298N Stepper Motor Driver Controller Board Module – by Tontec
(The board that controls the motor)

DFGB37RG-136i Cylinder Shape DC 24V Speed 20 RPM Geared Motor – by Amico
The motor it self (make sure to pick a motor that isn’t too fast.I chose the 20rpm model)

White Inbuilt Type Alarm Contacts Door Window Reed Switch – by Amico
(The Reed Switches (magnetic) which signals when to start/top the motor)

20pcs Photo Light Sensitive Resistor Photoresistor Optoresistor 5mm GM5539 5539 – by sunkee-E
(The Photocell that continually reads light levels.In this project, it’s instructed to read ever 10mins)

10k Ohm Resistors – 1/4 Watt – 5% – 10K (25 Pieces) – by E-Projects
(10k resistors for the photocell and the reed switches – refer to wiring diagram)

BB830 Solderless Plug-in BreadBoard, 830 tie-points, 4 power rails – by BusBoard Prototype Systems
(To connect all devices and wiring.Tip: apply hot glue to wired connections on breadboard once set)

Polycom SoundPoint IP Universal AC Power Supply 24V DC – by Polycom Inc.
(power supply for 24v motor)

Wall Adapter Power Supply – 9V DC 650mA – by NKC Electronics
(power supply for arduino)

Acrylic Sheet, Transparent Clear, 0.08″ Thickness, 12″ Width, 24″ Length – by Small Parts
(To cover door’s internal workings…prevents dust, shavings, feathers, etc.)

The Wiring Diagram for the Automatic Chicken Coop Door

Arduino Automatic Chicken Coop Door Fritzing Wiring Diagram

Arduino Automatic Chicken Coop Door Fritzing Wiring Diagram

Close-up of the motor controller

More than a few people have asked for close-up photos of the motor controller (the Fritzing library didn’t have an image of the L298N Stepper Motor Controller)

Here’s the L298N Stepper Motor Controller itself:

L298N Motor Controller for Automatic Chicken Coop Door

L298N Motor Controller for Automatic Chicken Coop Door

Here’s the top half of the connections (labelled)

L298N Motor Controller for Automatic Chicken Coop Door

L298N Motor Controller for Automatic Chicken Coop Door (top connection details)

Here’s the bottom half (labelled)

L298N Motor Controller for Automatic Chicken Coop Door

L298N Motor Controller for Automatic Chicken Coop Door (bottom connection details)


Note: the Stepper Motor Controller Board is indeed the l298n (the one in the pic might look different b/c I broke (fried) a couple of them while testing – but it’s definitely the same model… sometimes suppliers send the same product but with different layouts)

Notes on the wiring to make the board/motor work: (I used only 1 motor – Motor B)

  • 5v (from arduino)
  • gnd (from arduino)
  • enab (to enable the motor b)
  • int1 (direction 1 – up)
  • int2 (direction2 – down)
  • 24 v in to l298n board (vms *or* vcc in some controllers)
  • 24v gnd in to l298n board (gnd)
  • motor b out + (24 volts to motor)
  • motor b out – (gnd)

Here’s a closeup of the Automatic Chicken Coop Door Fritzing diagram

The Arduino Code for the Automatic Chicken Coop Door

[callout font_size=”13px” style=”limegreen”]

David Naves

David Naves

Please note:
I’m hoping that if you use or modify my code or ideas, you will share *your* coop project with me and the world (pictures, whatever) I’m big on sharing.

Also, since I’m a firm believer in sharing, if you have questions or comments, please ask them through comments in this blog, (below) instead of trying to email or call me directly… you’ll find you’ll be waiting a verrrrrry long time for an answer. =)

Cheers,
//D

[/callout]

Insider info
To hopefully save you some time, I’ll let you in on the trick that FINALLY got this door to work with the light levels, debouncing the switches and *the chickens*. (as you’ll see in the code)

Check the light levels every 10 minutes to avoid the readings bouncing back and forth between dark/twilight/light during those dawn/dusk minutes. Then, when “dark” is reached (for me i chose >= 0 && <= 3 based on when my chickens actually went & stayed in the coop) enable motor dir down > debounce the switches > stop. Then do the opposite for morning. I’m sure there are different, maybe more efficient methods, but this code has been running flawlessly for a while now and I’m feeling confident enough to go out at night without worrying about predators. Although I still somehow find a reason to check the ChickenCam from time to time. (currently waiting for my new servo motors and night vision web cam to arrive in the mail)[callout font_size=”13px” style=”limegreen”]

Code updated 02/06/15

[/callout]

Click here for the clean .ino file (zipped up)

 

/*
* Copyright 2015, David Naves (https://daveworks.net, https://davenaves.com)
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 3
* of the License, or (at your option) any later version.
* 
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
* 
* You should have received a copy of the GNU General Public License
* along with this program; if not,  write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 
* 02110-1301, USA. 

*/

 /*
* I'm hoping that if you use/modify this code, you will share your
* coop project with me and the world (pictures, whatever)
* I'm big on sharing.
* Cheers,
* //D
*/



// libraries


#include                          // load the onewire library for thermometer
#include                    // load the liquid crystal library



// print debug messages or not to serial
const boolean SerialDisplay = true;




// pins assignments

// temperature chip i/o
const int photocellPin = A0;                 // photocell connected to analog 0
const int enableCoopDoorMotorB = 7;          // enable motor b - pin 7
const int directionCloseCoopDoorMotorB = 8;  // direction close motor b - pin 8
const int directionOpenCoopDoorMotorB = 9;   // direction open motor b - pin 9
const int bottomSwitchPin = 26;              // bottom switch is connected to pin 26
const int topSwitchPin = 27;                 // top switch is connected to pin 27
const int coopDoorOpenLed = 40;              // led set to digital pin 40
const int coopDoorClosedLed = 41;            // led set to digital pin 41



// variables



// photocell
int photocellReading;                            // analog reading of the photocel
int photocellReadingLevel;                       // photocel reading levels (dark, twilight, light)

// reed switches top and bottom of coop door

// top switch

int topSwitchPinVal;                   // top switch var for reading the pin status
int topSwitchPinVal2;                  // top switch var for reading the pin delay/debounce status
int topSwitchState;                    // top switch var for to hold the switch state

// bottom switch

int bottomSwitchPinVal;                // bottom switch var for reading the pin status
int bottomSwitchPinVal2;               // bottom switch var for reading the pin delay/debounce status
int bottomSwitchState;                 // bottom switch var for to hold the switch state



// photocell reading delay
unsigned long lastPhotocellReadingTime = 0;
unsigned long photocellReadingDelay = 600000;   // 10 minutes

// debounce delay
unsigned long lastDebounceTime = 0;
unsigned long debounceDelay = 100;





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

void setup(void) {

  Serial.begin(9600); // initialize serial port hardware


  // welcome message
  if (SerialDisplay) {
    Serial.println(" Processes running:");
    Serial.println(" Timer doReadPhotoCell every 10 minutes - light levels: open or close door");
  }
 

  // coop door

  // coop door motor
  pinMode (enableCoopDoorMotorB, OUTPUT);           // enable motor pin = output
  pinMode (directionCloseCoopDoorMotorB, OUTPUT);   // motor close direction pin = output
  pinMode (directionOpenCoopDoorMotorB, OUTPUT);    // motor open direction pin = output

  // coop door leds
  pinMode (coopDoorOpenLed, OUTPUT);                // enable coopDoorOpenLed = output
  pinMode (coopDoorClosedLed, OUTPUT);              // enable coopDoorClosedLed = output
  digitalWrite(coopDoorClosedLed, LOW);

  // coop door switches
  // bottom switch
  pinMode(bottomSwitchPin, INPUT);                  // set bottom switch pin as input
  digitalWrite(bottomSwitchPin, HIGH);              // activate bottom switch resistor

  // top switch
  pinMode(topSwitchPin, INPUT);                     // set top switch pin as input
  digitalWrite(topSwitchPin, HIGH);                 // activate top switch resistor



}

// ************************************** functions **************************************



// operate the coop door

// photocel to read levels of exterior light

void doReadPhotoCell() { // function to be called repeatedly - per coopPhotoCellTimer set in setup

  photocellReading = analogRead(photocellPin);

  if ((unsigned long)(millis() - lastPhotocellReadingTime) >= photocellReadingDelay) {
    lastPhotocellReadingTime = millis();

    //  set photocel threshholds
    if (photocellReading >= 0 && photocellReading <= 3) { photocellReadingLevel = '1'; if (SerialDisplay) { Serial.println(" Photocel Reading Level:"); Serial.println(" - Dark"); } } else if (photocellReading >= 4 && photocellReading <= 120) { photocellReadingLevel = '2'; if (SerialDisplay) { Serial.println(" Photocel Reading Level:"); Serial.println(" - Twilight"); } } else if (photocellReading >= 125 ) {
      photocellReadingLevel = '3';
      if (SerialDisplay) {
        Serial.println(" Photocel Reading Level:");
        Serial.println(" - Light");
      }
    }
    if (SerialDisplay) {
      Serial.println(" Photocel Analog Reading = ");
      Serial.println(photocellReading);
    }
  }
}

//debounce bottom reed switch

void debounceBottomReedSwitch() {

  //debounce bottom reed switch
  bottomSwitchPinVal = digitalRead(bottomSwitchPin);       // read input value and store it in val

  if ((unsigned long)(millis() - lastDebounceTime) > debounceDelay) {    // delay 10ms for consistent readings

    bottomSwitchPinVal2 = digitalRead(bottomSwitchPin);    // read input value again to check or bounce

    if (bottomSwitchPinVal == bottomSwitchPinVal2) {       // make sure we have 2 consistant readings
      if (bottomSwitchPinVal != bottomSwitchState) {       // the switch state has changed!
        bottomSwitchState = bottomSwitchPinVal;
      }
      if (SerialDisplay) {
        Serial.print (" Bottom Switch Value: ");           // display "Bottom Switch Value:"
        Serial.println(digitalRead(bottomSwitchPin));      // display current value of bottom switch;
      }
    }
  }
}



// debounce top reed switch
void debounceTopReedSwitch() {

  topSwitchPinVal = digitalRead(topSwitchPin);             // read input value and store it in val

  if ((unsigned long)(millis() - lastDebounceTime) > debounceDelay) {     // delay 10ms for consistent readings

    topSwitchPinVal2 = digitalRead(topSwitchPin);          // read input value again to check or bounce

    if (topSwitchPinVal == topSwitchPinVal2) {             // make sure we have 2 consistant readings
      if (topSwitchPinVal != topSwitchState) {             // the button state has changed!
        topSwitchState = topSwitchPinVal;
      }
      if (SerialDisplay) {
        Serial.print (" Top Switch Value: ");              // display "Bottom Switch Value:"
        Serial.println(digitalRead(topSwitchPin));         // display current value of bottom switch;
      }
    }
  }
}


// stop the coop door motor
void stopCoopDoorMotorB() {
  digitalWrite (directionCloseCoopDoorMotorB, LOW);      // turn off motor close direction
  digitalWrite (directionOpenCoopDoorMotorB, LOW);       // turn on motor open direction
  analogWrite (enableCoopDoorMotorB, 0);                 // enable motor, 0 speed
}



// close the coop door motor (motor dir close = clockwise)
void closeCoopDoorMotorB() {
  digitalWrite (directionCloseCoopDoorMotorB, HIGH);     // turn on motor close direction
  digitalWrite (directionOpenCoopDoorMotorB, LOW);       // turn off motor open direction
  analogWrite (enableCoopDoorMotorB, 255);               // enable motor, full speed
  if (bottomSwitchPinVal == 0) {                         // if bottom reed switch circuit is closed
    stopCoopDoorMotorB();
    if (SerialDisplay) {
      Serial.println(" Coop Door Closed - no danger");
    }
  }
}



// open the coop door (motor dir open = counter-clockwise)
void openCoopDoorMotorB() {
  digitalWrite(directionCloseCoopDoorMotorB, LOW);       // turn off motor close direction
  digitalWrite(directionOpenCoopDoorMotorB, HIGH);       // turn on motor open direction
  analogWrite(enableCoopDoorMotorB, 255);                // enable motor, full speed
  if (topSwitchPinVal == 0) {                            // if top reed switch circuit is closed
    stopCoopDoorMotorB();
    if (SerialDisplay) {
      Serial.println(" Coop Door open - danger!");
    }
  }
}





// do the coop door
void doCoopDoor() {
  if (photocellReadingLevel  == '1') {              // if it's dark
    if (photocellReadingLevel != '2') {             // if it's not twilight
      if (photocellReadingLevel != '3') {           // if it's not light
        debounceTopReedSwitch();                    // read and debounce the switches
        debounceBottomReedSwitch();
        closeCoopDoorMotorB();                      // close the door
      }
    }
  }
  if (photocellReadingLevel  == '3') {              // if it's light
    if (photocellReadingLevel != '2') {             // if it's not twilight
      if (photocellReadingLevel != '1') {           // if it's not dark
        debounceTopReedSwitch();                    // read and debounce the switches
        debounceBottomReedSwitch();
        openCoopDoorMotorB();                       // Open the door
      }
    }
  }
}



// ************************************** the loop **************************************

void loop() {
  
  doReadPhotoCell();
  doCoopDoor();

}

Click here for the clean .ino file (zipped up)

Lessons Learned

What I’ve learned about the door, Arduino, light and construction:

  • Best to check the light levels every 10 minutes to avoid the readings bouncing back and forth between dark/twilight/light during those dawn/dusk minutes
  • Test your door with your chickens to see if any of them like to hang outside after hours
  • Testing the actual light values outside is very important (many variables involved: light from neighbor’s house, clouds, internal/external coop lights etc.)
  • Debouncing of your switches within your Arduino code is important (door will jump around and fail as electronic readings vary greatly by the millisecond)
  • Reach out for help on the Arduino Forums before pulling out your hair. (be nice, do your homework and ask very specific questions)
  • I changed from micro-switches to reed switches (magnets) because I didn’t want the mechanics of the micro-switches to fail over time AND because chickens are very messy, kicking up shavings and sawdust, which might get caught in the mechanic, thereby preventing electrical contact.

What I’ve learned about the chickens:

  • Keeping on a light within the coop can keep chickens outside longer (I think b/c the ambient light shines outside) And that’s important when it comes to automating this door, so they won’t get accidentally locked out.
  • They can jump and fly (high and far)
  • They love to roost in safety at night, but want nothing more than to get OUT as soon as it’s light out