Universidad Nacional de Rosario

Facultad de Ciencias Exactas, Ingeniera y

Agrimensura
Escuela de Ingeniera Electrnica
Informtica Electrnica

Trabajo Prctico Final:

Balanza Electrnica

Autores:
Nombre y Apellido

N de Legajo

Bruno Giovanon

G-3233/6

Mller Hernn

M-3985/3

Mayo / 2011

Introduccin:

En el presente trabajo se expone el diseo de una balanza que dispone

de una celda de carga, un amplificador de seal y la placa de desarrollo
DEMO9S08LC60 como convertidor analgico-digital. Se calculan sus
parmetros, la ecuacin de escala del sistema completo y los mrgenes de
error propios de toda medicin.
Objetivos:
Se proponen como objetivos de ste trabajo ampliar la utilidad de la
placa de desarrollo para poder combinar su funcionalidad con circuitos
externos, a fin de lograr recibir, transmitir, controlar o exponer datos desde o
hacia el exterior. En ste caso es de mucha utilidad el display LCD incorporado
en la placa para mostrar un valor medido a travs de un conversor analgicodigital.
Desarrollo:
Fuente de alimentacin:
Lo ms apropiado en ste caso fu la utilizacin de una fuente de PC
para alimentar la celda, el amplificador y la placa de desarrollo. Dicha fuente es
de fcil obtencin y dispone de salidas a +12, -12, +5, -5, +3,3 y 0 voltios,
valores de tensin ptimas para alimentar amplificadores operacionales.
Celda de carga:
Es el elemento sensor de peso marca REACCIN modelo CD-20 y fue
retirada de una balanza comercial.
Contiene 5 resistencias del tipo strin-gauge (4 conectadas en
configuracin puente de weatstone y 1 en serie con la alimentacin para
compensar los efectos trmicos) sujetas a una pieza de aluminio que cuando
se le aplica un esfuerzo de compresin sufre pequeos estiramientos que
actan directamente sobre las resistencias de sensado, produciendo una
tensin diferencial directamente proporcional a los Kg aplicados a la celda. La
figura 1 nuestra la disposicin de las resistencias sobre la celda.

Figura 1: Resistencias de la celda

La caracterstica es (2 +- 0,01) mV/V esto significa entrega 2mv por

cada voltio a carga mxima con un error de medicin de (0,01/2)*100%= 0,5%.
ste proyecto asume como carga mxima absoluta un peso de 10Kg y se
respeta el error absoluto, lo que dar como error de total en la celda de 1%
sobre el valor medido.
Amplificador:
En sta etapa hacemos uso de todo el conocimiento adquirido sobre
amplificadores operacionales, ya que permiten amplificar seales continuas a
modo diferencial de orden de las 100.000 veces. Dado que las seales de
tensin son del orden de los v se hace necesario amplificarla unas 1000
veces aproximadamente y ajustar los parmetros del circuito para lograr una
constante de escala y una medicin de 0 voltios cuando no hay esfuerzo sobre
la celda. El circuito utilizado se muestra en la figura 2 donde adoptamos un
circuito integrado TL082 que contiene 2 operacionales y resistencias de
tolerancia 5%

Figura 2: circuito amplificador

Los bornes S+ y S- son las conexiones de sensado de la celda, se

conectan los operacionales a +- 12v que son los mismos potenciales que los de
R2. La salida se conecta directamente al canal de entrada de la placa.
Se decide colocar un diodo Zener de 3,3v a la salida del amplificador
para limitar el valor respetando el lmite mximo de tensin admitido por el
canal de entrada. La potencia disipada por ste es un poco exesiva pero se
supone que la condicin de funcionamiento de ste es durante un tiempo muy
corto luego de que se detecta a travs de una alarma implementada y se retira
el sobrepeso. El mismo diodo tambin limita la salida a un valor positivo.
La resistencia variable R1 se usa como ajuste de rango y R2 es un
ajuste de cero que suma un valor de tensin a la salida. stos ajustes
resultaron ser dependientes entre s por lo que se debe iterar entre un ajuste y

el otro hasta lograr la caracterstica deseada. Se us un peso de 6,320 Kg

como patrn de referencia durante la calibracin.
El conjunto R5 y C1 es un filtro pasa bajos para filtrar componentes de
ruido introducidos por la fuente y dems interferencias electromagnticas
Valores:
R1 = 500
R2= 10k
R3=100k
R4=100k
R5=100
C1=470F
Z1=3,3v
AO= TL082 (amplificador operacional doble)
Conversin analgica digital:
El anlisis siguiente est basado en condiciones de amplificacin y
ajustes ideales y exentos de error, condicin nunca lograda debido al
desalinealidades del sistema.
La placa de desarrollo contiene un ADC que puede ser asignado a
cualquiera de los pines de entrada, en ste caso usamos el pin PTA3 por su
cmoda conexin con el exterior, usamos el nmero mximo de bits (12) para
aumentar resolucin, esto forma un CAD de 4096 niveles. Usamos 4000 para
la medicin y dejamos 96 para implementar una alarma por sobrepeso que
pudiera daar la celda o la entrada del microprocesador.
Con stos datos obtenemos el valor del cuanto en unidades de peso
como: 10Kg / 4000 = 2,5 gramos.
El valor de tensin mxima ser 3,3v * 4000 / 4096 = 3,22v
Si tomo como bit menos significativo la unidad de gramo (dgito) se obtiene una
ecuacin del error Kg = 1% Lectura + 3 dgitos.
Cdigo fuente:
Se desarrolla en cdigo C haciendo uso del Code Warrior, programa que
viene incorporado con la placa de desarrollo
/////////////////////////////////////////////////////////////////////////////////////////
//
// Trabajo Practico 3 Informatica Electronica
// Giovanon Bruno - Muller Hernan
// -------------------------------------------------------------------------------------/////////////////////////////////////////////////////////////////////////////////////////
#include
#include
#include
#include
#include

<hidef.h>
/* for EnableInterrupts macro */
"derivative.h" /* include peripheral declarations */
"lcd.h"
<stdio.h>
<math.h>

// Variables globales
float aux;
char salida[50];
Bool alarma=0;
float kilos;
//valor actual del peso
float cero;
//Tara

// Constantes
#define digito 1/400;
const float PreProd=4.25;

//producto de 7$ por Kilogramo

/////////////////////////////////////////////////////////////////////////////////////////
// PeriphInit
// -------------------------------------------------------------------------------------// Initializes various registers and peripherals
/////////////////////////////////////////////////////////////////////////////////////////
void PeriphInit(void)
{
// Disables COP and Enable RESET and BKGD pin
SOPT1 = 0x13;
#if !CLOCK
// Selects FEE mode for fBUS = 8 MHz
// Using crystal low-range oscillator. FLL prescaler factor (P) = 64
ICGC1 = 0x38;
// Sets MFD multiplication factor (N) to 4 and RFD divisor (R) to 1
ICGC2 = 0x20;
// Waita until FLL frequency is locked
while (!(ICGS1 & 0x08))
;
#else
// Selecta FEI mode
// Sets trimming for fBUS = 8 MHz
ICGTRM = NVICGTRM;
// Using internal reference clock. FLL prescaler factor (P) = 64
ICGC1 = 0x28;
// Sets MFD multiplication factor (N) to 14 and RFD divisor (R) to 2
ICGC2 = 0x51;
// Waits until FLL frequency is locked
while (!(ICGS1 & 0x08))
;
#endif
// Configures PTA[6..5] as output LEDs
PTAD = 0x00;
PTADD = 0x60;
// Configures PTB[7..3] as output LEDs
PTBD = 0x00;
PTBDD = 0xF8;

// Configures ADC peripheral (ADC clock = 1MHz)

// Bus clock as clock source, 12-bit conversion and divisor = 8
ADCCFG = 0x64;
// Selects ADC channel 3 (PTA3) and continuous conversion)
ADCSC1 = 0x23;
// Timer2 overflow about every 1ms
TPM2MOD = 8000;
// Stops timer2 and select 1 as prescaler divisor
TPM2SC = 0x00;
// Initializes LCD Driver Peripheral
LCDInit();
LCDOnOffState();
EnableInterrupts;
}

/////////////////////////////////////////////////////////////////////////////////////////
// Delay
// -------------------------------------------------------------------------------------// Delay of multiples of 1ms
/////////////////////////////////////////////////////////////////////////////////////////
void Delay(int del)
{
// Selects fBUS as timer2 clock source and start timer
TPM2SC = 0x08;
while(del)
if(TPM2SC&0x80)
{
del--;
// Clears TOF flag
TPM2SC &= ~0x80;
}
// Stops timer2
TPM2SC = 0x00;
}

/////////////////////////////////////////////////////////////////////////////////////////
// PrintString
// -------------------------------------------------------------------------------------// Prints a string on the LCD
/////////////////////////////////////////////////////////////////////////////////////////
void PrintString(unsigned char *str)
{
unsigned char i;
LCDClear();
for(i = 0; str[i] != 0; i++)
if (str[i] == '.')
LCDPutChar(',', i+1);

else
LCDPutChar(str[i], i+1);
}

/////////////////////////////////////////////////////////////////////////////////////////
// SlideString
// -------------------------------------------------------------------------------------// Slides strings on the LCD
/////////////////////////////////////////////////////////////////////////////////////////
void SlideString(unsigned char *str, unsigned char d)
{
unsigned char i, j, start;
for(i = 0; str[i] != 0; i++)
{
Delay(d);
LCDClear();
if(i < NUM_DIGITS)
start = 0;
else
start = i-NUM_DIGITS+1;
for(j = start; j <= i; j++){
if (str[j] == '.')
LCDPutChar(',', NUM_DIGITS-i+j);
else
LCDPutChar(str[j], NUM_DIGITS-i+j);
}
}
}

/////////////////////////////////////////////////////////////////////////////////////////
// CodifBarra
// -------------------------------------------------------------------------------------// Funcion que enciende los LEDs en forma de barra ascendente segn sea el
valor
// del mdulo de la aceleracin espacial
/////////////////////////////////////////////////////////////////////////////////////////
void CodifBarra(int hexa){
unsigned char leds;
hexa=hexa>>5;
// Divido en 8 niveles el mdulo de aceleracion
leds=0b11111111;
// Enciendo todos los LEDs
while (7-hexa>=0){ // Se ejecuta una la cantidad de veces igual a
hexa++;
// la cantidad de LEDs que sea necesario apagar
leds=leds>>1;
}
PTBD = leds<<3; //5 bits menos significativos en PTB[7..5]

PTAD = leds;

//3 bits mas significativos en PTA[7..3]

/////////////////////////////////////////////////////////////////////////////////////////
// Funcion LeerADC
// -------------------------------------------------------------------------------------// Lee el puerto que se le indica y devuelve la lectura en unidades de Kg
// restando el valor de tara y setea una bandera que simboliza un sobrepeso
// absoluto mayor que 10Kg
/////////////////////////////////////////////////////////////////////////////////////////
float LeerADC(Bool tarar) {
int i;
kilos=0;
for(i=0;i<10;i++){
//promedio sobre 10 mediciones
while(!(ADCSC1 & 0x80));
kilos=(ADCRH*255+ADCRL)+kilos;
Delay(30);
}
kilos=kilos/10;
if(kilos>=4000){
//Propongo 4000 como valor mximo medido por el
ADC
alarma=1;
return 0;
}
kilos=kilos*digito;
alarma=0;
if(tarar)
return(kilos);
return(kilos-cero);
}

/////////////////////////////////////////////////////////////////////////////////////////
//Funcion Pesar
//--------------------------------------------------------------------------------------//Lee el valor del canal ADC, lo adapta al valor en la unidad correspondiente
//y lo muestra por display
/////////////////////////////////////////////////////////////////////////////////////////
void Pesar(Bool estado){
aux=LeerADC(0);
if(estado)
sprintf(&salida, " %1.3f Kg",aux);
if(!estado){
aux=aux*PreProd;
sprintf(&salida, "%4.2f |",aux);
}
PrintString(salida);
}

/////////////////////////////////////////////////////////////////////////////////////////
//Funcion Error
//--------------------------------------------------------------------------------------//Lee el valor del canal ADC, calcula el error absoluto de la medicion
//y lo muestra por display en unidades de gramos
/////////////////////////////////////////////////////////////////////////////////////////
void Error(Bool estado){
aux=LeerADC(0);
aux=aux*10+3000*digito;
if(estado)
sprintf(&salida, "+- %3.0f g",aux);
if(!estado){
aux=aux*PreProd/10;
sprintf(&salida, "%4.2f Ct",aux);
}
PrintString(salida);
}

/////////////////////////////////////////////////////////////////////////////////////////
// MAIN
// -------------------------------------------------------------------------------------// Entry point
/////////////////////////////////////////////////////////////////////////////////////////
void main(void)
{
Bool estado;
// inicializa los perifericos
PeriphInit();
// imprime un texto de bienvenida
SlideString("trabajo final de sintesis
",130);
// tara inicial
cero=LeerADC(1);
// bucle en el que permanece por siempre
for(;;) {
if(PTCD_PTCD7==0)
cero=LeerADC(1);
if(PTCD_PTCD5==0){
estado=1;
SlideString("Peso en Kg
",130);
}
if(PTCD_PTCD4==0){
estado=0;
sprintf(&salida,"Producto de %1.1f |/kg
SlideString(&salida,130);

",PreProd);

}
Pesar(estado);
CodifBarra(0x00);
if(alarma)
CodifBarra(0xff);
for(;PTCD_PTCD3==0;)
Error(estado);
}
}

Conclusiones:
La construccin del proyecto se inicia con el sensor de peso como base
para el desarrollo de los dems componentes, como el amplificador de seal, la
programacin, la fuente y el hardware. Una robusta construccin en madera y
metal se hizo necesaria para soportar el peso al cual se somete y adems
asegura la correcta sujecin de los componentes. La fuente de PC introduca
mucho ruido al amplificador por lo que fue necesario que se extraiga fuera de la
caja metlica de sta, adems se us cable blindado y filtro pasa bajos para la
seal.
Con respecto a la conversin analgica digital se obtiene muy buena
resolucin y buena jerarqua, teniendo en cuenta que es un proyecto hogareo
con un sistema de amplificacin simple.
Con respecto a la programacin se desarroll un cdigo simple usando
muchas de las funciones de los trabajos anteriores con pequeas
modificaciones. Se pudo representar el smbolo $ modificando el smbolo de
barra vertical desde la estructura que representa cada smbolo en LCD.H.
En la figura 3 se muestra una foto del modelo terminado y funcionando
donde se observa la correcta medicin del peso en Kg del paquete de yerba.
La placa de desarrollo fue amurada ms alta sobre una placa de madera, la
cual tambin oculta la fuente y el amplificador. El modelo se conecta a la red de
220 v y slo tiene un interruptor que, una vez encendido, la balanza est lista
para realizar su funcin.

Figura 3: Modelo terminado y funcionando