You are on page 1of 11

Universidad Nacional de Rosario

Facultad de Ciencias Exactas, Ingeniería y
Agrimensura
Escuela de Ingeniería Electrónica
Informática Electrónica

Trabajo Práctico Final:
Balanza Electrónica

Autores:
Nombre y Apellido

Nº de Legajo

Bruno Giovanon

G-3233/6

Müller Hernán

M-3985/3

Mayo / 2011

Introducción:

Celda de carga: Es el elemento sensor de peso marca REACCIÓN modelo CD-20 y fue retirada de una balanza comercial. el amplificador y la placa de desarrollo. Contiene 5 resistencias del tipo strin-gauge (4 conectadas en configuración puente de weatstone y 1 en serie con la alimentación para compensar los efectos térmicos) sujetas a una pieza de aluminio que cuando se le aplica un esfuerzo de compresión sufre pequeños estiramientos que actúan directamente sobre las resistencias de sensado. 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. -5. valores de tensión óptimas para alimentar amplificadores operacionales.3 y 0 voltios. +5. controlar o exponer datos desde o hacia el exterior. Desarrollo: Fuente de alimentación: Lo más apropiado en éste caso fué la utilización de una fuente de PC para alimentar la celda. un amplificador de señal y la placa de desarrollo DEMO9S08LC60 como convertidor analógico-digital. transmitir. La figura 1 nuestra la disposición de las resistencias sobre la celda. -12.En el presente trabajo se expone el diseño de una balanza que dispone de una celda de carga. Figura 1: Resistencias de la celda . Se calculan sus parámetros. +3. En éste caso es de mucha utilidad el display LCD incorporado en la placa para mostrar un valor medido a través de un conversor analógicodigital. Dicha fuente es de fácil obtención y dispone de salidas a +12. la ecuación de escala del sistema completo y los márgenes de error propios de toda medición. produciendo una tensión diferencial directamente proporcional a los Kg aplicados a la celda.

Dado que las señales de tensión son del orden de los µv se hace necesario amplificarla unas 1000 veces aproximadamente y ajustar los parámetros del circuito para lograr una constante de escala y una medición de 0 voltios cuando no hay esfuerzo sobre la celda. Amplificador: En ésta etapa hacemos uso de todo el conocimiento adquirido sobre amplificadores operacionales.La característica es (2 +. La salida se conecta directamente al canal de entrada de la placa.12v que son los mismos potenciales que los de R2.son las conexiones de sensado de la celda.3v a la salida del amplificador para limitar el valor respetando el límite máximo de tensión admitido por el canal de entrada. ya que permiten amplificar señales continuas a modo diferencial de orden de las 100. se conectan los operacionales a +. Se decide colocar un diodo Zener de 3. 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.000 veces. El mismo diodo también limita la salida a un valor positivo. Éste proyecto asume como carga máxima absoluta un peso de 10Kg y se respeta el error absoluto.01/2)*100%= 0.0.01) mV/V esto significa entrega 2mv por cada voltio a carga máxima con un error de medición de (0. Éstos ajustes resultaron ser dependientes entre sí por lo que se debe iterar entre un ajuste y . La potencia disipada por éste es un poco exesiva pero se supone que la condición de funcionamiento de éste es durante un tiempo muy corto luego de que se detecta a través de una alarma implementada y se retira el sobrepeso. lo que dará como error de total en la celda de 1% sobre el valor medido. La resistencia variable R1 se usa como ajuste de rango y R2 es un ajuste de cero que suma un valor de tensión a la salida.5%.

h> /* for EnableInterrupts macro */ "derivative.el otro hasta lograr la característica deseada.5 gramos. en éste caso usamos el pin PTA3 por su cómoda conexión con el exterior.h" <stdio.320 Kg como patrón de referencia durante la calibración. condición nunca lograda debido al desalinealidades del sistema.h> <math. Se usó un peso de 6. usamos el número máximo de bits (12) para aumentar resolución.h" /* include peripheral declarations */ "lcd.22v Si tomo como bit menos significativo la unidad de gramo (dígito) se obtiene una ecuación del error ΔKg = 1% Lectura + 3 dígitos.3v * 4000 / 4096 = 3. El valor de tensión máxima será 3. La placa de desarrollo contiene un ADC que puede ser asignado a cualquiera de los pines de entrada. El conjunto R5 y C1 es un filtro pasa bajos para filtrar componentes de ruido introducidos por la fuente y demás interferencias electromagnéticas Valores: R1 = 500Ω R2= 10k Ω R3=100k Ω R4=100k Ω R5=100 Ω C1=470µF Z1=3.Muller Hernan // -------------------------------------------------------------------------------------///////////////////////////////////////////////////////////////////////////////////////// #include #include #include #include #include <hidef. Código fuente: Se desarrolla en código C haciendo uso del Code Warrior.h> . Con éstos datos obtenemos el valor del cuanto en unidades de peso como: 10Kg / 4000 = 2.3v AO= TL082 (amplificador operacional doble) Conversión analógica digital: El análisis siguiente está basado en condiciones de amplificación y ajustes ideales y exentos de error. Usamos 4000 para la medición y dejamos 96 para implementar una alarma por sobrepeso que pudiera dañar la celda o la entrada del microprocesador. esto forma un CAD de 4096 niveles. programa que viene incorporado con la placa de desarrollo ///////////////////////////////////////////////////////////////////////////////////////// // // Trabajo Practico 3 Informatica Electronica // Giovanon Bruno .

// Variables globales float aux. PTADD = 0x60. //producto de 7$ por Kilogramo ///////////////////////////////////////////////////////////////////////////////////////// // PeriphInit // -------------------------------------------------------------------------------------// Initializes various registers and peripherals ///////////////////////////////////////////////////////////////////////////////////////// void PeriphInit(void) { // Disables COP and Enable RESET and BKGD pin SOPT1 = 0x13. . const float PreProd=4. FLL prescaler factor (P) = 64 ICGC1 = 0x28. // Waits until FLL frequency is locked while (!(ICGS1 & 0x08)) . //valor actual del peso float cero. #else // Selecta FEI mode // Sets trimming for fBUS = 8 MHz ICGTRM = NVICGTRM. float kilos. // Using internal reference clock. Bool alarma=0.3] as output LEDs PTBD = 0x00. #endif // Configures PTA[6. // Configures PTB[7. FLL prescaler factor (P) = 64 ICGC1 = 0x38.5] as output LEDs PTAD = 0x00.25. #if !CLOCK // Selects FEE mode for fBUS = 8 MHz // Using crystal low-range oscillator.. // Waita until FLL frequency is locked while (!(ICGS1 & 0x08)) . PTBDD = 0xF8. char salida[50].. //Tara // Constantes #define digito 1/400. // Sets MFD multiplication factor (N) to 4 and RFD divisor (R) to 1 ICGC2 = 0x20. // Sets MFD multiplication factor (N) to 14 and RFD divisor (R) to 2 ICGC2 = 0x51.

while(del) if(TPM2SC&0x80) { del--. } ///////////////////////////////////////////////////////////////////////////////////////// // PrintString // -------------------------------------------------------------------------------------// Prints a string on the LCD ///////////////////////////////////////////////////////////////////////////////////////// void PrintString(unsigned char *str) { unsigned char i. // Timer2 overflow about every 1ms TPM2MOD = 8000. // Stops timer2 and select 1 as prescaler divisor TPM2SC = 0x00. LCDClear().') LCDPutChar('. for(i = 0. // Clears TOF flag TPM2SC &= ~0x80. // Selects ADC channel 3 (PTA3) and continuous conversion) ADCSC1 = 0x23. } ///////////////////////////////////////////////////////////////////////////////////////// // Delay // -------------------------------------------------------------------------------------// Delay of multiples of 1ms ///////////////////////////////////////////////////////////////////////////////////////// void Delay(int del) { // Selects fBUS as timer2 clock source and start timer TPM2SC = 0x08. // Initializes LCD Driver Peripheral LCDInit(). 12-bit conversion and divisor = 8 ADCCFG = 0x64. str[i] != 0. LCDOnOffState(). EnableInterrupts. i+1). } // Stops timer2 TPM2SC = 0x00.'. . i++) if (str[i] == '.// Configures ADC peripheral (ADC clock = 1MHz) // Bus clock as clock source.

') LCDPutChar('.else LCDPutChar(str[i]. } } } ///////////////////////////////////////////////////////////////////////////////////////// // CodifBarra // -------------------------------------------------------------------------------------// Funcion que enciende los LEDs en forma de barra ascendente según sea el valor // del módulo de la aceleración espacial ///////////////////////////////////////////////////////////////////////////////////////// void CodifBarra(int hexa){ unsigned char leds. j. for(j = start.. else LCDPutChar(str[j]. // Enciendo todos los LEDs while (7-hexa>=0){ // Se ejecuta una la cantidad de veces igual a hexa++. i+1). start. else start = i-NUM_DIGITS+1. // Divido en 8 niveles el módulo de aceleracion leds=0b11111111. j <= i.5] . if(i < NUM_DIGITS) start = 0. for(i = 0. NUM_DIGITS-i+j). } PTBD = leds<<3. LCDClear(). NUM_DIGITS-i+j). str[i] != 0. j++){ if (str[j] == '. i++) { Delay(d). hexa=hexa>>5.'. //5 bits menos significativos en PTB[7. } ///////////////////////////////////////////////////////////////////////////////////////// // SlideString // -------------------------------------------------------------------------------------// Slides strings on the LCD ///////////////////////////////////////////////////////////////////////////////////////// void SlideString(unsigned char *str. // la cantidad de LEDs que sea necesario apagar leds=leds>>1. unsigned char d) { unsigned char i.

} ///////////////////////////////////////////////////////////////////////////////////////// //Funcion Pesar //--------------------------------------------------------------------------------------//Lee el valor del canal ADC. sprintf(&salida.PTAD = leds.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. //3 bits mas significativos en PTA[7.i<10. for(i=0. kilos=0. return 0.2f |". Delay(30). } kilos=kilos*digito.. lo adapta al valor en la unidad correspondiente //y lo muestra por display ///////////////////////////////////////////////////////////////////////////////////////// void Pesar(Bool estado){ aux=LeerADC(0). if(kilos>=4000){ //Propongo 4000 como valor máximo medido por el ADC alarma=1.aux). } . " %1.i++){ //promedio sobre 10 mediciones while(!(ADCSC1 & 0x80)).aux). kilos=(ADCRH*255+ADCRL)+kilos. if(estado) sprintf(&salida. return(kilos-cero). if(!estado){ aux=aux*PreProd. "%4. } PrintString(salida).3f Kg". } kilos=kilos/10. alarma=0. if(tarar) return(kilos).

} if(PTCD_PTCD4==0){ estado=0. ". if(!estado){ aux=aux*PreProd/10.aux). // inicializa los perifericos PeriphInit(). sprintf(&salida. aux=aux*10+3000*digito.130). } PrintString(salida). if(estado) sprintf(&salida.0f g".PreProd)."Producto de %1. calcula el error absoluto de la medicion //y lo muestra por display en unidades de gramos ///////////////////////////////////////////////////////////////////////////////////////// void Error(Bool estado){ aux=LeerADC(0).2f Ct". // imprime un texto de bienvenida SlideString("trabajo final de sintesis ". // bucle en el que permanece por siempre for(. SlideString("Peso en Kg ".%3.///////////////////////////////////////////////////////////////////////////////////////// //Funcion Error //--------------------------------------------------------------------------------------//Lee el valor del canal ADC.1f |/kg SlideString(&salida. sprintf(&salida.130). . if(PTCD_PTCD5==0){ estado=1. // tara inicial cero=LeerADC(1).130). "%4.aux). "+.) { if(PTCD_PTCD7==0) cero=LeerADC(1). } ///////////////////////////////////////////////////////////////////////////////////////// // MAIN // -------------------------------------------------------------------------------------// Entry point ///////////////////////////////////////////////////////////////////////////////////////// void main(void) { Bool estado..

PTCD_PTCD3==0. La placa de desarrollo fue amurada más alta sobre una placa de madera. CodifBarra(0x00). El modelo se conecta a la red de 220 v y sólo tiene un interruptor que. Con respecto a la programación se desarrolló un código simple usando muchas de las funciones de los trabajos anteriores con pequeñas modificaciones. for(. if(alarma) CodifBarra(0xff). además se usó cable blindado y filtro pasa bajos para la señal.H. una vez encendido. la fuente y el hardware. la balanza está lista para realizar su función. La fuente de PC introducía mucho ruido al amplificador por lo que fue necesario que se extraiga fuera de la caja metálica de ésta. En la figura 3 se muestra una foto del modelo terminado y funcionando donde se observa la correcta medición del peso en Kg del paquete de yerba.) Error(estado). Se pudo representar el símbolo $ modificando el símbolo de barra vertical desde la estructura que representa cada símbolo en LCD. teniendo en cuenta que es un proyecto hogareño con un sistema de amplificación simple. la cual también oculta la fuente y el amplificador.} Pesar(estado). como el amplificador de señal. . Una robusta construcción en madera y metal se hizo necesaria para soportar el peso al cual se somete y además asegura la correcta sujeción de los componentes. Con respecto a la conversión analógica digital se obtiene muy buena resolución y buena jerarquía. } } Conclusiones: La construcción del proyecto se inicia con el sensor de peso como base para el desarrollo de los demás componentes. la programación.

Figura 3: Modelo terminado y funcionando .