Creepy Crawly High School

New robots shaping up

2012-02-19T05:37:00.000-08:00

I might almost have my students read this post from Mike Estee about Paper Robots, since it echos what we teach them about design and iteration and I'm trying to get them to make more complex designs. I also have always liked the idea of using foldable laser cut materials such as cardboard. However, $50 in servos is a bit steep, and I think a more pleasing mechanism (e.g. with strong locomotion) can be accomplished with fewer motors (see HEXBUG Spider with one servo and one motor). Criticizing a design is part of the design process.

Speaking of iterations, in our first iteration of teaching the unit in the fall, we had insects with either 1,2 or 3 legs on each of 2 sides. A good start, but this spring we are teaching it better and we have the following new shapes shaping up (pun intended):

a radially symmetric 6 legged creature (inspired by the HEXBUG Spider). I think we'll have to 3D print some of this one unless the students get really clever.
an 8-legged crab (4 layers of 2 legs each, inspired by the HEXBUG Crab)
a quadruped design with a 2-bar linkage that creates a hoof-like motion (inspired by the Star Wars AT-AT Walker)
a quadruped with a additional legs on the front and the back

I'm super excited to see the new designs emerge!

From Mike Estee's Paper Robots:

Project photos

2011-12-07T08:54:00.001-08:00

Here are some project photos

Cutting the centipede on the laser cutter

Constructing the centipede

The lion

Third computational project: sound sensor

2011-12-07T08:29:00.001-08:00

The third computational project uses an electret microphone as a sound sensor. When a loud sound is detected, the robot changes direction and toggles the red led.

The electret microphone is the Sparkfun electret microphone breakout with + attached via a 330 Ohm resistor to reduce the voltage (our batteries are 6v).

The sensor is calibrated to ambient sound levels when the program starts. The trimpot controls how loud the sound has to be.

I wanted the sound sensor to be able to detect a clap, but this did not work. However, with an appropriate trimpot setting, tapping on the sensor and blowing on the sensor worked well.

Here is the code (available in the Dropbox folder):

#include <pololu/orangutan.h>

/*

* knock: start with motors running forward and red led off.

* when sound heard, reverse motors and toggle led.

* pot controls sound trigger level

*/

#define DEBOUNCE 300

#define SUM_SAMPLES 10

#define NUM_SAMPLES 20

#define WAIT 10

int state = 0;

int trigger = 0;

int analog_read_sum(int id, int samples);

int main()

{

int maxCalib = 0;

int minCalib = 1023*SUM_SAMPLES;

int sumCalib = 0;

for(int i = 0; i < NUM_SAMPLES; i++) {

int sound = analog_read_sum(6, SUM_SAMPLES);

if(sound > maxCalib) {

maxCalib = sound;

}

if(sound < minCalib) {

minCalib = sound;

}

sumCalib += sound;

}

sumCalib /= NUM_SAMPLES;

while(1)

{

int sound = analog_read_sum(6, SUM_SAMPLES);

int pot = read_trimpot();

if(sound > sumCalib + pot) {

trigger = 1;

state = !state;

}

int motorSpeed = (1 - 2 * state) * 255;

set_motors(motorSpeed, motorSpeed);

red_led(state);

if(trigger) {

delay_ms(DEBOUNCE);

trigger = 0;

}

int analog_read_sum(int id, int samples) {

int sum = 0;

for(int i = 0; i < samples; i++) {

sum += analog_read(id);

}

return sum;

}

Second computational project: antennae!2011-11-15T15:23:00.001-08:00

For the second computational project, we attach antennae (SPDT switches with long levers) to the front of the robot. During normal operation the robot proceeds full speed ahead. When the right antenna is contacted, the robot turns counterclockwise (e.g. left) by reversing the left motor. When the left antenna is contacted, the robot turns clockwise (e.g right) by reversing the right motor. The trimpot is used to control the duration of the rotation.

Here is the code (available in the Dropbox folder):


#include <pololu/orangutan.h>
/*
 * antennae: for for the Orangutan LV, SV, SVP, X2, Baby-O and 3pi robot.
 *
 * This program causes the robot to turn when it hits a wall.
  
 * Setup:
 * There are 2 SPDT switches, sensor0 and sensor1 connected to PB0 and PB1
 * respectively. There are two motors connected M1 and M2. Without loss of
 * generality, M1 is the right (driver's side) motor and M2 the left.
 * Normally, sensor0 is connected to the left side of the robot, sensor1 is
 * connected to the right side of the robot.
  
 * Operation:
 * Normal operation: both motors drive forward.
 *
 * When a switch is pressed, the red LED lights and the robot turns for
 * 10 * the value of the trimpot milliseconds. (Trimpot values are 10 bit
 * integers, e.g. the values range from 0 to 1023). During this time,
 * input is not processed.
 *
 * sensor0 activated: drive M1 backward and drive M2 forward, creating a
 * clockwise turn.
 * sensor1 activated: drive M2 backward and M1 forward, creating a
 * counterclockwise turn.
  
 * Questions:
 * 1. What happens if the sensor connections are switched (e.g. sensor0 is
 * right and sensor1 is left). Equivalently, M1 and M2 could be switched.
 * 2. Explain what is happening in the code.
 * 3. (Requires coding) How could we modify this program so that it detects
 * and responds to a switch being depressed while turning? Why would this be
 * desirable? What design choices do we have to make before we start coding?
 */
#define MOTOR_SPEED 255
#define DELAY_MS 20
#define SCALE 10
int main()
{
  while(1)
  {
    // input goes high when the switch is pressed
    int sensor0 = is_digital_input_high(IO_B0)?0:1;
    int sensor1 = is_digital_input_high(IO_B1)?0:1;
    int pot = read_trimpot();
    set_motors((1 - 2 * sensor0) * MOTOR_SPEED, (1 - 2 * sensor1) * MOTOR_SPEED);
     
    if(sensor0 || sensor1) {
        red_led(1);
        delay_ms(SCALE * pot);
    } else {
        red_led(0);
        delay_ms(DELAY_MS);
    }
  }
}

First computational project: controlling the motors with a trimpot (knob)

2011-11-15T15:17:00.001-08:00

For the first computational project for the robotic insects, we program the computer so that the onboard trimpot (knob) controls the motor speed and direction. Hook the first motor up to M1 and the second motor to M2, by connecting one wire from the first motor to M1A and one wire to M1B, and similarly for M2). Turn the trimpot with a screwdriver. The code is as follows (from Pololu website):

#include <pololu/orangutan.h>

/*
* motors1: for the Orangutan LV-168, Orangutan SV-xx8, Orangutan SVP,
*    and Baby Orangutan B
*
* This example uses the OrangutanMotors functions to drive
* motors in response to the position of user trimmer potentiometer
* and blinks the red user LED at a rate determined by the trimmer
* potentiometer position. It uses the OrangutanAnalog library to measure
* the trimpot position, and it uses the OrangutanLEDs library to provide
* limited feedback with the red user LED.
*
* http://www.pololu.com/docs/0J20
* http://www.pololu.com
* http://forum.pololu.com
*/

unsigned long prevMillis = 0;

int main()
{
  while(1)
  {
    // note that the following line could also be accomplished with:
    // int pot = analogRead(7);
    int pot = read_trimpot();    // determine the trimpot position
    int motorSpeed = pot/2-256; // turn pot reading into number between -256 and 255
    if(motorSpeed == -256)
        motorSpeed = -255; // 256 is out of range
    set_motors(motorSpeed, motorSpeed);

    int ledDelay = motorSpeed;
    if(ledDelay < 0)
      ledDelay = -ledDelay; // make the delay a non-negative number
    ledDelay = 256-ledDelay; // the delay should be short when the speed is high

    red_led(1);       // turn red LED on
    delay_ms(ledDelay);

    red_led(0);       // turn red LED off
    delay_ms(ledDelay);
  }
}

Project information

2011-11-14T12:54:00.001-08:00

Dropbox folder containing Solidworks files and code

Here are some images to help with the programming (from here)

Pin assignments

Component Layout. ISP Pin 1 connects to the red wire on the programmer.

Modeling insect legs with cardboard and scissors

2011-10-15T09:53:00.001-07:00

First prototype

2011-10-08T13:54:00.001-07:00

Tamiya six-legged robot example

2011-10-02T20:09:00.001-07:00

First SolidWorks insect model

2011-09-21T06:55:00.000-07:00

Welcome

2011-09-02T09:27:00.000-07:00

For the Fall 2011 Drafting class at Boulder High School, we (Dan Zahner and Charles Dietrich, the instructors) are designing a project to have the students build mechanical leg mechanisms for motor-driven robotic insects...thus the Creepy Crawly High School blog is born!

These robots take inspiration from popular robotic insect toys (such as the HEXBUG line of motor-driven robotic insects). The instructors will provide motors, gearboxes and a programmable microcontroller that responds to sensory input and actuates the motors. Students, working in groups, will be responsible for designing the "legs" that attach to the drive shafts and propel the insect. The Millenium Lab at Boulder High School has a laser cutter and a 3D printer that will be used to fabricate the legs.

Students will document their progress and final project on the web using blog updates, project sites such as Thingiverse or Instructables, and other tools such as YouTube.

About the instructors: Dan Zahner runs the Millennium Lab at Boulder High School and teaches Design Technology, Drafting, and Robotics. Charles Dietrich is a computer science PhD student at the University of Colorado at Boulder. Charles is working with Dan as part of Project eCSite, a NSF-funded program to bring computer science graduate students into high school classrooms.