Druckempfindlicher Sensor (FSR)

Kurzfassung für Eilige: Ein FSR (Force Sensitive Resistor) ist ein flacher, flexibler druckempfindlicher Widerstand. Mit einem einfachen Spannungsteiler misst du am Analog-Pin deines Arduino/ESP die Druckstärke. Für exakte Werte brauchst du eine Kalibrierung.

Key Takeaways

FSR = Widerstand sinkt bei Druck → ideal für Touch/Belegung/Force-Input

Anschluss als Spannungsteiler mit 10–47 kΩ Referenzwiderstand

Nichtlinear → relative Stufen ok, absolute Kräfte nur mit Kalibrierung

Beispielsketch für Arduino inklusive Glättung & Druckstufen

Was ist ein FSR?

Ein Force Sensitive Resistor (FSR) ist ein Sensor, dessen Widerstand mit zunehmendem Druck stark abnimmt. Er ist flach, leicht, robust und damit perfekt für User-Interfaces, Musikinstrumente, Robotik-Greifer oder Sitz-/Belegungssensoren. Für Bastelprojekte ist z. B. der Interlink FSR-402 verbreitet.

Typische Einsatzfälle

Sieh dir jetzt meinen neuen Arduino-Videokurs an: Jetzt ansehen!

Druckabhängige Tasten/Trigger (sanft ↔ stark)
Velocity-Pads für Musikcontroller
Griffkraft-Erkennung in Robotik/Wearables
Belegungssensor in Stuhl/Sitzauflage

So funktioniert der FSR

Der FSR ist piezoresistiv: Durch Druck vergrößert sich die leitende Kontaktfläche im Sensoraufbau. Ergebnis: R↓ bei F↑ (stark nichtlinear). Ohne Druck ist der Widerstand sehr groß (quasi „offen“), bei leichter Berührung im 100-kΩ‑Bereich, bei starkem Druck bis in den kΩ/100‑Ω‑Bereich. Genauigkeitswunder ist er nicht – qualitative Messungen sind seine Stärke.

Bauteile & Daten

Formen: rund (Ø ≈ 18 mm), rechteckig/streifenförmig, Matten/Arrays
Dicke: ~0,45 mm, leicht flexibel
Arbeitsbereich: reagiert ab sehr kleinen Kräften; sinnvoll bis ca. 10 N (modellabhängig)
Lebensdauer: viele 100k–Mio. Betätigungen (je nach Hersteller/Typ)
Charakteristik: logarithmisch, temperatur- und mechanikabhängig → Kalibrieren!

Schaltung: Spannungsteiler

Ziel: Die Knotenspannung steigt mit Druck und wird am Analog-Pin gemessen.

Vcc ── FSR ──●── Rfix ── GND

│

A0 (Analog)

Empfehlungen

Rfix: 10–47 kΩ (für leichte Berührungen eher 47–100 kΩ, für harte Drücke 10–22 kΩ)
Vcc: 5 V (Arduino Uno) oder 3,3 V (ESP32/ESP8266)
Noise: 100 nF vom Messpunkt nach GND kann helfen
Leitungen kurz halten, saubere Masseführung

Arduino-Beispielcode

Der Sketch liest den FSR, glättet den Wert mit einem gleitenden Mittel und teilt die Messung in Druckstufen ein.

// FSR am A0, Spannungsteiler mit 10k–47k nach GND
const int fsrPin = A0;
const float vcc = 5.0; // 5V beim UNO
const int adcMax = 1023; // 10 Bit


// Gleitender Mittelwert
const int N = 10; // Puffergröße
int buf[N]; int idx=0; long sum=0;


void setup() {
Serial.begin(115200);
for (int i=0;i<N;i++) buf[i]=0;
}


int smoothRead() {
int val = analogRead(fsrPin);
sum -= buf[idx];
buf[idx] = val;
sum += val;
idx = (idx+1)%N;
return sum / N;
}


void loop() {
int raw = smoothRead();
float voltage = (raw * vcc) / adcMax;


// Grobe Druckstufen – Schwellen ggf. anpassen
const float soft = 0.5; // leichte Berührung
const float medium = 1.5; // mittlerer Druck
const float hard = 3.0; // starker Druck


const char* level = "kein Druck";
if (voltage > soft) level = "soft";
if (voltage > medium) level = "medium";
if (voltage > hard) level = "hard";


Serial.print("ADC="); Serial.print(raw);
Serial.print(" U="); Serial.print(voltage,2); Serial.print("V ");
Serial.println(level);
delay(10);
}

ESP32-Hinweis: ADC ist 12‑Bit (0…4095) und typ. 3,3 V Referenz → Konstanten anpassen.

Kalibrierung (Kraft abschätzen)

Willst du aus der Spannung N (Newton) ableiten, brauchst du eigene Referenzmessungen.

So geht’s in 5 Schritten

Sensor mechanisch sauber lagern (flache Auflage, ggf. Gummipad)
Bekannte Gewichte/Kräfte nacheinander auflegen (z. B. 0, 0,5, 1, 2, 5, 10 N)
Je Punkt 20–50 Messwerte mitteln → Tabelle (Kraft ↔ Spannung)
In Excel/Python Kurve fitten (oft Potenzfunktion) oder Lookup-Tabelle anlegen
Im Sketch Werte in Kraftbereiche umrechnen (z. B. if/else oder Interpolation)

Pro‑Tipp: Lieber Bereiche (z. B. „leicht/mittel/stark“) als exakte N‑Werte anzeigen – stabiler und praxistauglich.

Tipps & häufige Fehler

Nichtlinearität & Drift: Temperatur/Alterung beachten → gelegentlich neu kalibrieren
Kraft verteilen: Weiche Deckschicht (Schaum/Gummi) verhindert Hot‑Spots
Vorspannung: Für „belegt/unbelegt“ eine kleine Grundlast einplanen
Rfix passend wählen: Ziel‑Spannungsbereich an den ADC anpassen
Präzision nötig? → Wägezelle/Dehnungsmessstreifen statt FSR

Praxisbeispiele

Druck‑DJ‑Pad: Lautstärke/Filter je nach Druck
Roboter-Greifer: Schließt bis Druck > Schwellwert
Sitzsensor: Belegung + „Zappelfaktor“
Game-Controller: Analoge Trigger statt On/Off

Einkaufsliste

1× FSR, z. B. Interlink FSR‑402 (rund)
1× Widerstand 10–47 kΩ (ein paar Werte zum Testen)
Kabel, Breadboard, 100 nF Kondensator (optional)
Arduino Uno/Nano oder ESP32/ESP8266

Downloads

Schaltplan (PNG): /wp-content/uploads/fsr_wiring_diagram.png
Schaltplan (SVG): /wp-content/uploads/fsr_wiring_diagram.svg
Hero-Bild (PNG): /wp-content/uploads/fsr_hero_banner.png

ALT‑Texte (Empfehlung)

fsr_hero_banner.png → „Druckempfindlicher Sensor (FSR) – Funktionsprinzip und Anschluss“

fsr_wiring_diagram.png → „FSR an Arduino als Spannungsteiler mit Rfix und A0“

fsr_wiring_diagram.svg → „Schaltplan: Force Sensitive Resistor mit Arduino“

FAQ

Wie schließe ich einen FSR an Arduino an?
Als Spannungsteiler: FSR an Vcc, Knoten an A0, Rfix (10–47 kΩ) nach GND.

Ist ein FSR ein präziser Kraftsensor?
Nein, er ist nichtlinear und driftet. Für relative Messungen top; für präzise Kräfte lieber Wägezellen.

Welche Versorgung nutze ich?
5 V beim Arduino Uno, 3,3 V bei ESP32/ESP8266. Passe die ADC‑Konstanten im Sketch an.

Wie kalibriere ich einen FSR?
Mehrere Referenzgewichte messen, Kurve/Lookup erstellen und im Code hinterlegen.

Wenn dir das Projekt gefallen hat und du von weiteren interessanten Projekten inspiriert werden willst, sieh dir doch mal mein neues E-Book »Arduino Projekte Volume 1« an!

Die beliebtesten Arduino-Projekte von StartHardware
Inklusive Schaltplan, Beschreibung und Code
Arduino-Schnellstart-Kapitel
Kompakter Programmierkurs