How to Make a Gesture-Controlled Wheelchair for Students Projects & Final Year Projects in Lahore

A gesture-controlled wheelchair lets the rider drive with hand movements instead of a joystick or buttons. An accelerometer worn on the hand reads the tilt, the gesture is sent wirelessly over Bluetooth, and an Arduino on the wheelchair drives the motors forward, backward, left or right. It is a popular final year project for students in Pakistan because it combines sensors, wireless communication, motor control and assistive technology in one working system.

This guide builds a small-scale working model with two units: a glove unit (Arduino Nano + MPU6050 + HC-05 Bluetooth) and a wheelchair unit (Arduino UNO + HC-05 + L298N motor driver + four gear motors). Be clear about the scope: this is a model that demonstrates gesture control on the floor. It is not a full-size wheelchair that can carry a person — that needs high-torque motors, a strong frame, a large 12V battery and proper engineering.

How the System Works

The system has two units that talk to each other over Bluetooth:

1. Glove unit — the MPU6050 accelerometer reads the hand tilt. Tilt forward sends F, backward sends B, left sends L, right sends R, and a level hand sends S (stop). One letter is sent every 200 ms.
2. Wheelchair unit — the second Arduino receives the letter over Bluetooth and drives the L298N motor driver: F moves both sides forward, B reverses, L and R spin the chair left or right, S stops.
3. Safety stop — if no command arrives for more than 1 second (Bluetooth drops, glove switched off, out of range), the wheelchair stops by itself. A wheelchair must never keep driving on a lost signal.

The two HC-05 modules are paired once (one master, one slave) and then connect automatically whenever both are powered.

Main Components Needed

The four small gear motors drive a model base. For a full-size wheelchair you would need high-torque 12V/24V motors, a steel frame and a large 12V battery — that is a different, much bigger build.

Wiring

Glove Unit — Arduino Nano + MPU6050 + HC-05 (master)

Power the glove Nano from a small 5V power bank through the USB port.

Wheelchair Unit — Arduino UNO + HC-05 (slave) + L298N

Connect the battery negative to the L298N GND and to the Arduino GND as well — a common ground is essential, otherwise the motor signals have no return path and the motors will not run. Power the Arduino from its own 5V power bank through USB, not from the 12V battery.

Do not connect ENA / ENB to the 12V battery. ENA and ENB are 5V logic enable pins — 12V on them can damage the L298N module and the Arduino. With the jumpers left ON, the module feeds them its own 5V and the motors run at full speed. (If you want speed control later, remove the jumpers and drive ENA/ENB from two PWM pins instead — never from 12V.)

Pairing the Two HC-05 Modules

Pair them once; after that they connect automatically when both are powered.

1. Hold the small EN (KEY) button on a module while powering it — it enters AT mode (LED blinks slowly). Connect it to the Arduino IDE Serial Monitor at 38400 baud, “Both NL & CR” line ending.
2. On the glove module, send AT+ROLE=1 (master). It should reply OK.
3. On the wheelchair module, send AT+ROLE=0 (slave — this is the default, but check it).
4. On the wheelchair module, send AT+ADDR? and note the address it returns (for example 98d3:31:fd1234).
5. On the glove module, send AT+BIND=98d3,31,fd1234 using the address from step 4, with colons replaced by commas.
6. Power both modules off and on again normally (without holding EN). The master connects to the slave by itself — both LEDs blink twice per second when linked.

If the modules were bought as a pre-paired pair, skip these steps — they connect on their own.

Required Libraries

Install these from the Arduino IDE Library Manager (Sketch → Include Library → Manage Libraries):

• Adafruit MPU6050 by Adafruit
• Adafruit Unified Sensor by Adafruit

SoftwareSerial and Wire are built into the Arduino IDE — no install needed.

Complete Arduino Code

Sketch 1 — Glove Unit (Arduino Nano)

/*
  Gesture Wheelchair — GLOVE unit (Arduino Nano)
  MPU6050 reads the hand tilt and sends one letter
  over Bluetooth every 200 ms:
  F = forward, B = backward, L = left, R = right, S = stop.
  The MPU6050 must sit flat on the glove with its pins
  pointing forward. If the chair moves the wrong way,
  swap F with B (or L with R) below — see the testing section.
*/

#include <Wire.h>
#include <Adafruit_MPU6050.h>
#include <Adafruit_Sensor.h>
#include <SoftwareSerial.h>
#include <math.h>

Adafruit_MPU6050 mpu;
SoftwareSerial bt(2, 3);   // HC-05: TX -> D2, RX -> D3

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

  if (!mpu.begin()) {
    Serial.println("MPU6050 not found! Check SDA -> A4, SCL -> A5.");
    while (1) { delay(10); }
  }
  mpu.setAccelerometerRange(MPU6050_RANGE_8_G);

  Serial.println("Glove ready. Tilt your hand to drive.");
}

void loop() {
  sensors_event_t a, g, temp;
  mpu.getEvent(&a, &g, &temp);

  // Dead zone of 3 m/s^2 around level, so small hand shakes do nothing.
  char cmd = 'S';
  if (a.acceleration.x > 3.0)       cmd = 'F';
  else if (a.acceleration.x < -3.0) cmd = 'B';
  else if (a.acceleration.y > 3.0)  cmd = 'L';
  else if (a.acceleration.y < -3.0) cmd = 'R';

  bt.write(cmd);
  Serial.print("Gesture: ");
  Serial.println(cmd);
  delay(200);
}

Sketch 2 — Wheelchair Unit (Arduino UNO)

/*
  Gesture Wheelchair — WHEELCHAIR unit (Arduino UNO)
  Receives F / B / L / R / S over Bluetooth and drives
  the L298N motor driver. Safety stop: if no command
  arrives for more than 1 second, the motors stop.
  ENA / ENB jumpers stay ON (5V). NEVER connect ENA/ENB to 12V.
*/

#include <SoftwareSerial.h>

SoftwareSerial bt(2, 3);   // HC-05: TX -> D2, RX -> D3

const int IN1 = 5, IN2 = 6, IN3 = 9, IN4 = 10;

unsigned long lastCmd = 0;

void setup() {
  Serial.begin(9600);
  bt.begin(9600);
  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);
  pinMode(IN3, OUTPUT);
  pinMode(IN4, OUTPUT);
  stopMotors();
  Serial.println("Wheelchair ready. Waiting for gesture commands...");
}

void loop() {
  if (bt.available()) {
    char cmd = (char)bt.read();
    lastCmd = millis();
    if (cmd == 'F')      forward();
    else if (cmd == 'B') backward();
    else if (cmd == 'L') left();
    else if (cmd == 'R') right();
    else if (cmd == 'S') stopMotors();
    Serial.print("Command: ");
    Serial.println(cmd);
  }

  // Safety stop: no command for 1 second means the link is gone.
  if (millis() - lastCmd > 1000) {
    stopMotors();
  }
}

void forward()  { digitalWrite(IN1, HIGH); digitalWrite(IN2, LOW);  digitalWrite(IN3, HIGH); digitalWrite(IN4, LOW); }
void backward() { digitalWrite(IN1, LOW);  digitalWrite(IN2, HIGH); digitalWrite(IN3, LOW);  digitalWrite(IN4, HIGH); }
void left()     { digitalWrite(IN1, LOW);  digitalWrite(IN2, HIGH); digitalWrite(IN3, HIGH); digitalWrite(IN4, LOW); }
void right()    { digitalWrite(IN1, HIGH); digitalWrite(IN2, LOW);  digitalWrite(IN3, LOW);  digitalWrite(IN4, HIGH); }
void stopMotors(){ digitalWrite(IN1, LOW); digitalWrite(IN2, LOW);  digitalWrite(IN3, LOW);  digitalWrite(IN4, LOW); }

What the Code Does

• The glove sketch reads the MPU6050 tilt every 200 ms and sends one letter (F, B, L, R or S). A dead zone of 3 m/s² around level stops small hand shakes from moving the chair.
• The wheelchair sketch reads each letter and sets the four L298N inputs for forward, backward, left spin, right spin or stop.
• Left and right spin the chair in place (one side forward, one side backward) — that is how a differential-drive model turns.
• If the Bluetooth link drops, the wheelchair stops by itself within 1 second instead of carrying on with the last command.

How to Make the Wheelchair

Step 1: Build the Model Base

Fix the four gear motors and wheels to a flat base or small frame, two on each side. Wire the two left motors in parallel to OUT1/OUT2 and the two right motors in parallel to OUT3/OUT4.

Step 2: Wire the Wheelchair Unit

Wire the UNO, HC-05 (slave) and L298N as in the table above. Connect the 12V battery to the L298N 12V terminal and join all grounds together.

Step 3: Build the Glove Unit

Mount the MPU6050 flat on a glove with its pins pointing forward, and wire it with the Nano and the HC-05 (master). Power it from a small power bank.

Step 4: Pair the Bluetooth Modules

Follow the pairing steps above, then power both units normally and check that both HC-05 LEDs blink twice per second (linked).

Step 5: Upload the Code

Upload Sketch 1 to the Nano and Sketch 2 to the UNO. Keep the USB cables connected and both Serial Monitors open for the first test.

Step 6: Test on the Floor

Put the model on the floor — never test with a person on it. Tilt your hand forward and check the model drives forward, then try each direction.

Testing the System

1. Test the MPU6050 first. The glove Serial Monitor should print “Glove ready.” and then a letter every 200 ms. If it prints “MPU6050 not found”, check SDA → A4 and SCL → A5.
2. Test the Bluetooth link. With both units powered, the wheelchair Serial Monitor should print “Wheelchair ready.” and then the same letters the glove is sending. If nothing arrives, re-check the pairing and that both modules run at 9600 baud.
3. Test the motors. Tilt forward — both sides should drive forward. If one side runs backward, swap that motor’s two wires on the L298N output.
4. Test the directions. If forward tilt drives the model backward, swap F and B in the glove sketch (or turn the MPU6050 around on the glove). Same for left and right.
5. Test the safety stop. Switch the glove off while the model is moving — it must stop within about 1 second.

Troubleshooting

• “MPU6050 not found”: check SDA → A4, SCL → A5, and that VCC is on 5V. Some MPU6050 boards have the AD0 pin pulled so the address is 0x69 instead of 0x68 — the Adafruit library uses 0x68 by default.
• Wheelchair Serial Monitor shows nothing: the HC-05 modules are not paired. Redo the pairing steps, check both are at 9600 baud in normal mode, and that TX/RX are not swapped (module TX → Arduino D2).
• Motors do not run at all: check the 12V battery is connected to the L298N 12V terminal, the ENA/ENB jumpers are ON, and the battery negative, L298N GND and Arduino GND are all joined (common ground).
• One side runs backward: swap the two wires of that side’s motors on the L298N output terminals.
• Chair turns the wrong way: swap L and R in the glove sketch, or turn the MPU6050 around on the glove.
• Chair jitters on small hand movements: raise the dead zone in the glove sketch from 3.0 to 4.0.
• Chair keeps moving after the glove is off: the 1-second safety stop is not working — check that the millis() - lastCmd > 1000 block is in the wheelchair sketch’s loop().

Applications

• School and college projects — a complete sensor + wireless + motor-control system in one build.
• Final year projects — gesture control with a live driving demo is easy to show to judges.
• Assistive-technology demos — shows how hand gestures can drive a mobility device.
• A base for your own version — add a buzzer, an obstacle sensor that stops the chair, or speed control with the ENA/ENB pins driven from PWM outputs.

Where to Buy the Components

The Arduino UNO, Nano, L298N, gear motors, 18650 cells and holders, breadboard and jumper wires are available at QKZEE Technologies, Shop 20, 1st Floor, Al-Khalil Center, Hall Road, Lahore, and online at qkzeetech.com with delivery all over Pakistan — see the links above. The MPU6050 and HC-05 modules are available at the Hall Road shop on request.

Still Stuck?

If the motors do not run, or the Bluetooth link never connects, message us — tell us what both Serial Monitors show and which step you are on, and we will help you find the fault.

FAQs

Do I really need two Arduinos?

Yes, for the wireless version: one on the glove reads the gestures, one on the chair drives the motors, and Bluetooth links them. A one-board version is possible, but then the glove would be wired to the chair with a cable.

Can this wheelchair carry a person?

No. This is a small-scale model built with small gear motors. A full-size wheelchair needs high-torque 12V/24V motors, a steel frame, a large 12V battery and proper engineering — that is a different build.

What battery should I use?

Three 18650 cells in series give about 11.1V, which runs the L298N and the small gear motors. A 12V lead-acid battery also works for a bigger model.

Why must the chair stop when Bluetooth drops?

Because a wheelchair that keeps driving on a lost signal is dangerous. The sketch stops the motors if no command arrives for 1 second.

Why can ENA and ENB not go to the 12V battery?

ENA and ENB are 5V logic enable pins. 12V on them can damage the L298N module and the Arduino. Leave the jumpers ON so the module feeds them its own 5V.

Can I add speed control?

Yes. Remove the ENA/ENB jumpers and drive ENA and ENB from two PWM pins (for example D3 and D11 on the UNO — move the HC-05 to other pins first), then use analogWrite() to set the speed.

Conclusion

Building a gesture-controlled wheelchair brings together motion sensing, Bluetooth communication and motor control in one project. Build the two units, pair the Bluetooth modules, upload both sketches, and test the model on the floor before showing it to anyone. With the code in this guide, students in Pakistan can demonstrate a working system and explain every part of it — from the hand tilt to the motors — to their teachers and judges.