nfc_st25dv16kc.c

Go to the documentation of this file.

/*
 * nfc_st25dv16kc.c
 *
 *  Created on: 9. 3. 2026
 *      Author: Milan
 *
 *  ST25DV16KC – Dynamic NFC/RFID Tag with 16Kbit EEPROM.
 *
 *  I2C communication uses 16-bit register addressing throughout.
 *  All dynamic registers (0x2000-0x2107) are in the User memory address
 *  space (I2C 0xA6).  System registers require password presentation before
 *  writing.
 *
 *  Default I2C password: 8 x 0x00.
 */
 
#include "i2c.h"
#include "nfc_st25dv16kc.h"
#include <string.h>
 
/* ---------------------------------------------------------------------------
 * I2C addresses (8-bit, shifted for HAL)
 * --------------------------------------------------------------------------- */
#define ST25DV16KC_I2C_ADDR_USER    (0x53 << 1)  /**< User memory / EEPROM - A6  */
#define ST25DV16KC_I2C_ADDR_SYSTEM  (0x57 << 1)  /**< System configuration - AE */
 
/* ---------------------------------------------------------------------------
 * Dynamic registers – accessible via User I2C address (16-bit addressing)
 * --------------------------------------------------------------------------- */
#define ST25DV16KC_REG_GPO_CTRL_DYN   0x2000U  /**< GPO control (dynamic)        */
#define ST25DV16KC_REG_EH_CTRL_DYN    0x2001U  /**< Energy-harvesting ctrl (dyn) */
#define ST25DV16KC_REG_RF_MNGT_DYN    0x2002U  /**< RF management (dynamic)      */
#define ST25DV16KC_REG_I2C_SSO_DYN    0x2003U  /**< I2C security-session open    */
#define ST25DV16KC_REG_MB_CTRL_DYN    0x2006U  /**< Mailbox control (dynamic)    */
#define ST25DV16KC_REG_MB_LEN_DYN     0x2007U  /**< Mailbox message length (dyn) */
#define ST25DV16KC_REG_MB_DATA        0x2008U  /**< Mailbox RAM start (256 bytes)*/
 
/* ---------------------------------------------------------------------------
 * System registers – accessible via System I2C address (16-bit addressing)
 * (require I2C password presentation for write access)
 * --------------------------------------------------------------------------- */
#define ST25DV16KC_SYS_REG_RF_MNGT   0x0003U  /**< RF_MNGT static register      */
#define ST25DV16KC_SYS_REG_MB_MODE   0x000DU  /**< Mailbox enable (static)      */
#define ST25DV16KC_SYS_REG_I2C_PWD   0x0900U  /**< I2C password register        */
 
/* ---------------------------------------------------------------------------
 * GPO_CTRL_DYN bit masks
 * --------------------------------------------------------------------------- */
#define ST25DV16KC_GPO_EN            0x80U  /**< GPO output enable              */
#define ST25DV16KC_GPO_MSG_READY_EN  0x40U  /**< GPO on mailbox message-ready   */
#define ST25DV16KC_GPO_RF_ACTIVITY   0x20U  /**< GPO on RF activity             */
#define ST25DV16KC_GPO_RF_INTERRUPT  0x10U  /**< GPO on RF interrupt            */
#define ST25DV16KC_GPO_FIELD_CHANGE  0x08U  /**< GPO on RF field change         */
#define ST25DV16KC_GPO_RF_PUT_MSG    0x04U  /**< GPO when RF writes to mailbox  */
#define ST25DV16KC_GPO_RF_GET_MSG    0x02U  /**< GPO when RF reads mailbox      */
#define ST25DV16KC_GPO_RF_WRITE      0x01U  /**< GPO on RF EEPROM write         */
 
/** GPO value used by nfc_st25dv16kc_On(): all events enabled */
#define ST25DV16KC_GPO_ALL_EN  (ST25DV16KC_GPO_EN | ST25DV16KC_GPO_MSG_READY_EN | \
                                 ST25DV16KC_GPO_FIELD_CHANGE | ST25DV16KC_GPO_RF_WRITE)
 
/** GPO value used by nfc_st25dv16kc_INT_On(): field-change interrupt only */
#define ST25DV16KC_GPO_INT_EN  (ST25DV16KC_GPO_EN | ST25DV16KC_GPO_FIELD_CHANGE)
 
/* ---------------------------------------------------------------------------
 * MB_CTRL_DYN bit masks
 * --------------------------------------------------------------------------- */
#define ST25DV16KC_MB_EN             0x01U  /**< Enable mailbox                 */
#define ST25DV16KC_MB_RF_PUT_MSG     0x02U  /**< RF has written to mailbox      */
#define ST25DV16KC_MB_I2C_PUT_MSG    0x04U  /**< I2C host has written to mailbox*/
 
/* ---------------------------------------------------------------------------
 * RF_MNGT_DYN bit masks
 * --------------------------------------------------------------------------- */
#define ST25DV16KC_RF_SLEEP          0x01U  /**< Put RF analog block to sleep   */
#define ST25DV16KC_RF_DISABLE        0x02U  /**< Fully disable RF interface     */
 
/* ---------------------------------------------------------------------------
 * EH_CTRL_DYN bit masks
 * --------------------------------------------------------------------------- */
#define ST25DV16KC_EH_FIELD_ON       0x04U  /**< RF field is currently detected */
 
/* ---------------------------------------------------------------------------
 * RF busy-wait parameters
 * --------------------------------------------------------------------------- */
/** Maximum number of 5 ms wait cycles before giving up (100 ms total). */
#define ST25DV16KC_RF_BUSY_TIMEOUT   20U
 
/* ---------------------------------------------------------------------------
 * Mailbox size
 * --------------------------------------------------------------------------- */
#define ST25DV16KC_MB_SIZE           256U   /**< Mailbox buffer size in bytes   */
 
/* ---------------------------------------------------------------------------
 * Module-private state
 * --------------------------------------------------------------------------- */
 
/** 1 when the chip is present and successfully initialised, 0 otherwise. */
static int8_t _isNfc = 0;
static int8_t _isOnOff = 1; // cumulative on/off - on start is on
#define EEPROM_TIMEOUT 5000 // because of phone and conflict with read/write the timeout must be longer
/* ---------------------------------------------------------------------------
 * Static (private) helpers
 * --------------------------------------------------------------------------- */
 
#if 0
static HAL_StatusTypeDef nfc_st25dv16kc_PresentPassword(I2C_HandleTypeDef *hi2c)
{
    HAL_StatusTypeDef status;
    uint8_t pwd_payload[17] = {0,0,0,0,0,0,0,0,9,0,0,0,0,0,0,0,0}; // toto je spravne nastavene heslo
 
 
 
    status = HAL_I2C_Mem_Write(hi2c, ST25DV16KC_I2C_ADDR_SYSTEM, ST25DV16KC_SYS_REG_I2C_PWD, I2C_MEMADD_SIZE_16BIT, pwd_payload, sizeof(pwd_payload), 200);
    return status;
}
 
 
 
/**
 * @brief Present the default I2C password to open a security session.
 *        The payload is: [0x09 validation code] + [8-byte pwd] + [8-byte pwd].
 *        Default password is 8 x 0x00.
 * @param hi2c Pointer to I2C handle.
 * @retval HAL_StatusTypeDef result of the I2C write.
 */
static HAL_StatusTypeDef nfc_st25dv16kc_PresentPassword(I2C_HandleTypeDef *hi2c)
{
    HAL_StatusTypeDef status;
//  uint8_t pwd_payload[17];
//  pwd_payload[0] = 0x09; // Validation code
 
//  memset(&pwd_payload[1], 0x00, 16); // 8-byte pwd repeated twice (default)
 
//  status = HAL_I2C_Mem_Write(hi2c, ST25DV16KC_I2C_ADDR_SYSTEM, ST25DV16KC_SYS_REG_I2C_PWD, I2C_MEMADD_SIZE_16BIT, pwd_payload, 17, 200);
 
    uint8_t pwd_payload[9];
    pwd_payload[8] = 0x09; // Validation code
 
    static uint8_t ppp = 0;
    int i;
    char buf[9] = {};
    for (i=0; i<8; i++)
    {
        pwd_payload[i] = ((ppp>>i) & 1);
        buf[i] = pwd_payload[i]+'0';
    }
    ++ppp;
    writeLog(buf);
 
 
 
    //memset(&pwd_payload[1], 0x01, 8); // 8-byte pwd repeated twice (default)
    status = HAL_I2C_Mem_Write(hi2c, ST25DV16KC_I2C_ADDR_SYSTEM, ST25DV16KC_SYS_REG_I2C_PWD, I2C_MEMADD_SIZE_16BIT, pwd_payload, sizeof(pwd_payload), 200);
    if (status == HAL_OK)
    {
 
        HAL_Delay(10);
 
        //uint8_t lock = 0;
        //status = HAL_I2C_Mem_Read(hi2c, ST25DV16KC_I2C_ADDR_SYSTEM, 0x0801, I2C_MEMADD_SIZE_16BIT, &lock, 1, 100);
        //if (status == HAL_OK)
        //  writeLog("pwdOK:%d", (int)lock);
    }
 
 
    return status;
}
 
static HAL_StatusTypeDef nfc_st25dv16kc_SetRFMgmt(I2C_HandleTypeDef *hi2c, uint8_t enable)
{
    HAL_StatusTypeDef status = HAL_ERROR;
    uint8_t val = enable ? 0x00 : 0x01; // 0 = RF Enabled, 1 = RF Disabled
 
    if (_isNfc)
        do
        {
            if ((status = nfc_st25dv16kc_PresentPassword(hi2c)) != HAL_OK)
                break;
            if ((status = HAL_I2C_Mem_Write(hi2c, ST25DV16KC_I2C_ADDR_SYSTEM, 0x0003, 2, &val, 1, 100)) != HAL_OK)
                break;
        }while(0);
    return status;
}
 
 
#define ST25_ADDR_SYST         0xAE
#define ST25_ADDR_USER         0xA6
 
// Default values for common System Registers
#define REG_GPO_DEFAULT        0x00  // All interrupts disabled, active low
#define REG_RF_MNGT_DEFAULT    0x00  // RF enabled, no sleep
#define REG_IT_TIME_DEFAULT    0x03  // Standard pulse duration
static HAL_StatusTypeDef ST25_FactoryReset_Config(I2C_HandleTypeDef *hi2c)
{
    HAL_StatusTypeDef status;
    uint8_t data;
 
 
    nfc_st25dv16kc_PresentPassword(hi2c);
 
    // 1. Reset GPO Strategy (Address 0x0000 in System Area)
    data = REG_GPO_DEFAULT;
    status = HAL_I2C_Mem_Write(hi2c, ST25_ADDR_SYST, 0x0000,
                               I2C_MEMADD_SIZE_16BIT, &data, 1, 100);
    if (status != HAL_OK) return status;
 
    // 2. Reset RF Management (Address 0x0003 in System Area)
    data = REG_RF_MNGT_DEFAULT;
    status = HAL_I2C_Mem_Write(hi2c, ST25_ADDR_SYST, 0x0003,
                               I2C_MEMADD_SIZE_16BIT, &data, 1, 100);
 
    // 3. Clear User Memory (Optional but recommended for 'Full' reset)
    // For the 16KC (2KB), we loop through blocks.
    uint8_t empty[16] = {0};
    for(uint16_t i = 0; i < 2048; i += 16) {
        HAL_I2C_Mem_Write(hi2c, ST25_ADDR_USER, i,
                          I2C_MEMADD_SIZE_16BIT, empty, 16, 100);
        HAL_Delay(5); // EEPROM write cycle time
    }
 
    return status;
}
#endif
/**
 * @brief Write a value to GPO_CTRL_DYN with retry to tolerate transient NACKs
 *        from the RF field.
 * @param hi2c  Pointer to I2C handle.
 * @param value Byte value to write to GPO_CTRL_DYN.
 * @retval HAL_StatusTypeDef result of the last I2C write attempt.
 */
static HAL_StatusTypeDef nfc_st25dv16kc_WriteGPO(I2C_HandleTypeDef *hi2c, uint8_t value)
{
    HAL_StatusTypeDef status = HAL_ERROR;
    uint8_t reg_val = value;
    uint8_t i;
 
    for (i = 0; i < 5; i++)
    {
        status = HAL_I2C_Mem_Write(hi2c, ST25DV16KC_I2C_ADDR_USER, ST25DV16KC_REG_GPO_CTRL_DYN, I2C_MEMADD_SIZE_16BIT, &reg_val, 1, 100);
        if (status == HAL_OK)
            break;
        HAL_Delay(10);
    }
    /* If repeated failures, the chip is no longer responding */
    _isNfc = (status == HAL_OK);
    return status;
}
 
/* ---------------------------------------------------------------------------
 * Public API implementation
 * --------------------------------------------------------------------------- */
 
int8_t nfc_st25dv16kc_Is(I2C_HandleTypeDef *hi2c, int8_t tryInit)
{
    if (!_isNfc && tryInit)
        nfc_st25dv16kc_Init(hi2c);
    return _isNfc;
}
 
HAL_StatusTypeDef nfc_st25dv16kc_Init(I2C_HandleTypeDef *hi2c)
{
    HAL_StatusTypeDef status;
 
    do
    {
        /* 1. Verify the chip is on the I2C bus */
        if ((status = I2C_IsDeviceReadyMT(hi2c, ST25DV16KC_I2C_ADDR_USER, 10, 100)) != HAL_OK)
            break;
 
 
        // on ST25DV16KC-J - LoRa_PHT v1 is mail box not available
#if 0
 
 
        /* 2. Enable the Mailbox (MB_EN bit in MB_CTRL_DYN).
         *    Use a retry loop because an active RF field may cause a NACK.*/
 
        // before mailbox - the password
        if ((status = nfc_st25dv16kc_PresentPassword(hi2c)) != HAL_OK)
            break;
 
 
 
        uint8_t reg_val = ST25DV16KC_MB_EN;
        uint8_t i;
        for (i = 0; i < 5; i++)
        {
            status = HAL_I2C_Mem_Write(hi2c, ST25DV16KC_I2C_ADDR_USER,  ST25DV16KC_REG_MB_CTRL_DYN, I2C_MEMADD_SIZE_16BIT, &reg_val, 1, 100);
            if (status == HAL_OK)
                break;
            HAL_Delay(10);
        }
        if (status != HAL_OK)
            break;
 
        /* 3. Wait for the mailbox to stabilise */
        HAL_Delay(50);
#endif
 
        /* 5. Mark as present and switch GPO off (lowest-power default) */
        _isNfc = 1;
        nfc_st25dv16kc_Off(hi2c);
 
    } while (0);
 
    return status;
}
 
HAL_StatusTypeDef nfc_st25dv16kc_IsOn(I2C_HandleTypeDef *hi2c, uint8_t *onOff)
{
    HAL_StatusTypeDef status = HAL_ERROR;
 
    if (_isNfc)
    {
        uint8_t reg_val = 0;
        status = HAL_I2C_Mem_Read(hi2c, ST25DV16KC_I2C_ADDR_USER, ST25DV16KC_REG_GPO_CTRL_DYN, I2C_MEMADD_SIZE_16BIT, &reg_val, 1, 100);
        if (status == HAL_OK && onOff != NULL)
            *onOff = (reg_val & ST25DV16KC_GPO_EN) ? 1U : 0U;
    }
    return status;
}
 
HAL_StatusTypeDef nfc_st25dv16kc_On(I2C_HandleTypeDef *hi2c)
{
    HAL_StatusTypeDef status = HAL_ERROR;
 
    if (_isNfc)
    {
        status = HAL_OK;
        if (_isOnOff++ == 0)
        {
            /* Enable GPO with all relevant event bits:
             *   GPO_EN | MSG_READY | FIELD_CHANGE | RF_WRITE = 0xC9 */
            status = nfc_st25dv16kc_WriteGPO(hi2c, ST25DV16KC_GPO_ALL_EN);
        }
    }
    return status;
}
 
HAL_StatusTypeDef nfc_st25dv16kc_Off(I2C_HandleTypeDef *hi2c)
{
    HAL_StatusTypeDef status = HAL_ERROR;
 
    if (_isNfc)
    {
        status = HAL_OK;
 
        if (_isOnOff > 0)
        {
            if (--_isOnOff == 0)
            {
                /* Disable GPO output */
                //status = nfc_st25dv16kc_WriteGPO(hi2c, 0x00); //leave all to by availble on phone
                status = nfc_st25dv16kc_WriteGPO(hi2c, ST25DV16KC_GPO_EN);  // GPO-INT
 
                /* Put RF to sleep for minimum current consumption (~1 µA).
                 * RF_MNGT_DYN is a dynamic register – no password required. */
                if (status == HAL_OK)
                {
                    uint8_t rf_val = ST25DV16KC_RF_SLEEP;
                    status = HAL_I2C_Mem_Write(hi2c, ST25DV16KC_I2C_ADDR_USER, ST25DV16KC_REG_RF_MNGT_DYN, I2C_MEMADD_SIZE_16BIT, &rf_val, 1, 100);
                }
            }
        }
    }
    return status;
}
 
#if 0
int8_t nfc_st25dv16kc_IsRFBusy(I2C_HandleTypeDef *hi2c)
{
    uint8_t reg_val = 0;
 
    if (_isNfc)
    {
 
        /* Read RF_MNGT_DYN (0x2002); bit 1 = FIELD_ON – RF field is present.
         * If the I2C read fails assume the field is not active. */
        if (HAL_I2C_Mem_Read(hi2c, ST25DV16KC_I2C_ADDR_USER, ST25DV16KC_REG_RF_MNGT_DYN,   // <-- was REG_EH_CTRL_DYN
                             I2C_MEMADD_SIZE_16BIT, &reg_val, 1, 50) != HAL_OK)
            return 0;
 
        /* FIELD_ON is bit 1 of RF_MNGT_DYN */
    }
    return (reg_val & 0x02U) ? 1 : 0;   // <-- was 0x04 on EH_CTRL_DYN
}
#endif
 
HAL_StatusTypeDef nfc_st25dv16kc_WriteEEPROM(I2C_HandleTypeDef *hi2c, uint16_t addr, uint8_t *pData, uint16_t len)
{
    HAL_StatusTypeDef status = HAL_ERROR;
 
    if (_isNfc)
    {
        status = HAL_OK;
 
        /* Wait for RF write to complete
         uint8_t retry_count = 0;
         while (nfc_st25dv16kc_IsRFBusy(hi2c))
         {
             HAL_Delay(5);
             if (++retry_count >= ST25DV16KC_RF_BUSY_TIMEOUT)
             {
                 status = HAL_TIMEOUT;
                 break;
             }
         }*/
        if (status == HAL_OK)
            do
            {
                uint16_t i = 0;
                while (i < len)
                {
                    /* ST25DV page size is 4 bytes for write operations */
                    /* Clip chunk to: remaining bytes, max 4, and must not cross 4-byte page */
                    uint16_t page_offset = (addr + i) % 4;  // offset within current 4-byte page
                    uint16_t max_in_page = 4 - page_offset;  // bytes left in this page
                    uint16_t remaining = len - i;
                    uint16_t chunk = remaining < max_in_page ? remaining : max_in_page;
 
                    /* Poll for ACK — device NACKs during internal write cycle */
                    uint8_t retry = 0;
                    do
                    {
                        if ((status = HAL_I2C_Mem_Write(hi2c, ST25DV16KC_I2C_ADDR_USER, addr + i, I2C_MEMADD_SIZE_16BIT, &pData[i], chunk, EEPROM_TIMEOUT)) == HAL_OK)
                            break;  // break on HAL_OK, do no need more attempts
                        HAL_Delay(2);
                    } while (++retry < 10);
 
                    if (status != HAL_OK)
                        break;
                    i += chunk;
                    HAL_Delay(6);  // tW: ensure write cycle completes before next page
                }
            } while (0);
    }
    return status;
}
 
HAL_StatusTypeDef nfc_st25dv16kc_ReadEEPROM(I2C_HandleTypeDef *hi2c, uint16_t addr, uint8_t *pData, uint16_t len)
{
    HAL_StatusTypeDef status = HAL_ERROR;
 
    if (_isNfc)
        status = HAL_I2C_Mem_Read(hi2c, ST25DV16KC_I2C_ADDR_USER, addr, I2C_MEMADD_SIZE_16BIT, pData, len, EEPROM_TIMEOUT);
    return status;
}
 
HAL_StatusTypeDef nfc_st25dv16kc_ProcessMailBox(I2C_HandleTypeDef *hi2c)
{
    uint8_t mb_ctrl = 0;
    uint8_t mb_len = 0;
 
    if (!_isNfc)
        return HAL_ERROR;
 
    /* Read mailbox control register to check for an RF-sourced message */
    if (HAL_I2C_Mem_Read(hi2c, ST25DV16KC_I2C_ADDR_USER,
    ST25DV16KC_REG_MB_CTRL_DYN, I2C_MEMADD_SIZE_16BIT, &mb_ctrl, 1, 100) != HAL_OK)
        return HAL_ERROR;
 
    if (mb_ctrl & ST25DV16KC_MB_RF_PUT_MSG)
    {
        /* Get message length (register value = length - 1) */
        if (HAL_I2C_Mem_Read(hi2c, ST25DV16KC_I2C_ADDR_USER,
        ST25DV16KC_REG_MB_LEN_DYN, I2C_MEMADD_SIZE_16BIT, &mb_len, 1, 100) != HAL_OK)
            return HAL_ERROR;
 
        uint16_t msg_len = (uint16_t) mb_len + 1U;
        if (msg_len > ST25DV16KC_MB_SIZE)
            msg_len = ST25DV16KC_MB_SIZE;
 
        uint8_t buffer[ST25DV16KC_MB_SIZE];
        if (HAL_I2C_Mem_Read(hi2c, ST25DV16KC_I2C_ADDR_USER,
        ST25DV16KC_REG_MB_DATA, I2C_MEMADD_SIZE_16BIT, buffer, msg_len, 300) != HAL_OK)
            return HAL_ERROR;
 
        nfc_st25dv16kc_OnMailboxData(buffer, msg_len);
        return HAL_OK;
    }
 
    return HAL_ERROR; /* No RF message pending */
}
 
HAL_StatusTypeDef nfc_st25dv16kc_WriteMailBox(I2C_HandleTypeDef *hi2c, uint8_t *pData, uint16_t len)
{
    HAL_StatusTypeDef status = HAL_ERROR;
    uint8_t reg_val;
 
    if (_isNfc)
    {
        if (len > ST25DV16KC_MB_SIZE)
            len = ST25DV16KC_MB_SIZE;
 
        do
        {
            /* Enable mailbox before writing */
            reg_val = ST25DV16KC_MB_EN;
            if ((status = HAL_I2C_Mem_Write(hi2c, ST25DV16KC_I2C_ADDR_USER, ST25DV16KC_REG_MB_CTRL_DYN, I2C_MEMADD_SIZE_16BIT, &reg_val, 1, 100)) != HAL_OK)
                break;
 
            /* Write payload into mailbox RAM */
            if ((status = HAL_I2C_Mem_Write(hi2c, ST25DV16KC_I2C_ADDR_USER, ST25DV16KC_REG_MB_DATA, I2C_MEMADD_SIZE_16BIT, pData, len, 300)) != HAL_OK)
                break;
        }while(0);
    }
    return status;
}
 
__weak void nfc_st25dv16kc_OnMailboxData(uint8_t *data, uint16_t len)
{
    /* Override in application code to handle received mailbox messages */
    (void) data;
    (void) len;
}