TODOPIC

Microcontroladores PIC => Lenguaje C para microcontroladores PIC => Mensaje iniciado por: mirazulado en 28 de Abril de 2005, 14:56:00

Título: Interrupcion RB4-RB7
Publicado por: mirazulado en 28 de Abril de 2005, 14:56:00
Tengo un problema que creo ya fue tratado en este foro y es el proteus emulando interrupcion externa RB4-RB7.. resulta que quiero tomar los datos de pulsadores mediante interrupcion RB4-7 y cada vez que entra a la interrupcion no sale nunca..
La unica forma de que funcione es con este antirrebote por soft e igual asi entra dos veces a la interrupcion luego de que solte el boton..

#int_RB             // interrupcion RB
void intb(){
putc("1");
while(!input(pin_B4)&&!input(pin_B5)&&!input(pin_B6)&&!input(pin_b7))
{};                   // antirrebote.

}

void main()
{
   port_b_pullups(TRUE);
   enable_interrupts(int_rb);
   enable_interrupts(global);
   while(1);
}

Esto es correcto ? es una falla del proteus como lei en otro mensaje ?
Un abrazo Mariano..
Título: RE: Interrupcion RB4-RB7
Publicado por: pocher en 28 de Abril de 2005, 22:55:00
El antirrebote por soft no es lo que acabas de poner, sino que está formado por una temporización, por ejemplo delay_ms(20), durante la cual esperamos a que nuestro pulsador-interruptor haya dejado de "saltar" y esa temporización viene seguida de una comprobación de nuestro pulsador-interruptor. Si nuestro pulsador-interruptor está a 1 (por ejemplo) entonces realizar el resto del programa, si está a 0 es que se ha metido en la interrupción como consecuencia de un rebote al "soltar" el pulsador, entonces no se ejecutará nuestro programa en el interior de la interrupción y saldrá de la interrupción sin hacer nada.

Un saludo
Título: RE: Interrupcion RB4-RB7
Publicado por: RaDoN en 29 de Abril de 2005, 03:41:00
Otra opcion a la que te ha dicho pocher, es que no tienes ni si quiera por que entrar otras veces en la interrupcion, despues del retardo para cubrir el rebote, tu as podido tener el dedo pulsdo y al soltarlo solicitara otra. Para que no pase, haz que no salga de la interrupción hasta que no suelte el boton (repito, despues del retardo de 20ms p.ej.).
Título: RE: Interrupcion RB4-RB7
Publicado por: mirazulado en 29 de Abril de 2005, 08:25:00
Disculpen ya encontre el error !!
resulta que:
#int_RB
void intb(){
putc("1");
delay_ms(100);
while(!input(pin_B4)&&!input(pin_B5)&&!input(pin_B6)&&!input(pin_b7));
}

me equivoque en los operadores OR que son || y no && esto quedaria :

#int_RB
void intb(){
putc("1");
delay_ms(20);
while(!input(pin_B4)||!input(pin_B5)||!input(pin_B6)||!input(pin_b7));
}

de esta forma anda bien, no se por que con && anda pero con efectos raros !!
Un abrazo y gracias !
Título: RE: Interrupcion RB4-RB7
Publicado por: RaDoN en 02 de Mayo de 2005, 13:10:00
Aprobecho este hilo referente a mi duda para así no tener que abrir otro. Aquí va: estoi practicando para aprender C y he planteando un programita que po medio de las interrupciones a las que se refiere el hilo, leer un teclado matricial 4x4 y mostrar la tecla pulsada en la pantalla del LCD. Pero en el display se ve la frase "Pulso -y un simbolo raro-", y no se donde puede estar el fallo.

Codigo:


//***********************************************
//* Practica con teclado 4x4 y LCD
//* Por Daniel G - by RaDoN (30/4/05)
//***********************************************

  #include "16F877.h"
  #fuses XT,NOWDT,NOPROTECT,PUT
  #use delay (clock=4000000)
  #use fast_io(D)

  #include "4x20_LCD.h"
  #include "4x4_KBD.h"

  #define use_portb_kbd

  #ORG 0x1F00,0x1FFF {} //for the 8k 16F876/7

  int tecla;

  #int_rb
  void control_rb() {
  tecla = kbd_getc();
  printf(lcd_putc,"fPulso %c",tecla); }

  void main() {
  lcd_init(); // Inicializa el LCD
  printf(lcd_putc,"f"Giño;
  port_b_pullups(TRUE);
  kbd_init(); // Inicializa el teclado matricial
  enable_interrupts(int_rb); // Habilita interrupión cambio de estado RB4:7
  enable_interrupts(global); // Habilita interrupciones globalmente
  sleep(); }



Y uso la libreria de CCS para el teclado modificada para un 4x4 en vez de 4x3:

Codigo:


///////////////////////////////////////////////////////////////////////////
////                             KBDD.C                                ////
////                  Generic keypad scan driver                       ////
////                                                                   ////
////  kbd_init()   Must be called before any other function.           ////
////                                                                   ////
////  c = kbd_getc(c)  Will return a key value if pressed or /0 if not ////
////                   This function should be called frequently so as ////
////                   not to miss a key press.                        ////
////                                                                   ////
///////////////////////////////////////////////////////////////////////////
////        (C) Copyright 1996,2003 Custom Computer Services           ////
//// This source code may only be used by licensed users of the CCS C  ////
//// compiler.  This source code may only be distributed to other      ////
//// licensed users of the CCS C compiler.  No other use, reproduction ////
//// or distribution is permitted without written permission.          ////
//// Derivative programs created using this software in object code    ////
//// form are not restricted in any way.                               ////
///////////////////////////////////////////////////////////////////////////

////////////////// The following defines the keypad layout on port D

// Un-comment the following define to use port B
// #define use_portb_kbd TRUE

// Make sure the port used has pull-up resistors (or the LCD) on
// the column pins


#if defined(__PCH__)
#if defined use_portb_kbd
   #byte kbd = 0xF81                   // This puts the entire structure
#else
   #byte kbd = 0xF83                   // This puts the entire structure
#endif
#else
#if defined use_portb_kbd
   #byte kbd = 6                  // on to port B (at address 6)
#else
   #byte kbd = 8                 // on to port D (at address 8)
#endif
#endif

#if defined use_portb_kbd
   #define set_tris_kbd(x) set_tris_b(x)
#else
   #define set_tris_kbd(x) set_tris_d(x)
#endif



//Keypad connection:   (for example column 0 is B2)
//                Bx:

#ifdef blue_keypad  ///////////////////////////////////// For the blue keypad
#define COL0 (1 << 2)
#define COL1 (1 << 3)
#define COL2 (1 << 6)

#define ROW0 (1 << 4)
#define ROW1 (1 << 7)
#define ROW2 (1 << 1)
#define ROW3 (1 << 5)

#else ////////////////////////////////////////////////// For the black keypad
#define COL0 (1 << 5)
#define COL1 (1 << 6)
#define COL2 (1 << 7)
#define COL3 (1 << 8)

#define ROW0 (1 << 1)
#define ROW1 (1 << 2)
#define ROW2 (1 << 3)
#define ROW3 (1 << 4)

#endif

#define ALL_ROWS (ROW0|ROW1|ROW2|ROW3)
#define ALL_PINS (ALL_ROWS|COL0|COL1|COL2|COL3)

// Keypad layout:
char const KEYS[4][4] = {{"1","2","3","A"},
                         {"4","5","6","B"},
                         {"7","8","9","C"},
                         {"*","0","#","D"}};

#define KBD_DEBOUNCE_FACTOR 33    // Set this number to apx n/333 where
                                  // n is the number of times you expect
                                  // to call kbd_getc each second


void kbd_init() {
}

char kbd_getc( ) {
   static BYTE kbd_call_count;
   static short int kbd_down;
   static char last_key;
   static BYTE col;

   BYTE kchar;
   BYTE row;

   kchar="";
   if(++kbd_call_count>KBD_DEBOUNCE_FACTOR) {
       switch (col) {
         case 0   : set_tris_kbd(ALL_PINS&~COL0);
                    kbd=~COL0&ALL_PINS;
                    break;
         case 1   : set_tris_kbd(ALL_PINS&~COL1);
                    kbd=~COL1&ALL_PINS;
                    break;
         case 2   : set_tris_kbd(ALL_PINS&~COL2);
                    kbd=~COL2&ALL_PINS;
                    break;
         case 3   : set_tris_kbd(ALL_PINS&~COL3);
                    kbd=~COL3&ALL_PINS;
                    break;
       }

       if(kbd_down) {
         if((kbd & (ALL_ROWS))==(ALL_ROWS)) {
           kbd_down=FALSE;
           kchar=last_key;
           last_key="";
         }
       } else {
          if((kbd & (ALL_ROWS))!=(ALL_ROWS)) {
             if((kbd & ROW0)==0)
               row=0;
             else if((kbd & ROW1)==0)
               row=1;
             else if((kbd & ROW2)==0)
               row=2;
             else if((kbd & ROW3)==0)
               row=3;
             last_key =KEYS[row][col];
             kbd_down = TRUE;
          } else {
             ++col;
             if(col==4)
               col=0;
          }
       }
      kbd_call_count=0;
   }
  set_tris_kbd(ALL_PINS);
  return(kchar);
}