| 6 | 
           kaklik | 
           1 | 
           #include "main.h"
  | 
        
        
            | 
            | 
           2 | 
           #include "..\common.h"
  | 
        
        
            | 
            | 
           3 | 
              | 
        
        
            | 
            | 
           4 | 
           #DEFINE LCD_RS          PIN_B1      // rizeni registru LCD displeje
  | 
        
        
            | 
            | 
           5 | 
           #DEFINE LCD_E           PIN_B0      // enable LCD displeje
  | 
        
        
            | 
            | 
           6 | 
           #DEFINE LCD_DATA_LSB    PIN_B2      // pripojeni LSB bitu datoveho portu LCD displeje (celkem 4 bity vzestupne za sebou)
  | 
        
        
            | 
            | 
           7 | 
           #INCLUDE "MYLCD.C"
  | 
        
        
            | 
            | 
           8 | 
           #DEFINE PRIJIMAC        PIN_A3      // pin na ktery je pripojen prijimac
  | 
        
        
            | 
            | 
           9 | 
           #DEFINE  SERVO_X         PIN_A0        // pin na ktery je pripojeno servo
  | 
        
        
            | 
            | 
           10 | 
           #DEFINE  SERVO_Y         PIN_A1
  | 
        
        
            | 
            | 
           11 | 
              | 
        
        
            | 
            | 
           12 | 
           int8     bit,x,y;
  | 
        
        
            | 
            | 
           13 | 
           int      counter;                      // pocitadlo 1 a 0 v detektoru
  | 
        
        
            | 
            | 
           14 | 
           int      x_old=0,y_old;
  | 
        
        
            | 
            | 
           15 | 
              | 
        
        
            | 
            | 
           16 | 
           void servo(int uhel, int souradnice)
  | 
        
        
            | 
            | 
           17 | 
           {
  | 
        
        
            | 
            | 
           18 | 
              | 
        
        
            | 
            | 
           19 | 
              | 
        
        
            | 
            | 
           20 | 
                 if (X==souradnice) output_high(SERVO_X); else output_high(SERVO_Y);
  | 
        
        
            | 
            | 
           21 | 
              | 
        
        
            | 
            | 
           22 | 
                 delay_us(62.5*uhel);
  | 
        
        
            | 
            | 
           23 | 
              | 
        
        
            | 
            | 
           24 | 
                 if (SERVO_X==souradnice) output_low(SERVO_X); else output_low(SERVO_Y);
  | 
        
        
            | 
            | 
           25 | 
               //  delay_ms(10);
  | 
        
        
            | 
            | 
           26 | 
              | 
        
        
            | 
            | 
           27 | 
              | 
        
        
            | 
            | 
           28 | 
           }
  | 
        
        
            | 
            | 
           29 | 
              | 
        
        
            | 
            | 
           30 | 
           int8 prijmout(int8* bit)
  | 
        
        
            | 
            | 
           31 | 
           {
  | 
        
        
            | 
            | 
           32 | 
           // ||    |
  | 
        
        
            | 
            | 
           33 | 
           // |--|_____   1
  | 
        
        
            | 
            | 
           34 | 
           //       |
  | 
        
        
            | 
            | 
           35 | 
           // |-|__|-|_   0
  | 
        
        
            | 
            | 
           36 | 
              | 
        
        
            | 
            | 
           37 | 
              while (!input(PRIJIMAC)) ;                // cekej na jednicku
  | 
        
        
            | 
            | 
           38 | 
              delay_us(IMPULS/4);                       // presvec se, jestli je stale 1 po 1/4 impulsu
  | 
        
        
            | 
            | 
           39 | 
              if (!input(PRIJIMAC)) return(false);          // vrat chybu, kdyz neni stale 1
  | 
        
        
            | 
            | 
           40 | 
              delay_us(3*IMPULS);                       // pockej na rozhodovaci misto
  | 
        
        
            | 
            | 
           41 | 
              if (input(PRIJIMAC)) *bit=0; else *bit=1; // dekoduj 1 nebo 0
  | 
        
        
            | 
            | 
           42 | 
              delay_us(IMPULS);                         // pockej na konec znaku
  | 
        
        
            | 
            | 
           43 | 
              | 
        
        
            | 
            | 
           44 | 
              output_bit(PIN_A0, *bit);  // kontrolni vystup
  | 
        
        
            | 
            | 
           45 | 
              | 
        
        
            | 
            | 
           46 | 
              return(true);                                // vrat, ze se cteni povedlo
  | 
        
        
            | 
            | 
           47 | 
           }
  | 
        
        
            | 
            | 
           48 | 
              | 
        
        
            | 
            | 
           49 | 
           int8 read_nibble(int8* value)
  | 
        
        
            | 
            | 
           50 | 
           {
  | 
        
        
            | 
            | 
           51 | 
              int8 n;     // citac
  | 
        
        
            | 
            | 
           52 | 
              int8 bit;   // pomocna promenna
  | 
        
        
            | 
            | 
           53 | 
              | 
        
        
            | 
            | 
           54 | 
              *value=0;
  | 
        
        
            | 
            | 
           55 | 
              for (n=1; n<=4; n++)                      // prijmi 4 bity
  | 
        
        
            | 
            | 
           56 | 
              {
  | 
        
        
            | 
            | 
           57 | 
                 *value >>= 1;                          // posun jiz prectene do leva
  | 
        
        
            | 
            | 
           58 | 
                 if (0==prijmout(&bit)) return(false);      // prijmi bit; pri chybe cteni vrat chybu
  | 
        
        
            | 
            | 
           59 | 
                 *value |= bit << 3;                    // pridej bit do nibblu
  | 
        
        
            | 
            | 
           60 | 
              };
  | 
        
        
            | 
            | 
           61 | 
              return(true);                                // vrat 1, jako ,ze je vse O.K.
  | 
        
        
            | 
            | 
           62 | 
           }
  | 
        
        
            | 
            | 
           63 | 
              | 
        
        
            | 
            | 
           64 | 
           /*void dekodovat(void)
  | 
        
        
            | 
            | 
           65 | 
           {
  | 
        
        
            | 
            | 
           66 | 
              int8 osa, hodnota, kontrola;
  | 
        
        
            | 
            | 
           67 | 
              | 
        
        
            | 
            | 
           68 | 
              counter=4;
  | 
        
        
            | 
            | 
           69 | 
              | 
        
        
            | 
            | 
           70 | 
           decoder:
  | 
        
        
            | 
            | 
           71 | 
              | 
        
        
            | 
            | 
           72 | 
                 counter=0;                                   // vynuluj citac
  | 
        
        
            | 
            | 
           73 | 
                 do                                           // vyhledej synchronizacni jednicky
  | 
        
        
            | 
            | 
           74 | 
                 {
  | 
        
        
            | 
            | 
           75 | 
                    if (!prijmout(&bit)) goto decoder;      // prijmi bit; pri chybe zacni znovu
  | 
        
        
            | 
            | 
           76 | 
                    if (1==bit) counter++; else goto decoder;  // kdyz je bit 1, tak zvys citac; jinak zacni znovu
  | 
        
        
            | 
            | 
           77 | 
                 } while(counter<4);                          // pockej na 4 jednicky
  | 
        
        
            | 
            | 
           78 | 
              | 
        
        
            | 
            | 
           79 | 
                 if (!read_nibble(&osa)) goto decoder;   // nacti identifikator osy
  | 
        
        
            | 
            | 
           80 | 
              | 
        
        
            | 
            | 
           81 | 
                 if (!read_nibble(&hodnota)) goto decoder;   // nacti 1. nibble; pri chybe zacni znovu
  | 
        
        
            | 
            | 
           82 | 
                 if (!read_nibble(&kontrola)) goto decoder;  // nacti 2. nibble; pri chybe zacni znovu
  | 
        
        
            | 
            | 
           83 | 
                 if (hodnota != kontrola) goto decoder;               // zacni znovu, pokud jsou ruzne nibble
  | 
        
        
            | 
            | 
           84 | 
              | 
        
        
            | 
            | 
           85 | 
                 switch (osa)            // rozeskoc se podle adresy osy
  | 
        
        
            | 
            | 
           86 | 
                 {
  | 
        
        
            | 
            | 
           87 | 
                 case OSA_X:
  | 
        
        
            | 
            | 
           88 | 
                    {
  | 
        
        
            | 
            | 
           89 | 
                       x=hodnota;
  | 
        
        
            | 
            | 
           90 | 
                       break;
  | 
        
        
            | 
            | 
           91 | 
                    };
  | 
        
        
            | 
            | 
           92 | 
                 case OSA_Y:
  | 
        
        
            | 
            | 
           93 | 
                    {
  | 
        
        
            | 
            | 
           94 | 
                       y=hodnota;
  | 
        
        
            | 
            | 
           95 | 
                       break;
  | 
        
        
            | 
            | 
           96 | 
                    };
  | 
        
        
            | 
            | 
           97 | 
                 case TLs:
  | 
        
        
            | 
            | 
           98 | 
                    {
  | 
        
        
            | 
            | 
           99 | 
                       break;
  | 
        
        
            | 
            | 
           100 | 
                    };
  | 
        
        
            | 
            | 
           101 | 
                 };
  | 
        
        
            | 
            | 
           102 | 
           }
  | 
        
        
            | 
            | 
           103 | 
           */
  | 
        
        
            | 
            | 
           104 | 
           void main()
  | 
        
        
            | 
            | 
           105 | 
           {
  | 
        
        
            | 
            | 
           106 | 
              lcd_init();                  // zinicializuj LCD display
  | 
        
        
            | 
            | 
           107 | 
              | 
        
        
            | 
            | 
           108 | 
              while (true)
  | 
        
        
            | 
            | 
           109 | 
              {
  | 
        
        
            | 
            | 
           110 | 
              int8 osa, hodnota, kontrola;
  | 
        
        
            | 
            | 
           111 | 
              | 
        
        
            | 
            | 
           112 | 
              counter=4;
  | 
        
        
            | 
            | 
           113 | 
              | 
        
        
            | 
            | 
           114 | 
           decoder:
  | 
        
        
            | 
            | 
           115 | 
              | 
        
        
            | 
            | 
           116 | 
                 servo(x_old,SERVO_X);
  | 
        
        
            | 
            | 
           117 | 
              | 
        
        
            | 
            | 
           118 | 
                 servo(y_old,SERVO_Y);
  | 
        
        
            | 
            | 
           119 | 
              | 
        
        
            | 
            | 
           120 | 
                 counter=0;                                   // vynuluj citac
  | 
        
        
            | 
            | 
           121 | 
                 do                                           // vyhledej synchronizacni jednicky
  | 
        
        
            | 
            | 
           122 | 
                 {
  | 
        
        
            | 
            | 
           123 | 
                    if (!prijmout(&bit)) goto decoder;      // prijmi bit; pri chybe zacni znovu
  | 
        
        
            | 
            | 
           124 | 
                    if (1==bit) counter++; else goto decoder;  // kdyz je bit 1, tak zvys citac; jinak zacni znovu
  | 
        
        
            | 
            | 
           125 | 
                 } while(counter<4);                          // pockej na 4 jednicky
  | 
        
        
            | 
            | 
           126 | 
              | 
        
        
            | 
            | 
           127 | 
                 if (!read_nibble(&osa)) goto decoder;   // nacti identifikator osy
  | 
        
        
            | 
            | 
           128 | 
              | 
        
        
            | 
            | 
           129 | 
                 if (!read_nibble(&hodnota)) goto decoder;   // nacti 1. nibble; pri chybe zacni znovu
  | 
        
        
            | 
            | 
           130 | 
                 if (!read_nibble(&kontrola)) goto decoder;  // nacti 2. nibble; pri chybe zacni znovu
  | 
        
        
            | 
            | 
           131 | 
                 if (hodnota != kontrola) goto decoder;               // zacni znovu, pokud jsou ruzne nibble
  | 
        
        
            | 
            | 
           132 | 
              | 
        
        
            | 
            | 
           133 | 
                 switch (osa)            // rozeskoc se podle adresy osy
  | 
        
        
            | 
            | 
           134 | 
                 {
  | 
        
        
            | 
            | 
           135 | 
                 case OSA_X:
  | 
        
        
            | 
            | 
           136 | 
                    {
  | 
        
        
            | 
            | 
           137 | 
              | 
        
        
            | 
            | 
           138 | 
                       x=hodnota;
  | 
        
        
            | 
            | 
           139 | 
                       x_old=x;
  | 
        
        
            | 
            | 
           140 | 
              | 
        
        
            | 
            | 
           141 | 
                       break;
  | 
        
        
            | 
            | 
           142 | 
                    };
  | 
        
        
            | 
            | 
           143 | 
                 case OSA_Y:
  | 
        
        
            | 
            | 
           144 | 
                    {
  | 
        
        
            | 
            | 
           145 | 
                       y=hodnota;
  | 
        
        
            | 
            | 
           146 | 
                       y_old=y
  | 
        
        
            | 
            | 
           147 | 
                       break;
  | 
        
        
            | 
            | 
           148 | 
                    };
  | 
        
        
            | 
            | 
           149 | 
                 case TLs:
  | 
        
        
            | 
            | 
           150 | 
                    {
  | 
        
        
            | 
            | 
           151 | 
                       break;
  | 
        
        
            | 
            | 
           152 | 
                    };
  | 
        
        
            | 
            | 
           153 | 
                 };
  | 
        
        
            | 
            | 
           154 | 
              | 
        
        
            | 
            | 
           155 | 
              | 
        
        
            | 
            | 
           156 | 
                 lcd_gotoxy(1,1);                       // vytiskni X a Y
  | 
        
        
            | 
            | 
           157 | 
                 printf(lcd_putc,"X: %U      ", x);
  | 
        
        
            | 
            | 
           158 | 
                 lcd_gotoxy(1,2);
  | 
        
        
            | 
            | 
           159 | 
                 printf(lcd_putc,"Y: %U      ", y);
  | 
        
        
            | 
            | 
           160 | 
               }
  | 
        
        
            | 
            | 
           161 | 
           }
  | 
        
        
            | 
            | 
           162 | 
              | 
        
        
            | 
            | 
           163 | 
              |