Aprender

Cómo usar una resistencia sensible a la fuerza (FSR) con un Arduino

O mira todas las lecciones.

  • 526componentes en el banco de trabajo
  • 46placas funcionando ahora
  • 1.00xtiempo real, en todas las placas
Arduino Uno: una resistencia sensible a la fuerza en A0en vivo0.000 s 0.00x
Haz clic para abrirlo en el editor
Un FSR de 5 V a A0 y una resistencia de 10k de A0 a GND, en un ATmega328P simulado. Arrastra el control deslizante para presionar más fuerte.

Un FSR es una resistencia que baja cuando la presionas. Conecta una patita a 5 V y la otra a A0, pon una resistencia de 10k de A0 a GND y léela con analogRead(). Mientras más fuerte presiones, más alto será el número. Sin la de 10k no funciona en absoluto, que es el error más común al empezar.

El circuito de arriba es un FSR 402 redondo con su resistencia de 10k en un Uno. Presiona Ejecutar y arrastra el control deslizante de la almohadilla. Sin tocarla, el monitor serie imprime "A0 = 1 (4 mV)". A 20 g, más o menos el peso del toque ligero de un dedo, salta a "A0 = 221 (1080 mV)". A 100 g marca 512, a 1 kg 883 y en el máximo de la almohadilla, 2 kg, marca 938.

Abajo verás cómo funciona la almohadilla, el cableado, un sketch que clasifica las presiones en ligeras y fuertes, una almohadilla de batería que cuenta cada golpe una sola vez, cómo elegir la resistencia y qué tan cerca puedes llegar a los gramos.

Lo que necesitas

  • Un Arduino Uno
  • Una resistencia sensible a la fuerza, como la FSR 402 redonda o la FSR 406 cuadrada
  • Una resistencia de 10k (café, negro, naranja)
  • Una protoboard y cables jumper

Cableado

Componente y pinVa aNota
FSR, cualquier patita5 VUn FSR no tiene polaridad
FSR, la otra patitaA0
Resistencia de 10kDe A0 a GNDForma el divisor; sin ella A0 siempre marca 1023

Cómo funciona un FSR

Dentro de la almohadilla hay dos capas delgadas con un espacio entre ellas. Una tiene dedos de metal impresos, la otra tinta de carbono. Al presionar, la tinta toca más dedos, así que la resistencia baja. Por debajo de unos 20 g las capas no se tocan en absoluto y la almohadilla está abierta. Luego se activa en torno a 36k y sigue bajando: unos 10k a 100 g, 1.6k a 1 kg y menos de 1k a 2 kg.

Por eso la lectura salta de 1 a 221 en vez de subir poco a poco. Un FSR es bueno para "más fuerte" y "más suave". No es una báscula: dos almohadillas de la misma bolsa pueden dar lecturas bastante distintas, y una real baja un poco con una carga constante. Para peso, usa mejor una celda de carga y un HX711.

Toque ligero, apretón o presión fuerte

Este sketch lee A0 dos veces por segundo y clasifica la lectura en cuatro bandas. Presionamos la almohadilla en el simulador con cada peso por turno. Sin tocar imprimió "1 no press", a 20 g "221 light touch", a 100 g "512 squeeze" y a 1 kg "883 hard press".

Las bandas las pones tú. Imprime primero el número sin procesar, presiona la almohadilla como lo hará tu proyecto y elige los límites según lo que veas.

Clasifica la presión en bandas
const int FSR = A0;

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

void loop() {
  int reading = analogRead(FSR);
  Serial.print(reading);
  if (reading < 10) {
    Serial.println("  no press");
  } else if (reading < 300) {
    Serial.println("  light touch");
  } else if (reading < 700) {
    Serial.println("  squeeze");
  } else {
    Serial.println("  hard press");
  }
  delay(500);
}

Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.

Una almohadilla de batería que cuenta cada golpe una sola vez

El sketch de batería obvio, if (analogRead(A0) > 400) Serial.println("hit");, imprime "hit" en cada vuelta del loop mientras la almohadilla esté presionada. Presionamos con 500 g, soltamos, presionamos con 1 kg, aflojamos a 100 g sin soltar, volvimos a presionar fuerte y soltamos. Eso imprimió "hit" 156 veces.

La solución es recordar si la almohadilla está presionada. El sketch de abajo cuenta un golpe cuando la lectura sube por encima de 400 y no cuenta otro hasta que baje de nuevo por debajo de 100. El hueco entre los dos números es lo que evita que una presión que oscila alrededor de 400 cuente dos veces. Las mismas presiones imprimieron "hit 1" y "hit 2", y nada más: el afloje nunca bajó de 100, así que seguía siendo el mismo golpe.

Un golpe, una cuenta
const int HIT = 400;      // a press has to rise past this
const int RELEASE = 100;  // and fall back under this before the next one

bool down = false;
int hits = 0;

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

void loop() {
  int reading = analogRead(A0);
  if (!down && reading > HIT) {
    down = true;
    hits++;
    Serial.print("hit ");
    Serial.println(hits);
  } else if (down && reading < RELEASE) {
    down = false;
  }
  delay(5);
}

Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.

Elegir la resistencia

La resistencia fija decide qué parte del rango de la almohadilla queda en medio del ADC. Con la de 10k, 20 g marcó 221 y 2 kg marcó 938, lo que reparte todo el rango a lo largo de la escala. Una de 47k es mejor para un toque ligero: 20 g marcó 578, pero 1 kg ya marcaba 990 y el extremo superior queda aplastado. Una de 3.3k es al revés: 20 g marcó solo 85 y 2 kg marcó 802 con margen de sobra.

Así que usa 47k para una almohadilla que tocas con un dedo, 10k para la mayoría de los proyectos y 3.3k para algo en lo que te paras.

De la lectura a los gramos

El divisor da la resistencia de la almohadilla: R = 10000 * (1023 - raw) / raw. La curva típica del FSR 402 convierte eso en fuerza. El sketch de abajo hace ambas cosas. A 100 g imprimió "9980 ohms, about 100 g" y a 1 kg "1586 ohms, about 1000 g".

Coincide tan bien aquí porque la almohadilla simulada sigue la curva típica exactamente. Una almohadilla real no, y dos de la misma bolsa pueden discrepar sobre la misma presión. Usa los gramos para comparar una presión con otra en la misma almohadilla, no para pesar cosas.

Estima la fuerza
const float R_FIXED = 10000.0;  // the resistor from A0 to GND

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

void loop() {
  int raw = analogRead(A0);
  if (raw < 10) {
    Serial.println("no press");
  } else {
    float ohms = R_FIXED * (1023 - raw) / raw;
    // The FSR 402's typical curve: 10k at 100 g, falling as force^0.8.
    float grams = 100.0 * pow(10000.0 / ohms, 1.25);
    Serial.print(ohms, 0);
    Serial.print(" ohms, about ");
    Serial.print(grams, 0);
    Serial.println(" g");
  }
  delay(500);
}

Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.

Errores comunes

Dejar fuera la de 10k. Con el FSR de 5 V a A0 y nada más, A0 leyó 1023 sin tocarlo y 1023 con 100 g. No hay divisor, así que no hay nada que la presión pueda cambiar.

Esperar una lectura por debajo de 20 g. La almohadilla está abierta hasta que las capas se tocan, así que una pluma no hace nada.

Tratarlo como una báscula. Distingue bien entre más duro y más suave, pero mal los gramos. Una celda de carga es el componente para el peso.

Doblar la patita o soldarla caliente. Las pistas están impresas sobre plástico; mejor sujétalas en un conector o en una protoboard.

Presionar con la punta del dedo sobre una almohadilla grande. Solo cuenta la parte que se presiona, así que pon un pequeño taco de hule o una moneda sobre la almohadilla para repartir la fuerza de manera uniforme.

Abre este circuito en el editor. Arduino Uno: una resistencia sensible a la fuerza en A0, conectada como se muestra al inicio de esta página. Cambia un componente o un valor y ejecútalo de nuevo.

Preguntas

¿Cómo conecto un FSR a un Arduino?

Una patita a 5 V, la otra a A0, y una resistencia de 10k de A0 a GND. Léelo con analogRead(A0): alrededor de 1 sin tocar, y sube al presionar.

¿Por qué mi FSR siempre lee 1023?

Falta la resistencia de A0 a GND, así que A0 solo ve 5 V a través de la almohadilla. Agrega una de 10k de A0 a GND y la lectura baja a alrededor de 1 cuando nada la presiona.

¿Qué resistencia debo usar con un FSR?

10k para la mayoría de los proyectos. Con 47k un toque suave lee más alto pero se queda sin rango en una presión fuerte; 3.3k es al revés, para cargas pesadas.

¿Puede un FSR medir peso?

Solo aproximadamente. Su curva da un estimado en gramos, pero las almohadillas reales difieren entre sí y derivan bajo una carga constante. Para peso, usa una celda de carga con un HX711.

¿Funciona igual un FSR en un Arduino Nano?

Sí. El Nano tiene el mismo convertidor de 10 bits en un riel de 5 V, así que el mismo divisor de 10k da los mismos números: con 100 g en la almohadilla, un Nano aquí leyó 512 en A0, igual que el Uno.

Ármalo en la vida real

Abre el editor, cambia un valor y mira cómo cambia el número con él. Nada que instalar y sin necesidad de cuenta.