CCS PCM C Compiler, Version 4.106, 47914               22-5-13 12:34

               Filename: D:\Honza\MLAB\Designs\Measuring_instruments\GM_counter\SW\counter\main.lst

               ROM used: 2825 words (34%)
                         Largest free fragment is 2048
               RAM used: 36 (10%) at main() level
                         55 (15%) worst case
               Stack:    6 worst case (5 in main + 1 for interrupts)

*
0000:  MOVLW  08
0001:  MOVWF  0A
0002:  GOTO   000
0003:  NOP
0004:  MOVWF  7F
0005:  SWAPF  03,W
0006:  CLRF   03
0007:  MOVWF  21
0008:  MOVF   0A,W
0009:  MOVWF  20
000A:  CLRF   0A
000B:  MOVF   04,W
000C:  MOVWF  22
000D:  MOVF   77,W
000E:  MOVWF  23
000F:  MOVF   78,W
0010:  MOVWF  24
0011:  MOVF   79,W
0012:  MOVWF  25
0013:  MOVF   7A,W
0014:  MOVWF  26
0015:  BCF    03.7
0016:  BCF    03.5
0017:  BTFSS  0B.5
0018:  GOTO   01B
0019:  BTFSC  0B.2
001A:  GOTO   032
001B:  MOVLW  8C
001C:  MOVWF  04
001D:  BTFSS  00.0
001E:  GOTO   021
001F:  BTFSC  0C.0
0020:  GOTO   035
0021:  MOVF   22,W
0022:  MOVWF  04
0023:  MOVF   23,W
0024:  MOVWF  77
0025:  MOVF   24,W
0026:  MOVWF  78
0027:  MOVF   25,W
0028:  MOVWF  79
0029:  MOVF   26,W
002A:  MOVWF  7A
002B:  MOVF   20,W
002C:  MOVWF  0A
002D:  SWAPF  21,W
002E:  MOVWF  03
002F:  SWAPF  7F,F
0030:  SWAPF  7F,W
0031:  RETFIE
0032:  BCF    0A.3
0033:  BCF    0A.4
0034:  GOTO   040
0035:  BCF    0A.3
0036:  BCF    0A.4
0037:  GOTO   047
.................... #include ".\main.h" 
.................... #include <16F887.h> 
.................... //////// Standard Header file for the PIC16F887 device //////////////// 
.................... #device PIC16F887 
.................... #list 
....................  
.................... #device adc=10 
....................  
.................... #FUSES NOWDT                    //No Watch Dog Timer 
.................... #FUSES INTRC                    //Internal RC Osc 
.................... #FUSES NOPUT                    //No Power Up Timer 
.................... #FUSES MCLR                     //Master Clear pin enabled 
.................... #FUSES NOPROTECT                //Code not protected from reading 
.................... #FUSES NOCPD                    //No EE protection 
.................... #FUSES NOBROWNOUT               //No brownout reset 
.................... #FUSES IESO                     //Internal External Switch Over mode enabled 
.................... #FUSES FCMEN                    //Fail-safe clock monitor enabled 
.................... #FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O 
.................... #FUSES NODEBUG                  //No Debug mode for ICD 
.................... #FUSES NOWRT                    //Program memory not write protected 
.................... #FUSES BORV40                   //Brownout reset at 4.0V 
....................  
.................... #use delay(clock=8000000) 
*
00A9:  MOVLW  46
00AA:  MOVWF  04
00AB:  BCF    03.7
00AC:  MOVF   00,W
00AD:  BTFSC  03.2
00AE:  GOTO   0BC
00AF:  MOVLW  02
00B0:  MOVWF  78
00B1:  CLRF   77
00B2:  DECFSZ 77,F
00B3:  GOTO   0B2
00B4:  DECFSZ 78,F
00B5:  GOTO   0B1
00B6:  MOVLW  97
00B7:  MOVWF  77
00B8:  DECFSZ 77,F
00B9:  GOTO   0B8
00BA:  DECFSZ 00,F
00BB:  GOTO   0AF
00BC:  RETURN
*
05FC:  MOVLW  08
05FD:  SUBWF  40,F
05FE:  BTFSS  03.0
05FF:  GOTO   60C
0600:  MOVLW  40
0601:  MOVWF  04
0602:  BCF    03.7
0603:  BCF    03.0
0604:  RRF    00,F
0605:  MOVF   00,W
0606:  BTFSC  03.2
0607:  GOTO   60C
0608:  GOTO   60A
0609:  NOP
060A:  DECFSZ 00,F
060B:  GOTO   609
060C:  RETURN
.................... #use rs232(baud=9600,parity=N,xmit=PIN_B7,rcv=PIN_B6,bits=8) 
*
0235:  BSF    03.5
0236:  BCF    06.7
0237:  BCF    03.5
0238:  BCF    06.7
0239:  MOVLW  08
023A:  MOVWF  78
023B:  GOTO   23C
023C:  NOP
023D:  BSF    78.7
023E:  GOTO   24D
023F:  BCF    78.7
0240:  RRF    45,F
0241:  BTFSC  03.0
0242:  BSF    06.7
0243:  BTFSS  03.0
0244:  BCF    06.7
0245:  BSF    78.6
0246:  GOTO   24D
0247:  BCF    78.6
0248:  DECFSZ 78,F
0249:  GOTO   240
024A:  GOTO   24B
024B:  NOP
024C:  BSF    06.7
024D:  MOVLW  3F
024E:  MOVWF  04
024F:  DECFSZ 04,F
0250:  GOTO   24F
0251:  NOP
0252:  BTFSC  78.7
0253:  GOTO   23F
0254:  BTFSC  78.6
0255:  GOTO   247
0256:  RETURN
....................  
....................  
....................  
.................... #define LED1 PIN_C6  //CHANGE PIN_XX TO YOUR LED PIN NUMBER, EX: PIN_A5 
.................... #define LED2 PIN_C5  //CHANGE PIN_XX TO YOUR LED PIN NUMBER, EX: PIN_A5 
.................... #define LED3 PIN_C4  // pulse detect 
.................... #define LED4 PIN_D3  //CHANGE PIN_XX TO YOUR LED PIN NUMBER 
....................  
.................... #define S1 PIN_C2  // raw up  
.................... #define S2 PIN_C3  // raw down    
.................... #define S3 PIN_D0  // fine up 
.................... #define S4 PIN_D1  // fine down  
.................... #define S5 PIN_B1  // time setup 
.................... #define S6 PIN_B2  // treshold setup 
....................  
.................... #define BEEP PIN_D2  //piezo beeper 
....................  
.................... #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  
.................... #include <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.         //// 
.................... ////                 \a  Set cursor position to upper left                 //// 
.................... ////                 \f  Clear display, set cursor to upper left           //// 
.................... ////                 \n  Go to start of second line                        //// 
.................... ////                 \b  Move back one position                            //// 
.................... ////              If LCD_EXTENDED_NEWLINE is defined, the \n character     //// 
.................... ////              will erase all remanining characters on the current      //// 
.................... ////              line, and move the cursor to the beginning of the next   //// 
.................... ////              line.                                                    //// 
.................... ////              If LCD_EXTENDED_NEWLINE is defined, the \r character     //// 
.................... ////              will move the cursor to the start of the current         //// 
.................... ////              line.                                                    //// 
.................... ////                                                                       //// 
.................... ////  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. 
.................... // 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 
....................  
.................... #ifndef LCD_LINE_LENGTH 
....................    #define LCD_LINE_LENGTH 20 
.................... #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); 
*
0122:  BSF    08.4
....................    output_float(LCD_DATA5); 
0123:  BSF    08.5
....................    output_float(LCD_DATA6); 
0124:  BSF    08.6
....................    output_float(LCD_DATA7); 
0125:  BSF    08.7
....................   #else 
....................    lcdtris.data = 0xF; 
....................   #endif 
....................  #endif 
....................          
....................    lcd_output_rw(1); 
0126:  BCF    03.5
0127:  BSF    09.2
0128:  BSF    03.5
0129:  BCF    09.2
....................    delay_cycles(1); 
012A:  NOP
....................    lcd_output_enable(1); 
012B:  BCF    03.5
012C:  BSF    09.0
012D:  BSF    03.5
012E:  BCF    09.0
....................    delay_cycles(1); 
012F:  NOP
....................    high = lcd_read_nibble(); 
0130:  BCF    03.5
0131:  CALL   0E9
0132:  MOVF   78,W
0133:  MOVWF  4D
....................        
....................    lcd_output_enable(0); 
0134:  BCF    09.0
0135:  BSF    03.5
0136:  BCF    09.0
....................    delay_cycles(1); 
0137:  NOP
....................    lcd_output_enable(1); 
0138:  BCF    03.5
0139:  BSF    09.0
013A:  BSF    03.5
013B:  BCF    09.0
....................    delay_us(1); 
013C:  GOTO   13D
....................    low = lcd_read_nibble(); 
013D:  BCF    03.5
013E:  CALL   0E9
013F:  MOVF   78,W
0140:  MOVWF  4C
....................        
....................    lcd_output_enable(0); 
0141:  BCF    09.0
0142:  BSF    03.5
0143:  BCF    09.0
....................  
....................  #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); 
0144:  BCF    08.4
....................    output_drive(LCD_DATA5); 
0145:  BCF    08.5
....................    output_drive(LCD_DATA6); 
0146:  BCF    08.6
....................    output_drive(LCD_DATA7); 
0147:  BCF    08.7
....................   #else 
....................    lcdtris.data = 0x0; 
....................   #endif 
....................  #endif 
....................  
....................    return( (high<<4) | low); 
0148:  BCF    03.5
0149:  SWAPF  4D,W
014A:  MOVWF  77
014B:  MOVLW  F0
014C:  ANDWF  77,F
014D:  MOVF   77,W
014E:  IORWF  4C,W
014F:  MOVWF  78
.................... } 
....................  
.................... BYTE lcd_read_nibble(void) 
.................... { 
....................   #if (defined(LCD_DATA4) && defined(LCD_DATA5) && defined(LCD_DATA6) && defined(LCD_DATA7)) 
*
00E9:  CLRF   4E
....................    BYTE n = 0x00; 
....................  
....................    /* Read the data port */ 
....................    n |= input(LCD_DATA4); 
00EA:  BSF    03.5
00EB:  BSF    08.4
00EC:  MOVLW  00
00ED:  BCF    03.5
00EE:  BTFSC  08.4
00EF:  MOVLW  01
00F0:  IORWF  4E,F
....................    n |= input(LCD_DATA5) << 1; 
00F1:  BSF    03.5
00F2:  BSF    08.5
00F3:  MOVLW  00
00F4:  BCF    03.5
00F5:  BTFSC  08.5
00F6:  MOVLW  01
00F7:  MOVWF  77
00F8:  BCF    03.0
00F9:  RLF    77,F
00FA:  MOVF   77,W
00FB:  IORWF  4E,F
....................    n |= input(LCD_DATA6) << 2; 
00FC:  BSF    03.5
00FD:  BSF    08.6
00FE:  MOVLW  00
00FF:  BCF    03.5
0100:  BTFSC  08.6
0101:  MOVLW  01
0102:  MOVWF  77
0103:  RLF    77,F
0104:  RLF    77,F
0105:  MOVLW  FC
0106:  ANDWF  77,F
0107:  MOVF   77,W
0108:  IORWF  4E,F
....................    n |= input(LCD_DATA7) << 3; 
0109:  BSF    03.5
010A:  BSF    08.7
010B:  MOVLW  00
010C:  BCF    03.5
010D:  BTFSC  08.7
010E:  MOVLW  01
010F:  MOVWF  77
0110:  RLF    77,F
0111:  RLF    77,F
0112:  RLF    77,F
0113:  MOVLW  F8
0114:  ANDWF  77,F
0115:  MOVF   77,W
0116:  IORWF  4E,F
....................     
....................    return(n); 
0117:  MOVF   4E,W
0118:  MOVWF  78
....................   #else 
....................    return(lcd.data); 
....................   #endif 
.................... } 
0119:  RETURN
....................  
.................... 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)); 
*
00BD:  BTFSC  4D.0
00BE:  GOTO   0C1
00BF:  BCF    08.4
00C0:  GOTO   0C2
00C1:  BSF    08.4
00C2:  BSF    03.5
00C3:  BCF    08.4
....................    output_bit(LCD_DATA5, bit_test(n, 1)); 
00C4:  BCF    03.5
00C5:  BTFSC  4D.1
00C6:  GOTO   0C9
00C7:  BCF    08.5
00C8:  GOTO   0CA
00C9:  BSF    08.5
00CA:  BSF    03.5
00CB:  BCF    08.5
....................    output_bit(LCD_DATA6, bit_test(n, 2)); 
00CC:  BCF    03.5
00CD:  BTFSC  4D.2
00CE:  GOTO   0D1
00CF:  BCF    08.6
00D0:  GOTO   0D2
00D1:  BSF    08.6
00D2:  BSF    03.5
00D3:  BCF    08.6
....................    output_bit(LCD_DATA7, bit_test(n, 3)); 
00D4:  BCF    03.5
00D5:  BTFSC  4D.3
00D6:  GOTO   0D9
00D7:  BCF    08.7
00D8:  GOTO   0DA
00D9:  BSF    08.7
00DA:  BSF    03.5
00DB:  BCF    08.7
....................   #else       
....................    lcdlat.data = n; 
....................   #endif 
....................        
....................    delay_cycles(1); 
00DC:  NOP
....................    lcd_output_enable(1); 
00DD:  BCF    03.5
00DE:  BSF    09.0
00DF:  BSF    03.5
00E0:  BCF    09.0
....................    delay_us(2); 
00E1:  GOTO   0E2
00E2:  GOTO   0E3
....................    lcd_output_enable(0); 
00E3:  BCF    03.5
00E4:  BCF    09.0
00E5:  BSF    03.5
00E6:  BCF    09.0
.................... } 
00E7:  BCF    03.5
00E8:  RETURN
....................  
.................... void lcd_send_byte(BYTE address, BYTE n) 
.................... { 
....................   #if defined(__PCB__) 
....................    set_tris_lcd(LCD_OUTPUT_MAP); 
....................   #else 
....................    lcd_enable_tris(); 
*
011A:  BSF    03.5
011B:  BCF    09.0
....................    lcd_rs_tris(); 
011C:  BCF    09.1
....................    lcd_rw_tris(); 
011D:  BCF    09.2
....................   #endif 
....................  
....................    lcd_output_rs(0); 
011E:  BCF    03.5
011F:  BCF    09.1
0120:  BSF    03.5
0121:  BCF    09.1
....................    while ( bit_test(lcd_read_byte(),7) ) ; 
*
0150:  MOVF   78,W
0151:  MOVWF  4C
0152:  BTFSS  4C.7
0153:  GOTO   156
0154:  BSF    03.5
0155:  GOTO   122
....................    lcd_output_rs(address); 
0156:  MOVF   4A,F
0157:  BTFSS  03.2
0158:  GOTO   15B
0159:  BCF    09.1
015A:  GOTO   15C
015B:  BSF    09.1
015C:  BSF    03.5
015D:  BCF    09.1
....................    delay_cycles(1); 
015E:  NOP
....................    lcd_output_rw(0); 
015F:  BCF    03.5
0160:  BCF    09.2
0161:  BSF    03.5
0162:  BCF    09.2
....................    delay_cycles(1); 
0163:  NOP
....................    lcd_output_enable(0); 
0164:  BCF    03.5
0165:  BCF    09.0
0166:  BSF    03.5
0167:  BCF    09.0
....................    lcd_send_nibble(n >> 4); 
0168:  BCF    03.5
0169:  SWAPF  4B,W
016A:  MOVWF  4C
016B:  MOVLW  0F
016C:  ANDWF  4C,F
016D:  MOVF   4C,W
016E:  MOVWF  4D
016F:  CALL   0BD
....................    lcd_send_nibble(n & 0xf); 
0170:  MOVF   4B,W
0171:  ANDLW  0F
0172:  MOVWF  4C
0173:  MOVWF  4D
0174:  CALL   0BD
.................... } 
0175:  RETURN
....................  
.................... #if defined(LCD_EXTENDED_NEWLINE) 
.................... unsigned int8 g_LcdX, g_LcdY; 
.................... #endif 
....................  
.................... 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); 
0176:  BSF    03.5
0177:  BCF    08.4
....................    output_drive(LCD_DATA5); 
0178:  BCF    08.5
....................    output_drive(LCD_DATA6); 
0179:  BCF    08.6
....................    output_drive(LCD_DATA7); 
017A:  BCF    08.7
....................   #else 
....................    lcdtris.data = 0x0; 
....................   #endif 
....................    lcd_enable_tris(); 
017B:  BCF    09.0
....................    lcd_rs_tris(); 
017C:  BCF    09.1
....................    lcd_rw_tris(); 
017D:  BCF    09.2
....................  #endif 
....................  
....................    lcd_output_rs(0); 
017E:  BCF    03.5
017F:  BCF    09.1
0180:  BSF    03.5
0181:  BCF    09.1
....................    lcd_output_rw(0); 
0182:  BCF    03.5
0183:  BCF    09.2
0184:  BSF    03.5
0185:  BCF    09.2
....................    lcd_output_enable(0); 
0186:  BCF    03.5
0187:  BCF    09.0
0188:  BSF    03.5
0189:  BCF    09.0
....................      
....................    delay_ms(15); 
018A:  MOVLW  0F
018B:  BCF    03.5
018C:  MOVWF  46
018D:  CALL   0A9
....................    for(i=1;i<=3;++i) 
018E:  MOVLW  01
018F:  MOVWF  39
0190:  MOVF   39,W
0191:  SUBLW  03
0192:  BTFSS  03.0
0193:  GOTO   19C
....................    { 
....................        lcd_send_nibble(3); 
0194:  MOVLW  03
0195:  MOVWF  4D
0196:  CALL   0BD
....................        delay_ms(5); 
0197:  MOVLW  05
0198:  MOVWF  46
0199:  CALL   0A9
....................    } 
019A:  INCF   39,F
019B:  GOTO   190
....................     
....................    lcd_send_nibble(2); 
019C:  MOVLW  02
019D:  MOVWF  4D
019E:  CALL   0BD
....................    for(i=0;i<=3;++i) 
019F:  CLRF   39
01A0:  MOVF   39,W
01A1:  SUBLW  03
01A2:  BTFSS  03.0
01A3:  GOTO   1AD
....................       lcd_send_byte(0,LCD_INIT_STRING[i]); 
01A4:  MOVF   39,W
01A5:  CALL   038
01A6:  MOVWF  3A
01A7:  CLRF   4A
01A8:  MOVF   3A,W
01A9:  MOVWF  4B
01AA:  CALL   11A
....................  
....................   #if defined(LCD_EXTENDED_NEWLINE) 
01AB:  INCF   39,F
01AC:  GOTO   1A0
....................    g_LcdX = 0; 
....................    g_LcdY = 0; 
....................   #endif 
.................... } 
01AD:  BSF    0A.3
01AE:  BCF    0A.4
01AF:  GOTO   0B3 (RETURN)
....................  
.................... void lcd_gotoxy(BYTE x, BYTE y) 
.................... { 
....................    BYTE address; 
....................     
....................    if(y!=1) 
01B0:  DECFSZ 47,W
01B1:  GOTO   1B3
01B2:  GOTO   1B6
....................       address=LCD_LINE_TWO; 
01B3:  MOVLW  40
01B4:  MOVWF  48
....................    else 
01B5:  GOTO   1B7
....................       address=0; 
01B6:  CLRF   48
....................       
....................    address+=x-1; 
01B7:  MOVLW  01
01B8:  SUBWF  46,W
01B9:  ADDWF  48,F
....................    lcd_send_byte(0,0x80|address); 
01BA:  MOVF   48,W
01BB:  IORLW  80
01BC:  MOVWF  49
01BD:  CLRF   4A
01BE:  MOVF   49,W
01BF:  MOVWF  4B
01C0:  CALL   11A
....................  
....................   #if defined(LCD_EXTENDED_NEWLINE) 
....................    g_LcdX = x - 1; 
....................    g_LcdY = y - 1; 
....................   #endif 
.................... } 
01C1:  RETURN
....................  
.................... void lcd_putc(char c) 
.................... { 
....................    switch (c) 
....................    { 
01C2:  MOVF   45,W
01C3:  XORLW  07
01C4:  BTFSC  03.2
01C5:  GOTO   1D0
01C6:  XORLW  0B
01C7:  BTFSC  03.2
01C8:  GOTO   1D5
01C9:  XORLW  06
01CA:  BTFSC  03.2
01CB:  GOTO   1DD
01CC:  XORLW  02
01CD:  BTFSC  03.2
01CE:  GOTO   1E3
01CF:  GOTO   1E8
....................       case '\a'   :  lcd_gotoxy(1,1);     break; 
01D0:  MOVLW  01
01D1:  MOVWF  46
01D2:  MOVWF  47
01D3:  CALL   1B0
01D4:  GOTO   1EE
....................  
....................       case '\f'   :  lcd_send_byte(0,1); 
01D5:  CLRF   4A
01D6:  MOVLW  01
01D7:  MOVWF  4B
01D8:  CALL   11A
....................                      delay_ms(2); 
01D9:  MOVLW  02
01DA:  MOVWF  46
01DB:  CALL   0A9
....................                     #if defined(LCD_EXTENDED_NEWLINE) 
....................                      g_LcdX = 0; 
....................                      g_LcdY = 0; 
....................                     #endif 
....................                      break; 
01DC:  GOTO   1EE
....................  
....................      #if defined(LCD_EXTENDED_NEWLINE) 
....................       case '\r'   :  lcd_gotoxy(1, g_LcdY+1);   break; 
....................       case '\n'   : 
....................          while (g_LcdX++ < LCD_LINE_LENGTH) 
....................          { 
....................             lcd_send_byte(1, ' '); 
....................          } 
....................          lcd_gotoxy(1, g_LcdY+2); 
....................          break; 
....................      #else 
....................       case '\n'   : lcd_gotoxy(1,2);        break; 
01DD:  MOVLW  01
01DE:  MOVWF  46
01DF:  MOVLW  02
01E0:  MOVWF  47
01E1:  CALL   1B0
01E2:  GOTO   1EE
....................      #endif 
....................       
....................       case '\b'   : lcd_send_byte(0,0x10);  break; 
01E3:  CLRF   4A
01E4:  MOVLW  10
01E5:  MOVWF  4B
01E6:  CALL   11A
01E7:  GOTO   1EE
....................       
....................      #if defined(LCD_EXTENDED_NEWLINE) 
....................       default     :  
....................          if (g_LcdX < LCD_LINE_LENGTH) 
....................          { 
....................             lcd_send_byte(1, c); 
....................             g_LcdX++; 
....................          } 
....................          break; 
....................      #else 
....................       default     : lcd_send_byte(1,c);     break; 
01E8:  MOVLW  01
01E9:  MOVWF  4A
01EA:  MOVF   45,W
01EB:  MOVWF  4B
01EC:  CALL   11A
01ED:  GOTO   1EE
....................      #endif 
....................    } 
.................... } 
01EE:  RETURN
....................   
.................... 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); 
.................... } 
....................  
....................  
....................  
.................... unsigned int32 pulse_count=0; 
.................... unsigned int16 overflow_count=0; 
.................... unsigned int16 time_overflow_count=0; 
....................  
....................  
.................... #int_RTCC 
.................... void  RTCC_isr(void)  
.................... { 
....................    time_overflow_count++; 
*
0040:  INCF   2D,F
0041:  BTFSC  03.2
0042:  INCF   2E,F
.................... } 
....................  
0043:  BCF    0B.2
0044:  BCF    0A.3
0045:  BCF    0A.4
0046:  GOTO   021
.................... #int_TIMER1 
.................... void  TIMER1_isr(void)  
.................... { 
....................    overflow_count++; 
0047:  INCF   2B,F
0048:  BTFSC  03.2
0049:  INCF   2C,F
....................    output_toggle(LED3); 
004A:  BCF    2F.4
004B:  MOVF   2F,W
004C:  BSF    03.5
004D:  MOVWF  07
004E:  MOVLW  10
004F:  BCF    03.5
0050:  XORWF  07,F
....................    output_toggle(BEEP); 
0051:  BSF    03.5
0052:  BCF    08.2
0053:  MOVLW  04
0054:  BCF    03.5
0055:  XORWF  08,F
.................... } 
....................  
0056:  BCF    0C.0
0057:  BCF    0A.3
0058:  BCF    0A.4
0059:  GOTO   021
.................... void sound_beep( unsigned int lenght, int16 frequency) 
.................... { 
.................... unsigned int i; 
....................     
....................    for(i=0;i<=lenght;i++) 
*
060D:  CLRF   3C
060E:  MOVF   3C,W
060F:  SUBWF  39,W
0610:  BTFSS  03.0
0611:  GOTO   655
....................    { 
....................       output_toggle(BEEP); 
0612:  BSF    03.5
0613:  BCF    08.2
0614:  MOVLW  04
0615:  BCF    03.5
0616:  XORWF  08,F
....................       delay_us(1/frequency); 
0617:  CLRF   3E
0618:  MOVLW  01
0619:  MOVWF  3D
061A:  MOVF   3B,W
061B:  MOVWF  40
061C:  MOVF   3A,W
061D:  MOVWF  3F
*
0642:  MOVF   79,W
0643:  MOVWF  3E
0644:  MOVF   78,W
0645:  MOVWF  3D
0646:  MOVF   3E,W
0647:  MOVWF  3F
0648:  INCF   3F,F
0649:  DECF   3F,F
064A:  BTFSC  03.2
064B:  GOTO   650
064C:  MOVLW  FF
064D:  MOVWF  40
064E:  CALL   5FC
064F:  GOTO   649
0650:  MOVF   3D,W
0651:  MOVWF  40
0652:  CALL   5FC
....................    } 
0653:  INCF   3C,F
0654:  GOTO   60E
.................... } 
0655:  RETURN
....................  
.................... void main() 
.................... { 
*
0800:  CLRF   04
0801:  BCF    03.7
0802:  MOVLW  1F
0803:  ANDWF  03,F
0804:  MOVLW  71
0805:  BSF    03.5
0806:  MOVWF  0F
0807:  MOVF   0F,W
0808:  BCF    06.7
0809:  BCF    03.5
080A:  BSF    06.7
080B:  CLRF   2A
080C:  CLRF   29
080D:  CLRF   28
080E:  CLRF   27
080F:  CLRF   2C
0810:  CLRF   2B
0811:  CLRF   2E
0812:  CLRF   2D
0813:  BSF    03.5
0814:  BSF    03.6
0815:  MOVF   09,W
0816:  ANDLW  C0
0817:  MOVWF  09
0818:  BCF    03.6
0819:  BCF    1F.4
081A:  BCF    1F.5
081B:  MOVLW  00
081C:  BSF    03.6
081D:  MOVWF  08
081E:  BCF    03.5
081F:  CLRF   07
0820:  CLRF   08
0821:  CLRF   09
*
0825:  CLRF   31
0826:  MOVLW  3C
0827:  MOVWF  30
0828:  CLRF   38
0829:  CLRF   37
.................... unsigned int16 integration_time=60; 
.................... unsigned int16 time; 
.................... unsigned int16 last_timer; // promena pro praskani 
.................... unsigned int1  button_press,voltage_setup,time_setup;  // semafor pro cteni tlacitek 
.................... unsigned int16 measurement_number=0; 
....................  
....................    setup_adc_ports(sAN0|VSS_VDD); 
082A:  BSF    03.5
082B:  BSF    03.6
082C:  MOVF   09,W
082D:  ANDLW  C0
082E:  MOVWF  09
082F:  BCF    03.6
0830:  BCF    1F.4
0831:  BCF    1F.5
0832:  MOVLW  01
0833:  BSF    03.6
0834:  MOVWF  08
....................    setup_adc(ADC_CLOCK_DIV_32); 
0835:  BCF    03.5
0836:  BCF    03.6
0837:  BCF    1F.6
0838:  BSF    1F.7
0839:  BSF    03.5
083A:  BSF    1F.7
083B:  BCF    03.5
083C:  BSF    1F.0
....................    setup_spi(SPI_SS_DISABLED); 
083D:  BCF    14.5
083E:  BCF    2F.5
083F:  MOVF   2F,W
0840:  BSF    03.5
0841:  MOVWF  07
0842:  BCF    03.5
0843:  BSF    2F.4
0844:  MOVF   2F,W
0845:  BSF    03.5
0846:  MOVWF  07
0847:  BCF    03.5
0848:  BCF    2F.3
0849:  MOVF   2F,W
084A:  BSF    03.5
084B:  MOVWF  07
084C:  MOVLW  01
084D:  BCF    03.5
084E:  MOVWF  14
084F:  MOVLW  00
0850:  BSF    03.5
0851:  MOVWF  14
....................    setup_timer_0(RTCC_INTERNAL|RTCC_DIV_256); 
0852:  MOVF   01,W
0853:  ANDLW  C0
0854:  IORLW  07
0855:  MOVWF  01
....................    setup_timer_1(T1_EXTERNAL|T1_DIV_BY_1); 
0856:  MOVLW  07
0857:  BCF    03.5
0858:  MOVWF  10
....................    setup_timer_2(T2_DISABLED,0,1); 
0859:  MOVLW  00
085A:  MOVWF  78
085B:  MOVWF  12
085C:  MOVLW  00
085D:  BSF    03.5
085E:  MOVWF  12
....................    setup_ccp1(CCP_PWM); 
085F:  BCF    03.5
0860:  BCF    2F.2
0861:  MOVF   2F,W
0862:  BSF    03.5
0863:  MOVWF  07
0864:  BCF    03.5
0865:  BCF    07.2
0866:  BSF    03.5
0867:  BCF    09.6
0868:  MOVLW  0C
0869:  BCF    03.5
086A:  MOVWF  17
086B:  BSF    03.5
086C:  CLRF   1B
086D:  CLRF   1C
086E:  MOVLW  01
086F:  MOVWF  1D
....................    setup_ccp2(CCP_PWM); 
0870:  BCF    03.5
0871:  BCF    2F.1
0872:  MOVF   2F,W
0873:  BSF    03.5
0874:  MOVWF  07
0875:  BCF    03.5
0876:  BCF    07.1
0877:  MOVLW  0C
0878:  MOVWF  1D
0879:  MOVLW  01
087A:  MOVWF  00
....................    setup_oscillator(OSC_8MHZ); 
087B:  MOVLW  71
087C:  BSF    03.5
087D:  MOVWF  0F
087E:  MOVF   0F,W
....................  
....................    set_pwm1_duty(0); 
087F:  BCF    03.5
0880:  CLRF   15
....................    set_pwm2_duty(0); 
0881:  CLRF   1B
....................  
....................    output_high(LED1); 
0882:  BCF    2F.6
0883:  MOVF   2F,W
0884:  BSF    03.5
0885:  MOVWF  07
0886:  BCF    03.5
0887:  BSF    07.6
....................    output_high(LED2); 
0888:  BCF    2F.5
0889:  MOVF   2F,W
088A:  BSF    03.5
088B:  MOVWF  07
088C:  BCF    03.5
088D:  BSF    07.5
....................    output_high(LED3); 
088E:  BCF    2F.4
088F:  MOVF   2F,W
0890:  BSF    03.5
0891:  MOVWF  07
0892:  BCF    03.5
0893:  BSF    07.4
....................    output_high(LED4); 
0894:  BSF    03.5
0895:  BCF    08.3
0896:  BCF    03.5
0897:  BSF    08.3
....................    output_low(BEEP); 
0898:  BSF    03.5
0899:  BCF    08.2
089A:  BCF    03.5
089B:  BCF    08.2
....................  
....................    setup_comparator(CP2_A0_VREF|CP2_OUT_ON_A5);  // sets two comparators(A1 and VR and A2 as the output) 
089C:  BSF    03.6
089D:  CLRF   07
089E:  MOVLW  A4
089F:  MOVWF  08
08A0:  MOVLW  10
08A1:  MOVWF  09
08A2:  BSF    03.5
08A3:  BCF    03.6
08A4:  BCF    05.5
08A5:  BSF    05.0
....................    setup_vref(VREF_HIGH|6);   //sets 3.6(vdd *value/32 +vdd/4) if vdd is 5.0V 
08A6:  MOVLW  86
08A7:  MOVWF  17
....................    enable_interrupts(INT_COMP);  //enables the comparator interrupt 
08A8:  BSF    0D.5
....................    enable_interrupts(INT_RTCC); 
08A9:  BCF    03.5
08AA:  BSF    0B.5
....................    enable_interrupts(INT_TIMER1); 
08AB:  BSF    03.5
08AC:  BSF    0C.0
....................    enable_interrupts(INT_TIMER2); 
08AD:  BSF    0C.1
....................    enable_interrupts(GLOBAL); 
08AE:  MOVLW  C0
08AF:  BCF    03.5
08B0:  IORWF  0B,F
....................    lcd_init(); 
08B1:  BCF    0A.3
08B2:  GOTO   176
08B3:  BSF    0A.3
....................  
....................    lcd_putc("\fGM counter V1.0 \n   2013 MLAB"); 
08B4:  MOVLW  5A
08B5:  BSF    03.6
08B6:  MOVWF  0D
08B7:  MOVLW  00
08B8:  MOVWF  0F
08B9:  BCF    0A.3
08BA:  BCF    03.6
08BB:  CALL   1EF
08BC:  BSF    0A.3
....................    printf("Geiger-Muller Counter V1.0 \r\n"); 
08BD:  MOVLW  6A
08BE:  BSF    03.6
08BF:  MOVWF  0D
08C0:  MOVLW  00
08C1:  MOVWF  0F
08C2:  BCF    0A.3
08C3:  BCF    03.6
08C4:  CALL   257
08C5:  BSF    0A.3
....................    printf("(c) 2013 MLAB and UST.cz \r\n"); 
08C6:  MOVLW  79
08C7:  BSF    03.6
08C8:  MOVWF  0D
08C9:  MOVLW  00
08CA:  MOVWF  0F
08CB:  BCF    0A.3
08CC:  BCF    03.6
08CD:  CALL   257
08CE:  BSF    0A.3
....................    Delay_ms(1000); 
08CF:  MOVLW  04
08D0:  MOVWF  39
08D1:  MOVLW  FA
08D2:  MOVWF  46
08D3:  BCF    0A.3
08D4:  CALL   0A9
08D5:  BSF    0A.3
08D6:  DECFSZ 39,F
08D7:  GOTO   0D1
....................     
....................    lcd_putc("\f"); 
08D8:  MOVLW  87
08D9:  BSF    03.6
08DA:  MOVWF  0D
08DB:  MOVLW  00
08DC:  MOVWF  0F
08DD:  BCF    0A.3
08DE:  BCF    03.6
08DF:  CALL   1EF
08E0:  BSF    0A.3
....................    printf("\r\n"); 
08E1:  MOVLW  0D
08E2:  MOVWF  45
08E3:  BCF    0A.3
08E4:  CALL   235
08E5:  BSF    0A.3
08E6:  MOVLW  0A
08E7:  MOVWF  45
08E8:  BCF    0A.3
08E9:  CALL   235
08EA:  BSF    0A.3
....................     
....................    set_timer1(0); 
08EB:  CLRF   0F
08EC:  CLRF   0E
....................  
....................    lcd_gotoxy(1,1);     // vypsani hodnoty count, abz byla na LCD hned od zapnuti  
08ED:  MOVLW  01
08EE:  MOVWF  46
08EF:  MOVWF  47
08F0:  BCF    0A.3
08F1:  CALL   1B0
08F2:  BSF    0A.3
....................    printf(lcd_putc,"Count:%lu     ",pulse_count); 
08F3:  MOVLW  88
08F4:  BSF    03.6
08F5:  MOVWF  0D
08F6:  MOVLW  00
08F7:  MOVWF  0F
08F8:  BCF    03.0
08F9:  MOVLW  06
08FA:  BCF    03.6
08FB:  MOVWF  39
08FC:  BCF    0A.3
08FD:  CALL   29D
08FE:  BSF    0A.3
08FF:  MOVLW  41
0900:  MOVWF  04
0901:  MOVF   2A,W
0902:  MOVWF  3C
0903:  MOVF   29,W
0904:  MOVWF  3B
0905:  MOVF   28,W
0906:  MOVWF  3A
0907:  MOVF   27,W
0908:  MOVWF  39
0909:  BCF    0A.3
090A:  CALL   32E
090B:  BSF    0A.3
090C:  MOVLW  8C
090D:  BSF    03.6
090E:  MOVWF  0D
090F:  MOVLW  00
0910:  MOVWF  0F
0911:  BSF    03.0
0912:  MOVLW  05
0913:  BCF    03.6
0914:  MOVWF  39
0915:  BCF    0A.3
0916:  CALL   29D
0917:  BSF    0A.3
....................  
....................    while(true) 
....................    { 
....................       pulse_count = get_timer1() + (0xffff * overflow_count); // compute pulse count 
0918:  MOVF   0F,W
0919:  MOVWF  7A
091A:  MOVF   0E,W
091B:  MOVWF  77
091C:  MOVF   0F,W
091D:  SUBWF  7A,W
091E:  BTFSS  03.2
091F:  GOTO   118
0920:  MOVF   77,W
0921:  MOVWF  39
0922:  MOVF   7A,W
0923:  MOVWF  3A
0924:  MOVLW  FF
0925:  MOVWF  3C
0926:  MOVWF  3B
0927:  MOVF   2C,W
0928:  MOVWF  3E
0929:  MOVF   2B,W
092A:  MOVWF  3D
092B:  BCF    0A.3
092C:  GOTO   38A
092D:  BSF    0A.3
092E:  MOVF   79,W
092F:  MOVWF  7A
0930:  MOVF   78,W
0931:  ADDWF  39,W
0932:  MOVWF  27
0933:  MOVF   3A,W
0934:  MOVWF  28
0935:  MOVF   7A,W
0936:  BTFSC  03.0
0937:  INCFSZ 7A,W
0938:  ADDWF  28,F
0939:  CLRF   29
093A:  CLRF   2A
....................       time = integration_time + 1 - (time_overflow_count * 0.0327); // compute time interval 
093B:  MOVLW  01
093C:  ADDWF  30,W
093D:  MOVWF  39
093E:  MOVF   31,W
093F:  MOVWF  3A
0940:  BTFSC  03.0
0941:  INCF   3A,F
0942:  MOVF   2E,W
0943:  MOVWF  40
0944:  MOVF   2D,W
0945:  MOVWF  3F
0946:  BCF    0A.3
0947:  CALL   3A1
0948:  BSF    0A.3
0949:  MOVF   7A,W
094A:  MOVWF  3E
094B:  MOVF   79,W
094C:  MOVWF  3D
094D:  MOVF   78,W
094E:  MOVWF  3C
094F:  MOVF   77,W
0950:  MOVWF  3B
0951:  MOVLW  6F
0952:  MOVWF  42
0953:  MOVLW  F0
0954:  MOVWF  41
0955:  MOVLW  05
0956:  MOVWF  40
0957:  MOVLW  7A
0958:  MOVWF  3F
0959:  BCF    0A.3
095A:  GOTO   3BE
095B:  BSF    0A.3
095C:  MOVF   77,W
095D:  MOVWF  3B
095E:  MOVF   78,W
095F:  MOVWF  3C
0960:  MOVF   79,W
0961:  MOVWF  3D
0962:  MOVF   7A,W
0963:  MOVWF  3E
0964:  MOVF   3A,W
0965:  MOVWF  40
0966:  MOVF   39,W
0967:  MOVWF  3F
0968:  BCF    0A.3
0969:  CALL   3A1
096A:  BSF    0A.3
096B:  BSF    03.1
096C:  MOVF   7A,W
096D:  MOVWF  42
096E:  MOVF   79,W
096F:  MOVWF  41
0970:  MOVF   78,W
0971:  MOVWF  40
0972:  MOVF   77,W
0973:  MOVWF  3F
0974:  MOVF   3E,W
0975:  MOVWF  46
0976:  MOVF   3D,W
0977:  MOVWF  45
0978:  MOVF   3C,W
0979:  MOVWF  44
097A:  MOVF   3B,W
097B:  MOVWF  43
097C:  BCF    0A.3
097D:  GOTO   435
097E:  BSF    0A.3
097F:  MOVF   7A,W
0980:  MOVWF  42
0981:  MOVF   79,W
0982:  MOVWF  41
0983:  MOVF   78,W
0984:  MOVWF  40
0985:  MOVF   77,W
0986:  MOVWF  3F
0987:  BCF    0A.3
0988:  GOTO   578
0989:  BSF    0A.3
098A:  MOVF   79,W
098B:  MOVWF  33
098C:  MOVF   78,W
098D:  MOVWF  32
....................        
....................       if(get_timer1() != last_timer)  // timer count increment detection 
098E:  MOVF   0F,W
098F:  MOVWF  7A
0990:  MOVF   0E,W
0991:  MOVWF  77
0992:  MOVF   0F,W
0993:  SUBWF  7A,W
0994:  BTFSS  03.2
0995:  GOTO   18E
0996:  MOVF   77,W
0997:  MOVWF  39
0998:  MOVF   7A,W
0999:  MOVWF  3A
099A:  MOVF   34,W
099B:  SUBWF  39,W
099C:  BTFSS  03.2
099D:  GOTO   1A2
099E:  MOVF   35,W
099F:  SUBWF  3A,W
09A0:  BTFSC  03.2
09A1:  GOTO   1EF
....................       { 
....................          output_toggle(BEEP); 
09A2:  BSF    03.5
09A3:  BCF    08.2
09A4:  MOVLW  04
09A5:  BCF    03.5
09A6:  XORWF  08,F
....................          delay_ms(1); 
09A7:  MOVLW  01
09A8:  MOVWF  46
09A9:  BCF    0A.3
09AA:  CALL   0A9
09AB:  BSF    0A.3
....................          output_toggle(BEEP); 
09AC:  BSF    03.5
09AD:  BCF    08.2
09AE:  MOVLW  04
09AF:  BCF    03.5
09B0:  XORWF  08,F
....................          output_toggle(LED3); 
09B1:  BCF    2F.4
09B2:  MOVF   2F,W
09B3:  BSF    03.5
09B4:  MOVWF  07
09B5:  MOVLW  10
09B6:  BCF    03.5
09B7:  XORWF  07,F
....................          last_timer=get_timer1(); 
09B8:  MOVF   0F,W
09B9:  MOVWF  7A
09BA:  MOVF   0E,W
09BB:  MOVWF  77
09BC:  MOVF   0F,W
09BD:  SUBWF  7A,W
09BE:  BTFSS  03.2
09BF:  GOTO   1B8
09C0:  MOVF   77,W
09C1:  MOVWF  34
09C2:  MOVF   7A,W
09C3:  MOVWF  35
....................          lcd_gotoxy(1,1);     // prepsani dat na displeje  
09C4:  MOVLW  01
09C5:  MOVWF  46
09C6:  MOVWF  47
09C7:  BCF    0A.3
09C8:  CALL   1B0
09C9:  BSF    0A.3
....................          printf(lcd_putc,"Count:%lu     ",pulse_count); 
09CA:  MOVLW  90
09CB:  BSF    03.6
09CC:  MOVWF  0D
09CD:  MOVLW  00
09CE:  MOVWF  0F
09CF:  BCF    03.0
09D0:  MOVLW  06
09D1:  BCF    03.6
09D2:  MOVWF  39
09D3:  BCF    0A.3
09D4:  CALL   29D
09D5:  BSF    0A.3
09D6:  MOVLW  41
09D7:  MOVWF  04
09D8:  MOVF   2A,W
09D9:  MOVWF  3C
09DA:  MOVF   29,W
09DB:  MOVWF  3B
09DC:  MOVF   28,W
09DD:  MOVWF  3A
09DE:  MOVF   27,W
09DF:  MOVWF  39
09E0:  BCF    0A.3
09E1:  CALL   32E
09E2:  BSF    0A.3
09E3:  MOVLW  94
09E4:  BSF    03.6
09E5:  MOVWF  0D
09E6:  MOVLW  00
09E7:  MOVWF  0F
09E8:  BSF    03.0
09E9:  MOVLW  05
09EA:  BCF    03.6
09EB:  MOVWF  39
09EC:  BCF    0A.3
09ED:  CALL   29D
09EE:  BSF    0A.3
....................       } 
....................        
....................       lcd_gotoxy(1,2); 
09EF:  MOVLW  01
09F0:  MOVWF  46
09F1:  MOVLW  02
09F2:  MOVWF  47
09F3:  BCF    0A.3
09F4:  CALL   1B0
09F5:  BSF    0A.3
....................       printf(lcd_putc,"T:%lu   ",time); 
09F6:  MOVLW  54
09F7:  MOVWF  45
09F8:  BCF    0A.3
09F9:  CALL   1C2
09FA:  BSF    0A.3
09FB:  MOVLW  3A
09FC:  MOVWF  45
09FD:  BCF    0A.3
09FE:  CALL   1C2
09FF:  BSF    0A.3
0A00:  MOVLW  10
0A01:  MOVWF  04
0A02:  MOVF   33,W
0A03:  MOVWF  3A
0A04:  MOVF   32,W
0A05:  MOVWF  39
0A06:  BCF    0A.3
0A07:  CALL   599
0A08:  BSF    0A.3
0A09:  MOVLW  20
0A0A:  MOVWF  45
0A0B:  BCF    0A.3
0A0C:  CALL   1C2
0A0D:  BSF    0A.3
0A0E:  MOVLW  20
0A0F:  MOVWF  45
0A10:  BCF    0A.3
0A11:  CALL   1C2
0A12:  BSF    0A.3
0A13:  MOVLW  20
0A14:  MOVWF  45
0A15:  BCF    0A.3
0A16:  CALL   1C2
0A17:  BSF    0A.3
....................       lcd_gotoxy(9,2); 
0A18:  MOVLW  09
0A19:  MOVWF  46
0A1A:  MOVLW  02
0A1B:  MOVWF  47
0A1C:  BCF    0A.3
0A1D:  CALL   1B0
0A1E:  BSF    0A.3
....................       printf(lcd_putc,"I:%lu    ", integration_time); 
0A1F:  MOVLW  49
0A20:  MOVWF  45
0A21:  BCF    0A.3
0A22:  CALL   1C2
0A23:  BSF    0A.3
0A24:  MOVLW  3A
0A25:  MOVWF  45
0A26:  BCF    0A.3
0A27:  CALL   1C2
0A28:  BSF    0A.3
0A29:  MOVLW  10
0A2A:  MOVWF  04
0A2B:  MOVF   31,W
0A2C:  MOVWF  3A
0A2D:  MOVF   30,W
0A2E:  MOVWF  39
0A2F:  BCF    0A.3
0A30:  CALL   599
0A31:  BSF    0A.3
0A32:  MOVLW  9A
0A33:  BSF    03.6
0A34:  MOVWF  0D
0A35:  MOVLW  00
0A36:  MOVWF  0F
0A37:  BSF    03.0
0A38:  MOVLW  04
0A39:  BCF    03.6
0A3A:  MOVWF  39
0A3B:  BCF    0A.3
0A3C:  CALL   29D
0A3D:  BSF    0A.3
....................  
....................       if(time == 0)     // po uplynuti mereneho intervalu  vypis na seriovku   
0A3E:  MOVF   32,F
0A3F:  BTFSS  03.2
0A40:  GOTO   298
0A41:  MOVF   33,F
0A42:  BTFSS  03.2
0A43:  GOTO   298
....................       { 
....................          set_timer0(0); 
0A44:  CLRF   01
....................          time_overflow_count=0; 
0A45:  CLRF   2E
0A46:  CLRF   2D
....................          sound_beep(1000,700); 
0A47:  MOVLW  E8
0A48:  MOVWF  39
0A49:  MOVLW  02
0A4A:  MOVWF  3B
0A4B:  MOVLW  BC
0A4C:  MOVWF  3A
0A4D:  BCF    0A.3
0A4E:  CALL   60D
0A4F:  BSF    0A.3
....................          printf("$GMC1.0 %lu %lu %lu  \r\n", measurement_number, integration_time, pulse_count); 
0A50:  MOVLW  9D
0A51:  BSF    03.6
0A52:  MOVWF  0D
0A53:  MOVLW  00
0A54:  MOVWF  0F
0A55:  BCF    03.0
0A56:  MOVLW  08
0A57:  BCF    03.6
0A58:  MOVWF  39
0A59:  BCF    0A.3
0A5A:  CALL   656
0A5B:  BSF    0A.3
0A5C:  MOVLW  10
0A5D:  MOVWF  04
0A5E:  MOVF   38,W
0A5F:  MOVWF  3A
0A60:  MOVF   37,W
0A61:  MOVWF  39
0A62:  BCF    0A.3
0A63:  CALL   6A5
0A64:  BSF    0A.3
0A65:  MOVLW  20
0A66:  MOVWF  45
0A67:  BCF    0A.3
0A68:  CALL   235
0A69:  BSF    0A.3
0A6A:  MOVLW  10
0A6B:  MOVWF  04
0A6C:  MOVF   31,W
0A6D:  MOVWF  3A
0A6E:  MOVF   30,W
0A6F:  MOVWF  39
0A70:  BCF    0A.3
0A71:  CALL   6A5
0A72:  BSF    0A.3
0A73:  MOVLW  20
0A74:  MOVWF  45
0A75:  BCF    0A.3
0A76:  CALL   235
0A77:  BSF    0A.3
0A78:  MOVLW  41
0A79:  MOVWF  04
0A7A:  MOVF   2A,W
0A7B:  MOVWF  3C
0A7C:  MOVF   29,W
0A7D:  MOVWF  3B
0A7E:  MOVF   28,W
0A7F:  MOVWF  3A
0A80:  MOVF   27,W
0A81:  MOVWF  39
0A82:  BCF    0A.3
0A83:  GOTO   708
0A84:  BSF    0A.3
0A85:  MOVLW  A6
0A86:  BSF    03.6
0A87:  MOVWF  0D
0A88:  MOVLW  00
0A89:  MOVWF  0F
0A8A:  BSF    03.0
0A8B:  MOVLW  04
0A8C:  BCF    03.6
0A8D:  MOVWF  39
0A8E:  BCF    0A.3
0A8F:  CALL   656
0A90:  BSF    0A.3
....................          set_timer1(0); 
0A91:  CLRF   0F
0A92:  CLRF   0E
....................          overflow_count=0; 
0A93:  CLRF   2C
0A94:  CLRF   2B
....................          measurement_number++; 
0A95:  INCF   37,F
0A96:  BTFSC  03.2
0A97:  INCF   38,F
....................       } 
....................  
....................       if(button_press==false ) // tlacitka se ctou znovu pouze pokud v redchozim cyklu nebyla zmacknuta. 
0A98:  BTFSC  36.0
0A99:  GOTO   37E
....................       { 
....................          if(!input(S1)) 
0A9A:  BSF    2F.2
0A9B:  MOVF   2F,W
0A9C:  BSF    03.5
0A9D:  MOVWF  07
0A9E:  BCF    03.5
0A9F:  BTFSC  07.2
0AA0:  GOTO   2C7
....................          { 
....................             delay_ms(20); 
0AA1:  MOVLW  14
0AA2:  MOVWF  46
0AA3:  BCF    0A.3
0AA4:  CALL   0A9
0AA5:  BSF    0A.3
....................             if(!input(S1)) 
0AA6:  BSF    2F.2
0AA7:  MOVF   2F,W
0AA8:  BSF    03.5
0AA9:  MOVWF  07
0AAA:  BCF    03.5
0AAB:  BTFSC  07.2
0AAC:  GOTO   2C7
....................             { 
....................                button_press=true; 
0AAD:  BSF    36.0
....................                if(time_setup==TRUE) 
0AAE:  BTFSS  36.2
0AAF:  GOTO   2C7
....................                { 
....................                   sound_beep(100,700); 
0AB0:  MOVLW  64
0AB1:  MOVWF  39
0AB2:  MOVLW  02
0AB3:  MOVWF  3B
0AB4:  MOVLW  BC
0AB5:  MOVWF  3A
0AB6:  BCF    0A.3
0AB7:  CALL   60D
0AB8:  BSF    0A.3
....................                   if(integration_time < 0xfffa ) integration_time+=5; 
0AB9:  MOVF   31,W
0ABA:  SUBLW  FF
0ABB:  BTFSS  03.0
0ABC:  GOTO   2C7
0ABD:  BTFSS  03.2
0ABE:  GOTO   2C3
0ABF:  MOVF   30,W
0AC0:  SUBLW  F9
0AC1:  BTFSS  03.0
0AC2:  GOTO   2C7
0AC3:  MOVLW  05
0AC4:  ADDWF  30,F
0AC5:  BTFSC  03.0
0AC6:  INCF   31,F
....................                } 
....................             } 
....................          } 
....................  
....................          if(!input(S2)) 
0AC7:  BSF    2F.3
0AC8:  MOVF   2F,W
0AC9:  BSF    03.5
0ACA:  MOVWF  07
0ACB:  BCF    03.5
0ACC:  BTFSC  07.3
0ACD:  GOTO   2FA
....................          { 
....................             delay_ms(20); 
0ACE:  MOVLW  14
0ACF:  MOVWF  46
0AD0:  BCF    0A.3
0AD1:  CALL   0A9
0AD2:  BSF    0A.3
....................             if(!input(S2)) 
0AD3:  BSF    2F.3
0AD4:  MOVF   2F,W
0AD5:  BSF    03.5
0AD6:  MOVWF  07
0AD7:  BCF    03.5
0AD8:  BTFSC  07.3
0AD9:  GOTO   2FA
....................             { 
....................                button_press=true; 
0ADA:  BSF    36.0
....................                if(time_setup==TRUE) 
0ADB:  BTFSS  36.2
0ADC:  GOTO   2FA
....................                { 
....................                   sound_beep(100,600); 
0ADD:  MOVLW  64
0ADE:  MOVWF  39
0ADF:  MOVLW  02
0AE0:  MOVWF  3B
0AE1:  MOVLW  58
0AE2:  MOVWF  3A
0AE3:  BCF    0A.3
0AE4:  CALL   60D
0AE5:  BSF    0A.3
....................                   if(integration_time > 0x0005 ) integration_time-=5; 
0AE6:  MOVF   31,F
0AE7:  BTFSS  03.2
0AE8:  GOTO   2ED
0AE9:  MOVF   30,W
0AEA:  SUBLW  05
0AEB:  BTFSC  03.0
0AEC:  GOTO   2F3
0AED:  MOVLW  05
0AEE:  SUBWF  30,F
0AEF:  MOVLW  00
0AF0:  BTFSS  03.0
0AF1:  MOVLW  01
0AF2:  SUBWF  31,F
....................  
....................                   set_timer0(0);  // vynulovani pocitadel, kdyz uzivatel sahne na tlacitka 
0AF3:  CLRF   01
....................                   time_overflow_count=0;                
0AF4:  CLRF   2E
0AF5:  CLRF   2D
....................                   set_timer1(0); 
0AF6:  CLRF   0F
0AF7:  CLRF   0E
....................                   overflow_count=0; 
0AF8:  CLRF   2C
0AF9:  CLRF   2B
....................                } 
....................             } 
....................          } 
....................  
....................          if(!input(S3)) 
0AFA:  BSF    03.5
0AFB:  BSF    08.0
0AFC:  BCF    03.5
0AFD:  BTFSC  08.0
0AFE:  GOTO   31D
....................          { 
....................             delay_ms(20); 
0AFF:  MOVLW  14
0B00:  MOVWF  46
0B01:  BCF    0A.3
0B02:  CALL   0A9
0B03:  BSF    0A.3
....................             if(!input(S3)) 
0B04:  BSF    03.5
0B05:  BSF    08.0
0B06:  BCF    03.5
0B07:  BTFSC  08.0
0B08:  GOTO   31D
....................             { 
....................                button_press=true; 
0B09:  BSF    36.0
....................                if(time_setup==TRUE) 
0B0A:  BTFSS  36.2
0B0B:  GOTO   31D
....................                { 
....................                   sound_beep(100,500); 
0B0C:  MOVLW  64
0B0D:  MOVWF  39
0B0E:  MOVLW  01
0B0F:  MOVWF  3B
0B10:  MOVLW  F4
0B11:  MOVWF  3A
0B12:  BCF    0A.3
0B13:  CALL   60D
0B14:  BSF    0A.3
....................                   if(integration_time < 0xffff ) integration_time++; 
0B15:  INCFSZ 30,W
0B16:  GOTO   31A
0B17:  INCFSZ 31,W
0B18:  GOTO   31A
0B19:  GOTO   31D
0B1A:  INCF   30,F
0B1B:  BTFSC  03.2
0B1C:  INCF   31,F
....................                } 
....................             } 
....................          } 
....................  
....................          if(!input(S4)) 
0B1D:  BSF    03.5
0B1E:  BSF    08.1
0B1F:  BCF    03.5
0B20:  BTFSC  08.1
0B21:  GOTO   34A
....................          { 
....................             delay_ms(20); 
0B22:  MOVLW  14
0B23:  MOVWF  46
0B24:  BCF    0A.3
0B25:  CALL   0A9
0B26:  BSF    0A.3
....................             if(!input(S4)) 
0B27:  BSF    03.5
0B28:  BSF    08.1
0B29:  BCF    03.5
0B2A:  BTFSC  08.1
0B2B:  GOTO   34A
....................             { 
....................                button_press=true; 
0B2C:  BSF    36.0
....................                if(time_setup==TRUE) 
0B2D:  BTFSS  36.2
0B2E:  GOTO   34A
....................                { 
....................                   sound_beep(100,400); 
0B2F:  MOVLW  64
0B30:  MOVWF  39
0B31:  MOVLW  01
0B32:  MOVWF  3B
0B33:  MOVLW  90
0B34:  MOVWF  3A
0B35:  BCF    0A.3
0B36:  CALL   60D
0B37:  BSF    0A.3
....................                   if(integration_time > 0x0001 ) integration_time--; 
0B38:  MOVF   31,F
0B39:  BTFSS  03.2
0B3A:  GOTO   33F
0B3B:  MOVF   30,W
0B3C:  SUBLW  01
0B3D:  BTFSC  03.0
0B3E:  GOTO   343
0B3F:  MOVF   30,W
0B40:  BTFSC  03.2
0B41:  DECF   31,F
0B42:  DECF   30,F
....................  
....................                   set_timer0(0);  // vynulovani pocitadel, kdyz uzivatel sahne na tlacitka 
0B43:  CLRF   01
....................                   time_overflow_count=0;                
0B44:  CLRF   2E
0B45:  CLRF   2D
....................                   set_timer1(0); 
0B46:  CLRF   0F
0B47:  CLRF   0E
....................                   overflow_count=0; 
0B48:  CLRF   2C
0B49:  CLRF   2B
....................                } 
....................             } 
....................          } 
....................           
....................          if(!input(S5))    // prepnuti na  nastavovani casu 
0B4A:  BSF    03.5
0B4B:  BSF    06.1
0B4C:  BCF    03.5
0B4D:  BTFSC  06.1
0B4E:  GOTO   364
....................          { 
....................             delay_ms(20); 
0B4F:  MOVLW  14
0B50:  MOVWF  46
0B51:  BCF    0A.3
0B52:  CALL   0A9
0B53:  BSF    0A.3
....................             if(!input(S5)) 
0B54:  BSF    03.5
0B55:  BSF    06.1
0B56:  BCF    03.5
0B57:  BTFSC  06.1
0B58:  GOTO   364
....................             { 
....................               sound_beep(100,800); 
0B59:  MOVLW  64
0B5A:  MOVWF  39
0B5B:  MOVLW  03
0B5C:  MOVWF  3B
0B5D:  MOVLW  20
0B5E:  MOVWF  3A
0B5F:  BCF    0A.3
0B60:  CALL   60D
0B61:  BSF    0A.3
....................               voltage_setup=FALSE; 
0B62:  BCF    36.1
....................               time_setup=TRUE; 
0B63:  BSF    36.2
....................             } 
....................          } 
....................           
....................          if(!input(S6))    // prepnuti na nastavovani napeti 
0B64:  BSF    03.5
0B65:  BSF    06.2
0B66:  BCF    03.5
0B67:  BTFSC  06.2
0B68:  GOTO   37E
....................          { 
....................             delay_ms(20); 
0B69:  MOVLW  14
0B6A:  MOVWF  46
0B6B:  BCF    0A.3
0B6C:  CALL   0A9
0B6D:  BSF    0A.3
....................             if(!input(S6)) 
0B6E:  BSF    03.5
0B6F:  BSF    06.2
0B70:  BCF    03.5
0B71:  BTFSC  06.2
0B72:  GOTO   37E
....................             { 
....................               sound_beep(100,800); 
0B73:  MOVLW  64
0B74:  MOVWF  39
0B75:  MOVLW  03
0B76:  MOVWF  3B
0B77:  MOVLW  20
0B78:  MOVWF  3A
0B79:  BCF    0A.3
0B7A:  CALL   60D
0B7B:  BSF    0A.3
....................               voltage_setup=TRUE; 
0B7C:  BSF    36.1
....................               time_setup=FALSE; 
0B7D:  BCF    36.2
....................             } 
....................          } 
....................       } 
....................        
....................       if ( input(S1) && input(S2) && input(S3) && input(S4) && input(S5) && input(S6))  // detekce pustenych tlacitek  
0B7E:  BSF    2F.2
0B7F:  MOVF   2F,W
0B80:  BSF    03.5
0B81:  MOVWF  07
0B82:  BCF    03.5
0B83:  BTFSS  07.2
0B84:  GOTO   3A1
0B85:  BSF    2F.3
0B86:  MOVF   2F,W
0B87:  BSF    03.5
0B88:  MOVWF  07
0B89:  BCF    03.5
0B8A:  BTFSS  07.3
0B8B:  GOTO   3A1
0B8C:  BSF    03.5
0B8D:  BSF    08.0
0B8E:  BCF    03.5
0B8F:  BTFSS  08.0
0B90:  GOTO   3A1
0B91:  BSF    03.5
0B92:  BSF    08.1
0B93:  BCF    03.5
0B94:  BTFSS  08.1
0B95:  GOTO   3A1
0B96:  BSF    03.5
0B97:  BSF    06.1
0B98:  BCF    03.5
0B99:  BTFSS  06.1
0B9A:  GOTO   3A1
0B9B:  BSF    03.5
0B9C:  BSF    06.2
0B9D:  BCF    03.5
0B9E:  BTFSS  06.2
0B9F:  GOTO   3A1
....................       {  
....................          button_press=false; 
0BA0:  BCF    36.0
....................       } 
....................    } 
0BA1:  GOTO   118
.................... } 
0BA2:  SLEEP

Configuration Fuses:
   Word  1: 2CF5   INTRC NOWDT NOPUT MCLR NOPROTECT NOCPD NOBROWNOUT IESO FCMEN NOLVP NODEBUG
   Word  2: 3FFF   NOWRT BORV40