Published April 16, 2018

Pelops' Hand

Using Wi-Fi and myoelectric technology, Pelop's Hand was designed as a low-cost prosthetic concept to emulate the squeezing of one's hand.

IntermediateFull instructions provided20 hours2,035

Things used in this project

Hardware components

Particle Photon

Dental floss

Acted as Finger Ligaments

Servos (Tower Pro MG996R)

Prosthetic 'Muscle'

2x4 Wood

made up our arm, and the palm

tongue depressor

cut into thirds, each third composed a third of a finger

duct tape

used to bridge the finger segments

Adafruit MyoWare Muscle sensor

Breadboard (generic)

Jumper wires (generic)

AA Batteries

4xAA battery holder

Plastic straws

connected "ligaments" (dental floss) to fingers (tounge depressors)

USB-A to Micro-USB Cable

electodes

EMG sensor component

Software apps and online services

Particle Pi

ThingSpeak API

Hand tools and fabrication machines

Hot glue gun (generic)

Drill

Soldering iron (generic)

Story

Using Wi-Fi and myoelectric technology, Pelops' Hand was designed as a low-cost prosthetic concept to emulate the squeezing of one's hand.

1: The Photon

Functioning as both the microprocessor and the WiFI communication device, the two Particle Photons used were the keystone to this project. One Photon collected muscle activity and transmitted the relevant data to our second Photon, which would in return move the arm. This communication was all done through the Particles online cloud. When the sensor Photon activity reached a certain threshold (usually 2500, but variance depended greatly on placement of the sensor components) it would publish the activity on the cloud. The muscle Photon would then react to this published activity and send a signal to the servo motors. This was all accomplished using the publish and subscribe functions in the Particle IDE and can be seen in the code below.

2: EMG sensor

Electromyography is the measurement of nerve activity associated with muscles. Whenever you contract or relax your muscles, the nerves that control them use electrical signals to do so. By using disposable adhesives electrodes, a prosthetic can react to nerve stimuli just as the rest of our appendages do. We decided to use a MyoWare EMG sensor after a few test runs with a homemade sensor showed erratic and inconsistent data. The MyoWare sensor has three tabs for electrodes to attach too. Two being for direct measurement of voltage across the muscle, and the third acted as ground reference.

We observed the most accurate data when the two main electrodes are on the muscle, and the reference electrode was far from the other electrodes, as seen below.

Sensor placement

The MyoWare sensor was connected to our photon at three pins, Vin, GND, and the signal pin A0. (If unclear see circuit diagram)

3: Prosthetic

Consisting mostly of Wood and duct tape, the mechanical hand we designed is pretty rudimentary. The fingers are cut up tongue depressors connected by duct tape to provide resistance so that the fingers return to their natural state when unprovoked. Along the fingers cut up plastic straws were glued on. Dental floss was then wired thru each of them, with one end being tied up at the ends of the fingers, and the other end connected to two servo motors along the prosthetic's forearm. the dental floss acts as the tendons in our own fingers, when the servo motors are turned they pull the strings, and with them the fingers.

4: Results

As we were testing the prosthetic we actually fried out a Photon trying to power the servo motors with the Vin pin. To work around this we actually powered the servomotors with external batteries, but still used a Photon to control them. (If unclear see circuit diagram)

An example of Pelop's hand in action, is shown below:

Using https://thingspeak.com/ and the integration capacity already embedded in the particle cloud, we can observe the servomotor response to the EMG sensor in graph form.

Figure 1: EMG sensor response

Figure 2: Servomotor response

As you can see the servomotor response to the EMG sensor was not instantaneous. The servo response came after a lag usually lasting less than a couple seconds. One reason for this could be a cluttered and redundant code used in the servo Photon. Links to these ThingSpeak Pages are below.

https://thingspeak.com/channels/477962

https://thingspeak.com/channels/477946

I hope you find this project interesting. If you have any questions or concerns please feel free to email us at Pierrefenrick@gmail.com

Code

#include "lib1.h"
const String key = "A5AFV9NYTTZV7GKS";

int servo1 = A5;  // registers variable to PIN
int servo2 = A4;
int led= D7;
int movement;


void setup() {
                            
   pinMode(servo1,OUTPUT);       //define output type
    pinMode(servo2,OUTPUT); 
    pinMode(led, OUTPUT);

 
    Particle.subscribe("start",servomoto);          // listen to cloud for sensor trigger
    Particle.function("move",move);  
                                                    // function to play with servoposition
    Particle.variable("movement",  &movement, INT);    // used to define cloud variable, read out later

}


void loop() {
         Particle.publish("thingSpeakWrite_", "{ \"1\": \"" + String(movement) + "\"," + "\"k\": \"" + key + "\" }", PRIVATE); // Publishes activity  to ThingSpeak
     
delay(1000);
}

 void servomoto(const char *event, const char *data)      // probably wrong, trying to read sensor photon, and react accordingly,

{ 
    movement=1;
    analogWrite(servo1,212);     //can use low or high with analog write, if not have the servo value enough to hold tension in wire
     analogWrite(servo2,212); 
     digitalWrite(led, HIGH);
     Particle.publish("thingSpeakWrite_", "{ \"1\": \"" + String(movement) + "\"," + "\"k\": \"" + key + "\" }", PRIVATE); // Publishes activity  to ThingSpeak
     
delay(1000);

        analogWrite(servo1,01);
         analogWrite(servo2,01);
         digitalWrite(led, LOW);
delay(7500);
         movement=0;
     
         
}


int move(String command) {

    if (command=="30") {
        analogWrite(servo1,43);
         analogWrite(servo2,43);
        
        delay(1000);
        analogWrite(servo1,1);
        analogWrite(servo2,1);
        delay(1000);
        analogWrite(servo1,0);
        analogWrite(servo2,0);
        return 1;
    }
    else if (command=="60") {
        analogWrite(servo1,86);
        analogWrite(servo2,86);
    
         delay(1000);
        analogWrite(servo1,1);
        analogWrite(servo2,1);
         delay(1000);
         
        analogWrite(servo1,0);
        analogWrite(servo2,0);
        return 2;
    }
    else if (command=="90") {
        analogWrite(servo1,128);
        analogWrite(servo2,128);

         delay(1000);
        analogWrite(servo1,1);
         delay(1000);
        analogWrite(servo1,0);
        
         
        analogWrite(servo2,1);
         delay(1000);
        analogWrite(servo2,0);
        return 3;
    }
    else if (command=="120") {
        analogWrite(servo1,172);
        
         analogWrite(servo2,172);
         delay(1000);
        
        analogWrite(servo1,1);
         analogWrite(servo2,1);
         delay(1000);
        analogWrite(servo1,0);
        analogWrite(servo2,0);
        return 4;
    }
    else if (command=="150") {
        analogWrite(servo1,212);
        analogWrite(servo2,212);
         delay(1000);
        analogWrite(servo1,1);
        analogWrite(servo2,1);
         delay(1000);
        analogWrite(servo1,0);
        analogWrite(servo2,0);
        return 5;
    }
    else if (command=="180") {
        analogWrite(servo1,255);
        analogWrite(servo2,255);
         delay(1000);
        analogWrite(servo1,1);
        analogWrite(servo2,1);
         delay(1000);
        analogWrite(servo1,0);
        analogWrite(servo2,0);
        return 6;
    }
    
    
    else {
        return -1;
    }


}

const String key = "RC2WR9D1Z5G3NEJC";


int EMG = A0;           // defining the pin of use

int activity;           // variable to store measured emg output

int start;              // true/false value published to the cloud for partner photon to use




 char emgactivity;

void setup() {
    
    pinMode(EMG,INPUT);     // defines how A0 will be used
    
   Particle.variable("activity",  &activity, INT);    // used to define cloud variable, read out later


}





void loop() {
    
    activity = analogRead(EMG);         // tells photon to read A4 pin
    
    if (activity<=2500)                // Compares sensor output with the measured low activity level, actually 20mV, but not necessarily what pin A4 will read
    {
     
        
        delay(500);                     // short time period for recuring measurments
      
    }
    else if (activity>2500 & activity<5000)        // if sensor output is above low activity levels, will publish to this to the cloud 
    {
        Particle.publish("start","normalval", PUBLIC);    // creates incident
        delay(1000);                    // longer time period in order to allow servos to move
       
    }
    else {
        Particle.publish("large value","possible fault", PUBLIC);
    }
     
Particle.publish("thingSpeakWrite_", "{ \"1\": \"" + String(activity) + "\"," + "\"k\": \"" + key + "\" }", PRIVATE); // Publishes activity  to ThingSpeak

}

Credits

Pierre Fenrick

1 project • 2 followers

I am a former EMT, current Mechanical Engineering student pursuing a career where medicine meets technology.

Pelops' Hand

Things used in this project

Hardware components

Software apps and online services

Hand tools and fabrication machines

Story

1: The Photon

2: EMG sensor

3: Prosthetic

Schematics

Circuit Diagram

Code

Servo code

MyoWare Sensor Code

Credits

Pierre Fenrick

Comments

Embed the widget on your own site

Pelops' Hand

Pelops' Hand

Things used in this project

Hardware components

Software apps and online services

Hand tools and fabrication machines

Story

1: The Photon

2: EMG sensor

3: Prosthetic

Schematics

Circuit Diagram

Code

Servo code

MyoWare Sensor Code

Credits

Pierre Fenrick

Comments

Related channels and tags