TODOPIC
Microcontroladores PIC => * PROYECTOS * => Mensaje iniciado por: pastito en 23 de Marzo de 2010, 15:13:56
-
Estimados PICeros... les cuento mi última odisea... en noviembre del año pasado se me rompió la heladera.
Una Bosch no frost, modelo KSU 66.
La historia completa está aca. (http://www.yoreparo.com/foros/refrigeracion/462822_0.html#1555260)
Para los que les dé huevo leer el tread ese (que es largo, el tema es que el servicio técnico de Bosch, da a la heladera por muerta) y el repuesto de la plaqueta con el microcontrolador no es posible de conseguir (o por lo menos yo no pude).
Como no tengo las más de 4 lucas que cuesta una heladera similar nueva y conseguí el manual de servicio de Bosch en la red, me di cuenta testeando todos los componentes de que el problema claramente era el microcontrolador, porque el resto del hardware del refrigerador funcionaba correctamente.
¿Qué hacer para un PICero de pura cepa como yo?
Adivinaron: ¡¡¡¡¡PONER UN PIC!!!!!! :-/
Entonces puse manos a la obra. Armé una plaqueta con un fuente integrada para un PIC 18F452 en epoxy con cristal de 20Mhz. El circuito está aqui. (http://pastito.homedns.org/heladera/18F452.jpg) Esta es la foto (http://pastito.homedns.org/heladera/contr1.jpg) de la plaqueta terminada. Esa es una foto (http://pastito.homedns.org/heladera/contr2.jpg) de costado.
Después diseñé una plaqueta con 4 relays, uno de 20 Amperes para el compresor, uno para la resistencia de deshielo del evaporador, uno para la resistencia de la bandeja de drenaje y otro para el ventilador (forzador) que manda el aire frio desde el congelador a la parte de abajo de la heladera. Esta es una foto (http://pastito.homedns.org/heladera/reles.jpg) de la placa de los relés terminada.
Le puse un display de 2X16 de LCD, mismo que tuve un inconveniente... porque al principio usé uno sin backlight que tenia dando vueltas por ahi, pero después de instalado en la caja, me doy cuenta que estaba roto... y era un toque mas grande que el resto de los displays que tengo... así es que mala suerte... pero el agujero de la caja quedó más grande de lo que tenía que ser.
Después diseñé una plaqueta con todos los circuitos de control que iba a necesitar. Acá está la foto (http://pastito.homedns.org/heladera/control.jpg). Nótese que tiene:
1.- Soporte para 3 termistores NTC (para medir la temperatura)
2.- Soporte para tres switches
3.- Soporte para las dos puertas (más de esto adelante)
4.- Un MAX232 para que se pueda reprogramar en circuito
5.- Un buzzer para que suene si olvido una puerta de la heladera abierta
Para los termistores, el tema es que no son lineales, así es que tuve que descular el polinimio de Steinhart-Hart, que describe
la curva con una precisión asombrosa (0.1 %).
La heladera tiene de fábrica dos termistores, uno en el evaporador (que se usa para el deshielo) y el otro en el lugar más caliente del freezer (la esquina superior derecha, al fondo).
Esto es muy desafortunado, porque el ventilador forzador no se puede controlar de acuerdo a la temperatura de abajo de la heladera, simplemente porque no hay un termistor que mida el frío de abajo. Así es que simplemente instalé uno, tal como lo muestra esta foto (http://pastito.homedns.org/heladera/termistor.jpg). Nótese que el mismo no queda a la vista sino debajo de la moldura (está a la vista para la foto).
Después encaré el problema de las puertas... las mismas están directamente conectadas a 220v. Así es que para leerlas armé este circuito (http://pastito.homedns.org/heladera/doors.jpg) con dos acopladores ópticos. Como podrán observar, del otro lado me devuelve una cuadrada de 50 Hz. Con lo cual lo único que tengo que hacer es tomar 3 lecturas a 13 ms cada una para saber si las puertas fueron abiertas.
Una vez solucionado eso... armé todo el proyecto mismo que quedó más o menos asi (http://pastito.homedns.org/heladera/caja1.jpg). Esta es otra foto (http://pastito.homedns.org/heladera/caja2.jpg).
Acá hay una foto (http://pastito.homedns.org/heladera/serial.jpg) del DB9 que le puse a la caja.
Aqui hay una foto (http://pastito.homedns.org/heladera/overview.jpg) de todo armado.
Una vez que puse todo y puse un bootloader en el PIC, lo más divertido fue programar.
Armé los ciclos tal cual están descriptos en el manual de la Bosch, sobre todo el de deshielo, y lo mejoré de acuerdo a mis ideas. Más o menos esto es lo que hace:
1.- El ciclo del compresor es de 20 minutos encendido por 10 de apagado (para que no se queme) y se prende bajo demanda. Para que encienda el freezer tiene que estar en -20 centígrados en su lugar más caliente. Se apaga a los -25.
2.- Cada vez que se abre una puerta, se dispara un timeout... si a los 20 segundos no se cierra la puerta, suena el buzzer. También el ventilador para (para no sacar el frío de la heladera) y se cuenta el número de segundos que las puertas quedaron abiertas y se lleva un contador global. Esto es importante porque cada vez que se abren las puertas entra humedad. Cuando las puertas se cierran y como dice el manual el ventilador se enciende un minuto para hacer un reciclado total del aire (y sacar la humedad del mismo).
3.- El ciclo de descongelado depende del número de veces (tiempo total) de puertas abiertas... mientras más tiempo las abrís, antes entra el ciclo de deshielo. También depende de cuánto le costó el último deshielo. Si costó el tope (60 minutos) el próximo deshielo se hace más rápido.
4.- El ventilador enciende depende de la temperatura de la heladera bajo demanda (porque esta el tercer termistor que mide la temperatura de abajo). También el ventilador hace un reciclado total de aire cada media hora.
5.- Se puede setear desde la botonera temperatura mínima y máxima de la heladera. Esos valores se escriben en la ROM del 18F452 asi es que reviven un reset.
6.- Puse un timeot cuando arranca la heladera de 2 minutos. La idea es que en un corte de luz, espere 2 minutos para evitar que el compresor vaya a recibir un pico de tensión.
7.- Lleva los tiempos totales de todo.
8.- Se puede iniciar un deshielo manual desde la botonera cuando así se lo desee.
El proyecto lo programé con PICC.
En resumen... la heladera quedó horrible de pinta... ¡pero funciona como nunca! Estoy feliz... con menos $200 de inversión y muchas tardes de diversion la hice andar ¡¡¡¡COMO YO QUIERO!!!!
Les dejo unas fotos de la pantalla del LCD
Arrancando... (http://pastito.homedns.org/heladera/lcd1.jpg)
Temperaturas... (http://pastito.homedns.org/heladera/lcd2.jpg) H = heladera E = evaporador y F = freezer
Indicador de encendido de compresor y ventilador. (http://pastito.homedns.org/heladera/lcd3.jpg)
Tiempo total de encendido (http://pastito.homedns.org/heladera/lcd4.jpg)
Laptop conectada a la heladera! (http://pastito.homedns.org/heladera/laptop.jpg)
Screenshot de la info que tira el puerto serial (http://pastito.homedns.org/heladera/infoserial.jpg)
¡¡¡Dejen sus comentarios!!!!
Saludos
-
Vaya proyecto, qué bueno que quedó como esperabas.
-
Muy interesante, te felicito!!
Vas a publicar el firmware??
-
Felicidades por tu exitos
-
Muy Bueno, te felicito!!
Saludos
-
PLA PLA PLA PLA !!! Felicitaciones !!! Un groso total
Saludos !
-
Excelente!! :-/ Felicitaciones. Nunca había visto un Laptop conectada a una heladera :D
Saludos!
-
Magnifico proyecto terminado. Enhorabuena.
Un saludo
-
Que buena solución!! yo lo llamaría un buen hack...
-
Me gustó mucho tu proyecto, siempre que se mejora algo a medida de cada uno la satisfacción es mayor :mrgreen:
saludos!
-
jo jo!! aguanten las bosch!! este caso es similar a muchos!! en el service oficial tienen muuuuuuuuuuuchas heladeras de ese modelo paradas por falta de repuesto! conozco de cerca un caso que al final llegó a buen puerto!! pero te puedo asegurar que nadie daba bola, la realidad de la situacion no es que bosch tenga malos productos, sino que en la aduana tienen todo parado por no llegar a los requerimientos que solicita el estado para exportar / importar, es por eso que algunos ingeniosos como vos pudieron solucionar por otro lado el problema, muy bueno realmente lo que has hecho! felicitaciones
-
:mrgreen: :mrgreen: Felicitaciones Pastito por tu heladera "tunning" :D
Ahora vendéle a Bosch tu diseño :mrgreen:
Saludos
Norberto
-
Muy bueno!!!!
:-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/
A como los helados??? :mrgreen: :mrgreen: :mrgreen:
Saludos
-
¡Gracias a todos por los comentarios!
La realidad es que esta heladera nunca anduvo tan bien como ahora. Es increíble lo estable que está.
El problema de la plaqueta de Bosch es que está hecha para ahorrar hasta el último centavo. Por ejemplo, para el ventilador, que consume 4 watts, está gobernado por un triac Phillips Z0103, mismo que está en el límite del consumo.
Con el tiempo, el ventilador se llena de hielo, se corroen los rodamientos y se pierde lubricante, por lo que necesariamente hace más pesado y el triac termina volando por el aire.
Lo único que me hubiera gustado sería haber podido miniaturizar el proyecto lo suficiente como para que quedara dentro del gabinete de la heladera... pero no se puede todo en la vida. Viviré con esta caja fea y el día que me deshaga de la misma el heredero tendrá que soportarla!
El resumen es que me divertí y aprendí mucho de refrigeración en el camino... y de aplicar un PIC a un problema real. Si hubiera tenido el dinero, me hubiera comprado una nueva...
En resumen, lo que mejoró en esta solución respecto a la implementación de Bosch es:
1.- Tiene display de LCD que te explica lo que está sucediendo en tu heladera
2.- Tiene salida serial, que se puede capturar en un archivo e incluso de puede graficar temperaturas, ciclos de deshielo, etc.
3.- Tiene control de temperatura en la sección de la heladera microcontrolada.
4.- Los comandos permiten efectuar un deshielo manual cuando se lo desee
5.- Tiene alarma de puertas abiertas con timer de 20 segundos (que se puede setear a voluntad)
6.- Es más eficiente en cuanto a consumo de energía, porque no tiene cliclos tipo timer sino todo funciona bajo demanda (sensores de temperatura)
7.- Lleva contadores totales que se pueden revisar cuando se desee desde el display LCD o el serial. Esto permite sabes si hay fallos o problemas de eficiencia de alguna de las partes.
Puede decirse que ahora si es una heladera INTELIGENTE
A todo esto... en todas las casas de repuestos, HAY respuestos para Whirpool... para los que piensan invertir en una heladera nueva.
Hace un ratito conecté el serial para recopilar los datos y esto es lo que se lee:
Uptime: 334324 seconds.
Temperaturas -> hel:4.46 ev:-34.77 fre:-25.57
Comp = 1 - Fan = 1
TE comp = 579 - TA comp = 1296
TE fan = 346 - TA fan = 353
T_COMP_TOTAL = 12357 T_FAN_TOTAL = 243555
Tiempo ultimo deshielo = 943
Total puertas abiertas 142
Pantalla 1 - Deshielos = 3
temp_max_hel 7 temp_min_hel 4
O sea que la heladera está encendida hace 3 días, 20 horas 52 minutos y 4 segundos --sin ser reseteada---
La temperatura de la heladera es de 4.46 grados, del evaporador de -34.77 y del freezer -25.57
Compresor y ventilador estaban encendidos en el momento de la lectura
Tiempo encendido del compresor 579 segundos (casi 10 minutos) pero viene de estar 1296 segundos apagado (21:36)
Tiempo encendido del ventilador 346 segundos, tiempo de apagado 353
Tiempo compresor encendido en total 3 horas, 25 minutos y 57 segundos (se resetea después de cada deshielo)
Tiempo de ventilador total 2 días, 19 horas, 39 minutos y 15 segundos
Tiempo que tomó hacer el último ciclo de deshielo: 15 minutos y 43 segundos
Total de puertas abiertas 142 segundos (este valor también se resetea en el último deshielo)
Pantalla 1 (es que la botonera tengo 11 pantallas con toda la info en el LCD)
Cantidad de ciclos de deshielo 3
Temperatura máxima de la heladera 7 grados y mínima de 4
Saludos
-
Una función interesante a agregar podría ser el modo fiesta y el modo vacaciones ;-)
-
Un buen ejemplo de saber utilizar la cabeza!!! :mrgreen:. Felicidades
-
Una función interesante a agregar podría ser el modo fiesta y el modo vacaciones ;-)
En realidad como el programa adapta los ciclos de deshielo y el encendido --tanto compresor como del forzador-- es bajo demanda, creo que no es necesario. Así como está compensa los dos extremos.
La verdad es que no se me ocurre qué otra función ponerle...
Estoy orgulloso del programa, porque si bien me llevó una tarde delinearlo y después 3 o 4 días de una hora para refinarlo, llegó al punto en el que está estable y sin bugs evidentes.
Un acierto fue poner 3 potenciómetros en vez de los termistores y programar simulando los diferentes escenarios, con tiempos de ciclos reducidos a pocos segundos. Con eso, pude emular y verificar el funcionamiento correcto de todos los ciclos, antes siquiera de conectar el proyecto a la heladera real.
Dato curioso... del PIC18F452 usé el 48% de la ROM y 12% de la RAM. ¡Sobra mucho espacio!
Un abrazo
-
EXCELENTE! Felicitaciones por el proyecto! yo que recien estoy empezando cone sto, veo las cosas que se pueden hacer y me dan mas ganas de aprender :P
Estas cosas inspiran :mrgreen:
exitos! ;-)
-
EXCELENTE! Felicitaciones por el proyecto! yo que recien estoy empezando cone sto, veo las cosas que se pueden hacer y me dan mas ganas de aprender :P
Estas cosas inspiran :mrgreen:
exitos! ;-)
Gracias!
Te cuento que tuve que pelear mucho con el ruido. Lo que aprendí sirve como para armar una pequeña guia práctica.
Ahora funciona perfectamente.
Una cosa que me di cuenta es que los deshielos se hacen cada 20 horas de compresor. O sea que si se va la luz en la hora 19
Puede tardar 39 horas de compresor entre un deshielo y otro!
Claro que en el diseño original de la plaqueta ese problema no está resuelto.
Lo que se me ocurrio es poner una variable en EEPROM si se quiere hacer un deshielo cada vez que la heladera se enciende o no con
un menú que se pueda cambiar el valor y listo. Si lo ponés en habilitado, cada vez que hay un corte de energía, el ciclo comienza con un deshielo.
Un abrazo
-
Exelente proyecto, lo comico es que hoy compre una Heladera con mi vieja, pero no Bosch :D :D.
De esto ultimo que comentas, sino lo que puedes hacer es almacenar una variable en la eeprom que se incremente una vez por hora, asi, si hubo un corte de energia, la variable queda igual, y cuando retorna la energia sigue contando hasta llegar a las 20 horas.
Solo una ocurrencia.
Saludos.
-
Magnífico proyecto. Te felicito porque una vez terminado parece sencillo, pero realmente tiene detrás un montón de horas de quebraderos de cabeza.
Esas temperaturas que pones en el texto, ¿son grados Farenheit?
-
Exelente proyecto, lo comico es que hoy compre una Heladera con mi vieja, pero no Bosch :D :D.
De esto ultimo que comentas, sino lo que puedes hacer es almacenar una variable en la eeprom que se incremente una vez por hora, asi, si hubo un corte de energia, la variable queda igual, y cuando retorna la energia sigue contando hasta llegar a las 20 horas.
Solo una ocurrencia.
Saludos.
Pensé en ese acercamiento, pero lo que no me convenció es que la EEPROM no es más que memoria flash y tiene una cantidad limitada de escrituras antes de romperse. Me parece que son 100.000.
Dirás... 100.000 horas es mucho... si es cierto, son 11 años, pero ese es el promedio de vida... no el minimo... y mi objetivo es que el diseño de esta solución sea lo más durable posible. Calculo que una heladera tiene que durar ese tiempo o quizá más.
Un abrazo
-
Tienes razon, si lo ves desde ese punto de vista tienes razon, otra solucion seria en vez de hacerlo cada hora, hacerlo cada 5 horas, o 10 horas, con esto se multiplicaria el tiempo de vida de la eeprom
Saludos.
-
Magnífico proyecto. Te felicito porque una vez terminado parece sencillo, pero realmente tiene detrás un montón de horas de quebraderos de cabeza.
Esas temperaturas que pones en el texto, ¿son grados Farenheit?
No. Son centígrados!
El desafío grande fue lidiar con el ruido para implementar un PIC en el hostil mundo real.
Aprendí mucho en el camino. Estaba pensando escribir un artículo aquí sobre el tema.
Un abrazo
-
Tienes razon, si lo ves desde ese punto de vista tienes razon, otra solucion seria en vez de hacerlo cada hora, hacerlo cada 5 horas, o 10 horas, con esto se multiplicaria el tiempo de vida de la eeprom
Saludos.
La solución que le di es fina... si se va la luz, cuando vuelve, lo primero que hace es disparar un ciclo de descongelado.
¿Que es lo peor que puede pasar? Que justo después de un ciclo de descongelado venga otro.
Como el descongelado está microcontrolado (el PIC monitorea el termistor del evaporador, y cuando llega a los 4 grados centígrados da por terminado el ciclo), ya lo he probado y dos ciclos de descongelado seguidos (sin ni un minuto de distancia entre uno y otro) no son suficientes para derretir un cubito de hielo (mucho menos un alimento que esté congelado desde hace tiempo).
Si el segundo ciclo de descongelado es una hora después del funcionamiento de la heladera, entonces es totalmente normal y es más, ayuda a mantener la heladera bien descongelada.
Esta conducta se puede modificar desde el menu... y revisar a mano... si se limpiaron los contadores, se reseteo la heladera y se puede dispara un ciclo de descongelado manual... pero en realidad que quede descongelando al arranque es una solución porque te olvidás del tema.
Un abrazo
-
Exelente su trabajo Amigo y muy buen aporte para quien quiera hacer algo así o tenga el mismo problema con las heladeras que poseen placas electrónicas.
Saludos.
-
Hola gente. Poco me ven por acá como se habrán dado cuenta pero leo casi todo (No me he presentado lo cual haré luego de este mensaje antes que me lo notifique algún moderador)
También se que el tema es muy viejo pero alguien que quiera hacer algo parecido tiene una idea del funcionamiento de las NO Frost.
El tema es el siguiente estudio electrónica digital porque soy técnico en refrigeración y la mayoría de las heladeras no frost tienen el mismo problema.
Estimado Gustavo, como habrás visto, en el primer post están especificados los ciclos. Lo saqué del manual de servicio de Bosch. Calculo que son los mismos para cualquier heladera no frost. Lo que vos describís es el equipamiento de una heladera analógica. Las heladeras de la era digital como la Bosch KSU-66, no tienen termostato ni bimetal. El control se hace desde la plaqueta con el microcontrolador via relays.
A propósito... mi heladera sigue funcionando sin problemas. Ya cumplió 5 años!
Saludos
Pastito
-
.
-
gag2009 creo que entendiste mal el mensaje o al menos el tono del mismo, es cierto que pastito no leyo el post tuyo por completo o se salteo la parte que dice "NoFrost mas viejas", pero eso no amerita tu respuesta de esa forma (al menos como lo lei yo al remarcar tantas veces que usted dejo de particiar en los foros por los motivos que sean y que te respondieron de manera despreciativa).
Es cierto que mucha gente no lee ni investiga, de aqui tal ves la mayoria de las preguntas se soluciona usando google, pero la gente es asi.
Respecto al foro:
No creo que haga falta decirlo pero aqui todos tenemos puntos de vista distintos. Estamos para aportar ese punto de vista, ante un problema distintas personas aportan distintas "posibles" soluciones. Y es cuestion de la persona elegir el camino a seguir. Se enseña a las personas que no saben y tambien se aprende de las personas que saben mucho mas que uno.
Respecto a las heladeras, en base a mi experiencia:
Yo tambien estoy en desacuerdo sobre pastito sobre lo del ciclo del compresor, este tiene que marchar hasta que llegue a la temperatura deseada o que exista un ciclo mas largo de encendido/apagado.
A pesar que lo diga el manual me parece muy corto. Es mi parecer, pero si el desarrollador hizo asi el programa y pone cual es el funcionamiento en el manual, me parece bien. Su objetivo fue copiar el funcionamiento de lo que dice el manual y lo logro, me parece excelente y cumplio con su objetivo, funciona dentro de los parametros que tuvo al diseñarlo (parametros ofrecidos por el manual)
Una de las cosas que note en tu post fue el Fusible termico. Yo ademas de las planchas(algunas) jamas los vi. Ya que calientan muy poco las resistencias al menos las que probe.
Otra generalidad que hiciste y que a mi no me parecio fue
Eso es en las heladeras NoFrost mas viejas las nuevas reemplazan todo eso por placa y sensores y respetan los mismos funcionamientos.
No todas funcionan igual como ya dije, depende de lo que el diseñador hizo en el programa. Me refiero al ciclo de apagado/encendido. Ventilador, etc.
Mi pregunta por ejemplo para vos seria:
Bimetal digamos que es una llave térmica para entenderlo mas o menos funciona cuando tenemos en su base temperaturas menores a los -5 grados (parece un transistor) y lo que hace es habilitar el paso de los 220 v para la resistencia
En resumen siempre esta activo y calienta el freezer hasta llegar a los -5ºC ?. Si estas a -20ºC en el ambiente(aire) del freezer, el caño deberia estar mucho mas frio.
PD: es mas un rele activado por temperatura (por su caracteristica ON-OFF)
El punto de descongelamiento puede variar. Por ejemplo puedo hacer marchar el descongelamiento 15 min cada ves que paro el compresor en su ciclo de 6hs y cortarlo en caso que caliente por demas.
En fin como ves cada uno tiene su punto de vista. Esto no quita que vos tengas razon (y yo no) o que yo la tenga (y vos no), podemos tenerla ambos o ninguno. Nos basamos en la experiencia obtenida y en lo que sabemos.
-
Estimado moderador,
Me ajuste a los ciclos descriptos en el manual de Bosch, pero, para proteger el compresor de sobrecalentamiento,
escribí un ciclo para que se apague cada 30 minutos de encendido y descanse por 5 minutos, independientemente de que si llegó
a la temperatura correcta o no. Esta es una medida de seguridad... si se quedó sin gas y no es eficiente el compresor, que no se queme.
Al ser microcontrolado todo y bajo demanda, los ciclos no son del todo fijos, sino que tienen variaciones dependiendo de las condiciones
o demanda. Creo personalmente que es más eficiente en cuanto a consumo de energía.
El comportamiento del ciclo de deshielo cuando se fue la energía es seteable (grabable en la EEPROM), para poder configurar si lo
queremos o no.
Publico el código en PICC del proyecto por si alguien tiene el mismo problema. Tengo también los diseños en eagle de todas las placas
de control que diseñé.
Reemplacé mi email con xxxx... por motivos obvios... no quiero que mi casilla se llene de spam.
Espero que le sirva a alguien. Este código tiene la virtud de estar probado por el tiempo... 5 años de perfecto funcionamiento en
mi heladera lo atestiguan.
Me quedaron cosas en el tintero que en un momento quise escribir. Por ejemplo el buzzer sacarlo por PWM para que suene encendido/apagado
y no un tono continuo como ahora.
En la sección del forzador (fan) se podría juntar estadísticas, en conjunto con las estadísticas de ciclo de compresor. Si ambos pasan demasiado tiempo
encendidos, se perdió la eficiencia (probablemente se descargó el gas) y estaría bueno imprimir un mensaje de error en el display LCD.
#define CLOCK_SPEED 4000000 // Reloj a 4 Mhz (mas que suficiente y mas estable)
#define INTS_PER_SECOND 15 // (4000000/(4*256*256)) // Para interrupt timer0
#define USAR_WDT // Comentar si no queremos usar WDT
// Ver parametro WDT_TIMEOUT en la inicializacion
#define BITS_ADC 10 // Resolucion ADC de 10 bits
#define FAC_ADC 0.004882813 // Convertir ADC a volts 5/1024
#define T_HEL 7 // Canal ADC del termistor de la heladera
#define T_FRE_EV 6 // Canal ADC termistor del evaporador (freezer)
#define T_FRE 5 // Canal ADC termistor freezer
#define T_HEL_R2 10000 // Valor de la resistencia R2 en termistor heladera
// Constantes para el termistor del freezer para polinomio Steinhart/Hart
#define T_FRE_a 1.3089E-03
#define T_FRE_B 2.3286E-04
#define T_FRE_C 1.0230E-07
// Constantes para el termistor de 10 --heladera-- para polinomio Steinhart/Hart
#define T_HEL_a 1.6441E-03
#define T_HEL_B 1.4214E-04
#define T_HEL_C 5.2878E-07
#define USAR_LCD // Comentar si no queremos output a LCD
#define USAR_SERIAL // Comentar si no queremos output a serial
#define BOTON1 0 // Canal ADC del boton 1 de la botonera
#define BOTON2 1 // Canal ADC del boton 2 de la botonera
#define BOTON3 2 // Canal ADC del boton 3 de la botonera
#define COMPRESOR PIN_D4 // Relay que controla el compresor
#define HEATER PIN_D5 // Relay que controla el calentador del evaporador
#define TRAY PIN_D6 // Relay que controla el calentador de la bandeja
#define FAN PIN_D7 // Relay que controla el ventilador
#define PUERTA_HEL PIN_C5 // Puerta heladera
#define PUERTA_FRE PIN_C4 // Puerta del freezer
#define BUZZER PIN_C3 // Chicharra de puertas abiertas
#define ARRANQUE 60 // Numero de segundos antes de arrancar
#define TEMP_FRE_MAX -20 // Temperatura maxima de freezer
#define TEMP_FRE_MIN -27 // Temperatura minima de freezer
#define TEMP_FRE_MIN_NOFAN -25 // Temperatura Freezer minima sin fan
#define TEMP_MIN_EV -42 // Temperatura minima del evaporador
#define TEMP_HEL_MAX_DEF 8 // Temperatura minima heladera por default
#define TEMP_HEL_MIN_DEF 4 // Temperatura maxima heladera por default
#define TEMP_MAX_SET 15 // Temperatura maxima seteable para la heladera
#define TEMP_MIN_SET -5 // Temperatura minima seteable para la heladera
#define TEMP_MAX_DES 4 // Temperatura maxima del evaporador en deshielo
#define COMP_MAX_ON 1800 // Tiempo en seg maximo de encendido de compresor
#define COMP_MIN_OFF 300 // Segundos minimos de descanso de compresor
#define FAN_MAX_OFF 1800 // Segundos del ventilador sin hacer nada
#define CICLO_MIN_FAN 60 // Segundos de encendido del fan
#define TIEMPO_COMP_MAX 72000 // Tiempo maximo para descongelar
#define TIEMPO_COMP_MED 32400 // Tiempo medio para descongelar
#define TIEMPO_COMP_MIN 21600 // Tiempo min para descongelar
#define TIEMPO_PUERTAS_AB 900 // Tiempo maximo puertas abiertas p/descongelar
#define T_ULT_DESH_MIN 1100 // Tiempo minimo ultimo deshielo
#define T_MAX_PUER_ABIERTAS 40 // Tiempo maximo puertas abiertas
#define T_DESC_DESHIELO 600 // Tiempo de descanso antes del deshielo
#define T_MAX_DESHIELO 4800 // Tiempo maximo de deshielo
#define T_DESHIELO_TRAY 600 // Tiempo de deshielo del tray al final del ciclo
#define MS_MUESTRA_P 13 // Tiempo de muestreo puertas
#define PANTALLA_MAX 12 // Numero de pantallas de info a mostrar
#define TMOUT_TMP_SET 40 // Timeout seteo de temperatura
#if defined(__PCM__)
#include <16F877.h>
#fuses HS,NOWDT,NOPROTECT,NOLVP
#use delay(clock=CLOCK_SPEED)
#use rs232(baud=19200, xmit=PIN_C6, rcv=PIN_C7)
#device adc=BITS_ADC
#elif defined(__PCH__)
#include <18F452.h>
#ifdef USAR_WDT
#fuses HS,WDT128,NOPROTECT,NOLVP,NOBROWNOUT
#else
#fuses HS,NOWDT,NOPROTECT,NOLVP,NOBROWNOUT
#endif
#device adc=BITS_ADC
#use delay(clock=CLOCK_SPEED)
#use rs232(baud=19200, xmit=PIN_C6, rcv=PIN_C7)
#rom int 0xf00000={1,2,3,4}
#endif
#include <bootloader.h>
#include <math.h> // Incluir funciones matematicas
#ifdef USAR_LCD
#include "C:\docs\pic\picc\18f452\heladera_4MHZ\lcd.c" // Cargar driver LCD
#endif
// Para interrupt reloj
long long seconds = 0; // A running seconds counter
BYTE int_count; // Number of interrupts left before a second has elapsed
float temp_hel; // Temperatura heladera
float temp_ev; // Temperatura evaporador (se usa para descongelado)
float temp_fre; // Temperatura freezer
long long te_compresor; // Tiempo de encendido del compresor
long long ta_compresor; // Tiempo de apagado de compresor
long long t_compresor_total; // Tiempo total de encendido de compresor
long long te_fan; // Tiempo de encendido del compresor
long long ta_fan; // Tiempo de apagado de compresor
long long t_fan_total; // Tiempo total de encendido de compresor
long long te_deshielo; // Tiempo de comienzo de deshielo
long long ta_deshielo; // Tiempo de apagado de deshielo
long long t_ultimo_deshielo; // Tiempo del ultimo deshielo
long long t_puertas_abiertas; // Tiempo total de puertas abiertas
int1 compresor_encendido; // Compresor encendido = 1, apagado = 0
int1 fan_encendido; // Ventilador encendido = 1, apagado = 0
signed int deshielo_arranque; // Descongelar al arrancar, 1 = encendido, 0 = apagado
signed int temp_max_hel; // Temperatura maxima heladera
signed int temp_min_hel; // Temperatura minima heladera
long cant_deshielos; // Cantidad de deshielos
void espera (long segundos)
{
long i;
for (i=0; i < segundos * 5; ++i)
{
delay_ms (200);
#ifdef USAR_WDT
restart_wdt ();
#endif
}
}
/*
void test ( )
{
#ifdef USAR_SERIAL
printf ("Relay 1 prendido\n\r");
#endif
#ifdef USAR_LCD
printf (lcd_putc, "\fRelay 1\nPrendido");
#endif
output_low (COMPRESOR);
espera (4);
output_high (COMPRESOR);
#ifdef USAR_LCD
printf (lcd_putc, "\fRelay 1\nApagado");
#endif
#ifdef USAR_LCD
printf ("Relay 1 apagado\n\r");
#endif
espera (4);
}
*/
#int_rtcc // This function is called every time
void clock_isr() { // the RTCC (timer0) overflows (255->0).
// For this program this is apx 76 times
if(--int_count==0) { // per second.
++seconds;
int_count=INTS_PER_SECOND;
}
}
// Esta rutina espera la cantidad de segundos definida en ARRANQUE
// antes de encender la heladera para evitar posibles picos de tension
// despues de un corte de energia
void arrancar ( ) {
long i;
for (i = ARRANQUE; i > 0; --i) {
espera (1);
#ifdef USAR_LCD
printf (lcd_putc, "\fEncendido en\n%Lu segundos",i);
#endif
#ifdef USAR_SERIAL
printf ("%Lu seg para arrancar\n\r",i);
#endif
}
}
// Funcion polinimio de Steinhart-Hart para resolver curva de temperatura
// de termistores
// Si el parametro termistor es igual a 0, se trata del termistor de la
// heladera, si es igual a 1, es el termistor de freezer
float steinhart (float R1, int1 termistor){
float lnRes, lnRes3, temp, TempC ;
lnRes = log(R1);
lnRes3 = lnRes * lnRes * lnRes;
if (termistor == 0)
temp = T_HEL_a + T_HEL_B * lnRes + T_HEL_C * lnRes3;
else
temp = T_FRE_a + T_FRE_B * lnRes + T_FRE_C * lnRes3;
TempC = 1 / temp - 273.15; // Cero absoluto
return (TempC);
}
void temperaturas ( ) {
long res;
float R1;
#ifdef USAR_WDT
restart_wdt ();
#endif
// Leemos temperatura heladera
set_adc_channel (T_HEL);
delay_ms(10);
res = read_adc();
R1=((T_HEL_R2 *5) / (res * FAC_ADC)) - T_HEL_R2;
temp_hel = steinhart (R1, 0); // Llamar con 0 para heladera y con 1 para freezer
// Leemos temperatura freezer (evaporador)
set_adc_channel (T_FRE_EV);
delay_ms (10);
res = read_adc();
R1=((T_HEL_R2 *5) / (res * FAC_ADC)) - T_HEL_R2;
temp_ev = steinhart (R1, 1); // Llamar con 0 para heladera y con 1 para freezer
// Leemos temperatura freezer (evaporador)
set_adc_channel (T_FRE);
delay_ms (10);
res = read_adc();
R1=((T_HEL_R2 *5) / (res * FAC_ADC)) - T_HEL_R2;
temp_fre = steinhart (R1, 1); // Llamar con 0 para heladera y con 1 para freezer
}
void inicializar ()
{
// Setear todos los pines como output para evitar ruido
output_float (PIN_A0);
output_float (PIN_A1);
output_float (PIN_A2);
output_float (PIN_A3);
output_float (PIN_A4);
output_float (PIN_A5);
output_float (PIN_A6);
output_float (PIN_B0);
output_float (PIN_B1);
output_float (PIN_B2);
output_float (PIN_B3);
output_float (PIN_B4);
output_float (PIN_B5);
output_float (PIN_B6);
output_float (PIN_B7);
output_float (PIN_C0);
output_float (PIN_C1);
output_float (PIN_C2);
output_float (PIN_C3);
output_float (PIN_C4);
output_float (PIN_C5);
output_float (PIN_C6);
output_float (PIN_C7);
output_float (PIN_D0);
output_float (PIN_D1);
output_float (PIN_D2);
output_float (PIN_D3);
output_float (PIN_D4);
output_float (PIN_D5);
output_float (PIN_D6);
output_float (PIN_D7);
output_float (PIN_E0);
output_float (PIN_E1);
output_float (PIN_E2);
t_compresor_total = 0; // Inicializar tiempo total de encendido de compresor
ta_compresor = 0; // inicializamos tiempo apagado de compresor
te_compresor = 0; // Inicializamos tiempo de apagado del compresor
compresor_encendido = 0; // Seteamos el compresor en apagado
t_ultimo_deshielo = 0; // Inicializar tiempo ultimo deshielo
t_puertas_abiertas = 0; // Tiempo total de puertas abiertas
output_low (COMPRESOR); // Apagamos el compresor
output_low (FAN); // Apagamos el ventilador
output_low (HEATER); // Apagamos la resistencia de deshielo
output_low (TRAY); // Apagamos la resistencia de drenaje
output_low (BUZZER); // Apagamos la chicharra
fan_encendido = 0; // Seteamos el fan en apagado
te_fan = 0; // Resetamos Tiempo Encendido de ventilador
ta_fan = 0; // Reseteamos Tiempo Apagado de ventilador
t_fan_total = 0; // Reseteamos tiempo total del ventilador
cant_deshielos = 0; // Reseteamos cantidad de deshielos
temp_max_hel = read_eeprom (1); // Leemos las temperaturas de la EEPROM
temp_min_hel = read_eeprom (0);
deshielo_arranque = read_eeprom (2); // Leemos deshielo arranque
// Si las temperaturas estan fuera de rango, setear defaults
if (temp_max_hel > TEMP_MAX_SET || temp_max_hel < TEMP_MIN_SET)
temp_max_hel = TEMP_HEL_MAX_DEF;
if (temp_min_hel > TEMP_MAX_SET || temp_min_hel < TEMP_MIN_SET)
temp_min_hel = TEMP_HEL_MAX_DEF;
// Si el seteo de descongelar al arrancar esta mal, inicializarlo
if (deshielo_arranque < 0 || deshielo_arranque > 1)
deshielo_arranque = 1;
// Hacemos sonar el buzzer!
output_high (BUZZER);
delay_ms (500);
output_low (BUZZER);
#ifdef USAR_WDT
restart_wdt ();
#endif
}
void cont_compresor (int1 i) {
if (i == 1) {
compresor_encendido = 1; // Ponemos la bandera de compresor encendido
te_compresor = seconds; // Empezamos a contar los segundos
output_high (COMPRESOR); // Encendemos el compresor
}
if (i == 0) {
compresor_encendido = 0;
output_low (COMPRESOR);
ta_compresor = seconds;
t_compresor_total = t_compresor_total + (ta_compresor - te_compresor);
}
}
void cont_fan (int1 i) {
if (i == 1) {
fan_encendido = 1; // Ponemos la bandera de ventilador encendido
te_fan = seconds; // Empezamos a contar los segundos
output_high (FAN); // Encendemos el ventilador
lcd_init ();
delay_ms (20);
}
if (i == 0) {
fan_encendido = 0;
output_low (FAN); // Apagamos el ventilador
ta_fan = seconds;
t_fan_total = t_fan_total + (ta_fan - te_fan);
lcd_init ();
delay_ms (20);
}
}
void descongelar (void) {
int1 terminado=0;
long i;
cont_compresor (0); // Apagamos el compresor
output_low (FAN); // Apagamos el ventilador
t_compresor_total = 0; // Reseteamos tiempo de compresor encendido
t_puertas_abiertas = 0; // Reseteamos tiempo total de puertas abiertas
// 5 minutos de descanso
++cant_deshielos;
delay_ms (10);
for (i=T_DESC_DESHIELO; i > 0; --i) {
#ifdef USAR_LCD
printf (lcd_putc, "\fDeshielo-Espera\n%ld segundos",i);
#endif
#ifdef USAR_SERIAL
printf ("\fDeshielo-Espera %ld segundos\n\r",i);
#endif
espera (1);
}
lcd_init ();
delay_ms (20);
// Mientras que el sensor de temperatura del evaporador no llegue a los
// 3 grados centigrados, calentar resistencia de evaporador y de dreno
te_deshielo = seconds;
output_high (HEATER); //Encendemos el heater
#ifdef USAR_LCD
printf (lcd_putc, "\fEncendiendo\nheater");
#endif
#ifdef USAR_SERIAL
printf ("\fEncendiendo heater...\n\r");
#endif
espera (2); // Para que se alcance a leer en el display
// Esperamos 10 segundos para evitar golpe
for (i=10; i > 0; --i) {
#ifdef USAR_LCD
printf (lcd_putc, "\fEspera\n%ld segundos",i);
#endif
#ifdef USAR_SERIAL
printf ("\fEspera %ld segundos\n\r",i);
#endif
espera (1);
}
lcd_init ();
delay_ms (20);
output_high (TRAY); // Encendemos el tray
#ifdef USAR_LCD
printf (lcd_putc, "\fEncendiendo\ntray");
#endif
#ifdef USAR_SERIAL
printf ("\fEncendiendo tray...\n\r");
#endif
espera (2); // Para que se alcance a leer en el display
while (!terminado) {
temperaturas ();
if ((temp_ev > TEMP_MAX_DES) || (seconds-te_deshielo) > T_MAX_DESHIELO) {
terminado = TRUE;
output_low (HEATER); // Apagamos el heater
}
#ifdef USAR_LCD
printf (lcd_putc, "\fDeshielo T:%f\nSeg: %Lu", temp_ev, seconds-te_deshielo);
#endif
#ifdef USAR_SERIAL
printf ("\fDeshielo.T %f Segundos: %Lu\n\r", temp_ev, seconds-te_deshielo);
#endif
espera (1);
}
ta_deshielo = seconds;
t_ultimo_deshielo = (ta_deshielo - te_deshielo);
// La resistencia de dreno tiene que quedar encendida 10 minutos mas
for (i = T_DESHIELO_TRAY; i > 1; --i) {
#ifdef USAR_LCD
printf (lcd_putc, "\fDeshielo-Tray\n%ld Tot %Lu",i, t_ultimo_deshielo);
#endif
#ifdef USAR_SERIAL
printf ("\fDeshielo-Tray %ld Seg - Tot %Lu\n\r",i, t_ultimo_deshielo);
#endif
espera (1);
}
output_low (TRAY); // Apagamos la resistencia de dreno
}
int1 leer_puertas (VOID)
{
int1 muestra1, muestra2, muestra3, muestra4;
int1 puerta_ab_hel, puerta_ab_fre;
int1 resultado;
muestra1 = input (PUERTA_HEL); // Tomamos 3 muestras de 15 milisegundos de la puerta de la heladera
delay_ms (MS_MUESTRA_P); // para evitar la cuadrada de 50Hz
muestra2 = input (PUERTA_HEL);
delay_ms (MS_MUESTRA_P);
muestra3 = input (PUERTA_HEL);
delay_ms (MS_MUESTRA_P);
muestra4 = input (PUERTA_HEL);
if (muestra1 || muestra2 || muestra3 || muestra4)
puerta_ab_hel = TRUE;
else
puerta_ab_hel = FALSE;
muestra1 = input (PUERTA_FRE); // Tomamos 3 muestras de 15 milisegundos de la puerta de la heladera
delay_ms (MS_MUESTRA_P); // para evitar la cuadrada de 50Hz
muestra2 = input (PUERTA_FRE);
delay_ms (MS_MUESTRA_P);
muestra3 = input (PUERTA_FRE);
delay_ms (MS_MUESTRA_P);
muestra4 = input (PUERTA_FRE);
if (muestra1 || muestra2 || muestra3 || muestra4)
puerta_ab_fre = TRUE;
else
puerta_ab_fre = FALSE;
if (puerta_ab_hel || puerta_ab_fre)
resultado = 1;
else
resultado = 0;
#ifdef USAR_WDT
restart_wdt ();
#endif
return (resultado);
}
int1 leer_boton (int canal_adc)
{
long res;
#ifdef USAR_WDT
restart_wdt ();
#endif
set_adc_channel (canal_adc);
delay_ms(10);
res = read_adc();
if (res > 1000)
{
delay_ms (150); // Debounce del pobre
#ifdef USAR_WDT
restart_wdt ();
#endif
return (1);
}
else
return (0);
}
void seteos_varios (VOID)
{
int1 pb1, pb2, pb3, salir1, salir2, desc;
long long te_temp; // Tiempo en el que comenzamos a setear la temperatura
signed int temp_min_ori;
signed int temp_max_ori;
signed int deshielo_arranque_ori;
salir1 = FALSE;
salir2 = FALSE;
desc = FALSE;
te_temp = seconds;
temp_min_ori = temp_min_hel;
temp_max_ori = temp_max_hel;
deshielo_arranque_ori = deshielo_arranque;
#ifdef USAR_LCD
lcd_init (); // Inicializar Display LCD
delay_ms (10);
#endif
while (!salir1)
{
#ifdef USAR_WDT
restart_wdt ();
#endif
pb1 = leer_boton (BOTON1); // Leemos los botones de la botonera
pb2 = leer_boton (BOTON2);
pb3 = leer_boton (BOTON3);
// Seteamos temperatura minima
while (!salir2)
{
#ifdef USAR_WDT
restart_wdt ();
#endif
#ifdef USAR_LCD
printf (lcd_putc, "\fTEMP MINIMA:\n%d", temp_min_hel);
#endif
#ifdef USAR_SERIAL
printf ("\fTEMP MINIMA: %d\n\r", temp_min_hel);
#endif
pb1 = leer_boton (BOTON1); // Leemos los botones de la botonera
pb2 = leer_boton (BOTON2);
pb3 = leer_boton (BOTON3);
if (pb1)
salir2 = TRUE;
if (pb2)
{
--temp_min_hel;
if (temp_min_hel < TEMP_MIN_SET)
temp_min_hel = TEMP_MIN_SET;
}
if (pb3)
{
++temp_min_hel;
if (temp_min_hel > TEMP_MAX_SET)
temp_min_hel = TEMP_MAX_SET;
}
if ((seconds - te_temp) > TMOUT_TMP_SET)
salir2 = TRUE;
}
// Seteamos temperatura maxima
salir2 = FALSE;
while (!salir2)
{
#ifdef USAR_WDT
restart_wdt ();
#endif
#ifdef USAR_LCD
printf (lcd_putc, "\fTEMP MAXIMA:\n%d", temp_max_hel);
#endif
#ifdef USAR_SERIAL
printf ("\fTEMP MAXIMA: %d\n\r", temp_max_hel);
#endif
pb1 = leer_boton (BOTON1); // Leemos los botones de la botonera
pb2 = leer_boton (BOTON2);
pb3 = leer_boton (BOTON3);
if (pb1)
salir2 = TRUE;
if (pb2)
{
--temp_max_hel;
if (temp_max_hel < TEMP_MIN_SET)
temp_max_hel = TEMP_MIN_SET;
}
if (pb3)
{
++temp_max_hel;
if (temp_max_hel > TEMP_MAX_SET)
temp_max_hel = TEMP_MAX_SET;
}
if ((seconds - te_temp) > TMOUT_TMP_SET)
salir2 = TRUE;
}
if (pb1){
salir1 = TRUE;
}
if ((seconds - te_temp) > TMOUT_TMP_SET)
salir1 = TRUE;
// Preguntamos si queremos un ciclo de descongelado manual
salir2 = FALSE;
while (!salir2)
{
#ifdef USAR_WDT
restart_wdt ();
#endif
#ifdef USAR_LCD
printf (lcd_putc, "\fDeshielo ahora?\n");
if (desc == TRUE)
printf (lcd_putc, "SI");
else
printf (lcd_putc, "NO");
#endif
#ifdef USAR_SERIAL
printf ("\fDescongelar ahora?");
if (desc == TRUE)
printf ("SI\n\r");
else
printf ("NO\n\r");
#endif
pb1 = leer_boton (BOTON1); // Leemos los botones de la botonera
pb2 = leer_boton (BOTON2);
pb3 = leer_boton (BOTON3);
if (pb1)
salir2 = TRUE;
if (pb2)
--desc;
if (pb3)
++desc;
if ((seconds - te_temp) > TMOUT_TMP_SET) {
salir2 = TRUE;
desc = FALSE;
}
}
// Preguntamos si queremos setear deshielo al arranque
salir2 = FALSE;
while (!salir2)
{
#ifdef USAR_WDT
restart_wdt ();
#endif
#ifdef USAR_LCD
printf (lcd_putc, "\fDeshielo arranq?\n");
if (deshielo_arranque == TRUE)
printf (lcd_putc, "SI");
else
printf (lcd_putc, "NO");
#endif
#ifdef USAR_SERIAL
printf ("\fDeshielo al arranque?");
if (deshielo_arranque == TRUE)
printf ("SI\n\r");
else
printf ("NO\n\r");
#endif
pb1 = leer_boton (BOTON1); // Leemos los botones de la botonera
pb2 = leer_boton (BOTON2);
pb3 = leer_boton (BOTON3);
if (pb1)
salir2 = TRUE;
if (pb2)
deshielo_arranque = 0;
if (pb3)
deshielo_arranque = 1;
if ((seconds - te_temp) > TMOUT_TMP_SET) {
salir2 = TRUE;
deshielo_arranque = TRUE;
}
}
}
if ((seconds - te_temp) > TMOUT_TMP_SET)
{
#ifdef USAR_LCD
printf (lcd_putc, "\fTIMEOUT\nseteos");
#endif
#ifdef USAR_SERIAL
printf ("TIMEOUT en seteos!\n\r");
#endif
espera (2);
}
if (temp_max_hel <= temp_min_hel)
{
#ifdef USAR_LCD
printf (lcd_putc, "\fERROR: temp min\n>= temp max!");
#endif
#ifdef USAR_SERIAL
printf ("ERROR: temp min => que temp max!\n\r");
#endif
temp_min_hel = temp_min_ori;
temp_max_hel = temp_max_ori;
espera (2);
}
// Escribimos en la EEPROM los valores
#ifdef USAR_WDT
restart_wdt ();
#endif
// Escribimos en la EEPROM los valores solo si cambiaron
if (temp_min_hel != temp_min_ori)
write_eeprom (0, temp_min_hel);
if (temp_max_hel != temp_max_ori)
write_eeprom (1, temp_max_hel);
if (deshielo_arranque != deshielo_arranque_ori)
write_eeprom (2, deshielo_arranque);
// Si elegimos que descongele manualmente... hacerlo
if (desc == TRUE)
descongelar ();
}
void main(void) {
int_count=INTS_PER_SECOND;
long long te_puertas_abiertas;
long long mostrar_info;
int1 puertas_abiertas;
int1 salir;
int1 pb1;
int1 pb2;
int1 pb3;
int pantalla;
long long dias, horas, minutos, segundos;
inicializar (); // Inicializar variables y relays
set_timer0 (0);
setup_counters (RTCC_INTERNAL, RTCC_DIV_256 | RTCC_8_BIT);
enable_interrupts (INT_RTCC);
enable_interrupts (GLOBAL);
te_puertas_abiertas = 0;
pantalla = 1;
setup_adc(ADC_CLOCK_INTERNAL);
setup_adc_ports (ALL_ANALOG);
#ifdef USAR_WDT
// #define WDT_TIMEOUT 4 // default es de 7 segundos
setup_wdt (WDT_ON);
#endif
#ifdef USAR_LCD
lcd_init (); // Inicializar Display LCD
delay_ms (10);
#endif
#ifdef USAR_SERIAL
printf ("\r\nControl para heladera Bosch KSU-66 disenado, construido y programado por:\r\n");
printf ("Fernan Rodriguez Cespedes - xxxxxxx@xxxxx.com\r\n\r\n");
#endif
// Esta rutina nos avisa si se restarteo el procesador por Watchdog Timer o no
switch ( restart_cause() )
{
case WDT_TIMEOUT:
{
#ifdef USAR_LCD
printf (lcd_putc, "\fError\nRestart por WDT!");
#ifdef USAR_SERIAL
printf("\r\nReinicio por timeout del watchdog!\r\n");
#endif
espera (2);
break;
}
case NORMAL_POWER_UP:
{
#ifdef USAR_LCD
printf (lcd_putc, "\fEncendido\nnormal!");
#endif
#ifdef USAR_SERIAL
printf("\r\nEncendido normal!\r\n");
#endif
break;
}
}
// Si el seteo de descongelar al arrancar esta encendido, hacerlo. Si no, arrancar normalmente.
if (deshielo_arranque == TRUE)
descongelar ();
else
arrancar (); // Segundos antes de arrancar para proteger
// el compresor de un pico de tension si se fue la luz
mostrar_info = seconds - 4;
for (;;)
{
// test ();
#ifdef USAR_WDT
restart_wdt ();
#endif
temperaturas (); // Leer las temperaturas de los termistores NTC
// Seccion del compresor
if (temp_fre >= TEMP_FRE_MAX) // Si la temperatura del freezer es > limite
if (compresor_encendido == FALSE) // Si el compresor esta apagado...
if (seconds - ta_compresor > COMP_MIN_OFF) // Si el periodo de descanso se cumplio, encendemos
cont_compresor (TRUE);
if (compresor_encendido == TRUE) // Si el tiempo de enc compresor > maximo o si la temperatura < maximo, apagamos el compresor
if ((seconds - te_compresor) > COMP_MAX_ON || temp_fre <= TEMP_FRE_MIN)
cont_compresor (FALSE);
if (compresor_encendido == TRUE) // Si el fan esta apagado, la temperatura no va a llegar nunca abajo de los -25 en freezer
if (fan_encendido == FALSE) // asi es que apagamos el compresor
if (temp_ev <= TEMP_MIN_EV && temp_fre <= TEMP_FRE_MIN_NOFAN)
cont_compresor (FALSE);
// Fin seccion compresor
// Seccion ventilador (FAN)
if (fan_encendido == FALSE)
{
if (temp_hel >= temp_max_hel) // Si la temperatura de la heladera es mayor
cont_fan (TRUE); // que el maximo permitido, encendemos el FAN
if (compresor_encendido == TRUE && fan_encendido == FALSE) // Si el compresor esta encendido y el
cont_fan (TRUE); // ventilador esta apagado, prendemos el ventilador
}
if (fan_encendido == TRUE)
if (temp_hel <= temp_min_hel) // Si la temp es menor que el min, y el ciclo minimo se cumplio, lo apagamos
if ((seconds - te_fan) > CICLO_MIN_FAN)
cont_fan (FALSE);
if (fan_encendido == FALSE) // Encender el ventilador por timeout
if ((seconds - ta_fan) > FAN_MAX_OFF)
cont_fan (TRUE);
// Se podria agregar una seccion que cuente cuantos segundos estuvo
// encendido el ventilador. Si prendio demasiado, hay problemas.
// Fin seccion ventilador
// Seccion descongelado
if (t_ultimo_deshielo < T_ULT_DESH_MIN) // Si el tiempo del ultimo deshielo es menor al minimo
if (t_compresor_total > TIEMPO_COMP_MAX) // Si el tiempo total del compresor es mayor que el tiempo maximo, descongelamos
descongelar ();
if (t_ultimo_deshielo > T_ULT_DESH_MIN)
if (t_compresor_total > TIEMPO_COMP_MED)
descongelar ();
if (t_puertas_abiertas > TIEMPO_PUERTAS_AB)
if (t_compresor_total > TIEMPO_COMP_MIN)
descongelar ();
// Fin seccion descongelado
#ifdef USAR_WDT
restart_wdt ();
#endif
// Seccion puertas
puertas_abiertas = leer_puertas ();
if (puertas_abiertas)
{
salir = FALSE;
te_puertas_abiertas = seconds;
cont_fan(FALSE); // Apagamos el ventilador
#ifdef USAR_LCD
printf (lcd_putc, "\fPUERTAS\nABIERTAS");
#endif
#ifdef USAR_SERIAL
printf ("PUERTAS ABIERTAS\n\r");
#endif
while (!salir)
{
if ((seconds - te_puertas_abiertas) > T_MAX_PUER_ABIERTAS)
output_high (BUZZER);
puertas_abiertas = leer_puertas ();
if (puertas_abiertas == FALSE)
{
salir = TRUE;
output_low (BUZZER);
t_puertas_abiertas = t_puertas_abiertas + (seconds - te_puertas_abiertas);
}
#ifdef USAR_WDT
restart_wdt ();
#endif
}
//printf ("Test point 1\r\n");
cont_fan (TRUE); // Hacemos un ciclo de ventilador
mostrar_info = seconds - 4;
}
// Fin seccion puertas
// Seccion botonera (la ultima uffffff!!!! lo que costo llegar hasta aca!!!!)
pb1 = leer_boton (BOTON1); // Leemos los botones de la botonera
pb2 = leer_boton (BOTON2);
pb3 = leer_boton (BOTON3);
// Si presionamos el Push Button 1 (pb1) entonces nos metemos en el modo
// de setear la temperatura. La misma se escribe a EEPROM interna para que
// no se pierda en un reset.
if (pb1)
seteos_varios (); // Ojo que esta es la temp a la que dispara el FAN, descongelado manual y descongelado al arranque
// Si presionamos los otros dos botones, incrementamos o decrementamos la
// variable pantalla, para que el display LCD nos muestre otra info.
// PANTALLA_MAX es el numero maximo de pantallas disponibles
if (pb2) {
--pantalla;
if (pantalla < 1)
pantalla = PANTALLA_MAX;
mostrar_info = seconds - 4; // Hacemos que el display muestre al toque para que parezca responsivo
}
if (pb3) {
++pantalla;
if (pantalla > PANTALLA_MAX)
pantalla = 1;
mostrar_info = seconds - 4;
}
// Fin seccion botonera! Chaaa chaaaaaaannnn!!!!
// Mostramos info nueva solo cada 4 segundos... es una heladera cheee!!!!
if (mostrar_info < seconds - 3)
{
mostrar_info = seconds;
#ifdef USAR_LCD
if (pantalla == 1)
printf (lcd_putc, "\fTemps - H:%f\nE:%f F:%f", temp_hel, temp_ev, temp_fre);
if (pantalla == 2)
printf (lcd_putc, "\fCompresor = %d\nVent = %d", compresor_encendido, fan_encendido);
if (pantalla == 3)
{
segundos = t_ultimo_deshielo;
minutos = segundos / 60;
segundos %= 60;
horas = minutos / 60;
minutos %= 60;
printf (lcd_putc, "\fTiempo ult desh\n%02Lu:%02Lu:%02Lu", horas, minutos, segundos);
}
if (pantalla == 4)
{
segundos = seconds;
minutos = segundos / 60;
segundos %= 60;
horas = minutos / 60;
minutos %= 60;
dias = horas / 24;
horas %= 24;
printf (lcd_putc, "\fTiempo encendido\n%Lu:%02Lu:%02Lu:%02Lu", dias, horas, minutos, segundos);
}
if (pantalla == 5)
{
segundos = t_compresor_total;
minutos = segundos / 60;
segundos %= 60;
horas = minutos / 60;
minutos %= 60;
dias = horas / 24;
horas %= 24;
printf (lcd_putc, "\fTot COMP enc\n%Lu:%02Lu:%02Lu:%02Lu", dias, horas, minutos, segundos);
}
if (pantalla == 6)
{
segundos = t_fan_total;
minutos = segundos / 60;
segundos %= 60;
horas = minutos / 60;
minutos %= 60;
dias = horas / 24;
horas %= 24;
printf (lcd_putc, "\fTot FAN enc\n%Lu:%02Lu:%02Lu:%02Lu", dias, horas, minutos, segundos);
}
if (pantalla == 7)
{
segundos = t_puertas_abiertas;
minutos = segundos / 60;
segundos %= 60;
horas = minutos / 60;
minutos %= 60;
printf (lcd_putc, "\fTotal puertas ab\n%02Lu:%02Lu:%02Lu", horas, minutos, segundos);
}
if (pantalla == 8)
printf (lcd_putc, "\fTemp max %d\nTemp min %d", temp_max_hel, temp_min_hel);
if (pantalla == 9)
{
if (compresor_encendido)
printf (lcd_putc, "\fTiempo enc COMP\n%Lu", seconds - te_compresor);
else
printf (lcd_putc, "\fTiempo apag COM\n%Lu",seconds - ta_compresor);
}
if (pantalla == 10)
{
if (fan_encendido)
printf (lcd_putc, "\fTiempo enc FAN\n%Lu", seconds - te_fan);
else
printf (lcd_putc, "\fTiempo apag FAN\n%Lu", seconds - ta_fan);
}
if (pantalla == 11)
printf (lcd_putc, "\fCant deshielos\n%ld", cant_deshielos);
if (pantalla == 12)
printf (lcd_putc, "\fxxxxxx@\nyahoo.com");
#endif
#ifdef USAR_SERIAL
printf("\n\rUptime: %Lu seconds.\n\r",seconds);
printf ("Temperaturas -> hel:%f ev:%f fre:%f\n\r", temp_hel, temp_ev, temp_fre);
printf ("Comp = %d - Fan = %d\n\r", compresor_encendido, fan_encendido);
printf ("TE comp = %Lu - TA comp = %Lu\n\r", seconds - te_compresor, seconds - ta_compresor);
printf ("TE fan = %Lu - TA fan = %Lu\n\r", seconds - te_fan, seconds - ta_fan);
printf ("T_COMP_TOTAL = %Lu T_FAN_TOTAL = %Lu\n\r", t_compresor_total, t_fan_total);
printf ("Tiempo ultimo deshielo = %Lu\n\r", t_ultimo_deshielo);
printf ("Total puertas abiertas %Lu\n\r", t_puertas_abiertas);
printf ("Pantalla %d - Deshielos = %ld\n\r", pantalla, cant_deshielos);
printf ("temp_max_hel %d temp_min_hel %d\n\r", temp_max_hel, temp_min_hel);
#endif
}
}
}
-
Personalmente creo que no era necesario hacer todo eso ya que vienen temporizadores mecanicos para las no frost y de termostato le pones uno mecanico, pero bueno, te divertiste
-
Hola. Soy oscar, primero quería felicitar a pastito por el proyecto, la verdad se ve muy completo. El motivo por el que revivo el post es que tengo una heladera wihrpool WRI424, el cual no consigo la placa original, sólo consigo una copia del original por 3700$, viendo lo que escribió pastito, creo que la placa la puedo adaptar a mi heladera, el tema es que no encuentro el esquema del pic, el link parece caído. Si alguien fuese tan amable de pasarmelo estaría muy agradecido!! Disculpen la molestia.
-
Hola. Soy oscar, primero quería felicitar a pastito por el proyecto, la verdad se ve muy completo. El motivo por el que revivo el post es que tengo una heladera wihrpool WRI424, el cual no consigo la placa original, sólo consigo una copia del original por 3700$, viendo lo que escribió pastito, creo que la placa la puedo adaptar a mi heladera, el tema es que no encuentro el esquema del pic, el link parece caído. Si alguien fuese tan amable de pasarmelo estaría muy agradecido!! Disculpen la molestia.
Tambien podrias usar la misma placa original de la whirpool, imagino que probaste y efectivamente es el micro quien murio. Me refiero de usar esa placa que ya posee todo, conectores, protecciones, fuente, etc. Y solo usar el software que hizo pastito ( si es que esta ) y hacer una pequeña plaqueta que conecte las cosas los pines del PIC con el pin correspondiente de la placa.
Tal ves necesites adaptar un par de cosas pero es viable, ahora si no queres hacer mas nada que simplemente copiar y pegar, espero que alguno posea el diseño o pastito vuelva:
Última vez activo: 10 de Abril de 2015, 13:23:57