Universidad Nacional de RosarioFacultad 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: valores de tensión óptimas para alimentar amplificadores operacionales. -5. Figura 1: Resistencias de la celda . controlar o exponer datos desde o hacia el exterior. la ecuación de escala del sistema completo y los márgenes de error propios de toda medición. -12.En el presente trabajo se expone el diseño de una balanza que dispone de una celda de carga. produciendo una tensión diferencial directamente proporcional a los Kg aplicados a la celda. Se calculan sus parámetros. Objetivos: Se proponen como objetivos de éste trabajo ampliar la utilidad de la placa de desarrollo para poder combinar su funcionalidad con circuitos externos. Celda de carga: Es el elemento sensor de peso marca REACCIÓN modelo CD-20 y fue retirada de una balanza comercial.3 y 0 voltios. +5. un amplificador de señal y la placa de desarrollo DEMO9S08LC60 como convertidor analógico-digital. Dicha fuente es de fácil obtención y dispone de salidas a +12. transmitir. 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. 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. el amplificador y la placa de desarrollo. La figura 1 nuestra la disposición de las resistencias sobre la celda. a fin de lograr recibir. +3. 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. Se decide colocar un diodo Zener de 3. lo que dará como error de total en la celda de 1% sobre el valor medido.000 veces.son las conexiones de sensado de 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.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. Éste proyecto asume como carga máxima absoluta un peso de 10Kg y se respeta el error absoluto.01/2)*100%= 0. La salida se conecta directamente al canal de entrada de la placa. 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.5%. El mismo diodo también limita la salida a un valor positivo. Éstos ajustes resultaron ser dependientes entre sí por lo que se debe iterar entre un ajuste y .01) mV/V esto significa entrega 2mv por cada voltio a carga máxima con un error de medición de (0.0. Amplificador: En ésta etapa hacemos uso de todo el conocimiento adquirido sobre amplificadores operacionales. se conectan los operacionales a +. 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.12v que son los mismos potenciales que los de R2. 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.La característica es (2 +. condición nunca lograda debido al desalinealidades del sistema.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. usamos el número máximo de bits (12) para aumentar resolución.Muller Hernan // -------------------------------------------------------------------------------------///////////////////////////////////////////////////////////////////////////////////////// #include #include #include #include #include <hidef.320 Kg como patrón de referencia durante la calibración.h" /* include peripheral declarations */ "lcd. en éste caso usamos el pin PTA3 por su cómoda conexión con el exterior. programa que viene incorporado con la placa de desarrollo ///////////////////////////////////////////////////////////////////////////////////////// // // Trabajo Practico 3 Informatica Electronica // Giovanon Bruno .h> . Con éstos datos obtenemos el valor del cuanto en unidades de peso como: 10Kg / 4000 = 2.5 gramos. La placa de desarrollo contiene un ADC que puede ser asignado a cualquiera de los pines de entrada. Código fuente: Se desarrolla en código C haciendo uso del Code Warrior.h> /* for EnableInterrupts macro */ "derivative.3v * 4000 / 4096 = 3. 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. El valor de tensión máxima será 3.h" <stdio.h> <math.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. esto forma un CAD de 4096 niveles.el otro hasta lograr la característica deseada. Se usó un peso de 6. 3] as output LEDs PTBD = 0x00. // Sets MFD multiplication factor (N) to 14 and RFD divisor (R) to 2 ICGC2 = 0x51.5] as output LEDs PTAD = 0x00. //producto de 7$ por Kilogramo ///////////////////////////////////////////////////////////////////////////////////////// // PeriphInit // -------------------------------------------------------------------------------------// Initializes various registers and peripherals ///////////////////////////////////////////////////////////////////////////////////////// void PeriphInit(void) { // Disables COP and Enable RESET and BKGD pin SOPT1 = 0x13. // Sets MFD multiplication factor (N) to 4 and RFD divisor (R) to 1 ICGC2 = 0x20. #else // Selecta FEI mode // Sets trimming for fBUS = 8 MHz ICGTRM = NVICGTRM. PTADD = 0x60. . FLL prescaler factor (P) = 64 ICGC1 = 0x38.25. PTBDD = 0xF8. FLL prescaler factor (P) = 64 ICGC1 = 0x28. const float PreProd=4. char salida[50]. // Using internal reference clock. #endif // Configures PTA[6.// Variables globales float aux. // Waits until FLL frequency is locked while (!(ICGS1 & 0x08)) . Bool alarma=0. #if !CLOCK // Selects FEE mode for fBUS = 8 MHz // Using crystal low-range oscillator.. //valor actual del peso float cero. float kilos. // Configures PTB[7. //Tara // Constantes #define digito 1/400.. // Waita until FLL frequency is locked while (!(ICGS1 & 0x08)) . } ///////////////////////////////////////////////////////////////////////////////////////// // 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(). EnableInterrupts. i+1).// Configures ADC peripheral (ADC clock = 1MHz) // Bus clock as clock source. } ///////////////////////////////////////////////////////////////////////////////////////// // PrintString // -------------------------------------------------------------------------------------// Prints a string on the LCD ///////////////////////////////////////////////////////////////////////////////////////// void PrintString(unsigned char *str) { unsigned char i. LCDOnOffState(). // Selects ADC channel 3 (PTA3) and continuous conversion) ADCSC1 = 0x23. // Timer2 overflow about every 1ms TPM2MOD = 8000.') LCDPutChar('. while(del) if(TPM2SC&0x80) { del--. } // Stops timer2 TPM2SC = 0x00. str[i] != 0. i++) if (str[i] == '. // Stops timer2 and select 1 as prescaler divisor TPM2SC = 0x00. . LCDClear(). // Clears TOF flag TPM2SC &= ~0x80. 12-bit conversion and divisor = 8 ADCCFG = 0x64.'. for(i = 0. ') LCDPutChar('. hexa=hexa>>5. // Enciendo todos los LEDs while (7-hexa>=0){ // Se ejecuta una la cantidad de veces igual a hexa++. start. if(i < NUM_DIGITS) start = 0. NUM_DIGITS-i+j). for(i = 0. i+1). i++) { Delay(d). j. j++){ if (str[j] == '. str[i] != 0. //5 bits menos significativos en PTB[7. unsigned char d) { unsigned char i. // Divido en 8 niveles el módulo de aceleracion leds=0b11111111.else LCDPutChar(str[i]. else start = i-NUM_DIGITS+1. NUM_DIGITS-i+j). } ///////////////////////////////////////////////////////////////////////////////////////// // SlideString // -------------------------------------------------------------------------------------// Slides strings on the LCD ///////////////////////////////////////////////////////////////////////////////////////// void SlideString(unsigned char *str. } } } ///////////////////////////////////////////////////////////////////////////////////////// // 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.'. LCDClear(). } PTBD = leds<<3. for(j = start.5] . else LCDPutChar(str[j]. j <= i.. // la cantidad de LEDs que sea necesario apagar leds=leds>>1. //3 bits mas significativos en PTA[7. } kilos=kilos/10. } ///////////////////////////////////////////////////////////////////////////////////////// //Funcion Pesar //--------------------------------------------------------------------------------------//Lee el valor del canal ADC. return 0.i<10. Delay(30). } kilos=kilos*digito. } PrintString(salida). sprintf(&salida. "%4.i++){ //promedio sobre 10 mediciones while(!(ADCSC1 & 0x80)). kilos=0.2f |". alarma=0.PTAD = leds.3f Kg". if(!estado){ aux=aux*PreProd. if(estado) sprintf(&salida.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. if(tarar) return(kilos). lo adapta al valor en la unidad correspondiente //y lo muestra por display ///////////////////////////////////////////////////////////////////////////////////////// void Pesar(Bool estado){ aux=LeerADC(0). " %1. kilos=(ADCRH*255+ADCRL)+kilos. } . for(i=0..aux).aux). return(kilos-cero). if(kilos>=4000){ //Propongo 4000 como valor máximo medido por el ADC alarma=1. 130).aux). "+. // inicializa los perifericos PeriphInit(). } ///////////////////////////////////////////////////////////////////////////////////////// // MAIN // -------------------------------------------------------------------------------------// Entry point ///////////////////////////////////////////////////////////////////////////////////////// void main(void) { Bool estado. if(estado) sprintf(&salida.PreProd)..130).1f |/kg SlideString(&salida. } if(PTCD_PTCD4==0){ estado=0. sprintf(&salida. sprintf(&salida. } PrintString(salida).2f Ct". // imprime un texto de bienvenida SlideString("trabajo final de sintesis ". // tara inicial cero=LeerADC(1). if(PTCD_PTCD5==0){ estado=1. calcula el error absoluto de la medicion //y lo muestra por display en unidades de gramos ///////////////////////////////////////////////////////////////////////////////////////// void Error(Bool estado){ aux=LeerADC(0).aux). if(!estado){ aux=aux*PreProd/10. aux=aux*10+3000*digito.///////////////////////////////////////////////////////////////////////////////////////// //Funcion Error //--------------------------------------------------------------------------------------//Lee el valor del canal ADC. .%3.) { if(PTCD_PTCD7==0) cero=LeerADC(1). ". "%4. // bucle en el que permanece por siempre for(."Producto de %1. SlideString("Peso en Kg ".0f g".130). La placa de desarrollo fue amurada más alta sobre una placa de madera. la programación. 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. CodifBarra(0x00). Con respecto a la conversión analógica digital se obtiene muy buena resolución y buena jerarquía. como el amplificador de señal. la balanza está lista para realizar su función. 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.} Pesar(estado). .PTCD_PTCD3==0.H. Se pudo representar el símbolo $ modificando el símbolo de barra vertical desde la estructura que representa cada símbolo en LCD. } } Conclusiones: La construcción del proyecto se inicia con el sensor de peso como base para el desarrollo de los demás componentes. 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. El modelo se conecta a la red de 220 v y sólo tiene un interruptor que. if(alarma) CodifBarra(0xff). 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. la fuente y el hardware. for(. una vez encendido.) Error(estado). la cual también oculta la fuente y el amplificador. teniendo en cuenta que es un proyecto hogareño con un sistema de amplificación simple. además se usó cable blindado y filtro pasa bajos para la señal. Figura 3: Modelo terminado y funcionando .