www.open-tager.ru

/*****************************************************************************
 * tm_send
 *
 * Отправка байта.
 */
static void tm_send( unsigned char byte )
{
    static unsigned char i,b;
    b=byte;
    for( i = 0; i < 8; i++ )
    {
        unsigned char pulldown_time, recovery_time;

        if( b & 1 )
        {
            /* write-one time slot */
            pulldown_time = 10;
            recovery_time = 80;
        }
        else
        {
            /* write-zero time slot */
            pulldown_time = 70;
            recovery_time = 20;
        }
        dint();
        TM_TX_PULLDOWN();
        tm_delay( pulldown_time );
        TM_TX_RELEASE();
        eint();
        tm_delay( recovery_time );
        b >>= 1;
    }
}

/*****************************************************************************
 * tm_read
 *
 * Приём байта.
 */
static unsigned char tm_read()
{
    static unsigned char i, ret = 0;

    for( i = 0; i < 8; i++ )
    {
        unsigned char in;

        dint();
        TM_TX_PULLDOWN();
        tm_delay( 5 );
        TM_TX_RELEASE();
        tm_delay( 5 );
        in = TM_RX_IN;
        eint();
        ret >>= 1;
        if( in & TM_RX_PIN )
            ret |= BIT7;
        /* release & recovery */
        tm_delay( 200);
    }
    return ret;
}

/*****************************************************************************
 * new_crc8
 *
 * Вычисление нового значения CRC8.
 */
static unsigned char new_crc8( unsigned char crc8, unsigned char byte )
{
    unsigned char i;

    for( i = 0; i < 8; i++ )
    {
        if( (crc8 ^ byte) & 1 )
            crc8 = ((crc8 ^ 0x18) >> 1) | 0x80;
        else
            crc8 >>= 1;
        byte >>= 1;
    }
    return crc8;
}

/*****************************************************************************
 * read_serial_number
 *
 * Чтение кода ключа и запись события в очередь главной задачи.
 */
static void read_serial_number()
{       
    static unsigned char k;
    read_attempts = 240;
    tm_event=no_tm_event;
    k=0;
    while( read_attempts-- )
    {

    static unsigned char n, crc8;

        /* задержка через каждые 16 попыток */
        if( (read_attempts & 15) == 0 )
            {
             timer_3=0;
             while(timer_3 < 3);
            }

        tm_delay(512);
        /* reset */
        TM_TX_PULLDOWN();
        tm_delay( 480 );  /* tRSTL > 480us */

        /* завершаем импульс сброса, проверяем уровень, должен быть высокий */
        dint();
        TM_TX_RELEASE();
        tm_delay( 7 );   /* 15us minimum tPDH */
        if( (TM_RX_IN & TM_RX_PIN) == 0 )
        {
            /* вероятно, вход просто закорочен */
            eint();
            continue;
        }

        /* контролируем presence pulse */
        tm_delay(80);  /* 60us minimum tPDL */
        n = TM_RX_IN;
        eint();
        if( n & TM_RX_PIN )
            /* что-то не так, уровень должен оставаться низким */
            continue;

        /* ожидаем завершения presence pulse */

        tm_delay(240); /* tPDL */
        if( !(TM_RX_IN & TM_RX_PIN) )
            /* таймаут */
            continue;


        /* выдерживаем высокий уровень tRSTH */
        tm_delay( 480 );

        /* посылаем команду Read ROM */
        tm_send( 0x33 );

        /* читаем тип устройства */
        n = tm_read();
        if( 0 == n )
        /* тип устройства не может быть нулевым */
        continue;
       
        crc8 = new_crc8( 0, n );

        /* читаем код */
        for( n = 0; n < 6; n++ )
        {
            unsigned char code = tm_read();
            tm_code[ n ] = code;
            crc8 = new_crc8( crc8, code );
        }

        /* читаем crc8 и проверяем */
        if( tm_read() != crc8 )
           {
            tm_event=tm_crc_error;
            continue;
           }
        else { tm_event=tm_crc_ok;  return;}
           
    }
}

#define TM_TX_PULLDOWN()   PORTA|=(1<<7)
#define TM_TX_RELEASE()   PORTA&=~(1<<7)    



/*************************************************************************
 delay loop for small accurate delays: 16-bit counter, 4 cycles/loop
*************************************************************************/
static inline void _delayFourCycles(unsigned int __count)
{
    if ( __count == 0 )   
        __asm__ __volatile__( "rjmp 1f\n 1:" );    // 2 cycles
    else
        __asm__ __volatile__ (
           "1: sbiw %0,1" "\n\t"                 
           "brne 1b"                              // 4 cycles/loop
           : "=w" (__count)
           : "0" (__count)
          );
}


/*************************************************************************
delay for a minimum of <us> microseconds
the number of loops is calculated at compile-time from MCU clock frequency
*************************************************************************/
#define delay(us)  _delayFourCycles( ( ( 1*(F_CPU/4000) )*us)/1000 )



volatile  unsigned char ch;
volatile unsigned char crc8;
volatile unsigned char code;
volatile unsigned char in;
volatile unsigned char tm_code[6]; //считанный код ключа Touch_memory

/**************************************************************************************
* Функция выполняет настройку внешних прерываний вывода INT1
***************************************************************************************/
void init_tm(void){

DDRD &=~(1<<3);             //Настраиваем вывод INT1 как вход
PORTD&=~(1<<3);               //Выключаем подтягивающий резистор
DDRA|=(1<<7);
PORTA&=~(1<<7);


}



/*****************************************************************************
 * tm_send
 *
 * Отправка байта.
 */
void tm_send( unsigned char byte )
{
    unsigned char i,b;
    b=byte;
    for( i = 0; i < 8; i++ )
    {
        volatile unsigned char pulldown_time, recovery_time;

        if( b & 1 )
        {
            /* write-one time slot */
            pulldown_time = 10;
            recovery_time = 80;
        }
        if (b&1==0)
        {
            /* write-zero time slot */
            pulldown_time = 70;
            recovery_time = 20;
        }
        TM_TX_PULLDOWN();
      
        delay( pulldown_time );
        TM_TX_RELEASE();
        delay( recovery_time );
        b >>= 1;
    }
}


/*****************************************************************************
 * tm_read
 *
 * Приём байта.
 */
unsigned char tm_read()
{
    unsigned char i, ret = 0;

    for( i = 0; i < 8; i++ )
    {

        TM_TX_PULLDOWN();
        delay( 5 );
        TM_TX_RELEASE();
      delay(5);

        in =  (PIND) & (1<<3);
        ret >>= 1;
        if(in)
            ret |= (1<<7);
        /* release & recovery */
        delay( 200);
    }
    return ret;
}


/*****************************************************************************
 * new_crc8
 *
 * Вычисление нового значения CRC8.
 */
unsigned char new_crc8( unsigned char crc8, unsigned char byte )
{
    unsigned char i;

    for( i = 0; i < 8; i++ )
    {
        if( (crc8 ^ byte) & 1 )
            crc8 = ((crc8 ^ 0x18) >> 1) | 0x80;
        else
            crc8 >>= 1;
        byte >>= 1;
    }
    return crc8;
}




void tm_read_serial_number()
{       

uint8_t read_attempts = 1;
while( read_attempts-- )
    {
      delay(512);




      /* reset */
      TM_TX_PULLDOWN();
      delay(480);  /* tRSTL > 480us */
      /* завершаем импульс сброса, проверяем уровень, должен быть высокий */
      TM_TX_RELEASE();

      delay(7);   /* 15us minimum tPDH */
       if( (PIND&(1<<3)) == 0 )
        {
            /* вероятно, вход просто закорочен */
            continue;
        }
          /* контролируем presence pulse */
       
      delay(80);  /* 60us minimum tPDL */

      if( PIND&(1<<3) )
            /* что-то не так, уровень должен оставаться низким */
            continue;

      /* ожидаем завершения presence pulse */

        delay(240); /* tPDL */
        if( !(PIND&(1<<3)) )
            /* таймаут */
            continue;

      /* выдерживаем высокий уровень tRSTH */
        delay( 480 );
      
        /* посылаем команду Read ROM */
        tm_send( 0x33 );

 /* читаем тип устройства */
     
      ch = tm_read();
        if( 0 == ch)
        /* тип устройства не может быть нулевым */

       
        continue;

      

       crc8 = new_crc8( 0, ch );


 /* читаем код */
        for( ch = 0; ch < 6; ch++ )
        {
            code = tm_read();
            tm_code[ ch ] = code;
            crc8 = new_crc8( crc8, code );
        }
 /* читаем crc8 и проверяем */
        ch = tm_read();
      if( ch != crc8 )
         continue;
   
        else { return;}

   }


}    

/*****************************************************************************
 * tm_send
 *
 * Отправка байта.
 */
void tm_send( unsigned char byte )
{
    unsigned char i,b;
    b=byte;
    for( i = 0; i < 8; i++ )
    {
        volatile unsigned char pulldown_time, recovery_time;

        if( b & 1 )
        {
         /* write-one */
         TM_TX_PULLDOWN();
           TM_TX_RELEASE();
         delay( 80 );   
        }
        if ((b&1)==0)
        {
          /* write-zero */
            TM_TX_PULLDOWN();
         delay( 70 );
           TM_TX_RELEASE();
             delay( 20 );             
        }

        b >>= 1;
    }
}