How To Save Data from Arduino To A .csv File Using Processing

November 12, 2014 Elaine Laguerta 23 Comments

Introduction

Spreadsheets are awesome! They are a ubiquitous and powerful file structure that can cause headache and joy in equally heart-stopping intensities. Within the context of a larger project, you may want to save Arduino data (from sensors, for example) to a .csv file for further analysis, visualization, or whatever spreadsheet bonanzas you can dream up. The following two sketches save data from Arduino to a .csv file on your computer, complete with a timestamp with gloriously specific column names (year, month, day, hour, minute, second…and you can add milliseconds!).

This 2-sketch solution takes advantage of the built-in Table class in Processing. Tables are also awesome, as they are basically spreadsheets in the Processing world. Read all about them (this link has some handy methods for working with tables beyond what this tutorialprovides): http://processing.org/reference/javadoc/core/processing/data/Table.html

Here is an overview of what this tutorial accomplishes:

This is a beginning-level tutorial with one prerequisite! Arduino and Processing have to shake hands. I know it’s a lot to ask, but cooperation is at the root of any good spreadsheet. Here’s a link to a tutorial: http://www.hackerscapes.com/2014/10/lab-6-processing/

First, Download and Install the following:

Arduino IDE: http://arduino.cc/en/main/software
Processing 2.0: https://www.processing.org/download/

Step 1: Read Data, Send to Processing via Serial Port

First, set up the Arduino side. Here’s a a gist-y sketch:

/*
Sending Data to Processing via the Serial Port
This sketch provides a basic framework to send data from Arduino to Processing over a Serial Port. This is a beginning level sketch.

Hardware:
* Sensors connected to Arduino input pins
* Arduino connected to computer via USB cord

Software:
*Arduino programmer
*Processing (download the Processing software here: https://www.processing.org/download/

Additional Libraries:
*Read about the Software Serial library here: http://arduino.cc/en/Reference/softwareSerial

Created 12 November 2014
By Elaine Laguerta
http://url/of/online/tutorial.cc
*/

/*To avoid overloading the Arduino memory, and to encourage portability to smaller microprocessors, this sketch
does not timestamp or transform data. In this tutorial, timestamping data is handled on the processing side.

Whether you process data on the Arduino side is up to you. Given memory limitations of the Arduino, even a few computations and mapping of values can
max out the memory and fail. I recommend doing as little as possible on the Arduino board.*/

#include SoftwareSerial.h

/*Declare your sensor pins as variables. I'm using Analog In pins 0 and 1. Change the names and numbers as needed
Pro tip: If you're pressed for memory, use #define to declare your sensor pins without using any memory. Just be careful that your pin name shows up NOWHERE ELSE in your sketch!
for more info, see: http://arduino.cc/en/Reference/Define
*/
int sensor1Pin = 0;
int sensor2Pin = 1;
int sennsor3Pin = 2;

/*Create an array to store sensor values. I'm using floats. Floats use 4 bytes to represent numbers in exponential notation. Use int if you are representing whole numbers from -32,768 to 32,767.
For more info on the appropriate data type for your sensor values, check out the language reference on data type: http://arduino.cc/en/Reference/HomePage
Customize the array's size to be equal to your number of sensors.
*/
float sensorVals[] = {0,0,0}

/*Pro tip: if you have a larger number of sensors, you can use a for loop to initialize your sensor value array. Here's sample code (assuming you have 6 sensor values):
float sensorVals[6];
int i;
for (i=0; i&lt;6; i++)
{
sensorVals[i] = 0;
}
*/

void setup(){
Serial.begin(9600); //This line tells the Serial port to begin communicating at 9600 bauds
}

//
void loop(){
//read each sensor value. We are assuming analog values. Customize as nessary to read all of your sensor values into the array. Remember to replace "sensor1Pin" and "sensor2Pin" with your actual pin names from above!
sensorVal[0] = analogRead(sensor1Pin);
sensorVal[1] = analogRead(sensor2Pin);
sensorVal[2] = analogRead(sensor3Pin);
/*If you are reading digital values, use digitalRead() instead. Here's an example:
sensorVal[0] = digitalRead(sensor1Pin);
*/

//print over the serial line to send to Processing. To work with the processisng sketch we provide, follow this easy convention: separate each sensor value with a comma, and separate each cycle of loop with a newline character.
//Remember to separate each sensor value with a comma. Print every value and comma using Serial.print(), except the last sensor value. For the last sensor value, use Serial.println()
Serial.print(sensors[0]);
Serial.print(",");
Serial.print(sensors[1]);
Serial.print(",");
Serial.println(sensors[1]);
delay(100);
}

Sending Data to Processing via the Serial Port

This sketch provides a basic framework to send data from Arduino to Processing over a Serial Port. This is a beginning level sketch.

Hardware:

* Sensors connected to Arduino input pins

* Arduino connected to computer via USB cord

Software:

*Arduino programmer

*Processing (download the Processing software here: https://www.processing.org/download/

Additional Libraries:

*Read about the Software Serial library here: http://arduino.cc/en/Reference/softwareSerial

Created 12 November 2014

By Elaine Laguerta

http://url/of/online/tutorial.cc

/*To avoid overloading the Arduino memory, and to encourage portability to smaller microprocessors, this sketch

does not timestamp or transform data. In this tutorial, timestamping data is handled on the processing side.

Whether you process data on the Arduino side is up to you. Given memory limitations of the Arduino, even a few computations and mapping of values can

max out the memory and fail. I recommend doing as little as possible on the Arduino board.*/

#include SoftwareSerial.h

/*Declare your sensor pins as variables. I'm using Analog In pins 0 and 1. Change the names and numbers as needed

Pro tip: If you're pressed for memory, use #define to declare your sensor pins without using any memory. Just be careful that your pin name shows up NOWHERE ELSE in your sketch!

for more info, see: http://arduino.cc/en/Reference/Define

int sensor1Pin = 0;

int sensor2Pin = 1;

int sennsor3Pin = 2;

/*Create an array to store sensor values. I'm using floats. Floats use 4 bytes to represent numbers in exponential notation. Use int if you are representing whole numbers from -32,768 to 32,767.

For more info on the appropriate data type for your sensor values, check out the language reference on data type: http://arduino.cc/en/Reference/HomePage

Customize the array's size to be equal to your number of sensors.

float sensorVals[] = {0,0,0}

/*Pro tip: if you have a larger number of sensors, you can use a for loop to initialize your sensor value array. Here's sample code (assuming you have 6 sensor values):

float sensorVals[6];

int i;

for (i=0; i<6; i++)

{

sensorVals[i] = 0;

}

void setup(){

Serial.begin(9600); //This line tells the Serial port to begin communicating at 9600 bauds

}

void loop(){

//read each sensor value. We are assuming analog values. Customize as nessary to read all of your sensor values into the array. Remember to replace "sensor1Pin" and "sensor2Pin" with your actual pin names from above!

sensorVal[0] = analogRead(sensor1Pin);

sensorVal[1] = analogRead(sensor2Pin);

sensorVal[2] = analogRead(sensor3Pin);

/*If you are reading digital values, use digitalRead() instead. Here's an example:

sensorVal[0] = digitalRead(sensor1Pin);

//print over the serial line to send to Processing. To work with the processisng sketch we provide, follow this easy convention: separate each sensor value with a comma, and separate each cycle of loop with a newline character.

//Remember to separate each sensor value with a comma. Print every value and comma using Serial.print(), except the last sensor value. For the last sensor value, use Serial.println()

Serial.print(sensors[0]);

Serial.print(",");

Serial.print(sensors[1]);

Serial.print(",");

Serial.println(sensors[1]);

delay(100);

}

Step 2: Use Processing to Receive Data from Arduino, Write data to a Table, and Save Table to a .csv
Now we will handle the processing side.

/* 
  Saving Values from Arduino to a .csv File Using Processing - Pseduocode

  This sketch provides a basic framework to read data from Arduino over the serial port and save it to .csv file on your computer.
  The .csv file will be saved in the same folder as your Processing sketch.
  This sketch takes advantage of Processing 2.0's built-in Table class.
  This sketch assumes that values read by Arduino are separated by commas, and each Arduino reading is separated by a newline character.
  Each reading will have it's own row and timestamp in the resulting csv file. This sketch will write a new file a set number of times. Each file will contain all records from the beginning of the sketch's run.  
  This sketch pseduo-code only. Comments will direct you to places where you should customize the code.
  This is a beginning level sketch.

  The hardware:
  * Sensors connected to Arduino input pins
  * Arduino connected to computer via USB cord
        
  The software:
  *Arduino programmer
  *Processing (download the Processing software here: https://www.processing.org/download/
  *Download the Software Serial library from here: http://arduino.cc/en/Reference/softwareSerial

  Created 12 November 2014
  By Elaine Laguerta
  http://url/of/online/tutorial.cc

*/

import processing.serial.*;
Serial myPort; //creates a software serial port on which you will listen to Arduino
Table dataTable; //table where we will read in and store values. You can name it something more creative!

int numReadings = 500; //keeps track of how many readings you'd like to take before writing the file. 
int readingCounter = 0; //counts each reading to compare to numReadings. 
 
String fileName;
void setup()
{
  String portName = Serial.list()[1]; 
  //CAUTION: your Arduino port number is probably different! Mine happened to be 1. Use a "handshake" sketch to figure out and test which port number your Arduino is talking on. A "handshake" establishes that Arduino and Processing are listening/talking on the same port.
  //Here's a link to a basic handshake tutorial: https://processing.org/tutorials/overview/
  
  myPort = new Serial(this, portName, 9600); //set up your port to listen to the serial port
   
  table.addColumn("id"); //This column stores a unique identifier for each record. We will just count up from 0 - so your first reading will be ID 0, your second will be ID 1, etc. 
  
  //the following adds columns for time. You can also add milliseconds. See the Time/Date functions for Processing: https://www.processing.org/reference/ 
  table.addColumn("year");
  table.addColumn("month");
  table.addColumn("day");
  table.addColumn("hour");
  table.addColumn("minute");
  table.addColumn("second");
  
  //the following are dummy columns for each data value. Add as many columns as you have data values. Customize the names as needed. Make sure they are in the same order as the order that Arduino is sending them!
  table.addColumn("sensor1");
  table.addColumn("sensor2");

}

void serialEvent(Serial myPort){
  val = myPort.readStringUntil('\n'); //The newline separator separates each Arduino loop. We will parse the data by each newline separator. 
  if (val!= null) { //We have a reading! Record it.
    val = trim(val); //gets rid of any whitespace or Unicode nonbreakable space
    println(val); //Optional, useful for debugging. If you see this, you know data is being sent. Delete if  you like. 
    float sensorVals[] = float(split(val, ',')); //parses the packet from Arduino and places the valeus into the sensorVals array. I am assuming floats. Change the data type to match the datatype coming from Arduino. 
   
    TableRow newRow = dataTable.addRow(); //add a row for this new reading
    newRow.setInt("id", table.lastRowIndex());//record a unique identifier (the row's index)
    
    //record time stamp
    newRow.setInt("year", year());
    newRow.setInt("month", month());
    newRow.setInt("day", day());
    newRow.setInt("hour", hour());
    newRow.setInt("minute", minute());
    newRow.setInt("second", second());
    
    //record sensor information. Customize the names so they match your sensor column names. 
    newRow.setFloat("sensor1", sensorVals[0]);
    newRow.setFloat("sensor2", sensorVals[1]);
    
    readingCounter++; //optional, use if you'd like to write your file every numReadings reading cycles
    
    //saves the table as a csv in the same folder as the sketch every numReadings. 
    if (readingCounter % numReadings ==0)//The % is a modulus, a math operator that signifies remainder after division. The if statement checks if readingCounter is a multiple of numReadings (the remainder of readingCounter/numReadings is 0)
    {
      fileName = str(year()) + str(month()) + str(day()) + str(dataTable.lastRowIndex()); //this filename is of the form year+month+day+readingCounter
      saveTable(dataTable, fileName); //Woo! save it to your computer. It is ready for all your spreadsheet dreams. 
    }
   }
}

void draw()
{ 
   //visualize your sensor data in real time here! In the future we hope to add some cool and useful graphic displays that can be tuned to different ranges of values. 
}

Saving Values from Arduino to a .csv File Using Processing - Pseduocode

This sketch provides a basic framework to read data from Arduino over the serial port and save it to .csv file on your computer.

The .csv file will be saved in the same folder as your Processing sketch.

This sketch takes advantage of Processing 2.0's built-in Table class.

This sketch assumes that values read by Arduino are separated by commas, and each Arduino reading is separated by a newline character.

Each reading will have it's own row and timestamp in the resulting csv file. This sketch will write a new file a set number of times. Each file will contain all records from the beginning of the sketch's run.

This sketch pseduo-code only. Comments will direct you to places where you should customize the code.

This is a beginning level sketch.

The hardware:

* Sensors connected to Arduino input pins

* Arduino connected to computer via USB cord

The software:

*Arduino programmer

*Processing (download the Processing software here: https://www.processing.org/download/

*Download the Software Serial library from here: http://arduino.cc/en/Reference/softwareSerial

Created 12 November 2014

By Elaine Laguerta

http://url/of/online/tutorial.cc

import processing.serial.*;

Serial myPort; //creates a software serial port on which you will listen to Arduino

Table dataTable; //table where we will read in and store values. You can name it something more creative!

int numReadings = 500; //keeps track of how many readings you'd like to take before writing the file.

int readingCounter = 0; //counts each reading to compare to numReadings.

String fileName;

void setup()

{

String portName = Serial.list()[1];

//CAUTION: your Arduino port number is probably different! Mine happened to be 1. Use a "handshake" sketch to figure out and test which port number your Arduino is talking on. A "handshake" establishes that Arduino and Processing are listening/talking on the same port.

//Here's a link to a basic handshake tutorial: https://processing.org/tutorials/overview/

myPort = new Serial(this, portName, 9600); //set up your port to listen to the serial port

table.addColumn("id"); //This column stores a unique identifier for each record. We will just count up from 0 - so your first reading will be ID 0, your second will be ID 1, etc.

//the following adds columns for time. You can also add milliseconds. See the Time/Date functions for Processing: https://www.processing.org/reference/

table.addColumn("year");

table.addColumn("month");

table.addColumn("day");

table.addColumn("hour");

table.addColumn("minute");

table.addColumn("second");

//the following are dummy columns for each data value. Add as many columns as you have data values. Customize the names as needed. Make sure they are in the same order as the order that Arduino is sending them!

table.addColumn("sensor1");

table.addColumn("sensor2");

}

void serialEvent(Serial myPort){

val = myPort.readStringUntil('\n'); //The newline separator separates each Arduino loop. We will parse the data by each newline separator.

if (val!= null) { //We have a reading! Record it.

val = trim(val); //gets rid of any whitespace or Unicode nonbreakable space

println(val); //Optional, useful for debugging. If you see this, you know data is being sent. Delete if you like.

float sensorVals[] = float(split(val, ',')); //parses the packet from Arduino and places the valeus into the sensorVals array. I am assuming floats. Change the data type to match the datatype coming from Arduino.

TableRow newRow = dataTable.addRow(); //add a row for this new reading

newRow.setInt("id", table.lastRowIndex());//record a unique identifier (the row's index)

//record time stamp

newRow.setInt("year", year());

newRow.setInt("month", month());

newRow.setInt("day", day());

newRow.setInt("hour", hour());

newRow.setInt("minute", minute());

newRow.setInt("second", second());

//record sensor information. Customize the names so they match your sensor column names.

newRow.setFloat("sensor1", sensorVals[0]);

newRow.setFloat("sensor2", sensorVals[1]);

readingCounter++; //optional, use if you'd like to write your file every numReadings reading cycles

//saves the table as a csv in the same folder as the sketch every numReadings.

if (readingCounter % numReadings ==0)//The % is a modulus, a math operator that signifies remainder after division. The if statement checks if readingCounter is a multiple of numReadings (the remainder of readingCounter/numReadings is 0)

{

fileName = str(year()) + str(month()) + str(day()) + str(dataTable.lastRowIndex()); //this filename is of the form year+month+day+readingCounter

saveTable(dataTable, fileName); //Woo! save it to your computer. It is ready for all your spreadsheet dreams.

}

void draw()

{

//visualize your sensor data in real time here! In the future we hope to add some cool and useful graphic displays that can be tuned to different ranges of values.

}

Additional Resources

All about Tables in Processing: https://www.processing.org/reference/Table.html
The Arduino Software Serial Library: http://arduino.cc/en/Reference/softwareSerial
Arduino data types (a must-read before you choose the data type for your data input): http://arduino.cc/en/Reference/HomePage

TUTORIALS

Using a motion sensor to turn on a light (and keep it on til everybody leaves)

November 12, 2014 Mariel Steiner Leave a comment

USING A MOTION SENSOR TO TURN ON A LIGHT (and keep it on)

The goal of this tutorial is to use a PIR sensor to detect movement in a plaza, then turn on a secondary system (in this case, just an LED light). The key thing here is not to detect every single movement, but to turn on the light and keep it on until the PIR detects no movement for a certain period of time, at which point the light should turn off.

The parts you’ll need for this tutorial are:

Parts:

PIR motion sensor
Arduino UNO
3 pin stacking header
Jumper wires + resistors
LED light

Here’s how to set up your breadboard (and resultant circuit):

The PIR sensor has 3 pins, which should be labeled. On our PIR, the pins read
“VCC,” “OUT,” “GND” from left to right on the botton of the plate.

Connect the PIR into the breadboard so that (–) pin connects to the Gnd row,
(+) pin connects to 5V, and Out pin connects to digital pin 2.

To test the sensor, plug the (+) pin of a red LED into pin 13 and connect the (-)
pin to GND

Now to put in the code. Again, the important thing here is that we don’t just want the PIR sensor to measure motion, we want it to reflect when a space is active and keep the LED on for as long as there is activity in the space. So, we have to set a minimum period of time after for the PIR to take measurements finding no motion, and then to turn off. In the code, this period is 10 seconds, but you can change it if a longer or shorter amount of time seems more appropriate to you.

/*

USING A MOTION SENSOR TO TURN ON A LIGHT (and keep it on)

Hardware connections:

PIR Sensor

The PIR sensor has 3 pins, which should be labeled. On our PIR, the pins read
"VCC," "OUT," "GND" from left to right on the botton of the plate.

Connect the PIR into the breadboard so that (–) pin connects to the Gnd row,
(+) pin connects to 5V, and Out pin connects to digital pin 2.

To test the sensor, plug the (+) pin of a red LED into pin 13 and connect the (-)
pin to GND

This tutorial was written with the help of Kristian Gohlke from http://playground.arduino.cc/Code/PIRsense
and John Edgar Park from http://makezine.com/projects/PIR-Sensor-Arduino-Alarm/ and https://learn.adafruit.com/pir-passive-infrared-proximity-motion-sensor/using-a-pir
*/

//VARIABLES

//the time we give the sensor to calibrate (10-60 secs according to the datasheet; we'll give it a minute to be safe)
int calibrationTime = 60000;

//the time when the sensor outputs a "low" signal
long unsigned int lowIn;

//the number of milliseconds the sensor has to be low before we assume all motion has stopped and to turn off the LED
long unsigned int pause = 10000;

boolean lockLow = true;
boolean takeLowTime;

int pirPin = 2;    //the digital pin connected to the PIR sensor's output
int ledPin = 13;   //the pin the LED is plugged into for testing

//SETUP

void setup(){
Serial.begin(9600);
pinMode(pirPin, INPUT);
pinMode(ledPin, OUTPUT);
digitalWrite(pirPin, LOW);

//give the sensor time to calibrate
Serial.print("calibrating sensor ");
for(int i = 0; i  pause){   //if the PIR pin does not detect motion for longer than the pause time
lockLow = true;
digitalWrite(ledPin, LOW);      //turn off the LED
Serial.print("motion ended at "); //and record when motion ended
Serial.print((millis() - pause)/1000);
Serial.println(" sec");
delay(50);
}
}

USING A MOTION SENSOR TO TURN ON A LIGHT (and keep it on)

Hardware connections:

PIR Sensor

The PIR sensor has 3 pins, which should be labeled. On our PIR, the pins read

"VCC," "OUT," "GND" from left to right on the botton of the plate.

Connect the PIR into the breadboard so that (–) pin connects to the Gnd row,

(+) pin connects to 5V, and Out pin connects to digital pin 2.

To test the sensor, plug the (+) pin of a red LED into pin 13 and connect the (-)

pin to GND

This tutorial was written with the help of Kristian Gohlke from http://playground.arduino.cc/Code/PIRsense

and John Edgar Park from http://makezine.com/projects/PIR-Sensor-Arduino-Alarm/ and https://learn.adafruit.com/pir-passive-infrared-proximity-motion-sensor/using-a-pir

//VARIABLES

//the time we give the sensor to calibrate (10-60 secs according to the datasheet; we'll give it a minute to be safe)

int calibrationTime = 60000;

//the time when the sensor outputs a "low" signal

long unsigned int lowIn;

//the number of milliseconds the sensor has to be low before we assume all motion has stopped and to turn off the LED

long unsigned int pause = 10000;

boolean lockLow = true;

boolean takeLowTime;

int pirPin = 2; //the digital pin connected to the PIR sensor's output

int ledPin = 13; //the pin the LED is plugged into for testing

//SETUP

void setup(){

Serial.begin(9600);

pinMode(pirPin, INPUT);

pinMode(ledPin, OUTPUT);

digitalWrite(pirPin, LOW);

//give the sensor time to calibrate

Serial.print("calibrating sensor ");

for(int i = 0; i pause){ //if the PIR pin does not detect motion for longer than the pause time

lockLow = true;

digitalWrite(ledPin, LOW); //turn off the LED

Serial.print("motion ended at "); //and record when motion ended

Serial.print((millis() - pause)/1000);

Serial.println(" sec");

delay(50);

}

TUTORIALS

Lighting multiple LEDs with sensors (force sensitive resistor or potentiometer)

November 12, 2014 Mustafa Ahmad 1 Comment

This tutorial shows how to light multiple LED’s one at a time through the use of either a force sensitive resistor or a potentiometer. Since both components deal with the increase or decrease of resistance through the circuit varying the voltage (which in our case is between 0 and 5v), both can be utilized with the same code.

First and foremost you’re going to need a few parts.

PARTS REQUIRED

1. Arduino Kit

2. Force Sensitive Reisistor (FSR)

3. Potentiometer

4. 3 – 330 Ohm Resistors

5. 1 – 10 Ohm Resistor

6. Jumper Wires

7. 3 LED’s

8. Breadboard

LIGHTING WITH FORCE SENSITIVE RESISTORS

Now that we have our parts, we’re going to start putting them together. Let’s start with the force sensitive resistor.

Connect your force sensitive resistor to the breadboard. From there, place a 10 Ohm resistor as shown in the diagram and connect that to ground by inserting one end of the resistor on the breadboard in the same column as the black wire. On the same row as the resistor insert a jumper wire and connect the other end of the jumper wire to the A0 pin on your arduino board. The ‘A0’ pin is your analogue pin that allows the sensor to communicate with your Arduino chip. Insert a second jumper wire from the sensor to the column of pins on the bread board that connects to the 5v power supply of your arduino kit (red wire).

Now let’s start connecting our LED’s

Place an LED on the bread board. Once that is done place a 330 Ohm resistor from the negative end of the LED (shorter leg) to ground and a jumper wire from the positive end of the LED (longer leg) to digital pin 9. We’re using the digital pin because our LED’s are going to operate through information provided from the sensor to the arduino kit digitally.

Let’s do that for a number of LED;s.

So far so good! Now let’s put a code in there and try to light them up.

ARDUINO CODE

Let’s open up the arduino interface and start writing some code. Make sure your arduino is disconnected while coding so nothing burns out or short circuits.

//The following code was written with the reference of the online links mentioned below.

//https://learn.adafruit.com/force-sensitive-resistor-fsr/using-an-fsr

//http://www.instructables.com/id/Force-sensitive-resistor-activated-led/

// Lets "declare" variables so that the computer knows
//about them when executing the code. We'll also need them so
//we can refer to them later.

//Variable names are case sensitive so type each name correctly
//whenever you refer to it.

int sensorPin = 0;    // force sensitive resistor connected to analog pin 0
int ledPin1 = 9;    //LED pin connected to digital pin 9
int ledPin2 = 10;    //LED pin connected to digital pin 10
int ledPin3 = 11;    //LED pin connected to digital pin 11
int sensorValue = 0;  

void setup() // This funtion runs once the sketch starts up.
// We'll be using pin 9, 10 and 11 to light the LED so it's important
//to refer to it as an output. We've named it ledPin.
{
  Serial.begin(9600); // starting up your serial monitor to view varying values
  pinMode(ledPin1, OUTPUT);
  pinMode(ledPin2, OUTPUT);
  pinMode(ledPin3, OUTPUT);
}

void loop()  // This funtion runs repeatedly after setup()is completed
{
  sensorValue = analogRead(sensorPin); //reading the values from the analog pin of the sensor
  // and throwing it out as a value
  Serial.print("Force value = ");  //Display value "Force value"
  Serial.println(sensorValue);
  
  if(sensorValue &gt; 0 &amp;&amp; sensorValue &lt;= 500) // an "if" statement giving a condition   //for the values that will allow you to switch between LED's.    {     digitalWrite(ledPin1, HIGH); // this is to say if the above statement is     // the LED shoud light up   }   else digitalWrite(ledPin1, LOW); // this is to say that if the above statement   //is not true the LED should turn or remain off.      if(sensorValue &gt; 500 &amp;&amp; sensorValue &lt;= 800)   {   digitalWrite(ledPin2, HIGH);   }   else digitalWrite(ledPin2, LOW);      if(sensorValue &gt; 800)
  {
    digitalWrite(ledPin3, HIGH);
  }
  else digitalWrite(ledPin3, LOW);
}

//The following code was written with the reference of the online links mentioned below.

//https://learn.adafruit.com/force-sensitive-resistor-fsr/using-an-fsr

//http://www.instructables.com/id/Force-sensitive-resistor-activated-led/

// Lets "declare" variables so that the computer knows

//about them when executing the code. We'll also need them so

//we can refer to them later.

//Variable names are case sensitive so type each name correctly

//whenever you refer to it.

int sensorPin = 0; // force sensitive resistor connected to analog pin 0

int ledPin1 = 9; //LED pin connected to digital pin 9

int ledPin2 = 10; //LED pin connected to digital pin 10

int ledPin3 = 11; //LED pin connected to digital pin 11

int sensorValue = 0;

void setup() // This funtion runs once the sketch starts up.

// We'll be using pin 9, 10 and 11 to light the LED so it's important

//to refer to it as an output. We've named it ledPin.

{

Serial.begin(9600); // starting up your serial monitor to view varying values

pinMode(ledPin1, OUTPUT);

pinMode(ledPin2, OUTPUT);

pinMode(ledPin3, OUTPUT);

}

void loop() // This funtion runs repeatedly after setup()is completed

{

sensorValue = analogRead(sensorPin); //reading the values from the analog pin of the sensor

// and throwing it out as a value

Serial.print("Force value = "); //Display value "Force value"

Serial.println(sensorValue);

if(sensorValue > 0 && sensorValue <= 500) // an "if" statement giving a condition //for the values that will allow you to switch between LED's. { digitalWrite(ledPin1, HIGH); // this is to say if the above statement is // the LED shoud light up } else digitalWrite(ledPin1, LOW); // this is to say that if the above statement //is not true the LED should turn or remain off. if(sensorValue > 500 && sensorValue <= 800) { digitalWrite(ledPin2, HIGH); } else digitalWrite(ledPin2, LOW); if(sensorValue > 800)

{

digitalWrite(ledPin3, HIGH);

}

else digitalWrite(ledPin3, LOW);

}

Once you’ve written the code connect your arduino port to the computer and click on the ‘upload’ icon (which is shaped like an arrow) at the top left corner of your interface (right below the edit menu).

If you run the code before connecting the arduino to your computer you might run into a serial port error.

If you have gotten everything running smoothly, press on the force sensitive resistor with different pressures and watch the LED’s change.

LIGHTING WITH A POTENTIOMETER

Now let’s see how we can light up the LED’s using a potentiometer. The thing to note here is that since the code works the same we can repeat all the steps above but replace the force sensitive resistor with the potentiometer.

The circuitry:

Insert the potentiometer on to the breadboard and connect jumper wires from the breadboard to the arduino board as shown in the diagram above. The middle jumper wire should be connected to the analog 0 pin as this is going to help determine the varying resistance values that will switch between LED’s. Once the potentiometer is plugged in and you have run the code through arduino, rotate the dial on the potentiometer and watch the LED’s change.

You can potentially develop some very interesting projects with the use of LED’s and sensors especially in an urban context when there is a lot of activity and the circuit is constantly being activated.

TUTORIALS

Pollution / Wind Sensing + RGB Pixel Strand

November 12, 2014 Kyle O'Konis Leave a comment

Introduction
Pollution has an extremely harmful presence in urban areas, a presence that is almost completely invisible to the human eye. This project attempts to make the invisible visible. This tutorial is one piece of a project that senses both wind and pollution and produces in output to a subtle light demonstration of these levels. In this tutorial, I will show how to connect an RGB pixel strand to an Arduino Uno and will provide the code and code instructions for how to receive an input from a sensor and create movement in the light strand.

Parts List
– Arduino Uno
– Adafruit 12mm Digital RGB LED Pixels (Strand of 25 ) WS2801
– 5V power source (computer USB or 5V battery)

Additional Libraries Needed
CLICK HERE to download the Adafruit WS2801 library needed for this project.

Wiring
Before beginning to wire the lights to the Arduino, please make sure you follow the diagram below and that you are plugging the right end of the light strand to the Arduino.

Notice that the pixel strand has four colored wires: red, yellow, green, and blue. First connect the blue wire to the ground (GND). Then connect the yellow wire to the Digital 2 pin and the green wire to the Digital 3 pin. Finally, connect the red wire to the 5V regulated power supply. See diagram below.

Circuit Diagram

Code

#include "Adafruit_WS2801.h"

// Choose which 2 pins you will use for output.
// Can be any valid output pins.
uint8_t dataPin  = 2;    // Yellow wire on Adafruit Pixels
uint8_t clockPin = 3;    // Green wire on Adafruit Pixels

// Don't forget to connect the ground wire to Arduino ground,
// and the +5V wire to a +5V supply

// Set the first variable to the NUMBER of pixels. 25 = 25 pixels in a row
Adafruit_WS2801 strip = Adafruit_WS2801(25, dataPin, clockPin);

void setup() {
  strip.begin();

  // Update LED contents, to start they are all 'off'
  strip.show();
}

void loop()
{

// oldVal  = the current Sensor light value
// newVal = the new sensor light value that we are updating the lights to reflect
// c is a RGB value translated to a 24bit interval - see Helper at the bottom of code
// wait is a delay in milli seconds
}

void updateLightHeight(uint8_t oldVal, uint8_t newVal, uint32_t c, uint8_t wait)

{ 
    int i; 
    int counter;
  // This if statement updates the light's values by turning off LED lights from the strip
  // The number of lights it turns off is the difference between the two sensor values.
  
  if (oldVal &gt; newVal)
  {
     counter = oldVal - newVal;
     for (i=0; i&lt;counter; i++)  // This turns off the lights from the top
                                // Turns off the lights as many times as the difference between the two values.
     {
       strip.setPixelColor(oldVal,0);
       strip.show();
       oldVal--;
     }
  }
  
  
  // This updates the light's values by turning on LED lights from the strip 
  // The number of lights it turns on is the difference between the two sensor values.
  
  else if (oldVal &lt; newVal)
  {
     counter = newVal-oldVal;
     for (i=0; i&lt;counter; i++)  // This turns on the lights from the top
                                // Turns on the lights as many times as the difference between the two values.
     {
       strip.setPixelColor(oldVal,c);
       strip.show();
       oldVal++;
     }
  }
  
   else if (oldVal == newVal) // If the values are equal, show the same lights as previous
  {
     strip.show();
  }
  
  delay(wait);
}


//These functions below are helpful for changing the colors based off of more sensing data. 
//This is beyond the scope of this tutorial for now, but this tutorial will hopefully be updated in the future to include this ability

/* Helper functions */
// Create a 24 bit color value from R,G,B
uint32_t Color(byte r, byte g, byte b)
{
  uint32_t c;
  c = r;
  c &lt;&lt;= 8;
  c |= g;
  c &lt;&lt;= 8;
  c |= b;
  return c;
}

//Input a value 0 to 255 to get a color value.
//The colours are a transition r - g -b - back to r
uint32_t Wheel(byte WheelPos)
{
  if (WheelPos &lt; 85) {
   return Color(WheelPos * 3, 255 - WheelPos * 3, 0);
  } else if (WheelPos &lt; 170) {
   WheelPos -= 85;
   return Color(255 - WheelPos * 3, 0, WheelPos * 3);
  } else {
   WheelPos -= 170; 
   return Color(0, WheelPos * 3, 255 - WheelPos * 3);
  }
}

100

101

102

103

104

#include "Adafruit_WS2801.h"

// Choose which 2 pins you will use for output.

// Can be any valid output pins.

uint8_t dataPin = 2; // Yellow wire on Adafruit Pixels

uint8_t clockPin = 3; // Green wire on Adafruit Pixels

// Don't forget to connect the ground wire to Arduino ground,

// and the +5V wire to a +5V supply

// Set the first variable to the NUMBER of pixels. 25 = 25 pixels in a row

Adafruit_WS2801 strip = Adafruit_WS2801(25, dataPin, clockPin);

void setup() {

strip.begin();

// Update LED contents, to start they are all 'off'

strip.show();

}

void loop()

{

// oldVal = the current Sensor light value

// newVal = the new sensor light value that we are updating the lights to reflect

// c is a RGB value translated to a 24bit interval - see Helper at the bottom of code

// wait is a delay in milli seconds

}

void updateLightHeight(uint8_t oldVal, uint8_t newVal, uint32_t c, uint8_t wait)

{

int i;

int counter;

// This if statement updates the light's values by turning off LED lights from the strip

// The number of lights it turns off is the difference between the two sensor values.

if (oldVal > newVal)

{

counter = oldVal - newVal;

for (i=0; i<counter; i++) // This turns off the lights from the top

// Turns off the lights as many times as the difference between the two values.

{

strip.setPixelColor(oldVal,0);

strip.show();

oldVal--;

}

// This updates the light's values by turning on LED lights from the strip

// The number of lights it turns on is the difference between the two sensor values.

else if (oldVal < newVal)

{

counter = newVal-oldVal;

for (i=0; i<counter; i++) // This turns on the lights from the top

// Turns on the lights as many times as the difference between the two values.

{

strip.setPixelColor(oldVal,c);

strip.show();

oldVal++;

}

else if (oldVal == newVal) // If the values are equal, show the same lights as previous

{

strip.show();

}

delay(wait);

}

//These functions below are helpful for changing the colors based off of more sensing data.

//This is beyond the scope of this tutorial for now, but this tutorial will hopefully be updated in the future to include this ability

/* Helper functions */

// Create a 24 bit color value from R,G,B

uint32_t Color(byte r, byte g, byte b)

{

uint32_t c;

c = r;

c <<= 8;

c |= g;

c <<= 8;

c |= b;

return c;

}

//Input a value 0 to 255 to get a color value.

//The colours are a transition r - g -b - back to r

uint32_t Wheel(byte WheelPos)

{

if (WheelPos < 85) {

return Color(WheelPos * 3, 255 - WheelPos * 3, 0);

} else if (WheelPos < 170) {

WheelPos -= 85;

return Color(255 - WheelPos * 3, 0, WheelPos * 3);

} else {

WheelPos -= 170;

return Color(0, WheelPos * 3, 255 - WheelPos * 3);

}

TUTORIALS

Direct communication between Arduino board and Processing

November 11, 2014 Namju Lee 1 Comment

This tutorial describes the process of direct communication between Arduino and Processing. I wish to learn this process, in order to overcome possible serial port problems between Arduino and Processing during serial communication. Moreover, direct control of Arduino board through Processing, results in a more clear and straight forward process. When considering the Arduino library in Processing allow us to get the data from the board automatically with no concerning about pins and its certain data array. This process is enabled by a special library called “StandardFirmata”, that allows data to be transferred automatically from Arduino to Processing by simplifying significantly the initialization of pins and data arrays. First of all, upload the library called “StandardFirmata”, which is located in the examples file of the Arduino sketch window. Since the library is uploaded correctly, the further steps of the process do not involve the Arduino window. The next step would be to create an example sketch in Processing in order to demonstrate the process. Open a Processing sketch and follow the code with the embedded comments below. Tutorial: Step A: Blink an LED with digitalWrite function

/////////////////////////////////////////////////////////
// Hackerscapes Fall 2014 LD Arch 254 
// Communication between Arduino board and Processing directly
// Arduino Uno and Processing 2.2.1 
//
// NJ Namju Lee,  
// 2014.11
/////////////////////////////////////////////////////////
// Tutorial Step A , blink LED with digitalWrite fuction
/////////////////////////////////////////////////////////
// USAGE
// clikc the processing sketch to blink a LED
/////////////////////////////////////////////////////////

// import libraries to use functions for serial and arduino communication
import processing.serial.*;
import cc.arduino.*;

// declare a variable for Arduino library  
Arduino arduino;

// setup like the setup in Arduino programming
void setup() {
  // define the size of sktech where we can do interaction processing with Arduino
  size(470, 200);
  frameRate(10);
  //print a list of the available serial devices. If your Arduino board is connected 
  //to the computer when you call this function, its device will be in the list.
  println(Arduino.list()); 
  
  // assign Arduino class based on the serial into the variable that we made
  arduino = new Arduino(this, Arduino.list()[0], 57600);
}

// draw is the same as the loop in Arduino programming
void draw() {
  
  background(0,0,0);

}

// As a function in Arduino programming, 
// we can built our own functions including diverse mouse events in processing.
// executing the fuction below when mouse is pressed
void mousePressed()
{
  // call the fuction about digitalWrite for the pin 10 in order to turn on the LED
  arduino.digitalWrite(7, Arduino.HIGH);
  background(255);
}

// executing the fuction below when mouse is released
void mouseReleased()
{
  // call the fuction about digitalWrite for the pin 10 in order to turn off the LED
  arduino.digitalWrite(7, Arduino.LOW);
}

/////////////////////////////////////////////////////////

// Hackerscapes Fall 2014 LD Arch 254

// Communication between Arduino board and Processing directly

// Arduino Uno and Processing 2.2.1

// NJ Namju Lee,

// 2014.11

/////////////////////////////////////////////////////////

// Tutorial Step A , blink LED with digitalWrite fuction

/////////////////////////////////////////////////////////

// USAGE

// clikc the processing sketch to blink a LED

/////////////////////////////////////////////////////////

// import libraries to use functions for serial and arduino communication

import processing.serial.*;

import cc.arduino.*;

// declare a variable for Arduino library

Arduino arduino;

// setup like the setup in Arduino programming

void setup() {

// define the size of sktech where we can do interaction processing with Arduino

size(470, 200);

frameRate(10);

//print a list of the available serial devices. If your Arduino board is connected

//to the computer when you call this function, its device will be in the list.

println(Arduino.list());

// assign Arduino class based on the serial into the variable that we made

arduino = new Arduino(this, Arduino.list()[0], 57600);

}

// draw is the same as the loop in Arduino programming

void draw() {

background(0,0,0);

}

// As a function in Arduino programming,

// we can built our own functions including diverse mouse events in processing.

// executing the fuction below when mouse is pressed

void mousePressed()

{

// call the fuction about digitalWrite for the pin 10 in order to turn on the LED

arduino.digitalWrite(7, Arduino.HIGH);

background(255);

}

// executing the fuction below when mouse is released

void mouseReleased()

{

// call the fuction about digitalWrite for the pin 10 in order to turn off the LED

arduino.digitalWrite(7, Arduino.LOW);

}

Click on the Processing sketch to blink an LED Click on the Processing sketch to blink an LED Tutorial: Step B: Changing LED brightness with analogWrite function based on mouse position

/////////////////////////////////////////////////////////
// Hackerscapes Fall 2014 LD Arch 254 
// Communication between Arduino board and Processing directly
// Arduino Uno and Processing 2.2.1 
//
// NJ Namju Lee,  
// 2014.11
/////////////////////////////////////////////////////////
// Tutorial Step B , Changing LED brightness with analogWrite fuction based on mouse position
/////////////////////////////////////////////////////////
// USAGE
// moving mouse on the processing sketch to change LED brightness
/////////////////////////////////////////////////////////

// import libraries to use functions for serial and arduino communication
import processing.serial.*;
import cc.arduino.*;

// declare a variable for Arduino library  
Arduino arduino;

int value; 
int count = 1;
// setup like the setup in Arduino programming
void setup() {
  // define the size of sktech where we can do interaction processing with Arduino
  size(255*2, 200);
  frameRate(60); 
  //print a list of the available serial devices. If your Arduino board is connected 
  //to the computer when you call this function, its device will be in the list.
  println(Arduino.list()); 
  
  // assign Arduino class based on the serial into the variable that we made
  arduino = new Arduino(this, Arduino.list()[0], 57600);
   gradientBG();
}

// draw is the same as the loop in Arduino programming
void draw() {
  // 60 frame in a second, based on the mouse's X position, the LED light's brightness can be interacted
  arduino.analogWrite(6, value);
  //arduino.digitalWrite(7, Arduino.HIGH);
}

void mouseMoved()
{
   // when mouse is moved, the value is redefined by mouse's X position.
   // the reason divide the value by 2 is that the sketch is double size of 255 which is maximum value of LED, 
   // in order to match the size of processing's sketch with the light range of LED.
   value = mouseX/2;
}

// This function draw gradient background from black to white color in the sketch of processing
// The background color indicate the Arduino LED intensity as a gradient color value
void gradientBG(){
  for (int i = 0; i &lt; width; i += 2){
   strokeWeight(2);
   stroke(i/2);
   line(i,0, i,height);   
  }
}

/////////////////////////////////////////////////////////

// Hackerscapes Fall 2014 LD Arch 254

// Communication between Arduino board and Processing directly

// Arduino Uno and Processing 2.2.1

// NJ Namju Lee,

// 2014.11

/////////////////////////////////////////////////////////

// Tutorial Step B , Changing LED brightness with analogWrite fuction based on mouse position

/////////////////////////////////////////////////////////

// USAGE

// moving mouse on the processing sketch to change LED brightness

/////////////////////////////////////////////////////////

// import libraries to use functions for serial and arduino communication

import processing.serial.*;

import cc.arduino.*;

// declare a variable for Arduino library

Arduino arduino;

int value;

int count = 1;

// setup like the setup in Arduino programming

void setup() {

// define the size of sktech where we can do interaction processing with Arduino

size(255*2, 200);

frameRate(60);

//print a list of the available serial devices. If your Arduino board is connected

//to the computer when you call this function, its device will be in the list.

println(Arduino.list());

// assign Arduino class based on the serial into the variable that we made

arduino = new Arduino(this, Arduino.list()[0], 57600);

gradientBG();

}

// draw is the same as the loop in Arduino programming

void draw() {

// 60 frame in a second, based on the mouse's X position, the LED light's brightness can be interacted

arduino.analogWrite(6, value);

//arduino.digitalWrite(7, Arduino.HIGH);

}

void mouseMoved()

{

// when mouse is moved, the value is redefined by mouse's X position.

// the reason divide the value by 2 is that the sketch is double size of 255 which is maximum value of LED,

// in order to match the size of processing's sketch with the light range of LED.

value = mouseX/2;

}

// This function draw gradient background from black to white color in the sketch of processing

// The background color indicate the Arduino LED intensity as a gradient color value

void gradientBG(){

for (int i = 0; i < width; i += 2){

strokeWeight(2);

stroke(i/2);

line(i,0, i,height);

}

Changing LED brightness with analogWrite fuction based on mouse position, the left of the sketch of Processing, value = 10 Changing LED brightness with analogWrite function based on mouse position, Processing window middle position, value = 180 Changing LED brightness with analogWrite function based on mouse position, Prossesing window right side, value = 255 Tutorial: Step C: Changing RGB LED brightness with analogWrite function based on mouse position

/////////////////////////////////////////////////////////
// Hackerscapes Fall 2014 LD Arch 254 
// Communication between Arduino board and Processing directly
// Arduino Uno and Processing 2.2.1 
//
// NJ Namju Lee,  
// 2014.11
/////////////////////////////////////////////////////////
// Tutorial Step C , Changing RGB LED brightness with analogWrite fuction based on mouse position
/////////////////////////////////////////////////////////
// USAGE
// Click and drag the handles of red, green, and blue in order to change RGB LED brightness and combination
///////////////////////////////////////////////////////////////
// reference, Handles example in Processing

// import libraries to use functions for serial and arduino communication
import processing.serial.*;
import cc.arduino.*;

// declare a variable for Arduino library, and an array for Handele class  
Arduino arduino;
Handle[] handles;

// declare a variable for red, green, blue in order to send them to Arduino board  
int r;
int g;
int b;

void setup() {
  size(520, 130);
  
  //print a list of the available serial devices. If your Arduino board is connected 
  //to the computer when you call this function, its device will be in the list.
  println(Arduino.list()); 
  
  // assign Arduino class based on the serial into the variable that we made
  arduino = new Arduino(this, Arduino.list()[0], 57600);

  // assign handle class into three handles in array  
  int num = height/3;
  handles = new Handle[num];
  int hsize = 10;
  for (int i = 0; i &lt; 3; i++) {
    handles[i] = new Handle(width/12, 10+i*50, 50-hsize/9, 10, handles);
  }
}

void draw() {
  background(255);
  
  // Based on mouse event, the handles class changes its handles sketch to show animation
  // and the class return its value, and save the value of r, g , b 
  r = handles[0].update();
  handles[0].display();
  g = handles[1].update();
  handles[1].display();
  b = handles[2].update();
  handles[2].display();

  //The r,g,b value apply the analogWrite function as an intensity level
  arduino.analogWrite(9, r);
  arduino.analogWrite(10, g);
  arduino.analogWrite(11, b);

}

// As a mouse event, when mouse is released, it executes the releaseEvent in the class.
void mouseReleased()  {
  for (int i = 0; i &lt; 3; i++) {
    handles[i].releaseEvent();
  }
}

/////////////////////////////////////////////////////////

// Hackerscapes Fall 2014 LD Arch 254

// Communication between Arduino board and Processing directly

// Arduino Uno and Processing 2.2.1

// NJ Namju Lee,

// 2014.11

/////////////////////////////////////////////////////////

// Tutorial Step C , Changing RGB LED brightness with analogWrite fuction based on mouse position

/////////////////////////////////////////////////////////

// USAGE

// Click and drag the handles of red, green, and blue in order to change RGB LED brightness and combination

///////////////////////////////////////////////////////////////

// reference, Handles example in Processing

// import libraries to use functions for serial and arduino communication

import processing.serial.*;

import cc.arduino.*;

// declare a variable for Arduino library, and an array for Handele class

Arduino arduino;

Handle[] handles;

// declare a variable for red, green, blue in order to send them to Arduino board

int r;

int g;

int b;

void setup() {

size(520, 130);

//print a list of the available serial devices. If your Arduino board is connected

//to the computer when you call this function, its device will be in the list.

println(Arduino.list());

// assign Arduino class based on the serial into the variable that we made

arduino = new Arduino(this, Arduino.list()[0], 57600);

// assign handle class into three handles in array

int num = height/3;

handles = new Handle[num];

int hsize = 10;

for (int i = 0; i < 3; i++) {

handles[i] = new Handle(width/12, 10+i*50, 50-hsize/9, 10, handles);

}

void draw() {

background(255);

// Based on mouse event, the handles class changes its handles sketch to show animation

// and the class return its value, and save the value of r, g , b

r = handles[0].update();

handles[0].display();

g = handles[1].update();

handles[1].display();

b = handles[2].update();

handles[2].display();

//The r,g,b value apply the analogWrite function as an intensity level

arduino.analogWrite(9, r);

arduino.analogWrite(10, g);

arduino.analogWrite(11, b);

}

// As a mouse event, when mouse is released, it executes the releaseEvent in the class.

void mouseReleased() {

for (int i = 0; i < 3; i++) {

handles[i].releaseEvent();

}

Changing RGB LED brightness with analogWrite function based on handle, value = red Changing RGB LED brightness with analogWrite function based on handle, value = green Changing RGB LED brightness with analogWrite function based on handle, value = blue Changing RGB LED brightness with analogWrite fuction based on handle, value R G B combination Tutorial: Step D: Analogue Read (Photo Resistor) from Arduino and data visualization in Processing

/////////////////////////////////////////////////////////
// Hackerscapes Fall 2014 LD Arch 254 
// Communication between Arduino board and Processing directly
// Arduino Uno and Processing 2.2.1 
//
// NJ Namju Lee,  
// 2014.11
/////////////////////////////////////////////////////////
// Tutorial Step D , Read analogue data from Arduino, visualize the data in processing
/////////////////////////////////////////////////////////

// import libraries to use functions for serial and arduino communication
import processing.serial.*;
import cc.arduino.*;

// declare a variable for Arduino library  
Arduino arduino;
int photo_resistor;

// setup like the setup in Arduino programming
void setup() {
  // define the size of sktech where we can do interaction processing with Arduino
  size(470, 200);
  frameRate(10);
  //print a list of the available serial devices. If your Arduino board is connected 
  //to the computer when you call this function, its device will be in the list.
  println(Arduino.list()); 
  
  // assign Arduino class based on the serial into the variable that we made
  arduino = new Arduino(this, Arduino.list()[0], 57600);
}

// draw is the same as the loop in Arduino programming
void draw() {
  
  // refresh the background color as the value from the Photo Resistor in Aurdino board.
  background(photo_resistor);
  
  // read the the analog pin of the number "0" from the board
  photo_resistor = arduino.analogRead(0);
  
  // remap the analogue data because the background color in processing need the integer data from 0 to 255
  photo_resistor = int(map(photo_resistor, 180, 580, 0, 255));
}

/////////////////////////////////////////////////////////

// Hackerscapes Fall 2014 LD Arch 254

// Communication between Arduino board and Processing directly

// Arduino Uno and Processing 2.2.1

// NJ Namju Lee,

// 2014.11

/////////////////////////////////////////////////////////

// Tutorial Step D , Read analogue data from Arduino, visualize the data in processing

/////////////////////////////////////////////////////////

// import libraries to use functions for serial and arduino communication

import processing.serial.*;

import cc.arduino.*;

// declare a variable for Arduino library

Arduino arduino;

int photo_resistor;

// setup like the setup in Arduino programming

void setup() {

// define the size of sktech where we can do interaction processing with Arduino

size(470, 200);

frameRate(10);

//print a list of the available serial devices. If your Arduino board is connected

//to the computer when you call this function, its device will be in the list.

println(Arduino.list());

// assign Arduino class based on the serial into the variable that we made

arduino = new Arduino(this, Arduino.list()[0], 57600);

}

// draw is the same as the loop in Arduino programming

void draw() {

// refresh the background color as the value from the Photo Resistor in Aurdino board.

background(photo_resistor);

// read the the analog pin of the number "0" from the board

photo_resistor = arduino.analogRead(0);

// remap the analogue data because the background color in processing need the integer data from 0 to 255

photo_resistor = int(map(photo_resistor, 180, 580, 0, 255));

}

Background color is affected by the Photo Resistor input from the Arduino board and is around the value of 50 (0, 255) in this example. Background color is affected by the Photo Resistor input from the Arduino board and is around the value of 50 (0, 255) in this example. Background color is affected by the Photo Resistor input from the Arduino board and is around the value of 50 (0, 255) in this example Documentation of cc.arduino library (link http://playground.arduino.cc/Interfacing/Processing) Arduino.list(): returns a list of the available serial devices. If your Arduino board is connected to the computer when you call this function, its device will be in the list.
Arduino(parent, name, rate): create an Arduino object. Parent should be “this” (without the quotes); name is the name of the serial device (i.e. one of the names returned by Arduino.list()); rate is the speed of the connection (typically 57600). Note that in the v2 library, the rate parameter is optional.
pinMode(pin, mode): set a digital pin to input, output, or servo mode (Arduino.INPUT, Arduino.OUTPUT, or Arduino.SERVO). digitalRead(pin): returns the value of a digital pin, either Arduino.LOW or Arduino.HIGH (the pin must be set as an input). digitalWrite(pin, value): writes Arduino.LOW or Arduino.HIGH to a digital pin.
analogRead(pin): returns the value of an analog input (from 0 to 1023).
analogWrite(pin, value): writes an analog value (PWM wave) to a digital pin that supports it (pins 3, 5, 6, 9, 10, and 11); value should be from 0 (always off) to 255 (always on).
servoWrite(pin, value): writes a value to a servo motor; value should be from 0 to 180.

Reference
http://playground.arduino.cc/Interfacing/Processing https://processing.org

TUTORIALS

Programming an AT tiny84 micro-controler through an Arduino Uno board

November 11, 2014 Eleanna Panagoulia Leave a comment

This tutorial describes the process of programming an ATtiny84 micro -controller through an Arduino board. The ATtiny84 is a high performance, small size processor that can be programmed and used instead of an Arduino board. This processor is similar to the original Arduino processor that is embedded on the Arduino Uno board. The use of a series of ATtinies 45/85 or 44/84 allows multiple connection of sensors or LEDs that exceed substantially the number of Pins that the Arduino Uno board provides. This means that instead of using multiple Arduinos to connect multiple sensors or output devices, we can use multiple ATtinies in order to save space, as well as money. In order to program a series of ATtinies and control the data flow from the Arduino board to them and vice versa, you will need to program each micro-controler individually through the breadboard and store the program to each. In the meantime, you will need to build a circuitry diagram called “bus diagram”, in order to understand the data flow between the Arduino and the multiple ATtinies. The structure of the “bus diagram” is relatively simple. It is a tree hierarchy diagram of Master and Slaves, which means that it does not include network connections between the controllers. The Arduino board is defined as the “Master” controller of the system and the ATtinies as the “Slave” micro-controlers. This means that the Arduino is controlling the flow of data exclusively, by “calling” each ATtiny at a time. Hence, every ATtiny “talks” directly to the Arduino board individually through the Arduino pins.

These diagrams explain the hierarchy of data flow, as well a typical structure of a “bus diagram”.

The following steps will describe the process of programming one ATtiny84 micro-controler through the breadboard.

For this process you will be required:

1_ Arduino Uno board

2_ Breadboard

3_ ATtiny84

4_ Capacitor 10uF

5_ 1 LED

6_ 1 resistor 330KΩ

7_ Jumper wires

Step 1

Open a new Arduino IDE (Arduino sketch window). If you don’t have Arduino installed, you can download it from the following link: http://arduino.cc/en/Main/Software

Step 2

In order to program an ATtiny84 you should import the ATtiny boards. To do so, download the ATtiny master zip. by clicking here: attiny-master

Consult the “Read me” file for accessing the necessary instructions. Unzip the “attiny – master” folder and paste the “attiny” folder in the Arduino sketchbook folder. Inside the Arduino sketchbook folder, create a sub-folder under the name “hardware” and paste the “attiny” folder there. Your “attiny” folder should contain a text file named “boards” and a folder named “variants“.

Step 3

Reboot your Arduino IDE. If you go to the “Sketch” menu –> Boards drop down, you should be able to see the names of the new boards that you’ve just installed.

Step 4

After installing the ATtiny boards you can begin connecting the ATtiny with the Arduino board. You can connect the two through the breadboard.

Before we start listing the connections, we should go through and describe the pins of the ATtiny. There are two kinds of configurations that describe the ATtiny pins, Physical and Software. The Physical Pins and the Pin numbers in the Software are very different. For example, on an ATtiny84, Physical Pin 1 is for VCC while, in the Software, Digital Pin 1 is actually Physical Pin 12. Also, the Analog Pins can have different numbers than the digital pins at the same physical location. The following diagram gathers all the different configurations of the ATtiny84 pins.

ATtiny 84 Pin Diagram

Arduino and ATtiny44/84 Connections

Arduino and ATtiny45/85 Connections

Step 5

Before you start the wiring connections between the Arduino and the ATtiny84, you should first set the Arduino as an ISP programmer for the ATtiny. This operation allows the Arduino to program the ATtiny and pass the code to it. To set the Arduino as an ISP programmer you should launch the Arduino IDE and open the examples folder. Menu –> File –> Examples –> Arduino as ISP

Then assign the board that you are using. In our case it is the Arduino Uno board. To do that go to Menu –> Tools –> Board –> Arduino Uno

Make sure you have set the serial port correctly by going to Menu –> Tools –> Serial Port

Now your Arduino board operates as an ISP programmer.

Step 6

Complete the connections shown in the previous diagrams. In this tutorial we will go through the basic operation of blinking an LED light through the ATtiny board. For this simple operation you will require few more connections to be made. You will need an LED light, a resistor 330KΩ and a Capacitor 10uF. The capacitor is required in order to prevent the Arduino from resetting the bootloader, which we will go through later in this tutorial.

The following photo shows what the final connections should look like.

Step 7

Open the Blink sketch from the example folder. Menu –> File –> Examples –> Basic –> Blink. In this sketch you will need to change the pin from 13 to 7.

Now you should have 2 Arduino sketches open in your screen

Step 8

Now you will set the ATtiny as your new board by going to Menu –> Tools –> Boards –> ATtiny84 1MHz. You can also operate on the ATtiny84 8MHz

Step 9

In this step you will assign the Arduino as ISP as the programmer of the ATtiny. Go to Menu –> Tools –> Programmer –> Arduino as ISP

Step 10

In order to upload the Blink sketch to the ATtiny you should go to Menu –> File –> Upload using Programmer

Step 10

Burn Bootloader. This is not a mandatory step, however it is recommended. To burn the bootloader go to Menu –> Tools –> Burn Bootloader

Notice that the LED starts blinking. Now the blink sketch is stored in the ATtiny84.

Thank you!

FIELD TRIP

East Bay Mini Maker Faire

October 24, 2014 Allison Lassiter Leave a comment

Class sightings of Arduinos (+ similar) in the wild at the 2014 East Bay Mini Maker Faire. Most popular item to photograph = Rubick’s cube solver (sensed color + motorized response).

[Show slideshow]

Assignments

Project: Phase 1, How-To

October 19, 2014 Allison Lassiter Leave a comment

You are going to write a tutorial for this blog on how to do one, little piece of your project. By writing the tutorial, you’ll not only get to know that piece well, you’ll also give back to the Arduino community.

1. With the support of your group, choose one aspect of your project to focus on. Be specific. For example, it’s better to learn how to make a force-sensitive paver (a project need that one group discussed in class), than how to generally use a force sensor.

2. Figure out how to make the code and the circuitry work. Find existing tutorials and fiddle around. If you get stuck, turn to your group members.

The Arduino Playground has links to many, many tutorials. There are also many on Instructables — some are easier to understand than others. What makes for a good tutorial?

3. Write your own tutorial. It must include a parts list, a circuit diagram, code, and any other information you need to make the tutorial as clear as possible (e.g., images, or a brief video).

As you write, think of your fellow classmates: would they understand how to follow your tutorial? Read the Arduino Style Guide for tips on writing tutorials.

4. Post your tutorial on this blog.

Find the email with your user name and password (I sent it to you on 10/27 and should have the subject “[HACKERSCAPES] Your username and password”). You have permission to write and edit posts. You can also delete your unpublished posts. If you need to delete a published post, let me know. (FYI – You can’t view your classmate’s posts that are in draft, and they can’t see yours.)
Use the link in the email to log in.
Once you’re logged in, click the link on the left side bar for Posts and choose “Add New.”
Give your post a clear title.
Categorize your post by checking the Tutorials box on the right of the screen.

To include any images in your tutorial, use the “Add Media” button, located underneath the title of the post.
Make your code nice and readable. To to this, you have to wrap the code in an html tag for pre-formatted text, called a pre tag. First, choose the Text tab (see image below).

Once you’re on the Text editor side, copy and paste in your Arduino code into WordPress. On the line before the code starts write: <pre lang=”arduino”>. On the line after the code ends, write: </pre>. If you do this on the Visual editor side, the tags won’t work.
Before you publish your draft, you can Preview it to make sure everything looks right. This is a good chance to check that your pre tags are working as planned and look for typos.
When you’re ready, hit Publish.
Feel free to correct any little things after you publish. If you ever make any more significant updates, it’s good to add a note (like I did at the bottom of Lab 3).

Assignments

Project: Phase 1, Presentation

October 19, 2014 Allison Lassiter Leave a comment

You will present your project in class on November 7. Your presentation will be 10 minutes long, in addition to 5-10 minutes of questions/discussion. You can use whatever supporting materials you would like to use: PowerPoint, boards, the white board, etc.

In your presentation you should:

1. State the larger urban problem/challenge that your project responds to.

2. State why your project addresses this challenge.

3. Explain how your project works.

Present a concept diagram of your project. What are your inputs (sensed data)? What are your outputs (responses to the sensed data)?
Present a more detailed parts diagram of your project. What hardware will you need? If there are points in the diagram where you’re not decided on the hardware, create a list of choices. For all hardware, include costs.

4. Discuss any additional design or technical questions your team is wrestling with.

Assignments

Lab 6: Processing

October 10, 2014 Allison Lassiter Leave a comment

In this lab, you are going to work on Processing, then Arduino, and then Processing and Arduino together. Through the lab, you’ll expand your use of capacitive sensors, practice serial communication, and learn more about Processing’s capabilities.

Processing

1. Complete this short Processing Overview.

2. Poke through the tutorials on processing.org. Look for ones that interest you. (If you’re like me, this will probably make you think — “Oh! So this is how so-and-so made that graphic.”)

Arduino

3. If you didn’t finish the Tiny Piano exercise in class, download my code from bSpace under Resources > Lab 6 Code and look it over.

There’s a few choices I made in my code that may be different from your code. For example, I created the function detectCapSense. It’s not really necessary — I just wanted to keep loop() as clean as possible. Also, I chose to store the sensor values in an array. You could store them as integers. It’s just personal style.

I used this code as the starting point for arduino_capsense_controller.ino, which you’ll use in this lab.

4. I made you a game. The code is also available on bSpace under Resources > Lab 6 Code. Please download it, and then set up your Arduino for capacitive sensing, if it’s not already (the same setup you had in class).

5. Upload arduino_capsense_controller.ino onto your Arduino. Run it. Check your serial monitor to make sure that your capacitive sensors are working. When you’re done, close your serial monitor.

Processing + Arduino

6. Now connect Arduino to Processing. To make sure the connection is working correctly, use the exact same sketch that you used in Lab 4 when you printed “Hello World” with Arduino, and then accessed that “Hello World” with Processing. I called this sketch processing_readstring.pde on bSpace.

Run processing_readstring.pde. You should see the same numbers that you saw before on your Arduino serial monitor streaming across the Processing serial monitor.

In the image below you see 0,0. If I were touching one of the sensors, there would be a number in the right or left position. For example, 0,60.

If it’s not working, make sure that you are connected to the correct serial port (this will more than likely be the same one you used in Lab 4). My sketch uses portName = Serial.list()[1] because that is the appropriate port for my computer — update it to work with yours.

7. Now you know that your sensors are working and you are connected to Processing.

Keep your Arduino code going, but stop the previous Processing sketch. Now run processing_capsense_game.pde. Don’t forget to update the port number — look for portName = Serial.list()[1] .

Use your sensors to control the ball. So exciting!

8. Actually, this game is lame. Please make it better.

Add two more sensors, so you can move the ball up and left, in addition to down and right. (Note that you don’t need alligator clips — you can just touch the end of the wire directly or use a paper clip without plastic coating.)
Make 4 additional improvements to the Processing side of the game. You pick what they are.

To see how it’s possible to expand the Processing interface quite a bit, you might derive some inspiration from the example of making your own game of Pong available here. This is not exactly pretty, since it’s a replica of a 1970s arcade game, but even so, Pong is popular.

Here’s a fancier example of Pong in action:

In general, there are many, many Processing tutorials available online. There is also example code included with the Processing IDE under File > Examples. These examples are pretty fun. They’re also almost entirely self-contained, so you just need to open one, hit Run, and then watch it do its thing.

9. Please upload to bSpace:

A paragraph or two explaining what changes you made to the game. (4 points)
Your updated Arduino and Processing code. (8 points)
A video showing your revised game in action. (8 points)

Environmental Sensing and Responsive Design