Introduction

In this part of the project we’re going to be performing the third step of what will eventually be the OwlBot. The OwlBot will be a device that can be used as a bird intimidation tool to scare away pesky birds in the yard, around the house or barn, at restaurants, or in trees, bushes, and gardens. Hence, the phrase, “The Bird Intimidator”.

The OwlBot (a.k.a. “The Bird Intimidator”) we’ll be making will be done in several parts. The OwlBot is an ambitious project. When complete, the OwlBot will sense motion. When motion is detected, the OwlBot should make owl sounds, perform varying movements, and flash its red eyes to intimidate and scare away pests. To put together all these tasks in one page would be too long and cumbersome, so we’ve decided to split each process we want the OwlBot to do into easy to accomplish chunks or parts as we continue on our goal to complete the OwlBot.

This is Part 3

This is part three. This third part of the OwlBot project will involve setting up its ability to have flashing red LED eyes when motion has been detected via the passive infrared sensor (PIR) we set up with our Arduino Uno in Part 1 of this OwlBot project series. While the LEDs flash, the owl sounds play from the MP3 player and dual speakers we added to our OwlBot prototype in Part 2 of this project series.

Our goal at the end of this part of the project will be to have the Arduino Uno tell the MP3 player to play owl sounds from an MP3 file to the speakers and to flash two red LEDs when motion is detected by the PIR sensor. Again, we’ll use the serial port on the Arduino IDE to print out whether or not motion is detected.

Goal of Part 3 of the OwlBot Project

A motionless, plastic great horned owl deterrent with a staring gaze might not do much over time. For the OwlBot to be effective enough to deter birds from nesting in an area throughout the year requires lifelike actions, like sound and movement. Our goal for Part 1 of the OwlBot project was to first get it to detect motion:

• Motion Sensing: When the OwlBot is complete, we want it to be able to sense motion of a bird or other creatures, and when it does to start making owl hooting sounds. We also want it to perform various movements, as well as flash its red eyes as an added effect to help deter pesky animals in the surrounding area. We’ll end up having all these actions done in sync when motion is detected, and we’ll use an HC-SR501 PIR sensor to get the OwlBot to detect motion.

Our goal for Part 2 of the OwlBot project was to get it to play owl sounds when motion is detected by the PIR sensor:

• Sound: We want the OwlBot to make owl sounds to notify any birds around that there’s an owl in the vicinity and that they should get the heck outta dodge. This purpose is to deter the birds from nesting close by. We’ll be using the DFRobot DFPlayer Pro Mini MP3 Player to store an audio file of owl sounds to be played. We don’t want the OwlBot to be hooting non-stop all day and night though, so we’ll use the PIR sensor to help the OwlBot sense when a bird has come near it. When a bird comes within the OwlBot’s field-of-view, then it can start making its owl calls. Of course, the OwlBot will not quite be smart enough to distinguish between a human passing by or a bird, but it’ll work fine, so we’ll just ignore those details, for now.

Now, our goal for Part 3 is to add two red LEDs to our prototype to act as the OwlBot’s eyes. When motion is detected by the PIR sensor, the owl sounds should play from the file on the MP3 player we added from Part 2 of this project, and also flash the two red LED eyes at the same time:

• Flashing LEDs: We want the OwlBot to have a pair of flashing red LED eyes to add another characteristic to it to assist in its ability to intimidate pesky creatures within its vicinity. Not only will these flashing red LED eyes have a purpose for scaring away birds, squirrels, cats, and the like, but it should also make it look cool too 😎.

Flat Top Clear Lens Red LEDs

In order to add some animation to the OwlBot’s eyes, we’ll use a couple of red LEDs that we’ll have the Arduino to flash when motion is detected by the PIR sensor we added to the prototype back in Part 1 of this project.

I’ve chosen a flat top, clear lens, red LED variety. I chose this type LED because I didn’t want to have the typical round domed red colored LEDs sticking out like two sore thumbs next to the OwlBot’s eyes when installed on its face later on in the finished project. You can have a look at what the owl looks like here. Having a couple clear lens LEDs that are flat head would look nicer, in my opinion. You can choose whatever LEDs are available to you or that you like best.

Let’s Be Methodical

I like to be very methodical about things, so we’ll go step-by-step — in detail — on the entire build of this project: the parts we’ll need, why we’re using them, how to connect them, how they work, and more! First, we’ll start with the following parts list:

Parts List

(This parts list is a continuation of the previous parts lists from Parts 1 and 2, of the OwlBot project.)

Tools Used in Project

Prototyping the Circuit

Previously, for Part 2 of the OwlBot prototype we successfully made all the connections needed for the Arduino Uno and DFPlayer Pro Mini MP3 Player, and created the code to play owl sounds when motion was detected by the PIR sensor. Now we need to add to this prototype the red LEDs that will act as the OwlBot’s spooky eyes. We also need to update the code and add to it the functionality we need to get the LEDs to flash when motion is detected by the PIR sensor.

Again, like I mentioned in the previous parts of this build, I will be using The Ultimate DIY 3220-Point Breadboard that was made from a separate project. I may refer to The Ultimate DIY 3220-Point Breadboard as “TUDIY” throughout this project to save me from having to say it every time.

DON’T WORRY! Even though I’ll be discussing how to make connections on TUDIY throughout the following prototyping steps, I’ll provide images of how to hook up items on a generic breadboard, so you can still follow along!

The Ultimate DIY 3220-Point Breadboard (TUDIY)

Adding the LEDs to the Prototype

Step 1 – Placing the LEDs Onto the Breadboard

LED #1

Take an LED and place the cathode (-) lead into a point on the negative rail of the negative supply of the Arduino we established on the breadboard of the Setting up 5V Power from the Arduino section in Part 1 of the OwlBot project.

Next, place the anode (+) lead of the LED into a point on the breadboard that isn’t inline with anything else. In my case, I’ve placed the first LED onto the breadboard with its anode at point a15 and its cathode in a point on the negative supply of the Arduino’s 5V supply that was established on the breadboard in Part 1.

LED #2

Now, take the second LED and place the cathode (-) lead into a point on the negative rail of the negative supply of the Arduino we established on the breadboard of the Setting up 5V Power from the Arduino section in Part 1 of the OwlBot project.

Next, place the anode (+) lead of the second LED into a point on the breadboard that isn’t inline with anything else. In my case, I’ve placed the second LED onto the breadboard with its anode at point a19 and its cathode in a point on the negative supply of the Arduino’s 5V supply that was established on the breadboard in Part 1.

Step 2 – Adding the Current Limiting Resistors

Now that we have the LEDs in place on the breadboard, it’s time to install the current limiting resistors. We’re going to use a 680Ω resistor as a current limiting resistor for each red LED.

Resistor #1

Take one of your resistors and place one of its leads at a point inline with the first LED we installed. In my case, I placed one of the leads of a 680Ω resistor at point c15, inline with LED #1, from Step 1, above.

Next, place the other lead of the resistor into a point across the point separator/divider (grooved gap) of the breadboard, as shown in the image below. In my case, I’ve placed the other lead of the resistor into point f15, on the breadboard.

Resistor #2

Take another 680Ω resistor and place one of its leads at a point inline with the second LED we installed. In my case, I placed one of the leads of the resistor at point c19, inline with LED #2, from Step 1, above.

Next, place the other lead of the resistor into a point across the point separator/divider (grooved gap) of the breadboard, as shown in the image below. In my case, I’ve placed the other lead of the resistor into point f19, on the breadboard.

Step 3 – Making the Connections to the Arduino

At this point, we have gotten the LEDs in place and we’ve connected their current limiting resistors. Next, we just need to make the final connections to the Arduino. I’ve grabbed two orange male-to-male jumper wires to complete the connection from each of the LEDs, their current limiting resistors, and to the Arduino.

Take one of the orange jumper wires and place one end of it into a point inline with the first LED and resistor. In my case, I placed one end of an orange jumper wire at point j15. Next, place the other end of the orange jumper wire into pin 4 of the Arduino.

Now, take the other orange jumper wire and place one end of it into a point inline with the second LED and resistor. In my case, I placed one end of the orange jumper wire at point j19. Next, place the other end of the orange jumper wire into pin 5 of the Arduino.

That’s it for our connections! Next, we just need to add to our code from Part 2 of the OwlBot project the functionality of blinking the red LEDs when motion is detected by the PIR sensor.

Programming the Arduino to Flash the LEDs

Now that we’ve made our connections for the LEDs and resistors to the Arduino, we’re ready to set up the OwlBot for blinking red eyes in the code. We’ll add the functionality of blinking the red LEDs when motion is detected by the PIR sensor into our code from Part 2 of the OwlBot project.

All we’ll do to make the LED eyes blink is to create a new function in the code that we’ll call when motion is detected by the PIR sensor we added to our prototype in Part 1 of the OwlBot project. This new function we’ll create in the code will have a couple of for loops within it that will enable us to have both LEDs blink, in sync, for approximately 10 seconds, then stop, and the following code should stop the other functions we’ve implemented, such as sound.

In keeping full transparency, I used the help of some fantastic people who have offered their knowledge of Arduino and some of the modules we’ve used freely on the internet, and will be referencing those sources as we continue with this project. As the program evolves, any sources used will be added into the Arduino code comments. It is encouraged that you go check out any person mentioned for yourself.

The following is the code we’ll write for the Arduino Uno to accomplish the tasks needed for our OwlBot prototype, so far:

/* ------------------------------------------------------------------------------
 * Project: OwlBot: The Bird Intimidator - Part 3: Flashing Red LED Eyes
 * Written by: Dustin Hodges (Motbots)
 * Date Created: 10/11/2024
 * Date Last Modified: 12/29/2024
 * Description: This is part three of the OwlBot project and its prototype process. Here, we
 * are adding to our code from Part 2 of the build the functionality of flashing red LED eyes.
 * Our new goal in the code is to have the LEDs we've installed onto our prototype to flash
 * every time motion is detected by the PIR sensor we installed in Part 1 of the build of
 * the OwlBot prototype.
 *
 * Microcontroller Board: Arduino Uno R3
 * IDE Version: Arduino IDE 2.3.4
 * Modules Used: HC-SR501 PIR sensor, DFRobot DFPlayer Pro Mini MP3 Player
 * Components Used: 2x Flat Top Clear Lens Red LEDs
 *
 * ------------------------------- REFERENCES -----------------------------------
 * DFPlayer Pro Reference 1: Toms Trains and Things (YouTube): “How I Setup & Program DFPlayer
 * Pro With Arduino Uno”
 *
 * DFPlayer Pro Reference 2: ModelSceneryTutorials (YouTube): “DFPlayer Pro Voice Prompt Removal:
 * A Comprehensive Tutorial To Unlocking the Full Potential”
 *
 * DFPlayer Mini Reference 1: Rachel De Barros (YouTube): "Motion-activated Sound Effects with
 * Arduino, PIR Sensor & MP3 Player"
 *
 * DFPlayer Mini Reference 2: The Last Outpost Workshop (YouTube): “Sound problems with the
 * MP3-TF-16p DFPlayer Mini?”
 * ------------------------------------------------------------------------------
 */

#include <DFRobot_DF1201S.h> // The DFRobot_DF1201S library for the DFPlayer Pro Mini MP3 Player
#include <SoftwareSerial.h>  // The SoftwareSerial library allows serial communication on
                             // other digital pins of an Arduino board.

/* The follwing is the initial setup of variables for the HC-SR051 PIR sensor. */
const int PIR = 12;          // Signal pin from PIR sensor to pin 12 on Arduino
const int RX = 3;            // This is what we'll designate as the RX pin on the Arduino (not the DF0768's RX pin)
const int TX = 2;            // This is what we'll designate as the TX pin on the Arduino (not the DF0768's TX pin)
int motionStatus = LOW;      // Current motion status or signal pin reading (0 = LOW, 1 = HIGH). Initially set to 0 or LOW.
int pirState = LOW;          // The state of the PIR signal pin (HIGH/LOW). Initially set to LOW.

SoftwareSerial soundFxSerial(RX, TX);   // Creating an object for our sound effects serial, saying which pins to use
                                        // for receiving (RX) and transmission (TX).
                                        // The SoftwareSerial is used to communicate with the DFPlayer Pro module.
DFRobot_DF1201S soundFxPlayer;          // We'll use this object when referring to the sound effects player (MP3 player).

/* The following is the initial setup of the variables for the OwlBot's blinking LED eyes. */
const int LEFT_EYE = 4;    // Red LED pin 4, for the owl's left eye (arbitrary).
const int RIGHT_EYE = 5;   // Red LED pin 5, for the owl's right eye (arbitrary).

/* The setup function does all the initial setting up of everything we need. When code is
 compiled and ran, the setup function is only entered into during processing once. */                                    
void setup() {
    // Pin modes
    pinMode(PIR, INPUT);        // Pin 12 on Arduino (signal line from PIR) is set as an input pin.
    pinMode(RX, INPUT);         // Our receiving pin for the Arduino needs to be an input.
    pinMode(TX, OUTPUT);        // Our transmission pin for the Arduino needs to be an output.
    pinMode(LEFT_EYE, OUTPUT);  // Make pin for left eye of owl (red LED pin 4) an output.
    pinMode(RIGHT_EYE, OUTPUT); // Make pin for right eye of owl (red LED pin 5) an output.

    // Initially turn off both eyes
    digitalWrite(LEFT_EYE, LOW);
    digitalWrite(RIGHT_EYE, LOW);
    
    // Serial setup
    Serial.begin(115200);               // Want to be able to use Serial Monitor for debugging purposes.
    soundFxSerial.begin(115200);        // Setting up the serial for the sound effects serial.
    soundFxPlayer.begin(soundFxSerial); // Telling the sound effects player to use the sound effects serial.

    // Player setup
    soundFxPlayer.setVol(30);                           // Set volume for the sound effects player.
    soundFxPlayer.switchFunction(soundFxPlayer.MUSIC);  // Enter music mode.
    soundFxPlayer.setPrompt(false);                     // Silence voice prompt at start.
    delay(2000);                                        // Delay for two seconds to allow everything to calibrate before proceeding.
    soundFxPlayer.setPlayMode(soundFxPlayer.ALLCYCLE);  // Set playback mode to "repeat all"
}

/* The loop function is an infinite loop, meaning once the code is compiled and ran, the
 processes of the code will continually run what's within the loop, until the processes are
 stopped, either within the code, or by the user, or by some other act of God. */
void loop() {
    motionStatus = digitalRead(PIR);  // Get the motion status from pin 12 (Is the signal HIGH or LOW?)
    
    /* If there's motion detected by the PIR sensor, do what's inside the loop. */
    if(motionStatus == HIGH) {
        // If the pirState is LOW (it's initially set to LOW)
        if(pirState == LOW) {
            Serial.println("Motion has been detected!");  // Print message to serial monitor.
            /* Going to need to change the pirState to HIGH, since motion has been detected. */
            pirState = HIGH;

            if(!soundFxPlayer.isPlaying()) {  // If the owl FX not playing...
              playOwl();                      // Play the owl MP3 audio.
            }
        }
    }
    /* Else, if no motion has been detected by the PIR sensor, do what's inside here: */
    else {
        // If the pirState is HIGH
        if(pirState == HIGH) {
            Serial.println("No motion detected.");        // Print message to serial monitor.
            /* Going to need to change the pirState to LOW, since no motion has been detected. */
            pirState = LOW;

            if(soundFxPlayer.isPlaying()) { // If the owl FX is still playing...
              pauseOwl();                   // Make absolute sure we pause the owl.
            }
        }
    }
}

/* The playOwl() function is called when we want to play the owl MP3 file to make owl sounds. */
void playOwl() {
  uint16_t fileNum = soundFxPlayer.getCurFileNumber();  // Getting the current file number in our MP3
                                                        // player and setting it to the variable 'fileNum'.
  soundFxPlayer.playFileNum(1);   // Play file #1, the numbers are arranged according to the sequence
                                  // of the files copied into the U-disk.
  soundFxPlayer.setPlayTime(0);   // Starts the file 0 seconds in (or at the very beginning).
  soundFxPlayer.start();          // Start playing sound FX.
  blinkEyes();                    // Blink the owl's spooky eyes.
  delay(250);                     // Wait 250 milliseconds (1/4 second)
  pauseOwl();                     // Pause the owl's FX as soon as we're done playing the FX.
}

/* The pauseOwl() function is called when we need to pause the audio playing from the MP3 file. */
void pauseOwl() {
  soundFxPlayer.pause();          // Pause the sound FX player.
}

/* The blinkEyes() function blinks the OwlBot's red LED eyes at a rapid pace for approximately 10 seconds. */
void blinkEyes() {
  delay(250);                     // Wait 250 milliseconds (1/4 second)

  for(int i = 0; i < 10; i++) {   // Do this loop ten times.
    for(int j = 4; j > 0; j--) {  // Do this loop four times.

      digitalWrite(LEFT_EYE, HIGH);   // Turn left eye on.
      digitalWrite(RIGHT_EYE, HIGH);  // Turn right eye on.
      delay(125);                     // Wait 125 milliseconds (1/8 second)

      digitalWrite(LEFT_EYE, LOW);    // Turn left eye off.
      digitalWrite(RIGHT_EYE, LOW);   // Turn right eye off.
      delay(125);                     // Wait 125 milliseconds (1/8 second)
    }
  }
}

The Code Explained

For this part, I will only go over the code we’ve added here for Part 3 of the OwlBot prototype build. If you need an explanation of the other parts of the code which we did in Part 2 of the prototyping process, please visit our page How to Make an OwlBot: The Bird Intimidator – Part 2: Making Sounds.

Referring to the code above, let’s walk through it line-by-line, to understand what’s going on:

Creating and Initializing the Variables

const int LEFT_EYE = 4;    // Red LED pin 4, for owl's left eye (arbitrary).

The LEFT_EYE variable is what we’ll designate as the “left eye” of the OwlBot. Here, we’ve initialized the variable to be equal to 4, which means that we want pin 4 of the Arduino to represent one of the red LEDs and its current limiting resistor we connected to it, i.e. the OwlBot’s left red LED eye.

const int RIGHT_EYE = 5;   // Red LED pin 5, for owl's right eye (arbitrary).

The RIGHT_EYE variable is what we’ll designate as the “right eye” of the OwlBot. Here, we’ve initialized the variable to be equal to 5, which means that we want pin 5 of the Arduino to represent one of the red LEDs and its current limiting resistor we connected to it, i.e. the OwlBot’s right red LED eye.

Pin Modes

In the setup, we’ll initialize the pin modes for each of the pins we’re using on the Arduino Uno for each of the LEDs we added to the prototype:

pinMode(LEFT_EYE, OUTPUT);  // Make pin for left eye of owl (red LED pin 4) an output.
pinMode(RIGHT_EYE, OUTPUT); // Make pin for right eye of owl (red LED pin 5) an output.

Here, we’ve set the LEFT_EYE and RIGHT_EYE variables we created to both be OUTPUTs, since we’ll be sending out HIGH and LOW signals to the LEDs from the Arduino through our code later.

Digital Write

// Initially turn off both eyes
digitalWrite(LEFT_EYE, LOW);
digitalWrite(RIGHT_EYE, LOW);

Still within the setup, we initially want both of the LEDs to be off when we turn the power on to the OwlBot. To do this, we use the digitalWrite() function, passing the LEFT_EYE and RIGHT_EYE variables as the initial argument in each, followed by the argument LOW, which provides 0V initially to pins 4 and 5 of the Arduino.

Inside the playOwl() Function

blinkEyes();                    // Blink the owl's spooky eyes.

Inside the playOwl() function we created in Part 2 of the OwlBot prototype build, we see that there’s a call to a new function called blinkEyes(), a function we create here in Part 3, as explained below.

The blinkEyes() Function

The blinkEyes() function is a function we create ourselves to control the process of blinking or flashing the red LEDs we added to our OwlBot prototype. This function contains a pair of for loops, one inside another, that allows us to create the illusion of the OwlBot having red blinking eyes.

/* The blinkEyes() function blinks the OwlBot's red LED eyes at a rapid pace for approximately 10 seconds. */
void blinkEyes() {
  delay(250);                     // Wait 250 milliseconds (1/4 second)

  for(int i = 0; i < 10; i++) {   // Do this loop ten times.
    for(int j = 4; j > 0; j--) {  // Do this loop four times.

      digitalWrite(LEFT_EYE, HIGH);   // Turn left eye on.
      digitalWrite(RIGHT_EYE, HIGH);  // Turn right eye on.
      delay(125);                     // Wait 125 milliseconds (1/8 second)

      digitalWrite(LEFT_EYE, LOW);    // Turn left eye off.
      digitalWrite(RIGHT_EYE, LOW);   // Turn right eye off.
      delay(125);                     // Wait 125 milliseconds (1/8 second)
    }
  }
}

This function is called from the playOwl() function. When motion is detected by the PIR sensor, the code is told to play the owl sounds stored on an MP3 file from the MP3 player we installed on the breadboard prototype of the OwlBot from Part 2 of this build. After a call is made to play the sounds, a call to the blinkEyes() function is made, where the code is told to turn the LEDs on and off at a fairly rapid pace, giving the effect of flashing LEDs. Hence, our OwlBot’s flashing red LED eyes.

Compiling and Uploading the Code to Arduino

Now, that we’ve gone over the program we’re going to use to get the Arduino to flash the LEDs, you can either tediously write the code yourself, or just copy-and-paste it into your file on the Arduino IDE. I’ve named my file owlbot_part-3.ino. You can name yours whatever you want.

If you need or want to see the process of copying and pasting the code into the Arduino IDE, connecting the Arduino to a computer, choosing the board and port under tools in the IDE, verifying code, and fixing code errors, then check out Part 1 of this OwlBot project here, because these processes are similar for Part 3.

Testing What We’ve Done

At this point, you have your prototype for step three of this project complete and you have completed writing your code for this step of the prototyping process. You’ve also copied the code, verified it, and fixed what errors you may have had after doing so. You’ve then compiled and uploaded the code to the Arduino Uno to see if what you’ve done so far even works! Here are the steps again, to test what you’ve done up to this point in the project:

1. Add the LEDs and their current limiting resistors to the prototype of the OwlBot project.
2. Create the code you’ll use for the Arduino Uno in the Arduino IDE.
3. Verify the code and fix any errors.
4. Compile and Upload the code to the Arduino Uno using the provided USB cable that came with your Arduino.
5. Leave the Arduino connected to your computer once you’re done compiling and uploading the code to the Arduino, start waving your hand in front of the PIR sensor. Once motion is detected, the MP3 player should start playing the owl sounds audio to the speakers and the red LEDs should start flashing.

Once you’ve compiled and uploaded your code to the Arduino, and have started waving your hand in front of the PIR sensor, you should start hearing the owl sounds playing from the MP3 player to the speakers and seeing the two red LEDs you’ve added to the prototype flashing. You should also be seeing the printouts on the serial monitor telling you whether motion is detected or is not detected.

If everything is working as it should, then congratulations! You’ve successfully completed the third step of the OwlBot prototype. Check out the video below to see the full prototyping process, as well as to see this part of the project working!

In step 4 of the OwlBot project, we’re going to be adding a couple of solenoids to our circuitry, that we’ll use to move the wings we’ll make for the OwlBot later on in the build series. We’ll also add a DC motor with a propeller on its shaft for added movement for the OwlBot. When motion is detected we’ll be able to hear owl hooting sounds, see flashing red LEDs, and have our first moving parts via the solenoids and DC motor that we’ll add later! So, stick around for more!

Video Build of the OwlBot: Part 3 – Flashing Red LED Eyes

VIDEO FOR PART 3 COMING SOON!

Overview

This has been Part 3 of the build for the OwlBot project. In Part 1, we made connections for the PIR sensor and Arduino. In Part 2, we added the DFPlayer Pro Mini MP3 Player to our setup, and in Part 3, we’ve added a couple red LEDs to our prototype to act as the OwlBot’s eyes. We ended up adding the functionality within our code for the Arduino to flash those LEDs when motion is detected by the PIR sensor, to give the OwlBot the effect of having flashing red eyes.

So, at this point in the project, we’ve made it to where our OwlBot prototype can sense motion by the PIR sensor we installed in Part 1 of the build. The OwlBot can make owl sounds via the MP3 player we added to the prototype in Part 2 of the build, and now we’ve added the ability for the OwlBot to have flashing red LED eyes when motion is detected. It seems that our OwlBot is becoming more and more alive and animated the farther we go in this build!

What’s Next

Now that we have implemented motion sensing, sound, and flashing LEDs, the next step in prototyping the OwlBot will be to prototype the OwlBot’s varying forms of movement. We’ll do this using a pair of solenoids and a DC motor. We’ll add the solenoids and DC motor to our prototype circuit, and then add to our code for the Arduino to be able to control the solenoids and motor to be activated while the MP3 player plays owl sounds and the LEDs flash when motion is detected by the PIR sensor. All this will be in Part 4 of the OwlBot project!

“How to Make an OwlBot: The Bird Intimidator – Part 4: Moving Parts” will be the next step of this project. This part of the project is currently being developed. You may check back to this page here, to see when it’s complete and ready for you to continue, or you may signup for our newsletter below to receive updates on this project and others!

Thank you for participating in this project. We hope that you have enjoyed the build thus far. Let us know by giving a comment in the comments section below. Share the link to your friends and family. Let them know how much you’ve enjoyed the process of prototyping the OwlBot!

PART 4 COMING SOON!

Newsletter Signup Form

Please enable JavaScript in your browser to complete this form.

Name *

First

Last

Email Name

Email *

Submit