CCS PCM C Compiler, Version 3.245, 27853 12-V-08 00:43
Filename: D:\MLAB_E\projekty\Ovladani_mobilnim_telefonem\SW\final\main.lst
ROM used: 2699 words (33%)
Largest free fragment is 2048
RAM used: 52 (30%) at main() level
139 (79%) worst case
Stack: 2 locations
*
0000: MOVLW 08
0001: MOVWF 0A
0002: GOTO 000
0003: NOP
.................... #include ".\main.h"
.................... #include <16F876A.h>
.................... //////// Standard Header file for the PIC16F876A device ////////////////
.................... #device PIC16F876A
.................... #list
....................
.................... #device adc=8
....................
.................... #FUSES WDT //Watch Dog Timer
.................... #FUSES HS//XT //Crystal osc <= 4mhz
.................... #FUSES NOPUT //No Power Up Timer
.................... #FUSES NOPROTECT //Code not protected from reading
.................... #FUSES NODEBUG //No Debug mode for ICD
.................... #FUSES NOBROWNOUT //No brownout reset
.................... #FUSES NOLVP //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
.................... #FUSES NOCPD //No EE protection
.................... #FUSES NOWRT //Program memory not write protected
....................
.................... #use delay(clock=18432000,RESTART_WDT)
*
01C8: MOVLW 52
01C9: MOVWF 04
01CA: MOVF 00,W
01CB: BTFSC 03.2
01CC: GOTO 1DD
01CD: MOVLW 05
01CE: MOVWF 78
01CF: MOVLW BF
01D0: MOVWF 77
01D1: CLRWDT
01D2: DECFSZ 77,F
01D3: GOTO 1D1
01D4: DECFSZ 78,F
01D5: GOTO 1CF
01D6: MOVLW F9
01D7: MOVWF 77
01D8: DECFSZ 77,F
01D9: GOTO 1D8
01DA: CLRWDT
01DB: DECFSZ 00,F
01DC: GOTO 1CD
01DD: RETLW 00
.................... #use rs232(STREAM=MOBIL,baud=19200,force_sw,parity=N,xmit=PIN_C6,rcv=PIN_B5,bits=8)
01DE: BCF 20.6
01DF: MOVF 20,W
01E0: BSF 03.5
01E1: MOVWF 07
01E2: BCF 03.5
01E3: BCF 07.6
01E4: MOVLW 08
01E5: MOVWF 78
01E6: NOP
01E7: NOP
01E8: NOP
01E9: BSF 78.7
01EA: GOTO 1FA
01EB: BCF 78.7
01EC: RRF 53,F
01ED: BTFSC 03.0
01EE: BSF 07.6
01EF: BTFSS 03.0
01F0: BCF 07.6
01F1: BSF 78.6
01F2: GOTO 1FA
01F3: BCF 78.6
01F4: DECFSZ 78,F
01F5: GOTO 1EC
01F6: NOP
01F7: NOP
01F8: NOP
01F9: BSF 07.6
01FA: MOVLW 49
01FB: MOVWF 04
01FC: DECFSZ 04,F
01FD: GOTO 1FC
01FE: NOP
01FF: NOP
0200: NOP
0201: BTFSC 78.7
0202: GOTO 1EB
0203: BTFSC 78.6
0204: GOTO 1F3
0205: RETLW 00
0206: MOVLW 08
0207: MOVWF 77
0208: BSF 03.5
0209: BSF 06.5
020A: BCF 03.5
020B: BTFSS 06.5
020C: GOTO 20F
020D: BSF 03.5
020E: GOTO 20A
020F: CLRF 57
0210: BSF 77.7
0211: GOTO 220
0212: BCF 77.7
0213: GOTO 220
0214: BCF 03.0
0215: BTFSC 06.5
0216: BSF 03.0
0217: RRF 57,F
0218: BSF 77.6
0219: GOTO 220
021A: BCF 77.6
021B: DECFSZ 77,F
021C: GOTO 214
021D: MOVF 57,W
021E: MOVWF 78
021F: GOTO 22D
0220: MOVLW 49
0221: BTFSC 77.7
0222: MOVLW 14
0223: MOVWF 78
0224: DECFSZ 78,F
0225: GOTO 224
0226: NOP
0227: NOP
0228: BTFSC 77.7
0229: GOTO 212
022A: BTFSC 77.6
022B: GOTO 21A
022C: GOTO 214
022D: RETLW 00
*
0814: MOVLW FF
0815: BCF 03.5
0816: MOVWF 20
.................... #use rs232(STREAM=VRTULE,baud=600,parity=N,xmit=PIN_B2,rcv=PIN_B4,bits=8)
*
0348: BSF 03.5
0349: BCF 06.2
034A: BCF 03.5
034B: BCF 06.2
034C: MOVLW 08
034D: MOVWF 78
034E: NOP
034F: NOP
0350: NOP
0351: BSF 78.7
0352: GOTO 362
0353: BCF 78.7
0354: RRF 52,F
0355: BTFSC 03.0
0356: BSF 06.2
0357: BTFSS 03.0
0358: BCF 06.2
0359: BSF 78.6
035A: GOTO 362
035B: BCF 78.6
035C: DECFSZ 78,F
035D: GOTO 354
035E: NOP
035F: NOP
0360: NOP
0361: BSF 06.2
0362: MOVLW 09
0363: MOVWF 77
0364: CLRF 04
0365: DECFSZ 04,F
0366: GOTO 365
0367: DECFSZ 77,F
0368: GOTO 364
0369: MOVLW F0
036A: MOVWF 04
036B: DECFSZ 04,F
036C: GOTO 36B
036D: NOP
036E: NOP
036F: BTFSC 78.7
0370: GOTO 353
0371: BTFSC 78.6
0372: GOTO 35B
0373: RETLW 00
....................
....................
....................
.................... #include <stdio.h>
.................... ///////////////////////////////////////////////////////////////////////////
.................... //// (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 <string.h>
.................... ////////////////////////////////////////////////////////////////////////////
.................... //// (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 <stddef.h>
.................... ///////////////////////////////////////////////////////////////////////////
.................... //// (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 <ctype.h>
.................... ////////////////////////////////////////////////////////////////////////////
.................... //// (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<sc1 && sc1 <sc2 +n)
.................... for(sc1+=n,sc2+=n;0<n;--n)
.................... *--sc1=*--sc2;
.................... else
.................... for(;0<n;--n)
.................... *sc1++=*sc2++;
.................... return s1;
.................... }
....................
.................... /* compiler ignored the name 'strcpy()'; perhaps, it's reserved?
.................... Standard template: char *strcpy(char *s1, const char *s2)
.................... copies the string s2 including the null character to s1*/
....................
.................... char *strcopy(char *s1, char *s2)
.................... {
.................... char *s;
....................
.................... for (s = s1; *s2 != 0; s++, s2++) {
.................... *s = *s2;
.................... }
.................... *s = *s2;
.................... return(s1);
.................... }
....................
.................... /* standard template:
.................... char *strncpy(char *s1, const char *s2, size_t n).
.................... Copies max of n characters (not following ending '\0')
.................... from s2 in s1; if s2 has less than n characters, appends 0 */
....................
.................... char *strncpy(char *s1, char *s2, size_t n)
.................... {
.................... char *s;
....................
.................... for (s = s1; n > 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' && 0<n)
.................... {
.................... *s = *s2;
.................... ++s;
.................... ++s2;
.................... --n;
.................... }
....................
.................... *s = '\0';
.................... return(s1);
.................... }
....................
.................... /***********************************************************/
....................
....................
.................... /*comparison functions*/
.................... /* standard template: signed int memcmp(void *s1, void *s2).
.................... Compares s1 & s2; returns -1 if s1<s2, 0 if s1=s2, 1 if s1>s2 */
....................
.................... signed int memcmp(void * s1,char *s2,size_t n)
.................... {
.................... char *su1, *su2;
.................... for(su1=s1, su2=s2; 0<n; ++su1, ++su2, --n)
.................... {
.................... if(*su1!=*su2)
.................... return ((*su1<*su2)?-1:+1);
.................... }
.................... return 0;
.................... }
....................
.................... /* standard template: int strcmp(const char *s1, const char *s2).
.................... Compares s1 & s2; returns -1 if s1<s2, 0 if s1=s2, 1 if s1>s2 */
....................
.................... 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 s1<s2, 0 if s1=s2, 1 if s1>s2 */
....................
.................... 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;
*
03A0: BSF 03.5
03A1: MOVF 47,W
03A2: MOVWF 49
.................... for(su=s;0<n;++su,--n)
03A3: MOVF 46,W
03A4: MOVWF 4A
03A5: MOVF 48,W
03A6: SUBLW 00
03A7: BTFSC 03.0
03A8: GOTO 3B5
.................... if(*su==uc)
03A9: MOVF 4A,W
03AA: MOVWF 04
03AB: MOVF 49,W
03AC: SUBWF 00,W
03AD: BTFSS 03.2
03AE: GOTO 3B2
.................... return su;
03AF: MOVF 4A,W
03B0: MOVWF 78
03B1: GOTO 3B7
03B2: INCF 4A,F
03B3: DECF 48,F
03B4: GOTO 3A5
.................... return NULL;
03B5: MOVLW 00
03B6: MOVWF 78
.................... }
03B7: BCF 03.5
03B8: RETLW 00
....................
.................... /* standard template: char *strchr(const char *s, int c).
.................... Finds first occurrence of c in s */
....................
.................... char *strchr(char *s, int c)
.................... {
.................... for (; *s != c; s++)
.................... if (*s == '\0')
.................... return(0);
.................... return(s);
.................... }
.................... /* standard template:
.................... size_t strcspn(const char *s1, const char *s2).
.................... Computes length of max initial segment of s1 that
.................... consists entirely of characters NOT from s2*/
....................
.................... int *strcspn(char *s1, char *s2)
.................... {
.................... char *sc1, *sc2;
....................
.................... for (sc1 = s1; *sc1 != 0; sc1++)
.................... for (sc2 = s2; *sc2 != 0; sc2++)
.................... if (*sc1 == *sc2)
.................... return(sc1 - s1);
.................... return(sc1 - s1);
.................... }
.................... /* standard template:
.................... char *strpbrk(const char *s1, const char *s2).
.................... Locates first occurence of any character from s2 in s1;
.................... returns s1 if s2 is empty string */
....................
.................... char *strpbrk(char *s1, char *s2)
.................... {
.................... char *sc1, *sc2;
....................
.................... for (sc1 = s1; *sc1 != 0; sc1++)
.................... for (sc2 = s2; *sc2 != 0; sc2++)
.................... if (*sc1 == *sc2)
.................... return(sc1);
.................... return(0);
.................... }
....................
....................
.................... /* standard template: char *strrchr(const char *s, int c).
.................... Finds last occurrence of c in s */
....................
.................... char *strrchr(char *s, int c)
.................... {
.................... char *p;
....................
.................... for (p = 0; ; s++)
.................... {
.................... if (*s == c)
.................... p = s;
.................... if (*s == '\0')
.................... return(p);
.................... }
.................... }
.................... /* computes length of max initial segment of s1 consisting
.................... entirely of characters from s2 */
....................
.................... int *strspn(char *s1, char *s2)
.................... {
.................... char *sc1, *sc2;
....................
.................... for (sc1 = s1; *sc1 != 0; sc1++)
.................... for (sc2 = s2; ; sc2++)
.................... if (*sc2 == '\0')
.................... return(sc1 - s1);
.................... else if (*sc1 == *sc2)
.................... break;
.................... return(sc1 - s1);
.................... }
.................... /* standard template:
.................... char *strstr(const char *s1, const char *s2);
.................... Locates first occurence of character sequence s2 in s1;
.................... returns 0 if s2 is empty string
....................
.................... Uncomment #define FASTER_BUT_MORE_ROM at the top of the
.................... file to use the faster algorithm */
.................... char *strstr(char *s1, char *s2)
.................... {
.................... char *s, *t;
....................
.................... #ifdef FASTER_BUT_MORE_ROM
.................... if (*s2 == '\0')
.................... return(s1);
.................... #endif
....................
.................... while (*s1)
.................... {
.................... for(s = s1, t = s2; *t && *s == *t; ++s, ++t);
....................
.................... if (*t == '\0')
.................... return s1;
.................... ++s1;
.................... #ifdef FASTER_BUT_MORE_ROM
.................... while(*s1 != '\0' && *s1 != *s2)
.................... ++s1;
.................... #endif
.................... }
.................... return 0;
.................... }
....................
.................... /* standard template: char *strtok(char *s1, const char *s2).
....................
.................... Finds next token in s1 delimited by a character from separator
.................... string s2 (which can be different from call to call). First call
.................... starts at beginning of s1 searching for first character NOT
.................... contained in s2; returns 0 if none is found.
.................... If one is found, it is the start of first token (return value).
.................... Function then searches from there for a character contained in s2.
.................... If none is found, current token extends to end of s1, and subsequent
.................... searches for a token will return 0. If one is found, it is
.................... overwritten by '\0', which terminates current token. Function saves
.................... pointer to following character from which next search will start.
.................... Each subsequent call, with 0 as first argument, starts searching
.................... from saved pointer */
....................
.................... char *strtok(char *s1, char *s2)
.................... {
.................... char *beg, *end;
.................... static char *save;
*
0817: CLRF 21
....................
.................... beg = (s1)? s1: save;
.................... beg += strspn(beg, s2);
.................... if (*beg == '\0')
.................... {
.................... *save = ' ';
.................... return(0);
.................... }
.................... end = strpbrk(beg, s2);
.................... if (*end != '\0')
.................... {
.................... *end = '\0';
.................... end++;
.................... }
.................... save = end;
.................... return(beg);
.................... }
....................
.................... /*****************************************************************/
.................... /*Miscellaneous functions*/
.................... /* standard template
.................... maps error number in errnum to an error message string
.................... Returns: Pointer to string
.................... */
.................... #ifdef _ERRNO
.................... char * strerror(int errnum)
.................... {
.................... char s[15];
.................... switch( errnum)
.................... {
.................... case 0:
.................... strcpy(s,"no errors");
.................... return s;
.................... case EDOM :
.................... strcpy(s,"domain error");
.................... return s;
.................... case ERANGE:
.................... strcpy(s,"range error");
.................... return s;
.................... }
.................... }
.................... #ENDIF
.................... /* standard template: size_t strlen(const char *s).
.................... Computes length of s1 (preceding terminating 0) */
....................
.................... int *strlen(char *s)
.................... {
.................... char *sc;
....................
.................... for (sc = s; *sc != 0; sc++);
.................... return(sc - s);
.................... }
....................
.................... /* standard template: size_t stricmp(const char *s1, const char *s2).
.................... Compares s1 to s2 ignoring case (upper vs. lower) */
....................
.................... signed int stricmp(char *s1, char *s2)
.................... {
.................... for(; *s1==*s2||(isalpha(*s1)&&isalpha(*s2)&&(*s1==*s2+32||*s2==*s1+32));
.................... s1++, s2++)
.................... if (*s1 == '\0')
.................... return(0);
.................... return((*s1 < *s2) ? -1: 1);
.................... }
....................
....................
.................... /* standard template: char *strlwr(char *s).
.................... Replaces uppercase letters by lowercase;
.................... returns pointer to new string s */
....................
.................... char *strlwr(char *s)
.................... {
.................... char *p;
....................
.................... for (p = s; *p != '\0'; p++)
.................... if (*p >= 'A' && *p <='Z')
.................... *p += 'a' - 'A';
.................... return(s);
.................... }
....................
....................
.................... /************************************************************/
....................
....................
.................... #endif
....................
.................... #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
....................
.................... #include <string.h>
.................... ////////////////////////////////////////////////////////////////////////////
.................... //// (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 <stddef.h>
.................... #include <ctype.h>
....................
....................
....................
.................... //////////////////////////////////////////////
.................... //// 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<sc1 && sc1 <sc2 +n)
.................... for(sc1+=n,sc2+=n;0<n;--n)
.................... *--sc1=*--sc2;
.................... else
.................... for(;0<n;--n)
.................... *sc1++=*sc2++;
.................... return s1;
.................... }
....................
.................... /* compiler ignored the name 'strcpy()'; perhaps, it's reserved?
.................... Standard template: char *strcpy(char *s1, const char *s2)
.................... copies the string s2 including the null character to s1*/
....................
.................... char *strcopy(char *s1, char *s2)
.................... {
.................... char *s;
....................
.................... for (s = s1; *s2 != 0; s++, s2++) {
.................... *s = *s2;
.................... }
.................... *s = *s2;
.................... return(s1);
.................... }
....................
.................... /* standard template:
.................... char *strncpy(char *s1, const char *s2, size_t n).
.................... Copies max of n characters (not following ending '\0')
.................... from s2 in s1; if s2 has less than n characters, appends 0 */
....................
.................... char *strncpy(char *s1, char *s2, size_t n)
.................... {
.................... char *s;
....................
.................... for (s = s1; n > 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' && 0<n)
.................... {
.................... *s = *s2;
.................... ++s;
.................... ++s2;
.................... --n;
.................... }
....................
.................... *s = '\0';
.................... return(s1);
.................... }
....................
.................... /***********************************************************/
....................
....................
.................... /*comparison functions*/
.................... /* standard template: signed int memcmp(void *s1, void *s2).
.................... Compares s1 & s2; returns -1 if s1<s2, 0 if s1=s2, 1 if s1>s2 */
....................
.................... signed int memcmp(void * s1,char *s2,size_t n)
.................... {
.................... char *su1, *su2;
.................... for(su1=s1, su2=s2; 0<n; ++su1, ++su2, --n)
.................... {
.................... if(*su1!=*su2)
.................... return ((*su1<*su2)?-1:+1);
.................... }
.................... return 0;
.................... }
....................
.................... /* standard template: int strcmp(const char *s1, const char *s2).
.................... Compares s1 & s2; returns -1 if s1<s2, 0 if s1=s2, 1 if s1>s2 */
....................
.................... 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 s1<s2, 0 if s1=s2, 1 if s1>s2 */
....................
.................... 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<n;++su,--n)
.................... if(*su==uc)
.................... return su;
.................... return NULL;
.................... }
....................
.................... /* standard template: char *strchr(const char *s, int c).
.................... Finds first occurrence of c in s */
....................
.................... char *strchr(char *s, int c)
.................... {
.................... for (; *s != c; s++)
.................... if (*s == '\0')
.................... return(0);
.................... return(s);
.................... }
.................... /* standard template:
.................... size_t strcspn(const char *s1, const char *s2).
.................... Computes length of max initial segment of s1 that
.................... consists entirely of characters NOT from s2*/
....................
.................... int *strcspn(char *s1, char *s2)
.................... {
.................... char *sc1, *sc2;
....................
.................... for (sc1 = s1; *sc1 != 0; sc1++)
.................... for (sc2 = s2; *sc2 != 0; sc2++)
.................... if (*sc1 == *sc2)
.................... return(sc1 - s1);
.................... return(sc1 - s1);
.................... }
.................... /* standard template:
.................... char *strpbrk(const char *s1, const char *s2).
.................... Locates first occurence of any character from s2 in s1;
.................... returns s1 if s2 is empty string */
....................
.................... char *strpbrk(char *s1, char *s2)
.................... {
.................... char *sc1, *sc2;
....................
.................... for (sc1 = s1; *sc1 != 0; sc1++)
.................... for (sc2 = s2; *sc2 != 0; sc2++)
.................... if (*sc1 == *sc2)
.................... return(sc1);
.................... return(0);
.................... }
....................
....................
.................... /* standard template: char *strrchr(const char *s, int c).
.................... Finds last occurrence of c in s */
....................
.................... char *strrchr(char *s, int c)
.................... {
.................... char *p;
....................
.................... for (p = 0; ; s++)
.................... {
.................... if (*s == c)
.................... p = s;
.................... if (*s == '\0')
.................... return(p);
.................... }
.................... }
.................... /* computes length of max initial segment of s1 consisting
.................... entirely of characters from s2 */
....................
.................... int *strspn(char *s1, char *s2)
.................... {
.................... char *sc1, *sc2;
....................
.................... for (sc1 = s1; *sc1 != 0; sc1++)
.................... for (sc2 = s2; ; sc2++)
.................... if (*sc2 == '\0')
.................... return(sc1 - s1);
.................... else if (*sc1 == *sc2)
.................... break;
.................... return(sc1 - s1);
.................... }
.................... /* standard template:
.................... char *strstr(const char *s1, const char *s2);
.................... Locates first occurence of character sequence s2 in s1;
.................... returns 0 if s2 is empty string
....................
.................... Uncomment #define FASTER_BUT_MORE_ROM at the top of the
.................... file to use the faster algorithm */
.................... char *strstr(char *s1, char *s2)
.................... {
.................... char *s, *t;
....................
.................... #ifdef FASTER_BUT_MORE_ROM
.................... if (*s2 == '\0')
.................... return(s1);
.................... #endif
....................
.................... while (*s1)
.................... {
.................... for(s = s1, t = s2; *t && *s == *t; ++s, ++t);
....................
.................... if (*t == '\0')
.................... return s1;
.................... ++s1;
.................... #ifdef FASTER_BUT_MORE_ROM
.................... while(*s1 != '\0' && *s1 != *s2)
.................... ++s1;
.................... #endif
.................... }
.................... return 0;
.................... }
....................
.................... /* standard template: char *strtok(char *s1, const char *s2).
....................
.................... Finds next token in s1 delimited by a character from separator
.................... string s2 (which can be different from call to call). First call
.................... starts at beginning of s1 searching for first character NOT
.................... contained in s2; returns 0 if none is found.
.................... If one is found, it is the start of first token (return value).
.................... Function then searches from there for a character contained in s2.
.................... If none is found, current token extends to end of s1, and subsequent
.................... searches for a token will return 0. If one is found, it is
.................... overwritten by '\0', which terminates current token. Function saves
.................... pointer to following character from which next search will start.
.................... Each subsequent call, with 0 as first argument, starts searching
.................... from saved pointer */
....................
.................... char *strtok(char *s1, char *s2)
.................... {
.................... char *beg, *end;
.................... static char *save;
....................
.................... beg = (s1)? s1: save;
.................... beg += strspn(beg, s2);
.................... if (*beg == '\0')
.................... {
.................... *save = ' ';
.................... return(0);
.................... }
.................... end = strpbrk(beg, s2);
.................... if (*end != '\0')
.................... {
.................... *end = '\0';
.................... end++;
.................... }
.................... save = end;
.................... return(beg);
.................... }
....................
.................... /*****************************************************************/
.................... /*Miscellaneous functions*/
.................... /* standard template
.................... maps error number in errnum to an error message string
.................... Returns: Pointer to string
.................... */
.................... #ifdef _ERRNO
.................... char * strerror(int errnum)
.................... {
.................... char s[15];
.................... switch( errnum)
.................... {
.................... case 0:
.................... strcpy(s,"no errors");
.................... return s;
.................... case EDOM :
.................... strcpy(s,"domain error");
.................... return s;
.................... case ERANGE:
.................... strcpy(s,"range error");
.................... return s;
.................... }
.................... }
.................... #ENDIF
.................... /* standard template: size_t strlen(const char *s).
.................... Computes length of s1 (preceding terminating 0) */
....................
.................... int *strlen(char *s)
.................... {
.................... char *sc;
....................
.................... for (sc = s; *sc != 0; sc++);
.................... return(sc - s);
.................... }
....................
.................... /* standard template: size_t stricmp(const char *s1, const char *s2).
.................... Compares s1 to s2 ignoring case (upper vs. lower) */
....................
.................... signed int stricmp(char *s1, char *s2)
.................... {
.................... for(; *s1==*s2||(isalpha(*s1)&&isalpha(*s2)&&(*s1==*s2+32||*s2==*s1+32));
.................... s1++, s2++)
.................... if (*s1 == '\0')
.................... return(0);
.................... return((*s1 < *s2) ? -1: 1);
.................... }
....................
....................
.................... /* standard template: char *strlwr(char *s).
.................... Replaces uppercase letters by lowercase;
.................... returns pointer to new string s */
....................
.................... char *strlwr(char *s)
.................... {
.................... char *p;
....................
.................... for (p = s; *p != '\0'; p++)
.................... if (*p >= 'A' && *p <='Z')
.................... *p += 'a' - 'A';
.................... return(s);
.................... }
....................
....................
.................... /************************************************************/
....................
....................
.................... #endif
....................
.................... #include <stdlib.h>
.................... ///////////////////////////////////////////////////////////////////////////
.................... //// (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 <stddef.h>
.................... ///////////////////////////////////////////////////////////////////////////
.................... //// (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 <stddef.h>
.................... ///////////////////////////////////////////////////////////////////////////
.................... //// (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 <string.h>
.................... ////////////////////////////////////////////////////////////////////////////
.................... //// (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 <stddef.h>
.................... #include <ctype.h>
....................
....................
....................
.................... //////////////////////////////////////////////
.................... //// 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<sc1 && sc1 <sc2 +n)
.................... for(sc1+=n,sc2+=n;0<n;--n)
.................... *--sc1=*--sc2;
.................... else
.................... for(;0<n;--n)
.................... *sc1++=*sc2++;
.................... return s1;
.................... }
....................
.................... /* compiler ignored the name 'strcpy()'; perhaps, it's reserved?
.................... Standard template: char *strcpy(char *s1, const char *s2)
.................... copies the string s2 including the null character to s1*/
....................
.................... char *strcopy(char *s1, char *s2)
.................... {
.................... char *s;
....................
.................... for (s = s1; *s2 != 0; s++, s2++) {
.................... *s = *s2;
.................... }
.................... *s = *s2;
.................... return(s1);
.................... }
....................
.................... /* standard template:
.................... char *strncpy(char *s1, const char *s2, size_t n).
.................... Copies max of n characters (not following ending '\0')
.................... from s2 in s1; if s2 has less than n characters, appends 0 */
....................
.................... char *strncpy(char *s1, char *s2, size_t n)
.................... {
.................... char *s;
....................
.................... for (s = s1; n > 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' && 0<n)
.................... {
.................... *s = *s2;
.................... ++s;
.................... ++s2;
.................... --n;
.................... }
....................
.................... *s = '\0';
.................... return(s1);
.................... }
....................
.................... /***********************************************************/
....................
....................
.................... /*comparison functions*/
.................... /* standard template: signed int memcmp(void *s1, void *s2).
.................... Compares s1 & s2; returns -1 if s1<s2, 0 if s1=s2, 1 if s1>s2 */
....................
.................... signed int memcmp(void * s1,char *s2,size_t n)
.................... {
.................... char *su1, *su2;
.................... for(su1=s1, su2=s2; 0<n; ++su1, ++su2, --n)
.................... {
.................... if(*su1!=*su2)
.................... return ((*su1<*su2)?-1:+1);
.................... }
.................... return 0;
.................... }
....................
.................... /* standard template: int strcmp(const char *s1, const char *s2).
.................... Compares s1 & s2; returns -1 if s1<s2, 0 if s1=s2, 1 if s1>s2 */
....................
.................... 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 s1<s2, 0 if s1=s2, 1 if s1>s2 */
....................
.................... 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<n;++su,--n)
.................... if(*su==uc)
.................... return su;
.................... return NULL;
.................... }
....................
.................... /* standard template: char *strchr(const char *s, int c).
.................... Finds first occurrence of c in s */
....................
.................... char *strchr(char *s, int c)
.................... {
.................... for (; *s != c; s++)
.................... if (*s == '\0')
.................... return(0);
.................... return(s);
.................... }
.................... /* standard template:
.................... size_t strcspn(const char *s1, const char *s2).
.................... Computes length of max initial segment of s1 that
.................... consists entirely of characters NOT from s2*/
....................
.................... int *strcspn(char *s1, char *s2)
.................... {
.................... char *sc1, *sc2;
....................
.................... for (sc1 = s1; *sc1 != 0; sc1++)
.................... for (sc2 = s2; *sc2 != 0; sc2++)
.................... if (*sc1 == *sc2)
.................... return(sc1 - s1);
.................... return(sc1 - s1);
.................... }
.................... /* standard template:
.................... char *strpbrk(const char *s1, const char *s2).
.................... Locates first occurence of any character from s2 in s1;
.................... returns s1 if s2 is empty string */
....................
.................... char *strpbrk(char *s1, char *s2)
.................... {
.................... char *sc1, *sc2;
....................
.................... for (sc1 = s1; *sc1 != 0; sc1++)
.................... for (sc2 = s2; *sc2 != 0; sc2++)
.................... if (*sc1 == *sc2)
.................... return(sc1);
.................... return(0);
.................... }
....................
....................
.................... /* standard template: char *strrchr(const char *s, int c).
.................... Finds last occurrence of c in s */
....................
.................... char *strrchr(char *s, int c)
.................... {
.................... char *p;
....................
.................... for (p = 0; ; s++)
.................... {
.................... if (*s == c)
.................... p = s;
.................... if (*s == '\0')
.................... return(p);
.................... }
.................... }
.................... /* computes length of max initial segment of s1 consisting
.................... entirely of characters from s2 */
....................
.................... int *strspn(char *s1, char *s2)
.................... {
.................... char *sc1, *sc2;
....................
.................... for (sc1 = s1; *sc1 != 0; sc1++)
.................... for (sc2 = s2; ; sc2++)
.................... if (*sc2 == '\0')
.................... return(sc1 - s1);
.................... else if (*sc1 == *sc2)
.................... break;
.................... return(sc1 - s1);
.................... }
.................... /* standard template:
.................... char *strstr(const char *s1, const char *s2);
.................... Locates first occurence of character sequence s2 in s1;
.................... returns 0 if s2 is empty string
....................
.................... Uncomment #define FASTER_BUT_MORE_ROM at the top of the
.................... file to use the faster algorithm */
.................... char *strstr(char *s1, char *s2)
.................... {
.................... char *s, *t;
....................
.................... #ifdef FASTER_BUT_MORE_ROM
.................... if (*s2 == '\0')
.................... return(s1);
.................... #endif
....................
.................... while (*s1)
.................... {
.................... for(s = s1, t = s2; *t && *s == *t; ++s, ++t);
....................
.................... if (*t == '\0')
.................... return s1;
.................... ++s1;
.................... #ifdef FASTER_BUT_MORE_ROM
.................... while(*s1 != '\0' && *s1 != *s2)
.................... ++s1;
.................... #endif
.................... }
.................... return 0;
.................... }
....................
.................... /* standard template: char *strtok(char *s1, const char *s2).
....................
.................... Finds next token in s1 delimited by a character from separator
.................... string s2 (which can be different from call to call). First call
.................... starts at beginning of s1 searching for first character NOT
.................... contained in s2; returns 0 if none is found.
.................... If one is found, it is the start of first token (return value).
.................... Function then searches from there for a character contained in s2.
.................... If none is found, current token extends to end of s1, and subsequent
.................... searches for a token will return 0. If one is found, it is
.................... overwritten by '\0', which terminates current token. Function saves
.................... pointer to following character from which next search will start.
.................... Each subsequent call, with 0 as first argument, starts searching
.................... from saved pointer */
....................
.................... char *strtok(char *s1, char *s2)
.................... {
.................... char *beg, *end;
.................... static char *save;
....................
.................... beg = (s1)? s1: save;
.................... beg += strspn(beg, s2);
.................... if (*beg == '\0')
.................... {
.................... *save = ' ';
.................... return(0);
.................... }
.................... end = strpbrk(beg, s2);
.................... if (*end != '\0')
.................... {
.................... *end = '\0';
.................... end++;
.................... }
.................... save = end;
.................... return(beg);
.................... }
....................
.................... /*****************************************************************/
.................... /*Miscellaneous functions*/
.................... /* standard template
.................... maps error number in errnum to an error message string
.................... Returns: Pointer to string
.................... */
.................... #ifdef _ERRNO
.................... char * strerror(int errnum)
.................... {
.................... char s[15];
.................... switch( errnum)
.................... {
.................... case 0:
.................... strcpy(s,"no errors");
.................... return s;
.................... case EDOM :
.................... strcpy(s,"domain error");
.................... return s;
.................... case ERANGE:
.................... strcpy(s,"range error");
.................... return s;
.................... }
.................... }
.................... #ENDIF
.................... /* standard template: size_t strlen(const char *s).
.................... Computes length of s1 (preceding terminating 0) */
....................
.................... int *strlen(char *s)
.................... {
.................... char *sc;
....................
.................... for (sc = s; *sc != 0; sc++);
.................... return(sc - s);
.................... }
....................
.................... /* standard template: size_t stricmp(const char *s1, const char *s2).
.................... Compares s1 to s2 ignoring case (upper vs. lower) */
....................
.................... signed int stricmp(char *s1, char *s2)
.................... {
.................... for(; *s1==*s2||(isalpha(*s1)&&isalpha(*s2)&&(*s1==*s2+32||*s2==*s1+32));
.................... s1++, s2++)
.................... if (*s1 == '\0')
.................... return(0);
.................... return((*s1 < *s2) ? -1: 1);
.................... }
....................
....................
.................... /* standard template: char *strlwr(char *s).
.................... Replaces uppercase letters by lowercase;
.................... returns pointer to new string s */
....................
.................... char *strlwr(char *s)
.................... {
.................... char *p;
....................
.................... for (p = s; *p != '\0'; p++)
.................... if (*p >= 'A' && *p <='Z')
.................... *p += 'a' - 'A';
.................... return(s);
.................... }
....................
....................
.................... /************************************************************/
....................
....................
.................... #endif
....................
....................
.................... div_t div(signed int numer,signed int denom)
.................... {
.................... div_t val;
.................... val.quot = numer / denom;
.................... val.rem = numer - (denom * val.quot);
.................... return (val);
.................... }
....................
.................... ldiv_t ldiv(signed long numer,signed long denom)
.................... {
.................... ldiv_t val;
.................... val.quot = numer / denom;
.................... val.rem = numer - (denom * val.quot);
.................... return (val);
.................... }
....................
.................... float atof(char * s)
.................... {
.................... float pow10 = 1.0;
.................... 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<expcnt;i++)
.................... exp*=10;
....................
.................... if(expsign==1)
.................... result/=exp;
.................... else
.................... result*=exp;
.................... }
.................... }
....................
.................... if (sign == 1)
.................... result = -1*result;
.................... return(result);
.................... }
....................
.................... signed int atoi(char *s)
.................... {
.................... signed int result;
.................... int sign, base, index;
.................... char c;
....................
.................... index = 0;
.................... sign = 0;
.................... base = 10;
.................... result = 0;
....................
.................... if (!s)
.................... return 0;
.................... // Omit all preceeding alpha characters
.................... c = s[index++];
....................
.................... // increase index if either positive or negative sign is detected
.................... if (c == '-')
.................... {
.................... sign = 1; // Set the sign to negative
.................... c = s[index++];
.................... }
.................... else if (c == '+')
.................... {
.................... c = s[index++];
.................... }
....................
.................... if (c >= '0' && c <= '9')
.................... {
....................
.................... // Check for hexa number
.................... if (c == '0' && (s[index] == 'x' || s[index] == 'X'))
.................... {
.................... base = 16;
.................... index++;
.................... c = s[index++];
.................... }
....................
.................... // The number is a decimal number
.................... if (base == 10)
.................... {
.................... while (c >= '0' && c <= '9')
.................... {
.................... result = 10*result + (c - '0');
.................... c = s[index++];
.................... }
.................... }
.................... else if (base == 16) // The number is a hexa number
.................... {
.................... c = toupper(c);
.................... while ( (c >= '0' && c <= '9') || (c >= 'A' && c<='F'))
.................... {
.................... if (c >= '0' && c <= '9')
.................... result = (result << 4) + (c - '0');
.................... else
.................... result = (result << 4) + (c - 'A' + 10);
....................
.................... c = s[index++];
.................... c = toupper(c);
.................... }
.................... }
.................... }
....................
.................... if (sign == 1 && base == 10)
.................... result = -result;
....................
.................... return(result);
.................... }
....................
.................... signed long atol(char *s)
.................... {
.................... signed long result;
.................... int sign, base, index;
.................... char c;
....................
.................... index = 0;
.................... sign = 0;
.................... base = 10;
.................... result = 0;
....................
.................... if (!s)
.................... 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;
*
03D2: CLRF 57
03D3: CLRF 58
.................... char sign;
.................... char digits[]="0123456789abcdefghijklmnopqstuvwxyz";
03D4: MOVLW 30
03D5: BSF 03.5
03D6: MOVWF 20
03D7: MOVLW 31
03D8: MOVWF 21
03D9: MOVLW 32
03DA: MOVWF 22
03DB: MOVLW 33
03DC: MOVWF 23
03DD: MOVLW 34
03DE: MOVWF 24
03DF: MOVLW 35
03E0: MOVWF 25
03E1: MOVLW 36
03E2: MOVWF 26
03E3: MOVLW 37
03E4: MOVWF 27
03E5: MOVLW 38
03E6: MOVWF 28
03E7: MOVLW 39
03E8: MOVWF 29
03E9: MOVLW 61
03EA: MOVWF 2A
03EB: MOVLW 62
03EC: MOVWF 2B
03ED: MOVLW 63
03EE: MOVWF 2C
03EF: MOVLW 64
03F0: MOVWF 2D
03F1: MOVLW 65
03F2: MOVWF 2E
03F3: MOVLW 66
03F4: MOVWF 2F
03F5: MOVLW 67
03F6: MOVWF 30
03F7: MOVLW 68
03F8: MOVWF 31
03F9: MOVLW 69
03FA: MOVWF 32
03FB: MOVLW 6A
03FC: MOVWF 33
03FD: MOVLW 6B
03FE: MOVWF 34
03FF: MOVLW 6C
0400: MOVWF 35
0401: MOVLW 6D
0402: MOVWF 36
0403: MOVLW 6E
0404: MOVWF 37
0405: MOVLW 6F
0406: MOVWF 38
0407: MOVLW 70
0408: MOVWF 39
0409: MOVLW 71
040A: MOVWF 3A
040B: MOVLW 73
040C: MOVWF 3B
040D: MOVLW 74
040E: MOVWF 3C
040F: MOVLW 75
0410: MOVWF 3D
0411: MOVLW 76
0412: MOVWF 3E
0413: MOVLW 77
0414: MOVWF 3F
0415: MOVLW 78
0416: MOVWF 40
0417: MOVLW 79
0418: MOVWF 41
0419: MOVLW 7A
041A: MOVWF 42
041B: CLRF 43
.................... for(sc=s;isspace(*sc);++sc);
041C: BCF 03.5
041D: MOVF 51,W
041E: MOVWF 54
041F: MOVF 54,W
0420: MOVWF 04
0421: MOVF 00,W
0422: SUBLW 20
0423: BTFSS 03.2
0424: GOTO 427
0425: INCF 54,F
0426: GOTO 41F
.................... sign=*sc=='-'||*sc=='+'?*sc++:'+';
0427: MOVF 54,W
0428: MOVWF 04
0429: MOVF 00,W
042A: SUBLW 2D
042B: BTFSC 03.2
042C: GOTO 433
042D: MOVF 54,W
042E: MOVWF 04
042F: MOVF 00,W
0430: SUBLW 2B
0431: BTFSS 03.2
0432: GOTO 438
0433: MOVF 54,W
0434: INCF 54,F
0435: MOVWF 04
0436: MOVF 00,W
0437: GOTO 439
0438: MOVLW 2B
0439: MOVWF 59
.................... if(sign=='-')
043A: MOVF 59,W
043B: SUBLW 2D
043C: BTFSS 03.2
043D: GOTO 449
.................... {
.................... if (endptr)
043E: MOVF 52,F
043F: BTFSC 03.2
0440: GOTO 445
.................... {
.................... *((char *)endptr)=s;
0441: MOVF 52,W
0442: MOVWF 04
0443: MOVF 51,W
0444: MOVWF 00
.................... }
.................... return 0;
0445: MOVLW 00
0446: MOVWF 78
0447: MOVWF 79
0448: GOTO 555
.................... }
....................
.................... if (base <0 || base ==1|| base >36) // invalid base
0449: BTFSC 53.7
044A: GOTO 454
044B: DECFSZ 53,W
044C: GOTO 44E
044D: GOTO 454
044E: BTFSC 53.7
044F: GOTO 460
0450: MOVF 53,W
0451: SUBLW 24
0452: BTFSC 03.0
0453: GOTO 460
.................... {
.................... if (endptr)
0454: MOVF 52,F
0455: BTFSC 03.2
0456: GOTO 45B
.................... {
.................... *((char *)endptr)=s;
0457: MOVF 52,W
0458: MOVWF 04
0459: MOVF 51,W
045A: MOVWF 00
.................... }
.................... return 0;
045B: MOVLW 00
045C: MOVWF 78
045D: MOVWF 79
045E: GOTO 555
.................... }
.................... else if (base)
045F: GOTO 4C6
0460: MOVF 53,F
0461: BTFSC 03.2
0462: GOTO 49D
.................... {
.................... if(base==16 && *sc =='0'&&(sc[1]=='x' || sc[1]=='X'))
0463: MOVF 53,W
0464: SUBLW 10
0465: BTFSS 03.2
0466: GOTO 47D
0467: MOVF 54,W
0468: MOVWF 04
0469: MOVF 00,W
046A: SUBLW 30
046B: BTFSS 03.2
046C: GOTO 47D
046D: MOVLW 01
046E: ADDWF 54,W
046F: MOVWF 04
0470: MOVF 00,W
0471: SUBLW 78
0472: BTFSC 03.2
0473: GOTO 47B
0474: MOVLW 01
0475: ADDWF 54,W
0476: MOVWF 04
0477: MOVF 00,W
0478: SUBLW 58
0479: BTFSS 03.2
047A: GOTO 47D
.................... sc+=2;
047B: MOVLW 02
047C: ADDWF 54,F
.................... if(base==8 && *sc =='0')
047D: MOVF 53,W
047E: SUBLW 08
047F: BTFSS 03.2
0480: GOTO 489
0481: MOVF 54,W
0482: MOVWF 04
0483: MOVF 00,W
0484: SUBLW 30
0485: BTFSS 03.2
0486: GOTO 489
.................... sc+=1;
0487: MOVLW 01
0488: ADDWF 54,F
.................... if(base==2 && *sc =='0'&&sc[1]=='b')
0489: MOVF 53,W
048A: SUBLW 02
048B: BTFSS 03.2
048C: GOTO 49C
048D: MOVF 54,W
048E: MOVWF 04
048F: MOVF 00,W
0490: SUBLW 30
0491: BTFSS 03.2
0492: GOTO 49C
0493: MOVLW 01
0494: ADDWF 54,W
0495: MOVWF 04
0496: MOVF 00,W
0497: SUBLW 62
0498: BTFSS 03.2
0499: GOTO 49C
.................... sc+=2;
049A: MOVLW 02
049B: ADDWF 54,F
....................
.................... }
.................... else if(*sc!='0') // base is 0, find base
049C: GOTO 4C6
049D: MOVF 54,W
049E: MOVWF 04
049F: MOVF 00,W
04A0: SUBLW 30
04A1: BTFSC 03.2
04A2: GOTO 4A6
.................... base=10;
04A3: MOVLW 0A
04A4: MOVWF 53
.................... else if (sc[1]=='x' || sc[1]=='X')
04A5: GOTO 4C6
04A6: MOVLW 01
04A7: ADDWF 54,W
04A8: MOVWF 04
04A9: MOVF 00,W
04AA: SUBLW 78
04AB: BTFSC 03.2
04AC: GOTO 4B4
04AD: MOVLW 01
04AE: ADDWF 54,W
04AF: MOVWF 04
04B0: MOVF 00,W
04B1: SUBLW 58
04B2: BTFSS 03.2
04B3: GOTO 4B9
.................... base =16,sc+=2;
04B4: MOVLW 10
04B5: MOVWF 53
04B6: MOVLW 02
04B7: ADDWF 54,F
.................... else if(sc[1]=='b')
04B8: GOTO 4C6
04B9: MOVLW 01
04BA: ADDWF 54,W
04BB: MOVWF 04
04BC: MOVF 00,W
04BD: SUBLW 62
04BE: BTFSS 03.2
04BF: GOTO 4C4
.................... base=2,sc+=2;
04C0: MOVLW 02
04C1: MOVWF 53
04C2: ADDWF 54,F
.................... else
04C3: GOTO 4C6
.................... base=8;
04C4: MOVLW 08
04C5: MOVWF 53
.................... for (s1=sc;*sc=='0';++sc);// skip leading zeroes
04C6: MOVF 54,W
04C7: MOVWF 55
04C8: MOVF 54,W
04C9: MOVWF 04
04CA: MOVF 00,W
04CB: SUBLW 30
04CC: BTFSS 03.2
04CD: GOTO 4D0
04CE: INCF 54,F
04CF: GOTO 4C8
.................... sd=memchr(digits,tolower(*sc),base);
04D0: MOVF 54,W
04D1: MOVWF 04
04D2: MOVF 00,W
04D3: MOVWF 5A
04D4: SUBLW 40
04D5: BTFSC 03.0
04D6: GOTO 4DE
04D7: MOVF 5A,W
04D8: SUBLW 5A
04D9: BTFSS 03.0
04DA: GOTO 4DE
04DB: MOVF 5A,W
04DC: IORLW 20
04DD: GOTO 4DF
04DE: MOVF 5A,W
04DF: MOVWF 5B
04E0: MOVLW A0
04E1: BSF 03.5
04E2: MOVWF 46
04E3: BCF 03.5
04E4: MOVF 5A,W
04E5: BSF 03.5
04E6: MOVWF 47
04E7: BCF 03.5
04E8: MOVF 53,W
04E9: BSF 03.5
04EA: MOVWF 48
04EB: BCF 03.5
04EC: CALL 3A0
04ED: MOVF 78,W
04EE: MOVWF 56
.................... for(; sd!=0; )
04EF: MOVF 56,F
04F0: BTFSC 03.2
04F1: GOTO 53B
.................... {
.................... x=x*base+(int16)(sd-digits);
04F2: CLRF 7A
04F3: MOVF 53,W
04F4: MOVWF 77
04F5: BTFSC 53.7
04F6: DECF 7A,F
04F7: MOVWF 5A
04F8: MOVF 7A,W
04F9: MOVWF 5B
04FA: MOVF 58,W
04FB: BSF 03.5
04FC: MOVWF 47
04FD: BCF 03.5
04FE: MOVF 57,W
04FF: BSF 03.5
0500: MOVWF 46
0501: BCF 03.5
0502: MOVF 7A,W
0503: BSF 03.5
0504: MOVWF 49
0505: BCF 03.5
0506: MOVF 5A,W
0507: BSF 03.5
0508: MOVWF 48
0509: BCF 03.5
050A: GOTO 3B9
050B: MOVF 78,W
050C: MOVWF 5B
050D: MOVLW A0
050E: SUBWF 56,W
050F: CLRF 7A
0510: ADDWF 78,W
0511: MOVWF 78
0512: BTFSC 03.0
0513: INCF 7A,F
0514: MOVF 79,W
0515: ADDWF 7A,F
0516: MOVF 78,W
0517: MOVWF 57
0518: MOVF 7A,W
0519: MOVWF 58
.................... ++sc;
051A: INCF 54,F
.................... sd=memchr(digits,tolower(*sc),base);
051B: MOVF 54,W
051C: MOVWF 04
051D: MOVF 00,W
051E: MOVWF 5A
051F: SUBLW 40
0520: BTFSC 03.0
0521: GOTO 529
0522: MOVF 5A,W
0523: SUBLW 5A
0524: BTFSS 03.0
0525: GOTO 529
0526: MOVF 5A,W
0527: IORLW 20
0528: GOTO 52A
0529: MOVF 5A,W
052A: MOVWF 5B
052B: MOVLW A0
052C: BSF 03.5
052D: MOVWF 46
052E: BCF 03.5
052F: MOVF 5A,W
0530: BSF 03.5
0531: MOVWF 47
0532: BCF 03.5
0533: MOVF 53,W
0534: BSF 03.5
0535: MOVWF 48
0536: BCF 03.5
0537: CALL 3A0
0538: MOVF 78,W
0539: MOVWF 56
.................... }
053A: GOTO 4EF
.................... if(s1==sc)
053B: MOVF 54,W
053C: SUBWF 55,W
053D: BTFSS 03.2
053E: GOTO 54A
.................... {
.................... if (endptr)
053F: MOVF 52,F
0540: BTFSC 03.2
0541: GOTO 546
.................... {
.................... *((char *)endptr)=s;
0542: MOVF 52,W
0543: MOVWF 04
0544: MOVF 51,W
0545: MOVWF 00
.................... }
.................... return 0;
0546: MOVLW 00
0547: MOVWF 78
0548: MOVWF 79
0549: GOTO 555
.................... }
.................... if (endptr)
054A: MOVF 52,F
054B: BTFSC 03.2
054C: GOTO 551
.................... *((char *)endptr)=sc;
054D: MOVF 52,W
054E: MOVWF 04
054F: MOVF 54,W
0550: MOVWF 00
.................... return x;
0551: MOVF 57,W
0552: MOVWF 78
0553: MOVF 58,W
0554: MOVWF 79
.................... }
0555: BSF 0A.3
0556: BCF 0A.4
0557: GOTO 503 (RETURN)
....................
....................
.................... 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;
*
0818: MOVLW 01
0819: MOVWF 22
081A: CLRF 23
081B: CLRF 24
081C: CLRF 25
....................
.................... 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
....................
....................
.................... #define DELKA 40
.................... #define VYKON 100
....................
.................... char odp[DELKA];
....................
.................... int1 check_new_sms()
.................... {
.................... fprintf(MOBIL,"AT+CMGL=0\r"); //vycti prijate SMS (0=nove;1=vsechny)
*
022E: CLRF 51
022F: MOVF 51,W
0230: CALL 004
0231: IORLW 00
0232: BTFSC 03.2
0233: GOTO 238
0234: INCF 51,F
0235: MOVWF 53
0236: CALL 1DE
0237: GOTO 22F
.................... while(fgetc(MOBIL)!=0x0A); // predkoc prvni radek odpovedi
0238: CALL 206
0239: MOVF 78,W
023A: SUBLW 0A
023B: BTFSS 03.2
023C: GOTO 238
.................... odp[0]=fgetc(MOBIL); // Nacti prvni dva znaky druheho radku odpovedi
023D: CALL 206
023E: MOVF 78,W
023F: MOVWF 26
.................... odp[1]=fgetc(MOBIL);
0240: CALL 206
0241: MOVF 78,W
0242: MOVWF 27
.................... while(fgetc(MOBIL)!=0x0A); // Preskoc zbytek radku
0243: CALL 206
0244: MOVF 78,W
0245: SUBLW 0A
0246: BTFSS 03.2
0247: GOTO 243
....................
.................... if(odp[0] == 'O' && odp[1] == 'K') return 1;
0248: MOVF 26,W
0249: SUBLW 4F
024A: BTFSS 03.2
024B: GOTO 254
024C: MOVF 27,W
024D: SUBLW 4B
024E: BTFSS 03.2
024F: GOTO 254
0250: MOVLW 01
0251: MOVWF 78
0252: GOTO 257
.................... else return 0;
0253: GOTO 257
0254: MOVLW 00
0255: MOVWF 78
0256: GOTO 257
.................... }
0257: BSF 0A.3
0258: BCF 0A.4
0259: GOTO 0A1 (RETURN)
....................
.................... read_sms()
.................... {
.................... int pom,pom2,pom3,odkl,odkl2,maskovadlo;
.................... for(pom=0;pom<54;pom++) //preskoc nedulezite informace
025A: CLRF 51
025B: MOVF 51,W
025C: SUBLW 35
025D: BTFSS 03.0
025E: GOTO 262
.................... {
.................... fgetc(MOBIL);
025F: CALL 206
.................... }
0260: INCF 51,F
0261: GOTO 25B
....................
.................... //gets(odp); //uloz zakodovany text SMS
....................
.................... odp[0]=fgetc(MOBIL);
0262: CALL 206
0263: MOVF 78,W
0264: MOVWF 26
.................... odp[1]=fgetc(MOBIL);
0265: CALL 206
0266: MOVF 78,W
0267: MOVWF 27
.................... odp[2]=fgetc(MOBIL);
0268: CALL 206
0269: MOVF 78,W
026A: MOVWF 28
.................... odp[3]=fgetc(MOBIL);
026B: CALL 206
026C: MOVF 78,W
026D: MOVWF 29
.................... odp[4]=fgetc(MOBIL);
026E: CALL 206
026F: MOVF 78,W
0270: MOVWF 2A
.................... odp[5]=fgetc(MOBIL);
0271: CALL 206
0272: MOVF 78,W
0273: MOVWF 2B
.................... odp[6]=fgetc(MOBIL);
0274: CALL 206
0275: MOVF 78,W
0276: MOVWF 2C
.................... odp[7]=fgetc(MOBIL);
0277: CALL 206
0278: MOVF 78,W
0279: MOVWF 2D
....................
.................... /*lcd_gotoxy(1,1);
.................... printf(lcd_putc,"\f%s\n",odp);*/
....................
.................... if(odp[0]==0) odp[1]='0'; // Prevod z ASCII do BIN
027A: MOVF 26,F
027B: BTFSS 03.2
027C: GOTO 27F
027D: MOVLW 30
027E: MOVWF 27
.................... odp[0]=odp[0] - '0';
027F: MOVLW 30
0280: SUBWF 26,F
.................... odp[1]=odp[1] - '0';
0281: SUBWF 27,F
.................... if(odp[0]>9) odp[0]=odp[0]-7;
0282: MOVF 26,W
0283: SUBLW 09
0284: BTFSC 03.0
0285: GOTO 288
0286: MOVLW 07
0287: SUBWF 26,F
.................... if(odp[1]>9) odp[1]=odp[1]-7;
0288: MOVF 27,W
0289: SUBLW 09
028A: BTFSC 03.0
028B: GOTO 28E
028C: MOVLW 07
028D: SUBWF 27,F
.................... odp[0]=odp[0] << 4;
028E: SWAPF 26,F
028F: MOVLW F0
0290: ANDWF 26,F
.................... odp[0] |= odp[1];
0291: MOVF 27,W
0292: IORWF 26,F
....................
.................... if(odp[2]==0) odp[3]='0';
0293: MOVF 28,F
0294: BTFSS 03.2
0295: GOTO 298
0296: MOVLW 30
0297: MOVWF 29
.................... odp[2]=odp[2] - '0';
0298: MOVLW 30
0299: SUBWF 28,F
.................... odp[3]=odp[3] - '0';
029A: SUBWF 29,F
.................... if(odp[2]>9) odp[2]=odp[2]-7;
029B: MOVF 28,W
029C: SUBLW 09
029D: BTFSC 03.0
029E: GOTO 2A1
029F: MOVLW 07
02A0: SUBWF 28,F
.................... if(odp[3]>9) odp[3]=odp[3]-7;
02A1: MOVF 29,W
02A2: SUBLW 09
02A3: BTFSC 03.0
02A4: GOTO 2A7
02A5: MOVLW 07
02A6: SUBWF 29,F
.................... odp[2]=odp[2] << 4;
02A7: SWAPF 28,F
02A8: MOVLW F0
02A9: ANDWF 28,F
.................... odp[2] |= odp[3];
02AA: MOVF 29,W
02AB: IORWF 28,F
....................
.................... if(odp[4]==0) odp[5]='0';
02AC: MOVF 2A,F
02AD: BTFSS 03.2
02AE: GOTO 2B1
02AF: MOVLW 30
02B0: MOVWF 2B
.................... odp[4]=odp[4] - '0';
02B1: MOVLW 30
02B2: SUBWF 2A,F
.................... odp[5]=odp[5] - '0';
02B3: SUBWF 2B,F
.................... if(odp[4]>9) odp[4]=odp[4]-7;
02B4: MOVF 2A,W
02B5: SUBLW 09
02B6: BTFSC 03.0
02B7: GOTO 2BA
02B8: MOVLW 07
02B9: SUBWF 2A,F
.................... if(odp[5]>9) odp[5]=odp[5]-7;
02BA: MOVF 2B,W
02BB: SUBLW 09
02BC: BTFSC 03.0
02BD: GOTO 2C0
02BE: MOVLW 07
02BF: SUBWF 2B,F
.................... odp[4]=odp[4] << 4;
02C0: SWAPF 2A,F
02C1: MOVLW F0
02C2: ANDWF 2A,F
.................... odp[4] |= odp[5];
02C3: MOVF 2B,W
02C4: IORWF 2A,F
....................
.................... if(odp[6]==0) odp[7]='0';
02C5: MOVF 2C,F
02C6: BTFSS 03.2
02C7: GOTO 2CA
02C8: MOVLW 30
02C9: MOVWF 2D
.................... odp[6]=odp[6] - '0';
02CA: MOVLW 30
02CB: SUBWF 2C,F
.................... odp[7]=odp[7] - '0';
02CC: SUBWF 2D,F
.................... if(odp[6]>9) odp[6]=odp[6]-7;
02CD: MOVF 2C,W
02CE: SUBLW 09
02CF: BTFSC 03.0
02D0: GOTO 2D3
02D1: MOVLW 07
02D2: SUBWF 2C,F
.................... if(odp[7]>9) odp[7]=odp[7]-7;
02D3: MOVF 2D,W
02D4: SUBLW 09
02D5: BTFSC 03.0
02D6: GOTO 2D9
02D7: MOVLW 07
02D8: SUBWF 2D,F
.................... odp[6]=odp[6] << 4;
02D9: SWAPF 2C,F
02DA: MOVLW F0
02DB: ANDWF 2C,F
.................... odp[6] |= odp[7];
02DC: MOVF 2D,W
02DD: IORWF 2C,F
....................
.................... odp[1]=odp[2];
02DE: MOVF 28,W
02DF: MOVWF 27
.................... odp[2]=odp[4];
02E0: MOVF 2A,W
02E1: MOVWF 28
.................... odp[3]=odp[6];
02E2: MOVF 2C,W
02E3: MOVWF 29
.................... odp[4]=odp[5]=odp[6]=0;
02E4: CLRF 2C
02E5: MOVF 2C,W
02E6: MOVWF 2B
02E7: MOVWF 2A
....................
.................... /*lcd_gotoxy(1,2);
.................... printf(lcd_putc,"%u %u %u %u",odp[0],odp[1],odp[2]odp[3]); */
....................
.................... pom3=0;
02E8: CLRF 53
.................... for (pom = 0; pom < 4;pom++)
02E9: CLRF 51
02EA: MOVF 51,W
02EB: SUBLW 03
02EC: BTFSS 03.0
02ED: GOTO 341
.................... {
.................... maskovadlo = maskovadlo >> 1; //rotace promene urcene pro maskovani
02EE: BCF 03.0
02EF: RRF 56,F
.................... maskovadlo = maskovadlo | 0x80;
02F0: BSF 56.7
.................... odkl = odp[pom] & maskovadlo; //odlozeni "prenosu" do odkl pomoci maskovadla
02F1: MOVLW 26
02F2: ADDWF 51,W
02F3: MOVWF 04
02F4: MOVF 00,W
02F5: ANDWF 56,W
02F6: MOVWF 54
.................... odp[pom] = odp[pom] << pom3; //rotace znaku
02F7: MOVLW 26
02F8: ADDWF 51,W
02F9: MOVWF 57
02FA: MOVLW 26
02FB: ADDWF 51,W
02FC: MOVWF 04
02FD: MOVF 00,W
02FE: MOVWF 77
02FF: MOVF 53,W
0300: MOVWF 78
0301: BTFSC 03.2
0302: GOTO 307
0303: BCF 03.0
0304: RLF 77,F
0305: DECFSZ 78,F
0306: GOTO 303
0307: MOVF 57,W
0308: MOVWF 04
0309: MOVF 77,W
030A: MOVWF 00
.................... for (pom2 = 0; pom2 < (8-pom3);pom2++) //rotace odkl2
030B: CLRF 52
030C: MOVF 53,W
030D: SUBLW 08
030E: SUBWF 52,W
030F: BTFSC 03.0
0310: GOTO 316
.................... {
.................... odkl2 = odkl2 >> 1;
0311: BCF 03.0
0312: RRF 55,F
.................... odkl2 = odkl2 & 127;
0313: BCF 55.7
.................... }
0314: INCF 52,F
0315: GOTO 30C
.................... odp[pom] = odp[pom] | odkl2; //pridani odkl2 ke znaku
0316: MOVLW 26
0317: ADDWF 51,W
0318: MOVWF 57
0319: MOVLW 26
031A: ADDWF 51,W
031B: MOVWF 04
031C: MOVF 00,W
031D: IORWF 55,W
031E: MOVWF 59
031F: MOVF 57,W
0320: MOVWF 04
0321: MOVF 59,W
0322: MOVWF 00
.................... odp[pom] = odp[pom] & 127; //smazani nejvysiho bitu
0323: MOVLW 26
0324: ADDWF 51,W
0325: MOVWF 57
0326: MOVLW 26
0327: ADDWF 51,W
0328: MOVWF 04
0329: MOVF 00,W
032A: ANDLW 7F
032B: MOVWF 59
032C: MOVF 57,W
032D: MOVWF 04
032E: MOVF 59,W
032F: MOVWF 00
.................... odkl2 = odkl; //ulozeni odlk na dalsi pruchod
0330: MOVF 54,W
0331: MOVWF 55
.................... pom3++; //inkrementace citace rotace
0332: INCF 53,F
.................... if (pom3 == 8) //kazdy 8my znak
0333: MOVF 53,W
0334: SUBLW 08
0335: BTFSS 03.2
0336: GOTO 33F
.................... {
.................... pom3 = 0; //smaz citac
0337: CLRF 53
.................... odp[pom+1] = odkl2; //uloz 8my znak vznikly z "prenosu"
0338: MOVLW 01
0339: ADDWF 51,W
033A: ADDLW 26
033B: MOVWF 04
033C: MOVF 55,W
033D: MOVWF 00
.................... maskovadlo = 0; //smaz maskovadlo
033E: CLRF 56
.................... }
.................... }
033F: INCF 51,F
0340: GOTO 2EA
.................... odp[pom]='\0';
0341: MOVLW 26
0342: ADDWF 51,W
0343: MOVWF 04
0344: CLRF 00
.................... }
0345: BSF 0A.3
0346: BCF 0A.4
0347: GOTO 0B1 (RETURN)
....................
.................... void read_time()
.................... {
.................... unsigned int8 n;
....................
....................
.................... fprintf(MOBIL,"AT+CCLK?\r");
*
037F: CLRF 52
0380: MOVF 52,W
0381: CALL 013
0382: IORLW 00
0383: BTFSC 03.2
0384: GOTO 389
0385: INCF 52,F
0386: MOVWF 53
0387: CALL 1DE
0388: GOTO 380
.................... while(fgetc(MOBIL)!='"');
0389: CALL 206
038A: MOVF 78,W
038B: SUBLW 22
038C: BTFSS 03.2
038D: GOTO 389
.................... for(n=0;n<12;n++) //preskoc nedulezite informace
038E: CLRF 51
038F: MOVF 51,W
0390: SUBLW 0B
0391: BTFSS 03.0
0392: GOTO 396
.................... {
.................... fgetc(MOBIL);
0393: CALL 206
.................... }
0394: INCF 51,F
0395: GOTO 38F
.................... odp[0]=fgetc(MOBIL);
0396: CALL 206
0397: MOVF 78,W
0398: MOVWF 26
.................... odp[1]=fgetc(MOBIL);
0399: CALL 206
039A: MOVF 78,W
039B: MOVWF 27
.................... odp[2]=0;
039C: CLRF 28
.................... }
039D: BSF 0A.3
039E: BCF 0A.4
039F: GOTO 4FA (RETURN)
....................
.................... void del_sms()
.................... {
.................... fprintf(MOBIL,"AT+CMGD=1\r"); //smaz prijatou SMSku
*
0374: CLRF 51
0375: MOVF 51,W
0376: CALL 021
0377: IORLW 00
0378: BTFSC 03.2
0379: GOTO 37E
037A: INCF 51,F
037B: MOVWF 53
037C: CALL 1DE
037D: GOTO 375
.................... }
037E: RETLW 00
....................
.................... void main()
.................... {
*
0800: CLRF 04
0801: MOVLW 1F
0802: ANDWF 03,F
0803: BCF 20.6
0804: MOVF 20,W
0805: BSF 03.5
0806: MOVWF 07
0807: BCF 03.5
0808: BSF 07.6
0809: BSF 03.5
080A: BCF 06.2
080B: BCF 03.5
080C: BSF 06.2
080D: BSF 03.5
080E: BSF 1F.0
080F: BSF 1F.1
0810: BSF 1F.2
0811: BCF 1F.3
0812: MOVLW 07
0813: MOVWF 1C
.................... setup_adc_ports(NO_ANALOGS);
*
081D: BSF 03.5
081E: BSF 1F.0
081F: BSF 1F.1
0820: BSF 1F.2
0821: BCF 1F.3
.................... setup_adc(ADC_OFF);
0822: BCF 03.5
0823: BCF 1F.0
.................... setup_spi(SPI_SS_DISABLED);
0824: BCF 14.5
0825: BCF 20.5
0826: MOVF 20,W
0827: BSF 03.5
0828: MOVWF 07
0829: BCF 03.5
082A: BSF 20.4
082B: MOVF 20,W
082C: BSF 03.5
082D: MOVWF 07
082E: BCF 03.5
082F: BCF 20.3
0830: MOVF 20,W
0831: BSF 03.5
0832: MOVWF 07
0833: MOVLW 01
0834: BCF 03.5
0835: MOVWF 14
0836: MOVLW 00
0837: BSF 03.5
0838: MOVWF 14
.................... setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
0839: MOVF 01,W
083A: ANDLW C7
083B: IORLW 08
083C: MOVWF 01
.................... setup_timer_1(T1_DISABLED);
083D: BCF 03.5
083E: CLRF 10
.................... setup_timer_2(T2_DIV_BY_4,255,1);
083F: MOVLW 00
0840: MOVWF 78
0841: IORLW 05
0842: MOVWF 12
0843: MOVLW FF
0844: BSF 03.5
0845: MOVWF 12
.................... setup_ccp1(CCP_PWM);
0846: BCF 03.5
0847: BCF 20.2
0848: MOVF 20,W
0849: BSF 03.5
084A: MOVWF 07
084B: BCF 03.5
084C: BCF 07.2
084D: MOVLW 0C
084E: MOVWF 17
.................... setup_ccp2(CCP_PWM);
084F: BCF 20.1
0850: MOVF 20,W
0851: BSF 03.5
0852: MOVWF 07
0853: BCF 03.5
0854: BCF 07.1
0855: MOVLW 0C
0856: MOVWF 1D
.................... setup_comparator(NC_NC_NC_NC);
0857: MOVLW 07
0858: BSF 03.5
0859: MOVWF 1C
085A: MOVF 05,W
085B: CLRWDT
085C: MOVLW 0E
085D: MOVWF 77
085E: DECFSZ 77,F
085F: GOTO 05E
0860: NOP
0861: NOP
0862: MOVF 1C,W
0863: BCF 03.5
0864: BCF 0D.6
.................... setup_vref(FALSE);
0865: BSF 03.5
0866: CLRF 1D
.................... setup_wdt(WDT_2304MS);
0867: MOVLW 0F
0868: MOVWF 77
0869: MOVLW 07
086A: BCF 03.5
086B: CLRF 01
086C: MOVLW 81
086D: MOVWF 04
086E: MOVF 00,W
086F: ANDLW F0
0870: IORLW 07
0871: MOVWF 00
0872: CLRWDT
0873: MOVF 00,W
0874: ANDLW F7
0875: BTFSC 77.3
0876: ANDLW F0
0877: IORWF 77,W
0878: MOVWF 00
....................
.................... set_pwm1_duty(0);
0879: CLRF 15
.................... set_pwm2_duty(0);
087A: CLRF 1B
....................
.................... while(TRUE)
.................... {
.................... unsigned int8 n;
.................... char *ptr;
.................... int time;
....................
.................... output_low(PIN_A4) ;
087B: BSF 03.5
087C: BCF 05.4
087D: BCF 03.5
087E: BCF 05.4
.................... delay_ms(150);
087F: MOVLW 96
0880: MOVWF 52
0881: BCF 0A.3
0882: CALL 1C8
0883: BSF 0A.3
.................... output_high(PIN_A4);
0884: BSF 03.5
0885: BCF 05.4
0886: BCF 03.5
0887: BSF 05.4
.................... delay_ms(150);
0888: MOVLW 96
0889: MOVWF 52
088A: BCF 0A.3
088B: CALL 1C8
088C: BSF 0A.3
.................... output_low(PIN_A4) ;
088D: BSF 03.5
088E: BCF 05.4
088F: BCF 03.5
0890: BCF 05.4
.................... delay_ms(150);
0891: MOVLW 96
0892: MOVWF 52
0893: BCF 0A.3
0894: CALL 1C8
0895: BSF 0A.3
.................... output_high(PIN_A4);
0896: BSF 03.5
0897: BCF 05.4
0898: BCF 03.5
0899: BSF 05.4
.................... delay_ms(150);
089A: MOVLW 96
089B: MOVWF 52
089C: BCF 0A.3
089D: CALL 1C8
089E: BSF 0A.3
....................
....................
.................... if(check_new_sms()) // Je odpoved "OK"?
089F: BCF 0A.3
08A0: GOTO 22E
08A1: BSF 0A.3
08A2: MOVF 78,F
08A3: BTFSC 03.2
08A4: GOTO 0AF
.................... {
.................... // printf(lcd_putc,"736 655 250");
.................... delay_ms(5000);
08A5: MOVLW 14
08A6: MOVWF 51
08A7: MOVLW FA
08A8: MOVWF 52
08A9: BCF 0A.3
08AA: CALL 1C8
08AB: BSF 0A.3
08AC: DECFSZ 51,F
08AD: GOTO 0A7
.................... }
.................... else
08AE: GOTO 4F8
.................... {
.................... read_sms();
08AF: BCF 0A.3
08B0: GOTO 25A
08B1: BSF 0A.3
....................
.................... if (toupper(odp[0]) == 'A')
08B2: MOVF 26,W
08B3: SUBLW 60
08B4: BTFSC 03.0
08B5: GOTO 0BD
08B6: MOVF 26,W
08B7: SUBLW 7A
08B8: BTFSS 03.0
08B9: GOTO 0BD
08BA: MOVF 26,W
08BB: ANDLW DF
08BC: GOTO 0BE
08BD: MOVF 26,W
08BE: SUBLW 41
08BF: BTFSS 03.2
08C0: GOTO 101
.................... {
.................... set_pwm1_duty(VYKON);
08C1: MOVLW 64
08C2: MOVWF 15
.................... set_pwm2_duty(VYKON);
08C3: MOVWF 1B
.................... Delay_ms(10000);
08C4: MOVLW 28
08C5: MOVWF 51
08C6: MOVLW FA
08C7: MOVWF 52
08C8: BCF 0A.3
08C9: CALL 1C8
08CA: BSF 0A.3
08CB: DECFSZ 51,F
08CC: GOTO 0C6
.................... fprintf(VRTULE,"JACK[BARmk"); // "JACK BAR :)"
08CD: CLRF 51
08CE: MOVF 51,W
08CF: BCF 0A.3
08D0: CALL 030
08D1: BSF 0A.3
08D2: IORLW 00
08D3: BTFSC 03.2
08D4: GOTO 0DB
08D5: INCF 51,F
08D6: MOVWF 52
08D7: BCF 0A.3
08D8: CALL 348
08D9: BSF 0A.3
08DA: GOTO 0CE
.................... Delay_ms(2000);
08DB: MOVLW 08
08DC: MOVWF 51
08DD: MOVLW FA
08DE: MOVWF 52
08DF: BCF 0A.3
08E0: CALL 1C8
08E1: BSF 0A.3
08E2: DECFSZ 51,F
08E3: GOTO 0DD
.................... fprintf(VRTULE,"JACK[BARmk"); // "JACK BAR :)"
08E4: CLRF 51
08E5: MOVF 51,W
08E6: BCF 0A.3
08E7: CALL 030
08E8: BSF 0A.3
08E9: IORLW 00
08EA: BTFSC 03.2
08EB: GOTO 0F2
08EC: INCF 51,F
08ED: MOVWF 52
08EE: BCF 0A.3
08EF: CALL 348
08F0: BSF 0A.3
08F1: GOTO 0E5
.................... Delay_ms(5000);
08F2: MOVLW 14
08F3: MOVWF 51
08F4: MOVLW FA
08F5: MOVWF 52
08F6: BCF 0A.3
08F7: CALL 1C8
08F8: BSF 0A.3
08F9: DECFSZ 51,F
08FA: GOTO 0F4
.................... set_pwm1_duty(0);
08FB: CLRF 15
.................... set_pwm2_duty(0);
08FC: CLRF 1B
.................... del_sms();
08FD: BCF 0A.3
08FE: CALL 374
08FF: BSF 0A.3
.................... break;
0900: GOTO 532
.................... }
....................
.................... if (toupper(odp[0]) == 'B')
0901: MOVF 26,W
0902: SUBLW 60
0903: BTFSC 03.0
0904: GOTO 10C
0905: MOVF 26,W
0906: SUBLW 7A
0907: BTFSS 03.0
0908: GOTO 10C
0909: MOVF 26,W
090A: ANDLW DF
090B: GOTO 10D
090C: MOVF 26,W
090D: SUBLW 42
090E: BTFSS 03.2
090F: GOTO 160
.................... {
.................... set_pwm1_duty(VYKON);
0910: MOVLW 64
0911: MOVWF 15
.................... set_pwm2_duty(VYKON);
0912: MOVWF 1B
.................... Delay_ms(10000);
0913: MOVLW 28
0914: MOVWF 51
0915: MOVLW FA
0916: MOVWF 52
0917: BCF 0A.3
0918: CALL 1C8
0919: BSF 0A.3
091A: DECFSZ 51,F
091B: GOTO 115
.................... for(n=0;n<=1;n++)
091C: CLRF 4E
091D: MOVF 4E,W
091E: SUBLW 01
091F: BTFSS 03.0
0920: GOTO 151
.................... {
.................... fprintf(VRTULE,"[ERROR[d[["); // " ERROR 3 "
0921: CLRF 51
0922: MOVF 51,W
0923: BCF 0A.3
0924: CALL 03F
0925: BSF 0A.3
0926: IORLW 00
0927: BTFSC 03.2
0928: GOTO 12F
0929: INCF 51,F
092A: MOVWF 52
092B: BCF 0A.3
092C: CALL 348
092D: BSF 0A.3
092E: GOTO 122
.................... Delay_ms(2000);
092F: MOVLW 08
0930: MOVWF 51
0931: MOVLW FA
0932: MOVWF 52
0933: BCF 0A.3
0934: CALL 1C8
0935: BSF 0A.3
0936: DECFSZ 51,F
0937: GOTO 131
.................... fprintf(VRTULE,"[OVERFLOW["); // " OVERFLOW "
0938: CLRF 51
0939: MOVF 51,W
093A: BCF 0A.3
093B: CALL 04E
093C: BSF 0A.3
093D: IORLW 00
093E: BTFSC 03.2
093F: GOTO 146
0940: INCF 51,F
0941: MOVWF 52
0942: BCF 0A.3
0943: CALL 348
0944: BSF 0A.3
0945: GOTO 139
.................... Delay_ms(2000);
0946: MOVLW 08
0947: MOVWF 51
0948: MOVLW FA
0949: MOVWF 52
094A: BCF 0A.3
094B: CALL 1C8
094C: BSF 0A.3
094D: DECFSZ 51,F
094E: GOTO 148
.................... }
094F: INCF 4E,F
0950: GOTO 11D
.................... Delay_ms(5000);
0951: MOVLW 14
0952: MOVWF 51
0953: MOVLW FA
0954: MOVWF 52
0955: BCF 0A.3
0956: CALL 1C8
0957: BSF 0A.3
0958: DECFSZ 51,F
0959: GOTO 153
.................... set_pwm1_duty(0);
095A: CLRF 15
.................... set_pwm2_duty(0);
095B: CLRF 1B
.................... del_sms();
095C: BCF 0A.3
095D: CALL 374
095E: BSF 0A.3
.................... break;
095F: GOTO 532
.................... }
....................
.................... if (toupper(odp[0]) == 'C')
0960: MOVF 26,W
0961: SUBLW 60
0962: BTFSC 03.0
0963: GOTO 16B
0964: MOVF 26,W
0965: SUBLW 7A
0966: BTFSS 03.0
0967: GOTO 16B
0968: MOVF 26,W
0969: ANDLW DF
096A: GOTO 16C
096B: MOVF 26,W
096C: SUBLW 43
096D: BTFSS 03.2
096E: GOTO 1D6
.................... {
.................... set_pwm1_duty(VYKON);
096F: MOVLW 64
0970: MOVWF 15
.................... set_pwm2_duty(VYKON);
0971: MOVWF 1B
.................... Delay_ms(10000);
0972: MOVLW 28
0973: MOVWF 51
0974: MOVLW FA
0975: MOVWF 52
0976: BCF 0A.3
0977: CALL 1C8
0978: BSF 0A.3
0979: DECFSZ 51,F
097A: GOTO 174
.................... for(n=0;n<=1;n++)
097B: CLRF 4E
097C: MOVF 4E,W
097D: SUBLW 01
097E: BTFSS 03.0
097F: GOTO 1C7
.................... {
.................... fprintf(VRTULE,"[ERROR[e[["); // " ERROR 4 "
0980: CLRF 51
0981: MOVF 51,W
0982: BCF 0A.3
0983: CALL 05D
0984: BSF 0A.3
0985: IORLW 00
0986: BTFSC 03.2
0987: GOTO 18E
0988: INCF 51,F
0989: MOVWF 52
098A: BCF 0A.3
098B: CALL 348
098C: BSF 0A.3
098D: GOTO 181
.................... Delay_ms(2000);
098E: MOVLW 08
098F: MOVWF 51
0990: MOVLW FA
0991: MOVWF 52
0992: BCF 0A.3
0993: CALL 1C8
0994: BSF 0A.3
0995: DECFSZ 51,F
0996: GOTO 190
.................... fprintf(VRTULE,"[OPAKUJTE["); // " OPAKUJTE "
0997: CLRF 51
0998: MOVF 51,W
0999: BCF 0A.3
099A: CALL 06C
099B: BSF 0A.3
099C: IORLW 00
099D: BTFSC 03.2
099E: GOTO 1A5
099F: INCF 51,F
09A0: MOVWF 52
09A1: BCF 0A.3
09A2: CALL 348
09A3: BSF 0A.3
09A4: GOTO 198
.................... Delay_ms(2000);
09A5: MOVLW 08
09A6: MOVWF 51
09A7: MOVLW FA
09A8: MOVWF 52
09A9: BCF 0A.3
09AA: CALL 1C8
09AB: BSF 0A.3
09AC: DECFSZ 51,F
09AD: GOTO 1A7
.................... fprintf(VRTULE,"[[VOLBU[[["); // " VOLBU "
09AE: CLRF 51
09AF: MOVF 51,W
09B0: BCF 0A.3
09B1: CALL 07B
09B2: BSF 0A.3
09B3: IORLW 00
09B4: BTFSC 03.2
09B5: GOTO 1BC
09B6: INCF 51,F
09B7: MOVWF 52
09B8: BCF 0A.3
09B9: CALL 348
09BA: BSF 0A.3
09BB: GOTO 1AF
.................... Delay_ms(2000);
09BC: MOVLW 08
09BD: MOVWF 51
09BE: MOVLW FA
09BF: MOVWF 52
09C0: BCF 0A.3
09C1: CALL 1C8
09C2: BSF 0A.3
09C3: DECFSZ 51,F
09C4: GOTO 1BE
.................... }
09C5: INCF 4E,F
09C6: GOTO 17C
.................... Delay_ms(3000);
09C7: MOVLW 0C
09C8: MOVWF 51
09C9: MOVLW FA
09CA: MOVWF 52
09CB: BCF 0A.3
09CC: CALL 1C8
09CD: BSF 0A.3
09CE: DECFSZ 51,F
09CF: GOTO 1C9
.................... set_pwm1_duty(0);
09D0: CLRF 15
.................... set_pwm2_duty(0);
09D1: CLRF 1B
.................... del_sms();
09D2: BCF 0A.3
09D3: CALL 374
09D4: BSF 0A.3
.................... break;
09D5: GOTO 532
.................... }
....................
.................... if (toupper(odp[0]) == 'D')
09D6: MOVF 26,W
09D7: SUBLW 60
09D8: BTFSC 03.0
09D9: GOTO 1E1
09DA: MOVF 26,W
09DB: SUBLW 7A
09DC: BTFSS 03.0
09DD: GOTO 1E1
09DE: MOVF 26,W
09DF: ANDLW DF
09E0: GOTO 1E2
09E1: MOVF 26,W
09E2: SUBLW 44
09E3: BTFSS 03.2
09E4: GOTO 225
.................... {
.................... set_pwm1_duty(VYKON);
09E5: MOVLW 64
09E6: MOVWF 15
.................... set_pwm2_duty(VYKON);
09E7: MOVWF 1B
.................... Delay_ms(10000);
09E8: MOVLW 28
09E9: MOVWF 51
09EA: MOVLW FA
09EB: MOVWF 52
09EC: BCF 0A.3
09ED: CALL 1C8
09EE: BSF 0A.3
09EF: DECFSZ 51,F
09F0: GOTO 1EA
.................... fprintf(VRTULE,"[[PEACE[[["); // " PEACE "
09F1: CLRF 51
09F2: MOVF 51,W
09F3: BCF 0A.3
09F4: CALL 08A
09F5: BSF 0A.3
09F6: IORLW 00
09F7: BTFSC 03.2
09F8: GOTO 1FF
09F9: INCF 51,F
09FA: MOVWF 52
09FB: BCF 0A.3
09FC: CALL 348
09FD: BSF 0A.3
09FE: GOTO 1F2
.................... Delay_ms(2000);
09FF: MOVLW 08
0A00: MOVWF 51
0A01: MOVLW FA
0A02: MOVWF 52
0A03: BCF 0A.3
0A04: CALL 1C8
0A05: BSF 0A.3
0A06: DECFSZ 51,F
0A07: GOTO 201
.................... fprintf(VRTULE,"[[PEACE[[[");
0A08: CLRF 51
0A09: MOVF 51,W
0A0A: BCF 0A.3
0A0B: CALL 08A
0A0C: BSF 0A.3
0A0D: IORLW 00
0A0E: BTFSC 03.2
0A0F: GOTO 216
0A10: INCF 51,F
0A11: MOVWF 52
0A12: BCF 0A.3
0A13: CALL 348
0A14: BSF 0A.3
0A15: GOTO 209
.................... Delay_ms(3000);
0A16: MOVLW 0C
0A17: MOVWF 51
0A18: MOVLW FA
0A19: MOVWF 52
0A1A: BCF 0A.3
0A1B: CALL 1C8
0A1C: BSF 0A.3
0A1D: DECFSZ 51,F
0A1E: GOTO 218
.................... set_pwm1_duty(0);
0A1F: CLRF 15
.................... set_pwm2_duty(0);
0A20: CLRF 1B
.................... del_sms();
0A21: BCF 0A.3
0A22: CALL 374
0A23: BSF 0A.3
.................... break;
0A24: GOTO 532
.................... }
....................
.................... if (toupper(odp[0]) == 'E')
0A25: MOVF 26,W
0A26: SUBLW 60
0A27: BTFSC 03.0
0A28: GOTO 230
0A29: MOVF 26,W
0A2A: SUBLW 7A
0A2B: BTFSS 03.0
0A2C: GOTO 230
0A2D: MOVF 26,W
0A2E: ANDLW DF
0A2F: GOTO 231
0A30: MOVF 26,W
0A31: SUBLW 45
0A32: BTFSS 03.2
0A33: GOTO 284
.................... {
.................... set_pwm1_duty(VYKON);
0A34: MOVLW 64
0A35: MOVWF 15
.................... set_pwm2_duty(VYKON);
0A36: MOVWF 1B
.................... Delay_ms(10000);
0A37: MOVLW 28
0A38: MOVWF 51
0A39: MOVLW FA
0A3A: MOVWF 52
0A3B: BCF 0A.3
0A3C: CALL 1C8
0A3D: BSF 0A.3
0A3E: DECFSZ 51,F
0A3F: GOTO 239
.................... for(n=0;n<=1;n++)
0A40: CLRF 4E
0A41: MOVF 4E,W
0A42: SUBLW 01
0A43: BTFSS 03.0
0A44: GOTO 275
.................... {
.................... fprintf(VRTULE,"[[[MORE[[["); // " MORE "
0A45: CLRF 51
0A46: MOVF 51,W
0A47: BCF 0A.3
0A48: CALL 099
0A49: BSF 0A.3
0A4A: IORLW 00
0A4B: BTFSC 03.2
0A4C: GOTO 253
0A4D: INCF 51,F
0A4E: MOVWF 52
0A4F: BCF 0A.3
0A50: CALL 348
0A51: BSF 0A.3
0A52: GOTO 246
.................... Delay_ms(2000);
0A53: MOVLW 08
0A54: MOVWF 51
0A55: MOVLW FA
0A56: MOVWF 52
0A57: BCF 0A.3
0A58: CALL 1C8
0A59: BSF 0A.3
0A5A: DECFSZ 51,F
0A5B: GOTO 255
.................... fprintf(VRTULE,"[[ZE[JO[[["); // " ZE JO "
0A5C: CLRF 51
0A5D: MOVF 51,W
0A5E: BCF 0A.3
0A5F: CALL 0A8
0A60: BSF 0A.3
0A61: IORLW 00
0A62: BTFSC 03.2
0A63: GOTO 26A
0A64: INCF 51,F
0A65: MOVWF 52
0A66: BCF 0A.3
0A67: CALL 348
0A68: BSF 0A.3
0A69: GOTO 25D
.................... Delay_ms(2000);
0A6A: MOVLW 08
0A6B: MOVWF 51
0A6C: MOVLW FA
0A6D: MOVWF 52
0A6E: BCF 0A.3
0A6F: CALL 1C8
0A70: BSF 0A.3
0A71: DECFSZ 51,F
0A72: GOTO 26C
.................... }
0A73: INCF 4E,F
0A74: GOTO 241
.................... Delay_ms(5000);
0A75: MOVLW 14
0A76: MOVWF 51
0A77: MOVLW FA
0A78: MOVWF 52
0A79: BCF 0A.3
0A7A: CALL 1C8
0A7B: BSF 0A.3
0A7C: DECFSZ 51,F
0A7D: GOTO 277
.................... set_pwm1_duty(0);
0A7E: CLRF 15
.................... set_pwm2_duty(0);
0A7F: CLRF 1B
.................... del_sms();
0A80: BCF 0A.3
0A81: CALL 374
0A82: BSF 0A.3
.................... break;
0A83: GOTO 532
.................... }
....................
.................... if (toupper(odp[0]) == 'F')
0A84: MOVF 26,W
0A85: SUBLW 60
0A86: BTFSC 03.0
0A87: GOTO 28F
0A88: MOVF 26,W
0A89: SUBLW 7A
0A8A: BTFSS 03.0
0A8B: GOTO 28F
0A8C: MOVF 26,W
0A8D: ANDLW DF
0A8E: GOTO 290
0A8F: MOVF 26,W
0A90: SUBLW 46
0A91: BTFSS 03.2
0A92: GOTO 2E3
.................... {
.................... set_pwm1_duty(VYKON);
0A93: MOVLW 64
0A94: MOVWF 15
.................... set_pwm2_duty(VYKON);
0A95: MOVWF 1B
.................... Delay_ms(10000);
0A96: MOVLW 28
0A97: MOVWF 51
0A98: MOVLW FA
0A99: MOVWF 52
0A9A: BCF 0A.3
0A9B: CALL 1C8
0A9C: BSF 0A.3
0A9D: DECFSZ 51,F
0A9E: GOTO 298
.................... for(n=0;n<=1;n++)
0A9F: CLRF 4E
0AA0: MOVF 4E,W
0AA1: SUBLW 01
0AA2: BTFSS 03.0
0AA3: GOTO 2D4
.................... {
.................... fprintf(VRTULE,"[ROZBITY[["); // " ROZBITY "
0AA4: CLRF 51
0AA5: MOVF 51,W
0AA6: BCF 0A.3
0AA7: CALL 0B7
0AA8: BSF 0A.3
0AA9: IORLW 00
0AAA: BTFSC 03.2
0AAB: GOTO 2B2
0AAC: INCF 51,F
0AAD: MOVWF 52
0AAE: BCF 0A.3
0AAF: CALL 348
0AB0: BSF 0A.3
0AB1: GOTO 2A5
.................... Delay_ms(2000);
0AB2: MOVLW 08
0AB3: MOVWF 51
0AB4: MOVLW FA
0AB5: MOVWF 52
0AB6: BCF 0A.3
0AB7: CALL 1C8
0AB8: BSF 0A.3
0AB9: DECFSZ 51,F
0ABA: GOTO 2B4
.................... fprintf(VRTULE,"[[BUDIK[[["); // " BUDIK "
0ABB: CLRF 51
0ABC: MOVF 51,W
0ABD: BCF 0A.3
0ABE: CALL 0C6
0ABF: BSF 0A.3
0AC0: IORLW 00
0AC1: BTFSC 03.2
0AC2: GOTO 2C9
0AC3: INCF 51,F
0AC4: MOVWF 52
0AC5: BCF 0A.3
0AC6: CALL 348
0AC7: BSF 0A.3
0AC8: GOTO 2BC
.................... Delay_ms(2000);
0AC9: MOVLW 08
0ACA: MOVWF 51
0ACB: MOVLW FA
0ACC: MOVWF 52
0ACD: BCF 0A.3
0ACE: CALL 1C8
0ACF: BSF 0A.3
0AD0: DECFSZ 51,F
0AD1: GOTO 2CB
.................... }
0AD2: INCF 4E,F
0AD3: GOTO 2A0
.................... Delay_ms(5000);
0AD4: MOVLW 14
0AD5: MOVWF 51
0AD6: MOVLW FA
0AD7: MOVWF 52
0AD8: BCF 0A.3
0AD9: CALL 1C8
0ADA: BSF 0A.3
0ADB: DECFSZ 51,F
0ADC: GOTO 2D6
.................... set_pwm1_duty(0);
0ADD: CLRF 15
.................... set_pwm2_duty(0);
0ADE: CLRF 1B
.................... del_sms();
0ADF: BCF 0A.3
0AE0: CALL 374
0AE1: BSF 0A.3
.................... break;
0AE2: GOTO 532
.................... }
....................
.................... if (toupper(odp[0]) == 'G')
0AE3: MOVF 26,W
0AE4: SUBLW 60
0AE5: BTFSC 03.0
0AE6: GOTO 2EE
0AE7: MOVF 26,W
0AE8: SUBLW 7A
0AE9: BTFSS 03.0
0AEA: GOTO 2EE
0AEB: MOVF 26,W
0AEC: ANDLW DF
0AED: GOTO 2EF
0AEE: MOVF 26,W
0AEF: SUBLW 47
0AF0: BTFSS 03.2
0AF1: GOTO 342
.................... {
.................... set_pwm1_duty(VYKON);
0AF2: MOVLW 64
0AF3: MOVWF 15
.................... set_pwm2_duty(VYKON);
0AF4: MOVWF 1B
.................... Delay_ms(10000);
0AF5: MOVLW 28
0AF6: MOVWF 51
0AF7: MOVLW FA
0AF8: MOVWF 52
0AF9: BCF 0A.3
0AFA: CALL 1C8
0AFB: BSF 0A.3
0AFC: DECFSZ 51,F
0AFD: GOTO 2F7
.................... for(n=0;n<=1;n++)
0AFE: CLRF 4E
0AFF: MOVF 4E,W
0B00: SUBLW 01
0B01: BTFSS 03.0
0B02: GOTO 333
.................... {
.................... fprintf(VRTULE,"[ZAPOJIT[["); // " ZAPOJIT "
0B03: CLRF 51
0B04: MOVF 51,W
0B05: BCF 0A.3
0B06: CALL 0D5
0B07: BSF 0A.3
0B08: IORLW 00
0B09: BTFSC 03.2
0B0A: GOTO 311
0B0B: INCF 51,F
0B0C: MOVWF 52
0B0D: BCF 0A.3
0B0E: CALL 348
0B0F: BSF 0A.3
0B10: GOTO 304
.................... Delay_ms(2000);
0B11: MOVLW 08
0B12: MOVWF 51
0B13: MOVLW FA
0B14: MOVWF 52
0B15: BCF 0A.3
0B16: CALL 1C8
0B17: BSF 0A.3
0B18: DECFSZ 51,F
0B19: GOTO 313
.................... fprintf(VRTULE,"[ZASUVKU[["); // " ZASUVKU "
0B1A: CLRF 51
0B1B: MOVF 51,W
0B1C: BCF 0A.3
0B1D: CALL 0E4
0B1E: BSF 0A.3
0B1F: IORLW 00
0B20: BTFSC 03.2
0B21: GOTO 328
0B22: INCF 51,F
0B23: MOVWF 52
0B24: BCF 0A.3
0B25: CALL 348
0B26: BSF 0A.3
0B27: GOTO 31B
.................... Delay_ms(2000);
0B28: MOVLW 08
0B29: MOVWF 51
0B2A: MOVLW FA
0B2B: MOVWF 52
0B2C: BCF 0A.3
0B2D: CALL 1C8
0B2E: BSF 0A.3
0B2F: DECFSZ 51,F
0B30: GOTO 32A
.................... }
0B31: INCF 4E,F
0B32: GOTO 2FF
.................... Delay_ms(5000);
0B33: MOVLW 14
0B34: MOVWF 51
0B35: MOVLW FA
0B36: MOVWF 52
0B37: BCF 0A.3
0B38: CALL 1C8
0B39: BSF 0A.3
0B3A: DECFSZ 51,F
0B3B: GOTO 335
.................... set_pwm1_duty(0);
0B3C: CLRF 15
.................... set_pwm2_duty(0);
0B3D: CLRF 1B
.................... del_sms();
0B3E: BCF 0A.3
0B3F: CALL 374
0B40: BSF 0A.3
.................... break;
0B41: GOTO 532
.................... }
....................
.................... if (toupper(odp[0]) == 'H')
0B42: MOVF 26,W
0B43: SUBLW 60
0B44: BTFSC 03.0
0B45: GOTO 34D
0B46: MOVF 26,W
0B47: SUBLW 7A
0B48: BTFSS 03.0
0B49: GOTO 34D
0B4A: MOVF 26,W
0B4B: ANDLW DF
0B4C: GOTO 34E
0B4D: MOVF 26,W
0B4E: SUBLW 48
0B4F: BTFSS 03.2
0B50: GOTO 3FD
.................... {
.................... set_pwm1_duty(VYKON);
0B51: MOVLW 64
0B52: MOVWF 15
.................... set_pwm2_duty(VYKON);
0B53: MOVWF 1B
.................... Delay_ms(10000);
0B54: MOVLW 28
0B55: MOVWF 51
0B56: MOVLW FA
0B57: MOVWF 52
0B58: BCF 0A.3
0B59: CALL 1C8
0B5A: BSF 0A.3
0B5B: DECFSZ 51,F
0B5C: GOTO 356
.................... for(n=0;n<=1;n++)
0B5D: CLRF 4E
0B5E: MOVF 4E,W
0B5F: SUBLW 01
0B60: BTFSS 03.0
0B61: GOTO 3EE
.................... {
.................... fprintf(VRTULE,"[[MARTIN[["); // " MARTIN "
0B62: CLRF 51
0B63: MOVF 51,W
0B64: BCF 0A.3
0B65: CALL 0F3
0B66: BSF 0A.3
0B67: IORLW 00
0B68: BTFSC 03.2
0B69: GOTO 370
0B6A: INCF 51,F
0B6B: MOVWF 52
0B6C: BCF 0A.3
0B6D: CALL 348
0B6E: BSF 0A.3
0B6F: GOTO 363
.................... Delay_ms(2000);
0B70: MOVLW 08
0B71: MOVWF 51
0B72: MOVLW FA
0B73: MOVWF 52
0B74: BCF 0A.3
0B75: CALL 1C8
0B76: BSF 0A.3
0B77: DECFSZ 51,F
0B78: GOTO 372
.................... fprintf(VRTULE,"[[SVEJDA[["); // " SVEJDA "
0B79: CLRF 51
0B7A: MOVF 51,W
0B7B: BCF 0A.3
0B7C: CALL 105
0B7D: BSF 0A.3
0B7E: IORLW 00
0B7F: BTFSC 03.2
0B80: GOTO 387
0B81: INCF 51,F
0B82: MOVWF 52
0B83: BCF 0A.3
0B84: CALL 348
0B85: BSF 0A.3
0B86: GOTO 37A
.................... Delay_ms(2000);
0B87: MOVLW 08
0B88: MOVWF 51
0B89: MOVLW FA
0B8A: MOVWF 52
0B8B: BCF 0A.3
0B8C: CALL 1C8
0B8D: BSF 0A.3
0B8E: DECFSZ 51,F
0B8F: GOTO 389
.................... fprintf(VRTULE,"[[TOMAS[[["); // " TOMAS "
0B90: CLRF 51
0B91: MOVF 51,W
0B92: BCF 0A.3
0B93: CALL 114
0B94: BSF 0A.3
0B95: IORLW 00
0B96: BTFSC 03.2
0B97: GOTO 39E
0B98: INCF 51,F
0B99: MOVWF 52
0B9A: BCF 0A.3
0B9B: CALL 348
0B9C: BSF 0A.3
0B9D: GOTO 391
.................... Delay_ms(2000);
0B9E: MOVLW 08
0B9F: MOVWF 51
0BA0: MOVLW FA
0BA1: MOVWF 52
0BA2: BCF 0A.3
0BA3: CALL 1C8
0BA4: BSF 0A.3
0BA5: DECFSZ 51,F
0BA6: GOTO 3A0
.................... fprintf(VRTULE,"[[[KAPL[[["); // "KAPL"
0BA7: CLRF 51
0BA8: MOVF 51,W
0BA9: BCF 0A.3
0BAA: CALL 123
0BAB: BSF 0A.3
0BAC: IORLW 00
0BAD: BTFSC 03.2
0BAE: GOTO 3B5
0BAF: INCF 51,F
0BB0: MOVWF 52
0BB1: BCF 0A.3
0BB2: CALL 348
0BB3: BSF 0A.3
0BB4: GOTO 3A8
.................... Delay_ms(2000);
0BB5: MOVLW 08
0BB6: MOVWF 51
0BB7: MOVLW FA
0BB8: MOVWF 52
0BB9: BCF 0A.3
0BBA: CALL 1C8
0BBB: BSF 0A.3
0BBC: DECFSZ 51,F
0BBD: GOTO 3B7
.................... fprintf(VRTULE,"[[JAKUB[[["); // " JAKUB "
0BBE: CLRF 51
0BBF: MOVF 51,W
0BC0: BCF 0A.3
0BC1: CALL 132
0BC2: BSF 0A.3
0BC3: IORLW 00
0BC4: BTFSC 03.2
0BC5: GOTO 3CC
0BC6: INCF 51,F
0BC7: MOVWF 52
0BC8: BCF 0A.3
0BC9: CALL 348
0BCA: BSF 0A.3
0BCB: GOTO 3BF
.................... Delay_ms(2000);
0BCC: MOVLW 08
0BCD: MOVWF 51
0BCE: MOVLW FA
0BCF: MOVWF 52
0BD0: BCF 0A.3
0BD1: CALL 1C8
0BD2: BSF 0A.3
0BD3: DECFSZ 51,F
0BD4: GOTO 3CE
.................... fprintf(VRTULE,"[[KAKONA[["); // "KAKONA"
0BD5: CLRF 51
0BD6: MOVF 51,W
0BD7: BCF 0A.3
0BD8: CALL 141
0BD9: BSF 0A.3
0BDA: IORLW 00
0BDB: BTFSC 03.2
0BDC: GOTO 3E3
0BDD: INCF 51,F
0BDE: MOVWF 52
0BDF: BCF 0A.3
0BE0: CALL 348
0BE1: BSF 0A.3
0BE2: GOTO 3D6
.................... Delay_ms(2000);
0BE3: MOVLW 08
0BE4: MOVWF 51
0BE5: MOVLW FA
0BE6: MOVWF 52
0BE7: BCF 0A.3
0BE8: CALL 1C8
0BE9: BSF 0A.3
0BEA: DECFSZ 51,F
0BEB: GOTO 3E5
.................... }
0BEC: INCF 4E,F
0BED: GOTO 35E
.................... Delay_ms(3000);
0BEE: MOVLW 0C
0BEF: MOVWF 51
0BF0: MOVLW FA
0BF1: MOVWF 52
0BF2: BCF 0A.3
0BF3: CALL 1C8
0BF4: BSF 0A.3
0BF5: DECFSZ 51,F
0BF6: GOTO 3F0
.................... set_pwm1_duty(0);
0BF7: CLRF 15
.................... set_pwm2_duty(0);
0BF8: CLRF 1B
.................... del_sms();
0BF9: BCF 0A.3
0BFA: CALL 374
0BFB: BSF 0A.3
.................... break;
0BFC: GOTO 532
.................... }
....................
.................... if (toupper(odp[0]) == 'I')
0BFD: MOVF 26,W
0BFE: SUBLW 60
0BFF: BTFSC 03.0
0C00: GOTO 408
0C01: MOVF 26,W
0C02: SUBLW 7A
0C03: BTFSS 03.0
0C04: GOTO 408
0C05: MOVF 26,W
0C06: ANDLW DF
0C07: GOTO 409
0C08: MOVF 26,W
0C09: SUBLW 49
0C0A: BTFSS 03.2
0C0B: GOTO 4A2
.................... {
.................... set_pwm1_duty(VYKON);
0C0C: MOVLW 64
0C0D: MOVWF 15
.................... set_pwm2_duty(VYKON);
0C0E: MOVWF 1B
.................... Delay_ms(10000);
0C0F: MOVLW 28
0C10: MOVWF 51
0C11: MOVLW FA
0C12: MOVWF 52
0C13: BCF 0A.3
0C14: CALL 1C8
0C15: BSF 0A.3
0C16: DECFSZ 51,F
0C17: GOTO 411
.................... for(n=0;n<=1;n++)
0C18: CLRF 4E
0C19: MOVF 4E,W
0C1A: SUBLW 01
0C1B: BTFSS 03.0
0C1C: GOTO 492
.................... {
.................... fprintf(VRTULE,"ODPOVED[NA"); // "ODPOVED NA"
0C1D: CLRF 51
0C1E: MOVF 51,W
0C1F: BCF 0A.3
0C20: CALL 150
0C21: BSF 0A.3
0C22: IORLW 00
0C23: BTFSC 03.2
0C24: GOTO 42B
0C25: INCF 51,F
0C26: MOVWF 52
0C27: BCF 0A.3
0C28: CALL 348
0C29: BSF 0A.3
0C2A: GOTO 41E
.................... Delay_ms(2000);
0C2B: MOVLW 08
0C2C: MOVWF 51
0C2D: MOVLW FA
0C2E: MOVWF 52
0C2F: BCF 0A.3
0C30: CALL 1C8
0C31: BSF 0A.3
0C32: DECFSZ 51,F
0C33: GOTO 42D
.................... fprintf(VRTULE,"[[VASI[[[["); // " VASI "
0C34: CLRF 51
0C35: MOVF 51,W
0C36: BCF 0A.3
0C37: CALL 15F
0C38: BSF 0A.3
0C39: IORLW 00
0C3A: BTFSC 03.2
0C3B: GOTO 442
0C3C: INCF 51,F
0C3D: MOVWF 52
0C3E: BCF 0A.3
0C3F: CALL 348
0C40: BSF 0A.3
0C41: GOTO 435
.................... Delay_ms(2000);
0C42: MOVLW 08
0C43: MOVWF 51
0C44: MOVLW FA
0C45: MOVWF 52
0C46: BCF 0A.3
0C47: CALL 1C8
0C48: BSF 0A.3
0C49: DECFSZ 51,F
0C4A: GOTO 444
.................... fprintf(VRTULE,"[[OTAZKU[["); // " OTAZKU "
0C4B: CLRF 51
0C4C: MOVF 51,W
0C4D: BCF 0A.3
0C4E: CALL 16E
0C4F: BSF 0A.3
0C50: IORLW 00
0C51: BTFSC 03.2
0C52: GOTO 459
0C53: INCF 51,F
0C54: MOVWF 52
0C55: BCF 0A.3
0C56: CALL 348
0C57: BSF 0A.3
0C58: GOTO 44C
.................... Delay_ms(2000);
0C59: MOVLW 08
0C5A: MOVWF 51
0C5B: MOVLW FA
0C5C: MOVWF 52
0C5D: BCF 0A.3
0C5E: CALL 1C8
0C5F: BSF 0A.3
0C60: DECFSZ 51,F
0C61: GOTO 45B
.................... fprintf(VRTULE,"[[[[JE[[[["); // "JE"
0C62: CLRF 51
0C63: MOVF 51,W
0C64: BCF 0A.3
0C65: CALL 17D
0C66: BSF 0A.3
0C67: IORLW 00
0C68: BTFSC 03.2
0C69: GOTO 470
0C6A: INCF 51,F
0C6B: MOVWF 52
0C6C: BCF 0A.3
0C6D: CALL 348
0C6E: BSF 0A.3
0C6F: GOTO 463
.................... Delay_ms(2000);
0C70: MOVLW 08
0C71: MOVWF 51
0C72: MOVLW FA
0C73: MOVWF 52
0C74: BCF 0A.3
0C75: CALL 1C8
0C76: BSF 0A.3
0C77: DECFSZ 51,F
0C78: GOTO 472
.................... fprintf(VRTULE,"[[[[ec[[[["); // " 42 "
0C79: CLRF 51
0C7A: MOVF 51,W
0C7B: BCF 0A.3
0C7C: CALL 18C
0C7D: BSF 0A.3
0C7E: IORLW 00
0C7F: BTFSC 03.2
0C80: GOTO 487
0C81: INCF 51,F
0C82: MOVWF 52
0C83: BCF 0A.3
0C84: CALL 348
0C85: BSF 0A.3
0C86: GOTO 47A
.................... Delay_ms(2000);
0C87: MOVLW 08
0C88: MOVWF 51
0C89: MOVLW FA
0C8A: MOVWF 52
0C8B: BCF 0A.3
0C8C: CALL 1C8
0C8D: BSF 0A.3
0C8E: DECFSZ 51,F
0C8F: GOTO 489
.................... }
0C90: INCF 4E,F
0C91: GOTO 419
.................... Delay_ms(3000);
0C92: MOVLW 0C
0C93: MOVWF 51
0C94: MOVLW FA
0C95: MOVWF 52
0C96: BCF 0A.3
0C97: CALL 1C8
0C98: BSF 0A.3
0C99: DECFSZ 51,F
0C9A: GOTO 494
.................... set_pwm1_duty(0);
0C9B: CLRF 15
.................... set_pwm2_duty(0);
0C9C: CLRF 1B
.................... del_sms();
0C9D: BCF 0A.3
0C9E: CALL 374
0C9F: BSF 0A.3
.................... break;
0CA0: GOTO 532
.................... }
.................... else
0CA1: GOTO 4F8
.................... {
.................... set_pwm1_duty(VYKON);
0CA2: MOVLW 64
0CA3: MOVWF 15
.................... set_pwm2_duty(VYKON);
0CA4: MOVWF 1B
.................... Delay_ms(10000);
0CA5: MOVLW 28
0CA6: MOVWF 51
0CA7: MOVLW FA
0CA8: MOVWF 52
0CA9: BCF 0A.3
0CAA: CALL 1C8
0CAB: BSF 0A.3
0CAC: DECFSZ 51,F
0CAD: GOTO 4A7
.................... fprintf(VRTULE,"[[NEUMIS[["); // "NEUMIS"
0CAE: CLRF 51
0CAF: MOVF 51,W
0CB0: BCF 0A.3
0CB1: CALL 19B
0CB2: BSF 0A.3
0CB3: IORLW 00
0CB4: BTFSC 03.2
0CB5: GOTO 4BC
0CB6: INCF 51,F
0CB7: MOVWF 52
0CB8: BCF 0A.3
0CB9: CALL 348
0CBA: BSF 0A.3
0CBB: GOTO 4AF
.................... Delay_ms(2000);
0CBC: MOVLW 08
0CBD: MOVWF 51
0CBE: MOVLW FA
0CBF: MOVWF 52
0CC0: BCF 0A.3
0CC1: CALL 1C8
0CC2: BSF 0A.3
0CC3: DECFSZ 51,F
0CC4: GOTO 4BE
.................... fprintf(VRTULE,"[[[PSAT[[["); // " PSAT "
0CC5: CLRF 51
0CC6: MOVF 51,W
0CC7: BCF 0A.3
0CC8: CALL 1AA
0CC9: BSF 0A.3
0CCA: IORLW 00
0CCB: BTFSC 03.2
0CCC: GOTO 4D3
0CCD: INCF 51,F
0CCE: MOVWF 52
0CCF: BCF 0A.3
0CD0: CALL 348
0CD1: BSF 0A.3
0CD2: GOTO 4C6
.................... Delay_ms(2000);
0CD3: MOVLW 08
0CD4: MOVWF 51
0CD5: MOVLW FA
0CD6: MOVWF 52
0CD7: BCF 0A.3
0CD8: CALL 1C8
0CD9: BSF 0A.3
0CDA: DECFSZ 51,F
0CDB: GOTO 4D5
.................... fprintf(VRTULE,"[[TRUBKO[["); // " TRUBKO "
0CDC: CLRF 51
0CDD: MOVF 51,W
0CDE: BCF 0A.3
0CDF: CALL 1B9
0CE0: BSF 0A.3
0CE1: IORLW 00
0CE2: BTFSC 03.2
0CE3: GOTO 4EA
0CE4: INCF 51,F
0CE5: MOVWF 52
0CE6: BCF 0A.3
0CE7: CALL 348
0CE8: BSF 0A.3
0CE9: GOTO 4DD
.................... Delay_ms(3000);
0CEA: MOVLW 0C
0CEB: MOVWF 51
0CEC: MOVLW FA
0CED: MOVWF 52
0CEE: BCF 0A.3
0CEF: CALL 1C8
0CF0: BSF 0A.3
0CF1: DECFSZ 51,F
0CF2: GOTO 4EC
.................... set_pwm1_duty(0);
0CF3: CLRF 15
.................... set_pwm2_duty(0);
0CF4: CLRF 1B
.................... del_sms();
0CF5: BCF 0A.3
0CF6: CALL 374
0CF7: BSF 0A.3
.................... }
.................... }
.................... read_time();
0CF8: BCF 0A.3
0CF9: GOTO 37F
0CFA: BSF 0A.3
.................... time=strtoul(odp,&ptr,10);
0CFB: MOVLW 26
0CFC: MOVWF 51
0CFD: MOVLW 4F
0CFE: MOVWF 52
0CFF: MOVLW 0A
0D00: MOVWF 53
0D01: BCF 0A.3
0D02: GOTO 3D2
0D03: BSF 0A.3
0D04: MOVF 78,W
0D05: MOVWF 50
.................... if((time >= 30 && time <= 32) || (time >= 0 && time <= 2) || (time >= 45 && time <= 47) || (time >= 15 && time <= 17))
0D06: MOVF 50,W
0D07: SUBLW 1D
0D08: BTFSC 03.0
0D09: GOTO 50E
0D0A: MOVF 50,W
0D0B: SUBLW 20
0D0C: BTFSC 03.0
0D0D: GOTO 522
0D0E: MOVF 50,W
0D0F: SUBLW 02
0D10: BTFSC 03.0
0D11: GOTO 522
0D12: MOVF 50,W
0D13: SUBLW 2C
0D14: BTFSC 03.0
0D15: GOTO 51A
0D16: MOVF 50,W
0D17: SUBLW 2F
0D18: BTFSC 03.0
0D19: GOTO 522
0D1A: MOVF 50,W
0D1B: SUBLW 0E
0D1C: BTFSC 03.0
0D1D: GOTO 526
0D1E: MOVF 50,W
0D1F: SUBLW 11
0D20: BTFSS 03.0
0D21: GOTO 526
.................... {
.................... set_pwm1_duty(VYKON);
0D22: MOVLW 64
0D23: MOVWF 15
.................... set_pwm2_duty(VYKON);
0D24: MOVWF 1B
.................... }
.................... else
0D25: GOTO 528
.................... {
.................... set_pwm1_duty(0);
0D26: CLRF 15
.................... set_pwm2_duty(0);
0D27: CLRF 1B
.................... }
....................
.................... delay_ms(1000);
0D28: MOVLW 04
0D29: MOVWF 51
0D2A: MOVLW FA
0D2B: MOVWF 52
0D2C: BCF 0A.3
0D2D: CALL 1C8
0D2E: BSF 0A.3
0D2F: DECFSZ 51,F
0D30: GOTO 52A
.................... }
0D31: GOTO 07B
.................... }
0D32: SLEEP
Configuration Fuses:
Word 1: 3F3E HS WDT NOPUT NODEBUG NOPROTECT NOBROWNOUT NOLVP NOCPD NOWRT