CCS PCH C Compiler, Version 5.103, 56135 10-Jan-23 11:28 Filename: C:\Users\Ga\Desktop\Embedded C Practical\ccs\main.lst ROM used: 570 bytes (2%) Largest free fragment is 32198 RAM used: 5 (0%) at main() level 16 (1%) worst case Stack used: 0 locations Stack size: 31 * 0000: GOTO 01D8 .................... #include .................... #include <18F25K22.h> .................... //////////// Standard Header file for the PIC18F25K22 device //////////////// .................... /////////////////////////////////////////////////////////////////////////// .................... //// (C) Copyright 1996, 2020 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 PIC18F25K22 .................... .................... #list .................... .................... #device ADC=8 .................... .................... #FUSES NOWDT //No Watch Dog Timer .................... #FUSES PRIMARY //Primary clock is system clock when scs=00 .................... #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 BORV19 //Brownout reset at 1.9V .................... #FUSES CCP3B5 //CCP3 input/output multiplexed with RB5 .................... #FUSES HFOFST //High Frequency INTRC starts clocking CPU immediately .................... #FUSES TIMER3C0 //Timer3 Clock In is on pin C0 .................... #FUSES CCP2B5 //CCP2 input/output multiplexed with RB5 .................... #FUSES NOPROTECT //Code not protected from reading .................... #FUSES NOWRT //Program memory not write protected .................... #FUSES NOEBTR //Memory not protected from table reads .................... .................... #use delay(internal=16MHz) 0004: CLRF FEA 0006: MOVLW 0A 0008: MOVWF FE9 000A: MOVF FEF,W 000C: BTFSC FD8.2 000E: GOTO 002E 0012: MOVLW 05 0014: MOVWF 01 0016: CLRF 00 0018: DECFSZ 00,F 001A: BRA 0018 001C: DECFSZ 01,F 001E: BRA 0016 0020: MOVLW 2E 0022: MOVWF 00 0024: DECFSZ 00,F 0026: BRA 0024 0028: BRA 002A 002A: DECFSZ FEF,F 002C: BRA 0012 002E: RETURN 0 .................... .................... #define LED PIN_C3 .................... #define DELAY 500 .................... .................... .................... .................... #define LCD_ENABLE_PIN PIN_C0 .................... #define LCD_RS_PIN PIN_C2 .................... #define LCD_RW_PIN PIN_C1 .................... #define LCD_DATA4 PIN_C4 .................... #define LCD_DATA5 PIN_C5 .................... #define LCD_DATA6 PIN_C6 .................... #define LCD_DATA7 PIN_C7 .................... .................... #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); * 00C8: BSF F94.4 .................... output_float(LCD_DATA5); 00CA: BSF F94.5 .................... output_float(LCD_DATA6); 00CC: BSF F94.6 .................... output_float(LCD_DATA7); 00CE: BSF F94.7 .................... #else .................... lcdtris.data = 0xF; .................... #endif .................... #endif .................... .................... lcd_output_rw(1); 00D0: BSF F8B.1 00D2: BCF F94.1 .................... delay_cycles(1); 00D4: NOP .................... lcd_output_enable(1); 00D6: BSF F8B.0 00D8: BCF F94.0 .................... delay_cycles(1); 00DA: NOP .................... high = lcd_read_nibble(); 00DC: RCALL 0076 00DE: MOVFF 01,0E .................... .................... lcd_output_enable(0); 00E2: BCF F8B.0 00E4: BCF F94.0 .................... delay_cycles(1); 00E6: NOP .................... lcd_output_enable(1); 00E8: BSF F8B.0 00EA: BCF F94.0 .................... delay_us(1); 00EC: BRA 00EE 00EE: BRA 00F0 .................... low = lcd_read_nibble(); 00F0: RCALL 0076 00F2: MOVFF 01,0D .................... .................... lcd_output_enable(0); 00F6: BCF F8B.0 00F8: BCF F94.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); 00FA: BCF F94.4 .................... output_drive(LCD_DATA5); 00FC: BCF F94.5 .................... output_drive(LCD_DATA6); 00FE: BCF F94.6 .................... output_drive(LCD_DATA7); 0100: BCF F94.7 .................... #else .................... lcdtris.data = 0x0; .................... #endif .................... #endif .................... .................... return( (high<<4) | low); 0102: SWAPF 0E,W 0104: MOVWF 00 0106: MOVLW F0 0108: ANDWF 00,F 010A: MOVF 00,W 010C: IORWF 0D,W 010E: MOVWF 01 0110: GOTO 0120 (RETURN) .................... } .................... .................... unsigned int8 lcd_read_nibble(void) .................... { .................... #if (defined(LCD_DATA4) && defined(LCD_DATA5) && defined(LCD_DATA6) && defined(LCD_DATA7)) * 0076: CLRF 0F .................... unsigned int8 n = 0x00; .................... .................... /* Read the data port */ .................... n |= input(LCD_DATA4); 0078: BSF F94.4 007A: MOVLW 00 007C: BTFSC F82.4 007E: MOVLW 01 0080: IORWF 0F,F .................... n |= input(LCD_DATA5) << 1; 0082: BSF F94.5 0084: MOVLW 00 0086: BTFSC F82.5 0088: MOVLW 01 008A: MOVWF 00 008C: BCF FD8.0 008E: RLCF 00,F 0090: MOVF 00,W 0092: IORWF 0F,F .................... n |= input(LCD_DATA6) << 2; 0094: BSF F94.6 0096: MOVLW 00 0098: BTFSC F82.6 009A: MOVLW 01 009C: MOVWF 00 009E: RLCF 00,F 00A0: RLCF 00,F 00A2: MOVLW FC 00A4: ANDWF 00,F 00A6: MOVF 00,W 00A8: IORWF 0F,F .................... n |= input(LCD_DATA7) << 3; 00AA: BSF F94.7 00AC: MOVLW 00 00AE: BTFSC F82.7 00B0: MOVLW 01 00B2: MOVWF 00 00B4: RLCF 00,F 00B6: RLCF 00,F 00B8: RLCF 00,F 00BA: MOVLW F8 00BC: ANDWF 00,F 00BE: MOVF 00,W 00C0: IORWF 0F,F .................... .................... return(n); 00C2: MOVFF 0F,01 .................... #else 00C6: 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)); * 0030: BTFSC 0E.0 0032: BRA 0038 0034: BCF F8B.4 0036: BRA 003A 0038: BSF F8B.4 003A: BCF F94.4 .................... output_bit(LCD_DATA5, bit_test(n, 1)); 003C: BTFSC 0E.1 003E: BRA 0044 0040: BCF F8B.5 0042: BRA 0046 0044: BSF F8B.5 0046: BCF F94.5 .................... output_bit(LCD_DATA6, bit_test(n, 2)); 0048: BTFSC 0E.2 004A: BRA 0050 004C: BCF F8B.6 004E: BRA 0052 0050: BSF F8B.6 0052: BCF F94.6 .................... output_bit(LCD_DATA7, bit_test(n, 3)); 0054: BTFSC 0E.3 0056: BRA 005C 0058: BCF F8B.7 005A: BRA 005E 005C: BSF F8B.7 005E: BCF F94.7 .................... #else .................... lcdlat.data = n; .................... #endif .................... .................... delay_cycles(1); 0060: NOP .................... lcd_output_enable(1); 0062: BSF F8B.0 0064: BCF F94.0 .................... delay_us(2); 0066: MOVLW 02 0068: MOVWF 00 006A: DECFSZ 00,F 006C: BRA 006A 006E: NOP .................... lcd_output_enable(0); 0070: BCF F8B.0 0072: BCF F94.0 0074: 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(); * 0114: BCF F94.0 .................... lcd_rs_tris(); 0116: BCF F94.2 .................... lcd_rw_tris(); 0118: BCF F94.1 .................... #endif .................... .................... lcd_output_rs(0); 011A: BCF F8B.2 011C: BCF F94.2 .................... while ( bit_test(lcd_read_byte(),7) ) ; 011E: BRA 00C8 0120: MOVFF 01,0D 0124: BTFSC 01.7 0126: BRA 011E .................... lcd_output_rs(address); 0128: MOVF 0B,F 012A: BNZ 0130 012C: BCF F8B.2 012E: BRA 0132 0130: BSF F8B.2 0132: BCF F94.2 .................... delay_cycles(1); 0134: NOP .................... lcd_output_rw(0); 0136: BCF F8B.1 0138: BCF F94.1 .................... delay_cycles(1); 013A: NOP .................... lcd_output_enable(0); 013C: BCF F8B.0 013E: BCF F94.0 .................... lcd_send_nibble(n >> 4); 0140: SWAPF 0C,W 0142: MOVWF 0D 0144: MOVLW 0F 0146: ANDWF 0D,F 0148: MOVFF 0D,0E 014C: RCALL 0030 .................... lcd_send_nibble(n & 0xf); 014E: MOVF 0C,W 0150: ANDLW 0F 0152: MOVWF 0D 0154: MOVWF 0E 0156: RCALL 0030 0158: GOTO 01D0 (RETURN) .................... } .................... .................... #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}; 015C: MOVLW 28 015E: MOVWF 06 0160: MOVLW 0C 0162: MOVWF 07 0164: MOVLW 01 0166: MOVWF 08 0168: MOVLW 06 016A: MOVWF 09 .................... // These bytes need to be sent to the LCD .................... // to start it up. .................... .................... .................... lcd_output_enable(0); 016C: BCF F8B.0 016E: BCF F94.0 .................... lcd_output_rs(0); 0170: BCF F8B.2 0172: BCF F94.2 .................... lcd_output_rw(0); 0174: BCF F8B.1 0176: BCF F94.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); 0178: BCF F94.4 .................... output_drive(LCD_DATA5); 017A: BCF F94.5 .................... output_drive(LCD_DATA6); 017C: BCF F94.6 .................... output_drive(LCD_DATA7); 017E: BCF F94.7 .................... #else .................... lcdtris.data = 0x0; .................... #endif .................... lcd_enable_tris(); 0180: BCF F94.0 .................... lcd_rs_tris(); 0182: BCF F94.2 .................... lcd_rw_tris(); 0184: BCF F94.1 .................... #endif .................... .................... delay_ms(15); 0186: MOVLW 0F 0188: MOVWF 0A 018A: RCALL 0004 .................... for(i=1;i<=3;++i) 018C: MOVLW 01 018E: MOVWF 05 0190: MOVF 05,W 0192: SUBLW 03 0194: BNC 01A6 .................... { .................... lcd_send_nibble(3); 0196: MOVLW 03 0198: MOVWF 0E 019A: RCALL 0030 .................... delay_ms(5); 019C: MOVLW 05 019E: MOVWF 0A 01A0: RCALL 0004 01A2: INCF 05,F 01A4: BRA 0190 .................... } .................... .................... lcd_send_nibble(2); 01A6: MOVLW 02 01A8: MOVWF 0E 01AA: RCALL 0030 .................... delay_ms(5); 01AC: MOVLW 05 01AE: MOVWF 0A 01B0: RCALL 0004 .................... for(i=0;i<=3;++i) 01B2: CLRF 05 01B4: MOVF 05,W 01B6: SUBLW 03 01B8: BNC 01D4 .................... lcd_send_byte(0,LCD_INIT_STRING[i]); 01BA: CLRF 03 01BC: MOVF 05,W 01BE: ADDLW 06 01C0: MOVWF FE9 01C2: MOVLW 00 01C4: ADDWFC 03,W 01C6: MOVWF FEA 01C8: MOVFF FEF,0C 01CC: CLRF 0B 01CE: BRA 0114 .................... .................... #if defined(LCD_EXTENDED_NEWLINE) 01D0: INCF 05,F 01D2: BRA 01B4 01D4: GOTO 0212 (RETURN) .................... g_LcdX = 0; .................... g_LcdY = 0; .................... #endif .................... } .................... .................... void lcd_gotoxy(unsigned int8 x, unsigned int8 y) .................... { .................... unsigned int8 address; .................... .................... if(y!=1) .................... address=LCD_LINE_TWO; .................... else .................... address=0; .................... .................... address+=x-1; .................... lcd_send_byte(0,0x80|address); .................... .................... #if defined(LCD_EXTENDED_NEWLINE) .................... g_LcdX = x - 1; .................... g_LcdY = y - 1; .................... #endif .................... } .................... .................... void lcd_putc(char c) .................... { .................... switch (c) .................... { .................... case '\a' : lcd_gotoxy(1,1); break; .................... .................... case '\f' : lcd_send_byte(0,1); .................... delay_ms(2); .................... #if defined(LCD_EXTENDED_NEWLINE) .................... g_LcdX = 0; .................... g_LcdY = 0; .................... #endif .................... break; .................... .................... #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; .................... #endif .................... .................... case '\b' : lcd_send_byte(0,0x10); break; .................... .................... #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; .................... #endif .................... } .................... } .................... .................... 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() 01D8: CLRF FF8 01DA: BCF FD0.7 01DC: MOVLW 70 01DE: MOVWF FD3 01E0: BCF F9B.6 01E2: BCF F9B.7 01E4: MOVLB F 01E6: CLRF x38 01E8: CLRF x39 01EA: CLRF x3A 01EC: CLRF F77 01EE: CLRF F78 01F0: CLRF F79 .................... { .................... setup_adc_ports(sAN0 | sAN1 | sAN2, VSS_VDD); 01F2: MOVF FC1,W 01F4: ANDLW F0 01F6: MOVWF FC1 01F8: MOVLW 07 01FA: MOVWF x38 01FC: MOVLW 00 01FE: MOVWF x39 0200: MOVWF x3A .................... setup_adc(ADC_CLOCK_INTERNAL | ADC_TAD_MUL_0); 0202: MOVF FC0,W 0204: ANDLW C0 0206: IORLW 07 0208: MOVWF FC0 020A: BCF FC0.7 020C: BSF FC2.0 .................... .................... lcd_init(); 020E: MOVLB 0 0210: BRA 015C .................... .................... while(TRUE) .................... { .................... .................... //Example blinking LED program .................... output_low(LED); 0212: BCF F94.3 0214: BCF F8B.3 .................... delay_ms(DELAY); 0216: MOVLW 02 0218: MOVWF 05 021A: MOVLW FA 021C: MOVWF 0A 021E: RCALL 0004 0220: DECFSZ 05,F 0222: BRA 021A .................... output_high(LED); 0224: BCF F94.3 0226: BSF F8B.3 .................... delay_ms(DELAY); 0228: MOVLW 02 022A: MOVWF 05 022C: MOVLW FA 022E: MOVWF 0A 0230: RCALL 0004 0232: DECFSZ 05,F 0234: BRA 022C 0236: BRA 0212 .................... .................... //TODO: User Code .................... } .................... .................... } 0238: SLEEP Configuration Fuses: Word 1: E800 INTRC_IO NOPLLEN PRIMARY FCMEN IESO Word 2: 3C1E PUT BROWNOUT BORV19 NOWDT WDT32768 Word 3: BF00 CCP2C1 PBADEN CCP3B5 HFOFST TIMER3C0 CCP2B5 MCLR 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