Subversion Repositories svnkaklik

Rev

Go to most recent revision | Blame | Last modification | View Log | Download

CCS PCM C Compiler, Version 3.221, 27853               26-IV-05 01:36

               Filename: D:\KAKLIK\programy\PIC_C\roboti\merkur\PIC16F88\tank.LST

               ROM used: 2140 words (52%)
                         Largest free fragment is 1570
               RAM used: 89 (51%) at main() level
                         101 (58%) worst case
               Stack:    4 worst case (3 in main + 1 for interrupts)

*
0000:  MOVLW  08
0001:  MOVWF  0A
0002:  GOTO   000
0003:  NOP
0004:  MOVWF  7F
0005:  SWAPF  03,W
0006:  CLRF   03
0007:  MOVWF  21
0008:  MOVF   7F,W
0009:  MOVWF  20
000A:  MOVF   0A,W
000B:  MOVWF  28
000C:  CLRF   0A
000D:  SWAPF  20,F
000E:  MOVF   04,W
000F:  MOVWF  22
0010:  MOVF   77,W
0011:  MOVWF  23
0012:  MOVF   78,W
0013:  MOVWF  24
0014:  MOVF   79,W
0015:  MOVWF  25
0016:  MOVF   7A,W
0017:  MOVWF  26
0018:  MOVF   7B,W
0019:  MOVWF  27
001A:  BCF    03.7
001B:  BCF    03.5
001C:  MOVLW  8C
001D:  MOVWF  04
001E:  BTFSS  00.1
001F:  GOTO   022
0020:  BTFSC  0C.1
0021:  GOTO   035
0022:  MOVF   22,W
0023:  MOVWF  04
0024:  MOVF   23,W
0025:  MOVWF  77
0026:  MOVF   24,W
0027:  MOVWF  78
0028:  MOVF   25,W
0029:  MOVWF  79
002A:  MOVF   26,W
002B:  MOVWF  7A
002C:  MOVF   27,W
002D:  MOVWF  7B
002E:  MOVF   28,W
002F:  MOVWF  0A
0030:  SWAPF  21,W
0031:  MOVWF  03
0032:  SWAPF  7F,F
0033:  SWAPF  7F,W
0034:  RETFIE
0035:  BCF    0A.3
0036:  GOTO   049
....................  #include "tank.h" 
....................  #include <16F88.h> 
....................  //////// Standard Header file for the PIC16F88 device ////////////////  
.................... #device PIC16F88  
.................... #list  
....................  
.................... #device adc=8  
.................... #fuses NOWDT,INTRC_IO, NOPUT, MCLR, NOBROWNOUT, NOLVP, NOCPD, NOWRT, NODEBUG, NOPROTECT, NOFCMEN, NOIESO  
.................... #use delay(clock=4000000)  
*
005C:  MOVLW  12
005D:  BSF    03.5
005E:  SUBWF  24,F
005F:  BTFSS  03.0
0060:  GOTO   06F
0061:  MOVLW  A4
0062:  MOVWF  04
0063:  MOVLW  FC
0064:  ANDWF  00,F
0065:  BCF    03.0
0066:  RRF    00,F
0067:  RRF    00,F
0068:  MOVF   00,W
0069:  BTFSC  03.2
006A:  GOTO   06F
006B:  GOTO   06D
006C:  NOP
006D:  DECFSZ 00,F
006E:  GOTO   06C
006F:  BCF    03.5
0070:  RETLW  00
*
009D:  MOVLW  7D
009E:  MOVWF  04
009F:  MOVF   00,W
00A0:  BTFSC  03.2
00A1:  GOTO   0B1
00A2:  MOVLW  01
00A3:  MOVWF  78
00A4:  CLRF   77
00A5:  DECFSZ 77,F
00A6:  GOTO   0A5
00A7:  DECFSZ 78,F
00A8:  GOTO   0A4
00A9:  MOVLW  4A
00AA:  MOVWF  77
00AB:  DECFSZ 77,F
00AC:  GOTO   0AB
00AD:  NOP
00AE:  NOP
00AF:  DECFSZ 00,F
00B0:  GOTO   0A2
00B1:  RETLW  00
....................   
....................  
....................   
.................... #define DEBUG  
....................   
.................... #define  TXo PIN_A3           // To the transmitter modulator  
.................... #include "AX25.c"             // podprogram pro prenos telemetrie 
.................... #list  
....................  
....................   
.................... unsigned int8 sensors;        // pomocna promenna pro cteni cidel na caru  
.................... unsigned int8 line;           // na ktere strane byla detekovana cara  
.................... unsigned int8 speed;          // rychlost zataceni  
.................... unsigned int8 rovinka;        // pocitadlo pro zjisteni rovneho useku  
.................... unsigned int8 last;           // kde byla cara, kdyz byly minule cidla mimo  
.................... unsigned int8 movement;       // obsahuje aktualni smer zataceni  
.................... unsigned int8 dira;           // pocita dobu po kterou je ztracena cara  
.................... unsigned int8 cihla;          // urcuje za jak dlouho muze byt znova detekovana cihla  
....................   
.................... // Konstanty pro dynamiku pohybu  
.................... #define T_DIRA       85      // po jakem case zataceni se detekuje dira  
.................... #define INC_SPEED    1        // prirustek rychlosti v jednom kroku  
.................... #define FW_POMALU    230      // trochu mimo caru vnitrni pas  
.................... #define FW_ZATACKA   200      // rychlost vnejsiho kola pri zataceni  
.................... #define FW_STREDNE   240      // trochu mimo caru vnejsi pas  
.................... #define COUVANI      600      // couvnuti zpet na caru, po detekci diry  
.................... #define PRES_DIRU    150  
.................... #define MAX_ROVINKA  (255-FW_STREDNE)  
.................... #define TRESHOLD     10        // rozhodovaci uroven komparatoru, 0xF = 0.75*Vdd  
.................... #define BUMPER_TRESHOLD 128  
.................... #define CIK_CAK      20000  
.................... #define T_CIHLA      100      // perioda detekce cihly  
....................   
.................... //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)    // Zastav  
.................... #define STOPL      output_low(PIN_B6);output_low(PIN_B7)  
....................   
.................... #define L 0b10  // left  
.................... #define R 0b01  // right  
.................... #define S 0b11  // straight  
....................   
.................... //cidla  
.................... #define RSENSOR    C2OUT      // Senzory na caru  
.................... #define LSENSOR    C1OUT  
.................... #define BUMPER     PIN_A4     // Senzor na cihlu  
....................   
.................... #define DIAG_SERVO      PIN_B3   // Propojka pro diagnosticky mod  
.................... #define DIAG_SENSORS    PIN_B2   // Propojka pro diagnosticky mod  
....................   
.................... #DEFINE SOUND_HI   PIN_A6     // komplementarni vystupy pro piezo pipak  
.................... #DEFINE SOUND_LO   PIN_A7  
....................   
.................... char AXstring[40];   // Buffer pro prenos telemetrie  
....................   
.................... // makro pro PWM  
.................... #define GO(motor, direction, power) if(get_timer0()<=power) \  
.................... {direction##motor;} else {stop##motor;}  
....................   
.................... #int_TIMER2  
.................... void TIMER2_isr()  
.................... {  
....................    if (speed<255) speed+=INC_SPEED;  
*
0049:  INCFSZ 42,W
004A:  GOTO   04C
004B:  GOTO   04E
004C:  MOVLW  01
004D:  ADDWF  42,F
....................    if (rovinka<MAX_ROVINKA) rovinka++;  
004E:  MOVF   43,W
004F:  SUBLW  0E
0050:  BTFSC  03.0
0051:  INCF   43,F
....................    if (dira<=T_DIRA) dira++;  
0052:  MOVF   46,W
0053:  SUBLW  55
0054:  BTFSC  03.0
0055:  INCF   46,F
....................    if (cihla>0) cihla--;  
0056:  MOVF   47,F
0057:  BTFSS  03.2
0058:  DECF   47,F
.................... }  
.................... // Primitivni Pipani  
0059:  BCF    0C.1
005A:  BCF    0A.3
005B:  GOTO   022
.................... void beep(unsigned int16 period, unsigned int16 length)  
.................... {  
....................    unsigned int16 nn;  
....................   
....................    for(nn=length; nn>0; nn--)  
*
0071:  BSF    03.5
0072:  MOVF   21,W
0073:  MOVWF  23
0074:  MOVF   20,W
0075:  MOVWF  22
0076:  MOVF   22,F
0077:  BTFSS  03.2
0078:  GOTO   07C
0079:  MOVF   23,F
007A:  BTFSC  03.2
007B:  GOTO   09B
....................    {  
....................      output_high(SOUND_HI);output_low(SOUND_LO);  
007C:  BCF    05.6
007D:  BCF    03.5
007E:  BSF    05.6
007F:  BSF    03.5
0080:  BCF    05.7
0081:  BCF    03.5
0082:  BCF    05.7
....................      delay_us(period);  
0083:  MOVF   7C,W
0084:  BSF    03.5
0085:  MOVWF  24
0086:  BCF    03.5
0087:  CALL   05C
....................      output_high(SOUND_LO);output_low(SOUND_HI);  
0088:  BSF    03.5
0089:  BCF    05.7
008A:  BCF    03.5
008B:  BSF    05.7
008C:  BSF    03.5
008D:  BCF    05.6
008E:  BCF    03.5
008F:  BCF    05.6
....................      delay_us(period);  
0090:  MOVF   7C,W
0091:  BSF    03.5
0092:  MOVWF  24
0093:  BCF    03.5
0094:  CALL   05C
....................    }  
0095:  BSF    03.5
0096:  MOVF   22,W
0097:  BTFSC  03.2
0098:  DECF   23,F
0099:  DECF   22,F
009A:  GOTO   076
.................... }  
009B:  BCF    03.5
009C:  RETLW  00
.................... /******************************************************************************/  
.................... void diagnostika()  
.................... {  
....................    unsigned int16 n;  
....................   
....................    while (input(DIAG_SERVO))   // Propojka, ktera spousti diagnostiku  
....................    {  
*
01D1:  BSF    03.5
01D2:  BSF    06.3
01D3:  BCF    03.5
01D4:  BTFSS  06.3
01D5:  GOTO   302
....................       for (n=500; n<800; n+=100)  
01D6:  MOVLW  01
01D7:  MOVWF  74
01D8:  MOVLW  F4
01D9:  MOVWF  73
01DA:  MOVF   74,W
01DB:  SUBLW  03
01DC:  BTFSS  03.0
01DD:  GOTO   1F4
01DE:  BTFSS  03.2
01DF:  GOTO   1E4
01E0:  MOVF   73,W
01E1:  SUBLW  1F
01E2:  BTFSS  03.0
01E3:  GOTO   1F4
....................       {  
....................          beep(n,n); //beep UP  
01E4:  MOVF   74,W
01E5:  MOVWF  7D
01E6:  MOVF   73,W
01E7:  MOVWF  7C
01E8:  MOVF   74,W
01E9:  BSF    03.5
01EA:  MOVWF  21
01EB:  MOVF   73,W
01EC:  MOVWF  20
01ED:  BCF    03.5
01EE:  CALL   071
....................       };  
01EF:  MOVLW  64
01F0:  ADDWF  73,F
01F1:  BTFSC  03.0
01F2:  INCF   74,F
01F3:  GOTO   1DA
....................       Delay_ms(1000);  
01F4:  MOVLW  04
01F5:  MOVWF  7C
01F6:  MOVLW  FA
01F7:  MOVWF  7D
01F8:  CALL   09D
01F9:  DECFSZ 7C,F
01FA:  GOTO   1F6
....................       //zastav vse  
....................       STOPL; STOPR;  
01FB:  BSF    03.5
01FC:  BCF    06.6
01FD:  BCF    03.5
01FE:  BCF    06.6
01FF:  BSF    03.5
0200:  BCF    06.7
0201:  BCF    03.5
0202:  BCF    06.7
0203:  BSF    03.5
0204:  BCF    06.4
0205:  BCF    03.5
0206:  BCF    06.4
0207:  BSF    03.5
0208:  BCF    06.5
0209:  BCF    03.5
020A:  BCF    06.5
....................       //pravy pas  
....................       FR; Delay_ms(1000); STOPR; Delay_ms(1000);  
020B:  BSF    03.5
020C:  BCF    06.5
020D:  BCF    03.5
020E:  BCF    06.5
020F:  BSF    03.5
0210:  BCF    06.4
0211:  BCF    03.5
0212:  BSF    06.4
0213:  MOVLW  04
0214:  MOVWF  7C
0215:  MOVLW  FA
0216:  MOVWF  7D
0217:  CALL   09D
0218:  DECFSZ 7C,F
0219:  GOTO   215
021A:  BSF    03.5
021B:  BCF    06.4
021C:  BCF    03.5
021D:  BCF    06.4
021E:  BSF    03.5
021F:  BCF    06.5
0220:  BCF    03.5
0221:  BCF    06.5
0222:  MOVLW  04
0223:  MOVWF  7C
0224:  MOVLW  FA
0225:  MOVWF  7D
0226:  CALL   09D
0227:  DECFSZ 7C,F
0228:  GOTO   224
....................       BR; Delay_ms(1000); STOPR; Delay_ms(1000);  
0229:  BSF    03.5
022A:  BCF    06.4
022B:  BCF    03.5
022C:  BCF    06.4
022D:  BSF    03.5
022E:  BCF    06.5
022F:  BCF    03.5
0230:  BSF    06.5
0231:  MOVLW  04
0232:  MOVWF  7C
0233:  MOVLW  FA
0234:  MOVWF  7D
0235:  CALL   09D
0236:  DECFSZ 7C,F
0237:  GOTO   233
0238:  BSF    03.5
0239:  BCF    06.4
023A:  BCF    03.5
023B:  BCF    06.4
023C:  BSF    03.5
023D:  BCF    06.5
023E:  BCF    03.5
023F:  BCF    06.5
0240:  MOVLW  04
0241:  MOVWF  7C
0242:  MOVLW  FA
0243:  MOVWF  7D
0244:  CALL   09D
0245:  DECFSZ 7C,F
0246:  GOTO   242
....................       Beep(880,100); Delay_ms(1000);  
0247:  MOVLW  03
0248:  MOVWF  7D
0249:  MOVLW  70
024A:  MOVWF  7C
024B:  BSF    03.5
024C:  CLRF   21
024D:  MOVLW  64
024E:  MOVWF  20
024F:  BCF    03.5
0250:  CALL   071
0251:  MOVLW  04
0252:  MOVWF  7C
0253:  MOVLW  FA
0254:  MOVWF  7D
0255:  CALL   09D
0256:  DECFSZ 7C,F
0257:  GOTO   253
....................       //levy pas  
....................       FL; Delay_ms(1000); STOPL; Delay_ms(1000);  
0258:  BSF    03.5
0259:  BCF    06.7
025A:  BCF    03.5
025B:  BCF    06.7
025C:  BSF    03.5
025D:  BCF    06.6
025E:  BCF    03.5
025F:  BSF    06.6
0260:  MOVLW  04
0261:  MOVWF  7C
0262:  MOVLW  FA
0263:  MOVWF  7D
0264:  CALL   09D
0265:  DECFSZ 7C,F
0266:  GOTO   262
0267:  BSF    03.5
0268:  BCF    06.6
0269:  BCF    03.5
026A:  BCF    06.6
026B:  BSF    03.5
026C:  BCF    06.7
026D:  BCF    03.5
026E:  BCF    06.7
026F:  MOVLW  04
0270:  MOVWF  7C
0271:  MOVLW  FA
0272:  MOVWF  7D
0273:  CALL   09D
0274:  DECFSZ 7C,F
0275:  GOTO   271
....................       BL; Delay_ms(1000); STOPL; Delay_ms(1000);  
0276:  BSF    03.5
0277:  BCF    06.6
0278:  BCF    03.5
0279:  BCF    06.6
027A:  BSF    03.5
027B:  BCF    06.7
027C:  BCF    03.5
027D:  BSF    06.7
027E:  MOVLW  04
027F:  MOVWF  7C
0280:  MOVLW  FA
0281:  MOVWF  7D
0282:  CALL   09D
0283:  DECFSZ 7C,F
0284:  GOTO   280
0285:  BSF    03.5
0286:  BCF    06.6
0287:  BCF    03.5
0288:  BCF    06.6
0289:  BSF    03.5
028A:  BCF    06.7
028B:  BCF    03.5
028C:  BCF    06.7
028D:  MOVLW  04
028E:  MOVWF  7C
028F:  MOVLW  FA
0290:  MOVWF  7D
0291:  CALL   09D
0292:  DECFSZ 7C,F
0293:  GOTO   28F
....................       Beep(880,100); Delay_ms(1000);  
0294:  MOVLW  03
0295:  MOVWF  7D
0296:  MOVLW  70
0297:  MOVWF  7C
0298:  BSF    03.5
0299:  CLRF   21
029A:  MOVLW  64
029B:  MOVWF  20
029C:  BCF    03.5
029D:  CALL   071
029E:  MOVLW  04
029F:  MOVWF  7C
02A0:  MOVLW  FA
02A1:  MOVWF  7D
02A2:  CALL   09D
02A3:  DECFSZ 7C,F
02A4:  GOTO   2A0
....................       //oba pasy  
....................       FL; FR; Delay_ms(1000); STOPL; STOPR; Delay_ms(1000);  
02A5:  BSF    03.5
02A6:  BCF    06.7
02A7:  BCF    03.5
02A8:  BCF    06.7
02A9:  BSF    03.5
02AA:  BCF    06.6
02AB:  BCF    03.5
02AC:  BSF    06.6
02AD:  BSF    03.5
02AE:  BCF    06.5
02AF:  BCF    03.5
02B0:  BCF    06.5
02B1:  BSF    03.5
02B2:  BCF    06.4
02B3:  BCF    03.5
02B4:  BSF    06.4
02B5:  MOVLW  04
02B6:  MOVWF  7C
02B7:  MOVLW  FA
02B8:  MOVWF  7D
02B9:  CALL   09D
02BA:  DECFSZ 7C,F
02BB:  GOTO   2B7
02BC:  BSF    03.5
02BD:  BCF    06.6
02BE:  BCF    03.5
02BF:  BCF    06.6
02C0:  BSF    03.5
02C1:  BCF    06.7
02C2:  BCF    03.5
02C3:  BCF    06.7
02C4:  BSF    03.5
02C5:  BCF    06.4
02C6:  BCF    03.5
02C7:  BCF    06.4
02C8:  BSF    03.5
02C9:  BCF    06.5
02CA:  BCF    03.5
02CB:  BCF    06.5
02CC:  MOVLW  04
02CD:  MOVWF  7C
02CE:  MOVLW  FA
02CF:  MOVWF  7D
02D0:  CALL   09D
02D1:  DECFSZ 7C,F
02D2:  GOTO   2CE
....................       BL; BR; Delay_ms(1000); STOPL; STOPR; Delay_ms(1000);  
02D3:  BSF    03.5
02D4:  BCF    06.6
02D5:  BCF    03.5
02D6:  BCF    06.6
02D7:  BSF    03.5
02D8:  BCF    06.7
02D9:  BCF    03.5
02DA:  BSF    06.7
02DB:  BSF    03.5
02DC:  BCF    06.4
02DD:  BCF    03.5
02DE:  BCF    06.4
02DF:  BSF    03.5
02E0:  BCF    06.5
02E1:  BCF    03.5
02E2:  BSF    06.5
02E3:  MOVLW  04
02E4:  MOVWF  7C
02E5:  MOVLW  FA
02E6:  MOVWF  7D
02E7:  CALL   09D
02E8:  DECFSZ 7C,F
02E9:  GOTO   2E5
02EA:  BSF    03.5
02EB:  BCF    06.6
02EC:  BCF    03.5
02ED:  BCF    06.6
02EE:  BSF    03.5
02EF:  BCF    06.7
02F0:  BCF    03.5
02F1:  BCF    06.7
02F2:  BSF    03.5
02F3:  BCF    06.4
02F4:  BCF    03.5
02F5:  BCF    06.4
02F6:  BSF    03.5
02F7:  BCF    06.5
02F8:  BCF    03.5
02F9:  BCF    06.5
02FA:  MOVLW  04
02FB:  MOVWF  7C
02FC:  MOVLW  FA
02FD:  MOVWF  7D
02FE:  CALL   09D
02FF:  DECFSZ 7C,F
0300:  GOTO   2FC
....................    };  
0301:  GOTO   1D1
....................    while (input(DIAG_SENSORS))  
....................    {  
0302:  BSF    03.5
0303:  BSF    06.2
0304:  BCF    03.5
0305:  BTFSS  06.2
0306:  GOTO   3C2
....................       int ls, rs;  
....................            while(!input(BUMPER)){beep(1100,100); Delay_ms(50);}  
0307:  BSF    03.5
0308:  BSF    05.4
0309:  BCF    03.5
030A:  BTFSC  05.4
030B:  GOTO   31A
030C:  MOVLW  04
030D:  MOVWF  7D
030E:  MOVLW  4C
030F:  MOVWF  7C
0310:  BSF    03.5
0311:  CLRF   21
0312:  MOVLW  64
0313:  MOVWF  20
0314:  BCF    03.5
0315:  CALL   071
0316:  MOVLW  32
0317:  MOVWF  7D
0318:  CALL   09D
0319:  GOTO   307
....................       set_adc_channel(RSENSOR);  
031A:  MOVLW  00
031B:  BSF    03.5
031C:  BTFSC  1C.7
031D:  MOVLW  01
031E:  MOVWF  7C
031F:  RLF    7C,W
0320:  MOVWF  77
0321:  RLF    77,F
0322:  RLF    77,F
0323:  MOVLW  F8
0324:  ANDWF  77,F
0325:  BCF    03.5
0326:  MOVF   1F,W
0327:  ANDLW  C7
0328:  IORWF  77,W
0329:  MOVWF  1F
....................       Delay_us(20);  
032A:  MOVLW  06
032B:  MOVWF  77
032C:  DECFSZ 77,F
032D:  GOTO   32C
032E:  NOP
....................       rs=read_adc();  
032F:  BSF    1F.2
0330:  BTFSC  1F.2
0331:  GOTO   330
0332:  MOVF   1E,W
0333:  MOVWF  76
....................       set_adc_channel(LSENSOR);  
0334:  MOVLW  00
0335:  BSF    03.5
0336:  BTFSC  1C.6
0337:  MOVLW  01
0338:  MOVWF  7C
0339:  RLF    7C,W
033A:  MOVWF  77
033B:  RLF    77,F
033C:  RLF    77,F
033D:  MOVLW  F8
033E:  ANDWF  77,F
033F:  BCF    03.5
0340:  MOVF   1F,W
0341:  ANDLW  C7
0342:  IORWF  77,W
0343:  MOVWF  1F
....................       Delay_us(20);  
0344:  MOVLW  06
0345:  MOVWF  77
0346:  DECFSZ 77,F
0347:  GOTO   346
0348:  NOP
....................       ls=read_adc();  
0349:  BSF    1F.2
034A:  BTFSC  1F.2
034B:  GOTO   34A
034C:  MOVF   1E,W
034D:  MOVWF  75
....................       sprintf(AXstring,"L: %U  R: %U\0", ls, rs);  // Convert DATA to String.  
034E:  MOVLW  48
034F:  MOVWF  70
0350:  MOVLW  4C
0351:  BSF    03.5
0352:  MOVWF  20
0353:  BCF    03.5
0354:  CALL   0B2
0355:  MOVLW  3A
0356:  BSF    03.5
0357:  MOVWF  20
0358:  BCF    03.5
0359:  CALL   0B2
035A:  MOVLW  20
035B:  BSF    03.5
035C:  MOVWF  20
035D:  BCF    03.5
035E:  CALL   0B2
035F:  MOVF   75,W
0360:  MOVWF  7D
0361:  MOVLW  18
0362:  MOVWF  7E
0363:  CALL   0D3
0364:  MOVLW  05
0365:  MOVWF  7C
0366:  MOVF   7C,W
0367:  CALL   037
0368:  INCF   7C,F
0369:  MOVWF  77
036A:  BSF    03.5
036B:  MOVWF  20
036C:  BCF    03.5
036D:  CALL   0B2
036E:  MOVLW  0A
036F:  SUBWF  7C,W
0370:  BTFSS  03.2
0371:  GOTO   366
0372:  MOVF   76,W
0373:  MOVWF  7D
0374:  MOVLW  18
0375:  MOVWF  7E
0376:  CALL   0D3
*
082D:  CLRF   70
....................       SendPacket(&AXstring[0]);  
*
0377:  MOVLW  48
0378:  MOVWF  7C
....................       delay_ms(1000);  
*
03BA:  MOVLW  04
03BB:  MOVWF  7C
03BC:  MOVLW  FA
03BD:  MOVWF  7D
03BE:  CALL   09D
03BF:  DECFSZ 7C,F
03C0:  GOTO   3BC
....................    };  
03C1:  GOTO   302
.................... }  
03C2:  BSF    0A.3
03C3:  GOTO   0BA (RETURN)
.................... ///////////////////////////////////////////////////////////////////////////////  
.................... void cikcak()  
.................... {  
.................... unsigned int16 n;  
....................   
....................    line = RSENSOR;         // cteni senzoru na caru  
03C4:  CLRF   41
03C5:  BSF    03.5
03C6:  BTFSS  1C.7
03C7:  GOTO   3CB
03C8:  BCF    03.5
03C9:  INCF   41,F
03CA:  BSF    03.5
....................    line |= LSENSOR << 1;  
03CB:  MOVLW  00
03CC:  BTFSC  1C.6
03CD:  MOVLW  01
03CE:  MOVWF  77
03CF:  BCF    03.0
03D0:  RLF    77,F
03D1:  MOVF   77,W
03D2:  BCF    03.5
03D3:  IORWF  41,F
....................    if (line!=0) return;  
03D4:  MOVF   41,F
03D5:  BTFSS  03.2
03D6:  GOTO   4B1
....................   
....................    n=0;  
03D7:  CLRF   76
03D8:  CLRF   75
....................    switch(movement)                                                                        // podivej se na druhou stranu nez se jelo  
....................    {  
03D9:  MOVF   45,W
03DA:  XORLW  02
03DB:  BTFSC  03.2
03DC:  GOTO   3E4
03DD:  XORLW  03
03DE:  BTFSC  03.2
03DF:  GOTO   3F7
03E0:  XORLW  02
03E1:  BTFSC  03.2
03E2:  GOTO   40A
03E3:  GOTO   421
....................    case L:  
....................                            FL;BR;  
03E4:  BSF    03.5
03E5:  BCF    06.7
03E6:  BCF    03.5
03E7:  BCF    06.7
03E8:  BSF    03.5
03E9:  BCF    06.6
03EA:  BCF    03.5
03EB:  BSF    06.6
03EC:  BSF    03.5
03ED:  BCF    06.4
03EE:  BCF    03.5
03EF:  BCF    06.4
03F0:  BSF    03.5
03F1:  BCF    06.5
03F2:  BCF    03.5
03F3:  BSF    06.5
....................                            movement=R;  
03F4:  MOVLW  01
03F5:  MOVWF  45
....................                    break;  
03F6:  GOTO   421
....................    case R:  
....................                            FR;BL;  
03F7:  BSF    03.5
03F8:  BCF    06.5
03F9:  BCF    03.5
03FA:  BCF    06.5
03FB:  BSF    03.5
03FC:  BCF    06.4
03FD:  BCF    03.5
03FE:  BSF    06.4
03FF:  BSF    03.5
0400:  BCF    06.6
0401:  BCF    03.5
0402:  BCF    06.6
0403:  BSF    03.5
0404:  BCF    06.7
0405:  BCF    03.5
0406:  BSF    06.7
....................                            movement=L;  
0407:  MOVLW  02
0408:  MOVWF  45
....................                    break;  
0409:  GOTO   421
....................    case S:  
....................                            FL;BR;  
040A:  BSF    03.5
040B:  BCF    06.7
040C:  BCF    03.5
040D:  BCF    06.7
040E:  BSF    03.5
040F:  BCF    06.6
0410:  BCF    03.5
0411:  BSF    06.6
0412:  BSF    03.5
0413:  BCF    06.4
0414:  BCF    03.5
0415:  BCF    06.4
0416:  BSF    03.5
0417:  BCF    06.5
0418:  BCF    03.5
0419:  BSF    06.5
....................                            movement=R;  
041A:  MOVLW  01
041B:  MOVWF  45
....................             n=CIK_CAK/2;  
041C:  MOVLW  27
041D:  MOVWF  76
041E:  MOVLW  10
041F:  MOVWF  75
....................                    break;  
0420:  GOTO   421
....................    }  
....................    while (0==(RSENSOR|LSENSOR))       // zkontroluj caru  
....................    {  
0421:  MOVLW  00
0422:  BSF    03.5
0423:  BTFSC  1C.7
0424:  MOVLW  01
0425:  MOVWF  7C
0426:  MOVLW  00
0427:  BTFSC  1C.6
0428:  MOVLW  01
0429:  IORWF  7C,W
042A:  XORLW  00
042B:  BTFSS  03.2
042C:  GOTO   46D
....................            if (n==CIK_CAK)                                                 // zmen smer zataceni  
042D:  MOVF   75,W
042E:  SUBLW  20
042F:  BTFSS  03.2
0430:  GOTO   467
0431:  MOVF   76,W
0432:  SUBLW  4E
0433:  BTFSS  03.2
0434:  GOTO   467
....................            {  
....................                    n=0;  
0435:  CLRF   76
0436:  CLRF   75
....................                    switch(movement)  
....................                    {  
0437:  BCF    03.5
0438:  MOVF   45,W
0439:  XORLW  02
043A:  BTFSC  03.2
043B:  GOTO   440
043C:  XORLW  03
043D:  BTFSC  03.2
043E:  GOTO   453
043F:  GOTO   466
....................                    case L:  
....................                                            FL;BR;  
0440:  BSF    03.5
0441:  BCF    06.7
0442:  BCF    03.5
0443:  BCF    06.7
0444:  BSF    03.5
0445:  BCF    06.6
0446:  BCF    03.5
0447:  BSF    06.6
0448:  BSF    03.5
0449:  BCF    06.4
044A:  BCF    03.5
044B:  BCF    06.4
044C:  BSF    03.5
044D:  BCF    06.5
044E:  BCF    03.5
044F:  BSF    06.5
....................                                            movement=R;  
0450:  MOVLW  01
0451:  MOVWF  45
....................                                    break;  
0452:  GOTO   466
....................                    case R:  
....................                                            FR;BL;  
0453:  BSF    03.5
0454:  BCF    06.5
0455:  BCF    03.5
0456:  BCF    06.5
0457:  BSF    03.5
0458:  BCF    06.4
0459:  BCF    03.5
045A:  BSF    06.4
045B:  BSF    03.5
045C:  BCF    06.6
045D:  BCF    03.5
045E:  BCF    06.6
045F:  BSF    03.5
0460:  BCF    06.7
0461:  BCF    03.5
0462:  BSF    06.7
....................                                            movement=L;  
0463:  MOVLW  02
0464:  MOVWF  45
....................                                    break;  
0465:  GOTO   466
0466:  BSF    03.5
....................                    }  
....................            }  
....................            n++;  
0467:  INCF   75,F
0468:  BTFSC  03.2
0469:  INCF   76,F
....................    }  
046A:  BCF    03.5
046B:  GOTO   421
046C:  BSF    03.5
....................    switch(movement)  
....................    {  
046D:  BCF    03.5
046E:  MOVF   45,W
046F:  XORLW  02
0470:  BTFSC  03.2
0471:  GOTO   476
0472:  XORLW  03
0473:  BTFSC  03.2
0474:  GOTO   489
0475:  GOTO   49C
....................    case L:  
....................             FL;BR;  
0476:  BSF    03.5
0477:  BCF    06.7
0478:  BCF    03.5
0479:  BCF    06.7
047A:  BSF    03.5
047B:  BCF    06.6
047C:  BCF    03.5
047D:  BSF    06.6
047E:  BSF    03.5
047F:  BCF    06.4
0480:  BCF    03.5
0481:  BCF    06.4
0482:  BSF    03.5
0483:  BCF    06.5
0484:  BCF    03.5
0485:  BSF    06.5
....................             movement=R;  
0486:  MOVLW  01
0487:  MOVWF  45
....................          break;  
0488:  GOTO   49C
....................    case R:  
....................             FR;BL;  
0489:  BSF    03.5
048A:  BCF    06.5
048B:  BCF    03.5
048C:  BCF    06.5
048D:  BSF    03.5
048E:  BCF    06.4
048F:  BCF    03.5
0490:  BSF    06.4
0491:  BSF    03.5
0492:  BCF    06.6
0493:  BCF    03.5
0494:  BCF    06.6
0495:  BSF    03.5
0496:  BCF    06.7
0497:  BCF    03.5
0498:  BSF    06.7
....................             movement=L;  
0499:  MOVLW  02
049A:  MOVWF  45
....................          break;  
049B:  GOTO   49C
....................    }  
....................    Delay_ms(50);  
049C:  MOVLW  32
049D:  MOVWF  7D
049E:  CALL   09D
....................    STOPL;STOPR;                                                                                            // nasli jsme caru  
049F:  BSF    03.5
04A0:  BCF    06.6
04A1:  BCF    03.5
04A2:  BCF    06.6
04A3:  BSF    03.5
04A4:  BCF    06.7
04A5:  BCF    03.5
04A6:  BCF    06.7
04A7:  BSF    03.5
04A8:  BCF    06.4
04A9:  BCF    03.5
04AA:  BCF    06.4
04AB:  BSF    03.5
04AC:  BCF    06.5
04AD:  BCF    03.5
04AE:  BCF    06.5
....................    line=S;  
04AF:  MOVLW  03
04B0:  MOVWF  41
.................... }  
04B1:  RETLW  00
.................... ///////////////////////////////////////////////////////////////////////////////  
.................... void objizdka()                     // objede cihlu  
.................... {  
.................... unsigned int16 n;  
....................   
....................    BL;BR;Delay_ms(200);  
04B2:  BSF    03.5
04B3:  BCF    06.6
04B4:  BCF    03.5
04B5:  BCF    06.6
04B6:  BSF    03.5
04B7:  BCF    06.7
04B8:  BCF    03.5
04B9:  BSF    06.7
04BA:  BSF    03.5
04BB:  BCF    06.4
04BC:  BCF    03.5
04BD:  BCF    06.4
04BE:  BSF    03.5
04BF:  BCF    06.5
04C0:  BCF    03.5
04C1:  BSF    06.5
04C2:  MOVLW  C8
04C3:  MOVWF  7D
04C4:  CALL   09D
....................    STOPR;STOPL;  
04C5:  BSF    03.5
04C6:  BCF    06.4
04C7:  BCF    03.5
04C8:  BCF    06.4
04C9:  BSF    03.5
04CA:  BCF    06.5
04CB:  BCF    03.5
04CC:  BCF    06.5
04CD:  BSF    03.5
04CE:  BCF    06.6
04CF:  BCF    03.5
04D0:  BCF    06.6
04D1:  BSF    03.5
04D2:  BCF    06.7
04D3:  BCF    03.5
04D4:  BCF    06.7
....................    beep(900,1000);  
04D5:  MOVLW  03
04D6:  MOVWF  7D
04D7:  MOVLW  84
04D8:  MOVWF  7C
04D9:  MOVLW  03
04DA:  BSF    03.5
04DB:  MOVWF  21
04DC:  MOVLW  E8
04DD:  MOVWF  20
04DE:  BCF    03.5
04DF:  CALL   071
....................    movement=S;  
04E0:  MOVLW  03
04E1:  MOVWF  45
....................    cikcak();  
04E2:  CALL   3C4
....................   
....................    BR; FL; Delay_ms(215);           // otoc se 70° do prava  
04E3:  BSF    03.5
04E4:  BCF    06.4
04E5:  BCF    03.5
04E6:  BCF    06.4
04E7:  BSF    03.5
04E8:  BCF    06.5
04E9:  BCF    03.5
04EA:  BSF    06.5
04EB:  BSF    03.5
04EC:  BCF    06.7
04ED:  BCF    03.5
04EE:  BCF    06.7
04EF:  BSF    03.5
04F0:  BCF    06.6
04F1:  BCF    03.5
04F2:  BSF    06.6
04F3:  MOVLW  D7
04F4:  MOVWF  7D
04F5:  CALL   09D
....................   
....................    FR; FL; Delay_ms(600);           // popojed rovne  
04F6:  BSF    03.5
04F7:  BCF    06.5
04F8:  BCF    03.5
04F9:  BCF    06.5
04FA:  BSF    03.5
04FB:  BCF    06.4
04FC:  BCF    03.5
04FD:  BSF    06.4
04FE:  BSF    03.5
04FF:  BCF    06.7
0500:  BCF    03.5
0501:  BCF    06.7
0502:  BSF    03.5
0503:  BCF    06.6
0504:  BCF    03.5
0505:  BSF    06.6
0506:  MOVLW  03
0507:  MOVWF  75
0508:  MOVLW  C8
0509:  MOVWF  7D
050A:  CALL   09D
050B:  DECFSZ 75,F
050C:  GOTO   508
....................   
....................    BL; Delay_ms(50);               // otoc se 90° do leva  
050D:  BSF    03.5
050E:  BCF    06.6
050F:  BCF    03.5
0510:  BCF    06.6
0511:  BSF    03.5
0512:  BCF    06.7
0513:  BCF    03.5
0514:  BSF    06.7
0515:  MOVLW  32
0516:  MOVWF  7D
0517:  CALL   09D
....................    STOPL; FR; Delay_ms(550);  
0518:  BSF    03.5
0519:  BCF    06.6
051A:  BCF    03.5
051B:  BCF    06.6
051C:  BSF    03.5
051D:  BCF    06.7
051E:  BCF    03.5
051F:  BCF    06.7
0520:  BSF    03.5
0521:  BCF    06.5
0522:  BCF    03.5
0523:  BCF    06.5
0524:  BSF    03.5
0525:  BCF    06.4
0526:  BCF    03.5
0527:  BSF    06.4
0528:  MOVLW  05
0529:  MOVWF  75
052A:  MOVLW  6E
052B:  MOVWF  7D
052C:  CALL   09D
052D:  DECFSZ 75,F
052E:  GOTO   52A
....................   
....................    FR; FL; Delay_ms(100);           // popojed rovne na slepo  
052F:  BSF    03.5
0530:  BCF    06.5
0531:  BCF    03.5
0532:  BCF    06.5
0533:  BSF    03.5
0534:  BCF    06.4
0535:  BCF    03.5
0536:  BSF    06.4
0537:  BSF    03.5
0538:  BCF    06.7
0539:  BCF    03.5
053A:  BCF    06.7
053B:  BSF    03.5
053C:  BCF    06.6
053D:  BCF    03.5
053E:  BSF    06.6
053F:  MOVLW  64
0540:  MOVWF  7D
0541:  CALL   09D
....................    for(n=600;n>0;n--)               // popojed rovne ale kontroluj caru  
0542:  MOVLW  02
0543:  MOVWF  74
0544:  MOVLW  58
0545:  MOVWF  73
0546:  MOVF   73,F
0547:  BTFSS  03.2
0548:  GOTO   54C
0549:  MOVF   74,F
054A:  BTFSC  03.2
054B:  GOTO   56B
....................    {  
....................       line = RSENSOR;         // cteni senzoru na caru  
054C:  CLRF   41
054D:  BSF    03.5
054E:  BTFSS  1C.7
054F:  GOTO   553
0550:  BCF    03.5
0551:  INCF   41,F
0552:  BSF    03.5
....................       line |= LSENSOR << 1;  
0553:  MOVLW  00
0554:  BTFSC  1C.6
0555:  MOVLW  01
0556:  MOVWF  77
0557:  BCF    03.0
0558:  RLF    77,F
0559:  MOVF   77,W
055A:  BCF    03.5
055B:  IORWF  41,F
....................       if (line!=0) {Delay_ms(50); break;}  
055C:  MOVF   41,F
055D:  BTFSC  03.2
055E:  GOTO   563
055F:  MOVLW  32
0560:  MOVWF  7D
0561:  CALL   09D
0562:  GOTO   56B
....................       Delay_ms(1);  
0563:  MOVLW  01
0564:  MOVWF  7D
0565:  CALL   09D
....................    }  
0566:  MOVF   73,W
0567:  BTFSC  03.2
0568:  DECF   74,F
0569:  DECF   73,F
056A:  GOTO   546
....................   
....................    BR;                              // otoc se 60° do prava  
056B:  BSF    03.5
056C:  BCF    06.4
056D:  BCF    03.5
056E:  BCF    06.4
056F:  BSF    03.5
0570:  BCF    06.5
0571:  BCF    03.5
0572:  BSF    06.5
....................    for(n=600;n>0;n--)  
0573:  MOVLW  02
0574:  MOVWF  74
0575:  MOVLW  58
0576:  MOVWF  73
0577:  MOVF   73,F
0578:  BTFSS  03.2
0579:  GOTO   57D
057A:  MOVF   74,F
057B:  BTFSC  03.2
057C:  GOTO   598
....................    {  
....................       line = RSENSOR;         // cteni senzoru na caru  
057D:  CLRF   41
057E:  BSF    03.5
057F:  BTFSS  1C.7
0580:  GOTO   584
0581:  BCF    03.5
0582:  INCF   41,F
0583:  BSF    03.5
....................       line |= LSENSOR << 1;  
0584:  MOVLW  00
0585:  BTFSC  1C.6
0586:  MOVLW  01
0587:  MOVWF  77
0588:  BCF    03.0
0589:  RLF    77,F
058A:  MOVF   77,W
058B:  BCF    03.5
058C:  IORWF  41,F
....................       if (line!=0) break;  
058D:  MOVF   41,F
058E:  BTFSS  03.2
058F:  GOTO   598
....................       Delay_ms(1);  
0590:  MOVLW  01
0591:  MOVWF  7D
0592:  CALL   09D
....................    }  
0593:  MOVF   73,W
0594:  BTFSC  03.2
0595:  DECF   74,F
0596:  DECF   73,F
0597:  GOTO   577
....................    STOPR; STOPL;  
0598:  BSF    03.5
0599:  BCF    06.4
059A:  BCF    03.5
059B:  BCF    06.4
059C:  BSF    03.5
059D:  BCF    06.5
059E:  BCF    03.5
059F:  BCF    06.5
05A0:  BSF    03.5
05A1:  BCF    06.6
05A2:  BCF    03.5
05A3:  BCF    06.6
05A4:  BSF    03.5
05A5:  BCF    06.7
05A6:  BCF    03.5
05A7:  BCF    06.7
....................   
....................    movement=R;  
05A8:  MOVLW  01
05A9:  MOVWF  45
....................    cikcak();  
05AA:  CALL   3C4
....................    cihla=T_DIRA;  
05AB:  MOVLW  55
05AC:  MOVWF  47
....................    dira=0;  
05AD:  CLRF   46
.................... }  
05AE:  BSF    0A.3
05AF:  GOTO   0F7 (RETURN)
.................... ///////////////////////////////////////////////////////////////////////////////  
.................... void prejeddiru()                    // vyresi diru  
.................... {  
.................... unsigned int16 n;  
....................   
....................    STOPL;STOPR;  
05B0:  BSF    03.5
05B1:  BCF    06.6
05B2:  BCF    03.5
05B3:  BCF    06.6
05B4:  BSF    03.5
05B5:  BCF    06.7
05B6:  BCF    03.5
05B7:  BCF    06.7
05B8:  BSF    03.5
05B9:  BCF    06.4
05BA:  BCF    03.5
05BB:  BCF    06.4
05BC:  BSF    03.5
05BD:  BCF    06.5
05BE:  BCF    03.5
05BF:  BCF    06.5
....................    beep(800,500);  
05C0:  MOVLW  03
05C1:  MOVWF  7D
05C2:  MOVLW  20
05C3:  MOVWF  7C
05C4:  MOVLW  01
05C5:  BSF    03.5
05C6:  MOVWF  21
05C7:  MOVLW  F4
05C8:  MOVWF  20
05C9:  BCF    03.5
05CA:  CALL   071
....................    switch (movement)                            //vrat se zpet na caru  
....................    {  
05CB:  MOVF   45,W
05CC:  XORLW  02
05CD:  BTFSC  03.2
05CE:  GOTO   5D6
05CF:  XORLW  03
05D0:  BTFSC  03.2
05D1:  GOTO   60E
05D2:  XORLW  02
05D3:  BTFSC  03.2
05D4:  GOTO   646
05D5:  GOTO   648
....................    case L:  
....................          for (n=COUVANI;n>0;n--) {GO(R,B,speed); Delay_ms(1);}  
05D6:  MOVLW  02
05D7:  MOVWF  74
05D8:  MOVLW  58
05D9:  MOVWF  73
05DA:  MOVF   73,F
05DB:  BTFSS  03.2
05DC:  GOTO   5E0
05DD:  MOVF   74,F
05DE:  BTFSC  03.2
05DF:  GOTO   5FD
05E0:  MOVF   01,W
05E1:  SUBWF  42,W
05E2:  BTFSS  03.0
05E3:  GOTO   5ED
05E4:  BSF    03.5
05E5:  BCF    06.4
05E6:  BCF    03.5
05E7:  BCF    06.4
05E8:  BSF    03.5
05E9:  BCF    06.5
05EA:  BCF    03.5
05EB:  BSF    06.5
05EC:  GOTO   5F5
05ED:  BSF    03.5
05EE:  BCF    06.4
05EF:  BCF    03.5
05F0:  BCF    06.4
05F1:  BSF    03.5
05F2:  BCF    06.5
05F3:  BCF    03.5
05F4:  BCF    06.5
05F5:  MOVLW  01
05F6:  MOVWF  7D
05F7:  CALL   09D
05F8:  MOVF   73,W
05F9:  BTFSC  03.2
05FA:  DECF   74,F
05FB:  DECF   73,F
05FC:  GOTO   5DA
....................          STOPL;STOPR;  
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
....................       break;  
060D:  GOTO   648
....................    case R:  
....................          for (n=COUVANI;n>0;n--) {GO(L,B,speed); Delay_ms(1);}  
060E:  MOVLW  02
060F:  MOVWF  74
0610:  MOVLW  58
0611:  MOVWF  73
0612:  MOVF   73,F
0613:  BTFSS  03.2
0614:  GOTO   618
0615:  MOVF   74,F
0616:  BTFSC  03.2
0617:  GOTO   635
0618:  MOVF   01,W
0619:  SUBWF  42,W
061A:  BTFSS  03.0
061B:  GOTO   625
061C:  BSF    03.5
061D:  BCF    06.6
061E:  BCF    03.5
061F:  BCF    06.6
0620:  BSF    03.5
0621:  BCF    06.7
0622:  BCF    03.5
0623:  BSF    06.7
0624:  GOTO   62D
0625:  BSF    03.5
0626:  BCF    06.6
0627:  BCF    03.5
0628:  BCF    06.6
0629:  BSF    03.5
062A:  BCF    06.7
062B:  BCF    03.5
062C:  BCF    06.7
062D:  MOVLW  01
062E:  MOVWF  7D
062F:  CALL   09D
0630:  MOVF   73,W
0631:  BTFSC  03.2
0632:  DECF   74,F
0633:  DECF   73,F
0634:  GOTO   612
....................          STOPL;STOPR;  
0635:  BSF    03.5
0636:  BCF    06.6
0637:  BCF    03.5
0638:  BCF    06.6
0639:  BSF    03.5
063A:  BCF    06.7
063B:  BCF    03.5
063C:  BCF    06.7
063D:  BSF    03.5
063E:  BCF    06.4
063F:  BCF    03.5
0640:  BCF    06.4
0641:  BSF    03.5
0642:  BCF    06.5
0643:  BCF    03.5
0644:  BCF    06.5
....................       break;  
0645:  GOTO   648
....................    case S:  
....................          goto sem;  
0646:  GOTO   666
....................       break;  
0647:  GOTO   648
....................    }  
....................    beep(800,500);  
0648:  MOVLW  03
0649:  MOVWF  7D
064A:  MOVLW  20
064B:  MOVWF  7C
064C:  MOVLW  01
064D:  BSF    03.5
064E:  MOVWF  21
064F:  MOVLW  F4
0650:  MOVWF  20
0651:  BCF    03.5
0652:  CALL   071
....................    FR;FL; Delay_ms(PRES_DIRU);   // popojedem dopredu mozna tam bude cara  
0653:  BSF    03.5
0654:  BCF    06.5
0655:  BCF    03.5
0656:  BCF    06.5
0657:  BSF    03.5
0658:  BCF    06.4
0659:  BCF    03.5
065A:  BSF    06.4
065B:  BSF    03.5
065C:  BCF    06.7
065D:  BCF    03.5
065E:  BCF    06.7
065F:  BSF    03.5
0660:  BCF    06.6
0661:  BCF    03.5
0662:  BSF    06.6
0663:  MOVLW  96
0664:  MOVWF  7D
0665:  CALL   09D
.................... sem:  
....................    STOPL; STOPR;  
0666:  BSF    03.5
0667:  BCF    06.6
0668:  BCF    03.5
0669:  BCF    06.6
066A:  BSF    03.5
066B:  BCF    06.7
066C:  BCF    03.5
066D:  BCF    06.7
066E:  BSF    03.5
066F:  BCF    06.4
0670:  BCF    03.5
0671:  BCF    06.4
0672:  BSF    03.5
0673:  BCF    06.5
0674:  BCF    03.5
0675:  BCF    06.5
....................    movement=S;  
0676:  MOVLW  03
0677:  MOVWF  45
....................    cikcak();                                    // najdi caru  
0678:  CALL   3C4
....................    cihla=T_DIRA;  
0679:  MOVLW  55
067A:  MOVWF  47
....................    dira=0;  
067B:  CLRF   46
.................... }  
067C:  BSF    0A.3
067D:  GOTO   190 (RETURN)
.................... ///////////////////////////////////////////////////////////////////////////////  
.................... void main()  
.................... {  
*
0800:  CLRF   04
0801:  MOVLW  1F
0802:  ANDWF  03,F
0803:  BSF    03.5
0804:  BCF    1F.4
0805:  BCF    1F.5
0806:  MOVF   1B,W
0807:  ANDLW  80
0808:  MOVWF  1B
0809:  MOVLW  07
080A:  MOVWF  1C
080B:  MOVF   1C,W
080C:  BCF    03.5
080D:  BCF    0D.6
080E:  MOVLW  60
080F:  BSF    03.5
0810:  MOVWF  0F
....................    unsigned int16 n; // pro FOR  
....................   
....................    STOPL; STOPR;     // prepne vystupy na ovladani motoru na output a zastavi  
*
082E:  BSF    03.5
082F:  BCF    06.6
0830:  BCF    03.5
0831:  BCF    06.6
0832:  BSF    03.5
0833:  BCF    06.7
0834:  BCF    03.5
0835:  BCF    06.7
0836:  BSF    03.5
0837:  BCF    06.4
0838:  BCF    03.5
0839:  BCF    06.4
083A:  BSF    03.5
083B:  BCF    06.5
083C:  BCF    03.5
083D:  BCF    06.5
....................   
....................    setup_oscillator(OSC_4MHZ|OSC_INTRC);     // 4 MHz interni RC oscilator  
083E:  MOVLW  62
083F:  BSF    03.5
0840:  MOVWF  0F
....................   
....................    port_b_pullups(TRUE);      // pullups pro piano na diagnostiku  
0841:  BCF    01.7
....................    setup_spi(FALSE);  
0842:  BCF    03.5
0843:  BCF    14.5
0844:  BSF    03.5
0845:  BCF    06.2
0846:  BSF    06.1
0847:  BCF    06.4
0848:  MOVLW  00
0849:  BCF    03.5
084A:  MOVWF  14
084B:  BSF    03.5
084C:  MOVWF  14
....................    setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);  // Casovac pro PWM  
084D:  MOVF   01,W
084E:  ANDLW  C7
084F:  IORLW  08
0850:  MOVWF  01
....................   
....................    setup_timer_2(T2_DIV_BY_4,255,10);    // Casovac pro regulaci  
0851:  MOVLW  48
0852:  MOVWF  78
0853:  IORLW  05
0854:  BCF    03.5
0855:  MOVWF  12
0856:  MOVLW  FF
0857:  BSF    03.5
0858:  MOVWF  12
....................                                          // preruseni kazdych 10ms  
....................    setup_adc_ports(sAN2|VSS_VDD);      // nastaveni A/D prevodniku pro naraznik  
0859:  BCF    1F.4
085A:  BCF    1F.5
085B:  MOVF   1B,W
085C:  ANDLW  80
085D:  IORLW  04
085E:  MOVWF  1B
....................    setup_adc(ADC_CLOCK_INTERNAL);  
085F:  BCF    1F.6
0860:  BCF    03.5
0861:  BSF    1F.6
0862:  BSF    1F.7
0863:  BSF    03.5
0864:  BCF    1F.7
0865:  BCF    03.5
0866:  BSF    1F.0
....................    set_adc_channel(2);  
0867:  MOVLW  10
0868:  MOVWF  78
0869:  MOVF   1F,W
086A:  ANDLW  C7
086B:  IORWF  78,W
086C:  MOVWF  1F
....................    setup_timer_1(T1_INTERNAL|T1_DIV_BY_1);   // Casovac pro naraznik  
086D:  MOVLW  85
086E:  MOVWF  10
....................    setup_ccp1(CCP_COMPARE_RESET_TIMER);  
086F:  BSF    03.5
0870:  BSF    06.3
0871:  MOVLW  0B
0872:  BCF    03.5
0873:  MOVWF  17
....................    CCP_1=(2^10)-1;                        // prevod kazdou 1ms  
0874:  CLRF   16
0875:  MOVLW  07
0876:  MOVWF  15
....................   
....................    setup_comparator(A0_VR_A1_VR);   // inicializace komparatoru pro cidla cary  
0877:  MOVLW  02
0878:  BSF    03.5
0879:  MOVWF  1C
087A:  MOVF   05,W
087B:  IORLW  03
087C:  MOVWF  05
087D:  MOVLW  03
087E:  MOVWF  77
087F:  DECFSZ 77,F
0880:  GOTO   07F
0881:  MOVF   1C,W
0882:  BCF    03.5
0883:  BCF    0D.6
....................    setup_vref(VREF_HIGH|TRESHOLD);        // 32 kroku od 0.25 do 0.75 Vdd  
0884:  MOVLW  8A
0885:  BSF    03.5
0886:  MOVWF  1D
....................   
....................    Beep(1000,200);     //double beep  
0887:  MOVLW  03
0888:  MOVWF  7D
0889:  MOVLW  E8
088A:  MOVWF  7C
088B:  CLRF   21
088C:  MOVLW  C8
088D:  MOVWF  20
088E:  BCF    0A.3
088F:  BCF    03.5
0890:  CALL   071
0891:  BSF    0A.3
....................    Delay_ms(50);  
0892:  MOVLW  32
0893:  MOVWF  7D
0894:  BCF    0A.3
0895:  CALL   09D
0896:  BSF    0A.3
....................    Beep(1000,200);  
0897:  MOVLW  03
0898:  MOVWF  7D
0899:  MOVLW  E8
089A:  MOVWF  7C
089B:  BSF    03.5
089C:  CLRF   21
089D:  MOVLW  C8
089E:  MOVWF  20
089F:  BCF    0A.3
08A0:  BCF    03.5
08A1:  CALL   071
08A2:  BSF    0A.3
....................    Delay_ms(1000);      // 1s  
08A3:  MOVLW  04
08A4:  MOVWF  73
08A5:  MOVLW  FA
08A6:  MOVWF  7D
08A7:  BCF    0A.3
08A8:  CALL   09D
08A9:  BSF    0A.3
08AA:  DECFSZ 73,F
08AB:  GOTO   0A5
....................   
....................          // povoleni rizeni rychlosti zataceni pres preruseni  
....................    enable_interrupts(INT_TIMER2);  
08AC:  BSF    03.5
08AD:  BSF    0C.1
....................    enable_interrupts(GLOBAL);  
08AE:  MOVLW  C0
08AF:  BCF    03.5
08B0:  IORWF  0B,F
....................   
.................... /*---------------------------------------------------------------------------*/  
....................    sensors=S;  
08B1:  MOVLW  03
08B2:  MOVWF  40
....................    line=S;  
08B3:  MOVWF  41
....................    last=S;  
08B4:  MOVWF  44
....................    movement=S;  
08B5:  MOVWF  45
....................    speed=FW_POMALU;  
08B6:  MOVLW  E6
08B7:  MOVWF  42
....................   
....................    diagnostika();  
08B8:  BCF    0A.3
08B9:  GOTO   1D1
08BA:  BSF    0A.3
....................    cikcak();     // toc se, abys nasel caru  
08BB:  BCF    0A.3
08BC:  CALL   3C4
08BD:  BSF    0A.3
....................    Delay_ms(500);  
08BE:  MOVLW  02
08BF:  MOVWF  73
08C0:  MOVLW  FA
08C1:  MOVWF  7D
08C2:  BCF    0A.3
08C3:  CALL   09D
08C4:  BSF    0A.3
08C5:  DECFSZ 73,F
08C6:  GOTO   0C0
....................    Beep(1000,200);  
08C7:  MOVLW  03
08C8:  MOVWF  7D
08C9:  MOVLW  E8
08CA:  MOVWF  7C
08CB:  BSF    03.5
08CC:  CLRF   21
08CD:  MOVLW  C8
08CE:  MOVWF  20
08CF:  BCF    0A.3
08D0:  BCF    03.5
08D1:  CALL   071
08D2:  BSF    0A.3
....................    Delay_ms(500);  
08D3:  MOVLW  02
08D4:  MOVWF  73
08D5:  MOVLW  FA
08D6:  MOVWF  7D
08D7:  BCF    0A.3
08D8:  CALL   09D
08D9:  BSF    0A.3
08DA:  DECFSZ 73,F
08DB:  GOTO   0D5
....................   
....................    while(true)       // hlavni smycka (jizda podle cary)  
....................    {  
....................       sensors = RSENSOR;         // cteni senzoru na caru  
08DC:  CLRF   40
08DD:  BSF    03.5
08DE:  BTFSS  1C.7
08DF:  GOTO   0E3
08E0:  BCF    03.5
08E1:  INCF   40,F
08E2:  BSF    03.5
....................       sensors |= LSENSOR << 1;  
08E3:  MOVLW  00
08E4:  BTFSC  1C.6
08E5:  MOVLW  01
08E6:  MOVWF  77
08E7:  BCF    03.0
08E8:  RLF    77,F
08E9:  MOVF   77,W
08EA:  BCF    03.5
08EB:  IORWF  40,F
....................   
....................       if ((read_adc(ADC_READ_ONLY)<BUMPER_TRESHOLD) && (cihla==0)) objizdka();  
08EC:  BTFSC  1F.2
08ED:  GOTO   0EC
08EE:  MOVF   1E,W
08EF:  SUBLW  7F
08F0:  BTFSS  03.0
08F1:  GOTO   0F8
08F2:  MOVF   47,F
08F3:  BTFSS  03.2
08F4:  GOTO   0F8
08F5:  BCF    0A.3
08F6:  GOTO   4B2
08F7:  BSF    0A.3
....................   
....................       switch (sensors)  // zatacej podle toho, kde vidis caru  
....................       {  
08F8:  MOVF   40,W
08F9:  XORLW  03
08FA:  BTFSC  03.2
08FB:  GOTO   103
08FC:  XORLW  01
08FD:  BTFSC  03.2
08FE:  GOTO   117
08FF:  XORLW  03
0900:  BTFSC  03.2
0901:  GOTO   150
0902:  GOTO   189
....................          case S:                          // rovne  
....................             FL; FR;  // pokud se jede dlouho rovne, tak pridej  
0903:  BSF    03.5
0904:  BCF    06.7
0905:  BCF    03.5
0906:  BCF    06.7
0907:  BSF    03.5
0908:  BCF    06.6
0909:  BCF    03.5
090A:  BSF    06.6
090B:  BSF    03.5
090C:  BCF    06.5
090D:  BCF    03.5
090E:  BCF    06.5
090F:  BSF    03.5
0910:  BCF    06.4
0911:  BCF    03.5
0912:  BSF    06.4
....................             dira=0;  
0913:  CLRF   46
....................             movement=S;  
0914:  MOVLW  03
0915:  MOVWF  45
....................             continue;  
0916:  GOTO   0DC
....................          case L:                          // trochu vlevo  
....................             GO(L, F, FW_POMALU+rovinka); GO(R, F, FW_STREDNE+rovinka);  
0917:  MOVF   01,W
0918:  MOVWF  73
0919:  MOVLW  E6
091A:  ADDWF  43,W
091B:  SUBWF  73,W
091C:  BTFSC  03.2
091D:  GOTO   120
091E:  BTFSC  03.0
091F:  GOTO   129
0920:  BSF    03.5
0921:  BCF    06.7
0922:  BCF    03.5
0923:  BCF    06.7
0924:  BSF    03.5
0925:  BCF    06.6
0926:  BCF    03.5
0927:  BSF    06.6
0928:  GOTO   131
0929:  BSF    03.5
092A:  BCF    06.6
092B:  BCF    03.5
092C:  BCF    06.6
092D:  BSF    03.5
092E:  BCF    06.7
092F:  BCF    03.5
0930:  BCF    06.7
0931:  MOVF   01,W
0932:  MOVWF  73
0933:  MOVLW  F0
0934:  ADDWF  43,W
0935:  SUBWF  73,W
0936:  BTFSC  03.2
0937:  GOTO   13A
0938:  BTFSC  03.0
0939:  GOTO   143
093A:  BSF    03.5
093B:  BCF    06.5
093C:  BCF    03.5
093D:  BCF    06.5
093E:  BSF    03.5
093F:  BCF    06.4
0940:  BCF    03.5
0941:  BSF    06.4
0942:  GOTO   14B
0943:  BSF    03.5
0944:  BCF    06.4
0945:  BCF    03.5
0946:  BCF    06.4
0947:  BSF    03.5
0948:  BCF    06.5
0949:  BCF    03.5
094A:  BCF    06.5
....................             line=L;  
094B:  MOVLW  02
094C:  MOVWF  41
....................             dira=0;  
094D:  CLRF   46
....................             movement=L;  
094E:  MOVWF  45
....................             continue;  
094F:  GOTO   0DC
....................          case R:                          // trochu vpravo  
....................             GO(R, F, FW_POMALU+rovinka); GO(L, F, FW_STREDNE+rovinka);  
0950:  MOVF   01,W
0951:  MOVWF  73
0952:  MOVLW  E6
0953:  ADDWF  43,W
0954:  SUBWF  73,W
0955:  BTFSC  03.2
0956:  GOTO   159
0957:  BTFSC  03.0
0958:  GOTO   162
0959:  BSF    03.5
095A:  BCF    06.5
095B:  BCF    03.5
095C:  BCF    06.5
095D:  BSF    03.5
095E:  BCF    06.4
095F:  BCF    03.5
0960:  BSF    06.4
0961:  GOTO   16A
0962:  BSF    03.5
0963:  BCF    06.4
0964:  BCF    03.5
0965:  BCF    06.4
0966:  BSF    03.5
0967:  BCF    06.5
0968:  BCF    03.5
0969:  BCF    06.5
096A:  MOVF   01,W
096B:  MOVWF  73
096C:  MOVLW  F0
096D:  ADDWF  43,W
096E:  SUBWF  73,W
096F:  BTFSC  03.2
0970:  GOTO   173
0971:  BTFSC  03.0
0972:  GOTO   17C
0973:  BSF    03.5
0974:  BCF    06.7
0975:  BCF    03.5
0976:  BCF    06.7
0977:  BSF    03.5
0978:  BCF    06.6
0979:  BCF    03.5
097A:  BSF    06.6
097B:  GOTO   184
097C:  BSF    03.5
097D:  BCF    06.6
097E:  BCF    03.5
097F:  BCF    06.6
0980:  BSF    03.5
0981:  BCF    06.7
0982:  BCF    03.5
0983:  BCF    06.7
....................             line=R;  
0984:  MOVLW  01
0985:  MOVWF  41
....................             dira=0;  
0986:  CLRF   46
....................             movement=R;  
0987:  MOVWF  45
....................             continue;  
0988:  GOTO   0DC
....................          default:       // kdyz jsou obe cidla mimo caru, tak pokracuj dal  
....................       }  
....................    rovinka=0;  
0989:  CLRF   43
....................       if (dira>=T_DIRA) prejeddiru();  
098A:  MOVF   46,W
098B:  SUBLW  54
098C:  BTFSC  03.0
098D:  GOTO   191
098E:  BCF    0A.3
098F:  GOTO   5B0
0990:  BSF    0A.3
....................       if (last!=line)     // pokud si prejel caru z jedne strany na druhou stranu, tak zabrzdi  
0991:  MOVF   41,W
0992:  SUBWF  44,W
0993:  BTFSC  03.2
0994:  GOTO   199
....................       {  
....................          last=line;  
0995:  MOVF   41,W
0996:  MOVWF  44
....................          speed=FW_ZATACKA;  
0997:  MOVLW  C8
0998:  MOVWF  42
....................       }  
....................       if (L==line)  // kdyz jsou obe cidla mimo caru, zatoc na caru  
0999:  MOVF   41,W
099A:  SUBLW  02
099B:  BTFSS  03.2
099C:  GOTO   1BD
....................       {  
....................          STOPL;  
099D:  BSF    03.5
099E:  BCF    06.6
099F:  BCF    03.5
09A0:  BCF    06.6
09A1:  BSF    03.5
09A2:  BCF    06.7
09A3:  BCF    03.5
09A4:  BCF    06.7
....................          GO(R, F, speed);  
09A5:  MOVF   01,W
09A6:  SUBWF  42,W
09A7:  BTFSS  03.0
09A8:  GOTO   1B2
09A9:  BSF    03.5
09AA:  BCF    06.5
09AB:  BCF    03.5
09AC:  BCF    06.5
09AD:  BSF    03.5
09AE:  BCF    06.4
09AF:  BCF    03.5
09B0:  BSF    06.4
09B1:  GOTO   1BA
09B2:  BSF    03.5
09B3:  BCF    06.4
09B4:  BCF    03.5
09B5:  BCF    06.4
09B6:  BSF    03.5
09B7:  BCF    06.5
09B8:  BCF    03.5
09B9:  BCF    06.5
....................          movement=L;  
09BA:  MOVLW  02
09BB:  MOVWF  45
....................       }  
....................       else  
09BC:  GOTO   1DC
....................       {  
....................          STOPR;  
09BD:  BSF    03.5
09BE:  BCF    06.4
09BF:  BCF    03.5
09C0:  BCF    06.4
09C1:  BSF    03.5
09C2:  BCF    06.5
09C3:  BCF    03.5
09C4:  BCF    06.5
....................          GO(L, F, speed);  
09C5:  MOVF   01,W
09C6:  SUBWF  42,W
09C7:  BTFSS  03.0
09C8:  GOTO   1D2
09C9:  BSF    03.5
09CA:  BCF    06.7
09CB:  BCF    03.5
09CC:  BCF    06.7
09CD:  BSF    03.5
09CE:  BCF    06.6
09CF:  BCF    03.5
09D0:  BSF    06.6
09D1:  GOTO   1DA
09D2:  BSF    03.5
09D3:  BCF    06.6
09D4:  BCF    03.5
09D5:  BCF    06.6
09D6:  BSF    03.5
09D7:  BCF    06.7
09D8:  BCF    03.5
09D9:  BCF    06.7
....................          movement=R;  
09DA:  MOVLW  01
09DB:  MOVWF  45
....................       }  
....................    } // while(true)  
09DC:  GOTO   0DC
.................... }  
....................   
....................  
09DD:  SLEEP

Configuration Fuses:
   Word  1: 3F38   NOWDT NOPUT MCLR NOBROWNOUT NOLVP NOCPD NOWRT NODEBUG CCPB0 NOPROTECT INTRC_IO
   Word  2: 3FFC   NOFCMEN NOIESO