身份證讀取設備開發解決方案：3、單片機讀取身份證資訊的demo

一、前言

前面我們已經在Windows(https://blog.csdn.net/weixin_39510813/article/details/118579865?spm=1001.2014.3001.5501)、Android(https://blog.csdn.net/weixin_39510813/article/details/118707701?spm=1001.2014.3001.5501)上確認過讀取身份證模塊的可行性，對應封裝模塊串口協議可以正常使用且比較方便，但是在某些情況下部分控制門磁等的舊的功能是已經在stm32單片機上開發了，目前的新功能只想疊加而不想重構，所以方案設計上為了可能會將讀取身份證、nfc卡等功能都還是放到單片機上處理，為了滿足這種方案設計，我們在單片機上也開發一個demo來做下測驗，理論上已經有了Android設備，那么將外設介面都放在這個Android設備上即可，再多一個單片機的設計有些浪費，而且結構設計、通信方案都是處于一個冗余的狀態，理想和現實總是有差距的，我們這里只確認該方案的可行性即可，合理性只做反饋，至于使用何種方案最侄訓是根據實際情況決定，

二、部分代碼及結果展示

1. 準備

• 串口連接：

目前身份證模塊和stm32是通過串口通信，stm32和Android也是通過串口通信，這也是串口的一個好處，可以和spi等介面復用，因此一個小的單片機可以使用多個串口，像我們使用的stm32L471RE里面目前有5個串口，一個除錯串口，一個用于和Android通信，目前再接一個和身份證模塊通信，還剩余兩個串口，這塊的串口需要讓硬體工程使結合原理圖焊接一下（由于我目前只除錯stm32和身份證模塊的通信，因此stm32和Android通信的串口暫時不需要）：

我們單片機上使用的是FreeRTOS，而且串口這塊已經封裝好了，因此加下來直接呼叫封裝好的介面進行串口初始化后再進行讀寫即可，

• 開發工具：

IAR，目前專案組不是使用的mdk，使用的是iar，因此開發工具需要準備好，這個我之前總結過了（https://blog.csdn.net/weixin_39510813/article/details/116065838?spm=1001.2014.3001.5501），

• 除錯工具：

串口除錯工具、stlink/v2

2. 部分代碼

注意：涉及協議的部分去掉了，

#include "readIDCardSerial.h"
#include "serialSend.h"
#include "beep.h"
#include "serial.h"
#include "modules_init.h"
#include "timer.h"
#include "unit.h"
#include "open_log.h"
#include "sysCfg.h"
#include "open_door.h"
#include "permi_list.h"
#include "tempwd.h"
#include "sysCntSave.h"
#include "BleDataHandle.h"
#include "config.h"
#include "crc32.h"

static portBASE_TYPE             xHigherPriorityTaskWoken = pdFALSE;
static xTaskHandle               readIDCardSerialTask;
void                             *readIDCardSerialPort = NULL;
__IO uint8_t                     readIDCardSerialreceiveTimeStart = TRUE;
readIDCardSerialReceiveDataType  readIDCardSerialReceiveData;
enum readIDCard_action {
    BUZZER,
    FIND_IDCARD,
    SELECT_IDCARD,
    READ_IDCARD,
    OTHER,
};
static enum readIDCard_action g_action = FIND_IDCARD;
static uint8_t g_readIDCardInfoFlag    = false;

/

void readIDCard_serial_receive_byte(uint8_t ch)
{
    readIDCardSerialReceiveData.buff[readIDCardSerialReceiveData.len++] = ch;

    if ( readIDCardSerialReceiveData.len >= SERIAL_RECEIVE_MAX)
    {
        log(ERR,"readIDCardSerial recv too length\n");
        memset(&readIDCardSerialReceiveData , 0x00, sizeof(readIDCardSerialReceiveDataType));
    }    
}

void readIDCard_serial_send( uint8_t *pData , uint16_t len)
{   
    serial.puts(readIDCardSerialPort , pData , len);
    log_arry(DEBUG,"send data:" ,pData , len);
    
    xSemaphoreGiveFromISR( xReadIDCardSerialSemaphore, &xHigherPriorityTaskWoken );
    portEND_SWITCHING_ISR(xHigherPriorityTaskWoken );
}

static void readIDCard_send_buzzer()
{
    //蜂鳴器
    unsigned char buzzer[9] = {...};
    
    log_arry(DEBUG, "send buzzer data:" ,(unsigned char *)buzzer, 9);
    readIDCard_serial_send(buzzer, 9);
}

static void readIDCard_send_findIDCard()
{
    //身份證尋卡
    unsigned char findIDCard[9] = {...};
    
    log_arry(DEBUG, "send findIDCard data:" ,(unsigned char *)findIDCard, 9);
    readIDCard_serial_send(findIDCard, 9);
}

static void readIDCard_send_selectIDCard()
{
    //身份證選卡
    unsigned char selectIDCard[9] = {...};
    
    log_arry(DEBUG, "send selectIDCard data:" ,(unsigned char *)selectIDCard, 9);
    readIDCard_serial_send(selectIDCard, 9);
}

static void readIDCard_send_readIDCard()
{
    //身份證讀卡
    unsigned char readIDCard[9] = {...};
    
    log_arry(DEBUG, "send readIDCard data:" ,(unsigned char *)readIDCard, 9);
    readIDCard_serial_send(readIDCard, 9);
}

void readIDCard_serial_timer_isr(void)
{    
    if(readIDCardSerialreceiveTimeStart)
    {
        readIDCardSerialreceiveTimeStart = FALSE;             
        readIDCardSerialReceiveData.receiveFinsh = TRUE;
        
        switch(g_action) {
        case BUZZER:
            readIDCard_send_buzzer();
            break;
        case FIND_IDCARD:
            readIDCard_send_findIDCard();
            break;
        case SELECT_IDCARD:
            readIDCard_send_selectIDCard();
            break;
        case READ_IDCARD:
            readIDCard_send_readIDCard();
            break;
        case OTHER:
            break;
        default:
            break;
        }
    }
    HAL_IWDG_Refresh(&hiwdg);
}

void readIDCardSerial_sendbyte( uint8_t ch)
{
    serial.putc(readIDCardSerialPort , ch );
}

void readIDCard_serial_open_door(void)
{
    uint8_t openVoiceFlag = config.read(CFG_SYS_OPEN_VOICE_ENABLE,NULL);
    if(openVoiceFlag == TRUE)
    {  
        beep.write(BEEP_NORMAL);
    }    
    open_door();
}

static void getName(unsigned char * idCardInfo) {
    unsigned short name[15];

    for(int i = 0; i < 15; i++) {
        name[i] = idCardInfo[8+2*i+1] << 8;
        name[i] = name[i] + (idCardInfo[8+2*i] & 0x00ff);
    }
    
    log_arry(DEBUG, "name data:" ,(unsigned char *)name, 15);
}

static void getSex(unsigned char * idCardInfo) {
    unsigned short sex[1];

    for(int i = 0; i < 1; i++){
        sex[i] = idCardInfo[8+30+2*i+1] << 8;
        sex[i] = sex[i] + (idCardInfo[8+30+2*i] & 0x00ff);
    }
    
    log_arry(DEBUG, "sex data:" ,(unsigned char *)sex, 1);
}

static void getNation(unsigned char * idCardInfo) {
    unsigned short nation[2];

    for(int i = 0; i < 2; i++) {
        nation[i] = idCardInfo[8+30+2+2*i+1] << 8;
        nation[i] = nation[i] + (idCardInfo[8+30+2+2*i] & 0x00ff);
    }
    
    log_arry(DEBUG, "nation data:" ,(unsigned char *)nation, 2);
}

static void getBirth(unsigned char * idCardInfo) {
    unsigned short birth[8];

    for(int i = 0; i < 8; i++) {
        birth[i] = idCardInfo[8+30+2+4+2*i+1] << 8;
        birth[i] = birth[i] + (idCardInfo[8+30+2+4+2*i] & 0x00ff);
    }
    
    log_arry(DEBUG, "birth data:" ,(unsigned char *)birth, 8);
}

static void getAddress(unsigned char * idCardInfo) {
    unsigned short address[35];

    for(int i = 0; i < 35; i++) {
        address[i] = idCardInfo[8+30+2+4+16+2*i+1] << 8;
        address[i] = address[i] + (idCardInfo[8+30+2+4+16+2*i] & 0x00ff);
    }
    
    log_arry(DEBUG, "address data:" ,(unsigned char *)address, 35);
}

static void getIDCardNum(unsigned char * idCardInfo) {
    unsigned short idCardNum[18];

    for(int i = 0; i < 18; i++) {
        idCardNum[i] = idCardInfo[8+30+2+4+16+70+2*i+1] << 8;
        idCardNum[i] = idCardNum[i] + (idCardInfo[8+30+2+4+16+70+2*i] & 0x00ff);
    }
    
    log_arry(DEBUG, "idCardNum data:" ,(unsigned char *)idCardNum, 18);
}

static void getIssuingAuthority(unsigned char * idCardInfo) {
    unsigned short issuingAuthority[15];

    for(int i = 0; i < 15; i++) {
        issuingAuthority[i] = idCardInfo[8+30+2+4+16+70+36+2*i+1] << 8;
        issuingAuthority[i] = issuingAuthority[i] + (idCardInfo[8+30+2+4+16+70+36+2*i] & 0x00ff);
    }
    
    log_arry(DEBUG, "issuingAuthority data:" ,(unsigned char *)issuingAuthority, 15);
}

static void getEffectiveStartDate(unsigned char * idCardInfo) {
    unsigned short effectiveStartDate[8];

    for(int i = 0; i < 8; i++) {
        effectiveStartDate[i] = idCardInfo[8+30+2+4+16+70+36+30+2*i+1] << 8;
        effectiveStartDate[i] = effectiveStartDate[i] + (idCardInfo[8+30+2+4+16+70+36+30+2*i] & 0x00ff);
    }
    
    log_arry(DEBUG, "effectiveStartDate data:" ,(unsigned char *)effectiveStartDate, 8);
}

static void getEffectiveEndDate(unsigned char * idCardInfo) {
    unsigned short effectiveEndDate[8];

    for(int i = 0; i < 8; i++) {
        effectiveEndDate[i] = idCardInfo[8+30+2+4+16+70+36+30+16+2*i+1] << 8;
        effectiveEndDate[i] = effectiveEndDate[i] + (idCardInfo[8+30+2+4+16+70+36+30+16+2*i] & 0x00ff);
    }
    
    log_arry(DEBUG, "effectiveEndDate data:" ,(unsigned char *)effectiveEndDate, 8);
}

void readIDCard_serial_data_deal(void)
{
    uint16_t dataofs = 0;
    readIDCardSerialReceiveDataType serialData;
    
    memset(&serialData  , 0x00 , sizeof(readIDCardSerialReceiveDataType));
    memcpy(&serialData , &readIDCardSerialReceiveData , sizeof(readIDCardSerialReceiveDataType));         
    memset( &readIDCardSerialReceiveData ,0x00 ,  sizeof(readIDCardSerialReceiveDataType));
    
    int systime = HAL_GetTick();
    
    while(dataofs < serialData.len && (serialData.buff != 0x00))
    {
        log_arry(DEBUG,"ReadIDCardSerial data:" ,(unsigned char *)serialData.buff, serialData.len);
        
        if((serialData.buff[dataofs] == 0xEA) && (serialData.buff[dataofs+1] == 0xEB) 
           && (serialData.buff[dataofs+2] == 0xEC) && (serialData.buff[dataofs+3] == 0xED))
        {
            switch(serialData.buff[dataofs+7]) {
            case 0xA4:
                log(INFO, "蜂鳴器\n");
                g_action = FIND_IDCARD;
                break;
            case 0xB0:
                log(INFO, "身份證尋卡\n");
                if(serialData.buff[dataofs+6] == 0) {
                    log(INFO, "身份證尋卡成功，開始選卡\n");
                    g_action = SELECT_IDCARD;
                } else {
                    log(WARN, "身份證尋卡失敗\n");
                    g_action = FIND_IDCARD;
                }
                break;
            case 0xB1:
                log(INFO, "身份證選卡\n");
                if(serialData.buff[dataofs+6] == 0) {
                    log(INFO, "身份證選卡成功，開始讀卡\n");
                    g_action = READ_IDCARD;
                } else {
                    log(WARN, "身份證選卡失敗\n");
                    g_action = FIND_IDCARD;
                }
                break;
            case 0xB4:
                log(INFO, "身份證讀取\n");
                if(serialData.buff[dataofs+6] == 0) {
                    log(INFO, "身份證讀取成功，開始處理讀取到的資料\n");
                    g_readIDCardInfoFlag = true;
                } else {
                    log(WARN, "身份證讀取失敗\n");
                    g_action = FIND_IDCARD;
                }
                break;
            default:
                log(WARN, "unknown");
                break;
            }
        }
        
        if(g_readIDCardInfoFlag) {
            log(INFO, "讀取到的資料長度:%u\n", serialData.len);
            if(serialData.len == 1290) {
                getName((unsigned char *)serialData.buff);
                getSex((unsigned char *)serialData.buff);
                getNation((unsigned char *)serialData.buff);
                getBirth((unsigned char *)serialData.buff);
                getAddress((unsigned char *)serialData.buff);
                getIDCardNum((unsigned char *)serialData.buff);
                getIssuingAuthority((unsigned char *)serialData.buff);
                getEffectiveStartDate((unsigned char *)serialData.buff);
                getEffectiveEndDate((unsigned char *)serialData.buff);
                
                g_action = BUZZER;
                g_readIDCardInfoFlag = false;
            }
            
            if(serialData.len > 1290) {
                g_readIDCardInfoFlag = false;
                g_action = FIND_IDCARD;
            }
        }
        
        memset(&serialData, 0x00 , sizeof(readIDCardSerialReceiveDataType));
    }
    
    log(WARN,"readIDCardSerial 處理時間:%d\n",HAL_GetTick()-systime);
    readIDCardSerialreceiveTimeStart = TRUE;
}

void readIDCardSerial_init( void )
{
    readIDCardSerialPort = serial.open("serial2");
    
    if( readIDCardSerialPort == NULL)
    {
        beep.write(BEEP_ALARM);
        return ;
    }

    serial.init(readIDCardSerialPort, 115200, readIDCard_serial_receive_byte);
    timer.creat(1000, TRUE, readIDCard_serial_timer_isr);
}

static void readIDCard_serial_task( void const *pvParameters)
{
    readIDCardSerial_init();
    
    memset(&readIDCardSerialReceiveData , 0x00 ,sizeof(readIDCardSerialReceiveDataType));
    
    for( ; ; )
    {
        if( xSemaphoreTake(xReadIDCardSerialSemaphore, 2000) == pdTRUE )
        {
            readIDCard_serial_data_deal();
        }
    }
} 

void creat_readIDCardSerial_task( void )
{
    osThreadDef( readIDCardSerial, readIDCard_serial_task , osPriorityHigh, 0, configMINIMAL_STACK_SIZE*3);
    readIDCardSerialTask = osThreadCreate(osThread(readIDCardSerial), NULL);
    configASSERT(readIDCardSerialTask);
}

readIDCardSerialFunsType readIDCardSerial = 
{
    .send = readIDCard_serial_send,
};

3. 結果展示

創建定時器一直進行尋卡，尋卡成功后進行選卡和讀卡，讀卡成功后呼叫蜂鳴器，上面的代碼為了便于測驗定時器時間設定為1000，讀取阻塞時間設定為2000，當讀取身份證成功后會發出“滴”的聲音，沒有身份證時則輪詢尋卡，

由于沒有GUI，所以這里我們通過串口除錯工具確認收發串口滿足協議即可（涉及協議的部分不便展示）:

三、常見錯誤

錯誤1

找不到頭檔案：

Fatal Error[Pe1696]: cannot open source file "readIDCardSerial.h" D:\code\a9a10_reader_shanghai\Src\freertos.c 76 

如下圖所示（右鍵齒輪出現Option，添加絕對路徑后可選取使用相對路徑）：

錯誤2

Error[Lp021]: the destination for compressed initializer batch "P6-1" is placed at an address that is dependent on the size of the batch, which is not allowed  

這個是記憶體不足造成的問題：https://blog.csdn.net/weixin_42381351/article/details/103677495

修改SRAM的大小即可，我這里目前修改為65位元組(搜索configTOTAL_HEAP_SIZE修改即可)，

四、注意事項

1. 確認串口線焊接正常

和硬體同事確認焊接的串口收發線（tx、rx）正常，我們可以使用蜂鳴器來確定發送正常，接收正常則需要讀取接收值確認，讀取不到時可以和硬體工程師一起使用示波器除錯一下，（stm32通過和身份證模塊的串口連接線進行收發，之后通過和usb轉ttl的串口進行日志資料列印，當我們和Android設備連接后還需要確認和Android的串口收發正常）

2. 其它

再者如果使用了freertos的話需要確認一下定時器和系統延時時間是否混用，這可能會導致例外中斷，

單片機中可以控制串口的快取，因此我們可以一次性讀取到所有的身份證資訊，不用分幾段來拼接，

單片機中串口收發需要注意收發的時序，這個和上層應用不太一樣的地方，調時序是個令人崩潰的活，如果你看到有工程師在調時序，千萬不要打擾，他可能會因此突然變的暴躁，

單片機的性能相對較弱，要注意不要在回圈中列印，