CCS PCH C Compiler, Version 5.048, 26145 26-Sep-22 12:18 Filename: C:\Users\soac-gj2\Desktop\Embedded C\project 2\proteus\PIC18F2525_1\Debug.lst ROM used: 2028 bytes (4%) Largest free fragment is 47120 RAM used: 38 (1%) at main() level 59 (1%) worst case Stack used: 6 locations (5 in main + 1 for interrupts) Stack size: 31 * 0000: GOTO 073E * 0008: MOVWF 04 000A: MOVFF FD8,05 000E: MOVFF FE0,06 0012: MOVLB 0 0014: MOVFF FE9,0C 0018: MOVFF FEA,07 001C: MOVFF FE1,08 0020: MOVFF FE2,09 0024: MOVFF FD9,0A 0028: MOVFF FDA,0B 002C: MOVFF FF3,12 0030: MOVFF FF4,13 0034: MOVFF FFA,14 0038: MOVFF FF5,15 003C: MOVFF FF6,16 0040: MOVFF FF7,17 0044: MOVFF 00,0E 0048: MOVFF 01,0F 004C: MOVFF 02,10 0050: MOVFF 03,11 0054: BTFSS F9D.1 0056: GOTO 0060 005A: BTFSC F9E.1 005C: GOTO 00AE 0060: MOVFF 0E,00 0064: MOVFF 0F,01 0068: MOVFF 10,02 006C: MOVFF 11,03 0070: MOVFF 0C,FE9 0074: MOVFF 07,FEA 0078: BSF 07.7 007A: MOVFF 08,FE1 007E: MOVFF 09,FE2 0082: MOVFF 0A,FD9 0086: MOVFF 0B,FDA 008A: MOVFF 12,FF3 008E: MOVFF 13,FF4 0092: MOVFF 14,FFA 0096: MOVFF 15,FF5 009A: MOVFF 16,FF6 009E: MOVFF 17,FF7 00A2: MOVF 04,W 00A4: MOVFF 06,FE0 00A8: MOVFF 05,FD8 00AC: RETFIE 0 .................... #import(file="main.o") .................... .................... #include .................... #include <18F2525.h> .................... //////////// Standard Header file for the PIC18F2525 device //////////////// .................... /////////////////////////////////////////////////////////////////////////// .................... //// (C) Copyright 1996, 2014 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. //// .................... /////////////////////////////////////////////////////////////////////////// .................... #device PIC18F2525 * 00D8: DATA 20,48 00DA: DATA 65,6C 00DC: DATA 6C,6F 00DE: DATA 20,57 00E0: DATA 6F,72 00E2: DATA 6C,64 00E4: DATA 20,25 00E6: DATA 33,4C 00E8: DATA 75,00 00EA: DATA 70,6F 00EC: DATA 74,3D 00EE: DATA 25,33 00F0: DATA 55,20 00F2: DATA 20,6C 00F4: DATA 69,74 00F6: DATA 3D,25 00F8: DATA 33,75 00FA: DATA 00,00 * 033C: TBLRD*+ 033E: MOVFF FF6,28 0342: MOVFF FF7,29 0346: MOVFF FF5,30 034A: RCALL 02EC 034C: MOVFF 28,FF6 0350: MOVFF 29,FF7 0354: DECFSZ 27,F 0356: BRA 033C 0358: RETURN 0 035A: MOVFF FEA,2F 035E: MOVFF FE9,2E 0362: SWAPF 28,W 0364: IORLW F0 0366: MOVWF 2A 0368: ADDWF 2A,F 036A: ADDLW E2 036C: MOVWF 2B 036E: ADDLW 32 0370: MOVWF 2D 0372: MOVF 28,W 0374: ANDLW 0F 0376: ADDWF 2B,F 0378: ADDWF 2B,F 037A: ADDWF 2D,F 037C: ADDLW E9 037E: MOVWF 2C 0380: ADDWF 2C,F 0382: ADDWF 2C,F 0384: SWAPF 27,W 0386: ANDLW 0F 0388: ADDWF 2C,F 038A: ADDWF 2D,F 038C: RLCF 2C,F 038E: RLCF 2D,F 0390: COMF 2D,F 0392: RLCF 2D,F 0394: MOVF 27,W 0396: ANDLW 0F 0398: ADDWF 2D,F 039A: RLCF 2A,F 039C: MOVLW 07 039E: MOVWF 29 03A0: MOVLW 0A 03A2: DECF 2C,F 03A4: ADDWF 2D,F 03A6: BNC 03A2 03A8: DECF 2B,F 03AA: ADDWF 2C,F 03AC: BNC 03A8 03AE: DECF 2A,F 03B0: ADDWF 2B,F 03B2: BNC 03AE 03B4: DECF 29,F 03B6: ADDWF 2A,F 03B8: BNC 03B4 03BA: CLRF FEA 03BC: MOVLW 29 03BE: MOVWF FE9 03C0: MOVLW 07 03C2: ANDWF 2E,W 03C4: BCF 2E.6 03C6: ADDWF FE9,F 03C8: MOVLW 00 03CA: ADDWFC FEA,F 03CC: MOVF FE9,W 03CE: SUBLW 2D 03D0: BNZ 03D8 03D2: MOVF FEA,F 03D4: BNZ 03D8 03D6: BSF 2E.6 03D8: MOVF FEF,W 03DA: MOVWF 00 03DC: BNZ 03EE 03DE: BTFSC 2E.6 03E0: BRA 03EE 03E2: BTFSC 2E.4 03E4: BRA 040C 03E6: BTFSC 2E.3 03E8: BRA 03EE 03EA: MOVLW 20 03EC: BRA 03F4 03EE: BSF 2E.3 03F0: BCF 2E.4 03F2: MOVLW 30 03F4: ADDWF 00,F 03F6: MOVFF FEA,28 03FA: MOVFF FE9,27 03FE: MOVFF 00,30 0402: RCALL 02EC 0404: MOVFF 28,FEA 0408: MOVFF 27,FE9 040C: MOVF FEE,W 040E: BTFSS 2E.6 0410: BRA 03CC 0412: RETURN 0 * 044C: BTFSC 27.7 044E: BRA 046E 0450: MOVLW 0F 0452: MOVWF 00 0454: SWAPF 26,W 0456: ANDWF 00,F 0458: MOVLW 0A 045A: SUBWF 00,W 045C: BC 0464 045E: MOVLW 30 0460: ADDWF 00,F 0462: BRA 0468 0464: MOVF 27,W 0466: ADDWF 00,F 0468: MOVFF 00,30 046C: RCALL 02EC 046E: MOVLW 0F 0470: ANDWF 26,F 0472: MOVLW 0A 0474: SUBWF 26,W 0476: BC 047C 0478: MOVLW 30 047A: BRA 0480 047C: BCF 27.7 047E: MOVF 27,W 0480: ADDWF 26,F 0482: MOVFF 26,30 0486: RCALL 02EC 0488: RETURN 0 048A: MOVFF FEA,2E 048E: MOVFF FE9,2D 0492: SWAPF 27,W 0494: IORLW F0 0496: MOVWF 29 0498: ADDWF 29,F 049A: ADDLW E2 049C: MOVWF 2A 049E: ADDLW 32 04A0: MOVWF 2C 04A2: MOVF 27,W 04A4: ANDLW 0F 04A6: ADDWF 2A,F 04A8: ADDWF 2A,F 04AA: ADDWF 2C,F 04AC: ADDLW E9 04AE: MOVWF 2B 04B0: ADDWF 2B,F 04B2: ADDWF 2B,F 04B4: SWAPF 26,W 04B6: ANDLW 0F 04B8: ADDWF 2B,F 04BA: ADDWF 2C,F 04BC: RLCF 2B,F 04BE: RLCF 2C,F 04C0: COMF 2C,F 04C2: RLCF 2C,F 04C4: MOVF 26,W 04C6: ANDLW 0F 04C8: ADDWF 2C,F 04CA: RLCF 29,F 04CC: MOVLW 07 04CE: MOVWF 28 04D0: MOVLW 0A 04D2: DECF 2B,F 04D4: ADDWF 2C,F 04D6: BNC 04D2 04D8: DECF 2A,F 04DA: ADDWF 2B,F 04DC: BNC 04D8 04DE: DECF 29,F 04E0: ADDWF 2A,F 04E2: BNC 04DE 04E4: DECF 28,F 04E6: ADDWF 29,F 04E8: BNC 04E4 04EA: CLRF FEA 04EC: MOVLW 28 04EE: MOVWF FE9 04F0: MOVLW 07 04F2: ANDWF 2D,W 04F4: BCF 2D.6 04F6: ADDWF FE9,F 04F8: MOVLW 00 04FA: ADDWFC FEA,F 04FC: MOVF FE9,W 04FE: SUBLW 2C 0500: BNZ 0508 0502: MOVF FEA,F 0504: BNZ 0508 0506: BSF 2D.6 0508: MOVF FEF,W 050A: MOVWF 00 050C: BNZ 051E 050E: BTFSC 2D.6 0510: BRA 051E 0512: BTFSC 2D.4 0514: BRA 052E 0516: BTFSC 2D.3 0518: BRA 051E 051A: MOVLW 20 051C: BRA 0524 051E: BSF 2D.3 0520: BCF 2D.4 0522: MOVLW 30 0524: ADDWF 00,F 0526: MOVF 00,W 0528: BTFSS F9E.4 052A: BRA 0528 052C: MOVWF FAD 052E: MOVF FEE,W 0530: BTFSS 2D.6 0532: BRA 04FC 0534: GOTO 05CE (RETURN) 0538: BTFSC 27.7 053A: BRA 055C 053C: MOVLW 0F 053E: MOVWF 00 0540: SWAPF 26,W 0542: ANDWF 00,F 0544: MOVLW 0A 0546: SUBWF 00,W 0548: BC 0550 054A: MOVLW 30 054C: ADDWF 00,F 054E: BRA 0554 0550: MOVF 27,W 0552: ADDWF 00,F 0554: MOVF 00,W 0556: BTFSS F9E.4 0558: BRA 0556 055A: MOVWF FAD 055C: MOVLW 0F 055E: ANDWF 26,F 0560: MOVLW 0A 0562: SUBWF 26,W 0564: BC 056A 0566: MOVLW 30 0568: BRA 056E 056A: BCF 27.7 056C: MOVF 27,W 056E: ADDWF 26,F 0570: MOVF 26,W 0572: BTFSS F9E.4 0574: BRA 0572 0576: MOVWF FAD 0578: RETURN 0 * 065A: MOVF 29,W 065C: CLRF 01 065E: SUBWF 28,W 0660: BC 0668 0662: MOVFF 28,00 0666: BRA 0680 0668: CLRF 00 066A: MOVLW 08 066C: MOVWF 2A 066E: RLCF 28,F 0670: RLCF 00,F 0672: MOVF 29,W 0674: SUBWF 00,W 0676: BTFSC FD8.0 0678: MOVWF 00 067A: RLCF 01,F 067C: DECFSZ 2A,F 067E: BRA 066E 0680: RETURN 0 0682: MOVF 01,W 0684: MOVFF 26,28 0688: MOVLW 64 068A: MOVWF 29 068C: RCALL 065A 068E: MOVFF 00,26 0692: MOVF 01,W 0694: MOVLW 30 0696: BNZ 06A6 0698: BTFSS 27.1 069A: BRA 06B4 069C: BTFSC 27.3 069E: BRA 06B4 06A0: BTFSC 27.4 06A2: MOVLW 20 06A4: BRA 06AC 06A6: BCF 27.3 06A8: BCF 27.4 06AA: BSF 27.0 06AC: ADDWF 01,F 06AE: MOVFF 01,30 06B2: RCALL 02EC 06B4: MOVFF 26,28 06B8: MOVLW 0A 06BA: MOVWF 29 06BC: RCALL 065A 06BE: MOVFF 00,26 06C2: MOVF 01,W 06C4: MOVLW 30 06C6: BNZ 06D4 06C8: BTFSC 27.3 06CA: BRA 06DC 06CC: BTFSS 27.0 06CE: BRA 06DC 06D0: BTFSC 27.4 06D2: MOVLW 20 06D4: ADDWF 01,F 06D6: MOVFF 01,30 06DA: RCALL 02EC 06DC: MOVLW 30 06DE: ADDWF 26,F 06E0: MOVFF 26,30 06E4: RCALL 02EC 06E6: RETURN 0 .................... .................... #list .................... .................... #device ADC=8 .................... .................... #FUSES FCMEN //Fail-safe clock monitor enabled .................... #FUSES IESO //Internal External Switch Over mode enabled .................... #FUSES PUT //Power Up Timer .................... #FUSES BROWNOUT //Reset when brownout detected .................... #FUSES BORV21 //Brownout reset at 2.1V .................... #FUSES NOPBADEN //PORTB pins are configured as digital I/O on RESET .................... #FUSES LPT1OSC //Timer1 configured for low-power operation .................... #FUSES NOMCLR //Master Clear pin used for I/O .................... #FUSES STVREN //Stack full/underflow will cause reset .................... #FUSES NOLVP //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O .................... #FUSES NOXINST //Extended set extension and Indexed Addressing mode disabled (Legacy mode) .................... #FUSES NOPROTECT //Code not protected from reading .................... #FUSES NOCPB //No Boot Block code protection .................... #FUSES NOCPD //No EE protection .................... #FUSES NOWRT //Program memory not write protected .................... #FUSES NOWRTC //Configuration registers not write protected .................... #FUSES NOWRTB //Boot block not write protected .................... #FUSES NOWRTD //Data EEPROM not write protected .................... #FUSES NOEBTR //Memory not protected from table reads .................... #FUSES NOEBTRB //Boot block not protected from table reads .................... .................... #use delay(internal=16MHz) * 00FC: CLRF FEA 00FE: MOVLW 31 0100: MOVWF FE9 0102: MOVF FEF,W 0104: BZ 0122 0106: MOVLW 05 0108: MOVWF 01 010A: CLRF 00 010C: DECFSZ 00,F 010E: BRA 010C 0110: DECFSZ 01,F 0112: BRA 010A 0114: MOVLW 2E 0116: MOVWF 00 0118: DECFSZ 00,F 011A: BRA 0118 011C: BRA 011E 011E: DECFSZ FEF,F 0120: BRA 0106 0122: RETURN 0 .................... #use rs232(baud=9600,parity=N,xmit=PIN_C6,rcv=PIN_C7,bits=8,stream=PORT1,errors) .................... .................... #define LED PIN_A4 .................... #define DELAY 500 .................... .................... .................... .................... .................... .................... unsigned int a=50; //define variables. .................... unsigned int b=100,f=75; .................... unsigned long int c=0,d=0; .................... unsigned int flag=0; .................... unsigned int x=1; .................... .................... unsigned int pot1=0; .................... unsigned int light=0; .................... unsigned int leds = 0; //define variables end .................... .................... #INT_TIMER2 .................... void TIMER2_isr(void) .................... { .................... a--; // increment a in the interrupt routine half second * 00AE: DECF 1A,F .................... if(!a) flag+=0x02; 00B0: MOVF 1A,F 00B2: BNZ 00B8 00B4: MOVLW 02 00B6: ADDWF 21,F .................... b--; 00B8: DECF 1B,F .................... if(!b) flag+=0x01; // enable flag bit 0x01 and 0x08 1 sec 00BA: MOVF 1B,F 00BC: BNZ 00C2 00BE: MOVLW 01 00C0: ADDWF 21,F .................... f--; 00C2: DECF 1C,F .................... if(!f) flag+=0x0c; // increment a in the interrupt routine 750mS 00C4: MOVF 1C,F 00C6: BNZ 00CC 00C8: MOVLW 0C 00CA: ADDWF 21,F .................... .................... d++; 00CC: INCF 1F,F 00CE: BTFSC FD8.2 00D0: INCF 20,F 00D2: BCF F9E.1 00D4: GOTO 0060 .................... } .................... .................... .................... void func1(unsigned int); // prototypes for our functions .................... void func2(); .................... void func3(); .................... void func4(); .................... void func5(); .................... // prototypes for our functions end .................... #define LCD_ENABLE_PIN PIN_B2 .................... #define LCD_RS_PIN PIN_B0 .................... #define LCD_RW_PIN PIN_B1 .................... #define LCD_DATA4 PIN_B4 .................... #define LCD_DATA5 PIN_B5 .................... #define LCD_DATA6 PIN_B6 .................... #define LCD_DATA7 PIN_B7 .................... .................... #include .................... /////////////////////////////////////////////////////////////////////////////// .................... //// 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 //// .................... //// //// .................... //// lcd_cursor_on(int1 on) Turn the cursor on (on=TRUE) or off //// .................... //// (on=FALSE). //// .................... //// //// .................... //// lcd_set_cgram_char(w, *p) Write a custom character to the CGRAM. //// .................... //// //// .................... //// //// .................... //// 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. //// .................... /////////////////////////////////////////////////////////////////////////// .................... .................... #ifndef __LCD_C__ .................... #define __LCD_C__ .................... .................... // define the pinout. .................... // only required if port access is being used. .................... typedef struct .................... { // This structure is overlayed .................... int1 enable; // on to an I/O port to gain .................... int1 rs; // access to the LCD pins. .................... int1 rw; // The bits are allocated from .................... int1 unused; // low order up. ENABLE will .................... unsigned int data : 4; // be LSB pin of that port. .................... #if defined(__PCD__) // The port used will be LCD_DATA_PORT. .................... unsigned 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 .................... .................... unsigned int8 lcd_read_nibble(void); .................... .................... unsigned int8 lcd_read_byte(void) .................... { .................... unsigned int8 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); * 01BC: BSF F93.4 .................... output_float(LCD_DATA5); 01BE: BSF F93.5 .................... output_float(LCD_DATA6); 01C0: BSF F93.6 .................... output_float(LCD_DATA7); 01C2: BSF F93.7 .................... #else .................... lcdtris.data = 0xF; .................... #endif .................... #endif .................... .................... lcd_output_rw(1); 01C4: BSF F8A.1 01C6: BCF F93.1 .................... delay_cycles(1); 01C8: NOP .................... lcd_output_enable(1); 01CA: BSF F8A.2 01CC: BCF F93.2 .................... delay_cycles(1); 01CE: NOP .................... high = lcd_read_nibble(); 01D0: RCALL 016A 01D2: MOVFF 01,38 .................... .................... lcd_output_enable(0); 01D6: BCF F8A.2 01D8: BCF F93.2 .................... delay_cycles(1); 01DA: NOP .................... lcd_output_enable(1); 01DC: BSF F8A.2 01DE: BCF F93.2 .................... delay_us(1); 01E0: BRA 01E2 01E2: BRA 01E4 .................... low = lcd_read_nibble(); 01E4: RCALL 016A 01E6: MOVFF 01,37 .................... .................... lcd_output_enable(0); 01EA: BCF F8A.2 01EC: BCF F93.2 .................... .................... #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); 01EE: BCF F93.4 .................... output_drive(LCD_DATA5); 01F0: BCF F93.5 .................... output_drive(LCD_DATA6); 01F2: BCF F93.6 .................... output_drive(LCD_DATA7); 01F4: BCF F93.7 .................... #else .................... lcdtris.data = 0x0; .................... #endif .................... #endif .................... .................... return( (high<<4) | low); 01F6: SWAPF 38,W 01F8: MOVWF 00 01FA: MOVLW F0 01FC: ANDWF 00,F 01FE: MOVF 00,W 0200: IORWF 37,W 0202: MOVWF 01 0204: GOTO 0214 (RETURN) .................... } .................... .................... unsigned int8 lcd_read_nibble(void) .................... { .................... #if (defined(LCD_DATA4) && defined(LCD_DATA5) && defined(LCD_DATA6) && defined(LCD_DATA7)) * 016A: CLRF 39 .................... unsigned int8 n = 0x00; .................... .................... /* Read the data port */ .................... n |= input(LCD_DATA4); 016C: BSF F93.4 016E: MOVLW 00 0170: BTFSC F81.4 0172: MOVLW 01 0174: IORWF 39,F .................... n |= input(LCD_DATA5) << 1; 0176: BSF F93.5 0178: MOVLW 00 017A: BTFSC F81.5 017C: MOVLW 01 017E: MOVWF 00 0180: BCF FD8.0 0182: RLCF 00,F 0184: MOVF 00,W 0186: IORWF 39,F .................... n |= input(LCD_DATA6) << 2; 0188: BSF F93.6 018A: MOVLW 00 018C: BTFSC F81.6 018E: MOVLW 01 0190: MOVWF 00 0192: RLCF 00,F 0194: RLCF 00,F 0196: MOVLW FC 0198: ANDWF 00,F 019A: MOVF 00,W 019C: IORWF 39,F .................... n |= input(LCD_DATA7) << 3; 019E: BSF F93.7 01A0: MOVLW 00 01A2: BTFSC F81.7 01A4: MOVLW 01 01A6: MOVWF 00 01A8: RLCF 00,F 01AA: RLCF 00,F 01AC: RLCF 00,F 01AE: MOVLW F8 01B0: ANDWF 00,F 01B2: MOVF 00,W 01B4: IORWF 39,F .................... .................... return(n); 01B6: MOVFF 39,01 .................... #else 01BA: RETURN 0 .................... return(lcd.data); .................... #endif .................... } .................... .................... void lcd_send_nibble(unsigned int8 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)); * 0124: BTFSC 38.0 0126: BRA 012C 0128: BCF F8A.4 012A: BRA 012E 012C: BSF F8A.4 012E: BCF F93.4 .................... output_bit(LCD_DATA5, bit_test(n, 1)); 0130: BTFSC 38.1 0132: BRA 0138 0134: BCF F8A.5 0136: BRA 013A 0138: BSF F8A.5 013A: BCF F93.5 .................... output_bit(LCD_DATA6, bit_test(n, 2)); 013C: BTFSC 38.2 013E: BRA 0144 0140: BCF F8A.6 0142: BRA 0146 0144: BSF F8A.6 0146: BCF F93.6 .................... output_bit(LCD_DATA7, bit_test(n, 3)); 0148: BTFSC 38.3 014A: BRA 0150 014C: BCF F8A.7 014E: BRA 0152 0150: BSF F8A.7 0152: BCF F93.7 .................... #else .................... lcdlat.data = n; .................... #endif .................... .................... delay_cycles(1); 0154: NOP .................... lcd_output_enable(1); 0156: BSF F8A.2 0158: BCF F93.2 .................... delay_us(2); 015A: MOVLW 02 015C: MOVWF 00 015E: DECFSZ 00,F 0160: BRA 015E 0162: NOP .................... lcd_output_enable(0); 0164: BCF F8A.2 0166: BCF F93.2 0168: RETURN 0 .................... } .................... .................... void lcd_send_byte(unsigned int8 address, unsigned int8 n) .................... { .................... #if defined(__PCB__) .................... set_tris_lcd(LCD_OUTPUT_MAP); .................... #else .................... lcd_enable_tris(); * 0208: BCF F93.2 .................... lcd_rs_tris(); 020A: BCF F93.0 .................... lcd_rw_tris(); 020C: BCF F93.1 .................... #endif .................... .................... lcd_output_rs(0); 020E: BCF F8A.0 0210: BCF F93.0 .................... while ( bit_test(lcd_read_byte(),7) ) ; 0212: BRA 01BC 0214: MOVFF 01,37 0218: BTFSC 01.7 021A: BRA 0212 .................... lcd_output_rs(address); 021C: MOVF 35,F 021E: BNZ 0224 0220: BCF F8A.0 0222: BRA 0226 0224: BSF F8A.0 0226: BCF F93.0 .................... delay_cycles(1); 0228: NOP .................... lcd_output_rw(0); 022A: BCF F8A.1 022C: BCF F93.1 .................... delay_cycles(1); 022E: NOP .................... lcd_output_enable(0); 0230: BCF F8A.2 0232: BCF F93.2 .................... lcd_send_nibble(n >> 4); 0234: SWAPF 36,W 0236: MOVWF 37 0238: MOVLW 0F 023A: ANDWF 37,F 023C: MOVFF 37,38 0240: RCALL 0124 .................... lcd_send_nibble(n & 0xf); 0242: MOVF 36,W 0244: ANDLW 0F 0246: MOVWF 37 0248: MOVWF 38 024A: RCALL 0124 024C: RETURN 0 .................... } .................... .................... #if defined(LCD_EXTENDED_NEWLINE) .................... unsigned int8 g_LcdX, g_LcdY; .................... #endif .................... .................... void lcd_init(void) .................... { .................... unsigned int8 i; .................... unsigned int8 LCD_INIT_STRING[4] = {0x20 | (LCD_TYPE << 2), 0xc, 1, 6}; 024E: MOVLW 28 0250: MOVWF 27 0252: MOVLW 0C 0254: MOVWF 28 0256: MOVLW 01 0258: MOVWF 29 025A: MOVLW 06 025C: MOVWF 2A .................... // These bytes need to be sent to the LCD .................... // to start it up. .................... .................... .................... lcd_output_enable(0); 025E: BCF F8A.2 0260: BCF F93.2 .................... lcd_output_rs(0); 0262: BCF F8A.0 0264: BCF F93.0 .................... lcd_output_rw(0); 0266: BCF F8A.1 0268: BCF F93.1 .................... .................... #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); 026A: BCF F93.4 .................... output_drive(LCD_DATA5); 026C: BCF F93.5 .................... output_drive(LCD_DATA6); 026E: BCF F93.6 .................... output_drive(LCD_DATA7); 0270: BCF F93.7 .................... #else .................... lcdtris.data = 0x0; .................... #endif .................... lcd_enable_tris(); 0272: BCF F93.2 .................... lcd_rs_tris(); 0274: BCF F93.0 .................... lcd_rw_tris(); 0276: BCF F93.1 .................... #endif .................... .................... delay_ms(15); 0278: MOVLW 0F 027A: MOVWF 31 027C: RCALL 00FC .................... for(i=1;i<=3;++i) 027E: MOVLW 01 0280: MOVWF 26 0282: MOVF 26,W 0284: SUBLW 03 0286: BNC 0298 .................... { .................... lcd_send_nibble(3); 0288: MOVLW 03 028A: MOVWF 38 028C: RCALL 0124 .................... delay_ms(5); 028E: MOVLW 05 0290: MOVWF 31 0292: RCALL 00FC 0294: INCF 26,F 0296: BRA 0282 .................... } .................... .................... lcd_send_nibble(2); 0298: MOVLW 02 029A: MOVWF 38 029C: RCALL 0124 .................... delay_ms(5); 029E: MOVLW 05 02A0: MOVWF 31 02A2: RCALL 00FC .................... for(i=0;i<=3;++i) 02A4: CLRF 26 02A6: MOVF 26,W 02A8: SUBLW 03 02AA: BNC 02C6 .................... lcd_send_byte(0,LCD_INIT_STRING[i]); 02AC: CLRF 03 02AE: MOVF 26,W 02B0: ADDLW 27 02B2: MOVWF FE9 02B4: MOVLW 00 02B6: ADDWFC 03,W 02B8: MOVWF FEA 02BA: MOVFF FEF,36 02BE: CLRF 35 02C0: RCALL 0208 .................... .................... #if defined(LCD_EXTENDED_NEWLINE) 02C2: INCF 26,F 02C4: BRA 02A6 02C6: GOTO 07B4 (RETURN) .................... g_LcdX = 0; .................... g_LcdY = 0; .................... #endif .................... } .................... .................... void lcd_gotoxy(unsigned int8 x, unsigned int8 y) .................... { .................... unsigned int8 address; .................... .................... if(y!=1) 02CA: DECFSZ 32,W 02CC: BRA 02D0 02CE: BRA 02D6 .................... address=LCD_LINE_TWO; 02D0: MOVLW 40 02D2: MOVWF 33 02D4: BRA 02D8 .................... else .................... address=0; 02D6: CLRF 33 .................... .................... address+=x-1; 02D8: MOVLW 01 02DA: SUBWF 31,W 02DC: ADDWF 33,F .................... lcd_send_byte(0,0x80|address); 02DE: MOVF 33,W 02E0: IORLW 80 02E2: MOVWF 34 02E4: CLRF 35 02E6: MOVWF 36 02E8: RCALL 0208 .................... .................... #if defined(LCD_EXTENDED_NEWLINE) 02EA: RETURN 0 .................... g_LcdX = x - 1; .................... g_LcdY = y - 1; .................... #endif .................... } .................... .................... void lcd_putc(char c) .................... { .................... switch (c) 02EC: MOVF 30,W 02EE: XORLW 07 02F0: BZ 0300 02F2: XORLW 0B 02F4: BZ 030A 02F6: XORLW 06 02F8: BZ 031A 02FA: XORLW 02 02FC: BZ 0326 02FE: BRA 0330 .................... { .................... case '\a' : lcd_gotoxy(1,1); break; 0300: MOVLW 01 0302: MOVWF 31 0304: MOVWF 32 0306: RCALL 02CA 0308: BRA 033A .................... .................... case '\f' : lcd_send_byte(0,1); 030A: CLRF 35 030C: MOVLW 01 030E: MOVWF 36 0310: RCALL 0208 .................... delay_ms(2); 0312: MOVLW 02 0314: MOVWF 31 0316: RCALL 00FC .................... #if defined(LCD_EXTENDED_NEWLINE) .................... g_LcdX = 0; .................... g_LcdY = 0; .................... #endif .................... break; 0318: BRA 033A .................... .................... #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; 031A: MOVLW 01 031C: MOVWF 31 031E: MOVLW 02 0320: MOVWF 32 0322: RCALL 02CA 0324: BRA 033A .................... #endif .................... .................... case '\b' : lcd_send_byte(0,0x10); break; 0326: CLRF 35 0328: MOVLW 10 032A: MOVWF 36 032C: RCALL 0208 032E: BRA 033A .................... .................... #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; 0330: MOVLW 01 0332: MOVWF 35 0334: MOVFF 30,36 0338: RCALL 0208 .................... #endif .................... } 033A: RETURN 0 .................... } .................... .................... char lcd_getc(unsigned int8 x, unsigned int8 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); .................... } .................... .................... // write a custom character to the ram .................... // which is 0-7 and specifies which character array we are modifying. .................... // ptr points to an array of 8 bytes, where each byte is the next row of .................... // pixels. only bits 0-4 are used. the last row is the cursor row, and .................... // usually you will want to leave this byte 0x00. .................... void lcd_set_cgram_char(unsigned int8 which, unsigned int8 *ptr) .................... { .................... unsigned int i; .................... .................... which <<= 3; .................... which &= 0x38; .................... .................... lcd_send_byte(0, 0x40 | which); //set cgram address .................... .................... for(i=0; i<8; i++) .................... { .................... lcd_send_byte(1, *ptr++); .................... } .................... .................... #if defined(LCD_EXTENDED_NEWLINE) .................... lcd_gotoxy(g_LcdX+1, g_LcdY+1); //set ddram address .................... #endif .................... } .................... .................... void lcd_cursor_on(int1 on) .................... { .................... if (on) .................... { .................... lcd_send_byte(0,0x0F); //turn LCD cursor ON .................... } .................... else .................... { .................... lcd_send_byte(0,0x0C); //turn LCD cursor OFF .................... } .................... } .................... .................... #endif .................... .................... .................... .................... .................... void main() * 073E: CLRF FF8 0740: BCF FD0.7 0742: BSF 07.7 0744: MOVLW 60 0746: MOVWF FD3 0748: MOVLW 40 074A: MOVWF F9B 074C: MOVF FD3,W 074E: CLRF 19 0750: BSF FB8.3 0752: MOVLW A0 0754: MOVWF FAF 0756: MOVLW 01 0758: MOVWF FB0 075A: MOVLW A6 075C: MOVWF FAC 075E: MOVLW 90 0760: MOVWF FAB 0762: MOVLW 32 0764: MOVWF 1A 0766: MOVLW 64 0768: MOVWF 1B 076A: MOVLW 4B 076C: MOVWF 1C 076E: CLRF 1E 0770: CLRF 1D 0772: CLRF 20 0774: CLRF 1F 0776: CLRF 21 0778: MOVLW 01 077A: MOVWF 22 077C: CLRF 23 077E: CLRF 24 0780: CLRF 25 0782: MOVF FC1,W 0784: ANDLW C0 0786: IORLW 0F 0788: MOVWF FC1 078A: MOVLW 07 078C: MOVWF FB4 .................... { .................... setup_adc_ports(AN0_TO_AN1); // select a0 & a1 as analogue 078E: MOVF FC1,W 0790: ANDLW C0 0792: IORLW 0D 0794: MOVWF FC1 .................... setup_adc(ADC_CLOCK_INTERNAL|ADC_TAD_MUL_0); 0796: MOVF FC0,W 0798: ANDLW C0 079A: IORLW 07 079C: MOVWF FC0 079E: BCF FC0.7 07A0: BSF FC2.0 .................... setup_timer_2(T2_DIV_BY_16,178,14); //716 us overflow, 10.0 ms interrupt 07A2: MOVLW 68 07A4: IORLW 06 07A6: MOVWF FCA 07A8: MOVLW B2 07AA: MOVWF FCB .................... .................... .................... enable_interrupts(INT_TIMER2); // enable timer 2 overflow interrupt 07AC: BSF F9D.1 .................... enable_interrupts(GLOBAL); // enable global interrupts 07AE: MOVLW C0 07B0: IORWF FF2,F .................... .................... lcd_init(); // initiate LCD 07B2: BRA 024E .................... .................... while(TRUE) // Main program while loop .................... { .................... .................... if(flag & 0x01) func1(1); // if flag 0x01 set - call our function 1 07B4: BTFSS 21.0 07B6: BRA 07BE 07B8: MOVLW 01 07BA: MOVWF 26 07BC: BRA 0414 .................... if(flag & 0x02) func2(); // if flag 0x02 set - call our function 2 07BE: BTFSC 21.1 07C0: BRA 057A .................... if(flag & 0x04) func3(); // if flag 0x02 set - call our function 3 07C2: BTFSC 21.2 07C4: BRA 060E .................... .................... func4(); 07C6: BRA 06E8 .................... if(flag & 0x08) { 07C8: BTFSS 21.3 07CA: BRA 07EC .................... if((pot1>128) && (input(Pin_A2)) && (light <=25)) { func5();} // flash led 07CC: MOVF 23,W 07CE: SUBLW 80 07D0: BC 07E2 07D2: BSF F92.2 07D4: BTFSS F80.2 07D6: BRA 07E2 07D8: MOVF 24,W 07DA: SUBLW 19 07DC: BNC 07E2 07DE: BRA 0726 07E0: BRA 07E8 .................... else {output_high(Pin_A4); leds=0;} 07E2: BCF F92.4 07E4: BSF F89.4 07E6: CLRF 25 .................... flag-=8; // flash led off 07E8: MOVLW 08 07EA: SUBWF 21,F .................... } 07EC: BRA 07B4 .................... .................... } // main program while loop end .................... .................... .................... } // END PROGRAM .................... 07EE: SLEEP .................... void func1(unsigned int x) .................... { .................... lcd_gotoxy(x,1); // got lcd position ready for next character * 0414: MOVFF 26,31 0418: MOVLW 01 041A: MOVWF 32 041C: RCALL 02CA .................... printf(lcd_putc," Hello World %3Lu",c); // print to lcd clear screen and hello world and the value of c 041E: MOVLW D8 0420: MOVWF FF6 0422: MOVLW 00 0424: MOVWF FF7 0426: MOVLW 0D 0428: MOVWF 27 042A: RCALL 033C 042C: MOVLW 02 042E: MOVWF FE9 0430: MOVFF 1E,28 0434: MOVFF 1D,27 0438: RCALL 035A .................... c++; // increment c 043A: INCF 1D,F 043C: BTFSC FD8.2 043E: INCF 1E,F .................... b=100; 0440: MOVLW 64 0442: MOVWF 1B .................... flag-=1; 0444: MOVLW 01 0446: SUBWF 21,F 0448: GOTO 07BE (RETURN) .................... .................... } .................... .................... void func2() .................... { .................... lcd_gotoxy(21,2); // got lcd position ready for next character * 057A: MOVLW 15 057C: MOVWF 31 057E: MOVLW 02 0580: MOVWF 32 0582: RCALL 02CA .................... printf(lcd_putc,"%6Lu %4Lx",d,d); // print to lcd the value of d in decimal and Hex 0584: MOVLW 01 0586: MOVWF 26 0588: MOVLW 20 058A: MOVWF 30 058C: RCALL 02EC 058E: DECFSZ 26,F 0590: BRA 0588 0592: MOVLW 00 0594: MOVWF FE9 0596: MOVFF 20,28 059A: MOVFF 1F,27 059E: RCALL 035A 05A0: MOVLW 20 05A2: MOVWF 30 05A4: RCALL 02EC 05A6: MOVLW 20 05A8: MOVWF 30 05AA: RCALL 02EC 05AC: MOVFF 20,26 05B0: MOVLW 57 05B2: MOVWF 27 05B4: RCALL 044C 05B6: MOVFF 1F,26 05BA: MOVLW 57 05BC: MOVWF 27 05BE: RCALL 044C .................... printf("%Lu %Lx\n\r",d,d); // print to the virtual terminal the value of d in decimal and Hex 05C0: MOVLW 10 05C2: MOVWF FE9 05C4: MOVFF 20,27 05C8: MOVFF 1F,26 05CC: BRA 048A 05CE: MOVLW 20 05D0: BTFSS F9E.4 05D2: BRA 05D0 05D4: MOVWF FAD 05D6: MOVLW 20 05D8: BTFSS F9E.4 05DA: BRA 05D8 05DC: MOVWF FAD 05DE: MOVFF 20,26 05E2: MOVLW 57 05E4: MOVWF 27 05E6: RCALL 0538 05E8: MOVFF 1F,26 05EC: MOVLW 57 05EE: MOVWF 27 05F0: RCALL 0538 05F2: MOVLW 0A 05F4: BTFSS F9E.4 05F6: BRA 05F4 05F8: MOVWF FAD 05FA: MOVLW 0D 05FC: BTFSS F9E.4 05FE: BRA 05FC 0600: MOVWF FAD .................... a=50; 0602: MOVLW 32 0604: MOVWF 1A .................... flag-=2; 0606: MOVLW 02 0608: SUBWF 21,F 060A: GOTO 07C2 (RETURN) .................... } .................... .................... void func3() .................... { // read analogue inputs .................... set_adc_channel(0); 060E: MOVLW 00 0610: MOVWF 01 0612: MOVF FC2,W 0614: ANDLW C3 0616: IORWF 01,W 0618: MOVWF FC2 .................... delay_us(20); 061A: MOVLW 1A 061C: MOVWF 00 061E: DECFSZ 00,F 0620: BRA 061E 0622: NOP .................... pot1 = read_adc(); 0624: BSF FC2.1 0626: BTFSC FC2.1 0628: BRA 0626 062A: MOVFF FC4,23 .................... set_adc_channel(1); 062E: MOVLW 04 0630: MOVWF 01 0632: MOVF FC2,W 0634: ANDLW C3 0636: IORWF 01,W 0638: MOVWF FC2 .................... delay_us(20); 063A: MOVLW 1A 063C: MOVWF 00 063E: DECFSZ 00,F 0640: BRA 063E 0642: NOP .................... light = read_adc(); 0644: BSF FC2.1 0646: BTFSC FC2.1 0648: BRA 0646 064A: MOVFF FC4,24 .................... f=75; 064E: MOVLW 4B 0650: MOVWF 1C .................... flag-=4; 0652: MOVLW 04 0654: SUBWF 21,F 0656: GOTO 07C6 (RETURN) .................... } .................... void func4() .................... { // display analog values on screen .................... lcd_gotoxy(1,2); // got lcd position ready for next character * 06E8: MOVLW 01 06EA: MOVWF 31 06EC: MOVLW 02 06EE: MOVWF 32 06F0: RCALL 02CA .................... printf(lcd_putc,"pot=%3U lit=%3u",pot1,light); // print to lcd clear screen and hello world and the value of c 06F2: MOVLW EA 06F4: MOVWF FF6 06F6: MOVLW 00 06F8: MOVWF FF7 06FA: MOVLW 04 06FC: MOVWF 27 06FE: RCALL 033C 0700: MOVFF 23,26 0704: MOVLW 13 0706: MOVWF 27 0708: RCALL 0682 070A: MOVLW F1 070C: MOVWF FF6 070E: MOVLW 00 0710: MOVWF FF7 0712: MOVLW 06 0714: MOVWF 27 0716: RCALL 033C 0718: MOVFF 24,26 071C: MOVLW 13 071E: MOVWF 27 0720: RCALL 0682 0722: GOTO 07C8 (RETURN) .................... } .................... .................... void func5() .................... { .................... if(leds) {output_low(Pin_A4); leds=0;} // switch on led 0726: MOVF 25,F 0728: BZ 0732 072A: BCF F92.4 072C: BCF F89.4 072E: CLRF 25 0730: BRA 073A .................... else {output_high(Pin_A4); leds=1;} //switch off led 0732: BCF F92.4 0734: BSF F89.4 0736: MOVLW 01 0738: MOVWF 25 073A: GOTO 07E0 (RETURN) .................... .................... } .................... Configuration Fuses: Word 1: C800 INTRC_IO FCMEN IESO Word 2: 1E1E PUT BROWNOUT BORV21 NOWDT WDT32768 Word 3: 0500 CCP2C1 NOPBADEN LPT1OSC NOMCLR Word 4: 0081 STVREN NOLVP NOXINST NODEBUG Word 5: C00F NOPROTECT NOCPB NOCPD Word 6: E00F NOWRT NOWRTC NOWRTB NOWRTD Word 7: 400F NOEBTR NOEBTRB