Published August 18, 2019 © GPL3+

Freedom Chair

Wheelchair add-on allows quadriplegic individuals to have greater freedom with a puff-controlled robotic arm and various safety mechanisms.

AdvancedFull instructions provided5 hours1,351

The Fleet Master - Runner Up

Exploring & Understanding Our Connected World

Things used in this project

Hardware components

DRIVE wheel chair

OWI Robotic Arm Edge

LED (generic)

wire conduit

Adafruit MPRLS ported pressure sensor breakout

Seeed Studio Grove - Round Force Sensor (FSR402)

Battery, 3.7 V

C&K Switches JS Series Switch

Resistor 10k ohm

Adafruit TCA9548A I2C Multiplexer

Particle Boron

Adafruit Ultimate GPS FeatherWing

Adafruit DC Motor + Stepper FeatherWing Add-on For All Feather Boards

Adafruit Quad Side-By-Side FeatherWing Kit with Headers

Galvanized Steel Two Hole Strap, 1-1/4" Pipe Size

Machine Screw with Nut, 6-32-Inch x 1-Inch, 10-Pack

metal clothes hanger

Software apps and online services

Twilio SMS Messaging API

Ubidots

Particle Build Web IDE

Hand tools and fabrication machines

3D Printer (generic)

Multitool, Screwdriver

Story

The Origin and Targeted Audience of the Freedom Chair: The Freedom Chair was designed as an open source wheel chair attachment to help quadriplegic people, or people who have lost use in all four limbs, gain a sense of independence within their lives. The reason for the name "Freedom Chair" is not only because it will help the user feel more free from their current limitations, but also because the idea was originally meant for, however not limited to, troops who came back from overseas without the use of their limbs. These soldiers fought for our freedom, so it only seemed right that I should try to give a little freedom back to them.

A popular maker magazine called 'Servo' had a small article on assistive technologies that I thought fit best with what I was trying to build. They write

"Assistive technologies can benefit people with disabilities by giving them a greater independence and control over their lives."

As I did more research I was troubled by how expensive these technologies could be. Although designed well, it seems unnecessary to have to pay thousands of dollars just to have a little freedom in ones life. This is where the Freedom Chair comes into play. The Freedom Chair attachment is a low cost piece of assistive technology, with various functions. Mounted on the wheel chair are two force sensing resistors, two "puff" sensors, a GPS, and most importantly, an easy to control robotic arm through the use of the puff sensors. Additionally, It is equipped with the Particle Boron board with LTE meaning that if the user were to fall out of the wheel chair, anywhere in the world, without WiFi, their care taker could be notified.

The Freedom Chair

The Beginning Stages: My initial designs consisted of drawings of what I planned the the wheel chair to look like, with the mounted arm and clamps. I also started with programming the puff sensors in Python to change values, either increasing or decreasing depending on how much pressure was applied when I either puffed or sipped. I translated this knowledge to my knowledge of programming the motors, and was able to make the motors move back and forth at different speeds, corresponding to the actions the user took on the sensors.

Original Freedom Chair Design

The Particle and The Feather: As I continued working on the project, I learned about the Particle Boron with its LTE capabilities and its compatibility to Adafruit's line of Feather boards. The reason this was so important was because this covered all aspects and functions of my project. The compatibility with the Feather was so useful because I could use the Ultimate GPS FeatherWing add-an, and the FeatherWing motor controller board add-ons, all on a quad side by side Feather kit. The Boron's LTE capabilities were especially useful because it could send data to the Ubidots dashboard and when paired with a communications platform called Twilio, it can send text message alerts to a care takers phone. It created a very compact and stable platform to program the motors and sensors, and also to communicate over LTE to send data to different sources.

The Particle Boron LTE with GPS and motor controller add-ons

The Robotic Arm: The arm is controlled by the user through the use of Adafruit's MPRLS ported pressure sensors. The use of puff sensors to control a wheelchair's movement is where the idea of using puff sensors to control the robotic arm came from. One sensor changes the motor that the user wants to move, shuffling through each motor in sequential order, and the other sensor controls the direction and speed that the selected motor moves. These sensors detect whether the user is sipping or puffing on the sensor because it detects the change in pressure within a tube connected to the sensor. The sensors are connected by small tubing that is attached to a headpiece made from a simple metal coat hanger. the shape of the coat hanger followed the design of a harmonica neck mount so the user can sip and puff on the tubing without the use of their hands. The robotic arm came as an easy to put together toy kit with 5 DC motors for all pivot points on the arm which I connected to two Adafruit Feather compatible motor controller boards. The arm was mounted in front of the person, on top of a wooden board from Lowes. The board was mounted on top of the arm rest of the wheel chair with clamps, also from Lowes, and 3D-printed spacers. The 3D printed spacers were fairly easy to design due to the simplicity of the wheel chair arm design, and an accurate caliper. I was able to test my 3D printed design in Fusion360 with the help of the programs 'Assembly' feature, where you can bring in all the parts you have made and join them together to check measurements and functionality. One problem that I encountered while testing the use of the pressure sensors and the robotic arm was that I couldn't determine which motor I had selected, so most of the time I was stuck trying to select a motor and completing a simple task ended up being extremely frustrating. To overcome this problem, I attached 5 LED's that corresponds to each motor, so when you shuffle through the motors, you can see the LED's light up displaying which motor is selected. The coding for the arm was simple, because of the useful ''Adafruit Motorshield V2' library and the motors being standard DC motors. The code consists of various if-then blocks to run the motors with the corresponding LED's turning on as selected. Another issue that I ran into was that the LED's didn't actually match up with the specific motor due to issues wiring the board together. To combat this I hooked up the Particle board to my computer and used the serial port to display which motor was paired with which item in the LED list.

'Sip and Puff' sensors and neck mount for tubing

3D printed spacers and robotic arm mount

The LED motor selection solution

The Pressure Sensors and GPS Text Message Safety Notification: Another big feature of the "Freedom Chair" is its ability to keep the users caretaker alerted if something were to happen with the user falling out of the wheel chair. Although this project is meant to allow the user to operate themselves without supervision, it is always important to have a caretaker still able to monitor the user in case something were to go wrong. The two force sensing resistors in the chair will read a high value when someone sits down on them, with the help of a 3D-printed cone shaped plate that could take the weight of a person, and push it all down into one central point on the sensor. The only challenge I encountered when creating the pressure plate was keeping the design thin, because the user would have to sit on it. Even after thinning it out as much as I could, it was still too thick, so I got a cushion for the wheelchair and it stopped the pressure plates from getting in the way. When both sensors are pressed down, the program identifies that change as a person sitting in the chair. The importance of having two sensors in this case is that it acts as a fail safe. If one sensor happens to lag or stop working, the other sensor can accurately collect the data. This way, if one sensor displays a low value of force and the other shows a high value of force, the Boron LTE board will work with Twilio, a cloud communications platform, to send a text message to the care taker. This works because the board sends data to the Particle cloud, which sends data to the Twilio platform using a web-hook integration system. The text message is sent to the care taker with the location of the event using the Ultimate GPS FeatherWing add-on.

Particle.publish("twilio_sms", "emergency out of seat", PRIVATE);

This is especially important because if the user had gone outside to some place without WiFi, the Boron LTE can still transmit this data and the care taker can easily find the user. This is all displayed on Ubidots, an IOT dashboard that has a standard library for Arduino. This library can be included in the Particle IDE and is useful to display information in a readable way. The Particle Boron sends data to the Ubidots server, which displays the location of the wheelchair on a map, and what value the force sensitive resistors are reading. These values are continuously updated to the IOT dashboard.

  ubidots.addContext("lat",str_lat);  ubidots.addContext("lat",str_lng);  ubidots.getContext(context);   ubidots.add("position", 1.0, context);   ubidots.add("Left_Seat_Sensor", leftSeatSensor);  // Change for your variable name  ubidots.add("Right_Seat_Sensor", rightSeatSensor);

Force sensitive resistor pressure plate design and mount. Note the cone shape on the 3D render.

Twilio Text message alert

Ubidots IoT dashboard with sensor values and GPS data

Testing: Throughout the project, I was continuously testing my design to see if anything could be improved. I worked inside of my house by testing the arm mechanism on various objects such as saltshakers and snickers bars. When I felt ready to test outside, I brought the wheelchair to my local municipal building to see if it could press the handicap button to open a door.

Testing the robotic arm inside

At my local municipal building getting ready to test

Trying the saltshaker

Future Improvements: There is always room for improving your projects, which is why I included some future changes I might like to add to the freedom chair. One of the biggest problems I ran into while testing was the strength of the robotic arm. Although it was easy to control, it had some problems lifting some objects. The package said it was only rated to lift objects under 100 grams, however it was slightly disappointing when it couldn't even press a button on a door, As can be seen in the video below. The motor at the base of the arm continued to slip gears. To improve the arm, I would like to design the arm myself, with a couple of heavy duty servo motors and 3d printed parts. Another problem with the arm was that it wasn't able to turn objects upside down. When I was testing the design I tried to use a salt shaker with the robotic arm, however I found that I could not rotate the grippers. Although I eventually found a way to turn it upside down, it was a very long and complicated process that could easily be fixed with a servo motor at the wrist of the arm. Also when testing, I found it unbelievably hard to select a motor. Although I had added in the indicator lights, it still had some issues when shuffling through the motors. It shuffled through the motors so fast that you had to guess when it would land on the specific light. It was like a carnival game. There are simple solutions to this problem, and complicated solutions. The simple solution would be to add delays within the shuffling block of the code, however I tried to stay away from delays as much as I could, because every delay meant that the whole board stopped, and you stopped collecting data for however long the delay was. A more complicated solution would be to add a clock to the program, where it would start a countdown to the next time the user could activate the puff or sip function again.

Failed attempt at pressing the handicap button due to a weak motor

Schematics

Code

Complete Code for Particle Boron - Freedom Chair

#include <Debounce.h>


#include "lib1.h"

#include <Ubidots.h>

#include "Particle.h"
#include "AssetTrackerRK.h"
#include <Adafruit_MPRLS.h>
#include "TCA9548A-RK.h"
#include <Adafruit-MotorShield-V2.h>
 
#define RESET_PIN  -1  // set to any GPIO pin # to hard-reset on begin()
#define EOC_PIN    -1  // set to any GPIO pin to read end-of-conversion by pin
  
#ifndef UBIDOTS_TOKEN
#define UBIDOTS_TOKEN "****" // Put here your Ubidots TOKEN
#endif 

Ubidots ubidots(UBIDOTS_TOKEN, UBI_UDP);
  
  
SYSTEM_THREAD(ENABLED);

void displayInfo(); // forward declaration

const unsigned long PUBLISH_PERIOD = 120000;
const unsigned long SERIAL_PERIOD = 5000;

// GPS variables and parameters
AssetTracker t;
unsigned long lastSerial = 0;
unsigned long lastPublish = 0;
unsigned long startFix = 0;
bool gettingFix = false;
int seatAlert = 0;
boolean inSeat = true;

// reset seat alert button, currently assigned to D2
long currentResetDebounce, previousResetDebounce;
long debounceInterval = 75;
int currentResetButton, previousResetButton;
int resetButtonState = HIGH;

char lastLocation[128]; // used for out of seat check alert

double lastLat = 0;
double lastLon = 0;

// Seat check variables and parameters
int leftSeatSensor, rightSeatSensor;
long currentSeatCheck, previousSeatCheck;
const long seatCheckInterval = 1500;


// sip/puff control variables and parameters
Adafruit_MPRLS mpr = Adafruit_MPRLS(RESET_PIN, EOC_PIN);
TCA9548A mux0(Wire, 0);
long currentSelect, previousSelect;
const long selectInterval = 50;

int motorIndex;
const int maxIndex = 5;

int lights[] = {7, 4, 6, 5, 3, 8};

// Motor variables and parameters
Adafruit_MotorShield AFMS0 = Adafruit_MotorShield(); 
Adafruit_MotorShield AFMS1 = Adafruit_MotorShield(0x61); 

Adafruit_DCMotor *baseMotor     = AFMS0.getMotor(1);
Adafruit_DCMotor *shoulderMotor = AFMS0.getMotor(2);
Adafruit_DCMotor *elbowMotor    = AFMS0.getMotor(3);
Adafruit_DCMotor *wristMotor    = AFMS0.getMotor(4);
Adafruit_DCMotor *gripMotor     = AFMS1.getMotor(2);
Adafruit_DCMotor *lightMotor    = AFMS1.getMotor(1);


Debounce debouncer = Debounce();

long currentUbidots, previousUbidots;
long ubidotsUpdateInterval = 2500;

bool updateUbidots()
{
   
  char* str_lat = (char *) malloc(sizeof(char)* 10);
  char* str_lng = (char *) malloc(sizeof(char)* 10);
  sprintf(str_lat, "%f", lastLat);
  sprintf(str_lng, "%f", lastLon);
  char* context = (char *) malloc(sizeof(char) * 30);
    
  ubidots.addContext("lat",str_lat);
  ubidots.addContext("lng",str_lng);
  ubidots.getContext(context); 
  ubidots.add("position", 1.0, context); 
  
  ubidots.add("Left_Seat_Sensor", leftSeatSensor);  // Change for your variable name
  ubidots.add("Right_Seat_Sensor", rightSeatSensor);

  bool bufferSent = false;
  bufferSent = ubidots.send(); 
  
  free(str_lat);
  free(str_lng);
  free(context);
    
}

void setup()
{
	Serial.begin();
	// Turn on GPS module
	
	Particle.variable("seatAlert", seatAlert);
    Particle.variable("latitude", lastLat);
    Particle.variable("longitude", lastLon);
	
	
	t.gpsOn();

	// Run in threaded mode - this eliminates the need to read Serial1 from loop or updateGPS() and dramatically
	// lowers the risk of lost or corrupted GPS data caused by blocking loop for too long and overflowing the
	// 64-byte serial buffer.
	t.startThreadedMode();

    startFix = millis();
    gettingFix = true;

    // If using an external antenna, uncomment this line:
    // t.antennaExternal();
    
    mux0.begin();
	mux0.setChannel(1);
	
	Serial.println("MPRLS Simple Test");
    if (! mpr.begin()) 
    {
        Serial.println("Failed to communicate with MPRLS sensor, check wiring?");
    }
  
    Serial.println("Found MPRLS sensor");
    
    // motor indicator lights
    pinMode(D8, OUTPUT);
    pinMode(D7, OUTPUT);
    pinMode(D6, OUTPUT);
    pinMode(D5, OUTPUT);
    pinMode(D4, OUTPUT);
    pinMode(D3, OUTPUT);
    
    // out of seat reset button
    //pinMode(D2, INPUT);
    debouncer.attach(D2, INPUT_PULLUP);
    debouncer.interval(35);
    
    
    
    
    // seat pressure/force resistor sensors
    pinMode(A0, INPUT);
    pinMode(A1, INPUT);
    currentSeatCheck = millis();
    previousSeatCheck = currentSeatCheck;
    
    
    AFMS0.begin();
    AFMS1.begin();
    baseMotor->setSpeed(250);
    shoulderMotor->setSpeed(250);
    elbowMotor->setSpeed(250);
    wristMotor->setSpeed(250);
    gripMotor->setSpeed(250);
    lightMotor->setSpeed(250);
}

void loop()
{
	// In threaded mode, you must not call updateGPS() from loop - it's handled automatically
	// from a separate thread if you call t.startThreadedMode()
    // Serial.println("check");
    // Out of seat alert check:
    currentSeatCheck = millis();
    if ((currentSeatCheck - previousSeatCheck) > seatCheckInterval)
    {
            previousSeatCheck = currentSeatCheck;
            leftSeatSensor = analogRead(A0);
            rightSeatSensor = analogRead(A1);
            // Serial.print("Checking Seat: ");
            // Serial.print("LS: ");Serial.print(leftSeatSensor);
            // Serial.print(" RS: ");Serial.print(rightSeatSensor);
            // Serial.print(" SeatCheck(inSeat, seatALert) ");Serial.print("(");
            // Serial.print(inSeat);Serial.print(",");Serial.print(seatAlert);
            // Serial.println(")");
            
            if ( (leftSeatSensor > 1200) || (rightSeatSensor > 1200))
            {
        	    
        	    if (inSeat) 
        	    {
                    inSeat = false;
                    seatAlert = 1;
                    
                    String smsLat = String(lastLat);
                    String smsLon = String(lastLon);
                    String emerGPS = String("OUT OF SEAT @ LAT: " + smsLat + " and LON: " + smsLon  );
                    
        	        // Particle.publish("ALERT", "out", PRIVATE);
        	        // Particle.publish("twilio_sms", "emergency out of seat", PRIVATE);
        	        // Particle.publish("twilio_sms", emerGPS, PRIVATE);
        	       // Serial.print("OUT OF SEAT _ALERT_: ");Serial.println(seatAlert);
        	    }
            }
    }
    
    debouncer.update();

    if ((debouncer.read()==HIGH) && (inSeat == false))
    {
        
        inSeat = true;
    } else {
        // do nothing.
    }
    
    // Sip-Puff controller check
    currentSelect = millis();
    if ((currentSelect - previousSelect)>selectInterval)
    {
        previousSelect = currentSelect;
        
        mux0.setChannel(0);
        float pressure_hPa0 = mpr.readPressure();
        
        Serial.print("Pressure0 (hPa): "); Serial.println(pressure_hPa0);
        
        if ( pressure_hPa0 > 1050 ) 
        {
            motorIndex++;
            if (motorIndex > maxIndex) { motorIndex = 0;} // roll over
            // Serial.print("TO NEXT FUNCTION: "); Serial.println(motorIndex);
        } else if (pressure_hPa0 < 900) {
            motorIndex--;
            if (motorIndex < 0) { motorIndex = maxIndex; } // roll over
            // Serial.print("TO PREVIOUS FUNCTION: ");Serial.println(motorIndex);
        } else {
           //  Serial.print("NO SELECTION CONDITION: ");Serial.println("functionIndex");
        }
        
       // Serial.print("MOTOR INDEX: ");
        // Serial.print(motorIndex);
        
        // Serial.print(" DIGITAL INDEX: ");
        // Serial.println(lights[motorIndex]);
        
        for (int i=0; i<6; i++)
        {
            if (i == motorIndex)
            {
                digitalWrite(lights[i], true);
            } else {
                digitalWrite(lights[i], false);
            }
        }
        
        mux0.setChannel(1);
        float pressure_hPa1 = mpr.readPressure();
        int direction = 0;
         Serial.print("Pressure1 (hPa): "); Serial.println(pressure_hPa1);
        if (pressure_hPa1 > 1050) { direction = 1; }
        else if ( pressure_hPa1 < 900 ) { direction = -1; }
        else { direction = 0; }
        
        // Serial.print("DIRECTION: ");Serial.println(direction);
 
        switch (motorIndex)
        {
            case 0:
                if (direction > 0) { baseMotor->run(FORWARD); }
                else if (direction < 0) { baseMotor->run(BACKWARD); }
                else { baseMotor->run(RELEASE); }
                break;
            case 1:
                if (direction > 0) {shoulderMotor->run(FORWARD);}
                else if (direction < 0) {shoulderMotor->run(BACKWARD);}
                else { shoulderMotor->run(RELEASE); }
                break;
            case 2:
                if (direction > 0) {elbowMotor->run(FORWARD);}
                else if (direction < 0) {elbowMotor->run(BACKWARD);}
                else { elbowMotor->run(RELEASE); }
                break;
            case 3:
                if (direction > 0) {wristMotor->run(FORWARD);}
                else if (direction < 0) {wristMotor->run(BACKWARD);}
                else { wristMotor->run(RELEASE); }
                break;
            case 4:
                if (direction > 0) { gripMotor->run(FORWARD); }
                else if (direction < 0) { gripMotor->run(BACKWARD); }
                else { gripMotor->run(RELEASE); }
                break;
            case 5:
                if (direction > 0) { lightMotor->run(FORWARD);}
                else if (direction < 0) { lightMotor->run(BACKWARD);}
                else { lightMotor->run(RELEASE); }
                break;        
        }
    }    
    
    
    currentUbidots = millis();
    if ((currentUbidots-previousUbidots)>ubidotsUpdateInterval)
    {
        // Particle.publish
        previousUbidots = currentUbidots;
        if ( updateUbidots()) {
            
            // Serial.println("UBiDOTS UPDATED :)");
        } else {
            // Serial.println("UBIDOTS NOT UPDATE :(");
        }
        
    }
    
    
    
	displayInfo();
}

void displayInfo()
{
	if (millis() - lastSerial >= SERIAL_PERIOD) {
		lastSerial = millis();

		char buf[128];
		if (t.gpsFix()) {
			snprintf(buf, sizeof(buf), "location:%f,%f altitude:%f satellites:%d hdop:%d", t.readLatDeg(), t.readLonDeg(), t.getAltitude(), t.getSatellites(), t.getTinyGPSPlus()->getHDOP().value());
			// snprintf(lastLocation, sizeof(lastLocation), "location:%f,%f altitude:%f satellites:%d hdop:%d", t.readLatDeg(), t.readLonDeg(), t.getAltitude(), t.getSatellites(), t.getTinyGPSPlus()->getHDOP().value());
			snprintf(lastLocation, sizeof(lastLocation), "{\"position\": {\"value\":1, \"context\":{\"lat\": \"%f\", \"lng\": \"%f\"}}}", t.readLatDeg(), t.readLonDeg());
			lastLat = t.readLatDeg();
			lastLon = t.readLonDeg();
			
			if (gettingFix) {
				gettingFix = false;
				unsigned long elapsed = millis() - startFix;
				Serial.printlnf("%lu milliseconds to get GPS fix", elapsed);
			}
		}
		else {
			snprintf(buf, sizeof(buf), "no location satellites:%d", t.getSatellites());
			if (!gettingFix) {
				gettingFix = true;
				startFix = millis();
			}
		}
		Serial.println(buf);

		if (Particle.connected()) {
			if (millis() - lastPublish >= PUBLISH_PERIOD) {
				lastPublish = millis();
				Particle.publish("gps", buf, PRIVATE);
			}
		}
	}

}