WebSVN – svnkaklik – Diff – /roboti/istrobot/tank/main.c


#include "D:\KAKLIK\programy\PIC_C\roboti\tank\main.h"
 
//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"
 
#DEFINE TXo        PIN_C0     // Vysilac
#include "C:\library\kaklik\CCS\AX25.c"             // Podprogram pro prenos telemetrie
 
//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
 
#use 	fixed_io(b_outputs=PIN_B2, PIN_B3, PIN_B4, PIN_B5, PIN_B6, PIN_B7)
#use 	fixed_io(a_outputs=PIN_A2)
#use	fixed_io(c_outputs=PIN_C0)
 
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_C5))
   {
      set_adc_channel(RSENSOR);
      Delay_us(2);
 
      set_adc_channel(LSENSOR);
      Delay_us(2);
 
      sprintf(AXstring,"Counter: %U\0", n++);  // Convert DATA to String.
      SendPacket(&AXstring[0]);
      delay_ms(1000);
   }
 
   while (input(PIN_C4))
   {
 
      for (n=500; n<5000; n+=100)
      {
         SoundBeep(n,50);                        //beep
      };
      Delay_ms(1000);
 
      STOPL;                     //zastav vse
      STOPR;
 
      FR;                        //pravy pas
      Delay_ms(1000);
      STOPR;
      Delay_ms(1000);
      BR;
      Delay_ms(1000);
      STOPR;
      Delay_ms(1000);
 
      FL;                        //levy pas
      Delay_ms(1000);
      STOPL;
      Delay_ms(1000);
      BL;
      Delay_ms(1000);
      STOPL;
      Delay_ms(1000);
 
      FL;                        //oba pasy
      FR;
      Delay_ms(1000);
      STOPL;
      STOPR;
      Delay_ms(1000);
      BL;
      BR;
      Delay_ms(1000);
      STOPL;
      STOPR;
      Delay_ms(1000);
   }
}
 
void main()
{
  setup_adc_ports(RA0_RA1_RA3_ANALOG);
  setup_adc(ADC_CLOCK_DIV_2);
  diagnostika();
 
  SoundBeep(640,200);                        //beep
  Delay_ms(50);
  SoundBeep(640,200);
  Delay_ms(1000); // 1s
 
  movement=R;
  line=S;
  dira=0;
 
  //cik_cak();    // toc se, abys nasel caru
  FL; FR;         // vpred
 
                                                   // Sledovani cary
  while(true)
  {
snimani:
    set_adc_channel(RSENSOR);
    Delay_us(2);
    if (TRESHOLD > read_adc())    // Cara pod pravym senzorem
    {
      dira=0;    // nuluj pocitadlo diry, protoze jsme videli caru
      line=R;    // zaznamenej, kdes videl caru
      FL;FR;
      goto snimani;
    }
 
    set_adc_channel(LSENSOR);
    Delay_us(2);
    if (TRESHOLD > read_adc())    // Cara pod levym senzorem
    {
      dira=0;    // nuluj pocitadlo diry, protoze jsme videli caru
      line=L;    // zaznamenej, kdes videl caru
      FL;FR;
      goto snimani;
    }
 
    // oba senzory mimo caru
    if (0==dira) // v prvnim cyklu po ztrate cary zacneme zahybat
                 // v ostatnich cyklech nedelame nic (pro urychleni snimani)
    {
                           // kdyz nevidis caru, tak jed tam, kdes ji videl naposled
      if(line==L)
      {
        // doleva
//      STOPL;
      FR;
        movement=L;    // poznamenej kam jedes
      }
      if(line==R)
      {
        // doprava
//     STOPR;
        FL;
        movement=R;    // poznamenej kam jedes
      }
      dira++;   // zvets pocitadlo diry, aby to pristi cyklus tudy neslo
      goto snimani; // co nejrychleji se vrat na snimani cary
    }
 
    /*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)
 
}
 
/*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
}*/

Rev 2	Rev 4
1	`#include "D:\KAKLIK\programy\PIC_C\roboti\tank\main.h"`	1	`#include "D:\KAKLIK\programy\PIC_C\roboti\tank\main.h"`
2		2
3	`//motory`	3	`//motory`
4	`#define FR output_high(PIN_B4);output_low(PIN_B5) // Vpred`	4	`#define FR output_high(PIN_B4);output_low(PIN_B5) // Vpred`
5	`#define FL output_high(PIN_B6);output_low(PIN_B7)`	5	`#define FL output_high(PIN_B6);output_low(PIN_B7)`
6	`#define BR output_high(PIN_B5);output_low(PIN_B4) // Vzad`	6	`#define BR output_high(PIN_B5);output_low(PIN_B4) // Vzad`
7	`#define BL output_high(PIN_B7);output_low(PIN_B6)`	7	`#define BL output_high(PIN_B7);output_low(PIN_B6)`
8	`#define STOPR output_low(PIN_B4);output_low(PIN_B5)`	8	`#define STOPR output_low(PIN_B4);output_low(PIN_B5)`
9	`#define STOPL output_low(PIN_B6);output_low(PIN_B7)`	9	`#define STOPL output_low(PIN_B6);output_low(PIN_B7)`
10		10
11	`//cidla`	11	`//cidla`
12	`#define RSENSOR 1 // Senzory na caru`	12	`#define RSENSOR 1 // Senzory na caru`
13	`#define LSENSOR 0`	13	`#define LSENSOR 0`
14	`//#define BUMPER SENSOR_2 // Senzor na cihlu`	14	`//#define BUMPER SENSOR_2 // Senzor na cihlu`
15		15
16	`//human interface`	16	`//human interface`
17	`#DEFINE LED PIN_A2`	17	`#DEFINE LED PIN_A2`
18		18
19	`#DEFINE SOUND_HI PIN_B2`	19	`#DEFINE SOUND_HI PIN_B2`
20	`#DEFINE SOUND_LO PIN_B3`	20	`#DEFINE SOUND_LO PIN_B3`
21	`#include "sound.c"`	21	`#include "sound.c"`
22		22
23	`#DEFINE TXo PIN_C0 // Vysilac`	23	`#DEFINE TXo PIN_C0 // Vysilac`
24	`#include "C:\library\kaklik\CCS\AX25.c" // Podprogram pro prenos telemetrie`	24	`#include "C:\library\kaklik\CCS\AX25.c" // Podprogram pro prenos telemetrie`
25		25
26	`//program`	26	`//program`
27	`#define MEZERA 38 // jak se muze jet dlouho bez cary`	27	`#define MEZERA 38 // jak se muze jet dlouho bez cary`
28	`#define COUVEJ 700 // kolik se ma couvat po detekci diry`	28	`#define COUVEJ 700 // kolik se ma couvat po detekci diry`
29	`#define CIKCAK 40 // kolik se ma jet cik/cak`	29	`#define CIKCAK 40 // kolik se ma jet cik/cak`
30	`#define PRES_DIRU 350 // jak predpokladame velkou diru`	30	`#define PRES_DIRU 350 // jak predpokladame velkou diru`
31	`#define TRESHOLD 50`	31	`#define TRESHOLD 50`
32		32
33	`#define L 0 // left`	33	`#define L 0 // left`
34	`#define R 1 // right`	34	`#define R 1 // right`
35	`#define S 2 // straight`	35	`#define S 2 // straight`
36		36
37	`#use fixed_io(b_outputs=PIN_B2, PIN_B3, PIN_B4, PIN_B5, PIN_B6, PIN_B7)`	37	`#use fixed_io(b_outputs=PIN_B2, PIN_B3, PIN_B4, PIN_B5, PIN_B6, PIN_B7)`
38	`#use fixed_io(a_outputs=PIN_A2)`	38	`#use fixed_io(a_outputs=PIN_A2)`
39	`#use fixed_io(c_outputs=PIN_C0)`	39	`#use fixed_io(c_outputs=PIN_C0)`
40		40
41	`char AXstring[40]; // Buffer pro prenos telemetrie`	41	`char AXstring[40]; // Buffer pro prenos telemetrie`
42		42
43	`int movement; // smer minuleho pohybu`	43	`int movement; // smer minuleho pohybu`
44	`int line; // na ktere strane byla detekovana cara`	44	`int line; // na ktere strane byla detekovana cara`
45	`int dira; // pocitadlo pro nalezeni preruseni cary`	45	`int dira; // pocitadlo pro nalezeni preruseni cary`
46	`int n; // pomocna promena pro cyklus FOR`	46	`int n; // pomocna promena pro cyklus FOR`
47		47
48	`void cik_cak() // Hledani cary`	48	`void cik_cak() // Hledani cary`
49	`{`	49	`{`
50	`n=CIKCAK/2; // poprve hned zatoc opacne, nez se jelo pred detekci diry`	50	`n=CIKCAK/2; // poprve hned zatoc opacne, nez se jelo pred detekci diry`
51	`switch(movement) // zmenime smer zataceni`	51	`switch(movement) // zmenime smer zataceni`
52	`{`	52	`{`
53	`case L:`	53	`case L:`
54	`FL;STOPR; // doprava`	54	`FL;STOPR; // doprava`
55	`movement=R; // poznamenej kam jedem`	55	`movement=R; // poznamenej kam jedem`
56	`line=L; // kdyz prejedem, tak bude cara vlevo`	56	`line=L; // kdyz prejedem, tak bude cara vlevo`
57	`break;`	57	`break;`
58	`case R:`	58	`case R:`
59	`FR;STOPL; // doleva`	59	`FR;STOPL; // doleva`
60	`movement=L; // poznamenej kam jedem`	60	`movement=L; // poznamenej kam jedem`
61	`line=R; // kdyz prejedem, tak bude cara vpravo`	61	`line=R; // kdyz prejedem, tak bude cara vpravo`
62	`break;`	62	`break;`
63	`}`	63	`}`
64		64
65	`while(true) // jed cik-cak, dokud nenajdes caru`	65	`while(true) // jed cik-cak, dokud nenajdes caru`
66	`{`	66	`{`
67	`set_adc_channel(RSENSOR);`	67	`set_adc_channel(RSENSOR);`
68	`if (TRESHOLD > read_adc()) // je cara ?`	68	`if (TRESHOLD > read_adc()) // je cara ?`
69	`{`	69	`{`
70	`STOPL;`	70	`STOPL;`
71	`STOPR;`	71	`STOPR;`
72	`break;`	72	`break;`
73	`};`	73	`};`
74	`if (CIKCAK < n++) // Jedeme uz dost dlouho cik? Pak jed cak.`	74	`if (CIKCAK < n++) // Jedeme uz dost dlouho cik? Pak jed cak.`
75	`{`	75	`{`
76	`n=0;`	76	`n=0;`
77	`STOPL;`	77	`STOPL;`
78	`STOPR;`	78	`STOPR;`
79	`switch(movement) // zmenime smer zataceni`	79	`switch(movement) // zmenime smer zataceni`
80	`{`	80	`{`
81	`case L:`	81	`case L:`
82	`FL; // doprava`	82	`FL; // doprava`
83	`movement=R; // poznamenej kam jedem`	83	`movement=R; // poznamenej kam jedem`
84	`line=L; // kdyz prejedem, tak bude cara vlevo`	84	`line=L; // kdyz prejedem, tak bude cara vlevo`
85	`break;`	85	`break;`
86	`case R:`	86	`case R:`
87	`FR; // doleva`	87	`FR; // doleva`
88	`movement=L; // poznamenej kam jedem`	88	`movement=L; // poznamenej kam jedem`
89	`line=R; // kdyz prejedem, tak bude cara vpravo`	89	`line=R; // kdyz prejedem, tak bude cara vpravo`
90	`break;`	90	`break;`
91	`}`	91	`}`
92	`}`	92	`}`
93	`}`	93	`}`
94	`}`	94	`}`
95		95
96		96
97	`void diagnostika()`	97	`void diagnostika()`
98	`{`	98	`{`
99	`int n;`	99	`int n;`
100	`while (input(PIN_C5))`	100	`while (input(PIN_C5))`
101	`{`	101	`{`
102	`set_adc_channel(RSENSOR);`	102	`set_adc_channel(RSENSOR);`
103	`Delay_us(2);`	103	`Delay_us(2);`
104		104
105	`set_adc_channel(LSENSOR);`	105	`set_adc_channel(LSENSOR);`
106	`Delay_us(2);`	106	`Delay_us(2);`
107		107
108	`sprintf(AXstring,"Counter: %U\0", n++); // Convert DATA to String.`	108	`sprintf(AXstring,"Counter: %U\0", n++); // Convert DATA to String.`
109	`SendPacket(&AXstring[0]);`	109	`SendPacket(&AXstring[0]);`
110	`delay_ms(1000);`	110	`delay_ms(1000);`
111	`}`	111	`}`
112		112
113	`while (input(PIN_C4))`	113	`while (input(PIN_C4))`
114	`{`	114	`{`
115		115
116	`for (n=500; n<5000; n+=100)`	116	`for (n=500; n<5000; n+=100)`
117	`{`	117	`{`
118	`SoundBeep(n,50); //beep`	118	`SoundBeep(n,50); //beep`
119	`};`	119	`};`
120	`Delay_ms(1000);`	120	`Delay_ms(1000);`
121		121
122	`STOPL; //zastav vse`	122	`STOPL; //zastav vse`
123	`STOPR;`	123	`STOPR;`
124		124
125	`FR; //pravy pas`	125	`FR; //pravy pas`
126	`Delay_ms(1000);`	126	`Delay_ms(1000);`
127	`STOPR;`	127	`STOPR;`
128	`Delay_ms(1000);`	128	`Delay_ms(1000);`
129	`BR;`	129	`BR;`
130	`Delay_ms(1000);`	130	`Delay_ms(1000);`
131	`STOPR;`	131	`STOPR;`
132	`Delay_ms(1000);`	132	`Delay_ms(1000);`
133		133
134	`FL; //levy pas`	134	`FL; //levy pas`
135	`Delay_ms(1000);`	135	`Delay_ms(1000);`
136	`STOPL;`	136	`STOPL;`
137	`Delay_ms(1000);`	137	`Delay_ms(1000);`
138	`BL;`	138	`BL;`
139	`Delay_ms(1000);`	139	`Delay_ms(1000);`
140	`STOPL;`	140	`STOPL;`
141	`Delay_ms(1000);`	141	`Delay_ms(1000);`
142		142
143	`FL; //oba pasy`	143	`FL; //oba pasy`
144	`FR;`	144	`FR;`
145	`Delay_ms(1000);`	145	`Delay_ms(1000);`
146	`STOPL;`	146	`STOPL;`
147	`STOPR;`	147	`STOPR;`
148	`Delay_ms(1000);`	148	`Delay_ms(1000);`
149	`BL;`	149	`BL;`
150	`BR;`	150	`BR;`
151	`Delay_ms(1000);`	151	`Delay_ms(1000);`
152	`STOPL;`	152	`STOPL;`
153	`STOPR;`	153	`STOPR;`
154	`Delay_ms(1000);`	154	`Delay_ms(1000);`
155	`}`	155	`}`
156	`}`	156	`}`
157		157
158	`void main()`	158	`void main()`
159	`{`	159	`{`
160	`setup_adc_ports(RA0_RA1_RA3_ANALOG);`	160	`setup_adc_ports(RA0_RA1_RA3_ANALOG);`
161	`setup_adc(ADC_CLOCK_DIV_2);`	161	`setup_adc(ADC_CLOCK_DIV_2);`
162	`diagnostika();`	162	`diagnostika();`
163		163
164	`SoundBeep(640,200); //beep`	164	`SoundBeep(640,200); //beep`
165	`Delay_ms(50);`	165	`Delay_ms(50);`
166	`SoundBeep(640,200);`	166	`SoundBeep(640,200);`
167	`Delay_ms(1000); // 1s`	167	`Delay_ms(1000); // 1s`
168		168
169	`movement=R;`	169	`movement=R;`
170	`line=S;`	170	`line=S;`
171	`dira=0;`	171	`dira=0;`
172		172
173	`//cik_cak(); // toc se, abys nasel caru`	173	`//cik_cak(); // toc se, abys nasel caru`
174	`FL; FR; // vpred`	174	`FL; FR; // vpred`
175		175
176	`// Sledovani cary`	176	`// Sledovani cary`
177	`while(true)`	177	`while(true)`
178	`{`	178	`{`
179	`snimani:`	179	`snimani:`
180	`set_adc_channel(RSENSOR);`	180	`set_adc_channel(RSENSOR);`
181	`Delay_us(2);`	181	`Delay_us(2);`
182	`if (TRESHOLD > read_adc()) // Cara pod pravym senzorem`	182	`if (TRESHOLD > read_adc()) // Cara pod pravym senzorem`
183	`{`	183	`{`
184	`dira=0; // nuluj pocitadlo diry, protoze jsme videli caru`	184	`dira=0; // nuluj pocitadlo diry, protoze jsme videli caru`
185	`line=R; // zaznamenej, kdes videl caru`	185	`line=R; // zaznamenej, kdes videl caru`
186	`FL;FR;`	186	`FL;FR;`
187	`goto snimani;`	187	`goto snimani;`
188	`}`	188	`}`
189		189
190	`set_adc_channel(LSENSOR);`	190	`set_adc_channel(LSENSOR);`
191	`Delay_us(2);`	191	`Delay_us(2);`
192	`if (TRESHOLD > read_adc()) // Cara pod levym senzorem`	192	`if (TRESHOLD > read_adc()) // Cara pod levym senzorem`
193	`{`	193	`{`
194	`dira=0; // nuluj pocitadlo diry, protoze jsme videli caru`	194	`dira=0; // nuluj pocitadlo diry, protoze jsme videli caru`
195	`line=L; // zaznamenej, kdes videl caru`	195	`line=L; // zaznamenej, kdes videl caru`
196	`FL;FR;`	196	`FL;FR;`
197	`goto snimani;`	197	`goto snimani;`
198	`}`	198	`}`
199		199
200	`// oba senzory mimo caru`	200	`// oba senzory mimo caru`
201	`if (0==dira) // v prvnim cyklu po ztrate cary zacneme zahybat`	201	`if (0==dira) // v prvnim cyklu po ztrate cary zacneme zahybat`
202	`// v ostatnich cyklech nedelame nic (pro urychleni snimani)`	202	`// v ostatnich cyklech nedelame nic (pro urychleni snimani)`
203	`{`	203	`{`
204	`// kdyz nevidis caru, tak jed tam, kdes ji videl naposled`	204	`// kdyz nevidis caru, tak jed tam, kdes ji videl naposled`
205	`if(line==L)`	205	`if(line==L)`
206	`{`	206	`{`
207	`// doleva`	207	`// doleva`
208	`// STOPL;`	208	`// STOPL;`
209	`FR;`	209	`FR;`
210	`movement=L; // poznamenej kam jedes`	210	`movement=L; // poznamenej kam jedes`
211	`}`	211	`}`
212	`if(line==R)`	212	`if(line==R)`
213	`{`	213	`{`
214	`// doprava`	214	`// doprava`
215	`// STOPR;`	215	`// STOPR;`
216	`FL;`	216	`FL;`
217	`movement=R; // poznamenej kam jedes`	217	`movement=R; // poznamenej kam jedes`
218	`}`	218	`}`
219	`dira++; // zvets pocitadlo diry, aby to pristi cyklus tudy neslo`	219	`dira++; // zvets pocitadlo diry, aby to pristi cyklus tudy neslo`
220	`goto snimani; // co nejrychleji se vrat na snimani cary`	220	`goto snimani; // co nejrychleji se vrat na snimani cary`
221	`}`	221	`}`
222		222
223	`/*if (MEZERA < dira++) // nejedeme uz moc dlouho bez cary?`	223	`/*if (MEZERA < dira++) // nejedeme uz moc dlouho bez cary?`
224	`{`	224	`{`
225	`dira=0;`	225	`dira=0;`
226	`switch(movement) // kam se jelo ?`	226	`switch(movement) // kam se jelo ?`
227	`{`	227	`{`
228	`case L:`	228	`case L:`
229	`BR; // couvej doprava`	229	`BR; // couvej doprava`
230	`Delay_ms(COUVEJ);`	230	`Delay_ms(COUVEJ);`
231	`movement=R;`	231	`movement=R;`
232	`break;`	232	`break;`
233	`case R:`	233	`case R:`
234	`BL; // couvej doleva`	234	`BL; // couvej doleva`
235	`Delay_ms(COUVEJ);`	235	`Delay_ms(COUVEJ);`
236	`movement=L;`	236	`movement=L;`
237	`break;`	237	`break;`
238	`}`	238	`}`
239	`STOP(); // konec couvani`	239	`STOP(); // konec couvani`
240	`FL; FR; // rovne pres diru`	240	`FL; FR; // rovne pres diru`
241	`Delay_ms(PRES_DIRU);`	241	`Delay_ms(PRES_DIRU);`
242	`STOP();`	242	`STOP();`
243	`cik_cak(); // najdi caru`	243	`cik_cak(); // najdi caru`
244	`FR; FL; // vpred`	244	`FR; FL; // vpred`
245	`} // dira*/`	245	`} // dira*/`
246		246
247	`} // while(true)`	247	`} // while(true)`
248		248
249	`}`	249	`}`
250		250
251	`/*void objizdka()`	251	`/*void objizdka()`
252	`{`	252	`{`
253	`BL; BR; // zacouvej`	253	`BL; BR; // zacouvej`
254	`Delay_ms(150);`	254	`Delay_ms(150);`
255	`STOP();`	255	`STOP();`
256		256
257	`cik_cak(); // vyrovnej se na caru`	257	`cik_cak(); // vyrovnej se na caru`
258	`cik_cak(); // radeji 3x, aby se vyrovnaly setrvacne sily`	258	`cik_cak(); // radeji 3x, aby se vyrovnaly setrvacne sily`
259	`cik_cak();`	259	`cik_cak();`
260		260
261	`BL; FR; Delay_ms(220); // vlevo`	261	`BL; FR; Delay_ms(220); // vlevo`
262	`STOP();`	262	`STOP();`
263	`FL; FR; Delay_ms(650); // rovne`	263	`FL; FR; Delay_ms(650); // rovne`
264	`STOP();`	264	`STOP();`
265	`FL; BR; Delay_ms(220); // vpravo`	265	`FL; BR; Delay_ms(220); // vpravo`
266	`STOP();`	266	`STOP();`
267	`FL; FR; Delay_ms(770); // rovne`	267	`FL; FR; Delay_ms(770); // rovne`
268	`STOP();`	268	`STOP();`
269	`FL; BR; Delay_ms(210); // vpravo`	269	`FL; BR; Delay_ms(210); // vpravo`
270	`STOP();`	270	`STOP();`
271	`FL; FR;`	271	`FL; FR;`
272	`Delay_ms(200); // kousek rovne`	272	`Delay_ms(200); // kousek rovne`
273	`// rovne, dokud nenarazis na caru`	273	`// rovne, dokud nenarazis na caru`
274	`while(input(RSENSOR)); // pravej senzor, protoze cihla je vpravo`	274	`while(input(RSENSOR)); // pravej senzor, protoze cihla je vpravo`
275	`STOP();`	275	`STOP();`
276	`BL; FR; // toc se doleva, dokud nenarazis na caru`	276	`BL; FR; // toc se doleva, dokud nenarazis na caru`
277	`while(input(LSENSOR)); // levej senzor, protoze cara je urcite vlevo`	277	`while(input(LSENSOR)); // levej senzor, protoze cara je urcite vlevo`
278	`STOP();`	278	`STOP();`
279	`line=R; // caru predpokladame vpravo, kdybysme ji prejeli`	279	`line=R; // caru predpokladame vpravo, kdybysme ji prejeli`
280	`dira=0;`	280	`dira=0;`
281	`FL; FR; // vpred`	281	`FL; FR; // vpred`
282	`}*/`	282	`}*/`

Subversion Repositories svnkaklik

(root)/roboti/istrobot/tank/main.c @ 360 – Rev 2 → 4