The folks over at [Soup], a British marketing agency, thought up this cool project. It’s a set of handbells hooked up to an Arduino, actuated by central locking motors found in car doors. By the look of some pictures, there was also a Lego version. Songs written by users (through the online interface) are placed in the que of a server. Once it’s time for the song to be played, serproxy sends the Arduino an appropriate set of commands for ringing the bells in sequence. All of this happens in the [Soup] office while it is streaming live through a webcam.

We think that this is definitely a great way to use surplus auto parts. After all, not everyone can build helicopters.

It seems as though the bells are down for the moment, or the employees got a bit annoyed at hearing them constantly ring.

Thanks to [Josh, Kyle, and Mike], it is now possible to wage (Nerf) war with an Arduino. The turret designed around it is capable of shooting 6 foam projectiles in close succession, between reloads. The faux weapon interfaces with a computer through the Arduino’s onboard serial link (via USB). Software on the PC sends commands to the Arduino, which then executes functions, such as panning, tilting, firing, and rotating the cylinder. The power for the firing itself comes from a 5 gal, 80 psi air compressor. The Java software on the host PC also does smarter things, like show streaming video from the turret’s webcam and even performs basic object tracking (with mixed success). All the code for building the brute is available on [Josh's] website.

[Fun3] wasn’t satisfied with current methods for duplicating Philips Ambilight. He wanted a completely plug and play solution without soldering so he could expand upon it in the future. This meant Arduino, ShiftBright, and (it pains us to say this) pre-made cables. Some of you are cringing at the thought of no real ‘work’ being necessary, but remember, now this is much easier for your “I can’t change the VCRs clock” aunt to set up and enjoy. Plus it’s quick, easy, and most importantly – clean, something a lot of hackers have a problem with.

We’ve seen the Arduino board in charge of some pretty unique tasks in the past. Harvesting locally grown soybeans was not one of them.

[Lance] rigged this beast up in order to automate the monotonous task of driving up and down the vast soybean fields of Iowa. The 15 ton farm combine’s hydraulic steering pump is at the mercy of a team of gadgets, including a GPS, Windows 7 PC, and the omnipresent Duemilanove (which acts as the output card, connecting the PC to the pump). So far, it is reported to be doing a great job, straying only about an inch and a half from its desired, GPS-programmed, path. Even if the Arduino decides to go totally berserk and drive the combine off course, speeding around at 5mph makes it pretty avoidable. A supervisor is also in the cabin at all times, looking out for errors. [Lance] eventually hopes to offload all steering-related calculations to the ATmega328P onboard.

Commenters are welcome to share heavier-duty uses for the Arduino (if they exist).

I’ve been having some fun with a Sparkfun Serial-enabled LCD screen (LCD-09393, $24.95). This little package will write out whatever you send along a serial data line. So this means you can add an LCD to a project with only three wires:  +V, GND, and RX (serial receive). In the real world, I’m hoping to use these LCDs in some lab instruments that we’ll be building in the spring semester. In particular, I’m looking at an arduino-based frequency counter. I also want to explore an arduino-based PID controller for various lab projects (temp. control, etc.).

My first test, however, was just getting the LCD to work. And then, I wanted to make it show my Twitter status. I’ve been using twitter (DrDawes) to post my office status and give students updates as to where I am or when I may be around again. This has been helpful since my research lab is in another building and I tend to be available but it may not look like it since I’m not in the physics building. This way if I want to step over to the lab, I can simply send an update, and save people the trouble of tracking me down. The rub is that not everyone has twitter, and sometimes people just come to my office anyway. That said, my goal is to post a 16×2 LCD screen on my door so that my availability status (formerly written on a whiteboard, or post-it) can be more 21st century.

As of this weekend, the whole system is working, although not yet installed. I’m running an Arduino as the LCD controller, but really it’s just reading serial from the computer and writing serial to the LCD, so I’m sure there is a more efficient way (I’ll work on that for v2.0). The arduino code is given below:

#include <SoftwareSerial.h>

#define txPin 2

int incomingByte = 0;    // for incoming serial data

SoftwareSerial LCD = SoftwareSerial(0, txPin);
// since the LCD does not send data back to the Arduino, we should only define the txPin

void setup()
{
 Serial.begin(9600);
 pinMode(txPin, OUTPUT);
 LCD.begin(9600);
}

void loop()
{
 if (Serial.available() > 0) {
 // read the incoming byte:
 incomingByte = Serial.read();
 LCD.print(incomingByte,BYTE);
 }
}

I like python, so I used it for the computer end of the project. The only things I had to figure out were how to write hex bytes to the serial port, and how the LCD memory was laid out. I wanted it to be a bit fancier than stock so I wrote two functions, one that scrolls the text across the LCD and one that pages it up line by line. This is necessary since twitter runs up to 140 characters and I can only show 32 on the LCD (at a time).

#!/usr/bin/env python
# encoding: utf-8
"""
TweetLCD.py

This twitter-to-LCD script implements two functions for displaying
text on a Sparkfun Serial LCD.

 scrollText - allows long lines of text to be scrolled along the top of the LCD
 pageText - allows long text to be paged up. First the top line is written, then
 the bottom line, then the lines shift up, and more text is
 written on the bottom line.

Created by Andrew M.C. Dawes on 2009-12-18.
Copyright (c) 2009 Andrew M.C. Dawes.
Some rights reserved. License: Creative Commons GNU GPL:

http://creativecommons.org/licenses/GPL/2.0/

"""

import serial, time, sys, twitter
SERIALPORT = "/dev/tty.usbserial-A6008cAP" # this is my USB serial port YMMV

def pageText(textstring, s):
 botline = ""
 cursor = 0
 for letter in textstring:
 # print letter, cursor     # this is for debugging
 s.write(letter)

 if cursor > 15:
 # I'm printing in second line so keep track of what I write
 botline = botline + letter
 # print botline

 if cursor == 31: # page the bottom line up to top, clear bottom, and write
 # print "cursor wrap"
 s.write('\xFE\x80') # wrap to start of first line
 s.write(botline) # write what was on the bottom (now on top)
 s.write("                ")
 s.write('\xFE\xC0') # skip to beginning of second line
 botline = ""
 cursor = 15 # reset to beginning of second line

 cursor = cursor + 1

 time.sleep(0.15) # set this delay to a comfortable value

def scrollText(textstring, s):
 nextstring = ""
 cursor = 0
 firstpass = True # test whether this is the first 16 characters
 for letter in textstring:
 if firstpass == False:
 s.write('\xFE\x18') # scroll left one spot at each letter

 # print letter, cursor    # this is for debugging
 s.write(letter)

 if cursor == 15:
 # I'm printing the last visible character
 s.write('\xFE\x90') # jump cursor to 2nd column of 16
 firstpass = False # once the first row is filled, we need to scroll

 if cursor == 31:
 s.write('\xFE\xA0') # jump cursor to 3rd column

 if cursor == 39:
 cursor = -1 # start over, there are only 40 characters in memory
 s.write('\xFE\x80') # this is the original character address.

 cursor = cursor + 1

 time.sleep(0.2) # adjust this to a comfortable value

def main():
 s = serial.Serial(SERIALPORT, 9600)
 time.sleep(2)
 s.write('\xFE\x01') # clear the LCD screen
 while(True):
 time.sleep(1)
 s.write('\xFE\x80') # goto 0 position
 api = twitter.Api()
 status = api.GetUserTimeline(user='DrDawes',count=1)[0]
 # textstring = "1111111111111111222222222222222233333333333333334444444444444444"
 textstring = "DrDawes@twitter: " + status.text
 scrollText(textstring,s) # choose one of these
 # pageText(textstring,s) # two options
 time.sleep(2)
 s.write('\xFE\x01') # clear the screen (in preparation to repeat)

 s.close()

if __name__ == '__main__':
 main()

You can see the two functions scrollText() and pageText() are responsible for cursor control and text movement. I’m still not sure which one I like better, but feel free to use these if you want them. The strange characters are pythons way of sending hex bytes as strings. The LCD uses the standard HD44780 controller, so there are special commands for controlling the LCD. For example, sending the string “\xFE\x01″ in python sends two hex bytes: 0xFE and then 0×01. This happens to be the command to clear the LCD screen. The cursor motion is controlled in a similar way, with address locations following the \xFE byte. 0×80 is the first position so I send \xFE\x80 to move the cursor there. Similarly, \x90 is the 17th horizontal position in the top line, not viewable without scrolling and \xA0 is the 33rd position in the top line. There are 40 positions in each line (2 rows in my case) so the scrolling text function checks for this and wraps the cursor accordingly.

The other nifty command used in scrollText() is \x18 which scrolls the text to the left (the way we want to scroll in order to read it). You can see in the code that scrolling doesn’t start until the first row is full of characters, once that happens it continues to scroll until all text has been shown. For scrolling, I take advantage of the fact that there are only 40 characters in memory and scrolling the screen has what I would call periodic boundary conditions (if you scroll past the end, you just get the beginning again). This makes it easy to write more than 40 characters to the display.

As part of my tinkering, I’ve also figured out a number of additional extended commands for the HD44780. Some are mentioned in the sparkfun datasheet, but there is a cryptic comment about many others existing. Check back for a future post with more of the details.

The team at [Sosolimited] was contracted to create an interesting holiday window dispay for the HBO retail store in NYC. The Times Square display encorporates a board of LEDs and a machine for blowing the artificial snow particles around the enclosure.

The code for controlling the LED array was written on top of the open source C++ toolkit, openFrameworks and the entire setup is interfaced through an Arduino Duelmilanove. Multiple Sharp IR sensors were hooked up to the Arduino in order to detect the movement of observers, which in turn triggers fans to blow the ’snow’ around. A National Control Devices relay board connects the heavy duty fans to the Arduino. This video demo shows just how attractive the project is in motion.

[Peter] thought of a creative, way to generate random entropy for under $100.

The USB Hourglass combines a sand timer with a rotating mechanism and an optical beam through the center of the timer to observe the falling sand. The amount of light reaching a detector is digitized at frequent intervals and processed by a microcontroller to determine when to rotate the hourglass. The digitized light levels are also sent by USB to a host PC where they can be used as a source of random entropy. Power is supplied over the USB cable.

With the USB Hourglass, the user can look at the sand falling through the center of the hourglass and monitor the randomness in the USB output data. And one can read the code line-by-line, compile it, and upload it to the microcontroller using only open-source and widely supported tools.

Build details and code here.

I have finally received my servo motors and finished building the bot.

I will try to post some video later… follows some pictures.

Being avid fanatics of flashing lights, we always love to see the peggy2 in action. The video above shows another improvement, which is two peggy2 units working together as one. [iservice2000] chained the two together and wrote new code for the display. Using an Arduino to drive it all, he has gotten them to act as one. While video on the peggy2 isn’t new, this is the first time we’ve seen two of them chained together. The end result is going to be a scrolling sign that can be updated via the web, or that can display tweets. We did notice a bit of tearing, is that from the camera or the software?

[via littlebirdceo]

Yes, your eyes do not lie, that is 12 cameras rigged to take a picture at the exact same moment. The idea is a single camera loses data (namely depth) when it takes a 3D image and transposes it onto a 2D medium. FuturePicture somewhat circumvents this loss by taking several pictures with different focus distances. In short, the camera array allows you to focus on multiple items within a scene. The project’s hardware and software have yet to be released (we do know it’s at least Arduino), but they plan to make it entirely open source so everyone can experiment. Of course, we’ll keep you up to date.
[via Make]

One of our favorite demos on the XBoard used to be playing a Bach aria  through a piezo speaker. I have just recreated the same sound using code for the Arduino and the Machine Science I/O Module. It was a little more impressive demo before the advent of polyphonic ring tones, but still nice sound for a little speaker. A feature of the I/O Module is that the entire song can be played with one line of code.  Also it can play while the Arduino is busy doing other important tasks.

Below is the sample code and a sound file from the device.

#include <machinescience.h>
#include <iomod.h>

unsigned int bach_aria[150] = {
 G5,No02,
 G5,No02,
 A5,No16,
 G5,No16,
 A5,No04,
 B5,No08,
 A5,No04,
 G5,No08,
 F5S,No08,
 E5,No04,
 D5,Nd02,
 G4,No16,
 F4S,No16,
 G4,Nd04,
 A4,No16,
 G4,No16,
 F4S,No16,
 G4,No16,
 A4,No16,
 G4,No16,
 A4,No16,
 G4,No16,
 A4,Nd32,
 G4,Nd32,
 A4,No32,
 G4,No32,
 A4,No32,
 G4,No16,
 F4S,No08,
 G4,No08,
 A4,No16,
 G4,No16,
 F4S,No08,
 G4,No16,
 F4S,No16,
 E4,No08,
 E4,No04,
 D4,Nd02,
 D5,No02,
 D5,No02,
 E5,No16,
 D5,No16,
 E5,No04,
 F5,No08,
 E5,No04,
 D5,No08,
 C5,No08,
 B4,No04,
 A4,No02,
 G5,No16,
 F5S,No16,
 E5,No16,
 F5S,No16,
 G5,No16,
 F5S,Nd08,
 A5,No16,
 G5,Nd08,
 F5S,No16,
 E5,Nd08,
 D5,No16,
 C5,Nd08,
 C5,No08,
 A5,No04,
 C5,No08,
 B4,No16,
 G4,Nd08,
 F4S,No04,
 F4S,No08,
 G4,No16,
 F4S,No16,
 G4,Nd04};

void setup() {
 network_control(ENABLE);
 iomod_song(bach_aria, 71);
}

void loop()
{
}

XIPMod code libraries and example sketches are available for the Arduino. Now you can control any Machine Science XIPMod using an Arduino, instead of a master module.

Download the XIPMode code library for the Arduino.

Merve is working on an Arduino-driven logic analyzer design in the Arduino Forum. It uses logic chips to drive SRAM memory during acquisition, the Arduino then dumps samples from the SRAM via a shift register.

We’re really interested in the result of this design. We once attempted a logic chip-based analyzer, but the design got complicated at high speeds because of the need for 16bit+ synchronous counters to drive the SRAM. Instead, we moved to CPLDs to try and squeeze all the logic ICs into a single, reprogrammable chip.

Several readers submitted a link to this post, thanks for the tip!

Here’s a Christmas tree project we can get behind. The “tree” itself is made of twisted pairs of insulated copper wire.  At the end of each pair a surface mount LED has been soldered between the two conductors.  All of the wire limbs converge into a 4×4 matrix. One tree uses a prototyping shield and an Arduino, the other tree is just using an ATtiny2313 microprocessor. Take a look at the twinkling tree in the video after the break.

This artful creation uses one color of LEDs.  We’d love to see future improvements that incorporate multiple colors, enhance the fading effects, and perhaps add some interactivity such as pulsing to an inspiring rendition of Chestnuts Roasting on and Open Fire (which, consequently, is called “The Christmas Song“).

The goal of this project is developing a wireless glove and a software framework to manipulate a parametric model in Rhino 3D. The glove reads user’s hand movement and gestures using mounted sensors on it. Then a LilyPad Arduino gathers sensors data as input, processes them, and sends them using a XBee module wirelessly to the computer. The software framework on computer gets sent data using another XBee module, connected to the computer. Finally, the framework translate data to information for controlling the parametric model in Rhino 3D.

Link to documentation: http://mtifall09.wordpress.com/files/2009/12/rhinoglove.pdf

Link to Arduino sketch: http://code.arc.cmu.edu/~cheng/uploads/RhinoGloveSketch.pde

Link to Grasshopper definition: http://rapidshare.com/files/321715436/Rhino_Glove.ghx

Link to video: http://www.youtube.com/watch?v=6A5I48RLtx4

A new chapter!

we tried some new simple interactions this morning.

First of all we used this code

int value = 0;
void setup() {
Serial.begin(9600);
<pre>}</pre>
//sets a signal on arduino's serial port?
void loop () {
value += 1; //values constantly plus one
Serial.println(value, DEC); // graphic visualization of the function
delay (5); //function delay, a number every 5 millisecond
}

Using the serial number and giving the command “println” is useful. The program records its outputs and clicking on the export button on the arduino program we’ll have a window with a numeric representation of every output. You can use it to check your program and to see if everything is going how is supposed to be.

After that we worked again on some basics with the leds.

//in order to get a simulation of an analogic output
//i must use a pwm pin
int ledPin =  3;    // LED connected to digital pin 3
int ledVal = 5;  //defines brightness
// The setup() method runs once, when the sketch starts
void setup()   {
 // initialize the digital pin as an output:
 pinMode(ledPin, OUTPUT);
}
void loop()  {
for  (int x=0; x<255; x++) { //defines x,fix a limit and establish that is gonna grow up
 analogWrite(ledPin, x); // pin brightness is gonna grow up
 delay(5); //imposta ritmo //with this rithm
}
for (int x=255; x>0; x--) { //same as before but descendent
 analogWrite(ledPin,x);
 delay(5);
}
}

In this case we got a led which light grows up and diminish slowly in a loop. The code is quite clear. The only important thing is to be connected to a pwm pin cause it’s simulates an analogic output, so it can have a modulation instead of a 0/1 output (digital output). In Arduino 2009 the pwm pins are 3,5,6,9,10,11.

We actually started from a simpler example with only light growing up, the code is basically the same

int ledPin =  3;    // LED connected to digital pin 3
int ledVal = 5;  //defines brightness
// The setup() method runs once, when the sketch starts
void setup()   {
 // initialize the digital pin as an output:
 pinMode(ledPin, OUTPUT);
}
void loop()  {
for  (int x=0; x<255; x++) { //defines x,fix a limit and establish that is gonna grow up
 analogWrite(ledPin, x); // pin brightness is gonna grow up
 delay(5); //imposta ritmo //with this rithm
}
}

Another variation of the code, with the same effect, is

//use a pwm pin
int ledPin =  3;    // LED connected to digital pin 3
int ledVal = 5;  //brigthness
int direction = 1 ; //variable, defines flow direction
// The setup() method runs once, when the sketch starts
void setup()   {
 // initialize the digital pin as an output:
 pinMode(ledPin, OUTPUT);
}
void loop()  {
for  (int x=0; x<255; x++) { //defines x with a limit and a growing up
 if(direction==1) { //when direction is +1
 analogWrite(ledPin,x);//then light will have a growing x value from 0 to 255
}
if(direction==-1) { // if direction is -1
 analogWrite(ledPin, 255-x); //light will diminish
}
delay(5); //general delay
}
direction *=-1; //every time direction (1) gets moltipled for -1. When is +1 it becomes -1, at the next cycle -1 will become again+1
}

After that we worked with a potentiometer

Basically is just an analogic switch, so that we don’t have only an on/off output but also every output between those two (the scale goes from 0 to 1023).
It must be connected to the 5 volt pin, to the grund and to a 10k resistor (as you can see it has 3 plugs). Here is the code

int sensorPin=2;  //output sensor
int sensorValue=0;
void setup () {
Serial.begin(9600);} //recall Arduino serial port
void loop (){
sensorValue = analogRead (sensorPin); //defines sensorvalue
int ledFadeValue = map(sensorValue, 0, 1023, 0, 255); //defines that the 0-1023 transistor range will be now converted in 0-255
analogWrite (11, ledFadeValue); //turns on the led
Serial.println(sensorValue, DEC); //digital output
delay(20); //rithm
}

So in here we just have a potentiometer that regulates a led. Now a variation

int sensorPin=2;
int sensorValue=0;
void setup(){
Serial.begin(9600); //recall Arduino serial
}
void loop (){
sensorValue = analogRead (sensorPin);
int ledFadeValue = map(sensorValue, 0, 1023, 0, 255); // 0-1023 is used as 0-255
analogWrite (11, ledFadeValue); // pin will turn on and off
int ledFadeValue2 = map(sensorValue, 0, 1023, 255, 0); // in here we do the opposite, potentiomter 0
//corresponds to led 255 and so on
analogWrite (10, ledFadeValue2); // pin will turn off and on
Serial.println(sensorValue, DEC); //digital output visual
delay(20);
}

So we learned that with the <em>map</em> option we can translate a range of values to another one. If we would have liked only to pass from a medium brigthness to a high one (not maximum still) the command would have been
[code]int ledFadeValue = map(sensorValue, 0, 1023, 123, 200);

I took a video of this

We were done with the potentometer then and we started using a simple push-button.

int buttonPin =2;  //button input
int ledPin=13; //output
int buttonState = 0;
void setup() {
 pinMode(ledPin,OUTPUT);
 pinMode(buttonPin,INPUT);  //button will be an input
}
void loop(){
 buttonState=digitalRead(buttonPin); //button state
 if(buttonState==HIGH){ //if the state is HIGH (pressed)
  digitalWrite(ledPin,HIGH); //turn LED on:
 } else{
 digitalWrite(ledPin,LOW);
<pre>
<pre> // turn LED off:</pre>
</pre>
}

<img class="alignnone" title="pulsante con buzzo" src="http://img138.imageshack.us/img138/8623/pulsanteconbuzzo.jpg" alt="" width="448" height="335" />

I think that looks simple. If you keep the button pushed it will turn on the led (a buzz in this case). Now a little variation
[code]int buttonPin =2; //button input
int ledPin=13; //pin output
int buttonState = 0;
int redpin =5; //second pin output
void setup() {
 pinMode(ledPin,OUTPUT);
 pinMode (redpin,OUTPUT);
 pinMode(buttonPin,INPUT);
}
void loop(){
 buttonState=digitalRead(buttonPin); //defines button state
 if(buttonState==HIGH){ //if is pressed
 digitalWrite(ledPin,HIGH);//turn LED on
digitalWrite(redpin,LOW); //and the other one off
 }
 else{
 digitalWrite(ledPin,LOW);// turn LED off
digitalWrite(redpin,HIGH); //and the other one on
 }
}

Se there is a led always on and when you push the button it will turn off with a new one that will be turn off as long as you keep pushed. Another step further

int old_val=0; //this variable stores the previous value of "val"
int state=0;
void setup(){
 pinMode(LED,OUTPUT); // tell arduino LED is on output
 pinMode(BUTTON, INPUT); //and Button is on input
}
void loop() {
 val=digitalRead(BUTTON); //read input value and store it
 if ((val==HIGH)&&(old_val==LOW)){ //check if there was a transition
 state=1-state; //changes state's value
 delay(10);
 }
 old_val=val; //val is now old,let's store it
 if (state==1){
 digitalWrite (LED,HIGH); //turn led on
 }else{
 digitalWrite(LED,LOW);
 }
}

So that every time you push the button the led will change its state without having to keep pushed. One push it turns on, another one and goes off again.

That's pretty much all the code we wrote. We tried some soldering (unfortunately I don't have a video of my first try). I guess I'm not really good ad it but
that's not the part that goes "public", i hope it won't be a huge problem. I took some pics but I didn't have a good camera, I hope I'll post a good one for the end of the week

That one is a buzzo beater, is an i/o device whichs makes a quite disturbing noise if on. We tried it with almost every function i mentioned before just to see how it responses.
After that the day was practically over, we just went home with "some" homework to do, works that I'll post later.

Do you find that beer pong is too dull on its own to keep your attention? Do you require flashing lights to accentuate your imbibing?  Here’s the perfect solution. Make an interactive beer pong table. It didn’t take much to sell us on the idea. We think everything needs a few more lights.

The idea is that as the game progresses, you get different feedback from the lights visible in the picture above.  [rohitk] is using an Arduino and some pressure sensors to tell when each cup is removed. Based on this the LEDs change color.