Published August 30, 2024 © MIT

Accessible Sewing Machine for Leg Impairment

Modifying the sewing machine foot pedal to a hand pedal for individuals with disabilities affecting both legs.

IntermediateFull instructions provided10 hours132

GRAND PRIZE MOBILITY IMPAIRMENTS

Build2gether 2.0 — Inclusive Innovation Challenge

Accessible Sewing Machine for Leg Impairment

Things used in this project

Hardware components

Nordic Semiconductor nRF52 Development Kit

DFRobot Flex Sensor 2.2

Cytron Technologies BTS7960 43A High Power Motor Driver Module

PCBWay Custom PCB

Electric Linear Motor Actuator

Limit Switch, 5 A

Digilent 60W PCIe 12V 5A Power Supply

Software apps and online services

Nordic Semiconductor nRF Connect SDK

Microsoft VS Code

Hand tools and fabrication machines

Soldering iron (generic)

Solder Wire, Lead Free

Wire Stripper & Cutter, 18-10 AWG / 0.75-4mm² Capacity Wires

Multitool, Screwdriver

Story

The situation of people with disabilities, their needs, and the barriers they face to participating fully in their societies is a critical issue. People with disabilities require the same essentials as those without disabilities. However, they often struggle to meet their needs due to difficulties in moving freely from place to place and the challenges of securing employment. Additionally, societal expectations often perceive individuals with disabilities as dependent and unable to fulfill their needs and wants through their own efforts. Therefore, modifying sewing machines presents an excellent opportunity for individuals with disabilities, particularly those with disabilities affecting both legs. Typically, sewing machines are operated by foot, and sewing work can be performed while sitting in one place, eliminating the need for movement.

The following few stories motivated me to do this project. This project aims to alter societal perceptions by modifying sewing machines to be hand-operated, thus enabling individuals with disabilities to work independently. By adopting the lower part of the sewing machine, which is typically foot-operated, to be hand-operated, people with disabilities can become self-sufficient. This change will help shift their status from dependent to independent, demonstrating that individuals with disabilities can contribute to society equally in terms of work, lifestyle, and meeting their needs and wants.

Currently, all types of sewing machines require the use of legs for operation, making them inaccessible to individuals with leg disabilities. Our modified sewing machine is fully operated by hand and specifically designed for those with disabilities affecting both legs. This innovation will transform the lives of these individuals, increasing their productivity and integrating them into the garment industry, where the ability to sit for extended periods is beneficial.

Hardware Connection

Before explaining the hardware connections let me explain how the system works. All types of sewing machines have a pedal switch that is used to control the speed of the sewing machine. As leg impairments are unable to control the pedal switch my goal is to make a way that enables the disabled to maintain the pedal in other ways. I used a flex sensor and a linear actuator to control the pedal switch with a finger. The linear actuator pushes the pedal switch based on the bending of the flex sensor and indirectly controls the speed of the sewing machine. The nRF52840 is used here to control the linear actuator based on the flex sensor reading. As a microcontroller pin is not capable of sourcing or sinking the required amount of current of a linear actuator, a high-power motor driver is used to drive and control the direction of the actuator. A limit switch is used to protect the pedal switch from abnormal pressure from the actuator.

The following figure shows the complete connection among the hardware components.

Connection diagram

Testing and Writing Code

I made a breadboard setup for testing the sensor and actuator. The sensor connection with nRF52840 is shown in the following image.

The following values were recorded in the serial monitor without bending the sensor which is quite stable.

The maximum voltage around 90-degree bending of the sensor was recorded as 2300mV. Based on the experimental value the code was written and the perfect pressure was achieved after multiple trials and errors. The code is attached in the code section and the complete project is provided with a GitHub link.

Making PCB

After finishing the code development and testing the hardware connections I designed the schematic and PCB using EasyEDA. The schematic and the 3D view of the PCB are represented below.

Schematic

PCB

The main components of the PCB are a few connectors. The motor driver, linear actuator, and flex sensor are not the components that can be directly assembled into the PCB. So, I used connectors to connect them with the nRF microcontroller.

Setup

I made a plywood frame and fixed the linear actuator with nuts, bolts, and zip ties.

On the back side, I placed the motor driver and the nRF52840 board with a few screws.

1 / 2

Video In Action

Code

Code for nRF52480

#include <zephyr/kernel.h>
#include <zephyr/drivers/adc.h>
#include <hal/nrf_gpio.h>

/* 1000 msec = 1 sec */
#define SLEEP_TIME_MS   1000

#define ADC_NODE DT_NODELABEL(adc)
static const struct device *adc_dev = DEVICE_DT_GET(ADC_NODE);

#define ADC_RESOLUTION 10
#define ADC_CHANNEL    0
#define ADC_PORT       SAADC_CH_PSELN_PSELN_AnalogInput0  //AIN0
#define ADC_REFERENCE  ADC_REF_INTERNAL                   //0.6V
#define ADC_GAIN       ADC_GAIN_1_5                       //ADC_REFERENCE*5

struct adc_channel_cfg chl0_cfg = {
	.gain = ADC_GAIN,
	.reference = ADC_REFERENCE,
	.acquisition_time = ADC_ACQ_TIME_DEFAULT,
	.channel_id = ADC_CHANNEL,
#ifdef CONFIG_ADC_NRFX_SAADC
	.input_positive = ADC_PORT
#endif
};

int16_t sample_buffer[1];

struct adc_sequence sequence = {
	/* individual channels will be added below */
	.channels = BIT(ADC_CHANNEL),
	.buffer = sample_buffer,
	/* buffer size in bytes, not number of samples */
	.buffer_size = sizeof(sample_buffer),
	.resolution = ADC_RESOLUTION
};


#define LED_GREEN NRF_GPIO_PIN_MAP(1, 10)
#define SPEED_INCREASE_PIN NRF_GPIO_PIN_MAP(1, 11)
#define SPEED_DECREASE_PIN NRF_GPIO_PIN_MAP(1, 12)

#define LIMIT_BOTTOM NRF_GPIO_PIN_MAP(1, 3)
#define LIMIT_TOP NRF_GPIO_PIN_MAP(1, 4)


/*Function Prototype*/
void initialize_adc(void);
int read_adc(void);



int main(void)
{
	nrf_gpio_cfg_output(LED_GREEN);
	nrf_gpio_cfg_output(SPEED_INCREASE_PIN);
	nrf_gpio_cfg_output(SPEED_DECREASE_PIN);

	nrf_gpio_cfg_input(LIMIT_BOTTOM, NRF_GPIO_PIN_PULLUP);
	nrf_gpio_cfg_input(LIMIT_TOP, NRF_GPIO_PIN_PULLUP);
 
    initialize_adc();

	int change_margin = 20; //determinds the sensitivity of the sensor, find it after trial and error
	int count = 1800;       //reduce false trigger 
	
	while (1) {
		
		int32_t flex_value = read_adc();

		while(flex_value>1800){

			if((flex_value-count)>change_margin){
				int delay_count = flex_value-count;  
				nrf_gpio_pin_set(SPEED_INCREASE_PIN);
				k_msleep(delay_count*1.7); //depends on the speed of the linear actuator
				//printk("Delay count positive: %d.\n", delay_count);
				nrf_gpio_pin_clear(SPEED_INCREASE_PIN);
				count += delay_count; 
				printk("Count: %d.\n", count);
			}

			else if((flex_value-count)<-change_margin){
				int delay_count = abs(flex_value-count);
				nrf_gpio_pin_set(SPEED_DECREASE_PIN);
				k_msleep(delay_count*1.7);
				//printk("Delay count negative: %d.\n", delay_count);
				nrf_gpio_pin_clear(SPEED_DECREASE_PIN);
				count -= delay_count; 
			}

			flex_value = read_adc();

		}

	}
	return 0;
}



void initialize_adc(void){
    int err;

	if(!device_is_ready(adc_dev)){
		printk("adc_dev not ready\n");
		return;
	}

	err = adc_channel_setup(adc_dev, &chl0_cfg);
	if(err != 0){
		printk("adc_channel_setup failed with error %d.\n, err");
		return;
	}
}


int read_adc(void){
    int err = adc_read(adc_dev, &sequence);
	if(err != 0){
		printk("ADC reading failed with error %d.\n", err);
		return;
	}

	int32_t mv_value = sample_buffer[0];
	//printk("ADC-raw: %d mV\n", mv_value);
	int32_t adc_vref = adc_ref_internal(adc_dev);
	adc_raw_to_millivolts(adc_vref, ADC_GAIN, ADC_RESOLUTION, &mv_value);
	//printk("ADC-Spannung: %d mV\n", mv_value); 
	//k_msleep(SLEEP_TIME_MS);
	return mv_value;   
}