Haz una pregunta
  Foros de Electrónica » Diseño digital » Microcontroladores y sistemas embebidos
Foros Registrarse ¿Olvidaste tu contraseña?

Temas similares

03/06/2014 #1


PICC de CCS y uso de interrupciones
Hola a todos.
No tengo mucha practica con programación (CSS) y me gustaría que me ayudarais a enfocar un problema.
Tengo un programa hecho y quisiera que empezara a funcionar cuando se active una interrupción externa. Si tengo el programa en el Main ¿cómo lo hariais? he pensado en hacer una comprobación en el main de una variable que cambiaría durante la interrupción, pero css no me permite hacerlo porque las variables de la interrupción no las veo en el Main y viceversa. también he pensado hacer una llamada a una función con el programa desde la interrupción, pero tampoco me reconoce dicha función.

Muchas gracias de antebrazo.
Aquí os dejo el programa por si os apetece hacer alguna modificación.
Código:
#include <18F2620.h>
#fuses NOMCLR
#fuses HS
#fuses PUT


#use delay(CLOCK=25M)
#use fast_io(a)
#use fast_io(b)
#use fast_io(c)


void RUN_PALABRA (int p)

{
   output_low(PIN_A0);      // `PARALEL LOAD` BAJO NECESARIO PARA QUE EL DATO PASE DEL LATCH AL REGISTRO
   output_low(PIN_A1);      // ´SHIF Y STORAGE CLOCK INPUT´ BAJO PREPARANDO EL FLANCO DE SUBIDA PARA LLEVAR EL DATO A LA AL REGISTRO
   output_c(p);             // SE PONE EL DATO EN EL PUERTO B
   output_high(PIN_A1);     // ´SHIF Y STORAGE CLOCK INPUT´ FLANCO DE SUBIDA PARA LLEVAR EL DATO AL REGISTRO
   output_high(PIN_A0);     // `PARALEL LOAD` ALTO NECESARIO PARA QUE EL REGISTRO PUEDA AVANZAR, PONE EL EL PRIMER BIT A LA SALIDA
   
   output_low(PIN_A2);      // 595 ´STORAGE CLOCK INPUT´ BAJO
   //output_low(PIN_B4);
   //output_high(PIN_A5);     // OUTPUT ENABLE ALTO,  SALIDA EN ALTA IMPEDANCIA
        
      int i; 
      for (i=0; i<8; i++)
      {
       //delay_ms(1);
      
      output_low(PIN_A2);  // 595 ´STORAGE CLOCK INPUT´ BAJO
      output_low(PIN_A3);  // 595 ´SHIFT CLOCK INPUT´ BAJO
      output_low(PIN_A1);  // 597 `SHIF Y STORAGE CLOCK INPUT` BAJO
      output_high(PIN_A2); // 595 ´STORAGE CLOCK INPUT´ ALTO PASA EL DATO AL REGISTRO Y LO DESPLAZA
      output_high(PIN_A1); // 597 `SHIF Y STORAGE CLOCK INPUT` ALTO     DESPLAZA

      
      }
       
output_high(PIN_A3); // 595 ´SHIFT CLOCK INPUT´ ALTO             PASA EL REGISTRO A LA SALIDA
      
}

#INT_EXT
void interrupt_service_rutine_ext0(void)
{
output_toggle(PIN_B3); //

}


void main (void)
{

delay_ms(1000);
enable_interrupts(INT_EXT);
ext_int_edge(l_to_h);
enable_interrupts(global);


set_tris_b(0b00000000);  // PUERTO B SALIDA CON B1, B2 Y B3 COMO ENTRADA PARA INTERRUPCIONES
set_tris_c(0b00000000);  // PUERTO C SALIDA
set_tris_a(0b11000000);  // PUERTO A SALIDA


  while (true)
  {
     RUN_PALABRA (0b01010101);
     RUN_PALABRA (0b01010101);
     RUN_PALABRA (0b01010101);
     RUN_PALABRA (0b01010101);
     RUN_PALABRA (0b01010101);
     RUN_PALABRA (0b01010101);
     RUN_PALABRA (0b01010101);
     RUN_PALABRA (0b01010101);
     RUN_PALABRA (0b01010101);
     RUN_PALABRA (0b01010101);
     RUN_PALABRA (0b01010101);
     RUN_PALABRA (0b01010101);
     RUN_PALABRA (0b01010101);
     RUN_PALABRA (0b01010101);
     RUN_PALABRA (0b01010101);
     RUN_PALABRA (0b01010101);
     
     RUN_PALABRA (0b00000000);
     RUN_PALABRA (0b00000000);
     RUN_PALABRA (0b00000000);
     RUN_PALABRA (0b00000000);
     RUN_PALABRA (0b00000000);
     RUN_PALABRA (0b00000000);
     RUN_PALABRA (0b00000000);
     RUN_PALABRA (0b00000000);
     RUN_PALABRA (0b00000000);
     RUN_PALABRA (0b00000000);
     RUN_PALABRA (0b00000000);
     RUN_PALABRA (0b00000000);
     RUN_PALABRA (0b00000000);
     RUN_PALABRA (0b00000000);
     RUN_PALABRA (0b00000000);
     RUN_PALABRA (0b00000000);
  
   // output_low(PIN_A5);  // OE VISUALIZAMOS QUE LA SALIDA DE LOS 595
  
  // delay_ms(1000);
  }           
  
   
}
03/06/2014 #2

Avatar de ByAxel

Hola.
Se puede declarar variables globales... pueden estar en cualquier parte fuera de Main.

Saludos
03/06/2014 #3


Amigo ahí modifiqué una parte de tu código, adjunto te lo dejo, me cuentas como te va, no tengo el compilador, de manera que asumo que se encuentra bien, lo único que modifiqué fue el estado de una bandera en la cual consultas si la interrupción se ha generado.

Código:
#include <18F2620.h>
#fuses NOMCLR
#fuses HS
#fuses PUT


#use delay(CLOCK=25M)
#use fast_io(a)
#use fast_io(b)
#use fast_io(c)

//Declaración de Variablea Globales
unsigned char bandera=0;

//Declaración de Funciones
void RUN_PALABRA (int p);


//Vectores de Interrupción
#INT_EXT
void interrupt_service_rutine_ext0(void)
{
    output_toggle(PIN_B3); //
    bandera = 1;

}


//Programa Principal
void main (void)
{

    delay_ms(1000);
    enable_interrupts(INT_EXT);
    ext_int_edge(l_to_h);
    enable_interrupts(global);


    set_tris_b(0b00000000); // PUERTO B SALIDA CON B1, B2 Y B3 COMO ENTRADA PARA INTERRUPCIONES
    set_tris_c(0b00000000); // PUERTO C SALIDA
    set_tris_a(0b11000000); // PUERTO A SALIDA


    while (true)
    {

    //Consultas el estado de la bandera
    if(bandera!=0){
        bandera=0
        //Ingresas tu codigo
    }


    RUN_PALABRA (0b01010101);
    RUN_PALABRA (0b01010101);
    RUN_PALABRA (0b01010101);
    RUN_PALABRA (0b01010101);
    RUN_PALABRA (0b01010101);
    RUN_PALABRA (0b01010101);
    RUN_PALABRA (0b01010101);
    RUN_PALABRA (0b01010101);
    RUN_PALABRA (0b01010101);
    RUN_PALABRA (0b01010101);
    RUN_PALABRA (0b01010101);
    RUN_PALABRA (0b01010101);
    RUN_PALABRA (0b01010101);
    RUN_PALABRA (0b01010101);
    RUN_PALABRA (0b01010101);
    RUN_PALABRA (0b01010101);

    RUN_PALABRA (0b00000000);
    RUN_PALABRA (0b00000000);
    RUN_PALABRA (0b00000000);
    RUN_PALABRA (0b00000000);
    RUN_PALABRA (0b00000000);
    RUN_PALABRA (0b00000000);
    RUN_PALABRA (0b00000000);
    RUN_PALABRA (0b00000000);
    RUN_PALABRA (0b00000000);
    RUN_PALABRA (0b00000000);
    RUN_PALABRA (0b00000000);
    RUN_PALABRA (0b00000000);
    RUN_PALABRA (0b00000000);
    RUN_PALABRA (0b00000000);
    RUN_PALABRA (0b00000000);
    RUN_PALABRA (0b00000000);

    // output_low(PIN_A5); // OE VISUALIZAMOS QUE LA SALIDA DE LOS 595

    // delay_ms(1000);
    } 

}

void RUN_PALABRA (int p)

{
    output_low(PIN_A0); // `PARALEL LOAD` BAJO NECESARIO PARA QUE EL DATO PASE DEL LATCH AL REGISTRO
    output_low(PIN_A1); // ´SHIF Y STORAGE CLOCK INPUT´ BAJO PREPARANDO EL FLANCO DE SUBIDA PARA LLEVAR EL DATO A LA AL REGISTRO
    output_c(p); // SE PONE EL DATO EN EL PUERTO B
    output_high(PIN_A1); // ´SHIF Y STORAGE CLOCK INPUT´ FLANCO DE SUBIDA PARA LLEVAR EL DATO AL REGISTRO
    output_high(PIN_A0); // `PARALEL LOAD` ALTO NECESARIO PARA QUE EL REGISTRO PUEDA AVANZAR, PONE EL EL PRIMER BIT A LA SALIDA

    output_low(PIN_A2); // 595 ´STORAGE CLOCK INPUT´ BAJO
    //output_low(PIN_B4);
    //output_high(PIN_A5); // OUTPUT ENABLE ALTO, SALIDA EN ALTA IMPEDANCIA

    int i; 
    for (i=0; i<8; i++)
    {
        //delay_ms(1);

        output_low(PIN_A2); // 595 ´STORAGE CLOCK INPUT´ BAJO
        output_low(PIN_A3); // 595 ´SHIFT CLOCK INPUT´ BAJO
        output_low(PIN_A1); // 597 `SHIF Y STORAGE CLOCK INPUT` BAJO
        output_high(PIN_A2); // 595 ´STORAGE CLOCK INPUT´ ALTO PASA EL DATO AL REGISTRO Y LO DESPLAZA
        output_high(PIN_A1); // 597 `SHIF Y STORAGE CLOCK INPUT` ALTO DESPLAZA
    }

    output_high(PIN_A3); // 595 ´SHIFT CLOCK INPUT´ ALTO PASA EL REGISTRO A LA SALIDA

}
03/06/2014 #4

Avatar de seaarg

Como te sugiere el forista, la bandera global estaria perfecta.

Si te queres ahorrar una variable, podes usar la bandera de interrupcion externa del mismo micro. Vas a tener que mirar los registros (tools -> device editor -> registers) para saber cual es
20/06/2014 #5


Perdonar por no contestar antes, acabo de volver de las vacaciones. Muchas gracias seaarg, edwin ts y ByAxel me habeis ayudado mucho. Lo voy a probar ahora mismo XD
23/06/2014 #6


Hola amigos. En efecto, como decís, puedo usar la variable bandera, pero aunque en la simulación de ISIS funciona perfectamente, cuando lo paso al hardware me sigue empezando el programa.
Os lo paso para que me digáis si estoy loco.
Nota: La interrupción funciona porque el led se apaga y se enciende.

Código:
#include <18F2620.h>

#fuses NOMCLR
#fuses HS
#fuses PUT
#fuses NOWDT



#use delay(CLOCK=25M)
#use fast_io(a)
#use fast_io(b)
#use fast_io(c)

//Declaración de Variablea Globales
unsigned char bandera;

//Declaración de Funciones
   void RUN_PALABRA (int p)

   {
   output_low(PIN_A0); // `PARALEL LOAD` BAJO NECESARIO PARA QUE EL DATO PASE DEL LATCH AL REGISTRO
   output_low(PIN_A1); // ´SHIF Y STORAGE CLOCK INPUT´ BAJO PREPARANDO EL FLANCO DE SUBIDA PARA LLEVAR EL DATO A LA AL REGISTRO
   output_c(p); // SE PONE EL DATO EN EL PUERTO B
   output_high(PIN_A1); // ´SHIF Y STORAGE CLOCK INPUT´ FLANCO DE SUBIDA PARA LLEVAR EL DATO AL REGISTRO
   output_high(PIN_A0); // `PARALEL LOAD` ALTO NECESARIO PARA QUE EL REGISTRO PUEDA AVANZAR, PONE EL EL PRIMER BIT A LA SALIDA
   
   output_low(PIN_A2); // 595 ´STORAGE CLOCK INPUT´ BAJO
   //output_low(PIN_B4);
   output_high(PIN_A5); // OUTPUT ENABLE ALTO, SALIDA EN ALTA IMPEDANCIA
   output_low(PIN_A3);
      int f;
      for (f=0; f<8; f++)
      {
      //delay_ms(1);
      
      output_low(PIN_A2); // 595 ´STORAGE CLOCK INPUT´ BAJO
      output_low(PIN_A3); // 595 ´SHIFT CLOCK INPUT´ BAJO
      output_low(PIN_A1); // 597 `SHIF Y STORAGE CLOCK INPUT` BAJO
      output_high(PIN_A2); // 595 ´STORAGE CLOCK INPUT´ ALTO PASA EL DATO AL REGISTRO Y LO DESPLAZA
      output_high(PIN_A1); // 597 `SHIF Y STORAGE CLOCK INPUT` ALTO DESPLAZA
      
      
      }
   
      output_high(PIN_A3); // 595 ´SHIFT CLOCK INPUT´ ALTO PASA EL REGISTRO A LA SALIDA
      
      }

   void CLEAR (void)
    {
   output_high(PIN_A5); // OUTPUT ENABLE ALTO, SALIDA EN ALTA IMPEDANCIA 
   output_low(PIN_A0); // `PARALEL LOAD` BAJO NECESARIO PARA QUE EL DATO PASE DEL LATCH AL REGISTRO
   output_low(PIN_A1); // ´SHIF Y STORAGE CLOCK INPUT´ BAJO PREPARANDO EL FLANCO DE SUBIDA PARA LLEVAR EL DATO A LA AL REGISTRO
   output_c(0b00000000); // SE PONE EL DATO EN EL PUERTO B
   output_high(PIN_A1); // ´SHIF Y STORAGE CLOCK INPUT´ FLANCO DE SUBIDA PARA LLEVAR EL DATO AL REGISTRO
   output_high(PIN_A0); // `PARALEL LOAD` ALTO NECESARIO PARA QUE EL REGISTRO PUEDA AVANZAR, PONE EL EL PRIMER BIT A LA SALIDA
   
   output_low(PIN_A2); // 595 ´STORAGE CLOCK INPUT´ BAJO
   //output_low(PIN_B4);
   
    int i;
    int e;
    for (e=0; e<16; e++)
    {
      for ( i=0; i<8; i++)
      {
      //delay_ms(1);
      
      output_low(PIN_A2); // 595 ´STORAGE CLOCK INPUT´ BAJO
      output_low(PIN_A3); // 595 ´SHIFT CLOCK INPUT´ BAJO
      output_low(PIN_A1); // 597 `SHIF Y STORAGE CLOCK INPUT` BAJO
      output_high(PIN_A2); // 595 ´STORAGE CLOCK INPUT´ ALTO PASA EL DATO AL REGISTRO Y LO DESPLAZA
      output_high(PIN_A1); // 597 `SHIF Y STORAGE CLOCK INPUT` ALTO DESPLAZA
      
      
      }
   
      
      
     }
    output_high(PIN_A3); // 595 ´SHIFT CLOCK INPUT´ ALTO PASA EL REGISTRO A LA SALIDA
    }


//Vectores de Interrupción
#INT_EXT
   void interrupt_service_rutine_ext0(void)
   {
   output_toggle(PIN_B3); //
   bandera=2;
   
   
   }

//Programa Principal
void main (void)
   {
   bandera=1;
   delay_ms(1000);
   enable_interrupts(INT_EXT);
   ext_int_edge(l_to_h);
   enable_interrupts(global);
   
   
   set_tris_b(0b00000001); // PUERTO B SALIDA CON B1, B2 Y B3 COMO ENTRADA PARA INTERRUPCIONES
   set_tris_c(0b00000000); // PUERTO C SALIDA
   set_tris_a(0b11000000); // PUERTO A SALIDA
  
  
  
  while (true)
    {
   //Consultas el estado de la bandera
      switch (bandera)
      {
      case 1:
      CLEAR();
      break;
      case 2: 
   
   
   
   RUN_PALABRA (0b10011001);
   RUN_PALABRA (0b10011001);
   RUN_PALABRA (0b10011001);
   RUN_PALABRA (0b10011001);
   RUN_PALABRA (0b10011001);
   RUN_PALABRA (0b10011001);
   RUN_PALABRA (0b10011001);
   RUN_PALABRA (0b10011001);
   RUN_PALABRA (0b10011001);
   RUN_PALABRA (0b10011001);
   RUN_PALABRA (0b10011001);
   RUN_PALABRA (0b10011001);
   RUN_PALABRA (0b10011001);
   RUN_PALABRA (0b10011001);
   RUN_PALABRA (0b10011001);
   RUN_PALABRA (0b10011001);
   
   output_low(PIN_A5);delay_ms(300);;
  
      }
   }
   
}
23/06/2014 #7


Alguien puede indicarme a que se debe estos 2 Warnings que me da el CCS?

interrupts disabled during call to prevent re-entrancy @ITOF
interrupts disabled during call to prevent re-entrancy @FLT
se los agradeceria mucho :(
23/06/2014 #8
Moderador

Avatar de D@rkbytes

Urbito dijo: Ver Mensaje
Alguien puede indicarme a que se debe estos 2 Warnings que me da el CCS?
se los agradeceria mucho :(
Esas advertencias aparecen cuando el compilador deshabilita algunas interrupciones para evitar un Stack Overflow.
O sea que, algunas veces se tienen que deshabilitar ciertas interrupciones durante la ejecución del programa.

No pasa nada, ya que el compilador lo está haciendo por ti, pero si las quieres evitar, debes deshabilitar las interrupciones que aparecen con advertencia.
Después las tienes que volver a habilitar para que se sigan ejecutando.
23/06/2014 #9


en mi caso estoy usando Interrupcion por TMR1, TMR2 y Externas. Esto quiere decir que, cuando se habilita una de ellas, se deshabilitan las demas hasta que salga de la interrupcion en la que se encuentra?

Muchas gracias!
23/06/2014 #10
Moderador

Avatar de D@rkbytes

Urbito dijo: Ver Mensaje
en mi caso estoy usando interrupción por TMR1, TMR2 y Externas.
¿Esto quiere decir que, cuando se habilita una de ellas, se deshabilitan las demás hasta que salga de la interrupción en la que se encuentra?
Nop. Si te fijas bien sobre los mensajes de advertencia, solo se deshabilitan algunas, no todas.
Posteriormente el compilador las vuelve a habilitar.
No deberías preocuparte por eso, a menos que quieras evitar esos mensajes y buscar cuando es que se generan.
23/06/2014 #11


Hola Amigo.

En primer lugar no veo la necesidad de utilizar un Switch para enviar unos datos por un registro de corrimiento y encender un led, por lo que veo lo que necesitas es:

Al presionar un pulsador, se deben enviar datos a un registro de corrimiento y cargar el valor que pasas como parámetro a la función en el Puerto B, en mi opinión, si deseas borrar el registro de corrimiento sencillamente lo podes hacer una vez antes del ciclo infinito, no veo la necesidad de estar borrando todo el tiempo el con clear() el registro de corrimiento, por otra parte, no veo la necesidad de poner tantas veces en el Puerto B el mismo dato, con solo cargarlo una vez es suficiente.

Te escribo el siguiente ejemplo, probablemente lo que sucede es que se te esta quedando bloqueado el Uc, porque todo el tiempo estas recorriendo el Switch.
Por otra parte, la estructura del Switch no está bien, donde dejaste el break del segundo caso y el case por default tampoco está.

Mira la siguiente estructura, amigo:

Código:
switch ( a ) {
case b:
  // Code
  break;
case c:
  // Code
  break;
default:
  // Code
  break;
}
No trabajo con ese compilador, pero te hice la siguiente modificación, prueba y di como te va.

Código:
#include <18F2620.h>

#fuses NOMCLR
#fuses HS
#fuses PUT
#fuses NOWDT



#use delay(CLOCK=25M)
#use fast_io(a)
#use fast_io(b)
#use fast_io(c)

//Declaración de Variablea Globales
unsigned char bandera;        

//Declaración de Funciones
   void RUN_PALABRA (int p)

   {
   output_low(PIN_A0); // `PARALEL LOAD` BAJO NECESARIO PARA QUE EL DATO PASE DEL LATCH AL REGISTRO
   output_low(PIN_A1); // ´SHIF Y STORAGE CLOCK INPUT´ BAJO PREPARANDO EL FLANCO DE SUBIDA PARA LLEVAR EL DATO A LA AL REGISTRO
   output_c(p); // SE PONE EL DATO EN EL PUERTO B
   output_high(PIN_A1); // ´SHIF Y STORAGE CLOCK INPUT´ FLANCO DE SUBIDA PARA LLEVAR EL DATO AL REGISTRO
   output_high(PIN_A0); // `PARALEL LOAD` ALTO NECESARIO PARA QUE EL REGISTRO PUEDA AVANZAR, PONE EL EL PRIMER BIT A LA SALIDA
   
   output_low(PIN_A2); // 595 ´STORAGE CLOCK INPUT´ BAJO
   //output_low(PIN_B4);
   output_high(PIN_A5); // OUTPUT ENABLE ALTO, SALIDA EN ALTA IMPEDANCIA
   output_low(PIN_A3);
      int f;
      for (f=0; f<8; f++)
      {
      //delay_ms(1);
      
      output_low(PIN_A2); // 595 ´STORAGE CLOCK INPUT´ BAJO
      output_low(PIN_A3); // 595 ´SHIFT CLOCK INPUT´ BAJO
      output_low(PIN_A1); // 597 `SHIF Y STORAGE CLOCK INPUT` BAJO
      output_high(PIN_A2); // 595 ´STORAGE CLOCK INPUT´ ALTO PASA EL DATO AL REGISTRO Y LO DESPLAZA
      output_high(PIN_A1); // 597 `SHIF Y STORAGE CLOCK INPUT` ALTO DESPLAZA
      
      
      }
   
      output_high(PIN_A3); // 595 ´SHIFT CLOCK INPUT´ ALTO PASA EL REGISTRO A LA SALIDA
      
   }

   void CLEAR (void)
    {
   output_high(PIN_A5); // OUTPUT ENABLE ALTO, SALIDA EN ALTA IMPEDANCIA 
   output_low(PIN_A0); // `PARALEL LOAD` BAJO NECESARIO PARA QUE EL DATO PASE DEL LATCH AL REGISTRO
   output_low(PIN_A1); // ´SHIF Y STORAGE CLOCK INPUT´ BAJO PREPARANDO EL FLANCO DE SUBIDA PARA LLEVAR EL DATO A LA AL REGISTRO
   output_c(0b00000000); // SE PONE EL DATO EN EL PUERTO B
   output_high(PIN_A1); // ´SHIF Y STORAGE CLOCK INPUT´ FLANCO DE SUBIDA PARA LLEVAR EL DATO AL REGISTRO
   output_high(PIN_A0); // `PARALEL LOAD` ALTO NECESARIO PARA QUE EL REGISTRO PUEDA AVANZAR, PONE EL EL PRIMER BIT A LA SALIDA
   
   output_low(PIN_A2); // 595 ´STORAGE CLOCK INPUT´ BAJO
   //output_low(PIN_B4);
   
    int i;
    int e;
    for (e=0; e<16; e++)
    {
      for ( i=0; i<8; i++)
      {
      //delay_ms(1);
      
      output_low(PIN_A2); // 595 ´STORAGE CLOCK INPUT´ BAJO
      output_low(PIN_A3); // 595 ´SHIFT CLOCK INPUT´ BAJO
      output_low(PIN_A1); // 597 `SHIF Y STORAGE CLOCK INPUT` BAJO
      output_high(PIN_A2); // 595 ´STORAGE CLOCK INPUT´ ALTO PASA EL DATO AL REGISTRO Y LO DESPLAZA
      output_high(PIN_A1); // 597 `SHIF Y STORAGE CLOCK INPUT` ALTO DESPLAZA
      
      
      }
   
      
      
     }
    output_high(PIN_A3); // 595 ´SHIFT CLOCK INPUT´ ALTO PASA EL REGISTRO A LA SALIDA
    }


//Vectores de Interrupción
#INT_EXT
   void interrupt_service_rutine_ext0(void)
   {
   output_toggle(PIN_B3); //
   bandera=1;
   
   
   }

//Programa Principal
void main (void)
   {
   bandera=0;
   delay_ms(1000);
   enable_interrupts(INT_EXT);
   ext_int_edge(l_to_h);
   enable_interrupts(global);
   
   
   set_tris_b(0b00000001); // PUERTO B SALIDA CON B1, B2 Y B3 COMO ENTRADA PARA INTERRUPCIONES
   set_tris_c(0b00000000); // PUERTO C SALIDA
   set_tris_a(0b11000000); // PUERTO A SALIDA
  
  CLEAR();
  
  while (true)
    {
    //Modificado
    if(bandera!=0){
        bandera=0;
        RUN_PALABRA (0b10011001);
        output_low(PIN_A5);delay_ms(300);
    }

/*
    //Consultas el estado de la bandera
      switch (bandera)
      {
      case 1:
      CLEAR();
      break;
      case 2: 
   
   
   
   RUN_PALABRA (0b10011001);
   RUN_PALABRA (0b10011001);
   RUN_PALABRA (0b10011001);
   RUN_PALABRA (0b10011001);
   RUN_PALABRA (0b10011001);
   RUN_PALABRA (0b10011001);
   RUN_PALABRA (0b10011001);
   RUN_PALABRA (0b10011001);
   RUN_PALABRA (0b10011001);
   RUN_PALABRA (0b10011001);
   RUN_PALABRA (0b10011001);
   RUN_PALABRA (0b10011001);
   RUN_PALABRA (0b10011001);
   RUN_PALABRA (0b10011001);
   RUN_PALABRA (0b10011001);
   RUN_PALABRA (0b10011001);
   
   output_low(PIN_A5);delay_ms(300);;
  
      }
*/
   }
   
}
Saludos.
15/10/2014 #12


Alguien de ustedes sabe por que me marca error en el enable global ?
este es mi codigo, básicamente el programa agrega un bit cada vez que presionas el logictouble.

#include<16f877.h>
#use delay(clock= 4Mhz)
#Fuses XT, NOWDT, NOPROTECT, NOLVP, PUT, NOBROWNOUT
#INT_EXT
int i;
void EXT(void)
{
i= i+1;
void main()
{
enable_interrupts(GLOBAL); // uso inipropiado aqui me dice eso cuando lo compilo
enable_interrupts(INT_EXT);

while(true);
output_b(0);
delay_ms(500);
if (i==0){i=1;} else {i=i<<1;}
}
15/10/2014 #13
Moderador

Avatar de D@rkbytes

Jgmicro dijo: Ver Mensaje
¿Alguien de ustedes sabe por qué me marca error en el enable global?
Porque estás anidando las rutinas.
Debes crear la rutina de servicio de interrupción en una sola estructura.

Por ejemplo, de esta forma:
Código:
int i;

#INT_EXT
void EXT(void)
{
   ++i;
}
También tendrás código sin funcionamiento en esta parte...
Código:
   while(true);
      output_b(0);
      delay_ms(500);
      if (i==0){i=1;} else {i=i<<1;}
Si cierras el bucle While con punto y coma ; se genera un bucle infinito en esa instrucción y de ahí no se pasará.
Por lo tanto, las instrucciones siguientes nunca se ejecutaran.
15/10/2014 #14


es cierto , muchas gracias ya lo modifique y no marca errores
Respuesta
¿Tienes una mejor respuesta a este tema? ¿Quieres hacerle una pregunta a nuestra comunidad y sus expertos? Registrate

Foros de Electrónica » Diseño digital » Microcontroladores y sistemas embebidos

Powered by vBulletin® Version 3.8.4
Copyright ©2000 - 2017, Jelsoft Enterprises Ltd.
Search Engine Optimization by vBSEO ©2011, Crawlability, Inc.