CCS PCH C Compiler, Version 5.103, 56135 20-Apr-23 07:31 Filename: C:\Users\Ga\Desktop\dis practical\ccs\main.lst ROM used: 386 bytes (1%) Largest free fragment is 48766 RAM used: 4 (0%) at main() level 15 (0%) worst case Stack used: 0 locations Stack size: 31 * 0000: GOTO 014A .................... #include .................... #include <18F2525.h> .................... //////////// Standard Header file for the PIC18F2525 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 PIC18F2525 .................... .................... #list .................... .................... #device ADC=10 .................... .................... #FUSES NOWDT //No Watch Dog Timer .................... #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 NOPROTECT //Code not protected from reading .................... #FUSES NOWRT //Program memory not write protected .................... #FUSES NOEBTR //Memory not protected from table reads .................... .................... #use delay(internal=8MHz) * 000C: CLRF FEA 000E: MOVLW 0A 0010: MOVWF FE9 0012: MOVF FEF,W 0014: BTFSC FD8.2 0016: GOTO 0034 001A: MOVLW 02 001C: MOVWF 01 001E: CLRF 00 0020: DECFSZ 00,F 0022: BRA 0020 0024: DECFSZ 01,F 0026: BRA 001E 0028: MOVLW 97 002A: MOVWF 00 002C: DECFSZ 00,F 002E: BRA 002C 0030: DECFSZ FEF,F 0032: BRA 001A 0034: RETURN 0 .................... #use STANDARD_IO( C ) .................... #use i2c(Master,Fast,sda=PIN_C4,scl=PIN_C3,force_hw) .................... .................... .................... .................... #include <2408.C> .................... .................... /////////////////////////////////////////////////////////////////////////// .................... //// Library for a MicroChip 24LC08B //// .................... //// //// .................... //// init_ext_eeprom(); Call before the other functions are used //// .................... //// //// .................... //// write_ext_eeprom(a, d); Write the byte d to the address a //// .................... //// //// .................... //// d = read_ext_eeprom(a); Read the byte d from the address a //// .................... //// //// .................... //// b = ext_eeprom_ready(); Returns TRUE if the eeprom is ready //// .................... //// to receive opcodes //// .................... //// //// .................... //// The main program may define EEPROM_SDA //// .................... //// and EEPROM_SCL to override the defaults below. //// .................... //// //// .................... //// Pin Layout //// .................... //// ----------------------------------------------------------- //// .................... //// | | //// .................... //// | 1: NC Not Connected | 8: VCC +5V | //// .................... //// | | | //// .................... //// | 2: NC Not Connected | 7: WP GND | //// .................... //// | | | //// .................... //// | 3: NC Not Connected | 6: SCL EEPROM_SCL and Pull-Up | //// .................... //// | | | //// .................... //// | 4: VSS GND | 5: SDA EEPROM_SDA and Pull-Up | //// .................... //// ----------------------------------------------------------- //// .................... //// //// .................... /////////////////////////////////////////////////////////////////////////// .................... //// (C) Copyright 1996, 2003 Custom Computer Services //// .................... //// This source code may only be used by licensed users of the CCS C //// .................... //// compiler. This source code may only be distributed to other //// .................... //// licensed users of the CCS C compiler. No other use, reproduction //// .................... //// or distribution is permitted without written permission. //// .................... //// Derivative programs created using this software in object code //// .................... //// form are not restricted in any way. //// .................... /////////////////////////////////////////////////////////////////////////// .................... .................... #ifndef EEPROM_SDA .................... .................... #define EEPROM_SDA PIN_C4 .................... #define EEPROM_SCL PIN_C3 .................... .................... #endif .................... .................... .................... #use i2c(master, sda=EEPROM_SDA, scl=EEPROM_SCL) .................... .................... #define EEPROM_ADDRESS long int .................... #define EEPROM_SIZE 1024 .................... .................... void init_ext_eeprom() { .................... output_float(EEPROM_SCL); * 0004: BSF F94.3 .................... output_float(EEPROM_SDA); 0006: BSF F94.4 0008: GOTO 017C (RETURN) .................... } .................... .................... BOOLEAN ext_eeprom_ready() { .................... int1 ack; .................... i2c_start(); // If the write command is acknowledged, .................... ack = i2c_write(0xa0); // then the device is ready. .................... i2c_stop(); .................... return !ack; .................... } .................... .................... void write_ext_eeprom(long int address, BYTE data) { .................... while(!ext_eeprom_ready()); .................... i2c_start(); .................... i2c_write((0xa0|(BYTE)(address>>7))&0xfe); .................... i2c_write(address); .................... i2c_write(data); .................... i2c_stop(); .................... } .................... .................... .................... BYTE read_ext_eeprom(long int address) { .................... BYTE data; .................... .................... while(!ext_eeprom_ready()); .................... i2c_start(); .................... i2c_write((0xa0|(BYTE)(address>>7))&0xfe); .................... i2c_write(address); .................... i2c_start(); .................... i2c_write((0xa0|(BYTE)(address>>7))|1); .................... data=i2c_read(0); .................... i2c_stop(); .................... return(data); .................... } .................... .................... .................... #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); .................... output_float(LCD_DATA5); .................... output_float(LCD_DATA6); .................... output_float(LCD_DATA7); .................... #else .................... lcdtris.data = 0xF; * 005C: MOVLW 0F 005E: ANDWF F93,W 0060: IORLW F0 0062: MOVWF F93 .................... #endif .................... #endif .................... .................... lcd_output_rw(1); 0064: BSF F8A.2 .................... delay_cycles(1); 0066: NOP .................... lcd_output_enable(1); 0068: BSF F8A.0 .................... delay_cycles(1); 006A: NOP .................... high = lcd_read_nibble(); 006C: RCALL 0050 006E: MOVFF 01,0E .................... .................... lcd_output_enable(0); 0072: BCF F8A.0 .................... delay_cycles(1); 0074: NOP .................... lcd_output_enable(1); 0076: BSF F8A.0 .................... delay_us(1); 0078: BRA 007A .................... low = lcd_read_nibble(); 007A: RCALL 0050 007C: MOVFF 01,0D .................... .................... lcd_output_enable(0); 0080: BCF F8A.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); .................... output_drive(LCD_DATA5); .................... output_drive(LCD_DATA6); .................... output_drive(LCD_DATA7); .................... #else .................... lcdtris.data = 0x0; 0082: MOVLW 0F 0084: ANDWF F93,W 0086: MOVWF F93 .................... #endif .................... #endif .................... .................... return( (high<<4) | low); 0088: SWAPF 0E,W 008A: MOVWF 00 008C: MOVLW F0 008E: ANDWF 00,F 0090: MOVF 00,W 0092: IORWF 0D,W 0094: MOVWF 01 0096: GOTO 00A4 (RETURN) .................... } .................... .................... unsigned int8 lcd_read_nibble(void) .................... { .................... #if (defined(LCD_DATA4) && defined(LCD_DATA5) && defined(LCD_DATA6) && defined(LCD_DATA7)) .................... unsigned int8 n = 0x00; .................... .................... /* Read the data port */ .................... n |= input(LCD_DATA4); .................... n |= input(LCD_DATA5) << 1; .................... n |= input(LCD_DATA6) << 2; .................... n |= input(LCD_DATA7) << 3; .................... .................... return(n); .................... #else .................... return(lcd.data); * 0050: MOVF F81,W 0052: MOVWF 00 0054: SWAPF 00,W 0056: ANDLW 0F 0058: MOVWF 01 .................... #endif 005A: RETURN 0 .................... } .................... .................... 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)); .................... output_bit(LCD_DATA5, bit_test(n, 1)); .................... output_bit(LCD_DATA6, bit_test(n, 2)); .................... output_bit(LCD_DATA7, bit_test(n, 3)); .................... #else .................... lcdlat.data = n; * 0036: SWAPF 0E,W 0038: ANDLW F0 003A: MOVWF 00 003C: MOVLW 0F 003E: ANDWF F8A,W 0040: IORWF 00,W 0042: MOVWF F8A .................... #endif .................... .................... delay_cycles(1); 0044: NOP .................... lcd_output_enable(1); 0046: BSF F8A.0 .................... delay_us(2); 0048: BRA 004A 004A: BRA 004C .................... lcd_output_enable(0); 004C: BCF F8A.0 004E: 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(); * 009A: BCF F93.0 .................... lcd_rs_tris(); 009C: BCF F93.1 .................... lcd_rw_tris(); 009E: BCF F93.2 .................... #endif .................... .................... lcd_output_rs(0); 00A0: BCF F8A.1 .................... while ( bit_test(lcd_read_byte(),7) ) ; 00A2: BRA 005C 00A4: MOVFF 01,0D 00A8: BTFSC 01.7 00AA: BRA 00A2 .................... lcd_output_rs(address); 00AC: BCF F8A.1 00AE: BTFSC 0B.0 00B0: BSF F8A.1 .................... delay_cycles(1); 00B2: NOP .................... lcd_output_rw(0); 00B4: BCF F8A.2 .................... delay_cycles(1); 00B6: NOP .................... lcd_output_enable(0); 00B8: BCF F8A.0 .................... lcd_send_nibble(n >> 4); 00BA: SWAPF 0C,W 00BC: MOVWF 0D 00BE: MOVLW 0F 00C0: ANDWF 0D,F 00C2: MOVFF 0D,0E 00C6: RCALL 0036 .................... lcd_send_nibble(n & 0xf); 00C8: MOVF 0C,W 00CA: ANDLW 0F 00CC: MOVWF 0D 00CE: MOVWF 0E 00D0: RCALL 0036 00D2: GOTO 0142 (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}; 00D6: MOVLW 28 00D8: MOVWF 06 00DA: MOVLW 0C 00DC: MOVWF 07 00DE: MOVLW 01 00E0: MOVWF 08 00E2: MOVLW 06 00E4: MOVWF 09 .................... // These bytes need to be sent to the LCD .................... // to start it up. .................... .................... .................... lcd_output_enable(0); 00E6: BCF F8A.0 .................... lcd_output_rs(0); 00E8: BCF F8A.1 .................... lcd_output_rw(0); 00EA: BCF F8A.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); .................... output_drive(LCD_DATA5); .................... output_drive(LCD_DATA6); .................... output_drive(LCD_DATA7); .................... #else .................... lcdtris.data = 0x0; 00EC: MOVLW 0F 00EE: ANDWF F93,W 00F0: MOVWF F93 .................... #endif .................... lcd_enable_tris(); 00F2: BCF F93.0 .................... lcd_rs_tris(); 00F4: BCF F93.1 .................... lcd_rw_tris(); 00F6: BCF F93.2 .................... #endif .................... .................... delay_ms(15); 00F8: MOVLW 0F 00FA: MOVWF 0A 00FC: RCALL 000C .................... for(i=1;i<=3;++i) 00FE: MOVLW 01 0100: MOVWF 05 0102: MOVF 05,W 0104: SUBLW 03 0106: BNC 0118 .................... { .................... lcd_send_nibble(3); 0108: MOVLW 03 010A: MOVWF 0E 010C: RCALL 0036 .................... delay_ms(5); 010E: MOVLW 05 0110: MOVWF 0A 0112: RCALL 000C 0114: INCF 05,F 0116: BRA 0102 .................... } .................... .................... lcd_send_nibble(2); 0118: MOVLW 02 011A: MOVWF 0E 011C: RCALL 0036 .................... delay_ms(5); 011E: MOVLW 05 0120: MOVWF 0A 0122: RCALL 000C .................... for(i=0;i<=3;++i) 0124: CLRF 05 0126: MOVF 05,W 0128: SUBLW 03 012A: BNC 0146 .................... lcd_send_byte(0,LCD_INIT_STRING[i]); 012C: CLRF 03 012E: MOVF 05,W 0130: ADDLW 06 0132: MOVWF FE9 0134: MOVLW 00 0136: ADDWFC 03,W 0138: MOVWF FEA 013A: MOVFF FEF,0C 013E: CLRF 0B 0140: BRA 009A .................... .................... #if defined(LCD_EXTENDED_NEWLINE) 0142: INCF 05,F 0144: BRA 0126 0146: GOTO 017E (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() 014A: CLRF FF8 014C: BCF FD0.7 014E: MOVLW 70 0150: MOVWF FD3 0152: CLRF F9B 0154: MOVF FD3,W 0156: BSF F94.3 0158: BSF F94.4 015A: MOVLW 04 015C: MOVWF FC8 015E: MOVLW 28 0160: MOVWF FC6 0162: BCF FC7.7 0164: BCF FC7.6 0166: MOVF FC1,W 0168: ANDLW C0 016A: IORLW 0F 016C: MOVWF FC1 016E: MOVLW 07 0170: MOVWF FB4 .................... { .................... setup_adc_ports(NO_ANALOGS, VSS_VDD); 0172: MOVF FC1,W 0174: ANDLW C0 0176: IORLW 0F 0178: MOVWF FC1 .................... init_ext_eeprom(); 017A: BRA 0004 .................... .................... lcd_init(); 017C: BRA 00D6 .................... .................... while(TRUE) .................... { 017E: BRA 017E .................... .................... .................... //TODO: User Code .................... } .................... .................... } 0180: SLEEP Configuration Fuses: Word 1: C800 INTRC_IO FCMEN IESO Word 2: 1E1E PUT BROWNOUT BORV21 NOWDT WDT32768 Word 3: 8700 CCP2C1 PBADEN LPT1OSC 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