Precision Indoor Positioning with Ultra WideBand UWB, ESP32 & Arduino: Hardware & Basics

RYUW122 uwb(&Serial1);

#define RX_PIN 16  // Connect to RYUW122 TX
#define TX_PIN 17  // Connect to RYUW122 RX
#define RESET_PIN 4 // Connect to RYUW122 NRST (active LOW)

RYUW122 uwb(TX_PIN, RX_PIN, &Serial1, RESET_PIN);

// RYUW122 uwb(&Serial2, RESET_PIN);

#define RX_PIN 5  // Connect to RYUW122 TX
#define TX_PIN 4  // Connect to RYUW122 RX
#define RESET_PIN 6 // Connect to RYUW122 NRST (active LOW)

RYUW122 uwb(TX_PIN, RX_PIN, &Serial1, RESET_PIN);

lib_deps =
    xreef/RYUW122@^1.0.0

/*
 * Author: Renzo Mischianti
 * Website: https://mischianti.org
 * Copyright (c) 2025 Renzo Mischianti
 * Part of the RYUW122 Arduino library examples. See LICENSE for details.
 */

/**
 * @file device_communication_test.ino
 * @brief Basic example for testing RYUW122 module communication and configuration
 *
 * This example performs basic AT command tests to verify:
 * - Serial communication with the module
 * - Configuration of basic parameters
 * - Reading module information
 *
 * Hardware connections:
 * - RYUW122 TX  -> Arduino RX (e.g., Pin 10 for SoftwareSerial)
 * - RYUW122 RX  -> Arduino TX (e.g., Pin 11 for SoftwareSerial)
 * - RYUW122 GND -> Arduino GND
 * - RYUW122 VCC -> Arduino 3.3V or 5V (check module specifications)
 * For esp32 like device It's important to set also NRST
 * - RYUW122 NRST-> ESP32 GPIO for RESET
 *
 * Open the Serial Monitor at 115200 baud to see the test results.
 */

#include <RYUW122.h>


// ------------------ ARDUINO UNO SOFTWARE SERIAL ------------------
// Define pins for SoftwareSerial (adjust based on your board)
// #define RX_PIN 10  // Connect to RYUW122 TX
// #define TX_PIN 11  // Connect to RYUW122 RX
//
// // Create RYUW122 instance with SoftwareSerial for Arduino UNO
// RYUW122 uwb(TX_PIN, RX_PIN, RYUW122BaudRate::B_9600);
// -----------------------------------------------------------------
// -------------------------- ARDUINO MEGA -------------------------
// RYUW122 uwb(&Serial1);
// -----------------------------------------------------------------
// ------------------------ ESP32 ----------------------------------
#define RX_PIN 5  // Connect to RYUW122 TX
#define TX_PIN 4  // Connect to RYUW122 RX
#define RESET_PIN 6 // Connect to RYUW122 NRST (active LOW)

RYUW122 uwb( TX_PIN, RX_PIN, &Serial1, RESET_PIN);
// -----------------------------------------------------------------

void printTestResult(const char* testName, bool result) {
    Serial.print(F("["));
    Serial.print(result ? F("PASS") : F("FAIL"));
    Serial.print(F("] "));
    Serial.println(testName);
}

void printSeparator() {
    Serial.println(F("========================================"));
}

void setup() {
    // Initialize serial for debugging
    Serial.begin(115200);
    while (!Serial) {
        ; // Wait for serial port to connect (needed for native USB)
    }

    delay(1000); // Give time for module to power up

    Serial.println(F("\n"));
    printSeparator();
    Serial.println(F("RYUW122 Basic Test"));
    printSeparator();

    // Test 1: Initialize module
    Serial.println(F("\nTest 1: Initialize Module"));
    bool initResult = uwb.begin();
    printTestResult("Module Initialization", initResult);
    if (!initResult) {
        Serial.println(F("ERROR: Cannot initialize module!"));
        Serial.println(F("Check connections and baud rate."));
        while (1) {
            delay(1000);
        }
    }

    delay(500);

    // Test 2: AT command test
    Serial.println(F("\nTest 2: AT Command Communication"));
    bool atResult = uwb.test();
    printTestResult("AT Command Test", atResult);
    if (!atResult) {
        Serial.println(F("ERROR: Module not responding to AT commands!"));
        while (1) {
            delay(1000);
        }
    }

    delay(500);

    // Test 3: Get firmware version
    Serial.println(F("\nTest 3: Read Firmware Version"));
    char version[32];
    bool versionResult = uwb.getFirmwareVersion(version);
    printTestResult("Get Firmware Version", versionResult);
    if (versionResult) {
        Serial.print(F("  Version: "));
        Serial.println(version);
    }

    delay(500);

    // Test 4: Get unique ID
    Serial.println(F("\nTest 4: Read Unique ID"));
    char uid[32];
    bool uidResult = uwb.getUid(uid);
    printTestResult("Get Unique ID", uidResult);
    if (uidResult) {
        Serial.print(F("  UID: "));
        Serial.println(uid);
    }

    delay(500);

    // Test 5: Set and verify mode
    Serial.println(F("\nTest 5: Set Operating Mode (TAG)"));
    bool setModeResult = uwb.setMode(RYUW122Mode::TAG);
    printTestResult("Set Mode", setModeResult);

    RYUW122Mode currentMode = uwb.getMode();
    bool verifyModeResult = (currentMode == RYUW122Mode::TAG);
    printTestResult("Verify Mode", verifyModeResult);
    if (verifyModeResult) {
        Serial.print(F("  Current Mode: "));
        Serial.println(RYUW122Mode_description(currentMode));
    }

    delay(500);

    // Test 6: Set and verify baud rate
    Serial.println(F("\nTest 6: Verify Baud Rate"));
    RYUW122BaudRate currentBaud = uwb.getBaudRate();
    Serial.print(F("  Current Baud Rate: "));
    Serial.println(RYUW122BaudRate_description(currentBaud));

    delay(500);

    // Test 7: Set and verify RF channel
    Serial.println(F("\nTest 7: Set RF Channel"));
    bool setChannelResult = uwb.setRfChannel(RYUW122RFChannel::CH_5);
    printTestResult("Set RF Channel", setChannelResult);

    RYUW122RFChannel currentChannel = uwb.getRfChannel();
    bool verifyChannelResult = (currentChannel == RYUW122RFChannel::CH_5);
    printTestResult("Verify RF Channel", verifyChannelResult);
    if (verifyChannelResult) {
        Serial.print(F("  Current Channel: "));
        Serial.println(RYUW122RFChannel_description(currentChannel));
    }

    delay(500);

    // Test 8: Set and verify bandwidth
    Serial.println(F("\nTest 8: Set Bandwidth"));
    bool setBandwidthResult = uwb.setBandwidth(RYUW122Bandwidth::BW_850K);
    printTestResult("Set Bandwidth", setBandwidthResult);

    RYUW122Bandwidth currentBandwidth = uwb.getBandwidth();
    bool verifyBandwidthResult = (currentBandwidth == RYUW122Bandwidth::BW_850K);
    printTestResult("Verify Bandwidth", verifyBandwidthResult);
    if (verifyBandwidthResult) {
        Serial.print(F("  Current Bandwidth: "));
        Serial.println(RYUW122Bandwidth_description(currentBandwidth));
    }

    delay(500);

    // Test 9: Set and verify network ID
    Serial.println(F("\nTest 9: Set Network ID"));
    const char* testNetworkId = "REYAX123";
    bool setNetworkResult = uwb.setNetworkId(testNetworkId);
    printTestResult("Set Network ID", setNetworkResult);

    char currentNetworkId[16];
    bool getNetworkResult = uwb.getNetworkId(currentNetworkId);
    printTestResult("Get Network ID", getNetworkResult);
    if (getNetworkResult) {
        Serial.print(F("  Network ID: "));
        Serial.println(currentNetworkId);
    }

    delay(500);

    // Test 10: Set and verify address
    Serial.println(F("\nTest 10: Set Address"));
    const char* testAddress = "TEST1234";
    bool setAddressResult = uwb.setAddress(testAddress);
    printTestResult("Set Address", setAddressResult);

    char currentAddress[16];
    bool getAddressResult = uwb.getAddress(currentAddress);
    printTestResult("Get Address", getAddressResult);
    if (getAddressResult) {
        Serial.print(F("  Address: "));
        Serial.println(currentAddress);
    }

    delay(500);

    // Test 11: Set RF power
    Serial.println(F("\nTest 11: Set RF Power"));
    bool setPowerResult = uwb.setRfPower(RYUW122RFPower::N32dBm);
    printTestResult("Set RF Power", setPowerResult);

    RYUW122RFPower currentPower = uwb.getRfPower();
    bool verifyPowerResult = (currentPower == RYUW122RFPower::N32dBm);
    printTestResult("Verify RF Power", verifyPowerResult);
    if (verifyPowerResult) {
        Serial.print(F("  RF Power: "));
        Serial.println(RYUW122RFPower_description(currentPower));
    }

    delay(500);

    // Test 12: RSSI display setting
    Serial.println(F("\nTest 12: RSSI Display Setting"));
    bool setRssiResult = uwb.setRssiDisplay(RYUW122RSSI::ENABLE);
    printTestResult("Set RSSI Display", setRssiResult);

    RYUW122RSSI currentRssi = uwb.getRssiDisplay();
    bool verifyRssiResult = (currentRssi == RYUW122RSSI::ENABLE);
    printTestResult("Verify RSSI Display", verifyRssiResult);
    if (verifyRssiResult) {
        Serial.print(F("  RSSI Display: "));
        Serial.println(RYUW122RSSI_description(currentRssi));
    }

    delay(500);

    // Test 13: Distance calibration
    Serial.println(F("\nTest 13: Distance Calibration"));
    bool setCalResult = uwb.setDistanceCalibration(0);
    printTestResult("Set Calibration", setCalResult);

    int currentCal = uwb.getDistanceCalibration();
    Serial.print(F("  Calibration Value: "));
    Serial.print(currentCal);
    Serial.println(F(" cm"));

    delay(500);

    bool resetResult = uwb.factoryReset();
    Serial.print(F("Reset Result: "));
    Serial.println(resetResult ? F("Success") : F("Failed"));

    delay(500);

    // Summary
    printSeparator();
    Serial.println(F("Basic Test Complete!"));
    Serial.println(F("All essential functions tested."));
    printSeparator();
    Serial.println(F("\nModule is ready for operation."));
    Serial.println(F("Use RYUW122_Anchor_Example or RYUW122_Tag_Example"));
    Serial.println(F("for communication testing."));
}

void loop() {
    // Nothing to do in loop for basic test
    delay(1000);
}

========================================
RYUW122 Basic Test
========================================

Test 1: Initialize Module
[PASS] Module Initialization

Test 2: AT Command Communication
[PASS] AT Command Test

Test 3: Read Firmware Version
[PASS] Get Firmware Version
  Version: RYUW122_V1.0.21

Test 4: Read Unique ID
[PASS] Get Unique ID
  UID: 1747363035343632

Test 5: Set Operating Mode (TAG)
[PASS] Set Mode
[PASS] Verify Mode
  Current Mode: TAG (mobile) mode

Test 6: Verify Baud Rate
  Current Baud Rate: 115200 bps

Test 7: Set RF Channel
[PASS] Set RF Channel
[PASS] Verify RF Channel
  Current Channel: Channel 5 (6489.6 MHz)

Test 8: Set Bandwidth
[PASS] Set Bandwidth
[PASS] Verify Bandwidth
  Current Bandwidth: 850 Kbps

Test 9: Set Network ID
[PASS] Set Network ID
[PASS] Get Network ID
  Network ID: REYAX123

Test 10: Set Address
[PASS] Set Address
[PASS] Get Address
  Address: TEST1234

Test 11: Set RF Power
[PASS] Set RF Power
[PASS] Verify RF Power
  RF Power: -32 dBm

Test 12: RSSI Display Setting
[PASS] Set RSSI Display
[PASS] Verify RSSI Display
  RSSI Display: RSSI display enabled

Test 13: Distance Calibration
[PASS] Set Calibration
  Calibration Value: 0 cm
========================================
Basic Test Complete!
All essential functions tested.
========================================

// ------------------------ ESP32 ----------------------------------
#define RX_PIN 5  // Connect to RYUW122 TX
#define TX_PIN 4  // Connect to RYUW122 RX
#define RESET_PIN 6 // Connect to RYUW122 NRST (active LOW)

// The constructor takes specific pins and the Serial interface
RYUW122 uwb(TX_PIN, RX_PIN, &Serial1, RESET_PIN);

    // Test 1: Initialize Module
    bool initResult = uwb.begin(); 
    // ... handling error ...
    if (!initResult) {
        Serial.println(F("ERROR: Cannot initialize module!"));
        // ...
    }

    // Test 5: Set and verify mode
    Serial.println(F("\nTest 5: Set Operating Mode (TAG)"));
    
    // 1. Action: Set the mode to TAG
    bool setModeResult = uwb.setMode(RYUW122Mode::TAG);
    
    // 2. Verification: Ask the module what mode it is in
    RYUW122Mode currentMode = uwb.getMode();
    
    // 3. Validation: Did the module actually switch to TAG?
    bool verifyModeResult = (currentMode == RYUW122Mode::TAG);
    printTestResult("Verify Mode", verifyModeResult);

    // Test 9: Set Network ID
    const char* testNetworkId = "REYAX123";
    bool setNetworkResult = uwb.setNetworkId(testNetworkId);

    // ...

    // Test 10: Set Address
    const char* testAddress = "TEST1234";
    bool setAddressResult = uwb.setAddress(testAddress);

/**
 * @file basic_anchor.ino
 * @author Renzo Mischianti
 * @brief Unified example for basic ANCHOR communication, demonstrating both Async and Sync methods.
 * @version 1.0.0
 * @date 2025-10-10
 *
 * This sketch contains two methods for communicating with a Tag.
 * METHOD 1 (Asynchronous) is recommended as it does not block the main loop.
 * METHOD 2 (Synchronous) is simpler but blocks the loop while waiting for a response.
 *
 * **Instructions:** Uncomment the method you want to use in the `loop()` function and comment out the other.
 *
 * @copyright Copyright (c) 2024
 *
 */

#include <RYUW122.h>

// --- Configuration ---
const char* NETWORK_ID = "AABBCCDD";
const char* ANCHOR_ADDRESS = "A1A1A1A1";
const char* TAG_ADDRESS = "T1T1T1T1";

// ------------------ ARDUINO UNO SOFTWARE SERIAL ------------------
// Define pins for SoftwareSerial (adjust based on your board)
// #define RX_PIN 10  // Connect to RYUW122 TX
// #define TX_PIN 11  // Connect to RYUW122 RX
//
// // Create RYUW122 instance with SoftwareSerial for Arduino UNO
// RYUW122 uwb(TX_PIN, RX_PIN, RYUW122BaudRate::B_9600);
// -----------------------------------------------------------------
// -------------------------- ARDUINO MEGA -------------------------
// RYUW122 uwb(&Serial1);
// -----------------------------------------------------------------
// ------------------------ ESP32 ----------------------------------
#define RX_PIN 5  // Connect to RYUW122 TX
#define TX_PIN 4  // Connect to RYUW122 RX
#define RESET_PIN 6 // Connect to RYUW122 NRST (active LOW)

RYUW122 uwb(TX_PIN, RX_PIN, &Serial1, RESET_PIN);
// -----------------------------------------------------------------

// --- State Variables (for both methods) ---
unsigned long lastSendTime = 0;
const unsigned long SEND_INTERVAL = 5000; // 5 seconds
int loopCounter = 0;
volatile bool responseReceived = false; // Used by Async method

/**
 * @brief Callback function for the Asynchronous method.
 * This function is automatically called when a response from a Tag is received.
 */
void onAnchorDataReceived(const char* tagAddress, int payloadLength, const char* data, int distance, int rssi) {
    Serial.println(F("\n--- Callback Triggered (Async Response) ---"));
    Serial.print(F("Response from TAG: ")); Serial.println(tagAddress);
    Serial.print(F("Data: ")); Serial.println(data);
    Serial.print(F("Distance: ")); Serial.print(distance); Serial.println(F(" cm"));
    Serial.print(F("RSSI: ")); Serial.print(rssi); Serial.println(F(" dBm"));
    Serial.println(F("-------------------------------------------"));
    responseReceived = true;
}

void setup() {
    Serial.begin(115200);
    while (!Serial) { delay(100); }
    Serial.println(F("RYUW122 Unified Anchor Example (Async/Sync)"));

    if (!uwb.begin()) {
        Serial.println(F("Failed to initialize RYUW122 module. Halting."));
        while (1);
    }

    // Configure module settings
    uwb.setMode(RYUW122Mode::ANCHOR);
    uwb.setNetworkId(NETWORK_ID);
    uwb.setAddress(ANCHOR_ADDRESS);
    // Enable RSSI display on the TAG as well, although distance is calculated at Anchor
    // This ensures consistency if we ever look at logs here
    uwb.setRssiDisplay(RYUW122RSSI::ENABLE);

    // Register the callback function. It's needed for the async method.
    // It doesn't harm to have it registered for the sync method too.
    uwb.onAnchorReceive(onAnchorDataReceived);

    Serial.println(F("Anchor configured. Starting main loop."));
}

void loop() {
    // =================================================================================
    // === CHOOSE YOUR METHOD: Uncomment the desired section and comment out the other ===
    // =================================================================================

    // --- METHOD 1: Asynchronous (Non-Blocking) Communication (Recommended) ---
    // The main loop continues to run while waiting for a response.
    // Serial.print(F("Main loop running... Counter: "));
    // Serial.println(loopCounter++);

    // Periodically send a non-blocking request
    if (millis() - lastSendTime >= SEND_INTERVAL) {
        lastSendTime = millis();
        const char* message = "PING (Async)";
        Serial.print(F("\nSending '")); Serial.print(message); Serial.print(F("' to TAG ")); Serial.println(TAG_ADDRESS);
        uwb.anchorSendData(TAG_ADDRESS, strlen(message), message); // Returns immediately
    }
    // The uwb.loop() function processes incoming data and triggers the callback when a response arrives.
    uwb.loop();
    delay(500); // Slow down loop for readability

    // --- METHOD 2: Synchronous (Blocking) Communication ---
    /*
    Serial.println(F("\nAttempting to send data to Tag (blocking)..."));
    const char* message = "PING (Sync)";

    // This function WAITS for a response or timeout
    AnchorResponse response = uwb.anchorSendDataSync(TAG_ADDRESS, strlen(message), message);

    if (response.success) {
        Serial.println(F("--- Sync Response Received ---"));
        Serial.print(F("Data: ")); Serial.println(response.responseData);
        Serial.print(F("Distance: ")); Serial.print(response.distance); Serial.println(F(" cm"));
        Serial.print(F("RSSI: ")); Serial.print(response.rssi); Serial.println(F(" dBm"));
        Serial.println(F("------------------------------"));
    } else {
        Serial.println(F("Failed to receive sync response from Tag."));
    }
    delay(SEND_INTERVAL); // Wait before sending the next blocking request
    */
}

/**
 * @file basic_tag.ino
 * @author Renzo Mischianti
 * @brief Unified example for a TAG to respond to an Anchor.
 * @version 1.0.0
 * @date 2025-10-10
 *
 * This sketch configures the module as a Tag. It listens for incoming data
 * from an Anchor and sends a response back. This single Tag sketch works
 * seamlessly with both the Asynchronous and Synchronous methods in the
 * corresponding Anchor sketch.
 *
 * @copyright Copyright (c) 2024
 *
 */

#include <RYUW122.h>

// --- Configuration ---
const char* NETWORK_ID = "AABBCCDD";
const char* TAG_ADDRESS = "T1T1T1T1";

// ------------------ ARDUINO UNO SOFTWARE SERIAL ------------------
// Define pins for SoftwareSerial (adjust based on your board)
// #define RX_PIN 10  // Connect to RYUW122 TX
// #define TX_PIN 11  // Connect to RYUW122 RX
//
// // Create RYUW122 instance with SoftwareSerial for Arduino UNO
// RYUW122 uwb(TX_PIN, RX_PIN, RYUW122BaudRate::B_9600);
// -----------------------------------------------------------------
// -------------------------- ARDUINO MEGA -------------------------
// RYUW122 uwb(&Serial1);
// -----------------------------------------------------------------
// ------------------------ ESP32 ----------------------------------
#define RX_PIN 5  // Connect to RYUW122 TX
#define TX_PIN 4  // Connect to RYUW122 RX
#define RESET_PIN 6 // Connect to RYUW122 NRST (active LOW)

RYUW122 uwb(TX_PIN, RX_PIN, &Serial1, RESET_PIN);
// -----------------------------------------------------------------

/**
 * @brief Callback function to handle data received from an Anchor.
 * This is the standard way for a Tag to operate. It automatically
 * processes incoming requests without blocking the main loop.
 */
void onTagDataReceived(int payloadLength, const char* data, int rssi) {
    Serial.println(F("\n--- Data Received from Anchor ---"));
    Serial.print(F("Data: ")); Serial.println(data);
    Serial.print(F("RSSI: ")); Serial.print(rssi); Serial.println(F(" dBm"));

    // Prepare and send a response back to the Anchor
    const char* response = "PONG";
    Serial.print(F("Sending response: '")); Serial.print(response); Serial.println(F("'"));
    uwb.tagSendData(strlen(response), response);
    Serial.println(F("---------------------------------"));
}

void setup() {
    Serial.begin(115200);
    while (!Serial) { delay(100); }
    Serial.println(F("RYUW122 Unified Tag Example"));

    if (!uwb.begin()) {
        Serial.println(F("Failed to initialize RYUW122 module. Halting."));
        while (1);
    }

    // Configure module settings
    uwb.setMode(RYUW122Mode::TAG);
    uwb.setNetworkId(NETWORK_ID);
    uwb.setAddress(TAG_ADDRESS);
    // Enable RSSI display on the TAG as well, although distance is calculated at Anchor
    // This ensures consistency if we ever look at logs here
    uwb.setRssiDisplay(RYUW122RSSI::ENABLE);

    // Register the callback for incoming data
    uwb.onTagReceive(onTagDataReceived);

    Serial.println(F("Tag configured and listening for messages."));
}

void loop() {
    // The library's loop() function processes incoming serial data.
    // When a message from an Anchor arrives, it will trigger the
    // `onTagDataReceived` callback automatically.
    uwb.loop();

    // A small delay is good practice to prevent the loop from spinning
    // too fast, which can be inefficient on some microcontrollers.
    delay(10);
}

const char* NETWORK_ID = "AABBCCDD";
const char* ANCHOR_ADDRESS = "A1A1A1A1"; // My ID
const char* TAG_ADDRESS = "T1T1T1T1";    // Target ID

// Send "PING" and move on immediately
uwb.anchorSendData(TAG_ADDRESS, strlen(message), message);

uwb.loop(); // Essential for Async! checks serial buffer

// In setup():
uwb.onAnchorReceive(onAnchorDataReceived);

// The function definition:
void onAnchorDataReceived(...) {
    // This runs when the Tag replies
    Serial.print("Distance: "); Serial.println(distance);
}

// This line BLOCKS the code for up to 2 seconds (default timeout)
AnchorResponse response = uwb.anchorSendDataSync(TAG_ADDRESS, strlen(message), message);

if (response.success) {
    // We only reach here after the exchange is finished
    Serial.println(response.distance);
}

void loop() {
    // Constantly check for incoming data from the module
    uwb.loop(); 
    delay(10);
}

void onTagDataReceived(int payloadLength, const char* data, int rssi) {
    // 1. Print what we received
    Serial.print("Data: "); Serial.println(data); // Prints "PING"

    // 2. Send a reply (The "PONG")
    // The library handles the timing to ensure the Anchor can calculate distance
    const char* response = "PONG";
    uwb.tagSendData(strlen(response), response);
}

RYUW122 Unified Tag Example
Tag configured and listening for messages.

--- Data Received from Anchor ---
Data: PING (Async)
RSSI: -86 dBm
Sending response: 'PONG'
---------------------------------

--- Data Received from Anchor ---
Data: PING (Async)
RSSI: -86 dBm
Sending response: 'PONG'
---------------------------------

--- Data Received from Anchor ---
Data: PING (Async)
RSSI: -87 dBm
Sending response: 'PONG'
---------------------------------

--- Data Received from Anchor ---
Data: PING (Async)
RSSI: -87 dBm
Sending response: 'PONG'
---------------------------------

RYUW122 Unified Anchor Example (Async/Sync)
Anchor configured. Starting main loop.

Sending 'PING (Async)' to TAG T1T1T1T1

--- Callback Triggered (Async Response) ---
Response from TAG: T1T1T1T1
Data: PONG
Distance: 38 cm
RSSI: -73 dBm
-------------------------------------------

Sending 'PING (Async)' to TAG T1T1T1T1

--- Callback Triggered (Async Response) ---
Response from TAG: T1T1T1T1
Data: PONG
Distance: 45 cm
RSSI: -73 dBm
-------------------------------------------

Sending 'PING (Async)' to TAG T1T1T1T1

--- Callback Triggered (Async Response) ---
Response from TAG: T1T1T1T1
Data: PONG
Distance: 38 cm
RSSI: -73 dBm
-------------------------------------------

Sending 'PING (Async)' to TAG T1T1T1T1

--- Callback Triggered (Async Response) ---
Response from TAG: T1T1T1T1
Data: PONG
Distance: 62 cm
RSSI: -60 dBm
-------------------------------------------

Sending 'PING (Async)' to TAG T1T1T1T1

--- Callback Triggered (Async Response) ---
Response from TAG: T1T1T1T1
Data: PONG
Distance: 50 cm
RSSI: -63 dBm
-------------------------------------------