From Tim's website
PIC Software - clock.lst
CCS PCM C Compiler, Version 3.023, 11997
Filename: D:\PIC\CLOCK3\CLOCK.LST
ROM used: 1103 (27%)
Largest free fragment is 2048
RAM used: 90 (47%) at main() level
147 (77%) worst case
Stack: 4 locations
*
0000: NOP
0001: MOVLW 00
0002: MOVWF 0A
0003: GOTO 240
.................... /* Device header and CCS compiler directives */
.................... #include <16f873.h>
.................... //////// Standard Header file for the PIC16F873 device ////////////////
.................... #device PIC16F873
.................... #list
....................
....................
.................... #device ICD=TRUE /* Incase we use the ICD */
.................... #device ADC=8 /* Only use the 8 MSBs */
.................... #use delay( clock=4000000 ) /* Set for a 4MHz Clock */
0004: MOVLW D0
0005: MOVWF 04
0006: MOVF 00,W
0007: BTFSC 03,2
0008: GOTO 018
0009: MOVLW 01
000A: MOVWF 21
000B: CLRF 20
000C: DECFSZ 20,F
000D: GOTO 00C
000E: DECFSZ 21,F
000F: GOTO 00B
0010: MOVLW 4A
0011: MOVWF 20
0012: DECFSZ 20,F
0013: GOTO 012
0014: NOP
0015: NOP
0016: DECFSZ 00,F
0017: GOTO 009
0018: RETLW 00
....................
.................... /* Include the code for the LCD display */
.................... #include "lcd.c"
.................... /* Define the hardware connections */
.................... const int LCD_EN_LINE = PIN_B1; /* Enable device, high-low to clock data */
.................... const int LCD_RW_LINE = PIN_B2; /* Read / Write line */
.................... const int LCD_RS_LINE = PIN_B3; /* Register Select line command or character */
.................... const int LCD_BUSY_PIN = PIN_C7; /* DB7 (connected to C7 shows busy flag */
....................
.................... /* Define some commands */
.................... const int LCD_CLEAR = 0x01; /* Clear the display and send cursor to Home */
.................... const int LCD_CUR_HOME = 0x02; /* Send the cursor to Home but keep display */
....................
.................... const int LCD_CUR_DEC = 0x04; /* Set cursor to move left after character */
.................... const int LCD_CUR_INC = 0x06; /* Set cursor to move right after character */
.................... const int LCD_CUR_SCR_R = 0x05; /* Set display to move right after character */
.................... const int LCD_CUR_SCR_L = 0x07; /* Set display to move left after character */
....................
.................... const int LCD_DISP_OFF = 0x08; /* Turn off the LCD display */
.................... const int LCD_DISP_ON = 0x0C; /* Turn on display, no cursor */
.................... const int LCD_DISP_CUR = 0x0E; /* Turn on display, with cursor */
.................... const int LCD_DISP_BLINK = 0x0F; /* Turn on display, with blinking cursor */
....................
.................... const int LCD_SHFT_CUR_L = 0x10; /* Decrement the cursor (move left) */
.................... const int LCD_SHFT_CUR_R = 0x14; /* Increment the cursor (move right) */
.................... const int LCD_SHFT_SCR_L = 0x18; /* Shift the display (scroll) to the left */
.................... const int LCD_SHFT_SCR_R = 0x1C; /* Shift the display (scroll) to the right */
....................
.................... const int LCD_SIZE_LARGE = 0x34; /* Large cursor, one line, 8 bit interface */
.................... const int LCD_SIZE_SMALL = 0x38; /* Small cursor, two lines, 8 bit interface */
....................
.................... /* Address is added to the following two values, up to 0F for each line */
.................... const int LCD_DD_ADD_L1 = 0x80; /* First Display RAM address on Line 1 */
.................... const int LCD_DD_ADD_L2 = 0xC0; /* First Display RAM address on Line 2 */
....................
.................... /* Line number for dots is added to each of the following addresses, up to 07 */
.................... const int LCD_CG_ADD_C0 = 0x40; /* First Character Generator RAM address */
.................... const int LCD_CG_ADD_C1 = 0x48; /* Second Character Generator RAM address */
.................... const int LCD_CG_ADD_C2 = 0x50; /* Third Character Generator RAM address */
.................... const int LCD_CG_ADD_C3 = 0x58; /* Fourth Character Generator RAM address */
.................... const int LCD_CG_ADD_C4 = 0x60; /* Fifth Character Generator RAM address */
.................... const int LCD_CG_ADD_C5 = 0x68; /* Sixth Character Generator RAM address */
.................... const int LCD_CG_ADD_C6 = 0x70; /* Seventh Character Generator RAM address */
.................... const int LCD_CG_ADD_C7 = 0x78; /* Eighth Character Generator RAM address */
....................
....................
.................... /* Functions */
.................... void lcd_command( char command );
.................... void lcd_character( char character );
.................... void lcd_number( int number );
.................... void lcd_initialise( int size );
....................
....................
.................... void lcd_command( char command )
.................... /* Sends the given command to the LCD display. Most of the commands are */
.................... /* defined in the header. This function will wait for the busy flag on the */
.................... /* display to clear before sending the command and returning. */
.................... {
.................... output_low( LCD_RS_LINE );
0019: BSF 03,5
001A: BCF 06,3
001B: BCF 03,5
001C: BCF 06,3
.................... output_high( LCD_RW_LINE );
001D: BSF 03,5
001E: BCF 06,2
001F: BCF 03,5
0020: BSF 06,2
....................
.................... /* Wait for busy flag */
.................... while( input( LCD_BUSY_PIN ) );
0021: BSF 25,7
0022: MOVF 25,W
0023: BSF 03,5
0024: MOVWF 07
0025: BCF 03,5
0026: BTFSC 07,7
0027: GOTO 021
0028: GOTO 029
....................
.................... output_low( LCD_RW_LINE );
0029: BSF 03,5
002A: BCF 06,2
002B: BCF 03,5
002C: BCF 06,2
....................
.................... /* Send the command */
.................... output_c( command );
002D: MOVLW 00
002E: MOVWF 25
002F: BSF 03,5
0030: MOVWF 07
0031: MOVF 4F,W
0032: BCF 03,5
0033: MOVWF 07
.................... output_low( LCD_EN_LINE );
0034: BSF 03,5
0035: BCF 06,1
0036: BCF 03,5
0037: BCF 06,1
.................... delay_us( 200 );
0038: MOVLW 42
0039: MOVWF 20
003A: DECFSZ 20,F
003B: GOTO 03A
003C: NOP
.................... output_high( LCD_EN_LINE );
003D: BSF 03,5
003E: BCF 06,1
003F: BCF 03,5
0040: BSF 06,1
....................
.................... /* Impose a 5ms delay while the command is processed */
.................... delay_ms( 5 );
0041: MOVLW 05
0042: BSF 03,5
0043: MOVWF 50
0044: BCF 03,5
0045: CALL 004
0046: RETLW 00
.................... }
....................
....................
.................... void lcd_character( char character )
.................... /* Sends the given character to the LCD display. ASCII Numbers and letters */
.................... /* are valid, and punctuation below 0x7F. Characters 0x00 to 0x0F are the */
.................... /* Generated Characters, which will be blank initially. Other useful symbols */
.................... /* and Greek characters may be found in the range 0x80 to 0xFF */
.................... {
.................... output_low( LCD_RS_LINE );
*
0093: BSF 03,5
0094: BCF 06,3
0095: BCF 03,5
0096: BCF 06,3
.................... output_high( LCD_RW_LINE );
0097: BSF 03,5
0098: BCF 06,2
0099: BCF 03,5
009A: BSF 06,2
....................
.................... /* Wait for busy flag */
.................... while( input( LCD_BUSY_PIN ) );
009B: BSF 25,7
009C: MOVF 25,W
009D: BSF 03,5
009E: MOVWF 07
009F: BCF 03,5
00A0: BTFSC 07,7
00A1: GOTO 09B
00A2: GOTO 0A3
....................
.................... output_low( LCD_RW_LINE );
00A3: BSF 03,5
00A4: BCF 06,2
00A5: BCF 03,5
00A6: BCF 06,2
.................... output_high( LCD_RS_LINE );
00A7: BSF 03,5
00A8: BCF 06,3
00A9: BCF 03,5
00AA: BSF 06,3
....................
.................... /* Send the command */
.................... output_c( character );
00AB: MOVLW 00
00AC: MOVWF 25
00AD: BSF 03,5
00AE: MOVWF 07
00AF: MOVF 53,W
00B0: BCF 03,5
00B1: MOVWF 07
.................... output_low( LCD_EN_LINE );
00B2: BSF 03,5
00B3: BCF 06,1
00B4: BCF 03,5
00B5: BCF 06,1
.................... delay_us( 200 );
00B6: MOVLW 42
00B7: MOVWF 20
00B8: DECFSZ 20,F
00B9: GOTO 0B8
00BA: NOP
.................... output_high( LCD_EN_LINE );
00BB: BSF 03,5
00BC: BCF 06,1
00BD: BCF 03,5
00BE: BSF 06,1
00BF: RETLW 00
.................... }
....................
....................
.................... void lcd_number( int number )
.................... /* Sends the given number to the LCD display, with up to 2 characters. This */
.................... /* limits number to 100 */
.................... {
.................... int tens = 0;
*
00EF: CLRF 50
00F0: CLRF 51
00F1: BCF 03,5
.................... int units = 0;
....................
.................... while( number > 9 )
00F2: BSF 03,5
00F3: MOVF 4F,W
00F4: SUBLW 09
00F5: BTFSS 03,0
00F6: GOTO 0F9
00F7: BCF 03,5
00F8: GOTO 100
00F9: BCF 03,5
.................... {
.................... tens++;
00FA: BSF 03,5
00FB: INCF 50,F
.................... number -= 10;
00FC: MOVLW 0A
00FD: SUBWF 4F,F
.................... }
00FE: BCF 03,5
00FF: GOTO 0F2
.................... units = number;
0100: BSF 03,5
0101: MOVF 4F,W
0102: MOVWF 51
....................
.................... lcd_character( '0' + tens );
0103: MOVLW 30
0104: ADDWF 50,W
0105: MOVWF 52
0106: MOVWF 53
0107: BCF 03,5
0108: CALL 093
.................... lcd_character( '0' + units );
0109: MOVLW 30
010A: BSF 03,5
010B: ADDWF 51,W
010C: MOVWF 52
010D: MOVWF 53
010E: BCF 03,5
010F: CALL 093
.................... }
....................
....................
.................... void lcd_initialise( int size )
.................... /* Initialises the display incase the initialisation at startup failed or the */
.................... /* cursor size is to be changed. 'size' is LCD_SIZE_SMALL or LCD_SIZE_LARGE */
.................... {
.................... int i;
....................
.................... delay_ms( 15 );
*
0047: MOVLW 0F
0048: BSF 03,5
0049: MOVWF 50
004A: BCF 03,5
004B: CALL 004
.................... output_low( LCD_RS_LINE );
004C: BSF 03,5
004D: BCF 06,3
004E: BCF 03,5
004F: BCF 06,3
....................
.................... for( i = 0; i < 3; i++ )
0050: BSF 03,5
0051: CLRF 49
0052: BCF 03,5
0053: BSF 03,5
0054: MOVF 49,W
0055: SUBLW 02
0056: BTFSC 03,0
0057: GOTO 05A
0058: BCF 03,5
0059: GOTO 078
005A: BCF 03,5
.................... {
.................... output_c( size );
005B: MOVLW 00
005C: MOVWF 25
005D: BSF 03,5
005E: MOVWF 07
005F: MOVF 48,W
0060: BCF 03,5
0061: MOVWF 07
....................
.................... output_low( LCD_EN_LINE );
0062: BSF 03,5
0063: BCF 06,1
0064: BCF 03,5
0065: BCF 06,1
.................... delay_us( 200 );
0066: MOVLW 42
0067: MOVWF 20
0068: DECFSZ 20,F
0069: GOTO 068
006A: NOP
.................... output_high( LCD_EN_LINE );
006B: BSF 03,5
006C: BCF 06,1
006D: BCF 03,5
006E: BSF 06,1
....................
.................... delay_ms( 5 );
006F: MOVLW 05
0070: BSF 03,5
0071: MOVWF 50
0072: BCF 03,5
0073: CALL 004
.................... }
0074: BSF 03,5
0075: INCF 49,F
0076: BCF 03,5
0077: GOTO 053
....................
.................... lcd_command( size );
0078: BSF 03,5
0079: MOVF 48,W
007A: MOVWF 4F
007B: BCF 03,5
007C: CALL 019
.................... lcd_command( LCD_DISP_OFF );
007D: MOVLW 08
007E: BSF 03,5
007F: MOVWF 4F
0080: BCF 03,5
0081: CALL 019
.................... lcd_command( LCD_DISP_ON );
0082: MOVLW 0C
0083: BSF 03,5
0084: MOVWF 4F
0085: BCF 03,5
0086: CALL 019
.................... lcd_command( LCD_CUR_INC );
0087: MOVLW 06
0088: BSF 03,5
0089: MOVWF 4F
008A: BCF 03,5
008B: CALL 019
.................... lcd_command( LCD_CLEAR );
008C: MOVLW 01
008D: BSF 03,5
008E: MOVWF 4F
008F: BCF 03,5
0090: CALL 019
0091: BCF 0A,3
0092: GOTO 2FE
.................... }
....................
....................
....................
.................... /* Define the hardware connections */
.................... const int CLOCK_EN_LINE = PIN_B0; /* Enable device */
.................... const int CLOCK_DATA_PIN = 0; /* Clock Data connected to ADC pin 0 */
.................... const int CLOCK_DATA_LED = PIN_B5; /* LED to show incomming pulses */
.................... const int CLOCK_EROR_LED = PIN_B4; /* LED to show error reading pulses */
....................
.................... const int THRESHOLD = 0x80;
....................
.................... enum PULSE_TYPE { PT_ERROR, /* Unidentified pulse */
.................... PT_SHORT, /* 75ms to 175ms pulse */
.................... PT_LONG, /* 175ms to 375ms pulse */
.................... PT_DOUBLE, /* Two short pulses */
.................... PT_START}; /* 375ms to 600ms pulse */
....................
....................
.................... /* Global Variables */
.................... int seconds = 0;
....................
.................... /* Functions */
.................... PULSE_TYPE clock_get_pulse();
.................... int clock_get_value( int no_of_pulses );
....................
....................
.................... PULSE_TYPE clock_get_pulse()
.................... /* Waits for the next pulse and returns the type of pulse */
.................... /* this can be LONG, SHORT, START, DOUBLE or ERROR as */
.................... /* defined in the enumeration above */
.................... {
.................... int pulse_shape;
.................... int i;
.................... int factor;
....................
.................... set_adc_channel( CLOCK_DATA_PIN );
*
00C0: MOVLW 00
00C1: MOVWF 21
00C2: MOVF 1F,W
00C3: ANDLW C7
00C4: IORWF 21,W
00C5: MOVWF 1F
.................... output_low( CLOCK_DATA_LED );
00C6: BSF 03,5
00C7: BCF 06,5
00C8: BCF 03,5
00C9: BCF 06,5
....................
.................... /* Wait for the input to go high */
.................... while( TRUE )
.................... {
.................... if( read_adc() > THRESHOLD )
00CA: BSF 1F,2
00CB: BTFSC 1F,2
00CC: GOTO 0CB
00CD: MOVF 1E,W
00CE: SUBLW 80
00CF: BTFSS 03,0
.................... break;
00D0: GOTO 0D2
.................... }
00D1: GOTO 0CA
.................... output_high( CLOCK_DATA_LED );
00D2: BSF 03,5
00D3: BCF 06,5
00D4: BCF 03,5
00D5: BSF 06,5
....................
.................... /* Wait for the input to go low */
.................... while( TRUE )
.................... {
.................... if( read_adc() < THRESHOLD )
00D6: BSF 1F,2
00D7: BTFSC 1F,2
00D8: GOTO 0D7
00D9: MOVF 1E,W
00DA: SUBLW 7F
00DB: BTFSC 03,0
.................... break;
00DC: GOTO 0DE
.................... }
00DD: GOTO 0D6
.................... output_low( CLOCK_DATA_LED );
00DE: BSF 03,5
00DF: BCF 06,5
00E0: BCF 03,5
00E1: BCF 06,5
....................
.................... /* Increment the seconds and display */
.................... lcd_command( LCD_DD_ADD_L2 + 7 );
00E2: MOVLW C7
00E3: BSF 03,5
00E4: MOVWF 4F
00E5: BCF 03,5
00E6: CALL 019
.................... if( ++seconds == 60 )
00E7: INCF 26,F
00E8: MOVF 26,W
00E9: SUBLW 3C
00EA: BTFSC 03,2
.................... seconds = 0;
00EB: CLRF 26
.................... lcd_number( seconds );
00EC: MOVF 26,W
00ED: BSF 03,5
00EE: MOVWF 4F
....................
.................... pulse_shape = 0;
*
0110: BSF 03,5
0111: CLRF 4C
.................... factor = 2;
0112: MOVLW 02
0113: MOVWF 4E
....................
.................... /* Record the shape of the pulse */
.................... delay_ms( 70 ); /* after 70ms */
0114: MOVLW 46
0115: MOVWF 50
0116: BCF 03,5
0117: CALL 004
.................... if( read_adc() < THRESHOLD )
0118: BSF 1F,2
0119: BTFSC 1F,2
011A: GOTO 119
011B: MOVF 1E,W
011C: SUBLW 7F
011D: BTFSS 03,0
011E: GOTO 128
.................... {
.................... output_low( CLOCK_DATA_LED );
011F: BSF 03,5
0120: BCF 06,5
0121: BCF 03,5
0122: BCF 06,5
.................... pulse_shape += 1;
0123: MOVLW 01
0124: BSF 03,5
0125: ADDWF 4C,F
.................... }
.................... else
0126: BCF 03,5
0127: GOTO 12C
.................... output_high( CLOCK_DATA_LED );
0128: BSF 03,5
0129: BCF 06,5
012A: BCF 03,5
012B: BSF 06,5
....................
.................... for( i = 0; i < 3; i++ )
012C: BSF 03,5
012D: CLRF 4D
012E: BCF 03,5
012F: BSF 03,5
0130: MOVF 4D,W
0131: SUBLW 02
0132: BTFSC 03,0
0133: GOTO 136
0134: BCF 03,5
0135: GOTO 158
0136: BCF 03,5
.................... {
.................... /* After 170, 270 and 370ms */
.................... delay_ms( 100 );
0137: MOVLW 64
0138: BSF 03,5
0139: MOVWF 50
013A: BCF 03,5
013B: CALL 004
.................... if( read_adc() < THRESHOLD )
013C: BSF 1F,2
013D: BTFSC 1F,2
013E: GOTO 13D
013F: MOVF 1E,W
0140: SUBLW 7F
0141: BTFSS 03,0
0142: GOTO 14C
.................... {
.................... output_low( CLOCK_DATA_LED );
0143: BSF 03,5
0144: BCF 06,5
0145: BCF 03,5
0146: BCF 06,5
.................... pulse_shape += factor;
0147: BSF 03,5
0148: MOVF 4E,W
0149: ADDWF 4C,F
.................... }
.................... else
014A: BCF 03,5
014B: GOTO 150
.................... output_high( CLOCK_DATA_LED );
014C: BSF 03,5
014D: BCF 06,5
014E: BCF 03,5
014F: BSF 06,5
....................
.................... factor *= 2;
0150: BCF 03,0
0151: BSF 03,5
0152: RLF 4E,F
0153: BCF 03,5
.................... }
0154: BSF 03,5
0155: INCF 4D,F
0156: BCF 03,5
0157: GOTO 12F
....................
.................... /* Wait out the rest of the period */
.................... if( read_adc() > THRESHOLD )
0158: BSF 1F,2
0159: BTFSC 1F,2
015A: GOTO 159
015B: MOVF 1E,W
015C: SUBLW 80
015D: BTFSC 03,0
015E: GOTO 16F
.................... delay_ms( 600 );
015F: MOVLW 03
0160: BSF 03,5
0161: MOVWF 4F
0162: BCF 03,5
0163: MOVLW C8
0164: BSF 03,5
0165: MOVWF 50
0166: BCF 03,5
0167: CALL 004
0168: BSF 03,5
0169: DECFSZ 4F,F
016A: GOTO 16C
016B: GOTO 16E
016C: BCF 03,5
016D: GOTO 163
016E: BCF 03,5
....................
.................... switch( pulse_shape )
016F: BSF 03,5
0170: MOVF 4C,W
0171: ADDLW F0
0172: BTFSS 03,0
0173: GOTO 176
0174: BCF 03,5
0175: GOTO 1A8
0176: ADDLW 10
0177: BCF 03,5
0178: GOTO 1AB
.................... {
.................... case 0:
.................... case 2:
.................... case 4:
.................... case 8:
.................... output_low( CLOCK_EROR_LED );
0179: BSF 03,5
017A: BCF 06,4
017B: BCF 03,5
017C: BCF 06,4
.................... return PT_ERROR;
017D: MOVLW 00
017E: MOVWF 21
017F: GOTO 1AA
.................... case 1:
.................... return PT_SHORT;
0180: MOVLW 01
0181: MOVWF 21
0182: GOTO 1AA
.................... case 3:
.................... case 7:
.................... return PT_LONG;
0183: MOVLW 02
0184: MOVWF 21
0185: GOTO 1AA
.................... case 5:
.................... return PT_DOUBLE;
0186: MOVLW 03
0187: MOVWF 21
0188: GOTO 1AA
.................... case 15:
.................... /* Check the low ends after 500ms */
.................... delay_ms( 230 ); /* after 600ms */
0189: MOVLW E6
018A: BSF 03,5
018B: MOVWF 50
018C: BCF 03,5
018D: CALL 004
.................... if( read_adc() < THRESHOLD )
018E: BSF 1F,2
018F: BTFSC 1F,2
0190: GOTO 18F
0191: MOVF 1E,W
0192: SUBLW 7F
0193: BTFSS 03,0
0194: GOTO 19D
.................... {
.................... output_low( CLOCK_EROR_LED );
0195: BSF 03,5
0196: BCF 06,4
0197: BCF 03,5
0198: BCF 06,4
.................... return PT_ERROR;
0199: MOVLW 00
019A: MOVWF 21
019B: GOTO 1AA
.................... }
.................... else
019C: GOTO 1A8
.................... {
.................... output_high( CLOCK_DATA_LED );
019D: BSF 03,5
019E: BCF 06,5
019F: BCF 03,5
01A0: BSF 06,5
.................... output_high( CLOCK_EROR_LED );
01A1: BSF 03,5
01A2: BCF 06,4
01A3: BCF 03,5
01A4: BSF 06,4
.................... return PT_START;
01A5: MOVLW 04
01A6: MOVWF 21
01A7: GOTO 1AA
.................... }
.................... }
*
01AB: BSF 0A,0
01AC: BCF 0A,1
01AD: BCF 0A,2
01AE: ADDWF 02,F
01AF: GOTO 179
01B0: GOTO 180
01B1: GOTO 179
01B2: GOTO 183
01B3: GOTO 179
01B4: GOTO 186
01B5: GOTO 1A8
01B6: GOTO 183
01B7: GOTO 179
01B8: GOTO 1A8
01B9: GOTO 1A8
01BA: GOTO 1A8
01BB: GOTO 1A8
01BC: GOTO 1A8
01BD: GOTO 1A8
01BE: GOTO 189
....................
.................... return PT_ERROR;
*
01A8: MOVLW 00
01A9: MOVWF 21
01AA: RETLW 00
.................... }
....................
....................
.................... int clock_get_value( int no_of_pulses )
.................... /* Collects the given number of pulses and returns the */
.................... /* decimal value where the first pulse is the most MSB. */
.................... /* 255 is returned as an error. */
.................... {
.................... PULSE_TYPE pulse;
.................... int p;
*
01BF: BSF 03,5
01C0: CLRF 4B
.................... int value = 0;
....................
.................... for( p = 0; p < no_of_pulses; p++ )
01C1: CLRF 4A
01C2: BCF 03,5
01C3: BSF 03,5
01C4: MOVF 48,W
01C5: SUBWF 4A,W
01C6: BTFSS 03,0
01C7: GOTO 1CA
01C8: BCF 03,5
01C9: GOTO 1EE
01CA: BCF 03,5
.................... {
.................... pulse = clock_get_pulse();
01CB: CALL 0C0
01CC: MOVF 21,W
01CD: BSF 03,5
01CE: MOVWF 49
....................
.................... switch( pulse )
01CF: MOVF 49,W
01D0: BCF 03,5
01D1: MOVWF 20
01D2: MOVLW 01
01D3: SUBWF 20,W
01D4: BTFSC 03,2
01D5: GOTO 1DB
01D6: MOVLW 02
01D7: SUBWF 20,W
01D8: BTFSC 03,2
01D9: GOTO 1E0
01DA: GOTO 1E7
.................... {
.................... case PT_SHORT:
.................... value *= 2;
01DB: BCF 03,0
01DC: BSF 03,5
01DD: RLF 4B,F
.................... break;
01DE: BCF 03,5
01DF: GOTO 1EA
.................... case PT_LONG:
.................... value *= 2;
01E0: BCF 03,0
01E1: BSF 03,5
01E2: RLF 4B,F
.................... value += 1;
01E3: MOVLW 01
01E4: ADDWF 4B,F
.................... break;
01E5: BCF 03,5
01E6: GOTO 1EA
.................... default:
.................... return 255;
01E7: MOVLW FF
01E8: MOVWF 21
01E9: GOTO 1F2
.................... }
.................... }
01EA: BSF 03,5
01EB: INCF 4A,F
01EC: BCF 03,5
01ED: GOTO 1C3
....................
.................... return value;
01EE: BSF 03,5
01EF: MOVF 4B,W
01F0: BCF 03,5
01F1: MOVWF 21
01F2: RETLW 00
.................... }
....................
.................... void main()
.................... /* This loop Waits for the start pulse and then decodes */
.................... /* the following 51 pulses to get the time and date. */
.................... {
.................... int i;
.................... int value1;
.................... int value2;
.................... char please_wait[15] = "Please Wait...";
.................... char day[22] = "SunMonTueWedThuFriSat";
*
0248: MOVLW 50
0249: MOVWF 2A
024A: MOVLW 6C
024B: MOVWF 2B
024C: MOVLW 65
024D: MOVWF 2C
024E: MOVLW 61
024F: MOVWF 2D
0250: MOVLW 73
0251: MOVWF 2E
0252: MOVLW 65
0253: MOVWF 2F
0254: MOVLW 20
0255: MOVWF 30
0256: MOVLW 57
0257: MOVWF 31
0258: MOVLW 61
0259: MOVWF 32
025A: MOVLW 69
025B: MOVWF 33
025C: MOVLW 74
025D: MOVWF 34
025E: MOVLW 2E
025F: MOVWF 35
0260: MOVLW 2E
0261: MOVWF 36
0262: MOVLW 2E
0263: MOVWF 37
0264: CLRF 38
0265: MOVLW 53
0266: MOVWF 39
0267: MOVLW 75
0268: MOVWF 3A
0269: MOVLW 6E
026A: MOVWF 3B
026B: MOVLW 4D
026C: MOVWF 3C
026D: MOVLW 6F
026E: MOVWF 3D
026F: MOVLW 6E
0270: MOVWF 3E
0271: MOVLW 54
0272: MOVWF 3F
0273: MOVLW 75
0274: MOVWF 40
0275: MOVLW 65
0276: MOVWF 41
0277: MOVLW 57
0278: MOVWF 42
0279: MOVLW 65
027A: MOVWF 43
027B: MOVLW 64
027C: MOVWF 44
027D: MOVLW 54
027E: MOVWF 45
027F: MOVLW 68
0280: MOVWF 46
0281: MOVLW 75
0282: MOVWF 47
0283: MOVLW 46
0284: MOVWF 48
0285: MOVLW 72
0286: MOVWF 49
0287: MOVLW 69
0288: MOVWF 4A
0289: MOVLW 53
028A: MOVWF 4B
028B: MOVLW 61
028C: MOVWF 4C
028D: MOVLW 74
028E: MOVWF 4D
028F: CLRF 4E
0290: MOVLW 20
0291: BSF 03,5
0292: MOVWF 20
0293: MOVLW 20
0294: MOVWF 21
0295: MOVLW 20
0296: MOVWF 22
0297: MOVLW 4A
0298: MOVWF 23
0299: MOVLW 61
029A: MOVWF 24
029B: MOVLW 6E
029C: MOVWF 25
029D: MOVLW 46
029E: MOVWF 26
029F: MOVLW 65
02A0: MOVWF 27
02A1: MOVLW 62
02A2: MOVWF 28
02A3: MOVLW 4D
02A4: MOVWF 29
02A5: MOVLW 61
02A6: MOVWF 2A
02A7: MOVLW 72
02A8: MOVWF 2B
02A9: MOVLW 41
02AA: MOVWF 2C
02AB: MOVLW 70
02AC: MOVWF 2D
02AD: MOVLW 72
02AE: MOVWF 2E
02AF: MOVLW 4D
02B0: MOVWF 2F
02B1: MOVLW 61
02B2: MOVWF 30
02B3: MOVLW 79
02B4: MOVWF 31
02B5: MOVLW 4A
02B6: MOVWF 32
02B7: MOVLW 75
02B8: MOVWF 33
02B9: MOVLW 6E
02BA: MOVWF 34
02BB: MOVLW 4A
02BC: MOVWF 35
02BD: MOVLW 75
02BE: MOVWF 36
02BF: MOVLW 6C
02C0: MOVWF 37
02C1: MOVLW 41
02C2: MOVWF 38
02C3: MOVLW 75
02C4: MOVWF 39
02C5: MOVLW 67
02C6: MOVWF 3A
02C7: MOVLW 53
02C8: MOVWF 3B
02C9: MOVLW 65
02CA: MOVWF 3C
02CB: MOVLW 70
02CC: MOVWF 3D
02CD: MOVLW 4F
02CE: MOVWF 3E
02CF: MOVLW 63
02D0: MOVWF 3F
02D1: MOVLW 74
02D2: MOVWF 40
02D3: MOVLW 4E
02D4: MOVWF 41
02D5: MOVLW 6F
02D6: MOVWF 42
02D7: MOVLW 76
02D8: MOVWF 43
02D9: MOVLW 44
02DA: MOVWF 44
02DB: MOVLW 65
02DC: MOVWF 45
02DD: MOVLW 63
02DE: MOVWF 46
02DF: CLRF 47
.................... char month[40] = " JanFebMarAprMayJunJulAugSepOctNovDec";
*
0240: CLRF 04
0241: MOVLW 9F
0242: MOVWF 04
0243: MOVLW 07
0244: MOVWF 00
0245: MOVLW FF
0246: MOVWF 25
0247: CLRF 26
....................
.................... setup_counters( RTCC_INTERNAL, RTCC_DIV_256 );
*
02E0: MOVLW 07
02E1: BCF 03,5
02E2: MOVWF 20
02E3: BTFSS 20,3
02E4: GOTO 2ED
02E5: MOVLW 07
02E6: CLRF 01
02E7: MOVLW 81
02E8: MOVWF 04
02E9: MOVF 00,W
02EA: ANDLW C0
02EB: IORLW 0F
02EC: MOVWF 00
02ED: CLRWDT
02EE: MOVLW 81
02EF: MOVWF 04
02F0: MOVF 00,W
02F1: ANDLW C0
02F2: IORWF 20,W
02F3: MOVWF 00
.................... setup_adc( ADC_CLOCK_INTERNAL );
02F4: MOVF 1F,W
02F5: ANDLW 38
02F6: IORLW C1
02F7: MOVWF 1F
.................... setup_adc_ports( ALL_ANALOG );
02F8: BSF 03,5
02F9: CLRF 1F
....................
.................... lcd_initialise( LCD_SIZE_SMALL );
02FA: MOVLW 38
02FB: MOVWF 48
02FC: BCF 03,5
02FD: GOTO 047
....................
.................... /* Enable the rugby clock */
.................... output_low( PIN_B0 );
02FE: BSF 03,5
02FF: BCF 06,0
0300: BCF 03,5
0301: BCF 06,0
....................
.................... /* Put up the 'Please Wait...' message */
.................... for( i = 0; i < 14; i++ )
0302: CLRF 27
0303: MOVF 27,W
0304: SUBLW 0D
0305: BTFSS 03,0
0306: GOTO 312
.................... lcd_character( please_wait[i] );
0307: MOVLW 2A
0308: ADDWF 27,W
0309: MOVWF 04
030A: MOVF 00,W
030B: MOVWF 4F
030C: BSF 03,5
030D: MOVWF 53
030E: BCF 03,5
030F: CALL 093
0310: INCF 27,F
0311: GOTO 303
.................... seconds = 0;
0312: CLRF 26
....................
.................... /* Wait for the start pulse from the clock */
.................... while( clock_get_pulse() != PT_START );
0313: CALL 0C0
0314: MOVF 21,W
0315: SUBLW 04
0316: BTFSC 03,2
0317: GOTO 319
0318: GOTO 313
.................... lcd_command( LCD_CLEAR );
0319: MOVLW 01
031A: BSF 03,5
031B: MOVWF 4F
031C: BCF 03,5
031D: CALL 019
.................... seconds = 0;
031E: CLRF 26
....................
.................... while( TRUE )
.................... {
.................... /* Count the number of double pulses and display */
.................... value1 = 0;
031F: CLRF 28
.................... for( i = 0; i < 8; i++ )
0320: CLRF 27
0321: MOVF 27,W
0322: SUBLW 07
0323: BTFSS 03,0
0324: GOTO 32C
.................... {
.................... if( clock_get_pulse() == PT_DOUBLE )
0325: CALL 0C0
0326: MOVF 21,W
0327: SUBLW 03
0328: BTFSC 03,2
.................... value1--;
0329: DECF 28,F
.................... }
032A: INCF 27,F
032B: GOTO 321
.................... for( i = 8; i < 16; i++ )
032C: MOVLW 08
032D: MOVWF 27
032E: MOVF 27,W
032F: SUBLW 0F
0330: BTFSS 03,0
0331: GOTO 339
.................... {
.................... if( clock_get_pulse() == PT_DOUBLE )
0332: CALL 0C0
0333: MOVF 21,W
0334: SUBLW 03
0335: BTFSC 03,2
.................... value1++;
0336: INCF 28,F
.................... }
0337: INCF 27,F
0338: GOTO 32E
.................... lcd_command( LCD_DD_ADD_L2 + 11 );
0339: MOVLW CB
033A: BSF 03,5
033B: MOVWF 4F
033C: BCF 03,5
033D: CALL 019
.................... lcd_character( '(' );
033E: MOVLW 28
033F: BSF 03,5
0340: MOVWF 53
0341: BCF 03,5
0342: CALL 093
.................... lcd_character( '+' );
0343: MOVLW 2B
0344: BSF 03,5
0345: MOVWF 53
0346: BCF 03,5
0347: CALL 093
.................... if( value1 < 0 )
.................... {
.................... lcd_command( LCD_SHFT_CUR_L );
.................... lcd_character( '-' );
.................... value1 = -value1;
.................... }
.................... lcd_character( '0' + value1 );
0348: MOVLW 30
0349: ADDWF 28,W
034A: MOVWF 4F
034B: BSF 03,5
034C: MOVWF 53
034D: BCF 03,5
034E: CALL 093
.................... lcd_character( ')' );
034F: MOVLW 29
0350: BSF 03,5
0351: MOVWF 53
0352: BCF 03,5
0353: CALL 093
....................
.................... /* Get the Year and display */
.................... value1 = clock_get_value( 4 );
0354: MOVLW 04
0355: BSF 03,5
0356: MOVWF 48
0357: BCF 03,5
0358: CALL 1BF
0359: MOVF 21,W
035A: MOVWF 28
.................... value2 = clock_get_value( 4 );
035B: MOVLW 04
035C: BSF 03,5
035D: MOVWF 48
035E: BCF 03,5
035F: CALL 1BF
0360: MOVF 21,W
0361: MOVWF 29
.................... lcd_command( LCD_DD_ADD_L1 + 11 );
0362: MOVLW 8B
0363: BSF 03,5
0364: MOVWF 4F
0365: BCF 03,5
0366: CALL 019
.................... lcd_character( '2' );
0367: MOVLW 32
0368: BSF 03,5
0369: MOVWF 53
036A: BCF 03,5
036B: CALL 093
.................... lcd_character( '0' );
036C: MOVLW 30
036D: BSF 03,5
036E: MOVWF 53
036F: BCF 03,5
0370: CALL 093
.................... lcd_character( '0' + value1 );
0371: MOVLW 30
0372: ADDWF 28,W
0373: MOVWF 4F
0374: BSF 03,5
0375: MOVWF 53
0376: BCF 03,5
0377: CALL 093
.................... lcd_character( '0' + value2 );
0378: MOVLW 30
0379: ADDWF 29,W
037A: MOVWF 4F
037B: BSF 03,5
037C: MOVWF 53
037D: BCF 03,5
037E: CALL 093
....................
.................... /* Get the Month and display */
.................... value1 = clock_get_value( 1 );
037F: MOVLW 01
0380: BSF 03,5
0381: MOVWF 48
0382: BCF 03,5
0383: CALL 1BF
0384: MOVF 21,W
0385: MOVWF 28
.................... value2 = clock_get_value( 4 );
0386: MOVLW 04
0387: BSF 03,5
0388: MOVWF 48
0389: BCF 03,5
038A: CALL 1BF
038B: MOVF 21,W
038C: MOVWF 29
.................... lcd_command( LCD_DD_ADD_L1 + 7 );
038D: MOVLW 87
038E: BSF 03,5
038F: MOVWF 4F
0390: BCF 03,5
0391: CALL 019
.................... value1 = 10 * value1 + value2;
*
01F3: CLRF 20
01F4: CLRF 21
01F5: BSF 03,5
01F6: MOVF 48,W
01F7: BCF 03,0
01F8: BTFSS 49,0
01F9: GOTO 1FD
01FA: BCF 03,5
01FB: ADDWF 20,F
01FC: BSF 03,5
01FD: BCF 03,5
01FE: RRF 20,F
01FF: RRF 21,F
0200: BSF 03,5
0201: BTFSS 49,1
0202: GOTO 206
0203: BCF 03,5
0204: ADDWF 20,F
0205: BSF 03,5
0206: BCF 03,5
0207: RRF 20,F
0208: RRF 21,F
0209: BSF 03,5
020A: BTFSS 49,2
020B: GOTO 20F
020C: BCF 03,5
020D: ADDWF 20,F
020E: BSF 03,5
020F: BCF 03,5
0210: RRF 20,F
0211: RRF 21,F
0212: BSF 03,5
0213: BTFSS 49,3
0214: GOTO 218
0215: BCF 03,5
0216: ADDWF 20,F
0217: BSF 03,5
0218: BCF 03,5
0219: RRF 20,F
021A: RRF 21,F
021B: BSF 03,5
021C: BTFSS 49,4
021D: GOTO 221
021E: BCF 03,5
021F: ADDWF 20,F
0220: BSF 03,5
0221: BCF 03,5
0222: RRF 20,F
0223: RRF 21,F
0224: BSF 03,5
0225: BTFSS 49,5
0226: GOTO 22A
0227: BCF 03,5
0228: ADDWF 20,F
0229: BSF 03,5
022A: BCF 03,5
022B: RRF 20,F
022C: RRF 21,F
022D: BSF 03,5
022E: BTFSS 49,6
022F: GOTO 233
0230: BCF 03,5
0231: ADDWF 20,F
0232: BSF 03,5
0233: BCF 03,5
0234: RRF 20,F
0235: RRF 21,F
0236: BSF 03,5
0237: BTFSS 49,7
0238: GOTO 23C
0239: BCF 03,5
023A: ADDWF 20,F
023B: BSF 03,5
023C: BCF 03,5
023D: RRF 20,F
023E: RRF 21,F
023F: RETLW 00
*
0392: MOVLW 0A
0393: BSF 03,5
0394: MOVWF 48
0395: BCF 03,5
0396: MOVF 28,W
0397: BSF 03,5
0398: MOVWF 49
0399: BCF 03,5
039A: CALL 1F3
039B: MOVF 29,W
039C: ADDWF 21,W
039D: MOVWF 28
.................... for( i = 0; i < 3; i++ )
039E: CLRF 27
039F: MOVF 27,W
03A0: SUBLW 02
03A1: BTFSS 03,0
03A2: GOTO 3B8
.................... lcd_character( month[ 3 * value1 + i ] );
03A3: MOVLW 03
03A4: BSF 03,5
03A5: MOVWF 48
03A6: BCF 03,5
03A7: MOVF 28,W
03A8: BSF 03,5
03A9: MOVWF 49
03AA: BCF 03,5
03AB: CALL 1F3
03AC: MOVF 27,W
03AD: ADDWF 21,W
03AE: ADDLW A0
03AF: MOVWF 04
03B0: MOVF 00,W
03B1: MOVWF 51
03B2: BSF 03,5
03B3: MOVWF 53
03B4: BCF 03,5
03B5: CALL 093
03B6: INCF 27,F
03B7: GOTO 39F
....................
.................... /* Get the Date and display */
.................... value1 = clock_get_value( 2 );
03B8: MOVLW 02
03B9: BSF 03,5
03BA: MOVWF 48
03BB: BCF 03,5
03BC: CALL 1BF
03BD: MOVF 21,W
03BE: MOVWF 28
.................... value2 = clock_get_value( 4 );
03BF: MOVLW 04
03C0: BSF 03,5
03C1: MOVWF 48
03C2: BCF 03,5
03C3: CALL 1BF
03C4: MOVF 21,W
03C5: MOVWF 29
.................... lcd_command( LCD_DD_ADD_L1 + 4 );
03C6: MOVLW 84
03C7: BSF 03,5
03C8: MOVWF 4F
03C9: BCF 03,5
03CA: CALL 019
.................... lcd_character( '0' + value1);
03CB: MOVLW 30
03CC: ADDWF 28,W
03CD: MOVWF 4F
03CE: BSF 03,5
03CF: MOVWF 53
03D0: BCF 03,5
03D1: CALL 093
.................... lcd_character( '0' + value2);
03D2: MOVLW 30
03D3: ADDWF 29,W
03D4: MOVWF 4F
03D5: BSF 03,5
03D6: MOVWF 53
03D7: BCF 03,5
03D8: CALL 093
....................
.................... /* Get the Day and display */
.................... value1 = clock_get_value( 3 );
03D9: MOVLW 03
03DA: BSF 03,5
03DB: MOVWF 48
03DC: BCF 03,5
03DD: CALL 1BF
03DE: MOVF 21,W
03DF: MOVWF 28
.................... lcd_command( LCD_DD_ADD_L1 + 0 );
03E0: MOVLW 80
03E1: BSF 03,5
03E2: MOVWF 4F
03E3: BCF 03,5
03E4: CALL 019
.................... for( i = 0; i < 3; i++ )
03E5: CLRF 27
03E6: MOVF 27,W
03E7: SUBLW 02
03E8: BTFSS 03,0
03E9: GOTO 3FF
.................... lcd_character( day[ 3 * value1 + i ] );
03EA: MOVLW 03
03EB: BSF 03,5
03EC: MOVWF 48
03ED: BCF 03,5
03EE: MOVF 28,W
03EF: BSF 03,5
03F0: MOVWF 49
03F1: BCF 03,5
03F2: CALL 1F3
03F3: MOVF 27,W
03F4: ADDWF 21,W
03F5: ADDLW 39
03F6: MOVWF 04
03F7: MOVF 00,W
03F8: MOVWF 51
03F9: BSF 03,5
03FA: MOVWF 53
03FB: BCF 03,5
03FC: CALL 093
03FD: INCF 27,F
03FE: GOTO 3E6
....................
.................... /* Get the Hour and display */
.................... value1 = clock_get_value( 2 );
03FF: MOVLW 02
0400: BSF 03,5
0401: MOVWF 48
0402: BCF 03,5
0403: CALL 1BF
0404: MOVF 21,W
0405: MOVWF 28
.................... value2 = clock_get_value( 4 );
0406: MOVLW 04
0407: BSF 03,5
0408: MOVWF 48
0409: BCF 03,5
040A: CALL 1BF
040B: MOVF 21,W
040C: MOVWF 29
.................... lcd_command( LCD_DD_ADD_L2 + 1 );
040D: MOVLW C1
040E: BSF 03,5
040F: MOVWF 4F
0410: BCF 03,5
0411: CALL 019
.................... lcd_character( '0' + value1 );
0412: MOVLW 30
0413: ADDWF 28,W
0414: MOVWF 4F
0415: BSF 03,5
0416: MOVWF 53
0417: BCF 03,5
0418: CALL 093
.................... lcd_character( '0' + value2 );
0419: MOVLW 30
041A: ADDWF 29,W
041B: MOVWF 4F
041C: BSF 03,5
041D: MOVWF 53
041E: BCF 03,5
041F: CALL 093
.................... lcd_character( ':' );
0420: MOVLW 3A
0421: BSF 03,5
0422: MOVWF 53
0423: BCF 03,5
0424: CALL 093
....................
.................... /* Get the Minutes but wait for zero seconds */
.................... value1 = clock_get_value( 3 );
0425: MOVLW 03
0426: BSF 03,5
0427: MOVWF 48
0428: BCF 03,5
0429: CALL 1BF
042A: MOVF 21,W
042B: MOVWF 28
.................... value2 = clock_get_value( 4 );
042C: MOVLW 04
042D: BSF 03,5
042E: MOVWF 48
042F: BCF 03,5
0430: CALL 1BF
0431: MOVF 21,W
0432: MOVWF 29
....................
.................... /* Wait for the start pulse from the clock */
.................... while( clock_get_pulse() != PT_START );
0433: CALL 0C0
0434: MOVF 21,W
0435: SUBLW 04
0436: BTFSC 03,2
0437: GOTO 439
0438: GOTO 433
.................... seconds = 0;
0439: CLRF 26
....................
.................... /* Display the minutes */
.................... lcd_command( LCD_DD_ADD_L2 + 4 );
043A: MOVLW C4
043B: BSF 03,5
043C: MOVWF 4F
043D: BCF 03,5
043E: CALL 019
.................... lcd_character( '0' + value1 );
043F: MOVLW 30
0440: ADDWF 28,W
0441: MOVWF 4F
0442: BSF 03,5
0443: MOVWF 53
0444: BCF 03,5
0445: CALL 093
.................... lcd_character( '0' + value2 );
0446: MOVLW 30
0447: ADDWF 29,W
0448: MOVWF 4F
0449: BSF 03,5
044A: MOVWF 53
044B: BCF 03,5
044C: CALL 093
.................... }
044D: GOTO 31F
.................... }
044E: SLEEP