DietroVetro.com

So, this was the most interesting thing we did in this lab – letting Arduino and Processing work together in perfect harmony.

But it all started when we…

CONNECTED A POTENTIOMETER
We attached the potentiometer’s outer red and black wires to power and ground, and connected the middle wire from the potentiometer to the Analog input pin 0 on your Arduino board.

SENDING SERIAL OUTPUT
Used the following Arduino program to send serial output of the values as bytes out to the computer:

int analogPin = 0;
int analogValue = 0;

void setup()
{
// start serial port at 9600 bps:
Serial.begin(9600);
}

void loop()
{
// read analog input, divide by 4 to make the range 0-255:
analogValue = analogRead(analogPin);
analogValue = analogValue / 4;
Serial.print(analogValue, BYTE);
// pause for 10 milliseconds:
delay(10);
}

CHECKED SERIAL OUTPUT
We opened the Arduino serial monitor and using the default settings of parsing at 9600 baud, we played with the potentiometer to see the output (or scrolling) of ASCII values.

Turning the potentiometer at different speeds affected the output (numerals, versus capital and lowercase letters). Click here to see it in action.

VERIFYING SERIAL PORT
We loaded a Sensor Graphing Sketch program to Processing. But first, before putting it into action, we verified the correct serial port.

MAKING A GRAPH
After verifying, we played the graphing program in Processing. This program basically demonstrated how serial output can be used to drive communication between different software components (in this case Arduino and Processing). And here’s the result:

Parts we used:
H-bridge, diode (brownish red colored little fellow), TIP-120 transistor (three legged black square), small DC motor, 10 µF capacitor (the black cylinder). We also used the breadboard, hook up wire, Arduino, potentiometer, switch, 1K Ohm resistor, 10K Ohm, resistors (or similar), wire stripper, multimeter.

HOOKING UP ARDUINO BOARD, ADDING POTENTIOMETER
Hooked up the Arduino to the breadboard, and then we added a potentiometer with the middle “output” wire connected to analog pin 0.

ADDING MOTOR
We soldered wires to the motor, and connected the motor wires to power and to the center collector pin of the TIP120 transistor. Then we connected the output end of an LED to the same center collector pin of the transistor. Then we added a diode with the input end of the attached to the right-side emitter pin of the transistor. This diode will prevent a spinning motor’s “blowback” current from shorting out the circuit.

We connected a 1K ohm resistor to the left-side base pin of the TIP120 transistor. We wired the other end of that resistor to Arduino digital pin 9. To reduce noise in the circuit, we put a 10µF capacitor between the power and ground rails of the breadboard. The circuit was completed by connecting the right-side emitter pin of the TIP120 to ground. This is what it looked like:

UPLOADED CODE
Uploaded the following code to translate the analog input into digital output that moves the motor.

int motorPin = 9; // motor connected to digital pin 9
int analogPin = 0; // potentiometer connected to analog pin 0
int val = 0; // variable to store the read value
void setup()
{
pinMode(motorPin, OUTPUT); // sets the pin as output
}
void loop()
{
val = analogRead(analogPin); // read the input pin
analogWrite(motorPin, val / 4); // analogRead values go from 0 to 1023, analogWrite values from 0 to 255
}

LOOK, it works, and we made a 6 seconds video to prove it!

ADDED A SWITCH
Removed all components except the motor and the wires connecting power between Arduino and the breadboard, and then hooked up a regular switch (SPST) to the breadboard.

ADDED AN H-BRIDGE
By adding a bunch of wires to different places on the breadboard all of a sudden an H-bridge was hooked up. Amazing. This is what such an H-bridge looks like all wired up:

This H-bridge combined with the code below was supposed to let us control the motor to go in different directions depending on the switch being in ON or OFF position. We didn’t actually make it happen, and we are not sure why – even after troubleshooting for a while. However, we are pretty sure the answer is hidden somewhere within the delicious spaghetti of wires surrounding the H-bridge.

const int switchPin = 2; // switch input
const int motor1Pin = 3; // H-bridge leg 1 (pin 3, 1A)
const int motor2Pin = 7; // H-bridge leg 2 (pin 7, 2A)
const int enablePin = 9; // H-bridge enable pin
const int ledPin = 13; // LED
void setup() {
// set the switch as an input:
pinMode(switchPin, INPUT);
// set all the other pins you’re using as outputs:
pinMode(motor1Pin, OUTPUT);
pinMode(motor2Pin, OUTPUT);
pinMode(enablePin, OUTPUT);
pinMode(ledPin, OUTPUT);
// set enablePin high so that motor can turn on:
digitalWrite(enablePin, HIGH);
// blink the LED 3 times. This should happen only once.
// if you see the LED blink three times, it means that the module
// reset itself,. probably because the motor caused a brownout
// or a short.
blink(ledPin, 3, 100);
}
void loop() {
// if the switch is high, motor will turn on one direction:
if (digitalRead(switchPin) == HIGH) {
digitalWrite(motor1Pin, LOW); // set leg 1 of the H-bridge low
digitalWrite(motor2Pin, HIGH); // set leg 2 of the H-bridge high
}
// if the switch is low, motor will turn in the other direction:
else {
digitalWrite(motor1Pin, HIGH); // set leg 1 of the H-bridge high
digitalWrite(motor2Pin, LOW); // set leg 2 of the H-bridge low
}
}
/*
blinks an LED
*/
void blink(int whatPin, int howManyTimes, int milliSecs) {
int i = 0;
for ( i = 0; i < howManyTimes; i++) {
digitalWrite(whatPin, HIGH);
delay(milliSecs/2);
digitalWrite(whatPin, LOW);
delay(milliSecs/2);
}
}

These people are freaked out. Why? Unless you click on the picture, you will never find out! In addition to these freaked out people, I have also made bouncing squares, blinking squares, squares that change color and snow men. It’s all here:

SquareLights
RaceTrack
ColorSquares
Bounce
Snow man
Freaked out creatures

We needed to find a problem in the world, and then fix it through the use of physical computing. Our problem is that we simply hate spelling mistakes. To make people spell correctly you need to get to them early. We made a simple game for kids to play with, that will give them immediate feedback on whether they are spelling right or wrong. In the short video below we are spelling the word ART. This is a prototype, which means some other 3 letter words can be spelled, but unfortunately not all words. The game is limited because we have not made enough contacts in each letter space for all letters of the alphabet to be used.

THIS IS HOW IT WORKS

THIS IS OUR LITTLE SECRET

AND THIS IS THE MIGHTY GAME BRAIN
…or the code behind it if you like. Except that in this code example, the user has to spell the word CAT instead. I guess CAT is a bit more kid-friendly than the word ART. Anyway. Game brain coming up:

//PIN FOR THE LED LIGHTS CONNECTED TO PLACES ON BLOCK TRAY

#define LED 10 // the pin for the LED for first letter block
#define LED2 11 // the pin for the LED for 2nd letter block
#define LED3 12 // the pin for the LED for 3rd letter block

//THE CONTACT SPOTS ON THE BLOCK TRAY

#define P1X 2 // the input pin where the contact for block 1 is connected
#define P1Y 3 // the input pin where the contact for block 1 is connected
#define P2X 4 // the input pin where the contact for block 2 is connected
#define P2Y 5 // the input pin where the contact for block 2 is connected
#define P3X 6 // the input pin where the contact for block 3 is connected
#define P3Y 7// the input pin where the contact for block 3 is connected

//STORING STATE OF THE INPUT PINS FROM LETTER BLOCKS

int placeX = 0; // val will be used to store the state of the input pin
int placeY = 0; // val will be used to store the state of the input pin
int place2X = 0; // val will be used to store the state of the input pin
int place2Y = 0; // val will be used to store the state of the input pin
int place3X = 0; // val will be used to store the state of the input pin
int place3Y = 0; // val will be used to store the state of the input pin

//THE WORD THE USER MUST SPELL

String theword = “CAT”; // using a constant String

void setup() {
pinMode(LED, OUTPUT); // tell Arduino LED is an output
pinMode(LED2, OUTPUT); // tell Arduino LED is an output
pinMode(LED3, OUTPUT); // tell Arduino LED is an output
pinMode(P1X, INPUT); // and contact is an input
pinMode(P1Y, INPUT); // and contact is an input
pinMode(P2X, INPUT); // and contact is an input
pinMode(P2Y, INPUT); // and contact is an input
pinMode(P3X, INPUT); // and contact is an input
pinMode(P3Y, INPUT); // and contact is an input
}

void loop(){
//READING EACH OF THE LETTERS IN THE WORD
int letter1 = theword.charAt(0);
int letter2 = theword.charAt(1);
int letter3 = theword.charAt(2);

//READING EACH OF THE LETTER BLOCKS
placeX = digitalRead(P1X); // read input value and store it
placeY = digitalRead(P1Y); // read input value and store it
place2X = digitalRead(P2X); // read input value and store it
place2Y = digitalRead(P2Y); // read input value and store it
place3X = digitalRead(P3X); // read input value and store it
place3Y = digitalRead(P3Y); // read input value and store it

//CHECKING LETTERPLACE 1
// CHECK whether input from the block is HIGH-HIGH (A)
if (placeX == HIGH && placeY == HIGH) {
if(letter1 == ‘A’) {
digitalWrite(LED, HIGH); // turn LED ON
}
}

// CHECK whether input from the block is HIGH-LOW (T)
else if (placeX == HIGH && placeY == LOW) {
if(letter1 == ‘T’) {
digitalWrite(LED, HIGH); // turn LED ON
}
}

// CHECK whether input from the block is LOW-HIGH (C or R or F)
// Made the same pattern underneath the C, R and F letter blocks
// The child can then play with different words that can be spelled with _AT
else if (placeX == LOW && placeY == HIGH) {
if(letter1 == ‘C’) {
digitalWrite(LED, HIGH); // turn LED ON
}
}

//CHECKING LETTERPLACE 2
// CHECK whether input from the block is HIGH-HIGH (A)
if (place2X == HIGH && place2Y == HIGH) {
if(letter2 == ‘A’) {
digitalWrite(LED2, HIGH); // turn LED ON
}
}

// CHECK whether input from the block is HIGH-LOW (T)
else if (place2X == HIGH && place2Y == LOW) {
if(letter2 == ‘T’) {
digitalWrite(LED2, HIGH); // turn LED ON
}
}

// CHECK whether input from the block is LOW-HIGH (C or R or F)
else if (place2X == LOW && place2Y == HIGH) {
if(letter2 == ‘C’) {
digitalWrite(LED2, HIGH); // turn LED ON
}
}

//CHECKING LETTERPLACE 3
// CHECK whether input from the block is HIGH-HIGH (A)
if (place3X == HIGH && place3Y == HIGH) {
if(letter3 == ‘A’) {
digitalWrite(LED3, HIGH); // turn LED ON
}
}

// CHECK whether input from the block is HIGH-LOW (T)
else if (place3X == HIGH && place3Y == LOW) {
if(letter3 == ‘T’) {
digitalWrite(LED3, HIGH); // turn LED ON
}
}

// CHECK whether input from the block is LOW-HIGH (C or R or F)
else if (place3X == LOW && place3Y == HIGH) {
if(letter3 == ‘C’) {
digitalWrite(LED3, HIGH); // turn LED ON
}
}

//CHECKING IF BLOCK IS REMOVED

if (placeX == LOW && placeY == LOW) {
digitalWrite(LED, LOW); // turns the LED off*/
}
if (place2X == LOW && place2Y == LOW) {
digitalWrite(LED2, LOW); // turns the LED off*/
}
if (place3X == LOW && place3Y == LOW) {
digitalWrite(LED3, LOW); // turns the LED off*/
}
}