dac.lst

PIC16F877A RTC1307 LCD 16x2 keypad 4x4 and a windows application connect with PIC on RS232

0427:  CALL   3F4
0428:  GOTO   438
....................      case '\b'   : lcd_send_byte(0,0x10);  break; 
0429:  BSF    03.6
042A:  CLRF   35
042B:  MOVLW  10
042C:  MOVWF  36
042D:  BCF    03.6
042E:  CALL   3CB
042F:  GOTO   438
....................      default     : lcd_send_byte(1,c);     break; 
0430:  MOVLW  01
0431:  BSF    03.6
0432:  MOVWF  35
0433:  MOVF   30,W
0434:  MOVWF  36
0435:  BCF    03.6
0436:  CALL   3CB
0437:  GOTO   438
....................    } 
.................... } 
0438:  RETLW  00
.................... #separate 
.................... char lcd_getc( BYTE x, BYTE y) { 
*
0503:  CLRF   28
0504:  BTFSC  0B.7
0505:  BSF    28.7
0506:  BCF    0B.7
....................    char value; 
....................  
....................     lcd_gotoxy(x,y); 
0507:  MOVF   71,W
0508:  BSF    03.6
0509:  MOVWF  31
050A:  MOVF   72,W
050B:  MOVWF  32
050C:  BCF    03.6
050D:  CALL   3F4
050E:  BTFSC  28.7
050F:  BSF    0B.7
0510:  CLRF   28
0511:  BTFSC  0B.7
0512:  BSF    28.7
0513:  BCF    0B.7
....................     while ( bit_test(lcd_read_byte(),7) ); // wait until busy flag is low 
0514:  CALL   396
0515:  BTFSC  28.7
0516:  BSF    0B.7
0517:  MOVF   78,W
0518:  MOVWF  74
0519:  BTFSC  74.7
051A:  GOTO   510
....................     lcd.rs=1; 
051B:  BSF    08.1
051C:  CLRF   28
051D:  BTFSC  0B.7
051E:  BSF    28.7
051F:  BCF    0B.7
....................     value = lcd_read_byte(); 
0520:  CALL   396
0521:  BTFSC  28.7
0522:  BSF    0B.7
0523:  MOVF   78,W
0524:  MOVWF  73
....................     lcd.rs=0; 
0525:  BCF    08.1
....................     return(value); 
0526:  MOVF   73,W
0527:  MOVWF  78
.................... } 
0528:  RETLW  00
....................  
.................... #include <KBD_VED.c> 
.................... /////////////////////////////////////////////////////////////////////////// 
.................... ////                             KBD.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,1997 Custom Computer Services           //// 
.................... ////                                                                   //// 
.................... /////////////////////////////////////////////////////////////////////////// 
....................  
.................... ////////////////// The following defines the keypad layout on port B 
.................... #byte kbd = 6   // Keypad is connected to port B (address 6) 
....................  
.................... //Keypad connection:   (for example column 0 is B2) 
.................... //                Bx: 
....................  
.................... #define COL0 (1 << 3) 
.................... #define COL1 (1 << 2) 
.................... #define COL2 (1 << 1) 
....................  
.................... #define COLINT (0x01) 
....................  
.................... #define ROW0 (1 << 7) 
.................... #define ROW1 (1 << 6) 
.................... #define ROW2 (1 << 5) 
.................... #define ROW3 (1 << 4) 
....................  
....................  
.................... #define ALL_ROWS (ROW0|ROW1|ROW2|ROW3) 
.................... #define ALL_PINS (ALL_ROWS|COL0|COL1|COL2|COLINT) 
....................  
.................... // 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 
.................... #separate 
.................... void kbd_init() 
.................... { 
....................    #ifdef __PCM__ 
....................        port_b_pullups(true);   // If not PCM be sure to use external pullups 
*
048F:  BSF    03.5
0490:  BCF    01.7
....................    #endif 
.................... } 
0491:  BCF    03.5
0492:  BCF    0A.3
0493:  BCF    0A.4
0494:  GOTO   60D (RETURN)
....................  
.................... #separate 
.................... char kbd_getc( ) 
.................... { 
....................    static byte kbd_call_count; 
*
05F9:  CLRF   2A
....................    static short int kbd_down; 
05FA:  BCF    2B.0
....................    static char last_key; 
05FB:  CLRF   2C
....................    static byte col; 
05FC:  CLRF   2D
....................  
....................    byte kchar; 
....................    byte row; 
....................  
....................    kchar='\0'; 
*
0495:  CLRF   68
....................    if(++kbd_call_count>KBD_DEBOUNCE_FACTOR) { 
0496:  INCF   2A,F
0497:  MOVF   2A,W
0498:  SUBLW  21
0499:  BTFSC  03.0
049A:  GOTO   4FC
....................        switch (col) { 
049B:  MOVF   2D,W
049C:  BTFSC  03.2
049D:  GOTO   4A5
049E:  XORLW  01
049F:  BTFSC  03.2
04A0:  GOTO   4AB
04A1:  XORLW  03
04A2:  BTFSC  03.2
04A3:  GOTO   4B1
04A4:  GOTO   4B7
....................          case 0   : set_tris_b(ALL_PINS&~COL0); 
04A5:  MOVLW  F7
04A6:  BSF    03.5
04A7:  MOVWF  06
....................                     kbd=~COL0&ALL_PINS; 
04A8:  BCF    03.5
04A9:  MOVWF  06
....................                     break; 
04AA:  GOTO   4B7
....................          case 1   : set_tris_b(ALL_PINS&~COL1); 
04AB:  MOVLW  FB
04AC:  BSF    03.5
04AD:  MOVWF  06
....................                     kbd=~COL1&ALL_PINS; 
04AE:  BCF    03.5
04AF:  MOVWF  06
....................                     break; 
04B0:  GOTO   4B7
....................          case 2   : set_tris_b(ALL_PINS&~COL2); 
04B1:  MOVLW  FD
04B2:  BSF    03.5
04B3:  MOVWF  06
....................                     kbd=~COL2&ALL_PINS; 
04B4:  BCF    03.5
04B5:  MOVWF  06
....................                     break; 
04B6:  GOTO   4B7
....................        } 
....................  
....................        if(kbd_down) { 
04B7:  BTFSS  2B.0
04B8:  GOTO   4C3
....................          if((kbd & (ALL_ROWS))==(ALL_ROWS)) { 
04B9:  MOVF   06,W
04BA:  ANDLW  F0
04BB:  SUBLW  F0
04BC:  BTFSS  03.2
04BD:  GOTO   4C2
....................            kbd_down=false; 
04BE:  BCF    2B.0
....................            kchar=last_key; 
04BF:  MOVF   2C,W
04C0:  MOVWF  68
....................            last_key='\0'; 
04C1:  CLRF   2C
....................          } 
....................        } else { 
04C2:  GOTO   4FB
....................           if((kbd & (ALL_ROWS))!=(ALL_ROWS)) { 
04C3:  MOVF   06,W
04C4:  ANDLW  F0
04C5:  SUBLW  F0
04C6:  BTFSC  03.2
04C7:  GOTO   4F6
....................              if((kbd & ROW0)==0) 
04C8:  MOVF   06,W
04C9:  ANDLW  80
04CA:  BTFSS  03.2
04CB:  GOTO   4CE
....................                row=0; 
04CC:  CLRF   69
....................              else if((kbd & ROW1)==0) 
04CD:  GOTO   4E2
04CE:  MOVF   06,W
04CF:  ANDLW  40
04D0:  BTFSS  03.2
04D1:  GOTO   4D5
....................                row=1; 
04D2:  MOVLW  01
04D3:  MOVWF  69
....................              else if((kbd & ROW2)==0) 
04D4:  GOTO   4E2
04D5:  MOVF   06,W
04D6:  ANDLW  20
04D7:  BTFSS  03.2
04D8:  GOTO   4DC
....................                row=2; 
04D9:  MOVLW  02
04DA:  MOVWF  69
....................              else if((kbd & ROW3)==0) 
04DB:  GOTO   4E2
04DC:  MOVF   06,W
04DD:  ANDLW  10
04DE:  BTFSS  03.2
04DF:  GOTO   4E2
....................                row=3; 
04E0:  MOVLW  03
04E1:  MOVWF  69
04E2:  CLRF   28
04E3:  BTFSC  0B.7
04E4:  BSF    28.7
04E5:  BCF    0B.7
....................              last_key =KEYS[row][col]; 
04E6:  MOVF   69,W
04E7:  BSF    03.6
04E8:  MOVWF  22
04E9:  MOVLW  03
04EA:  MOVWF  23
04EB:  BCF    03.6
04EC:  CALL   265
04ED:  BTFSC  28.7
04EE:  BSF    0B.7
04EF:  MOVF   2D,W
04F0:  ADDWF  78,W
04F1:  CALL   044
04F2:  MOVWF  78
04F3:  MOVWF  2C
....................              kbd_down = true; 
04F4:  BSF    2B.0
....................           } else { 
04F5:  GOTO   4FB
....................              ++col; 
04F6:  INCF   2D,F
....................              if(col==3) 
04F7:  MOVF   2D,W
04F8:  SUBLW  03
04F9:  BTFSC  03.2
....................                col=0; 
04FA:  CLRF   2D
....................           } 
....................        } 
....................       kbd_call_count=0; 
04FB:  CLRF   2A
....................    } 
....................   set_tris_b(ALL_PINS); 
04FC:  MOVLW  FF
04FD:  BSF    03.5
04FE:  MOVWF  06
....................   return(kchar); 
04FF:  BCF    03.5
0500:  MOVF   68,W
0501:  MOVWF  78
.................... } 
0502:  RETLW  00
....................  
.................... #include <TIME_VED.h> 
.................... #ifndef _struct_time_eeprom 
.................... #define _struct_time_eeprom 
....................  
.................... #ifndef _struct_date_time 
.................... #define _struct_date_time 
....................  
.................... ///////////////////////////////////////////// 
....................  
.................... typedef struct {  
....................    int8 seconds;    // 0 to 59  
....................    int8 minutes;    // 0 to 59  
....................    int8 hours;      // 0 to 23  (24-hour time)  
....................    int8 day;        // 0 = Sunday, 1 = Monday, etc.  
....................    int8 date;       // 1 to 31  
....................    int8 month;      // 1 to 12  
....................    int8 year;       // 00 to 99  
.................... } struct_date_time;  
....................  
.................... ///////////////////////////////////////////// 
.................... typedef struct { 
....................  
....................   byte h_hour; 
....................   byte l_hour; 
....................   byte h_minute; 
....................   byte l_minute; 
....................  
....................   } struct_time_eeprom;