The little bird jumps all the time. If you feed her by clicking the colorful ball, she will sing happily. But if you get closer, she will jump crazily and scream.

There’s a photoresistor, a flex sensor and a servo inside.

Code:

#include <Servo.h>

Servo myservo1; //360
int val1 = 0;
int val2 = 0;
int t1 = 80;
int t2 = 120;

int pos = 0;
int pos_l = 20;
int dir = 1;

int toneSpeed = 1800;
int speakerPin = 7;
int freq = 2000;
int feed = 2200;

int lightPin = 0;
int flexPin = 1;
int flexVal = 0;

void setup() {
myservo1.attach(9);
Serial.begin(9600);
pinMode(speakerPin, OUTPUT);
}
void loop() {
val1 = analogRead(lightPin);
//Serial.println(val1);
val1 = map(val1, 300, 800, 0, 180);
// Serial.println(val1);

flexVal = analogRead(flexPin);
Serial.println(flexVal);

if(flexVal < 8) {
tone(speakerPin, feed+flexVal*5, 8);
delay(10);
tone(speakerPin, feed+flexVal*5-150, 16);
noTone(speakerPin);
}

if(val1 <= t1) {
pos += 2 * dir;
noTone(speakerPin);
if(pos < pos_l) {
pos = pos_l;
dir *= -1;
}
else if(pos > pos_l+60) {
pos = pos_l+60;
dir *= -1;
}
}
else if(val1 > t1 && val1 <= t2) {
pos += 4 * dir;
noTone(speakerPin);

if(pos < pos_l) {
pos = pos_l;
dir *= -1;
}
else if(pos > pos_l+60) {
pos = pos_l+60;
dir *= -1;
}
}
else if(val1 > t2) {
pos += 5 * dir;
tone(speakerPin, freq+val1*5);
if(pos < pos_l) {
pos = pos_l;
dir *= -1;
}
else if(pos > pos_l+30) {
pos = pos_l+30;
dir *= -1;
}
}
// Serial.println(pos);
myservo1.write(pos);
delay(10);
}

CONCEPT

The “Breathing Device”, equipped with the same mechanical motion as “The breathing paper bag” but translated into an object that the user has to carry close to her/his hand. The device is shaped to fit the users hand. The tiny shape evokes feelings of protection. Additionally, through the intimate contact, the user feels the movement of the breathing tangible on the skin. The purpose of the object is to create a playful experience with it and raise deeper questions about how to evoke feelings for artificial objects. On another hand, it is used as a stress relief.

https://vimeo.com/111303016

People like  zazen to improve their self control .  It’s through the control of breathing and heartbeat . So i want to try to use a pulse sensor to  make some interaction with zen arts , a  brush pen draw a circle according to the BPM.

#include <Stepper.h>

const int stepsPerRevolution = 512; // change this to fit the number of steps per revolution
// for your motor

// initialize the stepper library on pins 8 through 11:
Stepper myStepper(stepsPerRevolution, 8,9,10,11);

// VARIABLES
int pulsePin = 0; // Pulse Sensor purple wire connected to analog pin 0
int blinkPin = 13; // pin to blink led at each beat
int fadePin = 5; // pin to do fancy classy fading blink at each beat
int fadeRate = 0;

int steps=0;// used to fade LED on with PWM on fadePin

boolean fadeIn = false;
// these variables are volatile because they are used during the interrupt service routine!
volatile int BPM; // used to hold the pulse rate
volatile int Signal; // holds the incoming raw data
volatile int IBI = 600; // holds the time between beats, the Inter-Beat Interval
volatile boolean Pulse = false; // true when pulse wave is high, false when it’s low
volatile boolean QS = false;
int times=0;// becomes true when Arduoino finds a beat.
void setup(){
pinMode(blinkPin,OUTPUT); // pin that will blink to your heartbeat!
pinMode(5,OUTPUT);
pinMode(4,OUTPUT);
pinMode(6,OUTPUT);
pinMode(2,OUTPUT); // pin that will fade to your heartbeat!
Serial.begin(115200);
myStepper.setSpeed(30); // we agree to talk fast!
interruptSetup();
// sets up to read Pulse Sensor signal every 2mS
// UN-COMMENT THE NEXT LINE IF YOU ARE POWERING The Pulse Sensor AT LOW VOLTAGE,
// AND APPLY THAT VOLTAGE TO THE A-REF PIN
//analogReference(EXTERNAL);
}

void loop(){
sendDataToProcessing(‘S’, Signal);
steps=map(BPM,50,150,140,20); // send Processing the raw Pulse Sensor data
if (QS == true){ // Quantified Self flag is true when arduino finds a heartbeat
fadeRate = 255; // Set ‘fadeRate’ Variable to 255 to fade LED with pulse

fadeIn = true;

sendDataToProcessing(‘B’,BPM); // send heart rate with a ‘B’ prefix
sendDataToProcessing(‘Q’,IBI); // send time between beats with a ‘Q’ prefix
QS = false;
times=times+1; // reset the Quantified Self flag for next time
}
if (times ==5){

myStepper.step(steps);
times=0;
ledFadeToBeat();
}
if (times ==1){
fadeRate -= 30; // set LED fade value
fadeRate = constrain(fadeRate,0,255); // keep LED fade value from going into negative numbers!
analogWrite(6,fadeRate);

}
if (times ==2){
fadeRate -= 30; // set LED fade value
fadeRate = constrain(fadeRate,0,255); // keep LED fade value from going into negative numbers!
analogWrite(5,fadeRate);

}
if (times ==3){
fadeRate -= 30; // set LED fade value
fadeRate = constrain(fadeRate,0,255); // keep LED fade value from going into negative numbers!
analogWrite(4,fadeRate);

}
if (times ==4){
fadeRate -= 30; // set LED fade value
fadeRate = constrain(fadeRate,0,255); // keep LED fade value from going into negative numbers!
analogWrite(2,fadeRate);

}

delay(20); // take a break
}
void ledFadeToBeat(){
fadeRate -= 15; // set LED fade value
fadeRate = constrain(fadeRate,0,255); // keep LED fade value from going into negative numbers!
analogWrite(5,fadeRate);
analogWrite(4,fadeRate);
analogWrite(6,fadeRate);
analogWrite(2,fadeRate);

// fade LED
}
void sendDataToProcessing(char symbol, int data ){
Serial.print(symbol); // symbol prefix tells Processing what type of data is coming
Serial.println(data); // the data to send culminating in a carriage return
}

CONCEPT

The machines designed for motor rehabilitation are aesthetically unpleasant and often not engaging or stimulating to the patient. I am interested in exploring the areas of healthcare and rehabilitation through art and new technologies in order to five people with motor challenges better health through inclusive design and interactive experiences. Rehabilitation is a slow and boring process, so how can the algorithm behind the interaction I am creating suggest a more engaging process?

I am currently researching the domains of motivation, agency and especially self-efficacy. What would keep my user from loosing interest? How is kinetic movement rewarding? How does externalization affect stress? How can haptic feedback be utilized to enhance muscle memory? My entire concept is grounded in my users experience, practically approaching the problems that people with disabilities face. I am particularly focusing on people that are very physically restrained – to the extent that even jumping on a wheelchair is exhausting.

For my midterm, I needed to prototype the experience with my peers in order to send out a package to different healthcare facilities in order to consult a specialist and ideally work with them for future prototyping. I conducted a short User Test Questionnaire in conjunction with the test, and below are some of my key insights:

• Vibrational feedback needs to be more clear, not using time but rather number of vibrations to indicate if you have done the exercises too slow/fast.
• People generally found the feedback to be helpful/rewarding/important, and would like to see this as a developed product.
• People did not pay so much attention to the visual feedback, and where more focused and grateful for the haptic feedback.

PROTOTYPE

The piece is based on a simple exercise routine: the bicep curl. Often times, it is difficult for people to stay with their routines, especially when highly disabled and check-ins with physical therapists are scarce. In this instance, haptic feedback lets you know if you have done the basic routine of ten bicep curls within the right time frame by giving you one long vibration. Two short tells you that you’ve done them too fast, and two long ones too slow. The origami works as a supplement in lifting all of it’s legs if you have done it right, and only some of them if wrong, simply to test the viability of visual stimuli in a simple way.

/*
VIBRATIONAL FEEDBACK BASED ON IF YOU HAVE DONE YOUR BICEP ROUTINES CORRECTLY. MOREOVER, YOU WILL SEE ORIGAMI MOVE AS FEEDBACK.
BY FABIOLA EINHORN FALL 2014 FOR THESIS AND PHYSICAL COMPUTING
*/

int vibration = 6;
int sensorValue = 0;
int flex = A3;
int counter = 0;
int timer;
int startTime;
int endTime;
int trainTime;
int flexinolA = 2;
int flexinolB = 3;
int flexinolC = 4;
int flexinolD = 5;

void setup() {
pinMode(vibration, OUTPUT);
pinMode(flexinolA, OUTPUT);
pinMode(flexinolB, OUTPUT);
pinMode(flexinolC, OUTPUT);
pinMode(flexinolD, OUTPUT);

Serial.begin(9600);
}

void loop() {
//Serial.println(sensorValue);
sensorValue = analogRead(flex);

delay(1); // delay in between reads for stability

if(sensorValue == 300){
if(counter == 0){
startTime = millis();
}

Serial.println(counter);
Serial.println(sensorValue);

counter = counter + 1;

delay(1000);

}

if(counter > 3){
analyze();
counter = 0;
}
}

void analyze(){
endTime = millis();
trainTime = endTime – startTime;
Serial.println(trainTime);

// IF YOU DID THE EXERCISES TOO FAST, GIVE TWO SHORT VIBRATIONS

if(trainTime <= 15000){
motor(500);
delay(1000);
motor(500);
Serial.println(“FLEEEXINOOOL”);

digitalWrite(flexinolA, HIGH);
delay(2000);
digitalWrite(flexinolA, LOW);

digitalWrite(flexinolC, HIGH);
delay(2000);
digitalWrite(flexinolC, LOW);
}

// IF YOU DID THE EXERCISES CORRECTLY, GIVE ONE LONG VIBRATION

if(trainTime > 15000 && trainTime < 25000){
motor(2000);
Serial.println(“FLEEEXINOOOL”);

digitalWrite(flexinolA, HIGH);
delay(2000);
digitalWrite(flexinolA, LOW);

digitalWrite(flexinolB, HIGH);
delay(2000);
digitalWrite(flexinolB, LOW);

digitalWrite(flexinolC, HIGH);
delay(2000);
digitalWrite(flexinolC, LOW);

digitalWrite(flexinolD, HIGH);
delay(2000);
digitalWrite(flexinolD, LOW);
}
// IF YOU DID THE EXERCISES TOO SLOWLY, GIVE TWO LONG VIBRATIONS
if(trainTime > 25000){
motor(2000);
delay(1000);
motor(2000);
Serial.println(“FLEEEXINOOOL”);

digitalWrite(flexinolC, HIGH);
delay(2000);
digitalWrite(flexinolC, LOW);

digitalWrite(flexinolD, HIGH);
delay(2000);
digitalWrite(flexinolD, LOW);
}

}

void motor(int valueLong) {
digitalWrite(vibration, HIGH);
delay(valueLong);
digitalWrite(vibration, LOW);
}

I made an obstacle avoiding rc car.

The sensor is mounted on the servo. For some reason when the servo is attached in the setup, the dc motors stop running, but the servo works and prints information to the console as it should.

here is simple version my code without the servo running-

int pinSpeaker=8;

float sinVal;
int toneVal;
unsigned long echo = 0;
int ultraSoundSignal = 7; // Ultrasound signal pin
unsigned long ultrasoundValue = 0;
#include <Servo.h> // Enables the Servo library
int pingPin = 7 ; // Ping sensor is connected to port A0
int centerDist, leftDist, rightDist, backDist; // Define variables center, left, right and back distance
long duration, inches, cm; // Define variables for Ping sensor

#include “MotorDriver.h”

#include “Servo.h”
Servo PingServo;
void setup()
{
Serial.begin(9600);

pinMode(pinSpeaker,OUTPUT);
pinMode(ultraSoundSignal,OUTPUT);
motordriver.init();
motordriver.setSpeed(110,MOTORA);
motordriver.setDirection(200,MOTORB);
// PingServo.attach(10); // Servo is attached to pin 10 in the motor shield
PingServo.write(90); // Center the Ping sensor (puts it at 90 degrees)
}

unsigned long ping(){
pinMode(ultraSoundSignal, OUTPUT); // Switch signalpin to output
digitalWrite(ultraSoundSignal, LOW); // Send low pulse
delayMicroseconds(2); // Wait for 2 microseconds
digitalWrite(ultraSoundSignal, HIGH); // Send high pulse
delayMicroseconds(5); // Wait for 5 microseconds
digitalWrite(ultraSoundSignal, LOW); // Holdoff
pinMode(ultraSoundSignal, INPUT); // Switch signalpin to input
digitalWrite(ultraSoundSignal, HIGH); // Turn on pullup resistor
// please note that pulseIn has a 1sec timeout, which may
// not be desirable. Depending on your sensor specs, you
// can likely bound the time like this — marcmerlin
// echo = pulseIn(ultraSoundSignal, HIGH, 38000)
echo = pulseIn(ultraSoundSignal, HIGH); //Listen for echo
ultrasoundValue = (echo / 58.138) * .39; //convert to CM then to inches
return ultrasoundValue;
}

void loop()
{

int x = 0;
x = ping();
Serial.println(x);
delay(250); //delay 1/4 seconds.

if (x >= 15){
motordriver.rotateWithID(MOTOR_CLOCKWISE, MOTORA);
}
else{
tone (8,100,76);
delay(105);
motordriver.rotateWithID(MOTOR_ANTICLOCKWISE, MOTORA);
motordriver.rotateWithID(MOTOR_CLOCKWISE, MOTORB);
delay(4000);

————————-

and here is the code that isn’t running with the servo-
#include “MotorDriver.h”
#include “Servo.h”// Enables the Servo library
Servo PingServo;

int minSafeDist = 11 ; // Minimum distance for ping sensor to know when to turn
int pingPin = 7 ;
int centerDist, leftDist, rightDist, backDist; // Define variables center, left, right and back distance
long duration, inches, cm; // Define variables for Ping sensor
void setup() {
Serial.begin(9600); // Enables Serial monitor for debugging purposes
Serial.println(“Serial test!”); // Test the Serial communication
PingServo.attach(3); // Servo is attached to pin 10 in the motor shield
PingServo.write(90); // Center the Ping sensor (puts it at 90 degrees)
motordriver.init();

motordriver.setSpeed(140,MOTORA);
motordriver.setDirection(200,MOTORB);
}

void loop()
{
LookAhead();
Serial.print(inches);
Serial.println(” inches”); // Prints a line in the serial monitor
if(inches >= minSafeDist) /* If the inches in front of an object is greater than or equal to the minimum safe distance (11 inches), react*/
{
motordriver.goForward();
delay(110); // Wait 0.11 seconds
}else // If not:

{
motordriver.stop(MOTORA);
motordriver.stop(MOTORB);
LookAround(); // Check your surroundings for best route
if(rightDist > leftDist) // If the right distance is greater than the left distance , turn right
{
motordriver.rotateWithID(MOTOR_CLOCKWISE, MOTORA);
motordriver.rotateWithID(MOTOR_CLOCKWISE, MOTORB);
}else if (leftDist > rightDist) // If the left distance is greater than the right distance , turn left
{
motordriver.rotateWithID(MOTOR_CLOCKWISE, MOTORA);
motordriver.rotateWithID(MOTOR_ANTICLOCKWISE, MOTORB);
}else if (leftDist&&rightDist<minSafeDist) // If the left and right distance is smaller than the min safe distance (11 inch) go back
{
motordriver.rotateWithID(MOTOR_ANTICLOCKWISE, MOTORA);
}
}
}

unsigned long ping() {
pinMode(pingPin, OUTPUT); // Make the Pingpin to output
digitalWrite(pingPin, LOW); //Send a low pulse
delayMicroseconds(2); // wait for two microseconds
digitalWrite(pingPin, HIGH); // Send a high pulse
delayMicroseconds(5); // wait for 5 micro seconds
digitalWrite(pingPin, LOW); // send a low pulse
pinMode(pingPin,INPUT); // switch the Pingpin to input
duration = pulseIn(pingPin, HIGH); //listen for echo

/*Convert micro seconds to Inches
————————————-*/

inches = microsecondsToInches(duration);
cm = microsecondsToCentimeters(duration);
}

long microsecondsToInches(long microseconds) // converts time to a distance
{
return microseconds / 74 / 2;
}
long microsecondsToCentimeters(long microseconds) // converts time to a distance
{
return microseconds / 29 / 2;
}

void LookAhead() {
PingServo.write(90);// angle to look forward
delay(175); // wait 0.175 seconds
ping();
}

void LookAround(){
PingServo.write(180); // 180° angle
delay(320); // wait 0.32 seconds
ping();
rightDist = inches; //get the right distance
PingServo.write(0); // look to the other side
delay(620); // wait 0.62 seconds
ping();
leftDist = inches; // get the left distance
PingServo.write(90); // 90° angle
delay(275); // wait 0.275 seconds

// Prints a line in the serial monitor
Serial.print(“RightDist: “);
Serial.println(rightDist);
Serial.print(“LeftDist: “);
Serial.println(leftDist);
Serial.print(“CenterDist: “);
Serial.println(centerDist);
}