Category Archives: TUTORIALS

How to Control a Servo’s Angle of Rotation in Relation to a Coordinate

November 12, 2014 Tessira Crawford 2 Comments

This tutorial explains how to control a Servo’s angle of rotation in relation to a coordinate that can be found in a typical grid of points. You will need a(n):

Arduino Uno
Breadboard
Servo (that can rotate 360 degrees)
6 Wires

Setting It Up

Before we begin to put the parts together, make sure your Arduino board is not connected to your computer!

First and foremost, the Servo needs to be connected to a proper source of power for it to work. Make sure to plug in a red wire from the 5V pin to the positive end of the breadboard and to ground it by plugging a black wire from the GND pin to the negative end of the breadboard.

Then, connect your Servo to your breadboard with 3 jumper wires: orange wire (signal) to F8 (breadboard), red wire (+5V) to positive end of breadboard, and brown wire (ground) to negative end of breadboard.

On the same row as the Servo’s orange wire, connect a yellow wire from J8 (breadboard) to pin 9 (Arduino board).

In the end, it should look like this:

Now, let’s make that Servo rotate!

Arduino Code

You will need to open up the Arduino interface before we can start writing some code. Remember, your Arduino board is not connected to the computer, so uploading anything is completely impossible. For your Arduino board’s safety, let’s keep it unplugged for now.

Firstly, you must include two different sets of libraries: (1) Servo.h and (2) math.h. These two libraries provide you with the ability to use your Servo and to use the inverse tangent function. Unfortunately, “pi” is not defined in either libraries, including “math.h”, so you must define it yourself.

// Insert two libraries: Servo.h (for your Servo to work) and math.h (for inverse tangent function).

#include 
#include 

// Name your servo.  I called mine: servo.

Servo servo;

// Since "pi" has not been defined in any of the available libraries, you must define it yourself.

const float pi = 3.14159265359;

// Set up some floats: (1) PersonX and PersonY (position of person in relation to a coordinate system), 
// (2) MotorX and MotorY (position of motor in relation to such coordinate system),
// (3) deltaX and deltaY (difference between the position of person in relationship to the position of the motor,
// and (4) angleRad and angleDeg (angle of motor to person in both radians and degrees).

float PersonX, PersonY;
float MotorX, MotorY;
float deltaX, deltaY;
float angleRad, angleDeg;

// In void setup(), make sure to set up a baudrate for your serial monitor 
// and to mention what pin your Servo is attached to.

void setup() {
  Serial.begin(9600);
  servo.attach(9);
}

// Insert two libraries: Servo.h (for your Servo to work) and math.h (for inverse tangent function).

#include

// Name your servo. I called mine: servo.

Servo servo;

// Since "pi" has not been defined in any of the available libraries, you must define it yourself.

const float pi = 3.14159265359;

// Set up some floats: (1) PersonX and PersonY (position of person in relation to a coordinate system),

// (2) MotorX and MotorY (position of motor in relation to such coordinate system),

// (3) deltaX and deltaY (difference between the position of person in relationship to the position of the motor,

// and (4) angleRad and angleDeg (angle of motor to person in both radians and degrees).

float PersonX, PersonY;

float MotorX, MotorY;

float deltaX, deltaY;

float angleRad, angleDeg;

// In void setup(), make sure to set up a baudrate for your serial monitor

// and to mention what pin your Servo is attached to.

void setup() {

Serial.begin(9600);

servo.attach(9);

}

We will now to declare a function that’s argument relies on the use of coordinates rather than separate x and y variables (see Diagram 1).

// Let's declare a function, and let us call that function motorTurn.

void motorTurn(int PersonX,int PersonY) { // PersonX is a person's location on the x-axis, while PersonY is a person's location on the y-axis.

  // As mentioned before, deltaX and deltaY is the difference between the position of a person in relation to the position of the motor.

  deltaX = PersonX - MotorX;
  deltaY = PersonY - MotorY;
  
  if (deltaX &gt; 0 ) {
    angleRad = atan(deltaY/deltaX);
  }
  else {
    angleRad = pi + atan(deltaY/deltaX);
  }
  
  angleDeg = angleRad * (180/pi); // Let us convert the angle from radians (angleRad) to degrees (angleDeg).

  if (angleDeg&gt;180) {
    angleDeg = -(360-angleDeg); // Now, let us keep the angles between -180 to 180 degrees, for the sake of clarity.
  }
  
  Serial.print("Coordinate: ");
  Serial.print(PersonX);
  Serial.print(",");
  Serial.println(PersonY);
  Serial.print("Angle: ");
  Serial.println(angleDeg);
  Serial.println(" degrees");
  
  servo.write(angleDeg);  // This should make the Servo rotate.
  delay(1000);
}

// Let's declare a function, and let us call that function motorTurn.

void motorTurn(int PersonX,int PersonY) { // PersonX is a person's location on the x-axis, while PersonY is a person's location on the y-axis.

// As mentioned before, deltaX and deltaY is the difference between the position of a person in relation to the position of the motor.

deltaX = PersonX - MotorX;

deltaY = PersonY - MotorY;

if (deltaX > 0 ) {

angleRad = atan(deltaY/deltaX);

}

else {

angleRad = pi + atan(deltaY/deltaX);

}

angleDeg = angleRad * (180/pi); // Let us convert the angle from radians (angleRad) to degrees (angleDeg).

if (angleDeg>180) {

angleDeg = -(360-angleDeg); // Now, let us keep the angles between -180 to 180 degrees, for the sake of clarity.

}

Serial.print("Coordinate: ");

Serial.print(PersonX);

Serial.print(",");

Serial.println(PersonY);

Serial.print("Angle: ");

Serial.println(angleDeg);

Serial.println(" degrees");

servo.write(angleDeg); // This should make the Servo rotate.

delay(1000);

}

C:UsersTessaDocumentsArduinoprojecttutorialDiagram Model — Diagram 1: Coordinate System

Within the loop function, we will state the position of the motor in relation to the grid (see Diagram 1). Now, we want the motor to angle towards the points located around it (which are diagrammed as circles). In the code below, we will focus on 4 points (see Diagram 2).

void loop() {
  // Give the motor a position:
  MotorX = 2.5; 
  MotorY = 2.5;
  
  // Now give the person a series of positions:
  motorTurn(1,1);
  delay(1000);
  motorTurn(2,1);
  delay(1000);
  motorTurn(3,1);
  delay(1000);
  motorTurn(4,1);
  delay(1000);
  motorTurn(5,1);
  delay(1000);
}

// The motor should now rotate towards the position of the person and eventually follow the person through each position within the series provided.

void loop() {

// Give the motor a position:

MotorX = 2.5;

MotorY = 2.5;

// Now give the person a series of positions:

motorTurn(1,1);

delay(1000);

motorTurn(2,1);

delay(1000);

motorTurn(3,1);

delay(1000);

motorTurn(4,1);

delay(1000);

motorTurn(5,1);

delay(1000);

}

// The motor should now rotate towards the position of the person and eventually follow the person through each position within the series provided.

Now plug in your Arduino, upload the code and watch your Servo’s arm rotate! You can also check out the angle of the arm in relation to the coordinate in your serial monitor!

If you like, you can expand on this tutorial by including sensors into the equation! Instead of manually giving a set of coordinates, you can collect coordinates through a series of sensors within a built grid. The motor’s arm will rotate to the individual’s position within that grid, thanks to the sensor!

TUTORIALS

Detecting occupied space using gridded motion sensors

November 12, 2014 Tanay Nandgaonkar Leave a comment

This tutorial will show how to identify the coordinates of the space encompassed by objects within a grid. By using two axes with evenly spaced PIR motion detectors, multiple moving objects can be identified. In addition, when multiple objects are close together in the space, the coordinates will include any area covered on two sides by the objects themselves.

Note: Although this tutorial will use 3 total PIR detectors, the number of sensors can be expanded for larger grids with minimal changes to the code.

Behavior:

Figure A: Gridded PIR Sensor System

The gridded PIR sensors should be set up as shown in Figure A. In the next few diagrams, the circles represent objects in the grid, and the X’s represent the squares whose coordinates will be returned by Arduino via the serial cable. The red lines show which PIR sensors are set off by the objects.

Figure B: One Object Detected

If one object is present in the grid, it will set off PIR sensors attached to the closest column and the closest row.

Figure C: Two objects detected in a line

If two objects in a straight horizontal/vertical line are detected, each object will be detected and the coordinates returned will only be those where the objects are located.

Figure D: Three objects detected (not in a line)

If the objects encompass a certain area on two sides (e.g. if a group of people is walking through a gridded area), the space that they enclose will also be returned as a coordinate value.

This will allow for the response to change when a group enters the space. If the group is neatly ordered in a straight line, the returned coordinates will similarly reflect a straight line. However, if the group is disorderly and spread out in the space, the returned coordinates will reflect the total area encompassed by the group.

Figure E: Objects Along a Diagonal Line

If the objects are placed along the entire diagonal, then all possible coordinates will be returned. According to the initial behavior, each returned value should be encompassed on two sides. In the diagonal case with all coordinate pairs returned, this is technically true, but some of the squares will be two squares or more removed from the actual object, which may encompass more space than desired. In order to fix this problem, additional sensors, such as force sensors on squares outside the diagonal, will provide enough input to double check the presence of objects in those areas.

This is an optional addition, but for our purposes, we will be focusing only on the PIR motion sensors in this tutorial.

Continue reading Detecting occupied space using gridded motion sensors →

TUTORIALS

Using an air quality sensor

November 12, 2014 Grant Saita 2 Comments

Introduction

In this tutorial we will be connecting a basic air quality sensor to collect data for other applications with Arduino. There are many sensors you can choose from depending on what gasses or aspect of air quality you are interested in. We were particularly interested in detecting levels of benzene as an indicator of air pollution caused by combustion engines.

For this tutorial we will be using the MQ-135 sensor which detects levels of: NH3, Benzene, Alcohol, NOx, CO2 and smoke.

For a larger list of sensors check this link

Parts List

You will need:

An Arduino unit. (we used the Uno)
MQ-135 sensor (link to source)
5 – jumper wires
Breadboard

Set Up

When looking at the sensor there are abbreviations next to the pins you need to wire.

G = Ground

AO = Analog Out

DO = Digital Out

V = Voltage (power source)

Here is a simple diagram of how your sensor should be wired to your Arduino.

Note: If you are using this particular sensor board you do not need to use a 10 ohm resistor as some of the basic diagrams for this sensor indicate.

Here we have the sensor set up.

Close up of the sensor and the wiring.

For our power source we used the on board 5V output from Arduino. We wired that to the “V” tab of the sensor board

Next we wired the “G” tab to the ground on the Arduino.

The last step was to wire the Analog Output (AO) to the A0 input on the Arduino.

Code

In our code we wanted to float the voltage readings so that we could eventually use it in Processing applications.

We also wanted to convert the voltage readings of 0-1023 from the sensor to a 0.0-5.0 value which would reflect the true voltage being read.

const int gasSensor =0;


void setup()
{
  Serial.begin(9600);      // sets the serial port to 9600
}

void loop()
{
  float voltage;
  voltage = getVoltage(gasSensor);
  
  Serial.println(voltage);
  delay(1000);
}

float getVoltage(int pin)
{
return (analogRead(pin) * 0.004882814);
  // This equation converts the 0 to 1023 value that analogRead()
  // returns, into a 0.0 to 5.0 value that is the true voltage
  // being read at that pin.

}

const int gasSensor =0;

void setup()

{

Serial.begin(9600); // sets the serial port to 9600

}

void loop()

{

float voltage;

voltage = getVoltage(gasSensor);

Serial.println(voltage);

delay(1000);

}

float getVoltage(int pin)

{

return (analogRead(pin) * 0.004882814);

// This equation converts the 0 to 1023 value that analogRead()

// returns, into a 0.0 to 5.0 value that is the true voltage

// being read at that pin.

}

Run this code to your Arduino and you will be ready to detect changes in the level of detectable gasses!

Notes:

After doing some research about this sensor it was discovered that while the MQ-135 can detect all of the gasses listed above, it cannot distinguish between them. If you are looking to specifically target one gas, it might be better to find a different sensor.
This sensor also needs uses a heater to warm up the sensor. It has been advised to not use this with a small battery source as it will quickly drain your battery.

Additional Information:

TUTORIALS

Turn Environmental Light Conditions Into a LED Power Switch

November 12, 2014 Erica Nagy Leave a comment

This tutorial allows you to turn environmental data, in this case the amount of light in the setting you are working in, into an on/off switch for LED lights. This tutorial is a precursor to a more complicated setup that will be deployed for turning data gathered by a weather shield into conditions for selecting functions on a Raspberry Pi.

Tutorial Parts List:

Arduino UNO (1)
Breadboard (1)
Photo resistor (1)
Jumper wires (7)
10k Ohm resistor (1)
330 Ohm resistor (2)
Red LED (1)
Yellow LED (1)

Arduino Setup:

Let’s start by setting up the hardware on our Arduino board. Note: the short leg (the negative side) of the LED lights should be below the long leg (the positive side) in this setup. Use the following diagram to guide your setup:

You may also find the following circuit diagram helpful for your setup:

Coding:

Once you have your board set up, it’s time to enter our code into Arduino. What we are looking to accomplish here is getting our Arduino to sense the level of light in the environment, and use that input to determine which LED light should turn on or off. This tutorial could be altered in many ways, you could use only one LED, and simply have that light turn on/off according to light level. You can also alter the level of brightness/darkness Arduino will use to determine whether the LED(s) should be turned on or off.

// Tutorial: How to turn environmental light conditions into a LED power switch

// First we need to declare constants to name the pins we will be using.
// This will allow us to call our pins by name in the sketch.

const int sensorPin = 0;      // Our photo resistor must connected to an analog pin (A0)
const int redledPin = 9;      // Our red LED pin
const int yellowledPin = 6;   // Our yellow LED pin
const int switchPoint = 200;  // Here we must declare a value to act as our switching 
                              // point to determine when to turn the LEDs on and off
                              // playing with this value will change how dark or light
                              // must be for the lights to switch on/off. Pick a value
                              // between the range of 0 and 255.

int lightLevel;               // Declare a global variable for light level

void setup()
{
  pinMode(redledPin, OUTPUT); // First we need to set up both LEDs to be outputs.
  pinMode(yellowledPin, OUTPUT);
}

void loop ()
{                             // To begin our void loop, we tell Arduino to determine 
                              // the value of lightLevel by using the analogRead()
                              // function. This function measures the incoming voltage
                              // from the photo resistor (connected to our sensorPin.) 
                              // The photo resistor relays this information to our analog
                              // pin in a range of 0 to 1023 (0 to 5 volts). 
  lightLevel = analogRead(sensorPin);
  
                              // Next we must create an if/else statement to set up the
                              // parameters for our switch. In this case, we are telling
                              // Arduino that if the lightLevel is less than the value of
                              // our switch point, keep the red LED off and turn the yellow 
                              // LED on.
  if (lightLevel &lt; switchPoint)  
  {
    digitalWrite(redledPin, HIGH);
    digitalWrite(yellowledPin, LOW);
  }
                              // if the lightLevel does not represent the above condition
                              // (if the lightLevel is greater than the value of the 
                              // switchPoint) then the red LED will turn on and the yellow 
                              // LED will turn off.
  else
  {
    digitalWrite(redledPin, LOW);
    digitalWrite(yellowledPin, HIGH);
  }
}

// Tutorial: How to turn environmental light conditions into a LED power switch

// First we need to declare constants to name the pins we will be using.

// This will allow us to call our pins by name in the sketch.

const int sensorPin = 0; // Our photo resistor must connected to an analog pin (A0)

const int redledPin = 9; // Our red LED pin

const int yellowledPin = 6; // Our yellow LED pin

const int switchPoint = 200; // Here we must declare a value to act as our switching

// point to determine when to turn the LEDs on and off

// playing with this value will change how dark or light

// must be for the lights to switch on/off. Pick a value

// between the range of 0 and 255.

int lightLevel; // Declare a global variable for light level

void setup()

{

pinMode(redledPin, OUTPUT); // First we need to set up both LEDs to be outputs.

pinMode(yellowledPin, OUTPUT);

}

void loop ()

{ // To begin our void loop, we tell Arduino to determine

// the value of lightLevel by using the analogRead()

// function. This function measures the incoming voltage

// from the photo resistor (connected to our sensorPin.)

// The photo resistor relays this information to our analog

// pin in a range of 0 to 1023 (0 to 5 volts).

lightLevel = analogRead(sensorPin);

// Next we must create an if/else statement to set up the

// parameters for our switch. In this case, we are telling

// Arduino that if the lightLevel is less than the value of

// our switch point, keep the red LED off and turn the yellow

// LED on.

if (lightLevel < switchPoint)

{

digitalWrite(redledPin, HIGH);

digitalWrite(yellowledPin, LOW);

}

// if the lightLevel does not represent the above condition

// (if the lightLevel is greater than the value of the

// switchPoint) then the red LED will turn on and the yellow

// LED will turn off.

else

{

digitalWrite(redledPin, LOW);

digitalWrite(yellowledPin, HIGH);

}

The following video illustrates what you should see when you are finished! I used a small keychain light to demonstrate the change of the LED lights under different light conditions. As mentioned earlier, you can alter the light level needed to switch the LEDs on/off in the code.

Tutorial_PhotoResistor

TUTORIALS

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