Tuesday, December 10, 2013

Arduino Compass Bearing Following Robot

Objective:
Build a robot that automatically tracks a user provided compass heading.  Create a proof of concept indoor model and then scale up for outdoor use.


-----
If you are not interested in the build details and just want to see the result take a look at the video below.  Basically, we are using an Arduino Nano and a LM303DLHC Micro Electro Mechanical (MEMs) compass sensor to read and track a compass bearing.

Rev 2.0: Uses the battery for the mounting chassis:


As shown in the videos, the robot continuously reads it's current compass bearing and adjusts to track the desired user direction.  It does this by turning the wheel motors on or off.  To keep things simple, the two motors are powered at full speed (no PWM).  The two motors are never on at the same time.
-----
Components:
Modern technology keeps the BOM small and puts the magic in the software that is shown later.















Ardunio Nano microcontroller for the brains.  About $10USD if you shop around.
-----












LM303DLHC MEMs sensor provides the magnetic compass reading input for the Arduino.  The LM303DLHC is has tilt compensation and accelerometers on board that can be used to detect hitting obstacles.  About $7USD shipped from "eBay China".
-----













754410NE H-Bridge to drive the motors.  (The Ardunio can't source enough current to drive the motors.)  At is stands now the project only powers the drive wheels to move forward, however; we selected the 754410NE because with just a few wires and lines of code it can drive both motors forward and reverse. About $3USD.
-----
Get the above parts, a breadboard, two DC motors, wheels, a power source, etc. and hook it all up.  In the diagram below I tried to closely mimic the breadboard setup in the pics:

















-----
Scaling Up:
We have a few APEX PA74 op amps that are capable of driving VERY high current loads.  We are in the process of scaling the build for outdoor use with strong 12VDC motors.  Here is a quick demo vid of the platform in action:


-----
If you are still with us, here is the Arduino Nano code.  This is the most simple example.  Other options include using the accelerometers to detect obstacles and drawing patterns (triangle, square, out and back, etc.)

/*
 **************************************
 ***** www.WhiskeyTangoHotel.Com  *****
 **************************************
    Project Name: LM303DLHC Compass Robot
 
    Start Date:  Nov 2013
 
    Program Rev History and Notes:
      Special thanks to pololu.com!  See their GitHub site.
   
      Point robot in desired direction then press reset button.
      Put robot on ground.  After 5 sec delay the robot will track the desired bearing.
   
      This version moves the robot on the user desired bearing forever.
      Other versions detect objects (bump) and draw patters (out and return, box, triangle)

 ***************************************
 */

// Define Variable Types and include.h
#include <Wire.h>
#include <LSM303.h>

int LeftWheel = 11;         //left motor on output D11
int RightWheel = 10;       //right motor on output D10

//**************************************

LSM303 compass;

int gotoheading;  //global var for the initial robot direction.  Or Press reset button...

void setup() {
   pinMode(LeftWheel, OUTPUT);      // sets the digital pin as output
   pinMode(RightWheel, OUTPUT);      // sets the digital pin as output
 
   digitalWrite(LeftWheel, LOW);
   digitalWrite(RightWheel, LOW);
 
   Serial.begin(9600);  // Used for debug only
 
   Wire.begin();
   compass.init();
   compass.enableDefault();

  //read the direction that you want the robot to go.  LM303 Header pins point to direction
  compass.read();
  gotoheading = compass.heading((LSM303::vector){0,-1,0});

  delay(5000);  // dealy xx mSecs after power up before doing anything

  // Calibration values. Use the pololu.com Calibrate example program to get the values for your compass.
  compass.m_min.x = -872; compass.m_min.y = -757; compass.m_min.z = -212;
  compass.m_max.x = +461; compass.m_max.y = +511; compass.m_max.z = 844;

}

void loop() {
  compass.read();
  int heading = compass.heading((LSM303::vector){0,-1,0});

 ///*  Print to the PC monitor.  Debug only.
  Serial.print(gotoheading);
  Serial.print(" Current is: ");
  Serial.print(heading);

//*/  //End Serial print to PC comment block
 
  if (heading > gotoheading)    //turn the bot left by turning on right motor
    {
      digitalWrite(LeftWheel, LOW);
      digitalWrite(RightWheel, HIGH);
      Serial.println("   OFF  --  ON");
    }
   
  if (heading <= gotoheading)  //turn the bot right by turning on left motor
    {
    digitalWrite(LeftWheel, HIGH);
    digitalWrite(RightWheel, LOW);
    Serial.println("   ON --  OFF");
    }

  delay(0);   //in mSecs

}  //void loop
 
-----

Friday, October 25, 2013

Exploding a Capacitor

Every electronics DIY/hobby site seems to have a cap exploding.  This is the WhiskeyTangoHotel oblatory example.  Actually, this is the first capacitor we have ever exploded (on purpose that is).  The cap is spec'd at 15VDC.  We reversed biased it with 40VDC.


Tuesday, August 6, 2013

Failure Tutorial: All hail the Mighty Bypass Cap

It's frustrating.  You design a great project, get it working perfectly on the breadboard with that nice beefy bench power supply only to discover it stops working in "the real world".  What the hell's going on?
-----

Here is a short video showing how everything just stops when the bypass cap from my Etch-a-Sketch to chart Temperature vs Time is removed.  Connect the bypass cap and, like magic, everything is back to normal.  Pretty amazing, huh?
-----
If you follow DIY projects on the web you see this issue frequently.  The fix often is simply to add a capacitor between power and ground.  This is called a by-pass cap or decoupling cap.  They are most useful in projects with electrical noise or where larger loads like motors, solenoids, relays, etc. are involved.

As I said, this recently happened to me.  I had the great idea to use two stepper motors mounted to an Etch-a-Sketch to chart Temperature vs Time.  The project came off fine in the end, but not without a bump in the road.

The rig was stable with one stepper motor.  However, adding the second stepper motor made everything 'wacky'.   Sometimes the PICAXE 18M2 microcontroller would not even accept new code downloads.  All fixed with a by-pass cap.
-----
Below is short video of the finished rig in action. (Thanks Hack-a-Day for featuring it!)  Take a look at the build page if you are interested in duplicating the project.

-----
Thanks for the visit and "All hail the mighty bypass cap"!!!

Tuesday, July 16, 2013

Raspberry PI: Charting Ambient vs Outside Temperature

How to use a Raspberry PI to chart ambient temperature vs outside temperature.  Source code and schematics below.

What you need:
-----
What you get:

Reading the graph above is pretty obvious.  It plots the temperature of the DS18B20 sensor connected to the Raspberry PI vs. the outside temperature that is provided by a local weather forecast feed.  Just for fun, we also display Min and Max temperatures (which can be reset).
-----
The graphing is provided by sen.se.  The sen.se site offers a lot of flexibility with "the internet of things".  sen.se is free.  Sign up and scan the tutorials.  The site is well laid out and the tutorials are very straight forward; you'll be an expert in no time.  Basically, you want to create a "channel" for your Raspberry PI by 'adding a device'.  sen.se will give you a 5 digit channel number for your RasPI and a very long passphrase that will be your personal identifier.  You will need both of these for the source code below.
-----
Next, let's connect the DS18B20 to the Raspberry PI.  The DS18B20 transmits its temperature reading via I2C bus.  Just follow the tutorial at Adafruit.  The connection is simple and looks like this:
-----
Load the Python script below into your Raspberry Pi and run it.  Be certain you enter your personal passphrase identifier and the device channel code that you got earlier from sen.se.  After you run the Python script head back over to sen.se.  You should see that sen.se has detected a 'heartbeat' from your Raspberry PI.  After that, it is just a matter of configuring one of the graphing apps on sen.se.  You can make your sen.se data public or private and there are many many tools to manipulate and display your data.
-----
Good luck!  Python script for the RasPI follows:

# WhiskeyTangoHotel.Com
# June 2013
# Program reads DS18B20 temp sensor and plots value to sen.se
# DS18B20 connections via AdaFruit tutorial
# With thanks to @Rob_Bishop

# This program is feed customized for RasPI(2)

import httplib
import json as simplejson
from random import randint
import time
import os
import glob

# Pass os commands to set up I2C bus 
os.system('modprobe w1-gpio')  
os.system('modprobe w1-therm')

base_dir = '/sys/bus/w1/devices/'
device_folder = glob.glob(base_dir + '28*')[0]
device_file = device_folder + '/w1_slave'

run_number = 0

SENSE_API_KEY = "long sen.se passphase here. note that it is in quotes"
FEED_ID1 = 12345  # five digit sen.se channel code.  note it is NOT in quotes

def read_temp_raw():  #read the DS18B20 function
    f = open(device_file, 'r')
    lines = f.readlines()
    f.close()
    return lines

def read_temp(): #process the raw temp file output and convert to F
    lines = read_temp_raw()
    while lines[0].strip()[-3:] != 'YES':
        time.sleep(1)
        lines = read_temp_raw()
    equals_pos = lines[1].find('t=')
    if equals_pos != -1:
        temp_string = lines[1][equals_pos+2:]
        ambC = float(temp_string) / 1000.0
        ambF = ambC * 9.0 / 5.0 + 32.0
        return ambF

def send_to_opensense(data):
#    print  >> fout, "\t=> Sending to OpenSense: %s" % data
try:
# prepare data 
datalist = [{"feed_id" : FEED_ID1, "value" :data['F']},]
headers = {"sense_key": SENSE_API_KEY,"content-type": "application/json"}
conn = httplib.HTTPConnection("api.sen.se")
# format a POST request with JSON content
conn.request("POST", "/events/", simplejson.dumps(datalist), headers)
response = conn.getresponse()
# you may get interesting information here in case it fails
#   print >> fout, response.status, response.reason
#   print >> fout, response.read()
conn.close()
except:
pass

while(True):
try:
run_number = run_number + 1
ambF = read_temp()
print "RasPI(2) Ambient Run:", run_number, "    ambF:",ambF
data = { 'F' : ambF}
send_to_opensense(data)
time.sleep(300)
except:
pass
-----

Wednesday, May 29, 2013

PI in the Oven: Logging Raspberry PI Core Temperatures to Sen.se

Objective:  Create a method of logging Raspberry PI data to the sen.se website.  In this example I plot the core temperature of two Raspberry PIs, but the method can be adapted to log virtually any form of data that you wish to capture or generate with the PI.  The python code is below to get you running quickly.
-----

The graph above is generated by sending data from the PI to the sen.se API.  Sen.se is one cool place.  Their goal is to assist in internet connectivity of personal devices; "the internet of things".  They have widgets, tools, applications, channels and a few other things that I barely understand.  Play around with sen.se some and you will get the idea .  In my application, I have sen.se graphing the core temperature of two Raspberry PIs; a data point every 60 seconds.  Just for fun, I also keep track of the number of reading, calculate an average temperature, and display the temperature change since the last reading.  Sen.se allows you to keep this information private or display it to the public.  
----
So.... from the graph we see one PI is running about ~12F hotter than the other.  Why?  

Probably due to a few reasons:  
RasPI_1 is always running the "motion" webcam software and functioning as an OpenVPN server.  RasPI_1 is also in a fully enclosed case.  (Maybe I should take it out of that case....)

RasPI_2 is not in a case on is only running my Hand of PI project.  Hand of PI is a robot hand that you can control by sending twitter commands to it.  Click for build page.

Of course, both PIs are running the temperature logging script.
-----
If you are still with me, the python source code is below.  It has been running flawlessly for a while, so it should be solid.  Occasionally Sen.se will go down briefly for maintenance, but that is why I put in the error traps.  Good luck and tweet the Hand of PI to let us know you were here!!!
------
# whiskeytangohotel.com
# May 2013

# Python script to read RaspberryPI
# internal core temp, covert from C to F
# and log to sen.se for graphing.

# If you get errros on the import
# make certain you have the 'apts' installed

import httplib
import json as simplejson
from random import randint
import time

# init some vars
run_number = 0
tempC = 0
tempF = 0


# Enter your private sen.se API KEY in quotes.  Enter the Feed ID# without quotes
SENSE_API_KEY = "x1xxxxxy2yyyyyyz3zzzz"  
FEED_ID1 = 12345

# Function to format for sen.se
# The try/expect are there to trap errors if sen.se goes down
# or is slow.  This keeps the script running.
def send_to_opensense(data):
try:
# prepare data 
datalist = [{"feed_id" : FEED_ID1, "value" :data['F']},]
headers = {"sense_key": SENSE_API_KEY,"content-type": "application/json"}
conn = httplib.HTTPConnection("api.sen.se")
# format a POST request with JSON content
conn.request("POST", "/events/", simplejson.dumps(datalist), headers)
response = conn.getresponse()
conn.close()
except:
pass   

while(True):

# The try/expect are there to trap errors if sen.se goes down
# or is slow.  This keeps the script running
try:
# read the PI core temperture and store in tempC
# then convert from C to F and send the data to sen,se
tempC = int(open('/sys/class/thermal/thermal_zone0/temp').read()) / 1e3
tempF = (tempC * 1.8) + 32
run_number = run_number + 1
print "Run:", run_number, "    tempC:", tempC, "    tempF:",tempF
data = { 'F' : tempF}
send_to_opensense(data)
time.sleep(60)
except:
pass
-----

Saturday, May 11, 2013

Speech Synthesis on the Raspberry PI

Here is a quick and simple tip to add speech output to jazz up your Raspberry PI projects.  It is easy as installing the "festival" Text to Speech (TTS) application then calling it from the command line or Python script.

To install "festival" you need to be at a terminal prompt on the Raspberry PI.  Then type:
$ sudo apt-get install festival festival-freebsoft-utils
You will get asked to confirm the install.  Type "Y".

To make the PI talk, just issue a command from the terminal prompt, such as:
$ echo  "Whiskey Tango Hotel dot com Where stupidity meets reality"| festival --tts
That's it.  Of course, you can also execute this from a Python script, etc.

Here's a sample of the output.  Sounds pretty good to me.




Thursday, April 11, 2013

Hand of PI (Twitter controlled Robot Hand)

OBJECTIVE:  Use the Raspberry PI to monitor a Twitter feed and control a mechanical device.

If you are not interested in the details of the build and just want to see the result you can watch the vid below.  

-----
RESULT:  Success!!!  You can control the "The Hand of PI" by sending a tweet to @OurCatDoor.   If  your tweet includes any of the text below, the "Hand of PI" obeys your command.  Valid commands are (lowercase):
  • one (holds up one finger)
  • peace (shows the two finger peace sign)
  • three (three fingers up)
  • hookem (if you are a Texas Longhorn fan this one makes sense)
  • fist (the Hand of PI gets ready to fight)
  • open (ready for a 'high five')
  • finger (well...  this will be the most tweeted command)
Go ahead, try it!!!  Send a tweet command to @OurCatDoor to let us know you were here.
-----
Basically what you are seeing is the Raspberry PI running a Python script searching any tweet sent to @OurCatDoor.  In the video, an iPad sends a tweet to @OurCatDoor that has the command "finger" in it.  It takes a few seconds, but the Raspberry PI finds the tweet, parses it, and find the "finger" command.  The Python script then sets the PI's GPIO ports High/Low.  The PI GPIO is connected to a PICAXE 18M2 (via a HC7404 buffer).  The PICAXE 18M2 reads the PI's GPIO to control five servo motors.  "Hand of PI" reacts with the appropriate gesture.  Watch closely and you can see the text on the screen update as the "finger" command is found and the "Hand of PI" gestures.   There's a lot going on here.  Confused?  This diagram should help (click to see full size):
Of course this isn't full schematic, but it lays out all the I/O to align with the source code you see below.  Really, the interconnects and 5VDC to the servos, PI, PICAXE, and HC7404 is something anyone wanting to duplicate the project should easily understand given the block diagram and source code.
-----
Let's show a few more pics and action videos of the rig before we get into the source code:
 
-----
This video is a bit long but demonstrates all the gestures of the "Hand of PI".  The screen in the background shows output from the Python script.  The screen is not needed, but I included it in the video to show the tweets as they are captured.  Note the "Hand of PI" reacts when a new tweet command is found.
Everyone wants to see the "Hand of PI" flip the bird; that is the last gesture if you want to skip to the end...
----
If you are still with us, enjoy some source code for your reading pleasure.

First the program that is running on the PICAXE 18M2.  It's job is to read the Raspberry PI's GPIO output and control the five servo motors on the "Hand of PI".

' PICAXE 18M2 for RaspPI intergration to Tweeter Controlled Hand Gesture Robot APRIL 2013
'"THE HAND OF PI"
' www.whiskeytangohotel.com
' NOTE: PICAXE Program Editor Rev newer than 5.3.6 causes servo jitter***
' Other than the minium PICAXE 18M2 'keep alive' 22K R & 10K R
' no other R, C, L, etc need for the project.
' Everything on PICAXE powered by 4.5VDC
' The PICAXE drives the servos straight from the chip.
' See pinouts in comments

' 0 is Thumb (PICAXE pin 6)
' 1 is Pointer (PICAXE pin 7)
' 2 is Middle (PICAXE pin 8)
' 3 is Ring (PICAXE pin 9)
' 4 is Pink (PICAXE pin 10)
' Normally Open Button Switch is PICAXE pin 18 (pulled HIGH with 10K)
; this button will not be used for the PI intergration

' PI GPIO 11 connected to c.0 (PICAXE pin 17)
' PI GPIO 13 connected to c.7 (PICAXE pin 16)
' PI GPIO 15 connected to c.6 (PICAXE pin 15)

symbol RaspPI11 = pinc.0
symbol RaspPI13 = pinc.7
symbol RaspPI15 = pinc.6

'Define Servo values to fully EXtend/Open finger
Symbol Ex_Thumb = 60
Symbol Ex_Pointer = 60
Symbol Ex_Middle = 245
Symbol Ex_Ring = 60
Symbol Ex_Pink = 60

'Define Servo values to fully CLose finger
Symbol CL_Thumb = 225
Symbol CL_Pointer = 240
Symbol CL_Middle = 50
Symbol CL_Ring = 240
Symbol CL_Pink = 240

'Init the servos
servo 0, Ex_Thumb
servo 1, Ex_Pointer
servo 2, Ex_Middle
servo 3, Ex_Ring
servo 4, Ex_Pink

pause 400

'Gesture Subroutines are (2^3 = 8 can be PI Callable)
' Valid Tweet commands are: one, peace, three, hookem, fist, finger, wave

'Insure Open_Hand position at program start
gosub Open_Hand
pause 500

main:  'This loops until hell freezes over

'Read the RasPI GPIO bus and  jump to gesture sub routine

If RaspPI15 = 0 and RaspPI13 = 0 and RaspPI11 = 0 then
gosub Open_Hand
end if

If RaspPI15 = 0 and RaspPI13 = 0 and RaspPI11 = 1 then
gosub One
end if

If RaspPI15 = 0 and RaspPI13 = 1 and RaspPI11 = 0 then
gosub Peace
end if

If RaspPI15 = 0 and RaspPI13 = 1 and RaspPI11 = 1 then
gosub Three
end if

If RaspPI15 = 1 and RaspPI13 = 0 and RaspPI11 = 0 then
gosub Hook_em
end if

If RaspPI15 = 1 and RaspPI13 = 0 and RaspPI11 = 1 then
gosub Fist
end if

If RaspPI15 = 1 and RaspPI13 = 1 and RaspPI11 = 0 then
gosub F_You
end if

'If RaspPI15 = 1 and RaspPI13 = 1 and RaspPI11 = 1 then
' gosub Wave  'wave is pretty hard on the servos, so we commented it
'end if

pause 5
goto main

' Gesture Subroutines below:
Open_Hand:
servopos 0, Ex_Thumb
servopos 1, Ex_Pointer
servopos 2, Ex_Middle
servopos 3, Ex_Ring
servopos 4, Ex_Pink
return ' Open_Hand

Hook_em:
servopos 0, CL_Thumb
servopos 1, Ex_Pointer
servopos 2, CL_Middle
servopos 3, CL_Ring
servopos 4, Ex_Pink
return 'Hook_em

F_you:
servopos 0, CL_Thumb
servopos 1, CL_Pointer
servopos 2, Ex_Middle
servopos 3, CL_Ring
servopos 4, CL_Pink
return 'F_you

One:
servopos 0, CL_Thumb
servopos 1, Ex_Pointer
servopos 2, CL_Middle
servopos 3, CL_Ring
servopos 4, CL_Pink
return 'One

Peace:
servopos 0, CL_Thumb
servopos 1, Ex_Pointer
servopos 2, Ex_Middle
servopos 3, CL_Ring
servopos 4, CL_Pink
return 'Two

Three:
servopos 0, CL_Thumb
servopos 1, Ex_Pointer
servopos 2, Ex_Middle
servopos 3, Ex_Ring
servopos 4, CL_Pink
return 'Three

Four:
servopos 0, CL_Thumb
servopos 1, Ex_Pointer
servopos 2, Ex_Middle
servopos 3, Ex_Ring
servopos 4, Ex_Pink
return 'Four

Fist:
servopos 0, CL_Thumb
servopos 1, CL_Pointer
servopos 2, CL_Middle
servopos 3, CL_Ring
servopos 4, CL_Pink
return 'Fist

Wave:  'waves the fingers
servopos 0, CL_Thumb
pause 70
servopos 1, CL_Pointer
pause 70
servopos 2, CL_Middle
pause 70
servopos 3, CL_Ring
pause 70
servopos 4, CL_Pink
pause 70

servopos 0, Ex_Thumb
pause 70
servopos 1, Ex_Pointer
pause 70
servopos 2, Ex_Middle
pause 70
servopos 3, Ex_Ring
pause 70
servopos 4, Ex_Pink
return 'Wave
----
Now for the Python script running on the Raspberry PI.  It's job is to search any tweet sent to @OurCatDoor and parse it for a "Hand of PI" command, then set the PI's GPIO for input to the PICAXE 18M2.



# WhiskeyTangoHotel.com - APRIL 2013   (special thanks to @Rob_Bishop)
# Error traps entered due to json hitting web site that was down etc.
# For next added to end of prog to blink LED to show program is running.

# Import the urllib library to read data from webpages
import urllib

# Import the simplejson library to  decode the data read from the webpage
import simplejson

# Import the time library for delay and lepse time tracking
import time
CurrentTime = time.time()

# Import the Raspberry Pi GPIO libraries
import RPi.GPIO as GPIO

# Set-up the GPIO pins
# Clear the current set-up
GPIO.cleanup()

# Set up the GPIO library to use Raspberry Pi board pin numbers
GPIO.setmode(GPIO.BOARD)

# Set pin 11, 13, 15  on the GPIO header to be an output
GPIO.setup(11,GPIO.OUT)  #PIXACE leg 17 (c.0)
GPIO.setup(13,GPIO.OUT)  #PIXACE leg 16 (c.7)
GPIO.setup(15,GPIO.OUT)  #PICAXE leg 15 (c.6)
GPIO.setup(7,GPIO.OUT)   #Blinkie LED to let us know the prog is running

# Start with Open Hand
GPIO.output(11,GPIO.LOW)
GPIO.output(13,GPIO.LOW)
GPIO.output(15,GPIO.LOW)
Last_gesture = "open"
Error_hit = 0
print "Hand open.  Waiting for Tweet...","\n"

# Function to take Twitter handle (e.g. @Raspberry_Pi) as an argument and return the most recent tweet

# Define the function name and show the arguments
def Latest_Tweet_to_Twitter_Handle(twitter_handle):
try:
# Get the results of a search on Twitter for tweets containing the given hand$
Twitter_search_results = urllib.urlopen("http://search.twitter.com/search.json?q="+twitter_handle)

# Decode the data that we got from the webpage to form a list of tweets
result_list = simplejson.loads(Twitter_search_results.read())

# The function returns the first result in the list
return result_list["results"][0]["text"]
except:
pass

# Main body of the program - Get the latest tweet and check if it contains certain words
# Loop to run forever

#Twitter commands the hand understands are:
#one, two, three, hookem, fist, finger, wave

while(True):
try:
#Time since program start in seconds
DeltaTime = int(time.time() - CurrentTime)

# Function gets the latest tweet mentioning the handle given in next line
Tweet=Latest_Tweet_to_Twitter_Handle("@OurCatDoor")

# START TEST(open): Check if tweet contains the word given in quotation marks
if "open" in Tweet: # and Last_gesture != "open":
Last_gesture = "open"
# If it did contain the word then print out the tweet along with a message
print DeltaTime,"seconds:",Tweet," - Gesture OPEN HAND","\n"
# Turn on the LED
GPIO.output(11,GPIO.LOW)
GPIO.output(13,GPIO.LOW)
GPIO.output(15,GPIO.LOW)
#---END TEST(open)---

# START TEST(one): Check if tweet contains the word given in quotation marks
if "one" in Tweet: # and Last_gesture != "one":
Last_gesture = "one"
# If it did contain the word then print out the tweet along with a message
print DeltaTime,"seconds:",Tweet," - Gesture ONE","\n"
# Set the PICAXE inputs
GPIO.output(11,GPIO.HIGH)
GPIO.output(13,GPIO.LOW)
GPIO.output(15,GPIO.LOW)
#---END TEST(one)---

# START TEST(peace): Check if tweet contains the word given in quotation marks
if "peace" in Tweet: # and Last_gesture != "peace":
Last_gesture = "peace"
# If it did contain the word then print out the tweet along with a message
print DeltaTime,"seconds:",Tweet," - Gesture PEACE","\n"
# Set the PICAXE inputs
GPIO.output(11,GPIO.LOW)
GPIO.output(13,GPIO.HIGH)
GPIO.output(15,GPIO.LOW)
#---END TEST(peace)---

# START TEST(three): Check if tweet contains the word given in quotation mar$
if "three" in Tweet: # and Last_gesture != "three":
Last_gesture = "three"
# If it did contain the word then print out the tweet along with a message
print DeltaTime,"seconds:",Tweet," - Gesture THREE","\n"
# Set the PICAXE inputs
GPIO.output(11,GPIO.HIGH)
GPIO.output(13,GPIO.HIGH)  
GPIO.output(15,GPIO.LOW)
#---END TEST(three)---

# START TEST(hookem): Check if tweet contains the word given in quotation mar$
if "hookem" in Tweet: # and Last_gesture != "hookem":
Last_gesture = "hookem"
# If it did contain the word then print out the tweet along with a message
print DeltaTime,"seconds:",Tweet," - Gesture HOOK EM HORNS","\n"
# Set the PICAXE inputs
GPIO.output(11,GPIO.LOW)
GPIO.output(13,GPIO.LOW)
GPIO.output(15,GPIO.HIGH)
#---END TEST(hookem)---

# START TEST(fist): Check if tweet contains the word given in quotation mar$
if "fist" in Tweet: # and Last_gesture != "fist":
Last_gesture = "fist"
# If it did contain the word then print out the tweet along with a message
print DeltaTime,"seconds:",Tweet," - Gesture FIST","\n"
# Set the PICAXE inputs
GPIO.output(11,GPIO.HIGH)
GPIO.output(13,GPIO.LOW)
GPIO.output(15,GPIO.HIGH)
#---END TEST(fist)---

# START TEST(finger): Check if tweet contains the word given in quotation mar$
if "finger" in Tweet: # and Last_gesture != "finger":
Last_gesture = "finger"
# If it did contain the word then print out the tweet along with a message
print DeltaTime,"seconds:",Tweet," - Gesture FINGER F_YOU","\n"
# TSet the PICAXE inputs
GPIO.output(11,GPIO.LOW)
GPIO.output(13,GPIO.HIGH)
GPIO.output(15,GPIO.HIGH)
#---END TEST(finger)---

# START TEST(wavewave): Check if tweet contains the word given in quotation mar$
if "wavewave" in Tweet: # and Last_gesture != "wave":
Last_gesture = "wavewave"
# If it did contain the word then print out the tweet along with a message
print DeltaTime,"seconds:",Tweet," - Gesture WAVE","\n"
# Set the PICAXE inputs
GPIO.output(11,GPIO.HIGH)
GPIO.output(13,GPIO.HIGH)
GPIO.output(15,GPIO.HIGH)
#---END TEST(wavewave)---

for x in range(0, 10):
# Wait for xx seconds before repeating
# Blinkie LED to let us know the program is running
GPIO.output(7,GPIO.HIGH)
time.sleep(.1)
GPIO.output(7,GPIO.LOW)
time.sleep(1)
except:
pass


-----
If you are still awake, thanks for checking out the build.  Send a tweet to @OurCatDoor to let us know you were here.
-----

Sunday, February 17, 2013

SpiroGraph 3D Laser Project [with Arduino]

Objective:  Reflect a laser beam off mirrors mounted on three fans to display a 'wild' 3D spirograph type pattern on any surface.  Provide fan speed control (manual or automatic) to adjust the displayed patterns.  Full electrical schematic and source code follows.
-----
If you are not interested in the build and just want to see the result, below is a short video.  If you want to really "trip" out you can watch the 20 minute version.  If you turn up the volume you can hear the fans speeds changing.




-----
If you read through the site, you can see I have been using other micro controllers (MSP430, PIC, PICAXE, Freescale Freedom, etc.)  The Arduino platform is certainly one of the most popular and I wanted to give it a try.

I approached this as an Arduino tutorial project because it combines a lot of basics that go into many projects.  I would recommend it to anyone interested in learning the Arduino because:
  • It's cool (maybe even relaxing) to watch.  Be the envy of your friends...
  • The parts are cheap; many probably already in your kit.
  • Demonstrates reading multiple ADC (Analog to Digital) voltage inputs.
  • Demonstrates multiple PWM (Pulse Width Modulation) outputs to vary LED brightness and control motor speeds.
  • Demonstrates random number generation with the Arduino.
  • Demonstrates using arrays for both variables and pin I/O assignments.
  • Demonstrates the Arduino "mapvalue" scaling function.
  • Demonstrates output of Arduino debug values to the PC screen.
  • Demonstrates multiple voltages being used for a project (12VDC, 5VDC, and 3.3VDC).
  • Demonstrates other program control stuff, etc....
If you are trying to learn the Arduino (or really, any other micro controller) this project beats the hell out of just a "Hello World" blinking LED.  The effect is guaranteed to impress your friends at the next Rave Party.
----
For the project you will need a few items:
  • Arduino (I used the Nano pictured above; $9USD shipped)
  • Laser Diode (check eBay for red ones that sell for ~$1.50USD shipped)
  • Three DC fans or motors (I rescued three 24VDC instrument cooling fans)
  • Three small mirrors and double sided tape to attach then to each fan center
  • Three 10K pots (used to control the fan speed independently)
  • Three LEDs and three 330 ohm resistors
  • AC/DC Power adaptor (I rescued an 18VDC wall wart)
  • LM7805 voltage regulator to tame the output from the wall wart to 5VDC
  • L78L33 voltage regulator (provides a 3.3VDC for the laser diode)
  • TC4469 Quad Motor Driver to provide controlled power to the fans
-----
First thing we need to do is arrange the three fan motors in a box pattern.  I fixed them together with yellow zip ties.  The "wall" on the far left is just a fan housing and where we will mount the red laser diode.  There is a better pic of that later.
-----
Here is a pic of the red laser diode mounted on a thick wire.  You can also see one of the small mirrors mounted to one of the fan's center with double sided tape.  
-----
The red laser beam is aimed so that it reflects off each mirror as it spins, and finally, on onto a wall, etc.  The path of the laser on the spinning mirrors is kinda like this:
-----
Next thing you will need to do connect up a bunch of wires per the schematic below.  Since there is voltage on the project that is higher that the Arduino, the LEDs, or the laser can handle pay special attention when connecting the voltage regulators (LM7805 and L78L33) and components or you will "cook" something.  Also, don't try to skimp out and go without the TC4469 to drive the fans.  The Arduino can't source enough current to drive the fans.  Motor drivers are common in projects so this is a good time learn how to use them anyway.   Click on the schematic to make to bigger.
-----
After connecting everything up, the mess will look something like this:
-----
We still need to program the Arduino Nano to control the project; read the POT locations, adjust the fan speeds and LED brightness, speed change delays, etc.  Simply copy and paste the source code below into the Arduino IDE (Integrated Development Enviroment) installed on your PC.  Then download the source code "sketch" into the Nano.  If this step seems daunting check out this page on the official Arduino site.
/*
 **************************************
 ***** www.WhiskeyTangoHotel.Com  *****
 **************************************
 Project Name: Spyrograph Laser (3 axis)

 Start Date:  Feb 2013

 Program Rev History and Notes: 
 Project controls 3 * 24VDC fans (with mirrors attached to the center).  A laser is
 shined onto the mirror.  A '3D' pattern is drawn on the wall with the laser.

 If a control POT is full up, the fans speed is random.
 If a control POT is full down, the fan turns off.
 Else the control POT varies the fan speed manually.

 ***************************************
 */

// Array starts at VAL 0.  PWM outputs for mirror motors on D9, 10, 11
int Mirror[] = {
  9, 10, 11};

// PWM outpts for LED status monitors,  They mimic the fan speed
int Led[] = {
  3, 5, 6};

// Analog pins.  Read Pots that control mirror motors
int Pot[] = {
  1, 2, 3};

int potvalue[3];  // Store the value of the Pot[] (this value will be 0-1023)
int mapvalue[3];  // We take the potvalue and rescale it for PWM outputs

int DelayVal = 2000;      // how fast for the PWM randon speed hold in mSecs
int KnobBuffer = 10;      // how much of the top end or bottom end of the pot to ignore for random or off fan
int FullSpin = 0;         // always 0. We want to hit mirrors with full power at program start
int MaxSpin = 0;          // 0 is full blast. largest val for PWM on mirros during run mode
int MinSpin = 200;        // 255 is off.  lowest speed/PWM for mirrors

void setup()
{
  //Serial.begin(9600);  // Comment in final version, just for debug...

  for (int i = 0; i<=2; i++) { 
    pinMode(Mirror[i], OUTPUT);      // sets the digital pins as output
    pinMode(Mirror[i], OUTPUT);
    pinMode(Mirror[i], OUTPUT);
  }

  for (int i = 0; i<=2; i++) {  
    pinMode(Led[i], OUTPUT);      // sets the digital pins as output
    pinMode(Led[i], OUTPUT);
    pinMode(Led[i], OUTPUT);
  }

  randomSeed(analogRead(0));    // Pin 0 is connected to nothing and will read 'noise' to generate a random seed

  //Spin the fan up full Speed to start and
  //Blink the LEDs as a self test
  for (int i = 0; i<=2; i++) {  
    digitalWrite(Mirror[i],0); // 0 (full low PWM applies full power the the fans)
    digitalWrite(Mirror[i],0);
    digitalWrite(Mirror[i],0);
  }

  for (int i = 0; i <= 50; i++) {  // Blink the LEDs
    digitalWrite(Led[0], 0);       // 0 turns the LED on
    digitalWrite(Led[1], 0);
    digitalWrite(Led[2], 0);
    delay(20);

    digitalWrite(Led[0], 255);     // 1 turns the LED off
    digitalWrite(Led[1], 255);
    digitalWrite(Led[2], 255);
    delay(20);
  } // endSelf Test Loop

}   //end Setup()

void loop()
{
  // Use Array values in a 'for loop' to Read the POTs and control the LEDs and Fans

  for (int i = 0; i<=2; i++) {  
    potvalue[i] = analogRead(Pot[i]);    // read the position of one of the three POTs
    
    //the mapvalue function will rescale the potvalues (0 to 1023) to a range for PWM output (255 to 0)
    mapvalue[i] = map(potvalue[i], 0, 1023, MinSpin, MaxSpin);   // on LOW (0) from the Arduino would turn fan full on due to TC4469 inverted input.

    if (mapvalue[i] <= KnobBuffer) {   // is pot near full up position randomize that mirror speed
      mapvalue[i] = random(MaxSpin, MinSpin);  
      delay(DelayVal);  // if we are random speeding the mirror then delay to allow for the speed adjustment to settle
    }

    if (mapvalue[i] >= MinSpin) {  // if POT is full down then
      mapvalue[i] = 255;           // turn off this fan (255 is off due to TC4469 inverted input.
    }

    analogWrite(Mirror[i],mapvalue[i]);   // Spin the fan to the selected or calulated speed.  0 = full; 255 = off
    analogWrite(Led[i], mapvalue[i]);     // LED brightness mimics fan speed.  0 = bright; 255 = off

    /* Serial.prints below are for debug.  Remove in final version.
    Serial.print(mapvalue[i]);
    Serial.print("   ");
    delay(500);
    */

    } //end control array for loop

    //Serial.println();  //Serial.print for debug.  Remove in final version.

}  // end void()  end of program code
-----
After you clean up all the wiring, the finished goods will tidy up nicely:



-----
If all goes well (which it will after you sort through your wiring errors, etc) you will be rewarded with your own laser light show.  Time to get out that Pink Floyd album and enjoy your work. 




-----
If you're still with me, thanks or checking out the build page.  This is a great project because it has a high visual effect; a 'wow' factor.  Good luck.
-----
Link back: Hack A Day
Link back: Hacked Gadgets
-----