Author: BleuIO

This article takes a deep dive into the capabilities of BleuIO, exploring how it can simplify BLE application testing, especially in complex environments like IoT, health, automotive, and smart home applications. Whether you are a seasoned developer or a newcomer, BleuIO provides a reliable, versatile tool to jumpstart your BLE projects. We’ll also cover an example project, the BLE Connectivity Test Tool, to illustrate BleuIO’s ease of use and the possibilities it opens up for developers.

Example Project: Building a BLE Connectivity Test Tool

To demonstrate the practicality and ease of using BleuIO, let’s look at a sample project: a BLE Connectivity Test Tool. This tool allows developers to test the connection stability of a BLE device, such as the HibouAir air quality monitor, by performing repeated connection and disconnection attempts. This example showcases how easy it is to set up a real-world testing scenario with BleuIO, perfect for those looking to explore connectivity applications.

This BLE Connectivity Test Tool will:

Scan for the HibouAir Device: Use BleuIO to locate the device based on its BLE address.

Initiate Connections: Repeatedly connect and disconnect from the HibouAir device, tracking the success and failure of each attempt.

Log Results: Display a summary at the end, indicating successful connections and any errors encountered.

Code Overview

The Python script below uses the official BleuIO Python library, which simplifies interaction with BLE devices. It uses AT commands to set the dongle in central mode, initiate connections, and disconnect after a set duration.

import time
from datetime import datetime
from bleuio_lib.bleuio_funcs import BleuIO

# Initialize the BleuIO dongle
dongle = BleuIO()

# Device address of HibouAir (replace with your actual address if different)
device_address = "[1]D1:79:29:DB:CB:CC"

# Number of connection attempts
test_count = 5
# Duration to stay connected in seconds
connect_duration = 2
# Delay between connection attempts
delay_between_tests = 5

# Counters for tracking connection results
successful_connections = 0
successful_disconnections = 0
connection_failures = 0

# Register scan callback to handle scanned device responses
def my_scan_callback(scan_input):
    print("\n\nScan Result: " + str(scan_input))

# Register event callback to handle connection events with timestamps
def my_evt_callback(evt_input):
    cbTime = datetime.now()
    currentTime = cbTime.strftime("%H:%M:%S")
    print("\n\n[" + str(currentTime) + "] Event: " + str(evt_input))

# Set up the callback functions
dongle.register_evt_cb(my_evt_callback)
dongle.register_scan_cb(my_scan_callback)

# Set the BLE role to central to initiate connections
dongle.at_central()

# Start the connection test
print("Starting BLE Connectivity Test with HibouAir device...\n")
for i in range(test_count):
    print(f"\nAttempt {i+1}/{test_count}")
    
    # Connect to the device
    connect_response = dongle.at_gapconnect(device_address)
    if connect_response.Ack.get("err") == 0:  # Check if the connection was successful
        print("Connection successful!")
        successful_connections += 1
        time.sleep(connect_duration)  # Stay connected for the specified duration

        # Disconnect
        disconnect_response = dongle.at_gapdisconnect()
        if disconnect_response.Ack.get("err") == 0:
            print("Disconnected successfully.")
            successful_disconnections += 1
        else:
            print("Error during disconnect:", disconnect_response.Ack.get("errMsg"))
            connection_failures += 1
    else:
        print("Connection failed:", connect_response.Ack.get("errMsg"))
        connection_failures += 1
    
    # Wait before the next attempt
    time.sleep(delay_between_tests)



# Display test results summary
print("\nConnectivity Test Summary:")
print(f"Total Connection Attempts: {test_count}")
print(f"Successful Connections: {successful_connections}")
print(f"Successful Disconnections: {successful_disconnections}")
print(f"Failures: {connection_failures}")

This tool’s simplicity shows how BleuIO can be used in the development and testing process, making it a preferred choice for developers who want to avoid BLE’s traditional complexities.

Output

Real-World Applications of BleuIO

IoT Device Testing: From smart home devices to industrial sensors, BleuIO is invaluable for testing the connectivity and data transmission of IoT devices.

Wearable Tech Development: For developers working on BLE-enabled wearables like fitness trackers or health monitors, BleuIO provides a straightforward way to test device connectivity.

Educational and Prototyping Tool: BleuIO’s ease of use makes it an excellent educational tool for introducing BLE concepts to students and rapid prototyping for startups.

Environmental Monitoring: As demonstrated with the HibouAir air quality monitor, BleuIO facilitates connectivity testing in applications involving environmental data, like CO2 monitoring, temperature, and humidity.

Why BleuIO for BLE Development?

Developing BLE applications often requires specialized hardware and software expertise. Traditional BLE development involves understanding intricate details of Bluetooth stacks, profiles, and data protocols. BleuIO alleviates this by offering a straightforward command structure that abstracts the technical details, allowing developers to quickly build and test applications.

In addition, BleuIO’s compact design makes it suitable for portable applications and rapid prototyping. From sensor connectivity to device tracking and monitoring, BleuIO proves to be a versatile asset for a range of BLE applications.

BleuIO offers an all-in-one solution for BLE development, bridging the gap between beginner-friendly usability and powerful functionality. With support for multiple platforms, easy integration with popular programming languages, and straightforward AT command access, BleuIO empowers developers to quickly and efficiently test, prototype, and deploy BLE applications.

By using tools like the BLE Connectivity Test Tool, developers can focus on creating innovative applications without needing to dive deep into the complexities of BLE. BleuIO enables developers to bring their ideas to life, from IoT to healthcare and beyond. Start your BLE development journey with BleuIO today and see the difference in ease and efficiency it brings to your projects.

Introduction
This project demonstrates how to integrate the Renesas EK-RA4M2 development board with the Renesas CO2 Sensor (RRH47000) and the new BleuIO Pro Dongle (SSD025) by Smart Sensor Devices, built on the Renesas Bluetooth Low Energy SoC DA14695. In this setup, the dongle advertises sensor data from the CO2 sensor, including CO2 concentration, humidity, and temperature.

The sensor data is displayed using the RTT Viewer.

Requirements

• EK-RA4M2
• BleuIO – Bluetooth Low Energy USB Dongle
• FSP Platform Installer (Includes e² studio IDE, toolchain, and FSP packs)
• J-Link RTT Viewer
• USB OTG Cable (USB-A, USB-B micro)
• Renesas RRH47000
• Our example project [Download from GitHub]

Setup

1. Connect a Micro USB device cable (Type-A male to Micro-B male) between J10 (Debug1) on the EK-RA4M2 and a computer’s USB port.
2. Plug in the BleuIO Dongle using a USB OTG Cable (Type-A female to Micro-B male) and connect it to J11 (USB Full Speed).
3. Ensure that Jumper J12 is placed on pins 1-2.
4. Remove Jumper J15 pins.

Setting up PMOD1
The RRH47000 sensor connects via PMOD1. Since the sensor requires 5V, and PMOD by default provides 3.3V, some modifications are necessary:

• For 5V the PMOD1 Config trace cut jumper E17 must be Short and E16 be Open.
  For I2C SCL E18 need to be Short and E14 need to be Open.
  For I2C SDA E19 need to be Short and E15 need to be Open.

• The PMOD1 config can be found on the back of the RA4M2:

Importing the Project

• Open e² studio IDE
• Choose a workspace and click ‘Launch’
• Download or clone the example project. Place the folder ‘bleuio_ra4m2_co2_monitor_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_co2_monitor_example’ project folder is located:

• Finally select the project and click ‘Finish’. You have now imported the the project!

Running the Example

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_co2_monitor_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 0x200009ac

On the debugger screen in e² studio click the ‘Resume’ icon twice to run the project.

• The application is now running. When starting up you should notice all LEDs lighting up for one second then only the red LED will be on. It will turn off as soon as the BleuIO is configured and the green LED will turn on when advertising start.
• You should now see the output on the RTTViewer. 

Scanning the Dongle
To view the advertised data, use an app like nRF Connect.

Decoding the Advertising Message
The advertising data format is as follows:

• 020106: Default advertising flag for connectable devices.
• 09FF3600026E173E1D27: Manufacturer-specific data.
  • 09: Message size.
  • FF: Manufacturer Specific Data flag.
  • 3600: Renesas Manufacturer ID (little-endian).
  • 026E: CO2 value in hex (622 in decimal).
  • 173E: Temperature value, split into two bytes (23.62°C).
  • 1D27: Humidity value, split into two bytes (29.39%).

This example serves as a foundational guide for integrating the Renesas EK-RA4M2 development board with a CO2 sensor and the BleuIO Pro Dongle for real-time monitoring. With its flexible setup, you can extend this project to suit your specific applications, such as real-time air quality monitoring, smart building systems, or other IoT-based environmental solutions. By leveraging the capabilities of the BleuIO Pro and Renesas platform, you can create robust, scalable solutions for your next Bluetooth Low Energy (BLE) project.

In today’s fast-paced world, flexibility and mobility in development are crucial. Whether you’re on the go or just want the convenience of working from your mobile device, having the ability to connect and interact with your development tools directly from your smartphone or tablet can be a game-changer. This article will guide you through a groundbreaking way to connect the BleuIO USB dongle to your mobile device using the Web Serial API. This tutorial will not only introduce you to the BleuIO dongle’s capabilities but also show you how to harness the power of BLE (Bluetooth Low Energy) on your mobile device with custom AT commands. By the end of this guide, you’ll be ready to run BLE scripts directly from your mobile browser, making BLE development more accessible and portable than ever.

Why This Matters

BleuIO is a versatile USB dongle that allows developers to easily add Bluetooth Low Energy (BLE) capabilities to their projects. Traditionally, connecting BLE devices to a mobile device required specialized apps or programming with platform-specific APIs. However, with the advent of the Web Serial API, it’s now possible to interact with BLE devices directly from a web browser, even on mobile devices. This means you can execute AT commands, scan for nearby BLE devices, and even build custom BLE applications right from your mobile browser.

This article is designed to help you leverage these capabilities, making BleuIO more accessible and useful whether you’re in the office, at home, or on the move. By following this tutorial, you’ll not only learn how to connect and communicate with BleuIO using your mobile device but also gain insight into how to integrate these features into your own BLE applications.

Getting Started: What You’ll Need

• BleuIO USB Dongle: The star of this tutorial, a compact USB device that adds BLE functionality to any device with a USB port.
• Mobile Device: A smartphone or tablet with a USB OTG (On-The-Go) adapter to connect the BleuIO dongle.
• Web Browser: A modern web browser that supports the Web Serial API. For this tutorial, we’ll focus on Google Chrome for Android.
• A Simple HTML/JavaScript Setup: We’ll walk through creating a basic web interface to send and receive AT commands from the BleuIO dongle.

Step 1: Setting Up Your Development Environment

Before diving into the code, let’s ensure your mobile device is ready. Here’s a quick checklist:

1. Connect BleuIO to Your Mobile Device: Use a USB OTG adapter to connect the BleuIO dongle to your smartphone or tablet.
2. Install a Compatible Browser: Ensure you have Google Chrome installed on your device. As of the time of writing, Chrome is one of the few mobile browsers that support the Web Serial API.

Step 2: Writing the Web Interface

Next, we’ll create a simple web interface that will allow you to connect to the BleuIO dongle, send AT commands, and display the responses. Below is the code we’ll use:

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Web Serial API with BleuIO</title>
    <link
      href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/css/bootstrap.min.css"
      rel="stylesheet"
      integrity="sha384-QWTKZyjpPEjISv5WaRU9OFeRpok6YctnYmDr5pNlyT2bRjXh0JMhjY6hW+ALEwIH"
      crossorigin="anonymous"
    />

    <script type="module">
      import { serial as webSerialPolyfill } from 'web-serial-polyfill@1.0.15';
      // Use webSerialPolyfill as you would navigator.serial.
    </script>
  </head>
  <body>
    <div class="container mt-5">
      <h1>BleuIO dongle Communication for Mobile browser</h1>
      <br /><br />
      <div class="row">
        <div class="col-md-6">
          <button id="connect" class="btn btn-success">
            Connect to BleuIO
          </button>
          <button id="disconnect" class="btn btn-danger" style="display: none">
            Disconnect
          </button>
          <br /><br /><br /><br />
          <div id="command-section" style="display: none">
            Basic command <br />
            <button id="scanBtn" class="btn btn-primary">
              Scan for nearby BLE devices (AT+GAPSCAN=3)
            </button>
            <br />
            <br />
            Write your own AT commands
            <input
              type="text"
              id="inputData"
              class="form-control"
              placeholder="Write AT commands"
            /><br />
            <button id="send" class="btn btn-warning">Send</button>
          </div>
        </div>
        <div class="col-md-6">
          <h4>Output</h4>
          <br />
          <textarea
            id="output"
            style="height: 500px; width: 100%; border: 1px solid grey"
            class="rounded p-4"
            placeholder="Output will appear here..."
            readonly
          ></textarea>
        </div>
      </div>
    </div>

    <script type="module" crossorigin>
      import { serial as webSerialPolyfill } from 'https://cdn.jsdelivr.net/npm/web-serial-polyfill@1.0.15';
      var serial_module = null;
      if ('serial' in navigator) {
        serial_module = navigator.serial;
      } else {
        if ('usb' in navigator) {
          serial_module = webSerialPolyfill;
        }
      }
      let port;
      let reader;
      const connectButton = document.getElementById('connect');
      const disconnectButton = document.getElementById('disconnect');
      const sendButton = document.getElementById('send');
      const outputArea = document.getElementById('output');
      const inputField = document.getElementById('inputData');
      const commandSection = document.getElementById('command-section');

      connectButton.addEventListener('click', async () => {
        try {
          port = await serial_module.requestPort();
          await port.open({ baudRate: 9600 });

          reader = port.readable.getReader();

          // Hide connect button, show disconnect button and command section
          connectButton.style.display = 'none';
          disconnectButton.style.display = 'block';
          commandSection.style.display = 'block';

          while (true) {
            const { value, done } = await reader.read();
            if (done) {
              reader.releaseLock();
              break;
            }
            outputArea.value += new TextDecoder().decode(value);
          }
        } catch (error) {
          console.error('Failed to connect:', error);
          alert(
            'Failed to connect to the device. Please try again.',
            JSON.stringify(error)
          );
        }
      });

      disconnectButton.addEventListener('click', async () => {
        try {
          if (reader) {
            reader.cancel();
            reader = null;
          }
          if (port) {
            await port.close();
            port = null;
          }

          // Show connect button, hide disconnect button and command section
          connectButton.style.display = 'block';
          disconnectButton.style.display = 'none';
          commandSection.style.display = 'none';
        } catch (error) {
          console.error('Failed to disconnect:', error);
          alert('Failed to disconnect from the device. Please try again.');
        }
      });

      sendButton.addEventListener('click', async () => {
        outputArea.value = '';
        const writer = port.writable.getWriter();
        const dataToSend = inputField.value + '\r\n';
        const data = new TextEncoder().encode(dataToSend);
        await writer.write(data);
        writer.releaseLock();
      });
      document.getElementById('scanBtn').addEventListener('click', async () => {
        const writer = port.writable.getWriter();
        let dataToSend = 'AT+CENTRAL' + '\r\n';
        let data = new TextEncoder().encode(dataToSend);
        await writer.write(data);
        dataToSend = 'AT+GAPSCAN=3' + '\r\n';
        data = new TextEncoder().encode(dataToSend);
        await writer.write(data);
        writer.releaseLock();
      });
    </script>
  </body>
</html>

Step 3: Running the Script

Once your HTML file is ready, you can open it in your mobile browser. We have uploaded the script on github to try out.

https://smart-sensor-devices-ab.github.io/mobile_web_ble/

Here’s what will happen:

1. Connect to BleuIO: Tap the “Connect to BleuIO” button to initiate a connection.
2. Send Commands: Once connected, you can start sending AT commands or use the built-in “Scan for BLE Devices” button to see nearby BLE devices.
3. View Output: The responses from the BleuIO dongle will appear in the output section on the right.

Step 4: Customizing and Expanding

This setup provides a solid foundation for more advanced BLE development on mobile devices. You can easily modify the script to add more AT commands or even build a full-fledged BLE application. Whether you want to control BLE devices, gather data, or create interactive applications, this setup offers flexibility and mobility.

Output:

With the BleuIO USB dongle and the Web Serial API, you can now bring BLE development to your mobile device, giving you the freedom to code, test, and interact with BLE devices wherever you are. This capability opens up new possibilities for developers who need to work on the go, providing a powerful toolset right in your pocket.

Introduction

In an age where air quality has become increasingly important, monitoring CO2 levels in various environments is crucial. This project demonstrates how to create a real-time CO2 monitoring system using the Renesas EK-RA4M2 evaluation kit and the BleuIO dongle.

This project walks you through the process of scanning Bluetooth advertising signals from a HibouAir sensor, retrieving CO2 data, and responding to these readings with visual cues through LED indicators on the Renesas board. Blue LED for ‘good’ (<600ppm), green LED for ‘average’ (<1000ppm) and red LED for ‘poor’ (>1000ppm).
The board will also print the CO2 values, as they change, on the RTTViewer.

Requirements

• EK-RA4M2
• BleuIO – Bluetooth Low Energy USB Dongle
• FSP Platform Installer (Includes e² studio IDE, toolchain, and FSP packs)
• J-Link RTT Viewer
• USB OTG Cable (USB-A, USB-B micro)
• HibouAir air quality monitor with CO2.
• Our example project [Download from GitHub]

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
• The example will make us of the on board LEDs R32 (Blue), R34 (Green) and R33 (Red):
• 

Importing project

• Open e² studio IDE
• Choose a workspace and click ‘Launch’
• Download or clone the example project. Place the folder ‘bleuio_ra4m2_co2_monitor_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_co2_monitor_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 56 to the board ID of the HibouAir Sensor:

#define BOARD_ID_TO_SCAN "2202B3"

The board ID is printed on the back of the HibouAir sensor:

• 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_co2_monitor_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.
• 

• The application is now running. When starting up you should notice all LEDs lighting up for one second then only the red LED will be on. It will turn off as soon as the BleuIO is configured.
• You should now see the output on the RTTViewer. 

Output

When the CO2 value is less than 600 ppm only the blue LED will be turned on.

If it’s over 600 ppm but below 1000 ppm then the green LED will be on.

If it’s above 1000 ppm then the red LED will be on.

Practical Use Case

The BleuIO RA4M2 CO2 Monitor is an excellent example of how BLE technology can be harnessed to create practical, real-world applications. This project is particularly relevant for environments where air quality monitoring is essential, such as:

• Offices and Workspaces: Monitor indoor air quality to ensure a healthy working environment, which can help in improving employee productivity and well-being.
• Schools and Educational Institutions: Keep track of CO2 levels in classrooms to maintain a healthy atmosphere conducive to learning.
• Public Buildings: Ensure that places with high foot traffic, like libraries or hospitals, maintain safe air quality levels for visitors.
• Smart Homes: Integrate CO2 monitoring into home automation systems, allowing for better air quality control and energy efficiency.

With the BleuIO dongle and this project as a foundation, developers can easily expand on this concept, integrating additional sensors or creating custom applications tailored to specific needs. The combination of Bluetooth Low Energy and the versatile RA4M2 platform opens up a world of possibilities for creating innovative, responsive systems.

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.