xiaozhengsheng/HL-PDJ-1
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
HL-PDJ-1/external/nfc_adafruit_library/adafruit_pn532.c

1055 lines
34 KiB
C
Raw Permalink Normal View History

初始版本
2025-08-19 09:49:41 +08:00
/*
* Adafruit PN532 library adapted to use in NRF51 and NRF52
*
* Software License Agreement (BSD License)
*
* Copyright (c) 2012, Adafruit Industries
* All rights reserved.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the copyright holders nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "sdk_config.h"
#if ADAFRUIT_PN532_ENABLED
#include <stdio.h>
#include <inttypes.h>
#include <string.h>
#include "adafruit_pn532.h"
#include "nrf_gpio.h"
#include "nrf_delay.h"
#include "nrf_drv_twi.h"
#include "app_error.h"
#include "app_util.h"
#include "nordic_common.h"
#define NRF_LOG_MODULE_NAME adafruit_pn532
#if ADAFRUIT_PN532_LOG_ENABLED
#define NRF_LOG_LEVEL ADAFRUIT_PN532_LOG_LEVEL
#define NRF_LOG_INFO_COLOR ADAFRUIT_PN532_INFO_COLOR
#else // ADAFRUIT_PN532_LOG_ENABLED
#define NRF_LOG_LEVEL 0
#endif // ADAFRUIT_PN532_LOG_ENABLED
#include "nrf_log.h"
NRF_LOG_MODULE_REGISTER();
// Type 2 Tag page/block read/write restrictions.
#define T2T_MAX_READ_PAGE_NUMBER 255
#define T2T_MIN_WRITE_PAGE_NUMBER 4
#define T2T_MAX_WRITE_PAGE_NUMBER 255
// Lengths and offsets for specific commands and responses.
#define COMMAND_GETFIRMWAREVERSION_LENGTH 1
#define REPLY_GETFIRMWAREVERSION_LENGTH (5 + PN532_FRAME_OVERHEAD)
#define COMMAND_SAMCONFIGURATION_LENGTH 4
#define REPLY_SAMCONFIGURATION_LENGTH (1 + PN532_FRAME_OVERHEAD)
#define COMMAND_POWERDOWN_BASE_LENGTH 2 // No GenerateIRQ parameter.
#define REPLY_POWERDOWN_LENGTH (2 + PN532_FRAME_OVERHEAD)
#define COMMAND_RFCONFIGURATION_MAXRETRIES_LENGTH 5
#define COMMAND_RFCONFIGURATION_RFFIELD_LENGTH 3
#define REPLY_RFCONFIGURATION_LENGTH (1 + PN532_FRAME_OVERHEAD)
#define COMMAND_INLISTPASSIVETARGET_BASE_LENGTH 3
#define REPLY_INLISTPASSIVETARGET_106A_TARGET_LENGTH (17 + PN532_FRAME_OVERHEAD)
#define REPLY_INLISTPASSIVETARGET_106A_NBTG_OFFSET 7
#define REPLY_INLISTPASSIVETARGET_106A_TG_OFFSET 8
#define REPLY_INLISTPASSIVETARGET_106A_SENS_RES_BYTE_1_OFFSET 10
#define REPLY_INLISTPASSIVETARGET_106A_SENS_RES_BYTE_2_OFFSET 9
#define REPLY_INLISTPASSIVETARGET_106A_SEL_RES_OFFSET 11
#define REPLY_INLISTPASSIVETARGET_106A_UID_LEN_OFFSET 12
#define REPLY_INLISTPASSIVETARGET_106A_UID_OFFSET 13
#define COMMAND_INDATAEXCHANGE_BASE_LENGTH 2
#define REPLY_INDATAEXCHANGE_BASE_LENGTH (2 + PN532_FRAME_OVERHEAD)
// Configuration parameters for SAMCONFIGURATION command.
#define SAMCONFIGURATION_MODE_NORMAL 0x01
#define SAMCONFIGURATION_MODE_VIRTUAL_CARD 0x02
#define SAMCONFIGURATION_MODE_WIRED_CARD 0x03
#define SAMCONFIGURATION_MODE_DUAL_CARD 0x04
#define SAMCONFIGURATION_IRQ_ENABLED 0x01
#define SAMCONFIGURATION_IRQ_DISABLED 0x00
// Configuration parameters for POWERDOWN command.
#define POWERDOWN_WAKEUP_IRQ 0x80
#define POWERDOWN_WAKEUP_SPI 0x20
// Configuration parameters for RFCONFIGURATION command.
#define RFCONFIGURATION_CFGITEM_RFFIELD 0x01
#define RFCONFIGURATION_CFGITEM_MAXRETRIES 0x05
#define RFCONFIGURATION_RFFIELD_ON 0x01
#define RFCONFIGURATION_RFFIELD_OFF 0x00
// Error mask for the status mask in INDATAEXCHANGE frame.
#define PN532_STATUS_ERROR_MASK 0x3F
// Size of the PN532 size packet.
#define PN532_ACK_PACKET_SIZE 6
// Default time-out for read_passive_target_id (time required for field scan).
#define PN532_DEFAULT_WAIT_FOR_READY_TIMEOUT 100
/**
* @brief Information about the communication between the host and the Adafruit PN532 Shield.
*/
typedef struct
{
uint8_t ss; // !< Slave select signal for SPI.
uint8_t clk; // !< Clock signal for SPI.
uint8_t mosi; // !< Master output, slave input signal for SPI.
uint8_t miso; // !< Master input, slave output signal for SPI.
uint8_t irq; // !< Interrupt pin for Adafruit.
uint8_t reset; // !< Reset pin for Adafruit.
uint8_t in_listed_tag; // !< Tag number of in listed tags.
bool using_spi; // !< True if using SPI, false if using I2C.
bool hardware_spi; // !< True if using hardware SPI, false if using software SPI.
} adafruit_pn532;
// ACK frame format.
static const uint8_t m_pn532_ack[] = {0x00, 0x00, 0xFF, 0x00, 0xFF, 0x00};
// Firmware version reply frame format (preamble to command byte).
static const uint8_t m_pn532_rsp_firmware_ver[] = {0x00, 0xFF, 0x06, 0xFA, 0xD5, 0x03};
static adafruit_pn532 m_pn532_object = {
.clk = 0,
.miso = 0,
.mosi = 0,
.ss = 0,
.irq = PN532_IRQ,
.reset = PN532_RESET,
.using_spi = false,
.hardware_spi = false
};
static const nrf_drv_twi_t m_twi_master = NRF_DRV_TWI_INSTANCE(PN532_CONFIG_TWI_INSTANCE);
static uint8_t m_pn532_packet_buf[PN532_PACKBUFF_SIZE];
static uint8_t m_pn532_rxtx_buffer[PN532_PACKBUFF_SIZE]; /// Buffer for low level communication.
static bool m_lib_initialized = false;
/**
* @brief Function to configure pins in host chip.
*
* This function configures specific pins to interact with the PN532 module.
*/
static void adafruit_pn532_pin_setup(void)
{
nrf_gpio_cfg_input(m_pn532_object.irq, NRF_GPIO_PIN_NOPULL);
// The reset pin in the AdaFruit NFC Shield is actually the PN532 reset indicator pin (RSTOUT_N)
// and cannot be used to perform reset of the chip. (RSTPD_N pin, see AdaFruit NFC Shield
// schematics).
nrf_gpio_cfg_input(m_pn532_object.reset, NRF_GPIO_PIN_NOPULL);
}
/**
* @brief Function to calculate the checksum byte.
*
* This function calculates the checksum byte, so that the sum of all verified bytes
* and the checksum byte is equal to 0.
*
* @param current_sum[in] Sum of all bytes used to calculate checksum.
*
* @retval Value of the checksum byte.
*/
static uint8_t adafruit_pn532_cs_complement_calc(uint8_t current_sum)
{
return ~current_sum + 1;
}
/**
* @brief Function to check correctness of PN532 Normal information frame header.
*
* @param p_buffer[in] Pointer to the buffer containing frame header.
* @param p_length[out] Pointer to the variable where the data length will be stored.
*
* @retval NRF_SUCCESS If the header was correct.
* @retval NRF_ERROR_INVALID_DATA Otherwise.
*/
static ret_code_t adafruit_pn532_header_check(uint8_t const * p_buffer, uint8_t * p_length)
{
// Preamble
if ( (p_buffer[PN532_PREAMBLE_OFFSET] != PN532_PREAMBLE) ||
(p_buffer[PN532_STARTCODE1_OFFSET] != PN532_STARTCODE1) ||
(p_buffer[PN532_STARTCODE2_OFFSET] != PN532_STARTCODE2) )
{
NRF_LOG_INFO("Preamble missing");
return NRF_ERROR_INVALID_DATA;
}
// Data length
if (p_buffer[PN532_LENGTH_CS_OFFSET] !=
adafruit_pn532_cs_complement_calc(p_buffer[PN532_LENGTH_OFFSET]))
{
NRF_LOG_INFO("Length check invalid: len: 0x%02x, cs: 02%02x",
p_buffer[PN532_LENGTH_OFFSET], p_buffer[PN532_LENGTH_CS_OFFSET]);
return NRF_ERROR_INVALID_DATA;
}
// Direction byte
if ( (p_buffer[PN532_TFI_OFFSET] != PN532_PN532TOHOST) &&
(p_buffer[PN532_TFI_OFFSET] != PN532_HOSTTOPN532) )
{
NRF_LOG_INFO("Invalid direction byte: %02x", p_buffer[PN532_TFI_OFFSET]);
return NRF_ERROR_INVALID_DATA;
}
*p_length = p_buffer[PN532_LENGTH_OFFSET];
return NRF_SUCCESS;
}
ret_code_t adafruit_pn532_init(bool force)
{
uint32_t ver_data; // Variable to store firmware version read from PN532.
if (m_lib_initialized && !(force))
{
NRF_LOG_INFO("Library is already initialized");
return NRF_SUCCESS;
}
if (force)
{
NRF_LOG_INFO("Forcing library reinitialization");
}
if (m_pn532_object.using_spi)
{
NRF_LOG_INFO("Communication over SPI is currently not supported!");
return NRF_ERROR_INTERNAL;
}
ret_code_t err_code = adafruit_pn532_i2c_create();
if (err_code != NRF_SUCCESS)
{
NRF_LOG_INFO("Failed to create I2C, err_code = %d", err_code);
return err_code;
}
adafruit_pn532_pin_setup();
// Delay for PN532 to catch up with NRF.
nrf_delay_ms(100);
NRF_LOG_INFO("Looking for PN532");
err_code = adafruit_pn532_firmware_version_get(&ver_data);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_INFO("Didn't find PN53x board, err_code = %d", err_code);
return err_code;
}
NRF_LOG_INFO("Found chip PN5%02x", (ver_data >> 24) & 0xFF);
NRF_LOG_INFO("Firmware version %d.%d", (ver_data >> 16) & 0xFF,
(ver_data >> 8) & 0xFF);
err_code = adafruit_pn532_sam_config(SAMCONFIGURATION_MODE_NORMAL);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_INFO("Failed to configure SAM, err_code = %d", err_code);
return err_code;
}
err_code = adafruit_pn532_passive_activation_retries_set(0xFF);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_INFO("Failed to set passive activation retries, err_code = %d", err_code);
return err_code;
}
NRF_LOG_INFO("Waiting for an ISO14443A card");
m_lib_initialized = true;
return NRF_SUCCESS;
}
ret_code_t adafruit_pn532_i2c_create(void)
{
NRF_LOG_INFO("Creating I2C");
nrf_drv_twi_config_t twi_config = NRF_DRV_TWI_DEFAULT_CONFIG;
twi_config.scl = PN532_CONFIG_SCL;
twi_config.sda = PN532_CONFIG_SDA;
ret_code_t ret = nrf_drv_twi_init(&m_twi_master, &twi_config, NULL, NULL);
if (ret != NRF_SUCCESS)
{
NRF_LOG_INFO("Failed to initialize TWI, err_code = %d", ret);
return ret;
}
nrf_drv_twi_enable(&m_twi_master);
return NRF_SUCCESS;
}
void adafruit_pn532_tag_info_printout(nfc_a_tag_info const * const p_tag_info)
{
NRF_LOG_INFO("Basic NFC-A Tag information");
NRF_LOG_INFO("Anticollision information byte of SENS_RES: 0x%02X",
p_tag_info->sens_res[SENS_RES_ANTICOLLISION_INFO_BYTE]);
NRF_LOG_INFO("Platform information byte of SENS_RES: 0x%02X",
p_tag_info->sens_res[SENS_RES_PLATFORM_INFO_BYTE]);
NRF_LOG_INFO("SEL_RES: 0x%02X", p_tag_info->sel_res);
NRF_LOG_INFO("%d-byte NFC ID:", p_tag_info->nfc_id_len);
NRF_LOG_HEXDUMP_INFO(p_tag_info->nfc_id, p_tag_info->nfc_id_len);
NRF_LOG_RAW_INFO("\r\n");
}
ret_code_t adafruit_pn532_firmware_version_get(uint32_t * p_response)
{
NRF_LOG_INFO("Trying to get the firmware version");
m_pn532_packet_buf[0] = PN532_COMMAND_GETFIRMWAREVERSION;
ret_code_t err_code = adafruit_pn532_cmd_send(m_pn532_packet_buf,
COMMAND_GETFIRMWAREVERSION_LENGTH,
1000);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_INFO("Failed to send GetFirmwareVersion command, err_code = %d", err_code);
return err_code;
}
// Read data packet.
err_code = adafruit_pn532_data_read(m_pn532_packet_buf, REPLY_GETFIRMWAREVERSION_LENGTH);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_INFO("Failed to read data, err_code = %d", err_code);
return err_code;
}
if (memcmp(m_pn532_packet_buf + 1, m_pn532_rsp_firmware_ver, sizeof(m_pn532_rsp_firmware_ver)))
{
NRF_LOG_INFO("Firmware frame doesn't match!");
return NRF_ERROR_NOT_FOUND;
}
// Extract firmware version from the frame.
*p_response = uint32_big_decode(m_pn532_packet_buf + PN532_DATA_OFFSET + 1);
return NRF_SUCCESS;
}
ret_code_t adafruit_pn532_cmd_send(uint8_t * p_cmd, uint8_t cmd_len, uint16_t timeout)
{
NRF_LOG_INFO("Trying to send command");
NRF_LOG_HEXDUMP_INFO(p_cmd, cmd_len);
ret_code_t err_code = adafruit_pn532_command_write(p_cmd, cmd_len);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_INFO("Failed to write command, err_code = %d", err_code);
return err_code;
}
// Wait for ACK
if (!adafruit_pn532_waitready_ms(timeout))
{
NRF_LOG_INFO("Failed while waiting");
return NRF_ERROR_INTERNAL;
}
return adafruit_pn532_ack_read();
}
ret_code_t adafruit_pn532_sam_config(uint8_t mode)
{
NRF_LOG_INFO("Attempting to configure SAM");
ret_code_t err_code;
if ( (mode != SAMCONFIGURATION_MODE_NORMAL) &&
(mode != SAMCONFIGURATION_MODE_VIRTUAL_CARD) &&
(mode != SAMCONFIGURATION_MODE_WIRED_CARD) &&
(mode != SAMCONFIGURATION_MODE_DUAL_CARD) )
{
return NRF_ERROR_INVALID_PARAM;
}
m_pn532_packet_buf[0] = PN532_COMMAND_SAMCONFIGURATION;
m_pn532_packet_buf[1] = mode;
m_pn532_packet_buf[2] = 0x14; // Time-out value
m_pn532_packet_buf[3] = SAMCONFIGURATION_IRQ_ENABLED;
err_code = adafruit_pn532_cmd_send(m_pn532_packet_buf, COMMAND_SAMCONFIGURATION_LENGTH, 1000);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_INFO("Failed while checking ACK! err_code = %d", err_code);
return err_code;
}
err_code = adafruit_pn532_data_read(m_pn532_packet_buf, REPLY_SAMCONFIGURATION_LENGTH);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_INFO("Failed while reading data! err_code = %d", err_code);
return err_code;
}
if (!(m_pn532_packet_buf[PN532_DATA_OFFSET] == PN532_COMMAND_SAMCONFIGURATION + 1))
{
NRF_LOG_INFO("Failed while checking SAMCONFIGURATION response, expected 0x%02x, got 0x%02x",
PN532_COMMAND_SAMCONFIGURATION + 1,
m_pn532_packet_buf[PN532_DATA_OFFSET]);
return NRF_ERROR_NOT_FOUND;
}
return NRF_SUCCESS;
}
ret_code_t adafruit_pn532_power_down(void)
{
NRF_LOG_INFO("Powering down the PN532");
m_pn532_packet_buf[0] = PN532_COMMAND_POWERDOWN;
m_pn532_packet_buf[1] = POWERDOWN_WAKEUP_IRQ;
ret_code_t err_code = adafruit_pn532_cmd_send(m_pn532_packet_buf,
COMMAND_POWERDOWN_BASE_LENGTH,
1000);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_INFO("Failed while checking ACK! err_code = %d", err_code);
return err_code;
}
err_code = adafruit_pn532_data_read(m_pn532_packet_buf, REPLY_POWERDOWN_LENGTH);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_INFO("Failed while reading data! err_code = %d", err_code);
return err_code;
}
if (!(m_pn532_packet_buf[PN532_DATA_OFFSET] == PN532_COMMAND_POWERDOWN + 1))
{
NRF_LOG_INFO("Failed while checking POWERDOWN response, expected 0x%02x, got 0x%02x",
PN532_COMMAND_POWERDOWN + 1,
m_pn532_packet_buf[PN532_DATA_OFFSET]);
return NRF_ERROR_NOT_FOUND;
}
// From PN532 user manual: "The PN532 needs approximately 1 ms to get into Power Down mode,
// after the command response." (Rev. 02, p. 7.2.11, page 98)
nrf_delay_ms(1);
return NRF_SUCCESS;
}
ret_code_t adafruit_pn532_wake_up(void)
{
ret_code_t err_code;
if (m_pn532_object.using_spi)
{
NRF_LOG_INFO("Communication over SPI is currently not supported!");
return NRF_ERROR_INTERNAL;
}
// Wakeup procedure as specified in PN532 User Manual Rev. 02, p. 7.2.11, page 99.
uint8_t dummy_byte = 0x55;
err_code = nrf_drv_twi_tx(&m_twi_master, PN532_I2C_ADDRESS, &dummy_byte, 1, false);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_INFO("Failed while calling twi tx, err_code = %d", err_code);
return err_code;
}
// Wait specified time to ensure that the PN532 shield is fully operational
// (PN532 data sheet, Rev. 3.2, page 209).
nrf_delay_ms(2);
return NRF_SUCCESS;
}
ret_code_t adafruit_pn532_passive_activation_retries_set(uint8_t max_retries)
{
ret_code_t err_code;
m_pn532_packet_buf[0] = PN532_COMMAND_RFCONFIGURATION;
m_pn532_packet_buf[1] = RFCONFIGURATION_CFGITEM_MAXRETRIES;
m_pn532_packet_buf[2] = 0xFF; // MxRtyATR retries (default value)
m_pn532_packet_buf[3] = 0x01; // MxRtyPSL retries (default value)
m_pn532_packet_buf[4] = max_retries; // MxRtyPassiveActivation retries (user value)
NRF_LOG_INFO("Setting MxRtyPassiveActivation to %i", max_retries);
err_code = adafruit_pn532_cmd_send(m_pn532_packet_buf,
COMMAND_RFCONFIGURATION_MAXRETRIES_LENGTH,
1000);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_INFO("Failed while checking ACK! err_code = %d", err_code);
return err_code;
}
return NRF_SUCCESS;
}
ret_code_t adafruit_pn532_nfc_a_target_init(nfc_a_tag_info * p_tag_info,
uint16_t timeout)
{
NRF_LOG_INFO("Trying to read passive target ID");
if (p_tag_info == NULL)
{
NRF_LOG_INFO("NULL pointers passed as arguments to adafruit_pn532_passive_target_init.");
return NRF_ERROR_INVALID_PARAM;
}
m_pn532_packet_buf[0] = PN532_COMMAND_INLISTPASSIVETARGET;
m_pn532_packet_buf[1] = 1; // Maximum number of targets.
m_pn532_packet_buf[2] = PN532_MIFARE_ISO14443A_BAUD;
ret_code_t err_code = adafruit_pn532_cmd_send(m_pn532_packet_buf,
COMMAND_INLISTPASSIVETARGET_BASE_LENGTH,
PN532_DEFAULT_WAIT_FOR_READY_TIMEOUT);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_INFO("No card(s) read, err_code = %d", err_code);
return err_code;
}
NRF_LOG_INFO("Waiting for IRQ (indicates card presence)");
// Give PN532 a little time to scan in case time-out is very small.
if (timeout < PN532_DEFAULT_WAIT_FOR_READY_TIMEOUT)
{
timeout = PN532_DEFAULT_WAIT_FOR_READY_TIMEOUT;
}
if (!adafruit_pn532_waitready_ms(timeout))
{
NRF_LOG_INFO("IRQ time-out");
return NRF_ERROR_INTERNAL;
}
err_code = adafruit_pn532_data_read(m_pn532_packet_buf,
REPLY_INLISTPASSIVETARGET_106A_TARGET_LENGTH);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_INFO("Failed while reading data! err_code = %d", err_code);
return err_code;
}
if (m_pn532_packet_buf[REPLY_INLISTPASSIVETARGET_106A_NBTG_OFFSET] != 1)
{
NRF_LOG_INFO("Failed while checking number of targets, expected 1, got %02x",
m_pn532_packet_buf[REPLY_INLISTPASSIVETARGET_106A_NBTG_OFFSET]);
return NRF_ERROR_INVALID_DATA;
}
if (MAX_NFC_A_ID_LEN < m_pn532_packet_buf[REPLY_INLISTPASSIVETARGET_106A_UID_LEN_OFFSET])
{
NRF_LOG_INFO("UID length is invalid.");
return NRF_ERROR_INVALID_LENGTH;
}
p_tag_info->sens_res[SENS_RES_ANTICOLLISION_INFO_BYTE] =
m_pn532_packet_buf[REPLY_INLISTPASSIVETARGET_106A_SENS_RES_BYTE_1_OFFSET];
p_tag_info->sens_res[SENS_RES_PLATFORM_INFO_BYTE] =
m_pn532_packet_buf[REPLY_INLISTPASSIVETARGET_106A_SENS_RES_BYTE_2_OFFSET];
p_tag_info->sel_res = m_pn532_packet_buf[REPLY_INLISTPASSIVETARGET_106A_SEL_RES_OFFSET];
p_tag_info->nfc_id_len = m_pn532_packet_buf[REPLY_INLISTPASSIVETARGET_106A_UID_LEN_OFFSET];
memcpy(p_tag_info->nfc_id,
m_pn532_packet_buf + REPLY_INLISTPASSIVETARGET_106A_UID_OFFSET,
p_tag_info->nfc_id_len);
m_pn532_object.in_listed_tag = m_pn532_packet_buf[REPLY_INLISTPASSIVETARGET_106A_TG_OFFSET];
return NRF_SUCCESS;
}
ret_code_t adafruit_pn532_in_data_exchange(uint8_t * p_send,
uint8_t send_len,
uint8_t * p_response,
uint8_t * p_response_len)
{
NRF_LOG_INFO("Trying in data exchange");
if ((uint16_t) send_len + 2 > PN532_PACKBUFF_SIZE)
{
NRF_LOG_INFO("APDU length (%d) too long for packet buffer (%d)",
send_len,
PN532_PACKBUFF_SIZE - 2);
return NRF_ERROR_INTERNAL;
}
if ((uint16_t) (*p_response_len) + REPLY_INDATAEXCHANGE_BASE_LENGTH > PN532_PACKBUFF_SIZE)
{
NRF_LOG_INFO("Desired response length (%d) too long for packet buffer (%d)",
*p_response_len,
PN532_PACKBUFF_SIZE);
return NRF_ERROR_INTERNAL;
}
// Prepare command.
m_pn532_packet_buf[0] = PN532_COMMAND_INDATAEXCHANGE;
m_pn532_packet_buf[1] = m_pn532_object.in_listed_tag;
memcpy(m_pn532_packet_buf + 2, p_send, send_len);
ret_code_t err_code = adafruit_pn532_cmd_send(m_pn532_packet_buf,
send_len + 2,
1000);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_INFO("Could not send ADPU, err_code = %d", err_code);
return err_code;
}
if (!adafruit_pn532_waitready_ms(1000))
{
NRF_LOG_INFO("Response never received for ADPU");
return NRF_ERROR_INTERNAL;
}
err_code = adafruit_pn532_data_read(m_pn532_packet_buf,
*p_response_len + REPLY_INDATAEXCHANGE_BASE_LENGTH);
// + 2 for command and status byte
if (err_code != NRF_SUCCESS)
{
NRF_LOG_INFO("Could not read data, err_code = %d", err_code);
return err_code;
}
uint8_t length = 0;
err_code = adafruit_pn532_header_check(m_pn532_packet_buf, &length);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_INFO("Invalid frame header");
return err_code;
}
if ( (m_pn532_packet_buf[PN532_TFI_OFFSET] != PN532_PN532TOHOST) ||
(m_pn532_packet_buf[PN532_DATA_OFFSET] != PN532_COMMAND_INDATAEXCHANGE + 1) )
{
NRF_LOG_INFO("Don't know how to handle this command: %02x",
m_pn532_packet_buf[PN532_DATA_OFFSET]);
return NRF_ERROR_INTERNAL;
}
// Check InDataExchange Status byte.
if ((m_pn532_packet_buf[PN532_DATA_OFFSET + 1] & PN532_STATUS_ERROR_MASK) != 0x00)
{
NRF_LOG_INFO("Status code indicates an error, %02x",
m_pn532_packet_buf[PN532_DATA_OFFSET + 1]);
return NRF_ERROR_INTERNAL;
}
length -= 3; // Calculate the actual data length
// Silently truncate response to fit into reply desired data size.
if (length > *p_response_len)
{
length = *p_response_len;
}
memcpy(p_response, m_pn532_packet_buf + PN532_DATA_OFFSET + 2, length);
*p_response_len = length;
return NRF_SUCCESS;
}
ret_code_t adafruit_pn532_tag2_read(uint8_t start_page, uint8_t * p_buffer)
{
NRF_LOG_INFO("Trying to read pages: %d-%d", start_page, start_page + T2T_END_PAGE_OFFSET);
ret_code_t err_code;
uint8_t cmd_buf[2];
uint8_t response_len = T2T_MAX_DATA_EXCHANGE;
cmd_buf[0] = MIFARE_CMD_READ;
cmd_buf[1] = start_page;
err_code = adafruit_pn532_in_data_exchange(cmd_buf, 2, p_buffer, &response_len);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_INFO("Failed to read pages: %d-%d",
start_page,
start_page + T2T_END_PAGE_OFFSET);
return err_code;
}
NRF_LOG_INFO("Pages %d-%d", start_page, start_page + T2T_END_PAGE_OFFSET);
NRF_LOG_HEXDUMP_INFO(p_buffer, response_len);
return NRF_SUCCESS;
}
ret_code_t adafruit_pn532_tag2_page_write(uint8_t page, uint8_t * p_data)
{
if (page < T2T_MIN_WRITE_PAGE_NUMBER)
{
NRF_LOG_INFO("Page value out of range, page = %d", page);
return NRF_ERROR_INVALID_PARAM;
}
NRF_LOG_INFO("Trying to write 4-byte page %u", page);
uint8_t write_buf[T2T_MAX_DATA_EXCHANGE];
uint8_t response_len = T2T_MAX_DATA_EXCHANGE;
write_buf[0] = MIFARE_ULTRALIGHT_CMD_WRITE;
write_buf[1] = page;
memcpy(write_buf + 2, p_data, T2T_PAGE_SIZE);
ret_code_t err_code = adafruit_pn532_in_data_exchange(write_buf,
2 + T2T_PAGE_SIZE,
write_buf,
&response_len);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_INFO("Failed to write page %d", page);
return err_code;
}
return NRF_SUCCESS;
}
ret_code_t adafruit_pn532_ndef_uri_tag2_write(uint8_t uri_id, char * p_url, uint8_t data_len)
{
NRF_LOG_INFO("Trying to write URI %d", uri_id);
uint8_t page_buf[4] = {0};
uint8_t uri_len = strlen(p_url);
uint8_t page_header[] =
{
0x00, 0x03, uri_len + 5, 0xD1,
0x01, uri_len + 1, 0x55, uri_id
};
uint8_t page_header_len = sizeof(page_header);
if ( (uri_len < 1) || (uri_len + 1 > (data_len - page_header_len)))
{
NRF_LOG_INFO("URL is too long for provided data length");
return NRF_ERROR_INVALID_PARAM;
}
ret_code_t err_code;
int32_t i;
uint8_t current_page = 4;
for (i = 0; i < 2; i++)
{
memcpy(page_buf, page_header + 4 * i, T2T_PAGE_SIZE);
err_code = adafruit_pn532_tag2_page_write(current_page, page_buf);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_INFO("Failed to write URI page %d, err_code = %d", current_page, err_code);
return err_code;
}
current_page++;
}
char * url_ptr = p_url;
uint8_t len_to_cpy = 0;
while (uri_len > 0)
{
// Prepare length of the chunk to copy.
if (uri_len < T2T_PAGE_SIZE)
{
len_to_cpy = uri_len;
// If do not copy a full page, prepare the buffer.
memset(page_buf, 0x00, T2T_PAGE_SIZE);
page_buf[len_to_cpy] = 0xFE; // Terminator block.
}
else
{
len_to_cpy = T2T_PAGE_SIZE;
}
memcpy(page_buf, url_ptr, len_to_cpy);
err_code = adafruit_pn532_tag2_page_write(current_page, page_buf);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_INFO("Failed to write page %d, err_code = %d", current_page, err_code);
return err_code;
}
current_page++;
// If the last page was sent, and there was no chance to insert TLV Terminator block,
// send another page with Terminator block in it.
if (uri_len == T2T_PAGE_SIZE)
{
memset(page_buf, 0x00, T2T_PAGE_SIZE);
page_buf[0] = 0xFE;
err_code = adafruit_pn532_tag2_page_write(current_page, page_buf);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_INFO("Failed to write page %d, err_code = %d", current_page, err_code);
return err_code;
}
current_page++;
}
uri_len -= len_to_cpy;
url_ptr += len_to_cpy;
}
return NRF_SUCCESS;
}
ret_code_t adafruit_pn532_ack_read(void)
{
NRF_LOG_INFO("Reading ACK");
uint8_t ack_buf[PN532_ACK_PACKET_SIZE];
ret_code_t err_code;
err_code = adafruit_pn532_data_read(ack_buf, PN532_ACK_PACKET_SIZE);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_INFO("ACK read failed");
return err_code;
}
// Wait for irq to be taken off.
for (uint16_t i = 0; i < 1000; i++)
{
if (!adafruit_pn532_is_ready())
{
break;
}
}
if (memcmp(ack_buf, m_pn532_ack, PN532_ACK_PACKET_SIZE) != 0)
{
NRF_LOG_INFO("Failed while comparing ACK packet");
return NRF_ERROR_INTERNAL;
}
return NRF_SUCCESS;
}
bool adafruit_pn532_is_ready(void)
{
return nrf_gpio_pin_read(m_pn532_object.irq) == 0;
}
bool adafruit_pn532_waitready_ms(uint16_t timeout)
{
uint16_t timer = 0;
bool result = false;
result = adafruit_pn532_is_ready();
while ((!result) && (timer < timeout))
{
timer += 1;
nrf_delay_ms(1);
result = adafruit_pn532_is_ready();
}
return result;
}
ret_code_t adafruit_pn532_data_read(uint8_t * p_buff, uint8_t n)
{
if (!adafruit_pn532_waitready_ms(PN532_DEFAULT_WAIT_FOR_READY_TIMEOUT))
{
return NRF_ERROR_INTERNAL;
}
if (m_pn532_object.using_spi)
{
NRF_LOG_INFO("Communication over SPI is currently not supported!");
return NRF_ERROR_INTERNAL;
}
if ((uint16_t) n + 1 > PN532_PACKBUFF_SIZE)
{
NRF_LOG_INFO("Rx buffer is too short!");
return NRF_ERROR_INVALID_PARAM;
}
if (n == UINT8_MAX)
{
NRF_LOG_INFO("Read command exceeds uint8_t !");
return NRF_ERROR_NOT_SUPPORTED;
}
ret_code_t err_code;
// In case of I2C, read the additional status byte.
NRF_LOG_INFO("Reading (%d bytes): ", n+1);
err_code = nrf_drv_twi_rx(&m_twi_master, PN532_I2C_ADDRESS, m_pn532_rxtx_buffer, n + 1);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_INFO("Failed while calling TWI rx, err_code = %d", err_code);
return err_code;
}
memcpy(p_buff, m_pn532_rxtx_buffer + 1, n);
NRF_LOG_HEXDUMP_INFO(p_buff, n);
return NRF_SUCCESS;
}
ret_code_t adafruit_pn532_command_write(uint8_t * p_cmd, uint8_t cmd_len)
{
ret_code_t err_code;
uint8_t checksum;
if (m_pn532_object.using_spi)
{
NRF_LOG_INFO("Communication over SPI is currently not supported!");
return NRF_ERROR_INTERNAL;
}
if ((uint16_t) cmd_len + PN532_FRAME_OVERHEAD > PN532_PACKBUFF_SIZE)
{
NRF_LOG_INFO("Tx buffer is too short!");
return NRF_ERROR_INVALID_PARAM;
}
// Compose header part of the command frame.
m_pn532_rxtx_buffer[0] = PN532_PREAMBLE;
m_pn532_rxtx_buffer[1] = PN532_STARTCODE1;
m_pn532_rxtx_buffer[2] = PN532_STARTCODE2;
m_pn532_rxtx_buffer[3] = cmd_len + 1; // Data length + TFI byte.
m_pn532_rxtx_buffer[4] = adafruit_pn532_cs_complement_calc(cmd_len + 1);
m_pn532_rxtx_buffer[5] = PN532_HOSTTOPN532;
// Copy the payload data.
memcpy(m_pn532_rxtx_buffer + HEADER_SEQUENCE_LENGTH, p_cmd, cmd_len);
// Calculate checksum.
checksum = PN532_HOSTTOPN532;
for (uint8_t i = 0; i < cmd_len; i++)
{
checksum += p_cmd[i];
}
checksum = adafruit_pn532_cs_complement_calc(checksum);
// Compose checksum part of the command frame.
m_pn532_rxtx_buffer[HEADER_SEQUENCE_LENGTH + cmd_len] = checksum;
m_pn532_rxtx_buffer[HEADER_SEQUENCE_LENGTH + cmd_len + 1] = PN532_POSTAMBLE;
NRF_LOG_INFO("Sending command");
NRF_LOG_HEXDUMP_INFO(m_pn532_rxtx_buffer, cmd_len + PN532_FRAME_OVERHEAD);
err_code = nrf_drv_twi_tx(&m_twi_master,
PN532_I2C_ADDRESS,
m_pn532_rxtx_buffer,
cmd_len + PN532_FRAME_OVERHEAD,
false);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_INFO("Failed while calling TWI tx 1, err_code = %d", err_code);
return err_code;
}
return NRF_SUCCESS;
}
/** Function for enabling or disabling the PN532 RF field.
*
* This function sends a configuration command to the PN532, which enables or disables the RF field.
*
* @param field_conf A value indicating whether the RF field should be turned on or off.
* Valid values are 1 (field on) and 0 (field off).
*
* @retval NRF_SUCCESS If the RF field was enabled successfully.
* @retval NRF_ERROR_INVALID_PARAM If the value in field_conf was invalid.
* @retval Other Otherwise.
*/
static ret_code_t adafruit_pn532_field_switch(uint8_t field_conf)
{
ret_code_t err_code;
if ( (field_conf != RFCONFIGURATION_RFFIELD_ON) && (field_conf != RFCONFIGURATION_RFFIELD_OFF) )
{
NRF_LOG_INFO("Invalid field configuration: 0x%02x", field_conf);
return NRF_ERROR_INVALID_PARAM;
}
m_pn532_packet_buf[0] = PN532_COMMAND_RFCONFIGURATION;
m_pn532_packet_buf[1] = RFCONFIGURATION_CFGITEM_RFFIELD;
m_pn532_packet_buf[2] = field_conf;
err_code = adafruit_pn532_cmd_send(m_pn532_packet_buf,
COMMAND_RFCONFIGURATION_RFFIELD_LENGTH,
1000);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_INFO("Failed while checking ACK! err_code = %d", err_code);
return err_code;
}
if (!adafruit_pn532_waitready_ms(PN532_DEFAULT_WAIT_FOR_READY_TIMEOUT))
{
return NRF_ERROR_INTERNAL;
}
return NRF_SUCCESS;
}
ret_code_t adafruit_pn532_field_on(void)
{
return adafruit_pn532_field_switch(RFCONFIGURATION_RFFIELD_ON);
}
ret_code_t adafruit_pn532_field_off(void)
{
return adafruit_pn532_field_switch(RFCONFIGURATION_RFFIELD_OFF);
}
#endif // ADAFRUIT_PN532_ENABLED
Reference in New Issue Copy Permalink