I FSR sono sensori di pressione super robusti utilizzati in molti settori industriali. Li troverai in batterie elettroniche, telefoni cellulari, dispositivi di gioco portatili e molti altri dispositivi elettronici portatili. Questi sensori sono facili da usare e ottimi per rilevare la pressione.
In questo tutorial imparerai come funziona un FSR e come usarlo con Arduino. Ho incluso 3 esempi con schema di collegamento e codice per permetterti di iniziare a sperimentare con il tuo sensore.
Prima ti mostrerò il funzionamento base del sensore. Poi vedremo come usare questo sensore come interruttore toggle. Infine, ti mostrerò come usare i LED per indicare la quantità di pressione applicata al sensore.
Materiali
Componenti hardware
 | Sensore FSR 402 (rotondo) | × 1 | Amazon |
 | Sensore FSR 406 (quadrato) | × 1 | Amazon |
 | Arduino Uno Rev3 | × 1 | Amazon |
| Breadboard | × 1 | Amazon | |
| Cavi jumper | ~ 10 | Amazon | |
 | Scatola assortimento resistori (vedi wiring per i valori) | × 1 | Amazon |
 | LED | ~ 10 | Amazon |
| Cavo USB tipo A/B | × 1 | Amazon |
Strumenti
 | Multimetro | Amazon |
Software
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
Come funziona un FSR?
La resistenza di un FSR dipende dalla pressione applicata sull’area sensibile. Più pressione applichi, più la resistenza diminuisce. L’intervallo di resistenza è piuttosto ampio: > 10 MΩ (nessuna pressione) fino a ~ 200 Ω (pressione massima). La maggior parte dei FSR può rilevare forze da 100 g a 10 kg.
Costruzione base
Un FSR è composto da due membrane e un adesivo distanziatore. Le membrane conduttive sono separate da un sottile strato d’aria quando non viene applicata pressione. Una delle membrane contiene due tracce che vanno dalla coda all’area sensibile (la parte rotonda). Queste tracce sono intrecciate ma non si toccano. L’altra membrana è rivestita con un inchiostro conduttivo. Quando premi sul sensore, l’inchiostro mette in corto le due tracce con una resistenza che dipende dalla pressione.
Come leggere un FSR?
Il grafico sotto mostra la curva resistenza vs forza per il sensore FSR 402. Nota che i dati sono rappresentati su scale logaritmiche. La risposta non è lineare! Come vedi, c’è un enorme calo di resistenza quando si applica una piccola pressione. Dopo di che, la resistenza è inversamente proporzionale alla forza applicata. Intorno a 10 kg (non mostrato nel grafico) il sensore si satura e un aumento della forza produce poca o nessuna diminuzione della resistenza.
Circuito partitore di tensione
Per misurare la forza applicata con Arduino, devi costruire un circuito partitore di tensione con l’FSR e una resistenza di pull-down. Questo circuito crea un’uscita di tensione variabile che può essere letta dall’ingresso ADC (convertitore analogico-digitale) del microcontrollore.
Scegliere la resistenza giusta per il sensore può essere un po’ complicato e dipende dall’intervallo di forza che vuoi misurare.
Il grafico sopra mostra le curve Vout vs forza per diversi valori di R (la resistenza di pull-down). Un resistore da 10 kΩ funziona bene se vuoi usare il sensore su tutto il suo intervallo di forza (100 g a 10 kg).
Esempio di calcolo
La tensione di uscita (Vout) che misuriamo con Arduino è descritta dalla seguente equazione:
Vout = Vcc x R / (R + Rfsr)
Quindi la tensione è inversamente proporzionale alla resistenza dell’FSR. Nota che la tensione di uscita che misuri è la caduta di tensione sulla resistenza di pull-down, non sull’FSR.
Quando non viene applicata forza, la resistenza dell’FSR sarà molto alta, prendiamo 10 MΩ come esempio. Ho usato una resistenza di pull-down da 10 kΩ e una Vcc di 5 V per questo tutorial, che porta al seguente output quando non viene applicata forza:
Vout = 5 V x 10 kΩ / (10 kΩ + 10 MΩ) = 0.005 V
Quindi quasi 0 V. Se premi molto forte sull’FSR, la resistenza scenderà a circa 200 Ω. Questo porta alla seguente tensione di uscita:
Vout = 5 V x 10 kΩ / (10 kΩ + 200 Ω) = 4.9 V
Come vedi, dovresti essere in grado di misurare una tensione di uscita tra 0 e 4.9 V a seconda della forza applicata al sensore.
Specifiche FSR
La tecnologia usata negli FSR è brevettata da Interlink Electronics, attiva dal 1985. I tipi più comuni di FSR che troverai sono gli Interlink FSR 402 e FSR 406.
Queste sono le specifiche del sensore rotondo 402 che ho usato in questo tutorial.
Specifiche FSR 402
| Forza di attuazione | ~0.1N minimo |
| Intervallo di sensibilità alla forza | ~0.1N – 100N |
| Intervallo di resistenza | >10 MΩ (circuito aperto) – ~200Ω |
| Risoluzione della forza | Continua (analogica) |
| Ripetibilità della forza | ± 6% |
| Area attiva | Ø 12.7 mm |
| Spessore nominale | 0.55 mm |
| Corsa dell’interruttore | 0.15 mm |
| Durata | > 10 milioni di attuazioni |
| Alimentazione | Qualsiasi! Consuma meno di 1mA di corrente, a seconda della resistenza usata nel partitore di tensione. |
| Costo | Check price |
Per maggiori informazioni, puoi consultare il datasheet qui. Include anche dati per gli altri sensori della Serie 400.
Collegamento a un FSR
Il modo più semplice per collegare un FSR è usare una breadboard. È ottimo per prototipazione e test. Se ti serve una soluzione più permanente, ti consiglio vivamente il Amphenol FCI Clincher Connector. Puoi semplicemente agganciare questi connettori intorno alle tracce argentate del connettore e collegare facilmente cavi jumper o Dupont.
Avvertenza
Non è consigliato saldare direttamente sulle tracce argentate esposte del sensore. Il substrato si scioglierà durante la saldatura e la giunzione non terrà. Non piegare o piegare la coda dell’FSR se la stai curvando; questo può causare rotture nelle tracce argentate stampate. Interlink suggerisce un raggio minimo di curvatura di 2.5 mm.
Testare un FSR
Il modo più semplice per verificare se il tuo FSR funziona correttamente è collegarlo a un multimetro. Ho usato cavi con pinze a coccodrillo per collegare il multimetro ai terminali esposti del sensore. Imposta il multimetro in modalità misurazione resistenza (Ω) e dovresti vedere il valore della resistenza cambiare quando premi sul sensore.
Poiché l’intervallo di resistenza è molto ampio (200 kΩ a 200 Ω), è meglio usare un multimetro con funzione autorange. Se non ne hai uno, prova a cambiare manualmente le impostazioni di range. 200 kΩ dovrebbe permetterti di vedere la maggior parte dell’intervallo.
Collegamenti – Collegare un Force Sensing Resistor (FSR) a Arduino UNO
Ora che sai che il sensore funziona correttamente, è il momento di collegarlo ad Arduino. Useremo una breadboard e cavi jumper, il modo più semplice per prototipare un circuito.
Come detto nell’introduzione, devi creare un circuito con una resistenza di pull-down da 10 kΩ.
Lo schema di collegamento sotto mostra come collegare il sensore FSR ad Arduino. Nota che un FSR non è polarizzato, proprio come le normali resistenze. Non c’è un lato positivo o negativo, collegalo semplicemente nell’orientamento che preferisci.
Collega uno dei terminali dell’FSR all’alimentazione (5 V, ma anche 3.3 V va bene) e l’altro terminale all’ingresso analogico di Arduino (A0). La resistenza di pull-down da 10 kΩ va collegata tra GND e A0.
1. Esempio di codice Arduino con FSR – Lettura tensione analogica
Ora che hai collegato il sensore, puoi caricare il seguente esempio di codice usando l’IDE Arduino.
Questo sketch leggerà i dati del sensore dall’ingresso analogico di Arduino e mostrerà l’output nel monitor seriale.
Come detto prima, la tensione di uscita del sensore sarà tra 0 V (nessuna pressione) e circa 5 V (pressione massima). Le schede Arduino hanno un convertitore analogico-digitale a 10 bit multicanale. Questo significa che mapperà la tensione di ingresso tra 0 e 5 V in valori interi tra 0 e 1023. Quindi vedrai un valore tra 0 e 1023 nel monitor seriale, a seconda di quanto premi il sensore.
/* Simple example code for Force Sensitive Resistor (FSR)
with Arduino. More info: https://www.makerguides.com */
// Define FSR pin:
#define fsrpin A0
//Define variable to store sensor readings:
int fsrreading; //Variable to store FSR value
void setup() {
// Begin serial communication at a baud rate of 9600:
Serial.begin(9600);
}
void loop() {
// Read the FSR pin and store the output as fsrreading:
fsrreading = analogRead(fsrpin);
// Print the fsrreading in the serial monitor:
// Print the string "Analog reading = ".
Serial.print("Analog reading = ");
// Print the fsrreading:
Serial.print(fsrreading);
// We can set some threshholds to display how much pressure is roughly applied:
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(" - Big squeeze");
}
delay(500); //Delay 500 ms.
}
Dovresti vedere il seguente output nel monitor seriale:
Assicurati che il monitor seriale sia impostato anche a 9600 baud.
2. Usare un Force Sensing Resistor (FSR) come interruttore toggle
In questo esempio userai il sensore FSR come interruttore toggle. Puoi usare questo programma per controllare molte altre funzioni, in questo caso per accendere e spegnere un LED.
Dovrai aggiungere un LED con una resistenza al circuito, come mostrato nello schema sotto.
Il terminale negativo del LED (il terminale corto) va collegato a GND tramite una resistenza e il terminale positivo al pin digitale 2. Il valore della resistenza dipende dal colore del LED che usi. Puoi usare i seguenti valori come guida:
- Blu, Verde, Bianco o UV: 68 Ω
- Rosso, Giallo o Giallo-Verde: 150 Ω
Se non hai questi valori di resistenza, prova a trovare uno simile. Puoi anche mettere più resistenze in serie per ottenere il valore corretto.
Lo sketch sotto farà toggle del LED acceso/spento quando premi sull’FSR. Controlla il valore del pin di ingresso analogico e cambia lo stato del LED quando il valore supera 500. Questo significa che una pressione molto leggera non verrà rilevata.
Questo esempio include anche il debounce dell’input ed è basato sul Arduino Switch tutorial.
/* Example code to use Force Sensitive Resistor (FSR)
as toggle switch to control LED.
More info: https://www.makerguides.com */
// Define pins:
#define fsrpin A0
#define ledpin 2
// Define variables:
int fsrreading; // The current reading from the FSR
int state = HIGH; // The current state of the output pin
int previous = 0; // The previous reading from the FSR
// The follow variables are long's because the time,
// measured in miliseconds, will quickly become a
// bigger number than can be stored in an int
long time = 0; // The last time the output pin was toggled
long debounce = 40; // The debounce time, increase if the output flickers
void setup() {
// Begin serial communication at a baud rate of 9600:
Serial.begin(9600);
// Set ledpin as output:
pinMode(ledpin, OUTPUT);
}
void loop() {
// Read the FSR pin and store the output as fsrreading:
fsrreading = analogRead(fsrpin);
// Print the fsrreading in the serial monitor:
Serial.println(fsrreading);
// If the input just went from below 500 to above 500
// and we've waited long enough to ignore any noise on the circuit,
// toggle the output pin and remember the time:
if (fsrreading > 500 && previous < 500 && millis() - time > debounce) {
if (state == HIGH)
state = LOW;
else
state = HIGH;
time = millis();
}
digitalWrite(ledpin, state);
previous = fsrreading;
}
3. Controllare più LED con un FSR come sensore di pressione
L’esempio sotto rende facile vedere quanta pressione applichi all’FSR. Più pressione applichi, più LED si accenderanno.
Puoi collegare i LED nello stesso modo di prima, vedi lo schema sotto. I LED sono collegati ai pin digitali da 2 a 7. L’FSR è collegato nello stesso modo di prima.
Poiché la tensione di uscita dell’FSR non è lineare, ho impostato un intervallo personalizzato per accendere ogni LED. Potresti doverlo regolare leggermente per il tuo sensore.
/* Arduino example code to control multiple LEDs with a
Force Sensitive Resistor (FSR) as pressure sensor.
More info: https://www.makerguides.com */
// Define pins:
#define fsrpin A0
#define led1 2
#define led2 3
#define led3 4
#define led4 5
#define led5 6
#define led6 7
// Define variables:
int fsrreading;
void setup() {
// Begin serial communication at a baud rate of 9600:
Serial.begin(9600);
// Set LED pins as output:
pinMode(led1, OUTPUT);
pinMode(led2, OUTPUT);
pinMode(led3, OUTPUT);
pinMode(led4, OUTPUT);
pinMode(led5, OUTPUT);
pinMode(led6, OUTPUT);
}
void loop() {
// Read the FSR pin and store the output as fsrreading:
fsrreading = analogRead(fsrpin);
// Print the fsrreading in the serial monitor:
Serial.println(fsrreading);
// Control the LEDs:
if (fsrreading > 200) {
digitalWrite(led1, HIGH);
}
else digitalWrite(led1, LOW);
if (fsrreading > 450) {
digitalWrite(led2, HIGH);
}
else digitalWrite(led2, LOW);
if (fsrreading > 550) {
digitalWrite(led3, HIGH);
}
else digitalWrite(led3, LOW);
if (fsrreading > 650) {
digitalWrite(led4, HIGH);
}
else digitalWrite(led4, LOW);
if (fsrreading > 800) {
digitalWrite(led5, HIGH);
}
else digitalWrite(led5, LOW);
if (fsrreading > 900) {
digitalWrite(led6, HIGH);
}
else digitalWrite(led6, LOW);
}
File CAD
Qui sotto trovi tutti i file CAD per i sensori della Serie 400 di Interlink.
Conclusione
In questo articolo ti ho mostrato come funziona un FSR e come usarlo con Arduino.
Se hai domande, suggerimenti o pensi che manchi qualcosa in questo tutorial, lascia pure un commento qui sotto.
