Balanza electrónica utilizando un sensor de presión

resistivo utilizando Arduino

Objetivo: medir el peso en onzas, utilizando una balanza física, circuitería y software de programación
(hiperterminal de Arduino).

Este proyecto requiere los siguientes materiales:

 1 Arduino UNO
 1 sensor de presión
 1 LM 258
 2 resistencias de 1kOhm
 1 resistencia de 100kOhms
 2 LED's (rojo y verde)
Para empezar, cabe aclarar que el sensor utilizado para este tipo de proyecto no es el ideal para medir
peso. Por lo tanto este diseño se basa en un modelo estadístico para aproximar lo más posible el peso.
Pero mejor empecemos hablando del sensor para entender ¿por qué no sirve funciona correctamente
para esta implementación?

Empecemos porque ese sensor es resistivo, recordemos el comportamiento de una resistencia variable
medida con un multimetro: tratamos de ajustar un valor, pero siempre cambia y no es estable. Así es el
comportamiento de este sensor, incluso en el lugar donde se hace presión si se cambia da otros valores,
así que hay que tener muy en cuenta este factor.

Según la hoja de datos este es el comportamiento del sensor:

A una mayor fuerza ejercida sobre el sensor, menor será la resistencia. Además de eso, la hoja de datos
nos proporciona varios circuitos, el que yo utilicé fue este:
El AmpOp es un LM258, RM es la resistencia fija, la gráfica de la par explica que valores podemos tomar
para esa resistencia y obviamente su comportamiento. Cabe resaltar que el comportamiento no es
exactamente igual, pero es similar, por ejemplo si usas la resistencia de 100K no te llegara a 4.7v sino
que llegaría a unos 3.7 - 4.2v (Es muy importante para tu modelación que pruebes antes este circuito).

A mí no me dejó satisfecho el comportamiento de este circuito, así que decidí hacer el divisor de voltaje
que hay entre RM y FSR invertido, el resultado obviamente es inverso, pero me gustó más los resultados
muestreados. El circuito que use para todo el proyecto es el siguiente, tiene un led rojo para marcar el
límite de operación del sensor (además este led parpadea cuando no hay un sensor conectado al circuito)
y uno verde que indica que no sobre pasa el límite. El circuito fue hecho en Fritzing (¿Por qué Fritzing?
Porque con este programa podemos hacer shields y conectarlo al Arduino sin necesidad de cables):

Obteniendo la siguiente gráfica (basada en la medición de algunos objetos con un peso ya definido y
tabulándolos):
Así que con los datos medidos, es hora de hacer una regresión (si miran la gráfica tiende a una función
logarítmica, por lo tanto realicé una regresión logarítmica) con mi calculadora voyage 200.
 Luego de la obtención de la ecuación de regresión se estimó los posibles rangos de medición para cada
peso:
Valor medido Valor mostrado Límite Límite
(oz) regresión inferior superior
0 #¡NUM! #¡NUM! #¡NUM!
0.25 184 179 189
0.5 153 148 158
0.75 135 130 140
1 122 117 127
1.5 104 99 109
2 92 87 97
3 74 69 79
4 61 56 66
5 51 46 56
6 43 38 48
7 36 31 41
8 30 25 35
9 25 20 30
10 20 15 25
11 16 11 21
12 12 7 17
13 8 3 13
14 5 0 10
15 2 -3 7
16 -1 -6 4

Secuencia del programa:

1. Lee pin analógico
2. Compara el valor con un valor equivalente a la desconexión del sensor
a. Si es afirmativo:
i. Enciende y apaga el led rojo
ii. lee el pin analógico
 iii. Regresa a paso 2
b. Si es negativo:
i. Continua con programa
3. Repetir 5 veces
a. lee pin analógico
b. Compara en los distintos rangos definidos en la tabla para cada valor
i. Si es afirmativo
1. envía valor de onzas
ii. Si es negativo
1. continua el programa
c. Retardo 500 milisegundos
d. Vuelve a paso 3, hasta cumplir condición
4. Compara el valor del pin analógico
a. Si el valor no excede el rango de lectura normal
i. Led verde = ON
ii. Led rojo = OFF
b. Si el valor excede el rango de lectura normal
i. Led verde = OFF
ii. Led rojo = ON
5. Fin de comparación
6. Reestablece variable
7. Retardo de 1.5 segundos
8. Regresa a paso 1

Código del programa con comentarios:

int secuencia = 0;
int Pinanalogo = A0; // coloco en una variable el pin analogo
int valor = 0; // variable que almacenará la lectura analóga
void setup() {
Serial.begin(9600); //inicia el protocolo de comunicación a PC
pinMode(2,OUTPUT); //pin digital 2 salida
pinMode(3,OUTPUT); //pin digital 3 salida
}
void loop() {
valor = analogRead(Pinanalogo);
while (valor > 600)
{
digitalWrite(3,LOW); //pin digital 3 en 0 lógico
delay (150);
digitalWrite(3,HIGH); //pin digital 2 en 1 lógico
delay (150);
valor = analogRead(Pinanalogo);
}
digitalWrite(3,LOW); //pin digital 3 en 0 lógico
for (secuencia=0;secuencia<6;secuencia++)
{
valor = analogRead(Pinanalogo); // almacena en "valor" la lectura analoga
if (valor > 178 && valor< 188) //condicion para 0.25 onza
{
Serial.println("0.25 onza");
}
if (valor > 148 && valor< 158) //condicion para 0.5 onza
{
Serial.println("0.5 onza");
}
if (valor > 130 && valor< 140) //condicion para 0.75 onza
{
Serial.println("0.75 onza");
}
if (valor > 115 && valor< 127) //condicion para 1 onza
{
Serial.println("1 onza");
}
if (valor > 99 && valor< 109) //condición para 1.5 onzas
{
Serial.println("1.5 onzas");
}
if (valor > 86 && valor< 96) //condicion para 2 onzas
{
Serial.println("2 onzas");
}
if (valor > 68 && valor< 78) // condición para 3 onzas
{
Serial.println("3 onzas");
}
if (valor > 55 && valor< 65) //condición para 4 onzas
{
Serial.println("4 onzas");
}
if (valor > 45 && valor< 55) //condición para 5 onzas
{
Serial.println("5 onzas");
}
if (valor > 37 && valor< 47) //condición para 6 onzas
{
Serial.println("6 onzas");
}
if (valor > 30 && valor< 40) //condición para 7 onzas
{
Serial.println("7 onzas");
}
if (valor > 24 && valor< 34) //condición para 8 onzas
{
Serial.println("8 onzas");
}
if (valor > 19 && valor< 29) //condición para 9 onzas
{
Serial.println("9 onzas");
}
if (valor > 21 && valor< 25) //condición para 10 onzas
{
Serial.println("10 onzas");
}
if (valor > 17 && valor< 20) //condición para 11 onzas
{
Serial.println("11 onzas");
}
if (valor > 12 && valor< 16) //condición para 12 onzas
{
Serial.println("12 onzas");
}
if (valor > 9 && valor< 13) //condición para 13 onzas
 {
Serial.println("13 onzas");
}
if (valor > 6 && valor< 10) //condición para 14 onzas
{
Serial.println("14 onzas");
}
if (valor > 5 && valor< 7) //condición para 15 onzas
{
Serial.println("15 onzas");
}
if (valor > 0 && valor< 4) //condición para 16 onzas
{
Serial.println("16 onzas");
}
delay(500);
}
if (valor > 30) //condiciones para leds
{
digitalWrite(3,LOW); //pin digital 3 en 0 lógico
digitalWrite(2,HIGH); //pin digital 2 en 1 lógico
}
else
{
digitalWrite(2,LOW); //pin digital 2 en 0 lógico
digitalWrite(3,HIGH); // pin digital 3 en 1 lógico
}
secuencia=0;
delay(1500); // retardo 1.5 segundos
}
Recomendaciones:
 Utilizar un Amplificador Operacional en modo de seguidor de corriente, es una técnica que se
debe aplicar al momento de leer un valor analógico, de esta manera estamos protegiendo al
microcontrolador, ya que el Amplificador Operacional en esta configuración se comporta:
Ventrada=Vsalida.
 Utilizar indicadores visuales al momento de alguna falla como lo son LED's, así se podrá tener
una noción de lo que está sucediendo.
 Realizar un buen diseño de balanza para que pueda concentrar en un solo punto la fuerza
ejercida al sensor resistivo y así tener una lectura más o menos constante.
 Utilizar los "shields" para Arduino simplifican la conexión a través de alambres y evita que las
soldaduras se puedan quebrar ya que no se usan alambras para conectar al Arduino.
 Utilizar un sensor de peso en lugar del sensor de presión resistivo, como lo habíamos indicado
en los retos encontrados, este sensor no es bueno para medir el peso de objetos, sino más bien para
medir el empuje o presión que alguien o algo ejerce al sensor. Recomendamos que se utilice este sensor:
http://www.sparkfun.com/products/10245. Claramente se puede observar en sus especificaciones que fue
diseñado para medir peso y no fuerza como el sensor resistivo.