Control de Temperatura del Invernadero

Transcripción

1 UNIVERSIDAD NACIONAL DE QUILMES INGENIERÍA EN AUTOMATIZACIÓN Y CONTROL INDUSTRIAL Control de Temperatura del Invernadero Profesor: Juárez, José Alumnos: PEPA, Hernán Carlos LIO, Guillermo Gustavo Página 1 de 30

2 Introducción El proyecto consiste en un control de temperatura de un invernadero. En el mismo se trata de controlar la temperatura mediante un sistema de calefacción y otro de enfriamiento. El sistema de calefacción consta de tres lámparas de 150 watts, las cuales son controladas (la potencia aplicada a las mismas ) con modulación de fase por medio de una señal PWM.El sistema de enfriamiento consta de un motor de corriente continua con una hélice acoplada a su eje, el cual es el encargado de extraer el aire que se encuentra en el interior del invernadero produciendo una circulación de aire de recambio que genera una disminución de la temperatura. La actuación sobre las lámparas esta gobernada mediante una acción PWM. Esta acción PWM, de muy baja frecuencia, es posible de implementar gracias a la utilización de un optotriac que posee un circuito de detección de cruce por cero, el cual se encarga de interfasear la modulación por ancho de pulso con la modulación de fase que se necesitaría para controlar potencia en corriente alterna. El mismo optotriac actuará sobre un triac que será quien alimente finalmente a las lámparas. Sobre el motor del extractor se aplicará un PWM de baja frecuencia. Esta señal PWM es la encargada de excitar un optoacoplador, el mismo actuará sobre un mosfet que será la interfaz de alimentación hacia el motor. Se usarán dos sensores de temperatura y se acondicionará la señal para poder usar el conversor A/D del micro en todo su rango Página 2 de 30

3 para obtener un valor proporcional a la temperatura. Se implementará un control PI. Según lo que este me diga se actuará sobre las lámparas, el motor o ambos. Tendrá pulsadores que me permiten cambiar de manual a automático, otros para subir y bajar la potencia de salida cuando el equipo se encuentra en manual y si esta en automático con estos pulsadores podré variar el Set Point. Los datos serán enviados a un display LCD que me mostrará el valor del Set Point, la variable de proceso y la potencia entregada a la resistencia calefactora. Página 3 de 30

4 Flujo del Programa INICIALIZACION GENERAL FLUJO DEL PROGRAMA MEDICION TEMPERATURA BARRER TECLADO CAMBIO TECLAS? NO SI ESTA EN MANUAL O AUTOMATICO? M SUBIR O BAJAR % POTENCIA TECLAS = $01 => SUBIR % POT TECLAS = $02 => BAJAR % POT (FIJARSE QUE ESTE ENTRE 00-FF) TECLAS = $03 => CAMBIAR A AUTO A SUBIR O BAJAR SP TECLAS = $01 => SUBIR SP TECLAS = $02 => BAJAR SP (FIJARSE QUE ESTE ENTRE 00-FF) TECLAS = $03 => CAMBIAR A MANUAL Página 4 de 30

5 ESTA EN MANUAL O AUTOMATICO? M A PI % POTENCIA => LAMPARAS NEG(% POTENCIA) => EXTRACTOR MUESTRO % POTENCIA MUESTRO TEMPERATURA MUESTRO SET POINT Página 5 de 30

6 Diagrama En Bloques Página 6 de 30

7 Entradas-Salidas *2 entradas analógicas conectadas al conversor A/D del micro (sensor de temperatura). *3 entradas digitales (pulsadores). *2 salida PWM *Salidas varias para el manejo del display. Detalles Del Programa *Se realizó un programa estructurado. *Se implementaron subrutinas y funciones varias. *Interrupción de tiempo real. *Se modularizó en secciones y en archivos separados para poder reutilizar el código fácilmente. *Código mixto. Switch Case Principal Se ubicó en el main un Switch Case principal que será la estructura de mi control. Se declaró una variable Teclas_Nuevo que tendrá el valor actualizado de los pulsadores luego de haber sido filtrados adecuadamente. Teclas_Nuevo = Sin_Cambio Ningún pulsador fue pulsado Teclas_Nuevo = Incrementa Se pulso el pulsador Subir Teclas_Nuevo = Decrementa Se pulso el pulsador Bajar Página 7 de 30

8 Teclas_Nuevo = Man_Auto Se pulso el pulsador Man/Auto Cualquier otro valor, por ejemplo pulsar dos pulsadores a la vez no se tomará como entrada válida y se lo descartará. También se de declaró una variable Fase que me indica en que estado esta mi control. Fase = Auto indica que mi control esta en modo automático. Fase = Manual indica que mi control esta en modo manual. Ambas variables fueron declaradas como enun, o sea, sólo pueden tomar dichos valores. Lo que hace el switch es analizar estas dos variables e indicar cuál es la acción que se debe tomar según el valor de estas. Si ninguna tecla fue presionada el switch no realiza ninguna acción. Si se toco la tecla ManAuto lo que hace es mirar el valor de Fase y cambiarla. Si la fase esta en Auto la cambia a Manual y si esta en Manual la pone en Auto. O sea que con un solo pulsador podemos poner al control en Manual o Automático. Página 8 de 30

9 Si se pulsó Incrementa lo que hace es mirar la Fase y según en que valor esté será la acción que realice. Si esta en Auto lo que hace es incrementar el SetPoint y si esta en manual el % de Potencia de salida. Si se pulsó Decrementa lo que hace es mirar la Fase y según en que valor esté será la acción que realice. Si esta en Auto lo que hace es decrementar el SetPoint y si esta en manual el % de Potencia de salida. switch(teclas_nuevo) //SWITCH CASE PRINCIPAL case Man_Auto: //CAMBIA DE MANUAL A AUTO Y VICEVERSA if(fase == Manual) Fase = Auto; else Fase = Manual; break; case Incrementa: //INCREMENTA EL SP O %POT if(fase == Manual) Incre_Pot();//INCREMENTAR POTENCIA else Incre_Sp();//INCREMENTAR SP break; case Ambos: //SE PULSARON AMBOS PULSADORES Página 9 de 30

10 break; case Decrementa: //DECREMENTA EL SP O %POT if(fase == Manual) Decre_Pot();//DECREMENTAR POTENCIA else Decre_Sp();//DECREMENTAR SP break; Funciones Incre_Sp, Decre_Sp, Incre_Pot, Decre_Pot En el archivo func_teclas se ubicaron las funciones que realizan las teclas. Lo que hacen estas funciones es incrementar y decrementar el SetPoint o el % de Potencia. Se les puso un filtro por la velocidad del micro para que no crezca muy rápido su valor al ser presionada. Se controló que no se vaya del rango de 0x00 0xFF. O sea, se las limito para que no desborden. void Incre_Sp(void) //INCREMENTA SP Aux01--; if(aux01 == 0) //Filtro por la velocidad del micro if (SP!= 0xFF) //Se fija que no me pase de $FF Página 10 de 30

11 SP++; Aux01 = Aux01_Valor; void Decre_Sp(void) //DECREMENTA SP Aux01--; if(aux01 == 0) //Filtro por la velocidad del micro if (SP!= 0x00) //Se fija que no me pase de $00 SP--; Aux01 = Aux01_Valor; Subrutina Barrido En el archivo teclas se creo una subrutina de assembler dedicada a leer el puerto de los pulsadores. Se logró mezclar el assembler con el c para obtener un código mixto. Esta subrutina se la llamó desde el main de la siguiente forma: //Declaración extern void Barrido(void); //Barrido_Teclas(); Barrido(); Esta subrutina tiene un filtro contra el rebote de teclas que se puede ajustar a gusto también y detecta el flanco de subida. En el caso de tener presionados por un tiempo los botones de subir y bajar permite subir permitir subir y bajar mas rápido para que no sea engorroso presionar muchas veces Página 11 de 30

12 por la detección del flanco. Este tiempo también es ajustable. xdef _Barrido xdef _Ini_Var_ASM xdef PortC xdef Msk_PortC xdef PortC_Viejo xdef Ret_Tec xdef Ret_Tec_Val xdef Teclas_Viejo xdef _Teclas_Nuevo xdef PortC_Nuevo xdef Ret_Tec2 xdef Ret_Tec2_Val _Ini_Var_ASM: ldaa Ret_Tec_Val staa Ret_Tec ldaa Ret_Tec2_Val staa Ret_Tec2 ldaa #$FF staa PortC rts ;************************************ ;BARRIDO DE TECLADO CON FILTRO ;DETECTA FLANCO SUBIDA _Barrido: ;*************************************** ;FILTRO TECLAS ldaa PortC cmpa PortC_Viejo beq Barrido_10 ldaa Ret_Tec_Val staa Ret_Tec ldaa PortC staa PortC_Viejo bra Barrido_20 Página 12 de 30

13 Barrido_10: dec Ret_Tec bne Barrido_20 ldaa PortC_Viejo staa PortC_Nuevo ldaa Ret_Tec_Val staa Ret_Tec Barrido_20: ;*************************************** ;*************************************** ;DETECCION FLANCO SUBIDA ldaa Teclas_Viejo coma staa Teclas_Viejo ldaa PortC_Nuevo coma anda Msk_PortC anda Teclas_Viejo staa _Teclas_Nuevo ldaa PortC_Nuevo coma anda Msk_PortC staa Teclas_Viejo ;*************************************** ;SUBIR Y BAJAR RAPIDO ;SOLO PARA ESTOS PULSADORES ;NO SE APLICA A CAMBIO DE FASE ldaa PortC_Nuevo coma cmpa #$02 beq Barrido_30 cmpa #$04 beq Barrido_30 bra Barrido_40 Barrido_30: dec Ret_Tec2 bne Barrido_40 staa _Teclas_Nuevo Página 13 de 30

14 ldaa Ret_Tec2_Val staa Ret_Tec2 Barrido_40: ;*************************************** rts ;*************************************** PortC: equ $1006 Msk_PortC: equ $07 ;3 PRIMEROS BITS PortC_Viejo: dc.b $00 Ret_Tec: dc.b $00 ;FILTRO POR REVOTE TECLAS Ret_Tec_Val: equ $01 Teclas_Viejo: dc.b $00 PortC_Nuevo: dc.b $00 Ret_Tec2: dc.b $02 ;SUBIR Y BAJAR MAS RAPIDO Ret_Tec2_Val: equ $01 Subrutina Ini_Var_ASM Lo que hace esta subrutina es inicializar las variables de assembler. Es llamada desde el main de la siguiente manera: //Declaración extern void Ini_Var_ASM(void); //Inicio variables en assembler Ini_Var_ASM(); _Ini_Var_ASM: ldaa Ret_Tec_Val staa Ret_Tec ldaa Ret_Tec2_Val staa Ret_Tec2 ldaa #$FF staa PortC rts Página 14 de 30

15 Variables globales Se creo un archivo variables_c para contener todas las variables globales de mi proyecto. ///////VARIABLES C//////// //typedef char BYTE; int contar=0,comparar=22; char Pot = 0x00, Aux01 = 0x00, Aux01_Valor = 0x01, SP = 0x00; char ii=0x00; char Sum, Error,kk; enum Manual, Auto Fase = Manual; enum Sin_Cambio, Man_Auto, Incrementa, Ambos, Decrementa,a,b,c,d Teclas_Nuevo = Sin_Cambio; int int pausa_cls=0x1000; pausa_lcd=0x0020; char datos_lcd[3]; char prom_conv=0; char conversion1=0,conversion2=0; Control Se llamó a la función desde el cuerpo principal del programa. Se fija la fase del programa, si esta en Manual deja el %Pot para que se modifique con los pulsadores. Si esta en Auto lo que hace es calcular la distancia de la variable de proceso con el SetPoint y aplicar un %Pot proporcional a esa distancia. En prom_conv tenemos el el valor de la temperatura promediado. En SP el SetPoint fijado. Error= SP - prom_conv; Página 15 de 30

16 Primeramente tenemos que fijarnos si SP es mayor que prom_conv. En caso de que sea al revez quiere decir que nuestra temperatura es superior al SP por lo cual debemos poner la Potencia a cero. %Pot = 0% Si el Error es positivo y además mayor a 50 cuentas quiere decir que estamos a unos 18ºC de distancia entonces aplicamos. %Pot = 100% Si el Error es menor a 50 cuentas y mayor a 8 (2ºC aprox.) aplicamos un control proporcional. %Pot = 0x03*Error; %Pot contiene un numero de cuentas proporcional al ancho del pulso del PWM que aplicamos para mover el Triac que aplica la tensión en las lámparas. Por ejemplo si %Pot = 0x80 estaremos aplicando un PWM con un ciclo de actividad del 50%. Al extractor se le aplicará la Potencia negada porque son acciones opuestas. Ejemplo: Para temperaturas extremas si queremos calentar al máximo necesitamos que las lámparas estén al 100% y el extractor al 0%. Para enfriar al máximo necesitamos las lámparas al 0% y extractor al 100%. Página 16 de 30

17 O sea, que en el momento de controlar una temperatura, si necesito calentar aumento un poco la potencia de las lámparas y disminuyo las del extractor. Y si necesito enfriar, aumento la potencia del extractor y disminuyo la de las lámparas. Pwm_Lamp(Pot); Pwm_Motor(Neg(Pot)); Si estamos dentro de la banda de 2ºC no aplicamos acción de control, o sea, le dejamos una histéresis. void Control(void) //Control P if(fase == Auto) if(sp > prom_conv) Error= SP - prom_conv; if(error>0x50) Pot=0xFF; else if(error>8) Pot=0x03*Error; else Pot=0x00; Página 17 de 30

18 Rutina se servicio de interrupción RTI La rutina de servicio de interrupción fue programada para que se active la interrupción de tiempo real cada 32 milisegundos aproximadamente. Ese tiempo sería el tiempo de scan que tiene nuestro sistema, en el cual debemos actualizar los datos del teclado. Se puso una variable que cuenta 33 veces para generar un scan de 1 segundo para tomar el valor de la temperatura por medio del conversor, aplicar el control estimado según los datos obtenidos y hacer el refresco del display con los datos actuales. //void void rutina(void) //Interrupcion de tiempo real TFLG2=0x40; //Barrido_Teclas(); Barrido(); cuenta--; if(cuenta == 0) //Conversor; CAPTURA_CONVERSORAD(); Enviar(); control(); cuenta = 33; switch(teclas_nuevo) //SWITCH CASE PRINCIPAL... Página 18 de 30

19 Conversor A/D Los sensores de temperatura entran al conversor A/D que esta configurado de modo multiple y single scan. Este conversor esta sincronizado con la RTI, o sea que se llama a la rutina de conversión desde dentro de la rutina de la RTI. Configuración del conversor A/D: OPTION=0x80; ADCTL=0x10; Dentro de la RTI se realiza la llamada a la función CAPTURA_CONVERSORAD(), dentro de la misma función se llama a la función conversión_canal() que es la encargada de iniciar la conversión y esperar el fin de conversión, una vez finalizada la conversión volcamos los resultados de los canales convertidos ADR1 y ADR2 en las variables globales conversión1 y conversión2 respectivamente. Estas variables son tratadas por la función promedio() y q hace un promedio móvil de las muestras para reducir las posibilidades de grandes variaciones de medición por causas de intromisión de ruido en la medición que efectúan los sensores y volcamos ese resultado en la variable global prom_conv. void CAPTURA_CONVERSORAD(void) conversion_canal(); conversion1=adr1; conversion2=adr2; promedio(); void conversion_canal(void) Página 19 de 30

20 ADCTL =0x80; while((adctl & 0x80)==0)//ESPERAR FIN DE CONVERSION void promedio (void) short conv1, conv2, prom; conv1 = (short)conversion1; conv2 = (short)conversion2; prom = (short)prom_conv; //Promedia las dos muestras nuevas y ademas promedia el valor //viejo para obtener un mejor filtrado de la señal prom = ((conv1 + conv2)/2 + prom)/2; prom_conv = (char)prom; Conversión ASCII La conversión de los datos a ASCII se realiza para enviar los datos al lcd. Los datos de potencia, porcentaje de actuación, variable de setpoint y variable medida de temperatura son cargadas a un array datos_lcd[i] y mediante la función que vemos a continuación son convertidas a ASCII void ascci(char var_asci) char i=3, resto=0; datos_lcd[2] = var_asci/100; //guardamos la centena en el vector resto = var_asci-(datos_lcd[2]*100); datos_lcd[1]=resto/10;//guardamos la decena datos_lcd[0]= resto-(datos_lcd[1]*10);//guardamos la unidad //convertimos a ascci Página 20 de 30

21 while(i!=0) i--; datos_lcd[i]=datos_lcd[i] + 48; Configuración del LCD El lcd se configuro en base a las subrutinas en assembler q se tradujeron al lenguaje c. En el lcd se pueden visualizar la temperatura medida, la potencia entregada a los pwm que actúan sobre las lámparas y sobre el motor y la señal de setpoint. Mediante la siguiente rutina se configuro e inicializó el display, esta función ini_lcd() se llama solo una vez desde el main con el solo propósito de inicializar el lcd y prepararlo para recibir datos: void INI_LCD(void) CMD_LCD(0x38); CMD_LCD(0x0e); CMD_LCD(0x01); //*********************** //enviar un comado al lcd //*********************** char CMD_LCD(char a) PORTA=a; PORTF &= 0xF9; ENABLE_LCD(); if(a!=0x01) PAUSA(pausa_lcd); else Página 21 de 30

22 PAUSA(pausa_cls); //******************* // habilitar el lcd //******************* void ENABLE_LCD(void) PORTF ^= 0x01; PORTF &= 0xFE; //************************ //pausa comandos lcd //************************ void PAUSA(int b) while(b!=0) b--; Envío al LCD Las funciones que se describen a continuación son utilizadas cada vez que el refresco del display, o sea cada vez q entro en la rutina de servicio de interrupción de la RTI, que fue configurada previamente para actualizar los datos aproximadamente cada 1000 milisegundos. Con la siguiente función se envía un dato al lcd, que previamente fue convertido a ASCII: void Envio_Dato(char a) PORTF ^= 0x04; //RS=1 PORTF &= 0xFD; //R/W=0 PORTA = a; ENABLE_LCD(); PAUSA(pausa_lcd); PORTF &= 0xF8; // Página 22 de 30

23 Con la función cursor nos posicionamos sobre la primera o segunda línea del display para escribir el dato deseado: void Cursor(char a) PORTA = a; PORTF &= 0xF9; //RS=0 R/W=0 ENABLE_LCD(); PAUSA(pausa_cls); La función enviar() engloba a todas las funciones antes descriptas para el procesamiento y envío de datos al display: void Enviar(void) char i=3, aux; Cursor(0x80);//Linea de Arriba Envio_Dato('T'); Envio_Dato(' '); //Acondiciono la Temp y convierto a ASCII //Acondiciono la Temp y convierto a ASCII aux = (char)((60*prom_conv)/255); ascci(aux); while(i!= 0) i--; Envio_Dato(datos_lcd[i]); Cursor(0xC0);//Linea de abajo if(fase == Manual) Envio_Dato('P'); Envio_Dato(' '); i=3; //Acondiciono la Pot y convierto a ASCII aux = (char)((100*pot)/255); ascci(aux); while(i!= 0) i--; Envio_Dato(datos_lcd[i]); Página 23 de 30

24 PWM else //Envio_Dato(' '); //Envio_Dato('%'); Envio_Dato('S'); Envio_Dato('P'); Envio_Dato(' '); i=3; //Acondiciono el SP y convierto a ASCII aux = (char)((60*sp)/255); ascci(aux); while(i!= 0) i--; Envio_Dato(datos_lcd[i]); Se configuraron dos TOC para crear dos PWM. while(1) if((tflg1&0x40)!=0) TFLG1=TFLG1 0x40; if(estado==0)//estadobajo) TCTL1=TCTL1&(~0x40); estado=1;//estadoalto; TOC2=TOC2 + 10*Pot; else TCTL1=TCTL1 0x40; estado=0;//estadobajo; TOC2=TOC2 + (Periodo - 10*Pot); //***************************** //pwm lamparas de calefaccion //***************************** if((tflg1&0x20)!=0) Página 24 de 30

25 TFLG1=TFLG1 0x20;// limpio el flag if(estado2==0)//estado bajo) TCTL1=TCTL1&(~0x10); estado2=1;//estadoalto; TOC3=TOC *(Periodo - Pot); else TCTL1=TCTL1 0x10; estado2=0;//estadobajo; TOC3=TOC3 + (100*Pot); Los PWM se pusieron dentro del bucle infinito ya que son de alta frecuencia. Se declaró una variable estado que contiene el valor de la salida y se configuró el TCTL1 para que pase a bajo o alto según el estado. El período se fijo en una variable que contenía una cierta cantidad de cuentas que me permitía obtener aproximadamente un período de 1.5 mseg para el del motor y diez veces más para el de las lámparas. Se eligió Período de 2550 para que sea fácil el escalado ya que Pot va de 0 a 255. TOC2=TOC2 + 10*Pot Ciclo ON del motor TOC2=TOC2 + (Periodo - 10*Pot); Ciclo OFF del motor. Página 25 de 30

26 Software de Desarrollo Archivo LINKER: # GENERIC LINK COMMAND FILE FOR 68HC11 # Copyright (c) 1999 by COSMIC Software # +seg.text -b 0x000 -n Init # Program start address crts.o # Startup routine +seg.data -a Init -n VarIni # Variables Inicializadas +seg.bss -a VarIni -n VarNoIni # Variables no Inicializadas +seg.const -a VarNoIni -n Constantes # Constantes +seg.text -b 0xC4 -n VectInt # Vectores de Interrupcion vector.o +seg.text -a VectInt -n Prog # Codigo variables_c.o main.o teclas.o conv_ascii.o conversorad.o actuacion_pwm.o control_pid.o func_teclas.o "C:\Archivos de programa\cosmic\eval11\lib\libf.h11" "C:\Archivos de programa\cosmic\eval11\lib\libi.h11" "C:\Archivos de programa\cosmic\eval11\lib\libm.h11" #Agregado para programa a EEPROM +seg.text -b 0xFE00 -n.text display.o Debido al tamaño del programa, fue necesario la utilización de la memoria EEPROM para almacenar las funciones mas genéricas, es decir, aquellas funciones que una vez probadas no volverían a ser modificadas. Por ejemplo la del display. Página 26 de 30

27 Al realizar un build del proyecto utilizando el archivo de linker descripto mas arriba, queda bien diferenciado en el archivo de salida.s19 principal, la parte del programa que residirá en la memoria RAM y la parte del programa que residirá en la memoria EEPROM. En base al archivo.s19 principal se construyeron manualmente dos archivos.s19 secundarios, uno destinado a la memoria RAM y otro destinado a la memoria EPPROM:.s19 para la RAM: S A5C446F63756D656E E E67735 C616C756D6E6F735C4D F63756D656E746F735C E 616C5C E616C2E B S E04007E00EEF8 S C S12300C400EE00EE00EE00EE00EE00EE00EE00EE00EE00EE00EE00EE00E E00EE00EE00EE38 S10D00E400EE00EE00EE00EE S12300EE3C3C306F01C6F818CE100018E707C6FF18E701BDFE00C68018C E100018E739C662 S123010E1018E7307F000AC605F7000C7F000DF7000BC601F7000F7F001 0BD01DBC6FFE708 S123012E A00E60026FABD01EBBD029A7C001CE BDFEABC 650E7016A01F6A6 S123014E00105A270B5A27195A27325A DF6000F2607C601F7000 F20217F000F20C6 S123016E1CF6000F2605BD031C2012BD DF6000F2605BD BD035AF6001C71 S123018EF1000A2404C6FF2005C1FF240A5F18CE100018E F001 CF6000F5A2703B3 S12301AE7E012BF6000DF F00015F7001DC C6FF200AC 10823E386033D6B S12301CE20015FF7000A4FBD02C87E012B9601B B7024C86FFB B S12301EEB D9601B70249B61006B A BB6024 8B7024B9601B7E0 S123020E0249B6024A43B7024AB6024B439407B4024AB70010B6024B B7024AB602F5 S123022E4B D7A024C2608B B7024C BD3F S123024E03AC05C603E7034FE606BD036E64F7001B86643DE702E606E00 2E7044FBD036E00 Página 27 de 30

28 S123026E0AF7001A860A3DE702E604E002F A0318CE0019E A18E600CB1D S123028E3018E700E60326EAAE C3C3018CE C F3 080FB18E6314F23 S12302AEED0018E632E300BD036E02FB BD036E02F C373630F676 S12302CE0027A6013DEB07F70018F6001EEB01F7001EF60026B6001E3DF B0018F70018E6B6 S12302EE01F00021B600253DFB0018F70018F F F F60023CA S123030EF70018E601F70021F A000B260FF6000A5C27037 C000AF6000CF747 S123032E000B397A000B260EF6000A27037A000AF6000CF7000B397A000 B260FF6000D5CAA S123034E27037C000DF6000CF7000B397A000B260EF6000D27037A000DF 6000CF7000B39F1 S123036E3C364D2A028D1830EE03EE008F164F8F028F306C C036 D A04403D S123038E C364D2A028DF430EE03EE008F164F8F0220DB18383 C DC S11603AE3C F308F18E F35ED00186E015F S903FFFFFE.s19 para la EEPROM: S A5C446F63756D656E E E67735 C616C756D6E6F735C4D F63756D656E746F735C E 616C5C E616C2E B S123FE00CC00388D0BCC000E8D06CC00018D01393C373630E60118CE E700181D0552 S123FE200618E605C80118E705181D0501E6015A2705FC FC001 18D C8C S123FE EC ED0026F C CE E605C80418E71A S123FE D0502E60118E70018E605C80118E705181D0501FC00138 DC418CE100018DE S123FE801D C373630E60118CE100018E700181D050618E60 5C80118E70518AF S123FEA01D0501FC00118D CCC00808DD5CC00548D9BF C3DBD036EFFD8 S123FEC0BD024DC603F7000E7A000ECE0019F6000E3AE6004FBDFE51F60 00E26EBCC00C0B5 S123FEE08DA4C603F7000ECC0050BDFE51F6000A86643DBD036EFFBD024 D20107A000ECEF1 S123FF000019F6000E3AE6004FBDFE51F6000E26EBC603F7000ECC0053B DFE51F6000D86AE S123FF203C3DBD036EFFBD024D20107A000ECE0019F6000E3AE6004FBDF E51F6000E26EBD8 S105FF A S903FFFFFE Página 28 de 30

29 Para la escritura de la memoria EEPROM se utilizó el programa JBug11: El procedimiento para la escritura de la memoria EEPROM es el siguiente (se asume que el programa ya ha sido convenientemente configurado): 1. Conectar el micro controlador con el JBug y resetearlo. 2. Escribir los siguientes comandos: R BPROT=10 habilita la escritura de la EEPROM. EBULK borra la memoria EEPROM. 3. VE FE00 FFFF verificamos el borrado de la memoria. 4. Utilizando el botón Load S 19 file to MCU memory seleccionar el archivo.s19 destinado a la memoria EEPROM. 5. Para la escritura de la memoria RAM se utilizo el ya conocido Cargador del HC11F1 para WIN32. Conclusiones Este proyecto nos permitió usar un lenguaje poderoso como es el C para programar el micro. Se pudo hacer un código mixto, o sea, parte en C y parte en assembler. Se tuvieron problemas de falta de memoria lo que provocó que no se modularise tanto como se pretendía. Se termino grabando parte en RAM y parte en ROM al lítime. Página 29 de 30

30 Los logros fueron *Adquirir dos valores de temperatura simulados con presets. *Obtener dos señales PWM con el ciclo de trabajo opuesto y de dos frecuencias distintas. *Funcionamiento correcto de la lógica de control creada. *Poder mandar los datos de temperatura, set point y % de potencia a través del display. Fracasos *No se pudo cerrar el lazo en la planta por falta de tiempo. Sólo se llego a prepear todo y verificar que funcione. *No se pudo hacer una buena presentación en el display por falta de memoria del micro. Sólo se pudo mostrar lo mínimo y necesario. *No se llego a implementar un PI por falta de tiempo y memoria. Se realizó un control P. Mejoras *Usar un micro mas moderno con más memoria para evitar tantos problemas y pérdida de tiempo. Página 30 de 30