So our little talk was the first one at the con and it was the bees knees.  Here is the video from the talk, slides will be up soon.

The Extraordinary Journey from Fundamental Electronics to Fabulous Enchanted Systems with Arduino’s and Magical Potions from droops on Vimeo.

Morgellon and I met up last night and went over our talk, in the overall score he beat me 5 to 1, but we still have two more events.  Some of the watchers of our practice got into the grab bag early and ended up with a LCD and a few Freeduinos.  They promised to come back to our table for the soldering and the such.

Pictures and videos of incriminating situations abound, just as soon as we get back to a safe an fast internet connection.

BEHOLD!… the Arduino USB board has evolved from the old “Decemilia” to the new “Deumilanove”!  Just like a fine wine, the Arduino keeps getting better over the course of time.

The new Deumilanove offers a few improvements over previous Arduinos including:

• automatically selects the appropriate power source (USB or external adaptor), eliminating the need for a power selection jumper.

• easy to cut trace for disabling the board’s auto-reset (and a solder jumper for re-enabling it)

• Read the complete overview of the Arduino Duemilanove:

http://www.arduino.cc/en/Main/ArduinoBoardDuemilanove

(Be sure to scroll down to the bottom of the page to download an audio file of how to pronounce “Duemilanove“!)

I am working on having processing read and act on data from the ardunino, this is a simple test and code should be up soon, i am working on a code repo for Morgellon and I to share projects.

Arduino / Processing Color Selector from droops on Vimeo.

This is for our talk at Phreaknic, the ardunio reads 3 linear pots and outputs serial data that looks like this:

X 56
Y 67
Z 10
X 59
Y 89
Z 10

Processing takes this, splits it up, and makes the pretty colors.

So here’ s my little version of the drum kit.  I’ve just used sample code from arduino.cc, but it’s more than enough to get the project up and running.  Expect to see it evolve over time, and if you plan on being at Phreaknic you can play with it there!

Arduino Knock Sensor Drum Kit v1.01 from Morgellon on Vimeo.

• Read how to use a piezo buzzer as a knock sensor

http://arduino.cc/en/Tutorial/Knock

• Read how to make a piezo buzzer play various tones, instead of just one!

http://arduino.cc/en/Tutorial/PlayMelody

Here’s the sample code I used, with a few tweaks added:

int ledPin = 13;      // led connected to control pin 13
int knockSensor = 0;  // the knock sensor will be plugged at analog pin 0
byte val = 0;         // variable to store the value read from the sensor pin
int statePin = LOW;   // variable used to store the last LED status, to toggle the light
int THRESHOLD = 100;  // threshold value to decide when the detected sound is a knock or not

// TONES  ==========================================
// Start by defining the relationship between
//       note, period, &  frequency.
#define  c     3830    // 261 Hz
#define  d     3400    // 294 Hz
#define  e     3038    // 329 Hz
#define  f     2864    // 349 Hz
#define  g     2550    // 392 Hz
#define  a     2272    // 440 Hz
#define  b     2028    // 493 Hz
#define  C     1912    // 523 Hz
// Define a special note, ‘R’, to represent a rest
#define  R     0

// SETUP ============================================
// Set up speaker on a PWM pin (digital 9, 10 or 11)
int speakerOut = 9;
// Do we want debugging on serial out? 1 for yes, 0 for no
int DEBUG = 1;

void setup() {
pinMode(ledPin, OUTPUT); // declare the ledPin as as OUTPUT
pinMode(speakerOut, OUTPUT);
Serial.begin(9600);       // use the serial port
}

// MELODY and TIMING  =======================================
//  melody[] is an array of notes, accompanied by beats[],
//  which sets each note’s relative length (higher #, longer note)
int melody[] = {  C,  b,  g,  C,  b,   e,   C,  c  };
int beats[]  = { 16, 16, 16,  8,  8,  16,  16, 16  };
int MAX_COUNT = sizeof(melody) / 2; // Melody length, for looping.

// Set overall tempo
long tempo = 10000;
// Set length of pause between notes
int pause = 1000;
// Loop variable to increase Rest length
int rest_count = 100; //<-BLETCHEROUS HACK; See NOTES

// Initialize core variables
int tone = 0;
int beat = 0;
long duration  = 0;

// PLAY TONE  ==============================================
// Pulse the speaker to play a tone for a particular duration
void playTone() {
long elapsed_time = 0;
if (tone > 0) { // if this isn’t a Rest beat, while the tone has
//  played less long than ‘duration’, pulse speaker HIGH and LOW
while (elapsed_time < duration) {

digitalWrite(speakerOut,HIGH);
delayMicroseconds(tone / 2);

// DOWN
digitalWrite(speakerOut, LOW);
delayMicroseconds(tone / 2);

// Keep track of how long we pulsed
elapsed_time += (tone);
}
}
else { // Rest beat; loop times delay
for (int j = 0; j < rest_count; j++) { // See NOTE on rest_count
delayMicroseconds(duration);
}
}
}

void loop() {
val = analogRead(knockSensor);    // read the sensor and store it in the variable “val”
if (val >= THRESHOLD) {
// statePin = !statePin;           // toggle the status of the ledPin (this trick doesn’t use time cycles)
digitalWrite(ledPin, HIGH); // turn the led on or off
Serial.println(”Knock!”);       // send the string “Knock!” back to the computer, followed by newline
for (int i=0; i<MAX_COUNT; i++) {
tone = melody[i];
beat = beats[i];

duration = beat * tempo; // Set up timing

playTone();
// A pause between notes…
delayMicroseconds(pause);
}
delay(10);                      // short delay to avoid overloading the serial port
}
digitalWrite(ledPin, LOW);
}

Metamorphosis from Glenn Marshall on Vimeo.

I totally ripped this off from Morgellon, but it sounded fun and I wanted to try it. He is going to build his own version of this that I am sure is going to be cooler.  I had to call him and ask some questions as he is most definitely the hardware end of our crazy love triangle. I want to dump the data into processing and have it animate the drums being hit, but that is for another day.

Arduino Knock Sensor Drum Kit v1 from droops on Vimeo.

When a drum is struck, a knock sensor (backwards peizo) talks to the arduino and activates an led ot change the color of the drum (blue), after a delay the blue led goes out and the drum becomes orange again.  I used a pullup resistor between the pins of the knock sensor, but i didnt get any different results with different values, so its probably dependent on the peizo that you use.

/*
droop's drum kit

dailyduino.com

droops - gmail

thanks for the idea josh!!
*/

int knockPin = 3; //pin for incoming knock sensor
int knockVal; //value from knock sensor
int knockLedPin = 10; //bue led
int normalLedPin = 4;  //orange led
int lightBlue = 2000; //counter for keeping blue light on
int limit = 1000; //how sensitive the knock sensor is, lower = higher sensitivity based on piezo and pull down resistor
int blueTime = 2000; //how long the blue led stays on

void setup(){
  pinMode(knockLedPin, OUTPUT);
  pinMode(normalLedPin, OUTPUT);
  pinMode(knockPin, INPUT);
  Serial.begin(9600);
  digitalWrite(knockLedPin, LOW);
  digitalWrite(normalLedPin, HIGH);
}

void loop(){

  knockVal = analogRead(knockPin); //read the knock sensor

  if (knockVal < limit){
    lightBlue = 0; //drop the value to activate the led
    Serial.println(knockVal);  //dump to serial for debugging
  }

  //this keeps the blue light on after a knock is registered
  if(lightBlue < blueTime){
    digitalWrite(normalLedPin, LOW);
    digitalWrite(knockLedPin, HIGH);
    lightBlue++;
  } else {
    digitalWrite(knockLedPin, LOW);
    digitalWrite(normalLedPin, HIGH);
  }  

}

Recently, I posted about using a solar panel as a method for charging a battery that powers the Arduino.  Although using a solar cell as a power source is the most obvious use, it is not the only use!

I found a post over at little-scale that shows how to use a solar cell with an Arduino as a photo sensor.  The code looks very similar to reading a pot, or other such device on an analog input.  Although, there a few caveats to doing this noted by little-scale:  The solar panel used in this example was rated at 2V and 25mA.
• Do not use a solar panel rated in excess of 5V. Doing so may damage the Arduino
• If data values appear incorrect, try scaling the byte ‘data’ in the Arduino sketch as it is captured. The analog inputs read data at 10 bit. However, a single, serially-printed value can only hold 8 bits of information.
• The data range with this particular solar panel is 0 < 6 using power-efficient, indoor lighting at night.

The next question after HOW could be WHY? There a many different applications that spring to my mind, from practical to abstract. I am also curious if you could still use a panel as a sensor and power source, by having one trace going to the analog input, and another going to the power source.

I have also decided to include a few examples from practical to abstract, to get your thoughts flowing on this subject.  The first example is a “practical” one from youtube user, ringsofdeath.  The second is a more “abstract” one from youtube user, 5imian.  I hope you enjoy the videos and they get the juices flowing!

• Read the blog post at Little-Scale on “solar sensing”

http://little-scale.blogspot.com/2008/03/connecting-solar-panel-to-arduino.html

• View a “practical” example of solar sensing on YouTube

http://www.youtube.com/watch?v=oThoa_zHTkk&NR=1

• View an “abstract” example of solar sensing on YouTube

http://www.youtube.com/watch?v=L5iPpLnZeyU