lithium flowers bloom » Arduino

Sensor Network: Data Logging and Visualization

L.J — Mon, 01 Mar 2010 07:50:18 +0000

I’m working with Sebastian and Michael as “visualization” team for the sensor network assignment for this week’s Sociable Objects Workshop. It’s very challenging for the whole class to work on one single project, but so far it went on pretty well. Tasks are split and assigned and we also find ways to work with dependencies and such constraints.

Since we are just focusing on the visualization part, meaning that we take on only after all the data are aggregated at the coordinator xbee, our main effort will be data logging, mining and visualization. So the first thing we built is a pseudo data generator that feeds data in the same format as the data will be from the coordinator. We talked to the base station team and agreed that we will be getting raw API I/O RX packet and we will take care of the parsing and data storage.

I put together some simple arduino code to feed pseudo data, they could be easily replaced by a real coordinator and ideally we will not have to change the processing code on the other side which is listening to the serial channel.

#define ADDRESS_COUNT 9
int addresses[9] = {
0x0001,
0x0002,
0x0003,
0x0004,
0x0005,
0x0006,
0x0007,
0x0008,
0x0009,
};

void setup()
{
Serial.begin(9600);
randomSeed(analogRead(0));
}

void loop()
{
for (int i = 0;i < ADDRESS_COUNT;i++)
{
if (random(1000) > 990)
{
if (random(1000) > 500)
{
sendPseudoPackage(addresses[i], 1);
}
else
{
sendPseudoPackage(addresses[i], 0);
}
}

}
delay(50);
}

void sendPseudoPackage(int address, int value) { // pass either a 0x4 or and 0x5 to turn the pin on or off
Serial.print(0x7E, BYTE); // start byte
Serial.print(0x0, BYTE); // high part of length (always zero)
Serial.print(0x17, BYTE); // low part of length (the number of bytes that follow, not including checksum)
Serial.print(0x92, BYTE); // 0x92 is I/O RX Packet

//05-12: 64-bit address
Serial.print(0x00,BYTE);
Serial.print(0x13,BYTE);

Serial.print(0xA2,BYTE);
Serial.print(0x00,BYTE);

Serial.print(0x40,BYTE);
Serial.print(0x33,BYTE);

int low = address & 0xFF;
int high = (address - low) >> 2;

Serial.print(high, BYTE);
Serial.print(low, BYTE);

//13-14: 16 bit of recipient or 0xFFFE if unknown
Serial.print(0xFF, BYTE);
Serial.print(0xFE, BYTE);

//15: Receive Option
Serial.print(0x01, BYTE);

//16: Num Samples
Serial.print(0x01, BYTE);

//17-18 Digital Channel Mask
Serial.print(0x00, BYTE);
Serial.print(0x01, BYTE); //only Digital I/O 0

//19: Analog Channel Mask
Serial.print(0x00, BYTE);

//20-21: Digital Samples
Serial.print(0x00, BYTE);
Serial.print(value, BYTE);

//no analog samples

// checksum is all bytes after length bytes
long sum = 0xFF; //fake
Serial.print( 0xFF - ( sum & 0xFF) , BYTE ); // calculate the proper checksum
delay(10); // safety pause to avoid overwhelming the serial port (if this function is not implemented properly)
}

Then I wrote a basic processing sketch which filters the data and stores only changes to the databases. The sketch itself servers as some sort of realtime visualization on the input, and we get a feeling of how often data are changing and potentially detects sensor failures if one sensor is not active for a very long time.

The processing sketch is sending data to a website that handles data logging. The website also provides query api that returns sensor history in json format, and functions like filtering by certain address. The site itself is lightweight and fairly easy to add new functionality.

The plan is to meet tomorrow and start building a web interface upon the api for the final visualization. Hopefully we could also get to verify if the pseudo data is identical to the real format, and maybe we can get a test run with the real setup.

~~Stay tuned!~~

UPDATE: A list of available API functions:

url: http://itp.nyu.edu/~lx243/sensornet/index.php/api/

all (meaning that the url will look like http://itp.nyu.edu/~lx243/sensornet/index.php/api/all)

returning all records in json format

find/:address

returning all records from address specified
address should be a string of 64bit address, e.g. 0013A20040330001

find_today/:address

find_by_day/:address/:day

day should be in the format of yyyymmdd, e.g. 20100301

status/:address

returning latest records from specified address

status_at/:address/:time

returning latest records by the time specified
time should be in the format of yyyymmddHHMMSS, e.g. 20100301140000

changes/:address

returning all changes at specified address

changes_today/:address

returning changes happened today at specified address

changes_by_day/:address/:day

returning changes happened today on specified date at specified address
day should be in the format of yyyymmdd, e.g. 20100301

stats/:address

returning open time, close time, changes, and total active time of the sensor

stats_today/:address

returning above stats from specified address

stats_by_day/:address/:day

returning above stats from specified address on specified day

UPDATE 2: Visualization

It took a while for Sebastian and I to make processing.js to talk to the API and get real time update. We used jQuery as a bridge to retrieve the data and feed it on the page to processing.js. But eventually all is fine:

Storytelling stickers update

L.J — Thu, 09 Apr 2009 22:28:27 +0000

Wrapping up what’s happened to the storytelling stickers!

THE READER

The RFID reader is working! It took a while though. I did some search and ended up taking arduino codes from http://blog.formatlos.de/2008/12/08/arduino-id-12/ featuring the AF_SoftSerial library. It’s very well written and comprehensive. The scripts added a kicking off step and a disconnection detection as well. Great work! A simple processing sketch was made to display the identifier code.

The tag needs to be really close to the reader to be recognized, which is fine in my project. But since I probably needs to get reading from both ends of a miniature trumpet/horn, that might not be good enough. I’m trying to build some antenna for the reader and see if it could extend the accessibility.

THE TAG

The tags arrived too. I ordered 300 raw EM4001 RFID tags (meaning that they come with exposed coil antennae) and unfortunately a lot of them broke. A lot of soldering is ahead! But I got enough to start anyway, like a hundred.

THE SOUND

I got the wave sound shield from Adafruit and finished assembling while procrastinating. But I haven’t tried to use them because it doesn’t record to the card and I decided to fall back to use a computer in this phrase.

So now it works like this. Whenever a card/tag/sticker is seen/read, according to the mode an audio clip associated to the tag ID would be recorded or played, by the computer. All sound files are stored on the computer instead of any hardware/memory card as I previously planned. The processing sketch was adapted to keep track of a known card and pick the corresponding sound file to play/record.

[Videos to be uploaded soon]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281

import ddf.minim.signals.*;
import ddf.minim.*;
import ddf.minim.analysis.*;
import ddf.minim.effects.*;
import processing.serial.*;

Serial myPort;
boolean connected = false;

String activeTag = "Waiting...";
PFont f = createFont("Helvetica", 50);

Hashtable cards;
Minim minim;
AudioInput in;
AudioRecorder recorder;
AudioPlayer player;

String previousCard = "";
boolean playMode = false;
boolean autoPilot = true;

void setup()
{
println("connecting...");
myPort = new Serial(this, Serial.list()[0], 9600);
myPort.clear();
cards = new Hashtable();

loadCards();

minim = new Minim(this);
in = minim.getLineIn(Minim.STEREO, 2048);

size(800,600);
background(0);
fill(255);
noStroke();
textAlign(CENTER);
textFont(f);
text("WAITING",width / 2, height / 2);
}

void draw()
{
background(0);
if (!connected)
{
myPort.write('C');
}
else
{
text(activeTag,width / 2, height / 2);

if (playMode)
{
text("PLAYING",width / 2, height / 2 + 90);
}
else
{
text("RECORDING",width / 2, height / 2 + 90);
}
if (recorder != null)
{
stroke(255);
if (playMode)
{
if (player != null)
{
for(int i = 0; i < player.left.size()-1; i++)
{
line(i, 50 + player.left.get(i)*50, i+1, 50 + player.left.get(i+1)*50);
line(i, 150 + player.right.get(i)*50, i+1, 150 + player.right.get(i+1)*50);
}
}
}
else
{
for(int i = 0; i < in.bufferSize() - 1; i++)
{
line(i, 50 + in.left.get(i)*50, i+1, 50 + in.left.get(i+1)*50);
line(i, 150 + in.right.get(i)*50, i+1, 150 + in.right.get(i+1)*50);
}
}
}
}
}

void closePlayer()
{
if (player != null && player.isPlaying())
{
try
{
player.close();
}
catch (Exception e)
{

}
}
}

void closeRecorder()
{
if (recorder != null/* && recorder.isRecording()*/)
{
try
{
recorder.endRecord();
recorder.save();
}
catch(Exception e)
{

}
}
}

void loadCards()
{
cards.clear();
String []lines = loadStrings("index.txt");
if (lines == null)
{
return;
}

for (int i = 0; i < lines.length ; i++)
{
String card = trim(lines[i]);
cards.put(card, true);
}
}

void dumpCards()
{
PrintWriter writer = createWriter("data/index.txt");

for (Enumeration e = cards.keys() ; e.hasMoreElements() ;)
{
String card = e.nextElement().toString();
writer.println(card);
}

writer.flush();
writer.close();
}

void serialEvent(Serial port) {
String myString = port.readStringUntil(' ');
if (myString != null)
{
myString = trim(myString);
if (myString.equals("connected"))
{
connected = true;
println("connected~!");
}
else
{
if (myString.equals("0000000000"))
{
activeTag = "Disconnected";

if (playMode && player != null)
{
println(previousCard + ": Disconnect from playing");
closePlayer();
}
else
{
println(previousCard + ": Disconnect from recording");
closeRecorder();
}
previousCard = "";

}
else
{
activeTag = myString;

if (!cards.containsKey(activeTag))
{
cards.put(activeTag,true);
dumpCards();
if (autoPilot)
{
closePlayer();
playMode = false; //auto switch to record
println("Autopilot: switch to record mode");
}
}
else //found
{
if (autoPilot)
{
playMode = true; //auto switch to play
closeRecorder();
println("Autopilot: switch to play mode");
}
}

if (playMode)
{
if (cards.containsKey(activeTag))
{
println(activeTag + ": Start playing new file, disconnect from previous " + previousCard);

closePlayer();

println("loading " + activeTag + " to play");
player = minim.loadFile("data/" + activeTag + ".wav", 2048);
player.play();
player.loop();
}
else
{
println(activeTag + ": Not recorded yet");
}
}
else //record mode
{
if (activeTag != previousCard)
{
println(activeTag + ": Start playing new file, disconnect from previous " + previousCard);
closePlayer();
closeRecorder();
}

recorder = minim.createRecorder(in, "data/" + activeTag + ".wav", true);
recorder.beginRecord();
}

previousCard = activeTag;
}
}
}
}

void stop()
{
in.close();

closePlayer();
closeRecorder();

minim.stop();
super.stop();
}

void keyPressed()
{
if (key == ' ')
{
playMode = !playMode;

if (playMode)
{
println("play mode");
}
else
{
println("record mode");
}
}

if (key == 'a')
{
autoPilot = !autoPilot;

if (autoPilot)
{
println("Autopilot: ON");
}
else
{
println("Autopilot: OFF");
}
}
}

THE NAME

Any thoughts on a name for the toy?

Everyone with crazy ideas of the keyless entry must be living in a dorm!

L.J — Fri, 07 Nov 2008 20:51:15 +0000

I ran into this post today and apparently it’s a similar but much savvier implementation of my unlocking system.
Really like the touch sensor use!

What’s really sad is I was locked again outside my bedroom two weeks ago at midnight. I cannot always stick my arduino to the door.

Nice work Alex!

Check out the video below:

UPDATED: Pcom lab catch up and GO OUT

L.J — Wed, 29 Oct 2008 15:59:59 +0000

The transister lab looks fun because I like these DC motors since young. They have a unique smell while spinning really fast. In my impression they could work very well with just 2 AA battery (3V) in a toy car, so I’m curious about how would it be with 9 or 12V.

First I hooked up the circuit according to the website walkthrough, using the 9V output from the arduino. Surprisedly it didn’t work, even in the simplified program without the potentiameter. I checked the circuit for a couple of times and tried to hook the motor directly to the batteries, 5V from the arduino and 12V from the wall through the adapter, all approaches worked.

It came to me a sad conclusion that the 9V output on my arduino is broken. So I tested the circuit with the 9V from my another arduino and it worked. Is it that the arduino cannot output 5V and 9V at the same time? I haven’t tested this hypothesis yet.

some photos and videos (the motor was spinning so hard that I had to tape it to the board):

I’l catch up with the H-bridge lab next week.

—— a happy going-out seperator ——

I was having a group meeting on a short film for commlab and someone just mentioned Michel Gondry while Marco turned around from the table beside and told us that Michel Gondry was going to give a talk right that evening at Strand. I hesitated for a while since I have another project due the next morning, but it was not long. We were really lucky that Marco got us there one hour earlier before the talk started at 7. Huge crowd started to gather since 6:30 and by then we were already sitting within 10 meters from the stage. I did take some photos but the memory card of my phone seems half broken and seriously it does not make much sense to take photo of people in a talk.

The talk started by showing some of Michel’s recent work, then a short interview between him and his PR guy, and another short video, and another short interview and so on. The screening including some excerpts from his latest film “be kind rewind” but my favorite is the music video he did for “Mad World” by Gary Jules and Michael Andrews. Not only Donnie Darko is one of my favorite and I love the song SOOOO MUUUCHHH but this music video is so moving and so well made in one long take. It’s like a combination of all my loved things. Check out the video below:

Michel also talked about the “protocal” of filmmaking and sharing within the community. It’s more discussed in his new book that I haven’t read yet so I’m not sure I totally understand that. He actually accused his PR guy for charging too high on the book (?). And once while Michel is still talking the guy started to check the time, Michel suddenly stopped and turned to him and said “Don’t look at your watch while I’m still talking. It’s VERY rude.” It became a little bit awkward in the atmosphere for a while. But I like it.

CUBE was not built/burnt in a day

L.J — Wed, 22 Oct 2008 16:12:27 +0000

ACT 0: BRAINSTORMING THE CUBE

ACT 1: ARDUINO ONLY SOUND ANALYSIS

pcom midterm: microphone + arduino beat detection from Leejay Xia on Vimeo.

pcom midterm: mircophone + arduinobeat detection log from Leejay Xia on Vimeo.

ACT 2: THE MACHANICS

pcom midterm: the skeleton from Leejay Xia on Vimeo.

ACT 3: IT WORKED!!!

pcom midterm: rhythm awareness dance pattern from Leejay Xia on Vimeo.

on two arduinos:

ACT 4: …UNTIL WE BURNT OUT THE CORE SERVO

The only motion left was the up-down. But it still works!

pcom midterm: dance! from Leejay Xia on Vimeo.

ACT 5: NOT THE WORST DANCE IN THE WORLD

pcom midterm: dance! from Leejay Xia on Vimeo.

PCom Update: multiple serial input

L.J — Wed, 15 Oct 2008 06:11:52 +0000

I’ve been mostly working on viz class and pcom mid term over the weekend. One big thing is I once made the eight-buck-deal RF Link work in the studio, but never succeeded in testing again since I went back to the dorm. I used software serial library to utilize digital pins as serial input/output and leave the original serial port for computer monitoring, but the RL Links still feel like a black box to me. The transmitter side looks working perfectly while I hooked up a USB cable and tried to read the TX stream, however the receiver side keeps getting rubbish data. More efforts are to be invested on this issue!!

Just a quick update on the multi-serial-input, shown as the video below (yes I still love my force sensors):

It’s pretty simple, just using two serial inputs. But the concept of encoding data and protocol is pretty clear.

Arduino Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

int leftPin = 4;
int rightPin = 5;
int leftValue,rightValue;

void setup()
{
beginSerial(9600); //set up communication back to pc
}

void loop()
{
leftValue = analogRead(leftPin);
rightValue = analogRead(rightPin);

//if (abs(leftValue - rightValue) > 50)
//{
Serial.print(leftValue,DEC);
Serial.print(44,BYTE);
Serial.print(rightValue,DEC);
Serial.print(44,BYTE);
Serial.println();
//}
}

Processing Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

import processing.serial.*;

Serial myPort;
String data;
int leftValue = 0;
int rightValue = 0;

void setup()
{
size(800, 600, P3D);
directionalLight(126, 126, 126, 0, 0, -1);
ambientLight(102, 102, 102);
noStroke();
myPort = new Serial(this, Serial.list()[0], 9600);
ellipseMode(CENTER);
}

void draw()
{
background(0);
float leftR = map(leftValue,0,1023,0,PI/2);
float rightR = map(rightValue,0,1023,0,PI/2);

translate(width/2, height/2);

rotateX(-PI/12);
rotateZ(rightR - leftR);
stroke(160,10);
fill(150,150,150,90);
box(500,10,100);
translate(0,10);

noStroke();
fill(255,0,0);
translate(map(rightValue - leftValue,-1023,1023,-250,250),-25);
sphere(10);
}

void serialEvent(Serial p) {
String input = p.readStringUntil(10); //make sure you return (Ascii 13) at the end of your transmission
if (input != null)
{
String[] parts = input.split(","); //this will only work if you put commas (Ascii 44) between things in your transmission

if (parts.length >= 2)
{
//println("Raw Input: " + input);
if (abs(int(parts[0]) - leftValue) > 10)
{
leftValue = int(parts[0]);
}
if (abs(int(parts[1]) - rightValue) > 10)
{
rightValue = int(parts[1]);
}
}
}
}

PCom: Serial Input in Processing

L.J — Wed, 08 Oct 2008 15:42:33 +0000

I do enjoy the force sensor I got in week 5′s application class so I’ll definitely use it more in the assignment!

First I revisited the processing codes I wrote for week 2, which now seems to be a total mess. I didn’t know about the serialEvent callback then so I parsed the serial input in the draw loop, and I didn’t use BYTE output in the arduino board so I need to parse it as string. It worked pretty well but the revised the version is much better.

Codes:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

import processing.serial.*;

Serial myPort;
int window = 800;
int[] values = new int[window - 100];
int index = 0;
int input = 0;

void setup()
{
size(window,window);
background(0,30);
smooth();
// List all the available serial ports:
//println(Serial.list());
myPort = new Serial(this, Serial.list()[0], 9600);

for (int i = 0;i<window - 100;i++)
{
values[i] = 0;
}
}

void draw()
{
background(0,20);
for (int i = 0; i < window - 100;i++)
{
int j = i + index;
if (j >= (window - 100))
{
j = j - (window - 100);
}

stroke(255,0,0,80);
line(50 + i, (window - 50), 50 + i, (window - 50) - (values[j] * (window - 100) / 1024));
stroke(255,0,0,100);
point(50 + i, (window - 50));
point(50 + i, (window - 50) - (values[j] * (window - 100) / 1024));
}
}

void serialEvent(Serial p) {
input = p.read();
println("input:" + input);
values[index] = input * 4;
index++;
if (index >= window - 100)
{
index = index - (window - 100);
}
}

Then I thought about the nature of the force sensor and really wished I could visualize the “force” in the processing. So I adopted the “string” example bundled in the processing application and integrated it with the serial input.

Codes:

import processing.serial.*;
// The serial port:
Serial myPort;
int input = 0;
int lastInput = -1;

// Spring drawing constants for top bar
int s_height = 16; // Height
int left = 150; // Left position
int right = 250; // Right position
int max = 300; // Maximum Y value
int min = 20; // Minimum Y value
boolean over = true; // If mouse over
boolean move = false; // If mouse down and over

// Spring simulation constants
float M = 0.8; // Mass
float K = 0.2; // Spring constant
float D = 0.92; // Damping
float R = 60; // Rest position

// Spring simulation variables
float ps = 60.0; // Position
float vs = 0.0; // Velocity
float as = 0; // Acceleration
float f = 0; // Force

void setup()
{
size(400, 400);
rectMode(CORNERS);
noStroke();
myPort = new Serial(this, Serial.list()[0], 9600);
}

void draw()
{
background(102);
updateSpring();
drawSpring();
}

void drawSpring()
{
// Draw base
fill(0.2);
float b_width = 0.5 * ps + -8;
rect(width/2 - b_width, ps + s_height, width/2 + b_width, 350);
}

void updateSpring()
{
// Update the spring position
if(!move) {
f = -K * (ps - R); // f=-ky
as = f / M; // Set the acceleration, f=ma == a=f/m
vs = D * (vs + as); // Set the velocity
ps = ps + vs; // Updated position
}
if(abs(vs) < 0.1) {
vs = 0.0;
}

// Test if mouse is over the top bar
/*
if(mouseX > left && mouseX < right && mouseY > ps && mouseY < ps + s_height) {
over = true;
} else {
over = false;
}
*/

// Set and constrain the position of top bar
if(move) {
ps = map(input,0,255,min,max) - s_height/2;
if (ps < min) { ps = min; }
if (ps > max) { ps = max; }
}
}

void serialEvent(Serial p) {
input = p.read();
println("input:" + input);

if (input > lastInput)
{
move = true;
}
else if (lastInput > input + 10 || input < 10)
{
move = false;
}

lastInput = input;
}

Solution for Lockouts

L.J — Wed, 01 Oct 2008 07:18:57 +0000

Lockouts are irritating. especially when you live in a dorm, at midnight, your roommate is sleeping, and backup keys are two hours away.

Here’s the self-service solution.

I should have made a much more complex combination lock with multiple sensors and flexible customization functionalities, but it’s two in the morning… so maybe next time…

Secret revealed.

It’s kind of low tech in the backstage. All we need are: arduino, plus a servomotor, and, gravity. 8 quarter coins are used as weight. So it’s basically a two dollar solution! (what? the arduino? breadboard servomotor and all the lab kits? well…)

More pictures:

bonus video – playing servomotor with force sensor (warning: not fun to watch at all)

Thanks Li for the force sensor! We”ll have to talk!

Physical Computing Week 2: Analog!

L.J — Wed, 17 Sep 2008 15:11:07 +0000

Hooking up the following stuff according to the diagram was easy and quick. And a resister of ~~220~~ 10K Om is working ideally to create an ouput range of 0 – 930 (from total darkness to direct shine of torchlight) for the photocell.

I changed the switch from last week to a much smaller one which could be inserted right into the breadboard, to get rid of the mess of the hookup wires. The output was quite straightforward in the arduino console window, so I decided to connect the output to the processing.

This is how it works:

Physical Computing Week 2 from Leejay Xia on Vimeo.

(Quick and Dirty) Code for Processing, it’s based on the example on their site

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

import processing.serial.*;

// The serial port:
Serial myPort;
int window = 400;
int[] values = new int[window - 100];
int index = 0;

void setup()
{
size(window,window);
background(0);
smooth();
// List all the available serial ports:
println(Serial.list());
myPort = new Serial(this, Serial.list()[0], 9600);
for (int i = 0;i<window - 100;i++)
{
values[i] = 0;
}
}

void draw()
{
if (myPort.available() > 0)
{
String inBuffer = myPort.readString();
String[] vals = splitTokens(inBuffer);

for (int i = 0;i<vals.length;i++)
{
values[index] = int(vals[i]);
//println(index+":"+values[index]+"/"+vals[i]);
index++;
if (index >= window - 100)
{
index = index - (window - 100);
}
}
background(0);
for (int i = 0; i < window - 100;i++)
{
int j = i + index;
if (j >= (window - 100))
{
j = j - (window - 100);
}
stroke(255,0,0,90);
line(50 + i, (window - 50), 50 + i, (window - 50) - (values[j] * (window - 100) / 1024));
stroke(255,0,0,100);
point(50 + i, (window - 50));
point(50 + i, (window - 50) - (values[j] * (window - 100) / 1024));
}
}
}

Notes-taking:

I tried also the Thermistors but have not yet find a right resister to tune its output range.
In the current codes, the arduino board must be plugged before the processing applet runs.
This is because the processing init code cannot find a usable serial port to initialize the object. And so far I didn’t see a possible way to initialize it during the draw() loop due to the lack of a try/catch machanism. More exploration to go!
The serial port transmits data much faster than the draw() function loops. Thus everytime we arrive in the draw() loop there might be a bunch of values waited in the buffer. These values need to be splited and stored accordingly. Of course a more complex protocal could be created to sample specific data or behavior.

More Photos:

Digital I/O with Arduino

L.J — Wed, 10 Sep 2008 06:02:49 +0000

I bought my first Arduino boards in 2007 and never touched them again ever since setting up the famous “blinking LED” code sample. It does recall some memory when I have my hands on the chips and boards and wires and stuff… again.

The Arduino I have is an old NG(Nuova Generazione) rev C, which is later replaced by the most popular “Diecimila”. ~~It comes with a less popular USB Type B port, and t~~The user would need to manually click the reset button before uploading the program to the board.

However there’s is still a good thing about it that it does provide a PIN 13 for LED with built-in resister. Hence it requires least effort to setup a minimum “Blinking LED” sample. You don’t even need a breadboard.

Adding digital input is fun. I decided to leave the LED output as is now that it’s working fine with the preset PIN 13, in the good wishes that I would not mess up too much with the breadboard.

B-O-O-M

Check out the video as well!

arduino_blinker_switch

A small piece of code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

int ledPin = 13;
int switchPin = 2;

void setup()
{
  pinMode(ledPin, OUTPUT); // sets the digital pin as output
  pinMode(switchPin, INPUT);
}

void loop()
{
  if (digitalRead(switchPin))
  {
   digitalWrite(ledPin, HIGH); // sets the LED on
   delay(1000); // waits for a second
   digitalWrite(ledPin, LOW); // sets the LED off
   delay(1000); // waits for a second
  }
}