Vous êtes sur la page 1sur 13

Interfaçage de la résistance de

détection de force (FSR) avec


Arduino

Force Sensing Résistances sont également connus comme la force


des résistances sensibles à ou capteurs de force ou seulement FSR . Ce sont
des capteurs peu coûteux et faciles à utiliser, spécialement conçus pour
détecter la pression physique, la compression et le poids.

Vous les trouverez dans les batteries électroniques, les téléphones mobiles,
les appareils de jeu portables et bien d'autres appareils électroniques
portables.

Bien que ces capteurs soient parfaits pour mesurer la pression, ils ne sont pas
très bons pour déterminer le poids qu'ils portent. Cependant, si vous voulez
simplement savoir «si le capteur a été pressé ou pressé et dans quelle
mesure», ils sont une bonne option pour votre prochain projet de détection
tactile.

Présentation de FSR
La technologie utilisée dans les FSR a été brevetée par Interlink
Electronics, qui fonctionne depuis 1985. Les types de FSR les plus courants
que vous trouverez facilement sont les Interlink FSR-402 et FSR-406.

Construction
Un FSR n'est rien d'autre qu'une résistance variable dont la résistance varie
lorsque la pression est appliquée à la zone de détection.

Il est composé de plusieurs fines couches flexibles. Plus il est pressé, plus les
éléments en carbone résistifs touchent les traces conductrices et cela réduit
la résistance.

Forme et taille
Il existe une variété d'options FSR et quelques caractéristiques clés telles que
la taille, la forme et la plage de détection qui les distinguent.
La plupart des FSR ont une zone de détection circulaire ou rectangulaire. Les
FSR carrés sont parfaits pour la détection sur une large zone, tandis que les
petits capteurs circulaires peuvent fournir une plus grande précision au champ
de détection.

Plage de détection
Une autre caractéristique clé du FSR est sa plage de détection nominale, qui
définit les pressions minimale et maximale que le capteur peut différencier.

Plus la force nominale est faible, plus le FSR est sensible. Toute pression au-
delà de la plage maximale du capteur n'est pas mesurable (ce qui peut
également endommager le capteur). Par exemple, un FSR plus petit de 1 kg
peut fournir des lectures plus sensibles de 0 à 1 kg, mais ne peut pas faire la
différence entre un poids de 2 kg et 5 kg.

Comment fonctionne FSR?


Comme nous l'avons dit, FSR est essentiellement une résistance qui change
sa valeur résistive en fonction de la pression sur laquelle elle a été appliquée.

Lorsqu'il n'y a pas de pression, le capteur ressemble à une résistance infinie


(circuit ouvert). Plus vous appuyez fort sur la tête du capteur, plus la
résistance entre les deux bornes sera faible, mais au fur et à mesure que vous
supprimez la pression, elle reviendra à sa valeur d'origine.

Le graphique ci-dessous affiche approximativement la résistance du capteur à


différentes mesures de force pour le capteur FSR 402. Notez que les données
sont tracées sur des échelles logarithmiques.
Notez que le graphique est généralement linéaire à partir de 50 g et plus, mais
pas en dessous de 50 g. Cela signifie que chaque fois que nous mettons une
pression dessus, sa résistance diminue rapidement de l'infini à 100K, puis
devient plus linéaire.

Lire un FSR
Le moyen le plus simple de lire le FSR est de connecter le FSR avec une
résistance de valeur fixe (généralement 10 kΩ) pour créer un diviseur de
tension. Pour ce faire, connectez une extrémité du FSR à l'alimentation et
l'autre à une résistance pull-down. Ensuite, le point entre la résistance pull-
down à valeur fixe et la résistance FSR variable est connecté à l'entrée ADC
d'un Arduino.

De cette façon, vous pouvez créer une sortie de tension variable, qui peut être
lue par l'entrée ADC d'un microcontrôleur.
Notez que la tension de sortie que vous mesurez est la chute de tension à
travers la résistance pull-down, pas à travers le FSR.

La sortie de la configuration du diviseur de tension est décrite par l'équation:

Dans la configuration représentée, la tension de sortie augmente avec


l'augmentation de la force.

Par exemple, avec une alimentation 5V et une résistance de rappel de 10K,


lorsqu'il n'y a pas de pression, la résistance FSR est très élevée (environ
10MΩ). Il en résulte la tension de sortie suivante:

Si vous appuyez vraiment fort sur le FSR, la résistance descendra à environ


250 Ω. Il en résulte la tension de sortie suivante:
Comme vous pouvez le voir, la tension de sortie varie de 0 à 5 V en fonction de
la force appliquée au capteur.

Le tableau ci-dessous indique la tension analogique approximative basée sur


la force / résistance du capteur avec une alimentation de 5 V et une résistance
de conversion 10K.

Force (lb) Force (N) Résistance FSR Tension à travers R

Rien Rien Infini 0V

0,04 lb 0,2 N 30 KΩ 1,3 V

0,22 lb 1N 6KΩ 3,1 V

2,2 livres 10N 1 KΩ 4,5 V

22 lb 100N 250Ω 4,9 V

Câblage d'un FSR à Arduino UNO


Il est assez facile de connecter FSR à un arduino.

Vous devez connecter une résistance pull-down de 10 kΩ en série avec le FSR


pour créer un circuit diviseur de tension. Ensuite, le point entre la résistance
pull-down et le FSR est connecté à l'entrée A0 ADC d'un Arduino.
Notez que les FSR sont essentiellement des résistances. Cela signifie que
vous pouvez les connecter dans les deux sens et ils fonctionneront très bien.

Code Arduino - Mesures FSR analogiques


simples
Pour notre première expérience, nous lirons les données du capteur à partir de
la broche ADC de l'Arduino et afficherons la sortie sur le moniteur série.

Le code est assez simple. Il imprime simplement ce qu'il interprète comme la


quantité de pression d'une manière qualitative. Pour la plupart des projets,
c'est à peu près tout ce dont vous avez besoin.

int fsrPin = 0; // the FSR and 10K pulldown are connected to a0


int fsrReading; // the analog reading from the FSR resistor divider

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

void loop(void) {
fsrReading = analogRead(fsrPin);
Serial.print("Analog reading = ");
Serial.print(fsrReading); // print the raw analog reading

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(1000);
}

Si tout va bien, vous devriez voir la sortie ci-dessous sur le moniteur série.

Explication du code:
L'esquisse commence par la déclaration de la broche Arduino à laquelle le FSR
et le pull-down 10K sont connectés. Nous définissons également la
variable fsrReadingqui contient la lecture analogique brute du FSR.

int fsrPin = 0;
int fsrReading;

Dans la fonction de configuration du code, nous initialisons la communication


série avec le PC.

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

En fonction de boucle, nous prenons la lecture analogique du diviseur de


résistance FSR et l'afficherons sur le moniteur série.

Comme mentionné précédemment, la tension de sortie du capteur est


comprise entre 0V (aucune pression appliquée) et environ 5V (pression
maximale appliquée). Lorsque l'Arduino convertit cette tension analogique en
numérique, il la convertit en fait en un nombre de 10 bits de 0 à 1023. Ainsi,
vous verrez une valeur entre 0 et 1023 dans un moniteur série, en fonction de
la force avec laquelle vous appuyez sur le capteur.

fsrReading = analogRead(fsrPin);

Serial.print("Analog reading = ");


Serial.print(fsrReading);

Finally, we print the amount of pressure measured qualitatively.

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");
}

Code Arduino - Mesures FSR analogiques


avancées
Notre prochaine esquisse Arduino est assez avancée. Il mesure la force de
Newton approximative mesurée par le FSR. Cela peut être très utile pour
calibrer les forces que vous pensez que le FSR subira.

int fsrPin = 0; // the FSR and 10K pulldown are connected to a0


int fsrReading; // the analog reading from the FSR resistor divider
int fsrVoltage; // the analog reading converted to voltage
unsigned long fsrResistance; // The voltage converted to resistance
unsigned long fsrConductance;
long fsrForce; // Finally, the resistance converted to force

void setup(void) {
Serial.begin(9600); // We'll send debugging information via the Serial
monitor
}

void loop(void) {
fsrReading = analogRead(fsrPin);
Serial.print("Analog reading = ");
Serial.println(fsrReading);

// analog voltage reading ranges from about 0 to 1023 which maps to 0V to 5V


(= 5000mV)
fsrVoltage = map(fsrReading, 0, 1023, 0, 5000);
Serial.print("Voltage reading in mV = ");
Serial.println(fsrVoltage);

if (fsrVoltage == 0) {
Serial.println("No pressure");
} else {
// The voltage = Vcc * R / (R + FSR) where R = 10K and Vcc = 5V
// so FSR = ((Vcc - V) * R) / V yay math!
fsrResistance = 5000 - fsrVoltage; // fsrVoltage is in millivolts so
5V = 5000mV
fsrResistance *= 10000; // 10K resistor
fsrResistance /= fsrVoltage;
Serial.print("FSR resistance in ohms = ");
Serial.println(fsrResistance);

fsrConductance = 1000000; // we measure in micromhos so


fsrConductance /= fsrResistance;
Serial.print("Conductance in microMhos: ");
Serial.println(fsrConductance);

// Use the two FSR guide graphs to approximate the force


if (fsrConductance <= 1000) {
fsrForce = fsrConductance / 80;
Serial.print("Force in Newtons: ");
Serial.println(fsrForce);
} else {
fsrForce = fsrConductance - 1000;
fsrForce /= 30;
Serial.print("Force in Newtons: ");
Serial.println(fsrForce);
}
}
Serial.println("--------------------");
delay(1000);
}

Voici à quoi ressemble la sortie sur le moniteur série.