Archive for the ‘Physical Computing’ Category
“Do you have a dream” Final Video Documentation
With this piece I would like to explore immigrant children’s vision of their community, their family and their future. It’s very important to hear what children’s are thinking, questioning and expecting from life. They are the future and we need to teach them how to respect each other. They need to talk and be heard regarding their dreams and expectations. Children are more open-minded to understanding the errors of the adults. They a have a fresh mind in order to think about change. Children have another way of looking at the world. They are honest, playful and sometimes full of energy like a volcano while other times they are just quite as a rock.
United States is a country build by immigrants from all over the world. It is a country that represents freedom and opportunities. Unfortunately the immigrant’s conditions have been deteriorating. Prejudice between different races, religious and cultures are more notorious. In places like New Mexico the number of gang members has been increasing. The economic crisis doesn’t help and people are constantly loosing their jobs. This is why it’s so important to listen to what children are thinking.
The footage I’m collecting reflects their playfulness. Here, they are learning how to use cameras and new technologies, making mistakes, hiding from each other and always having fun. It was their opportunity to speak out, but also a moment to play and discover. Almost all of the children that I’ve been working with are sons and daughters of immigrants or live in a Hispanic majority community. In Santa Fe, New Mexico I worked with two middle Schools with 6 and 7 graders. In New York, I’m working with 4th graders from the after School program at Henry Street Settlement.
The most interesting part of the workshops is that they have the opportunity to use the cameras and perform interviews on each other. The most important lesson that I learned is that it doesn’t matter how difficult the environment is, children are usually very playful. In Santa Fe, they were talking about serious issues, but at the same time they were dancing, playing, running and yelling into the microphone.
The experience from the audience will be somewhat subtle. The screens will be off most of the time. When the spectator crosses in front of one of them, it will trigger it to start showing the videos. The LCDs will be placed on the walls in a random manner, creating curiosity. They will remain off if there is no movement in front of them. They will be on if people are walking in front. The sound is very soft so you have to get close in order to pay attention. The other option is have captions so you the audience needs to be close to the small 10” screen to read it.
The audience will either ignore the screens or get curios and come closer. This behavior is similar to the contrast of when the children’s opinions are ignored by their parents versus when they are in their playful moments. Since the spectator has to actually stop and stand in front of the screen, it is a soft way of forcing them to pay close attention to the messages. By generating curiosity and playfulness, I want to bring the spectator closer to the children.
Final Observation Assignment
I don’t remember when it could have been, but I remember my reaction when the toilet flushed automatically. It was like magic for me. I couldn’t believe I could turn things on or off around me just by moving.
In the modern world, mankind’s effort is minimal. The closer we are from a developed city, the less effort we have to put in. Part of the goal of my career an as an artist, is to create interactions with the audience. Trying to be subtle by creating a large interaction with the minimal effort of the receptor has been one of my biggest challenges. This is why I’m interested in working with sensors that trigger different actions. I created this interaction before based on the site; but now thanks to this class I had the opportunity to research more about sensors, screen and interaction with the audience base on their movement.
Movement sensors are all over the place: in pubic restrooms, security alarms, doors, control remote, etc.
The equipment that I’ll be using is a series of screen that would be triggered by IR proximity sensors based on the movement of the audience. The goal of the activity is to eliminate any switch or button and turn the screens on or off based on movement. The audience will be engaged with all their body and they will change the posture based on movement. The audience will focus their attention on the images of the screen. The most challenging or difficulty in this action will be how to trigger the so und and video without interfering or triggering the rest of the screens.
Bellow is my observation video
Bellow is the first idea of the project and some links for materials
Mouse Pad documentation second part (a few weeks after the piece is done)
Click here for Slide Show
Here is the second part of the documentation. It shows you the up and down of the project. We have photos of h bridges, dc motors relays and mouse hacking. We learn a lot about serial communication, dc motors, relays, and the most important how to work in group.
Below is the code we finally use:
// Analog Sensors
int analogOne = 0; // Left moving Sensor
int analogTwo = 1; // Up moving Sensor
int analogThree = 2; // Right moving Sensor
int analogFour = 3; // Down moving Sensor
// Digital sensors
int digitalOne = 12; // Left Mouse Click
int digitalTwo = 13; // Right Mouse Click
int relay1Pin = 2; // Relay for left click
int relay2Pin = 7; // Relay for right click
int leftClick = 0; //variable for the left click
int rightClick = 0; //variable for the right click
// For motor # 1
int motor1Pin = 10; // H-bridge leg 1 (pin 2, 1A)
int motor2Pin = 11; // H-bridge leg 2 (pin 7, 2A)
// For motor # 2
int motor3Pin = 5; // H-bridge leg 3? (pin ??, 1A)
int motor4Pin = 6; // H-bridge leg 4? (pin ??, 2A)
// Pin “9”
int enablePin = 9; // H-bridge enable pin
int enablePin2 = 8; // H-bridge enable pin2
int sensorValue = 0; // reading from the sensor
void setup() {
Serial.begin(9600);
pinMode(digitalOne, INPUT);
pinMode(digitalTwo, INPUT);
pinMode(relay1Pin, OUTPUT);
pinMode(relay2Pin, OUTPUT);
pinMode(motor1Pin, OUTPUT);
pinMode(motor2Pin, OUTPUT);
pinMode(motor3Pin, OUTPUT);
pinMode(motor4Pin, OUTPUT);
pinMode(enablePin, OUTPUT);
digitalWrite(enablePin, HIGH);
pinMode(enablePin2, OUTPUT);
digitalWrite(enablePin2, HIGH);
}
void loop() {
if (analogRead(analogOne) > 100) {
//turn left
analogWrite(motor1Pin, 0); // set leg 1 of the H-bridge low
analogWrite(motor2Pin, 96); // set leg 2 of the H-bridge high
}
else {
//turn right
if (analogRead(analogThree) > 100) {
analogWrite(motor1Pin, 96); // set leg 1 of the H-bridge low
analogWrite(motor2Pin, 0); // set leg 2 of the H-bridge high
}
else {
// dont move left or right
analogWrite(motor1Pin, 0); // set leg 1 of the H-bridge low
analogWrite(motor2Pin, 0); // set leg 2 of the H-bridge low
}
}
if (analogRead(analogTwo) > 100) {
// Go up
analogWrite(motor3Pin, 0); // set leg 3 of the H-bridge low
analogWrite(motor4Pin, 96); // set leg 4 of the H-bridge high
}
else {
// Go down
if (analogRead(analogFour) > 100) {
analogWrite(motor3Pin, 96); // set leg 3 of the H-bridge high
analogWrite(motor4Pin, 0); // set leg 4 of the H-bridge low
}
else {
// Dont go up or down
analogWrite(motor3Pin, 0); // set leg 3 of the H-bridge low
analogWrite(motor4Pin, 0); // set leg 4 of the H-bridge low
}
}
// Mouse Clicks
leftClick = digitalRead(digitalOne);
if (leftClick > 0) {
digitalWrite(relay1Pin, HIGH); // Turn on relay 1
}
else {
digitalWrite(relay1Pin, LOW); // Turn off relay 1
}
rightClick = digitalRead(digitalTwo);
if (rightClick > 0) {
digitalWrite(relay2Pin, HIGH); // Turn on relay 2
}
else {
digitalWrite(relay2Pin, LOW); // Turn off relay 2
}
// Print the values to serial for monitoring
sensorValue = analogRead(analogOne);
Serial.print(sensorValue, DEC);
Serial.print(“,”);
sensorValue = analogRead(analogTwo);
Serial.print(sensorValue, DEC);
Serial.print(“,”);
sensorValue = analogRead(analogThree);
Serial.print(sensorValue, DEC);
Serial.print(“,”);
sensorValue = analogRead(analogFour);
Serial.print(sensorValue, DEC);
Serial.print(“,”);
sensorValue = digitalRead(digitalOne);
Serial.print(sensorValue, DEC);
Serial.print(“,”);
sensorValue = digitalRead(digitalTwo);
Serial.println(sensorValue, DEC);
}
Also Gordie made the second version of the housing of the mouse. This made the mouse pad more reliable. Below is the video
Our mousepad is working Hurray!!!!
Midterm 1st step and serial communication 2 week 6
We start working in our midterm idea we would like to create an interface for the computer. Our first idea it was to replace the keyboard in order to release the stress that we put in our wrist when we work in the computer. This piece was inspire by people who suffer of Carpal Tunnel Syndrome. Because we only have two weeks to complete this project we decide it to only imitate the mouse. Our final approach it was quite different that we thought. I will explain more soon.
The good news is that the serial communication lab that we have to do for this week was very helpfull to test all the sensors and understand visually the movement of the cursor using processing.
Bellow is step by step in our process. Ufff a lot hours of work 🙂
This is the photo documentation of the mat prototype:
This is all the 6 sensors working, 4 work as analogs and two digital. We look very happy
This is the documentation of the serial communication in processing
As I say before we took another different approach. We ore going to hack a mouse. The rotary tracks of the mouse inside are going to be connected to a dc motor and they will move them from one direction. We are going to have two of them. Bellow is Gordie working on it and the best part is working
Bellow is the call an response hand shake method, Gordie and Emily are the stars of this video
Idea for the Midterm
I’m very exited about my next project with Emily and Gordie, bellow is our idea and research, enjoy:
Power Presentation:
Images Observation:
“We spent a lot of time in front of the computer and we only use our hands, which generates a lot health issues like carpal tunnel syndrome. Our idea with this is to create an interface that could help the interaction with the computer from another perspective. We could redesign the computer interface similar to piano pedals and some kind of mouse and switch that could replace many functions of the mouse.
Here, the action is clicking and typing on the keyboard mouse. The medium is the computer program and the changes will be the behavior of the computer. The goal of clicking and typing of the computer is to create, change, modify or delete information.
The physical parameters of this activity are limited to your hands and eyes. The person engaged will only use his hands and eyes, while his legs and arms basically do nothing. The posture almost doesn’t change, so this also generates problems in your back, neck, hips and some cases legs. While working on the computer your focus is mainly on the screen and keyboard. The activity is engaging because we have a constant overflow of information. The stress on your hands wrist and the fact you don’t move the body for a long time”
Serial communication Week 1
Code 1:
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);
}Code 2:
import processing.serial.*;
Serial myPort; // The serial port
int graphXPos = 1; // the horizontal position of the graph:
void setup () {
size(400, 300); // window size
// List all the available serial ports
println(Serial.list());
myPort = new Serial(this, Serial.list()[0], 9600);
background(113,86,86);
}
void draw () {
// nothing happens in draw. It all happens in SerialEvent()
}
void serialEvent (Serial myPort) {
// get the byte:
int inByte = myPort.read();
// print it:
println(inByte);
// set the drawing color. Pick a pretty color:
stroke(123,128,158);
// draw the line:
line(graphXPos, height, graphXPos, height – inByte);
// at the edge of the screen, go back to the beginning:
if (graphXPos >= width) {
graphXPos = 0;
// clear the screen:
background(113,86,86);
}
else {
// increment the horizontal position for the next reading:
graphXPos++;
}
}
Week 4 Analog Output
Bellow is more documentation of my Analog Output Lab. I though it would be nice for future reference to have a better angle of the wires and Arduino. Also it was important to make interact real people with my chicken fighters. I hope you enjoy:
My wires:
Here is the code:
/*
Servo control from an analog input using the Arduino Servo library
This example code uses the Arduino Servo library which comes packaged with the Arduino software.
In order to make this work, you must include the Servo.h library file, create an instance of the Servo object,
attach a digital PWM pin to the Servo object, and then write an analog value to the Servo object to set its
position.
The difference between using the Servo library and the older method of pulsing a digital pin is that the library
handles a lot of the work for you. You no longer need to figure out the translation between pulse length and position.
You now can simply specify the angle you’d like your servo to be at and it will turn to that position.
Please note, unlike the older pulsing method you MUST use a digital PWM pin or it will not work.
by Rory Nugent
Created 20 Jan. 2009
*/
#include <Servo.h> // include the servo library
Servo servoMotor;
Servo servoMotor2;// creates an instance of the servo object to control a servo
int analogPin1 = 0; // the analog pin that the sensor is on
int analogValue1 = 0; // the value returned from the analog sensor
int analogPin2 = 1; // the analog pin that the sensor is on
int analogValue2 = 0; // the value returned from the analog sensor
int servoPin1 = 9; // Control pin for servo motor, must be a PWM pin
int servoPin2 = 10; // Control pin for servo motor, must be a PWM pin
void setup() {
servoMotor.attach(servoPin1); // attaches the servo on pin 9 to the servo object
servoMotor2.attach(servoPin2); // attaches the servo on pin 9 to the servo object
}
void loop()
{
analogValue1 = analogRead(analogPin1); // read the analog input (value between 0 and 1023)
analogValue1 = map(analogValue1, 0, 1023, 0, 179); // map the analog value (0 – 1023) to the angle of the servo (0 – 179)
servoMotor.write(analogValue1); // write the new mapped analog value to set the position of the servo
analogValue2 = analogRead(analogPin2); // read the analog input (value between 0 and 1023)
analogValue2 = map(analogValue2, 0, 1023, 0, 179); // map the analog value (0 – 1023) to the angle of the servo (0 – 179)
servoMotor2.write(analogValue2); // write the new mapped analog value to set the position of the servo
delay(15); // waits for the servo to get there
}
Bellow is final project in the Analog Output Lab
Bellow is step by step the development of the lab
Understanding Electricity- Week 3
1. Measuring Voltage
2. A Basic LED Circuit
3. Components in Series
Analog Input, Getting Creative, Love meter week 2 (1)
Click on the image
int potValue = 0; // value read from the pot
int Greenled = 9; // PWM pin that the GreenLED is on. n.b. PWM 0 is on digital pin 9
int Yellowled = 10; // PWM pin that the YellowLED is on.
int Redled = 11; // PWM pin that the redLED is on.
void setup() {
// initialize serial communications at 9600 bps:
Serial.begin(9600);
pinMode(Greenled,OUTPUT);
pinMode(Yellowled,OUTPUT);
pinMode(Redled,OUTPUT);
}
void loop() {
potValue = analogRead(potPin); // read the pot value
Serial.println(potValue);
if(100 <= potValue && potValue < 441)
{
digitalWrite(Greenled,HIGH);
digitalWrite(Yellowled,LOW);
digitalWrite(Redled,LOW);
}
else if(441 <= potValue && potValue < 782)
{
digitalWrite(Greenled,HIGH);
digitalWrite(Yellowled,HIGH);
digitalWrite(Redled,LOW);
}
else if(potValue >= 782)
{
digitalWrite(Greenled,HIGH);
digitalWrite(Yellowled,HIGH);
digitalWrite(Redled,HIGH);
}
else
{
digitalWrite(Greenled,LOW);
digitalWrite(Yellowled,LOW);
digitalWrite(Redled,LOW);
}
/*
if (0 < potValue <341) {
analogWrite(Greenled, potValue/4); // PWM the Green LED
delay(10); // wait 10 milliseconds before the next loop
}
if (201 <potValue <682) {
analogWrite(Yellowled, potValue/4); // PWM the Yellow LED
delay(10);
}
if (401<potValue <1023) {
analogWrite(Redled, potValue/4); // PWM the Yellow LED
delay(10);
}*/
}