h4100.c

PWM输出控制三路步进电机

/******************************************************************************
* ID (H4001)卡读卡模块程序!
******************************************************************************/

#include <avr/io.h>
#include "main.h"
#include "h4100.h"
#include <avr/interrupt.h>
#include <avr/signal.h>
uint8_t HHH[6];
SIGNAL(SIG_INTERRUPT0)
{
	uint16_t jjj;
	uint8_t test,kkk,result;
	asm("nop");
//	BUZ_OFF;
	cli();
	jjj = ReadCard(vvv);
	if(jjj)
	{		
		for (jjj=0; jjj<6 ;jjj++)
		{
			ccc[jjj] = vvv[jjj+1];
		}
		asm("nop");	
	//	RF_Init();
		Card_Show_Time=0;
		buz_count_ms =50;
		Buz_flag=1;
	
		Buz_uc_flag=1;
		Buz_Count_T =0;
		Clr_LCD_Flag=1;
		GICR =0x0;
		H4001_OK_1;		//let saved to flash
		asm("nop");
	}	
}

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

    DIS_TIMER0;     // 屏蔽定时器 0 中断
    TIFR = 0x02;    // 写入1,清除溢出标志
    RF_DIR0;        // PA.6设置为输入
	//T1 for receive timer
    TCCR1B=0x03;     // System Clock/8
    TCNT1=0x00;         
    DIS_TIMER1;     // 屏蔽定时器 0 中断
   // TIFR = 0x02;    // 写入1,清除溢出标志
    sei();
}

/******************************************************************************
function: ReadCard
desc    : implement Manchester decode to read h4001 ID Card,using Timer0
Input   : a uchar pointer to return 5 bytes card data
return  : Read card OK - 1; Read card error - 0.
******************************************************************************/
unsigned char ReadCard(unsigned char *CardData)
{
    uchar i;
    uchar j;
    uchar k;
    uchar rowCheck;            //row parity check
    uchar colCheck;            //column parity check
    uchar startFlag;           //judge the leading 
    uchar temp;                //
    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 = 202;               //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 = 242;         //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
 
        //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;
    }
    
    startFlag = 1;
    for ( i=1; i<6; i++ ) 
    {
        if( CardData[i] )            //不是全0
        {
            startFlag = 0;
            break;
        }
    }
    
    if ( startFlag ){  return 0;}//{ _SEI(); return 0;}
    
    if(1)                           // 卡号 全为零的时候报错
    {
      j=0;
      for(i=0;i<6;i++)
        if(CardData[i]==0) j++;
      if(j==6) return 0;
    }
    if(1)                           // 卡号 全 0xff 的时候报错
    {
      j=0;
      for(i=0;i<6;i++)
        if(CardData[i]==0xff) j++;
      if(j==6) return 0;
    }   
    return 1;
}
//===========================================================================
//===========================================================================