Force Sensitive Resistor Arduino: Building Pressure-Sensing Projects

Pressure sensing opens up a world of project possibilities that buttons and switches simply can’t match. Whether you want to build electronic drum pads, smart furniture that knows when someone sits down, or a robotic gripper that detects grip strength, a force sensitive resistor Arduino combination gets you there without breaking the bank.

I’ve integrated FSRs into dozens of prototypes over the years, from medical device research to interactive art installations. This guide covers the practical knowledge needed to make these sensors work reliably in your own builds.

What Is a Force Sensitive Resistor?

A force sensitive resistor (FSR) is a polymer thick film device that decreases in electrical resistance when pressure is applied to its active sensing area. The construction is deceptively simple: two flexible membranes separated by a thin air gap. One membrane carries interdigitated conductive traces, while the other is coated with a pressure-sensitive conductive ink.

When you press on the sensor, the ink contacts the traces, creating parallel resistance paths. Press harder, and more conductive particles make contact, lowering resistance further. Release the pressure, and resistance returns to its original high state.

This behavior makes FSRs ideal for detecting whether something has been pressed and roughly how hard, even though they’re not precision instruments.

FSR Characteristics You Need to Know

Property	Typical Value
No-pressure resistance	>10 MΩ (effectively open circuit)
Light pressure resistance	~100 kΩ
Maximum pressure resistance	~200 Ω
Force range	0.2 N to 100 N (varies by model)
Response time	<5 ms
Life cycle	>10 million actuations
Thickness	~0.5 mm

The relationship between force and resistance is logarithmic, not linear. There’s a steep drop in resistance with initial pressure, then a more gradual decrease as force increases. This characteristic affects how you design your voltage divider circuit.

Popular FSR Types for Arduino Projects

Several FSR models dominate the maker market. Understanding their differences helps you select the right sensor.

Model	Active Area	Force Range	Best For
FSR 400 (Short)	5mm diameter	0.2N – 20N	Button replacement
FSR 402	12.7mm diameter	0.2N – 20N	General purpose
FSR 406	38mm × 38mm square	0.2N – 20N	Large touch areas
FSR 408	609.6mm × 5.1mm strip	0.2N – 20N	Linear sensing

The Interlink FSR 402 remains the most common choice for Arduino projects due to its moderate size and wide availability. The square FSR 406 works well for dance pads and pressure mats where you need larger sensing areas.

Force Sensitive Resistor Arduino Wiring

Connecting an FSR to Arduino requires a voltage divider circuit. Since the sensor acts as a variable resistor, this configuration converts resistance changes into voltage changes that Arduino’s ADC can read.

Basic Voltage Divider Connections

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

Since FSRs are non-polarized (just like regular resistors), you can connect either pin to power without worrying about direction.

Choosing the Fixed Resistor Value

The fixed resistor value determines your circuit’s sensitivity range. Here’s how different values affect the output:

Fixed Resistor	Best For	Voltage Range
1 kΩ	Heavy force detection	Narrow range, high pressure
10 kΩ	General purpose	Wide range, balanced
47 kΩ	Light touch detection	Sensitive to small forces
100 kΩ	Very light touch	Maximum sensitivity

For most projects, start with a 10kΩ resistor. This provides good sensitivity across the FSR’s usable force range. If you find readings cluster at one end of the scale, swap in a different value.

Voltage Output vs Applied Force

Understanding how voltage relates to force helps you interpret sensor readings:

Applied Force	FSR Resistance	Voltage (with 10kΩ)
None	>10 MΩ	~0V
Light touch (20g)	~100 kΩ	~0.45V
Light squeeze (100g)	~10 kΩ	~2.5V
Medium squeeze (1kg)	~2 kΩ	~4.17V
Hard press (10kg)	~250 Ω	~4.88V

Notice that most of the voltage change happens between light touch and medium squeeze. This non-linear response is characteristic of all FSRs.

Basic Force Sensitive Resistor Arduino Code

Here’s a straightforward sketch to read and categorize pressure levels:

// Basic FSR Reading with Pressure Categories

const int fsrPin = A0;      // FSR connected to analog pin A0

int fsrReading;             // Raw analog reading

void setup() {

  Serial.begin(9600);

}

void loop() {

  fsrReading = analogRead(fsrPin);

  Serial.print(“Analog reading: “);

  Serial.print(fsrReading);

  // Categorize pressure levels

  if (fsrReading < 10) {

    Serial.println(” – No pressure”);

  } else if (fsrReading < 200) {

    Serial.println(” – Light touch”);

  } else if (fsrReading < 500) {

    Serial.println(” – Light squeeze”);

  } else if (fsrReading < 800) {

    Serial.println(” – Medium squeeze”);

  } else {

    Serial.println(” – Hard press”);

  }

  delay(200);

}

Upload this code, open Serial Monitor at 9600 baud, and press on your FSR. The threshold values above work for most FSR 402 sensors with 10kΩ resistors, but you may need to adjust based on your specific sensor and mounting.

Calculating Actual Force from FSR Readings

If you need approximate force values rather than qualitative categories, this more advanced sketch converts readings to Newtons:

// FSR Force Calculation

const int fsrPin = A0;

const float VCC = 5.0;           // Arduino supply voltage

const float R_DIV = 10000.0;     // Fixed resistor value (10kΩ)

void setup() {

  Serial.begin(9600);

}

void loop() {

  int fsrADC = analogRead(fsrPin);

  if (fsrADC != 0) {

    // Convert ADC value to voltage

    float fsrVoltage = fsrADC * VCC / 1023.0;

    // Calculate FSR resistance from voltage divider formula

    // Vout = VCC * R_DIV / (R_FSR + R_DIV)

    // Rearranged: R_FSR = R_DIV * (VCC/Vout – 1)

    float fsrResistance = R_DIV * (VCC / fsrVoltage – 1.0);

    // Approximate conductance (1/resistance)

    float fsrConductance = 1000000.0 / fsrResistance;  // in microMhos

    // Approximate force using FSR characteristic curve

    // This approximation works for FSR 402 in typical range

    float force;

    if (fsrConductance <= 1000) {

      force = fsrConductance / 80.0;

    } else {

      force = (fsrConductance – 1000.0) / 30.0;

    }

    Serial.print(“Resistance: “);

    Serial.print(fsrResistance);

    Serial.print(” ohms | Force: “);

    Serial.print(force);

    Serial.println(” N”);

  } else {

    Serial.println(“No pressure detected”);

  }

  delay(250);

}

Keep in mind that FSRs have roughly ±10% accuracy between sensors, so these force values are estimates rather than precise measurements.

Project: LED Brightness Control with FSR

A practical demonstration of FSR pressure sensing: control LED brightness based on how hard you press.

LED Control Wiring

Component	Arduino Pin
FSR Pin 1	5V
FSR Pin 2	A0 + 10kΩ to GND
LED Anode	D9 (PWM pin)
LED Cathode	GND via 220Ω resistor

LED Brightness Code

// FSR-Controlled LED Brightness

const int fsrPin = A0;

const int ledPin = 9;     // Must be PWM-capable pin

int fsrReading;

int ledBrightness;

void setup() {

  pinMode(ledPin, OUTPUT);

  Serial.begin(9600);

}

void loop() {

  fsrReading = analogRead(fsrPin);

  // Map FSR reading (0-1023) to LED brightness (0-255)

  ledBrightness = map(fsrReading, 0, 1023, 0, 255);

  // Apply brightness to LED

  analogWrite(ledPin, ledBrightness);

  Serial.print(“Pressure: “);

  Serial.print(fsrReading);

  Serial.print(” | Brightness: “);

  Serial.println(ledBrightness);

  delay(50);

}

Press lightly for a dim glow, press harder for full brightness. This demonstrates the fundamental principle used in velocity-sensitive drum pads and touch-responsive interfaces.

Project: FSR Toggle Switch

Use an FSR as a pressure-activated toggle switch with debouncing:

// FSR Toggle Switch with Debouncing

const int fsrPin = A0;

const int outputPin = 13;

const int pressThreshold = 200;    // Adjust based on your sensor

const int releaseThreshold = 100;  // Hysteresis prevents flickering

bool isPressed = false;

bool toggleState = false;

unsigned long lastToggleTime = 0;

const unsigned long debounceDelay = 300;

void setup() {

  pinMode(outputPin, OUTPUT);

  Serial.begin(9600);

}

void loop() {

  int fsrReading = analogRead(fsrPin);

  unsigned long currentTime = millis();

  // Detect press with hysteresis

  if (!isPressed && fsrReading > pressThreshold) {

    isPressed = true;

    // Toggle state if enough time has passed (debounce)

    if (currentTime – lastToggleTime > debounceDelay) {

      toggleState = !toggleState;

      digitalWrite(outputPin, toggleState);

      lastToggleTime = currentTime;

      Serial.print(“Toggled: “);

      Serial.println(toggleState ? “ON” : “OFF”);

    }

  }

  // Detect release

  if (isPressed && fsrReading < releaseThreshold) {

    isPressed = false;

  }

  delay(10);

}

The hysteresis (different thresholds for press and release) prevents rapid toggling when pressure hovers near the threshold.

Building Pressure Pads and Sensor Arrays

Many projects require multiple FSRs working together. Here’s how to wire and read an array of pressure sensors.

Multi-FSR Wiring

Sensor	Arduino Analog Pin	Resistor to GND
FSR 1	A0	10kΩ
FSR 2	A1	10kΩ
FSR 3	A2	10kΩ
FSR 4	A3	10kΩ

All FSRs share a common 5V connection. Each gets its own analog pin and pull-down resistor.

Multi-Sensor Code

// Reading Multiple FSRs

const int NUM_SENSORS = 4;

const int fsrPins[NUM_SENSORS] = {A0, A1, A2, A3};

const char* padNames[NUM_SENSORS] = {“Pad 1”, “Pad 2”, “Pad 3”, “Pad 4”};

int fsrReadings[NUM_SENSORS];

void setup() {

  Serial.begin(9600);

}

void loop() {

  // Read all sensors

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

    fsrReadings[i] = analogRead(fsrPins[i]);

    if (fsrReadings[i] > 50) {  // Threshold for detection

      Serial.print(padNames[i]);

      Serial.print(“: “);

      Serial.println(fsrReadings[i]);

    }

  }

  delay(50);

}

FSR Applications in Real Projects

The force sensitive resistor Arduino pairing appears across diverse applications:

Electronic Drum Pads

FSRs detect both hit presence and velocity (how hard you strike). Combined with MIDI libraries, Arduino transforms pressure data into velocity-sensitive drum triggers for digital audio workstations.

Dance Pads

Gaming dance pads use FSRs under each arrow panel. The thin profile fits beneath pad surfaces without affecting playability, while variable sensitivity allows per-panel calibration.

Robotic Grippers

FSRs on gripper fingers provide feedback for grasping objects with appropriate force. The robot can grip firmly enough to hold objects without crushing delicate items.

Smart Furniture

Pressure sensors in chairs, beds, and floor mats detect occupancy and weight distribution. Applications range from smart home automation to healthcare monitoring.

Musical Instruments

Pressure-sensitive keyboards and wind instrument controllers use FSRs to capture expression data that MIDI velocity alone can’t provide.

Troubleshooting Force Sensitive Resistor Problems

Common issues and their solutions:

Readings Stay Near Zero

Possible Cause	Solution
Loose connections	Check breadboard contacts
Wrong analog pin in code	Verify pin matches wiring
FSR damaged at crimp tabs	Inspect connection point
Pull-down resistor missing	Add 10kΩ to GND

Readings Jump Erratically

Possible Cause	Solution
Poor ground connection	Use shorter ground wire
Electrical noise	Add 0.1µF capacitor across FSR
Floating analog pins	Ground unused analog inputs

Readings Max Out Too Easily

Possible Cause	Solution
Fixed resistor too large	Try smaller value (1kΩ)
Pressing too hard	Use lighter touch
FSR rated for lower force	Use different model

Important Handling Precautions

FSRs are sensitive to heat. Never solder directly to the sensor tabs unless you’re confident in your skills. Instead, use:

• Breadboard insertion for prototyping
• Clincher connectors for permanent installations
• Screw terminals for field-serviceable designs
• Alligator clips for testing

If you must solder, use a temperature-controlled iron, work quickly (under 2 seconds), and never reheat the same joint.

Useful Resources for FSR Arduino Projects

Resource	Link	Description
Interlink FSR Guide	sparkfun.com/datasheets	Integration manual with circuit designs
Adafruit FSR Tutorial	learn.adafruit.com	Comprehensive hookup guide
Arduino IDE	arduino.cc/software	Programming environment
FSR 402 Datasheet	cdn.sparkfun.com	Technical specifications
HelloDrum Library	github.com/RyoKosaka	FSR-compatible drum library

Component Sources

Component	Suppliers
Interlink FSR 402	SparkFun, Adafruit, Digi-Key
Square FSR 406	Adafruit, Mouser
FSR Adapter Boards	SparkFun
Resistor Kits	Amazon, electronics distributors

Frequently Asked Questions

How accurate are force sensitive resistors for measuring weight?

FSRs provide roughly ±10% accuracy at best, with significant variation between individual sensors. They excel at detecting relative pressure changes and threshold events but aren’t suitable for precision weight measurement. For applications requiring accurate force data, consider strain gauges or load cells instead.

Can I use multiple FSRs with one Arduino?

Yes, you can connect as many FSRs as you have analog input pins. Arduino Uno has six analog inputs (A0-A5), allowing six simultaneous pressure sensors. Each FSR needs its own pull-down resistor but can share a common 5V supply. For more sensors, use Arduino Mega (16 analog pins) or an analog multiplexer.

What resistor value should I use for my FSR circuit?

Start with 10kΩ for general-purpose applications. If your readings cluster near zero (not sensitive enough), try a larger resistor like 47kΩ or 100kΩ. If readings max out too easily, use a smaller value like 3.3kΩ or 1kΩ. The goal is to use the full ADC range across your expected force range.

Why do my FSR readings drift over time?

FSRs exhibit hysteresis and drift, especially under sustained pressure. The sensor’s resistance may slowly change while constant force is applied, then take time to return to baseline after release. For applications requiring stable readings, implement software averaging and avoid relying on absolute values for extended periods.

Can FSRs detect the location of pressure on the sensing area?

Standard FSRs only measure total force, not position. The entire active area contributes to one resistance reading. For position sensing, you need multiple smaller FSRs arranged in a grid, or a specialized linear position sensor like the FSR 408 strip, which can indicate where along its length pressure is applied.

Moving Forward with Pressure Sensing

The force sensitive resistor Arduino combination offers an accessible entry point into pressure-sensing electronics. While FSRs won’t replace precision instruments, their low cost, thin profile, and easy integration make them valuable for interactive projects, prototyping, and applications where detecting presence and relative force matters more than exact measurements.

Start with the basic voltage divider circuit and threshold detection code. Once that works, experiment with different resistor values to optimize sensitivity for your use case. From there, scale up to multi-sensor arrays, add MIDI output for musical applications, or integrate pressure feedback into robotic systems.

The simplicity of FSRs is their strength. A few dollars in components and an afternoon of experimentation can transform static projects into pressure-responsive systems that react naturally to human touch.