使用PN7160B1HN/C100E和PIC32MZ2048EFH100实现跨应用的NFC集成

具有SPI接口并符合NFC论坛和NCI 2.0标准的近场通信（NFC）解决方案

NFC 7 Click - SPI with Flip&Click PIC32MZ

已发布 1月 22, 2025

点击板

NFC 7 Click - SPI

开发板

Flip&Click PIC32MZ

编译器

NECTO Studio

微控制器单元

PIC32MZ2048EFH100

高灵敏度的 NFC 功能，具有低功耗需求，非常适合移动设备和智能家居网关

硬件概览

它是如何工作的？

NFC 7 Click 基于 NXP 的 PN7160，这是一款近场通信 (NFC) 控制器。该多功能 NFC 解决方案符合 NFC Forum 和 NCI 2.0 标准，能够为广泛的 NFC 应用提供强大的集成能力。此版本的 NFC 7 Click 专门通过 SPI 接口（PN7160B1HN/C100E）与主 MCU 通信，并提供针对低功耗优化的架构。PN7160 具备多种省电模式，包括硬件掉电模式、固件激活的待机模式以及低功耗轮询循环，可在不同操作场景中高效利用能量。NFC 7 Click 特别适用于便携式和低功耗应用，在需要可靠 NFC 功能的场景中表现优异，例如移动设备、可穿戴技术、个人数字助理、消费电子和智能家居网关。PN7160 的核心是一代全新射频无接触前端，支持符合 NFCIP-1 和 NFCIP-2、ISO/IEC 14443、ISO/IEC 15693、MIFARE 和 FeliCa 标准的

传输模式。该先进设计通过更高的灵敏度和主动负载调制能力显著提升了性能，即使在较小的天线设计（例如集成于此板上的天线）中，也能保持可靠的通信。PN7160 引入增强的动态负载调制振幅 (DLMA)，根据外部场强动态调整调制振幅。在卡片模拟模式下，该功能延长了通信距离，并确保 Type A、B 和 F 通信具有 5° 精度的独立相位调整。此外，动态功率控制使得此板即使在零距离时也能在读卡器模式下以最大功率运行，而不会超出标准限制。在独立卡片功能中，PN7160 在由主 MCU 配置后可以自主运行，让被动集成电路卡 (PICC) 功能无需主机持续供电即可发挥作用。这使得 NFC 7 Click 成为节能和始终在线 NFC 应用的理想解决方案。正如所述，NFC 7 Click 使用标准 SPI 通信协议，允许主 MCU

以高达 7MHz 的时钟频率控制 PN7160。在板背面有一组电阻，需要根据板版本进行配置；在这种情况下，仅填充 SPI 位置的电阻以支持 SPI 功能。除了接口引脚外，NFC 7 Click 还包含 VEN 引脚，用于将设备置于硬件掉电模式，以在不使用时节省能源。同时，它还使用 IRQ 引脚处理中断请求，为主 MCU 提供及时响应事件（如标签检测、操作完成或错误）的机制，从而增强 NFC 应用的整体响应能力和效率。此 Click board™ 可通过 VCC SEL 跳线选择 3.3V 或 5V 逻辑电平运行。这种设计确保 3.3V 和 5V 的 MCU 都能正确使用通信线路。此外，该 Click board™ 提供了易于使用的函数库和示例代码，可作为进一步开发的参考。

NFC 7 Click (SPI) hardware overview image

功能概述

开发板

Flip&Click PIC32MZ 是一款紧凑型开发板，设计为一套完整的解决方案，它将 Click 板™的灵活性带给您喜爱的微控制器，使其成为实现您想法的完美入门套件。它配备了一款板载 32 位 PIC32MZ 微控制器，Microchip 的 PIC32MZ2048EFH100，四个 mikroBUS™ 插槽用于 Click 板™连接，两个 USB 连接器，LED 指示灯，按钮，调试器/程序员连接器，以及两个与 Arduino-UNO 引脚兼容的头部。得益于创

新的制造技术，它允许您快速构建具有独特功能和特性的小工具。Flip&Click PIC32MZ 开发套件的每个部分都包含了使同一板块运行最高效的必要组件。此外，还可以选择 Flip&Click PIC32MZ 的编程方式，使用 chipKIT 引导程序（Arduino 风格的开发环境）或我们的 USB HID 引导程序，使用 mikroC、mikroBasic 和 mikroPascal for PIC32。该套件包括一个通过 USB 类型-C（USB-C）连接器的干净且调

节过的电源供应模块。所有 mikroBUS™ 本身支持的通信方法都在这块板上，包括已经建立良好的 mikroBUS™ 插槽、用户可配置的按钮和 LED 指示灯。Flip&Click PIC32MZ 开发套件允许您在几分钟内创建新的应用程序。它由 Mikroe 软件工具原生支持，得益于大量不同的 Click 板™（超过一千块板），其数量每天都在增长，它涵盖了原型制作的许多方面。

微控制器概述

MCU卡片 / MCU

建筑

PIC32

MCU 内存 (KB)

2048

硅供应商

Microchip

引脚数

100

RAM (字节)

524288

你完善了我！

配件

运行在 13.56MHz 的 RFID 标签符合 ISO14443-A 标准，确保了高频通信。这种近距离卡技术，通常以 MIFARE 卡为代表，在访问控制、公共交通和支付系统等应用中实现了安全且无接触的交互。ISO14443-A 标准定义了通信协议，并包含防冲突机制以便同时处理多个卡片。这些 RFID 标签具有可变的内存容量，从几字节到几千字节不等，满足不同应用需求。为确保数据安全，该标准集成了加密和身份验证等功能。以 MIFARE 技术为代表的这些标签因其高效性而广泛应用，在多种识别和访问场景中显著提高了便利性和安全性。

使用的MCU引脚

mikroBUS™映射器

Reset

RE2

RST

SPI Select / ID COMM

RA0

SPI Clock

RG6

SCK

SPI Data OUT

RC4

MISO

SPI Data IN

RB5

MOSI

Power Supply

3.3V

Ground

GND

Hard Power-Down Mode

RC14

PWM

Interrupt Request

RD9

INT

SCL

SDA

Power Supply

Ground

GND

“仔细看看！”

Click board™ 原理图

一步一步来

项目组装

Flip&Click PIC32MZ front image hardware assembly

从选择您的开发板和Click板™开始。以Flip&Click PIC32MZ作为您的开发板开始。

GNSS2 Click front image hardware assembly

GNSS2 Click complete accessories setup image hardware assembly

Flip&Click PIC32MZ MB1 Access - upright/background hardware assembly

Flip&Click PIC32MZ MCU step hardware assembly

Necto No Display image step 8 hardware assembly

Debug Image Necto Step hardware assembly

实时跟踪您的结果

应用程序输出

1. 应用程序输出 - 在调试模式下，“应用程序输出”窗口支持实时数据监控，直接提供执行结果的可视化。请按照提供的教程正确配置环境，以确保数据正确显示。

2. UART 终端 - 使用UART Terminal通过USB to UART converter监视数据传输，实现Click board™与开发系统之间的直接通信。请根据项目需求配置波特率和其他串行设置，以确保正常运行。有关分步设置说明，请参考提供的教程。

3. Plot 输出 - Plot功能提供了一种强大的方式来可视化实时传感器数据，使趋势分析、调试和多个数据点的对比变得更加直观。要正确设置，请按照提供的教程，其中包含使用Plot功能显示Click board™读数的分步示例。在代码中使用Plot功能时，请使用以下函数：plot(insert_graph_name, variable_name);。这是一个通用格式，用户需要将“insert_graph_name”替换为实际图表名称，并将“variable_name”替换为要显示的参数。

软件支持

库描述

NFC 7 Click - SPI 演示应用程序使用 NECTO Studio开发，确保与 mikroSDK 的开源库和工具兼容。该演示设计为即插即用，可与所有具有 mikroBUS™ 插座的开发板、入门板和 mikromedia 板完全兼容，用于快速实现和测试。

示例描述
此示例演示了如何使用 NFC 7 SPI Click 板，通过处理各种 NFC 技术和协议，确保应用程序能够响应不同类型的 NFC 卡（A、B、F、V）。

关键功能:

nfc7spi_cfg_setup - 配置对象初始化函数。
nfc7spi_init - 初始化函数。
nfc7spi_default_cfg - Click 默认配置函数。
nfc7spi_wait_discovery - 等待检测到远程 NFC 设备。
nfc7spi_presence_check - 等待检测到的目标设备被移除。
nfc7spi_stop_discovery - 停止 RF 发现过程。

应用初始化
初始化驱动程序和日志记录器，执行 Click 默认配置，并读取设备固件版本。

应用任务
等待检测到 NFC 设备，检查其是否支持已知的 NFC 技术，然后根据其协议处理该设备。应用程序继续处理设备（读取和写入信息），并等待卡片被移除。一旦卡片被移除，重新启动发现过程以检测新的 NFC 设备。

开源

代码示例

完整的应用程序代码和一个现成的项目可以通过NECTO Studio包管理器直接安装到NECTO Studio。应用程序代码也可以在MIKROE的GitHub账户中找到。

/*!
 * @file main.c
 * @brief NFC 7 SPI Click example
 *
 * # Description
 * This example demonstrates the use of NFC 7 SPI Click board by handling the detection
 * and processing of various NFC technologies and protocols, and ensuring the application
 * can respond to different NFC card types (A,B,F,V).
 *
 * The demo application is composed of two sections :
 *
 * ## Application Init
 * Initializes the driver and logger, performs the Click default configuration and
 * reads the device firmware version.
 *
 * ## Application Task
 * Waits for an NFC device to be discovered, checks if it supports a known NFC technology, 
 * and then handles the device based on its protocol. The application continues processing
 * the device (reading and writing information) and waits until the card is removed.
 * Once the card is removed, the discovery process is restarted to detect a new NFC device.
 *
 * @author Stefan Filipovic
 *
 */

#include "board.h"
#include "log.h"
#include "nfc7spi.h"

static nfc7spi_t nfc7spi;
static log_t logger;

/**
 * @brief NFC 7 SPI handle ISO14443-3A function.
 * @details This function handles discovered ISO14443-3A / Type 2 Tag (T2T) card by performing
 * read/write data to memory block 32.
 * @param[in] ctx : Click context object.
 * See #nfc7spi_t object definition for detailed explanation.
 * @return None.
 * @note None.
 */
static void nfc7spi_handle_iso14443_3a ( nfc7spi_t *ctx );

/**
 * @brief NFC 7 SPI handle ISO14443-4 function.
 * @details This function handles discovered ISO14443-4 (ISO-DEP) card by selecting the PPSE
 * (Paypass Payment System Environment) application.
 * @param[in] ctx : Click context object.
 * See #nfc7spi_t object definition for detailed explanation.
 * @return None.
 * @note None.
 */
static void nfc7spi_handle_iso14443_4 ( nfc7spi_t *ctx );

/**
 * @brief NFC 7 SPI handle ISO15693 function.
 * @details This function handles discovered ISO15693 card by performing read/write data
 * to memory block 32.
 * @param[in] ctx : Click context object.
 * See #nfc7spi_t object definition for detailed explanation.
 * @return None.
 * @note None.
 */
static void nfc7spi_handle_iso15693 ( nfc7spi_t *ctx );

/**
 * @brief NFC 7 SPI handle mifare function.
 * @details This function handles discovered MIFARE card by performing read/write data
 * to memory block 32.
 * @param[in] ctx : Click context object.
 * See #nfc7spi_t object definition for detailed explanation.
 * @return None.
 * @note None.
 */
static void nfc7spi_handle_mifare ( nfc7spi_t *ctx );

/**
 * @brief NFC 7 SPI display card info function.
 * @details This function parses and displays the discovered card info on the USB UART.
 * @param[in] rf_intf : Discovered NFC remote device properties.
 * @return None.
 * @note None.
 */
static void nfc7spi_display_card_info ( nfc7spi_rf_intf_t rf_intf );

void application_init ( void ) 
{
    log_cfg_t log_cfg;  /**< Logger config object. */
    nfc7spi_cfg_t nfc7spi_cfg;  /**< Click config object. */

    /** 
     * Logger initialization.
     * Default baud rate: 115200
     * Default log level: LOG_LEVEL_DEBUG
     * @note If USB_UART_RX and USB_UART_TX 
     * are defined as HAL_PIN_NC, you will 
     * need to define them manually for log to work. 
     * See @b LOG_MAP_USB_UART macro definition for detailed explanation.
     */
    LOG_MAP_USB_UART( log_cfg );
    log_init( &logger, &log_cfg );
    log_info( &logger, " Application Init " );

    // Click initialization.
    nfc7spi_cfg_setup( &nfc7spi_cfg );
    NFC7SPI_MAP_MIKROBUS( nfc7spi_cfg, MIKROBUS_1 );
    if ( SPI_MASTER_ERROR == nfc7spi_init( &nfc7spi, &nfc7spi_cfg ) ) 
    {
        log_error( &logger, " Communication init." );
        for ( ; ; );
    }
    
    if ( NFC7SPI_ERROR == nfc7spi_default_cfg ( &nfc7spi ) )
    {
        log_error( &logger, " Default configuration." );
        for ( ; ; );
    }
    log_printf( &logger, " FW version: %.2X.%.2X.%.2X\r\n", 
                ( uint16_t ) nfc7spi.fw_version[ 0 ], 
                ( uint16_t ) nfc7spi.fw_version[ 1 ], 
                ( uint16_t ) nfc7spi.fw_version[ 2 ] );
    
    log_info( &logger, " Application Task " );
}

void application_task ( void ) 
{
    nfc7spi_rf_intf_t rf_intf;
    log_printf( &logger, " WAITING FOR DEVICE DISCOVERY\r\n\n" );
    if ( NFC7SPI_OK == nfc7spi_wait_discovery ( &nfc7spi, &rf_intf ) )
    {
        if ( ( NFC7SPI_NCI_RF_TECH_PASSIVE_POLL_NFC_A == rf_intf.mode_tech ) || 
             ( NFC7SPI_NCI_RF_TECH_PASSIVE_POLL_NFC_B == rf_intf.mode_tech ) || 
             ( NFC7SPI_NCI_RF_TECH_PASSIVE_POLL_NFC_F == rf_intf.mode_tech ) || 
             ( NFC7SPI_NCI_RF_TECH_PASSIVE_POLL_15693 == rf_intf.mode_tech ) )
        {
            for ( ; ; )
            {
                nfc7spi_display_card_info ( rf_intf );

                switch ( rf_intf.protocol )
                {
                    case NFC7SPI_NCI_RF_PROT_T2T:
                    {
                        nfc7spi_handle_iso14443_3a ( &nfc7spi );
                        break;
                    }
                    case NFC7SPI_NCI_RF_PROT_ISODEP:
                    {
                        nfc7spi_handle_iso14443_4 ( &nfc7spi );
                        break;
                    }
                    case NFC7SPI_NCI_RF_PROT_T5T:
                    {
                        nfc7spi_handle_iso15693 ( &nfc7spi );
                        break;
                    }
                    case NFC7SPI_NCI_RF_PROT_MIFARE:
                    {
                        nfc7spi_handle_mifare ( &nfc7spi );
                        break;
                    }
                    default:
                    {
                        break;
                    }
                }
                if ( !rf_intf.more_tags )
                {
                    break;
                }
                nfc7spi_reader_act_next ( &nfc7spi, &rf_intf );
            }
            
            nfc7spi_presence_check ( &nfc7spi, &rf_intf );
            log_printf ( &logger, " - CARD REMOVED\r\n\n" );

            nfc7spi_stop_discovery ( &nfc7spi );
            while ( NFC7SPI_OK != nfc7spi_start_discovery ( &nfc7spi ) );
        }
        else
        {
            log_printf ( &logger, " - WRONG DISCOVERY\r\n\n" );
        }
    }
}

int main ( void ) 
{
    /* Do not remove this line or clock might not be set correctly. */
    #ifdef PREINIT_SUPPORTED
    preinit();
    #endif
    
    application_init( );
    
    for ( ; ; ) 
    {
        application_task( );
    }

    return 0;
}

static void nfc7spi_handle_iso14443_3a ( nfc7spi_t *ctx )
{
    #define BLK_NB_ISO14443_3A      32
    #define DATA_WRITE_ISO14443_3A  0x11, 0x22, 0x33, 0x44
    uint8_t rd_block[ ] = { NFC7SPI_T2T_CMD_READ, BLK_NB_ISO14443_3A };
    uint8_t wr_block[ ] = { NFC7SPI_T2T_CMD_WRITE, BLK_NB_ISO14443_3A, DATA_WRITE_ISO14443_3A };
    err_t error_flag = NFC7SPI_OK;

    // Read block
    ctx->pkt_data.payload_len = sizeof ( rd_block );
    memcpy ( ctx->pkt_data.payload, rd_block, ctx->pkt_data.payload_len );
    error_flag = nfc7spi_reader_tag_cmd ( ctx, &ctx->pkt_data );
    if ( ( NFC7SPI_OK != error_flag ) || 
         ( NFC7SPI_NCI_STAT_OK != ctx->pkt_data.payload[ ctx->pkt_data.payload_len - 1 ] ) )
    {
        log_printf ( &logger, " Read block %u failed with error %.2X\r\n", 
                     ( uint16_t ) rd_block[ 1 ], 
                     ( uint16_t ) ctx->pkt_data.payload[ ctx->pkt_data.payload_len - 1 ] );
        return;
    }
    log_printf ( &logger, " Read block %u: ", ( uint16_t ) rd_block[ 1 ] );
    for ( uint8_t cnt = 0; cnt < 4; cnt++ )
    {
        log_printf( &logger, "%.2X ", ( uint16_t ) ctx->pkt_data.payload[ cnt ] );
    }
    log_printf( &logger, "\r\n" );

    // Write block
    ctx->pkt_data.payload_len = sizeof ( wr_block );
    memcpy ( ctx->pkt_data.payload, wr_block, ctx->pkt_data.payload_len );
    error_flag = nfc7spi_reader_tag_cmd ( ctx, &ctx->pkt_data );
    if ( ( NFC7SPI_OK != error_flag ) || ( NFC7SPI_T2T_ACK != ctx->pkt_data.payload[ 0 ] ) )
    {
        log_printf ( &logger, " Write block %u failed with error %.2X\r\n", 
                     ( uint16_t ) wr_block[ 1 ], 
                     ( uint16_t ) ctx->pkt_data.payload[ ctx->pkt_data.payload_len - 1 ] );
        return;
    }
    log_printf ( &logger, " Block %u written\r\n", ( uint16_t ) wr_block[ 1 ] );
    
    // Read back block
    ctx->pkt_data.payload_len = sizeof ( rd_block );
    memcpy ( ctx->pkt_data.payload, rd_block, ctx->pkt_data.payload_len );
    error_flag = nfc7spi_reader_tag_cmd ( ctx, &ctx->pkt_data );
    if ( ( NFC7SPI_OK != error_flag ) || 
         ( NFC7SPI_NCI_STAT_OK != ctx->pkt_data.payload[ ctx->pkt_data.payload_len - 1 ] ) )
    {
        log_printf ( &logger, " Read block %u failed with error %.2X\r\n", 
                     ( uint16_t ) rd_block[ 1 ], 
                     ( uint16_t ) ctx->pkt_data.payload[ ctx->pkt_data.payload_len - 1 ] );
        return;
    }
    log_printf ( &logger, " Read block %u: ", ( uint16_t ) rd_block[ 1 ] );
    for ( uint8_t cnt = 0; cnt < 4; cnt++ )
    {
        log_printf( &logger, "%.2X ", ( uint16_t ) ctx->pkt_data.payload[ cnt ] );
    }
    log_printf( &logger, "\r\n" );
}

static void nfc7spi_handle_iso14443_4 ( nfc7spi_t *ctx )
{
    err_t error_flag = NFC7SPI_OK;

    ctx->pkt_data.payload_len = strlen ( NFC7SPI_T4T_PPSE_APDU ) + 6;
    ctx->pkt_data.payload[ 0 ] = NFC7SPI_T4T_CLA_NO_SECURE;
    ctx->pkt_data.payload[ 1 ] = NFC7SPI_T4T_INS_SELECT;
    ctx->pkt_data.payload[ 2 ] = NFC7SPI_T4T_P1_SELECT_BY_NAME;
    ctx->pkt_data.payload[ 3 ] = NFC7SPI_T4T_P2_ONLY_OCCURANCE;
    ctx->pkt_data.payload[ 4 ] = strlen ( NFC7SPI_T4T_PPSE_APDU );
    memcpy ( &ctx->pkt_data.payload[ 5 ], NFC7SPI_T4T_PPSE_APDU, strlen ( NFC7SPI_T4T_PPSE_APDU ) );
    ctx->pkt_data.payload[ ctx->pkt_data.payload_len - 1 ] = NFC7SPI_T4T_LE_RSP_MAY_PRESENT;
    error_flag = nfc7spi_reader_tag_cmd ( ctx, &ctx->pkt_data );
    if ( ( NFC7SPI_OK != error_flag ) || 
         ( NFC7SPI_T4T_RSP_COMPLETE_1 != ctx->pkt_data.payload[ ctx->pkt_data.payload_len - 2 ] ) || 
         ( NFC7SPI_T4T_RSP_COMPLETE_2 != ctx->pkt_data.payload[ ctx->pkt_data.payload_len - 1 ] ) )
    {
        log_printf ( &logger, " Select PPSE failed with error %.2X %.2X\r\n", 
                     ( uint16_t ) ctx->pkt_data.payload[ ctx->pkt_data.payload_len - 2 ], 
                     ( uint16_t ) ctx->pkt_data.payload[ ctx->pkt_data.payload_len - 1 ] );
        return;
    }
    log_printf ( &logger, " Select PPSE Application succeed\r\n" );
}

static void nfc7spi_handle_iso15693 ( nfc7spi_t *ctx )
{
    #define BLK_NB_ISO15693     32
    #define DATA_WRITE_ISO15693 0x11, 0x22, 0x33, 0x44
    uint8_t rd_block[ ] = { NFC7SPI_ISO15693_FLAG_DR_HIGH, NFC7SPI_ISO15693_CMD_READ_SINGLE, BLK_NB_ISO15693 };
    uint8_t wr_block[ ] = { NFC7SPI_ISO15693_FLAG_DR_HIGH, NFC7SPI_ISO15693_CMD_WRITE_SINGLE, 
                            BLK_NB_ISO15693, DATA_WRITE_ISO15693 };
    err_t error_flag = NFC7SPI_OK;

    // Read
    ctx->pkt_data.payload_len = sizeof ( rd_block );
    memcpy ( ctx->pkt_data.payload, rd_block, ctx->pkt_data.payload_len );
    error_flag = nfc7spi_reader_tag_cmd ( ctx, &ctx->pkt_data );
    if ( ( NFC7SPI_OK != error_flag ) || 
         ( NFC7SPI_ISO15693_RSP_OK != ctx->pkt_data.payload[ ctx->pkt_data.payload_len - 1 ] ) )
    {
        log_printf ( &logger, " Read block %u failed with error %.2X\r\n", 
                     ( uint16_t ) rd_block[ 2 ], 
                     ( uint16_t ) ctx->pkt_data.payload[ ctx->pkt_data.payload_len - 1 ] );
        return;
    }
    log_printf ( &logger, " Read block %u: ", ( uint16_t ) rd_block[ 2 ] );
    for ( uint8_t cnt = 0; cnt < ( ctx->pkt_data.payload_len - 2 ); cnt++ )
    {
        log_printf( &logger, "%.2X ", ( uint16_t ) ctx->pkt_data.payload[ cnt + 1 ] );
    }
    log_printf( &logger, "\r\n" );

    // Write
    ctx->pkt_data.payload_len = sizeof ( wr_block );
    memcpy ( ctx->pkt_data.payload, wr_block, ctx->pkt_data.payload_len );
    error_flag = nfc7spi_reader_tag_cmd ( ctx, &ctx->pkt_data );
    if ( ( NFC7SPI_OK != error_flag ) || 
         ( NFC7SPI_ISO15693_RSP_OK != ctx->pkt_data.payload[ ctx->pkt_data.payload_len - 1 ] ) )
    {
        log_printf ( &logger, " Write block %u failed with error %.2X\r\n", 
                     ( uint16_t ) wr_block[ 2 ], 
                     ( uint16_t ) ctx->pkt_data.payload[ ctx->pkt_data.payload_len - 1 ] );
        return;
    }
    log_printf ( &logger, " Block %u written\r\n", ( uint16_t ) wr_block[ 2 ] );
    
    // Read back
    ctx->pkt_data.payload_len = sizeof ( rd_block );
    memcpy ( ctx->pkt_data.payload, rd_block, ctx->pkt_data.payload_len );
    error_flag = nfc7spi_reader_tag_cmd ( ctx, &ctx->pkt_data );
    if ( ( NFC7SPI_OK != error_flag ) || 
         ( NFC7SPI_ISO15693_RSP_OK != ctx->pkt_data.payload[ ctx->pkt_data.payload_len - 1 ] ) )
    {
        log_printf ( &logger, " Read block %u failed with error %.2X\r\n", 
                     ( uint16_t ) rd_block[ 2 ], 
                     ( uint16_t ) ctx->pkt_data.payload[ ctx->pkt_data.payload_len - 1 ] );
        return;
    }
    log_printf ( &logger, " Read block %u: ", ( uint16_t ) rd_block[ 2 ] );
    for ( uint8_t cnt = 0; cnt < ( ctx->pkt_data.payload_len - 2 ); cnt++ )
    {
        log_printf( &logger, "%.2X ", ( uint16_t ) ctx->pkt_data.payload[ cnt + 1 ] );
    }
    log_printf( &logger, "\r\n" );
}

static void nfc7spi_handle_mifare ( nfc7spi_t *ctx )
{
    #define BLK_NB_MFC      32 // Do not use first 4 blocks and sector trailer blocks (7, 11, 15, etc)
    #define KEY_MFC         0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
    #define DATA_WRITE_MFC  0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF
    uint8_t authenticate[ ] = { NFC7SPI_MFC_REQ_AUTHENTICATE, BLK_NB_MFC / 4, NFC7SPI_MFC_KEY_SELECTOR_A_EMB, KEY_MFC };
    uint8_t rd_block[ ] = { NFC7SPI_MFC_REQ_XCHG_DATA, NFC7SPI_MFC_CMD_READ, BLK_NB_MFC };
    uint8_t wr_part1[ ] = { NFC7SPI_MFC_REQ_XCHG_DATA, NFC7SPI_MFC_CMD_WRITE, BLK_NB_MFC };
    uint8_t wr_part2[ ] = { NFC7SPI_MFC_REQ_XCHG_DATA, DATA_WRITE_MFC };
    err_t error_flag = NFC7SPI_OK;

    if ( ( BLK_NB_MFC < 4 ) || ( 3 == ( BLK_NB_MFC % 4 ) ) )
    {
        log_printf ( &logger, " Block %u is a sector trailer block\r\n", ( uint16_t ) BLK_NB_MFC );
        return;
    }
    // Authenticate
    ctx->pkt_data.payload_len = sizeof ( authenticate );
    memcpy ( ctx->pkt_data.payload, authenticate, ctx->pkt_data.payload_len );
    error_flag = nfc7spi_reader_tag_cmd ( ctx, &ctx->pkt_data );
    if ( ( NFC7SPI_OK != error_flag ) || 
         ( NFC7SPI_NCI_STAT_OK != ctx->pkt_data.payload[ ctx->pkt_data.payload_len - 1 ] ) )
    {
        log_printf ( &logger, " Authenticate sector %u failed with error %.2X\r\n", 
                     ( uint16_t ) authenticate[ 1 ], 
                     ( uint16_t ) ctx->pkt_data.payload[ ctx->pkt_data.payload_len - 1 ] );
        return;
    }
    log_printf ( &logger, " Authenticate sector %u succeed\r\n", ( uint16_t ) authenticate[ 1 ] );

    // Read block
    ctx->pkt_data.payload_len = sizeof ( rd_block );
    memcpy ( ctx->pkt_data.payload, rd_block, ctx->pkt_data.payload_len );
    error_flag = nfc7spi_reader_tag_cmd ( ctx, &ctx->pkt_data );
    if ( ( NFC7SPI_OK != error_flag ) || 
         ( NFC7SPI_NCI_STAT_OK != ctx->pkt_data.payload[ ctx->pkt_data.payload_len - 1 ] ) )
    {
        log_printf ( &logger, " Read block %u failed with error %.2X\r\n", 
                     ( uint16_t ) rd_block[ 2 ], 
                     ( uint16_t ) ctx->pkt_data.payload[ ctx->pkt_data.payload_len - 1 ] );
        return;
    }
    log_printf ( &logger, " Read block %u: ", ( uint16_t ) rd_block[ 2 ] );
    for ( uint8_t cnt = 0; cnt < ( ctx->pkt_data.payload_len - 2 ); cnt++ )
    {
        log_printf( &logger, "%.2X ", ( uint16_t ) ctx->pkt_data.payload[ cnt + 1 ] );
    }
    log_printf( &logger, "\r\n" );

    // Write block
    ctx->pkt_data.payload_len = sizeof ( wr_part1 );
    memcpy ( ctx->pkt_data.payload, wr_part1, ctx->pkt_data.payload_len );
    error_flag = nfc7spi_reader_tag_cmd ( ctx, &ctx->pkt_data );
    if ( ( NFC7SPI_OK != error_flag ) || ( NFC7SPI_MFC_ACK != ctx->pkt_data.payload[ 1 ] ) )
    {
        log_printf ( &logger, " Write block %u failed with error %.2X\r\n", 
                     ( uint16_t ) wr_part1[ 2 ], 
                     ( uint16_t ) ctx->pkt_data.payload[ ctx->pkt_data.payload_len - 1 ] );
        return;
    }
    ctx->pkt_data.payload_len = sizeof ( wr_part2 );
    memcpy ( ctx->pkt_data.payload, wr_part2, ctx->pkt_data.payload_len );
    error_flag = nfc7spi_reader_tag_cmd ( ctx, &ctx->pkt_data );
    if ( ( NFC7SPI_OK != error_flag ) || ( NFC7SPI_MFC_ACK != ctx->pkt_data.payload[ 1 ] ) )
    {
        log_printf ( &logger, " Write block %u failed with error %.2X\r\n", 
                     ( uint16_t ) wr_part1[ 2 ], 
                     ( uint16_t ) ctx->pkt_data.payload[ ctx->pkt_data.payload_len - 1 ] );
        return;
    }
    log_printf ( &logger, " Block %u written\r\n", ( uint16_t ) wr_part1[ 2 ] );
    
    // Read back
    ctx->pkt_data.payload_len = sizeof ( rd_block );
    memcpy ( ctx->pkt_data.payload, rd_block, ctx->pkt_data.payload_len );
    error_flag = nfc7spi_reader_tag_cmd ( ctx, &ctx->pkt_data );
    if ( ( NFC7SPI_OK != error_flag ) || 
         ( NFC7SPI_NCI_STAT_OK != ctx->pkt_data.payload[ ctx->pkt_data.payload_len - 1 ] ) )
    {
        log_printf ( &logger, " Read block %u failed with error %.2X\r\n", 
                     ( uint16_t ) rd_block[ 2 ], 
                     ( uint16_t ) ctx->pkt_data.payload[ ctx->pkt_data.payload_len - 1 ] );
        return;
    }
    log_printf ( &logger, " Read block %u: ", ( uint16_t ) rd_block[ 2 ] );
    for ( uint8_t cnt = 0; cnt < ( ctx->pkt_data.payload_len - 2 ); cnt++ )
    {
        log_printf( &logger, "%.2X ", ( uint16_t ) ctx->pkt_data.payload[ cnt + 1 ] );
    }
    log_printf( &logger, "\r\n" );
}

static void nfc7spi_display_card_info ( nfc7spi_rf_intf_t rf_intf )
{
    switch ( rf_intf.protocol )
    {
        case NFC7SPI_NCI_RF_PROT_T1T:
        case NFC7SPI_NCI_RF_PROT_T2T:
        case NFC7SPI_NCI_RF_PROT_T3T:
        case NFC7SPI_NCI_RF_PROT_ISODEP:
        {
            log_printf( &logger, " - POLL MODE: Remote T%uT activated\r\n", ( uint16_t ) rf_intf.protocol );
            break;
        }
        case NFC7SPI_NCI_RF_PROT_T5T:
        {
            log_printf( &logger, " - POLL MODE: Remote ISO15693 card activated\r\n" );
            break;
        }
        case NFC7SPI_NCI_RF_PROT_MIFARE:
        {
            log_printf( &logger, " - POLL MODE: Remote MIFARE card activated\r\n" );
            break;
        }
        default:
        {
            log_printf( &logger, " - POLL MODE: Undetermined target\r\n" );
            return;
        }
    }

    switch ( rf_intf.mode_tech )
    {
        case NFC7SPI_NCI_RF_TECH_PASSIVE_POLL_NFC_A:
        {
            log_printf( &logger, "\tSENS_RES = %.2X %.2X\r\n", 
                        ( uint16_t ) rf_intf.info.nfc_app.sens_res[ 0 ], 
                        ( uint16_t ) rf_intf.info.nfc_app.sens_res[ 1 ] );
            log_printf( &logger, "\tNFCID = " );
            for ( uint8_t cnt = 0; cnt < rf_intf.info.nfc_app.nfc_id_len; cnt++ )
            {
                log_printf( &logger, "%.2X ", ( uint16_t ) rf_intf.info.nfc_app.nfc_id[ cnt ] );
            }
            log_printf( &logger, "\r\n" );
            if ( 0 != rf_intf.info.nfc_app.sel_res_len )
            {
                log_printf( &logger, "\tSEL_RES = %.2X\r\n", ( uint16_t ) rf_intf.info.nfc_app.sens_res[ 0 ] );
            }
            break;
        }
        case NFC7SPI_NCI_RF_TECH_PASSIVE_POLL_NFC_B:
        {
            if ( 0 != rf_intf.info.nfc_bpp.sens_res_len )
            {
                log_printf( &logger, "\tSENS_RES = " );
                for ( uint8_t cnt = 0; cnt < rf_intf.info.nfc_bpp.sens_res_len; cnt++ )
                {
                    log_printf( &logger, "%.2X ", ( uint16_t ) rf_intf.info.nfc_bpp.sens_res[ cnt ] );
                }
                log_printf( &logger, "\r\n" );
            }
            break;
        }
        case NFC7SPI_NCI_RF_TECH_PASSIVE_POLL_NFC_F:
        {
            log_printf( &logger, "\tBitrate = %s\r\n", ( char * ) 
                        ( ( 1 == rf_intf.info.nfc_fpp.bitrate ) ? "212" : "424" ) );
            if ( 0 != rf_intf.info.nfc_fpp.sens_res_len )
            {
                log_printf( &logger, "\tSENS_RES = " );
                for ( uint8_t cnt = 0; cnt < rf_intf.info.nfc_fpp.sens_res_len; cnt++ )
                {
                    log_printf( &logger, "%.2X ", ( uint16_t ) rf_intf.info.nfc_fpp.sens_res[ cnt ] );
                }
                log_printf( &logger, "\r\n" );
            }
            break;
        }
        case NFC7SPI_NCI_RF_TECH_PASSIVE_POLL_15693:
        {
            log_printf( &logger, "\tID = " );
            for ( uint8_t cnt = 0; cnt < sizeof ( rf_intf.info.nfc_vpp.id ); cnt++ )
            {
                log_printf( &logger, "%.2X ", ( uint16_t ) rf_intf.info.nfc_vpp.id[ cnt ] );
            }
            log_printf( &logger, "\r\n" );
            log_printf( &logger, "\tAFI = %.2X\r\n", ( uint16_t ) rf_intf.info.nfc_vpp.afi );
            log_printf( &logger, "\tDSFID = %.2X\r\n", ( uint16_t ) rf_intf.info.nfc_vpp.dsf_id );
            break;
        }
        default:
        {
            break;
        }
    }
}

// ------------------------------------------------------------------------ END