reader.c

非接触式IC卡串口读写程序源码

/*
******************************************************************************
*								READER C FILE	
*
* Filename      :       reader.c
*
* Description   :     	function for event processing 
*
* Author        :       Jun Jiang
*
* Date          :       2008.10.10
*
******************************************************************************
*/

int ceil = 0;

/*
******************************************************************************
*
*                               INCLUDE HEADER
*
******************************************************************************
*/

#include 	<stdio.h>
#include 	<stdlib.h>
#include 	<lib3000s.h>
#include	"Port.h"
#include	"14443Source.h"

/*
******************************************************************************
*
*								MACRO DEFINITION
*
******************************************************************************
*/

#define     SPLIT_LSB(U8INT)    (U8INT & 0x0F)     // get lsb of a data(char)
#define     SPLIT_MSB(U8INT)    ((U8INT >> 4) & 0x0F)       // get msb of a data(char)
#define		BCD_TO_CHAR(BCD)	( BCD > 9 ? (BCD - 10 + 'A') : (BCD + '0') )

/*
******************************************************************************
*
*							PROTOTYPE DECLARATION	
*
******************************************************************************
*/

char* BCDtoStr(char* pDst, const char* pSrc, int Len);
void InputNum(unsigned long long* pKeyAddr, unsigned long long* pBlkNum);
void Input16Data(char* pDst);

/*
******************************************************************************
*                     		READ UID FUNCTION 
* 
* Description:  read UID function for RdUIN menu.
* 
* Arguments  :  int	id		menu  id
*             	int event	event id 
*   
* Return     :  int
*
* Note       : 
*
******************************************************************************
*/

int RdUIDFunc(int id, int event) 
{
	char 	bff[32];
	static char RdUIDFuncBff[32];  
	int  	port1_hdl;
	int		flag;
	static int RdUIDFuncFlag;

	switch (event)
	{
		case EV_START:
			
			RdUIDFuncFlag = -1;
			port1_hdl = OpenDev("/dev/ttyS1");		// open port1
			if (-1 == port1_hdl) {					// deal with opening error
				sprintf(RdUIDFuncBff, "Open port1 failed!");
				return RET_NONE;
			}	
			if ( -1  == SetPort(port1_hdl, 8, 1, 'N') ) {	// set port1 failed
				sprintf(RdUIDFuncBff, "Set port1 failed!");
				return RET_NONE;
			}
			if ( -1 == SetSpeed(port1_hdl, 19200) ) {	// setting speed error
				sprintf(RdUIDFuncBff, "Set speed error!");
				return RET_NONE;
			} 

			flag = ReadUID(0xFF, bff, port1_hdl, 19200);	// read UID
			close(port1_hdl);								// close port1 
		
			switch (flag) {
			
				case 0:								// success
					RdUIDFuncFlag = 0;
					BCDtoStr(RdUIDFuncBff, bff, 5);	// transform result to string
					break;

				case 1:
					sprintf(RdUIDFuncBff, "parameter error!");
					break;

				case 2:
					sprintf(RdUIDFuncBff, "timeout!");
					break;

				case 3:
					sprintf(RdUIDFuncBff, "ack failed!");
					break;

				case 4:
					sprintf(RdUIDFuncBff, "read UID failed!");
					break;

				case 5:
					sprintf(RdUIDFuncBff, "func:select error!");
					break;

				case 6:
					sprintf(RdUIDFuncBff, "rec incompleted!");
					break;
			}
			
			return RET_NONE;
			break;

		case EV_LOOP:
				
			if (0 == RdUIDFuncFlag) {
				lmt_disp_line_center(0, 0, 16, 1, "UID Number:");
				lmt_disp_line_center(1, 0, 16, 1, RdUIDFuncBff);
				
				return RET_LOOP;	
			}
			else {
				lmt_disp_line_clear(0, 0, 16, 4);
				lmt_disp_line(1, 0, 16, 2, RdUIDFuncBff);
				sleep(2);
				lmt_disp_line_clear(0, 0, 16, 4);
				return RET_PREV;
			}		
	
			break;

		default:
			return RET_NONE;
			break;
	}
}


/*
******************************************************************************
*                     8Bit BCD ARRAY TO STRING
* 
* Description:  transform a 8bit BCD array to string 
* 
* Arguments  :  char* 		pDst		pointer of string
*				const char*	pSrc		pointer of BCD array
*				int			Len			number of BCD array			
*   
* Return     :  char* 		pDst		pointer of string
*
* Note       :  have no error handler function and caller must ensure adequancy
*				memory of string.
*
******************************************************************************
*/

char* BCDtoStr(char* pDst, const char* pSrc, int Len)
{
	char*		p_dst;
	const char*	p_src;

	char 	temp;
	int 	i;

	p_src	= pSrc;
	p_dst	= pDst;

	for (i = 0; i < Len; i++) {
		temp	 = SPLIT_MSB(*p_src);
		*p_dst++ = BCD_TO_CHAR(temp);
		temp	 = SPLIT_LSB(*p_src);
		*p_dst++ = BCD_TO_CHAR(temp);
		p_src++;
	}	
	*p_dst = '\0';
	
	return	pDst;
}



/*
******************************************************************************
*                    		INPUT	NUMBER 
* 
* Description:	receive number of key address and block number 
* 
* Arguments  : 	unsigned long long* pKeyAddr		pointer of key address
*				unsigned long long* pBlkNum		pointer of block number 
*   
* Return     :	void
*
* Note       : 	
*
******************************************************************************
*/

void InputNum(unsigned long long* pKeyAddr, unsigned long long* pBlkNum)
{
	int 		event;
	unsigned long long	key_addr;
	unsigned long long	blk_num;
	IMAGEBITS   scrn_bff[128 * 64];

	lmt_disp_line_clear(0, 0, 16, 4);					// clear the screen
	lmt_disp_line_center(0, 0, 16, 1, "Input Number");
	lmt_disp_line(1, 0, 16, 1, "Key Addr:");
	lmt_disp_line(2, 0, 16, 1, "BlockNum:");			// prompted
	lmt_lcd_copy(0, 0, 128, 64, scrn_bff);				// save screen

	do {
		event = 1;
		
		lmt_lcd_paste(0, 0, 128, 64, scrn_bff);			// paste screen
		lmt_inputbox_uint_right(1, 10, 3, &key_addr);	// get keyAddr
		lmt_inputbox_uint_right(2, 10, 3, &blk_num);  	// get BlockNum
		lmt_disp_line_clear(0, 0, 16, 3);		

		if ( !(key_addr >= 0 && key_addr < 24) ) {		// parameter error
			lmt_disp_line_center(1, 0, 16, 1, "KeyAddr Error!");
			event = 0;									
		}
			
		if ( !(blk_num >= 0 && blk_num < 192) ) {		// parameter error
			lmt_disp_line_center(2, 0, 16, 1, "BlockNumError!");
			event = 0;
		}
		
		if (!event) { 
			sleep(2);	
		}												// delay 2 second

	} while (!event);
	
	lmt_disp_line_clear(0, 0, 16, 4);					// clear the screen
	
	*pKeyAddr = key_addr;
	*pBlkNum  = blk_num;
	
}


/*
******************************************************************************
*                     		READ A BLOCK FUNCTION 
* 
* Description:  read a block function for RdBlk menu.
* 
* Arguments  :  int	id		menu  id
*             	int event	event id 
*   
* Return     :  int
*
* Note       : 
*
******************************************************************************
*/

int RdBlkFunc(int id, int event)
{
	char 				bff[64];
	int  				port1_hdl;
	int					flag;
	static int 			RdBlkFuncFlag;
	static char 		RdBlkFuncBff[64];  
	long   long			key_addr;
	static long long	RdBlkFuncBlkNum;
	
	switch (event)
	{
		case EV_START:
			
			RdBlkFuncFlag = -1;
			port1_hdl = OpenDev("/dev/ttyS1");		// open port1
			if (-1 == port1_hdl) {					// deal with opening error
				sprintf(RdBlkFuncBff, "Open port1 failed!");
				return RET_NONE;
			}	
			if ( -1  == SetPort(port1_hdl, 8, 1, 'N') ) {	// set port1 failed
				sprintf(RdBlkFuncBff, "Set port1 failed!");
				return RET_NONE;
			}
			if ( -1 == SetSpeed(port1_hdl, 19200) ) {	// setting speed error
				sprintf(RdBlkFuncBff, "Set speed error!");
				return RET_NONE;
			} 

			InputNum(&key_addr, &RdBlkFuncBlkNum);				// get key_address and block_number
			flag = ReadBlk(0xFF, (int)key_addr, (int)RdBlkFuncBlkNum, bff, port1_hdl, 19200);	// read a block
			close(port1_hdl);								// close port1 
		
			switch (flag) {
			
				case 0:								// success
					RdBlkFuncFlag = 0;
					BCDtoStr(RdBlkFuncBff, bff, 16);	// transform result to string
					break;

				case 1:
					sprintf(RdBlkFuncBff, "parameter error!");
					break;

				case 2:
					sprintf(RdBlkFuncBff, "timeout!");
					break;

				case 3:
					sprintf(RdBlkFuncBff, "ack failed!");
					break;

				case 4:
					sprintf(RdBlkFuncBff, "read block failed!");
					break;

				case 5:
					sprintf(RdBlkFuncBff, "func:select error!");
					break;

				case 6:
					sprintf(RdBlkFuncBff, "receive incompleted!");
					break;
			}
			
			return RET_NONE;
			break;

		case EV_LOOP:
				
			if (0 == RdBlkFuncFlag) {
				sprintf(bff, "Block %3d data:", (int)RdBlkFuncBlkNum);
				lmt_disp_line_center(0, 0, 16, 1, bff);
				lmt_disp_line_center(2, 0, 16, 2, RdBlkFuncBff);
				
				return RET_LOOP;	
			}
			else {
				lmt_disp_line_clear(0, 0, 16, 4);
				lmt_disp_line(1, 0, 16, 2, RdBlkFuncBff);
				sleep(2);
				return RET_PREV;
			}		
	
			break;

		default:
			return RET_NONE;
			break;
	}
}


/*
******************************************************************************
*                     		WRITE A BLOCK FUNCTION 
* 
* Description:  write a block function for WrBlk menu.
* 
* Arguments  :  int	id		menu  id
*             	int event	event id 
*   
* Return     :  int
*
* Note       : 
*
******************************************************************************
*/

int WrBlkFunc(int id, int event)
{
	char 				bff[64];
	int  				port1_hdl;
	int 				flag;
	static int 			WrBlkFuncFlag;
	static char 		WrBlkFuncBff[64];  
	long   long			key_addr;
	static long long	WrBlkFuncBlkNum;
	
	switch (event)
	{
		case EV_START:
			
			WrBlkFuncFlag = -1;
			port1_hdl = OpenDev("/dev/ttyS1");		// open port1
			if (-1 == port1_hdl) {					// deal with opening error
				sprintf(WrBlkFuncBff, "Open port1 failed!");
				return RET_NONE;
			}	
			if ( -1  == SetPort(port1_hdl, 8, 1, 'N') ) {	// set port1 failed
				sprintf(WrBlkFuncBff, "Set port1 failed!");
				return RET_NONE;
			}
			if ( -1 == SetSpeed(port1_hdl, 19200) ) {	// setting speed error
				sprintf(WrBlkFuncBff, "Set speed error!");
				return RET_NONE;
			} 

			InputNum(&key_addr, &WrBlkFuncBlkNum);				// get key_address and block_number
			Input16Data(bff);									// get 16 bytes data for a block
			flag  = WriteBlk(0xFF, (int)key_addr, (int)WrBlkFuncBlkNum, bff, port1_hdl, 19200);	// read a block
			close(port1_hdl);								// close port1 
		
			switch (flag) {
			
				case 0:								// success
					WrBlkFuncFlag = 0;
					sprintf(WrBlkFuncBff, "Write block %3d success!", (int)WrBlkFuncBlkNum);
					break;

				case 1:
					sprintf(WrBlkFuncBff, "parameter error!");
					break;

				case 2:
					sprintf(WrBlkFuncBff, "timeout!");
					break;

				case 3:
					sprintf(WrBlkFuncBff, "ack failed!");
					break;

				case 4:
					sprintf(WrBlkFuncBff, "write block failed!");
					break;

				case 5:
					sprintf(WrBlkFuncBff, "func:select error!");
					break;

				case 6:
					sprintf(WrBlkFuncBff, "receive incompleted!");
					break;
			}
			
			return RET_NONE;
			break;

		case EV_LOOP:
				
			if (0 == WrBlkFuncFlag) {
				lmt_disp_line_center(1, 0, 16, 2, WrBlkFuncBff);
				
				sleep(2);
				return RET_PREV;
			}
			else {
				lmt_disp_line_clear(0, 0, 16, 4);
				lmt_disp_line(1, 0, 16, 2, WrBlkFuncBff);
				sleep(2);
				return RET_PREV;
			}		
	
			break;

		default:
			return RET_NONE;
			break;
	}
}


/*
******************************************************************************
*                    	INPUT DATA FOR WRITE A BLOCK 
* 
* Description:	receiving 16 byte data for writing a block 
* 
* Arguments  : 	char* pDst		pointer of area stroed 16 bytes data	
*   
* Return     :	void
*
* Note       : 	
*
******************************************************************************
*/

void Input16Data(char* pDst)
{
	int 	i;
	unsigned long long temp;
	char 	bff[32];

	for (i = 0; i < 16; i++) {
		
		do {
			sprintf(bff, "%2dth data:", (i + 1));
			lmt_disp_line(3, 0, 16, 1, bff);			// prompted message
			lmt_inputbox_uint_right(3, 10, 3, &temp);	// input data 
			
			if ( temp > 255) {
				lmt_disp_line_clear(3, 0, 16, 1);				
				lmt_disp_line(3, 0, 16, 1, "Illegal data!");
				sleep(1);								// delay 1 second
				lmt_disp_line_clear(3, 0, 16, 1);				
			}
		} while (temp > 255);							// repeat if illegal

		pDst[i] = temp & 0xFF;							// write into array
		BCDtoStr(bff, &pDst[i], 1);
		lmt_disp_line((i / 8), (i % 8* 2), 2, 1, bff);		// display it
	} // for

	lmt_disp_line_clear(3, 0, 16, 1);
	lmt_disp_line_center(3, 0, 16, 1, "Input completed!");
	sleep(1);											// input 16 bytes OK!
	lmt_disp_line_clear(0, 0, 16, 4);

}