Recursos del PIC. Interrupción Externa por RB0/INT

[biblioman]

Hola a todos. Aquí tenéis otro ejemplo del uso de los recursos del PIC.

Código: Seleccionar todo

/*--------------------------------------------------------*\
|  Ejemplo uso de interrupción externa por RB0            |
|  autor: biblioman                                       |
|  www.aquihayapuntes.com                                 |
\*--------------------------------------------------------*/
#include <16F84A.h>
#FUSES NOWDT        //No utilizar el timer Watch Dog
#FUSES XT           //Oscilador XT <= 4mhz
#FUSES NOPUT        //No timer en la alimentación
#FUSES NOPROTECT    //codigo no protegido
#bit RB0=0x06.0     //Identificadores de bits
#bit RB7=0x06.7
#bit RB1=0x06.1
#use delay(clock=4000000)//Frecuencia de reloj

#int_EXT
void  EXT_isr(void){
  if (RB1)//Si el interruptor de desactivación está abierto
  {
    RB7=1;// activa la alarma conectada en RB7 
    while(RB1); //mientras el RB1=1 bucle infinito
    RB7=0; //cuando RB1=0, se desacactiva la alarma
  }
}
void main(){
   set_tris_b(0b01111111); //configura la puerta B
   RB7=0;//inicializo RB7
   enable_interrupts(GLOBAL);//habilito interrupción global
   enable_interrupts(INT_EXT);//habilito interrupción externa
   while(true);     //Bucle infinito hasta interrupción
}


La alarma es muy simplona. Como posibles mejoras se podría hacer:

-Sustituir el interruptor por un LCD y un teclado, que presente un menú donde se pueda introducir una clave para desactivar la alarma, así como poder cambiar la clave que se tendrá que guardar en la EPROM del PIC.

-También que avise al exterior por medio de un SMS ó una llamada a un teléfono que previamente tengamos seleccionado.

Bueno espero vuestros comentarios y modificaciones del ejemplo para mejorarlo.

Un saludo y hasta pronto

El DNS lo tenéis aquí:

[QuijotescoXp]

Como siempre el ejemplo que propones está estupendo.

He de decir que sobre el montaje de proteus, la parte que gestiona la alarma a partir del transistor se me queda grande, es decir no piloto aun nada de darlintong, triac, etc.
Del resto lo entiendo sin problemas.

Desde mi punto de vista, yo no controlaría la desactivación de la alarma en el bloque de la interrupción. La explcación es sencilla, dejamos al micro en un espera activa hasta que se pulse la desactivación y eso no es del todo correcto.
Imaginemos, por poner un ejemplo, que debemos refrescar el valor del WDT cada 500 ms, y eso lo hacemos dentro del while(true) de la función main, si se tarda más de ese tiempo (cosa que ocurrirá seguro) en desactivar la alarma, el wdt reseteará el micro. No se si se entiende esto.

En su lugar propongo controlar la desactivación de la alarma dentro del while(true) de la función main, de esta manera:

Código: Seleccionar todo

#include <16F84A.h>
#FUSES NOWDT                    // No utilizar el timer Watch Dog
#FUSES XT                       // Oscilador XT <= 4mhz
#FUSES NOPUT                    // No timer en la alimentación
#FUSES NOPROTECT                // Código no protegido
#bit   RB0=0x06.0               // Identificadores de bits
#bit   RB7=0x06.7
#bit   RB1=0x06.1
#use   delay( clock = 4000000 ) //Frecuencia de reloj

#int_EXT

void EXT_isr( void )
{
   if( RB1 )
   {
      /* Si el interruptor de desactivación está abierto */
      RB7 = 1; // Se activa la alarma conectada en RB7       
   }
}

void main()
{
   set_tris_b( 0b01111111 );     // Se configura la puerta B
   RB7 = 0;                      // Se inicializa RB7
   enable_interrupts( GLOBAL );  // Se habilita la interrupción global
   enable_interrupts( INT_EXT ); // Se habilita la  interrupción externa
   
   while( true )
   {
      if( !RB1 && RB7 )
      {
         /* Si alarma desactivada y alarma en funcionamiento */
         RB7 = 0;         
      }
     
      /* Resto de gestiones en la funcion main...*/
   }
}


Ojo todo esto lo pongo sin compilar, ni probar.

Bueno pues ya me contareís que opinais.

[biblioman]

Hola Quijotesto XP. Me satisface que te interese el curso y participes tan activamente en él, a ver si conseguimos que cada vez sean mas los participantes.

He de decir que sobre el montaje de proteus, la parte que gestiona la alarma a partir del transistor se me queda grande, es decir no piloto aun nada de darlintong, triac, etc.

Un montaje darlintong es una conexión típica entre dos transistores con el fín de aumentar la ganancia de corriente. Hay mucha información en la red, si te interesa aqui tienes una página donde aparece el conexionada del par de transistores.

http://www.victoryvictor.net/transistor4.htm

Desde mi punto de vista, yo no controlaría la desactivación de la alarma en el bloque de la interrupción. La explcación es sencilla, dejamos al micro en un espera activa hasta que se pulse la desactivación y eso no es del todo correcto.
Imaginemos, por poner un ejemplo, que debemos refrescar el valor del WDT cada 500 ms, y eso lo hacemos dentro del while(true) de la función main, si se tarda más de ese tiempo (cosa que ocurrirá seguro) en desactivar la alarma, el wdt reseteará el micro.

En el ejemplo el WDT está desactivado por medio de la directiva:

#FUSES NOWDT

Por lo que el micro nunca se reseteará por lo menos a causa del WDT.

Si lo habilitamos también se puede refrecar dentro de la función de interrupción por medio de la función:

restard_wdt();

Sin embargo con vistas a ampliar las funcionalidades del ejemplo estoy de acuerdo contigo en la modificación que has hecho, de esta manera mientras RB1 este a uno (alarma conectada) el micro puede estar haciendo otras cosas dentro de main() o de cualquier otra función.

Ojo todo esto lo pongo sin compilar, ni probar.

El programa lo he probado y compila bien y el funcionamiento es correcto, solo le he visto un pequeño fallo y es que si la alarma está ya activada, cada vez que pulse el botón que simula el sensor de alarma se volverá a poner RB7 a 1 cosa que no es necesaria, ya que lo tenemos ya a nivel alto, modificando este pequeño detalle el ejemplo qedaría así:

Código: Seleccionar todo

#include <16F84A.h>
#FUSES NOWDT                    // No utilizar el timer Watch Dog
#FUSES XT                       // Oscilador XT <= 4mhz
#FUSES NOPUT                    // No timer en la alimentación
#FUSES NOPROTECT                // Código no protegido
#bit   RB0=0x06.0               // Identificadores de bits
#bit   RB7=0x06.7
#bit   RB1=0x06.1
#use   delay( clock = 4000000 ) //Frecuencia de reloj

#int_EXT

void EXT_isr( void )
{
   if( RB1 && !RB7 )
   {
      /* Si el interruptor de desactivación está abierto
      y la alarma no está activada ya*/
      RB7 = 1; // Se activa la alarma conectada en RB7       
   }
}

void main()
{
   set_tris_b( 0b01111111 );     // Se configura la puerta B
   RB7 = 0;                      // Se inicializa RB7
   enable_interrupts( GLOBAL );  // Se habilita la interrupción global
   enable_interrupts( INT_EXT ); // Se habilita la  interrupción externa
   
   while( true )
   {
      if( !RB1 && RB7 )
      {
         /* Si alarma desactivada y alarma en funcionamiento */
         RB7 = 0;         
      }
     
      /* Resto de gestiones en la funcion main...*/
   }
}

Un saludo y sigue comentando, tus aportaciones son muy valiosas.

[QuijotescoXp]

Perfecto, gracias por el enlace y ahora buscaré un hueco para empollarmelo y poder seguir a tu ritmo.

Saludos.

[myesid]

Hola a todos:

Tengo el siguiente programa desarrollado por mi con el pic 16f628A. este toma un dato binario de (4 bits + 1 bit de sincronia) lo compara con otro dato ya guardado en la eeprom interna del pic, al ser comparados tres datos ya guardados en la eeprom del pic este activa una salida y la mantiene por 6 series de tres datos activada si estos datos no se vuelven a presentar la salida se apaga.

al principio lo hize normal con su dato de entrada en el puerto A del pic y ya puedo generar la secuencia de encendido, pero al darme cuenta que el pic es mucho mas rapido que los datos de entrada decidi hacerlo por interrupcion externa pero no se como deberia ser la interaccion entre las constantes de apoyo del programa y la interrupcion.
agrego los dos codigos realizados espero me puedan ayudar a detectar errores y pueda aprender a manejar la interrupcion por RB0

1 Programa sin interrupcion

Código: Seleccionar todo

#include <16F628A.h>
    #use delay (clock=4000000)
    #use rs232(baud=9600,parity=N,xmit=PIN_b2,rcv=PIN_b1,bits=8)

   
    // declaracion de puertos direccion en mapa de memoria
    #byte porta=0x05
    #use fast_io(a)
   //al usar bit a bit como salida se debe declarar el tris correspondiente en el main
    #byte portb=0x06
    #use fast_io(b)     
   
    void main(void)
    {
         // declaracion de variables
         int eepromv [3];// valor de la eeprom
         int valordatos[3];// valor que viene de la linea de datos
         int aux;
         int cont;
         int i;
         
         // guarda el numero del decodificador en la eeprom interna del pic
            write_eeprom(0,12);
            write_eeprom(1,0);
            write_eeprom(2,2);
           
        // se asignan los datos de la eeprom a vector para su comparacion
       // con el dato de la linea de datos
            eepromv[0]=read_eeprom(0);
            eepromv[1]=read_eeprom(1);
            eepromv[2]=read_eeprom(2);       
         
         //configuracion de puertos
         set_tris_b(0x00);
         
         //programa
         for(;;)
         {
            //toma el dato del mt8870 de 5 bits y lo pasa a4 bit dejando aparte el std
            if(input(pin_a4)==1)
            {  aux=porta;
               
                for(i=0;i!=3;i++)
               {
                  valordatos[i]=aux-16;
                  printf("valor captura:%U\r:",valordatos[i]);
                  printf("valor de eeprom %u\r",eepromv[i]);
                         
                  if(valordatos[i]==eepromv[i])
                     {
                         cont++;
                         printf("valor del contador%u\r",cont);
                         if(cont>=3)
                        {
                            output_b(0x80);                             
                            if(cont<=5)
                            {
                               output_b(0x80);                                   
                            }
                            else
                              {  cont=0;
                                 output_b(0x00);
                              }                             
                        }
                        else
                           output_b(0x00);                         
                     }                                     
               }                       
            }
            else
            printf("valor es:%U\r:",0);// si el std es 0 no hace nada
            delay_ms(1000);
            output_b(0x00);   
           
           
           
               
           
           
         }         
    }




2 codigo con interrupcion

Código: Seleccionar todo

#include <16F628A.h>
    #use delay (clock=4000000)
    #use rs232(baud=9600,parity=N,xmit=PIN_b2,rcv=PIN_b1,bits=8)

   
    // declaracion de puertos direccion en mapa de memoria
    #byte porta=0x05
    #use fast_io(a)
   //al usar bit a bit como salida se debe declarar el tris correspondiente en el main
    #byte portb=0x06
    #use fast_io(b) 
   
    #int_ext
    void ext_isr(void)
    {
      // declaracion de variables
         int eepromv [3];// valor de la eeprom
         int valordatos[3];// valor que viene de la linea de datos
         int aux;
         int cont;
         int i;
         
         // guarda el numero del decodificador en la eeprom interna del pic
            write_eeprom(0,12);
            write_eeprom(1,0);
            write_eeprom(2,2);
           
        // se asignan los datos de la eeprom a vector para su comparacion
       // con el dato de la linea de datos
            eepromv[0]=read_eeprom(0);
            eepromv[1]=read_eeprom(1);
            eepromv[2]=read_eeprom(2);       
         
         if(input(pin_b0)==1)
        {
        aux=porta;
               
                for(i=0;i!=3;i++)
               {
                  valordatos[i]=aux-16;
                  printf("valor captura:%U\r:",valordatos[i]);
                  printf("valor de eeprom %u\r",eepromv[i]);
                         
                  if(valordatos[i]==eepromv[i])
                     {
                         cont++;
                         printf("valor del contador%u\r",cont);
                         if(cont>=3)
                        {
                            output_b(0x80);                             
                            if(cont<=5)
                            {
                               output_b(0x80);                                   
                            }
                            else
                              {  cont=0;
                                 output_b(0x00);
                              }                             
                        }
                        else
                           output_b(0x00);                         
                     }                                     
        }
         
     
    }
   
    void main(void)
    {
           
         
         //configuracion de puertos
         set_tris_b(0x0F);
         enable_interrupts(global);
         enable_interrupts(int_ext);
         //programa
         while(true);
         
         
    }


agradezco de antemano toda la ayuda prestada
adjunto simulacion del archivo sin interrupcion

saludos desde bogota

programa_decodificadorv1.rar

[myesid]

hola biblioman

Qusiera que me ayudaras a descubrir el error en es te codigo es que como tu bien sabes estoy aprendiendo y estoy interesado en saber acerca de interrupciones

¿Podrias explicarme paso a paso como realizar una interrupcion de este tipo?

lo que quiero hacer con este programa es tomar los datos guardado en la eeprom del pic y comparar contra una entrada de datos que esta en el puerto A del pic.

Código: Seleccionar todo

#include <16F628A.h>
    #use delay (clock=4000000)
    #use rs232(baud=9600,parity=N,xmit=PIN_b2,rcv=PIN_b1,bits=8)

   
    // declaracion de puertos direccion en mapa de memoria
    #byte porta=0x05
    #use fast_io(a)
   //al usar bit a bit como salida se debe declarar el tris correspondiente en el main     
    #byte portb=0x06
    #bit valvula=0x06.7
    #use fast_io(b)
     
    //declaracion de variables globales
    // declaracion de variables
         int eepromv [3];// valor de la eeprom
         int valordatos[3];// valor que viene de la linea de datos
         int aux;
         int cont;
         int i;
   
   
    #int_ext
    void ext_isr()
    {
               aux=porta;
               
                for(i=0;i!=3;i++)
               {
                  valordatos[i]=aux-16;
//!                  printf("valor captura:%U\r:",valordatos[i]);
//!                  printf("valor de eeprom %u\r",eepromv[i]);
                         
                  if(valordatos[i]==eepromv[i])
                     {
                         cont++;
//!                         printf("valor del contador%u\r",cont);
                         if(cont>=3)
                        {
                            valvula=1;
                           
                            if(cont<=5)
                            {
                               valvula=1;
                               
                            }
                            else
                              {  cont=0;
                                 valvula=0;
                                 
                              }                             
                        }
                        else
                           valvula=0;
                                                 
                     }           
     
     
    }
     
    void main()
    {

         // guarda el numero del decodificador en la eeprom interna del pic
            write_eeprom(0,12);
            write_eeprom(1,0);
            write_eeprom(2,2);
           
        // se asignan los datos de la eeprom a vector para su comparacion
       // con el dato de la linea de datos
            eepromv[0]=read_eeprom(0);
            eepromv[1]=read_eeprom(1);
            eepromv[2]=read_eeprom(2);       
         
         //configuracion de puertos
//!         set_tris_b(0x0f);
         enable_interrupts(global);
         enable_interrupts(int_ext);
         valvula=0;         
         printf("valor captura:%U\r:",valordatos[i]);
         printf("valor de eeprom %u\r",eepromv[i]);
         printf("valor del contador%u\r",cont);
         //programa
         while(true)
         {}

    }
    }



agradeciendo la ayuda prestada de antemano
Saludos

[biblioman]

Hola myesid.

Qusiera que me ayudaras a descubrir el error en es te codigo es que como tu bien sabes estoy aprendiendo y estoy interesado en saber acerca de interrupciones

Creo que el error que tienes es de concepto, vamos a ir por pasos:

Primero. ¿Que pretendes con esta instrucción?--> valordatos[i]=aux-16; Si como creo es enmascarar el bit de más peso del PortA. Deberías de tener en cuenta que si no defines el puertoA como entrada ó salida, por defecto se define como entrada y su valor es leído como 0 y no como 1. (compruebalo, estoy escribiendo sin mirar el datasheet). Por lo que creo que ese -16 te sobraría, si como veo en el esquema el pin RA4 no lo vas a utilizar.

Segundo. Si como creo lo que quieres hacer, es comparar el valor guardado en tres posiciones de la EEPROM, con tres valores introducidos secuencialmente por el PortA. El problema que tienes es de sincronización, emplees ó no interrupciones.
Por ejemplo imagina que STD= 1. El programa entra en la función de interrupción, seguidamente entras en el bucle for y lees tres veces el valor del PortA a una velocidad de: Frecuencia del reloj principal/4. Como lógicamente en ese tiempo no te ha dado tiempo a cambiar el valor en las entradas conectadas al PuertoA el resultado siempre será falso. Deberías saber primero a que frecuencia van a cambiar los valores de entrada y luego en función de eso poner un retardo entre cada iteración del bucle for, para que le de tiempo a las entradas a cambiar su valor, antes que el bucle for acabe la iteración en curso.

Reflexiona sobre esto y luego me cuentas, por cierto, como vas con el "comecocos" para el LCD, me quede esperando tú respuesta.


Un saludo

[myesid]

Hola Biblioman:

Primero. ¿Que pretendes con esta instrucción?--> valordatos[i]=aux-16; Si como creo es enmascarar el bit de más peso del PortA. Deberías de tener en cuenta que si no defines el puertoA como entrada ó salida, por defecto se define como entrada y su valor es leído como 0 y no como 1. (compruebalo, estoy escribiendo sin mirar el datasheet). Por lo que creo que ese -16 te sobraría, si como veo en el esquema el pin RA4 no lo vas a utilizar.

Si, es que en un principio pense hacerlo sin interrupciones pero al pasarlo a un programa con interrupciones esta linea debe ser eliminada

Segundo. Si como creo lo que quieres hacer, es comparar el valor guardado en tres posiciones de la EEPROM, con tres valores introducidos secuencialmente por el PortA. El problema que tienes es de sincronización, emplees ó no interrupciones.
Por ejemplo imagina que STD= 1. El programa entra en la función de interrupción, seguidamente entras en el bucle for y lees tres veces el valor del PortA a una velocidad de: Frecuencia del reloj principal/4. Como lógicamente en ese tiempo no te ha dado tiempo a cambiar el valor en las entradas conectadas al PuertoA el resultado siempre será falso. Deberías saber primero a que frecuencia van a cambiar los valores de entrada y luego en función de eso poner un retardo entre cada iteración del bucle for, para que le de tiempo a las entradas a cambiar su valor, antes que el bucle for acabe la iteración en curso.

respecto a lo de la sincronia si es cierto, ya que los datos de entrada tienen un periodo de 1 segundo aproximadamente, pero el agregar el retardo en el for para que la comparacion diera verdadera con los cambios provistos a la entrada con tal velocidad hacia que se retardara todo el grupo de datos mas no dato a dato por tal motivo me preocupe de realizar la comparacion de los datos dato a dato por medio de if-else consecutivos al interior de la interrupcion que al ser verdaderos activan unas banderas(cont1,cont2,cont3) que hacen que se encienda la salida propuesta en el puerto B

Código: Seleccionar todo

#include <16F628A.h>
    #use delay (clock=4000000)
    #use rs232(baud=9600,parity=N,xmit=PIN_b2,rcv=PIN_b1,bits=8)

   
    // declaracion de puertos direccion en mapa de memoria
    #byte porta=0x05
    #use fast_io(a)
   //al usar bit a bit como salida se debe declarar el tris correspondiente en el main     
    #byte portb=0x06
    #bit valvula=0x06.7
    #use fast_io(b)
     
    //declaracion de variables globales
    // declaracion de variables
         int eepromv [3];// valor de la eeprom
         //int valordatos[3];// valor que viene de la linea de datos
         int aux;
         int cont;
         int cont1;
         int cont2;
         int cont3;
         int i;

   
    #int_ext
    void ext_isr()
    {                                     
                  aux=porta;
                 
                   if(aux==eepromv[0])
                     {
                        printf("valor captura:%U\r:",aux);
                        printf("primer dato primer if %u\r",eepromv[0]);
                        cont++;               
                        cont1=1;
                     }
                    else if(aux==eepromv[1])
                        {
                           printf("valor captura:%U\r:",aux);
                           printf("segundo dato segundo if %u\r",eepromv[1]);
                           cont++;                   
                           cont2=1;
                        }
                         else if(aux==eepromv[2])
                                    {
                                       printf("valor captura:%U\r:",aux);
                                       printf("tercer dato tercer if %u\r",eepromv[2]);
                                       cont++;                             
                                       cont3=1;                                                                                                                                                                         
                                    }
                                    else
                                       cont++;
                                       
                   
                   printf("valor del contador%u\r",cont);
                            if(cont1==1&&cont2==1&&cont3==1)
                                             {
                                                 valvula=1;
                                                 
                                                 if(cont<=18)
                                                 {
                                                    valvula=1;
                                                 }
                                                 else
                                                   {  cont=0;
                                                      valvula=0;
                                                   }                             
                                             }
                                             else
                                               
                                                 if(cont>=18)
                                                 {
                                                    valvula=0;
                                                    cont=0;
                                                 }
                   
                   
                     
   
    }
//!     
    void main(void)
    {
            valvula=0;
         // guarda el numero del decodificador en la eeprom interna del pic
            write_eeprom(0,12);
            write_eeprom(1,0);
            write_eeprom(2,2);
           
        // se asignan los datos de la eeprom a vector para su comparacion
       // con el dato de la linea de datos
            eepromv[0]=read_eeprom(0);
            eepromv[1]=read_eeprom(1);
            eepromv[2]=read_eeprom(2);       
         
         //configuracion de puertos
         set_tris_b(0x0f);
         set_tris_a(0xff); 
         enable_interrupts(global);
         enable_interrupts(int_ext);
         valvula=0;         
         //programa
         while(true);         
    }


Espero sus comentarios y sugerencias con respecto a este aporte,

PD: lo del comecocos para LCD hasta ahora lo voy a empezar debido a que primero debia salir de esta duda para asi enfrentar el comecocos

Saludos

[biblioman]

Hola myesid. No he tenido tiempo de depurar tu ejemplo todavía, pero por lo que me cuentas entiendo que al final has conseguido que el programa te funcione como tu quieres, si no es así, me lo dices e intentamos depurarlo. Como sugerencia te diría que intentaras sustituir los if-else anidados por algún switch-case para clarificar un poco el código, pero esto solo es una sugerencia, si para ti está claro así, pues no hay problema.

Un saludo

[myesid]

hola biblioman:

El codigo me funciona perfectamente gracias a las aclaraciones que vos me hiciste, muchas gracias