CCS PCM C Compiler, Version 3.241, 31854 12-Oct-07 15:13 Filename: Gulper_Main.lst ROM used: 1024 words (12%) Largest free fragment is 2048 RAM used: 132 (75%) at main() level 165 (94%) worst case Stack: 5 worst case (3 in main + 2 for interrupts) * 0000: MOVLW 00 0001: MOVWF 0A 0002: GOTO 2E4 0003: NOP 0004: MOVWF 7F 0005: SWAPF 03,W 0006: CLRF 03 0007: MOVWF 21 0008: MOVF 0A,W 0009: MOVWF 20 000A: CLRF 0A 000B: MOVF 04,W 000C: MOVWF 22 000D: MOVF 77,W 000E: MOVWF 23 000F: MOVF 78,W 0010: MOVWF 24 0011: MOVF 79,W 0012: MOVWF 25 0013: MOVF 7A,W 0014: MOVWF 26 0015: MOVF 7B,W 0016: MOVWF 27 0017: BCF 03.7 0018: BCF 03.5 0019: MOVLW 8C 001A: MOVWF 04 001B: BTFSS 00.5 001C: GOTO 01F 001D: BTFSC 0C.5 001E: GOTO 038 001F: MOVLW 8C 0020: MOVWF 04 0021: BTFSS 00.0 0022: GOTO 025 0023: BTFSC 0C.0 0024: GOTO 03B 0025: MOVF 22,W 0026: MOVWF 04 0027: MOVF 23,W 0028: MOVWF 77 0029: MOVF 24,W 002A: MOVWF 78 002B: MOVF 25,W 002C: MOVWF 79 002D: MOVF 26,W 002E: MOVWF 7A 002F: MOVF 27,W 0030: MOVWF 7B 0031: MOVF 20,W 0032: MOVWF 0A 0033: SWAPF 21,W 0034: MOVWF 03 0035: SWAPF 7F,F 0036: SWAPF 7F,W 0037: RETFIE 0038: BCF 0A.3 0039: BCF 0A.4 003A: GOTO 065 003B: BCF 0A.3 003C: BCF 0A.4 003D: GOTO 132 .................... /****************************************************************************/ .................... /* Copyright 2005 MBARI. */ .................... /* Monterey Bay Aquarium Research Institute Proprietary Information. */ .................... /* All rights reserved. */ .................... /****************************************************************************/ .................... #include <16f876A.h> .................... //////// Standard Header file for the PIC16F876A device //////////////// .................... #device PIC16F876A ADC=10 .................... #list .................... .................... .................... #include .................... //////////////////////////////////////////////////////////////////////////// .................... //// (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 _STRING .................... #define _STRING .................... #include .................... /////////////////////////////////////////////////////////////////////////// .................... //// (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 _STDDEF .................... .................... #define _STDDEF .................... .................... #if sizeof(int *)==1 .................... #define ptrdiff_t int .................... #else .................... #define ptrdiff_t long .................... #endif .................... .................... #define size_t int .................... #define wchar_t char .................... #define NULL 0 .................... .................... #define offsetof(s,f) (offsetofbit(s,f)/8) .................... .................... #endif .................... .................... #include .................... //////////////////////////////////////////////////////////////////////////// .................... //// (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 _CTYPE .................... #define _CTYPE .................... .................... #define islower(x) isamong(x,"abcdefghijklmnopqrstuvwxyz") .................... #define isupper(x) isamong(x,"ABCDEFGHIJKLMNOPQRSTUVWXYZ") .................... #define isalnum(x) isamong(x,"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz") .................... #define isalpha(x) isamong(x,"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz") .................... #define isdigit(x) isamong(x,"0123456789") .................... #define isspace(x) (x==' ') .................... #define isxdigit(x) isamong(x,"0123456789ABCDEFabcdef") .................... #define iscntrl(x) (x<' ') .................... #define isprint(x) (x>=' ') .................... #define isgraph(x) (x>' ') .................... #define ispunct(x) ((x>' ')&&!isalnum(x)) .................... .................... #endif .................... .................... .................... .................... .................... .................... ////////////////////////////////////////////// .................... //// Uncomment the following define to //// .................... //// allow some functions to use a //// .................... //// quicker algorithm, but use more ROM //// .................... //// //// .................... //// #define FASTER_BUT_MORE_ROM //// .................... ////////////////////////////////////////////// .................... .................... .................... .................... /*Copying functions*/ .................... /* standard template: .................... void *memmove(void *s1, void *s2, size_t n). .................... Copies max of n characters safely (not following ending '\0') .................... from s2 in s1; if s2 has less than n characters, appends 0 */ .................... .................... char *memmove(void *s1,char *s2,size_t n) .................... { .................... char *sc1; .................... char *sc2; .................... sc1=s1; .................... sc2=s2; .................... if(sc2 0 && *s2 != '\0'; n--) .................... *s++ = *s2++; .................... for (; n > 0; n--) .................... *s++ = '\0'; .................... .................... return(s1); .................... } .................... /***********************************************************/ .................... .................... /*concatenation functions*/ .................... /* standard template: char *strcat(char *s1, const char *s2) .................... appends s2 to s1*/ .................... .................... char *strcat(char *s1, char *s2) .................... { .................... char *s; .................... .................... for (s = s1; *s != '\0'; ++s); .................... while(*s2 != '\0') .................... { .................... *s = *s2; .................... ++s; .................... ++s2; .................... } .................... .................... *s = '\0'; .................... return(s1); .................... } .................... /* standard template: char *strncat(char *s1, char *s2,size_t n) .................... appends not more than n characters from s2 to s1*/ .................... .................... char *strncat(char *s1, char *s2, size_t n) .................... { .................... char *s; .................... .................... for (s = s1; *s != '\0'; ++s); * 01C6: MOVF 5A,W 01C7: MOVWF 5D 01C8: MOVF 5D,W 01C9: MOVWF 04 01CA: MOVF 00,F 01CB: BTFSC 03.2 01CC: GOTO 1CF 01CD: INCF 5D,F 01CE: GOTO 1C8 .................... while(*s2 != '\0' && 0s2 */ .................... .................... signed int memcmp(void * s1,char *s2,size_t n) .................... { .................... char *su1, *su2; .................... for(su1=s1, su2=s2; 0s2 */ .................... .................... signed int strcmp(char *s1, char *s2) .................... { .................... for (; *s1 == *s2; s1++, s2++) .................... if (*s1 == '\0') .................... return(0); .................... return((*s1 < *s2) ? -1: 1); .................... } .................... /* standard template: int strcoll(const char *s1, const char *s2). .................... Compares s1 & s2; returns -1 if s1s2 */ .................... .................... signed int strcoll(char *s1, char *s2) .................... { .................... for (; *s1 == *s2; s1++, s2++) .................... if (*s1 == '\0') .................... return(0); .................... return((*s1 < *s2) ? -1: 1); .................... } .................... .................... /* standard template: .................... int strncmp(const char *s1, const char *s2, size_t n). .................... Compares max of n characters (not following 0) from s1 to s2; .................... returns same as strcmp */ .................... .................... signed int strncmp(char *s1, char *s2, size_t n) .................... { .................... for (; n > 0; s1++, s2++, n--) .................... if (*s1 != *s2) .................... return((*s1 <*s2) ? -1: 1); .................... else if (*s1 == '\0') .................... return(0); .................... return(0); .................... } .................... /* standard template: .................... int strxfrm(const char *s1, const char *s2, size_t n). .................... transforms maximum of n characters from s2 and places them into s1*/ .................... size_t strxfrm(char *s1, char *s2, size_t n) .................... { .................... char *s; .................... int n1; .................... n1=n; .................... for (s = s1; n > 0 && *s2 != '\0'; n--) .................... *s++ = *s2++; .................... for (; n > 0; n--) .................... *s++ = '\0'; .................... .................... return(n1); .................... } .................... .................... .................... .................... .................... .................... /***********************************************************/ .................... /*Search functions*/ .................... /* standard template: void *memchr(const char *s, int c). .................... Finds first occurrence of c in n characters of s */ .................... .................... char *memchr(void *s,int c,size_t n) .................... { .................... char uc; .................... char *su; .................... uc=c; .................... for(su=s;0= 'A' && *p <='Z') .................... *p += 'a' - 'A'; .................... return(s); .................... } .................... .................... .................... /************************************************************/ .................... .................... .................... #endif .................... .................... #include .................... /////////////////////////////////////////////////////////////////////////// .................... //// (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 _STDLIB .................... #define _STDLIB .................... .................... //--------------------------------------------------------------------------- .................... // Definitions and types .................... //--------------------------------------------------------------------------- .................... .................... #ifndef RAND_MAX .................... #define RAND_MAX 32767 // The value of which is the maximum value .................... // ... returned by the rand function .................... #endif .................... .................... typedef struct { .................... signed int quot; .................... signed int rem; .................... } div_t; .................... .................... typedef struct { .................... signed long quot; .................... signed long rem; .................... } ldiv_t; .................... .................... #include .................... /////////////////////////////////////////////////////////////////////////// .................... //// (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 _STDDEF .................... .................... #define _STDDEF .................... .................... #if sizeof(int *)==1 .................... #define ptrdiff_t int .................... #else .................... #define ptrdiff_t long .................... #endif .................... .................... #define size_t int .................... #define wchar_t char .................... #define NULL 0 .................... .................... #define offsetof(s,f) (offsetofbit(s,f)/8) .................... .................... #endif .................... .................... .................... //--------------------------------------------------------------------------- .................... // String conversion functions .................... //--------------------------------------------------------------------------- .................... .................... /* Standard template: float atof(char * s) .................... * converts the initial portion of the string s to a float. .................... * returns the converted value if any, 0 otherwise .................... */ .................... float atof(char * s); .................... .................... /* Standard template: float atoe(char * s) .................... * converts the initial portion of the string s to a float. .................... * returns the converted value if any, 0 otherwise .................... * also handles E format numbers .................... */ .................... float atoe(char * s); .................... .................... /* Standard template: signed int atoi(char * s) .................... * converts the initial portion of the string s to a signed int .................... * returns the converted value if any, 0 otherwise .................... */ .................... signed int atoi(char *s); .................... .................... /* Syntax: signed int32 atoi32(char * s) .................... converts the initial portion of the string s to a signed int32 .................... returns the converted value if any, 0 otherwise*/ .................... signed int32 atoi32(char *s); .................... .................... /* Syntax: char * itoa(signed int32 num, int8 base, char * s) .................... converts the signed int32 to a string and .................... returns the converted value if any, 0 otherwise*/ .................... char * itoa(signed int32 num, int8 base, char * s); .................... .................... /* Standard template: signed long atol(char * s) .................... * converts the initial portion of the string s to a signed long .................... * returns the converted value if any, 0 otherwise .................... */ .................... signed long atol(char *s); .................... .................... /* Standard template: float strtol(char * s,char *endptr) .................... * converts the initial portion of the string s to a float .................... * returns the converted value if any, 0 otherwise .................... * the final string is returned in the endptr, if endptr is not null .................... */ .................... float strtod(char *s,char *endptr); .................... .................... /* Standard template: long strtoul(char * s,char *endptr,signed int base) .................... * converts the initial portion of the string s, represented as an .................... * integral value of radix base to a signed long. .................... * Returns the converted value if any, 0 otherwise .................... * the final string is returned in the endptr, if endptr is not null .................... */ .................... signed long strtol(char *s,char *endptr,signed int base); .................... .................... /* Standard template: long strtoul(char * s,char *endptr,signed int base) .................... * converts the initial portion of the string s, represented as an .................... * integral value of radix base to a unsigned long. .................... * returns the converted value if any, 0 otherwise .................... * the final string is returned in the endptr, if endptr is not null .................... */ .................... long strtoul(char *s,char *endptr,signed int base); .................... .................... //--------------------------------------------------------------------------- .................... // Pseudo-random sequence generation functions .................... //--------------------------------------------------------------------------- .................... .................... /* The rand function computes a sequence of pseudo-random integers in .................... * the range 0 to RAND_MAX .................... * .................... * Parameters: .................... * (none) .................... * .................... * Returns: .................... * The pseudo-random integer .................... */ .................... long rand(void); .................... .................... /* The srand function uses the argument as a seed for a new sequence of .................... * pseudo-random numbers to be returned by subsequent calls to rand. .................... * .................... * Parameters: .................... * [in] seed: The seed value to start from. You might need to pass .................... * .................... * Returns: .................... * (none) .................... * .................... * Remarks .................... * The srand function sets the starting point for generating .................... * a series of pseudorandom integers. To reinitialize the .................... * generator, use 1 as the seed argument. Any other value for .................... * seed sets the generator to a random starting point. rand .................... * retrieves the pseudorandom numbers that are generated. .................... * Calling rand before any call to srand generates the same .................... * sequence as calling srand with seed passed as 1. .................... * Usually, you need to pass a time here from outer source .................... * so that the numbers will be different every time you run. .................... */ .................... void srand(unsigned int32 seed); .................... .................... //--------------------------------------------------------------------------- .................... // Memory management functions .................... //--------------------------------------------------------------------------- .................... .................... // Comming soon .................... .................... //--------------------------------------------------------------------------- .................... // Communication with the environment .................... //--------------------------------------------------------------------------- .................... .................... /* The function returns 0 always .................... */ .................... signed int system(char *string); .................... .................... //--------------------------------------------------------------------------- .................... // Searching and sorting utilities .................... //--------------------------------------------------------------------------- .................... .................... /* Performs a binary search of a sorted array.. .................... * .................... * Parameters: .................... * [in] key: Object to search for .................... * [in] base: Pointer to base of search data .................... * [in] num: Number of elements .................... * [in] width: Width of elements .................... * [in] compare: Function that compares two elements .................... * .................... * Returns: .................... * bsearch returns a pointer to an occurrence of key in the array pointed .................... * to by base. If key is not found, the function returns NULL. If the .................... * array is not in order or contains duplicate records with identical keys, .................... * the result is unpredictable. .................... */ .................... //void *bsearch(const void *key, const void *base, size_t num, size_t width, .................... // int (*compare)(const void *, const void *)); .................... .................... /* Performs the shell-metzner sort (not the quick sort algorithm). The contents .................... * of the array are sorted into ascending order according to a comparison .................... * function pointed to by compar. .................... * .................... * Parameters: .................... * [in] base: Pointer to base of search data .................... * [in] num: Number of elements .................... * [in] width: Width of elements .................... * [in] compare: Function that compares two elements .................... * .................... * Returns: .................... * (none) .................... */ .................... //void *qsort(const void *base, size_t num, size_t width, .................... // int (*compare)(const void *, const void *)); .................... .................... //--------------------------------------------------------------------------- .................... // Integer arithmetic functions .................... //--------------------------------------------------------------------------- .................... .................... #define labs abs .................... .................... div_t div(signed int numer,signed int denom); .................... ldiv_t ldiv(signed long numer,signed long denom); .................... .................... //--------------------------------------------------------------------------- .................... // Multibyte character functions .................... //--------------------------------------------------------------------------- .................... .................... // Not supported .................... .................... //--------------------------------------------------------------------------- .................... // Multibyte string functions .................... //--------------------------------------------------------------------------- .................... .................... // Not supported .................... .................... .................... //--------------------------------------------------------------------------- .................... // Internal implementation .................... //--------------------------------------------------------------------------- .................... .................... #include .................... /////////////////////////////////////////////////////////////////////////// .................... //// (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 _STDDEF .................... .................... #define _STDDEF .................... .................... #if sizeof(int *)==1 .................... #define ptrdiff_t int .................... #else .................... #define ptrdiff_t long .................... #endif .................... .................... #define size_t int .................... #define wchar_t char .................... #define NULL 0 .................... .................... #define offsetof(s,f) (offsetofbit(s,f)/8) .................... .................... #endif .................... .................... #include .................... //////////////////////////////////////////////////////////////////////////// .................... //// (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 _STRING .................... #define _STRING .................... #include .................... #include .................... .................... .................... .................... ////////////////////////////////////////////// .................... //// Uncomment the following define to //// .................... //// allow some functions to use a //// .................... //// quicker algorithm, but use more ROM //// .................... //// //// .................... //// #define FASTER_BUT_MORE_ROM //// .................... ////////////////////////////////////////////// .................... .................... .................... .................... /*Copying functions*/ .................... /* standard template: .................... void *memmove(void *s1, void *s2, size_t n). .................... Copies max of n characters safely (not following ending '\0') .................... from s2 in s1; if s2 has less than n characters, appends 0 */ .................... .................... char *memmove(void *s1,char *s2,size_t n) .................... { .................... char *sc1; .................... char *sc2; .................... sc1=s1; .................... sc2=s2; .................... if(sc2 0 && *s2 != '\0'; n--) .................... *s++ = *s2++; .................... for (; n > 0; n--) .................... *s++ = '\0'; .................... .................... return(s1); .................... } .................... /***********************************************************/ .................... .................... /*concatenation functions*/ .................... /* standard template: char *strcat(char *s1, const char *s2) .................... appends s2 to s1*/ .................... .................... char *strcat(char *s1, char *s2) .................... { .................... char *s; .................... .................... for (s = s1; *s != '\0'; ++s); .................... while(*s2 != '\0') .................... { .................... *s = *s2; .................... ++s; .................... ++s2; .................... } .................... .................... *s = '\0'; .................... return(s1); .................... } .................... /* standard template: char *strncat(char *s1, char *s2,size_t n) .................... appends not more than n characters from s2 to s1*/ .................... .................... char *strncat(char *s1, char *s2, size_t n) .................... { .................... char *s; .................... .................... for (s = s1; *s != '\0'; ++s); .................... while(*s2 != '\0' && 0s2 */ .................... .................... signed int memcmp(void * s1,char *s2,size_t n) .................... { .................... char *su1, *su2; .................... for(su1=s1, su2=s2; 0s2 */ .................... .................... signed int strcmp(char *s1, char *s2) .................... { .................... for (; *s1 == *s2; s1++, s2++) .................... if (*s1 == '\0') .................... return(0); .................... return((*s1 < *s2) ? -1: 1); .................... } .................... /* standard template: int strcoll(const char *s1, const char *s2). .................... Compares s1 & s2; returns -1 if s1s2 */ .................... .................... signed int strcoll(char *s1, char *s2) .................... { .................... for (; *s1 == *s2; s1++, s2++) .................... if (*s1 == '\0') .................... return(0); .................... return((*s1 < *s2) ? -1: 1); .................... } .................... .................... /* standard template: .................... int strncmp(const char *s1, const char *s2, size_t n). .................... Compares max of n characters (not following 0) from s1 to s2; .................... returns same as strcmp */ .................... .................... signed int strncmp(char *s1, char *s2, size_t n) .................... { .................... for (; n > 0; s1++, s2++, n--) .................... if (*s1 != *s2) .................... return((*s1 <*s2) ? -1: 1); .................... else if (*s1 == '\0') .................... return(0); .................... return(0); .................... } .................... /* standard template: .................... int strxfrm(const char *s1, const char *s2, size_t n). .................... transforms maximum of n characters from s2 and places them into s1*/ .................... size_t strxfrm(char *s1, char *s2, size_t n) .................... { .................... char *s; .................... int n1; .................... n1=n; .................... for (s = s1; n > 0 && *s2 != '\0'; n--) .................... *s++ = *s2++; .................... for (; n > 0; n--) .................... *s++ = '\0'; .................... .................... return(n1); .................... } .................... .................... .................... .................... .................... .................... /***********************************************************/ .................... /*Search functions*/ .................... /* standard template: void *memchr(const char *s, int c). .................... Finds first occurrence of c in n characters of s */ .................... .................... char *memchr(void *s,int c,size_t n) .................... { .................... char uc; .................... char *su; .................... uc=c; .................... for(su=s;0= '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; .................... float result = 0.0; .................... int sign = 0; .................... char c; .................... int ptr = 0; .................... .................... c = s[ptr++]; .................... .................... if ((c>='0' && c<='9') || c=='+' || c=='-' || c=='.') { .................... if(c == '-') { .................... sign = 1; .................... c = s[ptr++]; .................... } .................... if(c == '+') .................... c = s[ptr++]; .................... .................... while((c >= '0' && c <= '9')) { .................... result = 10*result + c - '0'; .................... c = s[ptr++]; .................... } .................... .................... if (c == '.') { .................... c = s[ptr++]; .................... while((c >= '0' && c <= '9')) { .................... pow10 = pow10*10; .................... result += (c - '0')/pow10; .................... c = s[ptr++]; .................... } .................... } .................... .................... } .................... .................... if (sign == 1) .................... result = -1*result; .................... return(result); .................... } .................... .................... float atoe(char * s) .................... { .................... float pow10 = 1.0; .................... float result = 0.0; .................... int sign = 0; .................... int expsign = 0; .................... char c; .................... int ptr = 0; .................... int i; .................... float exp = 1.0; .................... int expcnt = 0; .................... .................... c = s[ptr++]; .................... .................... if ((c>='0' && c<='9') || c=='+' || c=='-' || c=='.' || c=='E' || c=='e') { .................... if(c == '-') { .................... sign = 1; .................... c = s[ptr++]; .................... } .................... if(c == '+') .................... c = s[ptr++]; .................... .................... while((c >= '0' && c <= '9')) { .................... result = 10*result + c - '0'; .................... c = s[ptr++]; .................... } .................... .................... if (c == '.') { .................... c = s[ptr++]; .................... while((c >= '0' && c <= '9')) { .................... pow10 = pow10*10; .................... result += (c - '0')/pow10; .................... c = s[ptr++]; .................... } .................... } .................... .................... // Handling the exponent .................... if (c=='e' || c=='E') { .................... c = s[ptr++]; .................... .................... if(c == '-') { .................... expsign = 1; .................... c = s[ptr++]; .................... } .................... if(c == '+') .................... c = s[ptr++]; .................... .................... while((c >= '0' && c <= '9')) { .................... expcnt = 10*expcnt + c - '0'; .................... c = s[ptr++]; .................... } .................... .................... for(i=0;i= '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) .................... return 0; .................... 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); .................... } .................... } .................... } .................... .................... if (base == 10 && sign == 1) .................... result = -result; .................... .................... return(result); .................... } .................... .................... /* A fast routine to multiply by 10 .................... */ .................... signed int32 mult_with10(int32 num) .................... { .................... return ( (num << 1) + (num << 3) ); .................... } .................... .................... signed int32 atoi32(char *s) .................... { .................... signed int32 result; .................... int sign, base, index; .................... char c; .................... .................... index = 0; .................... sign = 0; .................... base = 10; .................... result = 0; .................... .................... if (!s) .................... return 0; .................... 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 = (result << 1) + (result << 3); // 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 (base == 10 && sign == 1) .................... result = -result; .................... .................... return(result); .................... } .................... .................... char * itoa(signed int32 num, int8 base, char *s) .................... { .................... int32 temp=1; .................... int8 i,sign=0,cnt=0; .................... char c; .................... .................... if(num<0) { .................... sign=1; // Check for negative number .................... num*=-1; .................... } .................... .................... while(temp>0) { .................... temp=(num/base); .................... s[cnt]=(num%base)+'0'; // Conversion .................... .................... if(s[cnt]>0x39) .................... s[cnt]+=0x7; .................... .................... cnt++; .................... num=temp; .................... } .................... .................... if(sign==1) { .................... s[cnt]=0x2D; // Negative sign .................... cnt++; .................... } .................... .................... for(i = 0;i<(int8)(cnt/2);i++) { .................... .................... c=s[i]; .................... s[i]=s[cnt-i-1]; // Reverse the number .................... s[cnt-i-1]=c; .................... } .................... s[cnt]='\0'; // End the string .................... return s; .................... } .................... .................... float strtod(char *s,char *endptr) { .................... float pow10 = 1.0; .................... float result = 0.0; .................... int sign = 0, point = 0; .................... char c; .................... int ptr = 0; .................... .................... if (!s) .................... return 0; .................... c=s[ptr++]; .................... .................... .................... while((c>='0' && c<='9') || c=='+' || c=='-' || c=='.') { .................... if(c == '-') { .................... sign = 1; .................... c = s[ptr++]; .................... } .................... .................... while((c >= '0' && c <= '9') && point == 0) { .................... result = 10*result + c - '0'; .................... c = s[ptr++]; .................... } .................... .................... if (c == '.') { .................... point = 1; .................... c = s[ptr++]; .................... } .................... .................... while((c >= '0' && c <= '9') && point == 1) { .................... pow10 = pow10*10; .................... result += (c - '0')/pow10; .................... c = s[ptr++]; .................... } .................... .................... if (c == '+') { .................... c = s[ptr++]; .................... } .................... } .................... .................... if (sign == 1) .................... result = -1*result; .................... if(endptr) .................... { .................... if (ptr) { .................... ptr--; .................... *((char *)endptr)=s+ptr; .................... } .................... else .................... *((char *)endptr)=s; .................... } .................... .................... return(result); .................... } .................... .................... long strtoul(char *s,char *endptr,signed int base) .................... { .................... char *sc,*s1,*sd; .................... unsigned long x=0; .................... char sign; .................... char digits[]="0123456789abcdefghijklmnopqstuvwxyz"; .................... for(sc=s;isspace(*sc);++sc); .................... sign=*sc=='-'||*sc=='+'?*sc++:'+'; .................... if(sign=='-') .................... { .................... if (endptr) .................... { .................... *((char *)endptr)=s; .................... } .................... return 0; .................... } .................... .................... if (base <0 || base ==1|| base >36) // invalid base .................... { .................... if (endptr) .................... { .................... *((char *)endptr)=s; .................... } .................... return 0; .................... } .................... else if (base) .................... { .................... if(base==16 && *sc =='0'&&(sc[1]=='x' || sc[1]=='X')) .................... sc+=2; .................... if(base==8 && *sc =='0') .................... sc+=1; .................... if(base==2 && *sc =='0'&&sc[1]=='b') .................... sc+=2; .................... .................... } .................... else if(*sc!='0') // base is 0, find base .................... base=10; .................... else if (sc[1]=='x' || sc[1]=='X') .................... base =16,sc+=2; .................... else if(sc[1]=='b') .................... base=2,sc+=2; .................... else .................... base=8; .................... for (s1=sc;*sc=='0';++sc);// skip leading zeroes .................... sd=memchr(digits,tolower(*sc),base); .................... for(; sd!=0; ) .................... { .................... x=x*base+(int16)(sd-digits); .................... ++sc; .................... sd=memchr(digits,tolower(*sc),base); .................... } .................... if(s1==sc) .................... { .................... if (endptr) .................... { .................... *((char *)endptr)=s; .................... } .................... return 0; .................... } .................... if (endptr) .................... *((char *)endptr)=sc; .................... return x; .................... } .................... .................... .................... signed long strtol(char *s,char *endptr,signed int base) .................... { .................... char *sc,*s1,*sd; .................... signed long x=0; .................... char sign; .................... char digits[]="0123456789abcdefghijklmnopqstuvwxyz"; .................... for(sc=s;isspace(*sc);++sc); .................... sign=*sc=='-'||*sc=='+'?*sc++:'+'; .................... if (base <0 || base ==1|| base >36) // invalid base .................... { .................... if (endptr) .................... { .................... *((char *)endptr)=s; .................... } .................... return 0; .................... } .................... else if (base) .................... { .................... if(base==16 && *sc =='0'&&(sc[1]=='x' || sc[1]=='X')) .................... sc+=2; .................... if(base==8 && *sc =='0') .................... sc+=1; .................... if(base==2 && *sc =='0'&&sc[1]=='b') .................... sc+=2; .................... .................... } .................... else if(*sc!='0') // base is 0, find base .................... base=10; .................... else if (sc[1]=='x' || sc[1]=='X') .................... base =16,sc+=2; .................... else if(sc[1]=='b') .................... base=2,sc+=2; .................... else .................... base=8; .................... for (s1=sc;*sc=='0';++sc);// skip leading zeroes .................... .................... sd=memchr(digits,tolower(*sc),base); .................... for(;sd!=0;) .................... { .................... x=x*base+(int16)(sd-digits); .................... ++sc; .................... sd=memchr(digits,tolower(*sc),base); .................... } .................... if(s1==sc) .................... { .................... if (endptr) .................... { .................... *((char *)endptr)=s; .................... } .................... return 0; .................... } .................... if(sign=='-') .................... x =-x; .................... if (endptr) .................... *((char *)endptr)=sc; .................... return x; .................... } .................... .................... signed int system(char *string) .................... { .................... return 0; .................... } .................... .................... int mblen(char *s,size_t n) .................... { .................... return strlen(s); .................... } .................... .................... int mbtowc(wchar_t *pwc,char *s,size_t n) .................... { .................... *pwc=*s; .................... return 1; .................... } .................... .................... int wctomb(char *s,wchar_t wchar) .................... { .................... *s=wchar; .................... return 1; .................... } .................... .................... size_t mbstowcs(wchar_t *pwcs,char *s,size_t n) .................... { .................... strncpy(pwcs,s,n); .................... return strlen(pwcs); .................... } .................... .................... size_t wcstombs(char *s,wchar_t *pwcs,size_t n) .................... { .................... strncpy(s,pwcs,n); .................... return strlen(s); .................... } .................... .................... //--------------------------------------------------------------------------- .................... // The random number implementation .................... //--------------------------------------------------------------------------- .................... .................... unsigned int32 _Randseed = 1; 02FC: MOVLW 01 02FD: MOVWF 2A 02FE: CLRF 2B 02FF: CLRF 2C 0300: CLRF 2D .................... .................... long rand(void) .................... { .................... _Randseed = _Randseed * 1103515245 + 12345; .................... return ((unsigned long)(_Randseed >> 16) % RAND_MAX); .................... } .................... .................... void srand(unsigned int32 seed) .................... { .................... _Randseed = seed; .................... } .................... .................... //--------------------------------------------------------------------------- .................... // Searching and sorting utilities implementation .................... //--------------------------------------------------------------------------- .................... .................... typedef signed int (*_Cmpfun)(char * p1,char * p2); .................... .................... void qsort(char * qdata, int qitems, int qsize, _Cmpfun cmp) { .................... int m,j,i,l; .................... short done; .................... BYTE t[16]; .................... .................... m = qitems/2; .................... while( m > 0 ) { .................... for(j=0; j<(qitems-m); ++j) { .................... i = j; .................... do .................... { .................... done=TRUE; .................... l = i+m; .................... if( (*cmp)(qdata+i*qsize, qdata+l*qsize) > 0 ) { .................... memcpy(t, qdata+i*qsize, qsize); .................... memcpy(qdata+i*qsize, qdata+l*qsize, qsize); .................... memcpy(qdata+l*qsize, t, qsize); .................... if(m <= i) .................... i -= m; .................... done = FALSE; .................... } .................... } while(!done); .................... } .................... m = m/2; .................... } .................... } .................... .................... .................... char *bsearch(char *key, char *base, size_t num, size_t width,_Cmpfun cmp) .................... { .................... char *p, *q; .................... size_t n; .................... size_t pivot; .................... signed int val; .................... .................... p = base; .................... n = num; .................... .................... while (n > 0) .................... { .................... pivot = n >> 1; .................... q = p + width * pivot; .................... .................... val = (*cmp)(key, q); .................... .................... if (val < 0) .................... n = pivot; .................... else if (val == 0) .................... return ((char *)q); .................... else { .................... p = q + width; .................... n -= pivot + 1; .................... } .................... } .................... .................... return NULL; // There's no match .................... } .................... .................... .................... #endif .................... .................... #include .................... /////////////////////////////////////////////////////////////////////////// .................... //// (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 _STDIO .................... #define _STDIO .................... #include .................... //////////////////////////////////////////////////////////////////////////// .................... //// (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 _STRING .................... #define _STRING .................... #include .................... #include .................... .................... .................... .................... ////////////////////////////////////////////// .................... //// Uncomment the following define to //// .................... //// allow some functions to use a //// .................... //// quicker algorithm, but use more ROM //// .................... //// //// .................... //// #define FASTER_BUT_MORE_ROM //// .................... ////////////////////////////////////////////// .................... .................... .................... .................... /*Copying functions*/ .................... /* standard template: .................... void *memmove(void *s1, void *s2, size_t n). .................... Copies max of n characters safely (not following ending '\0') .................... from s2 in s1; if s2 has less than n characters, appends 0 */ .................... .................... char *memmove(void *s1,char *s2,size_t n) .................... { .................... char *sc1; .................... char *sc2; .................... sc1=s1; .................... sc2=s2; .................... if(sc2 0 && *s2 != '\0'; n--) .................... *s++ = *s2++; .................... for (; n > 0; n--) .................... *s++ = '\0'; .................... .................... return(s1); .................... } .................... /***********************************************************/ .................... .................... /*concatenation functions*/ .................... /* standard template: char *strcat(char *s1, const char *s2) .................... appends s2 to s1*/ .................... .................... char *strcat(char *s1, char *s2) .................... { .................... char *s; .................... .................... for (s = s1; *s != '\0'; ++s); .................... while(*s2 != '\0') .................... { .................... *s = *s2; .................... ++s; .................... ++s2; .................... } .................... .................... *s = '\0'; .................... return(s1); .................... } .................... /* standard template: char *strncat(char *s1, char *s2,size_t n) .................... appends not more than n characters from s2 to s1*/ .................... .................... char *strncat(char *s1, char *s2, size_t n) .................... { .................... char *s; .................... .................... for (s = s1; *s != '\0'; ++s); .................... while(*s2 != '\0' && 0s2 */ .................... .................... signed int memcmp(void * s1,char *s2,size_t n) .................... { .................... char *su1, *su2; .................... for(su1=s1, su2=s2; 0s2 */ .................... .................... signed int strcmp(char *s1, char *s2) .................... { .................... for (; *s1 == *s2; s1++, s2++) .................... if (*s1 == '\0') .................... return(0); .................... return((*s1 < *s2) ? -1: 1); .................... } .................... /* standard template: int strcoll(const char *s1, const char *s2). .................... Compares s1 & s2; returns -1 if s1s2 */ .................... .................... signed int strcoll(char *s1, char *s2) .................... { .................... for (; *s1 == *s2; s1++, s2++) .................... if (*s1 == '\0') .................... return(0); .................... return((*s1 < *s2) ? -1: 1); .................... } .................... .................... /* standard template: .................... int strncmp(const char *s1, const char *s2, size_t n). .................... Compares max of n characters (not following 0) from s1 to s2; .................... returns same as strcmp */ .................... .................... signed int strncmp(char *s1, char *s2, size_t n) .................... { .................... for (; n > 0; s1++, s2++, n--) .................... if (*s1 != *s2) .................... return((*s1 <*s2) ? -1: 1); .................... else if (*s1 == '\0') .................... return(0); .................... return(0); .................... } .................... /* standard template: .................... int strxfrm(const char *s1, const char *s2, size_t n). .................... transforms maximum of n characters from s2 and places them into s1*/ .................... size_t strxfrm(char *s1, char *s2, size_t n) .................... { .................... char *s; .................... int n1; .................... n1=n; .................... for (s = s1; n > 0 && *s2 != '\0'; n--) .................... *s++ = *s2++; .................... for (; n > 0; n--) .................... *s++ = '\0'; .................... .................... return(n1); .................... } .................... .................... .................... .................... .................... .................... /***********************************************************/ .................... /*Search functions*/ .................... /* standard template: void *memchr(const char *s, int c). .................... Finds first occurrence of c in n characters of s */ .................... .................... char *memchr(void *s,int c,size_t n) .................... { .................... char uc; .................... char *su; .................... uc=c; .................... for(su=s;0= 'A' && *p <='Z') .................... *p += 'a' - 'A'; .................... return(s); .................... } .................... .................... .................... /************************************************************/ .................... .................... .................... #endif .................... .................... #ifndef getc .................... #define getc getch .................... #define getchar getch .................... #define puts(s) {printf(s); putchar(13); putchar(10);} .................... #define putc putchar .................... #endif .................... /* maps error number to an error message. Writes a sequence of characters to .................... stderr stream thus: if s is not null then string pointed to by s follwed by .................... a colon (:) and a space and the appropriate error message returned by strerror .................... function with argument errno .................... .................... Returns: no value .................... */ .................... .................... #ifdef _ERRNO .................... void perror(char *s) .................... { .................... if(s) .................... fprintf(STDERR,"%s: ",s); .................... fprintf(STDERR,"%s\r\n",strerror(errno)); .................... } .................... #endif .................... #endif .................... .................... .................... #use delay(clock=4000000, restart_wdt) * 0195: MOVLW E1 0196: MOVWF 04 0197: MOVF 00,W 0198: BTFSC 03.2 0199: GOTO 1AB 019A: MOVLW 01 019B: MOVWF 78 019C: MOVLW BF 019D: MOVWF 77 019E: CLRWDT 019F: DECFSZ 77,F 01A0: GOTO 19E 01A1: DECFSZ 78,F 01A2: GOTO 19C 01A3: MOVLW 4A 01A4: MOVWF 77 01A5: DECFSZ 77,F 01A6: GOTO 1A5 01A7: NOP 01A8: CLRWDT 01A9: DECFSZ 00,F 01AA: GOTO 19A 01AB: RETLW 00 .................... #include "Gulper_Main.h" .................... /****************************************************************************/ .................... /* Copyright 2006 MBARI. */ .................... /* Monterey Bay Aquarium Research Institute Proprietary Information. */ .................... /* All rights reserved. */ .................... /****************************************************************************/ .................... #ifndef PH_PROBE_H .................... #define PH_PROBE_H .................... .................... #define VS_VERSION "0.7" .................... #define DEBUG 0 .................... .................... .................... int8 fire[]="F"; * 0301: MOVLW 46 0302: MOVWF 2E 0303: CLRF 2F .................... int8 query[]="Q"; 0304: MOVLW 51 0305: MOVWF 30 0306: CLRF 31 .................... int8 status[]= "S"; 0307: MOVLW 53 0308: MOVWF 32 0309: CLRF 33 .................... int8 version[]="V"; 030A: MOVLW 56 030B: MOVWF 34 030C: CLRF 35 .................... int8 actuation[]="A"; 030D: MOVLW 41 030E: MOVWF 36 030F: CLRF 37 .................... int8 reset[]="R"; 0310: MOVLW 52 0311: MOVWF 38 0312: CLRF 39 .................... .................... char response_message[20]; // String for storing node response back to MVC .................... .................... int8 serial_delay_msec = 3; // delay for clocking 485 bits 0313: MOVLW 03 0314: MOVWF 4E .................... .................... // Timing variable initialization .................... int32 seconds = 0; // A running seconds counter for timer 1 0315: CLRF 4F 0316: CLRF 50 0317: CLRF 51 0318: CLRF 52 .................... int32 T2_seconds = 0; // A running seconds counter for timer 2 0319: CLRF 53 031A: CLRF 54 031B: CLRF 55 031C: CLRF 56 .................... int8 int_count = 0; // Number of interrupts left before a second has elapsed on timer 1 031D: CLRF 57 .................... int8 T2_int_count = 0; // Number of interrupts left before a second has elapsed on timer 2 031E: CLRF 58 .................... int32 ElapsedSeconds = 0; // A running seconds counter for timer 1 031F: CLRF 59 0320: CLRF 5A 0321: CLRF 5B 0322: CLRF 5C .................... int32 T2_ElapsedSeconds = 0; // A running seconds counter for timer 2 0323: CLRF 5D 0324: CLRF 5E 0325: CLRF 5F 0326: CLRF 60 .................... int8 Elapsed_int_count = 0; // Number of interrupts elapsed for timer 1 0327: CLRF 61 .................... int8 T2_Elapsed_int_count = 0; // Number of interrupts elapsed for timer 2 0328: CLRF 62 .................... int32 Final_Proximity_Milliseconds = 0; // Used to store time between fire and proximity sensor 0329: CLRF 63 032A: CLRF 64 032B: CLRF 65 032C: CLRF 66 .................... int32 Final_Actuation_Milliseconds = 0; // Used to store time between fire and pin puller voltage >= 2 volts 032D: CLRF 67 032E: CLRF 68 032F: CLRF 69 0330: CLRF 6A .................... .................... // Booleans .................... Boolean Fired = false; // Fire command received? 0331: BCF 6B.0 .................... Boolean proximity = false; // Proximity sensor ISR called? 0332: BCF 6B.1 .................... Boolean prox_error = false; // Proximity sensor triggered before firing? 0333: BCF 6B.2 .................... Boolean actuation_bool = false; // Actuation voltage above 2 volts? 0334: BCF 6B.3 .................... Boolean proximity_expired = false; // Set true at 30 seconds past firing if no prox interrupt received 0335: BCF 6B.4 .................... Boolean bad_address = false; // Address out of range? 0336: BCF 6B.5 .................... Boolean bad_checksum = false; // Incoming checksum error? 0337: BCF 6B.6 .................... Boolean pin_puller_retracted = false; // did the pin puller retract? 0338: BCF 6B.7 .................... .................... .................... /* .................... The ticks per second is based on an 8-bit counter over flowing that .................... is driven by a 4 Mhz ocsillator prescaled by 4 and postscaled by 64. .................... .................... TICKS_PER_SEC = (OSC_CLK) / (PRESCALE) / (POSTSCALE) / (8_BIT_OVERFLOW) .................... = 4000000 / 4 / 64 / 256 .................... = 61.0351 .................... */ .................... #define TICKS_PER_SEC 61 .................... .................... #define HI 1 .................... #define LO 0 .................... .................... #define ON 1 .................... #define OFF 0 .................... .................... void startTimer(void); .................... void getElapsedTime(void); .................... void T2_startTimer(void); .................... void T2_getElapsedTime(void); .................... .................... #endif .................... .................... #include "RS485.c" .................... /****************************************************************************/ .................... /* Copyright 2006 MBARI. */ .................... /* Monterey Bay Aquarium Research Institute Proprietary Information. */ .................... /* All rights reserved. */ .................... /****************************************************************************/ .................... // .................... // .................... // .................... // .................... // .................... // .................... // .................... .................... .................... #include .................... /////////////////////////////////////////////////////////////////////////// .................... //// (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 _STDLIB .................... #define _STDLIB .................... .................... //--------------------------------------------------------------------------- .................... // Definitions and types .................... //--------------------------------------------------------------------------- .................... .................... #ifndef RAND_MAX .................... #define RAND_MAX 32767 // The value of which is the maximum value .................... // ... returned by the rand function .................... #endif .................... .................... typedef struct { .................... signed int quot; .................... signed int rem; .................... } div_t; .................... .................... typedef struct { .................... signed long quot; .................... signed long rem; .................... } ldiv_t; .................... .................... #include .................... .................... //--------------------------------------------------------------------------- .................... // String conversion functions .................... //--------------------------------------------------------------------------- .................... .................... /* Standard template: float atof(char * s) .................... * converts the initial portion of the string s to a float. .................... * returns the converted value if any, 0 otherwise .................... */ .................... float atof(char * s); .................... .................... /* Standard template: float atoe(char * s) .................... * converts the initial portion of the string s to a float. .................... * returns the converted value if any, 0 otherwise .................... * also handles E format numbers .................... */ .................... float atoe(char * s); .................... .................... /* Standard template: signed int atoi(char * s) .................... * converts the initial portion of the string s to a signed int .................... * returns the converted value if any, 0 otherwise .................... */ .................... signed int atoi(char *s); .................... .................... /* Syntax: signed int32 atoi32(char * s) .................... converts the initial portion of the string s to a signed int32 .................... returns the converted value if any, 0 otherwise*/ .................... signed int32 atoi32(char *s); .................... .................... /* Syntax: char * itoa(signed int32 num, int8 base, char * s) .................... converts the signed int32 to a string and .................... returns the converted value if any, 0 otherwise*/ .................... char * itoa(signed int32 num, int8 base, char * s); .................... .................... /* Standard template: signed long atol(char * s) .................... * converts the initial portion of the string s to a signed long .................... * returns the converted value if any, 0 otherwise .................... */ .................... signed long atol(char *s); .................... .................... /* Standard template: float strtol(char * s,char *endptr) .................... * converts the initial portion of the string s to a float .................... * returns the converted value if any, 0 otherwise .................... * the final string is returned in the endptr, if endptr is not null .................... */ .................... float strtod(char *s,char *endptr); .................... .................... /* Standard template: long strtoul(char * s,char *endptr,signed int base) .................... * converts the initial portion of the string s, represented as an .................... * integral value of radix base to a signed long. .................... * Returns the converted value if any, 0 otherwise .................... * the final string is returned in the endptr, if endptr is not null .................... */ .................... signed long strtol(char *s,char *endptr,signed int base); .................... .................... /* Standard template: long strtoul(char * s,char *endptr,signed int base) .................... * converts the initial portion of the string s, represented as an .................... * integral value of radix base to a unsigned long. .................... * returns the converted value if any, 0 otherwise .................... * the final string is returned in the endptr, if endptr is not null .................... */ .................... long strtoul(char *s,char *endptr,signed int base); .................... .................... //--------------------------------------------------------------------------- .................... // Pseudo-random sequence generation functions .................... //--------------------------------------------------------------------------- .................... .................... /* The rand function computes a sequence of pseudo-random integers in .................... * the range 0 to RAND_MAX .................... * .................... * Parameters: .................... * (none) .................... * .................... * Returns: .................... * The pseudo-random integer .................... */ .................... long rand(void); .................... .................... /* The srand function uses the argument as a seed for a new sequence of .................... * pseudo-random numbers to be returned by subsequent calls to rand. .................... * .................... * Parameters: .................... * [in] seed: The seed value to start from. You might need to pass .................... * .................... * Returns: .................... * (none) .................... * .................... * Remarks .................... * The srand function sets the starting point for generating .................... * a series of pseudorandom integers. To reinitialize the .................... * generator, use 1 as the seed argument. Any other value for .................... * seed sets the generator to a random starting point. rand .................... * retrieves the pseudorandom numbers that are generated. .................... * Calling rand before any call to srand generates the same .................... * sequence as calling srand with seed passed as 1. .................... * Usually, you need to pass a time here from outer source .................... * so that the numbers will be different every time you run. .................... */ .................... void srand(unsigned int32 seed); .................... .................... //--------------------------------------------------------------------------- .................... // Memory management functions .................... //--------------------------------------------------------------------------- .................... .................... // Comming soon .................... .................... //--------------------------------------------------------------------------- .................... // Communication with the environment .................... //--------------------------------------------------------------------------- .................... .................... /* The function returns 0 always .................... */ .................... signed int system(char *string); .................... .................... //--------------------------------------------------------------------------- .................... // Searching and sorting utilities .................... //--------------------------------------------------------------------------- .................... .................... /* Performs a binary search of a sorted array.. .................... * .................... * Parameters: .................... * [in] key: Object to search for .................... * [in] base: Pointer to base of search data .................... * [in] num: Number of elements .................... * [in] width: Width of elements .................... * [in] compare: Function that compares two elements .................... * .................... * Returns: .................... * bsearch returns a pointer to an occurrence of key in the array pointed .................... * to by base. If key is not found, the function returns NULL. If the .................... * array is not in order or contains duplicate records with identical keys, .................... * the result is unpredictable. .................... */ .................... //void *bsearch(const void *key, const void *base, size_t num, size_t width, .................... // int (*compare)(const void *, const void *)); .................... .................... /* Performs the shell-metzner sort (not the quick sort algorithm). The contents .................... * of the array are sorted into ascending order according to a comparison .................... * function pointed to by compar. .................... * .................... * Parameters: .................... * [in] base: Pointer to base of search data .................... * [in] num: Number of elements .................... * [in] width: Width of elements .................... * [in] compare: Function that compares two elements .................... * .................... * Returns: .................... * (none) .................... */ .................... //void *qsort(const void *base, size_t num, size_t width, .................... // int (*compare)(const void *, const void *)); .................... .................... //--------------------------------------------------------------------------- .................... // Integer arithmetic functions .................... //--------------------------------------------------------------------------- .................... .................... #define labs abs .................... .................... div_t div(signed int numer,signed int denom); .................... ldiv_t ldiv(signed long numer,signed long denom); .................... .................... //--------------------------------------------------------------------------- .................... // Multibyte character functions .................... //--------------------------------------------------------------------------- .................... .................... // Not supported .................... .................... //--------------------------------------------------------------------------- .................... // Multibyte string functions .................... //--------------------------------------------------------------------------- .................... .................... // Not supported .................... .................... .................... //--------------------------------------------------------------------------- .................... // Internal implementation .................... //--------------------------------------------------------------------------- .................... .................... #include .................... #include .................... .................... 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; .................... float result = 0.0; .................... int sign = 0; .................... char c; .................... int ptr = 0; .................... .................... c = s[ptr++]; .................... .................... if ((c>='0' && c<='9') || c=='+' || c=='-' || c=='.') { .................... if(c == '-') { .................... sign = 1; .................... c = s[ptr++]; .................... } .................... if(c == '+') .................... c = s[ptr++]; .................... .................... while((c >= '0' && c <= '9')) { .................... result = 10*result + c - '0'; .................... c = s[ptr++]; .................... } .................... .................... if (c == '.') { .................... c = s[ptr++]; .................... while((c >= '0' && c <= '9')) { .................... pow10 = pow10*10; .................... result += (c - '0')/pow10; .................... c = s[ptr++]; .................... } .................... } .................... .................... } .................... .................... if (sign == 1) .................... result = -1*result; .................... return(result); .................... } .................... .................... float atoe(char * s) .................... { .................... float pow10 = 1.0; .................... float result = 0.0; .................... int sign = 0; .................... int expsign = 0; .................... char c; .................... int ptr = 0; .................... int i; .................... float exp = 1.0; .................... int expcnt = 0; .................... .................... c = s[ptr++]; .................... .................... if ((c>='0' && c<='9') || c=='+' || c=='-' || c=='.' || c=='E' || c=='e') { .................... if(c == '-') { .................... sign = 1; .................... c = s[ptr++]; .................... } .................... if(c == '+') .................... c = s[ptr++]; .................... .................... while((c >= '0' && c <= '9')) { .................... result = 10*result + c - '0'; .................... c = s[ptr++]; .................... } .................... .................... if (c == '.') { .................... c = s[ptr++]; .................... while((c >= '0' && c <= '9')) { .................... pow10 = pow10*10; .................... result += (c - '0')/pow10; .................... c = s[ptr++]; .................... } .................... } .................... .................... // Handling the exponent .................... if (c=='e' || c=='E') { .................... c = s[ptr++]; .................... .................... if(c == '-') { .................... expsign = 1; .................... c = s[ptr++]; .................... } .................... if(c == '+') .................... c = s[ptr++]; .................... .................... while((c >= '0' && c <= '9')) { .................... expcnt = 10*expcnt + c - '0'; .................... c = s[ptr++]; .................... } .................... .................... for(i=0;i= '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) .................... return 0; .................... 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); .................... } .................... } .................... } .................... .................... if (base == 10 && sign == 1) .................... result = -result; .................... .................... return(result); .................... } .................... .................... /* A fast routine to multiply by 10 .................... */ .................... signed int32 mult_with10(int32 num) .................... { .................... return ( (num << 1) + (num << 3) ); .................... } .................... .................... signed int32 atoi32(char *s) .................... { .................... signed int32 result; .................... int sign, base, index; .................... char c; .................... .................... index = 0; .................... sign = 0; .................... base = 10; .................... result = 0; .................... .................... if (!s) .................... return 0; .................... 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 = (result << 1) + (result << 3); // 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 (base == 10 && sign == 1) .................... result = -result; .................... .................... return(result); .................... } .................... .................... char * itoa(signed int32 num, int8 base, char *s) .................... { .................... int32 temp=1; .................... int8 i,sign=0,cnt=0; .................... char c; .................... .................... if(num<0) { .................... sign=1; // Check for negative number .................... num*=-1; .................... } .................... .................... while(temp>0) { .................... temp=(num/base); .................... s[cnt]=(num%base)+'0'; // Conversion .................... .................... if(s[cnt]>0x39) .................... s[cnt]+=0x7; .................... .................... cnt++; .................... num=temp; .................... } .................... .................... if(sign==1) { .................... s[cnt]=0x2D; // Negative sign .................... cnt++; .................... } .................... .................... for(i = 0;i<(int8)(cnt/2);i++) { .................... .................... c=s[i]; .................... s[i]=s[cnt-i-1]; // Reverse the number .................... s[cnt-i-1]=c; .................... } .................... s[cnt]='\0'; // End the string .................... return s; .................... } .................... .................... float strtod(char *s,char *endptr) { .................... float pow10 = 1.0; .................... float result = 0.0; .................... int sign = 0, point = 0; .................... char c; .................... int ptr = 0; .................... .................... if (!s) .................... return 0; .................... c=s[ptr++]; .................... .................... .................... while((c>='0' && c<='9') || c=='+' || c=='-' || c=='.') { .................... if(c == '-') { .................... sign = 1; .................... c = s[ptr++]; .................... } .................... .................... while((c >= '0' && c <= '9') && point == 0) { .................... result = 10*result + c - '0'; .................... c = s[ptr++]; .................... } .................... .................... if (c == '.') { .................... point = 1; .................... c = s[ptr++]; .................... } .................... .................... while((c >= '0' && c <= '9') && point == 1) { .................... pow10 = pow10*10; .................... result += (c - '0')/pow10; .................... c = s[ptr++]; .................... } .................... .................... if (c == '+') { .................... c = s[ptr++]; .................... } .................... } .................... .................... if (sign == 1) .................... result = -1*result; .................... if(endptr) .................... { .................... if (ptr) { .................... ptr--; .................... *((char *)endptr)=s+ptr; .................... } .................... else .................... *((char *)endptr)=s; .................... } .................... .................... return(result); .................... } .................... .................... long strtoul(char *s,char *endptr,signed int base) .................... { .................... char *sc,*s1,*sd; .................... unsigned long x=0; .................... char sign; .................... char digits[]="0123456789abcdefghijklmnopqstuvwxyz"; .................... for(sc=s;isspace(*sc);++sc); .................... sign=*sc=='-'||*sc=='+'?*sc++:'+'; .................... if(sign=='-') .................... { .................... if (endptr) .................... { .................... *((char *)endptr)=s; .................... } .................... return 0; .................... } .................... .................... if (base <0 || base ==1|| base >36) // invalid base .................... { .................... if (endptr) .................... { .................... *((char *)endptr)=s; .................... } .................... return 0; .................... } .................... else if (base) .................... { .................... if(base==16 && *sc =='0'&&(sc[1]=='x' || sc[1]=='X')) .................... sc+=2; .................... if(base==8 && *sc =='0') .................... sc+=1; .................... if(base==2 && *sc =='0'&&sc[1]=='b') .................... sc+=2; .................... .................... } .................... else if(*sc!='0') // base is 0, find base .................... base=10; .................... else if (sc[1]=='x' || sc[1]=='X') .................... base =16,sc+=2; .................... else if(sc[1]=='b') .................... base=2,sc+=2; .................... else .................... base=8; .................... for (s1=sc;*sc=='0';++sc);// skip leading zeroes .................... sd=memchr(digits,tolower(*sc),base); .................... for(; sd!=0; ) .................... { .................... x=x*base+(int16)(sd-digits); .................... ++sc; .................... sd=memchr(digits,tolower(*sc),base); .................... } .................... if(s1==sc) .................... { .................... if (endptr) .................... { .................... *((char *)endptr)=s; .................... } .................... return 0; .................... } .................... if (endptr) .................... *((char *)endptr)=sc; .................... return x; .................... } .................... .................... .................... signed long strtol(char *s,char *endptr,signed int base) .................... { .................... char *sc,*s1,*sd; .................... signed long x=0; .................... char sign; .................... char digits[]="0123456789abcdefghijklmnopqstuvwxyz"; .................... for(sc=s;isspace(*sc);++sc); .................... sign=*sc=='-'||*sc=='+'?*sc++:'+'; .................... if (base <0 || base ==1|| base >36) // invalid base .................... { .................... if (endptr) .................... { .................... *((char *)endptr)=s; .................... } .................... return 0; .................... } .................... else if (base) .................... { .................... if(base==16 && *sc =='0'&&(sc[1]=='x' || sc[1]=='X')) .................... sc+=2; .................... if(base==8 && *sc =='0') .................... sc+=1; .................... if(base==2 && *sc =='0'&&sc[1]=='b') .................... sc+=2; .................... .................... } .................... else if(*sc!='0') // base is 0, find base .................... base=10; .................... else if (sc[1]=='x' || sc[1]=='X') .................... base =16,sc+=2; .................... else if(sc[1]=='b') .................... base=2,sc+=2; .................... else .................... base=8; .................... for (s1=sc;*sc=='0';++sc);// skip leading zeroes .................... .................... sd=memchr(digits,tolower(*sc),base); .................... for(;sd!=0;) .................... { .................... x=x*base+(int16)(sd-digits); .................... ++sc; .................... sd=memchr(digits,tolower(*sc),base); .................... } .................... if(s1==sc) .................... { .................... if (endptr) .................... { .................... *((char *)endptr)=s; .................... } .................... return 0; .................... } .................... if(sign=='-') .................... x =-x; .................... if (endptr) .................... *((char *)endptr)=sc; .................... return x; .................... } .................... .................... signed int system(char *string) .................... { .................... return 0; .................... } .................... .................... int mblen(char *s,size_t n) .................... { .................... return strlen(s); .................... } .................... .................... int mbtowc(wchar_t *pwc,char *s,size_t n) .................... { .................... *pwc=*s; .................... return 1; .................... } .................... .................... int wctomb(char *s,wchar_t wchar) .................... { .................... *s=wchar; .................... return 1; .................... } .................... .................... size_t mbstowcs(wchar_t *pwcs,char *s,size_t n) .................... { .................... strncpy(pwcs,s,n); .................... return strlen(pwcs); .................... } .................... .................... size_t wcstombs(char *s,wchar_t *pwcs,size_t n) .................... { .................... strncpy(s,pwcs,n); .................... return strlen(s); .................... } .................... .................... //--------------------------------------------------------------------------- .................... // The random number implementation .................... //--------------------------------------------------------------------------- .................... .................... unsigned int32 _Randseed = 1; .................... .................... long rand(void) .................... { .................... _Randseed = _Randseed * 1103515245 + 12345; .................... return ((unsigned long)(_Randseed >> 16) % RAND_MAX); .................... } .................... .................... void srand(unsigned int32 seed) .................... { .................... _Randseed = seed; .................... } .................... .................... //--------------------------------------------------------------------------- .................... // Searching and sorting utilities implementation .................... //--------------------------------------------------------------------------- .................... .................... typedef signed int (*_Cmpfun)(char * p1,char * p2); .................... .................... void qsort(char * qdata, int qitems, int qsize, _Cmpfun cmp) { .................... int m,j,i,l; .................... short done; .................... BYTE t[16]; .................... .................... m = qitems/2; .................... while( m > 0 ) { .................... for(j=0; j<(qitems-m); ++j) { .................... i = j; .................... do .................... { .................... done=TRUE; .................... l = i+m; .................... if( (*cmp)(qdata+i*qsize, qdata+l*qsize) > 0 ) { .................... memcpy(t, qdata+i*qsize, qsize); .................... memcpy(qdata+i*qsize, qdata+l*qsize, qsize); .................... memcpy(qdata+l*qsize, t, qsize); .................... if(m <= i) .................... i -= m; .................... done = FALSE; .................... } .................... } while(!done); .................... } .................... m = m/2; .................... } .................... } .................... .................... .................... char *bsearch(char *key, char *base, size_t num, size_t width,_Cmpfun cmp) .................... { .................... char *p, *q; .................... size_t n; .................... size_t pivot; .................... signed int val; .................... .................... p = base; .................... n = num; .................... .................... while (n > 0) .................... { .................... pivot = n >> 1; .................... q = p + width * pivot; .................... .................... val = (*cmp)(key, q); .................... .................... if (val < 0) .................... n = pivot; .................... else if (val == 0) .................... return ((char *)q); .................... else { .................... p = q + width; .................... n -= pivot + 1; .................... } .................... } .................... .................... return NULL; // There's no match .................... } .................... .................... .................... #endif .................... .................... .................... .................... #ifndef RS485_DRIVER .................... #define RS485_DRIVER .................... .................... int8 RS485_ID=0; 0339: CLRF 6C .................... .................... .................... #ifndef RS485_RX_PIN .................... #define RS485_RX_PIN PIN_C7 // Data receive pin .................... #endif .................... .................... #ifndef RS485_TX_PIN .................... #define RS485_TX_PIN PIN_C6 // Data transmit pin .................... #endif .................... .................... #ifndef RS485_RX_ENABLE .................... #define RS485_RX_ENABLE PIN_B4 // Controls RE pin. Should keep low. .................... #endif .................... .................... #use rs232(baud=9600, xmit=RS485_TX_PIN, rcv=RS485_RX_PIN,bits=8, enable=RS485_RX_ENABLE, stream=RS485,errors, RESTART_WDT, DISABLE_INTS)//rcv * 0058: CLRWDT 0059: BTFSS 0C.5 005A: GOTO 058 005B: MOVF 18,W 005C: MOVWF 6D 005D: MOVF 1A,W 005E: MOVWF 78 005F: BTFSS 6D.1 0060: GOTO 063 0061: BCF 18.4 0062: BSF 18.4 0063: NOP 0064: RETLW 00 * 017D: BSF 03.5 017E: BCF 06.4 017F: BCF 03.5 0180: BSF 06.4 0181: BTFSS 0C.4 0182: GOTO 181 0183: BSF 03.5 0184: MOVF 62,W 0185: BCF 03.5 0186: MOVWF 19 0187: NOP 0188: BSF 03.5 0189: BCF 06.4 018A: BCF 03.5 018B: BSF 06.4 018C: BSF 03.5 018D: BTFSC 18.1 018E: GOTO 191 018F: BCF 03.5 0190: GOTO 18C 0191: BCF 06.4 0192: BCF 03.5 0193: BCF 06.4 0194: RETLW 00 * 033A: CLRF 6D .................... .................... #define RS485_wait_time 20 // Wait time in milliseconds .................... .................... #bit rs485_collision = rs232_errors.6 .................... .................... int new_message; .................... int8 rs485_InBuffer[30]; .................... int8 cmd_InBuffer[1]; .................... int index; .................... int Receiving = false; 033B: CLRF 71 .................... int8 to_address = 0xFF; //Initialize to impossible address 033C: MOVLW FF 033D: MOVWF 72 .................... int8 incoming_checksum = 0x00; //To store incoming checksum 033E: CLRF 73 .................... .................... .................... // Purpose: Enable data reception .................... // Inputs: None .................... // Outputs: None .................... void RCV_ON(void) { .................... while(kbhit(RS485)) {fgetc(RS485);} // Clear RX buffer. Clear RDA interrupt flag. Clear overrun error flag. * 0178: BTFSS 0C.5 0179: GOTO 17C 017A: CALL 058 017B: GOTO 178 .................... // output_high(RS485_RX_ENABLE); .................... } 017C: RETLW 00 .................... .................... void RCV_OFF(void) { .................... output_low(RS485_RX_ENABLE); * 0173: BSF 03.5 0174: BCF 06.4 0175: BCF 03.5 0176: BCF 06.4 .................... } 0177: RETLW 00 .................... .................... .................... // Purpose: Initialize RS485 communication. Call this before .................... // using any other RS485 functions. .................... // Inputs: None .................... // Outputs: None .................... void rs485_init() { .................... RS485_ID= 0; .................... RCV_ON(); .................... new_message=FALSE; .................... enable_interrupts(INT_RDA); .................... enable_interrupts(GLOBAL); .................... .................... } .................... .................... .................... // Purpose: Send a message over the RS485 bus .................... // Inputs: 1) To address .................... // 2) From address .................... // 3) len .................... // 4) data (acknowlege, time to close) .................... // Outputs: TRUE if successful .................... // FALSE if failed .................... // Note: Format: msg typ | source | data .................... int1 rs485_send_message(int8 my_id, int8 len, int8* data) { .................... int8 try, i, cs; .................... int1 ret = FALSE; * 0225: BCF 60.0 .................... .................... RCV_OFF(); 0226: BCF 03.5 0227: CALL 173 .................... .................... for(try=0; try<5; ++try) { 0228: BSF 03.5 0229: CLRF 5D 022A: MOVF 5D,W 022B: SUBLW 04 022C: BTFSS 03.0 022D: GOTO 255 .................... rs485_collision = 0; 022E: BCF 03.5 022F: BCF 6D.6 .................... .................... for(i=0; i=7) // Check for end of message 0093: MOVF 70,W 0094: SUBLW 06 0095: BTFSC 03.0 0096: GOTO 12D .................... { .................... Receiving = false; // Done receiving 0097: CLRF 71 .................... index = 0; // Reset index 0098: CLRF 70 .................... new_message=TRUE; // Anncounce the receipt of a new message 0099: MOVLW 01 009A: BCF 03.5 009B: MOVWF 6E .................... .................... // .................... // Convert ascii to hex for to_address .................... // .................... if( (isxdigit(rs485_InBuffer[1])) && (isxdigit(rs485_InBuffer[2])) ) 009C: BSF 03.5 009D: MOVF 21,W 009E: SUBLW 2F 009F: BTFSC 03.0 00A0: GOTO 0A5 00A1: MOVF 21,W 00A2: SUBLW 39 00A3: BTFSC 03.0 00A4: GOTO 0B5 00A5: MOVF 21,W 00A6: SUBLW 40 00A7: BTFSC 03.0 00A8: GOTO 0AD 00A9: MOVF 21,W 00AA: SUBLW 46 00AB: BTFSC 03.0 00AC: GOTO 0B5 00AD: MOVF 21,W 00AE: SUBLW 60 00AF: BTFSC 03.0 00B0: GOTO 0E2 00B1: MOVF 21,W 00B2: SUBLW 66 00B3: BTFSS 03.0 00B4: GOTO 0E2 00B5: MOVF 22,W 00B6: SUBLW 2F 00B7: BTFSC 03.0 00B8: GOTO 0BD 00B9: MOVF 22,W 00BA: SUBLW 39 00BB: BTFSC 03.0 00BC: GOTO 0CD 00BD: MOVF 22,W 00BE: SUBLW 40 00BF: BTFSC 03.0 00C0: GOTO 0C5 00C1: MOVF 22,W 00C2: SUBLW 46 00C3: BTFSC 03.0 00C4: GOTO 0CD 00C5: MOVF 22,W 00C6: SUBLW 60 00C7: BTFSC 03.0 00C8: GOTO 0E2 00C9: MOVF 22,W 00CA: SUBLW 66 00CB: BTFSS 03.0 00CC: GOTO 0E2 .................... { .................... if (rs485_InBuffer[2] > '9') 00CD: MOVF 22,W 00CE: SUBLW 39 00CF: BTFSC 03.0 00D0: GOTO 0D3 .................... { .................... rs485_InBuffer[2] += 9; 00D1: MOVLW 09 00D2: ADDWF 22,F .................... } .................... rs485_InBuffer[2] &= 0x0F; 00D3: MOVLW 0F 00D4: ANDWF 22,F .................... .................... if (rs485_InBuffer[1] > '9') 00D5: MOVF 21,W 00D6: SUBLW 39 00D7: BTFSC 03.0 00D8: GOTO 0DB .................... { .................... rs485_InBuffer[1] += 9; 00D9: MOVLW 09 00DA: ADDWF 21,F .................... } .................... .................... rs485_InBuffer[1] &= 0x0F; 00DB: MOVLW 0F 00DC: ANDWF 21,F .................... to_address =( (rs485_InBuffer[1]<<1)|(rs485_InBuffer[2]) ); 00DD: BCF 03.0 00DE: RLF 21,W 00DF: IORWF 22,W 00E0: MOVWF 72 .................... } .................... else 00E1: GOTO 0E5 .................... { .................... bad_address = true; 00E2: BCF 03.5 00E3: BSF 6B.5 00E4: BSF 03.5 .................... } .................... .................... // .................... // Convert ascii to hex for incoming_checksum .................... // .................... if( (isxdigit(rs485_InBuffer[5])) && (isxdigit(rs485_InBuffer[6])) ) 00E5: MOVF 25,W 00E6: SUBLW 2F 00E7: BTFSC 03.0 00E8: GOTO 0ED 00E9: MOVF 25,W 00EA: SUBLW 39 00EB: BTFSC 03.0 00EC: GOTO 0FD 00ED: MOVF 25,W 00EE: SUBLW 40 00EF: BTFSC 03.0 00F0: GOTO 0F5 00F1: MOVF 25,W 00F2: SUBLW 46 00F3: BTFSC 03.0 00F4: GOTO 0FD 00F5: MOVF 25,W 00F6: SUBLW 60 00F7: BTFSC 03.0 00F8: GOTO 12A 00F9: MOVF 25,W 00FA: SUBLW 66 00FB: BTFSS 03.0 00FC: GOTO 12A 00FD: MOVF 26,W 00FE: SUBLW 2F 00FF: BTFSC 03.0 0100: GOTO 105 0101: MOVF 26,W 0102: SUBLW 39 0103: BTFSC 03.0 0104: GOTO 115 0105: MOVF 26,W 0106: SUBLW 40 0107: BTFSC 03.0 0108: GOTO 10D 0109: MOVF 26,W 010A: SUBLW 46 010B: BTFSC 03.0 010C: GOTO 115 010D: MOVF 26,W 010E: SUBLW 60 010F: BTFSC 03.0 0110: GOTO 12A 0111: MOVF 26,W 0112: SUBLW 66 0113: BTFSS 03.0 0114: GOTO 12A .................... { .................... if (rs485_InBuffer[6] > '9') 0115: MOVF 26,W 0116: SUBLW 39 0117: BTFSC 03.0 0118: GOTO 11B .................... { .................... rs485_InBuffer[6] += 9; 0119: MOVLW 09 011A: ADDWF 26,F .................... } .................... rs485_InBuffer[6] &= 0x0F; 011B: MOVLW 0F 011C: ANDWF 26,F .................... .................... if (rs485_InBuffer[5] > '9') 011D: MOVF 25,W 011E: SUBLW 39 011F: BTFSC 03.0 0120: GOTO 123 .................... { .................... rs485_InBuffer[5] += 9; 0121: MOVLW 09 0122: ADDWF 25,F .................... } .................... .................... rs485_InBuffer[5] &= 0x0F; 0123: MOVLW 0F 0124: ANDWF 25,F .................... incoming_checksum =( (rs485_InBuffer[5]<<1)|(rs485_InBuffer[6]) ); 0125: BCF 03.0 0126: RLF 25,W 0127: IORWF 26,W 0128: MOVWF 73 .................... } .................... else 0129: GOTO 12D .................... { .................... bad_checksum = true; 012A: BCF 03.5 012B: BSF 6B.6 012C: BSF 03.5 .................... } .................... .................... .................... } // End of message processing .................... } .................... // Turn receive back on .................... //** RCV_ON(); .................... } .................... .................... 012D: BCF 03.5 012E: BCF 0C.5 012F: BCF 0A.3 0130: BCF 0A.4 0131: GOTO 025 .................... int1 rs485_get_new_message(int8 my_ID, int1 wait) .................... { .................... while(wait && (new_message==FALSE)) {} .................... .................... if(new_message==FALSE) .................... return FALSE; .................... else .................... { .................... if( (to_address == RS485_ID) && (!bad_address) ) //check if message is for this address .................... { .................... new_message=FALSE; //clear new_message flag .................... return TRUE;} .................... else //message not for my address, clear new message flag but don't copy input data .................... { .................... bad_address = false; .................... new_message=FALSE; .................... return FALSE;} .................... } .................... } .................... .................... .................... .................... // Purpose: Wait for wait time for the RS485 bus to become idle .................... // Inputs: TRUE - restart the watch dog timer to prevent reset .................... // FALSE - watch dog timer not restarted .................... // Outputs: None .................... void rs485_wait_for_bus(int1 clrwdt) .................... { .................... int16 i; .................... .................... RCV_OFF(); * 01F5: BCF 03.5 01F6: CALL 173 .................... for(i=0; i <= (rs485_wait_time*20); ++i) 01F7: BSF 03.5 01F8: CLRF 5C 01F9: CLRF 5B 01FA: MOVF 5C,W 01FB: SUBLW 01 01FC: BTFSS 03.0 01FD: GOTO 21C 01FE: BTFSS 03.2 01FF: GOTO 204 0200: MOVF 5B,W 0201: SUBLW 90 0202: BTFSS 03.0 0203: GOTO 21C .................... { .................... if(!input(RS485_RX_PIN))//this is inverted as in the original file 0204: BSF 74.7 0205: MOVF 74,W 0206: MOVWF 07 0207: BCF 03.5 0208: BTFSC 07.7 0209: GOTO 20F * 033F: MOVWF 74 .................... i = 0; * 020A: BSF 03.5 020B: CLRF 5C 020C: CLRF 5B .................... else 020D: GOTO 215 020E: BCF 03.5 .................... delay_us(50); 020F: CLRWDT 0210: MOVLW 10 0211: MOVWF 77 0212: DECFSZ 77,F 0213: GOTO 212 0214: BSF 03.5 .................... .................... if(clrwdt) 0215: MOVF 5A,F 0216: BTFSS 03.2 .................... restart_wdt(); 0217: CLRWDT .................... } 0218: INCF 5B,F 0219: BTFSC 03.2 021A: INCF 5C,F 021B: GOTO 1FA .................... RCV_ON(); 021C: BCF 03.5 021D: CALL 178 .................... } .................... .................... void send_response(char* s) .................... { .................... int8 size; .................... char* header[20]; .................... // .................... output_bit(PIN_B1, HI); // Turn on TX LED .................... .................... sprintf(header, "*%x",RS485_ID); * 0340: CLRF 75 .................... s = strncat(header, s, 16); .................... .................... for(size=0; s[size]!='\0'; ++size); .................... .................... rs485_wait_for_bus(false); .................... while(!rs485_send_message(RS485_ID,size, s)) .................... { .................... delay_ms(10); .................... } .................... output_bit(PIN_B1, LO); // Turn off TX LED .................... } .................... .................... void send_error_response(char* s) .................... { .................... int8 size; .................... char* header[20]; .................... sprintf(header, "?%x ",RS485_ID); * 01AC: MOVLW C6 01AD: MOVWF 75 01AE: MOVLW 3F 01AF: BSF 03.5 01B0: MOVWF 5C 01B1: BCF 03.5 01B2: CALL 142 01B3: MOVF 6C,W 01B4: BSF 03.5 01B5: MOVWF 5A 01B6: MOVLW 57 01B7: MOVWF 5B 01B8: BCF 03.5 01B9: GOTO 14C 01BA: MOVLW 20 01BB: BSF 03.5 01BC: MOVWF 5C 01BD: BCF 03.5 01BE: CALL 142 .................... s = strncat(header, s, 16); 01BF: MOVLW C6 01C0: BSF 03.5 01C1: MOVWF 5A 01C2: MOVF 44,W 01C3: MOVWF 5B 01C4: MOVLW 10 01C5: MOVWF 5C * 01E9: MOVF 78,W 01EA: MOVWF 44 .................... .................... for(size=0; s[size]!='\0'; ++size); 01EB: CLRF 45 01EC: MOVF 44,W 01ED: ADDWF 45,W 01EE: MOVWF 04 01EF: MOVF 00,F 01F0: BTFSC 03.2 01F1: GOTO 1F4 01F2: INCF 45,F 01F3: GOTO 1EC .................... .................... rs485_wait_for_bus(false); 01F4: CLRF 5A .................... while(!rs485_send_message(RS485_ID,size, s)) .................... { * 021E: MOVF 6C,W 021F: BSF 03.5 0220: MOVWF 5A 0221: MOVF 45,W 0222: MOVWF 5B 0223: MOVF 44,W 0224: MOVWF 5C * 025C: MOVF 78,F 025D: BTFSS 03.2 025E: GOTO 265 .................... delay_ms(10); 025F: MOVLW 0A 0260: MOVWF 61 0261: BCF 03.5 0262: CALL 195 .................... } 0263: GOTO 21E 0264: BSF 03.5 .................... } 0265: BCF 03.5 0266: BCF 0A.3 0267: BCF 0A.4 0268: GOTO 392 (RETURN) .................... .................... .................... #include "Command_Handler.c" .................... /****************************************************************************/ .................... /* Copyright 2006 MBARI. */ .................... /* Monterey Bay Aquarium Research Institute Proprietary Information. */ .................... /* All rights reserved. */ .................... /****************************************************************************/ .................... .................... .................... #include .................... /////////////////////////////////////////////////////////////////////////// .................... //// (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 _STDLIB .................... #define _STDLIB .................... .................... //--------------------------------------------------------------------------- .................... // Definitions and types .................... //--------------------------------------------------------------------------- .................... .................... #ifndef RAND_MAX .................... #define RAND_MAX 32767 // The value of which is the maximum value .................... // ... returned by the rand function .................... #endif .................... .................... typedef struct { .................... signed int quot; .................... signed int rem; .................... } div_t; .................... .................... typedef struct { .................... signed long quot; .................... signed long rem; .................... } ldiv_t; .................... .................... #include .................... .................... //--------------------------------------------------------------------------- .................... // String conversion functions .................... //--------------------------------------------------------------------------- .................... .................... /* Standard template: float atof(char * s) .................... * converts the initial portion of the string s to a float. .................... * returns the converted value if any, 0 otherwise .................... */ .................... float atof(char * s); .................... .................... /* Standard template: float atoe(char * s) .................... * converts the initial portion of the string s to a float. .................... * returns the converted value if any, 0 otherwise .................... * also handles E format numbers .................... */ .................... float atoe(char * s); .................... .................... /* Standard template: signed int atoi(char * s) .................... * converts the initial portion of the string s to a signed int .................... * returns the converted value if any, 0 otherwise .................... */ .................... signed int atoi(char *s); .................... .................... /* Syntax: signed int32 atoi32(char * s) .................... converts the initial portion of the string s to a signed int32 .................... returns the converted value if any, 0 otherwise*/ .................... signed int32 atoi32(char *s); .................... .................... /* Syntax: char * itoa(signed int32 num, int8 base, char * s) .................... converts the signed int32 to a string and .................... returns the converted value if any, 0 otherwise*/ .................... char * itoa(signed int32 num, int8 base, char * s); .................... .................... /* Standard template: signed long atol(char * s) .................... * converts the initial portion of the string s to a signed long .................... * returns the converted value if any, 0 otherwise .................... */ .................... signed long atol(char *s); .................... .................... /* Standard template: float strtol(char * s,char *endptr) .................... * converts the initial portion of the string s to a float .................... * returns the converted value if any, 0 otherwise .................... * the final string is returned in the endptr, if endptr is not null .................... */ .................... float strtod(char *s,char *endptr); .................... .................... /* Standard template: long strtoul(char * s,char *endptr,signed int base) .................... * converts the initial portion of the string s, represented as an .................... * integral value of radix base to a signed long. .................... * Returns the converted value if any, 0 otherwise .................... * the final string is returned in the endptr, if endptr is not null .................... */ .................... signed long strtol(char *s,char *endptr,signed int base); .................... .................... /* Standard template: long strtoul(char * s,char *endptr,signed int base) .................... * converts the initial portion of the string s, represented as an .................... * integral value of radix base to a unsigned long. .................... * returns the converted value if any, 0 otherwise .................... * the final string is returned in the endptr, if endptr is not null .................... */ .................... long strtoul(char *s,char *endptr,signed int base); .................... .................... //--------------------------------------------------------------------------- .................... // Pseudo-random sequence generation functions .................... //--------------------------------------------------------------------------- .................... .................... /* The rand function computes a sequence of pseudo-random integers in .................... * the range 0 to RAND_MAX .................... * .................... * Parameters: .................... * (none) .................... * .................... * Returns: .................... * The pseudo-random integer .................... */ .................... long rand(void); .................... .................... /* The srand function uses the argument as a seed for a new sequence of .................... * pseudo-random numbers to be returned by subsequent calls to rand. .................... * .................... * Parameters: .................... * [in] seed: The seed value to start from. You might need to pass .................... * .................... * Returns: .................... * (none) .................... * .................... * Remarks .................... * The srand function sets the starting point for generating .................... * a series of pseudorandom integers. To reinitialize the .................... * generator, use 1 as the seed argument. Any other value for .................... * seed sets the generator to a random starting point. rand .................... * retrieves the pseudorandom numbers that are generated. .................... * Calling rand before any call to srand generates the same .................... * sequence as calling srand with seed passed as 1. .................... * Usually, you need to pass a time here from outer source .................... * so that the numbers will be different every time you run. .................... */ .................... void srand(unsigned int32 seed); .................... .................... //--------------------------------------------------------------------------- .................... // Memory management functions .................... //--------------------------------------------------------------------------- .................... .................... // Comming soon .................... .................... //--------------------------------------------------------------------------- .................... // Communication with the environment .................... //--------------------------------------------------------------------------- .................... .................... /* The function returns 0 always .................... */ .................... signed int system(char *string); .................... .................... //--------------------------------------------------------------------------- .................... // Searching and sorting utilities .................... //--------------------------------------------------------------------------- .................... .................... /* Performs a binary search of a sorted array.. .................... * .................... * Parameters: .................... * [in] key: Object to search for .................... * [in] base: Pointer to base of search data .................... * [in] num: Number of elements .................... * [in] width: Width of elements .................... * [in] compare: Function that compares two elements .................... * .................... * Returns: .................... * bsearch returns a pointer to an occurrence of key in the array pointed .................... * to by base. If key is not found, the function returns NULL. If the .................... * array is not in order or contains duplicate records with identical keys, .................... * the result is unpredictable. .................... */ .................... //void *bsearch(const void *key, const void *base, size_t num, size_t width, .................... // int (*compare)(const void *, const void *)); .................... .................... /* Performs the shell-metzner sort (not the quick sort algorithm). The contents .................... * of the array are sorted into ascending order according to a comparison .................... * function pointed to by compar. .................... * .................... * Parameters: .................... * [in] base: Pointer to base of search data .................... * [in] num: Number of elements .................... * [in] width: Width of elements .................... * [in] compare: Function that compares two elements .................... * .................... * Returns: .................... * (none) .................... */ .................... //void *qsort(const void *base, size_t num, size_t width, .................... // int (*compare)(const void *, const void *)); .................... .................... //--------------------------------------------------------------------------- .................... // Integer arithmetic functions .................... //--------------------------------------------------------------------------- .................... .................... #define labs abs .................... .................... div_t div(signed int numer,signed int denom); .................... ldiv_t ldiv(signed long numer,signed long denom); .................... .................... //--------------------------------------------------------------------------- .................... // Multibyte character functions .................... //--------------------------------------------------------------------------- .................... .................... // Not supported .................... .................... //--------------------------------------------------------------------------- .................... // Multibyte string functions .................... //--------------------------------------------------------------------------- .................... .................... // Not supported .................... .................... .................... //--------------------------------------------------------------------------- .................... // Internal implementation .................... //--------------------------------------------------------------------------- .................... .................... #include .................... #include .................... .................... 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; .................... float result = 0.0; .................... int sign = 0; .................... char c; .................... int ptr = 0; .................... .................... c = s[ptr++]; .................... .................... if ((c>='0' && c<='9') || c=='+' || c=='-' || c=='.') { .................... if(c == '-') { .................... sign = 1; .................... c = s[ptr++]; .................... } .................... if(c == '+') .................... c = s[ptr++]; .................... .................... while((c >= '0' && c <= '9')) { .................... result = 10*result + c - '0'; .................... c = s[ptr++]; .................... } .................... .................... if (c == '.') { .................... c = s[ptr++]; .................... while((c >= '0' && c <= '9')) { .................... pow10 = pow10*10; .................... result += (c - '0')/pow10; .................... c = s[ptr++]; .................... } .................... } .................... .................... } .................... .................... if (sign == 1) .................... result = -1*result; .................... return(result); .................... } .................... .................... float atoe(char * s) .................... { .................... float pow10 = 1.0; .................... float result = 0.0; .................... int sign = 0; .................... int expsign = 0; .................... char c; .................... int ptr = 0; .................... int i; .................... float exp = 1.0; .................... int expcnt = 0; .................... .................... c = s[ptr++]; .................... .................... if ((c>='0' && c<='9') || c=='+' || c=='-' || c=='.' || c=='E' || c=='e') { .................... if(c == '-') { .................... sign = 1; .................... c = s[ptr++]; .................... } .................... if(c == '+') .................... c = s[ptr++]; .................... .................... while((c >= '0' && c <= '9')) { .................... result = 10*result + c - '0'; .................... c = s[ptr++]; .................... } .................... .................... if (c == '.') { .................... c = s[ptr++]; .................... while((c >= '0' && c <= '9')) { .................... pow10 = pow10*10; .................... result += (c - '0')/pow10; .................... c = s[ptr++]; .................... } .................... } .................... .................... // Handling the exponent .................... if (c=='e' || c=='E') { .................... c = s[ptr++]; .................... .................... if(c == '-') { .................... expsign = 1; .................... c = s[ptr++]; .................... } .................... if(c == '+') .................... c = s[ptr++]; .................... .................... while((c >= '0' && c <= '9')) { .................... expcnt = 10*expcnt + c - '0'; .................... c = s[ptr++]; .................... } .................... .................... for(i=0;i= '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) .................... return 0; .................... 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); .................... } .................... } .................... } .................... .................... if (base == 10 && sign == 1) .................... result = -result; .................... .................... return(result); .................... } .................... .................... /* A fast routine to multiply by 10 .................... */ .................... signed int32 mult_with10(int32 num) .................... { .................... return ( (num << 1) + (num << 3) ); .................... } .................... .................... signed int32 atoi32(char *s) .................... { .................... signed int32 result; .................... int sign, base, index; .................... char c; .................... .................... index = 0; .................... sign = 0; .................... base = 10; .................... result = 0; .................... .................... if (!s) .................... return 0; .................... 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 = (result << 1) + (result << 3); // 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 (base == 10 && sign == 1) .................... result = -result; .................... .................... return(result); .................... } .................... .................... char * itoa(signed int32 num, int8 base, char *s) .................... { .................... int32 temp=1; .................... int8 i,sign=0,cnt=0; .................... char c; .................... .................... if(num<0) { .................... sign=1; // Check for negative number .................... num*=-1; .................... } .................... .................... while(temp>0) { .................... temp=(num/base); .................... s[cnt]=(num%base)+'0'; // Conversion .................... .................... if(s[cnt]>0x39) .................... s[cnt]+=0x7; .................... .................... cnt++; .................... num=temp; .................... } .................... .................... if(sign==1) { .................... s[cnt]=0x2D; // Negative sign .................... cnt++; .................... } .................... .................... for(i = 0;i<(int8)(cnt/2);i++) { .................... .................... c=s[i]; .................... s[i]=s[cnt-i-1]; // Reverse the number .................... s[cnt-i-1]=c; .................... } .................... s[cnt]='\0'; // End the string .................... return s; .................... } .................... .................... float strtod(char *s,char *endptr) { .................... float pow10 = 1.0; .................... float result = 0.0; .................... int sign = 0, point = 0; .................... char c; .................... int ptr = 0; .................... .................... if (!s) .................... return 0; .................... c=s[ptr++]; .................... .................... .................... while((c>='0' && c<='9') || c=='+' || c=='-' || c=='.') { .................... if(c == '-') { .................... sign = 1; .................... c = s[ptr++]; .................... } .................... .................... while((c >= '0' && c <= '9') && point == 0) { .................... result = 10*result + c - '0'; .................... c = s[ptr++]; .................... } .................... .................... if (c == '.') { .................... point = 1; .................... c = s[ptr++]; .................... } .................... .................... while((c >= '0' && c <= '9') && point == 1) { .................... pow10 = pow10*10; .................... result += (c - '0')/pow10; .................... c = s[ptr++]; .................... } .................... .................... if (c == '+') { .................... c = s[ptr++]; .................... } .................... } .................... .................... if (sign == 1) .................... result = -1*result; .................... if(endptr) .................... { .................... if (ptr) { .................... ptr--; .................... *((char *)endptr)=s+ptr; .................... } .................... else .................... *((char *)endptr)=s; .................... } .................... .................... return(result); .................... } .................... .................... long strtoul(char *s,char *endptr,signed int base) .................... { .................... char *sc,*s1,*sd; .................... unsigned long x=0; .................... char sign; .................... char digits[]="0123456789abcdefghijklmnopqstuvwxyz"; .................... for(sc=s;isspace(*sc);++sc); .................... sign=*sc=='-'||*sc=='+'?*sc++:'+'; .................... if(sign=='-') .................... { .................... if (endptr) .................... { .................... *((char *)endptr)=s; .................... } .................... return 0; .................... } .................... .................... if (base <0 || base ==1|| base >36) // invalid base .................... { .................... if (endptr) .................... { .................... *((char *)endptr)=s; .................... } .................... return 0; .................... } .................... else if (base) .................... { .................... if(base==16 && *sc =='0'&&(sc[1]=='x' || sc[1]=='X')) .................... sc+=2; .................... if(base==8 && *sc =='0') .................... sc+=1; .................... if(base==2 && *sc =='0'&&sc[1]=='b') .................... sc+=2; .................... .................... } .................... else if(*sc!='0') // base is 0, find base .................... base=10; .................... else if (sc[1]=='x' || sc[1]=='X') .................... base =16,sc+=2; .................... else if(sc[1]=='b') .................... base=2,sc+=2; .................... else .................... base=8; .................... for (s1=sc;*sc=='0';++sc);// skip leading zeroes .................... sd=memchr(digits,tolower(*sc),base); .................... for(; sd!=0; ) .................... { .................... x=x*base+(int16)(sd-digits); .................... ++sc; .................... sd=memchr(digits,tolower(*sc),base); .................... } .................... if(s1==sc) .................... { .................... if (endptr) .................... { .................... *((char *)endptr)=s; .................... } .................... return 0; .................... } .................... if (endptr) .................... *((char *)endptr)=sc; .................... return x; .................... } .................... .................... .................... signed long strtol(char *s,char *endptr,signed int base) .................... { .................... char *sc,*s1,*sd; .................... signed long x=0; .................... char sign; .................... char digits[]="0123456789abcdefghijklmnopqstuvwxyz"; .................... for(sc=s;isspace(*sc);++sc); .................... sign=*sc=='-'||*sc=='+'?*sc++:'+'; .................... if (base <0 || base ==1|| base >36) // invalid base .................... { .................... if (endptr) .................... { .................... *((char *)endptr)=s; .................... } .................... return 0; .................... } .................... else if (base) .................... { .................... if(base==16 && *sc =='0'&&(sc[1]=='x' || sc[1]=='X')) .................... sc+=2; .................... if(base==8 && *sc =='0') .................... sc+=1; .................... if(base==2 && *sc =='0'&&sc[1]=='b') .................... sc+=2; .................... .................... } .................... else if(*sc!='0') // base is 0, find base .................... base=10; .................... else if (sc[1]=='x' || sc[1]=='X') .................... base =16,sc+=2; .................... else if(sc[1]=='b') .................... base=2,sc+=2; .................... else .................... base=8; .................... for (s1=sc;*sc=='0';++sc);// skip leading zeroes .................... .................... sd=memchr(digits,tolower(*sc),base); .................... for(;sd!=0;) .................... { .................... x=x*base+(int16)(sd-digits); .................... ++sc; .................... sd=memchr(digits,tolower(*sc),base); .................... } .................... if(s1==sc) .................... { .................... if (endptr) .................... { .................... *((char *)endptr)=s; .................... } .................... return 0; .................... } .................... if(sign=='-') .................... x =-x; .................... if (endptr) .................... *((char *)endptr)=sc; .................... return x; .................... } .................... .................... signed int system(char *string) .................... { .................... return 0; .................... } .................... .................... int mblen(char *s,size_t n) .................... { .................... return strlen(s); .................... } .................... .................... int mbtowc(wchar_t *pwc,char *s,size_t n) .................... { .................... *pwc=*s; .................... return 1; .................... } .................... .................... int wctomb(char *s,wchar_t wchar) .................... { .................... *s=wchar; .................... return 1; .................... } .................... .................... size_t mbstowcs(wchar_t *pwcs,char *s,size_t n) .................... { .................... strncpy(pwcs,s,n); .................... return strlen(pwcs); .................... } .................... .................... size_t wcstombs(char *s,wchar_t *pwcs,size_t n) .................... { .................... strncpy(s,pwcs,n); .................... return strlen(s); .................... } .................... .................... //--------------------------------------------------------------------------- .................... // The random number implementation .................... //--------------------------------------------------------------------------- .................... .................... unsigned int32 _Randseed = 1; .................... .................... long rand(void) .................... { .................... _Randseed = _Randseed * 1103515245 + 12345; .................... return ((unsigned long)(_Randseed >> 16) % RAND_MAX); .................... } .................... .................... void srand(unsigned int32 seed) .................... { .................... _Randseed = seed; .................... } .................... .................... //--------------------------------------------------------------------------- .................... // Searching and sorting utilities implementation .................... //--------------------------------------------------------------------------- .................... .................... typedef signed int (*_Cmpfun)(char * p1,char * p2); .................... .................... void qsort(char * qdata, int qitems, int qsize, _Cmpfun cmp) { .................... int m,j,i,l; .................... short done; .................... BYTE t[16]; .................... .................... m = qitems/2; .................... while( m > 0 ) { .................... for(j=0; j<(qitems-m); ++j) { .................... i = j; .................... do .................... { .................... done=TRUE; .................... l = i+m; .................... if( (*cmp)(qdata+i*qsize, qdata+l*qsize) > 0 ) { .................... memcpy(t, qdata+i*qsize, qsize); .................... memcpy(qdata+i*qsize, qdata+l*qsize, qsize); .................... memcpy(qdata+l*qsize, t, qsize); .................... if(m <= i) .................... i -= m; .................... done = FALSE; .................... } .................... } while(!done); .................... } .................... m = m/2; .................... } .................... } .................... .................... .................... char *bsearch(char *key, char *base, size_t num, size_t width,_Cmpfun cmp) .................... { .................... char *p, *q; .................... size_t n; .................... size_t pivot; .................... signed int val; .................... .................... p = base; .................... n = num; .................... .................... while (n > 0) .................... { .................... pivot = n >> 1; .................... q = p + width * pivot; .................... .................... val = (*cmp)(key, q); .................... .................... if (val < 0) .................... n = pivot; .................... else if (val == 0) .................... return ((char *)q); .................... else { .................... p = q + width; .................... n -= pivot + 1; .................... } .................... } .................... .................... return NULL; // There's no match .................... } .................... .................... .................... #endif .................... .................... #include "Gulper_Main.h" .................... /****************************************************************************/ .................... /* Copyright 2006 MBARI. */ .................... /* Monterey Bay Aquarium Research Institute Proprietary Information. */ .................... /* All rights reserved. */ .................... /****************************************************************************/ .................... #ifndef PH_PROBE_H .................... #define PH_PROBE_H .................... .................... #define VS_VERSION "0.7" .................... #define DEBUG 0 .................... .................... .................... int8 fire[]="F"; .................... int8 query[]="Q"; .................... int8 status[]= "S"; .................... int8 version[]="V"; .................... int8 actuation[]="A"; .................... int8 reset[]="R"; .................... .................... char response_message[20]; // String for storing node response back to MVC .................... .................... int8 serial_delay_msec = 3; // delay for clocking 485 bits .................... .................... // Timing variable initialization .................... int32 seconds = 0; // A running seconds counter for timer 1 .................... int32 T2_seconds = 0; // A running seconds counter for timer 2 .................... int8 int_count = 0; // Number of interrupts left before a second has elapsed on timer 1 .................... int8 T2_int_count = 0; // Number of interrupts left before a second has elapsed on timer 2 .................... int32 ElapsedSeconds = 0; // A running seconds counter for timer 1 .................... int32 T2_ElapsedSeconds = 0; // A running seconds counter for timer 2 .................... int8 Elapsed_int_count = 0; // Number of interrupts elapsed for timer 1 .................... int8 T2_Elapsed_int_count = 0; // Number of interrupts elapsed for timer 2 .................... int32 Final_Proximity_Milliseconds = 0; // Used to store time between fire and proximity sensor .................... int32 Final_Actuation_Milliseconds = 0; // Used to store time between fire and pin puller voltage >= 2 volts .................... .................... // Booleans .................... Boolean Fired = false; // Fire command received? .................... Boolean proximity = false; // Proximity sensor ISR called? .................... Boolean prox_error = false; // Proximity sensor triggered before firing? .................... Boolean actuation_bool = false; // Actuation voltage above 2 volts? .................... Boolean proximity_expired = false; // Set true at 30 seconds past firing if no prox interrupt received .................... Boolean bad_address = false; // Address out of range? .................... Boolean bad_checksum = false; // Incoming checksum error? .................... Boolean pin_puller_retracted = false; // did the pin puller retract? .................... .................... .................... /* .................... The ticks per second is based on an 8-bit counter over flowing that .................... is driven by a 4 Mhz ocsillator prescaled by 4 and postscaled by 64. .................... .................... TICKS_PER_SEC = (OSC_CLK) / (PRESCALE) / (POSTSCALE) / (8_BIT_OVERFLOW) .................... = 4000000 / 4 / 64 / 256 .................... = 61.0351 .................... */ .................... #define TICKS_PER_SEC 61 .................... .................... #define HI 1 .................... #define LO 0 .................... .................... #define ON 1 .................... #define OFF 0 .................... .................... void startTimer(void); .................... void getElapsedTime(void); .................... void T2_startTimer(void); .................... void T2_getElapsedTime(void); .................... .................... #endif .................... .................... .................... int8 system_status = 0; // Used to store time between fire and proximity sensor * 0341: CLRF 76 .................... .................... .................... /* Actual Command Processing Below */ .................... .................... ///*** Fire Command ***/// .................... void handle_fire_command() { .................... startTimer(); // Start the clock .................... T2_startTimer(); // Start the actuation clock also .................... .................... output_bit(PIN_B2, HI); // Turn on fired LED .................... .................... output_bit(PIN_C4, LO); // Fire pin puller .................... output_bit(PIN_C5, HI); .................... .................... //delay_us(150000); // Delay for 150 msec .................... .................... //output_bit(PIN_C4, HI); // Clear pin puller .................... //output_bit(PIN_C5, LO); .................... .................... Fired = true; .................... } .................... .................... .................... ///*** Query Command ***/// .................... void handle_query_command() { .................... if(Fired && proximity) { .................... Final_Proximity_Milliseconds = ( (ElapsedSeconds * 1000) + (Elapsed_int_count * 66.6666) ); .................... } .................... // Print the time .................... sprintf(response_message, "%Ld\r\n", Final_Proximity_Milliseconds); .................... send_response(response_message); .................... } .................... .................... .................... ///*** Status Command ***/// .................... void handle_status_command() { .................... system_status = ( (Fired<<3)|(pin_puller_retracted<<2)|(proximity<<1)|(prox_error) ); .................... sprintf(response_message, "%x\r\n", system_status); .................... send_response(response_message); .................... } .................... .................... .................... ///*** Version Command ***/// .................... void handle_version_command() { .................... sprintf(response_message,"%s\r\n",VS_VERSION); .................... send_response(response_message); .................... } .................... .................... .................... ///*** Actuation Voltage Command ***/// .................... void handle_actuation_voltage_command() { .................... // Print the time .................... sprintf(response_message, "%Ld\r\n", Final_Actuation_Milliseconds); .................... send_response(response_message); .................... } .................... .................... .................... .................... #if DEBUG .................... #device ICD=TRUE .................... #fuses XT,WDT,NOPROTECT,PUT,NOBROWNOUT,NOLVP .................... #else .................... #fuses XT,WDT,NOPROTECT,PUT,NOLVP .................... #endif .................... .................... //#define RS485_RX_BUFFER_SIZE 64 .................... #define RS485_USE_EXT_INT FALSE .................... .................... .................... int8 in_char = 0; 0342: CLRF 7C .................... int8 next_in = 0; 0343: CLRF 7D .................... int8 next_out = 0; 0344: CLRF 7E .................... int8 *command; .................... int8 data[1]; .................... Boolean uart_TX = false; // Used for BIT uart checking 0345: BSF 03.5 0346: BCF 40.0 .................... .................... #define INTS_PER_SECOND 15 // (20000000/(4*256*256)) .................... .................... .................... #INT_TIMER1 // This function is called every time .................... void clock_isr() { // timer 1 overflows (65535->0), which is .................... // approximately 15 times per second for .................... if(--int_count==0) { // this program. * 0132: DECFSZ 57,F 0133: GOTO 13E .................... ++seconds; 0134: MOVLW 01 0135: ADDWF 4F,F 0136: BTFSC 03.0 0137: INCF 50,F 0138: BTFSC 03.2 0139: INCF 51,F 013A: BTFSC 03.2 013B: INCF 52,F .................... int_count = INTS_PER_SECOND; 013C: MOVLW 0F 013D: MOVWF 57 .................... } .................... } .................... .................... .................... // Purpose: Holds software in infinite loop to allow watchdog to reset 013E: BCF 0C.0 013F: BCF 0A.3 0140: BCF 0A.4 0141: GOTO 025 .................... void software_reset() { .................... for(;;) { .................... null; .................... } .................... } .................... .................... .................... .................... // .................... // Main execution loop .................... // .................... main() * 02E4: CLRF 04 02E5: MOVLW 1F 02E6: ANDWF 03,F 02E7: BSF 03.5 02E8: BCF 06.4 02E9: BCF 03.5 02EA: BCF 06.4 02EB: MOVLW 19 02EC: BSF 03.5 02ED: MOVWF 19 02EE: MOVLW 26 02EF: MOVWF 18 02F0: MOVLW 90 02F1: BCF 03.5 02F2: MOVWF 18 02F3: BSF 03.5 02F4: BSF 1F.0 02F5: BSF 1F.1 02F6: BSF 1F.2 02F7: BCF 1F.3 02F8: MOVLW 07 02F9: MOVWF 1C .................... { .................... .................... long int value; .................... char toggle; .................... /* .................... int resolution; .................... float scale=0.004; .................... float scaled_value; .................... float bus_volt_scale=6.00; .................... int GF_offset=512; .................... */ .................... // Set up the system clocks .................... int_count=INTS_PER_SECOND; * 0347: MOVLW 0F 0348: BCF 03.5 0349: MOVWF 57 .................... setup_wdt(WDT_288MS); // Initialize the watchdog. See fuses WDT also 034A: MOVLW 0C 034B: MOVWF 77 034C: MOVLW 07 034D: CLRF 01 034E: MOVLW 81 034F: MOVWF 04 0350: MOVF 00,W 0351: ANDLW F0 0352: IORLW 07 0353: MOVWF 00 0354: CLRWDT 0355: MOVF 00,W 0356: ANDLW F7 0357: BTFSC 77.3 0358: ANDLW F0 0359: IORWF 77,W 035A: MOVWF 00 .................... .................... // Initialize Serial and enable interrupts .................... // rs485_init(); .................... .................... // Initialize Outputs .................... .................... .................... // Set up analog input for AN0 .................... setup_adc(ADC_CLOCK_INTERNAL); 035B: BSF 03.5 035C: BCF 1F.6 035D: BCF 03.5 035E: BSF 1F.6 035F: BSF 1F.7 0360: BSF 03.5 0361: BSF 1F.7 0362: BCF 03.5 0363: BSF 1F.0 .................... setup_adc_ports(AN0_AN1_AN4_VREF_VREF); 0364: BSF 03.5 0365: BCF 1F.0 0366: BCF 1F.1 0367: BCF 1F.2 0368: BSF 1F.3 .................... //set_adc_channel(0); .................... .................... // Check for WDT reset and output error if necessary .................... switch ( restart_cause() ) .................... { 0369: MOVF 03,W 036A: ANDLW 18 036B: MOVWF 77 036C: MOVF 0E,W 036D: ANDLW 03 036E: IORWF 77,W 036F: BSF 0E.0 0370: BSF 0E.1 0371: BSF 03.3 0372: BSF 03.4 0373: XORLW 0B 0374: BCF 03.5 0375: BTFSC 03.2 0376: GOTO 37B 0377: XORLW 13 0378: BTFSC 03.2 0379: GOTO 391 037A: GOTO 392 .................... case WDT_TIMEOUT: .................... { .................... sprintf(response_message, "WDT\r\n"); 037B: MOVLW 3A 037C: MOVWF 75 037D: BSF 03.5 037E: CLRF 44 037F: MOVF 44,W 0380: BCF 03.5 0381: CALL 03E 0382: BSF 03.5 0383: INCF 44,F 0384: MOVWF 77 0385: MOVWF 5C 0386: BCF 03.5 0387: CALL 142 0388: MOVLW 05 0389: BSF 03.5 038A: SUBWF 44,W 038B: BTFSS 03.2 038C: GOTO 37F .................... send_error_response(response_message); 038D: MOVLW 3A 038E: MOVWF 44 038F: BCF 03.5 0390: GOTO 1AC .................... break; .................... } .................... case NORMAL_POWER_UP: .................... { .................... break; 0391: GOTO 392 .................... } .................... } .................... .................... .................... toggle=0; 0392: BSF 03.5 0393: CLRF 43 .................... /* Begin Loop */ .................... set_adc_channel(4); 0394: MOVLW 20 0395: MOVWF 78 0396: BCF 03.5 0397: MOVF 1F,W 0398: ANDLW C7 0399: IORWF 78,W 039A: MOVWF 1F .................... for(;;) .................... { .................... // strobe the dog .................... restart_wdt(); 039B: CLRWDT .................... .................... if ( kbhit()) 039C: BTFSS 0C.5 039D: GOTO 3AB .................... { .................... getch(); 039E: CALL 058 .................... toggle = !toggle; 039F: BSF 03.5 03A0: MOVF 43,F 03A1: BTFSC 03.2 03A2: GOTO 3A5 03A3: MOVLW 00 03A4: GOTO 3A6 03A5: MOVLW 01 03A6: MOVWF 43 .................... putc('!'); 03A7: MOVLW 21 03A8: MOVWF 62 03A9: BCF 03.5 03AA: CALL 17D .................... } .................... .................... .................... if ( toggle ) 03AB: BSF 03.5 03AC: MOVF 43,F 03AD: BTFSC 03.2 03AE: GOTO 3BF .................... { .................... output_bit(PIN_C1, HI); 03AF: BCF 03.5 03B0: BSF 07.1 03B1: BCF 74.1 03B2: MOVF 74,W 03B3: BSF 03.5 03B4: MOVWF 07 .................... delay_ms(1000); 03B5: MOVLW 04 03B6: MOVWF 44 03B7: MOVLW FA 03B8: MOVWF 61 03B9: BCF 03.5 03BA: CALL 195 03BB: BSF 03.5 03BC: DECFSZ 44,F 03BD: GOTO 3B7 .................... } .................... else 03BE: GOTO 3CE .................... { .................... output_bit(PIN_C1, LO); 03BF: BCF 03.5 03C0: BCF 07.1 03C1: BCF 74.1 03C2: MOVF 74,W 03C3: BSF 03.5 03C4: MOVWF 07 .................... delay_ms(1000); 03C5: MOVLW 04 03C6: MOVWF 44 03C7: MOVLW FA 03C8: MOVWF 61 03C9: BCF 03.5 03CA: CALL 195 03CB: BSF 03.5 03CC: DECFSZ 44,F 03CD: GOTO 3C7 .................... } .................... .................... delay_ms(1000); 03CE: MOVLW 04 03CF: MOVWF 44 03D0: MOVLW FA 03D1: MOVWF 61 03D2: BCF 03.5 03D3: CALL 195 03D4: BSF 03.5 03D5: DECFSZ 44,F 03D6: GOTO 3D0 .................... value = READ_ADC(); 03D7: BCF 03.5 03D8: BSF 1F.2 03D9: BTFSC 1F.2 03DA: GOTO 3D9 03DB: MOVF 1E,W 03DC: MOVWF 7A 03DD: BSF 03.5 03DE: MOVF 1E,W 03DF: MOVWF 41 03E0: MOVF 7A,W 03E1: MOVWF 42 .................... printf("\n\r Ch0:%Ld ",value); 03E2: CLRF 44 03E3: MOVF 44,W 03E4: BCF 03.5 03E5: CALL 048 03E6: BSF 03.5 03E7: INCF 44,F 03E8: MOVWF 77 03E9: MOVWF 62 03EA: BCF 03.5 03EB: CALL 17D 03EC: MOVLW 07 03ED: BSF 03.5 03EE: SUBWF 44,W 03EF: BTFSS 03.2 03F0: GOTO 3E3 03F1: MOVLW 10 03F2: MOVWF 04 03F3: MOVF 42,W 03F4: MOVWF 46 03F5: MOVF 41,W 03F6: MOVWF 45 03F7: BCF 03.5 03F8: GOTO 269 03F9: MOVLW 20 03FA: BSF 03.5 03FB: MOVWF 62 03FC: BCF 03.5 03FD: CALL 17D .................... // Main control loop .................... .................... } 03FE: GOTO 39B .................... .................... .................... .................... } 03FF: SLEEP Configuration Fuses: Word 1: 3F75 XT WDT PUT NODEBUG NOPROTECT BROWNOUT NOLVP NOCPD NOWRT