///////////xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx//////////
//                                              PŘÍJÍMAČ                                                     //
//////////xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx//////////       

//vstupy/výstupy
#define IN xxxx                     // místo xxxx přiřadit nějaký vstupní pin  // signál z vf modulu 
#define VYSTUP xxxx        // místo xxxx přiřadit nějaký výstupní pin  // spínaný výstup
#define KOD_ZAP 0xXX            //   hex  kód pro zapnutí
#define KOD_VZP 0xXX            //   hex  kód pro vypnutí
 
//proměnné  
unsigned char prijaty_byte;      

//funkce
void cti_byte(); 
unsigned char gray2bin(unsigned char n);//dekodér grayova kódu
void main(void)
{
int pocet; 
       
VYSTUP=0;

while (1)
     {
      if(IN==0)                      //detekuje sestupnou hranu
            { 
            pocet=0;
            while(IN==0)                //počítá jak dlouho je vstup v úrovni L
                   {
                   delay_us(8);          // 8 us + čas na vykonání = 10 us
                   pocet++;
                   };
            if(pocet>250)             //je li čas delší než 2,5 ms bere ho jako start bit který by měl být 3 ms
                   {
                   prijaty_byte=cti_byte();        //volá funkci pro vyhodnocení přijatých bytu ,přeloží z grayova kódu                   
                   if(prijaty_byte==KOD_ZAP)VYSTUP=1;     // když byte odpovidá definovanému kódu sepne výstup
                   else if(prijaty_byte==KOD_VYP)VYSTUP=0;  //nebo  ho vypne                                                             
                   }
            delay_ms(3);          //  * viz poznámka dole                         
            }   
      }
} 

 
//********************* funkce pro čtení bytu***********************//
unsigned char cti_byte()
{
unsigned char  a=0;  // 
unsigned char  i,,j; //proměnné pro cykly for
unsigned char bajt;
int pocet; //počítadlo násobku 10 us
 
 for(j=0;j<3;j++)                     //3x přečte přijatý byte 
         {  
         for(i=0;i<8;i++)          /// 8x změří délku pulsu v úrovni H
                  {                                  
                  bajt>>=1;              //rotuje proměnnou o 1 bit do prava
                  while(IN==0);           //čeká na úroveň  H
                  pocet=0;         
                  while(IN){pocet++; delay_us(8);}     //počítá  jak dlouho je vstup v úrovni H
                  if(pocet>150)bajt|=0x80;    // je li čas delší nez 1,5  ms  zapíše do nejvyššího bitu                                                                            
                  }                                                                         //proměnné bajt jedničku
         a=gray2bin(bajt);                                             //převede z grayova kódu
         if(a==KOD_ZAP||a==KOD_VYP)break;  //zjistí li, že přijatý byte odpovídá definovanému kódu pro vypnutí
                                                                                 //nebo zapnutí -  funkce další přijaté už nekontroluje a vrátí hodnotu přijatého bytu
         else a=0;                  //  jinak vrátí 0                                                       
         while(IN);                 //   není li ještě vstup v úrovni L  - čeká na sestupnou hranu
         delay_us(2700);     //čeká 2,7 ms
         while(IN==0);              // čeká zbytek do 3ms - prodleva  v úrovni L mezi jednotlivými byty
         }  
 
 return a;             
}



//********************* dekódování grayova kódu***********************//
 
 unsigned char gray2bin(unsigned char n)
{
register unsigned char t,s;
s=1;
while (t=(n>>s))
      {
      n^=t;
      s<<=1;
      };
return n;
 }




///////////xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx//////////
//                                              VYSÍLAČ                                                           //
//////////xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx//////////      




 #define ENABLE_TX   xxxx        // místo xxxx přiřadit nějaký výstupní pin  // aktivace vysílače
 #define OUT  xxxx                        //místo xxxx přiřadit nějaký výstupní pin   // posílaná data
 #define tlZAP  xxxx                        //místo xxxx přiřadit nějaký vstupní pin    //tlačítko zap.
 #define tlVYP  xxxx                        //místo xxxx přiřadit nějaký vstupní pin    //tlačítko vyp.
 #define ZAPNI 0xXX                  //nějaký hex kód
 #define VYPNI 0xXX                  //nějaký hex kód 
 
 //deklarace funkcí:
 void send(unsigned char kod);              
 void send_byte(unsigned char bajt) ;
 //hlavní funkce pro obsluhu dvou tlačítek by mohla vypadat nějak takto:
 void main()
 {
 if(tlZAP==0)             //při předpokladu,že tlačítko spíná proti GND
    {
    send(ZAPNI);
    while(tlZAP==0);       //čeká na uvolnění tlačítka
    }      
  
 if(tlZAP==0)
    {
    send(VYPNI);
    while(tlVYP==0);       //čeká na uvolnění tlačítka
    }        
    
 }          
 
 
  
 //pošle 3x za sebou stejný byte s prodlevou 3 ms mezi jednotlivymi byty
//vyslání celého trojbytu zabere max 100 ms (při posílání 0xFF)
void send(unsigned char kod)
{   
unsigned char i;  
unsigned char g_kod;    //neplést s g-bodem :-)

ENABLE_TX=1;              //aktivace vysílače
delay_ms(1);
 OUT=0;                                // výstup do L         
 delay_us(3100);              // start bit
 for(i=0;i<3;i++)
      {                  
       send_byte(g_kod);        
       OUT=0; 
       delay_ms(3);                 //prodleva mezi posílanými byty  (start bit následujícího byte)
       }
 ENABLE_TX=0;                               //deaktivace vysílače   
}                     

//***************************************
    
//pošle konkrétní byte    
void send_byte(unsigned char bajt) 
{     
     
     for(i=0;i<8;i++)
                     {  
                      OUT=0;                 //výstup do L
                      
                      if(bajt&0x01)                  // vymaskuje LSB (bit 0)
                             {
                             OUT=1;                       // když je 1 pošle se puls ve tvaru 2ms H 1 ms L
                             delay_ms(2);
                             OUT=0;
                             delay_ms(1); 
                             }  
                                        
                                        
                      else  
                            {
                              OUT=1;
                              delay_ms(1);           // když je  0 pošle se puls ve tvaru 1ms H 1 ms L
                              OUT=0;
                              delay_ms(1); 
                              }  
                          bajt>>=1;                       //rotace vysílaného bytu do prava
                         }   
                                   
                               
}     

  
 ///převod do grayova kódu je velmi jednoduchý:
 
unsigned char bin2gray(unsigned char n)
{
return n^n>>1;
}
 

 
 //// ponzámka:  zpožďovací  funkce delay_ms(); a delay_us(); jsou z knihovny compilleru Codevision AVR
 ///                         jiné IDE budou mít asi odlišný zápis