Roles: Becca Epstein as Tutor, Becca Wolfinger as Scribe/Integrator, Zade Delgros as Designer

Introduction

For this iteration, we were focused on getting more interesting behavior out of our autonomous robots “Ella and Chase”. To achieve this, we thought hard about what kind of personalities we wanted to embed in these robots. Our thought was to give each robot its own culture. Our goal in this piece was to illustrate the innate similarity between people as human beings despite the different ways we all perceive the world. To display these perceptual differences, we gave each arm a difference sensing mechanism. One arm looked out into its environment to control its direction. We made the other arm much more introspective by programming it to use its own acceleration and timing mechanisms in order to make decisions about its speed, direction, and the sounds it made.

In addition to the illustration of this concept, we also rethought the design of the cars. We wanted to make the circuity cleaner and more compact. This proved to be quite difficult because we added several components and planned to pack them all into a much smaller space. We used the clear acrylic to expose the hardware of the robots and highlight that innate metaphorical similarity between people despite differences in culture or perception.

Video

Technical Notes

Arm 1:

Our circuit consisted of an arduino nano, a drv883 h-bridge, a motor, 2 proximity sensors, a 5V step-up, a switch, a speaker, and a 3.3-volt Lipo battery. The switch and battery powered the entirety of the circuit, and the step-up stepped the battery up to a useable 5-volts. The proximity sensors were connected to analog pins 1 and 3 to send the arduino specific distances. The arduino was connected by pins 5 and 6 to the h-bridge to send logic to the motor to have it switch directions when the proximity sensor gave values after a specific threshold that would allow it to switch states from forwards to backwards. The speaker was connected to pin 8 to change the pitch.

Arm 2:

Our circuit consisted of an arduino nano, a drv883 h-bridge, a motor, a ADXL345 accelerometer, 5V step-up, a switch, a speaker, and 2 3.3-vold Lipo battery. The switch and battery powered the entirety of the arduino circuit, and the step-up stepped the battery up to a useable 5-volts while the other Lipo battery powered the H-bridge. The accelerometer was connected to digital pins 10-13 to send the arduino specific velocities. The arduino was connected by pins 5 and 6 to the h-bridge to send logic to the motor to have it switch directions , and by pin 8 to the speaker to change pitch, when the acceleromoter gave values after a specific threshold.

Photos

Autonomous robot overall view

Robot in motion

Robot with close up of moving part

proximity sensor left side

proximity sensor right side

Acceleration sensor

schematic for extroverted device

schematic for introverteddevice

Code

Introverted

//from https://www.sparkfun.com/tutorials/240

/*
* Introverted Arm
*/

//Add the SPI library so we can communicate with the ADXL345 sensor
#include
#include
#define MOTOR1A 5
#define MOTOR1B 6
//Assign the Chip Select signal to pin 10.
int CS=10;

//This is a list of some of the registers available on the ADXL345.
//To learn more about these and the rest of the registers on the ADXL345, read the datasheet!
char POWER_CTL = 0x2D; //Power Control Register
char DATA_FORMAT = 0x31;
char DATAX0 = 0x32; //X-Axis Data 0
char DATAX1 = 0x33; //X-Axis Data 1
char DATAY0 = 0x34; //Y-Axis Data 0
char DATAY1 = 0x35; //Y-Axis Data 1
char DATAZ0 = 0x36; //Z-Axis Data 0
char DATAZ1 = 0x37; //Z-Axis Data 1

//This buffer will hold values read from the ADXL345 registers.
char values[10];
//These variables will be used to hold the x,y and z axis accelerometer values.
int x,y,z;
int initx,inity,initz;

const int numReadings = 20; //length of smoothing array

int minPitch = 220;
int maxPitch = 1400;
int readings[numReadings]; //create array for smoothing
int index = 0;
int total = 0;
int average = 0;
int pitch = 220;
int stay = 10;
int checkCount= random(50, 100); //Randomize acceleration threshold for interesting behavior
int avgDist = 0;
boolean forward = true;

void setup(){
//Initiate an SPI communication instance.
SPI.begin();
//Configure the SPI connection for the ADXL345.
SPI.setDataMode(SPI_MODE3);
//Create a serial connection to display the data on the terminal.
Serial.begin(9600);
pinMode(MOTOR1A, OUTPUT);
pinMode(MOTOR1B, OUTPUT);
//Set up the Chip Select pin to be an output from the Arduino.
pinMode(CS, OUTPUT);
//Before communication starts, the Chip Select pin needs to be set high.
digitalWrite(CS, HIGH);

//Put the ADXL345 into +/- 4G range by writing the value 0x01 to the DATA_FORMAT register.
writeRegister(DATA_FORMAT, 0x01);
//Put the ADXL345 into Measurement Mode by writing 0x08 to the POWER_CTL register.
writeRegister(POWER_CTL, 0x08); //Measurement mode

for (int thisReading = 0; thisReading < numReadings; thisReading++)
readings[thisReading] = 0;

//base readings for difference
//Reading 6 bytes of data starting at register DATAX0 will retrieve the x,y and z acceleration values from the ADXL345.
//The results of the read operation will get stored to the values[] buffer.
readRegister(DATAX0, 6, values);

//The ADXL345 gives 10-bit acceleration values, but they are stored as bytes (8-bits). To get the full value, two bytes must be combined for each axis.
//The X value is stored in values[0] and values[1].
initx = ((int)values[1]<<8)|(int)values[0];
//The Y value is stored in values[2] and values[3].
inity = ((int)values[3]<<8)|(int)values[2];
//The Z value is stored in values[4] and values[5].
initz = ((int)values[5]<<8)|(int)values[4];
}

void loop(){

start:
Serial.println(“Entering start state.”);

analogWrite(MOTOR1B, 255-stay);
digitalWrite(MOTOR1A, HIGH);
callLoop();
if(stay < 250){ stay = stay+ 10; } if(stay > 250){
stay = 250;
}
tone(4, pitch);

if (avgDist > checkCount) {
pitch = 220;
stay = 10;
checkCount= random(50, 100);
goto state1;
}
else{
if(pitch < 880){
pitch ++;
}
goto start;
}

state1:
Serial.println(“Entering state 1.”);

analogWrite(MOTOR1A, 255 – stay);
digitalWrite(MOTOR1B, HIGH);
callLoop();
tone(4, pitch);
if(stay < 250){ stay = stay+10; } if(stay > 250){
stay = 250;
}
if (avgDist> checkCount) {
stay = 10;
pitch = 220;
checkCount= random(50, 100);
goto start;
}
else{
if(pitch < 880){ pitch ++; } goto state1; } delay (50); } //This function will write a value to a register on the ADXL345. //Parameters: // char registerAddress – The register to write a value to // char value – The value to be written to the specified register. void writeRegister(char registerAddress, char value){ //Set Chip Select pin low to signal the beginning of an SPI packet. digitalWrite(CS, LOW); //Transfer the register address over SPI. SPI.transfer(registerAddress); //Transfer the desired register value over SPI. SPI.transfer(value); //Set the Chip Select pin high to signal the end of an SPI packet. digitalWrite(CS, HIGH); } //This function will read a certain number of registers starting from a specified address and store their values in a buffer. //Parameters: // char registerAddress – The register address to start the read sequence from. // int numBytes – The number of registers that should be read. // char * values – A pointer to a buffer where the results of the operation should be stored. void readRegister(char registerAddress, int numBytes, char * values){ //Since we’re performing a read operation, the most significant bit of the register address should be set. char address = 0x80 | registerAddress; //If we’re doing a multi-byte read, bit 6 needs to be set as well. if(numBytes > 1)address = address | 0x40;

//Set the Chip select pin low to start an SPI packet.
digitalWrite(CS, LOW);
//Transfer the starting register address that needs to be read.
SPI.transfer(address);
//Continue to read registers until we’ve read the number specified, storing the results to the input buffer.
for(int i=0; i<numBytes; i++){
values[i] = SPI.transfer(0x00);
}
//Set the Chips Select pin high to end the SPI packet.
digitalWrite(CS, HIGH);
}

int callLoop(){
//Reading 6 bytes of data starting at register DATAX0 will retrieve the x,y and z acceleration values from the ADXL345.
//The results of the read operation will get stored to the values[] buffer.
readRegister(DATAX0, 6, values);

//The ADXL345 gives 10-bit acceleration values, but they are stored as bytes (8-bits). To get the full value, two bytes must be combined for each axis.
//The X value is stored in values[0] and values[1].
x = ((int)values[1]<<8)|(int)values[0];
//The Y value is stored in values[2] and values[3].
y = ((int)values[3]<<8)|(int)values[2];
//The Z value is stored in values[4] and values[5].
z = ((int)values[5]<<8)|(int)values[4]; avgDist = (initx – x)^2 + (inity – y)^2; //Print the results to the terminal. Serial.print(“x= “); Serial.print( x, DEC); Serial.print(‘,’); Serial.print(“y= “); Serial.print( y, DEC); Serial.print(‘,’); Serial.println(z, DEC); Serial.println(avgDist); total = total – readings[index]; readings[index] = avgDist; total= total + readings[index]; index = index + 1; if (index >= numReadings)
index = 0;
average = total / numReadings;

return average;
}

extroverted

#include <toneAC.h>

/*
The Extroverted Arm

*/
#define MOTOR1A 5
#define MOTOR1B 6

const int numReadings = 20; //length of smoothing array

int readings[numReadings]; //create array for smoothing
int index = 0;
int total = 0;
int average = 0;

int proxInputPin = A1; //proximity sensor
int proxInputPin2 = A3; //proximity sensor

int minDistance = 20; //objects are far away
int maxDistance = 680; //objects are close
int minPitch = 220;
int maxPitch = 1400;

boolean forward = true;
int stay = 10;

void setup() {
Serial.begin(9600);
for (int thisReading = 0; thisReading < numReadings; thisReading++)
readings[thisReading] = 0;
}

int scaleValues(int valIn, int minIn, int maxIn, int minOut, int maxOut) { //scale in range to out range
int inRange = (maxIn – minIn);
int outRange = (maxOut – minOut);
float scale = (valIn – minIn) / (float)inRange;
return (minOut + (scale * outRange));

}

int mapSerialToPitch(int sv) {
if (sv < minDistance) {
return minPitch; }
else if (sv > maxDistance) {
return maxPitch; }
else {
return ((sv – minDistance) + minPitch); }
}

void loop() {

start:
Serial.println(“Entering start state.”);
total = total – readings[index];
readings[index] = analogRead(proxInputPin2);

total= total + readings[index];
index = index + 1;
if (index >= numReadings)
index = 0;
average = total / numReadings;
int pitch = scaleValues(average, minDistance, maxDistance, minPitch, maxPitch);
mapSerialToPitch(average);
Serial.println(pitch);
tone(8, pitch);
forward = checkDirection(analogRead(proxInputPin2), true);

analogWrite(MOTOR1B, 255-stay);
digitalWrite(MOTOR1A, HIGH);

if(stay < 250){
stay = stay+50;
}
if(stay > 250){
stay = 250;
}
if (forward) {
goto state1;
}
else goto start;

state1:
Serial.println(“Entering state 1.”);
total = total – readings[index];
readings[index] = analogRead(proxInputPin);

total= total + readings[index];
index = index + 1;
if (index >= numReadings)
index = 0;
average = total / numReadings;
pitch = scaleValues(average, minDistance, maxDistance, minPitch, maxPitch);
mapSerialToPitch(average);
tone(8, pitch);
forward = checkDirection(analogRead(proxInputPin), false);

analogWrite(MOTOR1A, 255-stay);
digitalWrite(MOTOR1B, HIGH);
if(stay < 250){
stay = stay+50;
}
if(stay > 250){
stay = 250;
}
if (forward) {
goto start;
}
else goto state1;
}

boolean checkDirection(int average, boolean direct ){
if(average > 550){
return true;
}
else{
return false;
}
}

Roles: Becca Epstein as Tutor, Becca Wolfinger as Scribe/Integrator, Zade Delgros as Designer

Introduction

We have created two autonomous robots that share a common pivot to which they are constrained. They rotate about this central point and are therefore forced to come into contact with one another. When they get close to one another, each robot reacts in a different way. One will completely stop and then start to chase the other. When the other robot gets too close to its counterpart, it lashes in the other direction. These behaviors get interesting when a robot runs away from the other, it eventually runs back into it since they are both constrained around this central pivot.

Why We Did This

It would have been easy to have both robots controlled from the same micro controller. We decided not to take this short cut because we wanted each robot to have its own autonomy. We chose compact circuity and housing so that all of the electronic components could fit on the narrow arm of each robot. The clear acrylic bodies of the robots lets us observe the autonomy and independence of the two robots. As such, we programmed each robot’s “brain” (Arduino Nano) with different speed, acceleration, and response parameters. These parameters serve as personality traits for the robots’ behavior. Their current behavioral goal is to not come into direct contact with one another. Each robot has its own way of achieving this goal. What makes it interesting is the fact that they are frequently forced to come into contact, which perpetuates the cycle but in a way that is slightly different each time they come into close contact.

Video

Technical Notes

Photos

Autonomous Robot: Part Two – Top View

Autonomous Robot: Part Two – In motion shot

Autonomous Robot: Part Two – In motion shot continued

Autonomous Robot: Part Two – detail shot

Autonomous Robot: Part Two – side view of chaser

Autonomous Robot: Part Two – Close up of pivot structure

Autonomous Robot – Fritzing Circuit

Code

A sample of our code. Some of the numbers were tweaked in order to have the cars demonstrate different behavior.

#define MOTOR1A 5
#define MOTOR1B 6
#include

DistanceGP2Y0A21YK Dist;
int distance;

void setup()
{

Dist.begin(A2);
pinMode(MOTOR1A, OUTPUT);
pinMode(MOTOR1B, OUTPUT);
Serial.begin(9600);
}

void loop()
{
/*
PWM 0 Forward PWM, fast decay
1 PWM Forward PWM, slow decay
0 PWM Reverse PWM, fast decay
PWM 1 Reverse PWM, slow decay
*/
distance = Dist.getDistanceRaw();
int sensorValue = analogRead(A3);
if((sensorValue > 300)){
analogWrite(MOTOR1A, 50);
digitalWrite(MOTOR1B, HIGH);
delay(50);
}else {
analogWrite(MOTOR1B, 255-stay);
digitalWrite(MOTOR1A, HIGH);

if(stay < 250){ stay = stay+50; } if(stay > 250){
stay = 250;
}
}
delay(500); //make it readable
}

Roles: Alex Wang as Tutor, Ashley Lai as Tutor, Zade Delgros as Integrator, Becca Epstein as designer, Wole Idowu as scribe

Introduction

Recently there has been a rush of confidentiality breaches including Snowden, celebrity nudes, and Home Depot credit card information. We decided to toy with this idea of lost confidentiality by corrupting an official survey. We want each person to have a strong reaction to this loss so we chose extremely intimate questions of varying topics.  The experience of this installation is of walking up, seeing an official CMU survey, and then having to decide whether or not to broadcast your most personal doings to the random passerby. One side of a hallway has questions with big buttons that lead you forward,, while the other has the questions listed again, and LED lit signs saying yes or no. The observer would have to be paying close attention to figure out which of your answers goes to which question. The wished for outcome of this piece is to cause the participant to have an emotional crisis and to bewitch the observer.

Video

Technical Notes

Our survey works with a series of buttons that represent the choices for the yes/no questions we ask. There are five questions in total so ten buttons. Each button houses both a momentary switch as well as an LED. The LEDs light up two at a time depending on what question you are on. If you are on question one, the yes and no buttons will be illuminated until an answer is selected when the selections for the next question will then be lit up. We did this by connecting the LEDs in parallel and having them take an output from their respective momentary switch. Pressing the switch tells our Arduino’s code to loop through an array of length five which correspond to the questions. We connected 10 kilohm resistors to each of our buttons which helps to control the unstable noise that can occur when taking a sensitive input from a momentary switch. Answers to the survey questions are also coded to be yes or no. When an answer is selected, the Arduino sends an output to a 9-volt step-up regulator and then to one of two LED strips, illuminating either yes or no to display the user’s answer.

Photos

1B- Arduino- Full View

1B- Arduino- Official Sign

1B- Arduino- Start

1B- Arduino- Buttons

1B- Arduino- Button Close

1B- Arduino- Answer Side

1B- Arduino- No Close

1B-Arduino-Wires

1B- Arduino- Wires Close

1B- Arduino- Schematic

To be added

Roles: Maggie Burke  as Designer, Becca Epstein as Integrator/Scribe, Marc-Daniel  Julien as Tutor

Introduction

This story begins with a client. A well off lady who has a bit of an issue: She has difficulty interacting actively in society. We have created a device to better allow her to go to balls and parties looking as beautiful as ever while feeling more comfortable.

This device is in the form of an intricate mask to reflect the lady’s beauty. When there is not sufficient commotion and stimulus from conversation or the party in general, she is reminded to be present by flashing red lights and a soft buzzing within the mask. When the stimulus is at an acceptable level, blue lights stay on steadily and the mask is still

Video

Technical Notes

The circuit was designed to invert the input. The sound detector drives the gate of the first transistor. The drain of the second transistor is the inverted output which drives the gate of the second transistor. The second transistor is used to activate the actuators in the mask.

There are two layers to the mask both made of plaster coated cardboard and shaped with a dremmel. The masks are connected by 3/16 inch bolts and washers. The interior is coated with white faux fur, and in the middle is where the electronics lie. The exterior has RGB LEDs embedded and a covering of embroidered lace.

Photos

Social Mask – Far Away Calm

Social Mask – Two States

Social Mask – Side View

Social Mask – Detail of Mask

Social Mask – In Progress Shots

Social Mask – Inner Lining

Social Mask – Electronics

Social Mask – Circuit Diagram