BLE device presence detection : How to scan and filter devices by RSSI using BleuIO

In this tutorial, we’ll guide you through creating a project that scans for nearby Bluetooth Low Energy (BLE) devices, filters them based on RSSI (Received Signal Strength Indicator), and determines if a specific device, the Close Beacon, is within a certain range. We’ll use the BleuIO USB dongle, which simplifies BLE development through its easy-to-use AT commands. By the end of this tutorial, you’ll have a working BLE scanner that can identify when the Close Beacon is within approximately 5 meters.

Overview of the Project

The goal of this project is to continuously scan for nearby BLE devices and check if a particular device, identified by its name (“Close beacon”), is within a defined range. We determine the range by setting an RSSI filter, which allows us to estimate the distance based on signal strength. If the device is found within this range, it is considered “online”; otherwise, it is “offline”.

Hardware Used

  • BleuIO USB Dongle: A BLE USB dongle that makes it easy to create BLE applications, prototypes, or test devices with AT commands and available libraries for Python and JavaScript.
  • Close Beacon: A BLE beacon device that broadcasts its presence to nearby BLE scanners. This hardware will be our target device to identify if it’s within a 5-meter range based on its RSSI.

Use Cases

  • Proximity Detection: Identify if a specific BLE device (e.g., a beacon or wearable) is within a set distance from the scanner.
  • Asset Tracking: Monitor the presence of assets in a particular area based on their BLE signal strength.
  • Environment Monitoring: Set up zones where certain devices must be present and get notified if they leave the range.

Getting Started with BleuIO

Before diving into the code, let’s cover the basic setup:

  1. Hardware: You’ll need a BleuIO USB dongle. Plug it into your computer’s USB port.
  2. Software: We’ll use JavaScript for this tutorial, running in a modern web browser that supports the Web Serial API. No additional software is required.

AT Commands Used

  • ATV1: Ensures verbose mode is enabled, meaning all command responses are returned in a human-readable format.
  • AT+CENTRAL: Sets the dongle into Central mode, allowing it to scan and connect to other BLE devices.
  • AT+FRSSI=-70: Filters out devices with an RSSI lower than -70 dBm, which helps to focus on devices within a closer range.
  • AT+GAPSCAN=3: Initiates a scan for nearby BLE devices.

HTML Setup

The following HTML file provides a simple user interface with a “Scan” button that starts the BLE scanning process.

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Look for Close Beacon</title>
    <style>
      body {
        text-align: center;
        margin: 200px auto;
        width: 800px;
        font-size: 20px;
      }
    </style>
  </head>
  <body>
    <button id="connect" style="font-size: 20px; width: 200px; height: 50px">
      Scan
    </button>
    <pre id="output"></pre>

    <script src="serial.js"></script>
  </body>
</html>

JavaScript Code: serial.js

This script, which is linked in the HTML file, manages the BLE scanning and RSSI filtering.

let port;
let reader;
let writer;
let buffer = '';
let ibeaconFound = false;
let scanIntervalId;
const connectButton = document.getElementById('connect');
const outputElement = document.getElementById('output');

connectButton.addEventListener('click', async () => {
  try {
    // Request a port and open a connection.
    port = await navigator.serial.requestPort();
    await port.open({ baudRate: 9600 });

    // Start reading from the serial port.
    reader = port.readable.getReader();
    writer = port.writable.getWriter();

    // Send initial setup commands
    await writer.write(new TextEncoder().encode('ATV1\r'));
    await delay(1000);
    await writer.write(new TextEncoder().encode('AT+CENTRAL\r'));
    await delay(1000);
    await writer.write(new TextEncoder().encode('AT+FRSSI=-70\r'));
    await delay(1000);

    // Start the scanning process at 15-second intervals
    startScanInterval();

    // Read data from the device.
    readLoop();
  } catch (error) {
    console.error('There was an error opening the serial port:', error);
  }
});

function startScanInterval() {
  scanIntervalId = setInterval(async () => {
    ibeaconFound = false; // Reset the flag for each scan
    await writer.write(new TextEncoder().encode('AT+GAPSCAN=3\r'));

    // Wait 3 seconds to check if 'Close beacon' is found
    setTimeout(() => {
      if (ibeaconFound) {
        outputElement.innerHTML =
          '<div style="color: green; display: inline-block; margin-right: 8px;">&#9679;</div>Close beacon is within the range of 5 meters.<br>';
      } else {
        outputElement.innerHTML =
          '<div style="color: red; display: inline-block; margin-right: 8px;">&#9679;</div>Close beacon is not within the range of 5 meters.<br>';
      }
    }, 3000);
  }, 15000); // 15 seconds interval
}

async function readLoop() {
  while (true) {
    const { value, done } = await reader.read();
    if (done) {
      // Allow the serial port to be closed later.
      reader.releaseLock();
      break;
    }
    // Convert the data to a string and append it to the buffer.
    buffer += new TextDecoder().decode(value);

    // Split the buffer by line breaks to process each line separately.
    let lines = buffer.split('\n');
    buffer = lines.pop(); // Save the last incomplete line for the next read.

    for (let line of lines) {
      line = line.trim(); // Remove any extra whitespace

      // Check if the line is a valid JSON string
      if (line.startsWith('{') && line.endsWith('}')) {
        try {
          // Parse the JSON object.
          let data = JSON.parse(line);
          // Check if the object contains the 'name' property and if it's "Sheikh ibeacon".
          if (data.S && data.name === 'Close beacon') {
            ibeaconFound = true;
          }
        } catch (e) {
          console.error('Error parsing JSON:', e, line);
        }
      } else {
        // Log non-JSON lines for debugging or just ignore them.
        console.log('Non-JSON line received:', line);
      }
    }
  }
}

function delay(ms) {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

window.addEventListener('beforeunload', async () => {
  // Stop the scanning interval when the window is closed or refreshed.
  if (scanIntervalId) {
    clearInterval(scanIntervalId);
  }

  // Close the port when the window is closed or refreshed.
  if (reader) {
    await reader.cancel();
    reader.releaseLock();
  }
  if (writer) {
    writer.releaseLock();
  }
  if (port) {
    await port.close();
  }
});

Code Explanation

  1. HTML Interface:
    • The HTML file provides a simple user interface with a “Scan” button. When clicked, this button triggers the BLE scanning process.
  2. JavaScript Code:
    • Initialization: We start by requesting access to the serial port and opening a connection to the BLE dongle. After setting up the port, we configure the dongle by sending the ATV1, AT+CENTRAL, and AT+FRSSI=-70 commands. These commands enable verbose mode, set the device to central mode, and filter out weak BLE signals (below -70 dBm), respectively.
    • Scan Interval: The setInterval function initiates a BLE scan every 15 seconds. The AT+GAPSCAN=3 command scans for nearby BLE devices for 3 seconds.
    • Device Detection: After each scan, we check if the specific BLE device named “Close beacon” is found. If it is, a green dot appears with a message indicating the device is within range. If not, a red dot with a message indicating the device is not within range is shown.
    • Reading Data: The readLoop function continuously reads data from the serial port. It checks for JSON-formatted responses from the dongle and looks for the device name in the scanned results.
    • Clean Up: We ensure that the scanning process stops and the serial port is closed when the user leaves the page or closes the window.

Setting Up RSSI Filtering for 5-Meter Range Detection

In this project, the goal was to detect if a specific BLE device, “Close Beacon,” is within approximately 5 meters of our BLE dongle. We achieved this by using the Received Signal Strength Indicator (RSSI), which helps us estimate the distance based on the strength of the received signal.

Understanding RSSI and Distance

RSSI is a measure of signal strength, with higher (less negative) values indicating a closer proximity to the BLE device. The relationship between RSSI and distance is governed by the following formula:

  • A: RSSI at 1 meter (typically around -56 dBm for Bluetooth).
  • n: Path-loss exponent (usually 2 for free space, 3 for indoor environments).

For a 5-meter distance, we calculated that an RSSI of -70 dBm is appropriate. Using the formula:

  • A = -56 dBm
  • n = 2 (assuming a free-space environment)

An RSSI of -70 dBm corresponds to approximately 5 meters, which is suitable for detecting if a device is within this range.

Practical Distance Adjustment

While theoretical calculations are useful, it’s also possible to perform a practical distance adjustment by placing the “Close Beacon” 5 meters away from the BLE dongle in a controlled environment, such as a room. You can then read the obtained RSSI value directly from the BleuIO dongle. This approach takes into account the real-world radio performance of both devices, providing a more accurate and practical RSSI value for your specific setup.

Output

The BleuIO USB dongle makes it incredibly easy to develop and prototype BLE applications using AT commands. This project demonstrates how you can set up a BLE scanner with RSSI filtering to monitor the proximity of a specific device. Whether you’re developing a custom IoT solution, monitoring assets, or just exploring BLE technology, BleuIO provides a simple and effective toolset to get your projects up and running quickly.

By following this tutorial, you should now have a good understanding of how to use the BleuIO dongle to create a BLE application that scans for devices and filters them based on their signal strength.

Share this post on :

BLE Signal Strength Monitoring in real-time Using BleuIO and Renesas RA4M2

Introduction

This project demonstrates how to leverage the Renesas RA4M2 microcontroller, combined with the BleuIO Bluetooth Low Energy (BLE) USB dongle, to perform a wireless signal strength scan. It provides a practical example of how to use the USB Host Communication Device Class (HCDC) driver to communicate with a BLE device, highlighting how easy it is to create BLE applications using the BleuIO dongle.

By integrating these technologies, the project enables users to scan for nearby BLE devices, parse the Received Signal Strength Indicator (RSSI) from advertising data, and display it in real-time using the RTTViewer. This setup offers a hands-on approach to understanding BLE communication and signal strength analysis.

Requirements

Setup

  • Connect a Micro USB device cable (type-A male to micro-B male) between J10 (Debug1) and a Computer USB port.
  • Plug in a BleuIO Dongle in the USB OTG Cable (type-A female to micro-B male) and connect it to J11 (USB Full Speed).
  • Make sure Jumper J12 is placed on pins 1-2
  • Remove Jumper J15 pins

Importing project

  • Open e² studio IDE
  • Choose a workspace and click ‘Launch’
  • Download or clone the example project. Place the folder ‘bleuio_ra4m2_rssi_scan_example’ in workspace.
  • Choose Import Project
  • Select ‘Existing Projects into Workspace’ under the ‘General’ tab:
  • Click the ‘Browse…’ button and open folder where the ‘bleuio_ra4m2_rssi_scan_example’ project folder is located:
  • Finally select the project and click ‘Finish’. You have now imported the the project!

Running the example

  • Go to file ‘usb_hcdc_app.c’ under ‘src/’ and edit line 54 to the mac address of the desired:

#define ADDR_TO_SCAN "[0]D0:76:50:80:01:75"
  • [0] = public address
  • [1] = private address

    On a closebeacon the mac address is printed on the back of the box (it will need to be converted to Hex):


    For example: 208-118-080-128-001-117 in Hex is: D0-76-50-80-01-75
  • Build the project by clicking the building icon:
  • Use Debug to download and run the project. The first time you need to configure the debug settings. Click down arrow to the right of the Debug icon and select ‘Debug Configurations…’


    Under ‘Renesas GDB Hardware Debugging’ select ‘bleuio_ra4m2_rssi_scan_example.elf’ and click ‘Debug’.

    The debug is now configured and the ‘Debug’ icon can be used next time to run the project.
  • Open RTTViewer. Connect and use these settings:
  • Connection to J-Link: USB
    Specify Target Device: R7FA4M2AD
    Target Interface & Speed: SWD 4000kHz
    RTT Control Block: Address 0x2000095c
  • On the debugger screen in e² studio click the ‘Resume’ icon twice to run the project.


  • You should now see the output on the RTTViewer. Notice that when you move the scanned device closer to the BleuIO the RSSI value will increase.

Output

Below is the output screen that displays the RSSI values in real-time as the BleuIO dongle scans for nearby BLE devices:

Practical Use Cases

The BleuIO RA4M2 RSSI Scan Project can be applied in various scenarios where monitoring BLE signal strength is critical:

  1. Proximity-Based Applications: By tracking RSSI values, developers can create proximity-based applications where actions are triggered based on the distance between BLE devices, such as automated check-ins, asset tracking, or location-based services.
  2. Signal Strength Mapping: The project can be used to map signal strength in different environments, helping to optimize the placement of BLE devices like beacons in smart homes, retail stores, or industrial settings.
  3. Device Tracking and Monitoring: In IoT applications, RSSI can be used to monitor the presence and movement of devices within a specific range, useful in security systems, inventory management, or environmental monitoring.

This project not only showcases the capabilities of the BleuIO dongle but also serves as a foundation for developing more complex BLE applications. Whether you’re a hobbyist, developer, or engineer, this project provides valuable insights into BLE communication and its practical applications.

Share this post on :

Building BLE Applications with BleuIO and Go

In this tutorial, we will walk you through the steps to get started with Bluetooth Low Energy (BLE) development using the BleuIO USB dongle and the Go programming language. BleuIO is a versatile and user-friendly BLE USB dongle that simplifies BLE application development with its easy-to-use AT Commands. We will show you how to set up your environment, write a simple Go program to interact with the BLE dongle, and explore some of the key features of BleuIO.

Introduction to Go

Go, also known as Golang, is an open-source programming language developed by Google. It is designed for simplicity, efficiency, and reliability, making it an excellent choice for system programming and large-scale software development. Go’s strong concurrency support, fast compilation, and robust standard library make it a popular language for network programming, cloud services, and, of course, BLE applications.

Introduction to BleuIO

BleuIO is a Bluetooth Low Energy USB dongle that can be used to create new BLE applications quickly and easily. With its built-in AT Commands, developers can interact with the BLE dongle without needing deep knowledge of BLE protocols or complex configurations. BleuIO supports various operating systems, making it a versatile tool for any development environment.

Key features of BleuIO include:

  • Easy-to-use AT Commands for faster development
  • Compatibility with any programming language
  • Support for Windows, macOS, and Linux

Setting Up Your Development Environment

Step 1: Install Go

First, ensure that you have Go installed on your system. You can download the latest version of Go from the official website: https://golang.org/dl/. Follow the installation instructions for your operating system.

Step 2: Initialize a New Go Module

Create a directory and open a terminal . Run the following command to initialize a new Go module:

go mod init bleuio-example

Step 3: Install the Serial Package

Install the go.bug.st/serial package, which provides a simple API for serial communication in Go:

go get go.bug.st/serial

Writing Your First Go Program with BleuIO

Step 4: Write the Program

Create a new file named main.go in your project directory and add the following code:

package main

import (
"fmt"
"log"
"time"

"go.bug.st/serial"
)

func main() {
// Open the serial port
mode := &serial.Mode{
BaudRate: 9600,
}
port, err := serial.Open("/dev/cu.usbmodem4048FDE52CF21", mode)
if err != nil {
log.Fatalf("Failed to open port: %v", err)
}
defer port.Close()

// Write "AT+CENTRAL" to the serial port
_, err = port.Write([]byte("AT+CENTRAL\r"))
if err != nil {
log.Fatalf("Failed to write AT+CENTRAL to port: %v", err)
}
fmt.Println("Command sent: AT+CENTRAL")

// Wait for a short moment to ensure the command is processed
time.Sleep(2 * time.Second)

// Read the response for the AT+CENTRAL command
buf := make([]byte, 100)
n, err := port.Read(buf)
if err != nil {
log.Fatalf("Failed to read from port: %v", err)
}
fmt.Printf("Response from AT+CENTRAL:\n%s\n", string(buf[:n]))

// Write "AT+GAPSCAN=5" to the serial port
_, err = port.Write([]byte("AT+GAPSCAN=5\r"))
if err != nil {
log.Fatalf("Failed to write AT+GAPSCAN=5 to port: %v", err)
}
fmt.Println("Command sent: AT+GAPSCAN=5")

// Wait for the scan to complete (5 seconds in this case)
time.Sleep(6 * time.Second) // Adding a bit more time to ensure the response is received

// Read the response for the AT+GAPSCAN=5 command
buf = make([]byte, 1000)
n, err = port.Read(buf)
if err != nil {
log.Fatalf("Failed to read from port: %v", err)
}

// Print the response
fmt.Printf("Response from AT+GAPSCAN=5:\n%s\n", string(buf[:n]))
}

Step 5: Run the Program

Ensure your BleuIO USB dongle is connected and configured correctly. Then, run the program using the following command in the terminal:

go run main.go

Explanation of the Program

  1. Opening the Serial Port: The program opens the serial port where the BleuIO dongle is connected. Adjust the serial port path (/dev/cu.usbmodem4048FDE52CF21) according to your system (e.g., COM3 on Windows). To get the location of connected BleuIO on macOS, run this command on terminal ls /dev/cu.*
  2. Setting the Central Role: The program sends the AT+CENTRAL command to set the BLE dongle in central role mode. Similarly we can try sending AT+FINDSCANDATA=5B07=3 which will look for advertised data from BLE devices whose manufacturing id is 5B07.
  3. Reading the Response: It waits for 2 seconds to ensure the command is processed and reads the response from the serial port.
  4. Scanning for BLE Devices: The program sends the AT+GAPSCAN=5 command to scan for nearby BLE devices for 5 seconds.
  5. Printing the Scan Results: After waiting for the scan to complete, the program reads and prints the response from the serial port.

Output

This tutorial demonstrated how to get started with BLE development using the BleuIO USB dongle and the Go programming language. BleuIO simplifies BLE application development with its straightforward AT Commands, making it accessible for developers using any programming language. With Go’s efficiency and robust standard library, you can quickly develop powerful BLE applications.

Share this post on :

Introducing BleuIO Pro: Smart BLE USB Dongle for Advanced BLE Applications

We are thrilled to announce the release of the BleuIO Pro, the latest and most advanced addition to our range of Bluetooth Low Energy (BLE) USB dongles. Designed for the developers looking to create advance BLE 5.2 applications, the BleuIO Pro offers unmatched features, speed, and versatility.

Special Launch Offer: Save Big on BleuIO Pro

To celebrate the launch of the BleuIO Pro, we are offering an exclusive limited-time discount. Order now and get the BleuIO Pro for just $29, a significant saving off the regular price of $35. This offer is only available until September 2024, so don’t miss out on this opportunity to enhance your BLE projects with the most advanced BLE USB dongle on the market.

Get it now

Key Features of BleuIO Pro

The BleuIO Pro builds upon the solid foundation of our original BleuIO, including all its amazing features while introducing significant enhancements to meet the demands of advanced BLE applications. Here’s what makes the BleuIO Pro a game-changer:

  • Renesas SmartBond DA14695 SoC: At the heart of the BleuIO Pro is the powerful Renesas SmartBond DA14695 System-on-Chip (SoC), ensuring robust performance and reliability.
  • Bluetooth® Low Energy 5.2: Experience the latest in BLE technology with BLE 5.2, offering improved connection stability, extended range, and higher data throughput.
  • 32Mbit QSPI FLASH: With 32Mbit of Quad SPI Flash memory, the BleuIO Pro provides ample space for complex applications and data storage.
  • Transfer Speeds up to 2Mbps: Enjoy faster data transfer speeds, ideal for time-sensitive applications and large data exchanges.
  • Extended Advertising Packets: Utilize extended advertising packets to broadcast more data and improve the efficiency of your BLE communications.
  • Programmable LED: Customize the integrated LED for status indicators, notifications, or any application-specific functions.

Ideal for Advanced BLE Applications

The BleuIO Pro is perfect for developers looking to push the boundaries of BLE technology. Whether you’re working on IoT projects, wearable tech, smart home devices, or industrial automation, the BleuIO Pro provides the advanced capabilities you need.

Easy Development with AT Commands and Libraries

As with the original BleuIO, the BleuIO Pro can be easily programmed using AT Commands, making it accessible even for those new to BLE development. For faster and more sophisticated development, our Python and Javascript libraries offer extensive support and flexibility.

Don’t miss out on this opportunity to upgrade your toolkit and take your projects to the next level with the BleuIO Pro.

Share this post on :

Create your own Apple HomeKit Accessories to monitor air quality data using BleuIO

In this tutorial, we’ll walk you through the process of creating your own Apple HomeKit accessory that monitor and manage air quality data from a BLE device, specifically the HibouAir air quality monitoring device. By the end of this tutorial, you’ll have a functional BLE application that integrates with Apple’s HomeKit, demonstrating how easily you can develop BLE applications with the BleuIO dongle.

Overview of the Project

In this project, our goal is to create a BLE application that communicates with the HibouAir device, which provides air quality data. The application will:

  1. Connect to a BleuIO USB dongle to communicate with BLE devices.
  2. Scan for the HibouAir device using AT commands.
  3. Decode the air quality data from the HibouAir device.
  4. Integrate with HomeKit to display and manage the data in a smart home environment.
  5. Update the accessory information and continuously monitor the air quality data.

What is HomeKit?

HomeKit is Apple’s framework for home automation that allows users to control smart home devices using their Apple devices. With HomeKit, you can control a wide range of devices like lights, thermostats, locks, and sensors through the Apple Home app, Siri voice commands, and other Apple devices.

The key features of HomeKit include:

  • Secure Communication: HomeKit uses end-to-end encryption to ensure that data transmitted between your devices and the Home app remains private and secure.
  • Integration with Siri: HomeKit-enabled devices can be controlled using Siri voice commands, enabling hands-free control of your smart home.
  • Automation: Users can create automated routines and scenes that trigger actions based on time, location, or device status. For example, you can set up a “Good Night” scene that turns off the lights and locks the door when you say goodnight to Siri.

What is HAP-NodeJS?

HAP-NodeJS is an open-source implementation of the HomeKit Accessory Protocol (HAP) written in Node.js. It allows developers to create HomeKit-compatible accessories and bridge devices that can be controlled through Apple’s HomeKit ecosystem.

Devices Required

To follow this tutorial, you will need:

  1. BleuIO USB Dongle: A Bluetooth Low Energy USB dongle used to interface with BLE devices.
  2. HibouAir Device: A BLE air quality monitoring device that provides air quality metrics such as temperature, CO2 levels, humidity, and light levels.
  3. A Computer: Running Windows, macOS, or Linux ,  Raspberry Pi or any other platform that can run Node.js.

Connecting to BleuIO

To connect to the BleuIO dongle, we’ll use Node.js and the serialport package to communicate with the BLE device. The BleuIO dongle interfaces with your computer over a serial port, which allows you to send AT commands and receive data from BLE devices.

Decoding the Data

Once we receive the data from the HibouAir device, we need to decode it. The data is encoded in a specific format that we will parse and extract the relevant air quality metrics. We use a function to decode the advertisement data, which includes temperature, CO2 levels, humidity, and light levels.

Setting Up HomeKit Environment Data

We will use the hap-nodejs library to integrate our application with HomeKit. This will allow us to create HomeKit accessories that represent our air quality metrics. We set up services for temperature, CO2 levels, humidity, and light, and update these services with real-time data from the HibouAir device.

Running the Script

Here’s a step-by-step guide on how to set up and run the script:

  1. Install Required Packages
    First, make sure you have Node.js installed on your computer. Then, install the required npm packages by running
    npm install hap-nodejs serialport
  2. Create the Script
    Save the following code as hibouair.js or clone it from https://github.com/smart-sensor-devices-ab/bleuio-hibouair-homekit-integration
const hap = require('hap-nodejs');
const { SerialPort } = require('serialport');

const Accessory = hap.Accessory;
const Characteristic = hap.Characteristic;
const CharacteristicEventTypes = hap.CharacteristicEventTypes;
const Service = hap.Service;

// Get the device ID from the command-line arguments
const deviceId = process.argv[2];

if (!deviceId) {
  console.error(
    'Device ID not present. Please provide the device ID as follows:'
  );
  console.error('node hibouair.js <device_id>');
  process.exit(1);
}

// Define the manufacturer name you're looking for
const targetManufacturer = 'Smart Sensor Devices';

// Buffers to hold the incoming data
let buffer = '';
let scanningDetected = false;
let responseFound = false;
let port; // Variable to hold the SerialPort instance

// Initialize HomeKit accessories globally
let temperature, co2, humidity, light;

async function connectAndSendCommands() {
  try {
    // Get a list of all serial ports
    const ports = await SerialPort.list();

    // Find the port with the specified manufacturer
    const targetPort = ports.find(
      (port) => port.manufacturer === targetManufacturer
    );

    if (!targetPort) {
      console.log(`No port found with manufacturer: ${targetManufacturer}`);
      return;
    }

    // Log the selected port
    console.log(`Connecting to port: ${targetPort.path}`);

    // Create a new SerialPort instance for the selected port
    port = new SerialPort({
      path: targetPort.path,
      baudRate: 9600, // Adjust the baud rate as needed
    });

    // Event handler for when the port opens
    port.on('open', () => {
      console.log(
        `Port ${targetPort.path} is open and ready for communication.`
      );

      // Write the initial command
      port.write('AT+CENTRAL\r\n', (err) => {
        if (err) {
          console.error('Error writing initial command:', err.message);
        } else {
          console.log('Initial command sent: AT+CENTRAL');
        }
      });

      // Start the periodic scanning for BLE data
      setInterval(() => {
        port.write(`AT+FINDSCANDATA=${deviceId}=5\r\n`, (err) => {
          if (err) {
            console.error('Error writing scan command:', err.message);
          } else {
            console.log(`Scan command sent: AT+FINDSCANDATA=${deviceId}=5`);
          }
        });
      }, 20000); // 20000 milliseconds = 20 seconds
    });

    // Event handler for when data is received on the port
    port.on('data', (data) => {
      buffer += data.toString();
      processBuffer();
    });

    // Event handler for when there is an error
    port.on('error', (err) => {
      console.error('Error:', err.message);
      if (port) {
        port.close(() => {
          console.log('Port closed due to error.');
        });
      }
    });
  } catch (err) {
    console.error('Error listing or connecting to serial ports:', err);
    if (port) {
      port.close(() => {
        console.log('Port closed due to error.');
      });
    }
  }

  function processBuffer() {
    // Split the buffer into lines
    const lines = buffer.split('\r\n');

    for (let i = 0; i < lines.length; i++) {
      const line = lines[i].trim();

      if (line === 'SCANNING...') {
        scanningDetected = true;
      } else if (line === 'SCAN COMPLETE') {
        scanningDetected = false;
      } else if (scanningDetected && line.length > 0) {
        // Extract the data from the line
        const dataMatch = line.match(/^\[.*?\] Device Data \[ADV\]: (.+)$/);
        if (dataMatch && dataMatch[1]) {
          const extractedData = dataMatch[1].trim();
          console.log('Extracted data:', extractedData);

          // Decode the data
          const decodedData = advDataDecode(extractedData);
          console.log('Decoded data:', decodedData);

          responseFound = true;
          buffer = ''; // Clear the buffer after finding the response

          if (!temperature || !co2 || !humidity || !light) {
            setupAccessory(decodedData); // Setup accessory if not already done
          } else {
            updateAccessory(decodedData); // Update accessory with decoded data
          }

          return;
        }
      }
    }

    // Keep the remaining buffer if no relevant line was found
    buffer = lines[lines.length - 1]; // Retain the last part of the buffer
  }

  // Function to decode the advertisement data
  function advDataDecode(adv) {
    let pos = adv.indexOf('5B0705');
    let dt = new Date();
    let currentTs =
      dt.getFullYear() +
      '/' +
      (dt.getMonth() + 1).toString().padStart(2, '0') +
      '/' +
      dt.getDate().toString().padStart(2, '0') +
      ' ' +
      dt.getHours().toString().padStart(2, '0') +
      ':' +
      dt.getMinutes().toString().padStart(2, '0') +
      ':' +
      dt.getSeconds().toString().padStart(2, '0');
    let tempHex = parseInt(
      '0x' +
        adv
          .substr(pos + 22, 4)
          .match(/../g)
          .reverse()
          .join('')
    );
    if (adv) dataShowing = true;
    if (tempHex > 1000) tempHex = (tempHex - (65535 + 1)) / 10;
    else tempHex = tempHex / 10;
    return {
      boardID: adv.substr(pos + 8, 6),
      type: adv.substr(pos + 6, 2),
      light: parseInt(
        '0x' +
          adv
            .substr(pos + 14, 4)
            .match(/../g)
            .reverse()
            .join('')
      ),
      pressure:
        parseInt(
          '0x' +
            adv
              .substr(pos + 18, 4)
              .match(/../g)
              .reverse()
              .join('')
        ) / 10,
      temp: tempHex,
      hum:
        parseInt(
          '0x' +
            adv
              .substr(pos + 26, 4)
              .match(/../g)
              .reverse()
              .join('')
        ) / 10,
      voc: parseInt(
        '0x' +
          adv
            .substr(pos + 30, 4)
            .match(/../g)
            .reverse()
            .join('')
      ),
      pm1:
        parseInt(
          '0x' +
            adv
              .substr(pos + 34, 4)
              .match(/../g)
              .reverse()
              .join('')
        ) / 10,
      pm25:
        parseInt(
          '0x' +
            adv
              .substr(pos + 38, 4)
              .match(/../g)
              .reverse()
              .join('')
        ) / 10,
      pm10:
        parseInt(
          '0x' +
            adv
              .substr(pos + 42, 4)
              .match(/../g)
              .reverse()
              .join('')
        ) / 10,
      co2: parseInt('0x' + adv.substr(pos + 46, 4)),
      vocType: parseInt('0x' + adv.substr(pos + 50, 2)),
      ts: currentTs,
    };
  }
}

// Function to setup HomeKit accessory
function setupAccessory(data) {
  const accessoryUuid = hap.uuid.generate('hap.hibouair.sensor');
  const accessory = new Accessory('HibouAir', accessoryUuid);

  // Create a function to initialize services
  function initializeService(
    serviceType,
    serviceName,
    initialValue,
    characteristicType
  ) {
    const service = new serviceType(serviceName);

    const characteristic = service.getCharacteristic(characteristicType);

    characteristic.on(CharacteristicEventTypes.GET, (callback) => {
      console.log(`Queried current ${serviceName}: ${initialValue}`);
      callback(undefined, initialValue);
    });

    accessory.addService(service);

    return {
      service,
      characteristic,
      initialValue,
    };
  }

  // Initialize temperature, CO2, humidity, and light services
  temperature = initializeService(
    Service.TemperatureSensor,
    'Temperature Sensor',
    data.temp,
    Characteristic.CurrentTemperature
  );

  co2 = initializeService(
    Service.CarbonDioxideSensor,
    'CO2 Sensor',
    data.co2,
    Characteristic.CarbonDioxideLevel
  );

  humidity = initializeService(
    Service.HumiditySensor,
    'Humidity Sensor',
    data.hum,
    Characteristic.CurrentRelativeHumidity
  );

  light = initializeService(
    Service.LightSensor,
    'Light Sensor',
    data.light,
    Characteristic.CurrentAmbientLightLevel
  );

  // Set accessory information
  accessory
    .getService(Service.AccessoryInformation)
    .setCharacteristic(Characteristic.Manufacturer, 'Smart Sensor Devices')
    .setCharacteristic(Characteristic.SerialNumber, deviceId);

  // Publish the accessory
  accessory.publish({
    username: '17:51:07:F4:BC:8B',
    pincode: '123-45-678',
    port: 47129,
    category: hap.Categories.SENSOR, // value here defines the symbol shown in the pairing screen
  });

  console.log('Accessory setup finished!');
}

// Function to update HomeKit accessory with new data
function updateAccessory(data) {
  temperature.initialValue = data.temp;
  co2.initialValue = data.co2;
  humidity.initialValue = data.hum;
  light.initialValue = data.light;

  console.log(`Updated current temperature: ${temperature.initialValue}`);
  console.log(`Updated current CO2 level: ${co2.initialValue}`);
  console.log(`Updated current Humidity level: ${humidity.initialValue}`);
  console.log(`Updated current light level: ${light.initialValue}`);

  // Update the characteristic values
  temperature.service.setCharacteristic(
    Characteristic.CurrentTemperature,
    temperature.initialValue
  );
  co2.service.setCharacteristic(
    Characteristic.CarbonDioxideLevel,
    co2.initialValue
  );
  humidity.service.setCharacteristic(
    Characteristic.CurrentRelativeHumidity,
    humidity.initialValue
  );
  light.service.setCharacteristic(
    Characteristic.CurrentAmbientLightLevel,
    light.initialValue
  );
}

// Call the function to connect and send commands
connectAndSendCommands();

Run the Script

Execute the script from your terminal by providing the device ID as an argument:

node hibouair.js 220069

This command will start the script, connect to the BleuIO dongle, scan for the HibouAir device, decode the data, and set up the HomeKit accessories with the real-time data from the device.

Output

This tutorial demonstrates how easy it is to develop BLE applications using BleuIO and integrate them with HomeKit. By following these steps, you can create real-time monitoring solutions for a variety of BLE-enabled devices, enhancing the functionality of your smart home environment.

Share this post on :

Master BLE Device Discovery with BleuIO : An Expert Guide for BLE Developers

Enhancing BLE Applications with BleuIO: Efficient Device Scanning and Data Retrieval

In the world of Bluetooth Low Energy (BLE) technology, discovering and connecting to nearby devices is a foundational feature. Whether you are developing a BLE-enabled smart home system, a fitness tracker, or an industrial IoT application, the ability to scan for nearby devices and retrieve data efficiently is crucial. The BleuIO USB dongle, with its user-friendly AT commands, simplifies this process significantly. This article explores how to utilize the scanning features of BleuIO to enhance your BLE applications.

Why Efficient Device Scanning is Essential

Efficient scanning for BLE devices is vital for several reasons:

  1. Device Discovery: Quickly identifying and connecting to nearby devices is crucial for seamless user experiences in applications such as smart home systems, wearables, and more.
  2. Data Retrieval: Scanning allows you to gather advertising and response data from nearby BLE devices, which can be used for various purposes, from device identification to obtaining sensor readings.
  3. Power Management: Optimizing scan parameters helps conserve battery life, which is particularly important for portable and battery-operated devices.

How BleuIO Can Be Helpful

The BleuIO USB dongle offers a range of AT commands that make BLE development straightforward and efficient. Key among these are commands for scanning nearby devices and retrieving advertising data. Let’s dive into three essential commands: AT+GAPSCAN, AT+FINDSCANDATA, and AT+SCANTARGET.

Command: AT+GAPSCAN

The AT+GAPSCAN command initiates a Bluetooth device scan, either indefinitely or for a specified duration. This command is only accepted when the device is in the central role and not connected to any other device.

  • Usage:
  • AT+GAPSCAN starts an indefinite scan.
  • AT+GAPSCAN=seconds starts a scan for the specified number of seconds.
  • Example:
AT+GAPSCAN
SCANNING...

[01] Device: [1]30:63:C5:D0:B1:DE RSSI: -38

[02] Device: [0]D0:76:50:80:0A:98 RSSI: -75 (closebeacon.com)

[03] Device: [1]27:5D:B8:2E:96:B0 RSSI: -51

[04] Device: [1]5E:CE:CF:C5:20:BB RSSI: -84

SCAN COMPLETE

In this example, the AT+GAPSCAN command scans for nearby BLE devices, displaying their addresses and signal strengths (RSSI).

Practical Applications of AT+GAPSCAN

  1. Smart Home Systems: Automatically discover and list all BLE-enabled devices in your home, such as smart lights, locks, and thermostats.
  2. Wearable Devices: Quickly identify nearby fitness trackers or health monitors for data synchronization.
  3. Retail Environments: Scan for BLE beacons that provide location-based advertisements or information.

Command: AT+FINDSCANDATA

The AT+FINDSCANDATA command scans for advertising and response data containing specific search parameters. This scan can run indefinitely or for a set duration and is particularly useful for filtering devices based on their advertised data.

  • Usage:
  • AT+FINDSCANDATA=search_params starts an indefinite scan for devices containing the specified search parameters.
  • AT+FINDSCANDATA=search_params=seconds scans for the specified duration.
  • Example:
AT+FINDSCANDATA=FF5
SCANNING...

[00:D4:2E:CD:72:23] Device Data [ADV]: 02010618FF5B00110101010101010101011405326845343864353466757675

[D7:D3:AA:00:B5:24] Device Data [ADV]: 02010618FF540930430924302903049320943094F90890548359049E495432

SCAN COMPLETE

In this example, the AT+FINDSCANDATA command scans for devices advertising data that contains the string “FF5”.

Practical Applications of AT+FINDSCANDATA

  1. Custom Applications: Filter and find specific BLE devices in environments with many BLE signals.
  2. Targeted Marketing: Identify BLE beacons with specific advertising data for targeted advertising campaigns.
  3. Industrial Monitoring: Locate and interact with BLE sensors that provide specific types of data.

Command: AT+SCANTARGET

The AT+SCANTARGET command scans for advertising and response data from specific devices. You can scan for one or multiple devices, and the scan continues indefinitely unless a timer is set.

  • Usage:
  • AT+SCANTARGET=[addr_type]slave_address starts an indefinite scan for the specified device.
  • AT+SCANTARGET=[addr_type]slave_address=seconds scans for the specified device for the given duration.
  • Multiple devices can be scanned by separating addresses with a semicolon (;).
  • Example:
AT+SCANTARGET=[0]00:00:00:00:00:01
SCANNING...

[00:00:00:00:00:01] Device Data [ADV]: DataXYZ

[00:00:00:00:00:01] Device Data [RESP]: DataXYZ

In this example, the AT+SCANTARGET command scans for advertising and response data from the device with address 00:00:00:00:00:01.

Practical Applications of AT+SCANTARGET

  1. Device Tracking: Continuously monitor specific devices for location and status updates.
  2. Data Collection: Retrieve advertising and response data from specific BLE sensors in a targeted manner.
  3. Security Systems: Monitor specific BLE-enabled security devices for activity and alerts.


Testing your BLE application

Testing is critical phases in the development of BLE applications. The scanning features of the BleuIO USB dongle, particularly the AT+GAPSCAN, AT+FINDSCANDATA, and AT+SCANTARGET commands, make these tasks easier and more effective for BLE developers.

During the testing phase, developers need to verify that their BLE applications can reliably discover and interact with nearby devices. The AT+GAPSCAN command allows developers to initiate comprehensive scans of the BLE environment, quickly identifying all nearby devices along with their signal strengths (RSSI). This functionality is essential for:

Range Testing: Evaluating the effective communication range of the application, which is crucial for applications requiring long-distance connectivity, such as smart home systems or industrial IoT.

Compatibility Testing: Ensuring the application can detect and communicate with a wide range of BLE devices, regardless of manufacturer or model.

Performance Testing: Assessing how well the application performs in environments with multiple BLE devices, including signal interference and response times.

The scanning features of the BleuIO USB dongle are indispensable tools for BLE developers, especially during the testing and prototyping phases. Commands like AT+GAPSCAN, AT+FINDSCANDATA, and AT+SCANTARGET not only streamline the discovery and interaction with nearby devices but also enhance the efficiency and effectiveness of the development process. With these powerful scanning capabilities, developers can ensure their BLE applications are robust, reliable, and ready for real-world use.

Share this post on :

Optimize Your BLE Connectivity using BleuIO’s Connection Scan Parameters

In Bluetooth Low Energy (BLE) technology, efficient device connectivity is crucial. Whether you’re developing a smart home solution, a wearable health monitor, or an industrial IoT application, managing how your device searches for and connects to others can significantly impact its performance. This is where the BleuIO USB dongle comes in, offering an array of intuitive AT commands to streamline BLE application development. One such command, AT+CONNSCANPARAM, is particularly valuable for fine-tuning connection parameters. This article explores why this feature is essential, how it can be beneficial, and practical applications in the real world.

Why Connection Parameters Matter

Connection parameters in BLE devices dictate how often and how long a device scans for other devices. Proper configuration of these parameters is vital for several reasons:

  1. Power Efficiency: BLE devices are often battery-powered. Efficient scanning helps conserve battery life, extending the operational period of the device.
  2. Performance: The frequency and duration of scans can affect how quickly and reliably devices discover each other and establish connections.
  3. Scalability: In environments with multiple BLE devices, optimized scanning reduces interference and improves overall communication quality.

How BleuIO Can Be Helpful

The BleuIO USB dongle simplifies BLE development with its user-friendly AT commands. The AT+CONNSCANPARAM command is particularly powerful, allowing developers to set and query the scan interval and scan window parameters, thus optimizing the device’s connectivity according to specific application needs. This flexibility is invaluable for creating efficient, responsive, and reliable BLE applications.

Introducing the AT+CONNSCANPARAM Command

The AT+CONNSCANPARAM command is designed to set or query the connection scan window and interval. These parameters are crucial for managing how the BLE device initiates scans and how long it scans for during each interval.

  • Scan Interval: The time between consecutive scans.
  • Scan Window: The duration of each scan within the interval.

The command ensures the scan window is always equal to or smaller than the scan interval. Values can be set in steps of 0.625 milliseconds (ms), with the interval ranging from 2.5 ms to 10,240 ms.

Practical Applications in Real Life

Let’s explore how AT+CONNSCANPARAM can be applied in various real-world scenarios:

  1. Wearable Health Monitors: In wearable devices like fitness trackers or heart rate monitors, battery life is a critical factor. By adjusting the scan interval and window, developers can optimize these devices to scan less frequently but for longer periods, conserving battery while maintaining reliable data transmission. AT+CONNSCANPARAM=800=400 This command sets the scan interval to 500 ms and the scan window to 250 ms, balancing power efficiency with performance.
  2. Smart Home Devices: Devices such as smart locks or light bulbs need to be responsive to user commands. A shorter scan interval and longer scan window can enhance responsiveness. AT+CONNSCANPARAM=200=150 Here, the scan interval is 125 ms, and the scan window is 93.75 ms, ensuring quick response times while maintaining reasonable power consumption.
  3. Industrial IoT: In environments with numerous BLE devices, such as a factory floor, optimizing scan parameters can reduce interference and improve connectivity stability. AT+CONNSCANPARAM=400=200 This sets the scan interval to 250 ms and the scan window to 125 ms, ensuring efficient and stable communication amidst many devices.

Setting and Querying Connection Scan Parameters

To set the connection scan parameters, use the command in the following format:

AT+CONNSCANPARAM=scan_intv_ms=scan_win_ms

For example:

AT+CONNSCANPARAM=200=100
OK

This sets the scan interval to 125 ms (200 * 0.625 ms) and the scan window to 62.5 ms (100 * 0.625 ms). The device responds with OK indicating success.

To query the current parameters, simply use:

AT+CONNSCANPARAM

The device will return:

Connection Scan Interval = 320
Connection Scan Window = 160

This means the scan interval is 200 ms (320 * 0.625 ms) and the scan window is 100 ms (160 * 0.625 ms).

The AT+CONNSCANPARAM command on the BleuIO USB dongle provides developers with a powerful tool to optimize BLE connectivity for various applications. By understanding and leveraging this command, you can enhance the power efficiency, performance, and scalability of your BLE devices, making them more reliable and effective in real-world scenarios.

Unlock the full potential of your BLE projects with BleuIO. Get your dongle today and start creating smarter, more efficient BLE applications.

Share this post on :

Introducing BleuIO Firmware v2.7.4: Enhanced Scanning Capabilities

We are thrilled to announce the release of the latest firmware update for our popular Bluetooth Low Energy USB dongle, BleuIO. With version 2.7.4, we continue our commitment to providing the most versatile and user-friendly BLE solutions for developers. This update brings a host of new features designed to simplify and enhance your BLE application development process.

What’s New in Firmware v2.7.4?

Enhanced Scanning Functionality

In our ongoing effort to provide comprehensive BLE solutions, we’ve added several new commands that significantly improve the scanning capabilities of the BleuIO dongle. These updates allow developers to have more control over their BLE environment and extract more detailed information from nearby devices.

1. Device Name and Manufacturer Specific ID in Scan Results

The new firmware includes commands that enable the display of device names and manufacturer-specific IDs (Company IDs) in the advertising data or scan response. This feature is applicable to all modes of scans, including AT+GAPSCAN, AT+FINDSCANDATA, and AT+SCANTARGET. With these enhancements, identifying and differentiating between devices becomes more straightforward and efficient.

ATASSN: Toggle showing device names on or off in scans using AT+FINDSCANDATA and AT+SCANTARGET.

ATASSM: Toggle showing manufacturer-specific IDs on or off in scans using AT+GAPSCAN, AT+FINDSCANDATA, and AT+SCANTARGET.

2. Customizable Scan Interval and Scan Window

To provide more flexibility during connections, we’ve introduced a command to set the scan interval and scan window parameters. This feature ensures that you can fine-tune your scanning behavior to match the specific needs of your application, optimizing both power consumption and performance.

AT+CONNSCANPARAM: Set the scan interval and scan window used in connections.

3. Comprehensive Scan Parameter Configuration

We’ve also added a command to configure various scan parameters, allowing you to tailor the scanning process to your precise requirements. This includes settings for scan mode, scan type, scan interval, scan window, and filter duplicates, applicable across all scanning commands.

AT+SCANPARAM: Set scan parameters for AT+GAPSCAN, AT+FINDSCANDATA, and AT+SCANTARGET.

Benefits of the New Features

These enhancements are designed to offer several key benefits:

Improved Device Identification: Easily identify devices by their names and manufacturer IDs, making it simpler to manage and interact with multiple BLE devices.

Customizable Performance: Adjust scan intervals and windows to optimize for either speed or power efficiency based on your application’s needs.

Greater Control: Fine-tune scanning parameters to ensure you capture the most relevant data, minimizing noise and maximizing the efficiency of your BLE operations.

How to Update

Updating your BleuIO dongle to firmware version 2.7.4 is straightforward. Simply follow the instructions provided in our firmware update guide.

Get Started with the New Commands

To help you get started with the new features, we’ve updated our AT command reference guide with detailed explanations and examples for each of the new commands.

Share this post on :

Integrating BleuIO with Adafruit Feather RP2040 for Seamless BLE Applications (noise sensor) : Part 4

Introduction

This example is going to showcase how to connect a PDM MEMS Microphone to a Adafruit Feather RP2040, together with a BlueIO to create a background noise sensor that measures and advertisises the current sound level in decibel (dB).
This example is very similar to Integrating BleuIO with Adafruit Feather RP2040 for Seamless BLE Applications Part 2 but instead of reading sensor data over SPI every few seconds, we’re using the arduino PDM interface to continuously fill a buffer with data then everytime the buffer is full we’re going to translate the data into the current sound level in dB.
The buffer size of 8000 bytes (2 bytes per sample) and the sample rate of 16kHz means we record 250ms each time we fill the buffer.

Requirements

Connecting PDM Microphone.

  • Connect four wires from the PDM Microphone (3V, GND, DAT, CLK) to the following pins on the Feather Board:
  • 3V to 3.3V to power the device, then GND to GND.

  • And CLK to SCL, and DAT to SDA.

Running the example

  • Make sure the BleuIO Dongle is connected to the Feather RP2040 Board.
  • Connect the Feather RP2040 Board to your computer using the USB cable.
  • Make sure the Feather RP2040 Board is selected as well as the correct COM port in the drop-down menu.
  • (Optional) Change the frequency the advertising message is updated with the dB value, in the code
    // How often we update the advertising message (in seconds) #define READ_UPDATE_FREQUENCY 1
  • Click the Upload button.
  • Done! The dongle should now be advertising the sensor values. (If you just plugged in the Feather it may take about 10 seconds before advertising starts as the BleuIO bootloader opens and closes)
  • (Optional) Open Serial Monitor. You can open the Serial Monitor from the menu: Tools>Serial Monitor
    You should now see the output from the project.

Scanning the results

To see the results you can use any BLE scanner app.
Here we use nRF Connect:


The data in the red box is our sensor values:
0x0032

When we parse the hex into decimal values we get:
0x0032 = 50 dB

Share this post on :

BleuIO Firmware Update v2.7.3: Enhancing Connectivity and Usability

The latest firmware update for BleuIO, version 2.7.3, brings a suite of new functionalities and commands designed to enhance the performance and user experience of this Bluetooth Low Energy (BLE) USB dongle. With continuous firmware updates, BleuIO ensures that users can develop BLE applications quickly and efficiently. Here’s a detailed look at what the new update offers:

New Functionalities in v2.7.3

  1. Bonded Device Connectivity Improvement:
    • A new command has been introduced to scan for and connect to bonded devices, even if these devices are using a Private Random Resolvable Address. This improvement ensures that devices can maintain secure connections and improve overall reliability in various use cases.
  2. Toggle Resolved Addresses in Scan Results:
    • Users now have the option to toggle on or off the display of resolved addresses in scan results. This feature can be activated when using the AT+GAPSCAN command, providing greater control over the information displayed during device scans.
  3. Index-based Connection Command:
    • The AT+GAPCONNECT command has been enhanced to allow the use of an index from scan results obtained via the AT+GAPSCAN command. This simplifies the connection process by removing the need to input the full MAC address.
  4. Verbose Mode Index Display:
    • A new command allows users to toggle on or off the display of indexes from AT+GAPSCAN scan results in verbose mode. This feature is particularly useful for developers who need detailed scan information for debugging and development purposes.

New Commands Added

  1. AT+CONNECTBOND:
    • This command facilitates connection with already bonded devices, even if these devices are advertising using a Private Random Resolvable Address. It streamlines the reconnection process and enhances device management.
  2. ATSRA:
    • This command enables the display of resolved addresses in the scan results. It is a useful tool for users who need to view detailed addressing information during device scans.
  3. ATSIV:
    • This command allows users to show indexes in the verbose mode scan results. It provides an additional layer of information that can be crucial for in-depth analysis and debugging.

The v2.7.3 firmware update for BleuIO brings significant enhancements that improve both connectivity and usability. By adding new commands and functionalities, BleuIO continues to support developers in creating robust and efficient BLE applications. Whether you’re working on a new project or maintaining an existing application, these updates offer valuable tools and improvements to streamline your development process.

The new firmware can be downloaded from our getting started guide.

Share this post on :