📄 picweb.lst
字号:
0A99: BCF 03,6
0A9A: CALL 046
*
0E8D: MOVF 2B,W
0E8E: BSF 03,5
0E8F: BSF 03,6
0E90: MOVWF 2D
0E91: BCF 03,5
0E92: BCF 03,6
0E93: CALL 046
*
0EA9: MOVF 2F,W
0EAA: BSF 03,5
0EAB: BSF 03,6
0EAC: MOVWF 2D
0EAD: BCF 03,5
0EAE: BCF 03,6
0EAF: CALL 046
.................... check_byte(lw.b[0]);
*
0934: MOVF 2A,W
0935: BSF 03,5
0936: BSF 03,6
0937: MOVWF 2D
0938: BCF 03,5
0939: BCF 03,6
093A: CALL 046
*
0950: MOVF 2E,W
0951: BSF 03,5
0952: BSF 03,6
0953: MOVWF 2D
0954: BCF 03,5
0955: BCF 03,6
0956: CALL 046
*
0A7F: MOVF 2A,W
0A80: BSF 03,5
0A81: BSF 03,6
0A82: MOVWF 2D
0A83: BCF 03,5
0A84: BCF 03,6
0A85: CALL 046
*
0A9B: MOVF 2E,W
0A9C: BSF 03,5
0A9D: BSF 03,6
0A9E: MOVWF 2D
0A9F: BCF 03,5
0AA0: BCF 03,6
0AA1: CALL 046
*
0E94: MOVF 2A,W
0E95: BSF 03,5
0E96: BSF 03,6
0E97: MOVWF 2D
0E98: BCF 03,5
0E99: BCF 03,6
0E9A: CALL 046
*
0EB0: MOVF 2E,W
0EB1: BSF 03,5
0EB2: BSF 03,6
0EB3: MOVWF 2D
0EB4: BCF 03,5
0EB5: BCF 03,6
0EB6: CALL 046
.................... }
....................
.................... /* Add array of bytes to checksum value */
.................... void check_bytes(BYTE *dat, int len)
.................... {
.................... while (len--)
*
0D46: BSF 03,5
0D47: BSF 03,6
0D48: MOVF 18,W
0D49: DECF 18,F
0D4A: IORLW 00
0D4B: BTFSS 03,2
0D4C: GOTO 550
0D4D: BCF 03,5
0D4E: BCF 03,6
0D4F: GOTO 56E
0D50: BCF 03,5
0D51: BCF 03,6
.................... check_byte(*dat++);
0D52: BSF 03,5
0D53: BSF 03,6
0D54: MOVF 17,W
0D55: BCF 03,5
0D56: BCF 03,6
0D57: MOVWF 7A
0D58: BSF 03,5
0D59: BSF 03,6
0D5A: MOVF 16,W
0D5B: INCF 16,F
0D5C: BTFSC 03,2
0D5D: INCF 17,F
0D5E: MOVWF 04
0D5F: BCF 03,7
0D60: BCF 03,5
0D61: BCF 03,6
0D62: BTFSC 7A,0
0D63: BSF 03,7
0D64: MOVF 00,W
0D65: BSF 03,5
0D66: BSF 03,6
0D67: MOVWF 19
0D68: MOVF 19,W
0D69: MOVWF 2D
0D6A: BCF 03,5
0D6B: BCF 03,6
0D6C: CALL 046
0D6D: GOTO 546
.................... }
....................
.................... /* Start a transmission */
.................... void tx_start(void)
.................... {
.................... putchar(SLIP_END);
*
08DF: MOVLW C0
08E0: CLRWDT
08E1: BTFSS 0C,4
08E2: GOTO 0E0
08E3: MOVWF 19
.................... }
....................
.................... /* Encode and transmit a single SLIP byte */
.................... void tx_byte(BYTE b)
.................... {
.................... if (b==SLIP_END || b==SLIP_ESC)
*
0308: MOVLW C0
0309: BSF 03,5
030A: BSF 03,6
030B: SUBWF 19,W
030C: BTFSS 03,2
030D: GOTO 311
030E: BCF 03,5
030F: BCF 03,6
0310: GOTO 31E
0311: BCF 03,5
0312: BCF 03,6
0313: MOVLW DB
0314: BSF 03,5
0315: BSF 03,6
0316: SUBWF 19,W
0317: BTFSC 03,2
0318: GOTO 31C
0319: BCF 03,5
031A: BCF 03,6
031B: GOTO 33C
031C: BCF 03,5
031D: BCF 03,6
.................... {
.................... putchar(SLIP_ESC);
031E: MOVLW DB
031F: CLRWDT
0320: BTFSS 0C,4
0321: GOTO 31F
0322: MOVWF 19
.................... putchar(b==SLIP_END ? ESC_END : ESC_ESC);
0323: MOVLW C0
0324: BSF 03,5
0325: BSF 03,6
0326: SUBWF 19,W
0327: BTFSC 03,2
0328: GOTO 32C
0329: BCF 03,5
032A: BCF 03,6
032B: GOTO 330
032C: BCF 03,5
032D: BCF 03,6
032E: MOVLW DC
032F: GOTO 331
0330: MOVLW DD
0331: BSF 03,5
0332: BSF 03,6
0333: MOVWF 1A
0334: MOVF 1A,W
0335: BCF 03,5
0336: BCF 03,6
0337: CLRWDT
0338: BTFSS 0C,4
0339: GOTO 337
033A: MOVWF 19
.................... }
.................... else
033B: GOTO 345
.................... putchar(b);
033C: BSF 03,5
033D: BSF 03,6
033E: MOVF 19,W
033F: BCF 03,5
0340: BCF 03,6
0341: CLRWDT
0342: BTFSS 0C,4
0343: GOTO 341
0344: MOVWF 19
0345: RETLW 00
.................... }
....................
.................... /* End a transmission, start sending it out */
.................... void tx_end(void)
.................... {
.................... txflag = 1;
*
09A4: BSF 4B,1
09A5: RETLW 00
.................... }
....................
.................... /* Send a byte out to the SLIP link, then add to checksum */
.................... void put_byte(BYTE b)
.................... {
.................... if (txin < TXBUFFLEN)
*
08AF: MOVLW 60
08B0: SUBWF 4C,W
08B1: BTFSC 03,0
08B2: GOTO 0C6
.................... {
.................... write_txbuff(txin, b);
.................... txin++;
*
08C5: INCF 4C,F
.................... }
.................... check_byte(b);
08C6: BSF 03,5
08C7: BSF 03,6
08C8: MOVF 26,W
08C9: MOVWF 2D
08CA: BCF 03,5
08CB: BCF 03,6
08CC: CALL 046
08CD: RETLW 00
.................... }
....................
.................... /* Send a string out to the SLIP link, add to checksum */
.................... void put_str(char *s)
.................... {
.................... while (*s)
.................... put_byte(*s++);
.................... }
....................
.................... /* Send a null out to the SLIP link */
.................... void put_null(void)
.................... {
.................... put_byte(0);
*
07F3: BSF 03,5
07F4: BSF 03,6
07F5: CLRF 26
07F6: BCF 03,5
07F7: BCF 03,6
07F8: BSF 0A,3
07F9: CALL 0AF
07FA: BCF 0A,3
07FB: RETLW 00
.................... }
....................
.................... /* Send a word out to the SLIP link, then add to checksum */
.................... void put_word(WORD w)
.................... {
.................... put_byte(w >> 8);
*
09E9: BSF 03,5
09EA: BSF 03,6
09EB: MOVF 21,W
09EC: MOVWF 22
09ED: CLRF 23
09EE: MOVF 22,W
09EF: MOVWF 26
09F0: BCF 03,5
09F1: BCF 03,6
09F2: CALL 0AF
.................... put_byte(w);
09F3: BSF 03,5
09F4: BSF 03,6
09F5: MOVF 20,W
09F6: MOVWF 26
09F7: BCF 03,5
09F8: BCF 03,6
09F9: CALL 0AF
09FA: RETLW 00
.................... }
....................
.................... /* Send a null word out to the SLIP link */
.................... void put_nullw(void)
.................... {
.................... put_byte(0);
*
08CE: BSF 03,5
08CF: BSF 03,6
08D0: CLRF 26
08D1: BCF 03,5
08D2: BCF 03,6
08D3: CALL 0AF
.................... put_byte(0);
08D4: BSF 03,5
08D5: BSF 03,6
08D6: CLRF 26
08D7: BCF 03,5
08D8: BCF 03,6
08D9: CALL 0AF
08DA: RETLW 00
.................... }
....................
.................... void put_lword(LWORD &lw)
.................... {
.................... put_byte(lw.b[3]);
*
096B: MOVF 2D,W
096C: BSF 03,5
096D: BSF 03,6
096E: MOVWF 26
096F: BCF 03,5
0970: BCF 03,6
0971: CALL 0AF
*
0987: MOVF 31,W
0988: BSF 03,5
0989: BSF 03,6
098A: MOVWF 26
098B: BCF 03,5
098C: BCF 03,6
098D: CALL 0AF
*
0A16: MOVF 3D,W
0A17: BSF 03,5
0A18: BSF 03,6
0A19: MOVWF 26
0A1A: BCF 03,5
0A1B: BCF 03,6
0A1C: CALL 0AF
*
0A32: MOVF 39,W
0A33: BSF 03,5
0A34: BSF 03,6
0A35: MOVWF 26
0A36: BCF 03,5
0A37: BCF 03,6
0A38: CALL 0AF
.................... put_byte(lw.b[2]);
*
0972: MOVF 2C,W
0973: BSF 03,5
0974: BSF 03,6
0975: MOVWF 26
0976: BCF 03,5
0977: BCF 03,6
0978: CALL 0AF
*
098E: MOVF 30,W
098F: BSF 03,5
0990: BSF 03,6
0991: MOVWF 26
0992: BCF 03,5
0993: BCF 03,6
0994: CALL 0AF
*
0A1D: MOVF 3C,W
0A1E: BSF 03,5
0A1F: BSF 03,6
0A20: MOVWF 26
0A21: BCF 03,5
0A22: BCF 03,6
0A23: CALL 0AF
*
0A39: MOVF 38,W
0A3A: BSF 03,5
0A3B: BSF 03,6
0A3C: MOVWF 26
0A3D: BCF 03,5
0A3E: BCF 03,6
0A3F: CALL 0AF
.................... put_byte(lw.b[1]);
*
0979: MOVF 2B,W
097A: BSF 03,5
097B: BSF 03,6
097C: MOVWF 26
097D: BCF 03,5
097E: BCF 03,6
097F: CALL 0AF
*
0995: MOVF 2F,W
0996: BSF 03,5
0997: BSF 03,6
0998: MOVWF 26
0999: BCF 03,5
099A: BCF 03,6
099B: CALL 0AF
*
0A24: MOVF 3B,W
0A25: BSF 03,5
0A26: BSF 03,6
0A27: MOVWF 26
0A28: BCF 03,5
0A29: BCF 03,6
0A2A: CALL 0AF
*
0A40: MOVF 37,W
0A41: BSF 03,5
0A42: BSF 03,6
0A43: MOVWF 26
0A44: BCF 03,5
0A45: BCF 03,6
0A46: CALL 0AF
.................... put_byte(lw.b[0]);
*
0980: MOVF 2A,W
0981: BSF 03,5
0982: BSF 03,6
0983: MOVWF 26
0984: BCF 03,5
0985: BCF 03,6
0986: CALL 0AF
*
099C: MOVF 2E,W
099D: BSF 03,5
099E: BSF 03,6
099F: MOVWF 26
09A0: BCF 03,5
09A1: BCF 03,6
09A2: CALL 0AF
*
0A2B: MOVF 3A,W
0A2C: BSF 03,5
0A2D: BSF 03,6
0A2E: MOVWF 26
0A2F: BCF 03,5
0A30: BCF 03,6
0A31: CALL 0AF
*
0A47: MOVF 36,W
0A48: BSF 03,5
0A49: BSF 03,6
0A4A: MOVWF 26
0A4B: BCF 03,5
0A4C: BCF 03,6
0A4D: CALL 0AF
.................... }
....................
.................... /* Compute checksum of Tx bytes, given count */
.................... void check_txbytes(int n)
.................... {
.................... while (n--)
*
16C6: BSF 03,5
16C7: BSF 03,6
16C8: MOVF 1E,W
16C9: DECF 1E,F
16CA: IORLW 00
16CB: BTFSS 03,2
16CC: GOTO 6D0
16CD: BCF 03,5
16CE: BCF 03,6
16CF: GOTO 6EF
16D0: BCF 03,5
16D1: BCF 03,6
.................... {
.................... check_byte(read_txbuff(txin));
*
16E0: MOVF 78,W
16E1: BSF 03,5
16E2: BSF 03,6
16E3: MOVWF 1F
16E4: MOVF 1F,W
16E5: MOVWF 2D
16E6: BCF 03,5
16E7: BCF 03,6
16E8: BCF 0A,4
16E9: BSF 0A,3
16EA: CALL 046
16EB: BSF 0A,4
16EC: BCF 0A,3
.................... txin++;
16ED: INCF 4C,F
.................... }
16EE: GOTO 6C6
.................... }
....................
.................... /* Read a byte from the Tx buffer */
.................... BYTE read_txbuff(int &oset)
.................... {
.................... return(txbuff[oset]);
*
0672: MOVLW 10
0673: ADDWF 4D,W
0674: MOVWF 79
0675: MOVLW 01
0676: MOVWF 7A
0677: MOVF 79,W
0678: BTFSC 03,0
0679: INCF 7A,F
067A: MOVWF 04
067B: BCF 03,7
067C: BTFSC 7A,0
067D: BSF 03,7
067E: MOVF 00,W
067F: MOVWF 78
*
16D2: MOVLW 10
16D3: ADDWF 4C,W
16D4: MOVWF 79
16D5: MOVLW 01
16D6: MOVWF 7A
16D7: MOVF 79,W
16D8: BTFSC 03,0
16D9: INCF 7A,F
16DA: MOVWF 04
16DB: BCF 03,7
16DC: BTFSC 7A,0
16DD: BSF 03,7
16DE: MOVF 00,W
16DF: MOVWF 78
.................... }
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -