Build your own Minerva Owl Bot, powered by Crickit! Program her in CircuitPython to talk, look around, and flap her wings!

It doesn't take exotic materials to build your own audio-animatronic, just a few paper cups, craft supplies, a couple of servos, and a Circuit Playground Express with Crickit, battery pack, and a speaker!

Parts

Materials & Tools

To build this project you'll need:

• Paper cups, 4 ea.
• Hot glue and glue gun
• Pipe cleaners for decoration
• Popsicle stick, 1 ea.
• Yarn or string
• Scissors
• Colored markers or paint pens
• Optional stickers for facial features

For the Bonus Builds your also need:

• Cardboard
• Googly eyes
• Paper cups or plates
• Paper tubes
• Plastic decorative cogs
• Plastic pop rivets
• Makedo Scrus

Fabrication

Minerva's eye movement is based on a very creative technique I first was shown by Phil Torrone in his B.O.B. robot seen here, made entirely of recycled cups and containers:

The basic principle is that there are two cups, one inside the other. The outer cup is the head/face and has cutouts for eye sockets -- through which the inner cup can be seen. The inner cup has pupils, irises, and eye whites on it.

When the inner cup is rotated, instant eye movment! Here's a demonstration using two clear cups:

Build the Head

Make the Eyes

Micro Servo for Eye Movement

We'll connect the eye cup's servo horn to the head cup's servo shaft later, but first we'll build the owl's body.

Build the Body

Add Wings

Flapping Rig

Add Eyes

Your robot is built, but now let's add some decoration!

Decoration

First, we'll add a beak. You can draw on a triangle, or use a sticker, then cut out a proper beak from the light blue cup or paper as shown below.

You can even draw on some eyebrows or use stickers.

Don't forget about Minerva's stylish lightning bolt!

Popsicle Stick Legs

Pipe Cleaner Trim

Lashes

Our last bit of decoration will be eyelashes. We'll use a marker to draw these on.

You've completed building your robotic owl! Now it's time to wire things up to the Crickit robotics board!

Wire for Power and Sound

Plug the 3 AA battery pack into the 2.1mm DC power input on the Crickit.

Insert the two speaker wires into the two Speaker terminals on the Crickit. Either wire can go in either port, it is not polarized. Screw the terminals down into place.

Connect the Servos

Wire the micro servo that drives the eyes to the Servo 1 port on the Crickit board, and the full size servo that flaps the wings to the Servo 2 port. The yellow wire faces out, the dark wire faces towards the Circuit Playground Express.

Minerva is wired and ready for programming!

The program we'll use will do three primary things:

• play audio files
• rotate Servo 1 back and forth to move the eyes
• rotate Servo 2 back and forth to flap the wings

This is pretty straightforward in CircuitPython, especially because the Crickit and Circuit Playground Express combination is capable of playing back wave files while still doing other things!

First, we'll get everything set up, then we'll look at the code.

Setup the CPX and Crickit

The Circuit Playground Express (CPX) paired with the Crickit is a powerful, yet simple to use combination for building animatronics! To get started, you'll want to set up the CPX for use with CircuitPython by following this guide. When you're ready, and can upload code to the board return here.

To use the Crickit with the CPX, follow the steps listed here to install the special build of CircuitPython, as well as the latest library bundle.

Adafruit really likes using the Mu editor to edit the CircuitPython code. See this guide on loading and using Mu.

Playing Audio

The Circuit Playground Express plays back .wav files. If you would like to prepare your own files, follow the instructions in this guide. Download the following files and then uncompress the .zip file. Copy the .wav files to your CPX, which shows up as CPLAYBOOT on your computer.

Servo Eyes and Wings

To move the eyes and flap the wings, we'll send commands to the servo motors. Typical servos have a 180° range of motion, from 0° to 180° with 90° being the center position.

When our code starts we'll center both servos by telling them to go to 90°. Then, as each audio file is played back we'll send commands to the servos to swing back and forth between positions.

Here's the code. Download it and then save it to your CPX as code.py

# SPDX-FileCopyrightText: 2018 Kattni Rembor for Adafruit Industries
#
# SPDX-License-Identifier: MIT

import time
import board
import audioio
import audiocore
from adafruit_crickit import crickit

# Minerva Owl Robot

wavefiles = ["01.wav", "02.wav", "03.wav", "04.wav",
             "05.wav", "06.wav", "07.wav", "08.wav"]

# Two servos
eye_servo = crickit.servo_1
wing_servo = crickit.servo_2
# TowerPro servos like 500/2500 pulsewidths
eye_servo.set_pulse_width_range(min_pulse=500, max_pulse=2500)
wing_servo.set_pulse_width_range(min_pulse=500, max_pulse=2500)

# Servo angles
EYES_START = 90
EYES_LEFT = 110
EYES_RIGHT = 70
WINGS_START = 90
WINGS_END = 160

# Starting servo locations
eye_servo.angle = EYES_START
wing_servo.angle = WINGS_START

# Audio playback object and helper to play a full file
a = audioio.AudioOut(board.A0)


def play_file(wavfile):
    print("Playing", wavfile)
    with open(wavfile, "rb") as f:
        wav = audiocore.WaveFile(f)
        a.play(wav)
        while a.playing:  # turn servos, motors, etc. during playback
            eye_servo.angle = EYES_LEFT
            time.sleep(.25)
            eye_servo.angle = EYES_START
            time.sleep(.25)
            wing_servo.angle = WINGS_END
            time.sleep(.2)
            wing_servo.angle = WINGS_START
            time.sleep(.2)
            eye_servo.angle = EYES_RIGHT
            time.sleep(.25)
            eye_servo.angle = EYES_START
            time.sleep(.25)


while True:
    for i in range(8):
        play_file(wavefiles[i])
        time.sleep(2.5)

# SPDX-FileCopyrightText: 2018 Kattni Rembor for Adafruit Industries
#
# SPDX-License-Identifier: MIT

import time
import board
import audioio
import audiocore
from adafruit_crickit import crickit

# Minerva Owl Robot

wavefiles = ["01.wav", "02.wav", "03.wav", "04.wav",
             "05.wav", "06.wav", "07.wav", "08.wav"]

# Two servos
eye_servo = crickit.servo_1
wing_servo = crickit.servo_2
# TowerPro servos like 500/2500 pulsewidths
eye_servo.set_pulse_width_range(min_pulse=500, max_pulse=2500)
wing_servo.set_pulse_width_range(min_pulse=500, max_pulse=2500)

# Servo angles
EYES_START = 90
EYES_LEFT = 110
EYES_RIGHT = 70
WINGS_START = 90
WINGS_END = 160

# Starting servo locations
eye_servo.angle = EYES_START
wing_servo.angle = WINGS_START

# Audio playback object and helper to play a full file
a = audioio.AudioOut(board.A0)


def play_file(wavfile):
    print("Playing", wavfile)
    with open(wavfile, "rb") as f:
        wav = audiocore.WaveFile(f)
        a.play(wav)
        while a.playing:  # turn servos, motors, etc. during playback
            eye_servo.angle = EYES_LEFT
            time.sleep(.25)
            eye_servo.angle = EYES_START
            time.sleep(.25)
            wing_servo.angle = WINGS_END
            time.sleep(.2)
            wing_servo.angle = WINGS_START
            time.sleep(.2)
            eye_servo.angle = EYES_RIGHT
            time.sleep(.25)
            eye_servo.angle = EYES_START
            time.sleep(.25)


while True:
    for i in range(8):
        play_file(wavefiles[i])
        time.sleep(2.5)

Editing Your Code

If you'd like to make changes to the code at any time, Adafruit suggests using the Mu editor to edit your code and have an interactive REPL in CircuitPython on your computer (Mac, PC, Linux). You can learn about Mu and installation in this tutorial.

With your Crickit powered by the AA battery pack, its power switch in the ON position, and your code on the Circuit Playground Express, press the tiny CPX Reset button to begin. Minerva comes to life!

You can now try recording your own lines, changing the movement patterns and more, all in CircuitPython!

For the bonus tree and baby owl builds, continue on to the next page.

Owl Friends

If you've done any cardboard crafts at camp or in school, you may be familiar with this classic owl design! All it takes is a paper towel tube or toilet paper tube, some scissors or a hobby knife, googly eyes, and paint or markers!

Follow the images below and make your own!

Tree Time

You can also build a nice tree set for Minerva and friends! This one is made from some nice, thick 5-ply corrugated cardboard from a large shipping box.

Minerva has an affinity for cogs, so we'll decorate with plastic, gear-like "paddle wheels".

Poseable branches are joined to the trunk with Makedo Scrus.

You can make leaf clusters (also poseable) from paper cups and plastic pop rivets.

Have a look at these photos for inspiration!

Leaf Clusters

Branch Joints

Just Add Cogs!