In the Make: Robot build newsletter #3, Kurt Meredith was mentioned for his idea of thermoforming a CD. After viewing his blog, it gave me the idea to try using a hot air gun to bend the CD for my robot chassis.

I had two different CD’s, one was a TDK that had gold paint on it. This one folded over nicely, but the paint is now peeling on it. The other was some no name brand with no paint. Once I heated it up, it folded over but I could also hear some cracking. I broke a corner, but was able to fit it back by melting the two pieces together. Once I had both CDs folded the way I wanted them, I used some strong glue and stuck them together so that I had two sides to mount my servos to.

After the glue was dry, I was not happy with the rounded front and back, so took a Dremel to them and squared it off. The chassis seems fairly sturdy but I don’t think it would hold much weight without cracking my bends. I ran a bead of glue on the underside to help with this (I hope). I should have measured where I was going to place the servos and drilled those out first, but I wasn’t thinking that far ahead

What I wound up doing was taking an old soldering iron, drawing out my holes and servo mounting areas and then burning them away. It worked, but it is kind of ugly. I was able to file down a lot of the areas so they were fairly smooth.

RGB Lamp Kit

My new kit uses an Arduino clone that I designed that I am calling “StackDuino”. For this project I designed an RGB Led board that displays various colors. The RGB board screws on top of the StackDuino.

This kit will be home brew. I will be posting the Eagle Board files shortly for anyone interested.

We are in the process of setting up a new creative space in Columbus, OH called Lifelong Labs (http://www.lifelonglabs.com) and this will be one of the first project that we work on. We should be fully operational by March.

Lifelong Labs provide “all ages” instructional workshops that explore the intersection of art & technology.  An organization created to engage enthusiast and the general public with artistic works intertwined with scientific and technological elements.

Our mission is to provide a fun atmosphere for learning that the whole family can enjoy!

Below are a few photos of the RGb Lamp. This is an open source kit, you are welcome to improve upon it. If you add to the design, please send me some photos so I can display them here.

The kit will come with the StackDuino board, RGB LED board, recycled cardboard box and battery holder. I will also be including some files to you get started with creating a simple origami box to use for the lamp shade.

YouTube Video of Lamp

The Arduino code is by Earthshine Design and can be downloaded here.

StackDuino with RGB LED Board

a few photos of the lamp in action to show some of the colors…

RGB Lamp with simple paper shade

RGB Lamp with simple paper shade

RGB Lamp with simple paper shade

Part 2 is a build on the basic sequencer note-on/note-off control.

Part 3 is where it comes together with a hardware-and-Arduino based 4-step sequencer for the SX-150

Jeff has included complete instructions, explanations, schematics and Arduino sketch files for this build.

The Lilypad Interactive Passion Sensing Scarf works like so:

Scarf number one being worn by someone walking alone will light up with the color Blue for Lonely. When the wearer of scarf number two joins up with number one, the two scarves will sense each other and then light up Red for Love.

Future plans for capacitance touch: which will allow the colors to Pulsate for Passion if one wearer touches the other wearers scarf. View My Instructable

The robot was basically built using a Parallax Boe Bot chassis. Rather than using the Basic Stamp we added an Arduino with a proto shield to control the robot functions.

You can use any type of chassis for this project. The robot moves about using a ping sonar and IR sensors to avoid running into any objects. As you can see in the video, it was a bit thrown off by our kitten. We added additional items such as a wireless camera that sends audio/video back to our TV.The original design for this was created by an Instructable’s member and can be found here.

Items you will need for this project:

• Arduino/Freeduino or Breadboard Arduino
• (3) 3-Wire Sensor Cables
• Breadboard (small) or Breadboard (large)
• Protoshield
• (3) Sharp IR Sensors
• 5V 1A Switching voltage regulator
• Various lengths of wire
• LED
• 220 Ohm resistor
• Optional – 4 AA Battery Holder
• Piezo Speaker/Element
• Parallax Ping))) Ultrasonic Rangefinder
• (2) Parallax Continuous Rotation Servos
• 1 Parallax Standard Rotation Servos
• 9.6V Ni-Cd Rechargeable Battery (or any other 8-AA cell battery pack/any rechargeable battery pack above 9V)
• Optional Method: Dual Motor Breakout and 2 DC Motors (Tutorial Available Here)

Arduino Autonomous Robot

The standard servo will be used to mount the Ping Rangefinder. This will give you a back and forth sweep motion as the robot travels around. The two continuous rotation servos are used for the wheels. You do not need to use the Parallax brand of servos, other brands will work. You may have to adjust the PWM values in the source code to go with the servos you are using.

It is also possible to use DC motors and edit the code, which would be considerably cheaper. You could use a SN754410 Quad Half H-Bridge to drive two DC motors. Tutorial for how to do this is available here.

The Arduino hook up is pretty simple. You will have the following:

• Pin (Analog) 0: Left Sensor
• Pin (Analog) 1: Center Sensor
• Pin (Analog) 2: Right Sensor
• Pin 5: Pan Servo
• Pin 6: Left Drive Servo
• Pin 7: Ultrasonic Rangefinder ( ‘Ping)))’ )
• Pin 9: Right Drive Servo
• Pin 11: Piezo Speaker

Shield Close-up

Radioshack sells an RC car battery as well as connector repair kit. You can solder the repair kit connector onto the shield, and then be able to hook up your battery to power the servos with. You can use a separate battery holder to power the Arduino.

Make all your connections onto the shield. This way everything can remain in place if you need to use your Arduino for something else and save you from needing to tear apart everything.

for power to the shield, you won’t need any extra filter capacitors since the 5V switching  regulator has them built in. We used a small project box to hold the battery in place, and was able to attach the wireless camera on top of it.

The Arduino and camera are power source 1, while the servos and sensors are power source 2 (the RC battery). A small piece of PVC pipe mounted onto a cable clip will help you to keep your wires all organized to a central point and be less likely to get caught or tangled up into something as the robot is moving around.

Arduino Sketch

// Begin Robot Code
int micVal;
int cdsVal;
int irLval;  // Left IR
int irCval;  // Center IR
int irRval;  // Right IR

int i;   // Generic Counter
int x;  // Generic Counter
int PLval;  // Pulse Width for Left Servo
int PRval;  // Pulse Width for Right Servo
int cntr;  // Generic Counter Used for Determining amt. of Object Detections
int counter; // Generic Counter
int clrpth;  // amt. of Milliseconds Of Unobstructed Path
int objdet;  // Time an Object was Detected
int task;  // Routine to Follow for Clearest Path
int pwm;  // Pulse Width for Pan Servo
boolean add;  // Whether to Increment or Decrement PW Value for Pan Servo
int distance;  // Distance to Object Detected via Ultrasonic Ranger
int oldDistance;  // Previous Distance Value Read from Ultrasonic Ranger

float scale = 1.9866666666666666666666666666667;  // *Not Currently Used*

int LeftPin = 6;  // Left Servo
int RightPin = 9;  // Right Servo
int PiezoPin = 11;  // Piezo
int PingServoPin = 5;  // Pan Servo
int irLPin = 0;            // Analog 0; Left IR
int irCPin = 1;            // Analog 1; Center IR
int irRPin = 2;            // Analog 2; Right IR

int ultraSoundSignal = 7; // Ultrasound signal pin
int val = 0;              // Used for Ultrasonic Ranger
int ultrasoundValue = 0;  // Raw Distance Val
int oldUltrasoundValue;  // *Not used*
int pulseCount;        // Generic Counter
int timecount = 0; // Echo counter
int ledPin = 13; // LED connected to digital pin 13

#define BAUD 9600
#define CmConstant 1/29.034

void setup() {
  Serial.begin(9600);
  pinMode(PiezoPin, OUTPUT);
  pinMode(ledPin, OUTPUT);
  pinMode(LeftPin, OUTPUT);
  pinMode(RightPin, OUTPUT);
  pinMode(PingServoPin, OUTPUT);
  pinMode(irLPin, INPUT);
  pinMode(irCPin, INPUT);
  pinMode(irRPin, INPUT);
  for(i = 0; i < 500; i++) {
    digitalWrite(PiezoPin, HIGH);
    delayMicroseconds(1000);
    digitalWrite(PiezoPin, LOW);
    delayMicroseconds(1000);
  }
  for(i = 0; i < 20; i++) {
  digitalWrite(PingServoPin, HIGH);
  delayMicroseconds(655 * 2);
  digitalWrite(PingServoPin, LOW);
  delay(20);
  }
  ultrasoundValue = 600;
  i = 0;
}

void loop()
{
  //Scan();
  Look();
  Go();
}
void Look() {
  irLval = analogRead(irLPin);
  irCval = analogRead(irCPin);
  irRval = analogRead(irRPin);
  //if(counter > 10) {
    //counter = 0;
    //readPing();
  //}
  if(irLval > 200) {
    PLval = 850;
    PRval = 820;
    x = 5;
    cntr = cntr + 1;
    clrpth = 0;
    objdet = millis();
  }
  else if(irCval > 200) {
    PLval = 850;
    PRval = 820;
    x = 10;
    cntr = cntr + 1;
    clrpth = 0;
    objdet = millis();
  }
  else if(irRval > 200) {
    PLval = 650;
    PRval = 620;
    x = 5;
    cntr = cntr + 1;
    clrpth = 0;
    objdet = millis();
  }
  else {
    x = 1;
    PLval = 850;
    PRval = 620;
    counter = counter + 1;
    clrpth = (millis() - objdet);
    if(add == true) {
      pwm = pwm + 50;
    }
    else if(add == false) {
      pwm = pwm - 50;
    }
    if(pwm < 400) {
      pwm = 400;
      add = true;
    }
    if(pwm > 950) {
      pwm = 950;
      add = false;
    }
    digitalWrite(PingServoPin, HIGH);
    delayMicroseconds(pwm * 2);
    digitalWrite(PingServoPin, LOW);
    delay(20);
    readPing();
    if(ultrasoundValue < 500) {
      cntr = cntr + 1;
      switch(pwm) {
        case 400:
          x = 7;
          PLval = 650;
          PRval = 650;
          Go();
          break;
        case 500:
          x = 10;
          PLval = 650;
          PRval = 650;
          Go();
          break;
        case 600:
          x = 14;
          PLval = 850;
          PRval = 850;
          Go();
          break;
        case 700:
          x = 10;
          PLval = 850;
          PRval = 850;
          Go();
          break;
        case 950:
          x = 7;
          PLval = 850;
          PRval = 850;
          Go();
          break;
      }
    }
  }
  //Serial.print("clrpth: ");
  //Serial.println(clrpth);
  //Serial.print("objdet: ");
  //Serial.println(objdet);
  //Serial.print("cntr: ");
  //Serial.println(cntr);
  if(cntr > 25 && clrpth < 2000) {
    clrpth = 0;
    cntr = 0;
    Scan();
  }
}
void Go() {
  for(i = 0; i < x; i++) {
    digitalWrite(LeftPin, HIGH);
    delayMicroseconds(PLval * 2);
    digitalWrite(LeftPin, LOW);
    digitalWrite(RightPin, HIGH);
    delayMicroseconds(PRval * 2);
    digitalWrite(RightPin, LOW);
    delay(20);
  }
}
void readPing() {  // Get Distance from Ultrasonic Ranger
 timecount = 0;
 val = 0;
 pinMode(ultraSoundSignal, OUTPUT); // Switch signalpin to output

/* Send low-high-low pulse to activate the trigger pulse of the sensor
 * -------------------------------------------------------------------
 */

digitalWrite(ultraSoundSignal, LOW); // Send low pulse
delayMicroseconds(2); // Wait for 2 microseconds
digitalWrite(ultraSoundSignal, HIGH); // Send high pulse
delayMicroseconds(5); // Wait for 5 microseconds
digitalWrite(ultraSoundSignal, LOW); // Holdoff

/* Listening for echo pulse
 * -------------------------------------------------------------------
 */

pinMode(ultraSoundSignal, INPUT); // Switch signalpin to input
val = digitalRead(ultraSoundSignal); // Append signal value to val
while(val == LOW) { // Loop until pin reads a high value
  val = digitalRead(ultraSoundSignal);
}

while(val == HIGH) { // Loop until pin reads a high value
  val = digitalRead(ultraSoundSignal);
  timecount = timecount +1;            // Count echo pulse time
}

/* Writing out values to the serial port
 * -------------------------------------------------------------------
 */

ultrasoundValue = timecount; // Append echo pulse time to ultrasoundValue

//serialWrite('A'); // Example identifier for the sensor
//printInteger(ultrasoundValue);
//serialWrite(10);
//serialWrite(13);

/* Lite up LED if any value is passed by the echo pulse
 * -------------------------------------------------------------------
 */

if(timecount > 0){
  digitalWrite(ledPin, HIGH);
}
} 
void Scan() {   // Scan for the Clearest Path
  oldDistance = 30;
  task = 0;
  for(i = 1; i < 5; i++) {
    switch(i) {
      case 1:
        //Serial.println("Pos. 1");
        pwm = 1125;    ///  incr. by 100 from 1085
        break;
      case 2:
        //Serial.println("Pos. 2");
        pwm = 850; //// increased by 100 from 850
        break;
      case 3:
        //Serial.println("Pos. 3");
        pwm = 400;
        break;
      case 4:
        //Serial.println("Pos. 4");
        pwm = 235;
        break;
    }
    for(pulseCount = 0; pulseCount < 20; pulseCount++) {  // Adjust Pan Servo and Read USR
      digitalWrite(PingServoPin, HIGH);
      delayMicroseconds(pwm * 2);
      digitalWrite(PingServoPin, LOW);
      readPing();
      delay(20);
    }
    distance = ((float)ultrasoundValue * CmConstant);   // Calculate Distance in Cm
    if(distance > oldDistance) {  // If the Newest distance is longer, replace previous reading with it
      oldDistance = distance;
      task = i;   // Set task equal to Pan Servo Position
    }
  }
  //Serial.print("Task: ");
  //Serial.println(task);
  //Serial.print("distance: ");
  //Serial.println(distance);
  //Serial.print("oldDistance: ");
  //Serial.println(oldDistance);
  distance = 50;  // Prevents Scan from Looping
  switch(task) {   // Determine which task should be carried out
    case 0:  // Center was clearest
      x = 28;
      PLval = (850);
      PRval = (850);
      Go();
      break;
    case 1:  // 90 degrees Left was Clearest
      x = 14;
      PLval = (650);
      PRval = (650);
      Go();
      break;
    case 2:  // 45 degrees left
      x = 7;
      PLval = (650);
      PRval = (650);
      Go();
      break;
    case 3:  // 45 degrees right
      x = 7;
      PLval = (850);
      PRval = (850);
      Go();
      break;
    case 4:  // 90 degrees right
      x = 14;
      PLval = (850);
      PRval = (850);
      Go();
      break;
  }
}

// End Robot Code

Bridge Passage, photo courtesy of Professor Tom Robbins, Architecture

The bridge, “Passage” by L. Brower Hatcher at Columbus State, is one of the most outstanding and notable landmarks on campus. Connecting the main parking garage and Davidson Hall over Spring Street, the bridge offers safe passage above the fast moving one-way traffic below. Painted bright red, it also adds a strong visual contrast against the blue sky above and the green grass below.

The bridge contains many educational symbols and decorative metal icons mounted along the passage, which at one time were lighted at night by fiber-optics, creating a moving array of colors and light. This night-time light display has been noticeably absent for several years, apparently due to the mechanical failure of the high-powered “luminaries” which project colored light through the fiber optic cables.

Bridge Icons

As a class project, we designed a Solar Powered LED Lighting system to replace the existing outdated system that no longer works. (I can’t reveal the design yet here until things are approved) After thorough investigation, our class determined that the luminaries, located on the side of the bridge, most likely failed due to heat build-up, and possibly corrosion from exhaust and salt water mist from the traffic below. By contacting the vendor, we discovered that the 277 VAC model PH-3001 luminaries installed when the bridge was commissioned are no longer manufactured, and the replacement units would not be compatible with any of the PH-3001 units which still may be repairable on the bridge.  This means that to light the bridge again using the high-powered Metal-Halide luminaries, all 14 units would need to be replaced, at a minimum cost of $13,000.00 USD, not including labor.

It is also important to note, that the PH-3001 units are extremely difficult to maintain. Maintenance is very labor intensive, and consumes a large block of time for maintenance personnel who obviously have a multitude of other important tasks, maintaining a large campus the size of Columbus State. The bulbs burn out frequently, with a replacement cost of $211.00 each, or approximately $3000.00 USD per year. The units are also located in a difficult to reach location, and the fragile glass color wheels which require frequent cleaning and maintenance because of pollution from the traffic below, are easily damaged during maintenance.

Cost Benefit Analysis:

As noted earlier, the old Metal Halide lighting units are very labor intensive, and difficult to maintain. Due to heat buildup inside the enclosed units (Metal Halide bulbs run very hot), the bulbs would need to be changed yearly at a material cost of $3000.00 USD. Added to this amount would be a minimum of 28 hours of labor at $40 per hour, or $1120 in labor costs. The 14 units each consume approximately 200 watts of power per hour, or a total of $3.36 per day, $1226 per year. This would bring the approximate operating costs for the old lighting units to $3000 + $1120 + $1226 = $5346.00 per year operating cost.

Since the Solar Powered LED illuminated bridge runs off of the Sun’s energy, electrical costs and Carbon footprint would be Zero. LED light bulbs have an average MTBF (Mean time between failure) of 50,000 to 100,000 hours, or approximately 20 times that of the metal halide bulbs. By eliminating the mechanical rotating color wheels, valuable maintenance costs for an LED lighting system would be greatly reduced, to possibly only several hours per year. The estimated cost savings for the Solar Powered LED lighting system would be over $5000.00 USD per year.

So far the school has seemed to drag their feet with getting things done. Each day when I go to class and walk across the bridge I day dream about more stuff to add to the design which brings me to my original intent for this post, which is how to connect a PIR sensor to an Arduino.

The bridge has lighted square panels along the walkway. What I would like to see added is the ability for each panel to light up as a person gets close and then turn off as they move further away. This I feel will add to the cost savings since the walk way lights will only be in use at night when there is traffic on the bridge. If nobody is on the bridge, there is no need for them to be on at that time since the only purpose they serve is to see where you are walking.

Arduino with PIR Sensor

Connecting a PIR sensor to an Arduino board can be done easily. PIR sensors consist of 3 pins, Vcc (Positive Voltage), Vss (Ground), and Signal. Interfacing it to the Arduino only requires +5v, GND and a digital input pin.

I put a short video clip on YouTube showing how the sensor works and the code is below.

I am thinking I could easily put together a small board and have each one located throughout the bridge with PIR sensors connected to them to control the individual squares. Or possibly have one central location for a control station and each PIR sensor runs to it.

Then as you walk, each panel will light up and turn off a few seconds later as you move away from it. The panels are staggered all the way down the walkway, so this would give a nice effect at night as someone is walking across the bridge.

Another thought I had was to tie all the walkway panels into one PIR at the entrance and one PIR at the exit of the bridge (maybe one in the middle also) and then the bridge would light up in 2-3 stages, rather than individual panels. Kind of boring, but serves its purpose for safety.

Additional Resources:

Parallax PIR Sensor Datasheet

Arduino PIRsense

Arduino Sketch:

// Parallax PIR sensor's output

//VARS
//the time we give the sensor to calibrate (10-60 secs according to the datasheet)
int calibrationTime = 30;        

//the time when the sensor outputs a low impulse
long unsigned int lowIn;         

//the amount of milliseconds the sensor has to be low 
//before we assume all motion has stopped
long unsigned int pause = 5000;  

boolean lockLow = true;
boolean takeLowTime;  

int pirPin = 3;    //the digital pin connected to the PIR sensor's output
int ledPin = 13;

//SETUP
void setup(){
  Serial.begin(9600);
  pinMode(pirPin, INPUT);
  pinMode(ledPin, OUTPUT);
  digitalWrite(pirPin, LOW);

  //give the sensor some time to calibrate
  Serial.print("calibrating sensor ");
    for(int i = 0; i < calibrationTime; i++){
      Serial.print(".");
      delay(1000);
      }
    Serial.println(" done");
    Serial.println("SENSOR ACTIVE");
    delay(50);
  }

////////////////////////////
//LOOP
void loop(){

     if(digitalRead(pirPin) == HIGH){
       digitalWrite(ledPin, HIGH);   //the led visualizes the sensors output pin state
       if(lockLow){
         //makes sure we wait for a transition to LOW before any further output is made:
         lockLow = false;
         Serial.println("---");
         Serial.print("motion detected at ");
         Serial.print(millis()/1000);
         Serial.println(" sec");
         delay(50);
         }         
         takeLowTime = true;
       }

     if(digitalRead(pirPin) == LOW){
       digitalWrite(ledPin, LOW);  //the led visualizes the sensors output pin state

       if(takeLowTime){
        lowIn = millis();          //save the time of the transition from high to LOW
        takeLowTime = false;       //make sure this is only done at the start of a LOW phase
        }
       //if the sensor is low for more than the given pause, 
       //we assume that no more motion is going to happen
       if(!lockLow && millis() - lowIn > pause){
           //makes sure this block of code is only executed again after 
           //a new motion sequence has been detected
           lockLow = true;
           Serial.print("motion ended at ");      //output
           Serial.print((millis() - pause)/1000);
           Serial.println(" sec");
           delay(50);
           }
       }
  }

Drew and Jacob - Soldering boards

It’s that time of year again… where the sounds of knowledge fill the home labs, garages and basements across the globe. Here in the ArduinoFun lab, we have been busy working on this years project ADM-Robot 1.0 aka Recycle-bot.

I will be posting progress photos and notes as we go along to document the process for our science fair project.

What is ADM 1.0? Basically we built an Arduino, added a Dual Motor Controller to it and a small prototyping area. Hence the name ADM (Arduino Dual Motor).  The board works and is programmed just like a normal Arduino. For the science fair, part of the rules stated we could not use an actual Arduino board, but were able to build or modify our own.

Shawn and Jacob - Drilling component holes

Below is a zip file which contains the files that will allow you to create your own PCB file. According to Drew and Jacob, Recycle bot will be used in school to help drive interest in getting classmates to start recycling. “Having a cool robot moving around the lunch room to collect your recyclables will encourage everyone to participate because it is so cool!”

We will be using a metal trash can that we found at the store that just looks like it was meant to be a robot.

To make a copy of the PCB, you can follow the Instructable that I created that uses a home Inkjet printer. The entire process works really well and the boards have turned out great.

Drew and Jacob - Prototyping ADM 1.0

This zip file contains two PDF files (solder side & component side), for printing your own circuit board.

Once we get a little further along I will start posting some videos, photos and Arduino sketches that we use.

We are also working with GridConnect on a project, and hopefully if all goes well ADM will be enabled with WiFly

Board Photos on My Flickr Page.

Component Side, Solder Side

H-Bridge Setup

With this post I am going to show you how to use a SN754410NE Quad Half H-Bridge IC to control two 12 volt DC Motors.  I have added a video so that you can see the Dual Motor in action.  As you can see in the video, all the wires can be a little confusing to look at.  To make things easier to view and understand as we go along, I have also created an illustration for you to refer to.  You may also download a printable PDF file of this illustration.  I have depicted an Arduino board in the illustration, if you already have one you are good to go, if not… you can do like I have and Build Your Own Arduino following another one of my tutorials.

Here is the recommended parts you will need in order to complete this project. I have provided sources where you can purchase items from and their prices.

1. Arduino board – $29.95 at CuriousInventor.com or…
2. Build Your Own Arduino – Total build cost $15.95 at ArduinoFun.com
3. SN754410 Quad Half H-Bridge – $2.50 available at ArduinoFun.com
4. 840 Tie Point Breadboard – $6.95 available at ArduinoFun.com
5. Wire Jumper Kit – $12.95 available at ArduinoFun.com
6. Two DC Motors – $3.99 ea. available at ArduinoFun.com

H-Bridge Pinout

As you are looking at the SN754410NE chip, you will notice a u-shaped notch at one end.  This will help to identify pin 1.

Pins 1, 9, and 16 are +5V
Pin 8 is +12V and will run the +12V DC motors.
Pins 4, 5, 12, and 13 are for GND

DC Motors have two hook ups on them.  If you hooked one up straight to the source power you would have one lead going to positive and one lead going to GND.

For our H-Bridge driver, you will hook the left motor leads to pin 3 & 6.  The right motor leads will hook up to pins 11 & 14.

Connect h-bridge pin 2 to the Arduino digital pin 2, and h-bridge pin 7 to Arduino digital pin 3.
Connect h-bridge pin 10 to Arduino digital pin 8, and h-bridge pin 15 to Arduino digital pin 7

Once you have your h-bridge circuit completed, you can upload the sketch to your Arduino.  The sketch will cycle back and forth on the dc motors driving them forward and backwards and then light an led connected to pin 13 on the arduino.

Arduino Sketch

With the rising fuel prices I decided to purchase a Piaggio Scooter to ride back and forth to school on in nice weather.  Living in Ohio I only get about 6 months out of the year that I can ride it however it’s still a big savings for me.  During the winter months when you have to store your scooter unless you plug your battery into a wall tender when spring comes you will find your scooter not starting.  Looking for ways to save even more I set out to build something that would charge my scooter and not raise my electricity bill in the process.  The solution was to have a solar panel outside of my garage do the work for me.

You can view a larger photo on my Flickr page which will help to show the hook ups.  For the Arduino, I am using one that I created on a breadboard, you can follow this tutorial if you would like to do the same.

This is my initial testing of the Arduino Solar Tracker. I am going to need to also create a shunt regulator, so that when the battery is fully charged it won’t over charge.  The charging ability will basically shut off until the battery drops down to a certain level.  I picked up a nice solar panel at Harbour Freight, if you have a local store near you check there first because it may be cheaper in store than from the web.

The next step will be to build a bracket outside my garage that can hold the solar panel and be able to move as the sun moves across the sky.

I will post more information as I complete each piece of this project.  For now, here is what you will need to do in order to get the Arduino Solar Tracker portion set up.  Orignial credit to Stigern.net for the concept.

For testing purposes I used two small photoresistors, but the final project will use two giant cds cells.

What you will need:

1. (2) Photoresistors
2. (2) 470 Ohms resistors
3. (1) Servo
4. Hook-up wire
5. Breadboard

Hook-up

Breadboard Power. In my set up photo above, I used two small half sized breadboards.  Then I just jumped power and GND to the second one.

Servo Power. The red wire goes to 5V, the black wire goes to GND, and depending on your servo the yellow or white wire will go to arduino pin 9.

Schematic

Photocell Circuit:

The photocells are hooked up as 5v to leg one, then on leg two you will have leg one of the 470 Ohm resistor and a connection to arduino pin 0. The other leg of the resistor goes to GND. Do the same for the second photocell but it will connect to arduino pin 1.

Arduino Sketch File:

Arduino Wireless Xbee

I have set this post up as an introduction to using the Xbee devices with Arduino.   As a beginner, I found it confusing at first to get started so I hope this post will help others to get up and running a little easier.   The first place I checked out was Adafruits tutorials for the Xbee Adapter that she sells.

Once you have your Xbee’s configured you can follow this setup and use the sketches that I have provided below (Thanks to Guilherme Martins) and you should be able to be up and running fairly quickly.  You can view a larger (1024×768) version of this photo on my Flickr page which will help you see the hook-ups easier.

What You Will Need:

• 2 Arduinos, We used a Arduino Duemilanove and a Adafruit
• Boarduino
• Breadboard and Regulated Power
• 2 Potentiometers
• 2 Xbee Pro Devices
• 2 Xbee Adapter Kits
• Protoshield with Mini-breadboard
• 2 LED’s
• Hook-up Wire
• Portable Power for 2nd Arduino

The Arduino Duemilanove is the “receiver” and the Boarduino is the “sender”.   To not cause an error, upload both sketches to the Arduinos before hooking anything up.

For the Sender:  we hook up +5v power and GND to the Boarduino and again to the Xbee adapter.
1. Boarduino TX goes to Xbee RX and Boarduino RX goes to Xbee TX.
2. Power and GND to each of the Pots.
3. Analog Pin 2 to Pot 1
4. Analog Pin 5 to Pot 2

For the Receiver:  plug in your protoshield to the Arduino and place the Xbee on top. Position this so that you have room in front and behind the adapter to hook up wires to. Connect +5v power and GND from the protoshield to the Xbee adapter.
1. Arduino TX (D1 on shield) goes to Xbee RX and Arduino RX (D0 on shield) goes to Xbee TX
2. Digital Pin 5 connected through resistor 1 (we used 220 ohms) to positive end of the LED. GND to the negative end.
3. Digital Pin 6 connected through resistor 2 to positive end of LED. GND to to negative end.

Now, since you already uploaded the sketches to each Arduino, turn power on for both. Turn your potentiometers on and off and if you have everything correct, you will see the LED’s turn on an off.  The range on these particular Xbee’s were really good.  We tested the sender being in our basement lab and the reciever was traveling around the block in our neighborhood. Amazing!

Arduino Sketch Files:

1. Xbee Send
2. Xbee Receive

Other References:

1. Rob Faludi’s XBee page
2. Tom Igoe’s XBee page
3. Arduino Xbee Interface Circuit (AXIC)