Add portable NFC module

This commit is contained in:
2026-07-20 10:48:38 +08:00
commit 4ed123f87c
25 changed files with 3965 additions and 0 deletions

328
nfc/vendor/dp1312ea/Antcoll.c vendored Normal file
View File

@@ -0,0 +1,328 @@
#include <string.h>
#include <stdio.h>
#include "DP1312EA_Config.h"
#include "DP1312EA.h"
#include "TypeA.h"
#include "nfc_platform.h"
// 定义卡片状态
typedef enum {
CARD_STATE_IDLE,
CARD_STATE_READY,
CARD_STATE_ACTIVE,
CARD_STATE_HALT
} CardState;
// 卡片信息结构
typedef struct {
uint8_t uid[10]; // UID (4,7或10字节)
uint8_t uid_len; // UID长度
CardState state; // 卡片状态
} CardInfo;
// 系统参数
#define MAX_CARDS 10 // 最大检测卡片数量
CardInfo detectedCards[MAX_CARDS];
uint8_t cardCount = 0;
// 函数声明
void DP1312EA_Config(void);
uint8_t DP1312EA_Transceive(uint8_t *send, uint8_t sendLen, uint8_t *recv, uint8_t *recvLen);
uint8_t DP1312EA_Request(uint8_t cmd, uint8_t *atq);
uint8_t DP1312EA_Anticollision(uint8_t level, uint8_t *uid, uint8_t *uid_len);
uint8_t DP1312EA_Select(uint8_t level, uint8_t *uid, uint8_t uid_len, uint8_t *sak);
uint8_t DP1312EA_Halt(void);
void DP1312EA_HandleCollision(uint8_t *uid, uint8_t uid_len, uint8_t level);
void FindAllCards(void);
int TypeA_AntiColl(void);
// DP1312EA初始化
void DP1312EA_Config(void) {
DP1312EA_Reset();
// 配置DP1312EA寄存器
DP1312EA_PcdConfigISOType('A');
DP1312EA_FieldOn();
nfc_platform_sleep_ms(10);
}
// 发送和接收数据
uint8_t DP1312EA_Transceive(uint8_t *send, uint8_t sendLen, uint8_t *recv, uint8_t *recvLen) {
// 清除FIFO
DP1312EA_WriteRawRC(0x01, DP1312EA_IDLE);
DP1312EA_WriteRawRC(0x01, DP1312EA_MEM);
// 写入发送数据
DP1312EA_WriteFIFO(send, sendLen);
// 启动传输
DP1312EA_WriteRawRC(0x01, DP1312EA_TRANSCEIVE);
DP1312EA_WriteRawRC(0x0D, 0x30); // 启用发送和接收
// 等待传输完成
uint16 timeout = 2000; // 超时时间
while (!(DP1312EA_ReadRawRC(0x04) & 0x30) ){ // 等待TxIRq或RxIRq
if (--timeout == 0) {
DP1312EA_WriteRawRC(0x01, DP1312EA_IDLE); // 停止传输
return 1; // 超时错误
}
//nfc_platform_sleep_ms(1);
//Delay_us(100);
}
// 检查错误
if (DP1312EA_ReadRawRC(0x06) & 0x13) { // 检查错误标志
DP1312EA_WriteRawRC(0x01, DP1312EA_IDLE);
return 2; // 通信错误
}
// 读取接收数据
*recvLen = DP1312EA_ReadRawRC(0x0A); // FIFOLevel
if (*recvLen > 0) {
DP1312EA_ReadFIFO(recv, *recvLen);
}
DP1312EA_WriteRawRC(0x01, DP1312EA_IDLE);
return 0; // 成功
}
// 请求阶段
uint8_t DP1312EA_Request(uint8_t cmd, uint8_t *atq) {
uint8_t response[2];
uint8_t resLen = 2;
uint8_t status = DP1312EA_Transceive(&cmd, 1, response, &resLen);
if (status == 0 && resLen == 2) {
atq[0] = response[0];
atq[1] = response[1];
return 1; // 成功
}
return 0; // 失败
}
// 防冲突函数
uint8_t DP1312EA_Anticollision(uint8_t level, uint8_t *uid, uint8_t *uid_len) {
uint8_t anticoll_cmd;
uint8_t nvb;
switch(level) {
case 0:
anticoll_cmd = PICC_ANTICOLL1;
nvb = 0x20; // 32位
break;
case 1:
anticoll_cmd = PICC_ANTICOLL2;
nvb = 0x20; // 32位
break;
case 2:
anticoll_cmd = PICC_ANTICOLL3;
nvb = 0x20; // 32位
break;
default:
return 0;
}
uint8_t sendBuf[2] = {anticoll_cmd, nvb};
uint8_t recvBuf[10]; // 最大UID长度+1
uint8_t recvLen = sizeof(recvBuf);
uint8_t status = DP1312EA_Transceive(sendBuf, 2, recvBuf, &recvLen);
if (status != 0 || recvLen < 5) { // 至少4字节UID+1字节BCC
return 0; // 失败
}
// 检查冲突
if (DP1312EA_ReadRawRC(0x06) & 0x08) { // CollErr标志
return 2; // 冲突
}
// 计算BCC
uint8_t bcc = 0;
for (uint8_t i = 0; i < recvLen - 1; i++) {
bcc ^= recvBuf[i];
}
if (bcc != recvBuf[recvLen-1]) {
return 0; // BCC错误
}
// 复制UID
*uid_len = recvLen - 1;
memcpy(uid, recvBuf, *uid_len);
return 1; // 成功
}
// 选择卡片
uint8_t DP1312EA_Select(uint8_t level, uint8_t *uid, uint8_t uid_len, uint8_t *sak) {
uint8_t select_cmd;
switch(level) {
case 0: select_cmd = SELECT_0; break;
case 1: select_cmd = SELECT_1; break;
case 2: select_cmd = SELECT_2; break;
default: return 0;
}
uint8_t sendBuf[10]; // SEL + NVB + UID + BCC
uint8_t sendLen = 0;
sendBuf[sendLen++] = select_cmd;
sendBuf[sendLen++] = 0x70; // NVB=64位
uint8_t bcc = 0;
for (uint8_t i = 0; i < uid_len; i++) {
sendBuf[sendLen++] = uid[i];
bcc ^= uid[i];
}
sendBuf[sendLen++] = bcc;
uint8_t response[3];
uint8_t resLen = sizeof(response);
if (DP1312EA_Transceive(sendBuf, sendLen, response, &resLen) != 0 || resLen < 1) {
return 0; // 失败
}
*sak = response[0];
return 1; // 成功
}
// 休眠卡片
uint8_t DP1312EA_Halt(void) {
uint8_t halt_cmd[4] = {PICC_HALT, 0, 0, 0}; // CRC由DP1312EA计算
uint8_t resLen = 0;
return (DP1312EA_Transceive(halt_cmd, 4, NULL, &resLen) == 0);
}
// 处理冲突
void DP1312EA_HandleCollision(uint8_t *uid, uint8_t uid_len, uint8_t level) {
uint8_t coll_pos = DP1312EA_ReadRawRC(BitFramingReg) & 0x1F;
uint8_t bit_pos = coll_pos % 8;
uint8_t byte_pos = coll_pos / 8;
// 确定冲突位的位置
// uint8_t collision_byte = uid[byte_pos];
// 尝试两种可能的值 (0和1)
for (uint8_t bit_value = 0; bit_value <= 1; bit_value++) {
// 创建新的UID分支
uint8_t new_uid[10];
memcpy(new_uid, uid, uid_len);
// 设置冲突位的值
if (bit_value) {
new_uid[byte_pos] |= (1 << bit_pos);
} else {
new_uid[byte_pos] &= ~(1 << bit_pos);
}
// 尝试防冲突
uint8_t status = DP1312EA_Anticollision(level, new_uid, &uid_len);
if (status == 1) {
// 成功获取UID
uint8_t sak;
if (DP1312EA_Select(level, new_uid, uid_len, &sak)) {
// 检查SAK的UID完整标志
if (sak & 0x04) {
// UID完整存储卡片
if (cardCount < MAX_CARDS) {
memcpy(detectedCards[cardCount].uid, new_uid, uid_len);
detectedCards[cardCount].uid_len = uid_len;
detectedCards[cardCount].state = CARD_STATE_ACTIVE;
cardCount++;
}
// 使卡片休眠
DP1312EA_Halt();
} else {
// UID不完整进入下一级防冲突
DP1312EA_HandleCollision(new_uid, uid_len, level + 1);
}
}
} else if (status == 2) {
// 仍有冲突,递归处理
DP1312EA_HandleCollision(new_uid, uid_len, level);
}
}
}
// 完整的防冲突流程
void FindAllCards(void) {
cardCount = 0; // 重置卡片计数
// 1. 发送REQA唤醒卡片
uint8_t atq[2];
if (!DP1312EA_Request(PICC_REQIDL, atq)) {
return; // 没有卡片
}
// 2. 初始防冲突循环
uint8_t uid[10];
uint8_t uid_len;
uint8_t status;
while (cardCount < MAX_CARDS) {
status = DP1312EA_Anticollision(0, uid, &uid_len);
if (status == 1) {
// 成功获取UID
uint8_t sak;
if (DP1312EA_Select(0, uid, uid_len, &sak)) {
// 检查SAK的UID完整标志
if (sak & 0x04) {
// UID完整存储卡片
memcpy(detectedCards[cardCount].uid, uid, uid_len);
detectedCards[cardCount].uid_len = uid_len;
detectedCards[cardCount].state = CARD_STATE_ACTIVE;
cardCount++;
// 使卡片休眠
DP1312EA_Halt();
} else {
// UID不完整进入下一级防冲突
DP1312EA_HandleCollision(uid, uid_len, 1);
}
}
} else if (status == 2) {
// 冲突发生,处理冲突
DP1312EA_HandleCollision(uid, uid_len, 0);
} else {
// 没有更多卡片
break;
}
}
}
// 主函数
int TypeA_AntiColl(void) {
DP1312EA_Config();
while (1) {
FindAllCards();
if (cardCount > 0) {
// 处理所有检测到的卡片
for (uint8_t i = 0; i < cardCount; i++) {
// 打印UID
nfc_platform_log("Card %d UID: ", i);
for (uint8_t j = 0; j < detectedCards[i].uid_len; j++) {
nfc_platform_log("%02X ", detectedCards[i].uid[j]);
}
nfc_platform_log("\n");
}
}
//Delay_ms(500); // 延时后再检测
}
}

26
nfc/vendor/dp1312ea/DP1312EA.h vendored Normal file
View File

@@ -0,0 +1,26 @@
#ifndef DP1312EA_DRIVER_H
#define DP1312EA_DRIVER_H
#include <stdint.h>
#include "nfc.h"
#include "reg.h"
void DP1312EA_SetBitMask(u8 reg, u8 mask);
void DP1312EA_ClearBitMask(u8 reg, u8 mask);
void DP1312EA_WriteRawRC(u8 address, u8 value);
u8 DP1312EA_ReadRawRC(u8 address);
void Check_Chip(void);
void DP1312EA_Reset(void);
void DP1312EA_Enable(void);
void DP1312EA_Disable(void);
s8 DP1312EA_PcdComTransceive(struct TranSciveBuffer *pi);
void DP1312EA_WriteFIFO(uint8_t *data, uint8_t len);
void DP1312EA_ReadFIFO(uint8_t *buf, uint8_t len);
void DP1312EA_FieldOn(void);
void DP1312EA_FieldOff(void);
uint32_t nfc_dp1312ea_get_reset_pin(void);
#endif

74
nfc/vendor/dp1312ea/DP1312EA_Config.h vendored Normal file
View File

@@ -0,0 +1,74 @@
#ifndef __DP1312EA_Config_H
#define __DP1312EA_Config_H
//set IRQ LEVEL
#define IRQ_HIGH_LEVEL 1 //set high level irq
#define IRQ_LOW_LEVEL 2 //set low level irq
#define IRQ_LEVEL_SET IRQ_HIGH_LEVEL //设为低电平
//set irq output mode
#define IRQ_OUT_PP 1 //set IRQ CMOS ouput
#define IRQ_OUT_OD 2 //set IRQ OPEN drain
#define IRQ_OUT_MODE IRQ_OUT_PP //中断输出设置为CMOS
//sensitive adjust, 0-8
#define SENSITIVE_MIN 0
#define SENSITIVE_SEC 2
#define SENSITIVE_MID 4
#define SENSITIVE_SIX 6
#define SENSITIVE_MAX 8
#define LPCD_Sensitive_Value SENSITIVE_MIN //灵敏度设置
/* set check cycle */
#define CHECK_PERIOD_110MS 0x08ff //110ms +-12%
#define CHECK_PERIOD_220MS 0x10ff //220ms +-12%
#define CHECK_PERIOD_330MS 0x1aff //330ms +-12%
#define CHECK_PERIOD_430MS 0x22ff //430ms +-12%
/*设置LPCD检测周期*/
#define LPCD_Cycle_Time CHECK_PERIOD_220MS //430ms
/* set LPCD check time */
#define CHECK_TIME_10US 0x007f //10us
#define CHECK_TIME_05US 0x003f //5us
#define CHECK_TIME_20US 0x00ff //20us
/*选择检卡时长*/
#define LPCD_Duration_Time CHECK_TIME_05US //5us
/* 读卡寄存器配置,不同的天线适配不同的配置,选择最优的定义 */
#define REG_SET_1 1 //A卡寄存配置1
#define REG_SET_2 2 //A卡寄存配置2
#define REG_SET_3 3 //A卡寄存配置3
#define REG_SET_4 4 //A卡寄存配置4
#define TYPEA_REG_CONFIG REG_SET_1 //选择寄存器配置1
/* 通讯接口定义 */
#define INTERFACE_SPI 1
#define INTERFACE_I2C 2
#define INTERFACE_UART 3
/* 通讯接口选择 */
#define HOSTINTERFACE INTERFACE_I2C //SPI接口
/*调试信息是否通过口口打印定义,有定义则打印,无定义则不打印*/
//#define UART_DEBUG
#endif
/***********************************************END*******************************************************/

199
nfc/vendor/dp1312ea/Felica.c vendored Normal file
View File

@@ -0,0 +1,199 @@
/***********************************************************************************************
*FeliCa操作函数文件
***********************************************************************************************/
#include <stdio.h>
#include <string.h>
#include "DP1312EA.h"
#include "DP1312EA_Config.h"
#include "Felica.h"
#include "nfc_platform.h"
void ReadmoniF(void)
{
s8 status;
u8 i;
u8 IDm[10],PMm[8];
DP1312EA_PcdConfigISOTypeF();
nfc_platform_sleep_ms(10);
status = DP1312EA_PcdRequestF(IDm,PMm);
#ifdef UART_DEBUG
nfc_platform_log("ATQF: %d_",status);
if(status==MI_OK)
{
for(i=0;i<10;i++)
nfc_platform_log(" %02X ",IDm[i]);
nfc_platform_log("_");
for(i=0;i<8;i++)
nfc_platform_log(" %02X",PMm[i]);
}
nfc_platform_log("\n");
#endif
if(status!=MI_OK) return;
}
/***********************************************************************************************
*配置为FeliCa卡
***********************************************************************************************/
void DP1312EA_PcdConfigISOTypeF(void)
{
DP1312EA_ClearBitMask(Status2Reg,0x08);//08h //MFCrypto1On
DP1312EA_WriteRawRC(WaterLevelReg,0x10); //0bh,
DP1312EA_WriteRawRC(ControlReg,0x10);//0ch, //Initiator
DP1312EA_WriteRawRC(BitFramingReg,0); //0dh,
DP1312EA_WriteRawRC(ModeReg,0x00);//11h, *00*
DP1312EA_WriteRawRC(TxModeReg,0x92); //12h, 212k
DP1312EA_WriteRawRC(RxModeReg,0x92); //13h, 212k
//DP1312EA_WriteRawRC(TxModeReg,0xa2); //12h 424k
//DP1312EA_WriteRawRC(RxModeReg,0xa2);//13h 424k
DP1312EA_WriteRawRC(TxControlReg,0x80);//14h,
DP1312EA_WriteRawRC(TxAutoReg,0x00); //15h,
DP1312EA_WriteRawRC(TxSelReg,0x10);//16h
DP1312EA_WriteRawRC(RxSelReg,0x83);//17h
DP1312EA_WriteRawRC(RxThresholdReg,0x55); //18h
DP1312EA_WriteRawRC(DemodReg,0x6D); //19h
DP1312EA_WriteRawRC(TypeBReg,0); //1eh,
DP1312EA_WriteRawRC(GsNOffReg,0xF2); //23h
DP1312EA_WriteRawRC(ModWidthReg,0x26); //24h,
DP1312EA_WriteRawRC(RFCfgReg,0x78); //26h
DP1312EA_WriteRawRC(GsNOnReg,0xFF); //27h
DP1312EA_WriteRawRC(CWGsPReg,0x3f); //28h
DP1312EA_WriteRawRC(ModGsPReg,0x12); //29h
DP1312EA_WriteRawRC(TModeReg,0x8D); //2ah
DP1312EA_WriteRawRC(TPrescalerReg,0x00); //2bh
DP1312EA_FieldOff();
nfc_platform_sleep_ms(5);
DP1312EA_FieldOn();
}
s8 DP1312EA_PcdRequestF(u8 *pIDm,u8 *pPMm)
{
s8 status;
struct TranSciveBuffer MfComData,*pi = &MfComData;
DP1312EA_WriteRawRC(TPrescalerReg,0x01); //2bh,
DP1312EA_WriteRawRC(TModeReg,0x80); //2ah,
DP1312EA_WriteRawRC(TReloadRegL,0xEC);//2dh,
DP1312EA_WriteRawRC(TReloadRegH,0x5C); //2ch,
MfComData.MfCommand = DP1312EA_TRANSCEIVE;
MfComData.MfLength =6;
MfComData.MfData[0] =0x06;
MfComData.MfData[1] =0;
MfComData.MfData[2] =0xFF;
MfComData.MfData[3] =0xFF;
MfComData.MfData[4] =0;
MfComData.MfData[5] =0;
// FLAG_0;
status = DP1312EA_PcdComTransceive(pi);
// FLAG_1;
if (status == MI_OK)
{
if(MfComData.MfLength == 0x90)
{
memcpy(pIDm, &MfComData.MfData[2], 8);
memcpy(pPMm, &MfComData.MfData[10], 8);
}
else
status = MI_VALERR;
}
return status;
}
s8 DP1312EA_PcdReadF(u8 *pIDm,u8 *pDat)
{
s8 status;
struct TranSciveBuffer MfComData,*pi= &MfComData;
MfComData.MfCommand = DP1312EA_TRANSCEIVE;
MfComData.MfLength = 16;
MfComData.MfData[0] = 0x10; //len
MfComData.MfData[1] = 0x06;
memcpy(&MfComData.MfData[2],pIDm, 8);
MfComData.MfData[10] = 1; //bNumServices
MfComData.MfData[11] = 0x0B; //pServiceList..
MfComData.MfData[12] = 0;
MfComData.MfData[13] = 1; //read how much number of block
MfComData.MfData[14] = 0x80; //pBlockList..
MfComData.MfData[15] = 0x01;
status = DP1312EA_PcdComTransceive(pi);
if (status == MI_OK)
{
if(MfComData.MfLength == 0xE8)
{
memcpy(pDat, &MfComData.MfData[13], 16);
}
else
status = MI_VALERR;
}
return status;
}
/***********************************************************************************************
*检测并读取FeliCa卡函数
***********************************************************************************************/
void DP1312EA_Felica(void)
{
s8 status;
u8 i;
u8 IDm[8],PMm[8],buf[16];
DP1312EA_Reset();
DP1312EA_PcdConfigISOTypeF();
nfc_platform_sleep_ms(10);
status = DP1312EA_PcdRequestF(IDm,PMm);
#ifdef UART_DEBUG
nfc_platform_log("ATQF: %d_",status);
if(status==MI_OK)
{
for(i=0;i<8;i++)
nfc_platform_log(" %02X ",IDm[i]);
nfc_platform_log("_");
for(i=0;i<8;i++)
nfc_platform_log(" %02X",PMm[i]);
}
nfc_platform_log("\n");
#endif
if(status!=MI_OK) return;
status = DP1312EA_PcdReadF(IDm,buf);
#ifdef UART_DEBUG
nfc_platform_log("Read: %d_",status);
if(status==MI_OK)
{
for(i=0;i<16;i++)
nfc_platform_log(" %02X",buf[i]);
}
nfc_platform_log("\n");
#endif
if(status!=MI_OK) return;
do
{
DP1312EA_FieldOff();
nfc_platform_sleep_ms(10);
DP1312EA_FieldOn();
//LED_1;
nfc_platform_sleep_ms(10);
status = DP1312EA_PcdRequestF(IDm,PMm);
if(status==MI_OK){
// LED_0;
}
else
break;
}while(status==MI_OK);
}
/***********************************************END*******************************************************/

15
nfc/vendor/dp1312ea/Felica.h vendored Normal file
View File

@@ -0,0 +1,15 @@
#ifndef __FELICA_H
#define __FELICA_H
#include "nfc.h"
#include "reg.h"
void DP1312EA_Felica(void);
void DP1312EA_PcdConfigISOTypeF(void);
s8 DP1312EA_PcdRequestF(u8 *pIDm,u8 *pPMm);
s8 DP1312EA_PcdReadF(u8 *pIDm,u8 *pDat);
void ReadmoniF(void);
#endif
/***********************************************END*******************************************************/

227
nfc/vendor/dp1312ea/LPCD.c vendored Normal file
View File

@@ -0,0 +1,227 @@
/***********************************************************************************************
*LPCD<43><44><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD>
***********************************************************************************************/
#include <stdio.h>
#include "DP1312EA_Config.h"
#include "DP1312EA.h"
#include "LPCD.h"
#include "nfc_platform.h"
extern u8 Status_INT;
/***********************************************************************************************
*дLPCD<43>Ĵ<EFBFBD><C4B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ĵ<EFBFBD><C4B4><EFBFBD><EFBFBD><EFBFBD>ַ<EFBFBD><D6B7>Ҫд<D2AA><D0B4>ֵ
***********************************************************************************************/
void write_Lpcd_reg(u8 reg,u8 value)
{
DP1312EA_WriteRawRC(0x37,0xa0);
DP1312EA_WriteRawRC(0x0f,reg);
DP1312EA_WriteRawRC(0x37,0xa1);
DP1312EA_WriteRawRC(0x0f,value);
}
/***********************************************************************************************
*<2A><>ȡLPCD<43>Ĵ<EFBFBD><C4B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ĵ<EFBFBD><C4B4><EFBFBD><EFBFBD><EFBFBD>ַ,<2C><><EFBFBD>ض<EFBFBD>ȡ<EFBFBD><C8A1>ֵ
***********************************************************************************************/
u8 read_Lpcd_reg(u8 reg)
{
u8 value;
DP1312EA_WriteRawRC(0x37,0xa0);
DP1312EA_WriteRawRC(0x0f,reg);
DP1312EA_WriteRawRC(0x37,0xa1);
value = DP1312EA_ReadRawRC(0x0f);
return value;
}
/***********************************************************************************************
*<2A><>ȡLPCD Iͨ<49><CDA8><EFBFBD>Ĵ<EFBFBD><C4B4><EFBFBD>ֵ
***********************************************************************************************/
u8 Read_I_Channel(void)
{
u8 i;
DP1312EA_WriteRawRC(0x37,0xa0);
DP1312EA_WriteRawRC(0x0f,0x05);
DP1312EA_WriteRawRC(0x37,0xa1);
i = DP1312EA_ReadRawRC(0x0f); //LPCD_RI
return i;
}
/***********************************************************************************************
*<2A><>ȡLPCD Qͨ<51><CDA8><EFBFBD>Ĵ<EFBFBD><C4B4><EFBFBD>ֵ
***********************************************************************************************/
u8 Read_Q_Channel(void)
{
u8 q;
DP1312EA_WriteRawRC(0x37,0xa0);
DP1312EA_WriteRawRC(0x0f,0x06);
DP1312EA_WriteRawRC(0x37,0xa1);
q = DP1312EA_ReadRawRC(0x0f); //LPCD_RQ
return q;
}
/***********************************************************************************************
*<2A><><EFBFBD><EFBFBD>LPCD I/Qͨ<51><CDA8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵ
***********************************************************************************************/
void set_I_Q_threshold(u8 I_value,u8 Q_value)
{
u8 I_MIN,I_MAX;
u8 Q_MIN,Q_MAX;
if((I_value>=LPCD_Sensitive_Value)&&(Q_value>=LPCD_Sensitive_Value))
{
I_MIN = I_value - LPCD_Sensitive_Value;
I_MAX = I_value + LPCD_Sensitive_Value;
Q_MIN = Q_value - LPCD_Sensitive_Value;
Q_MAX = Q_value + LPCD_Sensitive_Value;
}
else
{
I_MIN = 0x9c;
I_MAX = 0x9c;
Q_MIN = 0x7c;
Q_MAX = 0x7c;
}
write_Lpcd_reg(0x01,I_MAX);
write_Lpcd_reg(0x02,I_MIN);
write_Lpcd_reg(0x03,Q_MAX);
write_Lpcd_reg(0x04,Q_MIN);
}
/***********************************************************************************************
*<2A><>ֹLPCD<43><44><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ѻ<EFBFBD><D1BA><EFBFBD><EFBFBD><EFBFBD>û<EFBFBD>и<EFBFBD>λ<EFBFBD><CEBB><EFBFBD><EFBFBD>оƬ<D0BE><C6AC><EFBFBD><EFBFBD>Ҫ<EFBFBD><D2AA><EFBFBD><EFBFBD>ǰ<EFBFBD>Ƚ<EFBFBD>ֹLPCD<43><44><EFBFBD><EFBFBD>
***********************************************************************************************/
void DP1312EA_LPCD_Stop(void)
{
DP1312EA_WriteRawRC(0x37,0xa0);
DP1312EA_WriteRawRC(0x0f,0x00);
DP1312EA_WriteRawRC(0x37,0xa1);
DP1312EA_WriteRawRC(0x0f,0x00);
}
/***********************************************************************************************
*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>оƬLPCD<43>жϱ<D0B6>־λ
***********************************************************************************************/
void Clear_lpcd_irq(void)
{
DP1312EA_WriteRawRC(DivIrqReg,0x20); //<2F><><EFBFBD>жϱ<D0B6><CFB1><EFBFBD>
}
/**********************************************************************************************************
*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ƣ<EFBFBD>void DP1312EA_LPCD_Enter(u16 cycle,u16 duration )
*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
<20><><EFBFBD>ò<EFBFBD><C3B2><EFBFBD><EFBFBD><EFBFBD>LPCDģʽ<C4A3><CABD><EFBFBD>в<EFBFBD><D0B2><EFBFBD>˳<EFBFBD><CBB3>Ҫ<EFBFBD>󣬲<EFBFBD>Ҫ<EFBFBD>Ķ<EFBFBD><C4B6><EFBFBD><EFBFBD><EFBFBD>˳<EFBFBD><CBB3><EFBFBD><EFBFBD>
*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
cycle<6C><65><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ڣ<EFBFBD>16λ<36><CEBB>Ĭ<EFBFBD><C4AC>0x22ff<66><66>380ms<6D><73><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Լ10%<25><>
duration<6F><6E><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD>16λ<36><CEBB>Ĭ<EFBFBD><C4AC>0x001f<31><66>2.5us<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ѡ0x003f=5us,0x007f=10us<75><73>
*<2A><><EFBFBD>ز<EFBFBD><D8B2><EFBFBD><EFBFBD><EFBFBD>
<20><>
*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
IRQ<52>жϣ<D0B6>1)<29><>ѡCMOS<4F><53><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>©<EFBFBD><C2A9><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>©<EFBFBD><C2A9><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>裻2)<29><>ѡ<EFBFBD>ߵ<EFBFBD>ƽ<EFBFBD>жϻ<D0B6><CFBB>͵<EFBFBD>ƽ<EFBFBD>жϣ<D0B6>
**********************************************************************************************************/
void DP1312EA_LPCD_Enter(u16 cycle,u16 duration )
{
u8 i,q,n;
n = DP1312EA_ReadRawRC(0x0c);
DP1312EA_WriteRawRC(0x0c, n|0x10);
//DP1312EA_WriteRawRC(0x28,0x02); //<2F>Ӳ<EFBFBD><D3B2><EFBFBD>Ч<EFBFBD><D0A7><EFBFBD><EFBFBD><EFBFBD><EFBFBD>,<2C><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
/*set IRQ int level*/
#if (IRQ_LEVEL_SET == IRQ_HIGH_LEVEL)
DP1312EA_WriteRawRC(ComIEnReg,0x00); //ComIEnReg<65><67>bit7 <20><>0<EFBFBD><30><EFBFBD>ߵ<EFBFBD>ƽ<EFBFBD>ж<EFBFBD>
#else
DP1312EA_WriteRawRC(ComIEnReg,0x80); //ComIEnReg<65><67>bit7 <20><>1<EFBFBD><31><EFBFBD>͵<EFBFBD>ƽ<EFBFBD>ж<EFBFBD>
#endif
/*set IRQ Output Mode*/
#if (IRQ_OUT_MODE == IRQ_OUT_PP)
DP1312EA_WriteRawRC(DivlEnReg,0xE0); //bit7=1<><31><EFBFBD><EFBFBD>ΪCMOS<4F><53><EFBFBD><EFBFBD><EFBFBD><EFBFBD>bit5=1 LPCD<43>ж<EFBFBD>ʹ<EFBFBD><CAB9>
#else
DP1312EA_WriteRawRC(DivlEnReg,0x60); //bit7=0<><30><EFBFBD><EFBFBD>ΪOPEN DRAIN<49><4E><EFBFBD><EFBFBD><EFBFBD><EFBFBD>bit5=1 LPCD<43>ж<EFBFBD>ʹ<EFBFBD><CAB9>
#endif
DP1312EA_WriteRawRC(DivIrqReg,0x7F); //<2F><><EFBFBD>жϱ<D0B6><CFB1><EFBFBD>
//<2F><><EFBFBD>ü<EFBFBD><C3BC><EFBFBD>ʱ<EFBFBD><CAB1>
write_Lpcd_reg(0x08,(u8)(duration>>8)); //ʱ<><CAB1><EFBFBD><EFBFBD>λ<EFBFBD>Ĵ<EFBFBD><C4B4><EFBFBD>
write_Lpcd_reg(0x09,(u8)duration); //ʱ<><CAB1><EFBFBD><EFBFBD>λ<EFBFBD>Ĵ<EFBFBD><C4B4><EFBFBD>
//<2F><><EFBFBD>ü<EFBFBD><C3BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
write_Lpcd_reg(0x0a,0x00); //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ڸ<EFBFBD>λ<EFBFBD>Ĵ<EFBFBD><C4B4><EFBFBD>
write_Lpcd_reg(0x0b,0xff); //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ڵ<EFBFBD>λ<EFBFBD>Ĵ<EFBFBD><C4B4><EFBFBD>
//׼<><D7BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>1
write_Lpcd_reg(0x01,0xf0); //LPCD<43><44><EFBFBD><EFBFBD><EFBFBD>Ĵ<EFBFBD><C4B4><EFBFBD>
write_Lpcd_reg(0x02,0x00);
write_Lpcd_reg(0x03,0xf0); //LPCD<43><44><EFBFBD><EFBFBD><EFBFBD>Ĵ<EFBFBD><C4B4><EFBFBD>
write_Lpcd_reg(0x04,0x00);
//ʹ<><CAB9>LPCD<43><44><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ҫ<EFBFBD>ֿ<EFBFBD>
write_Lpcd_reg(0x00,0x50); //enable LPCD
//<2F><><EFBFBD><EFBFBD>LPCD
write_Lpcd_reg(0x00,0xd0); //start LPCD
//<2F><>ȡ<EFBFBD><C8A1><EFBFBD>ƼĴ<C6BC><C4B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>DZ<EFBFBD><C7B1><EFBFBD><EFBFBD>ģ<EFBFBD>Ϊ<EFBFBD>˹۲<CBB9>
n=read_Lpcd_reg(0x00);
#ifdef UART_DEBUG
nfc_platform_log("lpcd_00reg = %02x \n",n);
#endif
nfc_platform_sleep_ms(5);
//<2F><><EFBFBD><EFBFBD><EFBFBD>ز<EFBFBD><D8B2><EFBFBD><EFBFBD>ȴ<EFBFBD>һ<EFBFBD><D2BB>У׼<D0A3><D7BC><EFBFBD><EFBFBD>
DP1312EA_WriteRawRC(TxControlReg,0x83);
nfc_platform_sleep_ms(20);
//<2F><>ȡI/Qֵ
i = Read_I_Channel();
q = Read_Q_Channel();
#ifdef UART_DEBUG
nfc_platform_log("lpcd_: I:%02X ,Q:%02X\n",i,q);
#endif
//<2F><><EFBFBD>û<EFBFBD><C3BB><EFBFBD><EFBFBD><EFBFBD>ֵ
set_I_Q_threshold(i,q);
//<2F><EFBFBD><E8B6A8><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD>
write_Lpcd_reg(0x08,(u8)(duration>>8)); //ʱ<><CAB1><EFBFBD><EFBFBD>λ<EFBFBD>Ĵ<EFBFBD><C4B4><EFBFBD>
write_Lpcd_reg(0x09,(u8)duration); //ʱ<><CAB1><EFBFBD><EFBFBD>λ<EFBFBD>Ĵ<EFBFBD><C4B4><EFBFBD>
//<2F><EFBFBD><E8B6A8><EFBFBD>ռ<EFBFBD><D5BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
write_Lpcd_reg(0x0a,(u8)(cycle>>8));
write_Lpcd_reg(0x0b,(u8)(cycle));
DP1312EA_WriteRawRC(DivIrqReg,0x7F); //<2F><><EFBFBD>жϱ<D0B6><CFB1><EFBFBD>
}
/***********************************************************************************************
*<2A>ȴ<EFBFBD><C8B4><EFBFBD><EFBFBD>ж<EFBFBD>
***********************************************************************************************/
u8 DP1312EA_CLEAR_IRQ(void)
{
Clear_lpcd_irq();
return MI_OK;
}
/***********************************************************************************************
*<2A><><EFBFBD><EFBFBD>LPCD<43><44><EFBFBD>ȴ<EFBFBD><C8B4>ж<EFBFBD>
***********************************************************************************************/
void DP1312EA_LPCD_Start(void)
{
DP1312EA_Reset();
nfc_platform_sleep_ms(5);
DP1312EA_LPCD_Enter(LPCD_Cycle_Time,LPCD_Duration_Time);
}
/**************************************************END*****************************************/

25
nfc/vendor/dp1312ea/LPCD.h vendored Normal file
View File

@@ -0,0 +1,25 @@
#ifndef __LPCD_H
#define __LPCD_H
#include "reg.h"
void write_Lpcd_reg(u8 reg,u8 value);
u8 read_Lpcd_reg(u8 reg);
u8 Read_Q_Channel(void);
u8 Read_I_Channel(void);
void set_I_Q_threshold(u8 I_value,u8 Q_value);
void DP1312EA_LPCD_Start(void);
u8 DP1312EA_CLEAR_IRQ(void);
void DP1312EA_Check_Card(void);
void Clear_lpcd_irq(void);
void DP1312EA_LPCD_Stop(void);
#endif
/***********************************************END*******************************************************/

1103
nfc/vendor/dp1312ea/TypeA.c vendored Normal file

File diff suppressed because it is too large Load Diff

46
nfc/vendor/dp1312ea/TypeA.h vendored Normal file
View File

@@ -0,0 +1,46 @@
#ifndef __TYPEA_H
#define __TYPEA_H
#include "nfc.h"
#include "reg.h"
u8 DP1312EA_SelfTest(void);
void DP1312EA_CalulateCRC(u8 *pIn ,u8 len,u8 *pOut );
s8 DP1312EA_PcdConfigISOType(u8 type);
s8 DP1312EA_PcdActivateA(u8 *patqa,u8 *puid,u8 *plen,u8 *psak);
s8 DP1312EA_PcdRequestA(u8 req_code,u8 *pTagType);
s8 DP1312EA_PcdAnticoll(u8 level,u8 *pSnr);
s8 DP1312EA_PcdSelect(u8 level,u8 *pSnr,u8 *pSize);
s8 DP1312EA_PcdAuthState(u8 auth_mode,u8 addr,u8 *pKey,u8 *pSnr);
s8 DP1312EA_PcdWrite(u8 addr,u8 *pData);
s8 DP1312EA_PcdRead(u8 addr,u8 *pData);
s8 DP1312EA_PcdHalt(void);
u8 DP1312EA_RatsA(u8 *pbuf,u8 *plen);
u8 DP1312EA_PpsA(u8 param,u8 *pPpss);
s8 DP1312EA_PcdMfulRead(u8 addr,u8 *pReaddata);
u8 DP1312EA_CPU_I_Block(u8 *psbuf,u8 slen,u8 *prbuf,u8 *prlen);
s8 DP1312EA_PcdJewelCommand(u8* pdata,u8 len,u8* resp,u8* replen);
s8 DP1312EA_PcdRidA(u8 *pUid);
s8 DP1312EA_PcdReadA(u8 *pUid);
s8 DP1312EA_PcdJewel(void);
s8 DP1312EA_PcdPollingF(u8 *p);
void DP1312EA_Felica(void);
void DP1312EA_TypeA(u8 *UID_a, u8 *len);
void DP1312EA_SetBaudrate(u8 txrate,u8 rrate);
void DP1312EA_Simulate_Card(void);
void DP1312EA_Simulate_Card_LP(void);
s8 DP1312EA_JewelTransceive(struct TranSciveBuffer *pi);
void DP1312EA_Simulate_CardF(void);
void test_input_voltage(void);
void test_TSTIIN_TSTQIN(void);
void test_TST_DF(void);
#endif
/**************************************************END*****************************************/

409
nfc/vendor/dp1312ea/TypeB.c vendored Normal file
View File

@@ -0,0 +1,409 @@
/***********************************************************************************************
* B卡操作文件
***********************************************************************************************/
#include <stdio.h>
#include <string.h>
#include "DP1312EA_Config.h"
#include "DP1312EA.h"
#include "TypeB.h"
#include "nfc_platform.h"
void DP1312EA_PcdConfigISOTypeB(void)
{
DP1312EA_ClearBitMask(Status2Reg,0x08);//08h
DP1312EA_WriteRawRC(WaterLevelReg,0x10); //0bh,
DP1312EA_WriteRawRC(ControlReg,0x10);//0ch,
DP1312EA_WriteRawRC(BitFramingReg,0); //0dh,
DP1312EA_WriteRawRC(ModeReg,0x3F);//11h
DP1312EA_WriteRawRC(TxModeReg,0x03); //12h,
DP1312EA_WriteRawRC(RxModeReg,0x03); //13h,
DP1312EA_WriteRawRC(TxControlReg,0x80);//14h
DP1312EA_WriteRawRC(TxAutoReg,0x00); //15h,
DP1312EA_WriteRawRC(RxSelReg,0x88);//17h,
DP1312EA_WriteRawRC(RxThresholdReg,0x50); //18h,
DP1312EA_WriteRawRC(DemodReg,0x4D); //19h,
DP1312EA_WriteRawRC(TypeBReg,0x00); //1eh,
DP1312EA_WriteRawRC(GsNOffReg,0xF2); //23h
DP1312EA_WriteRawRC(ModWidthReg,0x68); //24h,
DP1312EA_WriteRawRC(RFCfgReg,0x59); //26h
DP1312EA_WriteRawRC(GsNOnReg,0xF8); //27h
DP1312EA_WriteRawRC(CWGsPReg,0x3f); //28h
DP1312EA_WriteRawRC(ModGsPReg,0x20); //29h,
DP1312EA_WriteRawRC(TModeReg,0x8D); //2ah,
DP1312EA_WriteRawRC(TPrescalerReg,0x3e); //2bh
DP1312EA_WriteRawRC(TReloadRegL,30);//2dh
DP1312EA_WriteRawRC(TReloadRegH,0); //2ch
DP1312EA_WriteRawRC(AutoTestReg,0); //36h
DP1312EA_FieldOff();
nfc_platform_sleep_ms(5);
DP1312EA_FieldOn();
}
s8 DP1312EA_PcdRequestB(u8 *atqb,u8 *pLen)
{
s8 status;
struct TranSciveBuffer MfComData,*pi = &MfComData;
DP1312EA_WriteRawRC(TxModeReg,0x83); //12h
DP1312EA_WriteRawRC(RxModeReg,0x83); //13h
DP1312EA_WriteRawRC(TReloadRegL,0x59);//2dh,
DP1312EA_WriteRawRC(TReloadRegH,0x0A); //2ch,
DP1312EA_ClearBitMask(Status2Reg,0x08); //08h
DP1312EA_SetBitMask(TxControlReg,0x03); //14h 0x03
MfComData.MfCommand = DP1312EA_TRANSCEIVE;
MfComData.MfLength = 3;
MfComData.MfData[0] = PICC_ANTI;
MfComData.MfData[1] = 0;
MfComData.MfData[2] = 0;
status = DP1312EA_PcdComTransceive(pi);
if (status == MI_OK)
{
if((MfComData.MfLength == 0x60) || (MfComData.MfLength == 0x10) )
{
*pLen = MfComData.MfLength/8;
memcpy(atqb, &MfComData.MfData[0], *pLen);
}
else
status = MI_VALERR;
}
return status;
}
s8 DP1312EA_PcdAttribB(u8 *pCid)
{
s8 status;
struct TranSciveBuffer MfComData,*pi = &MfComData;
DP1312EA_WriteRawRC(TPrescalerReg,0x80); //2bh,
DP1312EA_WriteRawRC(TModeReg,0x80); //2ah,
DP1312EA_WriteRawRC(TReloadRegL,0xC9);//2dh,
DP1312EA_WriteRawRC(TReloadRegH,0xFF); //2ch,
MfComData.MfCommand = DP1312EA_TRANSCEIVE;
MfComData.MfLength = 9;
MfComData.MfData[0] = PICC_ATTRIB;
memset(&MfComData.MfData[1], 0x00, 4); //pupi
MfComData.MfData[5] = 0;
MfComData.MfData[6] = 0x08;
MfComData.MfData[7] = 0x01;
MfComData.MfData[8] = 0x08;
status = DP1312EA_PcdComTransceive(pi);
if (status == MI_OK)
{
if (MfComData.MfLength != 0x8)
status = MI_BITCOUNTERR;
else
*pCid = MfComData.MfData[0];
}
return status;
}
s8 DP1312EA_PcdGetUidB(u8 *puid)
{
s8 status;
struct TranSciveBuffer MfComData,*pi = &MfComData;
DP1312EA_WriteRawRC(TxModeReg,0x83); //12h
DP1312EA_WriteRawRC(RxModeReg,0x83); //13h
MfComData.MfCommand = DP1312EA_TRANSCEIVE;
MfComData.MfLength =5;
MfComData.MfData[0] =0x00;
MfComData.MfData[1] =0x36;
MfComData.MfData[2] =0x00;
MfComData.MfData[3] =0x00;
MfComData.MfData[4] =0x08;
status = DP1312EA_PcdComTransceive(pi);
if ((status == MI_OK)&& (MfComData.MfLength == 0x50) )
memcpy(puid, &MfComData.MfData[0], 10);
else
status = MI_ERR;
return status;
}
void DP1312EA_SRT512(void)
{
s8 status;
u8 i;
u8 RD_Data[12],Len;
u8 chipID;
DP1312EA_PcdConfigISOTypeB();
nfc_platform_sleep_ms(10);
status = INITIATE_PCALL16(&chipID,&Len,0);
if(status==MI_OK)
{
#ifdef UART_DEBUG
nfc_platform_log("Chip_ID1: %02X",chipID);
nfc_platform_log("\n");
#endif
}
if(status!=MI_OK) return;
status = SelectChipID(RD_Data,&Len,chipID);
if(status==MI_OK)
{
#ifdef UART_DEBUG
nfc_platform_log("Chip_ID2: %02X",RD_Data[0]);
nfc_platform_log("\n");
#endif
}
if(status!=MI_OK) return;
status = GetUid(RD_Data);
if(status==MI_OK)
{
#ifdef UART_DEBUG
for(i=0;i<8;i++)
nfc_platform_log(" %02X",RD_Data[i]);
nfc_platform_log("\n");
#endif
}
if(status!=MI_OK) return;
status = SRTReadBlock(0,RD_Data);
if(status==MI_OK)
{
#ifdef UART_DEBUG
for(i=0;i<4;i++)
nfc_platform_log(" %02X",RD_Data[i]);
nfc_platform_log("\n");
#endif
}
if(status!=MI_OK) return;
do
{
status = GetUid(RD_Data);
if(status==MI_OK)
{
// LED_0;
}
else
{
//LED_1;
break;
}
}while(status==MI_OK);
}
s8 Write_ReadBlock(u8 block,u8 *Data)
{
s8 status;
u8 i;
u8 random[]={0x80,0x23,0x03,0x27};
struct TranSciveBuffer MfComData,*pi = &MfComData;
DP1312EA_WriteRawRC(TxModeReg,0x83); //12h
DP1312EA_WriteRawRC(RxModeReg,0x83);
MfComData.MfCommand = DP1312EA_TRANSMIT;
MfComData.MfLength =6;
MfComData.MfData[0] =0x09;
MfComData.MfData[1] =block;
for (i=0;i<4;i++)
{
MfComData.MfData[2+i]=random[i];
}
status = DP1312EA_PcdComTransceive(pi);
if(status!= MI_OK) return MI_ERR;
nfc_platform_sleep_ms(5);
MfComData.MfCommand = DP1312EA_TRANSCEIVE;
MfComData.MfLength =2;
MfComData.MfData[0] =0x08;
MfComData.MfData[1] =block;
status = DP1312EA_PcdComTransceive(pi);
if ((status == MI_OK)&& (MfComData.MfLength == 0x20) )
memcpy(Data, &MfComData.MfData[0],4);
else
status = MI_ERR;
return status;
}
s8 SRTReadBlock(u8 block,u8 *Data)
{
s8 status;
struct TranSciveBuffer MfComData,*pi = &MfComData;
MfComData.MfCommand = DP1312EA_TRANSCEIVE;
MfComData.MfLength =2;
MfComData.MfData[0] =0x08;
MfComData.MfData[1] =block;
status = DP1312EA_PcdComTransceive(pi);
if ((status == MI_OK)&& (MfComData.MfLength == 0x20) )
memcpy(Data, &MfComData.MfData[0],4);
else
status = MI_ERR;
return status;
}
s8 GetUid(u8 *puid)
{
s8 status;
struct TranSciveBuffer MfComData,*pi = &MfComData;
DP1312EA_WriteRawRC(TxModeReg,0x83); //12h
DP1312EA_WriteRawRC(RxModeReg,0x83); //13h
MfComData.MfCommand = DP1312EA_TRANSCEIVE;
MfComData.MfLength =1;
MfComData.MfData[0] =0x0B;
status = DP1312EA_PcdComTransceive(pi);
if ((status == MI_OK)&& (MfComData.MfLength == 0x40) )
memcpy(puid, &MfComData.MfData[0], 8);
else
status = MI_ERR;
return status;
}
s8 SelectChipID(u8 *atqb,u8 *pLen,u8 id)
{
s8 status;
struct TranSciveBuffer MfComData,*pi = &MfComData;
DP1312EA_WriteRawRC(TxModeReg,0x83); //12h
DP1312EA_WriteRawRC(RxModeReg,0x83); //13h
DP1312EA_WriteRawRC(TReloadRegL,0x59);//2dh,
DP1312EA_WriteRawRC(TReloadRegH,0x0A); //2ch,
DP1312EA_ClearBitMask(Status2Reg,0x08); //08h
DP1312EA_SetBitMask(TxControlReg,0x03); //14h
MfComData.MfCommand = DP1312EA_TRANSCEIVE;
MfComData.MfLength = 2;
MfComData.MfData[0] = 0x0E;
MfComData.MfData[1] = id;
status = DP1312EA_PcdComTransceive(pi);
if (status == MI_OK)
{
if( MfComData.MfLength == 0x08 )
{
*pLen = MfComData.MfLength/8;
memcpy(atqb, &MfComData.MfData[0], *pLen);
}
else
status = MI_VALERR;
}
return status;
}
s8 INITIATE_PCALL16(u8 *atqb,u8 *pLen,u8 cmd)
{
s8 status;
struct TranSciveBuffer MfComData,*pi = &MfComData;
DP1312EA_WriteRawRC(TxModeReg,0x83); //12h
DP1312EA_WriteRawRC(RxModeReg,0x83); //13h
DP1312EA_WriteRawRC(TReloadRegL,0x59);//2dh,
DP1312EA_WriteRawRC(TReloadRegH,0x0A); //2ch,
DP1312EA_ClearBitMask(Status2Reg,0x08); //08h
DP1312EA_SetBitMask(TxControlReg,0x03);//14h
MfComData.MfCommand = DP1312EA_TRANSCEIVE;
MfComData.MfLength = 2;
MfComData.MfData[0] = 0x06;
MfComData.MfData[1] = cmd;
status = DP1312EA_PcdComTransceive(pi);
if (status == MI_OK)
{
if( MfComData.MfLength == 0x08 )
{
*pLen = MfComData.MfLength/8;
memcpy(atqb, &MfComData.MfData[0], *pLen);
}
else
status = MI_VALERR;
}
return status;
}
void DP1312EA_ChinaID2(u8 *UID_b)
{
s8 status;
u8 i;
u8 RD_Data[12],Len;
memset(UID_b,0x00,8);
DP1312EA_Reset();
DP1312EA_PcdConfigISOTypeB();
nfc_platform_sleep_ms(10);
status = DP1312EA_PcdRequestB(RD_Data,&Len);
#ifdef UART_DEBUG
nfc_platform_log("ATQB: %d_",status);
if(status==MI_OK)
{
for(i=0;i<Len;i++)
nfc_platform_log(" %02X",RD_Data[i]);
}
nfc_platform_log("\n");
#endif
if(status!=MI_OK)
return;
if(Len==12)
{
status = DP1312EA_PcdAttribB(RD_Data);
#ifdef UART_DEBUG
nfc_platform_log("SELECT:%d_",status);
if(status==MI_OK)
nfc_platform_log(" %02X",RD_Data[0]);
nfc_platform_log("\n");
#endif
if(status!=MI_OK)
return;
}
status = DP1312EA_PcdGetUidB(RD_Data);
if(status==MI_OK)
{
memcpy(UID_b,RD_Data,8);
}
#ifdef UART_DEBUG
nfc_platform_log("UID: %d_",status);
for(i=0;i<8;i++)
{
nfc_platform_log(" %02X",RD_Data[i]);
}
nfc_platform_log("\n");
#endif
//有卡则一直检测,无卡则退出
while(1)
{
DP1312EA_FieldOff();
nfc_platform_sleep_ms(10);
DP1312EA_FieldOn();
// LED_1;
nfc_platform_sleep_ms(10);
status = DP1312EA_PcdRequestB(RD_Data,&Len);
if(status==MI_OK)
{
// LED_0;
}
else
break;
}
}
/**************************************************END*****************************************/

22
nfc/vendor/dp1312ea/TypeB.h vendored Normal file
View File

@@ -0,0 +1,22 @@
#ifndef __TYPEB_H
#define __TYPEB_H
#include "nfc.h"
#include "reg.h"
void DP1312EA_ChinaID2(u8 *UID_b);
void DP1312EA_PcdConfigISOTypeB(void);
s8 DP1312EA_PcdRequestB(u8 *atqb,u8 *pLen);
s8 DP1312EA_PcdAttribB(u8 *pCid);
s8 DP1312EA_PcdGetUidB(u8 *puid);
void DP1312EA_SRT512(void);
s8 INITIATE_PCALL16(u8 *atqb,u8 *pLen,u8 cmd);
s8 SelectChipID(u8 *atqb,u8 *pLen,u8 id);
s8 GetUid(u8 *puid);
s8 Write_ReadBlock(u8 block,u8 *Data);
s8 SRTReadBlock(u8 block,u8 *Data);
#endif

111
nfc/vendor/dp1312ea/nfc.h vendored Normal file
View File

@@ -0,0 +1,111 @@
#ifndef DP1312EA_NFC_H
#define DP1312EA_NFC_H
#include <stdint.h>
typedef uint8_t u8;
typedef int8_t s8;
typedef uint16_t u16;
typedef int16_t s16;
typedef uint32_t u32;
typedef int32_t s32;
typedef int8_t int8;
typedef uint8_t uint8;
typedef uint16_t uint16;
typedef uint32_t uint32;
#define PICC_REQIDL 0x26
#define PICC_REQALL 0x52
#define PICC_ANTICOLL1 0x93
#define PICC_ANTICOLL2 0x95
#define PICC_ANTICOLL3 0x97
#define PICC_AUTHENT1A 0x60
#define PICC_AUTHENT1B 0x61
#define PICC_READ 0x30
#define PICC_WRITE 0xA0
#define PICC_DECREMENT 0xC0
#define PICC_INCREMENT 0xC1
#define PICC_RESTORE 0xC2
#define PICC_TRANSFER 0xB0
#define PICC_HALT 0x50
#define SELECT_0 0x93
#define SELECT_1 0x95
#define SELECT_2 0x97
#define PICC_ANTI 0x05
#define PICC_ATTRIB 0x1D
#define MI_OK 0
#define MI_CHK_OK 0
#define MI_NOTAGERR (-1)
#define MI_CHK_FAILED (-1)
#define MI_CRCERR (-2)
#define MI_CHK_COMPERR (-2)
#define MI_EMPTY (-3)
#define MI_AUTHERR (-4)
#define MI_PARITYERR (-5)
#define MI_CODEERR (-6)
#define MI_SERNRERR (-8)
#define MI_KEYERR (-9)
#define MI_NOTAUTHERR (-10)
#define MI_BITCOUNTERR (-11)
#define MI_BYTECOUNTERR (-12)
#define MI_IDLE (-13)
#define MI_TRANSERR (-14)
#define MI_WRITEERR (-15)
#define MI_INCRERR (-16)
#define MI_DECRERR (-17)
#define MI_READERR (-18)
#define MI_OVFLERR (-19)
#define MI_POLLING (-20)
#define MI_FRAMINGERR (-21)
#define MI_ACCESSERR (-22)
#define MI_UNKNOWN_COMMAND (-23)
#define MI_COLLERR (-24)
#define MI_RESETERR (-25)
#define MI_INITERR (-25)
#define MI_INTERFACEERR (-26)
#define MI_ACCESSTIMEOUT (-27)
#define MI_NOBITWISEANTICOLL (-28)
#define MI_QUIT (-30)
#define MI_RECBUF_OVERFLOW (-50)
#define MI_SENDBYTENR (-51)
#define MI_SENDBUF_OVERFLOW (-53)
#define MI_BAUDRATE_NOT_SUPPORTED (-54)
#define MI_SAME_BAUDRATE_REQUIRED (-55)
#define MI_WRONG_PARAMETER_VALUE (-60)
#define MI_BREAK (-99)
#define MI_NY_IMPLEMENTED (-100)
#define MI_NO_MFRC (-101)
#define MI_MFRC_NOTAUTH (-102)
#define MI_WRONG_DES_MODE (-103)
#define MI_HOST_AUTH_FAILED (-104)
#define MI_WRONG_LOAD_MODE (-106)
#define MI_WRONG_DESKEY (-107)
#define MI_MKLOAD_FAILED (-108)
#define MI_FIFOERR (-109)
#define MI_WRONG_ADDR (-110)
#define MI_DESKEYLOAD_FAILED (-111)
#define MI_WRONG_SEL_CNT (-114)
#define MI_WRONG_TEST_MODE (-117)
#define MI_TEST_FAILED (-118)
#define MI_TOC_ERROR (-119)
#define MI_COMM_ABORT (-120)
#define MI_INVALID_BASE (-121)
#define MI_MFRC_RESET (-122)
#define MI_WRONG_VALUE (-123)
#define MI_VALERR (-124)
#define MI_COM_ERR (-125)
#define MI_ERR (-126)
#define DEF_FIFO_LENGTH 64
#define MAXRLEN 18
struct TranSciveBuffer {
u8 MfCommand;
u16 MfLength;
u8 MfData[DEF_FIFO_LENGTH];
};
#endif

95
nfc/vendor/dp1312ea/reg.h vendored Normal file
View File

@@ -0,0 +1,95 @@
#ifndef __REG_H
#define __REG_H
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
/////////////////////////////////////////////////////////////////////
#define DP1312EA_IDLE 0x00 //ȡ<><C8A1><EFBFBD><EFBFBD>ǰ<EFBFBD><C7B0><EFBFBD><EFBFBD>
#define DP1312EA_MEM 0x01 //CONFIG<49><47><EFBFBD><EFBFBD>
#define DP1312EA_AUTHENT 0x0E //<2F><>֤<EFBFBD><D6A4>Կ
#define DP1312EA_RECEIVE 0x08 //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
#define DP1312EA_TRANSMIT 0x04 //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
#define DP1312EA_TRANSCEIVE 0x0C //<2F><><EFBFBD>Ͳ<EFBFBD><CDB2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
#define DP1312EA_RESETPHASE 0x0F //<2F><>λ
#define DP1312EA_CALCCRC 0x03 //CRC<52><43><EFBFBD><EFBFBD>
#define DP1312EA_AUTOCOLL 0x0D //MIFARE anticollision, Card Operation mode only
//<2F>Ĵ<EFBFBD><C4B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
/////////////////////////////////////////////////////////////////////
// PAGE 0
#define RFU00 0x00
#define CommandReg 0x01
#define ComIEnReg 0x02
#define DivlEnReg 0x03
#define ComIrqReg 0x04
#define DivIrqReg 0x05
#define ErrorReg 0x06
#define Status1Reg 0x07
#define Status2Reg 0x08
#define FIFODataReg 0x09
#define FIFOLevelReg 0x0A
#define WaterLevelReg 0x0B
#define ControlReg 0x0C
#define BitFramingReg 0x0D
#define CollReg 0x0E
#define RFU0F 0x0F
// PAGE 1
#define RFU10 0x10
#define ModeReg 0x11
#define TxModeReg 0x12
#define RxModeReg 0x13
#define TxControlReg 0x14
#define TxAskReg 0x15 //rc523
#define TxAutoReg 0x15 //pn512
#define TxSelReg 0x16
#define RxSelReg 0x17
#define RxThresholdReg 0x18
#define DemodReg 0x19
#define RFU1A 0x1A
#define RFU1B 0x1B
#define MifareReg 0x1C
#define ManualRCVReg 0x1D
#define TypeBReg 0x1E
#define SerialSpeedReg 0x1F
// PAGE 2
#define RFU20 0x20
#define CRCResultRegM 0x21
#define CRCResultRegL 0x22
#define GsNOffReg 0x23
#define ModWidthReg 0x24
#define TxBitPhaseReg 0x25
#define RFCfgReg 0x26
#define GsNOnReg 0x27
#define CWGsPReg 0x28
#define ModGsPReg 0x29
#define TModeReg 0x2A
#define TPrescalerReg 0x2B
#define TReloadRegH 0x2C
#define TReloadRegL 0x2D
#define TCounterValueRegH 0x2E
#define TCounterValueRegL 0x2F
// PAGE 3
#define RFU30 0x30
#define TestSel1Reg 0x31
#define TestSel2Reg 0x32
#define TestPinEnReg 0x33
#define TestPinValueReg 0x34
#define TestBusReg 0x35
#define AutoTestReg 0x36
#define VersionReg 0x37
#define AnalogTestReg 0x38
#define TestDAC1Reg 0x39
#define TestDAC2Reg 0x3A
#define TestADCReg 0x3B
#define RFU3C 0x3C
#define RFU3D 0x3D
#define RFU3E 0x3E
#define RFU3F 0x3F
#endif
/***********************************************END*******************************************************/