Blame | Last modification | View Log | Download
CCS PCW C Compiler, Version 3.110, 15448
Filename: d:\kaklik\programy\pic_c\roboti\merkur\main.LST
ROM used: 1572 (38%)
Largest free fragment is 2048
RAM used: 79 (41%) at main() level
90 (47%) worst case
Stack: 3 locations
*
0000: MOVLW 00
0001: MOVWF 0A
0002: GOTO 41D
0003: NOP
.................... #include "main.h"
.................... #include <16F873.h>
.................... //////// Standard Header file for the PIC16F873 device ////////////////
.................... #device PIC16F873
.................... #list
....................
.................... #device adc=8
.................... #use delay(clock=4000000)
*
0016: MOVLW 78
0017: MOVWF 04
0018: MOVLW FC
0019: ANDWF 00,F
001A: RRF 00,F
001B: RRF 00,F
001C: MOVF 00,W
001D: BTFSC 03.2
001E: GOTO 023
001F: GOTO 021
0020: NOP
0021: DECFSZ 00,F
0022: GOTO 020
0023: RETLW 00
*
004A: MOVLW 73
004B: MOVWF 04
004C: MOVF 00,W
004D: BTFSC 03.2
004E: GOTO 05E
004F: MOVLW 01
0050: MOVWF 21
0051: CLRF 20
0052: DECFSZ 20,F
0053: GOTO 052
0054: DECFSZ 21,F
0055: GOTO 051
0056: MOVLW 4A
0057: MOVWF 20
0058: DECFSZ 20,F
0059: GOTO 058
005A: NOP
005B: NOP
005C: DECFSZ 00,F
005D: GOTO 04F
005E: RETLW 00
.................... #fuses XT,NOWDT,NOLVP
....................
....................
....................
.................... #define TXo PIN_C3 // To the transmitter modulator
.................... #include "AX25.c" // podprogram pro prenos telemetrie
.................... //#define PTT PIN_A2 // PTT control
.................... //#define TXo PIN_C0 // To the transmitter modulator
.................... #define PERIODAH delay_us(222) // Halfperiod H 222;78/1200 500;430/500
.................... #define TAILH delay_us(78)
.................... #define PERIODAL delay_us(412) // Halfperiod L 412;345/1200 1000;880/500
.................... #define TAILL delay_us(345)
.................... #byte STATUS = 3 // CPUs status register
....................
.................... byte SendData[16] = {'A'<<1, 'L'<<1, 'L'<<1, ' '<<1, ' '<<1, ' '<<1, 0x60,
.................... 'C'<<1, 'Z'<<1, '0'<<1, 'R'<<1, 'R'<<1, 'R'<<1, 0x61,
.................... 0x03, 0xF0};
....................
.................... boolean bit;
.................... int fcslo, fcshi; // variabloes for calculating FCS (CRC)
.................... int stuff; // stuff counter for extra 0
.................... int flag_flag; // if it is sending flag (7E)
.................... int fcs_flag; // if it is sending Frame Check Sequence
.................... int i; // for for
....................
.................... void flipout() //flips the state of output pin a_1
.................... {
.................... stuff = 0; //since this is a 0, reset the stuff counter
*
00AE: CLRF 38
.................... if (bit)
00AF: BTFSS 35.0
00B0: GOTO 0B3
.................... {
.................... bit=FALSE; //if the state of the pin was low, make it high.
00B1: BCF 35.0
.................... }
.................... else
00B2: GOTO 0B4
.................... {
.................... bit=TRUE; //if the state of the pin was high make it low
00B3: BSF 35.0
.................... }
00B4: RETLW 00
.................... }
....................
.................... void fcsbit(byte tbyte)
.................... {
.................... #asm
.................... BCF STATUS,0
*
011A: BCF 03.0
.................... RRF fcshi,F // rotates the entire 16 bits
011B: RRF 37,F
.................... RRF fcslo,F // to the right
.................... #endasm
011C: RRF 36,F
.................... if (((STATUS & 0x01)^(tbyte)) ==0x01)
011D: MOVF 03,W
011E: ANDLW 01
011F: XORWF 77,W
0120: SUBLW 01
0121: BTFSS 03.2
0122: GOTO 127
.................... {
.................... fcshi = fcshi^0x84;
0123: MOVLW 84
0124: XORWF 37,F
.................... fcslo = fcslo^0x08;
0125: MOVLW 08
0126: XORWF 36,F
.................... }
.................... }
....................
.................... void SendBit ()
.................... {
.................... if (bit)
*
00B5: BTFSS 35.0
00B6: GOTO 0E8
.................... {
.................... output_high(TXo);
00B7: BCF 3C.3
00B8: MOVF 3C,W
00B9: BSF 03.5
00BA: MOVWF 07
00BB: BCF 03.5
00BC: BSF 07.3
.................... PERIODAH;
00BD: MOVLW 49
00BE: MOVWF 20
00BF: DECFSZ 20,F
00C0: GOTO 0BF
00C1: NOP
00C2: NOP
.................... output_low(TXo);
00C3: BCF 3C.3
00C4: MOVF 3C,W
00C5: BSF 03.5
00C6: MOVWF 07
00C7: BCF 03.5
00C8: BCF 07.3
.................... PERIODAH;
00C9: MOVLW 49
00CA: MOVWF 20
00CB: DECFSZ 20,F
00CC: GOTO 0CB
00CD: NOP
00CE: NOP
.................... output_high(TXo);
00CF: BCF 3C.3
00D0: MOVF 3C,W
00D1: BSF 03.5
00D2: MOVWF 07
00D3: BCF 03.5
00D4: BSF 07.3
.................... PERIODAH;
00D5: MOVLW 49
00D6: MOVWF 20
00D7: DECFSZ 20,F
00D8: GOTO 0D7
00D9: NOP
00DA: NOP
.................... output_low(TXo);
00DB: BCF 3C.3
00DC: MOVF 3C,W
00DD: BSF 03.5
00DE: MOVWF 07
00DF: BCF 03.5
00E0: BCF 07.3
.................... TAILH;
00E1: MOVLW 19
00E2: MOVWF 20
00E3: DECFSZ 20,F
00E4: GOTO 0E3
00E5: NOP
00E6: NOP
.................... }
.................... else
00E7: GOTO 0FE
.................... {
.................... output_high(TXo);
00E8: BCF 3C.3
00E9: MOVF 3C,W
00EA: BSF 03.5
00EB: MOVWF 07
00EC: BCF 03.5
00ED: BSF 07.3
.................... PERIODAL;
00EE: MOVLW 89
00EF: MOVWF 20
00F0: DECFSZ 20,F
00F1: GOTO 0F0
.................... output_low(TXo);
00F2: BCF 3C.3
00F3: MOVF 3C,W
00F4: BSF 03.5
00F5: MOVWF 07
00F6: BCF 03.5
00F7: BCF 07.3
.................... TAILL;
00F8: MOVLW 72
00F9: MOVWF 20
00FA: DECFSZ 20,F
00FB: GOTO 0FA
00FC: NOP
00FD: NOP
.................... };
00FE: RETLW 00
.................... }
....................
.................... void SendByte (byte inbyte)
.................... {
.................... int k, bt;
....................
.................... for (k=0;k<8;k++) //do the following for each of the 8 bits in the byte
00FF: CLRF 75
0100: MOVF 75,W
0101: SUBLW 07
0102: BTFSS 03.0
0103: GOTO 149
.................... {
.................... bt = inbyte & 0x01; //strip off the rightmost bit of the byte to be sent (inbyte)
0104: MOVF 74,W
0105: ANDLW 01
0106: MOVWF 76
.................... if ((fcs_flag == FALSE) & (flag_flag == FALSE)) fcsbit(bt); //do FCS calc, but only if this
0107: MOVF 3A,F
0108: BTFSC 03.2
0109: GOTO 10C
010A: MOVLW 00
010B: GOTO 10D
010C: MOVLW 01
010D: MOVWF 77
010E: MOVF 39,F
010F: BTFSC 03.2
0110: GOTO 113
0111: MOVLW 00
0112: GOTO 114
0113: MOVLW 01
0114: ANDWF 77,W
0115: XORLW 00
0116: BTFSC 03.2
0117: GOTO 127
0118: MOVF 76,W
0119: MOVWF 77
.................... //is not a flag or fcs byte
.................... if (bt == 0)
*
0127: MOVF 76,F
0128: BTFSS 03.2
0129: GOTO 12C
.................... {
.................... flipout();
012A: CALL 0AE
.................... } // if this bit is a zero, flip the output state
.................... else
012B: GOTO 144
.................... { //otherwise if it is a 1, do the following:
.................... if (flag_flag == FALSE) stuff++; //increment the count of consequtive 1's
012C: MOVF 39,F
012D: BTFSS 03.2
012E: GOTO 130
012F: INCF 38,F
.................... if ((flag_flag == FALSE) & (stuff == 5))
0130: MOVF 39,F
0131: BTFSC 03.2
0132: GOTO 135
0133: MOVLW 00
0134: GOTO 136
0135: MOVLW 01
0136: MOVWF 77
0137: MOVF 38,W
0138: SUBLW 05
0139: BTFSC 03.2
013A: GOTO 13D
013B: MOVLW 00
013C: GOTO 13E
013D: MOVLW 01
013E: ANDWF 77,W
013F: XORLW 00
0140: BTFSC 03.2
0141: GOTO 144
.................... { //stuff an extra 0, if 5 1's in a row
.................... SendBit();
0142: CALL 0B5
.................... flipout(); //flip the output state to stuff a 0
0143: CALL 0AE
.................... }//end of if
.................... }//end of else
.................... // delay_us(850); //introduces a delay that creates 1200 baud
.................... SendBit();
0144: CALL 0B5
.................... inbyte = inbyte>>1; //go to the next bit in the byte
0145: BCF 03.0
0146: RRF 74,F
.................... }//end of for
0147: INCF 75,F
0148: GOTO 100
0149: RETLW 00
.................... }//end of SendByte
....................
.................... void SendPacket(char *data)
.................... {
.................... bit=FALSE;
*
02CF: BCF 35.0
....................
.................... fcslo=fcshi=0xFF; //The 2 FCS Bytes are initialized to FF
02D0: MOVLW FF
02D1: MOVWF 37
02D2: MOVWF 36
.................... stuff = 0; //The variable stuff counts the number of 1's in a row. When it gets to 5
02D3: CLRF 38
.................... // it is time to stuff a 0.
....................
.................... // output_low(PTT); // Blinking LED
.................... // delay_ms(1000);
.................... // output_high(PTT);
....................
.................... flag_flag = TRUE; //The variable flag is true if you are transmitted flags (7E's) false otherwise.
02D4: MOVLW 01
02D5: MOVWF 39
.................... fcs_flag = FALSE; //The variable fcsflag is true if you are transmitting FCS bytes, false otherwise.
02D6: CLRF 3A
....................
.................... for(i=0; i<10; i++) SendByte(0x7E); //Sends flag bytes. Adjust length for txdelay
02D7: CLRF 3B
02D8: MOVF 3B,W
02D9: SUBLW 09
02DA: BTFSS 03.0
02DB: GOTO 2E1
02DC: MOVLW 7E
02DD: MOVWF 74
02DE: CALL 0FF
02DF: INCF 3B,F
02E0: GOTO 2D8
.................... //each flag takes approx 6.7 ms
.................... flag_flag = FALSE; //done sending flags
02E1: CLRF 39
....................
.................... for(i=0; i<16; i++) SendByte(SendData[i]); //send the packet bytes
02E2: CLRF 3B
02E3: MOVF 3B,W
02E4: SUBLW 0F
02E5: BTFSS 03.0
02E6: GOTO 2F0
02E7: MOVLW 25
02E8: ADDWF 3B,W
02E9: MOVWF 04
02EA: MOVF 00,W
02EB: MOVWF 73
02EC: MOVWF 74
02ED: CALL 0FF
02EE: INCF 3B,F
02EF: GOTO 2E3
....................
.................... for(i=0; 0 != *data; i++)
02F0: CLRF 3B
02F1: MOVF 72,W
02F2: MOVWF 04
02F3: MOVF 00,W
02F4: XORLW 00
02F5: BTFSC 03.2
02F6: GOTO 300
.................... {
.................... SendByte(*data); //send the packet bytes
02F7: MOVF 72,W
02F8: MOVWF 04
02F9: MOVF 00,W
02FA: MOVWF 73
02FB: MOVWF 74
02FC: CALL 0FF
.................... data++;
02FD: INCF 72,F
.................... };
02FE: INCF 3B,F
02FF: GOTO 2F1
....................
.................... fcs_flag = TRUE; //about to send the FCS bytes
0300: MOVLW 01
0301: MOVWF 3A
.................... fcslo =fcslo^0xff; //must XOR them with FF before sending
0302: MOVLW FF
0303: XORWF 36,F
.................... fcshi = fcshi^0xff;
0304: XORWF 37,F
.................... SendByte(fcslo); //send the low byte of fcs
0305: MOVF 36,W
0306: MOVWF 74
0307: CALL 0FF
.................... SendByte(fcshi); //send the high byte of fcs
0308: MOVF 37,W
0309: MOVWF 74
030A: CALL 0FF
.................... fcs_flag = FALSE; //done sending FCS
030B: CLRF 3A
.................... flag_flag = TRUE; //about to send flags
030C: MOVLW 01
030D: MOVWF 39
.................... SendByte(0x7e); // Send a flag to end packet
030E: MOVLW 7E
030F: MOVWF 74
0310: CALL 0FF
.................... }
....................
....................
....................
....................
....................
.................... //motory //Napred vypnout potom zapnout!
.................... #define FR output_low(PIN_B5); output_high(PIN_B4) // Vpred
.................... #define FL output_low(PIN_B7); output_high(PIN_B6)
.................... #define BR output_low(PIN_B4); output_high(PIN_B5) // Vzad
.................... #define BL output_low(PIN_B6); output_high(PIN_B7)
.................... #define STOPR output_low(PIN_B4);output_low(PIN_B5)
.................... #define STOPL output_low(PIN_B6);output_low(PIN_B7)
....................
.................... #define L 0b10 // left
.................... #define R 0b01 // right
.................... #define S 0b11 // straight
....................
.................... #define COUVANI 1600 // couvnuti po zjisteni diry
.................... #define MEZERA 5400 // za jak dlouho bude ztracena cara
.................... #define PRES_DIRU 400 // velikost mezery v care
.................... #define ODEZVA 1 // za jak dlouho po opusteni cary se ma zacit zatacet
.................... #define BRZDENI 100 // doba (v ms) ptrebna k zastaveni jednoho motoru
....................
.................... //cidla
.................... #define RSENSOR 1 // Senzory na caru
.................... #define LSENSOR 0
.................... #define BUMPER PIN_C4 // sensor na cihlu
....................
.................... #define DIAG_SERVO PIN_B0 // Propojka pro diagnosticky mod
.................... #define DIAG_SENSORS PIN_B1 // Propojka pro diagnosticky mod
....................
.................... #DEFINE SOUND_HI PIN_B3
.................... #DEFINE SOUND_LO PIN_B2
....................
.................... char AXstring[40]; // Buffer pro prenos telemetrie
....................
.................... int tresholdL; // rozhodovaci uroven pro prave cidlo
.................... int tresholdR; // rozhodovaci uroven pro prave cidlo
.................... int movement; // smer minuleho pohybu
.................... int line; // na ktere strane byla detekovana cara
.................... unsigned int16 dira; // pocitadlo pro nalezeni preruseni cary
....................
.................... // Primitivni Pipani
.................... void beep(unsigned int16 period, unsigned int16 length)
.................... {
.................... unsigned int16 nn;
....................
.................... for(nn=length; nn>0; nn--)
*
0024: MOVF 75,W
0025: MOVWF 77
0026: MOVF 74,W
0027: MOVWF 76
0028: MOVF 76,F
0029: BTFSS 03.2
002A: GOTO 02E
002B: MOVF 77,F
002C: BTFSC 03.2
002D: GOTO 049
.................... {
.................... output_high(SOUND_HI);output_low(SOUND_LO);
002E: BSF 03.5
002F: BCF 06.3
0030: BCF 03.5
0031: BSF 06.3
0032: BSF 03.5
0033: BCF 06.2
0034: BCF 03.5
0035: BCF 06.2
.................... delay_us(period);
0036: MOVF 72,W
0037: MOVWF 78
0038: CALL 016
.................... output_high(SOUND_LO);output_low(SOUND_HI);
0039: BSF 03.5
003A: BCF 06.2
003B: BCF 03.5
003C: BSF 06.2
003D: BSF 03.5
003E: BCF 06.3
003F: BCF 03.5
0040: BCF 06.3
.................... delay_us(period);
0041: MOVF 72,W
0042: MOVWF 78
0043: CALL 016
.................... }
0044: MOVF 76,W
0045: BTFSC 03.2
0046: DECF 77,F
0047: DECF 76,F
0048: GOTO 028
0049: RETLW 00
.................... }
....................
.................... // Diagnostika pohonu, hejbne vsema motorama ve vsech smerech
.................... void diagnostika()
.................... {
.................... unsigned int16 n;
....................
.................... while (input(DIAG_SERVO)) // Propojka, ktera spousti diagnostiku
*
014A: BSF 03.5
014B: BSF 06.0
014C: BCF 03.5
014D: BTFSS 06.0
014E: GOTO 275
.................... {
.................... for (n=500; n<800; n+=100)
014F: MOVLW 01
0150: MOVWF 6F
0151: MOVLW F4
0152: MOVWF 6E
0153: MOVF 6F,W
0154: SUBLW 03
0155: BTFSS 03.0
0156: GOTO 16B
0157: BTFSS 03.2
0158: GOTO 15D
0159: MOVF 6E,W
015A: SUBLW 1F
015B: BTFSS 03.0
015C: GOTO 16B
.................... {
.................... beep(n,n); //beep UP
015D: MOVF 6F,W
015E: MOVWF 73
015F: MOVF 6E,W
0160: MOVWF 72
0161: MOVF 6F,W
0162: MOVWF 75
0163: MOVF 6E,W
0164: MOVWF 74
0165: CALL 024
.................... };
0166: MOVLW 64
0167: ADDWF 6E,F
0168: BTFSC 03.0
0169: INCF 6F,F
016A: GOTO 153
.................... Delay_ms(1000);
016B: MOVLW 04
016C: MOVWF 72
016D: MOVLW FA
016E: MOVWF 73
016F: CALL 04A
0170: DECFSZ 72,F
0171: GOTO 16D
.................... //zastav vse
.................... STOPL; STOPR;
0172: BSF 03.5
0173: BCF 06.6
0174: BCF 03.5
0175: BCF 06.6
0176: BSF 03.5
0177: BCF 06.7
0178: BCF 03.5
0179: BCF 06.7
017A: BSF 03.5
017B: BCF 06.4
017C: BCF 03.5
017D: BCF 06.4
017E: BSF 03.5
017F: BCF 06.5
0180: BCF 03.5
0181: BCF 06.5
.................... //pravy pas
.................... FR; Delay_ms(1000); STOPR; Delay_ms(1000);
0182: BSF 03.5
0183: BCF 06.5
0184: BCF 03.5
0185: BCF 06.5
0186: BSF 03.5
0187: BCF 06.4
0188: BCF 03.5
0189: BSF 06.4
018A: MOVLW 04
018B: MOVWF 72
018C: MOVLW FA
018D: MOVWF 73
018E: CALL 04A
018F: DECFSZ 72,F
0190: GOTO 18C
0191: BSF 03.5
0192: BCF 06.4
0193: BCF 03.5
0194: BCF 06.4
0195: BSF 03.5
0196: BCF 06.5
0197: BCF 03.5
0198: BCF 06.5
0199: MOVLW 04
019A: MOVWF 72
019B: MOVLW FA
019C: MOVWF 73
019D: CALL 04A
019E: DECFSZ 72,F
019F: GOTO 19B
.................... BR; Delay_ms(1000); STOPR; Delay_ms(1000);
01A0: BSF 03.5
01A1: BCF 06.4
01A2: BCF 03.5
01A3: BCF 06.4
01A4: BSF 03.5
01A5: BCF 06.5
01A6: BCF 03.5
01A7: BSF 06.5
01A8: MOVLW 04
01A9: MOVWF 72
01AA: MOVLW FA
01AB: MOVWF 73
01AC: CALL 04A
01AD: DECFSZ 72,F
01AE: GOTO 1AA
01AF: BSF 03.5
01B0: BCF 06.4
01B1: BCF 03.5
01B2: BCF 06.4
01B3: BSF 03.5
01B4: BCF 06.5
01B5: BCF 03.5
01B6: BCF 06.5
01B7: MOVLW 04
01B8: MOVWF 72
01B9: MOVLW FA
01BA: MOVWF 73
01BB: CALL 04A
01BC: DECFSZ 72,F
01BD: GOTO 1B9
.................... Beep(880,100); Delay_ms(1000);
01BE: MOVLW 03
01BF: MOVWF 73
01C0: MOVLW 70
01C1: MOVWF 72
01C2: CLRF 75
01C3: MOVLW 64
01C4: MOVWF 74
01C5: CALL 024
01C6: MOVLW 04
01C7: MOVWF 72
01C8: MOVLW FA
01C9: MOVWF 73
01CA: CALL 04A
01CB: DECFSZ 72,F
01CC: GOTO 1C8
.................... //levy pas
.................... FL; Delay_ms(1000); STOPL; Delay_ms(1000);
01CD: BSF 03.5
01CE: BCF 06.7
01CF: BCF 03.5
01D0: BCF 06.7
01D1: BSF 03.5
01D2: BCF 06.6
01D3: BCF 03.5
01D4: BSF 06.6
01D5: MOVLW 04
01D6: MOVWF 72
01D7: MOVLW FA
01D8: MOVWF 73
01D9: CALL 04A
01DA: DECFSZ 72,F
01DB: GOTO 1D7
01DC: BSF 03.5
01DD: BCF 06.6
01DE: BCF 03.5
01DF: BCF 06.6
01E0: BSF 03.5
01E1: BCF 06.7
01E2: BCF 03.5
01E3: BCF 06.7
01E4: MOVLW 04
01E5: MOVWF 72
01E6: MOVLW FA
01E7: MOVWF 73
01E8: CALL 04A
01E9: DECFSZ 72,F
01EA: GOTO 1E6
.................... BL; Delay_ms(1000); STOPL; Delay_ms(1000);
01EB: BSF 03.5
01EC: BCF 06.6
01ED: BCF 03.5
01EE: BCF 06.6
01EF: BSF 03.5
01F0: BCF 06.7
01F1: BCF 03.5
01F2: BSF 06.7
01F3: MOVLW 04
01F4: MOVWF 72
01F5: MOVLW FA
01F6: MOVWF 73
01F7: CALL 04A
01F8: DECFSZ 72,F
01F9: GOTO 1F5
01FA: BSF 03.5
01FB: BCF 06.6
01FC: BCF 03.5
01FD: BCF 06.6
01FE: BSF 03.5
01FF: BCF 06.7
0200: BCF 03.5
0201: BCF 06.7
0202: MOVLW 04
0203: MOVWF 72
0204: MOVLW FA
0205: MOVWF 73
0206: CALL 04A
0207: DECFSZ 72,F
0208: GOTO 204
.................... Beep(880,100); Delay_ms(1000);
0209: MOVLW 03
020A: MOVWF 73
020B: MOVLW 70
020C: MOVWF 72
020D: CLRF 75
020E: MOVLW 64
020F: MOVWF 74
0210: CALL 024
0211: MOVLW 04
0212: MOVWF 72
0213: MOVLW FA
0214: MOVWF 73
0215: CALL 04A
0216: DECFSZ 72,F
0217: GOTO 213
.................... //oba pasy
.................... FL; FR; Delay_ms(1000); STOPL; STOPR; Delay_ms(1000);
0218: BSF 03.5
0219: BCF 06.7
021A: BCF 03.5
021B: BCF 06.7
021C: BSF 03.5
021D: BCF 06.6
021E: BCF 03.5
021F: BSF 06.6
0220: BSF 03.5
0221: BCF 06.5
0222: BCF 03.5
0223: BCF 06.5
0224: BSF 03.5
0225: BCF 06.4
0226: BCF 03.5
0227: BSF 06.4
0228: MOVLW 04
0229: MOVWF 72
022A: MOVLW FA
022B: MOVWF 73
022C: CALL 04A
022D: DECFSZ 72,F
022E: GOTO 22A
022F: BSF 03.5
0230: BCF 06.6
0231: BCF 03.5
0232: BCF 06.6
0233: BSF 03.5
0234: BCF 06.7
0235: BCF 03.5
0236: BCF 06.7
0237: BSF 03.5
0238: BCF 06.4
0239: BCF 03.5
023A: BCF 06.4
023B: BSF 03.5
023C: BCF 06.5
023D: BCF 03.5
023E: BCF 06.5
023F: MOVLW 04
0240: MOVWF 72
0241: MOVLW FA
0242: MOVWF 73
0243: CALL 04A
0244: DECFSZ 72,F
0245: GOTO 241
.................... BL; BR; Delay_ms(1000); STOPL; STOPR; Delay_ms(1000);
0246: BSF 03.5
0247: BCF 06.6
0248: BCF 03.5
0249: BCF 06.6
024A: BSF 03.5
024B: BCF 06.7
024C: BCF 03.5
024D: BSF 06.7
024E: BSF 03.5
024F: BCF 06.4
0250: BCF 03.5
0251: BCF 06.4
0252: BSF 03.5
0253: BCF 06.5
0254: BCF 03.5
0255: BSF 06.5
0256: MOVLW 04
0257: MOVWF 72
0258: MOVLW FA
0259: MOVWF 73
025A: CALL 04A
025B: DECFSZ 72,F
025C: GOTO 258
025D: BSF 03.5
025E: BCF 06.6
025F: BCF 03.5
0260: BCF 06.6
0261: BSF 03.5
0262: BCF 06.7
0263: BCF 03.5
0264: BCF 06.7
0265: BSF 03.5
0266: BCF 06.4
0267: BCF 03.5
0268: BCF 06.4
0269: BSF 03.5
026A: BCF 06.5
026B: BCF 03.5
026C: BCF 06.5
026D: MOVLW 04
026E: MOVWF 72
026F: MOVLW FA
0270: MOVWF 73
0271: CALL 04A
0272: DECFSZ 72,F
0273: GOTO 26F
.................... };
0274: GOTO 14A
....................
.................... while (input(DIAG_SENSORS))
0275: BSF 03.5
0276: BSF 06.1
0277: BCF 03.5
0278: BTFSS 06.1
0279: GOTO 319
.................... {
.................... int ls, rs;
.................... while(!input(BUMPER)){beep(1100,100); Delay_ms(50);}
027A: BSF 3C.4
027B: MOVF 3C,W
027C: BSF 03.5
027D: MOVWF 07
027E: BCF 03.5
027F: BTFSC 07.4
0280: GOTO 28D
0281: MOVLW 04
0282: MOVWF 73
0283: MOVLW 4C
0284: MOVWF 72
0285: CLRF 75
0286: MOVLW 64
0287: MOVWF 74
0288: CALL 024
0289: MOVLW 32
028A: MOVWF 73
028B: CALL 04A
028C: GOTO 27A
.................... set_adc_channel(RSENSOR);
028D: MOVLW 08
028E: MOVWF 21
028F: MOVF 1F,W
0290: ANDLW C7
0291: IORWF 21,W
0292: MOVWF 1F
.................... Delay_us(20);
0293: MOVLW 06
0294: MOVWF 20
0295: DECFSZ 20,F
0296: GOTO 295
0297: NOP
.................... rs=read_adc();
0298: BSF 1F.2
0299: BTFSC 1F.2
029A: GOTO 299
029B: MOVF 1E,W
029C: MOVWF 71
.................... set_adc_channel(LSENSOR);
029D: MOVLW 00
029E: MOVWF 21
029F: MOVF 1F,W
02A0: ANDLW C7
02A1: IORWF 21,W
02A2: MOVWF 1F
.................... Delay_us(20);
02A3: MOVLW 06
02A4: MOVWF 20
02A5: DECFSZ 20,F
02A6: GOTO 2A5
02A7: NOP
.................... ls=read_adc();
02A8: BSF 1F.2
02A9: BTFSC 1F.2
02AA: GOTO 2A9
02AB: MOVF 1E,W
02AC: MOVWF 70
.................... sprintf(AXstring,"L: %U R: %U\0", ls, rs); // Convert DATA to String.
*
0004: BCF 0A.0
0005: BCF 0A.1
0006: BCF 0A.2
0007: ADDWF 02,F
0008: RETLW 4C
0009: RETLW 3A
000A: RETLW 20
000B: RETLW 25
000C: RETLW 55
000D: RETLW 20
000E: RETLW 20
000F: RETLW 52
0010: RETLW 3A
0011: RETLW 20
0012: RETLW 25
0013: RETLW 55
0014: RETLW 00
0015: RETLW 00
*
007C: MOVF 21,W
007D: MOVF 73,W
007E: MOVWF 75
007F: MOVLW 64
0080: MOVWF 76
0081: CALL 067
0082: MOVF 20,W
0083: MOVWF 73
0084: MOVF 21,W
0085: MOVLW 30
0086: BTFSS 03.2
0087: GOTO 08F
0088: BTFSC 74.0
0089: BSF 74.3
008A: BTFSC 74.3
008B: GOTO 095
008C: BTFSC 74.4
008D: MOVLW 20
008E: GOTO 091
008F: BCF 74.3
0090: BCF 74.4
0091: ADDWF 21,F
0092: MOVF 21,W
0093: MOVWF 75
0094: CALL 05F
0095: MOVF 73,W
0096: MOVWF 75
0097: MOVLW 0A
0098: MOVWF 76
0099: CALL 067
009A: MOVF 20,W
009B: MOVWF 73
009C: MOVF 21,W
009D: MOVLW 30
009E: BTFSS 03.2
009F: GOTO 0A4
00A0: BTFSC 74.3
00A1: GOTO 0A8
00A2: BTFSC 74.4
00A3: MOVLW 20
00A4: ADDWF 21,F
00A5: MOVF 21,W
00A6: MOVWF 75
00A7: CALL 05F
00A8: MOVLW 30
00A9: ADDWF 73,F
00AA: MOVF 73,W
00AB: MOVWF 75
00AC: CALL 05F
00AD: RETLW 00
*
02AD: MOVLW 3D
02AE: MOVWF 6B
02AF: MOVLW 4C
02B0: MOVWF 75
02B1: CALL 05F
02B2: MOVLW 3A
02B3: MOVWF 75
02B4: CALL 05F
02B5: MOVLW 20
02B6: MOVWF 75
02B7: CALL 05F
02B8: MOVF 70,W
02B9: MOVWF 73
02BA: MOVLW 18
02BB: MOVWF 74
02BC: CALL 07C
02BD: MOVLW 05
02BE: MOVWF 72
02BF: MOVF 72,W
02C0: CALL 004
02C1: INCF 72,F
02C2: MOVWF 75
02C3: CALL 05F
02C4: MOVLW 0A
02C5: SUBWF 72,W
02C6: BTFSS 03.2
02C7: GOTO 2BF
02C8: MOVF 71,W
02C9: MOVWF 73
02CA: MOVLW 18
02CB: MOVWF 74
02CC: CALL 07C
.................... SendPacket(&AXstring[0]);
02CD: MOVLW 3D
02CE: MOVWF 72
.................... delay_ms(1000);
*
0311: MOVLW 04
0312: MOVWF 72
0313: MOVLW FA
0314: MOVWF 73
0315: CALL 04A
0316: DECFSZ 72,F
0317: GOTO 313
.................... };
0318: GOTO 275
0319: BCF 0A.3
031A: GOTO 45E (RETURN)
.................... }
....................
.................... void cikcak()
.................... {
.................... int n;
.................... switch(movement) // podivej se na jednu stranu
*
0364: MOVLW 01
0365: SUBWF 67,W
0366: ADDLW FD
0367: BTFSC 03.0
0368: GOTO 3A4
0369: ADDLW 03
036A: GOTO 410
.................... {
.................... case L:
.................... FL;BR;
036B: BSF 03.5
036C: BCF 06.7
036D: BCF 03.5
036E: BCF 06.7
036F: BSF 03.5
0370: BCF 06.6
0371: BCF 03.5
0372: BSF 06.6
0373: BSF 03.5
0374: BCF 06.4
0375: BCF 03.5
0376: BCF 06.4
0377: BSF 03.5
0378: BCF 06.5
0379: BCF 03.5
037A: BSF 06.5
.................... movement=R;
037B: MOVLW 01
037C: MOVWF 67
.................... break;
037D: GOTO 3A4
.................... case R:
.................... FR;BL;
037E: BSF 03.5
037F: BCF 06.5
0380: BCF 03.5
0381: BCF 06.5
0382: BSF 03.5
0383: BCF 06.4
0384: BCF 03.5
0385: BSF 06.4
0386: BSF 03.5
0387: BCF 06.6
0388: BCF 03.5
0389: BCF 06.6
038A: BSF 03.5
038B: BCF 06.7
038C: BCF 03.5
038D: BSF 06.7
.................... movement=L;
038E: MOVLW 02
038F: MOVWF 67
.................... break;
0390: GOTO 3A4
.................... case S:
.................... FR;BL;
0391: BSF 03.5
0392: BCF 06.5
0393: BCF 03.5
0394: BCF 06.5
0395: BSF 03.5
0396: BCF 06.4
0397: BCF 03.5
0398: BSF 06.4
0399: BSF 03.5
039A: BCF 06.6
039B: BCF 03.5
039C: BCF 06.6
039D: BSF 03.5
039E: BCF 06.7
039F: BCF 03.5
03A0: BSF 06.7
.................... movement=L;
03A1: MOVLW 02
03A2: MOVWF 67
.................... break;
03A3: GOTO 3A4
.................... }
*
0410: BCF 0A.0
0411: BCF 0A.1
0412: BSF 0A.2
0413: ADDWF 02,F
0414: GOTO 37E
0415: GOTO 36B
0416: GOTO 391
.................... set_adc_channel(LSENSOR);
*
03A4: MOVLW 00
03A5: MOVWF 21
03A6: MOVF 1F,W
03A7: ANDLW C7
03A8: IORWF 21,W
03A9: MOVWF 1F
.................... Delay_us(10);
03AA: MOVLW 03
03AB: MOVWF 20
03AC: DECFSZ 20,F
03AD: GOTO 3AC
.................... while (tresholdL < read_adc()) // je tam cara??
03AE: BSF 1F.2
03AF: BTFSC 1F.2
03B0: GOTO 3AF
03B1: MOVF 1E,W
03B2: SUBWF 65,W
03B3: BTFSC 03.0
03B4: GOTO 3FC
.................... {
.................... if (n==50) // asi bude na druhe strane
03B5: MOVF 6E,W
03B6: SUBLW 32
03B7: BTFSS 03.2
03B8: GOTO 3F7
.................... {
.................... STOPR;STOPL;
03B9: BSF 03.5
03BA: BCF 06.4
03BB: BCF 03.5
03BC: BCF 06.4
03BD: BSF 03.5
03BE: BCF 06.5
03BF: BCF 03.5
03C0: BCF 06.5
03C1: BSF 03.5
03C2: BCF 06.6
03C3: BCF 03.5
03C4: BCF 06.6
03C5: BSF 03.5
03C6: BCF 06.7
03C7: BCF 03.5
03C8: BCF 06.7
.................... n=0;
03C9: CLRF 6E
.................... switch(movement)
03CA: MOVLW 01
03CB: SUBWF 67,W
03CC: ADDLW FE
03CD: BTFSC 03.0
03CE: GOTO 3F7
03CF: ADDLW 02
03D0: GOTO 417
.................... {
.................... case L:
.................... FL;BR;
03D1: BSF 03.5
03D2: BCF 06.7
03D3: BCF 03.5
03D4: BCF 06.7
03D5: BSF 03.5
03D6: BCF 06.6
03D7: BCF 03.5
03D8: BSF 06.6
03D9: BSF 03.5
03DA: BCF 06.4
03DB: BCF 03.5
03DC: BCF 06.4
03DD: BSF 03.5
03DE: BCF 06.5
03DF: BCF 03.5
03E0: BSF 06.5
.................... movement=R;
03E1: MOVLW 01
03E2: MOVWF 67
.................... break;
03E3: GOTO 3F7
.................... case R:
.................... FR;BL;
03E4: BSF 03.5
03E5: BCF 06.5
03E6: BCF 03.5
03E7: BCF 06.5
03E8: BSF 03.5
03E9: BCF 06.4
03EA: BCF 03.5
03EB: BSF 06.4
03EC: BSF 03.5
03ED: BCF 06.6
03EE: BCF 03.5
03EF: BCF 06.6
03F0: BSF 03.5
03F1: BCF 06.7
03F2: BCF 03.5
03F3: BSF 06.7
.................... movement=L;
03F4: MOVLW 02
03F5: MOVWF 67
.................... break;
03F6: GOTO 3F7
.................... }
*
0417: BCF 0A.0
0418: BCF 0A.1
0419: BSF 0A.2
041A: ADDWF 02,F
041B: GOTO 3E4
041C: GOTO 3D1
.................... }
.................... Delay_ms(5);
*
03F7: MOVLW 05
03F8: MOVWF 73
03F9: CALL 04A
.................... n++;
03FA: INCF 6E,F
.................... }
03FB: GOTO 3AE
.................... STOPL;STOPR; // nasli jsme caru
03FC: BSF 03.5
03FD: BCF 06.6
03FE: BCF 03.5
03FF: BCF 06.6
0400: BSF 03.5
0401: BCF 06.7
0402: BCF 03.5
0403: BCF 06.7
0404: BSF 03.5
0405: BCF 06.4
0406: BCF 03.5
0407: BCF 06.4
0408: BSF 03.5
0409: BCF 06.5
040A: BCF 03.5
040B: BCF 06.5
.................... line=S;
040C: MOVLW 03
040D: MOVWF 68
040E: BCF 0A.3
040F: GOTO 610 (RETURN)
.................... }
.................... void objizdka()
.................... {
.................... BL;BR;Delay_ms(300);
*
031B: BSF 03.5
031C: BCF 06.6
031D: BCF 03.5
031E: BCF 06.6
031F: BSF 03.5
0320: BCF 06.7
0321: BCF 03.5
0322: BSF 06.7
0323: BSF 03.5
0324: BCF 06.4
0325: BCF 03.5
0326: BCF 06.4
0327: BSF 03.5
0328: BCF 06.5
0329: BCF 03.5
032A: BSF 06.5
032B: MOVLW 02
032C: MOVWF 6E
032D: MOVLW 96
032E: MOVWF 73
032F: CALL 04A
0330: DECFSZ 6E,F
0331: GOTO 32D
.................... STOPR;STOPL;
0332: BSF 03.5
0333: BCF 06.4
0334: BCF 03.5
0335: BCF 06.4
0336: BSF 03.5
0337: BCF 06.5
0338: BCF 03.5
0339: BCF 06.5
033A: BSF 03.5
033B: BCF 06.6
033C: BCF 03.5
033D: BCF 06.6
033E: BSF 03.5
033F: BCF 06.7
0340: BCF 03.5
0341: BCF 06.7
.................... beep(1000,1000);
0342: MOVLW 03
0343: MOVWF 73
0344: MOVLW E8
0345: MOVWF 72
0346: MOVLW 03
0347: MOVWF 75
0348: MOVLW E8
0349: MOVWF 74
034A: CALL 024
.................... Delay_ms(500);
034B: MOVLW 02
034C: MOVWF 6E
034D: MOVLW FA
034E: MOVWF 73
034F: CALL 04A
0350: DECFSZ 6E,F
0351: GOTO 34D
.................... beep(1000,1000);
0352: MOVLW 03
0353: MOVWF 73
0354: MOVLW E8
0355: MOVWF 72
0356: MOVLW 03
0357: MOVWF 75
0358: MOVLW E8
0359: MOVWF 74
035A: CALL 024
.................... Delay_ms(1000);
035B: MOVLW 04
035C: MOVWF 6E
035D: MOVLW FA
035E: MOVWF 73
035F: CALL 04A
0360: DECFSZ 6E,F
0361: GOTO 35D
0362: BCF 0A.3
0363: GOTO 48A (RETURN)
....................
.................... }
.................... void kalibrace()
.................... {
.................... unsigned int16 i;
.................... int min;
.................... int max;
.................... int current;
.................... int treshold;
....................
.................... FL; BR; Delay_ms(130);
.................... chyba1:
.................... FR; BL; //kalibrace leveho cidla
.................... set_adc_channel(LSENSOR);
.................... Delay_us(20);
.................... min=max=read_adc();
.................... for (i=1;i<=500;i++)
.................... {
.................... current=read_adc();
.................... if (max < current) max=current;
.................... if (min > current) min=current;
.................... Delay_us(500);
.................... }
.................... FL; BR;
.................... for (i=1;i<=500;i++)
.................... {
.................... current=read_adc();
.................... if (max < current) max=current;
.................... if (min > current) min=current;
.................... Delay_us(500);
.................... }
.................... STOPL; STOPR; Delay_ms(200);
.................... if((max-min)<50) {Beep(1000,300); GOTO chyba1;}
.................... treshold=(max-min)>>1;
.................... tresholdL=treshold+min;
....................
.................... chyba2:
.................... FR; BL;
.................... set_adc_channel(RSENSOR);
.................... Delay_us(20);
.................... min=max=read_adc(); //naplneni min a max nejakou rozumnou hodnotou
.................... for (i=1;i<=500 ;i++)
.................... {
.................... current=read_adc();
.................... if (max < current) max=current; //zmereni minima a maxima
.................... if (min > current) min=current;
.................... Delay_us(500);
.................... }
.................... FL; BR;
.................... for (i=1;i<=500 ;i++)
.................... {
.................... current=read_adc();
.................... if (max < current) max=current; //zmereni minima a maxima
.................... if (min > current) min=current;
.................... Delay_us(500);
.................... }
.................... STOPL; STOPR; Delay_ms(200);
.................... if((max-min)<50) {Beep(1000,300); GOTO chyba2;}
.................... treshold=(max-min)>>1;
.................... tresholdR=treshold+min;
....................
.................... FR; BL;
.................... movement=L;
.................... set_adc_channel(LSENSOR);
.................... Delay_us(20);
.................... while (tresholdL < read_adc()) Delay_us(100);
.................... FL; BR; Delay_ms(50);
.................... STOPL; STOPR; Delay_ms(500);
.................... Beep(780,200);
.................... }
....................
.................... void main()
.................... {
.................... unsigned int16 rovne; // pocita delku rovne cary
*
041D: CLRF 04
041E: MOVLW 1F
041F: ANDWF 03,F
0420: MOVLW 07
0421: BSF 03.5
0422: MOVWF 1F
0423: MOVLW 82
0424: BCF 03.5
0425: MOVWF 25
0426: MOVLW 98
0427: MOVWF 26
0428: MOVWF 27
0429: MOVLW 40
042A: MOVWF 28
042B: MOVWF 29
042C: MOVWF 2A
042D: MOVLW 60
042E: MOVWF 2B
042F: MOVLW 86
0430: MOVWF 2C
0431: MOVLW B4
0432: MOVWF 2D
0433: MOVLW 60
0434: MOVWF 2E
0435: MOVLW A4
0436: MOVWF 2F
0437: MOVWF 30
0438: MOVWF 31
0439: MOVLW 61
043A: MOVWF 32
043B: MOVLW 03
043C: MOVWF 33
043D: MOVLW F0
043E: MOVWF 34
043F: MOVLW FF
0440: MOVWF 3C
0441: CLRF 6B
....................
.................... STOPL; STOPR;
0442: BSF 03.5
0443: BCF 06.6
0444: BCF 03.5
0445: BCF 06.6
0446: BSF 03.5
0447: BCF 06.7
0448: BCF 03.5
0449: BCF 06.7
044A: BSF 03.5
044B: BCF 06.4
044C: BCF 03.5
044D: BCF 06.4
044E: BSF 03.5
044F: BCF 06.5
0450: BCF 03.5
0451: BCF 06.5
....................
.................... setup_adc_ports(RA0_RA1_RA3_ANALOG);
0452: MOVLW 04
0453: BSF 03.5
0454: MOVWF 1F
.................... setup_adc(ADC_CLOCK_DIV_2);
0455: BCF 03.5
0456: MOVF 1F,W
0457: ANDLW 38
0458: IORLW 01
0459: MOVWF 1F
....................
.................... port_b_pullups(false);
045A: BSF 03.5
045B: BSF 01.7
....................
.................... diagnostika();
045C: BCF 03.5
045D: GOTO 14A
....................
.................... Beep(1000,200); //double beep
045E: MOVLW 03
045F: MOVWF 73
0460: MOVLW E8
0461: MOVWF 72
0462: CLRF 75
0463: MOVLW C8
0464: MOVWF 74
0465: CALL 024
.................... Delay_ms(50);
0466: MOVLW 32
0467: MOVWF 73
0468: CALL 04A
.................... Beep(1000,200);
0469: MOVLW 03
046A: MOVWF 73
046B: MOVLW E8
046C: MOVWF 72
046D: CLRF 75
046E: MOVLW C8
046F: MOVWF 74
0470: CALL 024
.................... Delay_ms(1000); // 1s
0471: MOVLW 04
0472: MOVWF 6E
0473: MOVLW FA
0474: MOVWF 73
0475: CALL 04A
0476: DECFSZ 6E,F
0477: GOTO 473
....................
.................... // kalibrace();
.................... tresholdl=tresholdr=80;
0478: MOVLW 50
0479: MOVWF 66
047A: MOVWF 65
.................... // FL; FR;
.................... movement=S;
047B: MOVLW 03
047C: MOVWF 67
.................... line=S;
047D: MOVWF 68
.................... dira=0;
047E: CLRF 6A
047F: CLRF 69
.................... rovne=0;
0480: CLRF 6D
0481: CLRF 6C
....................
.................... while(true)
.................... {
.................... if(!input(BUMPER)) objizdka();
0482: BSF 3C.4
0483: MOVF 3C,W
0484: BSF 03.5
0485: MOVWF 07
0486: BCF 03.5
0487: BTFSC 07.4
0488: GOTO 48A
0489: GOTO 31B
.................... line=0;
048A: CLRF 68
.................... set_adc_channel(RSENSOR); // podivej se jestli neni cara pod pravym cidlem
048B: MOVLW 08
048C: MOVWF 21
048D: MOVF 1F,W
048E: ANDLW C7
048F: IORWF 21,W
0490: MOVWF 1F
.................... Delay_us(10);
0491: MOVLW 03
0492: MOVWF 20
0493: DECFSZ 20,F
0494: GOTO 493
.................... if(tresholdR > read_adc())
0495: BSF 1F.2
0496: BTFSC 1F.2
0497: GOTO 496
0498: MOVF 1E,W
0499: SUBWF 66,W
049A: BTFSC 03.2
049B: GOTO 4A2
049C: BTFSS 03.0
049D: GOTO 4A2
.................... {
.................... dira=0;
049E: CLRF 6A
049F: CLRF 69
.................... line=R;
04A0: MOVLW 01
04A1: MOVWF 68
.................... }
.................... set_adc_channel(LSENSOR); // kdyz cara nebyla pod pravym cidlem, mozna bude pod levym
04A2: MOVLW 00
04A3: MOVWF 21
04A4: MOVF 1F,W
04A5: ANDLW C7
04A6: IORWF 21,W
04A7: MOVWF 1F
.................... Delay_us(10);
04A8: MOVLW 03
04A9: MOVWF 20
04AA: DECFSZ 20,F
04AB: GOTO 4AA
.................... if(tresholdL > read_adc())
04AC: BSF 1F.2
04AD: BTFSC 1F.2
04AE: GOTO 4AD
04AF: MOVF 1E,W
04B0: SUBWF 65,W
04B1: BTFSC 03.2
04B2: GOTO 4B8
04B3: BTFSS 03.0
04B4: GOTO 4B8
.................... {
.................... dira=0;
04B5: CLRF 6A
04B6: CLRF 69
.................... line=line | L;
04B7: BSF 68.1
.................... }
....................
.................... switch(line)
04B8: MOVF 68,W
04B9: MOVWF 20
04BA: MOVLW 03
04BB: SUBWF 20,W
04BC: BTFSC 03.2
04BD: GOTO 4C7
04BE: MOVLW 02
04BF: SUBWF 20,W
04C0: BTFSC 03.2
04C1: GOTO 4DA
04C2: MOVLW 01
04C3: SUBWF 20,W
04C4: BTFSC 03.2
04C5: GOTO 4ED
04C6: GOTO 500
.................... {
.................... case S:
.................... FR;FL;
04C7: BSF 03.5
04C8: BCF 06.5
04C9: BCF 03.5
04CA: BCF 06.5
04CB: BSF 03.5
04CC: BCF 06.4
04CD: BCF 03.5
04CE: BSF 06.4
04CF: BSF 03.5
04D0: BCF 06.7
04D1: BCF 03.5
04D2: BCF 06.7
04D3: BSF 03.5
04D4: BCF 06.6
04D5: BCF 03.5
04D6: BSF 06.6
.................... movement=S;
04D7: MOVLW 03
04D8: MOVWF 67
.................... continue;
04D9: GOTO 482
.................... case L:
.................... STOPL;
04DA: BSF 03.5
04DB: BCF 06.6
04DC: BCF 03.5
04DD: BCF 06.6
04DE: BSF 03.5
04DF: BCF 06.7
04E0: BCF 03.5
04E1: BCF 06.7
.................... FR;movement=L;
04E2: BSF 03.5
04E3: BCF 06.5
04E4: BCF 03.5
04E5: BCF 06.5
04E6: BSF 03.5
04E7: BCF 06.4
04E8: BCF 03.5
04E9: BSF 06.4
04EA: MOVLW 02
04EB: MOVWF 67
.................... continue;
04EC: GOTO 482
.................... case R:
.................... STOPR;
04ED: BSF 03.5
04EE: BCF 06.4
04EF: BCF 03.5
04F0: BCF 06.4
04F1: BSF 03.5
04F2: BCF 06.5
04F3: BCF 03.5
04F4: BCF 06.5
.................... FL;movement=R;
04F5: BSF 03.5
04F6: BCF 06.7
04F7: BCF 03.5
04F8: BCF 06.7
04F9: BSF 03.5
04FA: BCF 06.6
04FB: BCF 03.5
04FC: BSF 06.6
04FD: MOVLW 01
04FE: MOVWF 67
.................... continue;
04FF: GOTO 482
.................... default:
.................... }
....................
.................... if (dira==ODEZVA) // kdyz uz chvili jedeme po bile plose
0500: DECFSZ 69,W
0501: GOTO 54A
0502: MOVF 6A,F
0503: BTFSS 03.2
0504: GOTO 54A
.................... {
.................... //BR;BL;Delay_us(rovne >>= 5);
.................... rovne=0; //kdyz sme museli zatocit, uz neni rovna cara
0505: CLRF 6D
0506: CLRF 6C
....................
.................... switch (line) // musime zatocit
0507: MOVLW 01
0508: SUBWF 68,W
0509: ADDLW FE
050A: BTFSC 03.0
050B: GOTO 54A
050C: ADDLW 02
050D: GOTO 617
.................... {
.................... case L:
.................... BL;Delay_ms(BRZDENI);STOPL;
050E: BSF 03.5
050F: BCF 06.6
0510: BCF 03.5
0511: BCF 06.6
0512: BSF 03.5
0513: BCF 06.7
0514: BCF 03.5
0515: BSF 06.7
0516: MOVLW 64
0517: MOVWF 73
0518: CALL 04A
0519: BSF 03.5
051A: BCF 06.6
051B: BCF 03.5
051C: BCF 06.6
051D: BSF 03.5
051E: BCF 06.7
051F: BCF 03.5
0520: BCF 06.7
.................... FR;
0521: BSF 03.5
0522: BCF 06.5
0523: BCF 03.5
0524: BCF 06.5
0525: BSF 03.5
0526: BCF 06.4
0527: BCF 03.5
0528: BSF 06.4
.................... movement=L;
0529: MOVLW 02
052A: MOVWF 67
.................... break;
052B: GOTO 54A
.................... case R:
.................... BR;Delay_ms(BRZDENI);STOPR;
052C: BSF 03.5
052D: BCF 06.4
052E: BCF 03.5
052F: BCF 06.4
0530: BSF 03.5
0531: BCF 06.5
0532: BCF 03.5
0533: BSF 06.5
0534: MOVLW 64
0535: MOVWF 73
0536: CALL 04A
0537: BSF 03.5
0538: BCF 06.4
0539: BCF 03.5
053A: BCF 06.4
053B: BSF 03.5
053C: BCF 06.5
053D: BCF 03.5
053E: BCF 06.5
.................... FL;
053F: BSF 03.5
0540: BCF 06.7
0541: BCF 03.5
0542: BCF 06.7
0543: BSF 03.5
0544: BCF 06.6
0545: BCF 03.5
0546: BSF 06.6
.................... movement=R;
0547: MOVLW 01
0548: MOVWF 67
.................... break;
0549: GOTO 54A
.................... }
*
0617: BCF 0A.0
0618: BSF 0A.1
0619: BSF 0A.2
061A: ADDWF 02,F
061B: GOTO 52C
061C: GOTO 50E
.................... }
.................... if (dira==MEZERA) // kdyz zkoncila cara
*
054A: MOVF 69,W
054B: SUBLW 18
054C: BTFSS 03.2
054D: GOTO 612
054E: MOVF 6A,W
054F: SUBLW 15
0550: BTFSS 03.2
0551: GOTO 612
.................... {
.................... beep(800,500);
0552: MOVLW 03
0553: MOVWF 73
0554: MOVLW 20
0555: MOVWF 72
0556: MOVLW 01
0557: MOVWF 75
0558: MOVLW F4
0559: MOVWF 74
055A: CALL 024
.................... Delay_ms(50);
055B: MOVLW 32
055C: MOVWF 73
055D: CALL 04A
.................... beep(800,500);
055E: MOVLW 03
055F: MOVWF 73
0560: MOVLW 20
0561: MOVWF 72
0562: MOVLW 01
0563: MOVWF 75
0564: MOVLW F4
0565: MOVWF 74
0566: CALL 024
.................... switch (movement) //vrat se zpet na caru
0567: MOVLW 01
0568: SUBWF 67,W
0569: ADDLW FD
056A: BTFSC 03.0
056B: GOTO 5E6
056C: ADDLW 03
056D: GOTO 61D
.................... {
.................... case L:
.................... STOPL;STOPR;
056E: BSF 03.5
056F: BCF 06.6
0570: BCF 03.5
0571: BCF 06.6
0572: BSF 03.5
0573: BCF 06.7
0574: BCF 03.5
0575: BCF 06.7
0576: BSF 03.5
0577: BCF 06.4
0578: BCF 03.5
0579: BCF 06.4
057A: BSF 03.5
057B: BCF 06.5
057C: BCF 03.5
057D: BCF 06.5
.................... BR;Delay_ms(COUVANI);STOPR;
057E: BSF 03.5
057F: BCF 06.4
0580: BCF 03.5
0581: BCF 06.4
0582: BSF 03.5
0583: BCF 06.5
0584: BCF 03.5
0585: BSF 06.5
0586: MOVLW 08
0587: MOVWF 6E
0588: MOVLW C8
0589: MOVWF 73
058A: CALL 04A
058B: DECFSZ 6E,F
058C: GOTO 588
058D: BSF 03.5
058E: BCF 06.4
058F: BCF 03.5
0590: BCF 06.4
0591: BSF 03.5
0592: BCF 06.5
0593: BCF 03.5
0594: BCF 06.5
.................... break;
0595: GOTO 5E6
.................... case R:
.................... STOPL;STOPR;
0596: BSF 03.5
0597: BCF 06.6
0598: BCF 03.5
0599: BCF 06.6
059A: BSF 03.5
059B: BCF 06.7
059C: BCF 03.5
059D: BCF 06.7
059E: BSF 03.5
059F: BCF 06.4
05A0: BCF 03.5
05A1: BCF 06.4
05A2: BSF 03.5
05A3: BCF 06.5
05A4: BCF 03.5
05A5: BCF 06.5
.................... BL;Delay_ms(COUVANI);STOPL;
05A6: BSF 03.5
05A7: BCF 06.6
05A8: BCF 03.5
05A9: BCF 06.6
05AA: BSF 03.5
05AB: BCF 06.7
05AC: BCF 03.5
05AD: BSF 06.7
05AE: MOVLW 08
05AF: MOVWF 6E
05B0: MOVLW C8
05B1: MOVWF 73
05B2: CALL 04A
05B3: DECFSZ 6E,F
05B4: GOTO 5B0
05B5: BSF 03.5
05B6: BCF 06.6
05B7: BCF 03.5
05B8: BCF 06.6
05B9: BSF 03.5
05BA: BCF 06.7
05BB: BCF 03.5
05BC: BCF 06.7
.................... break;
05BD: GOTO 5E6
.................... case S:
.................... BL; BR; Delay_ms(COUVANI);
05BE: BSF 03.5
05BF: BCF 06.6
05C0: BCF 03.5
05C1: BCF 06.6
05C2: BSF 03.5
05C3: BCF 06.7
05C4: BCF 03.5
05C5: BSF 06.7
05C6: BSF 03.5
05C7: BCF 06.4
05C8: BCF 03.5
05C9: BCF 06.4
05CA: BSF 03.5
05CB: BCF 06.5
05CC: BCF 03.5
05CD: BSF 06.5
05CE: MOVLW 08
05CF: MOVWF 6E
05D0: MOVLW C8
05D1: MOVWF 73
05D2: CALL 04A
05D3: DECFSZ 6E,F
05D4: GOTO 5D0
.................... STOPL; STOPR;
05D5: BSF 03.5
05D6: BCF 06.6
05D7: BCF 03.5
05D8: BCF 06.6
05D9: BSF 03.5
05DA: BCF 06.7
05DB: BCF 03.5
05DC: BCF 06.7
05DD: BSF 03.5
05DE: BCF 06.4
05DF: BCF 03.5
05E0: BCF 06.4
05E1: BSF 03.5
05E2: BCF 06.5
05E3: BCF 03.5
05E4: BCF 06.5
.................... break;
05E5: GOTO 5E6
.................... }
*
061D: BCF 0A.0
061E: BSF 0A.1
061F: BSF 0A.2
0620: ADDWF 02,F
0621: GOTO 596
0622: GOTO 56E
0623: GOTO 5BE
....................
.................... FR;FL; Delay_ms(PRES_DIRU); // popojedem dopredu mozna tam bude cara
*
05E6: BSF 03.5
05E7: BCF 06.5
05E8: BCF 03.5
05E9: BCF 06.5
05EA: BSF 03.5
05EB: BCF 06.4
05EC: BCF 03.5
05ED: BSF 06.4
05EE: BSF 03.5
05EF: BCF 06.7
05F0: BCF 03.5
05F1: BCF 06.7
05F2: BSF 03.5
05F3: BCF 06.6
05F4: BCF 03.5
05F5: BSF 06.6
05F6: MOVLW 02
05F7: MOVWF 6E
05F8: MOVLW C8
05F9: MOVWF 73
05FA: CALL 04A
05FB: DECFSZ 6E,F
05FC: GOTO 5F8
.................... STOPL; STOPR; movement=S;
05FD: BSF 03.5
05FE: BCF 06.6
05FF: BCF 03.5
0600: BCF 06.6
0601: BSF 03.5
0602: BCF 06.7
0603: BCF 03.5
0604: BCF 06.7
0605: BSF 03.5
0606: BCF 06.4
0607: BCF 03.5
0608: BCF 06.4
0609: BSF 03.5
060A: BCF 06.5
060B: BCF 03.5
060C: BCF 06.5
060D: MOVLW 03
060E: MOVWF 67
.................... cikcak(); // najdi caru
060F: GOTO 364
.................... dira=0;
0610: CLRF 6A
0611: CLRF 69
.................... }
.................... dira++;
0612: INCF 69,F
0613: BTFSC 03.2
0614: INCF 6A,F
.................... } // while(true)
0615: GOTO 482
.................... }
....................
0616: SLEEP