STM32duino ST25R3916

https://github.com/stm32duino/st25r3916
Admin
An Arduino library providing NFC RFAL (Radio Frequency Abstraction Layer) implementation for...
Tokens:10,763
Snippets:61
Trust Score:9.8
Update:2 months ago
Show doc for...
Tokens:
Raw
### Register Transceive Callbacks

Source: https://context7.com/stm32duino/st25r3916/llms.txt

Installs application-defined functions to be called before transmission, after reception, and at synchronization points. Useful for controlling external hardware like LEDs or RF switches.

```cpp
void myPreTxRx(void) {
  digitalWrite(LED_TX, HIGH);  // indicate TX active
}

void myPostTxRx(void) {
  digitalWrite(LED_TX, LOW);   // clear TX indicator
}

void mySync(void) {
  // optional synchronization point
}

rfal.rfalSetPreTxRxCallback(myPreTxRx);
rfal.rfalSetPostTxRxCallback(myPostTxRx);
rfal.rfalSetSyncTxRxCallback(mySync);
```

--------------------------------

### rfalSetPreTxRxCallback / rfalSetPostTxRxCallback / rfalSetSyncTxRxCallback

Source: https://context7.com/stm32duino/st25r3916/llms.txt

Install application-provided hooks that are called by the RFAL state machine immediately before transmission, after reception, and at synchronization points, respectively. These are useful for toggling LEDs, logging, or driving external RF switches.

```APIDOC
## rfalSetPreTxRxCallback / rfalSetPostTxRxCallback / rfalSetSyncTxRxCallback — Register transceive callbacks

### Description
Install application-provided hooks called by the RFAL state machine immediately before transmission, after reception, and at synchronization points respectively. Useful for toggling LEDs, logging, or driving external RF switches.

### Parameters
#### Request Body
- **preTxRxCallback** (void (*)(void)) - Callback function to be executed before transmission.
- **postTxRxCallback** (void (*)(void)) - Callback function to be executed after reception.
- **syncTxRxCallback** (void (*)(void)) - Callback function to be executed at synchronization points.

### Request Example
```cpp
void myPreTxRx(void) {
  digitalWrite(LED_TX, HIGH);  // indicate TX active
}

void myPostTxRx(void) {
  digitalWrite(LED_TX, LOW);   // clear TX indicator
}

void mySync(void) {
  // optional synchronization point
}

rfal.rfalSetPreTxRxCallback(myPreTxRx);
rfal.rfalSetPostTxRxCallback(myPostTxRx);
rfal.rfalSetSyncTxRxCallback(mySync);
```
```

--------------------------------

### Register Upper-Layer IRQ Callback

Source: https://context7.com/stm32duino/st25r3916/llms.txt

Installs a callback function that is invoked directly from the ST25R3916 Interrupt Service Routine (ISR). This allows higher-level layers to respond to hardware interrupts without polling.

```cpp
void nfcIrqHandler(void) {
  // Signal a FreeRTOS task or set a flag
  nfcEventFlag = true;
}

rfal.rfalSetUpperLayerCallback(nfcIrqHandler);
```

--------------------------------

### rfalSetUpperLayerCallback

Source: https://context7.com/stm32duino/st25r3916/llms.txt

Installs a callback function that is invoked from within the ST25R3916 Interrupt Service Routine (ISR). This allows higher-level NFC stack layers to react to hardware interrupts without constant polling.

```APIDOC
## rfalSetUpperLayerCallback — Register upper-layer IRQ callback

### Description
Installs a callback invoked from within the ST25R3916 ISR, allowing higher-level NFC stack layers to react to hardware interrupts without polling.

### Parameters
#### Request Body
- **irqCallback** (void (*)(void)) - The callback function to be registered.

### Request Example
```cpp
void nfcIrqHandler(void) {
  // Signal a FreeRTOS task or set a flag
  nfcEventFlag = true;
}

rfal.rfalSetUpperLayerCallback(nfcIrqHandler);
```
```

--------------------------------

### Execute ST25R3916 Direct Command

Source: https://context7.com/stm32duino/st25r3916/llms.txt

Sends a direct command byte to the chip to perform specific actions. Examples include clearing FIFOs, initiating transmissions, or calibrating regulators. Use for controlling chip operations directly.

```cpp
// Clear the FIFO, collision status, and IRQ status
ReturnCode err = rfal.st25r3916ExecuteCommand(ST25R3916_CMD_CLEAR_FIFO);

// Start a REQA transmission (short frame, no CRC)
err = rfal.st25r3916ExecuteCommand(ST25R3916_CMD_TRANSMIT_REQA);

// Trigger automatic regulator calibration
err = rfal.st25r3916ExecuteCommand(ST25R3916_CMD_ADJUST_REGULATORS);

if (err == ERR_NONE) {
  Serial.println("Direct command executed");
}
```

--------------------------------

### rfalSetMode

Source: https://context7.com/stm32duino/st25r3916/llms.txt

Sets the operating mode and bit rate for the ST25R3916 chip. This function configures the chip for a specific NFC technology (poll or listen) and programs the TX/RX bit rates. It must be called after `rfalInitialize` and before starting any transceive operation.

```APIDOC
## `rfalSetMode` — Set the operating mode and bit rate

Configures the chip for a specific NFC technology (poll or listen) and programs TX/RX bit rates. Must be called after `rfalInitialize` and before starting any transceive operation.

Supported `rfalMode` values: `RFAL_MODE_POLL_NFCA`, `RFAL_MODE_POLL_NFCB`, `RFAL_MODE_POLL_NFCF`, `RFAL_MODE_POLL_NFCV`, `RFAL_MODE_POLL_PICOPASS`, `RFAL_MODE_POLL_NFCA_T1T`, `RFAL_MODE_POLL_ACTIVE_P2P`, `RFAL_MODE_LISTEN_ACTIVE_P2P`, `RFAL_MODE_POLL_B_PRIME`, `RFAL_MODE_POLL_B_CTS`.

```cpp
// Set NFC-A (ISO14443A) poll mode at 106 kbit/s TX and RX
ReturnCode err = rfal.rfalSetMode(RFAL_MODE_POLL_NFCA, RFAL_BR_106, RFAL_BR_106);
if (err == ERR_NONE) {
  Serial.println("Mode set: NFC-A 106kbps");
}

// Set NFC-F (FeliCa) poll mode at 212 kbit/s
err = rfal.rfalSetMode(RFAL_MODE_POLL_NFCF, RFAL_BR_212, RFAL_BR_212);

// Available bit rate constants:
// RFAL_BR_106, RFAL_BR_212, RFAL_BR_424, RFAL_BR_848,
// RFAL_BR_1695, RFAL_BR_3390, RFAL_BR_6780, RFAL_BR_KEEP
```
```

--------------------------------

### Burst-Read ST25R3916 Registers

Source: https://context7.com/stm32duino/st25r3916/llms.txt

Reads multiple consecutive bytes from the chip starting at a specified register address into a buffer. Efficient for reading groups of related registers like FIFO status or configuration.

```cpp
uint8_t fifoStatus[2];
// Read ST25R3916_REG_FIFO_STATUS1 and STATUS2 in one burst
ReturnCode err = rfal.st25r3916ReadMultipleRegisters(ST25R3916_REG_FIFO_STATUS1, fifoStatus, 2);
if (err == ERR_NONE) {
  uint16_t fifoBytes = ((uint16_t)(fifoStatus[0]) | ((uint16_t)(fifoStatus[1] & 0x03) << 8));
  Serial.print("FIFO bytes available: ");
  Serial.println(fifoBytes);
}
```

--------------------------------

### Burst-Write ST25R3916 Registers

Source: https://context7.com/stm32duino/st25r3916/llms.txt

Writes multiple consecutive bytes from a buffer into chip registers starting at a specified address. Space-B access is handled transparently. Use for configuring multiple settings efficiently.

```cpp
// Configure both RX config registers in a single burst
uint8_t rxConf[2] = {
  ST25R3916_REG_RX_CONF1_lp_600khz,      // 600 kHz low-pass filter
  ST25R3916_REG_RX_CONF2_agc_en           // Enable AGC
};
ReturnCode err = rfal.st25r3916WriteMultipleRegisters(ST25R3916_REG_RX_CONF1, rxConf, 2);
if (err == ERR_NONE) {
  Serial.println("RX config registers written");
}
```

--------------------------------

### Constructor (SPI Mode)

Source: https://context7.com/stm32duino/st25r3916/llms.txt

Instantiate the driver using an SPI peripheral, chip-select pin, interrupt pin, and SPI clock speed. Ensure SPI and relevant pins are configured before calling.

```cpp
#include "rfal_rfst25r3916.h"
#include <SPI.h>

// Pins: CS=10, IRQ=A0, SPI speed=4 MHz
RfalRfST25R3916Class rfal(&SPI, 10, A0, 4000000);
```

--------------------------------

### Constructor (I2C Mode)

Source: https://context7.com/stm32duino/st25r3916/llms.txt

Instantiate the driver using an I2C peripheral and interrupt pin. The default I2C address is 0x50. Ensure the Wire library is included.

```cpp
#include "rfal_rfst25r3916.h"
#include <Wire.h>

// IRQ pin = A0
RfalRfST25R3916Class rfal(&Wire, A0);
```

--------------------------------

### Constructor (SPI mode)

Source: https://context7.com/stm32duino/st25r3916/llms.txt

Instantiate the ST25R3916 driver using an SPI peripheral. This constructor requires the SPI object, chip-select pin, interrupt pin, and SPI clock speed.

```APIDOC
## Constructor (SPI mode)

Instantiate the driver using an SPI peripheral, chip-select pin, interrupt pin, and SPI clock speed.

```cpp
#include "rfal_rfst25r3916.h"
#include <SPI.h>

// Pins: CS=10, IRQ=A0, SPI speed=4 MHz
RfalRfST25R3916Class rfal(&SPI, 10, A0, 4000000);
```
```

--------------------------------

### Constructor (I2C mode)

Source: https://context7.com/stm32duino/st25r3916/llms.txt

Instantiate the ST25R3916 driver using an I2C peripheral. This constructor requires the I2C object and interrupt pin, using the default I2C address 0x50.

```APIDOC
## Constructor (I2C mode)

Instantiate the driver using an I2C peripheral and interrupt pin (default I2C address 0x50).

```cpp
#include "rfal_rfst25r3916.h"
#include <Wire.h>

// IRQ pin = A0
RfalRfST25R3916Class rfal(&Wire, A0);
```
```

--------------------------------

### rfalInitialize

Source: https://context7.com/stm32duino/st25r3916/llms.txt

Initializes the RFAL and the ST25R3916 chip. This function resets the chip, configures the interrupt line, loads default analog settings, enables the external field detector, and performs regulator calibration. It must be called before any other RFAL function.

```APIDOC
## `rfalInitialize` — Initialize the RFAL and chip

Resets the ST25R3916 to its power-on state, configures the interrupt line, loads default analog configurations, enables the external field detector, and runs automatic regulator calibration. Must be called before any other RFAL function.

```cpp
ReturnCode err = rfal.rfalInitialize();
if (err != ERR_NONE) {
  Serial.print("RFAL init failed, error: ");
  Serial.println(err);
  while (true);
}
Serial.println("RFAL initialized");
```
```

--------------------------------

### Run Automatic Antenna Tuning (AAT)

Source: https://context7.com/stm32duino/st25r3916/llms.txt

Configures and runs the iterative hill-climbing algorithm for optimal antenna tuning. Pass NULL to use default parameters. The result includes tuned capacitor values and performance metrics.

```cpp
struct st25r3916AatTuneParams params = {
  .aat_a_min        = 0,
  .aat_a_max        = 255,
  .aat_a_start      = 127,
  .aat_a_stepWidth  = 32,
  .aat_b_min        = 0,
  .aat_b_max        = 255,
  .aat_b_start      = 127,
  .aat_b_stepWidth  = 32,
  .phaTarget        = 128,  // target phase (0-255)
  .phaWeight        = 2,
  .ampTarget        = 196,  // target amplitude (0-255)
  .ampWeight        = 1,
  .doDynamicSteps   = true,
  .measureLimit     = 50
};

struct st25r3916AatTuneResult result;
ReturnCode err = rfal.st25r3916AatTune(&params, &result);
if (err == ERR_NONE) {
  Serial.print("AAT_A="); Serial.println(result.aat_a);
  Serial.print("AAT_B="); Serial.println(result.aat_b);
  Serial.print("Phase="); Serial.println(result.pha);
  Serial.print("Amp=");   Serial.println(result.amp);
  Serial.print("Steps="); Serial.println(result.measureCnt);
}
```

--------------------------------

### st25r3916ExecuteCommand

Source: https://context7.com/stm32duino/st25r3916/llms.txt

Issues a direct command to the ST25R3916 chip.

```APIDOC
## st25r3916ExecuteCommand

### Description
Sends one of the ST25R3916 direct command bytes (e.g., `ST25R3916_CMD_TRANSMIT_WITH_CRC`, `ST25R3916_CMD_ADJUST_REGULATORS`, `ST25R3916_CMD_CLEAR_FIFO`).

### Method
```cpp
ReturnCode st25r3916ExecuteCommand(uint8_t cmd)
```

### Parameters
#### Path Parameters
- **cmd** (uint8_t) - Required - The command byte to execute.

### Request Example
```cpp
// Clear the FIFO, collision status, and IRQ status
ReturnCode err = rfal.st25r3916ExecuteCommand(ST25R3916_CMD_CLEAR_FIFO);

// Start a REQA transmission (short frame, no CRC)
err = rfal.st25r3916ExecuteCommand(ST25R3916_CMD_TRANSMIT_REQA);

// Trigger automatic regulator calibration
err = rfal.st25r3916ExecuteCommand(ST25R3916_CMD_ADJUST_REGULATORS);

if (err == ERR_NONE) {
  Serial.println("Direct command executed");
}
```

### Response
#### Success Response (ERR_NONE)
Indicates the command was successfully executed.

#### Response Example
```cpp
// Success message printed to console
```
```

--------------------------------

### Initialize RFAL and Chip

Source: https://context7.com/stm32duino/st25r3916/llms.txt

Resets the ST25R3916, configures interrupts, loads defaults, and calibrates regulators. Must be called before any other RFAL function. Check the return code for errors.

```cpp
ReturnCode err = rfal.rfalInitialize();
if (err != ERR_NONE) {
  Serial.print("RFAL init failed, error: ");
  Serial.println(err);
  while (true);
}
Serial.println("RFAL initialized");
```

--------------------------------

### Set Operating Mode and Bit Rate

Source: https://context7.com/stm32duino/st25r3916/llms.txt

Configures the chip for a specific NFC technology and programs TX/RX bit rates. Must be called after `rfalInitialize` and before transceive operations. Various modes and bit rates are supported.

```cpp
// Set NFC-A (ISO14443A) poll mode at 106 kbit/s TX and RX
ReturnCode err = rfal.rfalSetMode(RFAL_MODE_POLL_NFCA, RFAL_BR_106, RFAL_BR_106);
if (err == ERR_NONE) {
  Serial.println("Mode set: NFC-A 106kbps");
}

// Set NFC-F (FeliCa) poll mode at 212 kbit/s
err = rfal.rfalSetMode(RFAL_MODE_POLL_NFCF, RFAL_BR_212, RFAL_BR_212);

// Available bit rate constants:
// RFAL_BR_106, RFAL_BR_212, RFAL_BR_424, RFAL_BR_848,
// RFAL_BR_1695, RFAL_BR_3390, RFAL_BR_6780, RFAL_BR_KEEP
```

--------------------------------

### Calibrate Voltage Regulators

Source: https://context7.com/stm32duino/st25r3916/llms.txt

Performs automatic regulator adjustment for optimal analog performance. This is called by `rfalInitialize` but can be called again if supply conditions change. Check for `ERR_WRONG_STATE` if RFAL is not initialized.

```cpp
ReturnCode err = rfal.rfalCalibrate();
if (err == ERR_NONE) {
  Serial.println("Calibration complete");
} else if (err == ERR_WRONG_STATE) {
  Serial.println("Cannot calibrate: RFAL not initialized");
}
```

--------------------------------

### st25r3916AatTune

Source: https://context7.com/stm32duino/st25r3916/llms.txt

Runs the iterative hill-climbing algorithm to find the optimal Automatic Antenna Tuning (AAT) capacitor values (AAT_A and AAT_B) that minimize a cost function based on phase and amplitude measurements. Pass NULL for tuningParams to use built-in defaults.

```APIDOC
## st25r3916AatTune — Automatic Antenna Tuning (AAT)

### Description
Runs the iterative hill-climbing algorithm to find the optimal AAT_A (series capacitor) and AAT_B (parallel capacitor) values that minimize the cost function combining phase and amplitude measurements. Pass `NULL` for `tuningParams` to use built-in defaults.

### Parameters
#### Request Body
- **tuningParams** (struct st25r3916AatTuneParams*) - Optional - Structure containing parameters for the AAT algorithm.
  - **aat_a_min** (uint8_t) - Minimum value for AAT_A.
  - **aat_a_max** (uint8_t) - Maximum value for AAT_A.
  - **aat_a_start** (uint8_t) - Starting value for AAT_A.
  - **aat_a_stepWidth** (uint8_t) - Step width for AAT_A.
  - **aat_b_min** (uint8_t) - Minimum value for AAT_B.
  - **aat_b_max** (uint8_t) - Maximum value for AAT_B.
  - **aat_b_start** (uint8_t) - Starting value for AAT_B.
  - **aat_b_stepWidth** (uint8_t) - Step width for AAT_B.
  - **phaTarget** (uint8_t) - Target phase value (0-255).
  - **phaWeight** (uint8_t) - Weight for phase measurement.
  - **ampTarget** (uint8_t) - Target amplitude value (0-255).
  - **ampWeight** (uint8_t) - Weight for amplitude measurement.
  - **doDynamicSteps** (bool) - Enable dynamic step width adjustment.
  - **measureLimit** (uint8_t) - Limit for the number of measurements.
- **result** (struct st25r3916AatTuneResult*) - Output - Structure to store the AAT results.
  - **aat_a** (uint8_t) - Optimal AAT_A value.
  - **aat_b** (uint8_t) - Optimal AAT_B value.
  - **pha** (uint8_t) - Measured phase value.
  - **amp** (uint8_t) - Measured amplitude value.
  - **measureCnt** (uint8_t) - Number of measurements performed.

### Return Value
- **ReturnCode** - ERR_NONE on success, other error codes on failure.

### Request Example
```cpp
struct st25r3916AatTuneParams params = {
  .aat_a_min        = 0,
  .aat_a_max        = 255,
  .aat_a_start      = 127,
  .aat_a_stepWidth  = 32,
  .aat_b_min        = 0,
  .aat_b_max        = 255,
  .aat_b_start      = 127,
  .aat_b_stepWidth  = 32,
  .phaTarget        = 128,  // target phase (0-255)
  .phaWeight        = 2,
  .ampTarget        = 196,  // target amplitude (0-255)
  .ampWeight        = 1,
  .doDynamicSteps   = true,
  .measureLimit     = 50
};

struct st25r3916AatTuneResult result;
ReturnCode err = rfal.st25r3916AatTune(&params, &result);
if (err == ERR_NONE) {
  Serial.print("AAT_A="); Serial.println(result.aat_a);
  Serial.print("AAT_B="); Serial.println(result.aat_b);
  Serial.print("Phase="); Serial.println(result.pha);
  Serial.print("Amp=");   Serial.println(result.amp);
  Serial.print("Steps="); Serial.println(result.measureCnt);
}
```
```

--------------------------------

### rfalDeinitialize

Source: https://context7.com/stm32duino/st25r3916/llms.txt

Deinitializes the RFAL and the ST25R3916 chip. This function gracefully shuts down the chip, applies deinitialization configurations, and detaches the interrupt handler. It is safe to call before entering deep sleep mode.

```APIDOC
## `rfalDeinitialize` — Deinitialize the RFAL and chip

Gracefully shuts down the chip, applies deinitialization analog configs, and detaches the interrupt handler. Safe to call before entering deep sleep.

```cpp
ReturnCode err = rfal.rfalDeinitialize();
if (err == ERR_NONE) {
  Serial.println("RFAL deinitialized");
}
```
```

--------------------------------

### Define Original ST25R3916 Variant

Source: https://context7.com/stm32duino/st25r3916/llms.txt

Place this file in your Arduino sketch folder to override default chip variant selection. Without it, the library defaults to ST25R3916B.

```cpp
// st25r3916_custom_config.h — place in your Arduino sketch folder
#ifndef ST25R3916_CUSTOM_CONFIG_H
#define ST25R3916_CUSTOM_CONFIG_H

// Use the original ST25R3916 variant (not ST25R3916B)
#define ST25R3916

#endif /* ST25R3916_CUSTOM_CONFIG_H */
```

--------------------------------

### TX/RX Control Macros

Source: https://context7.com/stm32duino/st25r3916/llms.txt

Convenience macros for controlling the RF field and receiver. These macros set or clear the `tx_en` and `rx_en` bits in the `OP_CONTROL` register.

```APIDOC
## TX/RX Control Macros — Field and receiver control

### Description
Convenience macros that set or clear the `tx_en` and `rx_en` bits in `OP_CONTROL` to enable/disable the RF field and receiver.

### Methods
- **st25r3916TxRxOn()**: Turns on the RF field and receiver.
- **st25r3916IsTxEnabled()**: Checks if the transmitter is currently enabled.
- **st25r3916IsExtFieldOn()**: Checks for an external RF field (passive target detection).
- **st25r3916TxOff()**: Turns off only the transmitter (keeps receiver on).
- **st25r3916TxRxOff()**: Turns off both the transmitter and receiver.

### Request Example
```cpp
// Turn on RF field and receiver (initiator role)
rfal.st25r3916TxRxOn();

// Check if transmitter is currently enabled
if (rfal.st25r3916IsTxEnabled()) {
  Serial.println("TX field is ON");
}

// Check for an external RF field (passive target detection)
if (rfal.st25r3916IsExtFieldOn()) {
  Serial.println("External NFC field detected");
}

// Turn off only the transmitter (keep receiver on)
rfal.st25r3916TxOff();

// Turn off both transmitter and receiver
rfal.st25r3916TxRxOff();
```
```

--------------------------------

### st25r3916WriteFifo

Source: https://context7.com/stm32duino/st25r3916/llms.txt

Loads data into the transmit FIFO of the ST25R3916 chip.

```APIDOC
## st25r3916WriteFifo

### Description
Writes up to 512 bytes (ST25R3916 FIFO depth) into the transmit FIFO. Must be preceded by the appropriate `rfalSetMode` call and an RF field-on condition.

### Method
```cpp
ReturnCode st25r3916WriteFifo(const uint8_t *data, uint16_t length)
```

### Parameters
#### Path Parameters
- **data** (const uint8_t *) - Required - Pointer to the data buffer to write.
- **length** (uint16_t) - Required - The number of bytes to write to the FIFO.

### Request Example
```cpp
// Prepare an NFC-A REQA command
uint8_t txData[] = { 0x26 };  // REQA short frame byte
ReturnCode err = rfal.st25r3916WriteFifo(txData, sizeof(txData));
if (err == ERR_PARAM) {
  Serial.println("Error: data exceeds FIFO depth (512 bytes)");
} else if (err == ERR_NONE) {
  Serial.println("FIFO loaded");
}
```

### Response
#### Success Response (ERR_NONE)
Indicates the data was successfully loaded into the FIFO.
#### Error Response (ERR_PARAM)
Indicates the data length exceeds the FIFO capacity.

#### Response Example
```cpp
// Success or error message printed to console
```
```

--------------------------------

### rfalSetObsvMode / rfalGetObsvMode / rfalDisableObsvMode

Source: https://context7.com/stm32duino/st25r3916/llms.txt

Controls the ST25R3916 observation mode pins for debugging. TX and RX modes are independent 8-bit values that select which internal signal to route to the AUX pin.

```APIDOC
## rfalSetObsvMode / rfalGetObsvMode / rfalDisableObsvMode — Observation mode

### Description
Controls the ST25R3916 observation mode pins for debugging. TX and RX modes are independent 8-bit values selecting which internal signal to route to the AUX pin.

### Parameters
#### rfalSetObsvMode
- **txMode** (uint8_t) - Value to set for TX observation mode.
- **rxMode** (uint8_t) - Value to set for RX observation mode.

#### rfalGetObsvMode
- **txMode** (uint8_t*) - Pointer to store the current TX observation mode value.
- **rxMode** (uint8_t*) - Pointer to store the current RX observation mode value.

### Request Example
```cpp
// Enable observation mode: TX shows field driver, RX shows correlator output
rfal.rfalSetObsvMode(0x04, 0x01);

uint8_t txMode, rxMode;
rfal.rfalGetObsvMode(&txMode, &rxMode);
Serial.print("ObsvTx="); Serial.print(txMode);
Serial.print(" ObsvRx="); Serial.println(rxMode);

// Disable observation mode
rfal.rfalDisableObsvMode();
```
```

--------------------------------

### Manually Adjust Regulators and Read Result

Source: https://context7.com/stm32duino/st25r3916/llms.txt

Triggers the ST25R3916 Adjust Regulators command and returns the resulting value. Useful for diagnostics or power optimization. The result is provided via a pointer.

```cpp
uint16_t regResult = 0;
ReturnCode err = rfal.rfalAdjustRegulators(&regResult);
if (err == ERR_NONE) {
  Serial.print("Regulator result: 0x");
  Serial.println(regResult, HEX);
}
```

--------------------------------

### Control RF Field and Receiver

Source: https://context7.com/stm32duino/st25r3916/llms.txt

Convenience macros for enabling and disabling the RF field and receiver. Includes functions to check the status of the transmitter and external field detection.

```cpp
// Turn on RF field and receiver (initiator role)
rfal.st25r3916TxRxOn();

// Check if transmitter is currently enabled
if (rfal.st25r3916IsTxEnabled()) {
  Serial.println("TX field is ON");
}

// Check for an external RF field (passive target detection)
if (rfal.st25r3916IsExtFieldOn()) {
  Serial.println("External NFC field detected");
}

// Turn off only the transmitter (keep receiver on)
rfal.st25r3916TxOff();

// Turn off both transmitter and receiver
rfal.st25r3916TxRxOff();
```

--------------------------------

### Write to ST25R3916 TX FIFO

Source: https://context7.com/stm32duino/st25r3916/llms.txt

Loads data into the transmit FIFO, up to the chip's FIFO depth (512 bytes). Must be called after setting the mode and ensuring an RF field is present. Use for preparing data to be transmitted.

```cpp
// Prepare an NFC-A REQA command
uint8_t txData[] = { 0x26 };  // REQA short frame byte
ReturnCode err = rfal.st25r3916WriteFifo(txData, sizeof(txData));
if (err == ERR_PARAM) {
  Serial.println("Error: data exceeds FIFO depth (512 bytes)");
} else if (err == ERR_NONE) {
  Serial.println("FIFO loaded");
}
```

--------------------------------

### st25r3916WriteRegister

Source: https://context7.com/stm32duino/st25r3916/llms.txt

Writes a single byte to a specified ST25R3916 register.

```APIDOC
## st25r3916WriteRegister

### Description
Writes one byte to the specified register. Internally delegates to `st25r3916WriteMultipleRegisters`.

### Method
```cpp
ReturnCode st25r3916WriteRegister(uint8_t reg, uint8_t value)
```

### Parameters
#### Path Parameters
- **reg** (uint8_t) - Required - The register address to write to.
- **value** (uint8_t) - Required - The byte value to write.

### Request Example
```cpp
// Set bit rate to 106 kbps for both TX and RX
ReturnCode err = rfal.st25r3916WriteRegister(
  ST25R3916_REG_BIT_RATE,
  ST25R3916_REG_BIT_RATE_txrate_106 | ST25R3916_REG_BIT_RATE_rxrate_106
);
if (err == ERR_NONE) {
  Serial.println("Bit rate register written");
}
```

### Response
#### Success Response (ERR_NONE)
Indicates the write operation was successful.

#### Response Example
```cpp
// Success message printed to console
```
```

--------------------------------

### st25r3916ReadFifo

Source: https://context7.com/stm32duino/st25r3916/llms.txt

Drains received data from the RX FIFO of the ST25R3916 chip.

```APIDOC
## st25r3916ReadFifo

### Description
Reads `length` bytes from the receive FIFO into `buf`. Called after a transceive to retrieve the response frame.

### Method
```cpp
ReturnCode st25r3916ReadFifo(uint8_t *buf, uint16_t length)
```

### Parameters
#### Path Parameters
- **buf** (uint8_t *) - Required - Buffer to store the received data.
- **length** (uint16_t) - Required - The number of bytes to read from the FIFO.

### Request Example
```cpp
uint8_t rxBuf[32];
uint16_t bytesInFifo = 7;  // determined from FIFO_STATUS registers

ReturnCode err = rfal.st25r3916ReadFifo(rxBuf, bytesInFifo);
if (err == ERR_NONE) {
  Serial.print("Received: ");
  for (uint16_t i = 0; i < bytesInFifo; i++) {
    Serial.print(rxBuf[i], HEX);
    Serial.print(" ");
  }
  Serial.println();
}
```

### Response
#### Success Response (ERR_NONE)
- **buf** (uint8_t *) - The buffer containing the received data.

#### Response Example
```cpp
// Received data printed to console in HEX format
```
```

--------------------------------

### rfalCalibrate

Source: https://context7.com/stm32duino/st25r3916/llms.txt

Calibrates the voltage regulators of the ST25R3916. This function performs automatic regulator adjustment to optimize analog performance. It is called automatically by `rfalInitialize` but can be called again if supply conditions change.

```APIDOC
## `rfalCalibrate` — Calibrate voltage regulators

Performs automatic regulator adjustment on the ST25R3916 to optimize analog performance. Called automatically by `rfalInitialize`; can be called again if supply conditions change.

```cpp
ReturnCode err = rfal.rfalCalibrate();
if (err == ERR_NONE) {
  Serial.println("Calibration complete");
} else if (err == ERR_WRONG_STATE) {
  Serial.println("Cannot calibrate: RFAL not initialized");
}
```
```

--------------------------------

### Interrupt Mask Constants

Source: https://context7.com/stm32duino/st25r3916/llms.txt

Bit-mask constants used with interrupt enable/disable functions to select specific ST25R3916 interrupt sources.

```APIDOC
## Interrupt Mask Constants — IRQ sources

### Description
Bit-mask constants used with interrupt enable/disable functions to select which ST25R3916 interrupt sources to act on.

### Constants
- **ST25R3916_IRQ_MASK_TXE**: End of transmission interrupt.
- **ST25R3916_IRQ_MASK_RXS**: Start of receive interrupt.
- **ST25R3916_IRQ_MASK_RXE**: End of receive interrupt.
- **ST25R3916_IRQ_MASK_COL**: Bit collision interrupt.
- **ST25R3916_IRQ_MASK_FWL**: FIFO water level interrupt.
- **ST25R3916_IRQ_MASK_OSC**: Oscillator stable interrupt.
- **ST25R3916_IRQ_MASK_CRC**: CRC error interrupt.
- **ST25R3916_IRQ_MASK_PAR**: Parity error interrupt.
- **ST25R3916_IRQ_MASK_NRE**: No-response timer expired interrupt.
- **ST25R3916_IRQ_MASK_GPE**: General purpose timer expired interrupt.
- **ST25R3916_IRQ_MASK_EON**: External field on interrupt.
- **ST25R3916_IRQ_MASK_EOF**: External field off interrupt.
- **ST25R3916_IRQ_MASK_WT**: Wake-up interrupt.
- **ST25R3916_IRQ_MASK_WAM**: Wake-up due to amplitude interrupt.
- **ST25R3916_IRQ_MASK_WPH**: Wake-up due to phase interrupt.
- **ST25R3916_IRQ_MASK_ALL**: Mask for all interrupt sources.
- **ST25R3916_IRQ_MASK_NONE**: Mask for no interrupt sources.

### Request Example
```cpp
// Enable only end-of-receive and CRC error interrupts
uint32_t mask = ST25R3916_IRQ_MASK_RXE | ST25R3916_IRQ_MASK_CRC;

// Common mask values:
// ST25R3916_IRQ_MASK_TXE   - end of transmission
// ST25R3916_IRQ_MASK_RXS   - start of receive
// ST25R3916_IRQ_MASK_RXE   - end of receive
// ST25R3916_IRQ_MASK_COL   - bit collision
// ST25R3916_IRQ_MASK_FWL   - FIFO water level
// ST25R3916_IRQ_MASK_OSC   - oscillator stable
// ST25R3916_IRQ_MASK_CRC   - CRC error
// ST25R3916_IRQ_MASK_PAR   - parity error
// ST25R3916_IRQ_MASK_NRE   - no-response timer expired
// ST25R3916_IRQ_MASK_GPE   - general purpose timer expired
// ST25R3916_IRQ_MASK_EON   - external field on
// ST25R3916_IRQ_MASK_EOF   - external field off
// ST25R3916_IRQ_MASK_WT    - wake-up interrupt
// ST25R3916_IRQ_MASK_WAM   - wake-up due to amplitude
// ST25R3916_IRQ_MASK_WPH   - wake-up due to phase
// ST25R3916_IRQ_MASK_ALL   - all sources
// ST25R3916_IRQ_MASK_NONE  - none
```
```

--------------------------------

### Read from ST25R3916 RX FIFO

Source: https://context7.com/stm32duino/st25r3916/llms.txt

Reads received data from the receive FIFO into a buffer. Call this after a transceive operation to retrieve the response frame. The number of bytes to read should be determined from FIFO status registers.

```cpp
uint8_t rxBuf[32];
uint16_t bytesInFifo = 7;  // determined from FIFO_STATUS registers

ReturnCode err = rfal.st25r3916ReadFifo(rxBuf, bytesInFifo);
if (err == ERR_NONE) {
  Serial.print("Received: ");
  for (uint16_t i = 0; i < bytesInFifo; i++) {
    Serial.print(rxBuf[i], HEX);
    Serial.print(" ");
  }
  Serial.println();
}
```

--------------------------------

### Control Observation Mode Pins

Source: https://context7.com/stm32duino/st25r3916/llms.txt

Enables, retrieves, or disables the ST25R3916 observation mode pins for debugging. These pins can be configured to route internal signals to the AUX pin.

```cpp
// Enable observation mode: TX shows field driver, RX shows correlator output
rfal.rfalSetObsvMode(0x04, 0x01);

uint8_t txMode, rxMode;
rfal.rfalGetObsvMode(&txMode, &rxMode);
Serial.print("ObsvTx="); Serial.print(txMode);
Serial.print(" ObsvRx="); Serial.println(rxMode);

// Disable observation mode
rfal.rfalDisableObsvMode();
```

--------------------------------

### st25r3916ReadRegister

Source: https://context7.com/stm32duino/st25r3916/llms.txt

Reads a single byte from a specified ST25R3916 register address. Supports SPI and I2C transports.

```APIDOC
## st25r3916ReadRegister

### Description
Reads one byte from the specified ST25R3916 register address. Handles both SPI and I2C transports, and Space-B register access automatically.

### Method
```cpp
uint8_t st25r3916ReadRegister(uint8_t reg, uint8_t *val)
```

### Parameters
#### Path Parameters
- **reg** (uint8_t) - Required - The register address to read from.
- **val** (uint8_t *) - Required - Pointer to store the read byte.

### Request Example
```cpp
uint8_t val = 0;
// Read IC Identity register (0x3F) to verify chip presence
ReturnCode err = rfal.st25r3916ReadRegister(ST25R3916_REG_IC_IDENTITY, &val);
if (err == ERR_NONE) {
  uint8_t icType = (val & ST25R3916_REG_IC_IDENTITY_ic_type_mask) >> ST25R3916_REG_IC_IDENTITY_ic_type_shift;
  Serial.print("IC type: 0x");
  Serial.println(icType, HEX);
  // Expected: 0x05 for ST25R3916, 0x06 for ST25R3916B
}
```

### Response
#### Success Response (ERR_NONE)
- **val** (uint8_t) - The byte read from the register.

#### Response Example
```cpp
// val will contain the byte read from the register
```
```

--------------------------------

### Deinitialize RFAL and Chip

Source: https://context7.com/stm32duino/st25r3916/llms.txt

Gracefully shuts down the chip and detaches the interrupt handler. This function is safe to call before entering deep sleep.

```cpp
ReturnCode err = rfal.rfalDeinitialize();
if (err == ERR_NONE) {
  Serial.println("RFAL deinitialized");
}
```

--------------------------------

### st25r3916ReadMultipleRegisters

Source: https://context7.com/stm32duino/st25r3916/llms.txt

Performs a burst read of consecutive registers from the chip.

```APIDOC
## st25r3916ReadMultipleRegisters

### Description
Reads `length` bytes from the chip starting at register `reg` into `values`. Efficient for reading groups such as FIFO status, IRQ status, or all RX config registers in one SPI/I2C transaction.

### Method
```cpp
ReturnCode st25r3916ReadMultipleRegisters(uint8_t reg, uint8_t *values, uint8_t length)
```

### Parameters
#### Path Parameters
- **reg** (uint8_t) - Required - The starting register address.
- **values** (uint8_t *) - Required - Buffer to store the read bytes.
- **length** (uint8_t) - Required - The number of bytes to read.

### Request Example
```cpp
uint8_t fifoStatus[2];
// Read ST25R3916_REG_FIFO_STATUS1 and STATUS2 in one burst
ReturnCode err = rfal.st25r3916ReadMultipleRegisters(ST25R3916_REG_FIFO_STATUS1, fifoStatus, 2);
if (err == ERR_NONE) {
  uint16_t fifoBytes = ((uint16_t)(fifoStatus[0]) | ((uint16_t)(fifoStatus[1] & 0x03) << 8));
  Serial.print("FIFO bytes available: ");
  Serial.println(fifoBytes);
}
```

### Response
#### Success Response (ERR_NONE)
- **values** (uint8_t *) - The buffer containing the read bytes.

#### Response Example
```cpp
// fifoStatus will contain the bytes read from the registers
```
```

--------------------------------

### ST25R3916 Interrupt Mask Constants

Source: https://context7.com/stm32duino/st25r3916/llms.txt

Bit-mask constants used for configuring interrupt enable/disable functions. These constants specify which ST25R3916 interrupt sources should be acted upon.

```cpp
// Enable only end-of-receive and CRC error interrupts
uint32_t mask = ST25R3916_IRQ_MASK_RXE | ST25R3916_IRQ_MASK_CRC;

// Common mask values:
// ST25R3916_IRQ_MASK_TXE   - end of transmission
// ST25R3916_IRQ_MASK_RXS   - start of receive
// ST25R3916_IRQ_MASK_RXE   - end of receive
// ST25R3916_IRQ_MASK_COL   - bit collision
// ST25R3916_IRQ_MASK_FWL   - FIFO water level
// ST25R3916_IRQ_MASK_OSC   - oscillator stable
// ST25R3916_IRQ_MASK_CRC   - CRC error
// ST25R3916_IRQ_MASK_PAR   - parity error
// ST25R3916_IRQ_MASK_NRE   - no-response timer expired
// ST25R3916_IRQ_MASK_GPE   - general purpose timer expired
// ST25R3916_IRQ_MASK_EON   - external field on
// ST25R3916_IRQ_MASK_EOF   - external field off
// ST25R3916_IRQ_MASK_WT    - wake-up interrupt
// ST25R3916_IRQ_MASK_WAM   - wake-up due to amplitude
// ST25R3916_IRQ_MASK_WPH   - wake-up due to phase
// ST25R3916_IRQ_MASK_ALL   - all sources
// ST25R3916_IRQ_MASK_NONE  - none
```

--------------------------------

### st25r3916WriteMultipleRegisters

Source: https://context7.com/stm32duino/st25r3916/llms.txt

Performs a burst write of consecutive registers on the chip.

```APIDOC
## st25r3916WriteMultipleRegisters

### Description
Writes `length` bytes from `values` into chip registers starting at `reg`. Space-B access is handled transparently.

### Method
```cpp
ReturnCode st25r3916WriteMultipleRegisters(uint8_t reg, const uint8_t *values, uint8_t length)
```

### Parameters
#### Path Parameters
- **reg** (uint8_t) - Required - The starting register address.
- **values** (const uint8_t *) - Required - Buffer containing the bytes to write.
- **length** (uint8_t) - Required - The number of bytes to write.

### Request Example
```cpp
// Configure both RX config registers in a single burst
uint8_t rxConf[2] = {
  ST25R3916_REG_RX_CONF1_lp_600khz,
  ST25R3916_REG_RX_CONF2_agc_en
};
ReturnCode err = rfal.st25r3916WriteMultipleRegisters(ST25R3916_REG_RX_CONF1, rxConf, 2);
if (err == ERR_NONE) {
  Serial.println("RX config registers written");
}
```

### Response
#### Success Response (ERR_NONE)
Indicates the burst write operation was successful.

#### Response Example
```cpp
// Success message printed to console
```
```

--------------------------------

### Write ST25R3916 Register

Source: https://context7.com/stm32duino/st25r3916/llms.txt

Writes a single byte to a specified register. This function internally calls `st25r3916WriteMultipleRegisters`. Use to configure chip settings.

```cpp
// Set bit rate to 106 kbps for both TX and RX
ReturnCode err = rfal.st25r3916WriteRegister(
  ST25R3916_REG_BIT_RATE,
  ST25R3916_REG_BIT_RATE_txrate_106 | ST25R3916_REG_BIT_RATE_rxrate_106
);
if (err == ERR_NONE) {
  Serial.println("Bit rate register written");
}
```

--------------------------------

### Read ST25R3916 Register

Source: https://context7.com/stm32duino/st25r3916/llms.txt

Reads a single byte from a specified ST25R3916 register address. Handles SPI and I2C transports. Use to verify chip presence or read configuration.

```cpp
uint8_t val = 0;
// Read IC Identity register (0x3F) to verify chip presence
ReturnCode err = rfal.st25r3916ReadRegister(ST25R3916_REG_IC_IDENTITY, &val);
if (err == ERR_NONE) {
  uint8_t icType = (val & ST25R3916_REG_IC_IDENTITY_ic_type_mask) >> ST25R3916_REG_IC_IDENTITY_ic_type_shift;
  Serial.print("IC type: 0x");
  Serial.println(icType, HEX);
  // Expected: 0x05 for ST25R3916, 0x06 for ST25R3916B
}
```

--------------------------------

### rfalAdjustRegulators

Source: https://context7.com/stm32duino/st25r3916/llms.txt

Manually adjusts the regulators and reads the result. This function triggers the ST25R3916 Adjust Regulators direct command and returns the resulting regulator value. It is useful for diagnostic or power-optimization routines.

```APIDOC
## `rfalAdjustRegulators` — Manually adjust regulators and read result

Triggers the ST25R3916 Adjust Regulators direct command and returns the resulting regulator value. Useful for diagnostic or power-optimization routines.

```cpp
uint16_t regResult = 0;
ReturnCode err = rfal.rfalAdjustRegulators(&regResult);
if (err == ERR_NONE) {
  Serial.print("Regulator result: 0x");
  Serial.println(regResult, HEX);
}
```
```
Tokens:
Raw