BlueIO, a prominent player in the Bluetooth industry, has recently unveiled its firmware version v2.3.1. This update comes packed with exciting additions and crucial bug fixes, promising a more seamless and efficient Bluetooth experience.
Enhanced Features:
AT+SCANFILTER Upgrade: One of the standout features of the v2.3.1 firmware update is the enhancement made to the AT+SCANFILTER functionality. Previously, this feature only filtered based on UUID, but now, it has been extended to include “Service Data – 128-bit UUID” and “Service Data – 16-bit UUID” packets. This means that when filtering devices, you can now fine-tune your criteria even further, ensuring that only the most relevant devices are detected. This added flexibility is a significant boon for developers and users alike, enabling a more tailored Bluetooth experience.
Critical Bug Fixes:
SPS Message Recognition: Before the v2.3.1 update, some users may have encountered a frustrating issue where the dongle failed to recognize SPS (Serial Port Service) messages correctly. This problem stemmed from the system incorrectly handling messages due to a different handle, resulting in an improper display format that did not align with previous firmware versions. However, with the diligent efforts of the BlueIO team, this bug has been decisively squashed. Now, SPS messages are correctly recognized and displayed in a consistent manner, eliminating the confusion and inconvenience experienced by users.
AT+GETCONN Bonded Device Display: Another critical bug addressed in this firmware update relates to the AT+GETCONN command. Previously, when users attempted to reconnect with previously bonded or paired devices, these devices would not show up as bonded or paired during the reconnection process. This inconsistency could lead to unnecessary complications and frustration for users. Thankfully, BlueIO has rectified this issue in v2.3.1. Now, when you reconnect with your trusted devices, they will correctly appear as bonded or paired, streamlining the reconnection process and ensuring a smoother user experience.
Be sure to update your BlueIO firmware to v2.3.1 to take full advantage of these improvements and enjoy a more hassle-free Bluetooth experience. Details of the update can be found at
Bluetooth Low Energy (BLE) technology has revolutionized the way we interact with devices wirelessly, enabling a wide range of applications such as fitness trackers, smartwatches, and IoT devices. To demonstrate the seamless process of connecting to a BLE device and reading its characteristics, this tutorial will guide you through the steps of using the BleuIO JavaScript library. BleuIO simplifies the process of communicating with BLE devices and extracting valuable information from them.
Prerequisites
Before diving into the tutorial, make sure you have the following prerequisites:
Create a new directory for your project and navigate to it using the terminal.
Install BleuIO javascript library using npm i bleuio
Create an index.html page that contains buttons to connect to the dongle, connecting and reading characteristics value. We will also have a js script linked at the bottom of the page. Here is the full page content
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<title>Connect and Service data from BLE devices</title>
<link
href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.1/dist/css/bootstrap.min.css"
rel="stylesheet"
integrity="sha384-4bw+/aepP/YC94hEpVNVgiZdgIC5+VKNBQNGCHeKRQN+PtmoHDEXuppvnDJzQIu9"
crossorigin="anonymous"
/>
<style>
#terminal {
background-color: black;
color: white;
font-size: medium;
font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
padding: 20px;
margin: 20px 0;
}
</style>
</head>
<body>
<div class="container my-3">
<img src="https://www.bleuio.com/images/logo.png" alt="" />
<h1 class="my-4">Example script to connect and read Characteristics</h1>
<button class="btn btn-warning" id="connect">Connect</button>
<button class="btn btn-primary" id="info">Connection Information</button>
<button class="btn btn-success" id="ReadService">
Connect & Read Service Data
</button>
<h3><div id="readResponse"></div></h3>
<div id="terminal"></div>
</div>
<script type="module" src="./script.js"></script>
</body>
</html>
Create a js page that contains the logic for connecting to dongle and then connect to Air quality monitoring BLE device HibouAir. After connecting to the device we try to read device manufacturing company name by reading characteristics. following is the script file.
As you can notice on the script we have a variable called device to connect. This is the mac address of the HibouAir BLE device that we are trying to connect. You can replace this mac address to your own device. After the connection we print out the response in a terminal. on the terminal we can see available service and characteristics. In this script we are trying to read device manufacturer name which is stored at 0011 handle. Therefore we pass the value as at_gattcread function. You can read more about the AT commands at BleuIO getting started guide.
To run this script, we need a web bundler like parcel js.
Run the script with
npx parcel index.html
Example output
In this tutorial, we’ve successfully demonstrated how to connect to a BLE device using the BleuIO dongle and JavaScript. By leveraging the BleuIO’s Javascript library, we streamlined the process of establishing a connection, reading device characteristics, and displaying the information on a web page. BLE technology has vast potential for various applications, and BleuIO makes it easier than ever to interact with BLE devices programmatically. With this tutorial as a foundation, you can explore further and develop your own BLE-powered projects with confidence.
BleuIO, a leading provider of Bluetooth Low Energy (BLE) solutions, has recently released an exciting new Python library update that supports its latest firmware version 2.3.0. This Python library is a powerful tool that allows developers to manage BLE custom services effortlessly. In this article, we will explore the key features of BleuIO’s Python library, its benefits, and how it simplifies the process of creating custom BLE services.
BleuIO’s Python Library Update
BleuIO’s Python library is a comprehensive set of tools and functions that interface with the BleuIO Bluetooth Low Energy USB dongle. The latest update, which supports firmware version 2.3.0, introduces enhanced capabilities for managing custom BLE services, making it easier for developers to create and deploy custom services for their applications.
The Python library comes with a range of convenient AT commands that can be used to control various aspects of the BleuIO dongle, including scanning, advertising, connecting, and, most importantly, setting up custom services. With just a few lines of Python code, developers can now configure their own custom BLE services, tailoring them to meet the specific requirements of their projects.
Benefits of the Python Library for Custom Services
The new Python library from BleuIO offers several benefits that simplify the process of working with custom BLE services:
Ease of Use: The library abstracts the complexities of interacting with the BLE dongle through simple and easy-to-understand Python functions. This allows even those new to BLE development to get started quickly.
Time Efficiency: By providing high-level functions for custom service setup, the library saves developers valuable time. No need to write low-level code for every aspect of the BLE service creation; instead, developers can focus on implementing the unique features of their applications.
Flexible Customization: With the library, developers have complete control over the configuration of custom services. They can define custom UUIDs, set permissions, properties, and values for each characteristic, tailoring the service to their specific use case.
Real-time Updates: The example script demonstrates how to continuously update the values of characteristics and notify/indicate subscribers. This feature is invaluable for applications that require real-time data exchange.
Creating a Custom Service with BleuIO’s Python Library
Let’s take a look at a sample Python script that showcases how to create a custom BLE service using BleuIO’s Python library:
# (C) 2023 Smart Sensor Devices AB
import time
from datetime import datetime
from bleuio_lib.bleuio_funcs import BleuIO
# This example will show how to setup your own service
# Press Ctrl-C to exit the script.
# Scan result Callback function
def my_scan_callback(scan_input):
print("\n\nmy_scan_callback: " + str(scan_input))
# Event Callback function
def my_evt_callback(scan_input):
print("\n\nmy_evt_callback: " + str(scan_input))
# Start BleuIO
my_dongle = BleuIO()
# Register callback functions for scan results and events
my_dongle.register_evt_cb(my_evt_callback)
my_dongle.register_scan_cb(my_scan_callback)
# Run ATI Command
resp = my_dongle.ati()
print(resp.Cmd)
print(resp.Ack["errMsg"])
print(resp.Rsp)
print("My Role: " + my_dongle.status.role)
print("Is Adv: " + str(my_dongle.status.isAdvertising))
print("Is Connected: " + str(my_dongle.status.isConnected))
# Set role to dual if it isn't set already
if not my_dongle.status.role == my_dongle.gaproles.DUAL:
resp = my_dongle.at_dual()
print(resp.Cmd)
print(resp.Ack)
# Disconnect if we're connected
if my_dongle.status.isConnected:
resp = my_dongle.at_gapdisconnectall()
print(resp.Cmd)
print(resp.Ack)
# Stop Advertising if we're advertising
if my_dongle.status.isAdvertising:
resp = my_dongle.at_advstop()
print(resp.Cmd)
print(resp.Ack)
# Stop custom service just in case it had been started previously
resp = my_dongle.at_customservice_stop()
print(resp.Cmd)
print(resp.Ack)
# Service
# Set service UUID
resp = my_dongle.at_customservice(
0, my_dongle.UUID, "ee6ec068-7447-4045-9fd0-593f3ba3c2ee"
)
print(resp.Cmd)
print(resp.Ack)
# Characteristic 1
# Set characteristic 1 UUID
resp = my_dongle.at_customservice(
2, my_dongle.UUID, "018f55d9-d747-4c4e-a87b-e9b074ffd2b6"
)
print(resp.Cmd)
print(resp.Ack)
# Set characteristic 1 value length
resp = my_dongle.at_customservice(1, my_dongle.CHAR_LENGTH, "100")
print(resp.Cmd)
print(resp.Ack)
# Set characteristic 1 value
# Here we set it to the current time in hours, minutes and seconds format.
cbTime = datetime.now()
char1_data = cbTime.strftime("%H:%M:%S")
resp = my_dongle.at_customservice(1, my_dongle.CHAR_VALUE, char1_data)
print(resp.Cmd)
print(resp.Ack)
# Set characteristic 1 permissions
resp = my_dongle.at_customservice(1, my_dongle.CHAR_PERMISSION, "R")
print(resp.Cmd)
print(resp.Ack)
# Set characteristic 1 properties
# We set it to Read and Notify
resp = my_dongle.at_customservice(1, my_dongle.CHAR_PROPERTY, "NR")
print(resp.Cmd)
print(resp.Ack)
# Characteristic 2
# Set characteristic 2 UUID
resp = my_dongle.at_customservice(
2, my_dongle.UUID, "a693ba2c-f0df-40cb-aea7-8ae47281d997"
)
print(resp.Cmd)
print(resp.Ack)
# Set characteristic 2 value length
resp = my_dongle.at_customservice(2, my_dongle.CHAR_LENGTH, "100")
print(resp.Cmd)
print(resp.Ack)
# Set characteristic 2 value
# Here we set it to the current time in month, days and years format.
cbTime = datetime.now()
char2_data = cbTime.strftime("%m/%d/%Y")
resp = my_dongle.at_customservice(2, my_dongle.CHAR_VALUE, char2_data)
print(resp.Cmd)
print(resp.Ack)
# Set characteristic 2 permissions
resp = my_dongle.at_customservice(2, my_dongle.CHAR_PERMISSION, "R")
print(resp.Cmd)
print(resp.Ack)
# Set characteristic 2 properties
# We set it to Read and Indicate
resp = my_dongle.at_customservice(2, my_dongle.CHAR_PROPERTY, "IR")
print(resp.Cmd)
print(resp.Ack)
# Here we check that the service data we set has gone in
resp = my_dongle.at_customservice()
print(resp.Cmd)
print(resp.Ack)
print(resp.Rsp)
print(resp.End)
# Here we start the custom service so next time we advertise and someone connects they will see the new service
resp = my_dongle.at_customservice_start()
print(resp.Ack)
# Here we start advertising so other devices can detect us and connect
resp = my_dongle.at_advstart()
print(resp.Ack)
# Going in a never ending loop that will just update the values of Characteristic 1 and 2 every second.
# If anyone is subscribed we will notify/indicate them.
while True:
cbTime = datetime.now()
notiCharTime = cbTime.strftime("%H:%M:%S")
resp = my_dongle.at_customservice(1, my_dongle.CHAR_VALUE, notiCharTime)
print(resp.Cmd)
print(resp.Ack)
indiCharTime = cbTime.strftime("%m/%d/%Y")
resp = my_dongle.at_customservice(2, my_dongle.CHAR_VALUE, indiCharTime)
print(resp.Cmd)
print(resp.Ack)
time.sleep(1)
The example script demonstrates the process of setting up a custom service with two characteristics. Characteristic 1 holds the current time in hours, minutes, and seconds format, while Characteristic 2 contains the date in month, day, and year format. The script registers callbacks for scan results and events, sets up the service UUID, characteristic UUIDs, permissions, properties, and starts advertising the custom service.
With BleuIO’s Python library and the user-friendly AT commands, BLE application development becomes accessible to a wider audience, fostering a new era of creative and groundbreaking IoT solutions. Developers can explore the BleuIO Python library further by visiting the official PyPI page (https://pypi.org/project/bleuio/) and start harnessing the power of BLE for their projects.
BlueIO, a leading provider of Bluetooth Low Energy (BLE) solutions, has recently announced the release of its latest firmware version, v2.3.0. This firmware update brings a host of new features and improvements, enabling developers to create better and more customizable applications. With a focus on flexibility and enhanced functionality, BlueIO’s new firmware empowers developers to tailor their applications to meet specific requirements while offering seamless integration with other devices.
One of the key highlights of the BlueIO v2.3.0 firmware is the ability to create a custom service. This feature provides developers with unprecedented control over their applications, allowing them to define characteristics that handle data in a way that aligns with their unique needs. The custom service can be identified by other devices using a custom UUID, ensuring seamless communication and interoperability.
Custom Service Features:
BlueIO’s custom service offers several powerful features that enable developers to build highly specialized applications:
Custom UUID for the Service: Developers can set a custom UUID for the custom service, ensuring its unique identification and compatibility with other devices.
Multiple Characteristics: Up to five characteristics can be added to the custom service, offering increased versatility and flexibility.
Custom UUID for Each Characteristic: Developers can assign custom UUIDs to individual characteristics within the service, enabling precise identification and interaction.
Read/Write Properties: Each characteristic can be configured with read/write properties, allowing bidirectional data transfer between devices.
Write Without Response: Developers can choose to configure specific characteristics with the write without response property, optimizing data transfer efficiency.
Notify or Indicate: Characteristics can be configured to notify or indicate changes, enabling real-time updates to connected devices.
Descriptor Support: Developers can add descriptors to each characteristic, providing additional information and fine-grained control.
Value Manipulation: The firmware update allows developers to change and update the values of characteristics and descriptors, supporting both ASCII and byte data formats.
Peer Notifications: When updating the characteristic value, BlueIO can automatically notify all connected devices that have subscribed to any characteristic with either Notify or Indication properties.
New Commands:
The BlueIO v2.3.0 firmware introduces a set of new commands that facilitate easy setup and control of the custom service:
AT+CUSTOMSERVICE: This command allows developers to configure and query the settings for the custom service.
AT+CUSTOMSERVICESTART: Enables the start of the custom service, initiating its functionality.
AT+CUSTOMSERVICESTOP: Stops the custom service while retaining the user-defined settings.
AT+CUSTOMSERVICERESET: Disables the custom service and clears all user settings associated with it.
The release of BlueIO’s v2.3.0 firmware marks a significant milestone in meeting the demands of developers seeking advanced BLE solutions. The BlueIO team remains committed to enhancing their offerings and will continue to provide updates and new features to support developers in their application development journey.
In the realm of Bluetooth Low Energy (BLE) development, having a reliable tool for testing, debugging, and creating BLE applications is crucial. BLE simulators serve as virtual environments that mimic real-world BLE devices, enabling developers to streamline the development process. BleuIO, a Bluetooth Low Energy USB dongle, offers a versatile and user-friendly solution for harnessing the power of BLE simulation. In this article, we will explore the significance of BLE simulators, discuss why they are needed, and delve into the various ways BleuIO can assist developers in building robust BLE applications.
Why Do We Need a BLE Simulator? Testing and debugging BLE applications can be a complex and time-consuming process. Deploying real BLE devices for every development iteration is not only impractical but also resource-intensive. BLE simulators provide an efficient way to replicate various scenarios, allowing developers to validate their applications without relying on physical hardware. By emulating multiple BLE devices and their interactions, developers can thoroughly assess the reliability, compatibility, and functionality of their applications in a controlled environment. This not only reduces costs but also accelerates the development cycle.
How BleuIO Can Be Helpful BleuIO offers a range of features and functionalities that make it an invaluable tool for BLE application development:
BLE Simulation Capabilities: BleuIO acts as a powerful BLE simulator, allowing developers to create and control multiple virtual BLE devices within a single environment. This flexibility enables comprehensive testing of various use cases, such as connecting to multiple peripherals, exploring different communication scenarios, and validating application behavior under different signal strengths and environmental conditions.
User-Friendly : BleuIO helps to simplify the process of setting up and managing simulated BLE devices. Developers can easily configure device attributes, services, characteristics, and descriptors, all through AT commands. These commands provide developers with a means to interact with the device programmatically. This ease of use significantly reduces the learning curve and enhances productivity.
Real-Time Data Monitoring: With BleuIO, developers can monitor real-time data exchanged between virtual BLE devices and their applications. This feature is particularly useful for debugging purposes, as it allows developers to inspect data packets, analyze communication output, and identify potential issues or inconsistencies. By closely monitoring data flow, developers can refine their applications for optimal performance.
Cross-Platform Compatibility: BleuIO supports various operating systems, making it compatible with a wide range of development environments. Whether you are working on Windows, macOS, or Linux, BleuIO seamlessly integrates into your preferred development workflow, ensuring versatility and accessibility.
Basic Functions of BleuIO
BleuIO offers several fundamental functions that aid in BLE application development:
Device Configuration: Developers can easily configure the properties and behavior of virtual BLE devices using BleuIO. This includes setting device names, MAC addresses, advertising intervals, supported services, and characteristics. This flexibility enables developers to simulate diverse scenarios and test application behavior under different configurations.
Advertising and Scanning BleuIO enables the simulation of advertising and scanning functionalities, allowing developers to emulate device discovery and connection processes. This feature is crucial for testing application behavior when interacting with various devices and ensuring seamless connectivity.
GATT Server and Client: BleuIO supports both GATT server and client roles, enabling developers to simulate and test both peripheral and central devices. This versatility allows for comprehensive testing of the application’s functionality in different roles and scenarios.
BleuIO can be served as a powerful BLE simulator that streamlines the testing, debugging, and creation of Bluetooth Low Energy applications. By providing an intuitive AT commands, comprehensive simulation capabilities, real-time data monitoring, and cross-platform compatibility, BleuIO empowers developers to build robust and reliable BLE applications efficiently. With its flexibility and ease of use, BleuIO significantly reduces development time, accelerates the testing process, and enhances the overall quality of Bluetooth Low Energy applications.
The BleuIO team is excited to announce the release of their latest firmware version, v2.2.2, packed with new features and improvements for Bluetooth Low Energy (BLE) developers. This firmware update aims to provide an enhanced development experience and empower developers with more control over their BLE applications.
What’s new in this firmware :
One of the notable additions in this release is the inclusion of a new command that allows developers to set or query the maximum MTU (Maximum Transmission Unit) size used in MTU negotiation upon connecting to a device. This feature provides flexibility in adjusting the MTU size, enabling better optimization and efficiency in data transmission between devices.
Additionally, the BleuIO firmware v2.2.2 introduces a powerful filtering mechanism for scan results. A new command has been added to apply filters on the outcomes from AT+FINDSCANDATA and AT+GAPSCAN commands. This feature allows filtering based on three different parameters: Local Name, Service UUID, and Manufacturer Specific ID.
It enables the flexibility to activate one filter, two filters in combination, or all three filters simultaneously. Results will only be displayed if the selected filter value is present in the advertising or scan response data. For example, a filter can be set to exclusively show data packets from devices with the Local Name “BleuIO” (either Complete or Shortened) by executing the command AT+SCANFILTER=NAME=BleuIO.
By leveraging these filtering capabilities, developers can easily focus on specific devices or data packets that meet their criteria, streamlining the development and testing process.
To explore the full range of features and improvements introduced in BleuIO firmware v2.2.2, developers are encouraged to visit the official BleuIO documentation at https://www.bleuio.com/getting_started/docs/firmware/. The comprehensive documentation provides detailed information on firmware updates and guides on how to leverage these new features effectively.
The BleuIO team is committed to continuously enhancing the BLE development experience and providing tools needed to build robust and innovative applications. With each firmware release, BleuIO demonstrates its dedication to empowering developers and enabling seamless Bluetooth Low Energy development.
Stay tuned for future updates from the BleuIO team, as they continue to introduce new features and improvements to meet the evolving needs of the BLE developer community.
BleuIO, a leading provider of Bluetooth Low Energy (BLE) solutions, has recently released a new Node.js library for developers. This library is available on NPM, making it easy for developers to access and use it for their projects. With this library, developers can create BLE applications quickly and easily.
The BleuIO Node.js library provides a simple and straightforward way for developers to communicate with BLE devices. It supports a range of BLE protocols. This library is designed to work seamlessly with Node.js, making it easy to integrate into existing projects.
One of the primary advantages of using the BleuIO Node.js library is its ease of use. Developers do not need to have extensive knowledge of Bluetooth technology to use this library. The library provides a high-level API that simplifies the communication process, allowing developers to focus on their application’s functionality rather than the underlying BLE protocols.
Another advantage of the BleuIO Node.js library is its flexibility. The library can be used to create a range of BLE applications, from simple IoT devices to complex mobile applications. This flexibility is made possible by the library’s support for a range of BLE devices and protocols.
The BleuIO Node.js library is also highly customizable. Developers can configure the library to meet their specific requirements, such as setting up a custom scan interval or configuring the advertising payload. This flexibility allows developers to create applications that are tailored to their specific needs.
To use the BleuIO Node.js library, developers must have a BleuIO device or module. BleuIO devices are small, low-cost modules that can be integrated into a range of applications, from simple IoT devices to complex mobile applications. These devices provide a reliable and secure way to communicate with BLE devices.
Installation and how to use this library can be found on BleuIO’s getting started guide.
BleuIO Python library is updated and supports firmware version 2.2.1 .This update utilizes the new Verbose mode of the dongle and make it a lot simpler to work with Bluetooth Low Energy with Python. Now the AT commands returns an object with 4 members
Command
Acknowledge
Response
End
Each contains a JSON object, except Response. The Response contains a list of JSON objects since a command can have several responses.
This new update of the library makes it easier to get the relevant information without building your own parser. Status variables : Helpful status variables has been added which helps to keep track of the dongle status ; whether it is scanning, advertising or connected along with the dongle role. Callback function : A callback function should be registered for both scan results and events. The callback functions will run every time a new event or scan result is detected.
Using the library
List of AT commands are available at https://www.bleuio.com/getting_started/docs/commands/
and how to access these AT commands using python library can be found at https://pypi.org/project/bleuio/
Before starting to install our library, make sure you have the latest python installed on your system.
If you have never installed a library from PyPI, you must install the pip tool enabling you to download and install a PyPI package. There are several methods that are described on this page.
Now Install the library by running
pip install bleuio
pip automatically downloads and installs the most recent library on your system in the correct directory. To check that the installation went well, you can launch a Python interpreter and run the following lines:
from bleuio_lib.bleuio_funcs import BleuIO
my_dongle = BleuIO()
print(my_dongle.ati().Rsp)
Good luck on creating amazing Bluetooth Low Energy application using BleuIO and Python.
This project is about Bluetooth Low Energy based RGB LED Strip Color Control from a web browser and STM 32. The LEDs light strip can also be controlled wirelessly via a BLE scanning App using IOS or Android. With the received data, we decide which color of the RGB strip to activate.
You will need two dongles, one connected to the Nucleo board and one connected to a computer to control from web browser. The web script is also available on GitHub.
When the BleuIO Dongle is connected to the Nucleo boards USB port the STM32 will recognize it and directly start advertising. This allows the other Dongle to connect to it.
It will also accept 3 different inputs from the UART:
input
result
0
Send ATI (Request device information) command to BlueIO Dongle.
1
Manually turn the LED on
2
Manually turn the LED off
We have used a STM32 Nucleo-144 development board with STM32H743ZI MCU (STM32H743ZI micro mbed-Enabled Development Nucleo-144 series ARM® Cortex®-M7 MCU 32-Bit Embedded Evaluation Board) and the WS2812, a intelligent control LED light source, for this example.
Connect the LED to the Nucleo Board by connecting:
4-7 VDC to 5V
GND to any GND
DIN to PE9
On the Nucleo NUCLEO-H743ZI2:
Note : If you want to use another setup you will have to make sure it support USB Host and beware that the GPIO setup might be different and may need to be reconfigured in the .ioc file.
This project is based on another STM32 project (https://github.com/smart-sensor-devices-ab/stm32_bleuio_example) with the interface to the WS2812 Interface WS2812 with STM32 by Controllers Tech
The DIN pin will be connected to TIM1 which need to be enabled in to the .ioc file:
Parameter Settings:
DMA for TIM1 will also be enabled:
In main.c we will need to add a callback for TIM PWM Pulse Finished:
Either clone the project, or download it as a zip file and unzip it, into your STM32CubeIDE workspace.
4.2 Importing as an Existing Project
From STM32CubeIDE choose File>Import…
Then choose General>Existing Projects into Workspace then click ‘Next >’
Make sure you’ve choosen your workspace in ‘Select root directory:’
You should see the project “stm32_bleuio_rgb_led_example”, check it and click ‘Finish’.
5. Running the example
In STMCubeIDE click the hammer icon to build the project.
Open up the ‘STMicroelectronics STLink Viritual COM Port’ with a serial terminal emulation program like TeraTerm, Putty or CoolTerm.
Serial port Setup:
Baudrate: 115200
Data Bits: 8
Parity: None
Stop Bits: 1
Flow Control: None
Connect the BleuIO Dongle before running the example
In STMCubeIDE click the green play button to flash and run it on your board. The first time you click it the ‘Run Configuration’ window will appear. You can just leave it as is and click run.
You should be greeted by this welcome message:
Welcome to STM32 BleuIO RGB LED Example!
Press 0 to run the ATI command
Press 1 to manually turn on LED
Press 2 to manually turn off LED
The LED will turn on briefly when starting up.
Wait until the message: “[BleuIO Dongle Ready]” is shown.
The LEDs should now turn off and you can now connect with the other dongle using the script.
You can also use the uart commands (0, 1 or 2):
Press 0 to get device information.
1 to turn on LED.
2 to turn off LED.
Dongle response will be printed to UART.
Control the colors from a web browser
Connect the BleuIO dongle to the computer. Run the web script to connect to the other BleuIO dongle on the STM32. The web script is available inside the source file. Now we can control the colors wirelessly.
Create a simple Html file called index.html which will serve as the frontend of the script. This Html file contains some buttons that help connect and read advertised data from the remote dongle, which is connected to stm32.
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8" />
<meta http-equiv="X-UA-Compatible" content="IE=edge" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<link
href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/css/bootstrap.min.css"
rel="stylesheet"
integrity="sha384-1BmE4kWBq78iYhFldvKuhfTAU6auU8tT94WrHftjDbrCEXSU1oBoqyl2QvZ6jIW3"
crossorigin="anonymous"
/>
<title>
Bluetooth controlled RGB LED Strip - Control color from web browser
</title>
</head>
<body class="mt-5">
<div class="container mt-5">
<img
src="https://www.bleuio.com/blog/wp-content/themes/bleuio/images/logo.png"
/>
<h1 class="mb-5">
Bluetooth controlled RGB LED Strip - Control color from web browser
</h1>
<div class="row">
<div class="col-md-4 pt-5">
<button class="btn btn-success mb-2" id="connect">Connect</button>
<form method="post" id="sendMsgForm" name="sendMsgForm">
<div class="mb-3">
<label for="msgToSend" class="form-label"
>Select color option</label
>
<select
class="form-select"
aria-label="Default select example"
name="msgToSend"
id="msgToSend"
required
>
<option selected>Open this select menu</option>
<option value="L=0">LED Off</option>
<option value="L=1">LED On</option>
<option value="L=RED">Set LED lights red</option>
<option value="L=GREEN">Set LED lights green</option>
<option value="L=BLUE">Set LED lights blue</option>
<option value="L=RAINBOW">
Set LEDs lights to different colors
</option>
</select>
</div>
<button type="submit" class="btn btn-primary">Submit</button>
</form>
</div>
<div class="col-md-8">
<img
src="https://www.bleuio.com/blog/wp-content/uploads/2022/09/bluetooth-controlled-rgb-led-strip-collor-control.jpg"
/>
</div>
</div>
</div>
<script src="script.js"></script>
</body>
</html>
Create a js file called script.js and include it at the bottom of the Html file. This js file uses the BleuIO js library to write AT commands and communicate with the other dongle.
import * as my_dongle from 'bleuio'
const dongleToConnect='[0]40:48:FD:E5:2F:17'
document.getElementById('connect').addEventListener('click', function(){
my_dongle.at_connect()
document.getElementById("connect").disabled=true;
document.getElementById("sendMsgForm").hidden=false;
})
document.getElementById("sendMsgForm").addEventListener("submit", function(event){
event.preventDefault()
my_dongle.ati().then((data)=>{
//make central if not
if(JSON.stringify(data).includes("Peripheral")){
console.log('peripheral')
my_dongle.at_central().then((x)=>{
console.log('central now')
})
}
})
.then(()=>{
// connect to dongle
my_dongle.at_getconn().then((y)=>{
if(JSON.stringify(y).includes(dongleToConnect)){
console.log('already connected')
}else{
my_dongle.at_gapconnect(dongleToConnect).then(()=>{
console.log('connected successfully')
})
}
})
.then(()=>{
var theVal = document.getElementById('msgToSend').value;
console.log('Message Send '+theVal)
// send command to show data
my_dongle.at_spssend(theVal).then(()=>{
console.log('Message Send '+theVal)
})
})
})
});
The script has a button to connect to COM port on the computer. After connecting to the dongle , we should be able to control the colors of the LED strip.
To connect to the BleuIO dongle on the STM32, make sure the STM32 is powered up and a BleuIO dongle is connected to it.
Get the MAC address
Follow the steps to get the MAC address of the dongle that is connected to STM32
- Open this site https://bleuio.com/web_terminal.html and click connect to dongle.
- Select the appropriate port to connect.
- Once it says connected, type ATI. This will show dongle information and current status.
- If the dongle is on peripheral role, set it to central by typing AT+CENTRAL
- Now do a gap scan by typing AT+GAPSCAN
- Once you see your dongle on the list ,stop the scan by pressing control+c
- Copy the ID and paste it into the script (script.js) line #2
Run the web script
You will need a web bundler. You can use parcel.js
Once parcel js installed, go to the root directory of web script and type “parcel index.html”. This will start your development environment.
Open the script on a browser. For this example we opened http://localhost:1234
You can easily connect to the dongle and update the LED strip.
We live in a day where wireless data transfer is a rather common phenomenon. From offering location services or audio streaming to maintaining device networks and data transfers, all is made possible due to wireless communication technologies and Bluetooth is one of them. Bluetooth is a short-range wireless technology which helps exchange data between connected devices over short radiuses.
Bluetooth Low Energy is essential for IoT networks due to its ability to preserve battery power on devices. Major use cases of Bluetooth Low Energy technology include:
Use Cases
Mobile payments at retail outlets.
Wireless charging for multiple devices.
Keep track of traveller luggage at the airport by using smart tags.
Monitor air quality of the indoor environment by using BLE-powered sensors.
Remote monitoring of patient’s health conditions
Autonomous vehicles with intelligent seats and steering wheels, intelligent proximity reporting etc
Smart Home automation systems with sensors for tracking fire breakouts, water leakages, or motion in case of robbery.
Advantages of Bluetooth Low Energy technology
Sends an ID number via BLE advertising channels
The 2.4 GHz frequency controls interference in signals.
Determines the location of users within its range
Longer battery life by keeping the radio off when not required
Uninterrupted broadcast using Bluetooth beacon
The devices are able to establish connections and faster data transfer.
Small size (maximum up to 255 bytes) data transfer which is helpful for IoT-based applications
The 128-bit AES algorithm ensures the safety of data transfer.
Low power consumption compared to other wireless technologies.
Comparatively lower cost of deployment and maintenance of chipsets and modules.
The BleuIO is Bluetooth low energy USB dongle that can be used to create Bluetooth low energy application. Just use the AT Commands available on the device for faster development. The BleuIO is a fully integrated solution, providing MCU and Bluetooth® radio in one chip, based on Dialog Semiconductor latest Bluetooth chip DA14683. The FLASH based device permits field or boot upgradable, while application is stored on FLASH memory. Projects and tutorials with source code can be found at https://www.bleuio.com/blog/?bleprojects
