# Keypad + LCD por puerto B CCS



## ManuelAndree (Jul 14, 2012)

Les muestro un programa que hice en CCS, ya que la libreria KBD.C no podemos acoplarla para utilizarla en el mismo puerto B que el LCD.C utilice otra libreria Keypad.C. Abajo les adjunto el .rar donde esta el programa en CCS y tambien la simulacion en proteus (cambiar el keypad del simulador o la matriz en el keypad.c para corregir los botones). La unica duda que tengo en este programa es que como todos sabemos las interrupciones en CCS no se cierran pero borrando el flag RBIF si lo hace el compilador, pero en mi programa vuelve a abrir la interrupcion un par de veces (lo comprobé en el simulador mostrando un contador en el lcd) a pesar que bombardie por todos lados con bit_clear(INTCON,0), coloque delays y seguía la interrupcion unas cuantas veces y de ahi se deshabilitada recién, lo solucioné colocando en el programa principal antes que se reinice el while: PORTB=0xF0; que hace que el puerto b no cambie de valor para que no lo detecte la interrupción. Se los dejo para ver si alguien puede mejorarlo.

Programa Principal:


```
//Programador: Manuel Andreé Espinoza Rosas

#include <16F628a.h>                              // Preprocessor directive that selects the chip
#fuses XT,NOWDT,NOPROTECT,NOLVP                   // Preprocessor directive that defines the chip fuses 
#use delay(clock=4000000)                        // Preprocessor directive that specifies clock speed



#include <lcd.c>
#include <keypad.c>   //Libreria de teclado 4x4 
 
unsigned char key;   //Variable global tecla
int status; 
// Interrupcion RB4 - RB7 /////////////////////////////////////////////////////
 
#INT_RB
void interrupt_keypad()               
{
   key=read_keypad();         //Asigna la tecla pulsada
}
 
 
// Programa Principal /////////////////////////////////////////////////////////
 
void main() 
{
   key=0x80;
   lcd_init();
   lcd_putc("Presione tecla:");
   while(true)
   {

   init_keypad();
   if(key!=0x80)
      {
      lcd_init();
      lcd_putc('\f');            //
      lcd_gotoxy(1,1);         //Visualiza en el lcd
      lcd_putc("Tecla pulsada: ");
      lcd_putc(key);            //
      PORTB=0xF0;
      key=0x80;
      }
   }
}
```

Libreria LCD.C


```
///////////////////////////////////////////////////////////////////////////////
////                             LCD.C                                     ////
////                 Driver for common LCD modules                         ////
////                                                                       ////
////  lcd_init()   Must be called before any other function.               ////
////                                                                       ////
////  lcd_putc(c)  Will display c on the next position of the LCD.         ////
////                     The following have special meaning:               ////
////                      \f  Clear display                                ////
////                      \n  Go to start of second line                   ////
////                      \b  Move back one position                       ////
////                                                                       ////
////  lcd_gotoxy(x,y) Set write position on LCD (upper left is 1,1)        ////
////                                                                       ////
////  lcd_getc(x,y)   Returns character at position x,y on LCD             ////
////                                                                       ////
////  CONFIGURATION                                                        ////
////  The LCD can be configured in one of two ways: a.) port access or     ////
////  b.) pin access.  Port access requires the entire 7 bit interface     ////
////  connected to one GPIO port, and the data bits (D4:D7 of the LCD)     ////
////  connected to sequential pins on the GPIO.  Pin access                ////
////  has no requirements, all 7 bits of the control interface can         ////
////  can be connected to any GPIO using several ports.                    ////
////                                                                       ////
////  To use port access, #define LCD_DATA_PORT to the SFR location of     ////
////  of the GPIO port that holds the interface, -AND- edit LCD_PIN_MAP    ////
////  of this file to configure the pin order.  If you are using a         ////
////  baseline PIC (PCB), then LCD_OUTPUT_MAP and LCD_INPUT_MAP also must  ////
////  be defined.                                                          ////
////                                                                       ////
////  Example of port access:                                              ////
////     #define LCD_DATA_PORT getenv("SFR:PORTD")                         ////
////                                                                       ////
////  To use pin access, the following pins must be defined:               ////
////     LCD_ENABLE_PIN                                                    ////
////     LCD_RS_PIN                                                        ////
////     LCD_RW_PIN                                                        ////
////     LCD_DATA4                                                         ////
////     LCD_DATA5                                                         ////
////     LCD_DATA6                                                         ////
////     LCD_DATA7                                                         ////
////                                                                       ////
////  Example of pin access:                                               ////
////     #define LCD_ENABLE_PIN  PIN_E0                                    ////
////     #define LCD_RS_PIN      PIN_E1                                    ////
////     #define LCD_RW_PIN      PIN_E2                                    ////
////     #define LCD_DATA4       PIN_D4                                    ////
////     #define LCD_DATA5       PIN_D5                                    ////
////     #define LCD_DATA6       PIN_D6                                    ////
////     #define LCD_DATA7       PIN_D7                                    ////
////                                                                       ////
///////////////////////////////////////////////////////////////////////////////
////        (C) Copyright 1996,2010 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.                               ////
///////////////////////////////////////////////////////////////////////////

// define the pinout.
#define LCD_ENABLE_PIN  PIN_A2                                   ////
#define LCD_RS_PIN      PIN_A0                                    ////
#define LCD_RW_PIN      PIN_A1                                    ////
#define LCD_DATA4       PIN_B4                                    ////
#define LCD_DATA5       PIN_B5                                    ////
#define LCD_DATA6       PIN_B6                                    ////
#define LCD_DATA7       PIN_B7
// only required if port access is being used.
typedef struct  
{                            // This structure is overlayed
   BOOLEAN enable;           // on to an I/O port to gain
   BOOLEAN rs;               // access to the LCD pins.
   BOOLEAN rw;               // The bits are allocated from
   BOOLEAN unused;           // low order up.  ENABLE will
   int     data : 4;         // be LSB pin of that port.
  #if defined(__PCD__)       // The port used will be LCD_DATA_PORT.
   int    reserved: 8;
  #endif
} LCD_PIN_MAP;

// this is to improve compatability with previous LCD drivers that accepted
// a define labeled 'use_portb_lcd' that configured the LCD onto port B.
#if ((defined(use_portb_lcd)) && (use_portb_lcd==TRUE))
 #define LCD_DATA_PORT getenv("SFR:PORTB")
#endif

#if defined(__PCB__)
   // these definitions only need to be modified for baseline PICs.
   // all other PICs use LCD_PIN_MAP or individual LCD_xxx pin definitions.
/*                                    EN, RS,   RW,   UNUSED,  DATA  */
 const LCD_PIN_MAP LCD_OUTPUT_MAP =  {0,  0,    0,    0,       0};
 const LCD_PIN_MAP LCD_INPUT_MAP =   {0,  0,    0,    0,       0xF};
#endif

////////////////////// END CONFIGURATION ///////////////////////////////////

#ifndef LCD_ENABLE_PIN
   #define lcd_output_enable(x) lcdlat.enable=x
   #define lcd_enable_tris()   lcdtris.enable=0
#else
   #define lcd_output_enable(x) output_bit(LCD_ENABLE_PIN, x)
   #define lcd_enable_tris()  output_drive(LCD_ENABLE_PIN)
#endif

#ifndef LCD_RS_PIN
   #define lcd_output_rs(x) lcdlat.rs=x
   #define lcd_rs_tris()   lcdtris.rs=0
#else
   #define lcd_output_rs(x) output_bit(LCD_RS_PIN, x)
   #define lcd_rs_tris()  output_drive(LCD_RS_PIN)
#endif

#ifndef LCD_RW_PIN
   #define lcd_output_rw(x) lcdlat.rw=x
   #define lcd_rw_tris()   lcdtris.rw=0
#else
   #define lcd_output_rw(x) output_bit(LCD_RW_PIN, x)
   #define lcd_rw_tris()  output_drive(LCD_RW_PIN)
#endif

// original version of this library incorrectly labeled LCD_DATA0 as LCD_DATA4,
// LCD_DATA1 as LCD_DATA5, and so on.  this block of code makes the driver
// compatible with any code written for the original library
#if (defined(LCD_DATA0) && defined(LCD_DATA1) && defined(LCD_DATA2) && defined(LCD_DATA3) && !defined(LCD_DATA4) && !defined(LCD_DATA5) && !defined(LCD_DATA6) && !defined(LCD_DATA7))
   #define  LCD_DATA4    LCD_DATA0
   #define  LCD_DATA5    LCD_DATA1
   #define  LCD_DATA6    LCD_DATA2
   #define  LCD_DATA7    LCD_DATA3
#endif

#ifndef LCD_DATA4
#ifndef LCD_DATA_PORT
   #if defined(__PCB__)
      #define LCD_DATA_PORT      0x06     //portb
      #define set_tris_lcd(x)   set_tris_b(x)
   #else
     #if defined(PIN_D0)
      #define LCD_DATA_PORT      getenv("SFR:PORTD")     //portd
     #else
      #define LCD_DATA_PORT      getenv("SFR:PORTB")     //portb
     #endif
   #endif   
#endif

#if defined(__PCB__)
   LCD_PIN_MAP lcd, lcdlat;
   #byte lcd = LCD_DATA_PORT
   #byte lcdlat = LCD_DATA_PORT
#elif defined(__PCM__)
   LCD_PIN_MAP lcd, lcdlat, lcdtris;
   #byte lcd = LCD_DATA_PORT
   #byte lcdlat = LCD_DATA_PORT
   #byte lcdtris = LCD_DATA_PORT+0x80
#elif defined(__PCH__)
   LCD_PIN_MAP lcd, lcdlat, lcdtris;
   #byte lcd = LCD_DATA_PORT
   #byte lcdlat = LCD_DATA_PORT+9
   #byte lcdtris = LCD_DATA_PORT+0x12
#elif defined(__PCD__)
   LCD_PIN_MAP lcd, lcdlat, lcdtris;
   #word lcd = LCD_DATA_PORT
   #word lcdlat = LCD_DATA_PORT+2
   #word lcdtris = LCD_DATA_PORT-0x02
#endif
#endif   //LCD_DATA4 not defined

#ifndef LCD_TYPE
   #define LCD_TYPE 2           // 0=5x7, 1=5x10, 2=2 lines
#endif

#ifndef LCD_LINE_TWO
   #define LCD_LINE_TWO 0x40    // LCD RAM address for the second line
#endif

BYTE const LCD_INIT_STRING[4] = {0x20 | (LCD_TYPE << 2), 0xc, 1, 6};
                             // These bytes need to be sent to the LCD
                             // to start it up.

BYTE lcd_read_nibble(void);

BYTE lcd_read_byte(void)
{
   BYTE low,high;

 #if defined(__PCB__)
   set_tris_lcd(LCD_INPUT_MAP);
 #else
  #if (defined(LCD_DATA4) && defined(LCD_DATA5) && defined(LCD_DATA6) && defined(LCD_DATA7))
   output_float(LCD_DATA4);
   output_float(LCD_DATA5);
   output_float(LCD_DATA6);
   output_float(LCD_DATA7);
  #else
   lcdtris.data = 0xF;
  #endif
 #endif
        
   lcd_output_rw(1);
   delay_cycles(1);
   lcd_output_enable(1);
   delay_cycles(1);
   high = lcd_read_nibble();
      
   lcd_output_enable(0);
   delay_cycles(1);
   lcd_output_enable(1);
   delay_us(1);
   low = lcd_read_nibble();
      
   lcd_output_enable(0);

 #if defined(__PCB__)
   set_tris_lcd(LCD_INPUT_MAP);
 #else
  #if (defined(LCD_DATA4) && defined(LCD_DATA5) && defined(LCD_DATA6) && defined(LCD_DATA7))
   output_drive(LCD_DATA4);
   output_drive(LCD_DATA5);
   output_drive(LCD_DATA6);
   output_drive(LCD_DATA7);
  #else
   lcdtris.data = 0x0;
  #endif
 #endif

   return( (high<<4) | low);
}

BYTE lcd_read_nibble(void)
{
  #if (defined(LCD_DATA4) && defined(LCD_DATA5) && defined(LCD_DATA6) && defined(LCD_DATA7))
   BYTE n = 0x00;

   /* Read the data port */
   n |= input(LCD_DATA4);
   n |= input(LCD_DATA5) << 1;
   n |= input(LCD_DATA6) << 2;
   n |= input(LCD_DATA7) << 3;
   
   return(n);
  #else
   return(lcd.data);
  #endif
}

void lcd_send_nibble(BYTE n)
{
  #if (defined(LCD_DATA4) && defined(LCD_DATA5) && defined(LCD_DATA6) && defined(LCD_DATA7))
   /* Write to the data port */
   output_bit(LCD_DATA4, bit_test(n, 0));
   output_bit(LCD_DATA5, bit_test(n, 1));
   output_bit(LCD_DATA6, bit_test(n, 2));
   output_bit(LCD_DATA7, bit_test(n, 3));
  #else      
   lcdlat.data = n;
  #endif
      
   delay_cycles(1);
   lcd_output_enable(1);
   delay_us(2);
   lcd_output_enable(0);
}

void lcd_send_byte(BYTE address, BYTE n)
{
   lcd_enable_tris();
   lcd_rs_tris();
   lcd_rw_tris();

   lcd_output_rs(0);
   while ( bit_test(lcd_read_byte(),7) ) ;
   lcd_output_rs(address);
   delay_cycles(1);
   lcd_output_rw(0);
   delay_cycles(1);
   lcd_output_enable(0);
   lcd_send_nibble(n >> 4);
   lcd_send_nibble(n & 0xf);
}

void lcd_init(void) 
{
   BYTE i;

 #if defined(__PCB__)
   set_tris_lcd(LCD_OUTPUT_MAP);
 #else
  #if (defined(LCD_DATA4) && defined(LCD_DATA5) && defined(LCD_DATA6) && defined(LCD_DATA7))
   output_drive(LCD_DATA4);
   output_drive(LCD_DATA5);
   output_drive(LCD_DATA6);
   output_drive(LCD_DATA7);
  #else
   lcdtris.data = 0x0;
  #endif
   lcd_enable_tris();
   lcd_rs_tris();
   lcd_rw_tris();
 #endif

   lcd_output_rs(0);
   lcd_output_rw(0);
   lcd_output_enable(0);
    
   delay_ms(15);
   for(i=1;i<=3;++i)
   {
       lcd_send_nibble(3);
       delay_ms(5);
   }
    
   lcd_send_nibble(2);
   for(i=0;i<=3;++i)
      lcd_send_byte(0,LCD_INIT_STRING[i]);
}

void lcd_gotoxy(BYTE x, BYTE y)
{
   BYTE address;
   
   if(y!=1)
      address=LCD_LINE_TWO;
   else
      address=0;
     
   address+=x-1;
   lcd_send_byte(0,0x80|address);
}

void lcd_putc(char c)
{   
   switch (c)
   {
      case '\f'   :  lcd_send_byte(0,1); //borrar lcd
                     delay_ms(2);
                     break;
                     
      case '\n'   : lcd_gotoxy(1,2);        break; //enter
     
      case '\b'   : lcd_send_byte(0,0x10);  break; //derecha
      
      case '\r'   : lcd_send_byte(0,0x14);  break; //izquierda
     
      default     : lcd_send_byte(1,c);     break;
   }
}
 
char lcd_getc(BYTE x, BYTE y)
{
   char value;

   lcd_gotoxy(x,y);
   while ( bit_test(lcd_read_byte(),7) ); // wait until busy flag is low
   lcd_output_rs(1);
   value = lcd_read_byte();
   lcd_output_rs(0);
   
   return(value);
}

int lcd_getint(BYTE x, BYTE y)
{
   int value;

   lcd_gotoxy(x,y);
   while ( bit_test(lcd_read_byte(),7) ); // wait until busy flag is low
   lcd_output_rs(1);
   value = lcd_read_byte();
   lcd_output_rs(0);
   switch(value) {
      case '0':   value=0;
                  break;
      case '1':   value=1;
                  break;
      case '2':   value=2;
                  break;
      case '3':   value=3;
                  break;
      case '4':   value=4;
                  break;
      case '5':   value=5;
                  break;
      case '6':   value=6;
                  break;
      case '7':   value=7;
                  break;
      case '8':   value=8;
                  break;
      case '9':   value=9;
                  break;
   }
   return(value);
}
```

Libreria Keypad.C


```
///////////////////////////////////////////////////////////////////////////
////                             keypad.c                                          ////
////                  Driver para teclado 4x4 generico                   ////
////                                                                                    ////
////  init_keypad()   Debe llamarse desde el programa principal ////
////                  antes de cualquier funcion                             ////
////                        ////
////  scan_keypad()   Función de escaneo de teclado segun    ////
////      la matriz de teclado                ////
////                                                                                    ////
////  read_keypad()     Encuentra la tecla por el metodo de inversion   ////
////        de puerto, espera a que se deje de pulsar y  //// 
////              retorna.       ////
////                                                                           ////
///////////////////////////////////////////////////////////////////////////
////        (C) Copyright 1996,2009 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.                               ////
///////////////////////////////////////////////////////////////////////////
////                                           
////   RB4 RB5 RB6 RB7                               
////             ^   ^   ^   ^                                 
////             |   |   |   |                                 
////           |---|---|---|---|      El teclado se conecta sin      
////  RB0 ---> | 1 | 2 | 3 | A |      necesedad de resistencias ya  
////           |---|---|---|---|      que tiene las resistencias de  
////  RB1 ---> | 4 | 5 | 6 | B |      pull-up activadas             
////           |---|---|---|---|                           
////  RB1 ---> | 7 | 8 | 9 | C |                              
////           |---|---|---|---|                              
////  RB3 ---> | * | 0 | # | D |                              
////           |---|---|---|---|                              
////                                           
///////////////////////////////////////////////////////////////////////////
 
 
 
//Direcciones de los registros segun PDF del pic 16fXXX
 
#byte PORTB=0x06   //Pic 16f877a
#byte TRISB=0x86   //
#byte INTCON=0x0B

void init_keypad()   
{

   TRISB=0xF0;
   port_b_pullups (TRUE);    //Habilita pull-up internos del puerto B   
   PORTB=0xF0;
   enable_interrupts(INT_RB);      // Habilita la interrupcion del puerto B ( RB4 - RB7).
   enable_interrupts(GLOBAL);      // Habilita las interrupciones globales.
}
 
unsigned char scan_keypad()   
{
   unsigned char i=0,j=0,PORT,PORTH,PORTL,PH,PL,key;
 
   //Matriz de teclado
   char keypad[4][4] =   { {'1','2','3','A'},
                       {'4','5','6','B'},
                      {'7','8','9','C'},
                      {'E','0','F','D'} }; 
   PORT=PORTB;
   PORTH=PORT&0xF0;
   PORTL=PORT&0x0F;
   
   for(j=0;j<4;j++)
   {
      PH=~(0b00010000<<j)&0xF0;
      if(PORTH == PH)
      {
         for(i=0;i<4;i++)
         {
            PL=~(0b00000001<<i)&0x0F;
            if(PORTL == PL)
            {
               key=keypad[i][j];
               while(PORT==PORTB);
            }
         }
      }      
   }
   if(key)
      return(key);   //Si la tecla es encontrada retorna valor segun la matriz de teclado
   else   
      return(0x80);   //Si la tecla no es encontrada retorna un caracter nulo 
}
 
 
unsigned char read_keypad()
{   
   char read,key;
 
   read=PORTB;
   TRISB=0x0F;
   PORTB=read;
   key=scan_keypad();
   return(key);
}
```


----------



## ilcapo (Ago 3, 2012)

hola amigo , tube un problema similar y lo solucioné colocando resistencias en los pines RB4 al RB7 a lo mejor ese problema no te salte colocandolas, saludos !


----------



## kriztinitah (Sep 7, 2012)

estoy trabajando con el pic 18f2520 y necesito manejar al lcd y 4 pulsadores con las interrupciones del puerto b , tambien necesito dejasr libre rb0 y rb1 como pudiese hacer en ese caso? que me sugieres?


----------



## Berto75 (Jul 25, 2015)

Hola Manu. Estoy interesado en tu proyecto como una vase. Quiero hacer el mio introduciendome en el keypad-phone y el LCD. Te agradeceria a ti o cualquiera si tieneis un momento que le echasesis un vistazo a tu propio programa. He dejado las preguntas en el en MAYUSCULAS.

#include <lcd.c>
#include <keypad.c>   //Libreria de teclado 4x4 

unsigned char key;   //Variable global tecla
int status; 
// Interrupcion RB4 - RB7 ///¿ DONDE AS DECLARADO ESTO ?

#INT_RB
void interrupt_keypad() // EN NINGUN MOMENTO main(){ UTILIZA interrupt_keypad() }           
{
   key=read_keypad();         //Asigna la tecla pulsada
}


// Programa Principal /////////////////////////////////////////////////////////

void main() 
{
   key=0x80;
   lcd_init();
   lcd_putc("Presione tecla:");
   while(true)
   {

   init_keypad();//¿QUE DEVUELBE ESTA FUNCION? ¿CUAL ES SU TRABAJO?
   if(key!=0x80)
      {
      lcd_init();//¿PORQUE REPETIRLO CUAL ES LA VENTAJA? YO SOLO LO HAGO UNA VEC ANTES DEL WHILE
      lcd_putc('\f');            //******
      lcd_gotoxy(1,1);         
      lcd_putc("Tecla pulsada: ");//******* SI YO NO QUIERO BORRARLO TODO SOLO EL NUMERO ¿QUE PASOS DEBO SEGUIR?
      lcd_putc(key);            //
      PORTB=0xF0;//¿PARA QUE SIRBE ASIGNARLE ESTE VALOR AL PORTB?
      key=0x80;
      }
   }
}
/* MY COMPILACION DA 9 ERRORES TODOS REFERENTES AL ARCHIVO .HEX
SIGO LOS SIEMPRE LOS SIGUIENTES PASOS PARA CREAR EL .HEX: (esta vec no a servido)
Antes de crear nada (en este caso copiar-pegar)
-FILE
-NEW
-PROYECT WIZART (Sombrero de brujo)
   -Device       ----->NO ENTIENDO MUCHAS COSAS DESDE ARRIBA PARA ABAJO
      -Famili          Ejemplo: Devug Code NUNCA LO MARCO 
      -Device
   -Clock
      -Cristal   ----> NO SE PARA QUE MARCO ESTO NUNCA E UTILIZADO UN CRISTAL EXTERNO EN PROTEUS
      -Hz

¿ QUE PASOS HAY QUE SEGUIR PARA CREAR EL .HEX DE ESTE CODIGO EN CONCRETO ?*/


----------



## TRILO-BYTE (Jul 25, 2015)

No pues no tienes declarado el micro en tu programa

No se para que quieres el picwizzard en un programa ya empezado
Y la funcion de RB se manda a llamar con la directiva de interrupcion #int rb
Esa funcion no la llama el main

Se llama sola por que es una interrupcion solo se llamara cuando el micro entra a interrupcion


----------



## miglo (Jul 26, 2015)

Bufff cuantas preguntas, jeje.

Algunas te las puedo contestar a mi manera, si me equiboco que se me corriga.

```
#include <keypad.c>   //Libreria de teclado 4x4
```
yo utilizo esta libreria para el 4x4: KBD4x4.c, no recuerdo de donde la busque, es la de 3x4 modificada.


```
init_keypad();//¿QUE DEVUELBE ESTA FUNCION? ¿CUAL ES SU TRABAJO?
```

Antes no se como se declara el inicio de dicha libreria, por lo visto era asi, hoy en dia salvo que me equiboque se declara  kbd_init();, esto se hace para inicializar la libreria del teclado, en este caso de 4x4. Y si con declararla comenzado el main vale, por que la puso el que hizo el codigo "qui lo sa", jeje.


```
PORTB=0xF0;//¿PARA QUE SIRBE ASIGNARLE ESTE VALOR AL PORTB?
```

Esto quiere decir que el puerto B del pin 0 al 3 seran salidas y del pin 4 al 7 entradas, si lo traduces a binario seria lo mismo que poner 0b11110000, poniendolo en hexadecimal te ahorras trabajo, pero es lo mismo. 


```
// Interrupcion RB4 - RB7 ///¿ DONDE AS DECLARADO ESTO ?
```

A esto ya te ha contestado TRILO-BYTE, yo añadiria un poquito mas, eso si con el permiso de TRILO-BYTE, por lo que tengo leido casi todos los pics de microchip en el puerto B hay 2 clases de interrupciones: #INT_RB que se refiere a las interrupciones que se pueden usar en los pins del 4 al 7 del puerto B y la interrupcion #INT_EXT que se usa en el pin 0 del puerto B.


```
-Cristal   ----> NO SE PARA QUE MARCO ESTO NUNCA E UTILIZADO UN CRISTAL EXTERNO EN PROTEUS
      -Hz
```

Vamos haber claro que tienes que ponerlo, si no haces eso se entendera que trabajas con el reloj interno del pic y si no lo has declarado puessss nanai de la china, no te va a funcionar, otra cosa es tu estrañeza, de hecho me pasaba a mi al principio, no veas fantasmas que no los hay, aqui biene lo que te decia de leer un poquito.

El programa de proteus por sistema da por entendido, cuando le cargas el archivo al pic, el cristal que usa y aqui es donde se lleva a engaños, no necesita que tu pongas en èl el cristal, yo creo que en los esquemas deveriamos de ponerlo siempre.

Por lo que aprendido de D@rkbytes, lamentablemente proteus se carga al 100% enseguida con cualquier cosa que le añadamos, mas aun los que no tenemos mucha practica como yo y por lo que veo tu.


```
¿ QUE PASOS HAY QUE SEGUIR PARA CREAR EL .HEX DE ESTE CODIGO EN CONCRETO ?*
```

El archivo HEX te lo genera el compilador, siempre y cuando no tengas errores, mientras los tengas no te lo genera.


----------



## Berto75 (Jul 26, 2015)

Entiendo kbd_init(); (yo utilizo un 4x3 tambien vale) pero con ello no me explicas que es keypad(); Aunque echandole un vistazo de new al programa de Manu intuyo q es similar a numero=kbd_getc();

PORTB=0xF0; no me fije crei que era lo mismo que PORTB=F0; (Yo utilizo set_tris_B(0b11110000); siempre q este dentro de main() 

#INT_RB  interrupciones aplicadas usar en los pins del 4 al 7 del puerto B. ¿Es Standar-normalizado?
<16F628a.h> & <16f877> Solo tienen en comun que pin 4 es RB4, el contenido de pin 7 difiere
  RB7/T1OSI  &   RB7/PGD  ¿Se activan por 1 o 0?. Me confunde que interfieran en la lectura del keypad y
PORTB=0xF0 me lia deveria ser PORTB=0xF8 para q pin 4 sea Entrada de interrupcion. ¿ Si les configuras como salidas a estos pines anulas las interrupciones ?

Respecto al .Hex creo descartado q sea CCS Proteus no solo no atiende mi codigo. Tampoco reacciona con el codigo de los demas modifike lo q modifike no responde a lo nuevo, es la 2ª vec q me pasa. E dejado este tema en "simulacion y diseño" parece mas apropiado.

Si estoy muy verde Si. Podria liaros y liaros a preguntas cuando me ataca la skizofrenia es una p que no puedo parar.


----------



## TRILO-BYTE (Jul 26, 2015)

por que hay gente que escribe *q* en lugar de *que* eso me molesta mucho

antes de hacer cualquier cosa siempre hay que saber que tiene y que no tiene un micro

por ejemplo:
no le vamos a meter interrupciones por RS232 a un pic16f84a pues no tiene puerto RS232

siempre hay que revisar si nuestro micro tiene las interrupciones que necesitamos pues simplemente no va a compilar y marcara una diarrea de errores de compilacion


----------

