Build #4!

New features for build #4:

• It actually does something useful. (WOW!)
• Has basic error checking inplace, should help eliminate string index errors
• Has a basic packet structure in place, 959595 indicates that data is coming in.

First of all, this program will read the data in from the Sharp IR range sensor I am using as a semi random number generator. You will notice on the output it looks like this:

Output:

C&

C is 69 or something in ASCII(too lazy to check), which is a range that this sensor could be producing. In order to verify it is accurate, I replaced the actual sensor input on the ard with "343" and ran it, the output was W. Go ahead, hit alt + 343. W is the result, which verifies the output.

Also, please note in the code below, in the function, that I am using basic error checking to avoid errors. This one was implemented because I was getting a pretty constant string index error after a few seconds because it would not have any data and thus nothing to access(I think :P). Anyways, this basically runs a length check on the string and then verifys that the index that is about to be called is actually there, if not it breaks out of the while loop and goes around again. I am no professional coder, just a hobbyist, but I feel that these kinds of steps are crucial to a solid program. I am sure there are cleaner ways to do it, and I will look for them and try to think them up, but this is working for now.

You will see that I used 959595 for the initial "header" part of the data, and then only a & as the end in the function. The 959595 was used because it should be bigger then any of my sensor readings, and I used & because it was a random variable.

Anyways! Below is the code, as always.. feel free to use it for anything you want, no credit needed at all. Just enjoy it and hopefully learn some. Oh, that reminds me, this is all done in strings really. It is just easier in python and ard to use strings all around then dealing with conversions at the moment.

import serial

import time

Sensors1 = 0

r = 0

y = 0

# Setup area, starts serial, gives some info, then sleeps for about 2 seconds.

ser = serial.Serial('/dev/ttyUSB0', 19200, timeout=0) # Pretty straightforward, opens that device up for serial.

print "Current port location:" # Informational

print ser.portstr # Prints basic port information

time.sleep(1.75)

def Sensor_Read(): # This is the function that reads the sensor in.

i = 0

j = 0

r = 0

while i == 0:

r = ser.read(2)

if(j >= len(r)): break # Makes sure I am not refrencing an index that is out of range

if(r[j] == '&'): i = 1 # Reads until I find a &

j = j+1

return r

while y == 0:

sensors1 = ser.read(6)

if(ser.inWaiting() > 0): # Don't run this until something is in the buffer

if(len(sensors1) > 0):

if sensors1 == "959595": # This is arbitrary, I just told the arduino to write that as a 'header'

print "Output:"

print Sensor_Read()

time.sleep(.1)

else:

ser.flushInput() # If the numbers aren't write, wipe the buffer and retry

ser.close()

Now is the arduino code, a few quick notes. It is a very compact code base, because the ard is by far the weaker of the two systems for processing power and memory. Also, I commented out the build notice because it is not terribly relevant right now.

int InputSer = 0;

int potPin = 7;

int AnalogIn = 0;

void setup()

{

Serial.begin(19200); //Rather straightforward, 9600 baud rate for this serial connection.

//Serial.println("Adruino Python serial system. Ard Client. Build #4");

}

void loop() {

AnalogIn = analogRead(potPin);

Serial.println("959595");

Serial.write(AnalogIn); // This will send the intiger on the same line as the &, & carries a /n(line term) on it.

Serial.write('&'); // Signals end of variable

delay(100);

}

I really wish there was a way to make that code look cleaner, but just copy it to a wordpad(or whatever) and view it there. This is currently working on the Arduino mega and CentOS5 with Python 2.6(I believe). Also you need the PySerial module installed. Google it, if you still need help just email me or comment here.

Thanks all! Enjoy!

Its working :)

Quick update, made a lot of progress today. Hopefully enough to release build 4 tonight(with code!). Basically, I have a few small bugs to iron out and it should be good. I ended up using a datapacket idea like I said earlier, introduced the first function to my code as well. Good stuff :)

Look for an update in the next 12 hours.

Determined

Well I have determined the next step and commands needed. As I am 'new' to python a lot of googling has occurred, and lots of rummaging through documentation. Anyways, it turned out to be a super simple answer… Instead of fighting the Arduino's natural tendency to do everything in ASCII, I am going to embrace it. As far as I can tell, the ard sends everything in 8 ASCII sequences.

Example:

If I were to have the ard send over "I am a pretty duck!" on serial, and then have the python app just write out this:

print Serial.read()

It would appear on the screen as so:

I am a p

retty du

ck!

If I use the print Serial.readln() it would just come out as the single line of "I am a pretty duck!".

Anyways, using the serial.read() command on python I can have the ard send over something like "75757575" and have the python read that in as a string. Then convert that string to integer by using the int() command.

or:

BufferStr = serial.read()

BufferInt = int(BufferStr)

Assuming that BufferStr does indeed contain "75757575", BufferInt would then also contain 75757575.

Notice the lack of quote marks, indicating that is not a string but an actual integer value. This should alleviate my issues of type and data size. Using that, I should be able to get my system running pretty damn well by Wednesday night.

Oh, also I suppose an explanation is needed for my posting patterns. I work 3 or 4 day work weeks, 12 hour days though. So on work days I generally am at work, come home, fall asleep within an hour, and then head back to work after I wake up. During these swings I won't be able to do much with the actual code… mostly just research stuff on breaks at work.

Regards!

Update

Just wanted to put a quick update on the blog about current progress and issues. I am currently trying to setup a system to deal with varying data size. Obiviously if I am going to use this data for any sort of processing it has to be parsed correctly, I need to have a section of data that is cleanly accepted and verified. Right now I have it basically just reading everything in the buffer and printing it on the screen.. that works because I can easily distingush that "44" *pause* "512" *pause* "423 means that it was 44, 512, 423. However, when I remove the built-in pauses I am getting an output similiar to this:

44512354235212361263271581246123. Which is, of course, useless. So now I am faced with a larger series of questions that need answering.

1. What data format is the Arduino sending out when I use the Serial.write(X); command.

2. What data format is the Python program assuming the data coming in is?

3. Assuming the data types are both ASCII, then doesn't that limit the size of the data to 1 byte? Or 255 in decimal form?

I spent yesterday fiddiling with it, setting the arduino to write decimal numbers, or bytes, and was not getting the expected results. I suppose I need to buckle down and just start working out a data packet system.

So, that is where I am right now. No code updates or examples.. just a bit of theory discussion.

Code and further work

So in order to start this off right, I wanted to establish the very most basic of communication and method to verify that communication. Essentially I setup a breadboard with 3 LED's and each LED is wired to the Arduino on a different digital pin. This will let verify that what the python is telling the Arduino, is really occuring.

As you can see on the left in the photo, the setup is simple. The "red" is the connection for the Arduino to the LED's(through resistors) and then the black coming from the LED's are the ground. That goes to a shared ground, which then is wired back to the arduino's onboard ground. Very straightforward.

Here is a video I made of the setup in action. Sorry for the bad quality on all of my media.. its coming from a G1 phone, and thus pretty horrible.

As you can see, I now have a successful setup that allows a python "script" to command my Arduino in a very basic form. At the very bottom of this post I have both the arduino code and the python script. In order to run the python script you will need Python(http://www.python.org/) and also the Python Serial module(http://pyserial.sourceforge.net/). The code is designed to run a linux box, so keep that in mind. The only change you would need to make on a windows box is in the '/dev/ttyUSB0' section. You would need to change that to COMX, where X is the arduino's communication port.

I am writing this assuming that you have basic programming knowledge, which is all I have myself. It is a quick and dirty example of how this could work. I say quick and dirty because the Python script does no actual "thinking" it just sends the arduino a letter, waits a second, sends another, waits a bit more, and sends a third letter. In the Python code you will notice at the start it has a delay put in and that is because Python will exectue so fast that the serial buffers can't sync up.

Hopefully this is pretty self-explanatory. If you have any questions just comment and I will get to them ASAP. This is just the very very first step in the setup. Next comes building some functions for both the arduino and the Python. I am currently planning on a basic "start" section where the Python and arduino can negoitate with eachother about what type of error checking. This is done for scaling purposes; as the code base gets larger I want to have it already capable of a 'strict' error system that minimizes lost data. Then I will have a second one that is 'speed orientated' and whos only goal will be to make sure that it is discarding damaged chunks of code.

Please note, I generally won't be posting twice a day, but this is the first day and I am a pot of coffee in. :) Thanks all! Heres the code:

Python:

import serial

import time

ser = serial.Serial('/dev/ttyUSB0', 9600, timeout=0)

print "Current port location:"

print ser.portstr

time.sleep(1.75)

print ser.readline()

time.sleep(.1)

ser.write("P")

time.sleep(1.5)

ser.write("Q")

time.sleep(1.5)

ser.write("R")

time.sleep(1.5)

ser.close()

Now, onto the Arduino "sketch":

int led1 = 31;

int led2 = 33;

int led3 = 35;

int InputSer = 0; // led1-3 are just variables for which pins are connected to LED's on a breadboard.

void setup()

{

Serial.begin(9600); //Rather straightforward, 9600 baud rate for this serial connection.

Serial.println("Adruino Python serial system. Ard Client. Build #3");

pinMode(led1, OUTPUT); // These are setting the pins to be used as OUTPUT's(and thus power the LED's).

pinMode(led2, OUTPUT);

pinMode(led3, OUTPUT);

}

void loop() {

if (Serial.available() > 0) { //This is a test to see if anything is in the buffer. If so:

InputSer = Serial.read(); //This will read the next byte in the serial buffer.

Serial.println(InputSer); //This prints that variable, only done for debugging.

if(InputSer == 80){ // P to hit LED1 on

digitalWrite(led1, HIGH); // sets the LED on

delay(1000);

digitalWrite(led1, LOW);

}

if(InputSer == 81){ // Q to hit LED2 on

digitalWrite(led2, HIGH); // sets the LED on

delay(1000);

digitalWrite(led2, LOW);

}

if(InputSer == 82){ // R to hit LED3 on

digitalWrite(led3, HIGH); // sets the LED on

delay(1000);

digitalWrite(led3, LOW);

}

// Above you will see that I have a few different things that may need explaining. First of all, the 80, 81, and 82. This is what P, Q, and R are in "byte" form. These are just some numbers I guessed at random..

// If you are curious what numbers == what letters, just hit alt + XXXX. Alt 0080 is P. 81 is Q, 82 is R.

}

}

Current goals

So, a quick informational about the project. Essentially I am trying to get a software solution for getting my arduino's information into a computers memory. Its not terribly complex, but there isn't a very clear cut solution that allows easy use in Linux or windows. So my current idea is to use python's great PySerial libary solution in order to get them together.

Beneath you will find a few bullet points with rough ideas about some of the various problems that have arisen thus far:

• Any mobile system would be unable to communicate back to the server without a wireless system.
• Obviously the computer can transfer at a far higher rate then the arduino can. So its a tight rope between how much time the arduino should be transferring data, and how much time it should be controlling the other systems.
• Errors. Will need to implement error checking at most levels, probably on the server side.
• Modular? Need to decide whether this should be a python "library" or just a straight forward python app.

There are a lot more issues, but I feel that those are the biggest "design" questions I have to decide on. Naturally the mobile system aspect needs to be decided before I can decide anything else(Wireless links need more error checking then wired, etc etc). As of right now, I believe I will be using the "xbee" module as the wireless link. Its cheap, has decent range(100ft roughly for the cheap system), and is widely used so there is a ton of examples. So going on the assumption that I will be using the XBee solution I will need to implement at least some very basic error checking on it.

I am gonna find somewhere to store my code base and upload it sometime soon..