Flex Sensor Arduino: Build Bend Detection Projects That Actually Work

If you’ve ever wanted to detect finger movement, measure joint angles, or build a gesture-controlled device, you’ve probably come across flex sensors. These deceptively simple strips of resistive material have been around since the Nintendo Power Glove era, and they remain one of the most accessible ways to translate physical bending into digital data.

I’ve used flex sensor Arduino combinations in everything from rehabilitation monitoring prototypes to interactive art installations. This guide covers the practical knowledge you need to get these sensors working reliably in your own projects.

What Is a Flex Sensor and Why Use One?

A flex sensor is essentially a variable resistor that changes its resistance value based on how much you bend it. The construction is straightforward: a thin plastic substrate coated with conductive ink containing carbon particles. When the sensor lies flat, those particles maintain close contact, resulting in lower resistance. Bend the sensor, and the particles spread apart as the material stretches, increasing electrical resistance.

This elegantly simple mechanism makes flex sensors ideal for applications where you need to measure bending without complex mechanical linkages or expensive optical systems. They’re lightweight, have no moving parts, and interface easily with microcontrollers through basic voltage divider circuits.

Common Flex Sensor Applications

Application Area	Use Case
Robotics	Gripper feedback, joint angle sensing
Wearables	Smart gloves, posture monitors
Gaming/VR	Gesture controllers, motion tracking
Medical Devices	Rehabilitation equipment, prosthetics
Musical Instruments	Expression controllers, theremin alternatives
Automotive	Seat position sensing, steering wheel grip

Flex Sensor Specifications and Types

Flex sensors come in two standard sizes, and understanding their specifications helps you choose the right one for your project.

Comparing 2.2″ vs 4.5″ Flex Sensors

Specification	2.2″ Sensor	4.5″ Sensor
Length	55.88mm (2.2 inches)	114.3mm (4.5 inches)
Flat Resistance	10kΩ to 25kΩ	10kΩ to 25kΩ
Bent Resistance (90°)	60kΩ to 110kΩ	60kΩ to 110kΩ
Operating Temperature	-35°C to +80°C	-35°C to +80°C
Power Rating	0.5W continuous	0.5W continuous
Life Cycle	>1 million bends	>1 million bends
Detection Angle	Up to 180°	Up to 180°

The 2.2″ version works well for finger-length applications like data gloves, while the 4.5″ sensor suits larger joints like elbows or for projects where you need to detect bending over a longer surface area.

Understanding Flex Sensor Resistance Behavior

The relationship between bend angle and resistance isn’t perfectly linear, but it’s predictable enough for most applications:

Bend Angle	Approximate Resistance
0° (flat)	10kΩ – 25kΩ
45°	30kΩ – 50kΩ
90°	60kΩ – 110kΩ
180° (full bend)	100kΩ – 150kΩ

Note that these values vary between individual sensors and manufacturers. Your calibration routine should always measure actual values rather than assuming datasheet specifications.

Flex Sensor Arduino Wiring Guide

Connecting a flex sensor to Arduino requires creating a voltage divider circuit. Since the sensor’s resistance changes with bending, this divider produces a variable voltage that Arduino’s analog-to-digital converter can read.

Basic Components Needed

Component	Quantity	Notes
Flex Sensor	1	2.2″ or 4.5″
Arduino Uno/Nano	1	Any Arduino with ADC
Fixed Resistor	1	10kΩ to 47kΩ (see selection guide)
Breadboard	1	For prototyping
Jumper Wires	3+	Male-to-male

Voltage Divider Circuit Connections

Flex Sensor Pin	Connection
Pin 1	Arduino 5V
Pin 2	Arduino Analog Pin (A0) AND Fixed Resistor
Fixed Resistor (other end)	Arduino GND

The fixed resistor value matters for sensitivity. A 47kΩ resistor provides good sensitivity across the full bend range for most sensors. If your sensor has lower flat resistance (around 10kΩ), try a 22kΩ fixed resistor instead.

Choosing the Right Fixed Resistor

The ideal fixed resistor value falls between the sensor’s minimum and maximum resistance values. Here’s a quick selection guide:

Sensor Flat Resistance	Recommended Fixed Resistor
10kΩ	22kΩ to 33kΩ
25kΩ	33kΩ to 47kΩ
30kΩ	47kΩ to 68kΩ

Using a resistor too small compared to the sensor reduces your measurement range. Too large, and you lose resolution at higher bend angles.

Basic Flex Sensor Arduino Code

Here’s a straightforward sketch to read and display flex sensor values:

// Basic Flex Sensor Reading

const int flexPin = A0;           // Analog input pin

const int FIXED_RESISTOR = 47000; // 47kΩ fixed resistor

const float VCC = 5.0;            // Arduino supply voltage

void setup() {

  Serial.begin(9600);

}

void loop() {

  int adcValue = analogRead(flexPin);

  // Convert ADC value to voltage

  float voltage = adcValue * (VCC / 1023.0);

  // Calculate flex sensor resistance using voltage divider formula

  // Vout = VCC * R_fixed / (R_flex + R_fixed)

  // Rearranged: R_flex = R_fixed * (VCC/Vout – 1)

  float flexResistance = FIXED_RESISTOR * (VCC / voltage – 1.0);

  Serial.print(“ADC: “);

  Serial.print(adcValue);

  Serial.print(” | Voltage: “);

  Serial.print(voltage, 2);

  Serial.print(“V | Resistance: “);

  Serial.print(flexResistance / 1000, 1);

  Serial.println(“kΩ”);

  delay(200);

}

Upload this code, open the Serial Monitor at 9600 baud, and observe how the values change as you bend the sensor.

Converting Flex Sensor Readings to Bend Angle

Raw resistance values aren’t particularly useful for most applications. You’ll want to convert them to meaningful units like degrees.

// Flex Sensor Angle Detection

const int flexPin = A0;

// Calibration values – measure these for YOUR sensor

const float STRAIGHT_RESISTANCE = 25000.0;  // Resistance when flat

const float BENT_RESISTANCE = 100000.0;     // Resistance at 90 degrees

const int FIXED_RESISTOR = 47000;

const float VCC = 5.0;

void setup() {

  Serial.begin(9600);

  Serial.println(“Flex Sensor Angle Detection”);

  Serial.println(“—————————-“);

}

void loop() {

  int adcValue = analogRead(flexPin);

  float voltage = adcValue * (VCC / 1023.0);

  float flexResistance = FIXED_RESISTOR * (VCC / voltage – 1.0);

  // Map resistance to angle (0-90 degrees)

  float angle = map(flexResistance,

                    STRAIGHT_RESISTANCE, BENT_RESISTANCE,

                    0, 90);

  // Constrain to valid range

  angle = constrain(angle, 0, 90);

  Serial.print(“Resistance: “);

  Serial.print(flexResistance / 1000, 1);

  Serial.print(“kΩ | Angle: “);

  Serial.print(angle, 1);

  Serial.println(“°”);

  delay(100);

}

Calibration Process for Accurate Angle Detection

The calibration values in the code above are placeholders. Here’s how to determine your actual values:

Step 1: Upload the basic reading code and lay the sensor flat on a table. Record the resistance value shown in Serial Monitor. This becomes your STRAIGHT_RESISTANCE.

Step 2: Bend the sensor to a known 90-degree angle (use a right-angle reference or protractor). Record this resistance as your BENT_RESISTANCE.

Step 3: Update the calibration constants in your code with these measured values.

Step 4: Verify accuracy by checking intermediate angles and adjusting if necessary.

Flex Sensor Arduino Project: Controlling a Servo Motor

One of the most popular flex sensor applications is controlling servo motors for robotic hands or grippers. Here’s a complete implementation:

// Servo Control with Flex Sensor

#include <Servo.h>

Servo gripperServo;

const int flexPin = A0;

const int servoPin = 9;

// Calibration values

const int FLEX_STRAIGHT = 700;  // ADC value when sensor is flat

const int FLEX_BENT = 300;      // ADC value when fully bent

const int SERVO_MIN = 0;        // Servo angle when sensor straight

const int SERVO_MAX = 180;      // Servo angle when sensor bent

void setup() {

  gripperServo.attach(servoPin);

  Serial.begin(9600);

}

void loop() {

  int flexValue = analogRead(flexPin);

  // Map flex sensor value to servo angle

  int servoAngle = map(flexValue, FLEX_STRAIGHT, FLEX_BENT,

                       SERVO_MIN, SERVO_MAX);

  servoAngle = constrain(servoAngle, SERVO_MIN, SERVO_MAX);

  gripperServo.write(servoAngle);

  Serial.print(“Flex: “);

  Serial.print(flexValue);

  Serial.print(” | Servo: “);

  Serial.println(servoAngle);

  delay(50);

}

Servo Control Wiring

Component	Arduino Pin
Flex Sensor Output	A0
Servo Signal (Orange)	D9
Servo Power (Red)	5V (or external)
Servo Ground (Brown)	GND

For multiple servos, use an external power supply. Drawing too much current from Arduino’s 5V rail causes brownouts and erratic behavior.

Building a Data Glove with Multiple Flex Sensors

Data gloves require five flex sensors, one per finger, and demonstrate how to scale up from single-sensor projects.

Multi-Sensor Wiring Configuration

Finger	Flex Sensor	Arduino Pin	Fixed Resistor
Thumb	Sensor 1	A0	47kΩ
Index	Sensor 2	A1	47kΩ
Middle	Sensor 3	A2	47kΩ
Ring	Sensor 4	A3	47kΩ
Pinky	Sensor 5	A4	47kΩ

All sensors share common VCC (5V) and GND connections. Each requires its own fixed resistor to GND.

Data Glove Arduino Code

// Five-Finger Data Glove

const int NUM_FINGERS = 5;

const int fingerPins[NUM_FINGERS] = {A0, A1, A2, A3, A4};

const char* fingerNames[NUM_FINGERS] = {“Thumb”, “Index”, “Middle”, “Ring”, “Pinky”};

// Calibration arrays – populate with YOUR measured values

int straightValues[NUM_FINGERS] = {700, 680, 690, 710, 720};

int bentValues[NUM_FINGERS] = {300, 290, 310, 320, 280};

void setup() {

  Serial.begin(9600);

  Serial.println(“Data Glove Initialized”);

}

void loop() {

  for (int i = 0; i < NUM_FINGERS; i++) {

    int rawValue = analogRead(fingerPins[i]);

    int angle = map(rawValue, straightValues[i], bentValues[i], 0, 90);

    angle = constrain(angle, 0, 90);

    Serial.print(fingerNames[i]);

    Serial.print(“: “);

    Serial.print(angle);

    Serial.print(“° | “);

  }

  Serial.println();

  delay(100);

}

Troubleshooting Common Flex Sensor Problems

After working with flex sensors across many projects, I’ve encountered most failure modes. Here’s how to diagnose and fix them:

Problem: Readings Don’t Change When Bending

Possible Causes and Solutions:

Cause	Solution
Bending wrong direction	Bend away from printed side (text faces inward)
Resistor value too high	Try a smaller fixed resistor
Damaged sensor	Test with multimeter; replace if no resistance change
Poor breadboard contact	Use screw terminals or solder connections

Problem: Erratic or Noisy Readings

Fixes:

Add a 0.1µF capacitor across the sensor terminals to filter high-frequency noise. In code, implement averaging:

int getSmoothedReading(int pin, int samples) {

  long total = 0;

  for (int i = 0; i < samples; i++) {

    total += analogRead(pin);

    delay(5);

  }

  return total / samples;

}

Problem: Sensor Stopped Working After Soldering

Flex sensors are heat-sensitive. If you must solder to the tabs, use a low-temperature iron and limit contact time to under one second. Better alternatives include:

• Clincher connectors (crimp style)
• Screw terminals
• Alligator clips for testing

Problem: Inconsistent Readings Across Multiple Sensors

Each sensor has manufacturing variations. Calibrate individually using these steps:

1. Read flat resistance for each sensor
2. Read 90-degree resistance for each sensor
3. Store calibration values in arrays
4. Apply individual mapping in code

Advanced Flex Sensor Techniques

Adding Hysteresis for Cleaner State Detection

When using flex sensors for threshold-based triggers (like detecting a closed fist), add hysteresis to prevent jittering:

const int BEND_THRESHOLD = 400;

const int HYSTERESIS = 50;

bool isBent = false;

void loop() {

  int flexValue = analogRead(A0);

  if (!isBent && flexValue < BEND_THRESHOLD – HYSTERESIS) {

    isBent = true;

    Serial.println(“Bent detected”);

  }

  else if (isBent && flexValue > BEND_THRESHOLD + HYSTERESIS) {

    isBent = false;

    Serial.println(“Released”);

  }

}

Wireless Data Glove with HC-05 Bluetooth

Transmitting flex sensor data wirelessly opens up possibilities for VR controllers and remote robot operation:

#include <SoftwareSerial.h>

SoftwareSerial bluetooth(10, 11); // RX, TX

void setup() {

  bluetooth.begin(9600);

}

void loop() {

  int thumb = map(analogRead(A0), 700, 300, 0, 90);

  int index = map(analogRead(A1), 680, 290, 0, 90);

  // Send as comma-separated values

  bluetooth.print(thumb);

  bluetooth.print(“,”);

  bluetooth.println(index);

  delay(50);

}

Useful Resources for Flex Sensor Arduino Projects

Here are resources I reference regularly:

Resource	Link	Description
SparkFun Flex Sensor Guide	learn.sparkfun.com	Official hookup guide with examples
SpectraSymbol Datasheet	sparkfun.com/datasheets	Technical specifications
Arduino IDE	arduino.cc/software	Development environment
Fritzing	fritzing.org	Circuit diagram tool
Tinkercad Circuits	tinkercad.com	Online simulation
Arduino Project Hub	projecthub.arduino.cc	Community projects

Component Sources

Component	Recommended Suppliers
Flex Sensors	SparkFun, Adafruit, DFRobot
Arduino Boards	Official Arduino Store, SparkFun
Resistor Kits	Amazon, Digi-Key, Mouser
Servo Motors	Tower Pro (SG90), Hitec

Frequently Asked Questions

Can flex sensors detect bending in both directions?

Standard flex sensors only detect bending in one direction reliably. Bending away from the conductive ink increases resistance; bending toward it produces minimal change and can damage the sensor over time. If you need bidirectional sensing, mount two sensors back-to-back or use a different sensor technology like strain gauges.

What resistor value should I use with my flex sensor?

Choose a fixed resistor value between your sensor’s flat and fully bent resistance. For a sensor with 25kΩ flat resistance and 100kΩ bent resistance, a 47kΩ resistor provides good sensitivity across the full range. If readings cluster at one end of the scale, try adjusting the resistor value up or down.

How accurate are flex sensors for measuring angles?

With proper calibration, flex sensors typically achieve accuracy within 5-10 degrees. They’re better suited for relative motion detection and gesture recognition than precision goniometry. For higher accuracy, calibrate at multiple known angles and use interpolation, or consider encoders for critical applications.

Why do my flex sensor readings drift over time?

Drift usually results from temperature changes, mechanical fatigue, or moisture absorption. Allow sensors to stabilize at operating temperature before calibrating. Avoid over-bending past 180 degrees. For long-term stability, implement periodic recalibration routines or use the sensor for relative rather than absolute measurements.

Can I make my own flex sensor instead of buying one?

Yes, DIY flex sensors using pencil graphite on paper or conductive tape provide a budget option for experimentation. However, commercial sensors offer better consistency, durability, and repeatability. For prototyping and learning, DIY works fine. For any project requiring reliability, invest in proper sensors.

Taking Your Flex Sensor Projects Further

The flex sensor Arduino combination provides an accessible entry point into physical computing and human-machine interfaces. Once you’ve mastered basic bend detection, consider these directions:

Gesture Recognition: Train a machine learning model to recognize hand gestures from multiple flex sensor inputs. TensorFlow Lite runs on Arduino Nano 33 BLE for on-device inference.

Haptic Feedback: Combine flex sensing with vibration motors for bidirectional interaction. When a virtual object resists bending, the motor pulses to simulate physical feedback.

Biomechanics Monitoring: Track joint range of motion during rehabilitation exercises. Log data to SD card for therapist review.

The fundamental skill of converting physical movement into digital signals transfers to countless other sensors and applications. Start with the basic circuits here, calibrate carefully, and build from there.