Aplicación práctica de un Temporizador programable (MikroC 16F877)

[micro_carp]

Hola a todos!!!

Hace unos meses que retomé el tema de los Pics. Desde hace muchos años que no hacía nada respecto a esto, pero ahora estoy volviendo por los viejos caminos, porque esto es fascinante y además creo que tiene mucho potencial!!! … Antes el C no era tan difundido como ahora para aplicaciones con Microcontroladores… es mucho más potente  que el asembler. Soy nuevo en el foro, así que espero el apoyo de todo visitante a este post, tampoco soy un experto en programación, pero allí vamos...

Estaba pensando  hacer una aplicación práctica simple con el fin de poder  poner en marcha lo poco que puedo aprender durante mi tiempo libre, así que es una buena práctica (para mí) publicar mis avances, así puedo recibir críticas que mejoren mi técnica!!!

Vamos con lo principal:
Mi proyectito lo he llamado: “Aplicación práctica de un Temporizador programable”
Quería hacer una pequeña aplicación para una maquina, yo pensaba en usarlo para una insoladora aunque podría ser usado para cualquier cosa donde uno desee ingresar un tiempo por medio de unas teclas y luego presionado arranque debe empezar a funcionar, pero en realidad esto tiene varias funciones y también varias teclas que detallaré mas adelante. 

Por ahora les doy a conocer algunas de mis planteamientos. He pensado en que mi aplicación debe tener las siguientes funciones:
o Ingreso del tiempo de insolación
o Medidor del valor instantáneo de temperatura.
o Protección por sobre temperatura del motor y de la maquina insoladora 
o Reloj en tiempo real
o Horas de funcionamiento de las lámparas UV.
o Apagado de la luz UV al aperturar la puerta de la insoladora

Quizá  pueda parecer complicado para alguien que apenas empieza a manejar el C… Pero es un reto hacerlo posible, y aquí podrán seguir mis avances quizá en cámara lenta por que este desarrollo lo haré en mi tiempo libre, pero esto me pone en el reto de hacerlo lo mejor posible  y en el menor tiempo que pueda.

Por mi trabajo quizá pace algún tiempo antes de poder responder los mensaje que puedan haber, pero haré lo posible por tenerles algún avance cuando este cerca a una conexión a internet.

En el próximo post les doy más detalles de mi proyectito, por ahora les adelanto que quiero trabajar con el PIC16F877 compilo con MikroC.

Hasta el próximo post!!!

[micro_carp]

Un esquema inicial con el cual quiero empezar es el que inserto a continuación. Como verán, quiero que mi aplicación lleve 4 display de 7 segmentos. Como les decía mi aplicación no es algo de expertos y solo quiero poner en práctica lo que aprendo día a día, y lo más básico y económico es trabajar con display de segmentos y pulsadores.

- El PUERTO A manejará los 4 displays,
- El PUERTO D envía los datos a los displays
- El PUERTO B maneja los pulsadores
- El resto de pines disponibles serán utilizados mas adelante.

No se como hacer para que la imagen pueda ser colocada aqui mismo, asi que mejor lo adjunto, si alguien sabe com pegar la imagen en el mensaje me indica como hacerlo, por que no encuentro la manera de hacerlo.

Hasta la proxima...

[micro_carp]

Una de las cosas en las que he estado haciendo pruebas es como mostrar los datos en los displays de 7 segmentos. El programa que controlaría todo debería ser definido desde un inicio, por lo menos debería tener una secuencia ya definida, seguro que un programador experto haría un diagrama de flujo antes de empezar.

En realidad yo no tengo diagrama de flujo, pero tengo una idea de la secuencia que quiero que el programa realice. Eso lo publicaré en su momento.
Por ahora a mi me preocupa crear la parte del programa que deba mostrar en pantalla los datos. Así que me centraré en este punto… “Mostrar en pantalla los datos que yo deseo”.

Para que esto sea ordenado, en mi próximo post, vemos eso…

[micro_carp]

Como comentaba anteriormente, una parte del programa que debo realizar y en la que me ocuparé ahora es en mostrar los datos en los display. Tenemos 3 tipos de información que deben aparecer en la pantalla y son:

- Los minutos y segundos.
- La hora actual.
- Valores de configuración.

Como sabemos, tenemos 4 displays de 7 segmentos, el formato sería así:

   88.88 

Es decir MM.SS, estos mismos displays nos deben servir para mostrar otros datos por ejemplo, si yo quiero mostrar un código de error o alarma, estos mismos displays deben usarse. Digamos por ejemplo que el usuario apertura la tapa del equipo y entonces quiero mostrar un código de error, entonces debo mostrar códigos como “er.01”

Entonces, esta parte del programa debe mostrar los valores que se guardan en los registros tanto para la hora y minutos como para otros parámetros diversos.

Yo pienso que los dos primeros digititos deben mostrar los valores de algún registro y los otros dos deben mostrar los valores de otro registro. Así por ejemplo, mi temporizador tendrá un registro para contar los segundos y otro registro para contar los minutos, debo hacer que el programa decodifique el valor de estos registros y los muestre en la pantalla. El mismo trato tiene el registro de alarmas y errores incluso los registros donde actualizaré los datos para el reloj.

Olvidé decirles que pienso usar un reloj en tiempo real, pero como no se como hacer esa parte, lo estoy dejando para más adelante. Me ocuparé mas delante de este punto, por ahora la prioridad es el uso de los displays.

En el próximo post publico el programa que hace el barrido delos 4 displays y toma el dato de un registro y lo decodifica de tal manera que lo separa en dos registros y agrega el punto decimal. No se lo pierdan que esta interesante y necesito sus apreciaciones.

Por ahora paro la mano y me voy a hacer un poco de ejercicio físico para despejar la mente y concentrarme en mi proyectito!!!

[micro_carp]

Como les decía, lo primero que quiero hacer es la parte del programa que permita mostrar en pantalla el valor de los registros, aqui esta el codigo inicial que hace esto.

Explico luego:

-------------------------------------------------------------------------------------------------------------------------------------------

//*****DECLARACION DE LAS FUNCIONES
void BIN_7SEG(int f_data1bin,int f_data2bin);//Usado en la conversion de datos a
//valor de 7segmentos. Ingresas dos registros por ejemplo el de los segundos y
//minutos y entrega los datos en los registros (displa_1 ... display_4)

int BCD_7SEG(int f_digit);//Usado en la conversion de los datos a 7 segmentos
//Convierte valor BCD a 7 segmentos, cada registro es convertido a BCD y guardado
//en dos registros.

void DISPLAY(int f_data,int f_port);//Usado cuando se hace el barrido en cada
//interrupcion. Permite activar el bit del puerto que habilita el display asi
//mismo saca el dato por el puerto del display de 7segmentos (display_1...display_4)


//*****DECLARACION DE LAS VARIABLES

//*****DECLARACION DE VARIABLES USADAS PARA MOSTRAR VALOR EN DISPLAYS
unsigned count_1 =0; //Contador 1. Usado para mostrar los datos en displays
unsigned display_data=0; //Usado en "DISPLAY". Contiene valor a mostrar
unsigned display_port=0; //Usado en "DISPLAY". Indica que display mostrar

//*****DECLARACION DE VARIABLES USADAS PARA CONTABILIZAR SEGUNDOS Y MINUTOS
unsigned count_1sec=0;  //Ayuda a temporizar 250 veces 4ms para obtener 1 segundo
unsigned seconds_bin=0;//Cuenta los segundos en binario, de 0 a 59 segundos
unsigned minutes_bin=0;//Cuenta los minutos en binario, de 0 a 59 minutos


//*****DECLARACION DE VARIABLES USADAS PARA LA CONVERSION DE DATOS A VALORES DE
//7 SEGMENTOS. POR EJEMPLO EL REGISTRO SEGUNDOS ES CONVERTIDO PRIMERO A DOS
//REGISTROS EN BCD Y LUEGO PASADO A DOS REGISTROS CODIFICADO PARA 7 SEGMENTOS.
unsigned valor1_bcd=0;//Contiene el valor en BCD de f_data1bin
unsigned data1_7seg=0;//Contiene el primer digito en 7segmentos de Valor1_bcd
unsigned data2_7seg=0;//Contiene el segundo digito en 7segmentos de Valor2_bcd

unsigned valor2_bcd=0;//Contiene el valor en BCD de f_data2bin
unsigned data3_7seg=0;//Contiene el primer digito en 7segmentos de Valor2_bcd
unsigned data4_7seg=0;//Contiene el segundo digito en 7segmentos de Valor2_bcd

unsigned display_1=0; //Valor a mostrar en primer display (lado derecho)
unsigned display_2=0; //Valor a mostrar en segundo display
unsigned display_3=0; //Valor a mostrar en tercer display
unsigned display_4=0; //Valor a mostrar en cuarto display(lado izquierdo)


//--------------- RUTINA DE ATENCION A INTERRUPCIONES --------------------------

void interrupt() {

//------------- RUTINA DE ATENCION A INTERRUPCIONES POR TMRO -------------------
if (INTCON.TMR0IF==1){//Verificar si la interrupcion es por TMR0

//PRESENTACION DE VALOR EN LOS DISPLAYS EN CADA INTERRUPCION
  count_1++; //Contador usado para mostrar los datos en los displays. Cada incre-
             //mento se hace en 4ms.
  if (count_1==150) count_1=30; //Solo se muestran 4 displays y el punto

  switch (count_1){ // Permite seleccionar display que activara y valor que
                    //mostrara el display seleccionado.

         case 30: // Activaremos primer display y mostramos valor de "display_1"

              display_port=0b00000001;
              display_data=display_1;
              DISPLAY(display_data,display_port);//Llamada a funcion
              break;

         case 60: // Activamos segundo display y mostramos valor de "display_2"
              display_port=0b00000010;
              display_data=display_2;
              DISPLAY(display_data,display_port);//Llamada a funcion
              break;

         case 90: // Activamos tercer display y mostramos valor de "display_3"
              display_port=0b00000100;
              display_data=display_3;
              DISPLAY(display_data,display_port);//Llamada a funcion
              break;

         case 120: // Activamos cuarto display y mostramos valor de "display_4"
              display_port=0b00001000;
              display_data=display_4;//Llamada a funcion
              DISPLAY(display_data,display_port);
              break;
                  }


//REINICIO DE INTERRUPCION POR TMRO
  TMR0=6;  //Cargamos TMRO con el valor inicial
  INTCON=0b10100000;     // TMROIF=0(Bit_2), Reset Overflow Flag
                         // TMROIE=1(Bit_5), Enable TMRO interrupt
                         //GIE=1(Bit_7), Enable all interrupts
}
}

//-------------------------RUTINA PRINCIPAL-------------------------------------

void main(){

OPTION_REG = 0b10000100; //PS=100 (Bit_0,1,2) Prescaler select 1:32
                         //PSA=0 (Bit_3) Prescaler asigned to TMRO module
                         //TOCS=0 (Bit_5) Internal Clock (CLKO)
ADCON1=0X06;             //Configurar IOs como digitales
TRISA=0X00;              //Puerto_C como salida. Habilitacion de los displays
TRISD=0X00;
TRISB=0X00;              //Puerto_D como salida. Bus de datos para los displays
PORTA=PORTB=PORTD=0X00;  //Inicializar con los puertos apagados

TMR0=6;                  // Temporizador T0 cuenta de 6 a 255
INTCON=0b10100000;       // Habilitar interrupción por TMR0
                         // TMROIE=1 (Bit_5), Enable TMRO interrupt
                         // GIE=1 (Bit_7), Enable Global interrupts

while(1) {
    minutes_bin=3;
    seconds_bin=5;
    BIN_7SEG(minutes_bin,seconds_bin);
}
}






//++++++++++++++++++++DESARROLLO DE LAS FUNCIONES+++++++++++++++++++++++++++++++


//*****DESARROLLO DE FUNCION PARA CONVERTIR LOS DATOS BINARIOS A 4 VALORES GUAR
//DADOS EN DISPLAY_1 AL 4. F_DATA1BIN CONTIENE EL PRIMER VALOR BINARIO QUE SE
//CONVERTIRA EN BCD Y LUEGO A 7SEGMENTOS.  F_DATA2BIN ES EL SEGUNDO VALOR BINARIO
//f_data1bin es convertido y luego guardado en displays 1 y 2
//f_data2bin sobre los displays 3 y 4

   void  BIN_7SEG(int f_data2bin,int f_data1bin){
     valor1_bcd=Dec2Bcd(f_data1bin);//Funcion para convertir binario a BCD
     data1_7seg=valor1_bcd & 0b00001111;//Separar el primer digito BCD
     data2_7seg=(valor1_bcd & 0b11110000)>>4;//Separar el segundo digito BCD
     display_1=BCD_7SEG(data1_7seg);
     display_2=BCD_7SEG(data2_7seg);

     valor2_bcd=Dec2Bcd(f_data2bin);//Funcion para convertir binario a BCD
     data3_7seg=valor2_bcd & 0b00001111;//Separar el primer digito BCD
     data4_7seg=(valor2_bcd & 0b11110000)>>4;//Separar el segundo digito BCD
     display_3=(BCD_7SEG(data3_7seg)|0b10000000);//Colocamos el punto decimal
     display_4=BCD_7SEG(data4_7seg);//Funcion convierte el valor BCD a 7 Seg
       }


//*****DESARROLLO DE FUNCION PARA MOSTRAR LOS DATOS EN LOS DISPLAYS
void DISPLAY(int f_data,int f_port){
       PORTD=f_data; //Actualiza el valor a mostrar en display
       PORTA=f_port; //Activa el display donde mostraremos el dato
     return;
     }

//*****DESARROLLO DE FUNCION PARA PASAR BCD A 7 SEGMENTOS
int BCD_7SEG(int f_digit){

 switch (f_digit){
         case 0: return 0x3F; //0x3F es el código 7-segmentos del 0.
         case 1: return 0x06; //0x06 es el código 7-segmentos del 1.
         case 2: return 0x5B;
         case 3: return 0x4F;
         case 4: return 0x66;
         case 5: return 0x6D;
         case 6: return 0x7D;
         case 7: return 0x07;
         case 8: return 0x7F;
         case 9: return 0x6F;
 }
 }

[idide701]

Hola, yo no te voy poder echar una mano, pero te contesto por que, he visto que intentas construir un reloj en tiempo real, y yo tambien intento hacer uno con un DS1338, y aplicarlo a los pines 33 y 34 de un PIC18f4550, de entrada sólo quiero almacenar esta hora constantemente en un registro, para luego poder compararla con otros registros, y aqui llega mi primer problema,
¿como almaceno yo este dato constantemente? yo no se, si tu vas a hacer algo parecido, o alguien lo tiene hecho ó, puede decirme como hacerlo, pero agradeceria todo tipo de colaboración
un saludo
idide701

[AcoranTf]

Hola idide701, en cuanto al sistema de almacenado no te puedo ayudar, ya que no lo he hecho nunca, pero si te comento que para que alguien te ayude, haria falta saber con que frecuencia quieres almacenar el tiempo, (segundos, minutos, horas, por evento, etc.), la definicion de lo guardado, (fecha y hora completa, solo hora, minutos y segundos, etc.) y durante cuanto tiempo en total, ya que de eso dependera la capacidad que necesites para dicho almacenamiento. Si lo que quieres es controlar a que hora ocurrio algo en concreto, lomas correcto creo que seria que actives una interrupcion externa, que la dispare ese evento y en su rutina de atencion pongas que te guarde en la eeprom interna del PIC la hora en que ha ocurrido dicho evento. Este es el sistema mas eficaz, ya que no desperdicias capacidad. Si aun asi la capacidad de eeprom del PIC se te queda pequeña, deberias agregarle una eeprom externa, por ejemplo una 24C256 o similar, dependiendo de la capacidad necesaria.
Pero sobretodo aclara mejor tus necesidades, como te indicaba mas arriba.

Saludos.