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