xiaozhengsheng/HL-PDJ-1
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
HL-PDJ-1/components/nfc/t2t_parser/nfc_t2t_parser.c

680 lines
24 KiB
C
Raw Normal View History

初始版本
2025-08-19 09:49:41 +08:00
/**
* Copyright (c) 2015 - 2020, Nordic Semiconductor ASA
*
* 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, except as embedded into a Nordic
* Semiconductor ASA integrated circuit in a product or a software update for
* such product, 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 Nordic Semiconductor ASA nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* 4. This software, with or without modification, must only be used with a
* Nordic Semiconductor ASA integrated circuit.
*
* 5. Any software provided in binary form under this license must not be reverse
* engineered, decompiled, modified and/or disassembled.
*
* THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS 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_common.h"
#if NRF_MODULE_ENABLED(NFC_T2T_PARSER)
#include <string.h>
#include <stdbool.h>
#include "nrf_delay.h"
#include "nfc_t2t_parser.h"
#define NRF_LOG_MODULE_NAME nfc_t2t_parser
#if NFC_T2T_PARSER_LOG_ENABLED
#define NRF_LOG_LEVEL NFC_T2T_PARSER_LOG_LEVEL
#define NRF_LOG_INFO_COLOR NFC_T2T_PARSER_INFO_COLOR
#include "nrf_log.h"
NRF_LOG_MODULE_REGISTER();
#else // NFC_T2T_PARSER_LOG_ENABLED
#define NRF_LOG_LEVEL 0
#include "nrf_log.h"
#endif // NFC_T2T_PARSER_LOG_ENABLED
/// Gets least significant nibble (a 4-bit value) from a byte.
#define LSN_GET(val) (val & 0x0F)
/// Gets most significant nibble (a 4-bit value) from a byte.
#define MSN_GET(val) ((val >> 4) & 0x0F)
/**
* @brief Function for inserting the TLV block into a @ref type_2_tag_t structure.
*
* The content of a TLV block structure pointed by the p_tlv_block is copied into a TLV block
* array within the structure pointed by the p_type_2_tag.
*
* @param[in,out] p_type_2_tag Pointer to the structure that contains the TLV blocks array.
* @param[in] p_tlv_block Pointer to the TLV block to insert.
*
* @retval NRF_SUCCESS If the block was inserted successfully.
* @retval NRF_ERROR_NO_MEM If there is already maximum number of blocks stored in the array.
*
*/
static ret_code_t type_2_tag_tlv_block_insert(type_2_tag_t * p_type_2_tag,
tlv_block_t * p_tlv_block)
{
if (p_type_2_tag->tlv_count == p_type_2_tag->max_tlv_blocks)
{
return NRF_ERROR_NO_MEM;
}
// Copy contents of the source block.
p_type_2_tag->p_tlv_block_array[p_type_2_tag->tlv_count] = *p_tlv_block;
p_type_2_tag->tlv_count++;
return NRF_SUCCESS;
}
/**
* @brief Function for checking if the TLV block length is correct.
*
* Some TLV block has predefined length:
* TLV_NULL and TLV_TERMINATOR always have a length of 1 byte.
* TLV_LOCK_CONTROL and TLV_MEMORY_CONTROL always have a length of 3 bytes.
*
* @param[in] p_block_to_check Pointer to the structure that contains the TLV block length.
*
* @retval TRUE If the length is correct.
* @retval FALSE Otherwise.
*
*/
static bool tlv_block_is_data_length_correct(tlv_block_t * p_block_to_check)
{
switch (p_block_to_check->tag)
{
case TLV_NULL:
case TLV_TERMINATOR:
if (p_block_to_check->length != TLV_NULL_TERMINATOR_LEN)
{
return false;
}
break;
case TLV_LOCK_CONTROL:
case TLV_MEMORY_CONTROL:
if (p_block_to_check->length != TLV_LOCK_MEMORY_CTRL_LEN)
{
return false;
}
break;
case TLV_NDEF_MESSAGE:
case TLV_PROPRIETARY:
default:
// Any length will do.
break;
}
return true;
}
/**
* @brief Function for checking if the end of the tag data area was reached.
*
* @param[in] p_type_2_tag Pointer to the structure that contains the data area size.
* @param[in] offset Current byte offset.
*
* @retval TRUE If the offset indicates the end of the data area.
* @retval FALSE Otherwise.
*
*/
static bool type_2_tag_is_end_reached(type_2_tag_t * p_type_2_tag, uint16_t offset)
{
return offset == (p_type_2_tag->cc.data_area_size + T2T_FIRST_DATA_BLOCK_OFFSET);
}
/**
* @brief Function for checking if version of Type 2 Tag specification read from a tag is supported.
*
* @param[in] p_type_2_tag Pointer to the structure that contains the tag version.
*
* @retval TRUE If the version is supported and tag data can be parsed.
* @retval FALSE Otherwise.
*
*/
static bool type_2_tag_is_version_supported(type_2_tag_t * p_type_2_tag)
{
// Simple check atm, as only 1 major version has been issued so far, so no backward compatibility
// is needed, tags with newer version implemented shall be rejected according to the doc.
return p_type_2_tag->cc.major_version == T2T_SUPPORTED_MAJOR_VERSION;
}
/**
* @brief Function for checking if the field fits into the data area specified in
* the Capability Container.
*
* @param[in] p_type_2_tag Pointer to the structure that contains the data area size.
* @param[in] offset As Offset of the field to check.
* @param[in] field_length Length of the field to check.
*
* @retval TRUE If the field fits into the data area.
* @retval FALSE If the field exceeds the data area.
*
*/
static bool type_2_tag_is_field_within_data_range(type_2_tag_t * p_type_2_tag,
uint16_t offset,
uint16_t field_length)
{
// Invalid argument, return false.
if (field_length == 0)
{
return false;
}
return ( (offset + field_length - 1) <
(p_type_2_tag->cc.data_area_size + T2T_FIRST_DATA_BLOCK_OFFSET) )
&& ( offset >= T2T_FIRST_DATA_BLOCK_OFFSET );
}
/**
* @brief Function for reading the tag field of a TLV block from the p_raw_data buffer.
*
* This function reads the tag field containing a TLV block type and inserts its value into
* a structure pointed by the p_tlv_buf pointer.
*
* @param[in] p_type_2_tag Pointer to the structure that contains Type 2 Tag data parsed so far.
* @param[in] p_raw_data Pointer to the buffer with a raw data from the tag.
* @param[in,out] p_t_offset As input: offset of the tag field to read. As output: offset of
* the first byte after the tag field.
* @param[out] p_tlv_buf Pointer to a @ref tlv_block_t structure where the tag type will be
* inserted.
*
* @retval NRF_SUCCESS If the tag field at specified offset is correct.
* @retval NRF_ERROR_INVALID_DATA If the tag field at specified offset exceeds the data
* area specified in the Capability Container.
*
*/
static ret_code_t type_2_tag_type_extract(type_2_tag_t * p_type_2_tag,
uint8_t * p_raw_data,
uint16_t * p_t_offset,
tlv_block_t * p_tlv_buf)
{
if (!type_2_tag_is_field_within_data_range(p_type_2_tag, *p_t_offset, TLV_T_LENGTH))
{
return NRF_ERROR_INVALID_DATA;
}
p_tlv_buf->tag = p_raw_data[*p_t_offset];
*p_t_offset += TLV_T_LENGTH;
return NRF_SUCCESS;
}
/**
* @brief Function for reading the length field of a TLV block from the p_raw_data buffer.
*
* This function reads the length field of a TLV block and inserts its value into a structure
* pointed by the p_tlv_buf pointer.
*
* @param[in] p_type_2_tag Pointer to the structure that contains Type 2 Tag data parsed so far.
* @param[in] p_raw_data Pointer to the buffer with a raw data from the tag.
* @param[in,out] p_l_offset As input: offset of the length field to read. As output: offset of
* the first byte after the length field.
* @param[out] p_tlv_buf Pointer to a @ref tlv_block_t structure where the length will be
* inserted.
*
* @retval NRF_SUCCESS If the length field at specified offset is correct.
* @retval NRF_ERROR_INVALID_DATA If the length field at specified offset exceeds the data
* area specified in the Capability Container or has
* incorrect format.
*
*/
static ret_code_t type_2_tag_length_extract(type_2_tag_t * p_type_2_tag,
uint8_t * p_raw_data,
uint16_t * p_l_offset,
tlv_block_t * p_tlv_buf)
{
uint16_t length;
if (!type_2_tag_is_field_within_data_range(p_type_2_tag, *p_l_offset, TLV_L_SHORT_LENGTH))
{
return NRF_ERROR_INVALID_DATA;
}
length = p_raw_data[*p_l_offset];
if (length == TLV_L_FORMAT_FLAG)
{
// Check another two bytes.
if (!type_2_tag_is_field_within_data_range(p_type_2_tag, *p_l_offset, TLV_L_LONG_LENGTH))
{
return NRF_ERROR_INVALID_DATA;
}
length = uint16_big_decode(&p_raw_data[*p_l_offset + 1]);
// Long length value cannot be lower than 0xFF.
if (length < 0xFF)
{
return NRF_ERROR_INVALID_DATA;
}
p_tlv_buf->length = length;
*p_l_offset += TLV_L_LONG_LENGTH;
}
else
{
p_tlv_buf->length = length;
*p_l_offset += TLV_L_SHORT_LENGTH;
}
return NRF_SUCCESS;
}
/**
* @brief Function for reading a pointer to the value field of a TLV block from the p_raw_data buffer.
*
* This function reads a pointer to the value field of a TLV block and inserts it into
* a structure pointed by the p_tlv_buf pointer. If there is no value field present in the
* TLV block, NULL is inserted.
*
* @param[in] p_type_2_tag Pointer to the structure that contains Type 2 Tag data parsed so far.
* @param[in] p_raw_data Pointer to the buffer with a raw data from the tag.
* @param[in,out] p_v_offset As input: offset of the value field to read. As output: offset of
* the first byte after the value field.
* @param[in,out] p_tlv_buf Pointer to a @ref tlv_block_t structure where the value field
* pointer will be inserted.
*
* @retval NRF_SUCCESS If the value field at specified offset is correct.
* @retval NRF_ERROR_INVALID_DATA If the value field at specified offset exceeds the data
* area specified in the Capability Container.
*
*/
static ret_code_t type_2_tag_value_ptr_extract(type_2_tag_t * p_type_2_tag,
uint8_t * p_raw_data,
uint16_t * p_v_offset,
tlv_block_t * p_tlv_buf)
{
if (p_tlv_buf->length == 0)
{
// Clear the value pointer, don't touch the offset.
p_tlv_buf->p_value = NULL;
}
else
{
if (!type_2_tag_is_field_within_data_range(p_type_2_tag, *p_v_offset, p_tlv_buf->length))
{
return NRF_ERROR_INVALID_DATA;
}
p_tlv_buf->p_value = p_raw_data + *p_v_offset;
*p_v_offset += p_tlv_buf->length;
}
return NRF_SUCCESS;
}
/**
* @brief Function for reading a single TLV block from the p_raw_data buffer.
*
* This function reads a single TLV block from the p_raw_data buffer and stores its contents in a
* structure pointed by the p_tlv_buf.
*
* @param[in] p_type_2_tag Pointer to the structure that contains Type 2 Tag data parsed so far.
* @param[in] p_raw_data Pointer to the buffer with a raw data from the tag.
* @param[in,out] p_tlv_offset As input: offset of the TLV block to read. As output: offset of the
* next TLV block, 0 if it was the last block.
* @param[out] p_tlv_buf Pointer to a @ref tlv_block_t structure that will be filled with
* the data read.
*
* @retval NRF_SUCCESS If the parsing operation of the block succeeded. Otherwise, an error
* code is returned.
*
*/
static ret_code_t type_2_tag_tlv_block_extract(type_2_tag_t * p_type_2_tag,
uint8_t * p_raw_data,
uint16_t * p_offset,
tlv_block_t * p_tlv_buf)
{
ret_code_t err_code;
memset(p_tlv_buf, 0, sizeof(tlv_block_t));
// TLV Tag field.
err_code = type_2_tag_type_extract(p_type_2_tag, p_raw_data, p_offset, p_tlv_buf);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
// Further processing depends on tag field value.
switch (p_tlv_buf->tag)
{
case TLV_NULL:
// Simply ignore NULL blocks, leave the incremented offset.
break;
case TLV_TERMINATOR:
// Write 0 to the offset variable, indicating that last TLV block was found.
*p_offset = 0;
break;
case TLV_LOCK_CONTROL:
case TLV_MEMORY_CONTROL:
case TLV_NDEF_MESSAGE:
case TLV_PROPRIETARY:
default:
// Unknown blocks should also be extracted.
err_code = type_2_tag_length_extract(p_type_2_tag, p_raw_data, p_offset, p_tlv_buf);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
if (p_tlv_buf->length > 0)
{
err_code = type_2_tag_value_ptr_extract(p_type_2_tag, p_raw_data, p_offset, p_tlv_buf);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
}
break;
}
return NRF_SUCCESS;
}
/**
* @brief Function for checking the checksum bytes of the UID stored in internal area.
*
* This function calculates the block check character (BCC) bytes based on the parsed serial number
* and compares them with bytes read from the Type 2 Tag.
*
* @param[in] p_sn Pointer to the @ref type_2_tag_serial_number_t structure to check.
*
* @retval TRUE If the calculated BCC matched the BCC from the tag.
* @retval FALSE Otherwise.
*
*/
static bool type_2_tag_is_bcc_correct(type_2_tag_serial_number_t * p_sn)
{
uint8_t bcc1 = (uint8_t)T2T_UID_BCC_CASCADE_BYTE ^
(uint8_t)p_sn->manufacturer_id ^
(uint8_t)((p_sn->serial_number_part_1 >> 8) & 0xFF) ^
(uint8_t)(p_sn->serial_number_part_1 & 0xFF);
uint8_t bcc2 = (uint8_t)((p_sn->serial_number_part_2 >> 24) & 0xFF) ^
(uint8_t)((p_sn->serial_number_part_2 >> 16) & 0xFF) ^
(uint8_t)((p_sn->serial_number_part_2 >> 8) & 0xFF) ^
(uint8_t)( p_sn->serial_number_part_2 & 0xFF);
return (bcc1 == p_sn->check_byte_0) && (bcc2 == p_sn->check_byte_1);
}
/**
* @brief Function for parsing an internal area of a Type 2 Tag.
*
* This function reads data from an internal area in the raw data buffer and fills the
* @ref type_2_tag_serial_number_t structure within @ref type_2_tag_t.
*
* @param[in,out] p_type_2_tag Pointer to the structure that will be filled with parsed data.
* @param[in] p_raw_data Pointer to the buffer with raw data from the tag.
*
* @retval NRF_SUCCESS If the parsing operation of the internal area succeeded.
* Otherwise, an error code is returned.
*
*/
static ret_code_t type_2_tag_internal_parse(type_2_tag_t * p_type_2_tag, uint8_t * p_raw_data)
{
p_type_2_tag->sn.manufacturer_id = p_raw_data[0];
p_type_2_tag->sn.serial_number_part_1 = uint16_big_decode(&p_raw_data[1]);
p_type_2_tag->sn.check_byte_0 = p_raw_data[3];
p_type_2_tag->sn.serial_number_part_2 = uint32_big_decode(&p_raw_data[4]);
p_type_2_tag->sn.check_byte_1 = p_raw_data[8];
p_type_2_tag->sn.internal = p_raw_data[9];
p_type_2_tag->lock_bytes = uint16_big_decode(&p_raw_data[10]);
if (!type_2_tag_is_bcc_correct(&p_type_2_tag->sn))
{
NRF_LOG_WARNING("Warning! BCC of the serial number is not correct!");
}
return NRF_SUCCESS;
}
/**
* @brief Function for parsing a Capabiliy Container area of a Type 2 Tag.
*
* This function reads data from a Capability Container area in the raw data buffer and fills the
* @ref type_2_tag_capability_container_t structure within @ref type_2_tag_t.
*
* @param[in,out] p_type_2_tag Pointer to the structure that will be filled with parsed data.
* @param[in] p_raw_data Pointer to the buffer with raw data from the tag.
*
* @retval NRF_SUCCESS If the parsing operation of the Capability Container succeeded.
* Otherwise, an error code is returned.
*
*/
static ret_code_t type_2_tag_cc_parse(type_2_tag_t * p_type_2_tag, uint8_t * p_raw_data)
{
uint8_t * p_cc_block = p_raw_data + T2T_CC_BLOCK_OFFSET;
if (p_cc_block[0] != T2T_NFC_FORUM_DEFINED_DATA)
{
return NRF_ERROR_INVALID_DATA;
}
p_type_2_tag->cc.major_version = MSN_GET(p_cc_block[1]);
p_type_2_tag->cc.minor_version = LSN_GET(p_cc_block[1]);
p_type_2_tag->cc.data_area_size = p_cc_block[2] * 8;
p_type_2_tag->cc.read_access = MSN_GET(p_cc_block[3]);
p_type_2_tag->cc.write_access = LSN_GET(p_cc_block[3]);
return NRF_SUCCESS;
}
/**
* @brief Function for parsing a single TLV block.
*
* This function reads a single TLV block from the raw data buffer, from the position indicated by
* the p_tlv_offset, and adds it to the @ref type_2_tag_t structure.
*
* @param[in,out] p_type_2_tag Pointer to the structure that will be filled with parsed data.
* @param[in] p_raw_data Pointer to the buffer with raw data from the tag.
* @param[in,out] p_tlv_offset As input: offset of the TLV block to parse. As output: offset of the
* next TLV block, 0 if it was the last block.
*
* @retval NRF_SUCCESS If the parsing operation of the block succeeded. Otherwise, an error
* code is returned.
*
*/
static ret_code_t type_2_tag_tlv_parse(type_2_tag_t * p_type_2_tag,
uint8_t * p_raw_data,
uint16_t * p_tlv_offset)
{
ret_code_t err_code;
tlv_block_t new_block;
// Get tag field.
err_code = type_2_tag_tlv_block_extract(p_type_2_tag, p_raw_data, p_tlv_offset, &new_block);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
if (!tlv_block_is_data_length_correct(&new_block))
{
return NRF_ERROR_INVALID_DATA;
}
// Further action depends on tag type.
switch (new_block.tag)
{
case TLV_NULL:
case TLV_TERMINATOR:
// Ignore them.
break;
case TLV_LOCK_CONTROL:
case TLV_MEMORY_CONTROL:
case TLV_NDEF_MESSAGE:
case TLV_PROPRIETARY:
default:
// Unknown tag types are also added.
err_code = type_2_tag_tlv_block_insert(p_type_2_tag, &new_block);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_WARNING("Warning! Not enough memory to insert all of the blocks!");
return err_code;
}
break;
}
return NRF_SUCCESS;
}
void type_2_tag_clear(type_2_tag_t * p_type_2_tag)
{
p_type_2_tag->tlv_count = 0;
memset(&p_type_2_tag->cc, 0, sizeof(p_type_2_tag->cc));
memset(&p_type_2_tag->sn, 0, sizeof(p_type_2_tag->sn));
}
ret_code_t type_2_tag_parse(type_2_tag_t * p_type_2_tag, uint8_t * p_raw_data)
{
ret_code_t err_code;
type_2_tag_clear(p_type_2_tag);
err_code = type_2_tag_internal_parse(p_type_2_tag, p_raw_data);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
err_code = type_2_tag_cc_parse(p_type_2_tag, p_raw_data);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
if (!type_2_tag_is_version_supported(p_type_2_tag))
{
return NRF_ERROR_NOT_SUPPORTED;
}
uint16_t offset = T2T_FIRST_DATA_BLOCK_OFFSET;
while (offset > 0)
{
// Check if end of tag is reached (no terminator block was present).
if (type_2_tag_is_end_reached(p_type_2_tag, offset))
{
NRF_LOG_DEBUG("No terminator block was found in the tag!");
break;
}
err_code = type_2_tag_tlv_parse(p_type_2_tag, p_raw_data, &offset);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
}
return NRF_SUCCESS;
}
void type_2_tag_printout(type_2_tag_t * p_type_2_tag)
{
uint32_t i;
NRF_LOG_INFO("Type 2 Tag contents:");
NRF_LOG_INFO("Number of TLV blocks: %d", p_type_2_tag->tlv_count);
NRF_LOG_DEBUG("Internal data:");
NRF_LOG_DEBUG(" Manufacturer ID: 0x%02x", p_type_2_tag->sn.manufacturer_id);
NRF_LOG_DEBUG(" Serial number part 1: 0x%04x", p_type_2_tag->sn.serial_number_part_1);
NRF_LOG_DEBUG(" Check byte 0: 0x%02x", p_type_2_tag->sn.check_byte_0);
NRF_LOG_DEBUG(" Serial number part 2: 0x%08lx", p_type_2_tag->sn.serial_number_part_2);
NRF_LOG_DEBUG(" Check byte 1: 0x%02x", p_type_2_tag->sn.check_byte_1);
NRF_LOG_DEBUG(" Internal byte: 0x%02x", p_type_2_tag->sn.internal);
NRF_LOG_DEBUG(" Lock bytes: 0x%04x", p_type_2_tag->lock_bytes);
NRF_LOG_DEBUG("Capability Container data:");
NRF_LOG_DEBUG(" Major version number: %d", p_type_2_tag->cc.major_version);
NRF_LOG_DEBUG(" Minor version number: %d", p_type_2_tag->cc.minor_version);
NRF_LOG_DEBUG(" Data area size: %d", p_type_2_tag->cc.data_area_size);
NRF_LOG_DEBUG(" Read access: 0x%02X", p_type_2_tag->cc.read_access);
NRF_LOG_DEBUG(" Write access: 0x%02X", p_type_2_tag->cc.write_access);
for (i = 0; i < p_type_2_tag->tlv_count; i++)
{
NRF_LOG_INFO("TLV block 0x%02X: ", p_type_2_tag->p_tlv_block_array[i].tag);
switch (p_type_2_tag->p_tlv_block_array[i].tag)
{
case TLV_LOCK_CONTROL:
NRF_LOG_INFO("Lock Control");
break;
case TLV_MEMORY_CONTROL:
NRF_LOG_INFO("Memory Control");
break;
case TLV_NDEF_MESSAGE:
NRF_LOG_INFO("NDEF Message");
break;
case TLV_PROPRIETARY:
NRF_LOG_INFO("Proprietary");
break;
case TLV_NULL:
NRF_LOG_INFO("Null\r\n");
break;
case TLV_TERMINATOR:
NRF_LOG_INFO("Terminator");
break;
default:
NRF_LOG_INFO("Unknown");
break;
}
NRF_LOG_INFO(" Data length: %d", p_type_2_tag->p_tlv_block_array[i].length);
if (p_type_2_tag->p_tlv_block_array[i].length > 0)
{
NRF_LOG_DEBUG(" Data:");
NRF_LOG_HEXDUMP_DEBUG(p_type_2_tag->p_tlv_block_array[i].p_value,
p_type_2_tag->p_tlv_block_array[i].length);
}
}
}
#endif // NRF_MODULE_ENABLED(NFC_T2T_PARSER)
Reference in New Issue Copy Permalink