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 #else #byte kbd = 0xF83 #endif #else #if defined use_portb_kbd #byte kbd = 6 #else #byte kbd = 8 #endif #endif // on to port D (at address 8) // on to port B (at address 6) // This puts the entire structure // This puts the entire structure

#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 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)

// Keypad layout: char const KEYS[4][3] = {{'1','2','3'}, {'4','5','6'},

{'7','8','9'}, {'*','0','#'}};

#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 int1 kbd_down; static char last_key; static BYTE col;

BYTE kchar; BYTE row;

kchar='\0'; 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; }

if(kbd_down) { if((kbd & (ALL_ROWS))==(ALL_ROWS)) { kbd_down=FALSE; kchar=last_key; last_key='\0'; } } 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==3) col=0; } } kbd_call_count=0; } set_tris_kbd(ALL_PINS); return(kchar); }

LCDD.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 //// ////

/////////////////////////////////////////////////////////////////////////// //// (C) Copyright 1996,2007 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. ////

///////////////////////////////////////////////////////////////////////////

// As defined in the following structure the pin connection is as follows: // // // // // // // // // LCD pins D0-D3 are not used and PIC D3 is not used. D0 enable D1 rs D2 rw D4 D4 D5 D5 D6 D6 D7 D7

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

struct lcd_pin_map { BOOLEAN enable; BOOLEAN rs; BOOLEAN rw;

// This structure is overlayed // on to an I/O port to gain // access to the LCD pins. // The bits are allocated from

BOOLEAN unused; int } lcd; data : 4;

// low order up. ENABLE will // be pin B0.

#if defined use_portb_lcd //#locate lcd = getenv("sfr:PORTB") // This puts the entire structure over the port #ifdef __pch__ #locate lcd = 0xf81 #else #locate lcd = 6 #endif #define set_tris_lcd(x) set_tris_b(x) #else //#locate lcd = getenv("sfr:PORTD") // This puts the entire structure over the port #ifdef __pch__ #locate lcd = 0xf83 #else #locate lcd = 8 #endif #define set_tris_lcd(x) set_tris_d(x) #endif

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

#define lcd_line_two 0x40 // LCD RAM address for the second line

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.

// The following are used for setting // the I/O port direction register.

struct lcd_pin_map const LCD_WRITE = {0,0,0,0,0}; // For write mode all pins are out struct lcd_pin_map const LCD_READ = {0,0,0,0,15}; // For read mode data pins are in

BYTE lcd_read_byte() { BYTE low,high; set_tris_lcd(LCD_READ); lcd.rw = 1; delay_cycles(1); lcd.enable = 1; delay_cycles(1); high = lcd.data; lcd.enable = 0; delay_cycles(1); lcd.enable = 1;

delay_us(1); low = lcd.data; lcd.enable = 0; set_tris_lcd(LCD_WRITE); return( (high<<4) | low); }

void lcd_send_nibble( BYTE n ) { lcd.data = n; delay_cycles(1); lcd.enable = 1; delay_us(2); lcd.enable = 0; }

void lcd_send_byte( BYTE address, BYTE n ) {

lcd.rs = 0; while ( bit_test(lcd_read_byte(),7) ) ; lcd.rs = address; delay_cycles(1); lcd.rw = 0; delay_cycles(1); lcd.enable = 0; lcd_send_nibble(n >> 4);

lcd_send_nibble(n & 0xf); }

void lcd_init() { BYTE i; set_tris_lcd(LCD_WRITE); lcd.rs = 0; lcd.rw = 0; lcd.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); delay_ms(2); break; case '\n' : lcd_gotoxy(1,2); break;

case '\b' : lcd_send_byte(0,0x10); break; 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.rs=1; value = lcd_read_byte(); lcd.rs=0; return(value); }