WebSVN – svnkaklik – Diff – /roboti/istrobot/camerus/SW/876/camerus.c


#include ".\camerus.h"
 
#USE FAST_IO (C)     // Brana C je ve FAST_IO modu, aby slo rychle cteni z kamery
 
// A/D vstupy
#define  DALKOMER 4  // AN4/RA5 - dalkomer na cihlu
#define  CERNA    3  // AN3/RA3
#define  CERVENA  2  // AN2/RA2 - cervene kroutitko
#define  ZELENA   1  // AN1/RA0 - zelene kroutitko
#define  MODRA    0  // AN0/RA1 - modre kroutitko
 
// I/O
#define HREF   PIN_C5      // Signal HREF z kamery (v H po celou dobu radku)
#define PIX    PIN_C6      // Vstup pro body z kamery (za trivstupim hradlem OR (dig. komparator))
#define SERVO  PIN_B4      // Vystup na servo (1 az 2ms po cca 20ms (synchronizovano snimkovym kmitoctem))
#define MOT_L  PIN_B5      // Smer otaceni leveho motoru; druhy pol je RC2
#define MOT_R  PIN_B6      // Smer otaceni praveho motoru; druhy pol je RC1
#define DATA   PIN_B2      // K modulu LEDbar data
#define CP     PIN_B1      // K modulu LEDbar hodiny
#define ODO    PIN_A4      // Ze snimace z odometrie z praveho kola
//#define CIHLA  PIN_B0      // Vstup INT, generuje preruseni pri prekazce
#define IRLED  PIN_C0      // Modulovani vysilaci IR LED na detekci prekazky
 
#define CASMIN 6           // Rozsah radku snimace
#define CASMAX 192
#define CASAVR ((CASMAX+CASMIN) / 2)
 
#byte INTCON      = 0x0B         // Interrupt configuration register
   #bit GIE       = INTCON.7
   #bit PEIE      = INTCON.6
   #bit TMR0IE    = INTCON.5
   #bit INT0IE    = INTCON.4
   #bit RBIE      = INTCON.3
   #bit TMR0IF    = INTCON.2
   #bit INT0IF    = INTCON.1
   #bit RBIF      = INTCON.0
 
enum stavy {start,rozjezd,jizda,cihla,cil};
stavy stav;    // Kde jsme na trati
int8 cas;      // Cas hrany bila/cerna v radce
 
void SetServo(int8 angle)
{
   int8 n, offset;
 
   for(n=0; n<20; n++)
   {
      set_adc_channel(MODRA);    // Kroutitko na vystredeni predniho kolecka
      Delay_ms(1);
      offset=read_adc();
 
      output_high(SERVO);        // Odvysilani impuzu 1 az 2ms pro servo
      delay_us(1000);
      delay_us(offset);
      delay_us(offset);
      delay_us(offset);
      delay_us(angle);
      delay_us(angle);
      output_low(SERVO);
      delay_ms(18);
   }
}
 
#int_EXT
EXT_isr()   // Preruseni od prekazky
{
   set_pwm1_duty(0);    // reverz (zabrzdi)
   set_pwm2_duty(0);
   output_high(MOT_L);
   output_high(MOT_R);
   delay_ms(400);
   output_low(MOT_L); // zastav
   output_low(MOT_R);
   if (stav==cihla) while(true); // Zastav na furt
   if(stav==jizda)
   {
      int n;
 
      SetServo(CASAVR-CASMIN);
      set_pwm1_duty(40); // pomalu couvej
      set_pwm2_duty(40);
      output_high(MOT_L);
      output_high(MOT_R);
      n=0;
      while(true)
      {
         while(input(ODO));
         while(!input(ODO));
         n++;
         if(n==6) break;
      }
      set_pwm1_duty(255);    // reverz (zabrzdi)
      set_pwm2_duty(255);
      output_low(MOT_L);
      output_low(MOT_R);
      delay_ms(100);
      set_pwm1_duty(0);  // Zastav
      set_pwm2_duty(0);
      output_low(MOT_L);
      output_low(MOT_R);
      delay_ms(1000);
 
      SetServo((CASAVR-CASMIN)-20);   // doleva
      set_pwm1_duty(150);  // vpred
      set_pwm2_duty(200);
      output_low(MOT_L);
      output_low(MOT_R);
      stav=cihla;
      n=0;
      while(true)
      {
         while(input(ODO));
         while(!input(ODO));
         n++;
         if(n==10) break;
      }
      set_pwm1_duty(0);    // reverz (zabrzdi)
      set_pwm2_duty(0);
      output_high(MOT_L);
      output_high(MOT_R);
 
      SetServo((CASAVR-CASMIN));   // rovne
      set_pwm1_duty(140);  // vpred
      set_pwm2_duty(140);
      output_low(MOT_L);
      output_low(MOT_R);
      stav=cihla;
      n=0;
      while(true)
      {
         while(input(ODO));
         while(!input(ODO));
         n++;
         if(n==10) break;
      }
      set_pwm1_duty(0);    // reverz (zabrzdi)
      set_pwm2_duty(0);
      output_high(MOT_L);
      output_high(MOT_R);
      delay_ms(200);
      set_pwm1_duty(150);  // Zastav
      set_pwm2_duty(150);
      output_high(MOT_L);
      output_high(MOT_R);
      delay_ms(1000);
 
      SetServo(CASMIN);   // max. doleva
      set_pwm1_duty(0);  // vzad
      set_pwm2_duty(20);
      output_low(MOT_L);
      output_high(MOT_R);
      stav=cihla;
      n=0;
      while(true)
      {
         while(input(ODO));
         while(!input(ODO));
         n++;
         if(n==10) break;
      }
      set_pwm1_duty(0);    // reverz (zabrzdi)
      set_pwm2_duty(255);
      output_low(MOT_L);
      output_low(MOT_R);
      delay_ms(100);
      set_pwm1_duty(0);  // Zastav
      set_pwm2_duty(0);
      output_low(MOT_L);
      output_low(MOT_R);
      delay_ms(500);
 
 
      SetServo((CASAVR-CASMIN)+5);   // mirne doprava
      set_pwm1_duty(180);  // vpred
      set_pwm2_duty(180);
      output_low(MOT_L);
      output_low(MOT_R);
      stav=cihla;
      n=0;
      while(true)
      {
         while(input(ODO));
         while(!input(ODO));
         n++;
         if(n==10) break;
      }
      set_pwm1_duty(0);  // Zastav
      set_pwm2_duty(0);
      output_low(MOT_L);
      output_low(MOT_R);
      delay_ms(500);
 
 
      cas=CASMIN;  // Cara je vlevo
 
      stav=cihla;
   }
}
 
// Zobrazeni jednoho byte na modulu LEDbar
void disp(int8 x)
{
   int n;
 
   x=~x;
   for(n=0;n<=7;n++)
   {
      if (x & 1 == 1) output_high(DATA); else output_low(DATA);
      output_high(CP);
      x>>=1;
      output_low(CP);
   }
}
 
// Blikani LEDbarem ve stilu Night Rider
void NightRider(int8 x)
{
   int n,i,j;
 
   for(j=0;j<x;j++)
   {
      i=0x01;
      for(n=0;n<7;n++)
      {
         disp(i);
         rotate_left(&i, 1);
         delay_ms(40);
      }
      for(n=0;n<7;n++)
      {
         disp(i);
         rotate_right(&i, 1);
         delay_ms(40);
      }
   }
   disp(i);
   delay_ms(40);
   i=0;
   disp(i);
}
 
 
void main()
{
   int8 offset;   // Promena pro ulozeni ovsetu
   int8 rr;       // Promenna na ulozeni Rozumne rychlost
   int8 r1;       // Rychlost motoru 1
   int8 r2;       // Rychlost motoru 2
   int16 trasa;   // Pocitadlo ujete vzdalenosti
 
   setup_adc_ports(ALL_ANALOG);              // Zapnuti A/D prevodniku pro cteni kroutitek
   setup_adc(ADC_CLOCK_INTERNAL);
   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);  // Casovac pro mereni casu hrany W/B v radce
   setup_timer_1(T1_DISABLED);
   setup_timer_2(T2_DIV_BY_16,255,1);        // Casovac PWM motoru
   setup_ccp1(CCP_PWM); // RC1               // PWM pro motory
   setup_ccp2(CCP_PWM); // RC2
   setup_comparator(NC_NC_NC_NC);
   setup_vref(FALSE);
 
   set_tris_c(0b11111000);     // Nastaveni vstup/vystup pro branu C, protoze se nedela automaticky
 
   set_pwm1_duty(0);   // Zastav motory
   set_pwm2_duty(0);
   output_low(MOT_L);
   output_low(MOT_R);
 
   output_low(IRLED);   // Zapni LED na detekci prekazky
   
   NightRider(1);    // Aby se poznalo, ze byl RESET
                     // Musi se pockat, nez se rozjede kamera, nez se do ni zacnou posilat prikazy
 
   //... Nastaveni kamery ...
   i2c_start();      // Soft RESET kamery
   i2c_write(0xC0);        // Pro single slave musi mit vsechny zapisy adresu C0h
   i2c_write(0x12);        // Adresa registru COMH
   i2c_write(0x80 | 0x24); // Zapis ridiciho slova
   i2c_stop();
 
   i2c_start();      // BW
   i2c_write(0xC0);
   i2c_write(0x28);
   i2c_write(0b01000001);
   i2c_stop();
 
/*
   i2c_start();      // Contrast
   i2c_write(0xC0);
   i2c_write(0x05);
   i2c_write(0xA0);  // 48h
   i2c_stop();
 
   i2c_start();      // Brightness
   i2c_write(0xC0);
   i2c_write(0x06);
   i2c_write(0x0);  // 80h //9Ah
   i2c_stop();
 
   i2c_start();      // Band Filter
   i2c_write(0xC0);
   i2c_write(0x2D);
   i2c_write(0x04 | 0x03);
   i2c_stop();
*/
 
   i2c_start();      // Fame Rate
   i2c_write(0xC0);
   i2c_write(0x2B);
   i2c_write(0x00);  // cca 17ms (puvodni hodnota 5Eh = 20ms)
   i2c_stop();
 
   i2c_start();      // VSTRT
   i2c_write(0xC0);
   i2c_write(0x19);
   i2c_write(118);   // prostredni radka
   i2c_stop();
 
   i2c_start();      // VEND
   i2c_write(0xC0);
   i2c_write(0x1A);
   i2c_write(118);
   i2c_stop();
 
   NightRider(1);    // Musi se dat cas kamere na AGC a AEC
 
{ // Kalibrace kamery
   int8 t1,t2;
 
   for(offset=0;offset<=255;offset+=0x04) // Cita porad dokola
   {
      i2c_start();      // Brightness
      i2c_write(0xC0);
      i2c_write(0x06);
      i2c_write(offset);  // 80h default
      i2c_stop();
      disp(offset);
      delay_ms(50);
 
      t1=0;
      t2=0;
      while(!input(HREF));    // Cekej nez se zacnou posilat pixely z radky
      delay_ms(5);
      while(!input(HREF));    // Cekej nez se zacnou posilat pixely z radky
      set_timer0(0);          // Vynuluj pocitadlo casu
      if(!input(PIX)) continue;
      while(input(PIX));
      t1=get_timer0();    // Precti cas z citace casu hrany
      set_timer0(0);          // Vynuluj pocitadlo casu
      while(!input(PIX));
      t2=get_timer0();
 
      if((t1>60) && (t1<140) && (t2>5) && (t2<=10)) break;
 
      delay_ms(2);
   }
}
 
delay_ms(1000);
 
   cas=CASAVR-CASMIN;  // Inicializace promenych, aby neslo servo za roh a aby se to rozjelo jeste dneska
   stav=start;
   trasa=0;
 
   // ... Hlavni smycka ...
   while(true)
   {
      int8 pom;
      int8 n;
 
      pom=0;
      while(!input(HREF));    // Cekej nez se zacnou posilat pixely z radky
      set_timer0(0);          // Vynuluj pocitadlo casu
      while(input(HREF))      // Po dobu vysilani radky cekej na hranu W/B
      {
// !!!!Dodelat rozpoznani cerne cary napric pro zastaveni
         if(!input(PIX))   // Pokud se Xx za sebou precetla CERNA
         if(!input(PIX))
//         if(!input(PIX))
         {
            pom=get_timer0();    // Precti cas z citace casu hrany
            break;
         };
      };
      while(input(HREF));      // Pockej na shozeni signalu HREF
 
      if((pom<CASMAX) && (pom>CASMIN)) cas=pom;  // Orizni konce radku
      // Na konci obrazovaho radku to blbne. Jednak chyba od apertury
      // a vubec to nejak na kraji nefunguje.
 
      set_adc_channel(MODRA);    // Kroutitko na vystredeni predniho kolecka
      Delay_ms(1);
      offset=read_adc();
 
      output_high(SERVO);        // Odvysilani impuzu 1 az 2ms pro servo
      delay_us(1000);
      delay_us(offset);
      delay_us(offset);
      delay_us(offset);
      delay_us(cas);
      delay_us(cas);
      output_low(SERVO);
 
      set_adc_channel(ZELENA);   // Kroutitko pro vykon motoru
      Delay_ms(1);
      rr=read_adc()>>2; //!!! // 0-31
 
      // Elektronicky diferencial
      if(cas<CASAVR) {r1=cas-CASMIN; r2=CASAVR-CASMIN;}; // Normovani vystupni hodnoty radkoveho snimace
      if(cas==CASAVR) {r1=cas-CASMIN; r2=cas-CASMIN;};   // pro rizeni rychlosti motoru
      if(cas>CASAVR) {r1=CASAVR-CASMIN; r2=CASMAX-cas;}; // Rozsah 1 az 92
 
      if (r1>(CASAVR-CASMIN-rr)) r1=(r1<<1)+rr-(CASAVR-CASMIN);     // Neco jako nasobeni
      if (r2>(CASAVR-CASMIN-rr)) r2=(r2<<1)+rr-(CASAVR-CASMIN);
 
//      r1<<=1;     // Rychlost je dvojnasobna
//      r2<<=1;     // Rozsah 2 az 184
 
      if ((stav==jizda)||(stav==cihla))      // Jizda
      {
         set_pwm1_duty(r1);
         set_pwm2_duty(r2);
         trasa++;
      }
      else
      {
         set_pwm1_duty(0);       // Zastaveni
         set_pwm2_duty(0);
      }
 
      set_adc_channel(DALKOMER);   // Prepni A/D prevodnik na detektor cihly
      Delay_ms(1);
 
      if((stav==jizda)&&(trasa>50)) // musi to alespon 1s jet
      {
         ext_int_edge(H_TO_L);         // Nastav podminky preruseni od cihly
         INT0IF=0;                     // Zruseni predesle udalosti od startera
         enable_interrupts(INT_EXT);
         enable_interrupts(GLOBAL);
      };
 
      if(stav==start)
      if(read_adc()<128)
      {
         disp(0x55);
         while(read_adc()<128); // Cekej, dokud starter neda ruku pryc
         set_pwm1_duty(255);
         set_pwm2_duty(255);
         disp(0xAA);
         delay_ms(200);
         stav=jizda;
      }
 
      pom=0x80;
      for(n=CASMAX/8; n<cas; n+=CASMAX/8)
      {
         pom>>=1;
      }
      disp(pom);
 
 
 
 
 
   };
}

Rev 184	Rev 186
1	`#include ".\camerus.h"`	1	`#include ".\camerus.h"`
2		2
3	`#USE FAST_IO (C) // Brana C je ve FAST_IO modu, aby slo rychle cteni z kamery`	3	`#USE FAST_IO (C) // Brana C je ve FAST_IO modu, aby slo rychle cteni z kamery`
4		4
5	`// A/D vstupy`	5	`// A/D vstupy`
6	`#define DALKOMER 4 // AN4/RA5 - dalkomer na cihlu`	6	`#define DALKOMER 4 // AN4/RA5 - dalkomer na cihlu`
7	`#define CERNA 3 // AN3/RA3`	7	`#define CERNA 3 // AN3/RA3`
8	`#define CERVENA 2 // AN2/RA2 - cervene kroutitko`	8	`#define CERVENA 2 // AN2/RA2 - cervene kroutitko`
9	`#define ZELENA 1 // AN1/RA0 - zelene kroutitko`	9	`#define ZELENA 1 // AN1/RA0 - zelene kroutitko`
10	`#define MODRA 0 // AN0/RA1 - modre kroutitko`	10	`#define MODRA 0 // AN0/RA1 - modre kroutitko`
11		11
12	`// I/O`	12	`// I/O`
13	`#define HREF PIN_C5 // Signal HREF z kamery (v H po celou dobu radku)`	13	`#define HREF PIN_C5 // Signal HREF z kamery (v H po celou dobu radku)`
14	`#define PIX PIN_C6 // Vstup pro body z kamery (za trivstupim hradlem OR (dig. komparator))`	14	`#define PIX PIN_C6 // Vstup pro body z kamery (za trivstupim hradlem OR (dig. komparator))`
15	`#define SERVO PIN_B4 // Vystup na servo (1 az 2ms po cca 20ms (synchronizovano snimkovym kmitoctem))`	15	`#define SERVO PIN_B4 // Vystup na servo (1 az 2ms po cca 20ms (synchronizovano snimkovym kmitoctem))`
16	`#define MOT_L PIN_B5 // Smer otaceni leveho motoru; druhy pol je RC2`	16	`#define MOT_L PIN_B5 // Smer otaceni leveho motoru; druhy pol je RC2`
17	`#define MOT_R PIN_B6 // Smer otaceni praveho motoru; druhy pol je RC1`	17	`#define MOT_R PIN_B6 // Smer otaceni praveho motoru; druhy pol je RC1`
18	`#define DATA PIN_B2 // K modulu LEDbar data`	18	`#define DATA PIN_B2 // K modulu LEDbar data`
19	`#define CP PIN_B1 // K modulu LEDbar hodiny`	19	`#define CP PIN_B1 // K modulu LEDbar hodiny`
20	`#define ODO PIN_A4 // Ze snimace z odometrie z praveho kola`	20	`#define ODO PIN_A4 // Ze snimace z odometrie z praveho kola`
21	`//#define CIHLA PIN_B0 // Vstup INT, generuje preruseni pri prekazce`	21	`//#define CIHLA PIN_B0 // Vstup INT, generuje preruseni pri prekazce`
-		22	`#define IRLED PIN_C0 // Modulovani vysilaci IR LED na detekci prekazky`
22		23
23	`#define CASMIN 6 // Rozsah radku snimace`	24	`#define CASMIN 6 // Rozsah radku snimace`
24	`#define CASMAX 192`	25	`#define CASMAX 192`
25	`#define CASAVR ((CASMAX+CASMIN) / 2)`	26	`#define CASAVR ((CASMAX+CASMIN) / 2)`
26		27
27	`#byte INTCON = 0x0B // Interrupt configuration register`	28	`#byte INTCON = 0x0B // Interrupt configuration register`
28	`#bit GIE = INTCON.7`	29	`#bit GIE = INTCON.7`
29	`#bit PEIE = INTCON.6`	30	`#bit PEIE = INTCON.6`
30	`#bit TMR0IE = INTCON.5`	31	`#bit TMR0IE = INTCON.5`
31	`#bit INT0IE = INTCON.4`	32	`#bit INT0IE = INTCON.4`
32	`#bit RBIE = INTCON.3`	33	`#bit RBIE = INTCON.3`
33	`#bit TMR0IF = INTCON.2`	34	`#bit TMR0IF = INTCON.2`
34	`#bit INT0IF = INTCON.1`	35	`#bit INT0IF = INTCON.1`
35	`#bit RBIF = INTCON.0`	36	`#bit RBIF = INTCON.0`
36		37
37	`enum stavy {start,rozjezd,jizda,cihla,cil};`	38	`enum stavy {start,rozjezd,jizda,cihla,cil};`
38	`stavy stav; // Kde jsme na trati`	39	`stavy stav; // Kde jsme na trati`
39	`int8 cas; // Cas hrany bila/cerna v radce`	40	`int8 cas; // Cas hrany bila/cerna v radce`
40		41
41	`void SetServo(int8 angle)`	42	`void SetServo(int8 angle)`
42	`{`	43	`{`
43	`int8 n, offset;`	44	`int8 n, offset;`
44		45
45	`for(n=0; n<20; n++)`	46	`for(n=0; n<20; n++)`
46	`{`	47	`{`
47	`set_adc_channel(MODRA); // Kroutitko na vystredeni predniho kolecka`	48	`set_adc_channel(MODRA); // Kroutitko na vystredeni predniho kolecka`
48	`Delay_ms(1);`	49	`Delay_ms(1);`
49	`offset=read_adc();`	50	`offset=read_adc();`
50		51
51	`output_high(SERVO); // Odvysilani impuzu 1 az 2ms pro servo`	52	`output_high(SERVO); // Odvysilani impuzu 1 az 2ms pro servo`
52	`delay_us(1000);`	53	`delay_us(1000);`
53	`delay_us(offset);`	54	`delay_us(offset);`
54	`delay_us(offset);`	55	`delay_us(offset);`
55	`delay_us(offset);`	56	`delay_us(offset);`
56	`delay_us(angle);`	57	`delay_us(angle);`
57	`delay_us(angle);`	58	`delay_us(angle);`
58	`output_low(SERVO);`	59	`output_low(SERVO);`
59	`delay_ms(18);`	60	`delay_ms(18);`
60	`}`	61	`}`
61	`}`	62	`}`
62		63
63	`#int_EXT`	64	`#int_EXT`
64	`EXT_isr() // Preruseni od prekazky`	65	`EXT_isr() // Preruseni od prekazky`
65	`{`	66	`{`
66	`set_pwm1_duty(0); // reverz (zabrzdi)`	67	`set_pwm1_duty(0); // reverz (zabrzdi)`
67	`set_pwm2_duty(0);`	68	`set_pwm2_duty(0);`
68	`output_high(MOT_L);`	69	`output_high(MOT_L);`
69	`output_high(MOT_R);`	70	`output_high(MOT_R);`
70	`delay_ms(400);`	71	`delay_ms(400);`
71	`output_low(MOT_L); // zastav`	72	`output_low(MOT_L); // zastav`
72	`output_low(MOT_R);`	73	`output_low(MOT_R);`
73	`if (stav==cihla) while(true); // Zastav na furt`	74	`if (stav==cihla) while(true); // Zastav na furt`
74	`if(stav==jizda)`	75	`if(stav==jizda)`
75	`{`	76	`{`
76	`int n;`	77	`int n;`
77		78
78	`SetServo(CASAVR-CASMIN);`	79	`SetServo(CASAVR-CASMIN);`
79	`set_pwm1_duty(40); // pomalu couvej`	80	`set_pwm1_duty(40); // pomalu couvej`
80	`set_pwm2_duty(40);`	81	`set_pwm2_duty(40);`
81	`output_high(MOT_L);`	82	`output_high(MOT_L);`
82	`output_high(MOT_R);`	83	`output_high(MOT_R);`
83	`n=0;`	84	`n=0;`
84	`while(true)`	85	`while(true)`
85	`{`	86	`{`
86	`while(input(ODO));`	87	`while(input(ODO));`
87	`while(!input(ODO));`	88	`while(!input(ODO));`
88	`n++;`	89	`n++;`
89	`if(n==6) break;`	90	`if(n==6) break;`
90	`}`	91	`}`
91	`set_pwm1_duty(255); // reverz (zabrzdi)`	92	`set_pwm1_duty(255); // reverz (zabrzdi)`
92	`set_pwm2_duty(255);`	93	`set_pwm2_duty(255);`
93	`output_low(MOT_L);`	94	`output_low(MOT_L);`
94	`output_low(MOT_R);`	95	`output_low(MOT_R);`
95	`delay_ms(100);`	96	`delay_ms(100);`
96	`set_pwm1_duty(0); // Zastav`	97	`set_pwm1_duty(0); // Zastav`
97	`set_pwm2_duty(0);`	98	`set_pwm2_duty(0);`
98	`output_low(MOT_L);`	99	`output_low(MOT_L);`
99	`output_low(MOT_R);`	100	`output_low(MOT_R);`
100	`delay_ms(1000);`	101	`delay_ms(1000);`
101		102
102	`SetServo((CASAVR-CASMIN)-20); // doleva`	103	`SetServo((CASAVR-CASMIN)-20); // doleva`
103	`set_pwm1_duty(150); // vpred`	104	`set_pwm1_duty(150); // vpred`
104	`set_pwm2_duty(200);`	105	`set_pwm2_duty(200);`
105	`output_low(MOT_L);`	106	`output_low(MOT_L);`
106	`output_low(MOT_R);`	107	`output_low(MOT_R);`
107	`stav=cihla;`	108	`stav=cihla;`
108	`n=0;`	109	`n=0;`
109	`while(true)`	110	`while(true)`
110	`{`	111	`{`
111	`while(input(ODO));`	112	`while(input(ODO));`
112	`while(!input(ODO));`	113	`while(!input(ODO));`
113	`n++;`	114	`n++;`
114	`if(n==10) break;`	115	`if(n==10) break;`
115	`}`	116	`}`
116	`set_pwm1_duty(0); // reverz (zabrzdi)`	117	`set_pwm1_duty(0); // reverz (zabrzdi)`
117	`set_pwm2_duty(0);`	118	`set_pwm2_duty(0);`
118	`output_high(MOT_L);`	119	`output_high(MOT_L);`
119	`output_high(MOT_R);`	120	`output_high(MOT_R);`
120		121
121	`SetServo((CASAVR-CASMIN)); // rovne`	122	`SetServo((CASAVR-CASMIN)); // rovne`
122	`set_pwm1_duty(140); // vpred`	123	`set_pwm1_duty(140); // vpred`
123	`set_pwm2_duty(140);`	124	`set_pwm2_duty(140);`
124	`output_low(MOT_L);`	125	`output_low(MOT_L);`
125	`output_low(MOT_R);`	126	`output_low(MOT_R);`
126	`stav=cihla;`	127	`stav=cihla;`
127	`n=0;`	128	`n=0;`
128	`while(true)`	129	`while(true)`
129	`{`	130	`{`
130	`while(input(ODO));`	131	`while(input(ODO));`
131	`while(!input(ODO));`	132	`while(!input(ODO));`
132	`n++;`	133	`n++;`
133	`if(n==10) break;`	134	`if(n==10) break;`
134	`}`	135	`}`
135	`set_pwm1_duty(0); // reverz (zabrzdi)`	136	`set_pwm1_duty(0); // reverz (zabrzdi)`
136	`set_pwm2_duty(0);`	137	`set_pwm2_duty(0);`
137	`output_high(MOT_L);`	138	`output_high(MOT_L);`
138	`output_high(MOT_R);`	139	`output_high(MOT_R);`
139	`delay_ms(200);`	140	`delay_ms(200);`
140	`set_pwm1_duty(150); // Zastav`	141	`set_pwm1_duty(150); // Zastav`
141	`set_pwm2_duty(150);`	142	`set_pwm2_duty(150);`
142	`output_high(MOT_L);`	143	`output_high(MOT_L);`
143	`output_high(MOT_R);`	144	`output_high(MOT_R);`
144	`delay_ms(1000);`	145	`delay_ms(1000);`
145		146
146	`SetServo(CASMIN); // max. doleva`	147	`SetServo(CASMIN); // max. doleva`
147	`set_pwm1_duty(0); // vzad`	148	`set_pwm1_duty(0); // vzad`
148	`set_pwm2_duty(20);`	149	`set_pwm2_duty(20);`
149	`output_low(MOT_L);`	150	`output_low(MOT_L);`
150	`output_high(MOT_R);`	151	`output_high(MOT_R);`
151	`stav=cihla;`	152	`stav=cihla;`
152	`n=0;`	153	`n=0;`
153	`while(true)`	154	`while(true)`
154	`{`	155	`{`
155	`while(input(ODO));`	156	`while(input(ODO));`
156	`while(!input(ODO));`	157	`while(!input(ODO));`
157	`n++;`	158	`n++;`
158	`if(n==10) break;`	159	`if(n==10) break;`
159	`}`	160	`}`
160	`set_pwm1_duty(0); // reverz (zabrzdi)`	161	`set_pwm1_duty(0); // reverz (zabrzdi)`
161	`set_pwm2_duty(255);`	162	`set_pwm2_duty(255);`
162	`output_low(MOT_L);`	163	`output_low(MOT_L);`
163	`output_low(MOT_R);`	164	`output_low(MOT_R);`
164	`delay_ms(100);`	165	`delay_ms(100);`
165	`set_pwm1_duty(0); // Zastav`	166	`set_pwm1_duty(0); // Zastav`
166	`set_pwm2_duty(0);`	167	`set_pwm2_duty(0);`
167	`output_low(MOT_L);`	168	`output_low(MOT_L);`
168	`output_low(MOT_R);`	169	`output_low(MOT_R);`
169	`delay_ms(500);`	170	`delay_ms(500);`
170		171
171		172
172	`SetServo((CASAVR-CASMIN)+5); // mirne doprava`	173	`SetServo((CASAVR-CASMIN)+5); // mirne doprava`
173	`set_pwm1_duty(180); // vpred`	174	`set_pwm1_duty(180); // vpred`
174	`set_pwm2_duty(180);`	175	`set_pwm2_duty(180);`
175	`output_low(MOT_L);`	176	`output_low(MOT_L);`
176	`output_low(MOT_R);`	177	`output_low(MOT_R);`
177	`stav=cihla;`	178	`stav=cihla;`
178	`n=0;`	179	`n=0;`
179	`while(true)`	180	`while(true)`
180	`{`	181	`{`
181	`while(input(ODO));`	182	`while(input(ODO));`
182	`while(!input(ODO));`	183	`while(!input(ODO));`
183	`n++;`	184	`n++;`
184	`if(n==10) break;`	185	`if(n==10) break;`
185	`}`	186	`}`
186	`set_pwm1_duty(0); // Zastav`	187	`set_pwm1_duty(0); // Zastav`
187	`set_pwm2_duty(0);`	188	`set_pwm2_duty(0);`
188	`output_low(MOT_L);`	189	`output_low(MOT_L);`
189	`output_low(MOT_R);`	190	`output_low(MOT_R);`
190	`delay_ms(500);`	191	`delay_ms(500);`
191		192
192		193
193	`cas=CASMIN; // Cara je vlevo`	194	`cas=CASMIN; // Cara je vlevo`
194		195
195	`stav=cihla;`	196	`stav=cihla;`
196	`}`	197	`}`
197	`}`	198	`}`
198		199
199	`// Zobrazeni jednoho byte na modulu LEDbar`	200	`// Zobrazeni jednoho byte na modulu LEDbar`
200	`void disp(int8 x)`	201	`void disp(int8 x)`
201	`{`	202	`{`
202	`int n;`	203	`int n;`
203		204
204	`x=~x;`	205	`x=~x;`
205	`for(n=0;n<=7;n++)`	206	`for(n=0;n<=7;n++)`
206	`{`	207	`{`
207	`if (x & 1 == 1) output_high(DATA); else output_low(DATA);`	208	`if (x & 1 == 1) output_high(DATA); else output_low(DATA);`
208	`output_high(CP);`	209	`output_high(CP);`
209	`x>>=1;`	210	`x>>=1;`
210	`output_low(CP);`	211	`output_low(CP);`
211	`}`	212	`}`
212	`}`	213	`}`
213		214
214	`// Blikani LEDbarem ve stilu Night Rider`	215	`// Blikani LEDbarem ve stilu Night Rider`
215	`void NightRider(int8 x)`	216	`void NightRider(int8 x)`
216	`{`	217	`{`
217	`int n,i,j;`	218	`int n,i,j;`
218		219
219	`for(j=0;j<x;j++)`	220	`for(j=0;j<x;j++)`
220	`{`	221	`{`
221	`i=0x01;`	222	`i=0x01;`
222	`for(n=0;n<7;n++)`	223	`for(n=0;n<7;n++)`
223	`{`	224	`{`
224	`disp(i);`	225	`disp(i);`
225	`rotate_left(&i, 1);`	226	`rotate_left(&i, 1);`
226	`delay_ms(40);`	227	`delay_ms(40);`
227	`}`	228	`}`
228	`for(n=0;n<7;n++)`	229	`for(n=0;n<7;n++)`
229	`{`	230	`{`
230	`disp(i);`	231	`disp(i);`
231	`rotate_right(&i, 1);`	232	`rotate_right(&i, 1);`
232	`delay_ms(40);`	233	`delay_ms(40);`
233	`}`	234	`}`
234	`}`	235	`}`
235	`disp(i);`	236	`disp(i);`
236	`delay_ms(40);`	237	`delay_ms(40);`
237	`i=0;`	238	`i=0;`
238	`disp(i);`	239	`disp(i);`
239	`}`	240	`}`
240		241
241		242
242	`void main()`	243	`void main()`
243	`{`	244	`{`
244	`int8 offset; // Promena pro ulozeni ovsetu`	245	`int8 offset; // Promena pro ulozeni ovsetu`
245	`int8 rr; // Promenna na ulozeni Rozumne rychlost`	246	`int8 rr; // Promenna na ulozeni Rozumne rychlost`
246	`int8 r1; // Rychlost motoru 1`	247	`int8 r1; // Rychlost motoru 1`
247	`int8 r2; // Rychlost motoru 2`	248	`int8 r2; // Rychlost motoru 2`
248	`int16 trasa; // Pocitadlo ujete vzdalenosti`	249	`int16 trasa; // Pocitadlo ujete vzdalenosti`
249		250
250	`setup_adc_ports(ALL_ANALOG); // Zapnuti A/D prevodniku pro cteni kroutitek`	251	`setup_adc_ports(ALL_ANALOG); // Zapnuti A/D prevodniku pro cteni kroutitek`
251	`setup_adc(ADC_CLOCK_INTERNAL);`	252	`setup_adc(ADC_CLOCK_INTERNAL);`
252	`setup_timer_0(RTCC_INTERNAL\|RTCC_DIV_1); // Casovac pro mereni casu hrany W/B v radce`	253	`setup_timer_0(RTCC_INTERNAL\|RTCC_DIV_1); // Casovac pro mereni casu hrany W/B v radce`
253	`setup_timer_1(T1_DISABLED);`	254	`setup_timer_1(T1_DISABLED);`
254	`setup_timer_2(T2_DIV_BY_16,255,1); // Casovac PWM motoru`	255	`setup_timer_2(T2_DIV_BY_16,255,1); // Casovac PWM motoru`
255	`setup_ccp1(CCP_PWM); // RC1 // PWM pro motory`	256	`setup_ccp1(CCP_PWM); // RC1 // PWM pro motory`
256	`setup_ccp2(CCP_PWM); // RC2`	257	`setup_ccp2(CCP_PWM); // RC2`
257	`setup_comparator(NC_NC_NC_NC);`	258	`setup_comparator(NC_NC_NC_NC);`
258	`setup_vref(FALSE);`	259	`setup_vref(FALSE);`
259		260
260	`set_tris_c(0b11111000); // Nastaveni vstup/vystup pro branu C, protoze se nedela automaticky`	261	`set_tris_c(0b11111000); // Nastaveni vstup/vystup pro branu C, protoze se nedela automaticky`
261		262
262	`set_pwm1_duty(0); // Zastav motory`	263	`set_pwm1_duty(0); // Zastav motory`
263	`set_pwm2_duty(0);`	264	`set_pwm2_duty(0);`
264	`output_low(MOT_L);`	265	`output_low(MOT_L);`
265	`output_low(MOT_R);`	266	`output_low(MOT_R);`
266		267
-		268	`output_low(IRLED); // Zapni LED na detekci prekazky`
-		269
267	`NightRider(1); // Aby se poznalo, ze byl RESET`	270	`NightRider(1); // Aby se poznalo, ze byl RESET`
268	`// Musi se pockat, nez se rozjede kamera, nez se do ni zacnou posilat prikazy`	271	`// Musi se pockat, nez se rozjede kamera, nez se do ni zacnou posilat prikazy`
269		272
270	`//... Nastaveni kamery ...`	273	`//... Nastaveni kamery ...`
271	`i2c_start(); // Soft RESET kamery`	274	`i2c_start(); // Soft RESET kamery`
272	`i2c_write(0xC0); // Pro single slave musi mit vsechny zapisy adresu C0h`	275	`i2c_write(0xC0); // Pro single slave musi mit vsechny zapisy adresu C0h`
273	`i2c_write(0x12); // Adresa registru COMH`	276	`i2c_write(0x12); // Adresa registru COMH`
274	`i2c_write(0x80 \| 0x24); // Zapis ridiciho slova`	277	`i2c_write(0x80 \| 0x24); // Zapis ridiciho slova`
275	`i2c_stop();`	278	`i2c_stop();`
276		279
277	`i2c_start(); // BW`	280	`i2c_start(); // BW`
278	`i2c_write(0xC0);`	281	`i2c_write(0xC0);`
279	`i2c_write(0x28);`	282	`i2c_write(0x28);`
280	`i2c_write(0b01000001);`	283	`i2c_write(0b01000001);`
281	`i2c_stop();`	284	`i2c_stop();`
282		285
283	`/*`	286	`/*`
284	`i2c_start(); // Contrast`	287	`i2c_start(); // Contrast`
285	`i2c_write(0xC0);`	288	`i2c_write(0xC0);`
286	`i2c_write(0x05);`	289	`i2c_write(0x05);`
287	`i2c_write(0xA0); // 48h`	290	`i2c_write(0xA0); // 48h`
288	`i2c_stop();`	291	`i2c_stop();`
289		292
290	`i2c_start(); // Brightness`	293	`i2c_start(); // Brightness`
291	`i2c_write(0xC0);`	294	`i2c_write(0xC0);`
292	`i2c_write(0x06);`	295	`i2c_write(0x06);`
293	`i2c_write(0x0); // 80h //9Ah`	296	`i2c_write(0x0); // 80h //9Ah`
294	`i2c_stop();`	297	`i2c_stop();`
295		298
296	`i2c_start(); // Band Filter`	299	`i2c_start(); // Band Filter`
297	`i2c_write(0xC0);`	300	`i2c_write(0xC0);`
298	`i2c_write(0x2D);`	301	`i2c_write(0x2D);`
299	`i2c_write(0x04 \| 0x03);`	302	`i2c_write(0x04 \| 0x03);`
300	`i2c_stop();`	303	`i2c_stop();`
301	`*/`	304	`*/`
302		305
303	`i2c_start(); // Fame Rate`	306	`i2c_start(); // Fame Rate`
304	`i2c_write(0xC0);`	307	`i2c_write(0xC0);`
305	`i2c_write(0x2B);`	308	`i2c_write(0x2B);`
306	`i2c_write(0x00); // cca 17ms (puvodni hodnota 5Eh = 20ms)`	309	`i2c_write(0x00); // cca 17ms (puvodni hodnota 5Eh = 20ms)`
307	`i2c_stop();`	310	`i2c_stop();`
308		311
309	`i2c_start(); // VSTRT`	312	`i2c_start(); // VSTRT`
310	`i2c_write(0xC0);`	313	`i2c_write(0xC0);`
311	`i2c_write(0x19);`	314	`i2c_write(0x19);`
312	`i2c_write(118); // prostredni radka`	315	`i2c_write(118); // prostredni radka`
313	`i2c_stop();`	316	`i2c_stop();`
314		317
315	`i2c_start(); // VEND`	318	`i2c_start(); // VEND`
316	`i2c_write(0xC0);`	319	`i2c_write(0xC0);`
317	`i2c_write(0x1A);`	320	`i2c_write(0x1A);`
318	`i2c_write(118);`	321	`i2c_write(118);`
319	`i2c_stop();`	322	`i2c_stop();`
320		323
321	`NightRider(1); // Musi se dat cas kamere na AGC a AEC`	324	`NightRider(1); // Musi se dat cas kamere na AGC a AEC`
322		325
323	`{ // Kalibrace kamery`	326	`{ // Kalibrace kamery`
324	`int8 t1,t2;`	327	`int8 t1,t2;`
325		328
326	`for(offset=0;offset<=255;offset+=0x04) // Cita porad dokola`	329	`for(offset=0;offset<=255;offset+=0x04) // Cita porad dokola`
327	`{`	330	`{`
328	`i2c_start(); // Brightness`	331	`i2c_start(); // Brightness`
329	`i2c_write(0xC0);`	332	`i2c_write(0xC0);`
330	`i2c_write(0x06);`	333	`i2c_write(0x06);`
331	`i2c_write(offset); // 80h default`	334	`i2c_write(offset); // 80h default`
332	`i2c_stop();`	335	`i2c_stop();`
333	`disp(offset);`	336	`disp(offset);`
334	`delay_ms(50);`	337	`delay_ms(50);`
335		338
336	`t1=0;`	339	`t1=0;`
337	`t2=0;`	340	`t2=0;`
338	`while(!input(HREF)); // Cekej nez se zacnou posilat pixely z radky`	341	`while(!input(HREF)); // Cekej nez se zacnou posilat pixely z radky`
339	`delay_ms(5);`	342	`delay_ms(5);`
340	`while(!input(HREF)); // Cekej nez se zacnou posilat pixely z radky`	343	`while(!input(HREF)); // Cekej nez se zacnou posilat pixely z radky`
341	`set_timer0(0); // Vynuluj pocitadlo casu`	344	`set_timer0(0); // Vynuluj pocitadlo casu`
342	`if(!input(PIX)) continue;`	345	`if(!input(PIX)) continue;`
343	`while(input(PIX));`	346	`while(input(PIX));`
344	`t1=get_timer0(); // Precti cas z citace casu hrany`	347	`t1=get_timer0(); // Precti cas z citace casu hrany`
345	`set_timer0(0); // Vynuluj pocitadlo casu`	348	`set_timer0(0); // Vynuluj pocitadlo casu`
346	`while(!input(PIX));`	349	`while(!input(PIX));`
347	`t2=get_timer0();`	350	`t2=get_timer0();`
348		351
349	`if((t1>60) && (t1<140) && (t2>5) && (t2<=10)) break;`	352	`if((t1>60) && (t1<140) && (t2>5) && (t2<=10)) break;`
350		353
351	`delay_ms(2);`	354	`delay_ms(2);`
352	`}`	355	`}`
353	`}`	356	`}`
354		357
355	`delay_ms(1000);`	358	`delay_ms(1000);`
356		359
357	`cas=CASAVR-CASMIN; // Inicializace promenych, aby neslo servo za roh a aby se to rozjelo jeste dneska`	360	`cas=CASAVR-CASMIN; // Inicializace promenych, aby neslo servo za roh a aby se to rozjelo jeste dneska`
358	`stav=start;`	361	`stav=start;`
359	`trasa=0;`	362	`trasa=0;`
360		363
361	`// ... Hlavni smycka ...`	364	`// ... Hlavni smycka ...`
362	`while(true)`	365	`while(true)`
363	`{`	366	`{`
364	`int8 pom;`	367	`int8 pom;`
365	`int8 n;`	368	`int8 n;`
366		369
367	`pom=0;`	370	`pom=0;`
368	`while(!input(HREF)); // Cekej nez se zacnou posilat pixely z radky`	371	`while(!input(HREF)); // Cekej nez se zacnou posilat pixely z radky`
369	`set_timer0(0); // Vynuluj pocitadlo casu`	372	`set_timer0(0); // Vynuluj pocitadlo casu`
370	`while(input(HREF)) // Po dobu vysilani radky cekej na hranu W/B`	373	`while(input(HREF)) // Po dobu vysilani radky cekej na hranu W/B`
371	`{`	374	`{`
372	`// !!!!Dodelat rozpoznani cerne cary napric pro zastaveni`	375	`// !!!!Dodelat rozpoznani cerne cary napric pro zastaveni`
373	`if(!input(PIX)) // Pokud se Xx za sebou precetla CERNA`	376	`if(!input(PIX)) // Pokud se Xx za sebou precetla CERNA`
374	`if(!input(PIX))`	377	`if(!input(PIX))`
375	`// if(!input(PIX))`	378	`// if(!input(PIX))`
376	`{`	379	`{`
377	`pom=get_timer0(); // Precti cas z citace casu hrany`	380	`pom=get_timer0(); // Precti cas z citace casu hrany`
378	`break;`	381	`break;`
379	`};`	382	`};`
380	`};`	383	`};`
381	`while(input(HREF)); // Pockej na shozeni signalu HREF`	384	`while(input(HREF)); // Pockej na shozeni signalu HREF`
382		385
383	`if((pom<CASMAX) && (pom>CASMIN)) cas=pom; // Orizni konce radku`	386	`if((pom<CASMAX) && (pom>CASMIN)) cas=pom; // Orizni konce radku`
384	`// Na konci obrazovaho radku to blbne. Jednak chyba od apertury`	387	`// Na konci obrazovaho radku to blbne. Jednak chyba od apertury`
385	`// a vubec to nejak na kraji nefunguje.`	388	`// a vubec to nejak na kraji nefunguje.`
386		389
387	`set_adc_channel(MODRA); // Kroutitko na vystredeni predniho kolecka`	390	`set_adc_channel(MODRA); // Kroutitko na vystredeni predniho kolecka`
388	`Delay_ms(1);`	391	`Delay_ms(1);`
389	`offset=read_adc();`	392	`offset=read_adc();`
390		393
391	`output_high(SERVO); // Odvysilani impuzu 1 az 2ms pro servo`	394	`output_high(SERVO); // Odvysilani impuzu 1 az 2ms pro servo`
392	`delay_us(1000);`	395	`delay_us(1000);`
393	`delay_us(offset);`	396	`delay_us(offset);`
394	`delay_us(offset);`	397	`delay_us(offset);`
395	`delay_us(offset);`	398	`delay_us(offset);`
396	`delay_us(cas);`	399	`delay_us(cas);`
397	`delay_us(cas);`	400	`delay_us(cas);`
398	`output_low(SERVO);`	401	`output_low(SERVO);`
399		402
400	`set_adc_channel(ZELENA); // Kroutitko pro vykon motoru`	403	`set_adc_channel(ZELENA); // Kroutitko pro vykon motoru`
401	`Delay_ms(1);`	404	`Delay_ms(1);`
402	`rr=read_adc()>>2; //!!! // 0-31`	405	`rr=read_adc()>>2; //!!! // 0-31`
403		406
404	`// Elektronicky diferencial`	407	`// Elektronicky diferencial`
405	`if(cas<CASAVR) {r1=cas-CASMIN; r2=CASAVR-CASMIN;}; // Normovani vystupni hodnoty radkoveho snimace`	408	`if(cas<CASAVR) {r1=cas-CASMIN; r2=CASAVR-CASMIN;}; // Normovani vystupni hodnoty radkoveho snimace`
406	`if(cas==CASAVR) {r1=cas-CASMIN; r2=cas-CASMIN;}; // pro rizeni rychlosti motoru`	409	`if(cas==CASAVR) {r1=cas-CASMIN; r2=cas-CASMIN;}; // pro rizeni rychlosti motoru`
407	`if(cas>CASAVR) {r1=CASAVR-CASMIN; r2=CASMAX-cas;}; // Rozsah 1 az 92`	410	`if(cas>CASAVR) {r1=CASAVR-CASMIN; r2=CASMAX-cas;}; // Rozsah 1 az 92`
408		411
409	`if (r1>(CASAVR-CASMIN-rr)) r1=(r1<<1)+rr-(CASAVR-CASMIN); // Neco jako nasobeni`	412	`if (r1>(CASAVR-CASMIN-rr)) r1=(r1<<1)+rr-(CASAVR-CASMIN); // Neco jako nasobeni`
410	`if (r2>(CASAVR-CASMIN-rr)) r2=(r2<<1)+rr-(CASAVR-CASMIN);`	413	`if (r2>(CASAVR-CASMIN-rr)) r2=(r2<<1)+rr-(CASAVR-CASMIN);`
411		414
412	`// r1<<=1; // Rychlost je dvojnasobna`	415	`// r1<<=1; // Rychlost je dvojnasobna`
413	`// r2<<=1; // Rozsah 2 az 184`	416	`// r2<<=1; // Rozsah 2 az 184`
414		417
415	`if ((stav==jizda)\|\|(stav==cihla)) // Jizda`	418	`if ((stav==jizda)\|\|(stav==cihla)) // Jizda`
416	`{`	419	`{`
417	`set_pwm1_duty(r1);`	420	`set_pwm1_duty(r1);`
418	`set_pwm2_duty(r2);`	421	`set_pwm2_duty(r2);`
419	`trasa++;`	422	`trasa++;`
420	`}`	423	`}`
421	`else`	424	`else`
422	`{`	425	`{`
423	`set_pwm1_duty(0); // Zastaveni`	426	`set_pwm1_duty(0); // Zastaveni`
424	`set_pwm2_duty(0);`	427	`set_pwm2_duty(0);`
425	`}`	428	`}`
426		429
427	`set_adc_channel(DALKOMER); // Prepni A/D prevodnik na detektor cihly`	430	`set_adc_channel(DALKOMER); // Prepni A/D prevodnik na detektor cihly`
428	`Delay_ms(1);`	431	`Delay_ms(1);`
429		432
430	`if((stav==jizda)&&(trasa>50)) // musi to alespon 1s jet`	433	`if((stav==jizda)&&(trasa>50)) // musi to alespon 1s jet`
431	`{`	434	`{`
432	`ext_int_edge(H_TO_L); // Nastav podminky preruseni od cihly`	435	`ext_int_edge(H_TO_L); // Nastav podminky preruseni od cihly`
433	`INT0IF=0; // Zruseni predesle udalosti od startera`	436	`INT0IF=0; // Zruseni predesle udalosti od startera`
434	`enable_interrupts(INT_EXT);`	437	`enable_interrupts(INT_EXT);`
435	`enable_interrupts(GLOBAL);`	438	`enable_interrupts(GLOBAL);`
436	`};`	439	`};`
437		440
438	`if(stav==start)`	441	`if(stav==start)`
439	`if(read_adc()<128)`	442	`if(read_adc()<128)`
440	`{`	443	`{`
441	`disp(0x55);`	444	`disp(0x55);`
442	`while(read_adc()<128); // Cekej, dokud starter neda ruku pryc`	445	`while(read_adc()<128); // Cekej, dokud starter neda ruku pryc`
443	`set_pwm1_duty(255);`	446	`set_pwm1_duty(255);`
444	`set_pwm2_duty(255);`	447	`set_pwm2_duty(255);`
445	`disp(0xAA);`	448	`disp(0xAA);`
446	`delay_ms(200);`	449	`delay_ms(200);`
447	`stav=jizda;`	450	`stav=jizda;`
448	`}`	451	`}`
449		452
450	`pom=0x80;`	453	`pom=0x80;`
451	`for(n=CASMAX/8; n<cas; n+=CASMAX/8)`	454	`for(n=CASMAX/8; n<cas; n+=CASMAX/8)`
452	`{`	455	`{`
453	`pom>>=1;`	456	`pom>>=1;`
454	`}`	457	`}`
455	`disp(pom);`	458	`disp(pom);`
456		459
457	`output_high(PIN_C0);`	-
458	`delay_ms(1);`	-
459	`output_low(PIN_C0);`	-
460		-
461	`};`	460	`};`
462	`}`	461	`}`

Subversion Repositories svnkaklik

(root)/roboti/istrobot/camerus/SW/876/camerus.c – Rev 184 → 186