/*
* Module_RFID.c
*
* Created on: 2019-10-24
* Update: 2020-10-19
* Author: Eason Yang
* Version: V0.03
*
* History
* 1. Added : Reyax code.
*
*
*
*
*
*/
#include "Module_RFID.h"
//==================================
// PRINT OUT LOG FORMAT
//==================================
#define SystemLogMessage
#define DEBUG_INFO_1(format, args...) StoreLogMessage("[%s:%d][%s][Info] "format, __FILE__, __LINE__, __FUNCTION__, ##args)
#define DEBUG_WARN_1(format, args...) StoreLogMessage("[%s:%d][%s][Warn] "format, __FILE__, __LINE__, __FUNCTION__, ##args)
#define DEBUG_ERROR_1(format, args...) StoreLogMessage("[%s:%d][%s][Error] "format, __FILE__, __LINE__, __FUNCTION__, ##args)
//==================================
// SYSTEM CONSTANT
//==================================
#define Debug
#define ARRAY_SIZE(A) (sizeof(A) / sizeof(A[0]))
#define PASS 1
#define FAIL -1
//==================================
// RFID CMD CONSTANT
//==================================
unsigned int RFID_CMD_ISO1443A_REQUEST = 0x20;
unsigned int RFID_CMD_ISO1443B_REQUEST = 0x60;
unsigned int RFID_CMD_FELICA_POLLING_REQUEST = 0x2F;
unsigned int RFID_CMD_HALT_14443A = 0x28;
unsigned int RFID_CMD_BLOCK_READ = 0x21;
unsigned int RFID_CMD_BLOCK_WRITE = 0x22;
unsigned int RFID_CMD_BUZZER_SET = 0x14;
unsigned int RFID_CMD_RF_OUTPUT_LEVEL_SET = 0x02;
unsigned int RFID_CMD_DEFAULT_AUTO_DETECTING_CARD = 0x1D;
//==================================
// RFID MODE CONSTANT
//==================================
unsigned char WUPA = 0;
unsigned char REQA = 1;
unsigned char AFI = 0;
//==================================
// MIFARE CARD LENGTH
//==================================
unsigned int LENGTH_0 = 0;
unsigned int LENGTH_4 = 4;
unsigned int LENGTH_6 = 6;
unsigned int LENGTH_7 = 7;
unsigned int LENGTH_10 = 10;
//==================================
// RF output Level constant
//==================================
unsigned int RF_STRONGEST = 0x00;
unsigned int RF_STRONGER = 0x01;
unsigned int RF_WEAK = 0x02;
unsigned int RF_WEAKEST = 0x03;
//==================================
// Default of Automatic Detecting constant
//==================================
unsigned int TURN_OFF = 0x00;
unsigned int TURN_ON = 0X01;
unsigned int TURN_TEMPORARILY = 0x11;
//==================================
// MIFARE SECTOR SPACE
//==================================
#define ROW 6
#define COLUMN 16
unsigned char sectorKeyA[COLUMN][ROW] = { {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}
};
unsigned char serialNumber[32];
unsigned int cardLength;
//==================================
// SystemLog message
//==================================
#ifdef SystemLogMessage
int StoreLogMessage(const char *fmt, ...)
{
char Buf[4096 + 256];
char buffer[4096];
time_t CurrentTime;
struct tm *tm;
va_list args;
va_start(args, fmt);
int rc = vsnprintf(buffer, sizeof(buffer), fmt, args);
va_end(args);
memset(Buf, 0, sizeof(Buf));
CurrentTime = time(NULL);
tm = localtime(&CurrentTime);
sprintf(Buf,
"echo \"[%04d.%02d.%02d %02d:%02d:%02d] - %s\" >> /Storage/SystemLog/[%04d.%02d]RFID_SystemLog",
tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday, tm->tm_hour,
tm->tm_min, tm->tm_sec, buffer, tm->tm_year + 1900, tm->tm_mon + 1);
system(Buf);
#ifdef Debug
printf("[%04d.%02d.%02d %02d:%02d:%02d] - %s", tm->tm_year + 1900,
tm->tm_mon + 1, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec,
buffer);
#endif
return rc;
}
#endif
//==========================================
// Module's command send/receive
//==========================================
int system_command(int uart, unsigned char* cmd,int length, unsigned char* rx)
{
int len;
//sleep(2); //required to make flush work, for some reason
tcflush(uart,TCIOFLUSH);
if(write(uart, cmd, length) >= 0)
{
usleep(100000);
len = read(uart, rx, 256);
}
else
{
DEBUG_ERROR_1("system command %s response fail.\n", cmd);
}
return len;
}
//==========================================
// Module's AT command send/receive (REYAX)
//==========================================
int at_command(int uart, unsigned char* cmd,int length, unsigned char* rx)
{
int len;
//sleep(2); //required to make flush work, for some reason
tcflush(uart,TCIOFLUSH);
if(write(uart, cmd, length) >= ARRAY_SIZE(cmd))
{
usleep(100000);
len = read(uart, rx, 512);
}
else
{
DEBUG_ERROR_1("AT command %s response fail.\n", cmd);
}
return len;
}
//==========================================
// Calculation checksum function
//==========================================
char ClaCheckSum(unsigned char *buffer, int len)
{
int idx;
char chksum = 0;
for(idx = 0 ; idx < len-1 ; idx++)
{
chksum ^= *(buffer+idx);
}
return chksum;
}
int chksumValid(unsigned char * buffer)
{
int result = FAIL;
int chksum = 0;
if(buffer[0] > 2)
{
for(int idx=0;idx<(buffer[0]);idx++)
{
chksum ^= buffer[idx];
}
if(chksum == buffer[buffer[0]])
result = PASS;
}
return result;
}
bool getRequestCardSN(int Fd, int moduleType, RFID* rfid)
{
bool isSuccess = false;
if(ISO14443A_REQUEST_SN(Fd,moduleType,serialNumber) == true)
{
rfid->cardType = ISO14443A;
if(cardLength == LENGTH_4)
{
rfid->snType = RFID_SN_TYPE_4BYTE;
memcpy(rfid->currentCard, &serialNumber, 32);
}
else if(cardLength == LENGTH_7)
{
rfid->snType = RFID_SN_TYPE_7BYTE;
memcpy(rfid->currentCard, &serialNumber, 32);
}
isSuccess = true;
}
else if(ISO14443B_REQUEST_SN(Fd,moduleType,serialNumber) == true)
{
rfid->cardType = IS014443B;
rfid->snType = RFID_SN_TYPE_4BYTE;
memcpy(rfid->currentCard, &serialNumber, 32);
sleep(2);
isSuccess = true;
}
else if(FELICA_REQUEST_SN(Fd,moduleType,serialNumber) == true)
{
rfid->cardType = FELICA;
rfid->snType = RFID_SN_TYPE_6BYTE;
memcpy(rfid->currentCard, &serialNumber, 32);
sleep(2);
isSuccess = true;
}
else
{}
return isSuccess;
}
//==========================================
// ISO14443A Request SN function
//==========================================
bool ISO14443A_REQUEST_SN(int Fd, int moduleType, unsigned char *data)
{
bool isSuccess = false;
int tx_len = 4;
unsigned char txByte[4] = {0};
unsigned char rxByte[254] = {0};
unsigned char TX_MESSAGE[254] = {0};
unsigned char RX_MESSAGE[254] = {0};
unsigned char TMP_MESSAGE[254] = {0};
unsigned char TX_LENGTH = 0;
unsigned char RX_LENGTH = 0;
switch(moduleType)
{
case MODULE_EWT:
default:
//===============================
// Command
//===============================
txByte[0] = tx_len-1;
txByte[1] = RFID_CMD_ISO1443A_REQUEST;
txByte[2] = REQA;
txByte[ARRAY_SIZE(txByte)-1] = ClaCheckSum(txByte,ARRAY_SIZE(txByte));
if(Fd > 0)
{
if(system_command(Fd, txByte, tx_len, rxByte) > 0)
{
if(chksumValid(rxByte) == PASS)
{
if((rxByte[1] == RFID_CMD_ISO1443A_REQUEST))
{
if(rxByte[0] == 0x09)
{
cardLength = LENGTH_4;
memcpy(data, rxByte+2, cardLength);
DEBUG_INFO_1("MIFARE CLASSIC SN: %02X-%02X-%02X-%02X\n", data[0], data[1], data[2], data[3]);
isSuccess = true;
}
else if(rxByte[0] == 0x0C)
{
cardLength = LENGTH_7;
memcpy(data, rxByte+2, cardLength);
DEBUG_INFO_1("MIFARE PLUS SN: %02X-%02X-%02X-%02X-%02X-%02X-%02X\n", data[0], data[1], data[2], data[3], data[4], data[5], data[6]);
isSuccess = true;
}
else
{}
}
else if (rxByte[1] == 0xDF)
{
cardLength = LENGTH_0;
isSuccess = false;
}
else
{}
}
else
{
//DEBUG_ERROR_1("Response check sum mismatch.\n");
}
}
else
{}
}
else
{}
break;
case MODULE_REYAX:
if(Fd > 0)
{
memset(TX_MESSAGE, 0, sizeof(TX_MESSAGE));
memset(RX_MESSAGE, 0, sizeof(RX_MESSAGE));
strcpy((char*)TX_MESSAGE, "AT+SCAN=1\r\n");
TX_LENGTH = strlen((char*)TX_MESSAGE);
//DEBUG_INFO_1("ISO14443A TX_LENGTH : %d.\n", TX_LENGTH);
//DEBUG_INFO_1("ISO14443A TX_MESSAGE : %s.\n", TX_MESSAGE);
if((RX_LENGTH = at_command(Fd, TX_MESSAGE, TX_LENGTH, RX_MESSAGE)) > 0)
{
//DEBUG_INFO_1("ISO14443A RX_LENGTH : %d.\n", RX_LENGTH);
//DEBUG_INFO_1("ISO14443A RX_MESSAGE : %s.\n", RX_MESSAGE);
memset(TMP_MESSAGE, 0, sizeof(TMP_MESSAGE));
if(strstr((char*)RX_MESSAGE, "+SCAN=ISO14443A:"))
{
if(RX_LENGTH == 26)
{
cardLength = LENGTH_4;
memcpy(TMP_MESSAGE, RX_MESSAGE+16, (LENGTH_4*2));
DEBUG_INFO_1("Mifare Classic tmp message : %s.\n", TMP_MESSAGE);
sscanf((char*)TMP_MESSAGE, "%2X%2X%2X%2X", (unsigned int *)&data[0],
(unsigned int *)&data[1],
(unsigned int *)&data[2],
(unsigned int *)&data[3]);
isSuccess = true;
}
else if(RX_LENGTH == 32)
{
cardLength = LENGTH_7;
memcpy(TMP_MESSAGE, RX_MESSAGE+16, (RFID_SN_TYPE_7BYTE*2));
DEBUG_INFO_1("Mifare Plus tmp message : %s.\n", TMP_MESSAGE);
sscanf((char*)TMP_MESSAGE, "%2X%2X%2X%2X%2X%2X%2X", (unsigned int *)&data[0],
(unsigned int *)&data[1],
(unsigned int *)&data[2],
(unsigned int *)&data[3],
(unsigned int *)&data[4],
(unsigned int *)&data[5],
(unsigned int *)&data[6]);
isSuccess = true;
}
else
{
cardLength = LENGTH_0;
isSuccess = false;
}
}
else
{}
}
else
{}
}
else
{}
break;
}
return isSuccess;
}
//==========================================
// ISO14443B Request SN function
//==========================================
bool ISO14443B_REQUEST_SN(int Fd, int moduleType, unsigned char *data)
{
bool isSuccess = false;
int cardLength;
int tx_len = 5;
unsigned char txByte[5] = {0};
unsigned char rxByte[254] = {0};
/*
unsigned char TX_MESSAGE[254];
unsigned char RX_MESSAGE[254];
unsigned char TMP_MESSAGE[254];
unsigned char TX_LENGTH;
unsigned char RX_LENGTH;
*/
switch(moduleType)
{
case MODULE_EWT:
default:
//===============================
// Command
//===============================
txByte[0] = tx_len-1;
txByte[1] = RFID_CMD_ISO1443B_REQUEST;
txByte[2] = WUPA;
txByte[3] = AFI;
txByte[ARRAY_SIZE(txByte)-1] = ClaCheckSum(txByte,ARRAY_SIZE(txByte));
if(Fd > 0)
{
if(system_command(Fd, txByte, tx_len, rxByte) > 0)
{
if(chksumValid(rxByte) == PASS)
{
if((rxByte[1] == RFID_CMD_ISO1443B_REQUEST) && (rxByte[0] >= 12))
{
cardLength = LENGTH_4;
memcpy(data, rxByte+3, cardLength);
DEBUG_INFO_1("ISO14443-B SN: %02X-%02X-%02X-%02X\n", data[0], data[1], data[2], data[3]);
isSuccess = true;
}
else if(rxByte[1] == 0x9F)
{
cardLength = LENGTH_0;
isSuccess = false;
}
else
{}
}
else
{
//DEBUG_ERROR_1("Response check sum mismatch.\n");
}
}
else
{}
}
else
{}
break;
case MODULE_REYAX:
/*
if(Fd > 0)
{
memset(TX_MESSAGE, 0, sizeof(TX_MESSAGE));
memset(RX_MESSAGE, 0, sizeof(RX_MESSAGE));
strcpy((char*)TX_MESSAGE, "AT+SCAN=2\r\n");
TX_LENGTH = strlen((char*)TX_MESSAGE);
//DEBUG_INFO_1("IS014443B TX_LENGTH : %d.\n", TX_LENGTH);
//DEBUG_INFO_1("IS014443B TX_MESSAGE : %s.\n", TX_MESSAGE);
if((RX_LENGTH = at_command(Fd, TX_MESSAGE, TX_LENGTH, RX_MESSAGE);) > 0)
{
//DEBUG_INFO_1("IS014443B RX_LENGTH : %d.\n", RX_LENGTH);
//DEBUG_INFO_1("IS014443B RX MESSAGE : %s.\n", RX_MESSAGE);
memset(TMP_MESSAGE, 0, sizeof TMP_MESSAGE);
if(strstr((char*)RX_MESSAGE,"+SCAN=Felica:"))
{
if(RX_MESSAGE_LENGTH == 31)
{
cardLength = LENGTH_6;
memcpy(TMP_MESSAGE, RX_MESSAGE+17, (LENGTH_6*2));
DEBUG_INFO_1("IS014443B tmp message : %s...\n", TMP_MESSAGE);
sscanf((char*)TMP_MESSAGE, "%2X%2X%2X%2X%2X%2X", (unsigned int *)&data[0],
(unsigned int *)&data[1],
(unsigned int *)&data[2],
(unsigned int *)&data[3],
(unsigned int *)&data[4],
(unsigned int *)&data[5]);
isSuccess = true;
}
else
{
cardLength = LENGTH_0;
isSuccess = false;
}
}
else
{}
}
else
{}
}
else
{}
*/
break;
}
return isSuccess;
}
//==========================================
// FELICA Request SN function
//==========================================
bool FELICA_REQUEST_SN(int Fd, int moduleType, unsigned char *data)
{
bool isSuccess = false;
int cardLength;
int tx_len = 9;
unsigned char txByte[9] = {0};
unsigned char rxByte[254] = {0};
unsigned char TX_MESSAGE[254] = {0};
unsigned char RX_MESSAGE[254] = {0};
unsigned char TMP_MESSAGE[254] = {0};
unsigned char TX_LENGTH = 0;
unsigned char RX_LENGTH = 0;
switch(moduleType)
{
case MODULE_EWT:
default:
//===============================
// Command
//===============================
txByte[0] = tx_len-1;
txByte[1] = RFID_CMD_FELICA_POLLING_REQUEST;
txByte[2] = 0x06;
txByte[3] = 0x00;
txByte[4] = 0xFF;
txByte[5] = 0xFF;
txByte[6] = 0x01;
txByte[7] = 0x00;
txByte[ARRAY_SIZE(txByte)-1] = ClaCheckSum(txByte,ARRAY_SIZE(txByte));
if(Fd > 0)
{
memset(rxByte, 0, sizeof (rxByte));
if(system_command(Fd, txByte, tx_len, rxByte) > 0)
{
if(chksumValid(rxByte) == PASS)
{
if((rxByte[1] == RFID_CMD_FELICA_POLLING_REQUEST) && (rxByte[0] >= 22))
{
cardLength = LENGTH_6;
memcpy(data, rxByte+6, cardLength);
DEBUG_INFO_1("FELICA SN: %02X-%02X-%02X-%02X-%02X-%02X\n", data[0], data[1], data[2], data[3], data[4], data[5]);
isSuccess = true;
}
else if(rxByte[1] == 0xD0)
{
cardLength = LENGTH_0;
isSuccess = false;
}
else
{}
}
else
{
//DEBUG_ERROR_1("Response check sum mismatch.\n");
}
}
else
{}
}
else
{}
break;
case MODULE_REYAX:
if(Fd > 0)
{
memset(TX_MESSAGE, 0, sizeof(TX_MESSAGE));
memset(RX_MESSAGE, 0, sizeof(RX_MESSAGE));
strcpy((char*)TX_MESSAGE, "AT+SCAN=4\r\n");
TX_LENGTH = strlen((char*)TX_MESSAGE);
//DEBUG_INFO_1("FELICA TX_LENGTH : %d.\n", TX_LENGTH);
//DEBUG_INFO_1("FELICA TX_MESSAGE : %s.\n", TX_MESSAGE);
if((RX_LENGTH = at_command(Fd, TX_MESSAGE, TX_LENGTH, RX_MESSAGE)) > 0)
{
//DEBUG_INFO_1("FELICA RX_LENGTH : %d.\n", RX_LENGTH);
//DEBUG_INFO_1("FELICA RX_MESSAGE : %s.\n", RX_MESSAGE);
memset(TMP_MESSAGE, 0, sizeof(TMP_MESSAGE));
if(strstr((char*)RX_MESSAGE,"+SCAN=Felica:"))
{
if(RX_LENGTH == 31)
{
cardLength = LENGTH_6;
memcpy(TMP_MESSAGE, RX_MESSAGE+17, (LENGTH_6*2));
DEBUG_INFO_1("Felica tmp message : %s.\n", TMP_MESSAGE);
sscanf((char*)TMP_MESSAGE, "%2X%2X%2X%2X%2X%2X", (unsigned int *)&data[0],
(unsigned int *)&data[1],
(unsigned int *)&data[2],
(unsigned int *)&data[3],
(unsigned int *)&data[4],
(unsigned int *)&data[5]);
isSuccess = true;
}
else
{
cardLength = LENGTH_0;
isSuccess = false;
}
}
else
{}
}
else
{}
}
else
{}
break;
}
return isSuccess;
}
//==========================================
// Read block data from RFID card
//==========================================
bool getBlockRead(int Fd, int moduleType, int block, unsigned char keyId, unsigned char *data)
{
bool isSuccess = false;
int i;
int j = 0;
int len = 11;
unsigned char txByte[len];
unsigned char rxByte[254];
unsigned char tmp[254];
switch(moduleType)
{
case MODULE_EWT:
default:
//===============================
// Command
//===============================
txByte[0] = 0x0A;
txByte[1] = RFID_CMD_BLOCK_READ;
txByte[2] = keyId;
txByte[3] = block;
for(i = 4; i < 10; i++)
{
if( j < sizeof (sectorKeyA[0]))
{
txByte[i] = sectorKeyA[(int)(block/4)][j];
j++;
}
}
txByte[ARRAY_SIZE(txByte)-1] = ClaCheckSum(txByte,ARRAY_SIZE(txByte));
if(Fd > 0)
{
memset(rxByte, 0, sizeof(rxByte));
if(system_command(Fd, txByte, len, rxByte) > 0)
{
memset(tmp, 0, sizeof tmp);
memcpy(tmp, rxByte, sizeof (rxByte));
if((tmp[1] == RFID_CMD_BLOCK_READ))
{
DEBUG_INFO_1("Read block successfully.\n");
memcpy(data, rxByte+2, 16);
isSuccess = true;
}
else if (tmp[1] == 0xDE)
{
DEBUG_INFO_1("Read block unsuccessfully.\n");
}
else
{}
}
else
{}
}
else
{}
break;
}
return isSuccess;
}
//==========================================
// Write data into RFID card block
//==========================================
bool setBlockWrite(int Fd, int moduleType, int block, unsigned char keyid, unsigned char *data)
{
bool isSuccess = false;
int i;
int j = 0;
int len = 27;
unsigned char txByte[len];
unsigned char rxByte[254];
unsigned char tmp[254];
switch(moduleType)
{
case MODULE_EWT:
default:
//===============================
// Command
//===============================
txByte[0] = 0x1A;
txByte[1] = RFID_CMD_BLOCK_WRITE;
txByte[2] = keyid;
txByte[3] = block;
for(i = 4; i < 10; i++)
{
if( j < sizeof (sectorKeyA[0]))
{
txByte[i] = sectorKeyA[(int)(block/4)][j];
j++;
}
}
memcpy(txByte+10, data, 16);
txByte[ARRAY_SIZE(txByte)-1] = ClaCheckSum(txByte,(ARRAY_SIZE(txByte)));
if(Fd > 0)
{
memset(rxByte, 0, sizeof(rxByte));
if(system_command(Fd, txByte, len, rxByte) > 0)
{
memset(tmp, 0, sizeof tmp);
memcpy(tmp, rxByte, sizeof (rxByte));
if(tmp[1] == RFID_CMD_BLOCK_WRITE)
{
DEBUG_INFO_1("Write block successfully.\n");
isSuccess = true;
}
else if(tmp[1] == 0xDD)
{
DEBUG_INFO_1("Write block unsuccessfully.\n");
isSuccess = false;
}
else
{}
}
else
{}
}
else
{}
break;
}
return isSuccess;
}
//==========================================
// Buzzer set (EWT Module)
//==========================================
void setBuzzer(int Fd, int moduleType, unsigned char time)
{
int len = 4;
unsigned char txByte[len];
unsigned char rxByte[254];
unsigned char tmp[254];
switch(moduleType)
{
case MODULE_EWT:
default:
//===============================
// Command
//===============================
txByte[0] = 0x03;
txByte[1] = RFID_CMD_BUZZER_SET;
if(time > 0x0A)
{
time = 0x05;
txByte[2] = time;
DEBUG_WARN_1("Value is out of range.\n");
}
else
{
txByte[2] = time;
}
txByte[ARRAY_SIZE(txByte)-1] = ClaCheckSum(txByte,ARRAY_SIZE(txByte));
if(Fd > 0)
{
memset(rxByte, 0, sizeof(rxByte));
if(system_command(Fd, txByte, len, rxByte) > 0)
{
memset(tmp, 0, sizeof tmp);
memcpy(tmp, rxByte, sizeof (rxByte));
if(tmp[1] == 0x14)
{
DEBUG_INFO_1("Set Buzzer ok.\n");
DEBUG_INFO_1("Set Buzzer %d ms.\n",time);
}
else if(tmp[1] == 0xEC)
{
DEBUG_INFO_1("Set Buzzer fail.\n");
}
else
{}
}
else
{}
}
else
{}
break;
}
}
//==========================================
// Halt RFID card (EWT)
//==========================================
void sethaltCard(int Fd, int moduleType)
{
int len = 3;
unsigned char txByte[len];
unsigned char rxByte[254];
unsigned char tmp[254];
switch(moduleType)
{
case MODULE_EWT:
default:
//===============================
// Command
//===============================
txByte[0] = 0x02;
txByte[1] = RFID_CMD_HALT_14443A;
txByte[ARRAY_SIZE(txByte)-1] = ClaCheckSum(txByte,ARRAY_SIZE(txByte));
if(Fd > 0)
{
memset(rxByte, 0, sizeof(rxByte));
if(system_command(Fd, txByte, len, rxByte) > 0)
{
memset(tmp, 0, sizeof tmp);
memcpy(tmp, rxByte, sizeof (rxByte));
if(tmp[1] == 0x28)
{
DEBUG_INFO_1("Halt card pass.\n");
}
else if(tmp[1] == 0xD7)
{
DEBUG_INFO_1("Halt card fail.\n");
}
else
{}
}
else
{}
}
else
{}
break;
}
}
//==========================================
// Set the RF Output Level
//==========================================
bool setRfOutputLevel(int Fd, int moduleType, int Value)
{
bool isSuccess = false;
int len = 4;
unsigned char txByte[len];
unsigned char rxByte[254];
unsigned char tmp[254];
switch(moduleType)
{
case MODULE_EWT:
default:
//===============================
// Command
//===============================
txByte[0] = 0x03;
txByte[1] = RFID_CMD_RF_OUTPUT_LEVEL_SET;
txByte[2] = Value;
txByte[ARRAY_SIZE(txByte)-1] = ClaCheckSum(txByte,ARRAY_SIZE(txByte));
if(Fd > 0)
{
memset(rxByte, 0, sizeof(rxByte));
if(system_command(Fd, txByte, len, rxByte) > 0)
{
memset(tmp, 0, sizeof tmp);
memcpy(tmp, rxByte, sizeof (rxByte));
if(tmp[1] == RFID_CMD_RF_OUTPUT_LEVEL_SET)
{
DEBUG_INFO_1("Set the RF Output Level : Pass...\n");
if(Value == RF_STRONGEST)
{
DEBUG_INFO_1("Strongest...\n");
}
else if(Value == RF_STRONGER)
{
DEBUG_INFO_1("Strong...\n");
}
else if(Value == RF_WEAK)
{
DEBUG_INFO_1("Weak...\n");
}
else if(Value == RF_WEAKEST)
{
DEBUG_INFO_1("Weakest...\n");
}
isSuccess = true;
}
else if(tmp[1] == 0xFD)
{
DEBUG_INFO_1("Set the RF Output Level : Fail...\n");
DEBUG_INFO_1("Unknow value !!! \n");
DEBUG_INFO_1("Strongest : SET_RF_STRONGEST...\n");
DEBUG_INFO_1("Strong : SET_RF_STRONGER...\n");
DEBUG_INFO_1("Weak : SET_RF_WEAK...\n");
DEBUG_INFO_1("Weakest : SET_RF_WEAKEST...\n");
isSuccess = false;
}
else
{}
}
else
{}
}
else
{}
break;
}
return isSuccess;
}
//==========================================
// Set the Default of Automatic Detecting Card
//==========================================
bool setDefaultOfAutomaticDetectingCard(int Fd, int moduleType, int Value)
{
bool isSuccess = false;
int len = 4;
unsigned char txByte[len];
unsigned char rxByte[254];
unsigned char tmp[254];
switch(moduleType)
{
case MODULE_EWT:
default:
//===============================
// Command
//===============================
txByte[0] = 0x03;
txByte[1] = RFID_CMD_DEFAULT_AUTO_DETECTING_CARD;
txByte[2] = Value;
txByte[ARRAY_SIZE(txByte)-1] = ClaCheckSum(txByte,ARRAY_SIZE(txByte));
if(Fd > 0)
{
memset(rxByte, 0, sizeof(rxByte));
if(system_command(Fd, txByte, len, rxByte) > 0)
{
memset(tmp, 0, sizeof tmp);
memcpy(tmp, rxByte, sizeof (rxByte));
if(tmp[1] == RFID_CMD_DEFAULT_AUTO_DETECTING_CARD)
{
if(Value == TURN_OFF)
{
DEBUG_INFO_1("Default of Automatic Detecting Card : OFF...\n");
}
else if (Value == TURN_ON)
{
DEBUG_INFO_1("Default of Automatic Detecting Card : ON...\n");
}
else if (Value == TURN_TEMPORARILY)
{
DEBUG_INFO_1("Default of Automatic Detecting Card : Temporarily open and close automatically detect card...\n");
}
isSuccess = true;
}
else if(tmp[1] == 0xE2)
{
DEBUG_INFO_1("Value : SET_DETECTING_OFF = OFF...\n");
DEBUG_INFO_1("Value : SET_DETECTING_ON = ON...\n");
DEBUG_INFO_1("Value : SET_DETECTING_TEMPORARILY = Temporarily open and close...\n");
isSuccess = false;
}
else
{}
}
else
{}
}
else
{}
break;
}
return isSuccess;
}