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!!

Things have been quite action packed and distracting for me!  A recent move has not helped with the distraction factor either, lol. Between work, packing and unpacking, here are the other things I’ve been doing with my time:

Learning to Code. As I progress in my projects, my lack of coding abilities are really starting to be the limiting factor.  Among other things, I have been wanting to incorporate Processing into more projects.  In order to manifest my crazy ideas into reality, I decided to really focus on learning to “code”.   My favorite and possibly most valuable resource has been the Programming Methodology videos from Standford University.  The course is taught around Java, which is convenient for me as Processing is Java based.  Here is a link to the Programming Methodology course videos on youtube… they are also downloadable!  http://www.youtube.com/view_play_list?p=84A56BC7F4A1F852&search_query=programming+methodology

I’ll embed the first lecture to wet your whistle!

Crafting. Yes, that’s correct.  Crafting. I’ve been wanting to do some “wearable” projects… making use of the LilyPad, conductive thread and my madness, among other things.  So, I have been learning to use a sewing machine, along with hand stitching and other techniques.  Recently, I even had the opportunity to learn to make yarn from wool.  I also have acquired a large amount of wool and a Navajo spinning spindle, to spin the wool into yarn.  One of the things I would like to try is spinning my own “conductive yarn”.

If for some reason you were interested in learning more on this technique of spinning, here’s a nice link explaining the process: http://www.graftonfibers.com/navajospinning.htm

Don’t worry, things are starting to settle and slow down with me… so hopefully I soon have time to start applying my new found knowledge to some neat Arduino projects.

– Morgellon OUT!

Massimo Banzi at Flourish ’09 from Morgellon on Vimeo.

Processing Workshop at Flourish ’09 (pt1) from Morgellon on Vimeo.

Processing Workshop at Flourish ’09 (pt2) from Morgellon on Vimeo.

The Processing code creates a small black square on the screen.  When the mouse cursor is moved over the square, it changes color to yellow and sends a “H” over serial to the Arduino.  While the Arduino detects a “H” on serial it will light the LED.

Here’s a video of it in action and describing how to get started.

Basic Processing to Arduino Communications from Morgellon on Vimeo.

• Download Processing

http://processing.org/download/index.html

• Download Arduino to Processing Library

http://www.arduino.cc/playground/Interfacing/Processing

Now that you’ve gotten all the files installed and in their proper places, try out my test code I used in the video.

Arduino Code (Download here)

//  Read data from the serial port and turn ON or OFF a light depending on the value

char val;         //Data received from the serial port
int ledPin = 13;  //Set value ledPin to pin 13

void setup(){
pinMode(ledPin, OUTPUT);  //Sets pin as OUTPUT
Serial.begin(9600);    //Start serial communication at 9600bps
}

void loop(){
if (Serial.available()){  //If data is available to read,
val = Serial.read();    //read it and store it as val
}
if (val == ‘H’){              //If H is recieved
digitalWrite(ledPin, HIGH);  //turn ON light
} else {
digitalWrite(ledPin, LOW);  //If not leave light OFF
}
delay(25);
}

Processing Code(Download here)

//Check if the mouse is over a rectangle and write the status to the serial port

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

Serial port;    //Create object from Serial class

void setup() {
size(200, 200);
noStroke();
frameRate(10);
//Open the port that the board is connected to and use the same speed (9600bps)
port = new Serial(this, Serial.list()[0], 9600);
}

void draw() {
background (255);
if (mouseOverRect() == true) {  //If mouse if over square
fill(242, 204, 47);                    //change color
port.write(‘H’);              //send H to serial port
} else {            //If mouse is NOT over square
fill(0);          //change color
port.write(‘L’);  //send L to serial port
}
rect(50, 50, 100, 100);  //Draws the square
}

boolean mouseOverRect() {    //Tests if mouse is over square
return ((mouseX >= 50) && (mouseX <= 150) && (mouseY >= 50) && (mouseY <= 150));
}

Be sure to head over to the FLOSS Weekly site and listen to this interview!

• http://twit.tv/floss52

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.

The dot in the red pick, is me not being able to use a mouse properly, the lines on the text seem to be a problem with the font I picked.

/*
Color Selector

Takes 3 pots hooked up to analog 0,1,2 and uses them for the red green blue
values of a square.

Also displays the number for each color

*/

import processing.serial.*;

Serial myPort;
String inString;  // Input string from serial port:
String letter;
int number;
String numberS;
int redNum, greenNum, blueNum;

int x = 300; //somewhere around 200 or 300
int y = 300;

int lf = 10;

PFont font;

void setup() {
size(x, y);
//you may have to change the serial port
myPort = new Serial(this, Serial.list()[0], 9600);
myPort.bufferUntil(lf);

background(0);

font = loadFont("aakar-medium-20.vlw"); //make your own font

}

void draw() {

background(0);

textFont(font);

fill(255, 0, 0);
text(redNum, 10,30);

fill(0, 255, 0);
text(greenNum, 70,30);

fill(0, 0, 255);
text(blueNum, 130,30);

fill(redNum, greenNum, blueNum);
rect(0,50,x,y);

}

void serialEvent(Serial p) {
inString = (myPort.readString());

letter = inString.substring(0, 1);
numberS = inString.substring(2);
numberS = trim(numberS);
number = Integer.parseInt(numberS); //I could have combined a bit of this, but this code is for learning

if(letter.equals("R") == true) {
redNum = number;
}
if(letter.equals("G") == true) {
greenNum = number;
}
if(letter.equals("B") == true) {
blueNum = number;
}

}

/*Arduino Code

int bluePin = 2; //analog pin for right hand knob
int greenPin = 1;  //analog pin for left hand knob
int redPin = 0; //analog pin for center knob (width)

//Info for Serial Data
int id_1 = 'R';
int id_2 = 'G';
int id_3 = 'B';
int space = ' ';

void setup()
{
pinMode(redPin, INPUT);
pinMode(greenPin, INPUT);
pinMode(bluePin, INPUT);

Serial.begin(9600);
}

void loop()
{
int redNum = analogRead(redPin);
int greenNum = analogRead(greenPin);
int blueNum = analogRead(bluePin);

//the arduino will read from 0 to 1024 on teh analog pins, so we divide that by 4
redNum = redNum / 4;
greenNum = greenNum / 4;
blueNum = blueNum / 4;

printByte(id_1);
printByte(space);
printInteger(redNum);  printByte(10);

printByte(id_2);
printByte(space);
printInteger(greenNum);  printByte(10);

printByte(id_3);
printByte(space);
printInteger(blueNum);  printByte(10);

delay(10);

}

*/

http://accrochages.drone.ws/en/node/90

I have been playing with it a bit and have added some functionality to it. It now supports up to 3 inputs, 6 if i add a bit of code, has a second counter since the application (applet) started, and has lines across the screen for a bit of “what the heck value is this, zen”.

Here are a few screenshots of my additions to keep you interested, we will be talking more about this at Phreaknic hopefully. Code and such will be up soon, its a bit dirty and I want to add a few more things. Maybe Morgellon will bring his scope to Phreaknic and I can see what one actually does.