【2020意法半导体开发大赛】基于STM32F7与NFC06A1扩展模块的可视化门禁模块&物业远程门禁管理系统

楼主

donatello1996

9 主题
14 帖子
994 积分

身份：LV3 中级技术员

E币：655

发消息

 4438

 0

发表于 2020-10-9 10:03:35

显示全部楼层

本帖最后由 donatello1996 于 2020-10-13 00:19 编辑

本次比赛我原定计划使用USBHID通信的方案，使电脑端上位机程序可以通过USB线发送指令和数据控制开发板进行读卡/写卡操作，而开发板也可以通过STM32 LL库USB发送代码将读到的NFC卡信息发送到电脑端上位机，因此申请的是第一款开发板（ST25R3916-DISCO），但是收到的却是X-NUCLEO-NFC06A1扩展模块和nucleo-64 L476底板，板上没有USB接口，于是只能将官方代码移植到我自己的STM32F769Discovery开发板上，这个Discovery型号开发板带有Arduino扩展接口，4寸液晶屏，一个USB-HID接口，一个USART6串口，可以用于实现我的方案，但在实际测试中USB-HID接口的接收代码有问题，并且官方的X-NUCLEO-NFC06A1扩展模块的中断触发太频繁，因此USB接口只能发送不能接收，相当于崴了脚，不过好在有串口6（USART6），与电脑端上位机通信是没有任何问题的。解决了开发板问题，又到了NFC标签卡的问题，官方赠送了三个NFC标签，是V类标签，但是只有其中一个能识别，另外两个是坏的，于是我去淘宝买了最常用的那种NFC白卡，是A类标签，非常好用，要是没有买NFC白卡，这比赛都没法进行下去了。

系统框图如下：（点击可放大）

整个系统可以分为两部分，对外部分就是STM32主控板以及X-NUCLEO-NFC06A1扩展模块，主控板通过Arduino接口上的SPI接口以及IRQ外部中断接口与X-NUCLEO-NFC06A1扩展模块上面的ST25芯片通信，至于说为什么要用到外部中断呢，那是因为官方的代码就是用SPI中断+外部中断的方式进行通信的。另外，Arduino接口上还有6个通用GPIO接口用于控制扩展模块上面的6个LED灯，这六个灯用于指示各种事件，如LED_Field指示RF接收定时器的工作状态，每秒闪烁一次，LED_A指示是否监测到A类NFC卡读取，LED_V指示是否监测到V类NFC卡读取；对于STM32主控板即STM32F769Discovery开发板，除了用于显示各种信息用的大液晶屏，还有一个独立按键（蓝色），用于切换显示模式，有简易模式和完整模式两种，简易模式下，NFC读取后只显示UID号和物业门牌号，完整模式下，NFC读取后不仅显示UID号和门牌号，还显示住户姓名和电话，这个完整模式功能是方便住户用的，住户可以随时查看并修改上面的电话信息，两种模式选择哪种也是住户打卡时自行选择。在Arduino地板上引出了STM32主控板的USART6 TTL串口用于进行数据通信，通过一根CH340串口线转接到电脑USB接口上。最后就是门锁模块和红外传感器模块了，门锁模块用一根GPIO输出高低电平就可以控制，我这里没有专门的门锁模块，用一个电磁继电器代替，红外传感器则可以选择人体红外传感器或者反射式红外传感器，只是为了检测手势用的，可用可不用。

流程图如下：（点击可放大）

上电之后，除了进行对必要硬件接口的初始化外，就是打开三个中断，其中两个中断即SPI和IRQ外部中断是官方代码已经写明要打开的，不打开的话没法进行NFC卡的识别，然后就是串口空闲中断了，使用串口空闲中断+RX DMA接收的意义在于开发板可以零延迟接收串口发过来的指令，接收过程不需要CPU主控进行处理，CPU只需一直轮询接收完没有即可（判断一个bool类型的变量是否为真），并且指令长度可以不变，最长为65536字节，大部分情况是使用其中的256字节。

对于NFC卡读取，完整的通信流程如下：

进入官方的DemoCycle()函数的读卡分支，即NDEF_DEMO_READ =》
扩展模块检测到NFC卡的外部中断+SPI中断信号 =》
进行处理得到UID，NFC卡卡内信息 =》
将必要信息显示到液晶屏上 =》
通过特定串口指令将卡上信息发送到电脑QT上位机 =》
电脑上位机发送串口应答包进行开门（可发可不发，不发也没有任何影响）
对于最后一步，电脑端的QT上位机甚至还可以做一个小Demo扩展，就是从文件或者数据库中读取住户信息，只有记录在案的住户信息的其中一条与卡上信息吻合，才给开发板发送开门指令。

NFC卡读取，开发板=》电脑上位机串口指令帧结构：

这个帧结构理解起来非常简单，除去前四个起始字节和一个识别字节外，剩下的就是7个UID字节，4个门牌号字节，20个住户姓名字节，11个住户电话字节，1个住户类型字节；

电脑上位机，命令开发板进入读取循环：

这个更简单，识别到起始字节之后第五个字节是0x02就是上位机命令开发板进入读取循环；

NFC卡读取完成之后识别正确，上位机命令开发板开门串口指令帧结构：

这个一样简单，识别到起始字节之后第五个字节是0x03就是上位机让开发板开门；

对于NFC卡写入，电脑上位机完整的通信流程如下：

电脑QT上位机发送串口指令使开发板进入写卡循环 =》
进入官方的DemoCycle()函数的写卡分支，即NDEF_DEMO_WRITE_MSG1=》
扩展模块检测到NFC卡的外部中断+SPI中断信号 =》
进行处理将格式化信息写入到卡上=》
开发板发送串口应答包告知电脑上位机写卡完成

对于NFC卡写入，电脑上位机=》开发板的串口指令帧结构：

与开发板读取NFC卡发送到电脑端的流程大同小异，少了UID，起始字节改为电脑上位机=》开发板的格式；

NFC卡写入完毕后，开发板=》电脑上位机发送反馈完成报文的串口指令帧结构：

除了上述必要通信流程外，开发板程序加入独立看门狗防止SPI中断读取卡死或者程序跑飞，独立看门狗两秒溢出一次，喂狗间隔为DemoCycle()函数的自带Systick定时器，大致是一秒一次，为了防止在读卡时触发复位，SPI中断服务函数也加入喂狗操作。

电脑端QT上位机与STM32开发板通信采用的协议为串口和USB双协议，为了保证这次比赛作品的完成度并节省时间，目前只实现了串口协议部分的完整通信，而USB协议部分则是做了个简单的交互Demo。上位机界面如下：

NFC读取界面，完整显示NFC卡类型，UID，门牌号，住户姓名，电话，住户类型（租户或业主），这个界面只能读，没有交互按钮；

NFC写入界面，可以自定义门牌号，姓名，电话，在这个界面下可以直接将写入指令输送到主控板上，或者将主控板模式切换为读，下面加入一个写入状态的反馈显示。

到了演示效果环节，首先是默认状态下的NFC卡检测流程，开发板读取到NFC卡之后只在屏幕显示UID和门牌号：

住户可用按键切换屏幕是否完整显示NFC卡信息，即姓名和手机号也一起显示：

上位机界面可以看到NFC读取页面的信息刷新了：

至于NFC卡写入那里就不做太完整的演示了，只显示上位机变化：

STM32开发板代码压缩包文件：

STM32F769 - 副本.zip (3.31 MB, 下载次数: 9)

2020-10-12 01:09 上传

点击文件名下载附件

QT上位机压缩包：

1.haozip03.zip (3.47 MB, 下载次数: 5)

2020-10-12 09:12 上传

点击文件名下载附件

1.haozip02.zip (10 MB, 下载次数: 5)

2020-10-12 09:12 上传

点击文件名下载附件

1.haozip01.zip (10 MB, 下载次数: 14)

2020-10-12 09:12 上传

点击文件名下载附件

由于移植了STM32底板，因此SPI的四根引脚和IRQ引脚都要做相应改变，原来的L476的SPI1换成了F769的SPI2，NSS脚换了，重写了一份spi2.c和一份spi2.h驱动文件，其中引脚定义在spi2.h中

#ifndef _SPI2_H_
#define _SPI2_H_
#include "stm32f7xx.h"
#include <stdint.h>
#include "nfc06a1_conf.h"
typedef enum
{
TF_LED = 0, /*!< Led Type F */
TB_LED, /*!< Led Type B */
TA_LED, /*!< Led Type A */
TV_LED, /*!< Led Type V */
AP2P_LED, /*!< Led Type P2P */
TX_LED /*!< Led Field */
}NFC06A1_Led_E;
typedef struct
{
uint16_t NFC06A1_LED_PIN;
GPIO_TypeDef * NFC06A1_LED_PIN_PORT;
}NFC06A1_Led_TypeDef;
void NFC06A1_LED_Init(void);
void NFC06A1_LED_DeInit(const NFC06A1_Led_E led);
void NFC06A1_LED_ON(const NFC06A1_Led_E led);
void NFC06A1_LED_OFF(const NFC06A1_Led_E led);
void NFC06A1_LED_Toggle(const NFC06A1_Led_E led);
#define BUS_SPI2_NSS_GPIO_PIN GPIO_PIN_11
#define BUS_SPI2_NSS_GPIO_PORT GPIOA
#define BUS_SPI2_NSS_MODE GPIO_MODE_OUTPUT_PP
#define BUS_SPI2_NSS_GPIO_CLK_ENABLE() __HAL_RCC_GPIOA_CLK_ENABLE()
#define BUS_SPI2_IRQ_GPIO_PIN GPIO_PIN_6
#define BUS_SPI2_IRQ_GPIO_PORT GPIOA
#define BUS_SPI2_IRQ_MODE GPIO_MODE_IT_RISING
#define BUS_SPI2_IRQ_GPIO_CLK_ENABLE() __HAL_RCC_GPIOA_CLK_ENABLE()
void MX_SPI2_Init(int psc);
int32_t BSP_SPI2_SendRecv(const uint8_t * const pTxData, uint8_t * const pRxData, uint16_t Length);
void BSP_SPI2_IRQ_Callback(void);
void BSP_SPI2_IRQHandler(void);
#endif

nfc06a1_conf.h中对于六盏LED的GPIO引脚定义位置也要做相应修改：

#ifndef NFC06A1_CONF_H_
#define NFC06A1_CONF_H_
#ifdef __cplusplus
extern "C" {
#endif
#include "stm32f7xx.h"
#define NFC06A1_LED1_PIN_CLK_ENABLE() __HAL_RCC_GPIOA_CLK_ENABLE();
#define NFC06A1_LED2_PIN_CLK_ENABLE() __HAL_RCC_GPIOC_CLK_ENABLE();
#define NFC06A1_LED3_PIN_CLK_ENABLE() __HAL_RCC_GPIOF_CLK_ENABLE();
#define NFC06A1_LED4_PIN_CLK_ENABLE() __HAL_RCC_GPIOF_CLK_ENABLE();
#define NFC06A1_LED5_PIN_CLK_ENABLE() __HAL_RCC_GPIOF_CLK_ENABLE();
#define NFC06A1_LED6_PIN_CLK_ENABLE() __HAL_RCC_GPIOJ_CLK_ENABLE();
#define NFC06A1_LED1_PIN_CLK_DISABLE() __HAL_RCC_GPIOA_CLK_DISABLE();
#define NFC06A1_LED2_PIN_CLK_DISABLE() __HAL_RCC_GPIOC_CLK_DISABLE();
#define NFC06A1_LED3_PIN_CLK_DISABLE() __HAL_RCC_GPIOF_CLK_DISABLE();
#define NFC06A1_LED4_PIN_CLK_DISABLE() __HAL_RCC_GPIOF_CLK_DISABLE();
#define NFC06A1_LED5_PIN_CLK_DISABLE() __HAL_RCC_GPIOF_CLK_DISABLE();
#define NFC06A1_LED6_PIN_CLK_DISABLE() __HAL_RCC_GPIOJ_CLK_DISABLE();
#define NFC06A1_LED1_PIN GPIO_PIN_4
#define NFC06A1_LED1_PIN_PORT GPIOA
#define NFC06A1_LED2_PIN GPIO_PIN_2
#define NFC06A1_LED2_PIN_PORT GPIOC
#define NFC06A1_LED3_PIN GPIO_PIN_10
#define NFC06A1_LED3_PIN_PORT GPIOF
#define NFC06A1_LED4_PIN GPIO_PIN_8
#define NFC06A1_LED4_PIN_PORT GPIOF
#define NFC06A1_LED5_PIN GPIO_PIN_9
#define NFC06A1_LED5_PIN_PORT GPIOF
#define NFC06A1_LED6_PIN GPIO_PIN_3
#define NFC06A1_LED6_PIN_PORT GPIOJ
#define NFC06A1_ALLLED_GPIO_CLK_ENABLE() do{__HAL_RCC_GPIOA_CLK_ENABLE(); \
__HAL_RCC_GPIOC_CLK_ENABLE(); \
__HAL_RCC_GPIOF_CLK_ENABLE(); \
__HAL_RCC_GPIOJ_CLK_ENABLE(); \
}while(0)
#define NFC06A1_ALLLED_GPIO_CLK_DISABLE() do{__HAL_RCC_GPIOA_CLK_DISABLE(); \
__HAL_RCC_GPIOC_CLK_DISABLE(); \
__HAL_RCC_GPIOF_CLK_DISABLE(); \
__HAL_RCC_GPIOJ_CLK_DISABLE(); \
}while(0)
#ifdef __cplusplus
}
#endif
#endif

USART6串口不定长接收处理函数中对ndefDemoFeature变量的处理，以及ndefTEXT写入字符串的赋值，当开发板切换到写循环之后这些信息会自动写入到NFC卡中，非常好理解：

#include "usart.h"
#define BUFFERSIZE 255
struct __FILE
{
int handle;
};
FILE __stdout;
int fputc(int ch, FILE *f)
{
while((USART1->ISR&0X40)==0);
USART1->TDR=(unsigned char)ch;
return ch;
}
UART_HandleTypeDef UART1_Handler;
DMA_HandleTypeDef hdma_usart1_rx;
void UART1_Init(int baud)
{
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_USART1_CLK_ENABLE();
__HAL_RCC_DMA2_CLK_ENABLE();
GPIO_InitTypeDef GPIO_Initure;
GPIO_Initure.Pin=GPIO_PIN_9;
GPIO_Initure.Mode=GPIO_MODE_AF_PP;
GPIO_Initure.Pull=GPIO_PULLUP;
GPIO_Initure.Speed=GPIO_SPEED_FAST;
GPIO_Initure.Alternate=GPIO_AF7_USART1;
HAL_GPIO_Init(GPIOA,&GPIO_Initure);
GPIO_Initure.Pin=GPIO_PIN_10;
HAL_GPIO_Init(GPIOA,&GPIO_Initure);
UART1_Handler.Instance=USART1;
UART1_Handler.Init.BaudRate=baud;
UART1_Handler.Init.WordLength=UART_WORDLENGTH_8B;
UART1_Handler.Init.StopBits=UART_STOPBITS_1;
UART1_Handler.Init.Parity=UART_PARITY_NONE;
UART1_Handler.Init.HwFlowCtl=UART_HWCONTROL_NONE;
UART1_Handler.Init.Mode=UART_MODE_TX_RX;
HAL_UART_Init(&UART1_Handler);
// hdma_usart1_rx.Instance = DMA2_Stream2;
// hdma_usart1_rx.Init.Channel = DMA_CHANNEL_4;
// hdma_usart1_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;
// hdma_usart1_rx.Init.PeriphInc = DMA_PINC_DISABLE;
// hdma_usart1_rx.Init.MemInc = DMA_MINC_ENABLE;
// hdma_usart1_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
// hdma_usart1_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
// hdma_usart1_rx.Init.Mode = DMA_NORMAL;
// hdma_usart1_rx.Init.Priority = DMA_PRIORITY_LOW;
// hdma_usart1_rx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
// HAL_DMA_Init(&hdma_usart1_rx);
// __HAL_LINKDMA(&UART1_Handler,hdmarx,hdma_usart1_rx);
// __HAL_UART_ENABLE_IT(&UART1_Handler,UART_IT_IDLE);
//
// HAL_NVIC_SetPriority(USART1_IRQn, 0, 0);
// HAL_NVIC_EnableIRQ(USART1_IRQn);
}
//unsigned char rx1_buf[BUFFERSIZE],rx1_len=0,uart1_recv_end_flag;
//void UART1_DMA_Get()
//{
// if(uart1_recv_end_flag==1)
// {
// uart1_recv_end_flag=0;
// printf("%s %d\n",rx1_buf,rx1_len);
// HAL_UART_Receive_DMA(&UART1_Handler, (unsigned char*)rx1_buf, BUFFERSIZE);
// }
//}
//void USART1_IRQHandler()
//{
// int temp;
// if(__HAL_UART_GET_FLAG(&UART1_Handler, UART_FLAG_IDLE))
// {
// __HAL_UART_CLEAR_IDLEFLAG(&UART1_Handler);
// HAL_UART_DMAStop(&UART1_Handler);
// temp=__HAL_DMA_GET_COUNTER(&hdma_usart1_rx);
// rx1_len=BUFFERSIZE-temp;
// uart1_recv_end_flag=1;
// }
//}
UART_HandleTypeDef huart6;
DMA_HandleTypeDef hdma_usart6_rx;
void UART6_Send_Char(unsigned char ch)
{
while((USART6->ISR&0X40)==0);
USART6->TDR=(unsigned char)ch;
}
void UART6_Send_String(unsigned char s[])
{
int i=0;
while(s[i]!='\0')
{
UART6_Send_Char(s[i]);
i++;
}
}
void UART6_Init(int baud)
{
__HAL_RCC_GPIOC_CLK_ENABLE();
__HAL_RCC_USART6_CLK_ENABLE();
__HAL_RCC_DMA2_CLK_ENABLE();
GPIO_InitTypeDef GPIO_InitStruct;
GPIO_InitStruct.Pin = GPIO_PIN_7|GPIO_PIN_6;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF8_USART6;
HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
huart6.Instance = USART6;
huart6.Init.BaudRate = baud;
huart6.Init.WordLength = UART_WORDLENGTH_8B;
huart6.Init.StopBits = UART_STOPBITS_1;
huart6.Init.Parity = UART_PARITY_NONE;
huart6.Init.Mode = UART_MODE_TX_RX;
huart6.Init.HwFlowCtl = UART_HWCONTROL_NONE;
huart6.Init.OverSampling = UART_OVERSAMPLING_16;
huart6.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
huart6.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
HAL_UART_Init(&huart6);
hdma_usart6_rx.Instance = DMA2_Stream1;
hdma_usart6_rx.Init.Channel = DMA_CHANNEL_5;
hdma_usart6_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;
hdma_usart6_rx.Init.PeriphInc = DMA_PINC_DISABLE;
hdma_usart6_rx.Init.MemInc = DMA_MINC_ENABLE;
hdma_usart6_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
hdma_usart6_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
hdma_usart6_rx.Init.Mode = DMA_CIRCULAR;
hdma_usart6_rx.Init.Priority = DMA_PRIORITY_LOW;
hdma_usart6_rx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
HAL_DMA_Init(&hdma_usart6_rx);
__HAL_LINKDMA(&huart6,hdmarx,hdma_usart6_rx);
__HAL_UART_ENABLE_IT(&huart6,UART_IT_IDLE);
HAL_NVIC_SetPriority(DMA2_Stream1_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(DMA2_Stream1_IRQn);
HAL_NVIC_SetPriority(USART6_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(USART6_IRQn);
}
extern uint8_t ndefDemoFeature;
extern uint8_t ndefTEXT[32];
unsigned char rx6_buf[BUFFERSIZE],rx6_len=0,uart6_recv_end_flag;
<font color="DeepSkyBlue">void UART6_DMA_Get()
{
if(uart6_recv_end_flag==1)
{
uart6_recv_end_flag=0;
printf("%s %d\n",rx6_buf,rx6_len);
if(rx6_buf[0] == 0x03 && rx6_buf[1] == 0xfc &&
rx6_buf[2] == 0x04 && rx6_buf[3] == 0xfb )
{
if(rx6_buf[4] == 0x01)
{
if(rx6_buf[5] == 0x01)
{
printf("写卡\n");
ndefDemoFeature = 1;
ndefTEXT[0] = 'A';
memcpy(ndefTEXT+1,rx6_buf+6,36);
}
else if(rx6_buf[5] == 0x02)
{
printf("读卡\n");
ndefDemoFeature = 0;
}
else if(rx6_buf[5] == 0x03)
{
printf("开门\n");
ndefDemoFeature = 0;
}
}
}
HAL_UART_Receive_DMA(&huart6, (unsigned char*)rx6_buf, BUFFERSIZE);
}
}</font>
void USART6_IRQHandler()
{
int temp;
if(__HAL_UART_GET_FLAG(&huart6, UART_FLAG_IDLE))
{
__HAL_UART_CLEAR_IDLEFLAG(&huart6);
HAL_UART_DMAStop(&huart6);
temp=__HAL_DMA_GET_COUNTER(&hdma_usart6_rx);
rx6_len=BUFFERSIZE-temp;
uart6_recv_end_flag=1;
}
}

读取到NFC卡之后的处理函数，可以在此做屏幕显示，串口发送等操作：

extern uint8_t nfca_id[7];
extern uint8_t is_show_entire;
/*****************************************************************************/
ReturnCode ndefRtdTextDump(const ndefType* text)
{
uint8_t utfEncoding,i;
ndefConstBuffer8 bufLanguageCode;
ndefConstBuffer bufSentence;
if (text == NULL)
{
return ERR_PARAM;
}
if (text->id != NDEF_TYPE_RTD_TEXT)
{
return ERR_PARAM;
}
ndefGetRtdText(text, &utfEncoding, &bufLanguageCode, &bufSentence);
printf("\n\n----- ndefRtdTextDump utfEncoding=%d bufLanguageCode=%d:%s bufSentence=%d:%s-----\n\n",
utfEncoding,
bufLanguageCode.length,
bufLanguageCode.buffer,
bufSentence.length,
bufSentence.buffer
);
LCD_Show_String_1632(160,32,"ISO14443A/NFC-A card",LCD_COLOR_BLACK,LCD_COLOR_CYAN);
LCD_Show_Char_1632(64,96,Hex2Char(nfca_id[0]>>4),LCD_COLOR_BLACK,LCD_COLOR_CYAN);
LCD_Show_Char_1632(80,96,Hex2Char(nfca_id[0]&0xf),LCD_COLOR_BLACK,LCD_COLOR_CYAN);
LCD_Show_Char_1632(112,96,Hex2Char(nfca_id[1]>>4),LCD_COLOR_BLACK,LCD_COLOR_CYAN);
LCD_Show_Char_1632(128,96,Hex2Char(nfca_id[1]&0xf),LCD_COLOR_BLACK,LCD_COLOR_CYAN);
LCD_Show_Char_1632(160,96,Hex2Char(nfca_id[2]>>4),LCD_COLOR_BLACK,LCD_COLOR_CYAN);
LCD_Show_Char_1632(176,96,Hex2Char(nfca_id[2]&0xf),LCD_COLOR_BLACK,LCD_COLOR_CYAN);
LCD_Show_Char_1632(208,96,Hex2Char(nfca_id[3]>>4),LCD_COLOR_BLACK,LCD_COLOR_CYAN);
LCD_Show_Char_1632(224,96,Hex2Char(nfca_id[3]&0xf),LCD_COLOR_BLACK,LCD_COLOR_CYAN);
LCD_Show_Char_1632(256,96,Hex2Char(nfca_id[4]>>4),LCD_COLOR_BLACK,LCD_COLOR_CYAN);
LCD_Show_Char_1632(272,96,Hex2Char(nfca_id[4]&0xf),LCD_COLOR_BLACK,LCD_COLOR_CYAN);
LCD_Show_Char_1632(304,96,Hex2Char(nfca_id[5]>>4),LCD_COLOR_BLACK,LCD_COLOR_CYAN);
LCD_Show_Char_1632(320,96,Hex2Char(nfca_id[5]&0xf),LCD_COLOR_BLACK,LCD_COLOR_CYAN);
LCD_Show_Char_1632(352,96,Hex2Char(nfca_id[6]>>4),LCD_COLOR_BLACK,LCD_COLOR_CYAN);
LCD_Show_Char_1632(368,96,Hex2Char(nfca_id[6]&0xf),LCD_COLOR_BLACK,LCD_COLOR_CYAN);
LCD_Show_Char_1632(80,128,bufSentence.buffer[1],LCD_COLOR_BLACK,LCD_COLOR_CYAN);
LCD_Show_Char_1632(96,128,bufSentence.buffer[2],LCD_COLOR_BLACK,LCD_COLOR_CYAN);
LCD_Show_Char_1632(112,128,bufSentence.buffer[3],LCD_COLOR_BLACK,LCD_COLOR_CYAN);
LCD_Show_Char_1632(128,128,bufSentence.buffer[4],LCD_COLOR_BLACK,LCD_COLOR_CYAN);
if(is_show_entire)
{
for(i=0;i<20;i++)
LCD_Show_Char_1632(80+i*16,192,bufSentence.buffer[5+i],LCD_COLOR_BLACK,LCD_COLOR_CYAN);
for(i=0;i<11;i++)
LCD_Show_Char_1632(96+i*16,224,bufSentence.buffer[25+i],LCD_COLOR_BLACK,LCD_COLOR_CYAN);
LCD_Show_Char_1632(112,256,bufSentence.buffer[36],LCD_COLOR_BLACK,LCD_COLOR_CYAN);
}
UART6_Send_Char(0x01);
UART6_Send_Char(0xfe);
UART6_Send_Char(0x02);
UART6_Send_Char(0xfd);
UART6_Send_Char('A');
UART6_Send_Char(nfca_id[0]);
UART6_Send_Char(nfca_id[1]);
UART6_Send_Char(nfca_id[2]);
UART6_Send_Char(nfca_id[3]);
UART6_Send_Char(nfca_id[4]);
UART6_Send_Char(nfca_id[5]);
UART6_Send_Char(nfca_id[6]);
for(i=0;i<37;i++)
UART6_Send_Char(bufSentence.buffer[i]);
return ERR_NONE;
}