Poorman's oscilloscope (with Arduino + Processing)

"The resolution is 10 bits so this is not like a real oscilloscope"

Sure it is. Scopes are only 8 bits. They just use low-noise, variable-gain circuitry to measure a huge range of values.

It's the very low sampling frequency that makes this a "poor man's" scope. Real scopes go up to the MHz.

I'm wondering, could the sample rate be improved via USB? Using the CUI and HID drivers, mapping analog inputs to joystick X/Y/Z/Throttle etc.... I'm curious.... Or is it simply a limitation of the arduino's processing/sampling power?

Here's my screenshot:

See this:
http://code.google.com/p/arduinoscope/wiki/Usage

If you 'd like info about configuring or changing it to do other things.

I made a version that is easier to work with in any GUI (IMHO) and an example app that reads 6 analog pins.

Here are some features:
logic analyzer mode that shows 1's and 0's clearly.
pause frame
save frame
configurable pin-count
use as many pins as will fit on screen (tested with 12 at 800x800, seems ok)
shows volts, based on scaling settings

I set it up to be useful as a logic analyzer for digital pins, or oscilloscope for analog.

http://code.google.com/p/arduinoscope/

I'd like to add more features like extended frame logging (continuous) and detecting bytes in logic probe view, like SPI/i2C. I'd also like to add a parallel mode, for reading 8-pins at a time into a single byte.

//Have fun.

import processing.serial.*;

Serial port; // Create object from Serial class
int valA;
int valB;
int valC;
int valD;
int valE;
int valF;
// this should have been some kind of 2-diminsional array, I guess,
but it works.
int[] valuesA;
int[] valuesB;
int[] valuesC;
int[] valuesD;
int[] valuesE;
int[] valuesF;

PFont fontA;
PFont fontB;

// make sure you have these fonts made for Processing. Use
Tools...Create Font.
// "fontA" is a 48 pt font of some sort. It's what we use to show
the "now" value.
fontA = loadFont("CourierNewPSMT-48.vlw");

// "fontB" is a 14 pt font of some sort. It's what we use to show
the min and max values.
fontB = loadFont("CourierNewPSMT-14.vlw");

// I wouldn't change the size if I were you. There are some
functions that don't use
// the actual sizes to figure out where to put things. Sorry about that.
size(550, 600);

// Open the port that the board is connected to and use the same speed
// anything faster than 38.4k seems faster than the ADC on the
Arduino can keep up with.
// So, if you want it to be smooth, keep it at or below 38400. 28800
doesn't work at all,
// I do not know why. If you turn on smooth() you need to drop the
rate to 19.2k or lower.
// You will probably have to adjust Serial.list()[1] to get your serial port.
port = new Serial(this, Serial.list()[1], 38400);

// These are 6 arrays for the 6 analog input channels.
// I'm sure it could have just as well been a 2d array, but I'm not
that familiar
// with Processing yet and this was the easy way out.
valuesA = new int[width-150];
valuesB = new int[width-150];
valuesC = new int[width-150];
valuesD = new int[width-150];
valuesE = new int[width-150];
valuesF = new int[width-150];
// the -150 gives us room on the side for our text values.

// this turns on anti-aliasing. max bps is about 19.2k.
// uncomment out the next line to turn it on. Personally, I think
it's better left off.
//smooth();
}

int getY(int val) {
// I added -40 to this line to keep the lines from overlapping, to
// keep the values within their gray boxes.
return (int)(val / 1023.0f * (height-40)) - 1;
}

String decoder = "";
while (port.available() >= 3)
{
// read serial until we get to an "A".
decoder = port.readStringUntil(65);
}
// sanity check. make sure the string we got from the Arduino has
all the values inside.
if ((decoder.indexOf("B")>=1) & (decoder.indexOf("C")>=1) &
(decoder.indexOf("D")>=1) & (decoder.indexOf("E")>=1) &
(decoder.indexOf("F")>=1))
{
// decoder string doesn't contain an A at the beginning. it's at the end.
valA=int(decoder.substring(0,decoder.indexOf("B")));
//println("A" + str(valA));
valB=int(decoder.substring(decoder.indexOf("B")+1,decoder.indexOf("C")));
//println("B" + str(valB));
valC=int(decoder.substring(decoder.indexOf("C")+1,decoder.indexOf("D")));
//println("C" + str(valC));
valD=int(decoder.substring(decoder.indexOf("D")+1,decoder.indexOf("E")));
//println("D" + str(valD));
valE=int(decoder.substring(decoder.indexOf("E")+1,decoder.indexOf("F")));
//println("E" + str(valE));
valF=int(decoder.substring(decoder.indexOf("F")+1,decoder.indexOf("A")));
//println("F" + str(valF));
}

//shift the new values into the array, move everything else over by one
for (int i=0; i<width-151; i++) {
valuesA[i] = valuesA[i+1];
valuesB[i] = valuesB[i+1];
valuesC[i] = valuesC[i+1];
valuesD[i] = valuesD[i+1];
valuesE[i] = valuesE[i+1];
valuesF[i] = valuesF[i+1];
}

// -151 because the array is 151 less than the width. remember we
// saved room on the side of the screen for the actual text values.
valuesA[width-151] = valA;
valuesB[width-151] = valB;
valuesC[width-151] = valC;
valuesD[width-151] = valD;
valuesE[width-151] = valE;
valuesF[width-151] = valF;

background(0);

textFont(fontA);

// I'm sure these c/should have been determined using height math,
but I don't have the time really.
// Draw out the now values with the big font.
text(valA + 1, (width-140), 108-5);
text(valB + 1, (width-140), 206-5);
text(valC + 1, (width-140), 304-5);
text(valD + 1, (width-140), 402-5);
text(valE + 1, (width-140), 500-5);
text(valF + 1, (width-140), 598-5);

textFont(fontB);
// Draw out the min and max values with the small font.
// the h value (30,128,266,etc) is a function of height,
// but I didn't bother to actually do the math.
// I guess it's (98*n)+30 where n is 0,1,2,3,4,5, but I don't know
// exactly how height (600) relates to 98... ((h/6)-2??)
drawdata("0", width-90, 30, valuesA);
drawdata("1", width-90, 128, valuesB);
drawdata("2", width-90, 226, valuesC);
drawdata("3", width-90, 324, valuesD);
drawdata("4", width-90, 422, valuesE);
drawdata("5", width-90, 520, valuesF);

for (int x=150; x<width-1; x++) {
// next line adjusts the color of the stroke depending on the x
value. (fades out the end of the line)
check(x,255,0,0);

// next line draws the line needed to get this value in the array
to the next value in the array.
// the offsets (6+ in the next line) were used to get the values
where I wanted them without
// having to actually do real spacial math. There's a hack in getY
that offsets a little, too.
line((width)-x,
6+((height/6)*0)+((height-1-getY(valuesA[x-150]))/6), (width)-1-x,
6+((height/6)*0)+((height-1-getY(valuesA[x-149]))/6));
check(x,0,255,0);
line((width)-x,
4+((height/6)*1)+((height-1-getY(valuesB[x-150]))/6), (width)-1-x,
4+((height/6)*1)+((height-1-getY(valuesB[x-149]))/6));
check(x,0,0,255);
line((width)-x,
2+((height/6)*2)+((height-1-getY(valuesC[x-150]))/6), (width)-1-x,
2+((height/6)*2)+((height-1-getY(valuesC[x-149]))/6));
check(x,255,255,0);
line((width)-x,
0+((height/6)*3)+((height-1-getY(valuesD[x-150]))/6), (width)-1-x,
0+((height/6)*3)+((height-1-getY(valuesD[x-149]))/6));
check(x,0,255,255);
line((width)-x,
-2+((height/6)*4)+((height-1-getY(valuesE[x-150]))/6), (width)-1-x,
-2+((height/6)*4)+((height-1-getY(valuesE[x-149]))/6));
check(x,255,0,255);
line((width)-x,
-4+((height/6)*5)+((height-1-getY(valuesF[x-150]))/6), (width)-1-x,
-4+((height/6)*5)+((height-1-getY(valuesF[x-149]))/6));
}

// draw the boxes in gray.
stroke(170,170,170);

// these 5 lines divide the 6 inputs
line(0,108,width-1,108);
line(0,206,width-1,206);
line(0,304,width-1,304);
line(0,402,width-1,402);
line(0,500,width-1,500);

// these four lines make up the outer box
line( 0, 0, width-1, 0); // along the top
line(width-1, 0, width-1, height-1); // down the right
line(width-1, height-1, 0, height-1); // along the bottom
line( 0, height-1, 0, 0); // up the left
}

text("pin: " + pin, w, h);
text("min: " + str(min(values) + 1), w, h + 14);
text("max: " + str(max(values) + 1), w, h + 28);
}

// floating point operations in Processing are expensive.
// only do the math for the float (fading out effect) if
// we have to. You can change 170 to 160 if you want it to
// fade faster, but be sure to change the other 170 to 160
// and the 20 to 10.
// (20 is the difference between 170 and 150)
if (xx<=170)
{
float kick = (parseFloat(170-xx)/20)*255;
// invert kick so the brighter parts are on the left side instead
of the right.
stroke(rr,gg,bb,255-kick);
}
else
{
stroke(rr,gg,bb);
}
}

/*
This is the Arduino Code:

1. define ANALOGA_IN 0
2. define ANALOGB_IN 1
3. define ANALOGC_IN 2
4. define ANALOGD_IN 3
5. define ANALOGE_IN 4
6. define ANALOGF_IN 5

void setup() {
Serial.begin(38400);
}

void loop() {
int val[5];

val[0] = analogRead(ANALOGA_IN);
val[1] = analogRead(ANALOGB_IN);
val[2] = analogRead(ANALOGC_IN);
val[3] = analogRead(ANALOGD_IN);
val[4] = analogRead(ANALOGE_IN);
val[5] = analogRead(ANALOGF_IN);

Serial.print( "A" );
Serial.print( val[0] );
Serial.print( "B" );
Serial.print( val[1] );
Serial.print( "C" );
Serial.print( val[2] );
Serial.print( "D" );
Serial.print( val[3] );
Serial.print( "E" );
Serial.print( val[4] );
Serial.print( "F" );
Serial.print( val[5] );
}

• /

Hi,
This is cool.
I guess that in this case the max input frequency is restricted by the serial output...
Couldn't be possible to catch 1K values and send them?
In this case... how many samples per second would be achievable? Anyone?

This is a screen shot of your oscope displaying the output of a photo resistor aimed at an LED flashing a 1kHz.

Thanks for the work!

Thanks for the code, it works great! I wanted to do some more measuring. How can I go about measuring (and displaying) voltage from more than just pin 0? For that matter, any other colors available on the display? I'm a little light on processing/wiring.

I am not an electronics guru, so bare with me. If I am correct, there is a 5V limit on the analog pin. It would be nice if maybe 20V could be used. Any idea with what components you could create some kind of reference voltage. To make this more clear is, if the max voltage that can be applied is 20V, then I would like to have this converted to 5 V, 18V is then 4.5V (18*5/20), 12V is then 3V.

Would be nice if this is doable.

I'm going to try this when I get back to the bench. What do you use for 10-bit serial to the mac?