4_20ma_main.lst

PIC18F6720写DAC7612U,TA1604_LCD显示,I2C读写PCF8563,PIC单片机之间模拟I2C通讯,该软件已调试通过,已经在产品上使用,有中文说明.

0F62:  SUBLW  39
0F64:  BTFSS  FD8.0
0F66:  GOTO   1024
....................          result = 10*result + c - '0';  
0F6A:  CLRF   5A
0F6C:  CLRF   59
0F6E:  MOVLW  20
0F70:  MOVWF  58
0F72:  MOVLW  82
0F74:  MOVWF  57
0F76:  MOVFF  53,5E
0F7A:  MOVFF  52,5D
0F7E:  MOVFF  51,5C
0F82:  MOVFF  50,5B
0F86:  CALL   04BA
0F8A:  MOVFF  00,57
0F8E:  MOVFF  01,58
0F92:  MOVFF  02,59
0F96:  MOVFF  03,5A
0F9A:  CLRF   5C
0F9C:  MOVFF  55,5B
0FA0:  CALL   0B48
0FA4:  BCF    FD8.1
0FA6:  MOVFF  5A,62
0FAA:  MOVFF  59,61
0FAE:  MOVFF  58,60
0FB2:  MOVFF  57,5F
0FB6:  MOVFF  03,66
0FBA:  MOVFF  02,65
0FBE:  MOVFF  01,64
0FC2:  MOVFF  00,63
0FC6:  CALL   0B8E
0FCA:  MOVFF  00,5B
0FCE:  MOVFF  01,5C
0FD2:  MOVFF  02,5D
0FD6:  MOVFF  03,5E
0FDA:  BSF    FD8.1
0FDC:  MOVFF  03,62
0FE0:  MOVFF  02,61
0FE4:  MOVFF  01,60
0FE8:  MOVFF  00,5F
0FEC:  CLRF   x66
0FEE:  CLRF   x65
0FF0:  MOVLW  40
0FF2:  MOVWF  x64
0FF4:  MOVLW  84
0FF6:  MOVWF  x63
0FF8:  CALL   0B8E
0FFC:  MOVFF  03,53
1000:  MOVFF  02,52
1004:  MOVFF  01,51
1008:  MOVFF  00,50
....................          c = s[ptr++];  
100C:  MOVF   56,W
100E:  INCF   56,F
1010:  CLRF   03
1012:  ADDWF  4A,W
1014:  MOVWF  FE9
1016:  MOVF   4B,W
1018:  ADDWFC 03,W
101A:  MOVWF  FEA
101C:  MOVF   FEF,W
101E:  MOVWF  55
....................       }  
1020:  GOTO   0F56
....................   
....................       if (c == '.') {  
1024:  MOVF   55,W
1026:  SUBLW  2E
1028:  BTFSS  FD8.2
102A:  GOTO   1104
....................          c = s[ptr++];  
102E:  MOVF   56,W
1030:  INCF   56,F
1032:  CLRF   03
1034:  ADDWF  4A,W
1036:  MOVWF  FE9
1038:  MOVF   4B,W
103A:  ADDWFC 03,W
103C:  MOVWF  FEA
103E:  MOVF   FEF,W
1040:  MOVWF  55
....................          while((c >= '0' && c <= '9')) {  
1042:  MOVF   55,W
1044:  SUBLW  2F
1046:  BTFSC  FD8.0
1048:  GOTO   1104
104C:  MOVF   55,W
104E:  SUBLW  39
1050:  BTFSS  FD8.0
1052:  GOTO   1104
....................              pow10 = pow10*10;  
1056:  MOVFF  4F,5A
105A:  MOVFF  4E,59
105E:  MOVFF  4D,58
1062:  MOVFF  4C,57
1066:  CLRF   5E
1068:  CLRF   5D
106A:  MOVLW  20
106C:  MOVWF  5C
106E:  MOVLW  82
1070:  MOVWF  5B
1072:  CALL   04BA
1076:  MOVFF  03,4F
107A:  MOVFF  02,4E
107E:  MOVFF  01,4D
1082:  MOVFF  00,4C
....................              result += (c - '0')/pow10;  
1086:  MOVLW  30
1088:  SUBWF  55,W
108A:  CLRF   5C
108C:  MOVWF  5B
108E:  CALL   0B48
1092:  MOVFF  03,5B
1096:  MOVFF  02,5A
109A:  MOVFF  01,59
109E:  MOVFF  00,58
10A2:  MOVFF  4F,5F
10A6:  MOVFF  4E,5E
10AA:  MOVFF  4D,5D
10AE:  MOVFF  4C,5C
10B2:  CALL   05D8
10B6:  BCF    FD8.1
10B8:  MOVFF  53,62
10BC:  MOVFF  52,61
10C0:  MOVFF  51,60
10C4:  MOVFF  50,5F
10C8:  MOVFF  03,66
10CC:  MOVFF  02,65
10D0:  MOVFF  01,64
10D4:  MOVFF  00,63
10D8:  CALL   0B8E
10DC:  MOVFF  03,53
10E0:  MOVFF  02,52
10E4:  MOVFF  01,51
10E8:  MOVFF  00,50
....................              c = s[ptr++];  
10EC:  MOVF   56,W
10EE:  INCF   56,F
10F0:  CLRF   03
10F2:  ADDWF  4A,W
10F4:  MOVWF  FE9
10F6:  MOVF   4B,W
10F8:  ADDWFC 03,W
10FA:  MOVWF  FEA
10FC:  MOVF   FEF,W
10FE:  MOVWF  55
....................          }  
1100:  GOTO   1042
....................       }  
....................   
....................    }  
....................   
....................    if (sign == 1)  
....................       result = -1*result;  
1104:  DECFSZ 54,W
1106:  GOTO   113A
110A:  CLRF   5A
110C:  CLRF   59
110E:  MOVLW  80
1110:  MOVWF  58
1112:  MOVLW  7F
1114:  MOVWF  57
1116:  MOVFF  53,5E
111A:  MOVFF  52,5D
111E:  MOVFF  51,5C
1122:  MOVFF  50,5B
1126:  CALL   04BA
112A:  MOVFF  03,53
112E:  MOVFF  02,52
1132:  MOVFF  01,51
1136:  MOVFF  00,50
....................    return(result);  
113A:  MOVFF  50,00
113E:  MOVFF  51,01
1142:  MOVFF  52,02
1146:  MOVFF  53,03
.................... }  
114A:  GOTO   117A (RETURN)
....................   
.................... signed int atoi(char *s)  
.................... {  
....................    signed int result;  
....................    int sign, base, index;  
....................    char c;  
....................   
....................    index = 0;  
....................    sign = 0;  
....................    base = 10;  
....................    result = 0;  
....................   
....................    // Omit all preceeding alpha characters  
....................    if(s)  
....................       c = s[index++];  
....................   
....................    // increase index if either positive or negative sign is detected  
....................    if (c == '-')  
....................    {  
....................       sign = 1;         // Set the sign to negative  
....................       c = s[index++];  
....................    }  
....................    else if (c == '+')  
....................    {  
....................       c = s[index++];  
....................    }  
....................   
....................    if (c >= '0' && c <= '9')  
....................    {  
....................   
....................       // Check for hexa number  
....................       if (c == '0' && (s[index] == 'x' || s[index] == 'X'))  
....................       {  
....................          base = 16;  
....................          index++;  
....................          c = s[index++];  
....................       }  
....................   
....................       // The number is a decimal number  
....................       if (base == 10)  
....................       {  
....................          while (c >= '0' && c <= '9')  
....................          {  
....................             result = 10*result + (c - '0');  
....................             c = s[index++];  
....................          }  
....................       }  
....................       else if (base == 16)    // The number is a hexa number  
....................       {  
....................          c = toupper(c);  
....................          while ( (c >= '0' && c <= '9') || (c >= 'A' && c<='F'))  
....................          {  
....................             if (c >= '0' && c <= '9')  
....................                result = (result << 4) + (c - '0');  
....................             else  
....................                result = (result << 4) + (c - 'A' + 10);  
....................   
....................             c = s[index++];  
....................             c = toupper(c);  
....................          }  
....................       }  
....................    }  
....................   
....................    if (sign == 1 && base == 10)  
....................        result = -result;  
....................   
....................    return(result);  
.................... }  
....................   
.................... signed long atol(char *s)  
.................... {  
....................    signed long result;  
....................    int sign, base, index;  
....................    char c;  
....................   
....................    index = 0;  
....................    sign = 0;  
....................    base = 10;  
....................    result = 0;  
....................   
....................    if(s)  
....................       c = s[index++];  
....................   
....................    // increase index if either positive or negative sign is detected  
....................    if (c == '-')  
....................    {  
....................       sign = 1;         // Set the sign to negative  
....................       c = s[index++];  
....................    }  
....................    else if (c == '+')  
....................    {  
....................       c = s[index++];  
....................    }  
....................   
....................    if (c >= '0' && c <= '9')  
....................    {  
....................       if (c == '0' && (s[index] == 'x' || s[index] == 'X'))  
....................       {  
....................          base = 16;  
....................          index++;  
....................          c = s[index++];  
....................       }  
....................   
....................       // The number is a decimal number  
....................       if (base == 10)  
....................       {  
....................          while (c >= '0' && c <= '9')  
....................          {  
....................             result = 10*result + (c - '0');  
....................             c = s[index++];  
....................          }  
....................       }  
....................       else if (base == 16)    // The number is a hexa number  
....................       {  
....................          c = toupper(c);  
....................          while ( (c >= '0' && c <= '9') || (c >= 'A' && c <='F'))  
....................          {  
....................             if (c >= '0' && c <= '9')  
....................                result = (result << 4) + (c - '0');  
....................             else  
....................                result = (result << 4) + (c - 'A' + 10);  
....................   
....................             c = s[index++];c = toupper(c);  
....................          }  
....................       }  
....................    }  
....................   
....................