app_magdrive.c

磁条卡读卡的源代码

#include "App_Cfg.h"
#include "App_MagDrive.h"

MAGCARD_TRACK2 Track2_Data;
MAGCARD_TRACK3 Track3_Data;


void MagDrive_Init(void)
{
    REG32(GPALR) &= 0xFF0003FF;         //IO 5,6,7 8 9 10 11

    REG32(GPDIR) &= ~IO_CLS;
     	
	REG32(GPDIR) &= ~IO_TRACK_2_DATA;   //data  IO  for track2
	REG32(GPDIR) &= ~IO_TRACK_2_CLK;    //clock IO  for track2

	REG32(GPDIR) &= ~IO_TRACK_3_DATA;   //data  IO  for track3
	REG32(GPDIR) &= ~IO_TRACK_3_CLK;    //clock IO  for track3 
	
	
	REG32(GPDIR) |= IO_BUZZER_CTRL;
	REG32(GPDR)  &= ~IO_BUZZER_CTRL;
	
	REG32(GPDR)  |= IO_CLS;      
}


UINT1 MagDrive_Polling(void)
{
    memset(&Track2_Data,0,sizeof(Track2_Data));   
    memset(&Track3_Data,0,sizeof(Track3_Data));
    
    if ( REG32(GPDR) & IO_CLS ) return 0;

    do
    {
        //MagDrive_Get_TK1();
        MagDrive_Get_TK3();
        //MagDrive_Get_TK2();    
        
    }
    while( (REG32(GPDR) & IO_CLS) == 0 );
    
    Z32Print("\r\n");
    Z32Print("Swipe");
    Z32Printf("-----------------------------------------------------------------------------\r\n");
    
    Z32PrintHex(Track2_Data.TK2_Data,Track2_Data.TK2_Len,"Orign Track2:\r\n"); 
    Z32Printf("Track2 Length(Orign):%d",Track2_Data.TK2_Len);
    
    Z32Printf("\r\n");
    
    MagDrive_Fix_Track2(&Track2_Data);   
    
    Z32PrintHex(Track2_Data.TK2_Data,Track2_Data.TK2_Len,"Fixed Track2:\r\n");  
    Z32Printf("Track2 Length(Fixed):%d",Track2_Data.TK2_Len);  
    Z32Printf("\r\n");
    
    //if (0 == MagDrive_Check_Track2_Characters(Track2_Data.TK2_Data, Track2_Data.TK2_Len)) return 0;
    //if (0 == MagDrive_Check_LRC(Track2_Data.TK2_Data, Track2_Data.TK2_Len))               return 0; 
                       
    MagDrive_Decode_Track(Track2_Data.TK2_Data,Track2_Data.TK2_Data,Track2_Data.TK2_Len);
    Z32Print(Track2_Data.TK2_Data);
    
    Z32Printf("\r\n");
    
    /////////////////////////////////////////////////////////////////////////////
    
    Z32PrintHex(Track3_Data.TK3_Data,Track3_Data.TK3_Len,"Orign Track3:\r\n"); 
    Z32Printf("Track3 Length(Orign):%d",Track3_Data.TK3_Len);
    
    Z32Printf("\r\n");
    
    MagDrive_Fix_Track2((MAGCARD_TRACK2*)&Track3_Data);   
    
    Z32PrintHex(Track3_Data.TK3_Data,Track3_Data.TK3_Len,"Fixed Track3:\r\n");  
    Z32Printf("Track3 Length(Fixed):%d",Track3_Data.TK3_Len);  
    Z32Printf("\r\n");
    
    //if (0 == MagDrive_Check_Track2_Characters(Track3_Data.TK3_Data, Track3_Data.TK3_Len)) return 0;
    //if (0 == MagDrive_Check_LRC(Track3_Data.TK3_Data, Track3_Data.TK3_Len))               return 0; 
                       
    MagDrive_Decode_Track(Track3_Data.TK3_Data,Track3_Data.TK3_Data,Track3_Data.TK3_Len);
    Z32Print(Track3_Data.TK3_Data);
    
    Z32Printf("\r\n");
    
    return 1;                
}


UINT1 MagDrive_Get_TK1(void)
{

    return 0;
}

UINT1 MagDrive_Get_TK2(void)
{
    if ( REG32(GPDR)&IO_TRACK_2_CLK)
    { 
        Track2_Data.TK2_ClkSign = 0;                //Clock Status left unchanged        
        return 0;
    }    
    
    
    //Start To Sample the data
    //LSB First Read Out, b1 is LSB,  P is MSB 
    
    if (Track2_Data.TK2_ClkSign == 1) return 0;                         //Sample,already
    if (Track2_Data.TK2_Len >= sizeof(Track2_Data.TK2_Data)) return 1;  //Full ,already
    
    Track2_Data.TK2_ClkSign = 1;                                        //Clock Status Reverse
    
    if ( REG32(GPDR) & IO_TRACK_2_DATA )
    {  
        Track2_Data.TK2_StartGuard = 1;
        Track2_Data.TK2_BITMAP  |= (0x01 << Track2_Data.TK2_Index);     
    }
    else
    {
        //Self-clocking will be filtered out
        if (Track2_Data.TK2_StartGuard == 0) return 0;
    }
       
    Track2_Data.TK2_Index++;
    
    if (Track2_Data.TK2_Index == 5)
    {
        Track2_Data.TK2_Data[Track2_Data.TK2_Len++] = (UINT1)Track2_Data.TK2_BITMAP;
        Track2_Data.TK2_BITMAP = 0;
        Track2_Data.TK2_Index  = 0;                      
    }
    
    return 1;
}

UINT1 MagDrive_Get_TK3(void)
{
    if ( REG32(GPDR)&IO_TRACK_3_CLK)
    { 
        Track3_Data.TK3_ClkSign = 0;                //Clock Status left unchanged        
        return 0;
    }    
    
    
    //Start To Sample the data
    //LSB First Read Out, b1 is LSB,  P is MSB 
    
    if (Track3_Data.TK3_ClkSign == 1) return 0;                         //Sample,already
    if (Track3_Data.TK3_Len >= sizeof(Track3_Data.TK3_Data)) return 1;  //Full ,already
    
    Track3_Data.TK3_ClkSign = 1;                    //Clock Status Reverse
    
    if ( REG32(GPDR) & IO_TRACK_2_DATA )
    {  
        Track3_Data.TK3_StartGuard = 1;
        Track3_Data.TK3_BITMAP  |= (0x01 << Track3_Data.TK3_Index);     
    }
    else
    {
        //Self-clocking will be filtered out
        if (Track3_Data.TK3_StartGuard == 0) return 0;
    }
       
    Track3_Data.TK3_Index++;
    
    if (Track3_Data.TK3_Index == 5)
    {
        Track3_Data.TK3_Data[Track3_Data.TK3_Len++] = (UINT1)Track3_Data.TK3_BITMAP;
        Track3_Data.TK3_BITMAP = 0;
        Track3_Data.TK3_Index  = 0;                      
    }
    
    return 1;    
}


UINT1 MagDrive_Check_5Bits(UINT1 a5Bits)
{
    UINT2 i = 0;
    UINT1 nOddNum = 0;
		
	for (;i<5;i++) 
    {
		if (a5Bits & (0x01<<i)) nOddNum++; 
	}	

	return (nOddNum%2);	
}

UINT1 MagDrive_Check_Track2_Characters(UINT1* aBuff,UINT2 nLen)
{
    UINT2 i;
    
    for(i = 0 ; i < nLen ; i++)
    {
        if (0 ==  MagDrive_Check_5Bits(aBuff[i]))  return 0;    
    }
    
    return 1;
}


UINT1 MagDrive_Check_LRC(UINT1* aBuff,UINT2 nLen)
{
    UINT1 aTmp = 0;
    UINT1 i;
    
    for(i = 0; i < nLen; i++)
    {
        aTmp ^= aBuff[i];    
    }
    
    return (!aTmp);
}



UINT1 MagDrive_Decode_Track(UINT1* aOutData,UINT1* aInData,UINT2 nLen)
{
    int i = 0; 
    
    for( ; i < nLen; i++)
    {
        aOutData[i] = ( (0x0F & aInData[i]) + 0x30);    
    }
}

//fix up data：cut trailing clocking bits, and reverse bits

void MagDrive_Rvs_Bits(UINT1* aBuff, UINT2 nLen)
{
    UINT1 i,j;
    UINT1 aTmp;
    
    for( j = 0; j < nLen; j++)
    {               
        aTmp = 0;
        
        for( i = 0; i < 5; i++)
        {
                if ( aBuff[j] & (0x01<<i)) aTmp |= (0x01<<(4-i));
        }
        aBuff[j] = aTmp;
    }    
}


void MagDrive_Fix_Track2(MAGCARD_TRACK2* pTK2)
{
    //Cut trailing clocking bits
    UINT1 aTmp;
    UINT2 nIndex = 0;
    UINT2 nNum   = 0;
    

    if (pTK2->TK2_Len <= 0 ) return;
    while(pTK2->TK2_Data[pTK2->TK2_Len -1] == 0x00) pTK2->TK2_Len--;
    
    if (pTK2->TK2_Data[1] == 0x1F)         //反向刷卡
    {
        nNum = pTK2->TK2_Len/2;
        while(nIndex < nNum)
        {
                aTmp = (pTK2->TK2_Data[nIndex]);
                pTK2->TK2_Data[nIndex] = pTK2->TK2_Data[pTK2->TK2_Len -1 - nIndex];
                pTK2->TK2_Data[pTK2->TK2_Len - 1 - nIndex] = aTmp; 
                nIndex++;                          
        }   
        //Z32PrintHex(Track2_Data.TK2_Data,Track2_Data.TK2_Len,"Track2_Rvs:\r\n");
        MagDrive_Rvs_Bits( pTK2->TK2_Data, pTK2->TK2_Len);
    } 
}