Subversion Repositories svnkaklik

CCS PCM C Compiler, Version 3.221, 27853               18-VI-05 13:30

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

               ROM used: 1441 words (35%)
                         Largest free fragment is 2048
               RAM used: 27 (15%) at main() level
                         34 (19%) worst case
               Stack:    4 worst case (3 in main + 1 for interrupts)

*
0000:  MOVLW  00
0001:  MOVWF  0A
0002:  GOTO   2D1
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   037
....................  // Program pro predvadeni schopnosti robota Merkur  
.................... //------------------------------------------------  
....................   
.................... #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)  
*
0042:  MOVLW  12
0043:  SUBWF  3C,F
0044:  BTFSS  03.0
0045:  GOTO   054
0046:  MOVLW  3C
0047:  MOVWF  04
0048:  MOVLW  FC
0049:  ANDWF  00,F
004A:  BCF    03.0
004B:  RRF    00,F
004C:  RRF    00,F
004D:  MOVF   00,W
004E:  BTFSC  03.2
004F:  GOTO   054
0050:  GOTO   052
0051:  NOP
0052:  DECFSZ 00,F
0053:  GOTO   051
0054:  RETLW  00
*
0073:  MOVLW  37
0074:  MOVWF  04
0075:  MOVF   00,W
0076:  BTFSC  03.2
0077:  GOTO   087
0078:  MOVLW  01
0079:  MOVWF  78
007A:  CLRF   77
007B:  DECFSZ 77,F
007C:  GOTO   07B
007D:  DECFSZ 78,F
007E:  GOTO   07A
007F:  MOVLW  4A
0080:  MOVWF  77
0081:  DECFSZ 77,F
0082:  GOTO   081
0083:  NOP
0084:  NOP
0085:  DECFSZ 00,F
0086:  GOTO   078
0087:  RETLW  00
....................   
....................  
....................   
.................... 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 last;           // kde byla cara, kdyz byly minule cidla mimo  
.................... unsigned int8 rovinka;        // pocitadlo pro zjisteni rovneho useku  
.................... int cirkus;                   // pocitadlo, po kolika akcich se ma delat cirkus  
.................... int1 BW;                      // urcuje, jestli je cara cerno/bila nebo  
....................                               // bilo/cerna (true = bila cara, cerny podklad)  
....................   
.................... // Konstanty pro dynamiku pohybu  
.................... #define T_DIRA       120      // po jakem case zataceni se detekuje dira  
.................... #define FW_POMALU    170      // trochu mimo caru vnitrni pas  
.................... #define FW_ZATACKA   200      // rychlost vnejsiho kola pri zataceni  
.................... #define FW_STREDNE   190      // trochu mimo caru vnejsi pas  
.................... #define COUVANI      750      // couvnuti zpet na caru, po detekci diry  
.................... #define MAX_ROVINKA  (255-FW_STREDNE)  
.................... #define TRESHOLD     15       // rozhodovaci uroven komparatoru, 0xF = 0.75*Vdd  
.................... #define BUMPER_TRESHOLD 128   // rozhodovaci uroven cidla na prekazku  
....................   
.................... //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    (BW != C2OUT)      // Senzory na caru  
.................... #define LSENSOR    (BW != C1OUT)  
.................... #define BUMPER     sAN2     // Senzor na cihlu  
....................   
.................... #define DIAG_SERVO      PIN_B3   // Propojka pro diagnosticky mod  
.................... #define DIAG_SENSORS    PIN_B2   // Propojka pro diagnosticky mod  
.................... #define BARVY           PIN_B1   // Propojka pro nastaveni barvy cary  
....................   
.................... #define SPEAKER   PIN_B0     // vystup pro pipak  
....................   
.................... #define LED1   PIN_A4   // LEDky  
.................... #define LED2   PIN_A3  
.................... #define LED3   PIN_A7  
.................... #define LED4   PIN_A6  
....................   
.................... // makro pro PWM  
.................... #define GO(motor, direction, power) if(get_timer0()<=power) \  
.................... {direction##motor;} else {stop##motor;}  
....................   
.................... #int_TIMER2  
.................... void TIMER2_isr()  // obsluha zrychlovani  
.................... {  
....................    if (speed<255) speed++;  
*
0037:  INCFSZ 2B,W
0038:  GOTO   03A
0039:  GOTO   03B
003A:  INCF   2B,F
....................    if (rovinka<MAX_ROVINKA) rovinka++;  
003B:  MOVF   2D,W
003C:  SUBLW  40
003D:  BTFSC  03.0
003E:  INCF   2D,F
.................... }  
....................   
.................... // Primitivni Pipani  
003F:  BCF    0C.1
0040:  BCF    0A.3
0041:  GOTO   022
.................... void beep(unsigned int16 period, unsigned int16 length)  
.................... {  
....................    unsigned int16 nn;  
....................   
....................    for(nn=length; nn>0; nn--)  
*
0055:  MOVF   39,W
0056:  MOVWF  3B
0057:  MOVF   38,W
0058:  MOVWF  3A
0059:  MOVF   3A,F
005A:  BTFSS  03.2
005B:  GOTO   05F
005C:  MOVF   3B,F
005D:  BTFSC  03.2
005E:  GOTO   072
....................    {  
....................      output_high(SPEAKER);  
005F:  BSF    03.5
0060:  BCF    06.0
0061:  BCF    03.5
0062:  BSF    06.0
....................      delay_us(period);  
0063:  MOVF   36,W
0064:  MOVWF  3C
0065:  CALL   042
....................      output_low(SPEAKER);  
0066:  BSF    03.5
0067:  BCF    06.0
0068:  BCF    03.5
0069:  BCF    06.0
....................      delay_us(period);  
006A:  MOVF   36,W
006B:  MOVWF  3C
006C:  CALL   042
....................    }  
006D:  MOVF   3A,W
006E:  BTFSC  03.2
006F:  DECF   3B,F
0070:  DECF   3A,F
0071:  GOTO   059
.................... }  
0072:  RETLW  00
.................... /******************************************************************************/  
.................... void diagnostika()  
.................... {  
....................    unsigned int16 n;  
....................   
....................    while (input(DIAG_SERVO))   // Propojka, ktera spousti diagnostiku  
....................    {  
*
0088:  BSF    03.5
0089:  BSF    06.3
008A:  BCF    03.5
008B:  BTFSS  06.3
008C:  GOTO   1B3
....................       for (n=500; n<800; n+=100)  
008D:  MOVLW  01
008E:  MOVWF  35
008F:  MOVLW  F4
0090:  MOVWF  34
0091:  MOVF   35,W
0092:  SUBLW  03
0093:  BTFSS  03.0
0094:  GOTO   0A9
0095:  BTFSS  03.2
0096:  GOTO   09B
0097:  MOVF   34,W
0098:  SUBLW  1F
0099:  BTFSS  03.0
009A:  GOTO   0A9
....................       {  
....................          beep(n,n); //beep UP  
009B:  MOVF   35,W
009C:  MOVWF  37
009D:  MOVF   34,W
009E:  MOVWF  36
009F:  MOVF   35,W
00A0:  MOVWF  39
00A1:  MOVF   34,W
00A2:  MOVWF  38
00A3:  CALL   055
....................       };  
00A4:  MOVLW  64
00A5:  ADDWF  34,F
00A6:  BTFSC  03.0
00A7:  INCF   35,F
00A8:  GOTO   091
....................       Delay_ms(1000);  
00A9:  MOVLW  04
00AA:  MOVWF  36
00AB:  MOVLW  FA
00AC:  MOVWF  37
00AD:  CALL   073
00AE:  DECFSZ 36,F
00AF:  GOTO   0AB
....................       //zastav vse  
....................       STOPL; STOPR;  
00B0:  BSF    03.5
00B1:  BCF    06.6
00B2:  BCF    03.5
00B3:  BCF    06.6
00B4:  BSF    03.5
00B5:  BCF    06.7
00B6:  BCF    03.5
00B7:  BCF    06.7
00B8:  BSF    03.5
00B9:  BCF    06.4
00BA:  BCF    03.5
00BB:  BCF    06.4
00BC:  BSF    03.5
00BD:  BCF    06.5
00BE:  BCF    03.5
00BF:  BCF    06.5
....................       //pravy pas  
....................       FR; Delay_ms(1000); STOPR; Delay_ms(1000);  
00C0:  BSF    03.5
00C1:  BCF    06.5
00C2:  BCF    03.5
00C3:  BCF    06.5
00C4:  BSF    03.5
00C5:  BCF    06.4
00C6:  BCF    03.5
00C7:  BSF    06.4
00C8:  MOVLW  04
00C9:  MOVWF  36
00CA:  MOVLW  FA
00CB:  MOVWF  37
00CC:  CALL   073
00CD:  DECFSZ 36,F
00CE:  GOTO   0CA
00CF:  BSF    03.5
00D0:  BCF    06.4
00D1:  BCF    03.5
00D2:  BCF    06.4
00D3:  BSF    03.5
00D4:  BCF    06.5
00D5:  BCF    03.5
00D6:  BCF    06.5
00D7:  MOVLW  04
00D8:  MOVWF  36
00D9:  MOVLW  FA
00DA:  MOVWF  37
00DB:  CALL   073
00DC:  DECFSZ 36,F
00DD:  GOTO   0D9
....................       BR; Delay_ms(1000); STOPR; Delay_ms(1000);  
00DE:  BSF    03.5
00DF:  BCF    06.4
00E0:  BCF    03.5
00E1:  BCF    06.4
00E2:  BSF    03.5
00E3:  BCF    06.5
00E4:  BCF    03.5
00E5:  BSF    06.5
00E6:  MOVLW  04
00E7:  MOVWF  36
00E8:  MOVLW  FA
00E9:  MOVWF  37
00EA:  CALL   073
00EB:  DECFSZ 36,F
00EC:  GOTO   0E8
00ED:  BSF    03.5
00EE:  BCF    06.4
00EF:  BCF    03.5
00F0:  BCF    06.4
00F1:  BSF    03.5
00F2:  BCF    06.5
00F3:  BCF    03.5
00F4:  BCF    06.5
00F5:  MOVLW  04
00F6:  MOVWF  36
00F7:  MOVLW  FA
00F8:  MOVWF  37
00F9:  CALL   073
00FA:  DECFSZ 36,F
00FB:  GOTO   0F7
....................       Beep(880,100); Delay_ms(1000);  
00FC:  MOVLW  03
00FD:  MOVWF  37
00FE:  MOVLW  70
00FF:  MOVWF  36
0100:  CLRF   39
0101:  MOVLW  64
0102:  MOVWF  38
0103:  CALL   055
0104:  MOVLW  04
0105:  MOVWF  36
0106:  MOVLW  FA
0107:  MOVWF  37
0108:  CALL   073
0109:  DECFSZ 36,F
010A:  GOTO   106
....................       //levy pas  
....................       FL; Delay_ms(1000); STOPL; Delay_ms(1000);  
010B:  BSF    03.5
010C:  BCF    06.7
010D:  BCF    03.5
010E:  BCF    06.7
010F:  BSF    03.5
0110:  BCF    06.6
0111:  BCF    03.5
0112:  BSF    06.6
0113:  MOVLW  04
0114:  MOVWF  36
0115:  MOVLW  FA
0116:  MOVWF  37
0117:  CALL   073
0118:  DECFSZ 36,F
0119:  GOTO   115
011A:  BSF    03.5
011B:  BCF    06.6
011C:  BCF    03.5
011D:  BCF    06.6
011E:  BSF    03.5
011F:  BCF    06.7
0120:  BCF    03.5
0121:  BCF    06.7
0122:  MOVLW  04
0123:  MOVWF  36
0124:  MOVLW  FA
0125:  MOVWF  37
0126:  CALL   073
0127:  DECFSZ 36,F
0128:  GOTO   124
....................       BL; Delay_ms(1000); STOPL; Delay_ms(1000);  
0129:  BSF    03.5
012A:  BCF    06.6
012B:  BCF    03.5
012C:  BCF    06.6
012D:  BSF    03.5
012E:  BCF    06.7
012F:  BCF    03.5
0130:  BSF    06.7
0131:  MOVLW  04
0132:  MOVWF  36
0133:  MOVLW  FA
0134:  MOVWF  37
0135:  CALL   073
0136:  DECFSZ 36,F
0137:  GOTO   133
0138:  BSF    03.5
0139:  BCF    06.6
013A:  BCF    03.5
013B:  BCF    06.6
013C:  BSF    03.5
013D:  BCF    06.7
013E:  BCF    03.5
013F:  BCF    06.7
0140:  MOVLW  04
0141:  MOVWF  36
0142:  MOVLW  FA
0143:  MOVWF  37
0144:  CALL   073
0145:  DECFSZ 36,F
0146:  GOTO   142
....................       Beep(880,100); Delay_ms(1000);  
0147:  MOVLW  03
0148:  MOVWF  37
0149:  MOVLW  70
014A:  MOVWF  36
014B:  CLRF   39
014C:  MOVLW  64
014D:  MOVWF  38
014E:  CALL   055
014F:  MOVLW  04
0150:  MOVWF  36
0151:  MOVLW  FA
0152:  MOVWF  37
0153:  CALL   073
0154:  DECFSZ 36,F
0155:  GOTO   151
....................       //oba pasy  
....................       FL; FR; Delay_ms(1000); STOPL; STOPR; Delay_ms(1000);  
0156:  BSF    03.5
0157:  BCF    06.7
0158:  BCF    03.5
0159:  BCF    06.7
015A:  BSF    03.5
015B:  BCF    06.6
015C:  BCF    03.5
015D:  BSF    06.6
015E:  BSF    03.5
015F:  BCF    06.5
0160:  BCF    03.5
0161:  BCF    06.5
0162:  BSF    03.5
0163:  BCF    06.4
0164:  BCF    03.5
0165:  BSF    06.4
0166:  MOVLW  04
0167:  MOVWF  36
0168:  MOVLW  FA
0169:  MOVWF  37
016A:  CALL   073
016B:  DECFSZ 36,F
016C:  GOTO   168
016D:  BSF    03.5
016E:  BCF    06.6
016F:  BCF    03.5
0170:  BCF    06.6
0171:  BSF    03.5
0172:  BCF    06.7
0173:  BCF    03.5
0174:  BCF    06.7
0175:  BSF    03.5
0176:  BCF    06.4
0177:  BCF    03.5
0178:  BCF    06.4
0179:  BSF    03.5
017A:  BCF    06.5
017B:  BCF    03.5
017C:  BCF    06.5
017D:  MOVLW  04
017E:  MOVWF  36
017F:  MOVLW  FA
0180:  MOVWF  37
0181:  CALL   073
0182:  DECFSZ 36,F
0183:  GOTO   17F
....................       BL; BR; Delay_ms(1000); STOPL; STOPR; Delay_ms(1000);  
0184:  BSF    03.5
0185:  BCF    06.6
0186:  BCF    03.5
0187:  BCF    06.6
0188:  BSF    03.5
0189:  BCF    06.7
018A:  BCF    03.5
018B:  BSF    06.7
018C:  BSF    03.5
018D:  BCF    06.4
018E:  BCF    03.5
018F:  BCF    06.4
0190:  BSF    03.5
0191:  BCF    06.5
0192:  BCF    03.5
0193:  BSF    06.5
0194:  MOVLW  04
0195:  MOVWF  36
0196:  MOVLW  FA
0197:  MOVWF  37
0198:  CALL   073
0199:  DECFSZ 36,F
019A:  GOTO   196
019B:  BSF    03.5
019C:  BCF    06.6
019D:  BCF    03.5
019E:  BCF    06.6
019F:  BSF    03.5
01A0:  BCF    06.7
01A1:  BCF    03.5
01A2:  BCF    06.7
01A3:  BSF    03.5
01A4:  BCF    06.4
01A5:  BCF    03.5
01A6:  BCF    06.4
01A7:  BSF    03.5
01A8:  BCF    06.5
01A9:  BCF    03.5
01AA:  BCF    06.5
01AB:  MOVLW  04
01AC:  MOVWF  36
01AD:  MOVLW  FA
01AE:  MOVWF  37
01AF:  CALL   073
01B0:  DECFSZ 36,F
01B1:  GOTO   1AD
....................    };  
01B2:  GOTO   088
....................    while (input(DIAG_SENSORS))         // spusteni diagnostiky cidel  
....................    {  
01B3:  BSF    03.5
01B4:  BSF    06.2
01B5:  BCF    03.5
01B6:  BTFSS  06.2
01B7:  GOTO   1F6
....................       if (RSENSOR) beep(1000,200);  
01B8:  CLRF   77
01B9:  BSF    03.5
01BA:  BTFSC  1C.7
01BB:  BSF    77.0
01BC:  BCF    03.5
01BD:  MOVF   2F,W
01BE:  XORWF  77,W
01BF:  ANDLW  01
01C0:  BTFSC  03.2
01C1:  GOTO   1CA
01C2:  MOVLW  03
01C3:  MOVWF  37
01C4:  MOVLW  E8
01C5:  MOVWF  36
01C6:  CLRF   39
01C7:  MOVLW  C8
01C8:  MOVWF  38
01C9:  CALL   055
....................       Delay_ms(200);  
01CA:  MOVLW  C8
01CB:  MOVWF  37
01CC:  CALL   073
....................       if (LSENSOR) beep(2000,300);  
01CD:  CLRF   77
01CE:  BSF    03.5
01CF:  BTFSC  1C.6
01D0:  BSF    77.0
01D1:  BCF    03.5
01D2:  MOVF   2F,W
01D3:  XORWF  77,W
01D4:  ANDLW  01
01D5:  BTFSC  03.2
01D6:  GOTO   1E0
01D7:  MOVLW  07
01D8:  MOVWF  37
01D9:  MOVLW  D0
01DA:  MOVWF  36
01DB:  MOVLW  01
01DC:  MOVWF  39
01DD:  MOVLW  2C
01DE:  MOVWF  38
01DF:  CALL   055
....................       Delay_ms(200);  
01E0:  MOVLW  C8
01E1:  MOVWF  37
01E2:  CALL   073
....................       if ((read_adc(ADC_READ_ONLY)<BUMPER_TRESHOLD)) beep(3000,400);  
01E3:  BTFSC  1F.2
01E4:  GOTO   1E3
01E5:  MOVF   1E,W
01E6:  SUBLW  7F
01E7:  BTFSS  03.0
01E8:  GOTO   1F2
01E9:  MOVLW  0B
01EA:  MOVWF  37
01EB:  MOVLW  B8
01EC:  MOVWF  36
01ED:  MOVLW  01
01EE:  MOVWF  39
01EF:  MOVLW  90
01F0:  MOVWF  38
01F1:  CALL   055
....................       Delay_ms(200);  
01F2:  MOVLW  C8
01F3:  MOVWF  37
01F4:  CALL   073
....................    };  
01F5:  GOTO   1B3
.................... }  
01F6:  BCF    0A.3
01F7:  GOTO   378 (RETURN)
.................... ///////////////////////////////////////////////////////////////////////////////  
.................... void OtocSe()                     // otoci se zpet, kdyz je prekazka  
.................... {  
....................    unsigned int16 n;  
....................   
....................    BL; BR;                    // cukni zpatky  
01F8:  BSF    03.5
01F9:  BCF    06.6
01FA:  BCF    03.5
01FB:  BCF    06.6
01FC:  BSF    03.5
01FD:  BCF    06.7
01FE:  BCF    03.5
01FF:  BSF    06.7
0200:  BSF    03.5
0201:  BCF    06.4
0202:  BCF    03.5
0203:  BCF    06.4
0204:  BSF    03.5
0205:  BCF    06.5
0206:  BCF    03.5
0207:  BSF    06.5
....................    Delay_ms(200);  
0208:  MOVLW  C8
0209:  MOVWF  37
020A:  CALL   073
....................    STOPR;STOPL;  
020B:  BSF    03.5
020C:  BCF    06.4
020D:  BCF    03.5
020E:  BCF    06.4
020F:  BSF    03.5
0210:  BCF    06.5
0211:  BCF    03.5
0212:  BCF    06.5
0213:  BSF    03.5
0214:  BCF    06.6
0215:  BCF    03.5
0216:  BCF    06.6
0217:  BSF    03.5
0218:  BCF    06.7
0219:  BCF    03.5
021A:  BCF    06.7
....................    beep(800,400);  
021B:  MOVLW  03
021C:  MOVWF  37
021D:  MOVLW  20
021E:  MOVWF  36
021F:  MOVLW  01
0220:  MOVWF  39
0221:  MOVLW  90
0222:  MOVWF  38
0223:  CALL   055
....................    beep(2000,1000);  
0224:  MOVLW  07
0225:  MOVWF  37
0226:  MOVLW  D0
0227:  MOVWF  36
0228:  MOVLW  03
0229:  MOVWF  39
022A:  MOVLW  E8
022B:  MOVWF  38
022C:  CALL   055
....................    output_low(LED4);  
022D:  BSF    03.5
022E:  BCF    05.6
022F:  BCF    03.5
0230:  BCF    05.6
....................    beep(900,400);  
0231:  MOVLW  03
0232:  MOVWF  37
0233:  MOVLW  84
0234:  MOVWF  36
0235:  MOVLW  01
0236:  MOVWF  39
0237:  MOVLW  90
0238:  MOVWF  38
0239:  CALL   055
....................    output_low(LED1);  
023A:  BSF    03.5
023B:  BCF    05.4
023C:  BCF    03.5
023D:  BCF    05.4
....................   
....................    BR; FL; Delay_ms(100);           // otoc se 30° do prava  
023E:  BSF    03.5
023F:  BCF    06.4
0240:  BCF    03.5
0241:  BCF    06.4
0242:  BSF    03.5
0243:  BCF    06.5
0244:  BCF    03.5
0245:  BSF    06.5
0246:  BSF    03.5
0247:  BCF    06.7
0248:  BCF    03.5
0249:  BCF    06.7
024A:  BSF    03.5
024B:  BCF    06.6
024C:  BCF    03.5
024D:  BSF    06.6
024E:  MOVLW  64
024F:  MOVWF  37
0250:  CALL   073
....................    STOPL; STOPR;  
0251:  BSF    03.5
0252:  BCF    06.6
0253:  BCF    03.5
0254:  BCF    06.6
0255:  BSF    03.5
0256:  BCF    06.7
0257:  BCF    03.5
0258:  BCF    06.7
0259:  BSF    03.5
025A:  BCF    06.4
025B:  BCF    03.5
025C:  BCF    06.4
025D:  BSF    03.5
025E:  BCF    06.5
025F:  BCF    03.5
0260:  BCF    06.5
....................    beep(1000,1000);  
0261:  MOVLW  03
0262:  MOVWF  37
0263:  MOVLW  E8
0264:  MOVWF  36
0265:  MOVLW  03
0266:  MOVWF  39
0267:  MOVLW  E8
0268:  MOVWF  38
0269:  CALL   055
....................    output_low(LED3);  
026A:  BSF    03.5
026B:  BCF    05.7
026C:  BCF    03.5
026D:  BCF    05.7
....................   
....................    BR; FL;  
026E:  BSF    03.5
026F:  BCF    06.4
0270:  BCF    03.5
0271:  BCF    06.4
0272:  BSF    03.5
0273:  BCF    06.5
0274:  BCF    03.5
0275:  BSF    06.5
0276:  BSF    03.5
0277:  BCF    06.7
0278:  BCF    03.5
0279:  BCF    06.7
027A:  BSF    03.5
027B:  BCF    06.6
027C:  BCF    03.5
027D:  BSF    06.6
....................    for(n=40000;n>0;n--)               // toc se, dokud nenarazis na caru  
027E:  MOVLW  9C
027F:  MOVWF  35
0280:  MOVLW  40
0281:  MOVWF  34
0282:  MOVF   34,F
0283:  BTFSS  03.2
0284:  GOTO   288
0285:  MOVF   35,F
0286:  BTFSC  03.2
0287:  GOTO   2B0
....................    {  
....................       line = RSENSOR;         // cteni senzoru na caru  
0288:  CLRF   77
0289:  BSF    03.5
028A:  BTFSC  1C.7
028B:  BSF    77.0
028C:  BCF    03.5
028D:  MOVF   2F,W
028E:  XORWF  77,W
028F:  ANDLW  01
0290:  BTFSS  03.2
0291:  GOTO   294
0292:  MOVLW  00
0293:  GOTO   295
0294:  MOVLW  01
0295:  MOVWF  2A
....................       line |= LSENSOR << 1;  
0296:  CLRF   77
0297:  BSF    03.5
0298:  BTFSC  1C.6
0299:  BSF    77.0
029A:  BCF    03.5
029B:  MOVF   2F,W
029C:  XORWF  77,W
029D:  ANDLW  01
029E:  BTFSS  03.2
029F:  GOTO   2A2
02A0:  MOVLW  00
02A1:  GOTO   2A3
02A2:  MOVLW  01
02A3:  MOVWF  77
02A4:  BCF    03.0
02A5:  RLF    77,F
02A6:  MOVF   77,W
02A7:  IORWF  2A,F
....................       if (line!=0) break;  
02A8:  MOVF   2A,F
02A9:  BTFSS  03.2
02AA:  GOTO   2B0
....................    }  
02AB:  MOVF   34,W
02AC:  BTFSC  03.2
02AD:  DECF   35,F
02AE:  DECF   34,F
02AF:  GOTO   282
....................    STOPR; STOPL;  
02B0:  BSF    03.5
02B1:  BCF    06.4
02B2:  BCF    03.5
02B3:  BCF    06.4
02B4:  BSF    03.5
02B5:  BCF    06.5
02B6:  BCF    03.5
02B7:  BCF    06.5
02B8:  BSF    03.5
02B9:  BCF    06.6
02BA:  BCF    03.5
02BB:  BCF    06.6
02BC:  BSF    03.5
02BD:  BCF    06.7
02BE:  BCF    03.5
02BF:  BCF    06.7
....................    output_high(LED1); output_high(LED3); output_high(LED4);  
02C0:  BSF    03.5
02C1:  BCF    05.4
02C2:  BCF    03.5
02C3:  BSF    05.4
02C4:  BSF    03.5
02C5:  BCF    05.7
02C6:  BCF    03.5
02C7:  BSF    05.7
02C8:  BSF    03.5
02C9:  BCF    05.6
02CA:  BCF    03.5
02CB:  BSF    05.6
....................   
....................    line=L; // caru jsme prejeli, tak je vlevo  
02CC:  MOVLW  02
02CD:  MOVWF  2A
....................    cirkus=0;  
02CE:  CLRF   2E
.................... }  
02CF:  BCF    0A.3
02D0:  GOTO   3F1 (RETURN)
....................   
....................   
.................... void main()  
.................... {  
02D1:  CLRF   04
02D2:  MOVLW  1F
02D3:  ANDWF  03,F
02D4:  BSF    03.5
02D5:  BCF    1F.4
02D6:  BCF    1F.5
02D7:  MOVF   1B,W
02D8:  ANDLW  80
02D9:  MOVWF  1B
02DA:  MOVLW  07
02DB:  MOVWF  1C
02DC:  MOVF   1C,W
02DD:  BCF    03.5
02DE:  BCF    0D.6
02DF:  MOVLW  60
02E0:  BSF    03.5
02E1:  MOVWF  0F
....................    unsigned int16 n; // pro FOR  
....................    unsigned int16 i;  
....................   
....................    STOPL; STOPR;     // prepne vystupy na ovladani motoru na output a zastavi  
02E2:  BCF    06.6
02E3:  BCF    03.5
02E4:  BCF    06.6
02E5:  BSF    03.5
02E6:  BCF    06.7
02E7:  BCF    03.5
02E8:  BCF    06.7
02E9:  BSF    03.5
02EA:  BCF    06.4
02EB:  BCF    03.5
02EC:  BCF    06.4
02ED:  BSF    03.5
02EE:  BCF    06.5
02EF:  BCF    03.5
02F0:  BCF    06.5
....................   
....................    setup_oscillator(OSC_4MHZ|OSC_INTRC);     // 4 MHz interni RC oscilator  
02F1:  MOVLW  62
02F2:  BSF    03.5
02F3:  MOVWF  0F
....................   
....................    port_b_pullups(TRUE);      // pullups pro piano na diagnostiku  
02F4:  BCF    01.7
....................    setup_spi(FALSE);  
02F5:  BCF    03.5
02F6:  BCF    14.5
02F7:  BSF    03.5
02F8:  BCF    06.2
02F9:  BSF    06.1
02FA:  BCF    06.4
02FB:  MOVLW  00
02FC:  BCF    03.5
02FD:  MOVWF  14
02FE:  BSF    03.5
02FF:  MOVWF  14
....................    setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);  // Casovac pro PWM  
0300:  MOVF   01,W
0301:  ANDLW  C7
0302:  IORLW  08
0303:  MOVWF  01
....................   
....................    setup_timer_2(T2_DIV_BY_4,255,10);    // Casovac pro regulaci  
0304:  MOVLW  48
0305:  MOVWF  78
0306:  IORLW  05
0307:  BCF    03.5
0308:  MOVWF  12
0309:  MOVLW  FF
030A:  BSF    03.5
030B:  MOVWF  12
....................                                          // preruseni kazdych 10ms  
....................    setup_adc_ports(BUMPER|VSS_VDD);      // nastaveni A/D prevodniku pro naraznik  
030C:  BCF    1F.4
030D:  BCF    1F.5
030E:  MOVF   1B,W
030F:  ANDLW  80
0310:  IORLW  04
0311:  MOVWF  1B
....................    setup_adc(ADC_CLOCK_INTERNAL);  
0312:  BCF    1F.6
0313:  BCF    03.5
0314:  BSF    1F.6
0315:  BSF    1F.7
0316:  BSF    03.5
0317:  BCF    1F.7
0318:  BCF    03.5
0319:  BSF    1F.0
....................    set_adc_channel(2);  
031A:  MOVLW  10
031B:  MOVWF  78
031C:  MOVF   1F,W
031D:  ANDLW  C7
031E:  IORWF  78,W
031F:  MOVWF  1F
....................    setup_timer_1(T1_INTERNAL|T1_DIV_BY_1);   // Casovac pro naraznik  
0320:  MOVLW  85
0321:  MOVWF  10
....................    setup_ccp1(CCP_COMPARE_RESET_TIMER);  
0322:  BSF    03.5
0323:  BSF    06.3
0324:  MOVLW  0B
0325:  BCF    03.5
0326:  MOVWF  17
....................    CCP_1=(2^10)-1;                        // prevod kazdou 1ms  
0327:  CLRF   16
0328:  MOVLW  07
0329:  MOVWF  15
....................   
....................    output_low(LED1); output_low(LED2); output_low(LED3); output_low(LED4);  
032A:  BSF    03.5
032B:  BCF    05.4
032C:  BCF    03.5
032D:  BCF    05.4
032E:  BSF    03.5
032F:  BCF    05.3
0330:  BCF    03.5
0331:  BCF    05.3
0332:  BSF    03.5
0333:  BCF    05.7
0334:  BCF    03.5
0335:  BCF    05.7
0336:  BSF    03.5
0337:  BCF    05.6
0338:  BCF    03.5
0339:  BCF    05.6
....................   
....................    setup_comparator(A0_VR_A1_VR);   // inicializace komparatoru pro cidla cary  
033A:  MOVLW  02
033B:  BSF    03.5
033C:  MOVWF  1C
033D:  MOVF   05,W
033E:  IORLW  03
033F:  MOVWF  05
0340:  MOVLW  03
0341:  MOVWF  77
0342:  DECFSZ 77,F
0343:  GOTO   342
0344:  MOVF   1C,W
0345:  BCF    03.5
0346:  BCF    0D.6
....................    setup_vref(VREF_HIGH|TRESHOLD);        // 32 kroku od 0.25 do 0.75 Vdd  
0347:  MOVLW  8F
0348:  BSF    03.5
0349:  MOVWF  1D
....................   
....................    Beep(1000,200);     //double beep  
034A:  MOVLW  03
034B:  BCF    03.5
034C:  MOVWF  37
034D:  MOVLW  E8
034E:  MOVWF  36
034F:  CLRF   39
0350:  MOVLW  C8
0351:  MOVWF  38
0352:  CALL   055
....................    Delay_ms(50);  
0353:  MOVLW  32
0354:  MOVWF  37
0355:  CALL   073
....................    Beep(1000,200);  
0356:  MOVLW  03
0357:  MOVWF  37
0358:  MOVLW  E8
0359:  MOVWF  36
035A:  CLRF   39
035B:  MOVLW  C8
035C:  MOVWF  38
035D:  CALL   055
....................    Delay_ms(1000);      // 1s  
035E:  MOVLW  04
035F:  MOVWF  34
0360:  MOVLW  FA
0361:  MOVWF  37
0362:  CALL   073
0363:  DECFSZ 34,F
0364:  GOTO   360
....................   
....................    // povoleni rizeni rychlosti zataceni pres preruseni  
....................    enable_interrupts(INT_TIMER2);  
0365:  BSF    03.5
0366:  BSF    0C.1
....................    enable_interrupts(GLOBAL);  
0367:  MOVLW  C0
0368:  BCF    03.5
0369:  IORWF  0B,F
....................   
.................... /*---------------------------------------------------------------------------*/  
....................    sensors=S;  
036A:  MOVLW  03
036B:  MOVWF  29
....................    line=S;  
036C:  MOVWF  2A
....................    last=S;  
036D:  MOVWF  2C
....................    cirkus=0;  
036E:  CLRF   2E
.................... //   movement=S;  
....................    speed=FW_POMALU;  
036F:  MOVLW  AA
0370:  MOVWF  2B
....................   
....................    BW=input(BARVY);     // Jaka ma byt barva cary? 
0371:  BSF    03.5
0372:  BSF    06.1
0373:  BCF    03.5
0374:  BCF    2F.0
0375:  BTFSC  06.1
0376:  BSF    2F.0
....................    diagnostika();       // Zkus, jestli nekdo nechce, diagnostiku  
0377:  GOTO   088
....................    Delay_ms(500);  
0378:  MOVLW  02
0379:  MOVWF  34
037A:  MOVLW  FA
037B:  MOVWF  37
037C:  CALL   073
037D:  DECFSZ 34,F
037E:  GOTO   37A
....................   
....................    output_high(LED1); Beep(1000,200); Delay_ms(500);  
037F:  BSF    03.5
0380:  BCF    05.4
0381:  BCF    03.5
0382:  BSF    05.4
0383:  MOVLW  03
0384:  MOVWF  37
0385:  MOVLW  E8
0386:  MOVWF  36
0387:  CLRF   39
0388:  MOVLW  C8
0389:  MOVWF  38
038A:  CALL   055
038B:  MOVLW  02
038C:  MOVWF  34
038D:  MOVLW  FA
038E:  MOVWF  37
038F:  CALL   073
0390:  DECFSZ 34,F
0391:  GOTO   38D
....................    output_high(LED2); Beep(1000,200); Delay_ms(500);  
0392:  BSF    03.5
0393:  BCF    05.3
0394:  BCF    03.5
0395:  BSF    05.3
0396:  MOVLW  03
0397:  MOVWF  37
0398:  MOVLW  E8
0399:  MOVWF  36
039A:  CLRF   39
039B:  MOVLW  C8
039C:  MOVWF  38
039D:  CALL   055
039E:  MOVLW  02
039F:  MOVWF  34
03A0:  MOVLW  FA
03A1:  MOVWF  37
03A2:  CALL   073
03A3:  DECFSZ 34,F
03A4:  GOTO   3A0
....................    output_high(LED3); Beep(1000,200); Delay_ms(500);  
03A5:  BSF    03.5
03A6:  BCF    05.7
03A7:  BCF    03.5
03A8:  BSF    05.7
03A9:  MOVLW  03
03AA:  MOVWF  37
03AB:  MOVLW  E8
03AC:  MOVWF  36
03AD:  CLRF   39
03AE:  MOVLW  C8
03AF:  MOVWF  38
03B0:  CALL   055
03B1:  MOVLW  02
03B2:  MOVWF  34
03B3:  MOVLW  FA
03B4:  MOVWF  37
03B5:  CALL   073
03B6:  DECFSZ 34,F
03B7:  GOTO   3B3
....................    output_high(LED4); Beep(1000,200); Delay_ms(500);  
03B8:  BSF    03.5
03B9:  BCF    05.6
03BA:  BCF    03.5
03BB:  BSF    05.6
03BC:  MOVLW  03
03BD:  MOVWF  37
03BE:  MOVLW  E8
03BF:  MOVWF  36
03C0:  CLRF   39
03C1:  MOVLW  C8
03C2:  MOVWF  38
03C3:  CALL   055
03C4:  MOVLW  02
03C5:  MOVWF  34
03C6:  MOVLW  FA
03C7:  MOVWF  37
03C8:  CALL   073
03C9:  DECFSZ 34,F
03CA:  GOTO   3C6
....................   
....................    while(true)       // hlavni smycka (jizda podle cary)  
....................    {  
....................       sensors = RSENSOR;         // cteni senzoru na caru  
03CB:  CLRF   77
03CC:  BSF    03.5
03CD:  BTFSC  1C.7
03CE:  BSF    77.0
03CF:  BCF    03.5
03D0:  MOVF   2F,W
03D1:  XORWF  77,W
03D2:  ANDLW  01
03D3:  BTFSS  03.2
03D4:  GOTO   3D7
03D5:  MOVLW  00
03D6:  GOTO   3D8
03D7:  MOVLW  01
03D8:  MOVWF  29
....................       sensors |= LSENSOR << 1;  
03D9:  CLRF   77
03DA:  BSF    03.5
03DB:  BTFSC  1C.6
03DC:  BSF    77.0
03DD:  BCF    03.5
03DE:  MOVF   2F,W
03DF:  XORWF  77,W
03E0:  ANDLW  01
03E1:  BTFSS  03.2
03E2:  GOTO   3E5
03E3:  MOVLW  00
03E4:  GOTO   3E6
03E5:  MOVLW  01
03E6:  MOVWF  77
03E7:  BCF    03.0
03E8:  RLF    77,F
03E9:  MOVF   77,W
03EA:  IORWF  29,F
....................   
....................       if (read_adc(ADC_READ_ONLY)<BUMPER_TRESHOLD) OtocSe();  
03EB:  BTFSC  1F.2
03EC:  GOTO   3EB
03ED:  MOVF   1E,W
03EE:  SUBLW  7F
03EF:  BTFSC  03.0
03F0:  GOTO   1F8
....................   
....................       switch (sensors)  // zatacej podle toho, kde vidis caru  
....................       {  
03F1:  MOVF   29,W
03F2:  XORLW  03
03F3:  BTFSC  03.2
03F4:  GOTO   3FC
03F5:  XORLW  01
03F6:  BTFSC  03.2
03F7:  GOTO   431
03F8:  XORLW  03
03F9:  BTFSC  03.2
03FA:  GOTO   468
03FB:  GOTO   49F
....................          case S:                          // rovne  
....................             GO(L, F, FW_STREDNE+rovinka); GO(R, F, FW_STREDNE+rovinka);  
03FC:  MOVF   01,W
03FD:  MOVWF  34
03FE:  MOVLW  BE
03FF:  ADDWF  2D,W
0400:  SUBWF  34,W
0401:  BTFSC  03.2
0402:  GOTO   405
0403:  BTFSC  03.0
0404:  GOTO   40E
0405:  BSF    03.5
0406:  BCF    06.7
0407:  BCF    03.5
0408:  BCF    06.7
0409:  BSF    03.5
040A:  BCF    06.6
040B:  BCF    03.5
040C:  BSF    06.6
040D:  GOTO   416
040E:  BSF    03.5
040F:  BCF    06.6
0410:  BCF    03.5
0411:  BCF    06.6
0412:  BSF    03.5
0413:  BCF    06.7
0414:  BCF    03.5
0415:  BCF    06.7
0416:  MOVF   01,W
0417:  MOVWF  34
0418:  MOVLW  BE
0419:  ADDWF  2D,W
041A:  SUBWF  34,W
041B:  BTFSC  03.2
041C:  GOTO   41F
041D:  BTFSC  03.0
041E:  GOTO   428
041F:  BSF    03.5
0420:  BCF    06.5
0421:  BCF    03.5
0422:  BCF    06.5
0423:  BSF    03.5
0424:  BCF    06.4
0425:  BCF    03.5
0426:  BSF    06.4
0427:  GOTO   430
0428:  BSF    03.5
0429:  BCF    06.4
042A:  BCF    03.5
042B:  BCF    06.4
042C:  BSF    03.5
042D:  BCF    06.5
042E:  BCF    03.5
042F:  BCF    06.5
....................             continue;  
0430:  GOTO   3CB
....................          case L:                          // trochu vlevo  
....................             GO(L, F, FW_POMALU+rovinka); GO(R, F, FW_STREDNE+rovinka);  
0431:  MOVF   01,W
0432:  MOVWF  34
0433:  MOVLW  AA
0434:  ADDWF  2D,W
0435:  SUBWF  34,W
0436:  BTFSC  03.2
0437:  GOTO   43A
0438:  BTFSC  03.0
0439:  GOTO   443
043A:  BSF    03.5
043B:  BCF    06.7
043C:  BCF    03.5
043D:  BCF    06.7
043E:  BSF    03.5
043F:  BCF    06.6
0440:  BCF    03.5
0441:  BSF    06.6
0442:  GOTO   44B
0443:  BSF    03.5
0444:  BCF    06.6
0445:  BCF    03.5
0446:  BCF    06.6
0447:  BSF    03.5
0448:  BCF    06.7
0449:  BCF    03.5
044A:  BCF    06.7
044B:  MOVF   01,W
044C:  MOVWF  34
044D:  MOVLW  BE
044E:  ADDWF  2D,W
044F:  SUBWF  34,W
0450:  BTFSC  03.2
0451:  GOTO   454
0452:  BTFSC  03.0
0453:  GOTO   45D
0454:  BSF    03.5
0455:  BCF    06.5
0456:  BCF    03.5
0457:  BCF    06.5
0458:  BSF    03.5
0459:  BCF    06.4
045A:  BCF    03.5
045B:  BSF    06.4
045C:  GOTO   465
045D:  BSF    03.5
045E:  BCF    06.4
045F:  BCF    03.5
0460:  BCF    06.4
0461:  BSF    03.5
0462:  BCF    06.5
0463:  BCF    03.5
0464:  BCF    06.5
....................             line=L;  
0465:  MOVLW  02
0466:  MOVWF  2A
....................             continue;  
0467:  GOTO   3CB
....................          case R:                          // trochu vpravo  
....................             GO(R, F, FW_POMALU+rovinka); GO(L, F, FW_STREDNE+rovinka);  
0468:  MOVF   01,W
0469:  MOVWF  34
046A:  MOVLW  AA
046B:  ADDWF  2D,W
046C:  SUBWF  34,W
046D:  BTFSC  03.2
046E:  GOTO   471
046F:  BTFSC  03.0
0470:  GOTO   47A
0471:  BSF    03.5
0472:  BCF    06.5
0473:  BCF    03.5
0474:  BCF    06.5
0475:  BSF    03.5
0476:  BCF    06.4
0477:  BCF    03.5
0478:  BSF    06.4
0479:  GOTO   482
047A:  BSF    03.5
047B:  BCF    06.4
047C:  BCF    03.5
047D:  BCF    06.4
047E:  BSF    03.5
047F:  BCF    06.5
0480:  BCF    03.5
0481:  BCF    06.5
0482:  MOVF   01,W
0483:  MOVWF  34
0484:  MOVLW  BE
0485:  ADDWF  2D,W
0486:  SUBWF  34,W
0487:  BTFSC  03.2
0488:  GOTO   48B
0489:  BTFSC  03.0
048A:  GOTO   494
048B:  BSF    03.5
048C:  BCF    06.7
048D:  BCF    03.5
048E:  BCF    06.7
048F:  BSF    03.5
0490:  BCF    06.6
0491:  BCF    03.5
0492:  BSF    06.6
0493:  GOTO   49C
0494:  BSF    03.5
0495:  BCF    06.6
0496:  BCF    03.5
0497:  BCF    06.6
0498:  BSF    03.5
0499:  BCF    06.7
049A:  BCF    03.5
049B:  BCF    06.7
....................             line=R;  
049C:  MOVLW  01
049D:  MOVWF  2A
....................             continue;  
049E:  GOTO   3CB
....................          default:       // kdyz jsou obe cidla mimo caru, tak pokracuj dal  
....................       };  
....................       rovinka=0;  
049F:  CLRF   2D
....................   
....................       if (last!=line)   // pokud si prejel caru z jedne strany na druhou stranu,  
04A0:  MOVF   2A,W
04A1:  SUBWF  2C,W
04A2:  BTFSC  03.2
04A3:  GOTO   560
....................                         // tak zabrzdi  
....................       {  
....................          output_bit(LED1, !input(LED1));  
04A4:  BSF    03.5
04A5:  BSF    05.4
04A6:  BCF    03.5
04A7:  BTFSS  05.4
04A8:  GOTO   4AB
04A9:  BCF    05.4
04AA:  GOTO   4AC
04AB:  BSF    05.4
04AC:  BSF    03.5
04AD:  BCF    05.4
....................          last=line;  
04AE:  BCF    03.5
04AF:  MOVF   2A,W
04B0:  MOVWF  2C
....................          speed=FW_ZATACKA;  
04B1:  MOVLW  C8
04B2:  MOVWF  2B
....................          cirkus++;  
04B3:  INCF   2E,F
....................          if (cirkus>8)  
04B4:  MOVF   2E,W
04B5:  SUBLW  08
04B6:  BTFSC  03.0
04B7:  GOTO   560
....................          {  
....................             STOPL; STOPR;  
04B8:  BSF    03.5
04B9:  BCF    06.6
04BA:  BCF    03.5
04BB:  BCF    06.6
04BC:  BSF    03.5
04BD:  BCF    06.7
04BE:  BCF    03.5
04BF:  BCF    06.7
04C0:  BSF    03.5
04C1:  BCF    06.4
04C2:  BCF    03.5
04C3:  BCF    06.4
04C4:  BSF    03.5
04C5:  BCF    06.5
04C6:  BCF    03.5
04C7:  BCF    06.5
....................             cirkus=0;  
04C8:  CLRF   2E
....................             disable_interrupts(GLOBAL);  
04C9:  BCF    0B.6
04CA:  BCF    0B.7
04CB:  BTFSC  0B.7
04CC:  GOTO   4CA
....................             beep(1000,400);  
04CD:  MOVLW  03
04CE:  MOVWF  37
04CF:  MOVLW  E8
04D0:  MOVWF  36
04D1:  MOVLW  01
04D2:  MOVWF  39
04D3:  MOVLW  90
04D4:  MOVWF  38
04D5:  CALL   055
....................             for(n=3000; n>3950; n--) beep(n,10);  
04D6:  MOVLW  0B
04D7:  MOVWF  31
04D8:  MOVLW  B8
04D9:  MOVWF  30
04DA:  MOVF   31,W
04DB:  SUBLW  0E
04DC:  BTFSC  03.0
04DD:  GOTO   4F2
04DE:  XORLW  FF
04DF:  BTFSS  03.2
04E0:  GOTO   4E5
04E1:  MOVF   30,W
04E2:  SUBLW  6E
04E3:  BTFSC  03.0
04E4:  GOTO   4F2
04E5:  MOVF   31,W
04E6:  MOVWF  37
04E7:  MOVF   30,W
04E8:  MOVWF  36
04E9:  CLRF   39
04EA:  MOVLW  0A
04EB:  MOVWF  38
04EC:  CALL   055
04ED:  MOVF   30,W
04EE:  BTFSC  03.2
04EF:  DECF   31,F
04F0:  DECF   30,F
04F1:  GOTO   4DA
....................             output_low(LED1);  
04F2:  BSF    03.5
04F3:  BCF    05.4
04F4:  BCF    03.5
04F5:  BCF    05.4
....................               beep(2000,200);  
04F6:  MOVLW  07
04F7:  MOVWF  37
04F8:  MOVLW  D0
04F9:  MOVWF  36
04FA:  CLRF   39
04FB:  MOVLW  C8
04FC:  MOVWF  38
04FD:  CALL   055
....................             beep(900,400);  
04FE:  MOVLW  03
04FF:  MOVWF  37
0500:  MOVLW  84
0501:  MOVWF  36
0502:  MOVLW  01
0503:  MOVWF  39
0504:  MOVLW  90
0505:  MOVWF  38
0506:  CALL   055
....................             for(n=2950; n<3000; n++) beep(n,10);  
0507:  MOVLW  0B
0508:  MOVWF  31
0509:  MOVLW  86
050A:  MOVWF  30
050B:  MOVF   31,W
050C:  SUBLW  0B
050D:  BTFSS  03.0
050E:  GOTO   521
050F:  BTFSS  03.2
0510:  GOTO   515
0511:  MOVF   30,W
0512:  SUBLW  B7
0513:  BTFSS  03.0
0514:  GOTO   521
0515:  MOVF   31,W
0516:  MOVWF  37
0517:  MOVF   30,W
0518:  MOVWF  36
0519:  CLRF   39
051A:  MOVLW  0A
051B:  MOVWF  38
051C:  CALL   055
051D:  INCF   30,F
051E:  BTFSC  03.2
051F:  INCF   31,F
0520:  GOTO   50B
....................             output_low(LED2);  
0521:  BSF    03.5
0522:  BCF    05.3
0523:  BCF    03.5
0524:  BCF    05.3
....................             output_high(LED1);  
0525:  BSF    03.5
0526:  BCF    05.4
0527:  BCF    03.5
0528:  BSF    05.4
....................             beep(4000,400);  
0529:  MOVLW  0F
052A:  MOVWF  37
052B:  MOVLW  A0
052C:  MOVWF  36
052D:  MOVLW  01
052E:  MOVWF  39
052F:  MOVLW  90
0530:  MOVWF  38
0531:  CALL   055
....................               beep(1000,100);  
0532:  MOVLW  03
0533:  MOVWF  37
0534:  MOVLW  E8
0535:  MOVWF  36
0536:  CLRF   39
0537:  MOVLW  64
0538:  MOVWF  38
0539:  CALL   055
....................             output_low(LED3);  
053A:  BSF    03.5
053B:  BCF    05.7
053C:  BCF    03.5
053D:  BCF    05.7
....................             beep(3000,400);  
053E:  MOVLW  0B
053F:  MOVWF  37
0540:  MOVLW  B8
0541:  MOVWF  36
0542:  MOVLW  01
0543:  MOVWF  39
0544:  MOVLW  90
0545:  MOVWF  38
0546:  CALL   055
....................             Delay_ms(1000);  
0547:  MOVLW  04
0548:  MOVWF  34
0549:  MOVLW  FA
054A:  MOVWF  37
054B:  CALL   073
054C:  DECFSZ 34,F
054D:  GOTO   549
....................             output_high(LED1); output_high(LED2);  
054E:  BSF    03.5
054F:  BCF    05.4
0550:  BCF    03.5
0551:  BSF    05.4
0552:  BSF    03.5
0553:  BCF    05.3
0554:  BCF    03.5
0555:  BSF    05.3
....................             output_high(LED3); output_high(LED4);  
0556:  BSF    03.5
0557:  BCF    05.7
0558:  BCF    03.5
0559:  BSF    05.7
055A:  BSF    03.5
055B:  BCF    05.6
055C:  BCF    03.5
055D:  BSF    05.6
....................             enable_interrupts(GLOBAL);  
055E:  MOVLW  C0
055F:  IORWF  0B,F
....................          }  
....................       };  
....................   
....................       if (L==line)  // kdyz jsou obe cidla mimo caru, zatoc na caru  
0560:  MOVF   2A,W
0561:  SUBLW  02
0562:  BTFSS  03.2
0563:  GOTO   582
....................       {  
....................          STOPL;  
0564:  BSF    03.5
0565:  BCF    06.6
0566:  BCF    03.5
0567:  BCF    06.6
0568:  BSF    03.5
0569:  BCF    06.7
056A:  BCF    03.5
056B:  BCF    06.7
....................          GO(R, F, speed);  
056C:  MOVF   01,W
056D:  SUBWF  2B,W
056E:  BTFSS  03.0
056F:  GOTO   579
0570:  BSF    03.5
0571:  BCF    06.5
0572:  BCF    03.5
0573:  BCF    06.5
0574:  BSF    03.5
0575:  BCF    06.4
0576:  BCF    03.5
0577:  BSF    06.4
0578:  GOTO   581
0579:  BSF    03.5
057A:  BCF    06.4
057B:  BCF    03.5
057C:  BCF    06.4
057D:  BSF    03.5
057E:  BCF    06.5
057F:  BCF    03.5
0580:  BCF    06.5
....................       }  
....................       else  
0581:  GOTO   59F
....................       {  
....................          STOPR;  
0582:  BSF    03.5
0583:  BCF    06.4
0584:  BCF    03.5
0585:  BCF    06.4
0586:  BSF    03.5
0587:  BCF    06.5
0588:  BCF    03.5
0589:  BCF    06.5
....................          GO(L, F, speed);  
058A:  MOVF   01,W
058B:  SUBWF  2B,W
058C:  BTFSS  03.0
058D:  GOTO   597
058E:  BSF    03.5
058F:  BCF    06.7
0590:  BCF    03.5
0591:  BCF    06.7
0592:  BSF    03.5
0593:  BCF    06.6
0594:  BCF    03.5
0595:  BSF    06.6
0596:  GOTO   59F
0597:  BSF    03.5
0598:  BCF    06.6
0599:  BCF    03.5
059A:  BCF    06.6
059B:  BSF    03.5
059C:  BCF    06.7
059D:  BCF    03.5
059E:  BCF    06.7
....................       }  
....................   
....................    } // while(true)  
059F:  GOTO   3CB
.................... }  
....................   
....................  
05A0:  SLEEP

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