Pachube + Arduino from Morgellon on Vimeo.

STEP ONE: GET A PACHUBE ACCOUNT!

Head over to the Pachube website and see various sensors from all over the world and view their status.  Be sure to view the ABOUT page, this describes INPUTs and OUTPUTs, along with ways to interface with Pachube and your sensors.  The QUICKSTART page has the details to get started and how to use your API.  Pachube is still in beta, so you’ll need to get an invite code… but no worries, Pachube has an email address on the QUICKSTART page.  Just send them and email asking for an invite and what you would like to do.  If they let me in… they will let anyone in!

STEP TWO: PREPARE ARDUINO!

The Arduino can be interfaced with Pachube two ways: 1. With an Ethernet shield OR 2. Via USB connected to a PC running Processing… which is the way used in this tutorial… as I feel it is an easy and inexpensive way.  You can learn more about each way at the Pachube Arduino page.

To prep the Arduino, you need to connect the sensors you will be using and verify that they are working correctly! Once the sensors are good, then upload the “Standard Firmata” to the Arduino.  Now the Arduino is prepped for Pachube!  Leave the Arduino connected to the PC.

STEP THREE: PREPARE PROCESSING!

To have Processing communicate easily with Pachube, you will need to add a few libraries.  They are the Pachuino, Arduino and EEML libraries, they are available and there is more info at the PACHUINO page.  Download, unzip and move them to the libraries folder, in your sketchbook folder.  Now Processing is ready!

STEP FOUR: PREPARE INPUT FEED!

Once you have a Pachube account and your API key, go ahead and set up a new feed for your sensors.  Since I have light sensors, I started a new INPUT FEED.  I chose to make my feed “manual” (as this is easier for me) which means Pachube gets updates only when I send them.  Instead of Pachube connecting directly to my PC to pull the info.

STEP FIVE: PREPARE CODE FOR PROCESSING!

Once you have the libraries in the folder, you are ready to start Processing and start coding.  Below is the code I used for my light sensor.  This was taken from the sample code and stripped to make it more simple. I added a LED on pin 11 to light up (to let me know when my Arduino was running) and a delay(1500).

Be sure to add you API Key, and the URL of your INPUT FEED!

import processing.serial.*;
import cc.arduino.*;
import eeml.*;
import pachuino.*;

Pachuino p;
Arduino arduino;
int ledPin = 11;

void setup(){
p = new Pachuino(this, Arduino.list()[0], 115200);
p.manualUpdate(“http://www.pachube.com/api/2145.xml”); // change URL — this is the feed you want to update
p.setKey(“—YOUR API KEY HERE—”);

// local sensors
p.addLocalSensor(“analog”, 0,”Light Sensor Inside”);
p.addLocalSensor(“analog”, 1,”Light Sensor Outside”);
}

void draw(){
//p.debug();
p.digitalWrite(ledPin, Arduino.HIGH);
delay(1500);
}

// you don’t need to change any of these

void onReceiveEEML(DataIn d){
p.updateRemoteSensors(d);
}

STEP SIX: LAUNCH CODE AND COLLECT DATA!

Make sure that:

• Sensors are *working* and connected to Arduino
• Arduino is running “Standard Firmata” and connected to computer
• Processing is collecting sensor data from Arduino
• Computer has Internet connection

Now run your program and begin collecting data and sharing it on the web!!  Check your feed to make sure you data is being transmitted.  Have fun and happy tinkering!

–Morgellon OUT!

It also works with Arduino and Processing… hrmmmmm…..

The graphs will continue to update as they receive more data from the sensors.  It will be interesting to watch and compare the differences in the two graphs.  More to come soon!

–Morgellon OUT!!

DS18B20 Temperature Sensors + Arduino from Morgellon on Vimeo.

The DS18B20 is a small 3 pin temperature sensor that closely resembles a transistor.  Each one has a “unique” 64bit serial code and can communicate over a “1 Wire” protocol.   With a bit of code, we can have multiple temperature sensors all communicating and sending data over just one pin!

I’ve taken some pictures of my project today.  I have three DS18B20 all communicating over pin 10 on an Arduino.

The first, or closest to the Arduino, is wired in “Normal” or “Master” mode.

• GND(pin1) to Arduino GND
• DQ(pin2) to Arduino Pin 10
• VDD(pin3) to Arduino 5V
• a 4.7K Resistor between DQ(pin2) and VDD(pin3)

The last two, or middle and furthest away from the Arduino are wired in “Parasitic” or “Slave” mode.  These two require no power (as their name sake implies).

• GND(pin1) and VDD(pin3) to Arduino GND
• DQ(pin2) to Arduino Pin 10

The bit of sample code scans through the DS18B20 64bit serial codes until it finds no more unique codes.  It displays the information in HEX, followed by Celsius, then Fahrenheit of each sensor before moving to the next.

Download the code used in the example here:  http://serverwillprovide.com/icuubi/examples/multiDS18B20.pde

Read more about the DS18B20 Temperature Sensors and the Arduino!

• http://www.arduino.cc/playground/Learning/OneWire
• http://datasheets.maxim-ic.com/en/ds/DS18S20.pdf
• http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1161557194/75
• http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1199313338/0

So, Graxe was kind enough to drive down and share all his awesome gear with me.  I decided to take a bit of video last night, as he was unpacking.  The video is a little dark, as it was an impromptu session.  The battery was almost dead, so the video cuts out near the end.

Adventures in RepRap Land from Morgellon on Vimeo.

Fear not… after a trip to the Chinese buffet, we plan to return and do more electronics work.  We also plan on taking some more video and pictures… hopefully a little better quality this time around

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);
}

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

As usual, I had no idea how these things work, so I started plugging in wires and using a standard analog input sketch. That did not work at all, after I heard something pop I knew I was not on the right track. Then I started looking for some help. I still have not found a datasheet, but I found a graphic that made things work for me. My exact model is the OPB3902.

There are four pins on the bottom of these things, two to work the emitter (E) (pins 1 and 3) and two for the detector (D) (pins 2 and 4). Two resistors are needed, a 330 Ohm (orange orange red) and 2.2 K (red red orange).

I mounted the Optical Sensor on a proto board, having carefully cut off the plastic bump on the bottom of the sensor. I also used a led with a 1K (brown black red) for signaling when something was activating the switch. According to the drawing 5 volts would work, so that’s what I used, along with analog pin 2 for input and digital pin 12 for the signaling led.

After running my sketch and dumping the sensor reading to serial I found that it idled at ~929 and when the sensor was activated it was ~1020.  This is great, no problem to see a change of state, so I wrote a bit more code to activate the led.  I did not include a delay as I wanted the led to react quickly.

Here is my code, feel free to do with it as you will!

/*
Demo for a slotted optical sensor.

I am sure that someone elses code is in here somewhere
*/

int inputPin = 2;    // select the input pin for the potentiometer
int ledPin = 12;   // select the pin for the LED
int val = 0;       // variable to store the value coming from the sensor

void setup() {
  pinMode(inputPin, OUTPUT);  // declare the ledPin as an OUTPUT
  pinMode(ledPin, OUTPUT);
  Serial.begin(9600);
}

void loop() {

  val = analogRead(inputPin);    // read the value from the sensor
  Serial.println(val);

  if(val > 950){
    digitalWrite(ledPin, HIGH);  // turn the ledPin on
  } else {
    digitalWrite(ledPin, LOW);   // turn the ledPin off
  }
}

I am very excited to know how to set up this sensor.  Next time I am going to find some with the hook up wires already soldered and heatshrinked on.  For those that are curious, that is a Freeduino from NKC under there.

Since I started playing with Arduino’s, my wife knows that her kitchen table will be full of wires and little electronics that our kid doesn’t need to pull off the table.  Little LED’s that blink or some serial output to a computer are cool, but not so impressive.  But serial output to an LCD, a cool blue LCD, now things start to get interesting.

RFID Reader

Those are pictures of a RFID reader that I built the other day.  My 1.5 year old daughter thinks its the coolest thing.  Not only does an LED light up when a tag is read, but it has that fancy LCD.  Good design should be usable by little kids.  She can work the remote to our Mac’s, she can work an iPod, and now she can work my RFID reader.

RFID Reader LCD

If she knew how to solder, she could probably put one of these LCD’s together.  I am using 2 LCD’s from Modern Device and their Serial LCD Board to drive them.  Its as easy as adding a second serial output to your projects to add in an LCD.

There are a few other things you have to send on that serial connection and they are well documented at the bottom of the the above link.  There is also a test function on the Serial Board to make sure you hooked everything up properly.  The board will run either LCD, but you have to have different headers installed and a different resistor for the backlight.  No resistor, just a jumper wire for the 16×2 and a 15 ohm for the 20×4.

LCD117 Serial LCD Board

I had some problems with one of my Serial LCD Boards, but it seems to have been a hardware problem, I resoldered everything and it worked.  Paul at Modern Device has a forum set up where he will help you with any problem.  It’s very cool to have a company that sells things at good prices and will help you with their products.

20x4 LCD

Here is some example code to send data to the 16×2 LCD (just like the RFID Reader)

#include <SoftwareSerial.h>

#define rxPin 4
// rxPin is immaterial – not used – just make this an unused Arduino pin number
//the txPin is an unused digital pin, you can use analog pins for digital pins
#define txPin 14 // pin 14 is analog pin 0, on a BBB just use a servo cable

SoftwareSerial mySerial =  SoftwareSerial(rxPin, txPin);

void setup(){

pinMode(txPin, OUTPUT);
mySerial.begin(9600);    // 9600 baud is chip comm speed

mySerial.print(“?G216″); // set display geometry,  2 x 16 characters in this case
delay(100);               // pause to allow LCD EEPROM to program

mySerial.print(“?Bff”);  // set backlight to 40 hex
delay(100);              // pause to allow LCD EEPROM to program

mySerial.print(“?s6″);   // set tabs to six spaces
delay(1000);              // pause to allow LCD EEPROM to program

}

void loop(){

mySerial.print(“?c0″);          // turn cursor off
delay(300);                //without the delay, the LCD will crash

mySerial.print(“?f”);                   // clear the LCD
delay(100);
delay(3000);

mySerial.print(“?x00?y0″);              // cursor to first character of line 0

mySerial.print(“LCD117 test”);

delay(3000);

mySerial.print(“?x00?y1″);          // move cursor to beginning of line 1
mySerial.print(“moderndevice.com”);     // crass commercial message

delay(6000);                          // pause three secs to admire

mySerial.print(“?f”);                   // clear the LCD

mySerial.print(“?x00?y0″);          // move cursor to beginning of line 0

mySerial.print(” LCD 117 chip by”);         // displys LCD #117 on the screen

mySerial.print(“?x00?y1″);              // cursor to first character of line 1
mySerial.print(” phanderson.com”);

delay(3000);                          // pause three secs to admire

mySerial.print(“?f”);                   // clear the screen

delay(1000);
}