magneticread.c

磁条卡读取代码

#include "System.h"
#include "MagneticRead.h"


idata unsigned char chTrack1Buffer[READ_TRACK1BUFSIZE];
pdata unsigned char chTrack2Buffer[READ_TRACK2BUFSIZE];
pdata unsigned char chTrack3Buffer[READ_TRACK3BUFSIZE];

unsigned char nReadTrack1Len = 0;
unsigned char nReadTrack2Len = 0;
unsigned char nReadTrack3Len = 0;

//***************************************************************************
//
//	Read Track 1
//  
//***************************************************************************
unsigned char chTrack1Buf1;		//Track1 Data Buffer1 for recieve data
unsigned char chTrack1Buf2;		//Track1 Data Buffer2 for recieve data
unsigned char chTrack1Index;	//Track1 Data Buffer index for recieve data
unsigned char chTrack1Counter;	//Track1 Data bit counter for recieve data
bit fTrack1Start;				//Track1 Start recieve data , it be set by Track1 Receive
bit fTrack1Direction;			//Track1 Swipe direction: 1:Forward / 0:Reserve , it be set by Track1Interrupt 
bit fTrack1StartEnd;
bit fTrack1HaveData;

void TIMER0(void) interrupt 1 using 0
{
	unsigned char chTemp;
    bit ftemp;

	EA=0;

	fTrack1HaveData = TRUE;

	ftemp = !ioTrack1Dat; 

    if( fTrack1Start )
    {
		if( fTrack1Direction )
    	{
			chTrack1Buf1 = chTrack1Buf1 >> 1;
        	if( ftemp )
        	{
        		chTrack1Buf1 = chTrack1Buf1 | 0x40;
        	}
		}
		else
		{
        	if( ftemp )
        	{
        		chTrack1Buf1 = chTrack1Buf1 | 0x01;
        	}
			chTrack1Buf1 = chTrack1Buf1 << 1;
		}

        chTrack1Counter++;
        if( chTrack1Counter == 7 )
        {
        	chTrack1Counter = 0;
           	if( chTrack1Index < READ_TRACK1BUFSIZE - 1 )
           	{
           		chTrack1Buffer[chTrack1Index++] = chTrack1Buf1;
				chTrack1Buf1 = 0x00;
			}
		}
    }     

	// waiting for start code or end code
    else
    {
        chTemp = chTrack1Buf1 & 0x01;        
        chTrack1Buf1 = chTrack1Buf1 >> 1;
        if( ftemp ) chTrack1Buf1 = chTrack1Buf1 | 0x40;                
        chTrack1Buf2 = chTrack1Buf2 >> 1;
        if( chTemp ) chTrack1Buf2 = chTrack1Buf2 | 0x40;
 
		// check Track1 end code
		// [ LRC ] + [ End Code ]
		if( ( chTrack1Buf1 & 0x7F ) == READ_TRACK1_ENDCODE )
        {
			// Check Parity
			ACC = chTrack1Buf2;
			if( P )
			{
	    		chTrack1Buffer[chTrack1Index++] = chTrack1Buf2;
           		chTrack1Buffer[chTrack1Index++] = 0x1F;
		        fTrack1Start = TRUE;
				fTrack1Direction = FALSE;
				fTrack1StartEnd = FALSE;
				chTrack1Buf1 = 0x00;
			}
        }

  		// check Track1 start code
		// [ Start Code ] + [ Data ] + [ End Code ] + [ LRC ]
        else if( ( chTrack1Buf2 & 0x7F ) == READ_TRACK1_STARTCODE )
        {
			// Check Parity
			ACC = chTrack1Buf1;
			if( P )
			{
        		chTrack1Buffer[chTrack1Index++] = chTrack1Buf2;
            	chTrack1Buffer[chTrack1Index++] = chTrack1Buf1;
            	fTrack1Start = TRUE; 
				fTrack1Direction = TRUE;
				fTrack1StartEnd = FALSE;
            	chTrack1Buf1 = 0x00;
			}
        }
	}

	EA=1;
}

//***************************************************************************
//
//	Read Track 3
//  
//***************************************************************************
unsigned char chTrack3Buf1;		//Track3 Data Buffer1 for recieve data
unsigned char chTrack3Buf2;		//Track3 Data Buffer2 for recieve data
unsigned char chTrack3Index;	//Track3 Data Buffer index for recieve data
unsigned char chTrack3Counter;	//Track3 Data bit counter for recieve data
bit fTrack3Start;				//Track3 Start recieve data , it be set by Track3 Receive
bit fTrack3Direction;			//Track3 Swipe direction: 1:Forward / 0:Reserve	, it be set by Track3Interrupt 
bit fTrack3HaveData;
bit fTrack3StartEnd;

void EXINT1(void) interrupt 2 using 0
{
    unsigned char chTemp;
	bit ftemp;

	EA=0;

	fTrack3HaveData = TRUE;

    ftemp = !ioTrack3Dat;

    if( fTrack3Start )
    {
		if( fTrack3Direction )
    	{
			chTrack3Buf1 = chTrack3Buf1 >> 1;
        	if( ftemp )
        	{
        		chTrack3Buf1 = chTrack3Buf1 | 0x10;
        	}
		}
		else
		{
        	if( ftemp )
        	{
        		chTrack3Buf1 = chTrack3Buf1 | 0x01;
        	}
			chTrack3Buf1 = chTrack3Buf1 << 1;
		}
		chTrack3Counter++;
        if( chTrack3Counter == 5 )
        {
        	chTrack3Counter = 0;
           	if( chTrack3Index < READ_TRACK3BUFSIZE - 1 )
           	{
           		chTrack3Buffer[chTrack3Index++] = chTrack3Buf1;
				chTrack3Buf1 = 0x00;
			}
		}
	}

	// waiting for start code or end code
    else
    { 
        chTemp = chTrack3Buf1 & 0x01 ;
        chTrack3Buf1 = chTrack3Buf1 >> 1;
		if( ftemp ) chTrack3Buf1 = chTrack3Buf1 | 0x10;
		chTrack3Buf2 = chTrack3Buf2 >> 1;
        if( chTemp ) chTrack3Buf2 = chTrack3Buf2 | 0x10;

		// check Track3 end code
        if( ( chTrack3Buf1 & 0x1F ) == READ_TRACK23_ENDCODE )
        {
			// [ Start Code ] + [ End Code ] or [ End Code ] + [ Start Code ]
			if( ( chTrack3Buf2 & 0x1F ) == READ_TRACK23_STARTCODE )
			{
        		chTrack3Buffer[chTrack3Index++] = chTrack3Buf2;
            	chTrack3Buffer[chTrack3Index++] = chTrack3Buf1;
            	fTrack3Start = TRUE;
				fTrack3Direction = TRUE;
				fTrack3StartEnd = TRUE;
				chTrack3Buf1 = 0x00;
			}

			// [ LRC ] + [ End Code ]
			else
			{
				// Check Parity
				ACC = chTrack3Buf2;
				if( P )
				{
        			chTrack3Buffer[chTrack3Index++] = chTrack3Buf2;
            		chTrack3Buffer[chTrack3Index++] = 0x1F;
            		fTrack3Start = TRUE;
					fTrack3Direction = FALSE;
					fTrack3StartEnd = FALSE;
					chTrack3Buf1 = 0x00;
				}
			}
        }

		// check Track3 start code
		// [ Start Code ] + [ Data ] + [ End Code ] + [ LRC ]
        else if( ( chTrack3Buf2 & 0x1F ) == READ_TRACK23_STARTCODE )
        {
			// Check Parity
			ACC = chTrack3Buf1;
			if( P )
			{
        		chTrack3Buffer[chTrack3Index++] = chTrack3Buf2;
            	chTrack3Buffer[chTrack3Index++] = chTrack3Buf1;
            	fTrack3Start = TRUE;
				fTrack3Direction = TRUE;
				fTrack3StartEnd = FALSE;
				chTrack3Buf1 = 0x00;
			}
        }
	}

	EA=1;
}

//***************************************************************************
//
//	Read Track 2
//  
//***************************************************************************
unsigned char chTrack2Buf1;		//Track2 Data Buffer1 for recieve data
unsigned char chTrack2Buf2;		//Track2 Data Buffer2 for recieve data
unsigned char chTrack2Index;	//Track2 Data Buffer index for recieve data
unsigned char chTrack2Counter;	//Track2 Data bit counter for recieve data
bit fTrack2Start;				//Track2 Start recieve data , it be set by Track2 Receive
bit fTrack2Direction;			//Track2 Swipe direction: 1:Forward / 0:Reserve	, it be set by Track2Interrupt 
bit fTrack2StartEnd;
bit fTrack2HaveData;

void TIMER1(void) interrupt 3 using 0
{
	unsigned char chTemp;
	bit ftemp;

	EA=0;

	fTrack2HaveData = TRUE;

   	ftemp = !ioTrack2Dat;

    if( fTrack2Start )
 	{
		if( fTrack2Direction )
   		{
			chTrack2Buf1 = chTrack2Buf1 >> 1;
      		if( ftemp )
       		{
       			chTrack2Buf1 = chTrack2Buf1 | 0x10;
       		}
		}
		else
		{
       		if( ftemp )
       		{
       			chTrack2Buf1 = chTrack2Buf1 | 0x01;
       		}
			chTrack2Buf1 = chTrack2Buf1 << 1;
		}
		chTrack2Counter++;
   	   	if( chTrack2Counter == 5 )
      	{
       		chTrack2Counter = 0;
       		if( chTrack2Index < READ_TRACK2BUFSIZE - 1 )
 	     	{
 	      		chTrack2Buffer[chTrack2Index++] = chTrack2Buf1;
				chTrack2Buf1 = 0x00;
			}
		}
	}         

	// waiting for start code or end code
 	else
 	{
     	chTemp = chTrack2Buf1 & 0x01 ;
    	chTrack2Buf1 = chTrack2Buf1 >> 1;
		if( ftemp ) chTrack2Buf1 = chTrack2Buf1 | 0x10;
		chTrack2Buf2 = chTrack2Buf2 >> 1;
      	if( chTemp ) chTrack2Buf2 = chTrack2Buf2 | 0x10;

		// check Track2 end code
      	if( ( chTrack2Buf1 & 0x1F ) == READ_TRACK23_ENDCODE )
       	{
			// [ Start Code ] + [ End Code ] or [ End Code ] + [ Start Code ]
			if( ( chTrack2Buf2 & 0x1F ) == READ_TRACK23_STARTCODE )
			{
			    chTrack2Buffer[chTrack2Index++] = chTrack2Buf2;
           		chTrack2Buffer[chTrack2Index++] = chTrack2Buf1;
           		fTrack2Start = TRUE;
				fTrack2Direction = TRUE;
				fTrack2StartEnd = TRUE;
				chTrack2Buf1 = 0x00;
			}

			// [ LRC ] + [ End Code ]
			else
			{
				// Check Parity
				ACC = chTrack2Buf2;
				if( P )
				{
   	    			chTrack2Buffer[chTrack2Index++] = chTrack2Buf2;
           			chTrack2Buffer[chTrack2Index++] = 0x1F;
           			fTrack2Start = TRUE;
					fTrack2Direction = FALSE; 
					fTrack2StartEnd = FALSE;
					chTrack2Buf1 = 0x00;
				}
			}
	   	}

		// check Track2 start code
		// [ Start Code ] + [ Data ] + [ End Code ] + [ LRC ]
    	else if( ( chTrack2Buf2 & 0x1F ) == READ_TRACK23_STARTCODE )
       	{
			// Check Parity
			ACC = chTrack2Buf1;
			if( P )
			{
       			chTrack2Buffer[chTrack2Index++] = chTrack2Buf2;
          		chTrack2Buffer[chTrack2Index++] = chTrack2Buf1;
           		fTrack2Start = TRUE;
				fTrack2Direction = TRUE; 
				fTrack2StartEnd = FALSE;
				chTrack2Buf1 = 0x00;
			}
   	    }
	}
	EA=1;
}

void ReadyToRead()
{
	chTrack1Buf1 = 0;
	chTrack1Buf2 = 0;
	chTrack1Index = 0;
	chTrack1Counter = 0;
	fTrack1Start = 0;
	fTrack1StartEnd = 0;
	fTrack1HaveData = 0;
	fTrack1Direction = 0;
	
	chTrack2Buf1 = 0;
	chTrack2Buf2 = 0;
	chTrack2Index = 0;
	chTrack2Counter = 0;
	fTrack2Start = 0;
	fTrack2StartEnd = 0;
	fTrack2HaveData = 0;
	fTrack2Direction = 0;

	chTrack3Buf1 = 0;
	chTrack3Buf2 = 0;
	chTrack3Index = 0;
	chTrack3Counter = 0;
	fTrack3Start = 0;
	fTrack3StartEnd = 0;
	fTrack3HaveData = 0;
	fTrack3Direction = 0;
}

void Track1Check()
{
	int i=0,j=0,k=0,nTemp=0;

	for(i=chTrack1Index;i>1;i--)
	{
		if(	chTrack1Buffer[i] != 0x00 )
			break;
	}

	if( i < 2 )
	{