4_20ma_main.lst

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

....................   
.................... int *strcspn(char *s1, char *s2)  
.................... {  
....................    char *sc1, *sc2;  
....................   
....................    for (sc1 = s1; *sc1 != 0; sc1++)  
....................       for (sc2 = s2; *sc2 != 0; sc2++)  
....................          if (*sc1 == *sc2)  
....................             return(sc1 - s1);  
....................    return(sc1 - s1);  
.................... }  
.................... /* standard template:  
....................    char *strpbrk(const char *s1, const char *s2).  
....................    Locates first occurence of any character from s2 in s1;  
....................    returns s1 if s2 is empty string */  
....................   
.................... char *strpbrk(char *s1, char *s2)  
.................... {  
....................    char *sc1, *sc2;  
....................   
....................    for (sc1 = s1; *sc1 != 0; sc1++)  
....................       for (sc2 = s2; *sc2 != 0; sc2++)  
....................          if (*sc1 == *sc2)  
....................             return(sc1);  
....................    return(0);  
.................... }  
....................   
....................   
.................... /* standard template: char *strrchr(const char *s, int c).  
....................    Finds last occurrence of c in s */  
....................   
.................... char *strrchr(char *s, int c)  
.................... {  
....................    char *p;  
....................   
....................    for (p = 0; ; s++)  
....................    {  
....................       if (*s == c)  
....................          p = s;  
....................       if (*s == '\0')  
....................          return(p);  
....................    }  
.................... }  
.................... /* computes length of max initial segment of s1 consisting  
....................    entirely of characters from s2 */  
....................   
.................... int *strspn(char *s1, char *s2)  
.................... {  
....................    char *sc1, *sc2;  
....................   
....................    for (sc1 = s1; *sc1 != 0; sc1++)  
....................       for (sc2 = s2; ; sc2++)  
.................... 	 if (*sc2 == '\0')  
.................... 	    return(sc1 - s1);  
....................          else if (*sc1 == *sc2)  
....................             break;  
....................    return(sc1 - s1);  
.................... }  
.................... /* standard template:  
....................    char *strstr(const char *s1, const char *s2);  
....................    Locates first occurence of character sequence s2 in s1;  
....................    returns 0 if s2 is empty string  
....................   
....................    Uncomment #define FASTER_BUT_MORE_ROM at the top of the  
....................    file to use the faster algorithm */  
.................... char *strstr(char *s1, char *s2)  
.................... {  
.................... 	char *s, *t;  
....................   
....................    #ifdef FASTER_BUT_MORE_ROM  
....................    if (*s2 == '\0')  
....................          return(s1);  
....................    #endif  
....................   
.................... 	while (*s1)  
....................    {  
....................       for(s = s1, t = s2; *t && *s == *t; ++s, ++t);  
....................   
.................... 		if (*t == '\0')  
.................... 			return s1;  
....................       ++s1;  
....................       #ifdef FASTER_BUT_MORE_ROM  
....................          while(*s1 != '\0' && *s1 != *s2)  
....................             ++s1;  
....................       #endif  
.................... 	}  
.................... 	return 0;  
.................... }  
....................   
.................... /* standard template: char *strtok(char *s1, const char *s2).  
....................   
....................    Finds next token in s1 delimited by a character from separator  
....................    string s2 (which can be different from call to call).  First call  
....................    starts at beginning of s1 searching for first character NOT  
....................    contained in s2; returns 0 if none is found.  
....................    If one is found, it is the start of first token (return value).  
....................    Function then searches from there for a character contained in s2.  
....................    If none is found, current token extends to end of s1, and subsequent  
....................    searches for a token will return 0.  If one is found, it is  
....................    overwritten by '\0', which terminates current token.  Function saves  
....................    pointer to following character from which next search will start.  
....................    Each subsequent call, with 0 as first argument, starts searching  
....................    from saved pointer */  
....................   
.................... char *strtok(char *s1, char *s2)  
.................... {  
....................    char *beg, *end;  
....................    static char *save;  
*
1358:  CLRF   21
135A:  CLRF   22
....................   
....................    beg = (s1)??s1: save;  
....................    beg += strspn(beg, s2);  
....................    if (*beg == '\0')  
....................    {  
....................       *save = ' ';  
....................       return(0);  
....................    }  
....................    end = strpbrk(beg, s2);  
....................    if (*end != '\0')  
....................    {  
....................       *end = '\0';  
....................       end++;  
....................    }  
....................    save = end;  
....................    return(beg);  
.................... }  
....................   
.................... /*****************************************************************/  
.................... /*Miscellaneous functions*/  
.................... /* standard template  
.................... maps error number in errnum to an error message string  
.................... Returns: Pointer to string  
.................... */  
.................... #ifdef _ERRNO  
.................... char * strerror(int errnum)  
.................... {  
.................... char s[15];  
.................... switch( errnum)  
.................... {  
.................... case 0:  
....................    strcpy(s,"no errors");  
....................    return s;  
.................... case EDOM :  
....................    strcpy(s,"domain error");  
....................    return s;  
.................... case ERANGE:  
....................    strcpy(s,"range error");  
....................    return s;  
.................... }  
.................... }  
.................... #ENDIF  
.................... /* standard template: size_t strlen(const char *s).  
....................    Computes length of s1 (preceding terminating 0) */  
....................   
.................... int *strlen(char *s)  
.................... {  
....................    char *sc;  
....................   
....................    for (sc = s; *sc != 0; sc++);  
....................    return(sc - s);  
.................... }  
....................   
.................... /* standard template: size_t stricmp(const char *s1, const char *s2).  
....................    Compares s1 to s2 ignoring case (upper vs. lower) */  
....................   
.................... signed int stricmp(char *s1, char *s2)  
.................... {  
....................  for(; *s1==*s2||(isalpha(*s1)&&isalpha(*s2)&&(*s1==*s2+32||*s2==*s1+32));  
....................     s1++, s2++)  
....................     if (*s1 == '\0')  
....................        return(0);  
....................  return((*s1 < *s2) ??-1: 1);  
.................... }  
....................   
....................   
.................... /* standard template: char *strlwr(char *s).  
....................    Replaces uppercase letters by lowercase;  
....................    returns pointer to new string s */  
....................   
.................... char *strlwr(char *s)  
.................... {  
....................    char *p;  
....................   
....................    for (p = s; *p != '\0'; p++)  
....................       if (*p >= 'A' && *p <='Z')  
....................          *p += 'a' - 'A';  
....................    return(s);  
.................... }  
....................   
....................   
.................... /************************************************************/  
....................   
....................   
.................... #endif  
....................  
....................   
.................... div_t div(signed int numer,signed int denom)  
.................... {  
....................    div_t val;  
....................    val.quot = numer / denom;  
....................    val.rem = numer - (denom * val.quot);  
....................    return (val);  
.................... }  
....................   
.................... ldiv_t ldiv(signed long numer,signed long denom)  
.................... {  
....................    ldiv_t val;  
....................    val.quot = numer / denom;  
....................    val.rem = numer - (denom * val.quot);  
....................    return (val);  
.................... }  
....................   
.................... float atof(char * s)  
.................... {  
....................    float pow10 = 1.0;  
*
0EBA:  MOVLW  7F
0EBC:  MOVWF  4C
0EBE:  CLRF   4D
0EC0:  CLRF   4E
0EC2:  CLRF   4F
....................    float result = 0.0;  
0EC4:  CLRF   50
0EC6:  CLRF   51
0EC8:  CLRF   52
0ECA:  CLRF   53
....................    int sign = 0;  
0ECC:  CLRF   54
....................    char c;  
....................    int ptr = 0;  
0ECE:  CLRF   56
....................   
....................    c = s[ptr++];  
0ED0:  MOVF   56,W
0ED2:  INCF   56,F
0ED4:  CLRF   03
0ED6:  ADDWF  4A,W
0ED8:  MOVWF  FE9
0EDA:  MOVF   4B,W
0EDC:  ADDWFC 03,W
0EDE:  MOVWF  FEA
0EE0:  MOVF   FEF,W
0EE2:  MOVWF  55
....................   
....................    if ((c>='0' && c<='9') || c=='+' || c=='-' || c=='.') {  
0EE4:  MOVF   55,W
0EE6:  SUBLW  2F
0EE8:  BTFSC  FD8.0
0EEA:  GOTO   0EF8
0EEE:  MOVF   55,W
0EF0:  SUBLW  39
0EF2:  BTFSC  FD8.0
0EF4:  GOTO   0F16
0EF8:  MOVF   55,W
0EFA:  SUBLW  2B
0EFC:  BTFSC  FD8.2
0EFE:  GOTO   0F16
0F02:  MOVF   55,W
0F04:  SUBLW  2D
0F06:  BTFSC  FD8.2
0F08:  GOTO   0F16
0F0C:  MOVF   55,W
0F0E:  SUBLW  2E
0F10:  BTFSS  FD8.2
0F12:  GOTO   1104
....................       if(c == '-') {  
0F16:  MOVF   55,W
0F18:  SUBLW  2D
0F1A:  BTFSS  FD8.2
0F1C:  GOTO   0F38
....................          sign = 1;  
0F20:  MOVLW  01
0F22:  MOVWF  54
....................          c = s[ptr++];  
0F24:  MOVF   56,W
0F26:  INCF   56,F
0F28:  CLRF   03
0F2A:  ADDWF  4A,W
0F2C:  MOVWF  FE9
0F2E:  MOVF   4B,W
0F30:  ADDWFC 03,W
0F32:  MOVWF  FEA
0F34:  MOVF   FEF,W
0F36:  MOVWF  55
....................       }  
....................       if(c == '+')  
....................          c = s[ptr++];  
0F38:  MOVF   55,W
0F3A:  SUBLW  2B
0F3C:  BTFSS  FD8.2
0F3E:  GOTO   0F56
0F42:  MOVF   56,W
0F44:  INCF   56,F
0F46:  CLRF   03
0F48:  ADDWF  4A,W
0F4A:  MOVWF  FE9
0F4C:  MOVF   4B,W
0F4E:  ADDWFC 03,W
0F50:  MOVWF  FEA
0F52:  MOVF   FEF,W
0F54:  MOVWF  55
....................   
....................       while((c >= '0' && c <= '9')) {  
0F56:  MOVF   55,W
0F58:  SUBLW  2F
0F5A:  BTFSC  FD8.0
0F5C:  GOTO   1024
0F60:  MOVF   55,W