h4100.c

H4100射频卡驱动程序

/******************************************************************************
*
* ID 卡读卡模块程序!
*------------------------------------------------------------------------------
* 当前版本：2.1.3
* 作    者：陈兆红
* 完成日期：2005年10月15日
******************************************************************************/
#include "h4100.h"

/******************************************************************************
function: RF_Init
desc    : initial IO ports and Timer0 to read card
Input   : none
return  : none
******************************************************************************/
void RF_Init(void)
{
    // Timer/Counter 0 initialization
    // Clock source: System Clock
    // Clock value: 460.800 kHz
//  _CLI();
   
    TCCR0=0x02;     // System Clock/8
    TCNT0=0x00;      
    RF_EN;          // 1=>PA.5,设置为输出,使能 RF

    DIS_TIMER0;     // 屏蔽定时器 0 中断
    TIFR = 0x02;    // 写入1,清除溢出标志
    RF_DIR0;        // PA.6设置为输入

//    _SEI();
}

/******************************************************************************
function: ReadCard
desc    : implement Manchester decode to read h4100 ID Card,using Timer0
Input   : a uchar pointer to return 5 bytes card data
return  : Read card OK - 1; Read card error - 0.
******************************************************************************/
uchar ReadCard(uchar *CardData )
{
    uchar i;
    uchar j;
    uchar k;
    uchar rowCheck;            //row parity check
    uchar colCheck;            //column parity check
    uchar startFlag;           //judge the leading 
    uchar temp;                //
    
    RF_Init();
    
//    _CLI();    
    for ( k=0; k<20; k++ )     //if parity error, retry 20 times
    {
        rowCheck=0;
        colCheck=0;
        temp=0;        
        for(i=0; i<6; i++) CardData[i]=0;
                
        for(i=0; i < 100; i++)                     //try 100 times
        {
            startFlag=0;

            TIFR = 0x02;              //Clear T0 overflow int
            TCNT0 = 40;               //open timer0,longer than 1 bit time and less than 2 bit time
            
            while ( (TIFR & 2) == 0 ) //timer over
            {        
                if ( !RF_DATA )       //if not a 2 bit long high level
                {
                    startFlag=1;
                    break;                
                }
            }
            
            TIFR = 0x02;              //Clear T0 overflow int
            
            TCNT0 = 200;                 
            
            if ( startFlag )
            {
                continue;
            }
            
            while ( (TIFR & 2) == 0 )           //timer over
            {
                if ( !RF_DATA )
                {  break;   }
            }
            
            TIFR = 0x02;                 //Clear T0 overflow int
            TCNT0 = TCNT0_15BIT;                // 1 bit time
            
            if ( RF_DATA)
            {   continue;  }
                    
            for ( j=0; j<8; j++ )
            {
                while ( (TIFR & 2) == 0 )           //timer over
                {
                    
                }           
                
                TCNT0 = 0;                   //overtime counter
                TIFR = 0x02;                 //Clear T0 overflow int
                temp = RF_DATA;   
                while ( (temp == RF_DATA) && (!(TIFR&2))  )  ;        //wait level changed
                
                if ( (!temp)||(TIFR&2) )      //if 9 bits not all 1
                {
                    startFlag = 1;
                    break;
                }
                TIFR = 0x02;                  //Clear T0 overflow int
                TCNT0 = TCNT0_15BIT;          // 1 bit time                        
            }
            
            if ( startFlag )                  //not start head
            {   continue;  }
            else
            {   break;     }        
            
        }
        if ( startFlag || (i>98) )             // ??
        {
            TCNT0 = 0;
            TIFR = 0x02;                 //Clear T0 overflow int
            //_SEI();
            return 0;
        }
        
        rowCheck=0;
        //start receive data
        for ( i=0; i < 5 ; i++ )
        {
            
            for (j=0; j< 10; j++)
            {                
                while ( (TIFR & 2) == 0 )           //timer over
                {                        
                }           
                
                TCNT0 = TCNT0_1BIT;                        //overtime counter
                TIFR = 0x02;                
                
                temp = RF_DATA;   
                while ( (temp == RF_DATA) && (!(TIFR&2))  )  ;        //wait level changed
                
                
                TIFR = 0x02;                         //Clear T0 overflow int
                TCNT0 = TCNT0_15BIT;                 // 1 bit time      
                rowCheck ^=temp;
                
                if ( (j!=4) && (j!=9) )                
                {
                    CardData[i+1] <<=1;                
                    if (temp ) 
                    {
                        CardData[i+1] |= 0x01;
                    }
                    else
                    {
                        CardData[i+1] &= 0xfe;
                    }
                }
                else
                {
                    if( rowCheck  )
                    {
                        j++;
                        j--;
                        startFlag = 1;
                        break;
                    }
                }               
            }  
            if ( rowCheck )
            {                
                startFlag = 1;
                break;
            }         
        }
        
        if ( startFlag )
        {
            continue;
        }
        
        colCheck = 0;
        for ( i=0; i<4; i++ )                   //column check bit receive
        {
            
            while ( (TIFR & 2) == 0 )           //timer over
            {
                    
            }           
            
            TCNT0 = 0;                          //overtime counter
            TIFR = 0x02;                
            temp = RF_DATA;   
            while ( (temp == RF_DATA) && (!(TIFR&2))  )  ;        //wait level changed
            
            TIFR = 0x02;                 //Clear T0 overflow int    
            TCNT0 = TCNT0_15BIT;                // 1 bit time      
                    
            colCheck <<=1;
            
            if ( temp ) 
            {
                colCheck |= 0x01;
            }
            else
            {
                colCheck &= 0xfe;
            }
        }
        
        TCNT0 = 0;
        TIFR = 0x02;                 //Clear T0 overflow int
        //RF_CFE0;
        
        //Check if receive correct   
             
        for ( i=0; i<5; i++ )
        {
            temp = (CardData[i+1] & 0xf0) >> 4;
            colCheck ^= temp;
            colCheck ^= ( CardData[i+1] & 0x0f);        
        }
        
        if ( colCheck==0 )       //column check correct
        {            
            break;
        }
        j++;
    }
    
    if ( k>19 )
    {      
        k++; //_SEI(); 
        return 0;
    }
    if(1)                           // 卡号 全为零的时候报错
    {
      j=0;
      for(i=1;i<6;i++)
        if(CardData[i]==0) j++;
      if(j==5) return 0;
    }
    if(1)                           // 卡号 全 0xff 的时候报错
    {
      j=0;
      for(i=1;i<6;i++)
        if(CardData[i]==0xff) j++;
      if(j==5) return 0;
    }  
//    CardID[1]=0x00;       CardID[2]=0x00;   // 3字节有效
//    CardID[1]=0x00;       //CardID[2]=0x00;   // 4字节有效    
    //_SEI();
    return 1;
}
//===========================================================================
//===========================================================================