devicectrl.cpp

RFID温度签的源码

#include "stdafx.h"
#include ".\devicectrl.h"

#include "HardWareData.h"
#include "CommonMacro.h"

#define BUF_LENGTH		64

CDeviceCtrl::CDeviceCtrl(void)
{
}

CDeviceCtrl::~CDeviceCtrl(void)
{
}

//#define _TEST__

#ifdef _TEST__
INT_DATA_SCAN TempScanData;
int	g_ScanIndex = 0;
BOOL CDeviceCtrl::CMDScan( U8 u8Second, U8 u8MilliSecond, U16 u16Sign )
{
	TempScanData.u8ID[0] = _T('0');
	TempScanData.u8ID[1] = _T('0');
	TempScanData.u8ID[2] = _T('1');
	TempScanData.u8ID[3] = _T('A');
	TempScanData.u8ID[4] = _T('B');
	TempScanData.u8ID[5] = _T('C');

	TempScanData.u8TemperatureData1[0] = 1;
	TempScanData.u8TemperatureData1[1] = 1;
	TempScanData.u8TemperatureData1[2] = 1;
	TempScanData.u8TemperatureData1[3] = 1;

	TempScanData.u8TemperatureData2[0] = 1;
	TempScanData.u8TemperatureData2[1] = 1;
	TempScanData.u8TemperatureData2[2] = 1;
	TempScanData.u8TemperatureData2[3] = 1;
	g_ScanIndex = 0;

	return TRUE;
}



BOOL CDeviceCtrl::GetScanData( IN U32 BufDataSize, OUT U8* pCount, 
							  OUT INT_DATA_SCAN_COL* pScanBufData )
{
	return TRUE;
}

BOOL CDeviceCtrl::GetScanDataUnit(
								  OUT U8* pIsOver, OUT INT_DATA_SCAN* pScanBufData )
{
	TempScanData.u8ID[1] = g_ScanIndex;
	memcpy( pScanBufData, &TempScanData, sizeof(TempScanData) );
	g_ScanIndex++;
	if( g_ScanIndex == 120 )
	{
		*pIsOver = TRUE;
	}
	else
	{
		*pIsOver = FALSE;
	}
	return TRUE;
}

BOOL CDeviceCtrl::GetDataFromCard( OUT INT_DATA_CARD* pData, IN U32 BufSize )
{
	pData->u8Header = 0;
	pData->u8Length = 0;
	pData->u8SectorID = 0;
	pData->u8SectorIDLow = 0;

	pData->u8Data[0] = 1;
	pData->u8Data[1] = 2;
	pData->u8Data[2] = 3;
	pData->u8Data[3] = 4;
	pData->u8Data[4] = 5;
	pData->u8Data[5] = 6;
	pData->u8Data[6] = 7;
	pData->u8Data[7] = 8;
	pData->u8Data[8] = 2;
	pData->u8Data[9] = 0;
	pData->u8Data[10] = 0;
	pData->u8Data[11] = 7;
	pData->u8Data[12] = 0;
	pData->u8Data[13] = 7;
	pData->u8Data[14] = 1;
	pData->u8Data[15] = 2;

	return TRUE;
}

BOOL CDeviceCtrl::CMDWriteData( U32 CardID, INT_WRITE_CARD_DATA* pData )
{
	return TRUE;
}

BOOL CDeviceCtrl::GetCommonResult( U8* pResult )
{
	*pResult = 0;
	return TRUE;
}

#endif // _TSET__

#ifndef _TEST__

BOOL CDeviceCtrl::CMDScan( U8 u8Second, U8 u8MilliSecond, U16 u16Sign )
{
	BOOL bRet = FALSE;
	CMD_SCAN cmd;
	U32 Length = 0;

	cmd.u8Header	= 0x02;
	cmd.u8Command	= 0x01;
	cmd.u8Length	= 0x08;
	cmd.u8Sign[1]	= (U8)( u16Sign & 0x00FF );
	cmd.u8Sign[0]	= (U8)( (u16Sign & 0xFF00) >> 8 ); 
	cmd.u8Second	= u8Second;
	cmd.u8MilliSecond	= u8MilliSecond;
	cmd.u8CRC		= cmd.u8Header | cmd.u8Command | cmd.u8Length | cmd.u8Sign[0] | cmd.u8Sign[1] | cmd.u8Second | cmd.u8MilliSecond;
	bRet = WriteData( (U8*)&cmd, sizeof(cmd), &Length );

	//TCHAR ch[128];
	//swprintf( ch, _T("%3d %3d %3d %3d %3d %3d %3d %3d\n"), 
	//	cmd.u8Header, cmd.u8Command, cmd.u8Length, cmd.u8Sign[0], cmd.u8Sign[1], cmd.u8Second, cmd.u8MilliSecond, cmd.u8CRC );
	//OutputDebugString( ch );
	if( bRet )
	{
		if( Length != sizeof(cmd) )	
			bRet = FALSE;
	}

	return bRet;
}

#define SCAN_DATA_UNIT_SIZE 15

BOOL CDeviceCtrl::GetScanData( IN U32 BufDataSize, OUT U8* pCount, 
							OUT INT_DATA_SCAN_COL* pScanBufData )
{
	BOOL bRet = FALSE;
	U32 u32Length = 0;
	U8 Buf[SCAN_DATA_UNIT_SIZE];
	*pCount = 0;

	bRet = ReadData( Buf, SCAN_DATA_UNIT_SIZE, &u32Length );
	while ( bRet && ( u32Length == 15 || u32Length == 7 ) )
	{
		if( *pCount > MAX_DATA_SCAN )	break;
		if( Buf[0] == 0x02 )
		{
			if( Buf[1] == 0x30 && 
				Buf[2] == 0x30 && 
				Buf[3] == 0x30 && 
				Buf[4] == 0x30 && 
				Buf[5] == 0x30 && 
				Buf[6] == 0x30 )
			{
				break;
			}
			else
			{
				pScanBufData->ScanData[*pCount].u8ID[0] = Buf[1];
				pScanBufData->ScanData[*pCount].u8ID[1] = Buf[2];
				pScanBufData->ScanData[*pCount].u8ID[2] = Buf[3];
				pScanBufData->ScanData[*pCount].u8ID[3] = Buf[4];
				pScanBufData->ScanData[*pCount].u8ID[4] = Buf[5];
				pScanBufData->ScanData[*pCount].u8ID[5] = Buf[6];

				pScanBufData->ScanData[*pCount].u8TemperatureData1[0] = Buf[7];
				pScanBufData->ScanData[*pCount].u8TemperatureData1[1] = Buf[8];
				pScanBufData->ScanData[*pCount].u8TemperatureData1[2] = Buf[9];
				pScanBufData->ScanData[*pCount].u8TemperatureData1[3] = Buf[10];

				pScanBufData->ScanData[*pCount].u8TemperatureData2[0] = Buf[11];
				pScanBufData->ScanData[*pCount].u8TemperatureData2[1] = Buf[12];
				pScanBufData->ScanData[*pCount].u8TemperatureData2[2] = Buf[13];
				pScanBufData->ScanData[*pCount].u8TemperatureData2[3] = Buf[14];

				(*pCount)++;
			}
		}
		else
		{
			bRet = FALSE;
			break;
		}
		memset( Buf, 0, sizeof( Buf ) );
		u32Length = 0;
		bRet = ReadData( Buf, SCAN_DATA_UNIT_SIZE, &u32Length );
	};

	return bRet;
}

BOOL CDeviceCtrl::GetScanDataUnit(
					OUT U8* pIsOver, OUT INT_DATA_SCAN* pScanBufData )
{
	BOOL bRet = FALSE;
	U32 u32Length = 0;
	//U8 Buf[SCAN_DATA_UNIT_SIZE];
	U8 Buf[8] = {0};
	*pIsOver = TRUE;
	bRet = ReadData( Buf, 8, &u32Length );
	
	if ( bRet && ( u32Length == 8 || u32Length == 7 ) )
	{
		if( Buf[0] == 0x02 )
		{
			if( Buf[1] == 0x30 && 
				Buf[2] == 0x30 && 
				Buf[3] == 0x30 && 
				Buf[4] == 0x30 && 
				Buf[5] == 0x30 && 
				Buf[6] == 0x30 )
			{
				*pIsOver = TRUE;
			}
			else
			{
				//TCHAR ch[128];
				//swprintf( ch, _T("Buf:%3d %3d %3d %3d %3d %3d %3d %3d\n"), Buf[0], Buf[1], Buf[2], Buf[3], Buf[4], Buf[5], Buf[6], Buf[7] );
				//OutputDebugString( ch );
				pScanBufData->u8ID[0] = Buf[1];
				pScanBufData->u8ID[1] = Buf[2];
				if ( Buf[1] == 0 ){
					Buf[1] = 0;
				}
				pScanBufData->u8AD	= Buf[3];

				pScanBufData->u8TemperatureData1[0] = Buf[4];
				pScanBufData->u8TemperatureData1[1] = Buf[5];

				pScanBufData->u8TemperatureData2[0] = Buf[6];
				pScanBufData->u8TemperatureData2[1] = Buf[7];
				*pIsOver = FALSE;
			}
		}
		else
		{
			bRet = FALSE;
		}
	}

	return bRet;
}

BOOL CDeviceCtrl::GetDataFromCard( OUT INT_DATA_CARD* pData, IN U32 BufSize )
{
	BOOL bRet = FALSE;
	U32 u32Length = 0;
	U8 Buf[BUF_LENGTH]={0};

	bRet = ReadData( Buf, sizeof(Buf), &u32Length );
	if( bRet )
	{
		if( Buf[0] == 0x02 && Buf[1] == 0x15 )
		{
			memcpy( pData, Buf, u32Length > BufSize ? BufSize : u32Length );
		}
		else
		{
			bRet = FALSE;
		}
	}

	return bRet;
}

BOOL CDeviceCtrl::CMDWriteData( U32 CardID, INT_WRITE_CARD_DATA* pData )
{
	BOOL bRet = FALSE;
	if( pData == NULL )	return FALSE;
	if( pData->u8UnitCount > (256 - 6)/17 )	return FALSE;

	U32 u32Length;
	U8 u8BufSize = pData->u8UnitCount*18 + 6;
	U8 *pBuf = new U8[u8BufSize];
	memset( pBuf, 0,u8BufSize );
	if( pBuf )	
	{
		pBuf[0] = 0x2;
		pBuf[1] = 0x3;
		pBuf[2]	= 0x18;
		pBuf[3] = GET_CARD_ID2( CardID );
		pBuf[4] = GET_CARD_ID3( CardID );

		for( U8 i=0; i< pData->u8UnitCount; i++ )
		{
			memcpy( &pBuf[i*18 + 5], &(pData->WriteData[i]), 18 );
		}

		bRet = WriteData( pBuf, u8BufSize, &u32Length );
		if( bRet )
		{
			if( u32Length != u8BufSize )	bRet = FALSE;
		}

		delete[] pBuf;
	}

	return bRet;
}

BOOL CDeviceCtrl::GetCommonResult( U8* pResult )
{
	BOOL	bRet = FALSE;
	U32		u32Length;
	U8		Buf[4];

	bRet = ReadData( Buf, sizeof(Buf), &u32Length );

	do 
	{
		if( bRet == FALSE )	break;	
		bRet = FALSE;
		if( Buf[0] != 0x02 || Buf[1] != 0x04 )	break;
		if( Buf[3] != GetXorVal( Buf, 3 ) )	break;
		*pResult = Buf[2];
		bRet = TRUE;
	} while(0);

	return bRet;
}

#endif // _TEST__

BOOL CDeviceCtrl::CMDReadData( U8 SectorID, U32 CardID )
{
	BOOL bRet = FALSE;
	U32 u32Length = 0;

	CMD_READ_DATA cmd;
	cmd.u8Header	= 0x02;
	cmd.u8Command	= 0x02;
	cmd.u8Length	= 0x08;
	cmd.u8CardID[0]	= GET_CARD_ID2( CardID );
	cmd.u8CardID[1]	= GET_CARD_ID3( CardID );
	cmd.u8SectorID[0]	= 0;
	cmd.u8SectorID[1]	= SectorID;
	cmd.u8CRC		= cmd.u8CRC ^ cmd.u8Command ^ cmd.u8Length ^ 
		cmd.u8CardID[0] ^ cmd.u8CardID[1] ^ cmd.u8SectorID[0] ^ cmd.u8SectorID[1];

	bRet = WriteData( (U8*)&cmd, sizeof(cmd), &u32Length );
	if( bRet )
	{
		if( u32Length != sizeof(cmd) )
			bRet = FALSE;
	}

	return bRet;
}



BOOL CDeviceCtrl::GetWriteDataResult( U8 *pResult )
{
	return GetCommonResult( pResult );
}

BOOL CDeviceCtrl::CMDFlashLED( U32 CardID, U16 Times, U8 LEDStatus )
{
	BOOL bRet = FALSE;
	U32	u32Length = 0;
	U8	CMD[10];

	CMD[0]	= 0x02;
	CMD[1]	= 0x06;
	CMD[2]	= 0x09;
	CMD[3]	= GET_CARD_ID2( CardID );
	CMD[4]	= GET_CARD_ID3( CardID );
	CMD[5]	= GET_U16_HIGH( Times );
	CMD[6]	= GET_U16_LOW( Times );
	CMD[7]	= LEDStatus;
	CMD[8]	= GetXorVal( CMD, 9 );

	bRet = WriteData( CMD, sizeof(CMD), &u32Length );
	if( bRet )
	{
		if( u32Length != sizeof(CMD) )	bRet = FALSE;
	}

	return bRet;
}

BOOL CDeviceCtrl::GetFlashLEDResult( U8* pResult )
{
	return GetCommonResult( pResult );
}


BOOL CDeviceCtrl::CMDBroadcast( IN U8 IsReturnResult, IN U16 Times, IN U16 Sign )
{
	BOOL	bRet = FALSE;
	U32		u32Length = 0;
	U8		CMD[9];

	CMD[0]	= 0x02;
	CMD[1]	= 0x05;
	CMD[2]	= 0x09;
	CMD[3]	= IsReturnResult;
	CMD[4]	= GET_U16_HIGH( Sign );
	CMD[5]	= GET_U16_LOW( Sign );
	CMD[6]	= GET_U16_HIGH( Times );
	CMD[7]	= GET_U16_LOW( Times );
	CMD[8]	= GetXorVal( CMD, 8 );

	bRet = WriteData( CMD, sizeof(CMD), &u32Length );
	if( bRet )
	{
		if( u32Length != sizeof(CMD) )
			bRet = FALSE;
	}

	return bRet;
}

BOOL CDeviceCtrl::GetBroadcastResult( OUT U8* pResult )
{
	return GetCommonResult( pResult );
}

U8 CDeviceCtrl::GetXorVal( U8* pCMD, U8 CMDLength )
{
	U8 u8Result = 0;
	for( U8 i=0; i<CMDLength; i++ )
	{
		u8Result |= pCMD[i];
	}

	return u8Result;
}

BOOL CDeviceCtrl::CMDSetOutputPower( IN U32 CardID, IN U8 PowerClass )
{
	BOOL bRet = FALSE;
	U32	 u32Length = 0;
	U8	 CMD[8];

	CMD[0]	= 0x02;
	CMD[1]	= 0x06;
	CMD[2]	= 0x08;
	CMD[3]	= GET_CARD_ID1( CardID );
	CMD[4]	= GET_CARD_ID2( CardID );
	CMD[5]	= GET_CARD_ID3( CardID );
	CMD[6]	= PowerClass;
	CMD[7]	= GetXorVal( CMD, 7 );

	bRet = WriteData( CMD, sizeof(CMD), &u32Length );
	if( bRet )
	{
		if( u32Length != sizeof(CMD) )
			bRet = FALSE;
	}

	return bRet;
}

BOOL CDeviceCtrl::GetOutputPowerResult( OUT U8* pResult )
{
	return GetCommonResult( pResult );
}

BOOL CDeviceCtrl::CMDSpecialFlag( IN U32 CardID, IN U8 ReadWriteSign, IN U16 Sign )
{
	BOOL bRet = FALSE;
	U32	 u32Length = 0;
	U8	 CMD[10];

	CMD[0]	= 0x02;
	CMD[1]	= 0x07;
	CMD[2]	= 0x0A;
	CMD[3]	= GET_CARD_ID1( CardID );
	CMD[4]	= GET_CARD_ID2( CardID );
	CMD[5]	= GET_CARD_ID3( CardID );
	CMD[6]	= ReadWriteSign;
	CMD[7]	= GET_U16_HIGH( Sign );
	CMD[8]	= GET_U16_LOW( Sign );
	CMD[9]	= GetXorVal( CMD, 9 );

	bRet = WriteData( CMD, sizeof( CMD ), &u32Length );
	if( bRet )
	{
		if( u32Length != sizeof( CMD ) )
			bRet = FALSE;
	}

	return bRet;
}

BOOL CDeviceCtrl::GetSpecialFlagResult( OUT U8* pResult, OUT U16* pTagResult )
{
	BOOL bRet = FALSE;
	U32	 u32Length = 0;
	U8   Buf[6];

	bRet = ReadData( Buf, sizeof(Buf), &u32Length );
	
	do 
	{
		if( bRet == FALSE ) break;
		bRet = FALSE;
		if( Buf[0] != 0x02 || Buf[1] != 0x04 )	break;
		if( Buf[5] != GetXorVal( Buf, 5 ) )	break;
		*pResult = Buf[2];
		*pTagResult = GET_U16( Buf[3], Buf[4] );
		bRet = TRUE;
	} while(0);	

	return bRet;
}

BOOL CDeviceCtrl::CMDSetStartTime( IN U32 CardID, IN U8 Flag, IN U8 ReadWriteSign, IN CARD_TIME *pTime )
{
	BOOL bRet = FALSE;
	U32  u32Length = 0;
	U8	 CMD[12];

	CMD[0]	= 0x02;
	CMD[1]	= 0x08;
	CMD[2]	= 0x0C;
	CMD[3]	= GET_CARD_ID2( CardID );
	CMD[4]	= GET_CARD_ID3( CardID ) & 0x000000FF;
	CMD[5]	= ReadWriteSign;
	CMD[6]	= pTime->u8Year;
	CMD[7]	= pTime->u8Month;
	CMD[8] = pTime->u8Day;
	CMD[9] = pTime->u8Hour;
	CMD[10]	= pTime->u8Minute;
	CMD[11]	= GetXorVal( CMD, 13 );

	bRet = WriteData( CMD, sizeof(CMD), &u32Length );
	if( bRet )
	{
		if( u32Length != sizeof(CMD) )	bRet = FALSE;
	}

	return bRet;
}

BOOL CDeviceCtrl::GetSetStartTimeResult( OUT U8* pResult )
{
	return GetCommonResult( pResult );
}

BOOL CDeviceCtrl::GetStartTime( OUT CARD_TIME* pTime )
{
	BOOL bRet = FALSE;
	U32	 u32Length = 0;
	U8	 Buf[8];

	bRet = ReadData( Buf, sizeof( Buf ), &u32Length );
	do 
	{
		if( bRet == FALSE )	break;
		bRet = FALSE;
		if( Buf[0] != 0x02 || Buf[1] != 0x08 )	break;
		if( Buf[7] != GetXorVal( Buf, 7) )	break;
		pTime->u8Year	= Buf[2];