ArduinoFun.com Blog » Arduino Project http://arduinofun.com/blog - Think It - Build It - Share It - Thu, 01 Apr 2010 22:39:59 +0000 en hourly 1 CoasterBot Part I http://arduinofun.com/blog/2010/04/01/coasterbot-part-i/ http://arduinofun.com/blog/2010/04/01/coasterbot-part-i/#comments Thu, 01 Apr 2010 22:27:16 +0000 Administrator http://arduinofun.com/blog/?p=462 Jameco and Make Zine are holding a contest to build a “CoasterBot,” a mini robot development platform using CD/DVD media as the main body components. I signed up, and this will be my first post documenting my progress. I have my chassis ready so far, and plan to use my Arduino.

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.

Hot Air bending a CDI 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.

CoasterBot chassisAfter 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.

Share/Bookmark]]> http://arduinofun.com/blog/2010/04/01/coasterbot-part-i/feed/ 2 Shapeways.com adds $50.00 Coupon for Arduino Fun Contest http://arduinofun.com/blog/2009/11/18/shapeways-com-adds-50-00-coupon-for-arduino-fun-contest/ http://arduinofun.com/blog/2009/11/18/shapeways-com-adds-50-00-coupon-for-arduino-fun-contest/#comments Wed, 18 Nov 2009 18:14:36 +0000 Administrator http://arduinofun.com/blog/?p=283 ShapeWays.com

ShapeWays.com

ShapeWays.com has added a $50.00 Coupon to the ArduinoFun – Build It- contest! Have you ever wanted to turn your 3D designs into reality? Enter Shapeways! Just upload your design, we print it and ship it to you – it’s easy. Within ten working days you’ll hold your own design in your hands.

But that’s not all – we’re offering you everything you need to meet fellow Shapeways users, share your work and find inspiration.

We’re using a technique called ‘3D Printing’ which has proven itself as a high-quality production technique, but up to now has always been very expensive. By creating a large community we are able to produce much cheaper, meaning better prices for you.

Enter your Arduino project today!

Prizes:

Share/Bookmark]]> http://arduinofun.com/blog/2009/11/18/shapeways-com-adds-50-00-coupon-for-arduino-fun-contest/feed/ 0 Secret Knock Detecting Door Lock (Build It) http://arduinofun.com/blog/2009/11/02/secret-knock-detecting-door-lock-build-it/ http://arduinofun.com/blog/2009/11/02/secret-knock-detecting-door-lock-build-it/#comments Tue, 03 Nov 2009 00:36:51 +0000 Administrator http://arduinofun.com/blog/?p=234 Side view

Side view

Contest Entry by Steve Hoefer

How many times have you seen a secret hideout with a secret knock?  It’s a staple of cheesy dramas, Saturday afternoon movies, and tree houses throughout the world.

While working on another project I ran across the Arduino knock sensor tutorial.  Sensing a single knock is a great little project for learning about microcontrollers, but what about sensing specific knocks?  Seeeeecret knocks?  And if we could detect a secret knock, shouldn’t it unlock a door?   If you can’t tell by looking this was cobbled together from spare stuff around the lab, it’s not much more than a piezo speaker, a tiny gear reduction motor, and an Arduino. And PVC pipe.

UPDATE: 12/31/09 – Since this posting, Steve has updated the blog a bit, tweaked the code a bit and published a full Instructable.

http://grathio.com/2009/11/secret-knock-detecting-door-lock.html

http://www.instructables.com/id/Secret-Knock-Detecting-Door-Lock/

**Disclaimer: This was built with stuff I had lying around the lab.  How about a video to explain:

A microphone (okay, really a speaker) presses against the door and listens for knocks.  If it hears the right number of knocks in the right cadence it triggers the motor to turn the deadbolt and unlock the door.  If the sequence isn’t recognized, the system resets and listens for knocks again.

The default code is Shave and a Hair Cut but if that’s too obvious you can enter a new knock sequence by holding down the red button and knocking your new secret knock (up to 20 knocks).  The rhythm of your favorite song, Morse code, whatever!  The widget will play back your knock (by blinking the lights) so you can be sure it heard everything correctly.

The whole thing is attached to the door with suction cups

The components are simple, most of the work is done in the microcontroller.  The source code for the Arduino is available at the bottom of the page if you’re curious.

How does it work?

First it records the time between knocks.  If there is a long wait for a knock it stops listening and starts analyzing.

Basic circuity

Basic circuity

First it checks the number of knocks.  If that’s right, we go on to more vigorous authentication.   First it converts the absolute timing of the knocks to the rhythm of the knocks.  This lets us knock fast or slow and as long as we get the rhythm right it will unlock.  That way I can still unlock the door if I’m tired or full of caffeine.  After this it compares the timing with the secret key and if any individual knock is off by too much or the whole thing is off by a certain average amount the door stays locked.  If not, we trigger the motor to turn and the lock to unlock.  If the programming button is pressed it saves the rhythm information and then plays it back.

The detection is surprisingly accurate and can even be dialed up so it’s precise enough  to detect an individual person’s variation on a knock, similar to a Morse coder’s ‘fist‘.  (Though when the verifying is this tight it also triggers false negatives which are annoying.)

To keep things simple (and it’s because it’s what I had available) a motor is attached to the deadbolt using two pieces of spring steel bolted across the D shaft of the motor so that the connection will slip when the lock turns as far as it can. A more precise (and probably durable) way to do it would be to use a servo to turn the lock or have a detector sense when the lock had reached its extent.  Or replace the dead bolt with a solenoid.  Or whatever else you can think of.

Circuit fitting

Circuit fitting

The rest of the electronics are nothing special.  Its so simple that just adding feedback LEDs almost doubled the parts count.  The Arduino has a lot of unused potential on this project.

No proper schematic yet, but there’s a layout and parts list at the bottom of the page. Look for a fully documented Instructable soon.

With some extra electronics (an H-bridge) it would be possible to have the door automatically lock as well as unlock. Other improvements or changes that someone could do:

  • Adding a knob to adjust the sensitivity.
  • Building it into an actual door knocker.
  • Using a more economical microcontroller and enabling a sleep mode for better battery life.
  • Making the whole package small enough to fit inside the door.
  • Storing several knocks so several people can have their own private knocks.
  • Adding a real-time clock and using different knocks for different days of the week or times of day.
  • Listening for door bell presses rather than door knocks.
  • Adding a servo or solenoid powered knocker to provide feedback through the door.  It could then offer a challenge-response security where the door starts a knock sequence and the user has to finish it correctly.
  • Rather than listening for knocks, putting a photoresistor in the peep hole and detecting flashes of light from a pocket flashlight or simply by placing your hand over the peephole. Or an infrared receiver and use special key presses on a remote control.
Knock sensor layout (click for larger view)

Knock sensor layout (click for larger view)

Do I have to point out that this is not a great security measure since overhearing a knock sequence is pretty trivial?  No.  But it’s fun to make and play with.

Here’s my code: If you have trouble with cut and paste below you can download the .pde file here.

  1. /* Detects patterns of knocks and triggers a motor to unlock
  2. it if the pattern is correct.
  3.  
  4. By Steve Hoefer http://grathio.com
  5. Version 0.1.09.10.24
  6. Licensed under Creative Commons Attribution-Noncommercial-Share Alike 3.0
  7.  
  8. Analog Pin 0: Piezo speaker (connected to ground with 1M pulldown resistor)
  9. Digital Pin 2: Switch to enter a new code.  Short this to enter programming mode.
  10. Digital Pin 3: DC gear reduction motor attached to the lock. (Or a motor controller or
  11. a solenoid or other unlocking mechanisim.)
  12. Digital Pin 4: Green LED.
  13. Digital Pin 5: Red LED.
  14. */
  15.  
  16. // Pin definitions
  17. const int knockSensor = 0;
  18. // Piezo sensor on pin 0.
  19. const int programSwitch = 2;
  20. // If this is high we program a new code.
  21. const int lockMotor = 3;
  22. // Gear motor used to turn the lock.
  23. const int redLED = 4;
  24. // Status LED
  25. const int greenLED = 5;
  26. // Status LED
  27.  
  28. // Tuning constants.
  29. // Could be made vars and hooked to potentiometers for soft configuration, etc.
  30. const int threshold = 4;
  31. // Minimum signal from the piezo to register as a knock
  32. const int rejectValue = 25;
  33. // If an individual knock is off by this percentage of a knock we don’t unlock..
  34. const int averageRejectValue = 15;
  35. // If the average timing of the knocks is off by this percent we don’t unlock.
  36. const int knockFadeTime = 150;
  37. // milliseconds we allow a knock to fade before we listen for another one. (Debounce timer.)
  38. const int lockTurnTime = 450;
  39. // milliseconds that we run the motor to get it to go a half turn.
  40.  
  41. const int maximumKnocks = 20;
  42. // Maximum number of knocks to listen for.
  43. const int knockComplete = 1200;
  44. // Longest time to wait for a knock before we assume that it’s finished.
  45.  
  46. // Variables.
  47. int secretCode[maximumKnocks] = {50, 25, 25, 50, 100, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
  48. // Initial setup: "Shave and a Hair Cut, two bits."
  49. int knockReadings[maximumKnocks];
  50. // When someone knocks this array fills with delays between knocks.
  51. int knockSensorValue = 0; // Last reading of the knock sensor.
  52.  
  53. void setup() {
  54. pinMode(knockSensor, OUTPUT);
  55. pinMode(lockMotor, OUTPUT);
  56. pinMode(redLED, OUTPUT);
  57. pinMode(greenLED, OUTPUT);
  58. pinMode(programSwitch, INPUT);
  59.  
  60. //Serial.begin(19200);
  61. // Uncomment the Serial.bla lines for debugging.
  62. //Serial.println("Program start.");  // This line too.
  63.  
  64. digitalWrite(greenLED, HIGH);
  65. // Green LED on, everything is go.
  66. }
  67.  
  68. void loop() {
  69. // Listen for any knock at all.
  70. knockSensorValue = analogRead(knockSensor);
  71. if (knockSensorValue >=threshold){
  72. listenToSecretKnock();
  73.   }
  74. }
  75.  
  76. // Records the timing of knocks.
  77. void listenToSecretKnock(){
  78. //Serial.println("knock starting");    // debug.
  79. int i = 0;
  80. // First lets reset the listening array.
  81. for (i=0;i=threshold){   //got another knock…
  82. //record the delay time.
  83. now=millis();
  84. knockReadings[currentKnockNumber] = now-startTime;
  85. currentKnockNumber ++;   //increment the counter
  86. startTime=now;
  87. // and reset our timer for the next knock
  88. digitalWrite(greenLED, LOW);
  89. delay(knockFadeTime);
  90. // again, a little delay to let the knock decay.
  91. digitalWrite(greenLED, HIGH);
  92. }
  93.  
  94. now=millis();
  95.  
  96. //did we timeout or run out of knocks?
  97. } while ((now-startTime < knockComplete) &amp;&amp; (currentKnockNumber < maximumKnocks));
  98.  
  99. //we’ve got our knock recorded, lets see if it’s valid
  100.  
  101. if (validateKnock() == true){
  102. triggerDoorUnlock();
  103. } else {
  104. //Serial.println("Secret knock failed.");
  105. digitalWrite(greenLED, LOW);
  106. // We didn’t unlock, so blink the red LED as visual feedback.
  107.     for (i=0;i<4;i++){
  108.       digitalWrite(redLED, HIGH);
  109.       delay(100);
  110.       digitalWrite(redLED, LOW);
  111.       delay(100);
  112.     }
  113.     digitalWrite(greenLED, HIGH);
  114.   }
  115. }
  116.  
  117. // Runs the motor (or whatever) to unlock the door.
  118. void triggerDoorUnlock(){
  119. //Serial.println("Door unlocked!");
  120. int i=0;
  121.  
  122. // turn the motor on for a bit.
  123. digitalWrite(lockMotor, HIGH);
  124. digitalWrite(greenLED, HIGH);
  125. // And the green LED too.
  126.  
  127. delay (lockTurnTime);   // Wait a bit.
  128.  
  129. digitalWrite(lockMotor, LOW);  // Turn the motor off.
  130.  
  131. // Blink the green LED a few times for more visual feedback.
  132. for (i=0; i < 5; i++){
  133. digitalWrite(greenLED, LOW);
  134. delay(100);
  135. digitalWrite(greenLED, HIGH);
  136. delay(100);
  137.   }
  138.  
  139. }
  140.  
  141. // Sees if our knock matches the secret.
  142. // returns true if it’s a good knock, false if it’s not.
  143. // todo: break it into smaller functions for readability.
  144. boolean validateKnock(){
  145. int i=0;
  146.  
  147. // simplest check first: Did we get the right number of knocks?
  148. int currentKnockCount = 0;
  149. int secretKnockCount = 0;
  150. int maxKnockInterval = 0;
  151. // We use this later to normalize the times.
  152.  
  153. for (i=0;i 0){
  154. currentKnockCount++;
  155.     }
  156. if (secretCode[i] > 0){  //todo: precalculate this.
  157. secretKnockCount++;
  158.     }
  159.  
  160. if (knockReadings[i] > maxKnockInterval){
  161. // collect normalization data while we’re looping.
  162. maxKnockInterval = knockReadings[i];
  163.     }
  164.   }
  165.  
  166. // If we’re recording a new knock, save the info and get out of here.
  167. if (digitalRead(programSwitch)==HIGH){
  168. for (i=0;i< maximumKnocks ; i++){
  169. digitalWrite(greenLED, LOW);
  170. digitalWrite(redLED, LOW); // only turn it on if there’s a delay
  171. if (secretCode[i] > 0){
  172. delay( map(secretCode[i],0, 100, 0, maxKnockInterval));
  173. // Expand the time back out to what it was.  Roughly.
  174. digitalWrite(greenLED, HIGH);
  175. digitalWrite(redLED, HIGH);
  176.         }
  177. delay(50);
  178.       }
  179. return false;
  180. // We don’t unlock the door when we are recording a new knock.
  181.   }
  182.  
  183. if (currentKnockCount != secretKnockCount){
  184. return false;
  185.   }
  186.  
  187. /*  Now we compare the relative intervals of our knocks, not the absolute time between them.
  188. (ie: if you do the same pattern slow or fast it should still open the door.)
  189. This makes it less picky, which while making it less secure can also make it
  190. less of a pain to use if you’re tempo is a little slow or fast.
  191. */
  192. int totaltimeDifferences=0;
  193. int timeDiff=0;
  194. for (i=0;i rejectValue){ // Individual value too far out of whack
  195. return false;
  196.     }
  197. totaltimeDifferences += timeDiff;
  198.   }
  199. // It can also fail if the whole thing is too inaccurate.
  200. if (totaltimeDifferences/secretKnockCount>averageRejectValue){
  201. return false;
  202.   }
  203.  
  204. return true;
  205.  
  206. }
Share/Bookmark]]> http://arduinofun.com/blog/2009/11/02/secret-knock-detecting-door-lock-build-it/feed/ 4 Silly String Shooting Spider (Build It) http://arduinofun.com/blog/2009/11/01/silly-string-shooting-spider-contest-entry/ http://arduinofun.com/blog/2009/11/01/silly-string-shooting-spider-contest-entry/#comments Mon, 02 Nov 2009 00:43:22 +0000 Administrator http://arduinofun.com/blog/?p=215 Silly String Spider

Silly String Spider

Contest Entry by Todd Harrison

I had great fun this Halloween with a silly string shooting spider!  My plan was to use an Arduino micro-controller developer board to control my son’s “Teenage Mutant Ninja Turtle” RC car that already shoots silly string.  I didn’t get the spider to actually squirt the silly string but when you’re looking at a big black spider and something shoots silly string at you from the same direction it scares you just the same.

I was inspired to do this 4 hour marathon build by a blog posting by Eric on www.Instructables.com. Eric created a silly string shooting pumpkin which was so incredible I just had to build a spider for Halloween that did the same.

My major problem was that once I heard about Eric’s pumpkin I only had a day to get the supplies and about 4 hours of free time to wire-up something, code it and get it out in the front yard before the kids started coming for tricks or treats.

Here is a component breakdown of the final prop.

  • The red dot and arrow point to the RC car hiding under a bush.
  • 2) RC car remote control.
  • 3) Relay used by pin 2 on the Arduino to fire the remote control’s silly string button.
  • 4) Arduino board: Duemilanove with ATmega328 Purchased from adafruit.com
  • 5) Small blue servo to yank on the spiders leg: TowerPro SG-50.
  • 6) Two red LEDs for spider eyes. Not on the spider I know, I ran out of dev time
  • 7) Parallax Ping))) sonar sensor, held up with helping hands.
  • 8 ) Big black spider
Silly String Spider Parts

Silly String Spider Parts

I originally wanted the string to shoot from the spider’s behind but I really didn’t have time for that so I hid the RC car in the bushes behind the spider and loaded it with a fresh can of silly string.  All I really had to do was get the Arduino to sense somebody getting to close to the spider’s face and then “POW!” fire the silly string using the car’s remote control.

Just for extra effect I wanted the spider to move using a servo and have red LED eyes that blinked.  I also wanted the blinking and servo movement to ramp up faster and faster as a person got closer. To get this effect I used a Parallax Ping))) sonar sensor to track the approaching prey as well as to calculate an agitation delay.  The agitation delay was used to make the spider look more and more upset as the person got closer. If somebody was at a great distance the LED eyes flashed slow and the spider made slow jerking motions, but as the distance delay multiplier shortened the eyes flash furiously fast and the spider would jerk like mad!  If the trick-or-treater dared get closer the Arduino would fire a relay connected to the remote control and they would get a face full of silly string.

Silly String Spider Board Control

Silly String Spider Board Control

A lot of people did have the nerve to walk up on the spider but in the dark it took them a second to even realize they had just been doused in the face with silly string, but then they would laugh and do it again just for fun.  It only really scared a few that didn’t expect anything or were just standing behind the intended victim who was fortunately to short to get hit.

I didn’t get time to mount the eyes in the spider’s head but the red flashing LEDs on the control board seemed to have the same effect as they would have had if they were on the spider.  They were only needed to get the kids attention in the dark.

Arduino Sketch:

  1. #include
  2. Servo myservo;  // create servo object to control a servo
  3.  
  4. int pingPin = 7; // pin for ping sensor
  5. int stringPin = 2; // pin that will fire the silly string remote
  6. int LED_Eyes_Pin = 11; // pin for the two eyes
  7. int multiplier; // multiplier for delay
  8. int delay_time; // time to delay before next step
  9.  
  10. void setup() {
  11.   pinMode(LED_Eyes_Pin, OUTPUT);
  12.   pinMode(stringPin, OUTPUT);
  13.   myservo.attach(9);  // attaches the servo on pin 9 to the servo object
  14.   Serial.begin(9600);
  15.   digitalWrite(stringPin, LOW);    //make sure this is off so we don’t shoot string
  16. }
  17.  
  18. void loop() {
  19.   ping();
  20.   eyes_and_servo(0,0);
  21.   delay(delay_time);
  22.  
  23.   ping();
  24.   eyes_and_servo(100,255);
  25.   delay(delay_time);
  26. }
  27.  
  28. void eyes_and_servo(int servo_pos, int eye_pulse)
  29. {
  30.   analogWrite(LED_Eyes_Pin, eye_pulse);
  31.   myservo.write(servo_pos);
  32. }
  33.  
  34. void ping()
  35. {  long duration, inches;
  36.  
  37.   // The PING))) is triggered by a HIGH pulse of 2 or more microseconds.
  38.   // We give a short LOW pulse beforehand to ensure a clean HIGH pulse.
  39.   pinMode(pingPin, OUTPUT);
  40.   digitalWrite(pingPin, LOW);
  41.   delayMicroseconds(2);
  42.   digitalWrite(pingPin, HIGH);
  43.   delayMicroseconds(5);
  44.   digitalWrite(pingPin, LOW);
  45.  
  46.   // The same pin is used to read the signal from the PING))): a HIGH
  47.   // pulse whose duration is the time (in microseconds) from the sending
  48.   // of the ping to the reception of its echo off of an object.
  49.   pinMode(pingPin, INPUT);
  50.   duration = pulseIn(pingPin, HIGH);
  51.   // convert the time into a distance
  52.   inches = microsecondsToInches(duration);
  53.   multiplier = inches/10;
  54.  
  55.   delay_time = inches * multiplier;
  56.  
  57.   if (delay_time > 1000) {delay_time = 500;};
  58.  
  59.   if (delay_time < 300) {
  60.      digitalWrite(stringPin, HIGH);
  61.      delay(500);
  62.      digitalWrite(stringPin, LOW);
  63.      delay(2000);
  64.    };
  65.  
  66.   Serial.print(delay_time);
  67.   Serial.print(” delay time; inches are= “);
  68.   Serial.print(inches);
  69.   Serial.println();
  70. }
  71.  
  72. long microsecondsToInches(long microseconds)
  73. {
  74.   return microseconds / 74 / 2;
  75. }

Project Videos

Share/Bookmark]]> http://arduinofun.com/blog/2009/11/01/silly-string-shooting-spider-contest-entry/feed/ 1 Arduino Halloween Dropping Spider (Build It) http://arduinofun.com/blog/2009/11/01/arduino-halloween-dropping-spider-contest-entry/ http://arduinofun.com/blog/2009/11/01/arduino-halloween-dropping-spider-contest-entry/#comments Sun, 01 Nov 2009 20:32:34 +0000 Administrator http://arduinofun.com/blog/?p=196

Halloween Dropping Spider

Halloween Dropping Spider

Contest Entry by Noel Portugal

My Halloween project consisted of a dropping spider triggered by a PIR motion sensor mounted on a Jackolantern. The motion sensor triggered a dropping spider, lights, sounds, low laying fog and finally a tweet with a picture attached.

Setup: It’s all pretty basic. The arduino controlled the PIR motion sensor, the servos for dropping spider reel, Jackolantern LED lights, toy with scary sound, and the X10 CM17A. Then the arduino sent a serial message to the ioBridge serial API telling to GET the URL of my site. Then on my site I had a bash script with a while loop looking for request coming from the ioBridge server, then the script played a sound, grab the picture from a wireless webcam and post it to twitter via twitpic’s API using cURL.

Arduino Halloween Dropping Spider

Arduino Halloween Dropping Spider

Arduino Sketch
Here is the arduino sketch. I used the X10Firecracker and the Servo libraries as well as the PIR sensor example from the arduino playground.

Spider Reel
I end up using an VHS tape as a reel. I had to modify one servo to have continuous rotation. I used this guide to do so. The second servo just did the lift part.

ioBridge Monitor
To establish the arduino-ioBridge serial communication I was planning to use an RF solution, but due to time constraints I had to use a long speaker cable to connect the arduino TX to ioBridge’s Serial Board RX with one wire and the second for GND.

This is the bash script I used to trigger a sound as well as send a twitpic.

  1. #!/bin/bash
  2. booCounter=$1
  3. while true;do
  4. status=`tail -n 1 /private/var/log/apache2/access_log | cut -f 1 -d "-"`
  5. if [ "$status" = "00.00.000.000 " ]
  6. then
  7. echo "Boo" >> /private/var/log/apache2/access_log
  8. afplay /full/path/Halloween/werewolf.mp3
  9. msg="Boo, victim $booCounter just got really scared"
  10. sleep 5
  11. curl -O http://www.mywebcam.com/IMAGE.JPG
  12. curl -F media=@/full/path/Halloween/IMAGE.JPG -F "username=username" -F "password=password" -F
  13. "message=$msg" http://twitpic.com/api/uploadAndPost
  14. let booCounter=booCounter+1
  15. fi
  16. done

I used my mac os x Apache 2 server. I had to give write permissions to the access_log so I could append a bogus line as a “break”.

These are the parts that I used for this project:

Arduino Duemilanove
o Adafruit Protoshield

ioBridge IO-204
o ioBridge Serial Smart Board

x10 Firecracker CM17A
o x10 Transeiver, Appliance and lamp modules

VHS tape
o 2 Futaba S3003 servos
o Nylon rope

Plastic Jackolantern
o Parallax PIR sensor
o 2 red LEDs
+ 2 1K resistors
o Checklane Yada Yada Yada (thanks Erick for the tip http://www.instructables.com/id/Arduino-controlled-Silly-String-shooter/)
+ 1 2N2222 tranisistor
+ 1 10k resistor

Fog Machine
o 125VAC/10A DPDT Plug-In Relay (as a switch combined with x10)
o Styrofoam cooler and dryer hose and Ice to create low laying fog.

Wireless webcam
Lights and accesories
o Incandescent black light, strobe light, black light bulbs.

Project Video:

Share/Bookmark]]> http://arduinofun.com/blog/2009/11/01/arduino-halloween-dropping-spider-contest-entry/feed/ 0 Open Source ADM-Robot 1.0 (part 1) http://arduinofun.com/blog/2009/11/01/open-source-adm-robot-1-0-part-1/ http://arduinofun.com/blog/2009/11/01/open-source-adm-robot-1-0-part-1/#comments Sun, 01 Nov 2009 18:37:13 +0000 Administrator http://arduinofun.com/blog/?p=174 Drew and Jacob - Soldering boards

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

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

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

Share/Bookmark]]> http://arduinofun.com/blog/2009/11/01/open-source-adm-robot-1-0-part-1/feed/ 5