El 555 lo tengo montado a monoestable a 2 minutos de duración. Los ventiladores siempre están activados, cuando falta la alimentación principal, el PIC lo detecta y debe mandar una señal al 555 para activar los 2 minutos con los ventiladores activados mientras el aparato esté apagado, claro que usa una fuente alimentación externa al aparato para alimetar los ventiladores, el PIC y el 555.
¿Por qué no hago todo en un PIC16F84A?
Porque ya incluye todos los pines, tiene sensor de temperatura y LCD a parte de tener la memoria lleba.
¿Por qué no uso otro PIC?
Porque no tengo más y este me conformo. En caso de usar un PIC16F886 tendría que cambiar el ASM que no es tarea fácil.
¿Tengo otra posibilidad en vez de usar el 555?
Sí, también tengo en mente usar un PIC12F508 que haga de temporizador o 555. Claro que este me cuesta mucho entenderlo para programarlo, con el 16F84A su código mediente retardo es este:
Mediante retardos:
Código:
; El LED conectado a la línea 0 del puerto de salida se enciende durante 400 ms y se
; apaga durante 300 ms. Utiliza las subrutinas de la librería RETARDOS.INC.
;
; ZONA DE DATOS *********************************************************************
LIST P=16F84A
INCLUDE <P16F84A.INC>
__CONFIG _CP_OFF & _WDT_OFF & _PWRTE_ON & _XT_OSC
CBLOCK 0x0C
ENDC
#DEFINE LED PORTB,0
; ZONA DE CÓDIGOS *******************************************************************
ORG 0
Inicio
bsf STATUS,RP0 ; Acceso al Banco 1.
bcf LED ; Línea del LED configurada como salida.
bcf STATUS,RP0 ; Acceso al Banco 0.
Principal
bsf LED ; Enciende el LED
call Retardo_200ms ; durante la suma de este tiempo.
call Retardo_200ms
bcf LED ; Lo apaga durante la suma de los siguientes
call Retardo_200ms ; retardos.
call Retardo_100ms
goto Principal
INCLUDE <RETARDOS.INC> ; Librería con subrutinas de retardo.
END En C he encontrado este código.
Código:
#include<16F84A.h>
#fuses XT,NOPROTECT,NOWDT,PUT
#use delay(clock=4000000)
int1 Temporizador=0; // Dada la escaces de una variable booleana, usaremos un int1 que es el equivalente
int1 dSegundo=0; // El Booleano dSegundo indica 0 cada decima de segundo y el booleano Temporizador si es uno activa el temporizador
int16 Contador=0; // Dado que 2 min = 120s = 120s * 0.1s= 1200 conteos, usaremos una variable de 16bits
#INT_TIMER0
void timer0()
{
set_timer0(60); // Se carga el valor inicial del timer0 para la siguiente interrupcion
dSegundo++; // Se incrementa el "Booleano" Segundo si era 0 ahora es 1, si era 1 ahora es 0
if(!dSegundo) Contador++; // Si Segundo == 0, entonces Contador se incrementa.
if(Contador == 1200) // Si ya pasaron 2 minutos se apaga el Temporizador y se desabilitan las interrupciones
{
Temporizador=0;
disable_interrupts(GLOBAL);
}
output_bit(PIN_B0,Temporizador); // Se refresca la salida del Relevador
}
void main()
{
output_low(PIN_B0); // Estado bajo del pin B0 indica que el relé está desactivado.
setup_timer_0(RTCC_INTERNAL|RTCC_DIV_256); // Se configura el Timer0 como Temporizador y el divisor a 1:256
// Dado que el Tiempo maximo del Timer0 con divisor de 1:256 es:
// t=4/Fosc(Prescaler*(Dimension_Timer - Tiempo cargado))
// t=4/4000000(256*(255-0))=0.06528s
// Por lo que nos conviene manejarlo a 0.05s, asi cada 2 interrupciones hace un segundo
// Un valor muy cercano a 0.05
enable_interrupts(GLOBAL); // Se habilitan las interrupciones GLOBALES
while(TRUE)
{
if(input(PIN_A4)) // Si se presiona el PIN_A4
{
if(!Temporizador) // Si el temporizador esta desabilitado
{
output_high(PIN_B0); // Se habilita el Relevador
set_timer0(60); // Se carga en el registro del Timer0 un 60 decimal dado que:
// t=4/4000000(256*(255-60))=0.04992
// Un valor muy cercano a 0.05
enable_interrupts(INT_TIMER0); // Se habilita la interrupcion del Timer0
Temporizador=1; // Se habilita el Temporizador
Contador=0; // Se restablece a 0 el indicador de decimas de segundo y el contador
dSegundo=0;
}
else // Si el temporizador esta habilitado
{
output_low(PIN_B0); // Se desabilita el Relevador
Temporizador=0; // Se desabilita el temporizador
disable_interrupts(INT_TIMER0); // Se desabilita la interrupcion del Timer0
}
while(input(PIN_A4)); // Se espera hasta que se deje de presionar el boton del PIN_A4
}
}
} Ya se sabe que los retardos el PIC queda exclavo y no interrumpe su trabajo hasta acabar. Este código de arriba está bien para pasarlo al 12F508 si me interesaría, mejor usar un TIMER.
En cuanto al 555. Como módulo es posible hacerlo independiente del PIC de esta manera.
El 555 tiene un tiempo monoestable de 2 minutos, en este caso se usará astable. Para conectarlo como módulo al PIC se aconseja astable del 50% cicle duty, por ejemplo, 1 segundo en nivel alto a 5V y lo mismo para 0V, así durante un tiempo. Mientre el 555 a modo astable soltando señal cuadrada del pin 3.
La ventaja del PIC16F84A es que tiene un contador que puede contar las señales cuadradas que te puede dar en el pin 3 del famoso NE555 como astable. Ya empieza a contar el tiempo el PIC por cada pulso. Parece que el NE555 debe seguir dando señales hasta que el contador del PIC llegue a cuenta atrás a tope para saltar un condición.
120 pulsos son 2 minutos si el 555 tiene el T1 y T2 a cada segundo. Cuando el contador llegue a 0 a la salida del PIC se desactiva los ventiladores.
¿Se entiende el consepto de algo modular?
El aprender no es perder el tiempo, aunque te lo parezca ahora, en el futuro podrás tener otras ideas.