Final Documentation: Poison Protector

Intro

Poison Protector™ detects dangerous gasses in your home and notifies the occupants of your house when such a threat detected. Imagine you are sleeping far away from the kitchen and a CO leak is detected. Perhaps you are a heavy sleeper and the alarm from within the kitchen does not wake you. Poison Protector™ will, upon detection of a dangerous gas, traverse a predetermined path with an alarm. This path will pass all the rooms of the occupants and wake them up accordingly.

 

Block Diagram

As seen in the block diagram below, Poison Protector has 3 infrared sensors, 1 speaker, 1 CO detector, 1 methane detector, 1 Lithium batter, and 2 motors.

block diagram

 

Initial Sketches

Photo Mar 19, 5 54 24 PM

Photo Mar 19, 5 54 17 PM

Iteration 1 (Basic Structure)

Photo Mar 07, 4 19 45 PM

Iteration 2 (all parts working)

Photo Mar 18, 6 13 45 PM

Photo Mar 18, 6 13 29 PM

Iteration 3 (final prototype)

Photo Mar 18, 7 34 57 PM

Photo Mar 18, 7 34 54 PM

Finite State Machine

This finite state machine outlines the code that Poison Protector runs.  It has 3 basic states: default state, alert state, and end state.

fsm

Video of Final Prototype in Action

Video Mar 18, 7 35 49 PM

//motor pins
const int speedPin_M1 = 5;     //M1 Speed Control
const int speedPin_M2 = 6;     //M2 Speed Control
const int directionPin_M1 = 4;     //M1 Direction Control
const int directionPin_M2 = 7;     //M1 Direction Control

//gas pins
const int MQ4_AOUT = 0;
const int MQ7_AOUT = 1;

//infrared pins
const int INF1_AOUT = 2;
const int INF2_AOUT = 3;
const int INF3_AOUT = 4;

//speaker pin
const int SPEAKER_DIN = 3;

//limit ints
const int METHANE_LIMIT = 500;
const int CO_LIMIT = 500;
const int INF_LIMIT = 500;

//speed ints
const int lowSpeed = 60;
const int highSpeed = 100;

//vars for playing sound
int BassTab[]={1911,1702,1516,1431,1275,1136,1012};
int bassLen = 8;
int noteIndex = 0;
unsigned long lastPeriodStart = 0;
const int onDuration=1000;
const int periodDuration=1000;

//for driving
bool lastSeen; //true = right, false = left
bool startDrive = false;

//for stopping
int carStopCount = 0;
int numStops = 25;

//state maintinence
int STATE = 0;//0 = waiting, 1 = alert, 2 = wait for intervention

void setup(){
  Serial.begin(9600);     

  //for speaker
  pinMode(SPEAKER_DIN,OUTPUT);
  digitalWrite(SPEAKER_DIN,LOW);
}

void loop(){
  int methaneVal = analogRead(MQ4_AOUT);
  int coVal = analogRead(MQ7_AOUT);

  //waiting state
  if (STATE == 0) {
    if (methaneVal > METHANE_LIMIT || coVal > CO_LIMIT) {
      STATE = 1; //if gas hits a certain level, change state
    }  
  }

  //alert state
  else if (STATE == 1) {
    //read values
    int inf1Val = analogRead(INF1_AOUT);
    int inf2Val = analogRead(INF2_AOUT);
    int inf3Val = analogRead(INF3_AOUT);

    //check if at least one infrared sensor read the line
    bool didSense = setDirection(inf1Val, inf2Val, inf3Val);
    if (!didSense) {
      carStopCount++;
      if (carStopCount > numStops) {
        STATE = 2; //after a certain number of times of no reads, change state
      }
    }
    //if value read, reset stop count
    else {
      carStopCount = 0;
    }
    sound(); //play sound
  }

  //waiting alarm state
  else if (STATE == 2) {
    carStop(); //stop car
    sound(); // continue sound
  }
  
  delay(50);  
}

//return false if nothing sensed, true otherwise
bool setDirection(int right, int middle, int left) {
  //set bools for each sensor
  bool r,m,l;
  r = m = l = false;
  if (right > INF_LIMIT) r = true;
  if (left > INF_LIMIT) l = true;
  if (middle > INF_LIMIT) m = true;

  if (r && !l) {
    guideLeft();
  }
  else if (l && !r) {
    guideRight();
  }
  else if (!l && !r && !m) {
    return false;
  }
  else {
    guideStraight();
  }
  return true;
}

void guideRight() {
  carAdvance(highSpeed, lowSpeed);
}

void guideLeft() {
  carAdvance(lowSpeed, highSpeed);
}

void guideStraight() {
  carAdvance(highSpeed, highSpeed);
}

void sound(){
  if (millis() - lastPeriodStart >= periodDuration) {
    lastPeriodStart += periodDuration;
    tone(SPEAKER_DIN, BassTab[noteIndex], onDuration);
    noteIndex ++;
    if (noteIndex == bassLen) noteIndex = 0;
  }
}

void carStop(){                 //  Motor Stop
  digitalWrite(speedPin_M2,0); 
  digitalWrite(directionPin_M1,LOW);    
  digitalWrite(speedPin_M1,0);   
  digitalWrite(directionPin_M2,LOW);    
}   

void carBack(int leftSpeed,int rightSpeed){         //Move backward
  analogWrite (speedPin_M2,leftSpeed);              //PWM Speed Control
  digitalWrite(directionPin_M1,HIGH);    
  analogWrite (speedPin_M1,rightSpeed);    
  digitalWrite(directionPin_M2,HIGH);
} 

void carAdvance(int leftSpeed,int rightSpeed){       //Move forward
  analogWrite (speedPin_M2,leftSpeed);
  digitalWrite(directionPin_M1,LOW);   
  analogWrite (speedPin_M1,rightSpeed);    
  digitalWrite(directionPin_M2,LOW);
}

void carTurnLeft(int leftSpeed,int rightSpeed){      //Turn Left
  analogWrite (speedPin_M2,leftSpeed);
  digitalWrite(directionPin_M1,LOW);    
  analogWrite (speedPin_M1,rightSpeed);    
  digitalWrite(directionPin_M2,HIGH);
}
void carTurnRight(int leftSpeed,int rightSpeed){      //Turn Right
  analogWrite (speedPin_M2,leftSpeed);
  digitalWrite(directionPin_M1,HIGH);    
  analogWrite (speedPin_M1,rightSpeed);    
  digitalWrite(directionPin_M2,LOW);
}

Assignment 4a

timg-3I got inspiration for my drawing robot from a form of Chinese art called “Dishu” (地书). Artists use Chinese calligraphy brush pens and water, instead of ink, to write on the ground. I was really impressed when I saw a professor performed “Dishu” on the 8th floor last semester. Hence it became my initial incentive to build a robot that can draw. Based on my previous deliverables, I decided to use light sensors to control the direction of the robot and the ultrasonic sensor to prevent it from the obstacles. It will act accordingly to whatever information it get from those sensors.

TA&NL Final Documentation — Triangulord

Here is our final presentation of the robot, Triangulord.

TA&NL Robotics Final Presentation

Process Videos

Final Deliverable: “Drawbot”

Material list:

    • Arduino Uno *1
    • Plastic structure *4
    • Caster wheel *1
    • Rubber wheel *2
    • Motor *2
    • Cell box *1
    • Battery *5
    • Servo Motor *1
    • Switch button *1
    • Bread board *1
    • Light sensor *2
    • Ultrasonic sensor *1
    • Marker *1
    • White Board *1

Intro and Background Story:

I got inspiration for my drawing robot from a form of Chinese art called “Dishu” (地书). Artists use Chinese calligraphy brush pens and water, instead of ink, to write on the ground. I was really impressed when I saw a professor performed “Dishu” on the 8th floor last semester. Hence it became my initial incentive to build this robot that can draw. Based on my previous deliverables, I decided to use light sensors to control the direction of the robot and the ultrasonic sensor to prevent it from the obstacles. It is worth mentioning that my idea has been evolving since the beginning. For example, I have changed the main structure, the drawing tool, and even the pattern of drawing for several times. Finally, I ended up making a robot that was inconsistent with initial assumption. Yet I do not think this is necessarily a bad thing. In fact, under the help pf professor Rodolfo and other IMA fellows, I really enjoyed this process of constantly revising and polishing my robot. I am glad to see some self-improvement that came together with making the robot and I believe all the effort and time that I spent on this project is worth it.

Diagram:

In the process of revising the diagram, I was able to get a much deeper understanding of my robot as well as the logic hidden in it. It took me quite a lot of time testing and debugging, especially for the if conditions. Yet every time I found the mistake, I got a clearer image of how my robot would be working perfectly.WechatIMG5

Sketch:

Front view sketch 1 (below)

FullSizeRender 2

Front view sketch 2 (below)

WechatIMG7

Top view sketch 1 (below)

FullSizeRender

Top view sketch 2 (below)

WechatIMG6

Professor Rodolfo suggested that I should came up with a detailed, multi-dimensioned sketch before I started to make the robot. Hence, these sketches actually predated the initial form of the robot. And it works very well! Those sketches really helped me to make a blueprint for my project. My idea kept evolving since the beginning. Thus it was much easier for me to revise the sketch than making actual changes to the robot’s physical structure, as is shown in the uploaded pictures. My final design was a quadrate-shaped robot, with an extended rubber wheel on each side, and a caster ball in the front. Two big motors are attached to the rubber wheels so that the robot is strong enough to impel the marker to draw. The triangular-structure of three wheels also enables the robot to move freely. Above the caster ball is the breadboard, with a light sensor on each side. On the back side , I put the cell box and batteries there. The Arduino uno is on the upper layer of the batteries, attached with a servo motor. On the front side of the Arduino uno is the ultrasonic sensor.

 

Code1:

//This is the code that enables “Drawbot” to draw straight lines and circles according to order it receives.

#include <Ultrasonic.h>

int distance;

Ultrasonic ultrasonic(3);
const int speedPin_M1 = 5; //M1 Speed Control
const int speedPin_M2 = 6; //M2 Speed Control

const int directionPin_M1 = 4; //M1 Direction Control
const int directionPin_M2 = 7; //M2 Direction Control

const int LDR1 = A1; // Analog input pin that the potentiometer is attached to
const int LDR2 = A0; // Analog input pin that the potentiometer is attached to
int light1;
int light2;

#include <Servo.h>
Servo myservo; // create servo object to control a servo
// twelve servo objects can be created on most boards
int pos = 0; // variable to store the servo position

void setup()
{
Serial.begin(9600);
Serial.println(“start “);
myservo.attach(9); // attaches the servo on pin 9 to the servo object
}

/* the main loop is a test of the smooth function. It generates a simulated square wave and then
switches in four different smoothing values. Watch the numbers scroll by as the filter value
slows down the response. */

void loop() {
light1 = analogRead(LDR1); //left
Serial.print(“left:”);
Serial.println(light1);
light2 = analogRead(LDR2); //right
Serial.print(“right:”);
Serial.println(light2);
ultrasonic.MeasureInCentimeters();
distance = ultrasonic.RangeInCentimeters;
Serial.print(“distance:”);
Serial.println(distance);

if (distance < 15) {
carStop();
Serial.println(“Stopping…”);
}

else {
if (light1 > 900 || light2 > 900) {
if (light1 > light2) {
carTurnLeft( 70, 70);
Serial.println(“Turning left…”);}
else if (light1 < light2) {
carTurnRight( 70, 70);
Serial.println(“Turning right…”);}

} else {carAdvance( 100, 100);
Serial.println(“Going FWD…”);}
}

delay(500);

}

void carStop() { // Motor Stop
digitalWrite(speedPin_M2, 0);
digitalWrite(directionPin_M1, LOW);
digitalWrite(speedPin_M1, 0);
digitalWrite(directionPin_M2, LOW);
}

void carBack(int leftSpeed, int rightSpeed) { //Move backward
analogWrite (speedPin_M2, leftSpeed); //PWM Speed Control
digitalWrite(directionPin_M1, HIGH);
analogWrite (speedPin_M1, rightSpeed);
digitalWrite(directionPin_M2, HIGH);
}

void carAdvance(int leftSpeed, int rightSpeed) { //Move forward
analogWrite (speedPin_M2, leftSpeed);
digitalWrite(directionPin_M1, LOW);
analogWrite (speedPin_M1, rightSpeed);
digitalWrite(directionPin_M2, LOW);
}

void carTurnLeft(int leftSpeed, int rightSpeed) { //Turn Left
analogWrite (speedPin_M2, leftSpeed);
digitalWrite(directionPin_M1, LOW);
analogWrite (speedPin_M1, rightSpeed);
digitalWrite(directionPin_M2, HIGH);
}

void carTurnRight(int leftSpeed, int rightSpeed) { //Turn Right
analogWrite (speedPin_M2, leftSpeed);
digitalWrite(directionPin_M1, HIGH);
analogWrite (speedPin_M1, rightSpeed);
digitalWrite(directionPin_M2, LOW);
}

The Final Revision:

After showing the above-mentioned robot to Professor Rodolfo, he asked me to further think about the meaning of the project, for example, in what scenarios would people use it? What is the point of having a drawing robot instead of drawing ourselves? Those questions never came to me before so I started to think about them.  Then I thought of spirographe, a toy that I love to play when I was a kid. I began to think that, what if my “Drawbot” can draw more complicated patterns instead of lines and circles? Under the help of Jack Du, I started to revise my code. Below is the final code that I have for this project.

Final Code:

//This is the code that enables “Drawbot” to draw certain patterns. I can also change the pattern it draw by playing with the code.

#include <Ultrasonic.h>

int distance;

Ultrasonic ultrasonic(3);
const int speedPin_M1 = 5; //M1 Speed Control
const int speedPin_M2 = 6; //M2 Speed Control

const int directionPin_M1 = 4; //M1 Direction Control
const int directionPin_M2 = 7; //M2 Direction Control

const int LDR1 = A1; // Analog input pin that the potentiometer is attached to
const int LDR2 = A0; // Analog input pin that the potentiometer is attached to
int light1;
int light2;
int t;

#include <Servo.h>
Servo myservo; // create servo object to control a servo
// twelve servo objects can be created on most boards
int pos = 0; // variable to store the servo position

void setup()
{
Serial.begin(9600);
Serial.println(“start “);
myservo.attach(9); // attaches the servo on pin 9 to the servo object
t = 0;
}

void loop() {
light1 = analogRead(LDR1); //left
Serial.print(“left:”);
Serial.println(light1);
light2 = analogRead(LDR2); //right
Serial.print(“right:”);
Serial.println(light2);
ultrasonic.MeasureInCentimeters();
distance = ultrasonic.RangeInCentimeters;
Serial.print(“distance:”);
Serial.println(distance);
if (distance < 20) {
carStop();
Serial.println(“Stopping…”);
}
else {
if (light1 > 900 || light2 > 900) {
if (light1 > light2) {
carTurnRight( 200, 200);
Serial.println(“Turning right…”);}
else if (light1 < light2) {
carTurnLeft( 200, 200);
Serial.println(“Turning left…”);}

} else {
t=t+50;
carAdvance(100, 100);
delay(t);
carTurnLeft(100, 100);
delay(500);
Serial.println(“Going in pattern ↖(^ω^)↗ “);
}
}
}
void carStop() { // Motor Stop
digitalWrite(speedPin_M2, 0);
digitalWrite(directionPin_M1, LOW);
digitalWrite(speedPin_M1, 0);
digitalWrite(directionPin_M2, LOW);
}

void carBack(int leftSpeed, int rightSpeed) { //Move backward
analogWrite (speedPin_M2, leftSpeed); //PWM Speed Control
digitalWrite(directionPin_M1, HIGH);
analogWrite (speedPin_M1, rightSpeed);
digitalWrite(directionPin_M2, HIGH);
}

void carAdvance(int leftSpeed, int rightSpeed) { //Move forward
analogWrite (speedPin_M2, leftSpeed);
digitalWrite(directionPin_M1, LOW);
analogWrite (speedPin_M1, rightSpeed);
digitalWrite(directionPin_M2, LOW);
}

void carTurnLeft(int leftSpeed, int rightSpeed) { //Turn Left
analogWrite (speedPin_M2, leftSpeed);
digitalWrite(directionPin_M1, HIGH);
analogWrite (speedPin_M1, rightSpeed);
digitalWrite(directionPin_M2, LOW);
}

void carTurnRight(int leftSpeed, int rightSpeed) { //Turn Right
analogWrite (speedPin_M2, leftSpeed);
digitalWrite(directionPin_M1, LOW);
analogWrite (speedPin_M1, rightSpeed);
digitalWrite(directionPin_M2, HIGH);
}

void carGoPattern(int leftSpeed, int rightSpeed) { //Go in Pattern
analogWrite (speedPin_M2, leftSpeed);
digitalWrite(directionPin_M1, HIGH);
analogWrite (speedPin_M1, rightSpeed);
digitalWrite(directionPin_M2, LOW);
}

Sarabi: Robotics Deliverable 6 || Working Prototype and Refined Presentation

Introduction

My robot, whose name is Aggressive, is fundamentally an antisocial creature. I have so little space to call my own that I tend to be rather territorial of it, so my robot will “protect” it’s space. If left undisturbed, Aggressive “wanders” within the bounds of it’s area (demarcated by dark tape), but once it registers someone within that space, Aggressive will chase the intruder away. In a way, the robot is something like a guard dog. It protects its home. If given someone to take care of (i.e. Shanelle’s Passive), then Aggressive will take care of its space while also looking out for the well being of Passive. IR reflective sensors help Aggressive sense when it has reached the boundaries of its home, while ultrasonic range sensors detect when an intruder arrives. Communication between Passive and Aggressive will be wireless. Arms, made with servo motors, help “scare” the intruder away.

Parts

4 Ultrasonic range finders,1 IR reflective sensor, 2 servo motors, 4 wheels, metal chassis, MDF body, cardboard arms,  tons of wires, 5 AA Batteries, breadboard, glue, drill, screws

Circuit Diagram

IMG_20170319_232705_HDR

Finite State MachineIMG_20170319_232644_HDR

#include <Ultrasonic.h>

Ultrasonic Front(3); //UR sig pin (echo/nc is on 4)
int FDistance = analogRead(4);

const int analogInPin = A0;  // Analog input pin that the potentiometer is attached to
const int analogOutPin = 12; // Analog output pin that the LED is attached to
int sensorValue = 0;        // value read from the pot
int outputValue = 0;        // value output to the PWM (analog out)


int speedPin_M1 = 5;     //M1 Speed Control
int speedPin_M2 = 6;     //M2 Speed Control
int directionPin_M1 = 4;     //M1 Direction Control
int directionPin_M2 = 7;     //M1 Direction Control

void setup() {
  Serial.begin(9600);
}

void loop() {
  long FDistance;
  FDistance = Front.MeasureInCentimeters();

  switch (FDistance) {
    case 1: //intruder
      if (FDistance < 200) { //Fdistance = distance from front sensor
        carAdvance(100, 100);
      }
      break;
    case empty:
      if (FDistance > 200) {
        carWander();
      }
      break;
    case boundary: {
        sensorValue = analogRead(analogInPin);
        analogWrite(analogOutPin, outputValue);

        if (analogRead(A0) < 200) {
          Serial.println("clear");
          carAdvance(250, 250);
        } else if (analogRead(A0) > 200) {
          Serial.println("OUT OF BOUNDS");
          carStop();
          delay(10);
          carBack(100, 100);
          delay(1000);
          carTurnLeft(100, 100);
          delay(1000);
          carAdvance(250, 250);
        }
      }
      break;
    default: carWander();
  }

  void carSee() {
    // two measurements should keep an interval
    long RangeInCentimeters;
    RangeInCentimeters = Front.MeasureInCentimeters(); // two measurements should keep an interval
    Serial.print(RangeInCentimeters);//0~400cm
    Serial.println(" cm");
    delay(250);

    analogWrite(analogOutPin, outputValue);

    if (analogRead(IRAnalog) < 200) {
      Serial.println("clear");
    }


  }

  void carStop() {                //  Motor Stop
    digitalWrite(speedPin_M2, 0);
    digitalWrite(directionPin_M1, LOW);
    digitalWrite(speedPin_M1, 0);
    digitalWrite(directionPin_M2, LOW);
  }
  void carBack(int leftSpeed, int rightSpeed) {       //Move backward
    analogWrite (speedPin_M2, leftSpeed);             //PWM Speed Control
    digitalWrite(directionPin_M1, HIGH);
    analogWrite (speedPin_M1, rightSpeed);
    digitalWrite(directionPin_M2, HIGH);
  }
  void carAdvance(int leftSpeed, int rightSpeed) {     //Move forward
    analogWrite (speedPin_M2, leftSpeed);
    digitalWrite(directionPin_M1, LOW);
    analogWrite (speedPin_M1, rightSpeed);
    digitalWrite(directionPin_M2, LOW);
  }
  void carTurnLeft(int leftSpeed, int rightSpeed) {    //Turn Left
    analogWrite (speedPin_M2, leftSpeed);
    digitalWrite(directionPin_M1, LOW);
    analogWrite (speedPin_M1, rightSpeed);
    digitalWrite(directionPin_M2, HIGH);
  }
  void carTurnRight(int leftSpeed, int rightSpeed) {    //Turn Right
    analogWrite (speedPin_M2, leftSpeed);
    digitalWrite(directionPin_M1, HIGH);
    analogWrite (speedPin_M1, rightSpeed);
    digitalWrite(directionPin_M2, LOW);
  }

  void carWander() {

    carAdvance(250, 250);
    delay(2000);
    carTurnLeft(250, 250);
    delay(1000);
    carAdvance(250, 250);
    delay(2000);
    carTurnRight(250, 250);
    delay(1000);

  }

  void carChase() {
    carAdvance(100, 100);
    delay(50);
    unsigned int uS = sonar.ping_cm();
  }


IR: Deliverable 5 – TA & NL

Materials:

  • 3   –  Ultrasonic Rangefinder
  • 6   –  Light-Dependant Resistor
  • 12 – LEDs
  • 3   – Encoder Motors
  • 3   – Omniwheels
  • 1   – 7.9V Lithium Ion Battery
  • 3   – 3V Coin Batteries
  • 3   – NPN Transistors
  • 1   – DFRduino Romeo
  • 1   – Motordriver board
  • X   – Structural materials (laser-cut frame, screws and nuts, 3D-printed braces, etc.)

Story of Triangulord the Partybot:

Triangulord, so named for his triangular shape, loves to dance.  However, he only likes to dance in the dark, so he will seek out dark places before dancing.  When he finds a suitably dark location, he lights up and starts dancing.  Of course, Triangulord doesn’t want to bump into anything while he’s dancing or looking for a dark place, so he’ll avoid any object that gets too close.

Control System:

IMG_3628

Signal Processing:

/*
  HC-SR04 Ping distance sensor:
  VCC to arduino 5v
  GND to arduino GND
  Echo to Arduino pin 9
  Trig to Arduino pin 8*/
#define echopin1 9 // echo pin
#define trigpin1 8 // Trigger pin
#define echopin2 6 // echo pin
#define trigpin2 7 // Trigger pin


long duration1, distance1, duration2, distance2;

void setup() {
  Serial.begin (9600);
  pinMode (trigpin1, OUTPUT);
  pinMode (echopin1, INPUT );
  
  pinMode (trigpin2, OUTPUT);
  pinMode (echopin2, INPUT );
  pinMode (4, OUTPUT);
  pinMode (13, OUTPUT);
}
void loop ()
{

  digitalWrite(trigpin1, LOW);
  digitalWrite(trigpin2, LOW);
  delayMicroseconds(2);
  digitalWrite(trigpin1, HIGH);
  digitalWrite(trigpin2, HIGH);
  delayMicroseconds(10);
  duration1 = pulseIn (echopin1, HIGH);
  duration2 = pulseIn (echopin2, HIGH);
  distance1 = duration1 / 28.2;
  distance2 = duration2 / 28.2;
  delay (50);
  Serial.println(distance1);
  Serial.println(distance2);
  Serial.println(analogRead(A0));
  Serial.println(analogRead(A1));
  Serial.println();


    Serial.println(distance);
    if (distance >= 25 ) {
      digitalWrite (4, HIGH);
      digitalWrite (13, HIGH);
    }
    else if (distance <= 10) {
      digitalWrite (4, LOW);
      digitalWrite (13, LOW);
    }
}

Assignment 6: The Waseda Flutist Robot

This article focuses on the development of a robot that can play flute at Waseda University. The so-called flutist robot WF-4RII is the seventh iteration of flute-playing robots at the university. The WF-4RII attempts to emulate all the human organs involved with playing the flute, and the article goes into detail about the technical and mechanical components that enable the robot. While this description was interesting, I found the motivation behind this robot far more powerful.

The researchers hope to further their understanding of what goes into musical expression and “intuition”. The WF-4RII takes into account its own and previous human data when it plays. This makes sense to emulate how humans play, but does not necessarily create the same emotional response. The authors mention that they may explore neural networks in the future. Given the developments in convolutional networks and reinforcement learning in the recent years, I think there’s high application potential for the flutist robot. Furthermore, using these techniques will potentially allow the researchers further understanding, depending on the emergent characteristics that the robot undertakes.

IR: Response to Computer, Robot, Sheep Dog – TA

This is a response to the article The Computer, the Robot, and the Sheep Dog.

Although this article was a bit too enthusiastic regarding popular adoption of robots into everyday life, it raised some interesting considerations about the future of intelligent robots.  The more straightforward consideration was a comparison between animals and plants which humans have bred to perform certain tasks.  This is not much different from the process of making robots, and reconciling the two may give us a more holisitic system of design and ethics.  I agree a lot with this idea, and I’ve written about it in previous responses, so I’ll say no more here.  The second interesting consideration is a consideration of the role intelligent robots will play when integrated into human society.  Will they replace the people in our lives, the same way industrial robots replaced human workers in the workplace?  I tend to think they would, to a certain extent.  For example, I generally play video games against an AI opponent because my artificial adversary is always available, even when my human friends are not.  But this is more of the compliant “appliance” kind of robot mentioned in the article, which never objects to the wishes of its master, unlike a truly intelligent robot which may say “No!”.  If it came to intelligent robots that acted much like humans, I would personally prefer to be around the humans, because humans cannot change and evolve at the incomprehensible rates at which robots can.  In other words, between a robot and a human of similar intelligence, I think the human would be much safer to be around.

The final consideration, which I found the most interesting, is that tools (e.g. robots) shape their users as much as the users shape them.  Although almost every tool is, by definition, shaped by humans to perform a specific task, the use of that tool also inluences how the user behaves.  While the article’s example of a shepherd adapting to the actions of his sheep dog, this phenomenon is much more visible with electronic technology.  The internet in particular has fundamentally changed human interaction.  With robots bringing the digital revolution into the physical world, it isn’t hard to imagine how life for humans will change.  When robots, rather than humans, are transporting goods and people around the world, are performing dangerous tasks like mining and exploration, and are handling most of the production and waste of human society, there might be a fundamental shift toward a post-scarcity economy.  With the intelligent robots mentioned in this article that can perform even very complicated tasks, such as surgery and business management, humans might eventually devote their entire lives to creative pursuits.