mifare_i.cpp

RFID读标示例

  /*******************************************************************************************
 *                                                                                         *
 *                                 Mifare	                                           *
 *                                                                                         *
 *       Copy Right 2001-2002,LandStanding Co.,Ltd.NewLand Group. All Right Reserved.      *
 *                                                                                         *
 *                                                                                         *
 *******************************************************************************************/
/*******************************************************************************************
 *
 *	FILE:
 *		F:\MIFARE\Mifare\Mifare_i.cpp
 *
 *	INTRODUCTION:
 *		
 *
 *	Logs:
 *		2003/11/27		Created by cx.	
 *
 *	BUGREPORT:
 *
 ******************************************************************************************/
 
/******************************************************************************************
*	include files 
*******************************************************************************************/

/********************************************************************************************
*	local referenced extern function and variables 
********************************************************************************************/

/*********************************************************************************************
*	global variables
*********************************************************************************************/

/********************************************************************************************
*	local referenced macro defines & type defines
********************************************************************************************/

/*********************************************************************************************
*	local function prototype
*********************************************************************************************/

/*********************************************************************************************
*	Implementation functions 
*********************************************************************************************/

//#include "stdafx.h"
#include <uBase.h>
#include "uart.h"
#include "mifare_i.h"

int CalcChecksum(int a, int b);
BOOL Sendhandchar(unsigned char c);
BOOL Receivehandchar(char* c);
BOOL FirstHandshake();
BOOL SecondHandshake();



/*
#define COM_USE		COM1
#define BAUDRATE	9600
#define TIME_OUT	2000
*/
int COM_USE = 0;
int BAUDRATE = 9600;
int TIME_OUT = 2000;
#define BUFSIZE		500
unsigned char buf[BUFSIZE];

int CalcChecksum(int a, int b)
{
	return ((~a) & b) | ((~b) & a);
}
BOOL Sendhandchar(unsigned char c)
{
	UartWriteChar(COM_USE, c, TIMEOUT_INFINITE);
	return TRUE;
}
BOOL Receivehandchar(char* c)
{
	if (UartReadChar(COM_USE, c, TIME_OUT) != 0) {
		return FALSE;
	}
	return TRUE;
}
BOOL FirstHandshake()
{
	Sendhandchar(0x23);
	memset(buf, 0, BUFSIZE);
	if (Receivehandchar((char *)buf)) {
		if (buf[0] == 0x45) {
			return TRUE;
		}
	}
	return FALSE;
}
BOOL SecondHandshake()
{
	memset(buf, 0, BUFSIZE);
	if (Receivehandchar((char*)buf)) {
		if (buf[0] == 0x67) {
			Sendhandchar((char)0x89);
			return TRUE;
		}else{
			return FALSE;
		}
	}
	return FALSE;
}


BOOL Mifare_Initialization(int nPort, int nBaudRate, int nTimeout)
{
	COM_USE = nPort;
	BAUDRATE = nBaudRate;
	TIME_OUT = nTimeout;
		
	UartClose(COM_USE);
	
	UART_PARAM param;
	param.baudrate = BAUDRATE;
	param.data = 8;
	param.parity = NOPARITY;
	param.stop = ONESTOPBIT;
	if (UartOpen(COM_USE) != 0) {
		return FALSE;
	}
	UartSetParam(COM_USE, &param);
	if (FirstHandshake() == FALSE) {
		return FALSE;
	}
	buf[0] = 0x00;
	buf[1] = 0x00;
	buf[2] = 0x00;
	UartWrite(COM_USE, buf, 3, TIME_OUT);
	if (SecondHandshake() == FALSE) {
		return FALSE;
	}
	memset(buf, 0x20, BUFSIZE);
	UartRead(COM_USE, buf, 3, TIME_OUT);

	if (buf[0] == 0x00 && buf[1] == 0x00 && buf[2] == 0x00) {
		return TRUE;
	}
	return FALSE;


}
BOOL Mifare_UnInitialization()
{
	UartClose(COM_USE);
	return TRUE;
	
}

BOOL Mifare_GetSerialNumber(int *serialno)
{
	if (FirstHandshake() == FALSE) {
		return FALSE;
	}
	buf[0] = 0xab;
	buf[1] = 0x00;
	buf[2] = 0xab;
	UartWrite(COM_USE, buf, 3, TIME_OUT);
	if (SecondHandshake() == FALSE) {
		return FALSE;
	}
	memset(buf, 0x20, BUFSIZE);
	UartRead(COM_USE, buf, 7, TIME_OUT);
	
	if (buf[0] != 0x00 && buf[1] != 0x04) { //check returned code&length
		return FALSE;
	}
	char snbuf[5];
	for(int n = 0; n < 4; n++){
		snbuf[n] = buf[6 - n];
	}
	int nsr = 0;
	memcpy((void *)&nsr, (char *)(buf + 2), 4);
	*serialno = nsr;
	return TRUE;
}

BOOL Mifare_GetCardType(int *cardtype)
{
	if (FirstHandshake() == FALSE) {
		return FALSE;
	}
	buf[0] = 0xaa;
	buf[1] = 0x00;
	buf[2] = 0xaa;
	UartWrite(COM_USE, buf, 3, TIME_OUT);
	if (SecondHandshake() == FALSE) {
		return FALSE;
	}
	memset(buf, 0x20, BUFSIZE);
	UartRead(COM_USE, buf, 5, TIME_OUT);
	
	if (buf[0] != 0x00 && buf[1] != 0x02) {
		return FALSE;
	}
	*cardtype = (int)(*((short *)(buf + 2)));
	return TRUE;
}

BOOL Mifare_GetReaderCode(int *readercode)
{
	if (FirstHandshake() == FALSE) {
		return FALSE;
	}
	buf[0] = 0xa1;
	buf[1] = 0x00;
	buf[2] = 0xa1;
	UartWrite(COM_USE, buf, 3, TIME_OUT);
	if (SecondHandshake() == FALSE) {
		return FALSE;
	}
	memset(buf, 0x20, BUFSIZE);
	UartRead(COM_USE, buf, 5, TIME_OUT);
	
	if (buf[0] != 0x00 && buf[1] != 0x02) {
		return FALSE;
	}
	*readercode = (int)(*((int*)(buf + 2)));
	return TRUE;
}

BOOL Mifare_Halt()
{
	if (FirstHandshake() == FALSE) {
		return FALSE;
	}
	buf[0] = 0xbd;
	buf[1] = 0x00;
	buf[2] = 0xbd;
	UartWrite(COM_USE, buf, 3, TIME_OUT);
	if (SecondHandshake() == FALSE) {
		return FALSE;
	}
	memset(buf, 0x20, BUFSIZE);
	UartRead(COM_USE, buf, 3, TIME_OUT);
	
	if (buf[0] != 0x00) {
		return FALSE;
	}
	return TRUE;
}


BOOL Mifare_Request(int mode)
{
	if (FirstHandshake() == FALSE) {
		return FALSE;
	}
	int crc = CalcChecksum(CalcChecksum(0xb5, 0x01), mode);
	buf[0] = 0xb5;
	buf[1] = 0x01;
	buf[2] = (unsigned char)mode;
	buf[3] = (unsigned char)crc;
	UartWrite(COM_USE, buf, 4, TIME_OUT);
	if (SecondHandshake() == FALSE) {
		return FALSE;
	}
	memset(buf, 0x20, BUFSIZE);
	UartRead(COM_USE, buf, 3, TIME_OUT);
	
	if (buf[0] != 0x00) {
		return FALSE;
	}
	return TRUE;
}

BOOL Mifare_Authentication(int mode, int sector, int block)
{
	if (FirstHandshake() == FALSE) {
		return FALSE;
	}
	int nbpos = sector * 4 + block;

	int crc = CalcChecksum(CalcChecksum(CalcChecksum(CalcChecksum(0xb8, 0x03), mode), sector), nbpos);
	buf[0] = 0xb8;
	buf[1] = 0x03;
	buf[2] = (unsigned char)mode;
	buf[3] = (unsigned char)sector;
	buf[4] = (unsigned char)nbpos;
	buf[5] = (unsigned char)crc;

	UartWrite(COM_USE, buf, 6, TIME_OUT);
	if (SecondHandshake() == FALSE) {
		return FALSE;
	}
	memset(buf, 0x20, BUFSIZE);
	UartRead(COM_USE, buf, 3, TIME_OUT);
	
	if (buf[0] != 0x00) {
		return FALSE;
	}
	return TRUE;
}


BOOL Mifare_Select(int serialno)
{
	char nsn[5];
	memset(nsn, 0, 5);
	memcpy(nsn, (char*)&serialno, 4); 
	unsigned char snbuf[4];
	
	for(int n = 0; n < 4; n++){
		snbuf[n] = nsn[3 - n];
	}
	
	if (FirstHandshake() == FALSE) {
		return FALSE;
	}
	int crc = CalcChecksum(
		CalcChecksum(
		CalcChecksum(
		CalcChecksum(
		CalcChecksum(0xb7, 0x04), snbuf[0]), snbuf[1]), snbuf[2]), snbuf[3]);
	
	buf[0] = 0xb7;
	buf[1] = 0x04;
	memcpy(buf + 2, (unsigned char*)snbuf, 4);
	buf[6] = (unsigned char)crc;
	
	UartWrite(COM_USE, buf, 7, TIME_OUT);
	if (SecondHandshake() == FALSE) {
		return FALSE;
	}
	memset(buf, 0x20, BUFSIZE);
	UartRead(COM_USE, buf, 3, TIME_OUT);
	
	if (buf[0] != 0x00 ) {
		return FALSE;
	}
	return TRUE;
}


BOOL Mifare_Transkey(int sector, char* szkey)
{
	if (FirstHandshake() == FALSE) {
		return FALSE;
	}
	int crc = 
	CalcChecksum(CalcChecksum(CalcChecksum(CalcChecksum(CalcChecksum(
	CalcChecksum(CalcChecksum(CalcChecksum(
		0xa4, 0x07), sector), szkey[0]), szkey[1]), szkey[2]), szkey[3]), szkey[4]), szkey[5]);

	buf[0] = 0xa4;
	buf[1] = 0x07;
	buf[2] = (unsigned char)sector;
	memcpy(buf + 3, szkey, 6);
	buf[9] = (unsigned char)crc;
	UartWrite(COM_USE, buf, 10, TIME_OUT);
	if (SecondHandshake() == FALSE) {
		return FALSE;
	}
	memset(buf, 0x20, BUFSIZE);
	UartRead(COM_USE, buf, 3, TIME_OUT);
	
	if (buf[0] != 0x00) {
		return FALSE;
	}
	return TRUE;
}

BOOL Mifare_ReadBlock(int sector, int blockno, int mode, char* szdata, int serialno)
{
	// Q: What does `mode' mean?

	char nsn[5];
	int nbpos = sector * 4 + blockno;
	memset(nsn, 0, 5);
	memcpy(nsn, (char *)&serialno, 4);
	unsigned char snbuf[4];

	for(int n = 0; n < 4; n++){ // host order to network order
		snbuf[n] = nsn[3 - n];
	}

	if (FirstHandshake() == FALSE) {
		return FALSE;
	}
	int crc = CalcChecksum(CalcChecksum(CalcChecksum(CalcChecksum(CalcChecksum(
			CalcChecksum(CalcChecksum(0xac, 0x06), nbpos), snbuf[0]), snbuf[1]), snbuf[2]), snbuf[3]), mode);

	buf[0] = 0xac;
	buf[1] = 0x06;
	buf[2] = (unsigned char)nbpos;

	memcpy(buf + 3, (unsigned char*)snbuf, 4);
	buf[7] = (unsigned char)mode;
	buf[8] = (unsigned char)crc;

	UartWrite(COM_USE, buf, 9, TIME_OUT);
	if (SecondHandshake() == FALSE) {
		return FALSE;
	}
	memset(buf, 0x20, BUFSIZE);
	UartRead(COM_USE, buf, 19, TIME_OUT);
	
	if (buf[0] != 0x00 && buf[1] != 0x10) {
		return FALSE;
	}
	memcpy(szdata, buf + 2, 16);
	return TRUE;
}

BOOL Mifare_WriteBlock(int sector, int blockno, int mode, const char* szdata, int serialno)
{

	char nsn[5];
	int nbpos = sector * 4 + blockno;
	memset(nsn, 0, 5);
	memcpy(nsn, (char *)&serialno, 4);
	unsigned char snbuf[4];
	for(int n = 0; n < 4; n++){
		snbuf[n] = nsn[3 - n];
	}
	if (FirstHandshake() == FALSE) {
		return FALSE;
	}
	int crc = 
		CalcChecksum(CalcChecksum(CalcChecksum(CalcChecksum(CalcChecksum(
		CalcChecksum(CalcChecksum(CalcChecksum(CalcChecksum(CalcChecksum(
		CalcChecksum(CalcChecksum(CalcChecksum(CalcChecksum(CalcChecksum(
		CalcChecksum(CalcChecksum(CalcChecksum(CalcChecksum(CalcChecksum(
		CalcChecksum(CalcChecksum(CalcChecksum(
		0xad, 0x16), nbpos), snbuf[0]), snbuf[1]), snbuf[2]), snbuf[3]), 
		szdata[0]),szdata[1]),szdata[2]),szdata[3]),szdata[4]),szdata[5]),
		szdata[6]),szdata[7]),szdata[8]),szdata[9]),szdata[10]),szdata[11]),
		szdata[12]),szdata[13]),szdata[14]),szdata[15]),mode);
	buf[0] = 0xad;
	buf[1] = 0x16;
	buf[2] = (unsigned char)nbpos;
	memcpy(buf + 3, (char*)snbuf, 4);
	memcpy(buf + 7, szdata, 16);
	buf[23] = (unsigned char)mode;
	buf[24] = (unsigned char)crc;
	
	UartWrite(COM_USE, buf, 25, TIME_OUT);
	if (SecondHandshake() == FALSE) {
		return FALSE;
	}
	memset(buf, 0x20, BUFSIZE);
	UartRead(COM_USE, buf, 19, TIME_OUT);
	
	if (buf[0] != 0x00 && buf[1] != 0x10) {
		return FALSE;
	}
	return TRUE;
}