8

PROYECTO U. I
Aplicación de una balanza virtual mediante la simulación de un FSR

Materia: Instrumentación mecatrónica

Profesor: Ing. Darío Mendoza

Carrera: Ingeniería en Mecatrónica

NRC: 8534
22 DE JUNIO DEL 2020
UNIVERSIDAD DE LAS FUERZAS ARMADAS ESPE
Tite Ruíz Jonathan Danilo
CONTENIDO
Introducción ...........................................................................................................................................2

Objetivos ................................................................................................................................................2

Actividades desarrolladas ........................................................................................................................2

Circuito en Proteus .............................................................................................................................2

Comunicación virtual ..........................................................................................................................4

Programación en Arduino IDE ............................................................................................................6

Programación en LabVIEW ................................................................................................................7

Creación del GUI .............................................................................................................................. 11

Conclusiones ......................................................................................................................................... 13

Bibliografía ........................................................................................................................................... 13
INTRODUCCIÓN
El sensor de fuerza resistivo (FSR) es un dispositivo de película de polímero (PTF) que presenta una
disminución de la resistencia cuando aumenta la fuerza aplicada a la superficie activa. Su sensibilidad a
la fuerza está optimizada para uso en el control por toque humano de dispositivos electrónicos. Las FSRs
no son células de carga o galgas extensiométricas, aunque tengan propiedades similares. Las FSRs no
son adecuadas para medidas de precisión.

OBJETIVOS
• Realizar la simulación de un FSR mediante el software de simulación Proteus, para ejemplificar
el procesamiento de la señal obtenida a través de un sensor de fuerza real.
• Realizar un programa en Arduino que permita obtener la señal del FSR y procesarla, para
posteriormente presentarla como un valor de masa.
• Establecer la comunicación serial virtual entre los softwares Proteus y LabVIEW, para ejecutar
una transferencia de datos que permita el procesamiento de la señal del sensor en Proteus, y la
presentación de datos en LabVIEW.
• Realizar una interfaz gráfica mediante el software de simulación LabVIEW, para visualizar la
salida del procesamiento de la señal del FSR mediante la placa virtual Arduino.

ACTIVIDADES DESARROLLADAS
CIRCUITO EN PROTEUS
Para la realización del circuito en el software de simulación Proteus, se empieza por la implementación
del sensor FSR que se pretende utilizar. Proteus ya cuenta con varios dispositivos integrados que miden
la variable presión; sin embargo, al tratarse de CIs, no cumplen con la funcionalidad requerida para esta
práctica, por ello se ha optado por escoger un potenciómetro, ya que como se ha visto, un FSR es
prácticamente una resistencia que varía en magnitud con respecto a la fuerza ejercida en ella. Así, se
logra el acondicionamiento de este sensor, de la siguiente manera:

ILUSTRACIÓN 1: ACONDICIONAMIENTO DE UNA FSR

Para efectos de la simulación, se pretende trabajar con un sensor del tipo FSR 402 de la marca Interlink
Electronics. Se ha escogido el rango de 0 a 10kΩ del FSR, debido a que se trabajará en la zona en la que
la curva Fuerza vs. Resistencia, a escala logarítmica, es más lineal.

ILUSTRACIÓN 2: CURVA FUERZA VS RESISTENCIA DEL FSR 402

También se eligió un valor de resistencia RM acorde a la gráfica obtenida del datasheet del sensor,
para trabajar con una resistencia fija que se encuentra dentro del rango recomendado y fuera de los
límites de estos.

ILUSTRACIÓN 3: CURVAS DEL VOLTAJE DE SALIDA EN FUNCIÓN DE LA FUERZA APLICADA AL

FSR, TOMANDO EN CUENTA DIFERENTES VALORES DE RM

El siguiente paso para la implementación del circuito, es la elección de una placa virtual Arduino
dentro de Proteus, para conectar la señal proveniente del divisor de tensión.
 ILUSTRACIÓN 4: IMPLEMENTACIÓN DE ARDUINO VIRTUAL EN PROTEUS

COMUNICACIÓN VIRTUAL
Para poder establecer una comunicación virtual entre Proteus y Labview, se necesitan de la generación
de un par de puertos virtuales. Para este caso, se utilizará el software Virtual Serial Port, el cual
permite una fácil creación de estos puertos.

ILUSTRACIÓN 5: GENERACIÓN DE PAR DE PUERTOS VIRTUALES PARA COMUNICACIÓN SERIAL

Una vez generados los puertos virtuales, se procede a implementar el elemento que me permitirá
exportar y recibir los datos mediante uno de estos puertos en Proteus.
 ILUSTRACIÓN 6: CONEXIÓN VIRTUAL DE LA PLACA ARDUINO A UN PUERTO SERIAL.

Se configuran los parámetros del elemento COMPIM

ILUSTRACIÓN 7: CONFIGURACIÓN DE LOS PARÁMETROS DE COMUNICACIÓN DEL PUERTO

VIRTUAL COMPIM.

La entrada y salida digital en el Arduino están dadas por un switch que acciona el cambio de la
resistencia RM y un led que advierte del encendido del sistema, respectivamente.
 ILUSTRACIÓN 8: CIRCUITO FINAL IMPLEMENTADO EN PROTEUS, CON UNA ENTRADA Y UNA
SALIDA DIGITAL.

PROGRAMACIÓN EN ARDUINO IDE

La programación en Arduino se presenta a continuación, dentro del código se comentan los comandos
más importantes utilizados.

byte val1; //Primer byte de lectura del voltaje del divisor

byte val2; //Segundo byte de lectura del voltaje del divisor
char outp[1]; //Arreglo de bytes de salida
char labview; //Variable para lectura de dato de Labview
int activado = 0; //Estado de activación del sistema
boolean RM; //Estado de la resistencia RM
void setup() {
[Link](9600); //Comunicación serial a 9600 bd
pinMode(2, OUTPUT); //Pin digital 2 como salida
}

void loop() {
RM = digitalRead(3); //Lectura de estado de resistencia RM
if ([Link]()) { //¿Existen datos recibidos no leídos?
labview = [Link](); //Se lee el dato recibido
delay(2);
if (labview == 'a') {
digitalWrite(2, HIGH); //Se enciende el led que indica el inicio del sistema
activado = 1;
}
else if (labview == 'b') {
activado = 0;
 digitalWrite(2, LOW); //Se enciende el led que indica el inicio del sistema
}
if (activado == 1) {
if (RM == 0)
[Link]("10"); //Se envía el valor de 10 si existe una entrada lógica de 0
else
[Link]("03"); //Se envía el valor de 03 si existe una entrada lógica de 1

val1 = analogRead(0); //Se lee la entrada analógica

val2 = analogRead(0) >> 8;
outp[0] = val1;
outp[1] = val2;
[Link](outp[0]); //Se envía el valor analógico leído
[Link](outp[1]);
}
else {
[Link](512); //Si el sistema está apagado se envía el valor de 512
}
delay(100);
}
}

PROGRAMACIÓN EN LABVIEW
Para iniciar con el diagrama de programación, se colocaron los bloques correspondientes a la
comunicación serial que dispone LabVIEW en sus librerías, las cuales se encuentran en el apartado de
Instrument I/O -> Serial. De esta manera, se añade el bloque de VISA Configure Serial Port y sus
configuraciones iniciales para iniciar la comunicación.

ILUSTRACIÓN 9: APERTURA DEL PUERTO SERIAL CON SUS PARÁMETROS DE INICIALIZACIÓN

Donde:

• VISA resource name: Genera el desplegable de puertos COM disponibles a elegir.

• 9600: Es la velocidad en Baudios de transferencia de datos.
• 8: Es el número de bits a recibir por el puerto.
• NONE: se refiere a una paridad de datos nula.

Una vez se inicia la comunicación serial, se ingresa al ciclo While para establecer un envío y recepción
continua de datos.
 ILUSTRACIÓN 10: BUCLE WHILE EN LA PROGRAMACIÓN GRÁFICA DE LABVIEW

En el interior del bucle se inicia con un envío de datos al Arduino para controlar el inicio y cese del
sistema.

ILUSTRACIÓN 11: COMANDO DE INICIO DEL SISTEMA

Cuando la variable booleana inicio, cambia su estado a verdadero, se envía el carácter “a” que le indica
al Arduino que puede empezar a enviar datos a través del puerto.

Luego, se realiza la recepción de datos, para este caso, se receptan dos valores provenientes de proteus.
El primero se refiere al valor de la resistencia RM que se está utilizando, la cual puede ser de 10kOhm o
3KOhm, para posteriormente ser presentada en el GUI.

ILUSTRACIÓN 12: RECEPCIÓN DE VALOR DE RM

El segundo dato recibido, se refiere al valor en bits correspondiente al voltaje obtenido del divisor de
tensión. Este dato se recibe como una variable tipo string y se transforma en una palabra de bits sujeta
a una conversión posterior para obtener el valor deseado en volts.
 ILUSTRACIÓN 13: RECEPCIÓN DEL VOLTAJE MEDIDO

Una vez obtenido estos datos, se pueden calcular otros valores de interés, por ejemplo, el valor de la
resistencia FSR, teniendo en cuenta la magnitud máxima escogida 10kOhm (Se escoge esta magnitud
para poder limitar el rango de funcionamiento de la balanza, como se mostrará más adelante).

La ecuación para encontrar el valor de FSR se deduce a continuación:

 RM 
V = Vcc   
 RM + FSR 
V RM
=
Vcc RM + FSR
Vcc  RM
= RM + FSR
V
Vcc  RM
FSR = − RM
V

Esta última ecuación es la que se aplica en LabVIEW para presentar el valor de la FSR en el GUI

ILUSTRACIÓN 14: OBTENCIÓN DE VALOR DE FSR.

Otro valor de principal interés a calcular, es la fuerza aplicada al FSR, para esta aplicación, se referirá al
peso aplicado a la balanza. Para ello, se parte de la curva del sensor FSR 402 de Interlink Electronics.
 ILUSTRACIÓN 15: CURVA FUERZA VS RESISTENCIA DEL FSR 402.

En la curva se puede observar un tramo con una característica muy lineal en el intervalo de 50 g. a
10000 g., no obstante, se puede observar la escala logarítmica del marco de referencia, por ende, se
procede a obtener la ecuación de la recta, sobre esta escala, de la siguiente manera:

y = mx + b
log( y ) = m log( x) + b
log( y ) b
log( x) = −
m m
y
x=m b
10

Los valores de m y b se obtienen atendiendo a dos puntos cualesquiera de la línea en escala logarítmica

log(10) − log(0.3)
m=
log(50) − log(8000)
m = −0.69
1
= −1.4473
m
b = −m  log(50) + log(10)
b = 2.1738

Por tanto, la ecuación de la fuerza en función de la resistencia obtenida se define como:

1.4
Peso[ Kg ] =
( FSR[ K ])
1.4473
Esta ecuación es la que se programa en LabVIEW para conseguir el valor del peso a partir de dato de
FSR recibido. Esto se visualiza en el siguiente arreglo de bloques.

ILUSTRACIÓN 16: OBTENCIÓN DEL PESO A PARTIR DEL VALOR DE FSR Y RM UTILIZADAS

CREACIÓN DEL GUI

Una vez obtenidos los valores de interés, se procede con el diseño del GUI, el cual debe mostrar una
interfaz amigable e intuitiva al usuario, mostrando solo los datos relevantes. Se omitirá el proceso de
diseño y se muestra directamente el GUI final, que se presenta a continuación:
 ILUSTRACIÓN 17: INTERFAZ GRÁFICA DE USUARIO DEL SISTEMA

• Se inicia corriendo la simulación, luego, se elige el puerto por el cual se va a conectar LabVIEW,
para este caso, será el puerto COM5.
• Se presiona el botón Inicio y por consiguiente se podrán visualizar las variables presentadas en
tiempo real y su cambio al variar el potenciómetro desde Proteus, simulando de esta manera
una variación de fuerza.
CONCLUSIONES
• La ecuación de un FSR se ajusta de manera óptima a una función de la forma f(x)=1/x,
exceptuando los extremos, donde el sensor llega a su límite.
• Al seguir una función de carácter racional, se obtienen variaciones muy mínimas de la
resistencia FSR en función a una gran variación de peso a medida que el valor de peso a ser
calculado se aproxima al límite superior del sensor

BIBLIOGRAFÍA
NATIONAL INSTRUMENTS, [sin fecha]. Formula Node and Expression Node Functions. Formula
Node and Expression Node Functions - LabVIEW 2018 Help - National Instruments [en línea].
[Consulta: 23 June 2020]. Disponible en: [Link]
01/lvhowto/formula_node_and_express/.

INTERLINK ELECTRONICS, [sin fecha]. FSR 402 Data Sheet. .