CHANDANI POOJARA, RAMANI SAGAR, GAJJAR NAIMISH, TRIVEDI CHINTAN, Meen Patel

Published October 12, 2024

Neuro Glove: Smart Hand Rehabilitation Assistant

Neuro Glove is a smart rehabilitation assistant that uses AI and advanced sensors to enhance hand recovery

173

Neuro Glove: Smart Hand Rehabilitation Assistant

Things used in this project

Hardware components

Flex sensor

A flex sensor is a sensor that measures the amount of deflection or bending of the finger

ECG Sensor

An ECG (electrocardiogram) records the electrical signals that make the heartbeat

LED

To visualize the function of Proposed Prototype.

Breadboard

To Connect the sensors.

Multimeter

Checking the resistance of Flex Sensor

AMD Kria™ KR260 Robotics Starter Kit

Software apps and online services

Jupyter Notebook

Python Code

Arduino IDE

Arduino Code

Story

What is your project about?The proposed design features a wearable glove embedded with various sensors to measure hand movements and provide real-time feedback, aimed at assisting users in performing exercises correctly and enhancing recovery processes. This glove is particularly beneficial for rehabilitation, offering a non-invasive solution to track the progress of patients with hand injuries or those undergoing physical therapy. The sensors in the glove capture detailed data on finger flexion, extension, and overall hand movements. This data is then processed and displayed on a connected screen, giving users immediate visual feedback on their performance. The real-time feedback helps users adjust their movements to ensure exercises are done accurately, preventing potential injuries and improving the efficiency of the rehabilitation process. Additionally, the glove can store data for long-term tracking, allowing healthcare professionals to monitor progress remotely and tailor exercise programs to individual needs. This innovative approach not only enhances user engagement and motivation but also provides valuable insights into the recovery process, leading to quicker and more effective rehabilitation outcomes.Why did you decide to make it?Finding appropriate personalized hand rehabilitation can be quite challenging, especially considering the limitations of traditional methods. Typically, hand rehabilitation requires frequent visits to therapy centers, where patients receive guidance and perform exercises under the supervision of a professional therapist. However, these frequent visits can be a significant hurdle for many patients. Those with limited mobility, either due to the nature of their injury or other health conditions, may find it particularly difficult to travel regularly to therapy sessions. Additionally, patients who live in remote areas or far from rehabilitation centers face logistical challenges and may not have easy access to necessary therapy, leading to missed sessions.

Missed therapy sessions can have a detrimental impact on the rehabilitation process, potentially slowing down recovery and reducing the effectiveness of the treatment. Inconsistent attendance can lead to gaps in progress, making it harder for patients to regain full functionality of their hands. Furthermore, the lack of personalized, consistent feedback between sessions can result in improper exercise techniques, which might cause further injury or impede recovery.

A wearable glove equipped with sensors and real-time feedback mechanisms addresses these challenges by bringing personalized rehabilitation directly to the patient. This innovative solution allows patients to perform their exercises at home, ensuring they receive the necessary guidance and support without the need for frequent travel. The real-time feedback provided by the glove ensures that exercises are performed correctly, improving the effectiveness of the rehabilitation process. This technology empowers patients to take control of their recovery, enabling them to adhere more consistently to their therapy regimen and potentially achieve faster and more complete recovery outcomes.How does it work?In our device, a heart monitor sensor continuously tracks the user's pulse. When it detects a high pulse, it triggers a stepper motor to rotate. This motor will continue rotating until a flex sensor reaches its predetermined threshold, indicating that the desired finger flexion has been achieved. Following this, the system will pause for one second, allowing the stretched finger to release and relax before the cycle repeats. This entire process forms a loop, where the system continuously monitors for the next instance of a high pulse to activate the motor again.

For managing sensor inputs, we implemented a polled driver mechanism. This approach is particularly efficient given the brief duration of use, typically lasting only a few seconds per cycle. The polled driver mechanism ensures that the system is responsive and minimizes latency, effectively handling the sensor inputs without the need for more complex interrupt-driven designs.

To demonstrate the functionality of our device during development and testing phases, we used an LED in place of the motor. The LED lights up to indicate when the motor would be activated, providing a clear and visual representation of the system's operation. This substitution allows for safer and easier testing while verifying the accuracy and responsiveness of the heart monitor and flex sensor integration. Overall, this setup ensures that our device can effectively and reliably respond to high pulse detections, assisting users in their rehabilitation exercises by automating finger flexion and relaxation cycles.

Video Link:https://drive.google.com/drive/folders/1rhRV1QB_naLbEQtodlIcXuwRTpoFNYhd?usp=sharing

Schematics

Code

const int heartPin = A0; // Pin connected to the OUTPUT of the AD8232
int flexSensorPin = A1;
const int led = D13;
int sensorValue = 0;

void setup() {
  Serial.begin(9600); // Initialize serial communication
  pinMode(heartPin, INPUT);
  pinMode(flexSensorPin, INPUT);
  pinMode(led, OUTPUT);
  digitalWrite(led, HIGH); 
  
}

void loop() {
  digitalWrite(led, LOW);
  int sensorValue = 0;
  while(sensorValue<700){
    delay(100);
  sensorValue = analogRead(heartPin); // Read the analog value from the heart sensor
  Serial.print("heart Sensor Value: ");
  Serial.println(sensorValue*0.05*3); // Print the sensor value to the Serial Monitor
  }
  //if(sensorValue>=3 )
  {
    
    //digitalWrite(led, LOW);
    //delay(100);
    digitalWrite(led, HIGH); 
  }
  int fsensorValue = analogRead(flexSensorPin);
  
  while(fsensorValue<4)
  {fsensorValue = analogRead(flexSensorPin);
  Serial.print("Flex Value: ");
  Serial.println(fsensorValue);
  delay(500);}
  digitalWrite(led, LOW);
   // Read the value from the flex sensor
  Serial.print("Flex Sensor Value: ");
  Serial.println(fsensorValue);
  delay(10000);
}

/*int flexSensorPin = A1; // Pin connected to the flex sensor

void setup() {
  Serial.begin(9600); // Initialize serial communication
}

void loop() {
  int sensorValue = analogRead(flexSensorPin); // Read the value from the flex sensor
  Serial.print("Flex Sensor Value: ");
  Serial.println(sensorValue); // Print the sensor value to the Serial Monitor
  delay(500); // Delay for half a second
}*/

from pynq import Overlay
from pynq.lib import AxiGPIO
from time import sleep

# Load the overlay
overlay = Overlay("/path/to/your/bitstream.bit")

# Setup GPIO
heart_sensor_pin = overlay.AxiGPIO(0).channel1
flex_sensor_pin = overlay.AxiGPIO(1).channel1
led_pin = overlay.AxiGPIO(2).channel1

# Initialize pins
heart_sensor_pin.set_direction('in')
flex_sensor_pin.set_direction('in')
led_pin.set_direction('out')

# Function to read analog value from GPIO
def read_analog_pin(pin):
    return pin.read()

def main():
    print("Starting the program...")
    led_pin.write(1)  # Turn on LED
    
    while True:
        led_pin.write(0)  # Turn off LED
        sensor_value = 0
        
        while sensor_value < 700:
            sleep(0.1)
            sensor_value = read_analog_pin(heart_sensor_pin)  # Read heart sensor value
            print(f"Heart Sensor Value: {sensor_value * 0.05 * 3}")

        led_pin.write(1)  # Turn on LED

        flex_sensor_value = read_analog_pin(flex_sensor_pin)  # Read flex sensor value
        
        while flex_sensor_value < 4:
            flex_sensor_value = read_analog_pin(flex_sensor_pin)
            print(f"Flex Value: {flex_sensor_value}")
            sleep(0.5)
        
        led_pin.write(0)  # Turn off LED
        print(f"Flex Sensor Value: {flex_sensor_value}")
        sleep(10)

if _name_ == "_main_":
    main()

Neuro Glove: Smart Hand Rehabilitation Assistant

Things used in this project

Hardware components

Software apps and online services

Story

Custom parts and enclosures

Neuro Glove: Smart Hand Rehabilitation_1

Neuro Glove: Smart Hand Rehabilitation_2

Neuro Glove: Smart Hand Rehabilitation_3

Schematics

Neuro Glove: Smart Hand Rehabilitation_Block-Diagram

Neuro Glove: Smart Hand Rehabilitation_Circuit-Diagram

Neuro Glove: Smart Hand Rehabilitation_Hand

Code