This semester, I am taking a course entitled “Tinkering, Hacking, and Making” as part of my Digital Studies minor. Throughout the semester, we will be undertaking a variety digital studies projects that we will document on our blogs.
After finishing up work on the Scratch project, we moved into projects that combine coding and engineering. For this project, we were given the option to work with either a Hummingbird or Arduino board. Then, using a self-created or pre-written code, we would program a device or machine that involved interactivity or physical movement, such as a robot.
The specific requirements for the project were:
- Select a Board: Choose either a Hummingbird or Arduino board
- Build and Program: An interactive machine/device/robot built around the board, using any available language
- The Machine Should: Be interactive – sensors must respond to the environment (changes in temperature, light, motion) and react in some manner that includes movement, sound, lights.
- Build the Machine: Use the available recycled or new building materials and tools
Hummingbird v. Arduino
The main difference between the Hummingbird and Arduino boards was in ease of use. The Hummingbird board is a simplified version of the Arduino board that is easier to work with for beginners or those unfamiliar with programming and engineering.
While easier to use, the downside of the Hummingbird board is that it is less powerful and must be plugged into a computer to be operable. Because this limits movement, it would be very difficult to create a robot that travels great distances using Hummingbird.
Nevertheless, I decided to use Hummingbird – specifically the Hummginbird Duo because it is the simpler platform to work with, and I wanted to ease myself into the project. With Hummingbird, I also knew that I could code directly in Scratch, a program that I have already used.
Deciding What To Make – With Help from the “Tutorials” Section
Once I chose a platform, I needed to decide what sort of machine I was going to make. Because Halloween is around the corner, many of my classmates are creating Halloween decorations – including ghosts that moan and rattle chains, or hands that emerge from a spooky box.
I decided to look at the “Tutorials” section of the Bird Brain Technologies website for inspiration. Once selecting my product, (a Hummingbird Duo) device, (Mac computer) and programming language, (Scratch) I was given a set of building options. What caught my eye was the “Little Bot,” a simple robot made from cardboard and hot glue whose head titlts and pivots.
Making the Little Bot – My First “Draft”
According to “Step 2” of the Little Bot tutorial, I would only need a few items to make my own robot. These included:
- Hummingbird Duo Controller (Which I found in a box in the classroom)
- Battery Pack or AC Plug (Also found in the classroom. If I was not using Servo motors, I could have gotten away without this one.)
- 2 Position Servos (Found in a box in the classroom)
- 1 Circular Servo Horn with Servo Screw (Found in a box in the classroom)
- 1 Additional Servo Horn (Found in a box in the classroom, I chose to use an “X” shape just like in the tutorial)
I also needed a few craft supplies, including a hot glue gun, scissors and/or a box cutter, a market, tape, a screwdriver, and cardboard. Thankfully, as our classroom is located in the Education suite, there was a bounty of cardboard available for me to craft with.
My “Little Bot” required two 3×3 cubes of cardboard, which I was able to cut from an old poster board in the classroom. I crudely applied duct tape to hold each cube together according to instructions. I was okay with the cubes being crude because I treated this project as a “first draft” that I could fix the look and construction of later. Finally, I cut a variety of holes in each cube to make space for the servo motors, cords, and eyes of the robot.
A Surprising Amount of Hot Glue
What surprised me most about making the robot was how the skills needed to “eningeer” the robot were so similar to what you might learn in elementary school, such as how to cut with scissors or a small blade, or how to use a hot glue gun. There was a lot of hot glue involved in this project – I even had to hot glue one servo motor on top of the other!
Finishing Little Bot
Finishing up my robot, I added a few eyes with Sharpie, as well as some small arms. He looks a little ridiculous, but I was pleasantly surprised with how cute he looked in just a few hours of work. I also manually tested his head to make sure that it could move around.
Despite having followed the instructions to create a 3x3x3 inch cube for his head, his head was a little bigger than I would have preferred, so I also made a note to reduce the size of his head if I made another Bot in the future.
Once I had the servos installed in my bot, I replaced the blacks of his eyes with two red LED lights. I attached these by inserting them into two small holes in his eyes and nesting the LEDs inside.
Connecting the LEDs to the Hummingbird Board itself was rather easy, as I simply had to attach two wires to the “LED” section of the board. The particular board that I am using could have accommodated two more standard LEDs, or two more trips-color LEDs.
Coding My Robot
After my first attempt at putting my robot together, I needed to write a simple code in order to get him moving. As I mentioned earlier, I would be using Scratch to do this. I have “Scratch 2” downloaded on my computer, as well as the BirdBrainServer, which connects the code to my machine when it is plugged in to my computer.
Movement and LED Eyes
The first part of my Little Bot that I coded was movement left and right, followed by setting each eye to blink on and off in correspondence with his movements.
These codes were rather easy, as I could follow along the Scratch tutorials almost exactly. My first “successful” code for my Little Bot was as follows:
- Begin program
- Little Bot moves right, right eye blinks on
- Little Bot recanters, right eye blinks off
- Little Bot moves left, left eye blinks on
And that was it – the program just continued on a loop. I was pretty pleased with this, but these movements did not satisfy the “Interactivity” portion of the assignment.
Digging Through the Sensor Box
Not married to any particular type of interactivity, I decided to get inspiration from where inspiration is best bred – a big plastic box of various sensors and buttons. At first, I wanted to use a light sensor to have my robot turn on and begin movement if it was dim – such as by covering the light sensor in ones hand as if giving the robot a “handshake.”
I played around with the light sensor for a little bit, until discovering something even more interesting. A joystick.
Tactically Satisfying Interactivity
The joystick that I came upon was still wrapped in a protective, static-free plastic. Upon opening the plastic, a distinct smell filled the air – one that I might liken to the way that Disney’s Spaceship Earth in EPCOT smells. Wanting to use the joystick, I decided to look back again at the Hummingbird tutorials to figure out if I could have my robot move left and right in accordance with my joystick movements. Seems easy, right?
After looking at these tutorials, I learned how to move a sprite on screen with the joystick, and how to move two separate motors with the joystick, but not how to use the joystick as an activation point that would control the two servos.
The problem with my code as it existed was that upon running the program was that there was no relationship between the movement of the joystick and the movement of the servos. Clicking “run” on my program simply ran a loop of robot eye and head movements, unrelated to whether or not I was touching the joystick.
To solve this problem, I had to separate the movements from the beginning of the program, and nest them within “if…then” statements directly related to the joystick.
The Code that Sort Of Solved the Problem
While I could not figure out how to set the joystick to move the robots head left and right, I was able to figure out how to use the joystick as a “right” switch. When pressed, the robot will move its head to the right and blink its right eye. When depressed, the robot will move its head to the left and blink its left eye. This continues indefinitely so long as the program is running.
The video above shows the movements that I’ve programmed my Little Bot to do, all of which meet the assigned project criteria.
Overall, I am very happy with my robot – especially as it was my first attempt at making a robot! In the future, I would be interested in making a robot with a more well put-together body, such as by using a 3D printer.