Sensores FSR de fuerza o Galgas.

Estos sensores permiten detectar la presión física, pulsación y peso. Son fácil de usar y de bajo costo. Esta imagen del FSR, específicamente el modelo interlink 402. La parte gris redonda es  sensible al tacto.
El FRS está  hecho de 2 capas separadas. Cuánto más se presiona, la parte redonda de tu sensor se activa, toca el semiconductor y eso hace que la resistencia disminuya.

Los FSR’S son, básicamente, una resistencia que cambia su valor de resistencia (en ohmios Ω) dependiendo de la cantidad que se presiona. Estos sensores son de bajo costo y fácil de usar pero son poco precisos. También varían algunos de sensor a sensor tal vez 10% en cuanto la exactitud. Así que básicamente, si utilizas un FSR sólo debes esperar para obtener rangos de respuesta.

Debido a que son poco exactos no se recomienda para calcular el peso en kilogramos.
Sin embargo, para la mayoría de las  aplicaciones sensibles al tacto; el FSR ha sido explotado porque es fácil de usar y barato.

 

Características.

• TAMAÑO: ½” (12,5 mm) de diámetro por 0.02 área activa” de espesor (Interlink tiene algunos que son tan grandes como 1,5”x1.5”)
• Rendimiento: Circuito Infinito / abierto (sin presión) , 100KΩ ( ligera presión ) a 200Ω (presión máx . )
• Rango de fuerza: de 0 a 20 libras (de 0 a 100 Newtons ) que se aplica de manera uniforme sobre el área de superficie de 0,125 pulgadas cuadradas.
• Fuente de alimentación: Cualquiera este sensor utiliza menos de 1 mA de corriente ( depende de las posibles resistencias de pull-up / down utilizados y voltaje de alimentación).

 

¿Cómo se mide la fuerza / presión con un sensor FSR?

Como hemos dicho, la resistencia del FSR cambia a medida que se aplica más presión. Cuando no hay presión, el sensor se parece a una resistencia infinita (circuito abierto), ya que la presión aumenta, la resistencia disminuye. Este gráfico indica aproximadamente la resistencia del sensor en diferentes mediciones de fuerza. (Ten en cuenta que la fuerza no se mide en gramos y lo que realmente se mide en Newtons).

Es importante notar que el gráfico no es lineal (es un gráfico log / log ) y que en las mediciones de fuerza especialmente bajas, rápidamente va de infinito para 100KΩ.

 

¿Cómo probar el funcionamiento de un Sensor FSR?

La forma más fácil de entender cómo funciona un FSR es conectar un multímetro en el modo de medición de resistencia a los dos pines del sensor y ver los cambios en la resistencia.

 

Cómo conectar el sensor FSR.

Los FSR son básicamente resistencias variables. La variación de la resistencia se genera por la presión ejercida en la sueprficie de dicho sensor. Son sensores no polarizados, lo que significa que puedes conectarlo de cualquier forma y  trabajarán correctamente.

 

	Los FSR´S son de polímero con material conductivo serigrafiado. Esto significa que éste plástico y el material conductivo está montado sobre un delicado material. La mejor manera de conectarse es con un protoboard.
	O utiliza un conector jumper hembra/macho.
	O una terminal tipo clema.

Puedes soldar en los pines, pero debes ser muy rápido, ten cuidando de no arruinar tu FSR. Soldar directamente solo inténtalo si estás seguro de que tienes las habilidades necesarias para hacerlo o si es tu única opción.

 

Práctica de ejemplo con un Sensor FSR.

Método de lectura voltaje analógico; La forma más fácil para medir un sensor FSR es conectar un pin de nuestro sensor al voltaje y el otro pin una resistencia PULL DOWN a tierra. El punto intermedio, es decir, entre el arreglo de resistencia PULL-DOWN y la variable del FRS es conectado a una entrada analógica del microcontrolador Arduino  (como se muestra en la imagen).

Diagrama de resistencia PULL-DOWN y PULL- UP.

Por ejemplo, se muestra con 5 volts, pero puedes también alimentarlo con 3.3 volts.
La forma en que funciona, es que a medida que la resistencia de tu FSR disminuye, la resistencia total del sensor y la resistencia pull-down disminuye desde 100k ohmios a 10K ohmios. Esto significa que la corriente que pasa a través de ambas resistencias aumenta, lo que a su vez provoca que el voltaje de la resistencia  de 10K aumenta la resistencia.

Esta tabla indica el voltaje analógico aproximado basado en el sensor de fuerza/resistencia /5V y de resistencia 10K pull-down. Ten en cuenta que nuestro método toma algo de resistividad lineal pero no proporciona tensión lineal. Es porque la ecuación de tensión es:

Vo = Vcc (R / (R + FSR)

 

Ejemplo con un Diodo LED.

 

 

Conecta el FSR al igual que el ejemplo anterior, pero esta vez agrega un LED en el pin 11.
Acuerdate de utilizar una resistencia en pull-down o pull-up.

.

 

El siguiente código hace la lectura del voltaje analógico para determinar el  brillo de tu led rojo. Cuanto más se presiona el FSR, el led es más brillante. Recuerda que el LED tiene que estar conectado a un pin PWM(Pulso con modulación) para que funcione, usa el pin 11 para este ejemplo.

 

[code language=»java»]

/ * FSR
<ol>
<li>Conecta un extremo del FSR a 5V,y el otro extremo a Analog 0.</li>
<li>conecta un extremo de la resistencia de 10K de a0 a tierra .</li>
<li>Conecta tu led al pin 11, y la otra patita a tierra.</li>
<li></li>
<li>int fsrAnalogPin = 0; // FSR esta conectado a analog 0</li>
<li>int LEDpin = 11; // conecta el led al pin 11 (PWM pin)</li>
<li>int fsrReading; // la lectura analógica desde el resistor de FSR</li>
<li>int LEDbrightness;</li>
<li>void setup (void) {</li>
<li>begin(9600); // Podemos enviar la información de depuración al monitor serial</li>
<li>pinMode (ledPin, OUTPUT);</li>
</ol>
<ul>
<li>}</li>
</ul>
<ul>
<li>void loop (void) {</li>
</ul>
<ol start="15">
<li>fsrReading = analogRead (fsrAnalogPin);</li>
<li>print ( "lectura analógica =");</li>
<li>println (fsrReading);</li>
<li></li>
<li>// Necesitamos cambiar el rango de la lectura analógica(0-1023) debajo del rango.</li>
<li>// utilizada por analogWrite (0-255)</li>
<li>LEDbrightness = map (fsrReading, 0, 1023, 0, 255);</li>
<li>// LED se hace más brillante cuanto más fuerte se presiona</li>
<li>analogWrite (ledPin, LEDbrightness);</li>
<li></li>
<li>de retardo (100);</li>
<li></li>
<li>}</li>
<li></li>
</ol>
[/code]

Aquí se muestra el funcionamiento del sensor ya conectado.

Y si abres el monitor serial debe de aparecer esto.

 

Código sencillo para señales analógicas de un FSR.

Aquí es un ejemplo de código para la medición del FSR en un pin analógico.

No olvides conectarlo a pull-down.

Este código no hace ningún cálculo, sólo imprime lo que interpreta la cantidad de presión de una manera cualitativa. Para la mayoría de los proyectos, esto es prácticamente todo lo que se necesita.

1. / *  FSR.
3. conecta una patita de FSR a voltaje,y el otro en A0.
4. debes conectar la resistencia de 10K en A0 a tierra
7. int fsrPin = 0; // el FSR y 10K pulldown son conectados al pin a0
8. int fsrReading; // la lectura analógica del FSR
9. void setup (void)

• //La información de depuración puedes enviarla al Serial monitor

11. comenzar (9600);

• }

• void loop (void) {

15. fsrReading = analogRead (fsrPin);
17. print(«lectura analógica = «);
18. print(fsrReading); // la lectura analógica
20. // Si (fsrReading <10) {
21. println(» – sin apretar»);
22. } Else if (fsrReading <200) {
23. println(» -poco tocar»);
24. } Else if (fsrReading <500) {
25. println(» – ligero apretar»);
26. } Else if (fsrReading <800) {
27. println(» – Medio apretar»);
28. } Else {
29. println(» – Aprieta fuerte»);
30. }
31. retardo (1000);

• }

Se muestra el funcionamiento del fsr y el monitor serial

Código para mediciones analógicas de un FSR

Se tiene conectado el FSR a 5 volts del Arduino con una resistencia de 10K a GND (tierra) y el sensor se lee en el pin analógico 0. Nuestro FSR medirá la fuerza de Newton aproximada. Esto puede ser muy útil para calibrar los cambios que experimentan fuerzas.

1. / * FSR
3. conecta tu FSR a voltaje , y la otra patita en a0.
4. conecta la resistencia de 10k a tierra

 

5. int fsrPin = 0;   // el FSR y 10K pulldown son conectados en a0
6. int fsrReading; // la lectura del FSR
7. int fsrVoltage; // la lectura analógica es convertida a voltaje
8. unsigned long fsrResistance; //el voltaje convertido en resistencia.
9. fsrConductance largo sin signo;

• long fsrForce; //finalmente la resistencia se convierte ne fuerza

• void setup (void) {

13. begin(9600); //enviamos la depuración al monitor serial

• }

• void loop (void) {

17. fsrReading = analogRead (fsrPin);
18. print ( «lectura analógica =»);
19. println (fsrReading);
21. // Lectura de tensión analógica oscila entre 0 y 1023 que asigna a 0V a 5V (= 5000mV).
22. fsrVoltage = map (fsrReading, 0, 1023, 0, 5000);
23. print(«Voltaje leído en mV = «);
24. println (fsrVoltage);
26. si (fsrVoltage == 0) {
27. println(«sin presionar»);
28. } Else {
29. // el voltaje es = Vcc * R / (R + FSR) cuando R = 10K y Vcc = 5V
30. // entonces el FSR = ((Vcc – V) * R) / V.
31. fsrResistance = 5000 – fsrVoltage; // FsrVoltage es en milivoltios por lo 5V = 5000mV
32. fsrResistance *= 10000; // resistencia de 10k
33. fsrResistance / = fsrVoltage;
34. print(«lectura de FSR en ohms = «);
35. println (fsrResistance);
37. fsrConductance = 1000000; // podemos medir en miliohms   fsrConductance /= fsrResistance;
38. print(«Conductancia en mloOmhos: «);
39. println (fsrConductance);
41. // Utiliza de guía la gráfica del FSR para aproximarse.
42. si (fsrConductance <= 1000) {
43. fsrForce = fsrConductance / 80;
44. print(«Fuerza en Newtons: «);
45. println (fsrForce);
46. } Else {
47. fsrForce = fsrConductance – 1000;
48. fsrForce / = 30;
49. print(«Fuerza en Newtons: «);
50. println (fsrForce);
51. }
52. }
53. println ( «——————–«);
54. retardo (1000);
55. }

Lectura del FSR sin pines analógicos.

Es posible utilizarse incluso si no se tiene ningún pin análogo en el microcontrolador (es decir que si quieres conectar más de los pines analógicos que hay). La forma de hacer esto es mediante el aprovechamiento de una propiedad electrónica básica de resistencias y capacitores. Resulta que si tomas un capacitor que almacena, inicialmente no hay tensión y luego lo conectas a la corriente a través de un resistor, se carga el voltaje de alimentación lentamente. Cuanto mayor sea la resistencia, más lento es.
Esta imagen de un osciloscopio muestra lo que ocurre en el pin digital (amarillo).  La línea azul indica cuándo empieza a contar y cuando el rango es completo, unos 1.2 ms más tarde.

Esto pasa porque el capacitor actúa como un almacén y la resistencia es como un tubo delgado. Para llenar un almacén con un tubo muy delgado tarda bastante, puedes averiguar qué tan amplio es el tubo por el tiempo que tarda para llenar el almacén a la mitad.

En este caso, nuestro ‘almacén’ es un capacitor cerámico de 0.1uF. Se puede cambiar el capacitor de casi cualquier for, pero los valores de sincronización también cambiarán, 0.1uF parece ser un buen lugar para empezar con informes de estabilidad.
CÓDIGO

1. Conecta el FSR al voltaje, y el otro al pin 2.
2. el capacitor de 0.1uF conectado al pin 2 a tierra
5. int fsrPin = 2; // El fsr está conectado al pin2
6. int fsrReading; // lectura digital
7. int ledPin = 13; // puedes usar un led
9. void setup (void) {
10. //podemos enviar la información de depuración al monitor serial
11. comenzar (9600);
12. pinMode (ledPin, OUTPUT); // Haber un LED para la salida
13. }
14. void loop (void) {
15. //lee la resistencia por el método RCtime

16. fsrReading = RCtime (fsrPin);
18. si (fsrReading == 30000) {
19. // si se consiguen 3000 significa que el tiempo terminó
20. println(«Nada conectado!»);
21. } Else {
22. print(«RCtime leyendo = «);
23. println(fsrReading); //la lectura analógica
24. // proceso que mantiene el led parpadeando

27. fsrReading / = 10;
28. // entre más lo presiones incrementa el parpadeo
29. digitalWrite (ledPin, HIGH);
30. retardo (fsrReading);
31. digitalWrite (ledPin, LOW);
32. retardo (fsrReading);
33. }
34. de retardo (100);
35. }
36. // Utiliza un pin digital para medir una resistencia (como un FSR o célula fotoeléctrica!) // Hacemos esto por tener la resistencia actual de alimentación en un capacitor.
37. //Contando el tiempo que se tarda en llegar a Vcc/2 (para la mayoría de los arduinos, eso es 2,5 V).
38. int RCtime(int RCpin) {
39. int reading = 0; // inicia con 0

41. // establece el pin a una salida y llegar a BAJO
42. pinMode (RCpin, OUTPUT);
43. digitalWrite (RCpin, LOW);
45. // ahora se establece el pin para la entrada
46. pinMode (RCpin, INPUT);
47. while (digitalRead(RCpin) == LOW) { //Cuenta el tiempo que tarda en subir
48. reading++; //incremento de acuerdo al tiempo
50. si (== 30000 de lectura)
51. {
52. // si hemos llegado hasta este punto, la resistencia esta EN alto // su probable que algo esté mal conectado
53. break; // rompe el bucle
54. }
55. }
56. //esperamos que devuelva la lectura
57. retunr reading;
58. }

Es posible calcular la resistencia real de la lectura, pero desafortunadamente, las variaciones en el FSR y Arduino lo harán poco preciso. Debemos ser conscientes de que si cambia versiones FSR del sistema operativo, o utilizar un 3.3V arduino en vez de 5V, o cambio de 16 Mhz Arduino a un 8 Mhz (como lilypad) puede haber diferencias debido a que tarda para leer el valor de un pin. Generalmente eso no es gran cosa pero puede hacer que su proyecto sea difícil de depurar.