mifare1_h6152.c

Mifare1_H6152 的读卡程序

	while(!RI);
	tmp1 = SBUF;
	if(tmp1 == 'L')    // 登陆成功
		return 0;
	else
		return tmp1;    // 错误
}

/* 读块至缓冲区，参数block为要读取的块，buf保存读取的块信息，长度应为16个字节 */
uchar m_read_block(uchar block, uchar *buf)
{
	uchar i;
	
	if(block > 64)    // 块超过64报错
		return M_ERR_E;
	strcpy(m_buf, "r");
	Byte2HexCat(&block, 1, m_buf);    // 将block转换为16进制字符串
	m_send_cmd(m_buf);    // "r<block>"

	for(i=0; i<32; i++)    // 接收块数据
	{
		RI = 0;
		while(!RI);
		*(m_buf+i) = SBUF;
		if((*(m_buf+i)>0x39) && (*(m_buf+i)<'a'))    // 如果接收到错误信息则直接返回错误代码
			return *(m_buf+i);
	}
	*(m_buf+32) = 0;
	Hex2Byte(m_buf, buf);    // 将块内容由16进制字符串形式转换为字节数组

	return 0;    // 操作成功
}

/* 读数值块至缓冲区,参数block为要读取的块，buf保存读取的数值块信息，长度应为4个字节 */
uchar m_read_value(uchar block, uchar *buf)
{
	uchar i;
	
	if(block > 64)    // 块超过64报错
		return M_ERR_E;
	strcpy(m_buf, "rv");
	Byte2HexCat(&block, 1, m_buf);    // 将block转换为16进制字符串
	m_send_cmd(m_buf);    // "rv<block>"

	for(i=0; i<8; i++)    // 接收数值块数据
	{
		RI = 0;
		while(!RI);
		*(m_buf+i) = SBUF;
		if((*(m_buf+i)>0x39) && (*(m_buf+i)<'a'))    // 如果接收到错误信息则直接返回错误代码
			return *(m_buf+i);
	}
	*(m_buf+8) = 0;
	Hex2Byte(m_buf, buf);    // 将数值块内容由16进制字符串形式转换为字节数组

	return 0;    // 操作成功
}

/* 读工作寄存器内容至result变量，参数addr为要读取的寄存器地址，result保存读取的内容，长度应为1个字节 */
uchar m_read_register(uchar addr, uchar *result)
{
	uchar i;
	
	if(addr > 0x13)    // 工作寄存器最大地址0x13
		return M_ERR_E;
	strcpy(m_buf, "re");
	Byte2HexCat(&addr, 1, m_buf);    // 将block转换为16进制字符串
	m_send_cmd(m_buf);    // "re<reg>"

	for(i=0; i<2; i++)    // 接收工作寄存器数据
	{
		RI = 0;
		while(!RI);
		*(m_buf+i) = SBUF;
		if((*(m_buf+i)>0x39) && (*(m_buf+i)<'a'))    // 如果接收到错误信息则直接返回错误代码
			return *(m_buf+i);
	}
	*(m_buf+2) = 0;
	Hex2Byte(m_buf, result);    // 将寄存器内容由16进制字符串形式转换为字节数组

	return 0;    // 操作成功
}

/* 缓冲区内容写入块，参数block为要读取的块，buf保存要写入块的内容，长度为16个字节 */
uchar m_write_block(uchar block, uchar *buf)
{
	uchar i;
	
	if(block > 64)    // 块超过64报错
		return M_ERR_E;
	strcpy(m_buf, "w");
	Byte2HexCat(&block, 1, m_buf);    // 将block转换为16进制字符串
	Byte2HexCat(buf, 16, m_buf);    // 将要写入的内容转换为16进制字符串
	m_send_cmd(m_buf);    // "w<block><data>"
	
	for(i=0; i<32; i++)    // 接收返回数据，应为写入的内容
	{
		RI = 0;
		while(!RI);
		*(m_buf+i) = SBUF;
		if((*(m_buf+i)>0x39) && (*(m_buf+i)<'a'))    // 如果接收到错误信息则直接返回错误代码
			return *(m_buf+i);
	}
	
	return 0;    // 操作成功
}

/* 缓冲区内容写入数值块，参数block为要读取的块，buf保存要写入块的内容，长度为4个字节 */
uchar m_write_value(uchar block, uchar *buf)
{
	uchar i;
	
	if(block > 64)    // 块超过64报错
		return M_ERR_E;
	strcpy(m_buf, "wv");
	Byte2HexCat(&block, 1, m_buf);    // 将block转换为16进制字符串
	Byte2HexCat(buf, 4, m_buf);    // 将要写入的内容转换为16进制字符串
	m_send_cmd(m_buf);    // "wv<block><data>"
	
	for(i=0; i<8; i++)    // 接收返回数据，应为写入的内容
	{
		RI = 0;
		while(!RI);
		*(m_buf+i) = SBUF;
		if((*(m_buf+i)>0x39) && (*(m_buf+i)<'a'))    // 如果接收到错误信息则直接返回错误代码
			return *(m_buf+i);
	}
	
	return 0;    // 操作成功
}

/* data变量内容写入工作寄存器，参数addr为写入的寄存器地址 */
uchar m_write_register(uchar addr, uchar mydata)
{
	uchar i;
	
	if(addr > 0x13)    // 工作寄存器最大地址0x13
		return M_ERR_E;
	strcpy(m_buf, "we");
	Byte2HexCat(&addr, 1, m_buf);    // 将addr转换为16进制字符串
	Byte2HexCat(&mydata, 1, m_buf);    // 将要写入的内容转换为16进制字符串
	m_send_cmd(m_buf);    // "we<reg><data>"
	
	for(i=0; i<2; i++)    // 接收返回数据，应为写入的内容
	{
		RI = 0;
		while(!RI);
		*(m_buf+i) = SBUF;
		if((*(m_buf+i)>0x39) && (*(m_buf+i)<'a'))    // 如果接收到错误信息则直接返回错误代码
			return *(m_buf+i);
	}
	
	return 0;    // 操作成功
}

/* 缓冲区内容写入密码寄存器，参数addr为写入的寄存器地址，buf保存写入内容，长度为6个字节 */
uchar m_write_memory(uchar addr, uchar *buf)
{
	uchar i;
	
	if(addr > 0x1f)    // 工作寄存器最大地址0x1f
		return M_ERR_E;
	strcpy(m_buf, "wm");
	Byte2HexCat(&addr, 1, m_buf);    // 将addr转换为16进制字符串
	Byte2HexCat(buf, 6, m_buf);    // 将要写入的内容转换为16进制字符串
	m_send_cmd(m_buf);    // "wm<reg><data>"
	
	for(i=0; i<12; i++)    // 接收返回数据，应为写入的内容
	{
		RI = 0;
		while(!RI);
		*(m_buf+i) = SBUF;
		if((*(m_buf+i)>0x39) && (*(m_buf+i)<'a'))    // 如果接收到错误信息则直接返回错误代码
			return *(m_buf+i);
	}
	
	return 0;    // 操作成功
}

/* 数值块加值操作，参数block为要操作的数值块，value保存增加的值，result保存返回的操作结果 */
uchar m_increment(uchar block, uchar *value, uchar *result)
{
	uchar i;
	
	if(block > 64)    // 块超过64报错
		return M_ERR_E;
	strcpy(m_buf, "+");
	Byte2HexCat(&block, 1, m_buf);    // 将block转换为16进制字符串
	Byte2HexCat(value, 4, m_buf);    // 将要写入的内容转换为16进制字符串
	m_send_cmd(m_buf);    // "+<block><value>"
	
	for(i=0; i<8; i++)    // 接收返回数据，应为减值操作后的数值
	{
		RI = 0;
		while(!RI);
		*(m_buf+i) = SBUF;
		if((*(m_buf+i)>0x39) && (*(m_buf+i)<'a'))    // 如果接收到错误信息则直接返回错误代码
			return *(m_buf+i);
	}
	*(m_buf+8) = 0;
	Hex2Byte(m_buf, result);    // 将操作后数值块内容由16进制字符串形式转换为字节数组
	
	return 0;    // 操作成功
}

/* 数值块减值操作，参数block为要操作的数值块，value保存增加的值，result保存返回的操作结果 */
uchar m_decrement(uchar block, uchar *value, uchar *result)
{
	uchar i;
	
	if(block > 64)    // 块超过64报错
		return M_ERR_E;
	strcpy(m_buf, "-");
	Byte2HexCat(&block, 1, m_buf);    // 将block转换为16进制字符串
	Byte2HexCat(value, 4, m_buf);    // 将要写入的内容转换为16进制字符串
	m_send_cmd(m_buf);    // "-<block><value>"
	
	for(i=0; i<8; i++)    // 接收返回数据，应为减值操作后的数值
	{
		RI = 0;
		while(!RI);
		*(m_buf+i) = SBUF;
		if((*(m_buf+i)>0x39) && (*(m_buf+i)<'a'))    // 如果接收到错误信息则直接返回错误代码
			return *(m_buf+i);
	}
	*(m_buf+8) = 0;
	Hex2Byte(m_buf, result);    // 将操作后数值块内容由16进制字符串形式转换为字节数组
	
	return 0;    // 操作成功
}

/* 数值块内容复制，参数source为源块的地址，destination为目的块的地址 */
uchar m_copy(uchar source, uchar destination)
{
	uchar i;
	
	if((source>64) || (destination>64))    // 块超过64报错
		return M_ERR_E;
	strcpy(m_buf, "=");
	Byte2HexCat(&source, 1, m_buf);    // 源地址转换为16进制字符串
	Byte2HexCat(&destination, 1, m_buf);    // 目的地址转换为16进制字符串
	m_send_cmd(m_buf);    // "=<sou><des>"
	
	for(i=0; i<8; i++)    // 接收返回数据
	{
		RI = 0;
		while(!RI);
		*(m_buf+i) = SBUF;
		if((*(m_buf+i)>0x39) && (*(m_buf+i)<'a'))    // 如果接收到错误信息则直接返回错误代码
			return *(m_buf+i);
	}
	
	return 0;    // 操作成功
}

#endif