The Daily Duino

Another post on Pachube and how easy it is to get setup and going. This post will cover the basic steps on how to get some sensors online!  I will be using my project of two light sensors as an example.  The status of my light sensors are viewable at http://www.pachube.com/feeds/2145

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!

Quick update before I zonk out…  Yesterday I setup an account for Pachube and spent all night getting familiar with how it works. Pachube describes itself as a service that enables you to connect, tag and share real time sensor data from objects, devices, buildings and environments around the world. The key aim is to facilitate interaction between remote environments, both physical and virtual.

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

There has been quite a flurry of development revolving around the official ethernet shield recently. Here are what I consider a few of the more important changes.

Ethernet fixes – There are some connection issues with the ethernet library with regard to incomplete disconnects. Since the wiznet chip only supports 4 simultaneous connections, this manifests itself pretty quickly if you are trying to poll a server for changes. Etracer, from the arduino forums, found and fixed this problem and has released a new client.cpp as well as detailed the issues in a post to the arduino developers mailing list.

Another recent addition is Ben Combee’s Webduino library, which greatly simplifies processing html forms when using the arduino and ethernet shield as a web server. The library and basic examples are available at: http://code.google.com/p/webduino/

Bjoern Hartmann’s UDP library has also been used for a couple of recent projects including work on DNS/DHCP and fellow Infonomicon member Cynshard’s work on a NTP library. The NTP library is particularly useful since it can be combined with the software Date/Time library to have fairly accurate time without adding a hardware realtime clock to your project.

As you can see, there seems to be a lot of development activity ongoing for the official ethernet shield and since the addition of networking to the arduino greatly expands its possible uses, I think we’ll see even more. Please remember to thank these folks for their code and bugfix contributions…

So, I like to lurk in the #arduino IRC chatroom on freenode.net.  While in there the other day I started talking with Graxe and he mentioned that he would be near my area and inquired if I was interested in the RepRap.  Needless to say, I didn’t hesitate on arranging a meet-up!

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

Finally sat down and figured out how to send some basic signals via serial from Processing to an Arduino.  For this example I was just looking for basic functionality, so I settled for a simple way to turn a LED on and off.  It’s also mostly sample code gathered from the Internet.

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

For several years, I have been a user of various smart-phones of different makes and models.  Once I used my first smart-phone, I was truly hooked by the “life style”. Soon, I was left with little desire to return to a “normal” phone that “just made calls”. I am always finding new applications that remind me a smart-phone is more like a small computer that is capable of making phone calls, than just a fancy phone.

When I entered the world of the *duinos, I remember the question “Can I hook up my Arduino to my phone?” entering somewhere in the back of my mind.  There it sat, in the deep recesses of the mind…. until recently.

Ideally, I would like the ability to plug in or sync an Arduino and run the Arduino IDE on a mobile phone.  I have little desire to replace my computer and keyboard for a phone as my main environment.  Although, I would like the ability to use the phone as a “field unit”. Perhaps using it to edit, tweak, or update versions of a sketch without the need of a PC or laptop.

I have no idea if this is at all possible… but in the course of searching the internet for answers I have found some interesting projects with *duino’s and mobile phones!

• Here is an example of a BT Arduino communicating with a mobile phone over Blue-Tooth. http://www.youtube.com/watch?v=cgZiBl7Uzdo

This example is neat, but… the blue-tooth Arduino can be pricey and I’m really looking for a way to physical connect the arduino over USB… so we keep searching…

• This example has serial output from an Arduino being displayed on an iPod Touch or iPhone. http://www.youtube.com/watch?v=mEM-VHZTqhk

This example caught my eye and interest! (Possibly due to the nature of owning an iPhone…) So, I decided to poke around and see if I could find more info on the process. Most of what I found was in Japanese or broken links.

http://d.hatena.ne.jp/tabletlet/20080328/ The site where the video originated and the Google translation http://translate.google.com/translate?hl=en&ie=UTF-8&u=http%3A%2F%2Fd.hatena.ne.jp%2Ftabletlet%2F20080328%2F&sl=ja&tl=en&history_state0=

http://novi.10.dtiblog.com/blog-entry-213.html Another site in Japanese with a bit more info on establishing the serial communications and the Google translation http://translate.google.com/translate?hl=en&ie=UTF-8&u=http%3A%2F%2Fnovi.10.dtiblog.com%2Fblog-entry-213.html&sl=ja&tl=en&history_state0=

http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1207058161 A post in the Arduino.cc forums about connecting Arduino to iPod/iPhone serial.

http://devdot.wikispaces.com/Iphone+Serial+Port+Tutorial Info about iPod/iPhone serial communications.

http://pinouts.ru/Devices/ipod_pinout.shtml iPod/iPhone connector pin-out.

And of course, a few sources for iPod connectors and breakout boards:

• http://www.seeedstudio.com/depot/ipodext-assembled-version-breakout-for-ipod-p-148.html
• http://www.sparkfun.com/commerce/product_info.php?products_id=633
• http://www.sparkfun.com/commerce/product_info.php?products_id=8295

Recently I did a video attempting to describe and compare the differences in a digital PWM signal and an analog signal.  To supplement my recent video, I am sharing another video I recently found while traversing the tubes.

This video is about using PWM with FPGA’s— it’s not directly related with micro-controllers and is a bit technical.  For us though, Mrs. Shelly gives a good definition, examples and usages of PWM and the info could be helpful to those who still lack a good understanding of what PWM is doing.  The first 4:30 of the video is the only relevent part to us in the *duinoverse, after that it’s just about software implementation of FPGA’s …

Signals come in two basic types – Analog and Digital. Analog signals are capable of being any value, where Digital signals are called “discrete”, meaning they capable of being in only one of two states! The terms for these two states of a Digital signal are varied but include; ON/OFF, TRUE/FALSE, 1/0, HIGH/LOW, etc.

So what’s that mean? A good example of a Digital signal is a light switch in your house. You can either flip the light switch ON, or flip the light switch OFF. To follow this line of thought, an example of an Analog signal would be a light with a dimmer switch. With a dimmer switch you can adjust how bright or dim the light is, anywhere from completely OFF, to completely ON.

Okay… The Arduino is capable of analog and digital INPUT, but only capable of digital OUTPUT. When working with the Arduino we see that there are 6 analog pins and 14 digital pins. (It should be noted that if you have no need of analog INPUT; you may use the analog pins as extra digital OUTPUT pins — declaring them as digital pins 14 – 19)

So, if we are only capable of digital OUTPUT on the Arduino, how are we able to dim a LED?

dimming LED with digital PWM

ENTER PWM!! (Pulse Width Modulation) Some, but not all pins on the Arduino are capable of Digital PWM OUTPUT. Basically, PWM is the digital way of mimicking an analog OUTPUT.

To better show the difference between Analog and Digital PWM, I put together a simple LED dimmer circuit and hooked up an oscilloscope to view the Analog and Digital PWM signals. I took some video of everything in action to better serve as an example.

Analog Signal VS PWM Signal from Morgellon on Vimeo

The sketch I used in this video is available here: http://serverwillprovide.com/icuubi/examples/analog_vs_PWM.pde

I am not a car guy, but I enjoy my Scangauge and knowing my MPG every second of driving.  We have really changed how we drive and consume gas with this simple ability.

So how do I do with with an Arduino?  I had no idea other than there is some way to get the information from the OBD port.  Well it seems that you can use one injector lead and do this, there is even a project that spends time working on this.  Presenting the MPGuino!!

You can build this yourself, or you can get a kit for 40$.

Here is their main page

Here is their wiki

Here is a forum post with schematics

Here is how to put it in your car

I will hopefully order one of these soon and get to play with it.

Today we are going to be playing with some 433 mhz radios from Parallax.

Transmitter $30

Receiever $40

Datasheet

Now this is only going to be one way communication, as these will either transmit or recieve but not both.  This pair is extremely easy to use, they say these will range over 500ft and will speak between 12,000 – 19.2 K baud.

To use these, you simply put them inline with the wired example, on the transmitter there is a ground, power, data and  power down.  Don’t worry about the power down, you know where to plug the other 3.  Data is going to be your tx pin.

On the reciever there are those 4 pins and a signal pin.  This signal pin shows how strong the signal is from the transmitter.  You can read this like any other analog value.  Your data pin goes to rx.

Transmitter

Receiver

Transmitter Closeup

Receiver Closeup