Vous êtes sur la page 1sur 9

Interfaçage du capteur Flex

avec Arduino

Un capteur de flexion ou capteur de courbure est un capteur économique et


facile à utiliser spécialement conçu pour mesurer la valeur de la déflexion ou
de la flexion.

Il est devenu populaire dans les années 90 en raison de son utilisation dans le
Nintendo Power Glove comme interface de jeu. Depuis lors, les gens l'utilisent
comme goniomètre pour déterminer le mouvement des articulations, un
capteur de porte, un interrupteur de pare-chocs pour la détection de mur ou un
capteur de pression sur des pinces robotiques.

Présentation du capteur Flex


Un capteur flexible est essentiellement une résistance variable dont la
résistance varie lors de la flexion. Étant donné que la résistance est
directement proportionnelle à la quantité de flexion, on l'appelle souvent
un potentiomètre flexible .

Les capteurs Flex sont généralement disponibles en deux tailles: l'une mesure
5,588 cm (2,2 pouces) et l'autre 4,5 pouces (11,43 cm).

Construction
Un capteur flexible consiste en un substrat en résine phénolique avec une
encre conductrice déposée. Un conducteur segmenté est placé sur le dessus
pour former un potentiomètre flexible dans lequel la résistance change lors de
la déviation.
Mode d'emploi
Les capteurs Flex sont conçus pour fléchir dans une seule direction - loin de
l'encre (comme indiqué sur la figure). Plier le capteur dans une autre direction
peut l'endommager.

Veillez également à ne pas plier le capteur près de la base, car le bas du


capteur (où les broches sont serties) est très fragile et peut se casser lorsqu'il
est plié.

Comment fonctionne Flex Sensor?


L'encre conductrice imprimée sur le capteur agit comme une
résistance. Lorsque le capteur est droit, cette résistance est d'environ 25k.
Lorsque le capteur est plié, la couche conductrice est étirée, ce qui entraîne
une section transversale réduite (imaginez étirer un élastique). Cette section
transversale réduite se traduit par une résistance accrue. À un angle de 90 °,
cette résistance est d'environ 100KΩ.

Lorsque le capteur est à nouveau redressé, la résistance revient à sa valeur


d'origine. En mesurant la résistance, vous pouvez déterminer à quel point le
capteur est plié.

Lecture d'un capteur Flex


Le moyen le plus simple de lire le capteur flexible est de le connecter à une
résistance de valeur fixe (généralement 47 kΩ) pour créer un diviseur de
tension. Pour ce faire, connectez une extrémité du capteur à l'alimentation et
l'autre à une résistance pull-down. Ensuite, le point entre la résistance pull-
down à valeur fixe et le capteur flex 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 Arduino.
Notez que la tension de sortie que vous mesurez est la chute de tension à
travers la résistance de tirage vers le bas, et non à travers le capteur flexible.

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 diminue avec


l'augmentation du rayon de courbure.

Par exemple, avec une alimentation 5V et une résistance pull-down 47K,


lorsque le capteur est plat (0 °), la résistance est relativement faible (environ
25kΩ). Il en résulte la tension de sortie suivante:

Lorsqu'elle est complètement fléchie (90 °), la résistance monte à 100KΩ. Il en


résulte la tension de sortie suivante:
Câblage du capteur Flex à Arduino UNO
Il est assez facile de connecter un capteur flex à un arduino.

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


capteur flexible 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 capteurs flexibles sont essentiellement des résistances. Cela


signifie que vous pouvez les connecter dans les deux sens et ils
fonctionneront très bien.

Code Arduino
Voici un schéma simple qui lit les données du capteur à partir de la broche
ADC de l'Arduino et imprime la sortie sur le moniteur série. Pour la plupart des
projets, c'est à peu près tout ce dont vous avez besoin.

const int flexPin = A0; // Pin connected to voltage divider


output

// Change these constants according to your project's design


const float VCC = 5; // voltage at Ardunio 5V line
const float R_DIV = 47000.0; // resistor used to create a voltage divider
const float flatResistance = 25000.0; // resistance when flat
const float bendResistance = 100000.0; // resistance at 90 deg

void setup() {
Serial.begin(9600);
pinMode(flexPin, INPUT);
}

void loop() {
// Read the ADC, and calculate voltage and resistance from it
int ADCflex = analogRead(flexPin);
float Vflex = ADCflex * VCC / 1023.0;
float Rflex = R_DIV * (VCC / Vflex - 1.0);
Serial.println("Resistance: " + String(Rflex) + " ohms");

// Use the calculated resistance to estimate the sensor's bend angle:


float angle = map(Rflex, flatResistance, bendResistance, 0, 90.0);
Serial.println("Bend: " + String(angle) + " degrees");
Serial.println();

delay(500);
}

Si tout va bien, vous devriez voir un changement dans le calcul de la résistance


et de l'angle estimé lorsque vous pliez le capteur de flexion.
Explication du code:
L'esquisse commence par la déclaration de la broche Arduino à laquelle le FSR
et le 47K pulldown sont connectés.

const int flexPin = A0;

Ensuite, nous définissons quelques constantes: VCCla tension de votre


système, R_DIVla résistance utilisée pour créer un diviseur de
tension flatResistanceet bendResistancela résistance de votre capteur flexible
lorsqu'il est plat et plié à 90 °. Assurez-vous que vous définissez ces
constantes avec précision.

const float VCC = 5;


const float R_DIV = 47000.0;
const float flatResistance = 25000.0;
const float bendResistance = 100000.0;
Dans la fonction de configuration du code, nous initialisons la communication
série avec le PC et définissons flexPincomme INPUT.

void setup() {
Serial.begin(9600);
pinMode(flexPin, INPUT);
}

En fonction de boucle, nous prenons d'abord la lecture ADC.

int ADCflex = analogRead(flexPin);

Lorsque l'Arduino convertit cette tension analogique en numérique, il la


convertit en un nombre de 10 bits de 0 à 1023. Donc, pour calculer la tension
de sortie réelle, nous utilisons la formule ci-dessous:

float Vflex = ADCflex * VCC / 1023.0;

Ensuite, nous calculons la résistance du capteur flexible à l'aide de la formule


dérivée de la formule du diviseur de tension et l'affiche sur le moniteur série.

float Rflex = R_DIV * (VCC / Vflex - 1.0);


Serial.println("Resistance: " + String(Rflex) + " ohms");

Enfin, nous utilisons la résistance calculée pour estimer l'angle de courbure du


capteur. Pour ce faire, nous utilisons la map()fonction intégrée de l'EDI .

La map()fonction cartographie et convertit la résistance du capteur en angle de


courbure du capteur. Ainsi, lorsque nous appelons map(Rflex, flatResistance,
bendResistance, 0, 90.0), la valeur de flatResistanceserait mappée à 0 °, une
valeur de bendResistance90 ° et des valeurs intermédiaires à des valeurs
intermédiaires.

float angle = map(Rflex, flatResistance, bendResistance, 0, 90.0);


Serial.println("Bend: " + String(angle) + " degrees");
Serial.println();