Category: BleuIO

BleuIO, a versatile BLE USB dongle, simplifies BLE application development with its powerful AT commands and cross-platform compatibility. This tutorial demonstrates how to use BleuIO with Python to build a real-time BLE proximity-based LED control system.

In this example, we focus on monitoring the RSSI (Received Signal Strength Indicator) of a specific BLE device and controlling the LED blinking rate of BleuIO based on proximity. The closer the device, the faster the blinking rate. The script also ensures clean termination, turning off the LED when the program exits.

This tutorial uses the BleuIO Python library to showcase a practical use case. However, the concepts can be implemented in any programming language.

Devices and Tools Needed

1. BleuIO Pro BLE USB Dongle
2. Python Installed (Python 3.6 or newer recommended)
3. BleuIO Python Library
   Install the library using
   pip install bleuio
   • BleuIO Python Library on PyPI
4. Source Code
   Get the complete source code from GitHub:
   GitHub Repository

Use Case: Real-Time LED Blinking Based on Proximity

Objective:

1. Continuously monitor the RSSI value of a specific BLE device.
2. Adjust the LED blinking rate of the BleuIO dongle based on the device’s proximity.
3. Ensure the LED turns off when the script is terminated.

Workflow:

1. Scan for BLE devices: Identify the target device using its MAC address.
2. Read RSSI values: Fetch real-time signal strength data.
3. Control LED: Adjust the blinking rate based on proximity:
   • Very Close: Fast blinking.
   • Close: Moderate blinking.
   • Far: Slow blinking.
   • Very Far: Very slow blinking.
4. Graceful Exit: Turn off the LED when the script ends.

The Python Script

Below is the complete script for this project:

import time
import json
import atexit
from bleuio_lib.bleuio_funcs import BleuIO

rssi_value = None
dongle = None  

def scan_callback(scan_input):
    global rssi_value  
    try:
        device_data = json.loads(scan_input[0])  
        if device_data.get("addr") == "[1]6B:C0:5C:BD:CF:14":
            rssi_value = device_data["rssi"]  
            print(f"\nDevice Found! Address: {device_data['addr']}, RSSI: {rssi_value}")
    except json.JSONDecodeError as e:
        print(f"Error decoding JSON: {e}")
    except Exception as e:
        print(f"Unexpected error: {e}")

def send_led_command(dongle, rssi):
    if rssi is not None:  
        if rssi > -40:
            print(f"RSSI: {rssi} | Sending LED Command: 50/50")
            dongle.at_led(toggle="T", on_period="50", off_period="50")
        elif -60 <= rssi <= -40:
            print(f"RSSI: {rssi} | Sending LED Command: 100/100")
            dongle.at_led(toggle="T", on_period="100", off_period="100")
        elif -90 <= rssi < -60:
            print(f"RSSI: {rssi} | Sending LED Command: 200/200")
            dongle.at_led(toggle="T", on_period="200", off_period="200")
        else:
            print(f"RSSI: {rssi} | Sending LED Command: 300/300")
            dongle.at_led(toggle="T", on_period="300", off_period="300")
    else:
        print("No RSSI value available for LED command.")


def cleanup():
    if dongle:
        print("\n--- Turning off LED and cleaning up ---")
        dongle.at_led(0)

# Main logic
def main():
    global rssi_value, dongle  
    dongle = BleuIO()

    atexit.register(cleanup)

    dongle.register_scan_cb(scan_callback)

    print("\n--- Starting BLE Task ---\n")

    print("Setting device role to Central...")
    central_response = dongle.at_central()

    try:
        while True:
            print("\nStarting scan for 2 seconds...")
            dongle.at_gapscan(2)  
            time.sleep(3)  

            send_led_command(dongle, rssi_value)

            print("\nScan cycle completed. Restarting...\n")
            time.sleep(1)
    except KeyboardInterrupt:
        print("\n--- Script Terminated by User ---")

# Run the main function
if __name__ == "__main__":
    main()

How It Works

1. Initialization: The script initializes the BleuIO dongle and sets it to Central role for scanning.
2. Scan Callback: The scan_callback function extracts the RSSI value of the target device in real-time.
3. LED Control: Based on the RSSI value:
   • RSSI > -40: Fast blinking (50ms on/off).
   • -60 <= RSSI <= -40: Moderate blinking (100ms on/off).
   • -90 <= RSSI < -60: Slow blinking (200ms on/off).
   • RSSI < -90: Very slow blinking (300ms on/off).
4. Graceful Termination: The script turns off the LED when terminated with Ctrl + C.

Output

This example demonstrates how easy it is to use BleuIO for BLE applications. Whether you’re building proximity-based solutions or exploring BLE capabilities, BleuIO’s AT commands and Python library make it simple to get started.

Take this script, adapt it to your needs, and unlock the potential of BLE with BleuIO!

Bluetooth Low Energy (BLE) has become a core technology in the modern world, enabling secure and efficient communication for IoT devices, wearables, healthcare gadgets, and more. One of the fascinating applications of BLE is in creating private communication systems. In this tutorial, we will explore how to create a BLE chat application using the BleuIO USB dongle, a powerful yet simple device for BLE application development.

Why This Project?

With increasing concerns about privacy, BLE chat offers a solution that keeps communication entirely local. Unlike internet-based messaging systems, BLE chat does not rely on servers or cloud storage, ensuring that no data leaves your devices. This project demonstrates a simple prototype of such a BLE-based communication system.

How It Works

The project involves two laptops, each connected to a BleuIO USB dongle. For simplicity, we designate one laptop as User 1 (Central role) and the other as User 2 (Peripheral role). Here’s a high-level breakdown of the workflow:

1. Setup:
   Each laptop runs a script to initialize its BleuIO dongle. User 1 starts in a dual role and acts as the central device. User 2 also sets its dongle in a dual role but begins advertising itself.
2. Connection:
   Once User 2 starts advertising, it displays its MAC address. User 1 uses this MAC address to connect to User 2.
3. Messaging:
   After establishing a connection, the users can send and receive messages in real time. The communication is direct and local, with no reliance on external servers.

---

Setting Up the Project

The source code for this project is available on GitHub: BLE Chat Source Code. You can explore, experiment, and build on it to fit your needs.

Steps to Set Up the Project:

1. Clone the Repository
   Open a terminal on both computers and run
   git clone https://github.com/smart-sensor-devices-ab/ble-chat.git
2. Install Dependencies
   Navigate to the project directory and install the required Node.js dependencies
   cd ble-chat
npm install
3. Run the Server
   Start the server by running
   node server.js
   Ensure the server is running on both computers. The terminal should display messages confirming the dongle is detected.

Running the Scripts

Once the servers are running on both computers, follow these steps to use the BLE chat application:

1. User 1 Setup:
   • Open the browser and navigate to http://localhost:3000.
   • Click “Chat as User 1.” This will initialize the BleuIO dongle in dual role mode.
2. User 2 Setup:
   • On the second computer, open the browser and navigate to http://localhost:3000.
   • Click “Chat as User 2.” This will initialize the BleuIO dongle in dual role mode and start advertising. You’ll also see the MAC address of the dongle displayed on the screen.
3. Connecting the Devices:
   • Copy the MAC address from User 2’s screen and enter it on User 1’s screen in the provided input field.
   • Click “Connect” on User 1. Once the connection is established, you’ll see a confirmation message.
     
4. Start Chatting:
   • Use the chat interface on both devices to send messages back and forth. Messages sent from one device will instantly appear on the other device’s screen.
     

Output

In the video below, we demonstrate how this project works with two BleuIO dongles connected to two different computers. To provide a complete view, we are sharing the screen of the second computer to showcase how the chat functions in real-time.

Use Cases for BLE Chat

The BLE chat prototype we’ve created can inspire real-world applications. Here are some potential use cases:

Secure Local Communication:
BLE chat can be used for private messaging within offices, factories, or homes without the need for internet connectivity.

Education Projects:
BLE chat can be a great project for students learning about BLE technology and its applications.

Why Choose BleuIO for Your BLE Projects?

The BleuIO USB dongle makes BLE application development accessible for everyone, from beginners to advanced developers. Its built-in AT commands allow you to quickly prototype applications without diving into complex BLE stacks or SDKs. Whether you’re working on a small hobby project or an enterprise-level IoT solution, BleuIO provides the tools you need.

Here are some standout features of BleuIO:

• Cross-Platform Compatibility: Works seamlessly on Windows, macOS, and Linux.
• Simple AT Commands: No need for extensive coding; just use the built-in commands to control the dongle.
• Lightweight and Portable: Easy to carry and set up for on-the-go development.

This BLE chat application demonstrates the power and simplicity of BLE communication using the BleuIO USB dongle. While it’s a prototype, it showcases how BLE can enable private, secure, and efficient messaging without relying on external networks.

If you’re interested in exploring this further, the source code for the project is available. You can modify and extend it to fit your specific needs. With BleuIO, the possibilities are endless.

Order Your BleuIO USB Dongle Today!
Ready to create your own BLE applications? Visit BleuIO’s to learn more and order your dongle today.

This article will discuss about accessing a Bluetooth Low Energy (BLE) device—specifically the BleuIO BLE USB dongle—from a cloud-based computer. This setup is invaluable for developers, researchers, and organizations that need to control or monitor BLE devices located in remote or hard-to-reach locations. We will explain how to set up both local and cloud servers, and how to establish a secure connection between them, allowing you to send commands and receive data from a remote BLE device with ease.

Why Do We Need Remote Access to BLE Devices?

Remote access to BLE devices opens up new possibilities in IoT, distributed applications, and various remote monitoring and management scenarios. Here are a few key use cases where this approach can be especially beneficial:

Remote Device Monitoring: In scenarios where BLE devices like sensors or trackers are deployed in different physical locations—such as environmental monitoring stations, healthcare devices in hospitals, or industrial sensors in manufacturing facilities—remote access allows centralized monitoring and control. For example, an environmental monitoring company could deploy BLE sensors in different regions and access data from all devices from a single central hub.

Distributed Development and Testing: Developers and QA engineers can use remote access for testing and debugging BLE applications from any location, without needing to be physically near the BLE devices. This is particularly useful for teams working on IoT applications who want to test BLE functionality across different device types or networks. For instance, a developer could work on BLE application features from home, while the test device is connected to a machine in the office.

Centralized Management of BLE Devices: Organizations that manage multiple BLE devices across various locations, such as in retail stores, hospitals, or warehouses, can benefit from a centralized server setup to communicate with and manage all devices remotely. A central server could send updates, retrieve data, or manage configurations for multiple BLE devices, providing an efficient and scalable solution for distributed IoT applications.

Remote Troubleshooting and Maintenance: For businesses that deploy BLE devices at customer sites or in field locations, remote access allows technical support teams to troubleshoot issues without requiring on-site visits. This can reduce downtime and improve customer satisfaction. For example, a support technician could diagnose issues with a BLE-enabled device at a remote client site, identifying and resolving problems directly from the company’s central office.

By using BleuIO with AT commands, we make BLE application development much simpler and more accessible. The BleuIO dongle is compatible with Windows, macOS, and Linux, allowing consistent development across platforms.

Project Structure and Components

In this project, we’ll use the following components to remotely access and control BLE devices:

• Device with BleuIO Connected (Local Device): This is the device with the BleuIO dongle physically attached, acting as the local interface for sending and receiving BLE commands. It will run a small server to manage communication with the BLE dongle over a serial connection.
• Remote Access Server (Cloud Server): This is the server that provides remote access to the local device. By connecting to the local server, it enables us to send commands and receive data from the BLE dongle remotely.
• LocalTunnel: We’ll use LocalTunnel to generate a secure public URL, allowing the cloud server to communicate with the local device without needing complex router configurations. This URL acts as a bridge, making the local device accessible from anywhere with internet access.
• Node.js: Both the local device and the cloud server will use Node.js to run simple server scripts that facilitate communication between the cloud server and the BLE dongle.

Step-by-Step Guide

Step 1: Setting Up the Local Server with BleuIO dongle connected to it

Local device is where the BleuIO dongle is physically connected. We’ll set up a Node.js server that communicates with the dongle through the serial port. This server will accept commands from the cloud server and send them to the BLE dongle, then return the response.

Install Node.js (if not already installed) on Local device.

Create a project folder and initialize a Node.js project:
mkdir local_serial_server
cd local_serial_server
npm init -y

Install Dependencies:

• Install serialport to handle serial communication with the BLE dongle.Install socket.io to manage WebSocket connections.

npm install serialport socket.io

Create the Local Serial Server Script:

• Create a file named local_serial_server.js. This script will:
  • Listen for WebSocket connections from the cloud server.Accept commands, pass them to the BleuIO dongle, and send back responses.

const http = require('http');
const { SerialPort } = require('serialport');
const socketIo = require('socket.io');

const server = http.createServer();
const io = socketIo(server);

// Define the serial port path and baud rate
const portPath = 'COM592'; // Replace 'COM3' with your dongle's port
const serialPort = new SerialPort({ path: portPath, baudRate: 9600 });

// Listen for incoming connections from the cloud server
io.on('connection', (socket) => {
console.log('Connected to cloud server');

// Receive command from cloud and send to serial port
socket.on('sendCommand', (command) => {
const formattedCommand = `${command}\r\n`;
console.log(`Sending command to serial port: ${formattedCommand}`);
serialPort.write(formattedCommand);
});

// Send serial responses to cloud server
serialPort.on('data', (data) => {
console.log(`Data received from serial port: ${data}`);
socket.emit('serialResponse', data.toString());
});
});

// Start the server on a specified port
const LOCAL_PORT = 4000; // Choose any port, ensure firewall allows it
server.listen(LOCAL_PORT, () => {
console.log(`Local Serial Server running on http://localhost:${LOCAL_PORT}`);
});


Find and Set the Serial Port Path:

In your local_serial_server.js, specify the correct serial port path for your BLE dongle (e.g., COM3 on Windows or /dev/ttyUSB0 on Linux).

Run the Local Serial Server:

• Start the server by running: node local_serial_server.js

At this point, the local server is ready, but it’s only accessible to itself. Next, we’ll use LocalTunnel to make it accessible to the cloud server.

Step 2: Exposing the Local Server to the Internet Using LocalTunnel

Since local device 1 and cloud device are on different networks, we’ll need to create a public URL for the local server. There are several options to make a local server accessible publicly, including tools like ngrok, Pagekite, and LocalTunnel. For this tutorial, we’ll be using LocalTunnel as it’s free and easy to set up, but feel free to explore other solutions if they better meet your needs.

1. Install LocalTunnel:
   • On local device, install LocalTunnel globally npm install -g localtunnel
2. Start LocalTunnel:
   • Open a new terminal window on local device and run lt --port 4000
   • LocalTunnel will generate a public URL (e.g., https://five-sides-live.loca.lt). This URL will allow cloud device to access the local server running on port 4000 of Local device.
3. Save the LocalTunnel URL:
   • Copy the URL provided by LocalTunnel. This URL will be used in the cloud server configuration on Cloud device.

Step 3: Setting Up the Cloud Server on Cloud device

In this setup, Cloud device will act as the cloud server that connects to local device’s LocalTunnel URL, allowing remote access to the BLE dongle. Cloud device can be any machine with Node.js installed—located anywhere, such as a remote computer in New York. You could also deploy this server on a cloud platform like Heroku, Replit, or Vercel for persistent access.

For simplicity, in this example, we’ll demonstrate how to set up the cloud server on another computer running Node.js, not connected to the same network as local device.

Create a Project Folder on cloud device and Initialize Node.js:

Open a terminal or command prompt on cloud device and create a folder for the cloud server mkdir cloud_serial_server
cd cloud_serial_server
npm init -y

Install Dependencies:

You’ll need express to serve the front-end pages and socket.io to manage WebSocket communication.

Install socket.io-client to allow the cloud server to connect to the LocalTunnel URL created on Local device
npm install express socket.io socket.io-client

Create the Cloud Server Script: In the cloud_serial_server folder, create a file named cloud_server.js. This script will Connect to the LocalTunnel URL (generated by Local device) and forward BLE commands to the local server.Serve the front-end pages (index.html and page2.html) for interacting with the BLE device remotely.

const express = require('express');
const http = require('http');
const socketIo = require('socket.io');
const ioClient = require('socket.io-client'); // Client for local serial server

const app = express();
const server = http.createServer(app);
const io = socketIo(server);

// Connect to the local serial server via WebSocket
const LOCAL_SERVER_URL = 'https://real-poets-count.loca.lt';
const localSocket = ioClient(LOCAL_SERVER_URL);

// Serve static files (frontend files for Page 1 and Page 2)
app.use(express.static('public'));

// Handle messages from Page 2 and forward to local serial server
io.on('connection', (socket) => {
  console.log('Client connected to cloud server');

  // Receive command from Page 2 and forward to local serial server
  socket.on('sendCommand', (command) => {
    console.log(`Forwarding command to local server: ${command}`);
    localSocket.emit('sendCommand', command); // Send to local serial server
  });

  socket.on('disconnect', () => {
    console.log('Client disconnected from cloud server');
  });
});

// Receive data from local serial server and forward to clients
localSocket.on('serialResponse', (data) => {
  console.log(`Received data from local serial server: ${data}`);
  io.emit('serialResponse', data); // Broadcast to connected clients
});

const PORT = process.env.PORT || 3000;
server.listen(PORT, () => {
  console.log(`Cloud server is running on http://localhost:${PORT}`);
});

Update the LocalTunnel URL in Cloud Server:

Replace the LOCAL_SERVER_URL in cloud_server.js with the LocalTunnel URL you generated on Local device (e.g., https://five-sides-live.loca.lt).

Run the Cloud Server:

Start the cloud server by running:bashCopy codenode cloud_server.js

This will start a server that listens for connections on Cloud device. You can open a web browser on Cloud device and go to http://localhost:3000 to access the front-end pages.

Access the Front-End Pages:

Open a browser and navigate to http://localhost:3000/index.html (for displaying BLE responses) and http://localhost:3000/page2.html (for sending commands).

Note: If you decide to deploy this server to a cloud platform (e.g., Heroku, Replit, or Vercel), replace localhost with the appropriate URL provided by the platform.

With this setup, Cloud device can be anywhere in the world, allowing you to control and receive data from the BLE dongle on Local device (in Stockholm) remotely.

Source code

The source code is available here at https://github.com/smart-sensor-devices-ab/remote_bleuio.git

Output

This tutorial demonstrates the potential of combining Node.js, BLE technology, and tunneling services for remote BLE access. The BleuIO dongle’s compatibility and simplicity make it an excellent choice for developers interested in building BLE applications across various operating systems.