Go to most recent revision | Blame | Last modification | View Log | Download
CCS PCW C Compiler, Version 3.110, 15448
Filename: d:\kaklik\programy\pic_c\robot\tank\main.LST
ROM used: 893 (22%)
Largest free fragment is 2048
RAM used: 82 (43%) at main() level
101 (53%) worst case
Stack: 3 locations
*
0000: MOVLW 00
0001: MOVWF 0A
0002: GOTO 2CB
0003: NOP
.................... #include "D:\@KAKLIK\programy\PIC_C\robot\tank\main.h"
.................... #include <16F873.h>
.................... //////// Standard Header file for the PIC16F873 device ////////////////
.................... #device PIC16F873
.................... #list
....................
.................... #use delay(clock=4000000)
00A8: MOVLW 73
00A9: MOVWF 04
00AA: MOVF 00,W
00AB: BTFSC 03.2
00AC: GOTO 0BC
00AD: MOVLW 01
00AE: MOVWF 21
00AF: CLRF 20
00B0: DECFSZ 20,F
00B1: GOTO 0B0
00B2: DECFSZ 21,F
00B3: GOTO 0AF
00B4: MOVLW 4A
00B5: MOVWF 20
00B6: DECFSZ 20,F
00B7: GOTO 0B6
00B8: NOP
00B9: NOP
00BA: DECFSZ 00,F
00BB: GOTO 0AD
00BC: RETLW 00
.................... #fuses XT,NOWDT,NOLVP
....................
....................
....................
.................... //motory
.................... #define FR output_high(PIN_B4);output_low(PIN_B5) // Vpred
.................... #define FL output_high(PIN_B6);output_low(PIN_B7)
.................... #define BR output_high(PIN_B5);output_low(PIN_B4) // Vzad
.................... #define BL output_high(PIN_B7);output_low(PIN_B6)
.................... #define STOPR output_low(PIN_B4);output_low(PIN_B5)
.................... #define STOPL output_low(PIN_B6);output_low(PIN_B7)
....................
.................... //cidla
.................... #define RSENSOR 1 // Senzory na caru
.................... #define LSENSOR 0
.................... //#define BUMPER SENSOR_2 // Senzor na cihlu
....................
.................... //human interface
.................... #DEFINE LED PIN_A2
....................
.................... #DEFINE SOUND_HI PIN_B2
.................... #DEFINE SOUND_LO PIN_B3
.................... #include "sound.c"
.................... // Knihovna pro generovani hudebnich zvuku dane frekvence a delky nebo
.................... // dane noty temperovaneho ladeni a delky.
.................... //
.................... // Pro gnerovani nepouziva zadnou podporu HW, vse se generuje ciste SW.
.................... //
.................... // (c)miho 2003
.................... //
.................... // Historie
.................... // 1.00 Uvodni verze
.................... //
....................
....................
.................... // Konfiguracni parametry
.................... //#define SOUND_HI PIN_xx // Pozitivni vystup
.................... //#define SOUND_LO PIN_xx // Komplementarni vystup
.................... #ifndef SOUND_REZIE
.................... #define SOUND_REZIE 72 // Piskvorcova konstanta zahrnuje celkovou rezii ve smycce
.................... #endif
.................... #ifndef SOUND_CLOCK
.................... #define SOUND_CLOCK 4000000 // Frelvence krystalu v Hz
.................... #endif
....................
....................
.................... // Definice hudebnich tonu (not) pro proceduru SoundNote()
.................... #define SOUND_C 0
.................... #define SOUND_Cis 1
.................... #define SOUND_D 2
.................... #define SOUND_Dis 3
.................... #define SOUND_E 4
.................... #define SOUND_F 5
.................... #define SOUND_Fis 6
.................... #define SOUND_G 7
.................... #define SOUND_Gis 8
.................... #define SOUND_A 9
.................... #define SOUND_Ais 10
.................... #define SOUND_H 11
.................... #define SOUND_Space 12 // Pomlka
....................
....................
.................... // Prototypy verejnych procedur
....................
.................... void SoundBeep(unsigned int16 Frequency, unsigned int16 Duration);
.................... // Predava se frekvence v Hz a doba trvani v ms (0 znamena ticho)
....................
.................... void SoundNote(unsigned int8 Note, Octave, unsigned int16 Duration);
.................... // Predava se cislo noty (0 je C), posunuti v oktavach (0 nejnizsi ton,
.................... // SOUND_Space je ticho), doba trvani v ms
....................
.................... // Alternativni makra pro generovani konstatnich tonu
.................... // SoundBeepMacro(Frequency, Duration) - frekvence nesmi byt 0
.................... // SoundNoteMacro(Note, Octave, Duration) - nepodporuje SOUND_Space
.................... // SoundSpaceMacro(Duration) - hraje ticho
....................
.................... // Privatni cast
....................
....................
.................... #ORG 0x100, 0x128 // Aby skok nebyl pres hranici 0x100
.................... void DelaySpecial(unsigned int16 Time)
.................... // Pomocna procedura pro mereni spozdeni s granularitou 1 instrukcni takt
.................... // Cas v instrukcnich cyklech, skutecny cas je vetsi o _konstantni_ rezii
.................... // Maximalni cas je 65536 us
.................... {
.................... unsigned int8 TimeHi; // Pro pristup k horni casti Time
....................
.................... *0x0A = LABEL_ADDRESS(Next)>>8; // Nastav PCLATH
*
0100: MOVLW 01
0101: MOVWF 23
0102: MOVLW 0A
0103: MOVWF 7E
0104: MOVF 23,W
0105: MOVWF 0A
.................... #asm
.................... movf Time,w // Zpracuj nejnizsi 3 bity
0106: MOVF 7B,W
.................... xorlw 7 // Pro hodnotu 0 skakej pres vsechny nopy
0107: XORLW 07
.................... andlw 7 // Ber jen spodni 3 bity
0108: ANDLW 07
.................... addwf 2,f // Preskoc zadny az vsech 8 nopu (2 je PCL)
0109: ADDWF 02,F
.................... Next:
.................... nop // Spozdeni s granularitou 1 takt
010A: NOP
.................... nop
010B: NOP
.................... nop
010C: NOP
.................... nop
010D: NOP
.................... nop
010E: NOP
.................... nop
010F: NOP
.................... nop
0110: NOP
.................... nop
.................... #endasm
0111: NOP
.................... Time = Time >> 3; // Zahod spodni 3 bity
0112: RRF 7C,F
0113: RRF 7B,F
0114: RRF 7C,F
0115: RRF 7B,F
0116: RRF 7C,F
0117: RRF 7B,F
0118: MOVLW 1F
0119: ANDWF 7C,F
.................... TimeHi=Time>>8; // Oddel horni cast citace
011A: MOVF 7C,W
011B: MOVWF 7D
.................... Time++; // Korekce na casovani typu dcfsz
011C: INCF 7B,F
011D: BTFSC 03.2
011E: INCF 7C,F
.................... TimeHi++;
011F: INCF 7D,F
.................... #asm
.................... Loop:
.................... nop // Smycka musi trvat 8 taktu
0120: NOP
.................... nop // a ma 16 bitu dlouhy citac
0121: NOP
.................... nop
0122: NOP
.................... decfsz Time
0123: DECFSZ 7B,F
.................... goto Next1
0124: GOTO 126
.................... decfsz TimeHi
0125: DECFSZ 7D,F
.................... Next1:
.................... goto Loop
.................... #endasm
0126: GOTO 120
0127: RETLW 00
....................
.................... }
....................
....................
.................... unsigned int32 SoundCount; // Pocet pulperid geneovaneho signalu
.................... unsigned int32 SoundPeriod; // Delka pulperiody v us (zmensene o SOUND_REZIE)
....................
....................
.................... void SoundLoop()
.................... // Pomocna funkce - hlavni zvukova smycka
.................... {
.................... int1 Data;
.................... unsigned int16 i;
....................
.................... for(i=SoundCount;i>0;i--) // Pocet pulperiod
*
019F: MOVF 26,W
01A0: MOVWF 78
01A1: MOVF 25,W
01A2: MOVWF 77
01A3: MOVF 77,F
01A4: BTFSS 03.2
01A5: GOTO 1A9
01A6: MOVF 78,F
01A7: BTFSC 03.2
01A8: GOTO 1C9
.................... {
.................... output_bit(SOUND_HI,Data); // Nastav vystup
01A9: BTFSC 76.0
01AA: GOTO 1AD
01AB: BCF 06.2
01AC: GOTO 1AE
01AD: BSF 06.2
01AE: BSF 03.5
01AF: BCF 06.2
.................... output_bit(SOUND_LO,~Data);
01B0: BCF 03.5
01B1: BTFSS 76.0
01B2: GOTO 1B5
01B3: BCF 06.3
01B4: GOTO 1B6
01B5: BSF 06.3
01B6: BSF 03.5
01B7: BCF 06.3
.................... Data=~Data; // Otoc stav vystupu
01B8: MOVLW 01
01B9: BCF 03.5
01BA: XORWF 76,F
.................... DelaySpecial(SoundPeriod); // Pockej po dobu plperiody
01BB: MOVF 2A,W
01BC: MOVWF 7A
01BD: MOVF 29,W
01BE: MOVWF 79
01BF: MOVF 2A,W
01C0: MOVWF 7C
01C1: MOVF 29,W
01C2: MOVWF 7B
01C3: CALL 100
.................... }
01C4: MOVF 77,W
01C5: BTFSC 03.2
01C6: DECF 78,F
01C7: DECF 77,F
01C8: GOTO 1A3
.................... }
....................
....................
.................... void SoundBeep(unsigned int16 Frequency, unsigned int16 Duration)
.................... // Predava se frekvence v Hz a doba trvani v ms (0 znamena ticho)
.................... // Rozumne frekvence jsou v rozsahu cca 10Hz az 5000Hz pro krystal 4MHz,
.................... // cas do cca 5s (2*Cas/1000*Freq musi byt < nez 65536)
.................... {
.................... if (Frequency==0)
*
0129: MOVF 72,F
012A: BTFSS 03.2
012B: GOTO 140
012C: MOVF 73,F
012D: BTFSS 03.2
012E: GOTO 140
.................... {
.................... for(;Duration>0;Duration--)
012F: MOVF 74,F
0130: BTFSS 03.2
0131: GOTO 135
0132: MOVF 75,F
0133: BTFSC 03.2
0134: GOTO 13F
.................... {
.................... DelaySpecial(1000); // Zhruba 1ms
0135: MOVLW 03
0136: MOVWF 7C
0137: MOVLW E8
0138: MOVWF 7B
0139: CALL 100
.................... }
013A: MOVF 74,W
013B: BTFSC 03.2
013C: DECF 75,F
013D: DECF 74,F
013E: GOTO 12F
.................... return;
013F: GOTO 1C9
.................... }
....................
.................... SoundPeriod=(SOUND_CLOCK/4/2)/Frequency-SOUND_REZIE;
0140: CLRF 79
0141: MOVLW 07
0142: MOVWF 78
0143: MOVLW A1
0144: MOVWF 77
0145: MOVLW 20
0146: MOVWF 76
0147: CLRF 7D
0148: CLRF 7C
0149: MOVF 73,W
014A: MOVWF 7B
014B: MOVF 72,W
014C: MOVWF 7A
014D: CALL 004
014E: MOVF 23,W
014F: MOVWF 79
0150: MOVF 22,W
0151: MOVWF 78
0152: MOVF 21,W
0153: MOVWF 77
0154: MOVF 20,W
0155: MOVWF 76
0156: MOVLW 48
0157: SUBWF 76,W
0158: MOVWF 29
0159: MOVF 77,W
015A: MOVWF 2A
015B: MOVLW 00
015C: BTFSS 03.0
015D: MOVLW 01
015E: SUBWF 2A,F
015F: MOVF 78,W
0160: MOVWF 2B
0161: MOVLW 00
0162: BTFSS 03.0
0163: MOVLW 01
0164: SUBWF 2B,F
0165: MOVF 79,W
0166: MOVWF 2C
0167: MOVLW 00
0168: BTFSS 03.0
0169: MOVLW 01
016A: SUBWF 2C,F
....................
.................... SoundCount=Duration; // Vypocet poctu pulperiod signalu Duration*Frequency*2/1000
016B: CLRF 28
016C: CLRF 27
016D: MOVF 75,W
016E: MOVWF 26
016F: MOVF 74,W
0170: MOVWF 25
.................... SoundCount*=Frequency;
0171: MOVF 28,W
0172: MOVWF 79
0173: MOVF 27,W
0174: MOVWF 78
0175: MOVF 26,W
0176: MOVWF 77
0177: MOVF 25,W
0178: MOVWF 76
0179: CLRF 7D
017A: CLRF 7C
017B: MOVF 73,W
017C: MOVWF 7B
017D: MOVF 72,W
017E: MOVWF 7A
017F: GOTO 066
0180: MOVF 23,W
0181: MOVWF 28
0182: MOVF 22,W
0183: MOVWF 27
0184: MOVF 21,W
0185: MOVWF 26
0186: MOVF 20,W
0187: MOVWF 25
.................... SoundCount/=500;
0188: MOVF 28,W
0189: MOVWF 79
018A: MOVF 27,W
018B: MOVWF 78
018C: MOVF 26,W
018D: MOVWF 77
018E: MOVF 25,W
018F: MOVWF 76
0190: CLRF 7D
0191: CLRF 7C
0192: MOVLW 01
0193: MOVWF 7B
0194: MOVLW F4
0195: MOVWF 7A
0196: CALL 004
0197: MOVF 23,W
0198: MOVWF 28
0199: MOVF 22,W
019A: MOVWF 27
019B: MOVF 21,W
019C: MOVWF 26
019D: MOVF 20,W
019E: MOVWF 25
....................
.................... SoundLoop(); // Pozor pouzivaji se globalni parametry
*
01C9: RETLW 00
.................... }
....................
.................... // Definice casu pulperody pro nejnizsi oktavu, v mikrosekundach
.................... // Periody tonu v dalsich oktavach se ziskavaji rotaci vpravo
.................... #define SOUND_Peri_C (30578*(SOUND_CLOCK/1000)/1000/4/2) // Perioda 30578us
.................... #define SOUND_Peri_Cis (28862*(SOUND_CLOCK/1000)/1000/4/2) // Perioda 28862us
.................... #define SOUND_Peri_D (27242*(SOUND_CLOCK/1000)/1000/4/2) // Perioda 27242us
.................... #define SOUND_Peri_Dis (25713*(SOUND_CLOCK/1000)/1000/4/2) // Perioda 25713us
.................... #define SOUND_Peri_E (24270*(SOUND_CLOCK/1000)/1000/4/2) // Perioda 24270us
.................... #define SOUND_Peri_F (22908*(SOUND_CLOCK/1000)/1000/4/2) // Perioda 22908us
.................... #define SOUND_Peri_Fis (21622*(SOUND_CLOCK/1000)/1000/4/2) // Perioda 21622us
.................... #define SOUND_Peri_G (20408*(SOUND_CLOCK/1000)/1000/4/2) // Perioda 20408us
.................... #define SOUND_Peri_Gis (19263*(SOUND_CLOCK/1000)/1000/4/2) // Perioda 19263us
.................... #define SOUND_Peri_A (18182*(SOUND_CLOCK/1000)/1000/4/2) // Perioda 18182us
.................... #define SOUND_Peri_Ais (17161*(SOUND_CLOCK/1000)/1000/4/2) // Perioda 17161us
.................... #define SOUND_Peri_H (16198*(SOUND_CLOCK/1000)/1000/4/2) // Perioda 16198us
....................
.................... #if SOUND_Peri_C > 65535
.................... #error "Sound Clock too high (Note C requires delay > 65535 cycles)"
.................... #endif
....................
.................... const int16 Table[12] = SOUND_Peri_C, SOUND_Peri_Cis, SOUND_Peri_D, SOUND_Peri_Dis,
.................... SOUND_Peri_E, SOUND_Peri_F, SOUND_Peri_Fis, SOUND_Peri_G,
.................... SOUND_Peri_Gis, SOUND_Peri_A, SOUND_Peri_Ais, SOUND_Peri_H;
....................
.................... void SoundNote(unsigned int8 Note, Octave, unsigned int16 Duration)
.................... // Predava se cislo noty (0 je C), posunuti v oktavach (0 nejnizsi ton)
.................... // doba trvani v ms (0 znamena ticho)
.................... // Zahraje zadanou notu v zadane oktave dane delky
.................... {
....................
.................... if (Note==SOUND_Space)
.................... {
.................... for(;Duration>0;Duration--)
.................... DelaySpecial(1000); // Zhruba 1ms
.................... return;
.................... }
....................
.................... SoundPeriod=(Table[Note]>>Octave)-0; // Zde je chyba prekladace, nula musi zusat
....................
.................... SoundCount=Duration;
.................... SoundCount*=1000;
.................... SoundCount/=SoundPeriod;
....................
.................... SoundPeriod=SoundPeriod-SOUND_REZIE;
....................
.................... SoundLoop(); // Pozor pouzivaji se globalni parametry
.................... }
....................
....................
.................... // Sada maker, ktera neobsahuji slozity vypocet a jsou
.................... // tedy vhodna pro jednoduche pipnuti. Parametry jsou stejne
.................... // jako o funkci.
.................... #define SoundBeepMacro(F,D) \
.................... SoundPeriod=SOUND_CLOCK/4/2/F-SOUND_REZIE; \
.................... SoundCount=D*F/500; \
.................... SoundLoop();
....................
.................... #define SoundNoteMacro(N,O,D) \
.................... SoundPeriod=(Table[N]>>O)-SOUND_REZIE; \
.................... SoundCount=D*1000/(Table[N]>>O); \
.................... SoundLoop();
....................
.................... #define SoundPauseMacro(D) \
.................... { \
.................... #if D>255 \
.................... unsigned int16 i=D; \
.................... #else \
.................... unsigned int8 i=D; \
.................... #endif \
.................... for(;i>0;i--) \
.................... { \
.................... DelaySpecial(1000); \
.................... } \
.................... }
....................
....................
.................... #DEFINE TXo PIN_C0 // Vysilac
.................... #include "C:\library\kaklik\CCS\AX25.c" // Podprogram pro prenos telemetrie
.................... //#define PTT PIN_A2 // PTT control
.................... //#define TXo PIN_C0 // To the transmitter modulator
.................... #define PERIODAH delay_us(222) // Halfperiod H 222;78/1200 500;430/500
.................... #define TAILH delay_us(78)
.................... #define PERIODAL delay_us(412) // Halfperiod L 412;345/1200 1000;880/500
.................... #define TAILL delay_us(345)
.................... #byte STATUS = 3 // CPUs status register
....................
.................... byte SendData[16] = {'A'<<1, 'L'<<1, 'L'<<1, ' '<<1, ' '<<1, ' '<<1, 0x60,
.................... 'C'<<1, 'Z'<<1, '0'<<1, 'R'<<1, 'R'<<1, 'R'<<1, 0x61,
.................... 0x03, 0xF0};
....................
.................... boolean bit;
.................... int fcslo, fcshi; // variabloes for calculating FCS (CRC)
.................... int stuff; // stuff counter for extra 0
.................... int flag_flag; // if it is sending flag (7E)
.................... int fcs_flag; // if it is sending Frame Check Sequence
.................... int i; // for for
....................
.................... void flipout() //flips the state of output pin a_1
.................... {
.................... stuff = 0; //since this is a 0, reset the stuff counter
.................... if (bit)
.................... {
.................... bit=FALSE; //if the state of the pin was low, make it high.
.................... }
.................... else
.................... {
.................... bit=TRUE; //if the state of the pin was high make it low
.................... }
.................... }
....................
.................... void fcsbit(byte tbyte)
.................... {
.................... #asm
.................... BCF STATUS,0
.................... RRF fcshi,F // rotates the entire 16 bits
.................... RRF fcslo,F // to the right
.................... #endasm
.................... if (((STATUS & 0x01)^(tbyte)) ==0x01)
.................... {
.................... fcshi = fcshi^0x84;
.................... fcslo = fcslo^0x08;
.................... }
.................... }
....................
.................... void SendBit ()
.................... {
.................... if (bit)
.................... {
.................... output_high(TXo);
.................... PERIODAH;
.................... output_low(TXo);
.................... PERIODAH;
.................... output_high(TXo);
.................... PERIODAH;
.................... output_low(TXo);
.................... TAILH;
.................... }
.................... else
.................... {
.................... output_high(TXo);
.................... PERIODAL;
.................... output_low(TXo);
.................... TAILL;
.................... };
.................... }
....................
.................... void SendByte (byte inbyte)
.................... {
.................... int k, bt;
....................
.................... for (k=0;k<8;k++) //do the following for each of the 8 bits in the byte
.................... {
.................... bt = inbyte & 0x01; //strip off the rightmost bit of the byte to be sent (inbyte)
.................... if ((fcs_flag == FALSE) & (flag_flag == FALSE)) fcsbit(bt); //do FCS calc, but only if this
.................... //is not a flag or fcs byte
.................... if (bt == 0)
.................... {
.................... flipout();
.................... } // if this bit is a zero, flip the output state
.................... else
.................... { //otherwise if it is a 1, do the following:
.................... if (flag_flag == FALSE) stuff++; //increment the count of consequtive 1's
.................... if ((flag_flag == FALSE) & (stuff == 5))
.................... { //stuff an extra 0, if 5 1's in a row
.................... SendBit();
.................... flipout(); //flip the output state to stuff a 0
.................... }//end of if
.................... }//end of else
.................... // delay_us(850); //introduces a delay that creates 1200 baud
.................... SendBit();
.................... inbyte = inbyte>>1; //go to the next bit in the byte
.................... }//end of for
.................... }//end of SendByte
....................
.................... void SendPacket(char *data)
.................... {
.................... bit=FALSE;
....................
.................... fcslo=fcshi=0xFF; //The 2 FCS Bytes are initialized to FF
.................... stuff = 0; //The variable stuff counts the number of 1's in a row. When it gets to 5
.................... // it is time to stuff a 0.
....................
.................... // output_low(PTT); // Blinking LED
.................... // delay_ms(1000);
.................... // output_high(PTT);
....................
.................... flag_flag = TRUE; //The variable flag is true if you are transmitted flags (7E's) false otherwise.
.................... fcs_flag = FALSE; //The variable fcsflag is true if you are transmitting FCS bytes, false otherwise.
....................
.................... for(i=0; i<10; i++) SendByte(0x7E); //Sends flag bytes. Adjust length for txdelay
.................... //each flag takes approx 6.7 ms
.................... flag_flag = FALSE; //done sending flags
....................
.................... for(i=0; i<16; i++) SendByte(SendData[i]); //send the packet bytes
....................
.................... for(i=0; 0 != *data; i++)
.................... {
.................... SendByte(*data); //send the packet bytes
.................... data++;
.................... };
....................
.................... fcs_flag = TRUE; //about to send the FCS bytes
.................... fcslo =fcslo^0xff; //must XOR them with FF before sending
.................... fcshi = fcshi^0xff;
.................... SendByte(fcslo); //send the low byte of fcs
.................... SendByte(fcshi); //send the high byte of fcs
.................... fcs_flag = FALSE; //done sending FCS
.................... flag_flag = TRUE; //about to send flags
.................... SendByte(0x7e); // Send a flag to end packet
.................... }
....................
....................
....................
....................
....................
.................... //program
.................... #define MEZERA 38 // jak se muze jet dlouho bez cary
.................... #define COUVEJ 700 // kolik se ma couvat po detekci diry
.................... #define CIKCAK 40 // kolik se ma jet cik/cak
.................... #define PRES_DIRU 350 // jak predpokladame velkou diru
.................... #define TRESHOLD 50
....................
.................... #define L 0 // left
.................... #define R 1 // right
.................... #define S 2 // straight
....................
.................... char AXstring[40]; // Buffer pro prenos telemetrie
....................
.................... int movement; // smer minuleho pohybu
.................... int line; // na ktere strane byla detekovana cara
.................... int dira; // pocitadlo pro nalezeni preruseni cary
.................... int n; // pomocna promena pro cyklus FOR
....................
.................... void cik_cak() // Hledani cary
.................... {
.................... n=CIKCAK/2; // poprve hned zatoc opacne, nez se jelo pred detekci diry
.................... switch(movement) // zmenime smer zataceni
.................... {
.................... case L:
.................... FL;STOPR; // doprava
.................... movement=R; // poznamenej kam jedem
.................... line=L; // kdyz prejedem, tak bude cara vlevo
.................... break;
.................... case R:
.................... FR;STOPL; // doleva
.................... movement=L; // poznamenej kam jedem
.................... line=R; // kdyz prejedem, tak bude cara vpravo
.................... break;
.................... }
....................
.................... while(true) // jed cik-cak, dokud nenajdes caru
.................... {
.................... set_adc_channel(RSENSOR);
.................... if (TRESHOLD > read_adc()) // je cara ??
.................... {
.................... STOPL;
.................... STOPR;
.................... break;
.................... };
.................... if (CIKCAK < n++) // Jedeme uz dost dlouho cik??Pak jed cak.
.................... {
.................... n=0;
.................... STOPL;
.................... STOPR;
.................... switch(movement) // zmenime smer zataceni
.................... {
.................... case L:
.................... FL; // doprava
.................... movement=R; // poznamenej kam jedem
.................... line=L; // kdyz prejedem, tak bude cara vlevo
.................... break;
.................... case R:
.................... FR; // doleva
.................... movement=L; // poznamenej kam jedem
.................... line=R; // kdyz prejedem, tak bude cara vpravo
.................... break;
.................... }
.................... }
.................... }
.................... }
....................
....................
.................... void diagnostika()
.................... {
.................... int n;
....................
.................... while (input(PIN_C4))
01CA: BSF 44.4
01CB: MOVF 44,W
01CC: BSF 03.5
01CD: MOVWF 07
01CE: BCF 03.5
01CF: BTFSS 07.4
01D0: GOTO 2C9
.................... {
....................
.................... for (n=500; n<5000; n+=100)
01D1: MOVLW F4
01D2: MOVWF 71
.................... {
.................... SoundBeep(n,50); //beep
01D3: CLRF 73
01D4: MOVF 71,W
01D5: MOVWF 72
01D6: CLRF 75
01D7: MOVLW 32
01D8: MOVWF 74
01D9: CALL 129
.................... };
01DA: MOVLW 64
01DB: ADDWF 71,F
01DC: GOTO 1D3
.................... Delay_ms(1000);
01DD: MOVLW 04
01DE: MOVWF 72
01DF: MOVLW FA
01E0: MOVWF 73
01E1: CALL 0A8
01E2: DECFSZ 72,F
01E3: GOTO 1DF
....................
.................... STOPL; //zastav vse
01E4: BSF 03.5
01E5: BCF 06.6
01E6: BCF 03.5
01E7: BCF 06.6
01E8: BSF 03.5
01E9: BCF 06.7
01EA: BCF 03.5
01EB: BCF 06.7
.................... STOPR;
01EC: BSF 03.5
01ED: BCF 06.4
01EE: BCF 03.5
01EF: BCF 06.4
01F0: BSF 03.5
01F1: BCF 06.5
01F2: BCF 03.5
01F3: BCF 06.5
....................
.................... FR; //pravy pas
01F4: BSF 03.5
01F5: BCF 06.4
01F6: BCF 03.5
01F7: BSF 06.4
01F8: BSF 03.5
01F9: BCF 06.5
01FA: BCF 03.5
01FB: BCF 06.5
.................... Delay_ms(1000);
01FC: MOVLW 04
01FD: MOVWF 72
01FE: MOVLW FA
01FF: MOVWF 73
0200: CALL 0A8
0201: DECFSZ 72,F
0202: GOTO 1FE
.................... STOPR;
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
.................... Delay_ms(1000);
020B: MOVLW 04
020C: MOVWF 72
020D: MOVLW FA
020E: MOVWF 73
020F: CALL 0A8
0210: DECFSZ 72,F
0211: GOTO 20D
.................... BR;
0212: BSF 03.5
0213: BCF 06.5
0214: BCF 03.5
0215: BSF 06.5
0216: BSF 03.5
0217: BCF 06.4
0218: BCF 03.5
0219: BCF 06.4
.................... Delay_ms(1000);
021A: MOVLW 04
021B: MOVWF 72
021C: MOVLW FA
021D: MOVWF 73
021E: CALL 0A8
021F: DECFSZ 72,F
0220: GOTO 21C
.................... STOPR;
0221: BSF 03.5
0222: BCF 06.4
0223: BCF 03.5
0224: BCF 06.4
0225: BSF 03.5
0226: BCF 06.5
0227: BCF 03.5
0228: BCF 06.5
.................... Delay_ms(1000);
0229: MOVLW 04
022A: MOVWF 72
022B: MOVLW FA
022C: MOVWF 73
022D: CALL 0A8
022E: DECFSZ 72,F
022F: GOTO 22B
....................
.................... FL; //levy pas
0230: BSF 03.5
0231: BCF 06.6
0232: BCF 03.5
0233: BSF 06.6
0234: BSF 03.5
0235: BCF 06.7
0236: BCF 03.5
0237: BCF 06.7
.................... Delay_ms(1000);
0238: MOVLW 04
0239: MOVWF 72
023A: MOVLW FA
023B: MOVWF 73
023C: CALL 0A8
023D: DECFSZ 72,F
023E: GOTO 23A
.................... STOPL;
023F: BSF 03.5
0240: BCF 06.6
0241: BCF 03.5
0242: BCF 06.6
0243: BSF 03.5
0244: BCF 06.7
0245: BCF 03.5
0246: BCF 06.7
.................... Delay_ms(1000);
0247: MOVLW 04
0248: MOVWF 72
0249: MOVLW FA
024A: MOVWF 73
024B: CALL 0A8
024C: DECFSZ 72,F
024D: GOTO 249
.................... BL;
024E: BSF 03.5
024F: BCF 06.7
0250: BCF 03.5
0251: BSF 06.7
0252: BSF 03.5
0253: BCF 06.6
0254: BCF 03.5
0255: BCF 06.6
.................... Delay_ms(1000);
0256: MOVLW 04
0257: MOVWF 72
0258: MOVLW FA
0259: MOVWF 73
025A: CALL 0A8
025B: DECFSZ 72,F
025C: GOTO 258
.................... STOPL;
025D: BSF 03.5
025E: BCF 06.6
025F: BCF 03.5
0260: BCF 06.6
0261: BSF 03.5
0262: BCF 06.7
0263: BCF 03.5
0264: BCF 06.7
.................... Delay_ms(1000);
0265: MOVLW 04
0266: MOVWF 72
0267: MOVLW FA
0268: MOVWF 73
0269: CALL 0A8
026A: DECFSZ 72,F
026B: GOTO 267
....................
.................... FL; //oba pasy
026C: BSF 03.5
026D: BCF 06.6
026E: BCF 03.5
026F: BSF 06.6
0270: BSF 03.5
0271: BCF 06.7
0272: BCF 03.5
0273: BCF 06.7
.................... FR;
0274: BSF 03.5
0275: BCF 06.4
0276: BCF 03.5
0277: BSF 06.4
0278: BSF 03.5
0279: BCF 06.5
027A: BCF 03.5
027B: BCF 06.5
.................... Delay_ms(1000);
027C: MOVLW 04
027D: MOVWF 72
027E: MOVLW FA
027F: MOVWF 73
0280: CALL 0A8
0281: DECFSZ 72,F
0282: GOTO 27E
.................... STOPL;
0283: BSF 03.5
0284: BCF 06.6
0285: BCF 03.5
0286: BCF 06.6
0287: BSF 03.5
0288: BCF 06.7
0289: BCF 03.5
028A: BCF 06.7
.................... STOPR;
028B: BSF 03.5
028C: BCF 06.4
028D: BCF 03.5
028E: BCF 06.4
028F: BSF 03.5
0290: BCF 06.5
0291: BCF 03.5
0292: BCF 06.5
.................... Delay_ms(1000);
0293: MOVLW 04
0294: MOVWF 72
0295: MOVLW FA
0296: MOVWF 73
0297: CALL 0A8
0298: DECFSZ 72,F
0299: GOTO 295
.................... BL;
029A: BSF 03.5
029B: BCF 06.7
029C: BCF 03.5
029D: BSF 06.7
029E: BSF 03.5
029F: BCF 06.6
02A0: BCF 03.5
02A1: BCF 06.6
.................... BR;
02A2: BSF 03.5
02A3: BCF 06.5
02A4: BCF 03.5
02A5: BSF 06.5
02A6: BSF 03.5
02A7: BCF 06.4
02A8: BCF 03.5
02A9: BCF 06.4
.................... Delay_ms(1000);
02AA: MOVLW 04
02AB: MOVWF 72
02AC: MOVLW FA
02AD: MOVWF 73
02AE: CALL 0A8
02AF: DECFSZ 72,F
02B0: GOTO 2AC
.................... STOPL;
02B1: BSF 03.5
02B2: BCF 06.6
02B3: BCF 03.5
02B4: BCF 06.6
02B5: BSF 03.5
02B6: BCF 06.7
02B7: BCF 03.5
02B8: BCF 06.7
.................... STOPR;
02B9: BSF 03.5
02BA: BCF 06.4
02BB: BCF 03.5
02BC: BCF 06.4
02BD: BSF 03.5
02BE: BCF 06.5
02BF: BCF 03.5
02C0: BCF 06.5
.................... Delay_ms(1000);
02C1: MOVLW 04
02C2: MOVWF 72
02C3: MOVLW FA
02C4: MOVWF 73
02C5: CALL 0A8
02C6: DECFSZ 72,F
02C7: GOTO 2C3
.................... }
02C8: GOTO 1CA
02C9: BCF 0A.3
02CA: GOTO 2F0 (RETURN)
.................... }
....................
.................... void main()
.................... {
02CB: CLRF 04
02CC: MOVLW 1F
02CD: ANDWF 03,F
02CE: MOVLW 07
02CF: BSF 03.5
02D0: MOVWF 1F
02D1: MOVLW 82
02D2: BCF 03.5
02D3: MOVWF 2D
02D4: MOVLW 98
02D5: MOVWF 2E
02D6: MOVWF 2F
02D7: MOVLW 40
02D8: MOVWF 30
02D9: MOVWF 31
02DA: MOVWF 32
02DB: MOVLW 60
02DC: MOVWF 33
02DD: MOVLW 86
02DE: MOVWF 34
02DF: MOVLW B4
02E0: MOVWF 35
02E1: MOVLW 60
02E2: MOVWF 36
02E3: MOVLW A4
02E4: MOVWF 37
02E5: MOVWF 38
02E6: MOVWF 39
02E7: MOVLW 61
02E8: MOVWF 3A
02E9: MOVLW 03
02EA: MOVWF 3B
02EB: MOVLW F0
02EC: MOVWF 3C
02ED: MOVLW FF
02EE: MOVWF 44
.................... diagnostika();
02EF: GOTO 1CA
....................
.................... SoundBeep(640,200); //beep
02F0: MOVLW 02
02F1: MOVWF 73
02F2: MOVLW 80
02F3: MOVWF 72
02F4: CLRF 75
02F5: MOVLW C8
02F6: MOVWF 74
02F7: CALL 129
.................... Delay_ms(50);
02F8: MOVLW 32
02F9: MOVWF 73
02FA: CALL 0A8
.................... SoundBeep(640,200);
02FB: MOVLW 02
02FC: MOVWF 73
02FD: MOVLW 80
02FE: MOVWF 72
02FF: CLRF 75
0300: MOVLW C8
0301: MOVWF 74
0302: CALL 129
....................
.................... setup_adc_ports(RA0_RA1_RA3_ANALOG);
0303: MOVLW 04
0304: BSF 03.5
0305: MOVWF 1F
.................... setup_adc(ADC_CLOCK_DIV_2);
0306: BCF 03.5
0307: MOVF 1F,W
0308: ANDLW 38
0309: IORLW 01
030A: MOVWF 1F
.................... Delay_ms(1000); // 1s
030B: MOVLW 04
030C: MOVWF 71
030D: MOVLW FA
030E: MOVWF 73
030F: CALL 0A8
0310: DECFSZ 71,F
0311: GOTO 30D
....................
.................... movement=R;
0312: MOVLW 01
0313: MOVWF 6D
.................... line=S;
0314: MOVLW 02
0315: MOVWF 6E
.................... dira=0;
0316: CLRF 6F
....................
.................... //cik_cak(); // toc se, abys nasel caru
.................... FL; FR; // vpred
0317: BSF 03.5
0318: BCF 06.6
0319: BCF 03.5
031A: BSF 06.6
031B: BSF 03.5
031C: BCF 06.7
031D: BCF 03.5
031E: BCF 06.7
031F: BSF 03.5
0320: BCF 06.4
0321: BCF 03.5
0322: BSF 06.4
0323: BSF 03.5
0324: BCF 06.5
0325: BCF 03.5
0326: BCF 06.5
....................
.................... // Sledovani cary
.................... while(true)
.................... {
.................... snimani:
.................... set_adc_channel(RSENSOR);
0327: MOVLW 08
0328: MOVWF 21
0329: MOVF 1F,W
032A: ANDLW C7
032B: IORWF 21,W
032C: MOVWF 1F
.................... Delay_us(2);
032D: NOP
032E: NOP
.................... if (TRESHOLD > read_adc()) // Cara pod pravym senzorem
032F: BSF 1F.2
0330: BTFSC 1F.2
0331: GOTO 330
0332: MOVF 1E,W
0333: SUBLW 31
0334: BTFSS 03.0
0335: GOTO 34A
.................... {
.................... dira=0; // nuluj pocitadlo diry, protoze jsme videli caru
0336: CLRF 6F
.................... line=R; // zaznamenej, kdes videl caru
0337: MOVLW 01
0338: MOVWF 6E
.................... FL;FR;
0339: BSF 03.5
033A: BCF 06.6
033B: BCF 03.5
033C: BSF 06.6
033D: BSF 03.5
033E: BCF 06.7
033F: BCF 03.5
0340: BCF 06.7
0341: BSF 03.5
0342: BCF 06.4
0343: BCF 03.5
0344: BSF 06.4
0345: BSF 03.5
0346: BCF 06.5
0347: BCF 03.5
0348: BCF 06.5
.................... goto snimani;
0349: GOTO 327
.................... }
....................
.................... set_adc_channel(LSENSOR);
034A: MOVLW 00
034B: MOVWF 21
034C: MOVF 1F,W
034D: ANDLW C7
034E: IORWF 21,W
034F: MOVWF 1F
.................... Delay_us(2);
0350: NOP
0351: NOP
.................... if (TRESHOLD > read_adc()) // Cara pod levym senzorem
0352: BSF 1F.2
0353: BTFSC 1F.2
0354: GOTO 353
0355: MOVF 1E,W
0356: SUBLW 31
0357: BTFSS 03.0
0358: GOTO 36C
.................... {
.................... dira=0; // nuluj pocitadlo diry, protoze jsme videli caru
0359: CLRF 6F
.................... line=L; // zaznamenej, kdes videl caru
035A: CLRF 6E
.................... FL;FR;
035B: BSF 03.5
035C: BCF 06.6
035D: BCF 03.5
035E: BSF 06.6
035F: BSF 03.5
0360: BCF 06.7
0361: BCF 03.5
0362: BCF 06.7
0363: BSF 03.5
0364: BCF 06.4
0365: BCF 03.5
0366: BSF 06.4
0367: BSF 03.5
0368: BCF 06.5
0369: BCF 03.5
036A: BCF 06.5
.................... goto snimani;
036B: GOTO 327
.................... }
....................
.................... // oba senzory mimo caru
.................... if (0==dira) // v prvnim cyklu po ztrate cary zacneme zahybat
036C: MOVF 6F,F
036D: BTFSS 03.2
036E: GOTO 3BF
.................... // v ostatnich cyklech nedelame nic (pro urychleni snimani)
.................... {
.................... STOPL;
036F: BSF 03.5
0370: BCF 06.6
0371: BCF 03.5
0372: BCF 06.6
0373: BSF 03.5
0374: BCF 06.7
0375: BCF 03.5
0376: BCF 06.7
.................... STOPR;
0377: BSF 03.5
0378: BCF 06.4
0379: BCF 03.5
037A: BCF 06.4
037B: BSF 03.5
037C: BCF 06.5
037D: BCF 03.5
037E: BCF 06.5
.................... BL;
037F: BSF 03.5
0380: BCF 06.7
0381: BCF 03.5
0382: BSF 06.7
0383: BSF 03.5
0384: BCF 06.6
0385: BCF 03.5
0386: BCF 06.6
.................... BR;
0387: BSF 03.5
0388: BCF 06.5
0389: BCF 03.5
038A: BSF 06.5
038B: BSF 03.5
038C: BCF 06.4
038D: BCF 03.5
038E: BCF 06.4
.................... Delay_ms(20);
038F: MOVLW 14
0390: MOVWF 73
0391: CALL 0A8
.................... STOPL;
0392: BSF 03.5
0393: BCF 06.6
0394: BCF 03.5
0395: BCF 06.6
0396: BSF 03.5
0397: BCF 06.7
0398: BCF 03.5
0399: BCF 06.7
.................... STOPR;
039A: BSF 03.5
039B: BCF 06.4
039C: BCF 03.5
039D: BCF 06.4
039E: BSF 03.5
039F: BCF 06.5
03A0: BCF 03.5
03A1: BCF 06.5
.................... Delay_ms(200);
03A2: MOVLW C8
03A3: MOVWF 73
03A4: CALL 0A8
.................... // kdyz nevidis caru, tak jed tam, kdes ji videl naposled
.................... if(line==L)
03A5: MOVF 6E,F
03A6: BTFSS 03.2
03A7: GOTO 3B1
.................... {
.................... // doleva
.................... // STOPL;
.................... FR;
03A8: BSF 03.5
03A9: BCF 06.4
03AA: BCF 03.5
03AB: BSF 06.4
03AC: BSF 03.5
03AD: BCF 06.5
03AE: BCF 03.5
03AF: BCF 06.5
.................... movement=L; // poznamenej kam jedes
03B0: CLRF 6D
.................... }
.................... if(line==R)
03B1: DECFSZ 6E,W
03B2: GOTO 3BD
.................... {
.................... // doprava
.................... // STOPR;
.................... FL;
03B3: BSF 03.5
03B4: BCF 06.6
03B5: BCF 03.5
03B6: BSF 06.6
03B7: BSF 03.5
03B8: BCF 06.7
03B9: BCF 03.5
03BA: BCF 06.7
.................... movement=R; // poznamenej kam jedes
03BB: MOVLW 01
03BC: MOVWF 6D
.................... }
.................... dira++; // zvets pocitadlo diry, aby to pristi cyklus tudy neslo
03BD: INCF 6F,F
.................... goto snimani; // co nejrychleji se vrat na snimani cary
03BE: GOTO 327
.................... }
....................
.................... /*if (MEZERA < dira++) // nejedeme uz moc dlouho bez cary??
.................... {
.................... dira=0;
.................... switch(movement) // kam se jelo ??
.................... {
.................... case L:
.................... BR; // couvej doprava
.................... Delay_ms(COUVEJ);
.................... movement=R;
.................... break;
.................... case R:
.................... BL; // couvej doleva
.................... Delay_ms(COUVEJ);
.................... movement=L;
.................... break;
.................... }
.................... STOP(); // konec couvani
.................... FL; FR; // rovne pres diru
.................... Delay_ms(PRES_DIRU);
.................... STOP();
.................... cik_cak(); // najdi caru
.................... FR; FL; // vpred
.................... } // dira*/
....................
.................... } // while(true)
03BF: GOTO 327
....................
.................... }
....................
03C0: SLEEP
.................... /*void objizdka()
.................... {
.................... BL; BR; // zacouvej
.................... Delay_ms(150);
.................... STOP();
....................
.................... cik_cak(); // vyrovnej se na caru
.................... cik_cak(); // radeji 3x, aby se vyrovnaly setrvacne sily
.................... cik_cak();
....................
.................... BL; FR; Delay_ms(220); // vlevo
.................... STOP();
.................... FL; FR; Delay_ms(650); // rovne
.................... STOP();
.................... FL; BR; Delay_ms(220); // vpravo
.................... STOP();
.................... FL; FR; Delay_ms(770); // rovne
.................... STOP();
.................... FL; BR; Delay_ms(210); // vpravo
.................... STOP();
.................... FL; FR;
.................... Delay_ms(200); // kousek rovne
.................... // rovne, dokud nenarazis na caru
.................... while(input(RSENSOR)); // pravej senzor, protoze cihla je vpravo
.................... STOP();
.................... BL; FR; // toc se doleva, dokud nenarazis na caru
.................... while(input(LSENSOR)); // levej senzor, protoze cara je urcite vlevo
.................... STOP();
.................... line=R; // caru predpokladame vpravo, kdybysme ji prejeli
.................... dira=0;
.................... FL; FR; // vpred
.................... }*/
....................