This project shows how to turn a BleuIO USB dongle into a tiny gateway that streams live air-quality data from a HibouAir sensor straight to Adafruit IO. The script listens for Bluetooth Low Energy (BLE) advertising packets, decodes CO2, temperature, and humidity, and posts fresh readings to your Adafruit IO feeds every few seconds. The result is a clean, shareable dashboard that updates in real time—perfect for demos, labs, offices, classrooms, and proofs of concept.

What is Adafruit IO—and why pair it with BleuIO?

Adafruit IO is a cloud platform for makers and developers that lets you collect, visualize, and route device data using a simple REST API or MQTT. You don’t need any Adafruit hardware; if you can make an HTTPS request, you can send data. BleuIO fits in beautifully here: the dongle handles the BLE side—scanning and parsing sensor frames—while a short Python script formats those values and pushes them to Adafruit IO. In practice that means you can take any BLE-advertising sensor, translate its packets into numbers, and land them on an IoT-friendly dashboard without servers or containers.

Requirements

To complete this project, you will need:

• BleuIO BLE USB Dongle – acts as the BLE central device to capture advertising packets.
• HibouAir Air quality monitor – broadcasts environmental data such as CO2, temperature, and humidity.
• Python libraries – install them with: pip install pyserial requests
• Adafruit IO account – free to sign up at io.adafruit.com.
• Adafruit IO Key – available under your account’s “My Key” page for authentication.

How it works

When you start the script, it opens the BleuIO serial port and switches the dongle into central role the very first time the program runs. From then on it repeatedly performs a short BLE scan that filters for HibouAir advertising frames. The scanner always picks the latest matching packet and decodes the fields we care about: CO2 (ppm), temperature (°C), and humidity (%rH). The script then posts each value to its own Adafruit IO feed over HTTPS. Because Adafruit IO is designed for live IoT data, your dashboard widgets update as soon as new points arrive. The loop cadence is configurable (10 seconds by default), which keeps you comfortably under Adafruit IO’s free-tier request limits.

The code (key points)

The script is intentionally small and readable. It opens the serial device (for example /dev/cu.usbmodemXXXX on macOS or COM7 on Windows), sends the BleuIO commands to scan for a few seconds, and parses the returned “Device Data [ADV]” lines.

A compact decoder extracts CO2, temperature, and humidity from the HibouAir manufacturer data, including the byte order and scaling.

To make the setup painless, credentials are read from variables (AIO_USER, AIO_KEY) and feed names default to co2, temperature, and humidity. Each value is sent to the REST endpoint /api/v2/{username}/feeds/{feed_key}/data with a simple JSON body {"value": <number>}.

The script includes gentle sanity checks (for example, temperature range and humidity bounds) to ignore any malformed frames, and it prints a concise log line each time it pushes fresh data.

Here is the GitHub link with the full source so you can clone and run it as-is or adapt it to other sensors.

How to run the code

Before running, set your serial port and Adafruit IO credentials.

On macOS you can list ports with ls /dev/cu.usbmodem*;

on Windows use Device Manager to find the COM number. Update username and AIO key information, then run the script.
The program will put BleuIO into central mode on first launch and, every cycle, will scan, decode, and push CO2, temperature, and humidity to the three feeds.
If you see an HTTP 401 error, double-check the AIO key; a 404 usually means a feed name typo. If the script can’t open the serial port, confirm the path and that no other program is holding it open.

Creating Adafruit IO feeds, key, and dashboard

Log in to Adafruit IO and create three feeds named co2, temperature, and humidity. Your AIO Key is available under your account’s “My Key” page; copy it and keep it private. With feeds in place, open the Dashboards section and create a new dashboard for this project (for example, “HibouAir Live”). Add a few blocks: a gauge or line chart for CO₂ (with a range that makes sense for your space), another gauge or slide for temperature, and a slide or line chart for humidity so you can see the trend over time. Each block points to its corresponding feed. As the script posts to those feeds, the blocks will animate and refresh automatically. You can reorder blocks, tweak colors and ranges, and share a read-only link if you want others to watch along.

Output

Once everything is connected, the dashboard shows a live CO2 number in gauge an line chart, an updating temperature value, and a humidity box that advances with each new reading. The values move in near real time as the script cycles, and any spikes or changes in air quality appear immediately.

Use cases

Real-time air-quality dashboards are useful in far more places than a lab bench. Facility manager can watch CO2 levels across meeting rooms to optimize ventilation; schools and libraries can surface temperature and humidity alongside occupancy schedules; small manufacturers can keep an eye on comfort and safety in production spaces; and hobbyists can monitor their home offices or studios. Because the pipeline is “BLE sensor → BleuIO → HTTPS → Adafruit IO,” you can swap HibouAir for other BLE advertisers and reuse the same approach to visualize anything from soil moisture to ambient light.

This project highlights how quickly you can go from BLE broadcast to live cloud dashboard with BleuIO and Adafruit IO. There’s no server to maintain, no container to deploy—just a tiny USB dongle, an air quality monitoring device like HibouAir, a short Python script, and a few clicks on the Adafruit IO site. The result is a shareable, real-time view of your environment that’s easy to extend, brand, and automate.

In this project, we demonstrate how to stream Bluetooth Low Energy (BLE) sensor data directly into Microsoft Power BI using the BleuIO USB dongle. By combining a HibouAir environmental sensor with BleuIO and a simple Python script, we can capture live readings of CO2, temperature, and humidity and display them in real time on a Power BI dashboard.

The goal of this project is to make BLE data visualization simple and accessible. Instead of dealing with complex server setups or containers, BleuIO provides an easy way to turn raw BLE advertising packets into meaningful insights that anyone can understand at a glance.

Why Power BI?

Microsoft Power BI is a business analytics platform designed to turn raw data into interactive dashboards and reports. One of its most powerful features is the ability to handle real-time streaming datasets, allowing live updates from sensors or IoT devices.

For IoT developers and organizations, this is a game-changer. Imagine watching air quality readings from your office appear in real time, or combining BLE sensor data with other business metrics to get a fuller picture of your environment. By using BleuIO as a BLE-to-cloud bridge, developers can integrate IoT data into Power BI dashboards quickly, without heavy infrastructure.

Requirements

To follow this tutorial, you will need:

• A BleuIO USB dongle.
• A HibouAir air quality monitor (for CO2, temperature, and humidity).
• A free or paid Microsoft Power BI account.
• The Python libraries pyserial and requests, which can be installed with: pip install pyserial requests

Setup: Power BI Streaming Dataset

Before writing any code, we need to set up a streaming dataset in Power BI.

1. Log in to Power BI Service and go to My workspace.
2. Select New → Streaming dataset → API.
3. Define the fields you’ll collect from the sensor:
   • CO2 (Number)
   • temperature (Number)
   • humidity (Number)
   • timestamp (DateTime or Text)
4. Toggle Historic data analysis ON if you want Power BI to store rows for reporting.
5. Save the dataset and copy the Push URL that Power BI generates. This will look something like: https://api.powerbi.com/beta/.../datasets/{id}/rows?key=...

This Push URL is what the Python script will use to send live sensor data to your dashboard.

The Script

We wrote a Python script that takes care of the entire process. Once it starts, the script connects to the BleuIO dongle through the serial port and switches it into central mode (this is done only the first time it runs). From then on, it performs a BLE scan every 10 seconds, specifically looking for HibouAir sensor advertising data. When the sensor is found, the script decodes the broadcast payload into CO2, temperature, and humidity values. These values are then packaged into the required JSON format and pushed directly to Power BI, where they appear instantly on your dashboard.

Before running the script, make sure to update two important details:

• Dongle port location: On macOS it will look like /dev/cu.usbmodemXXXX, while on Windows it will appear as COMX.
• Power BI Push URL: Use the one you generated earlier during the dataset setup.

We’ve published the full script on GitHub here:
GitHub Link for Script

To run it:

python script.py

Setup Dashboard

With the script running and sending live data, the next step is to build your Power BI dashboard.

1. Go to My workspace in Power BI and click New → Dashboard.
2. Give the dashboard a descriptive name, for example HibouAir Live Data.
3. Select + Add a tile → Custom streaming data, then choose the dataset you created earlier.
4. Pick a visualization type that suits your needs:
   • A Card to display the current CO₂ value.
   • A Gauge to track temperature within a target range.
   • A Line chart to watch humidity changes over time.
5. Map the fields (CO2, temperature, humidity, timestamp) to each visual and pin them to your dashboard.

Within seconds of running the script, you’ll see live sensor readings begin to appear in your Power BI dashboard — updating automatically with every scan.

Output

Here’s what the final result looks like when the dashboard starts receiving data from the HibouAir sensor.

Use Cases

This project shows just one way to use BLE and Power BI together, but the possibilities are broad. For example, you could build air quality monitoring dashboards in offices, schools, or factories to help maintain healthier environments. In agriculture, farmers could create smart dashboards that combine soil and environmental sensors to optimize crop conditions. The same method can be applied to cold chain logistics, where monitoring temperature and humidity is essential for transporting food or medicine. Fitness and health enthusiasts could stream real-time data from BLE wearables into personal dashboards, making progress more visible and motivating. And for developers, Power BI is an excellent tool for rapid IoT prototyping, offering instant visualization of new sensor data without building a complex backend system.

With BleuIO and Microsoft Power BI, it’s easy to transform BLE sensor broadcasts into live dashboards. This integration makes it possible to visualize environmental data in real time, share insights instantly, and build prototypes faster than ever before. Whether you’re a developer, researcher, or business professional, combining BLE sensors with Power BI opens the door to smarter, data-driven decisions.

This tutorial walks you through a tiny, privacy-first web app that reads only the advertised CO2 level from a nearby HibouAir sensor using a BleuIO USB BLE dongle. There’s no pairing, cloud, or backend—just your browser, the dongle, and a page that decodes a numeric CO2 value broadcast in BLE advertisements and renders it as a color bar (default window 400–2000 ppm) with a simple “High CO2” warning when your threshold is crossed.

This project is a follow-up to the Ambient-Adaptive Noise Bar with BleuIO & HibouAir. We reused the same structure and UI, but swap the decoder to read CO2 instead of noise.

What you’ll build

A single HTML file that talks to BleuIO over the Web Serial API. The page puts BleuIO in the central role, periodically runs a targeted scan for your HibouAir Board ID, and parses the Manufacturer Specific Data (MSD) bytes in each advertisement to extract CO2 (ppm). The value drives a horizontal gradient bar; cross the threshold and a warning banner appears. Everything runs locally in the browser.

• Code: GitHub repository
• Try it now: Live demo on GitHub Pages — plug in BleuIO, and press Connect. Make sure to pass correct HibouAir Board ID

Why a CO2-only, browser-based monitor?

CO2 is a practical proxy for ventilation. Elevated levels are associated with stale air, drowsiness, and reduced productivity. Many spaces—meeting rooms, classrooms, offices, homes—benefit from quick visual feedback so people know when to air out the room. Reading only a single, device-computed number from BLE advertisements keeps the design simple, fast, and privacy-preserving.

Hardware & software

• BleuIO USB BLE dongle
• HibouAir C02 monitor

How it works (at a glance)

BLE devices periodically broadcast short advertisement packets with real-time CO2 values. We can read them without pairing.

This page filters to a specific Board ID, captures the advertisement line, extracts the longest hex payload, and then decodes CO2 from a fixed position inside the MSD. The result is mapped to a 0–100% fill of the bar (for a display window of 400–2000 ppm), and we show a banner when CO2 ≥ threshold (default 1000 ppm).

Below is the exact function used in this project:

function decodeCo2FromAdv(hex) {
  // sanitize → bytes
  hex = (hex || '').replace(/[^0-9A-F]/gi, '');
  if (hex.length % 2) hex = hex.slice(0, -1);
  const b = new Uint8Array(hex.length / 2);
  for (let i = 0; i < b.length; i++) b[i] = parseInt(hex.substr(i*2,2), 16);

  // locate MSD anchor and read CO2 at fixed offset (big-endian)
  for (let i = 0; i <= b.length - 5; i++) {
    if (b[i] === 0x5B && b[i+1] === 0x07 && b[i+2] === 0x05) {
      const idx = i + 23;                // CO2 MSB position in this layout
      if (idx + 1 < b.length) {
        return (b[idx] << 8) | b[idx+1]; // ppm
      }
    }
  }
  return null;
}

The BLE flow

When you click Connect, the page opens a serial session to BleuIO and sends:

• AT+CENTRAL once, to enter scanning mode
• AT+FINDSCANDATA=<BOARD_ID>=3 every cycle to run a 3-second targeted scan
• The reader consumes lines until BleuIO prints SCAN COMPLETE, then waits and repeats

Each time an advertisement arrives, the page extracts the hex payload, decodes CO2, updates the bar, and toggles the High CO2 banner if the threshold is exceeded.

Output

You’ll see a horizontal color bar labeled with the current CO2 ppm. The bar fills from left to right as values rise within the 400–2000 ppm window. A bold High CO2 banner appears when the reading crosses your threshold (default 1000 ppm), serving as a polite nudge to improve ventilation.

Use cases

This simple CO2 bar works well anywhere people gather and air can get stale. In meeting rooms and classrooms it provides a live cue to crack a window or switch on ventilation as occupancy rises. In open offices it nudges teams toward timely air exchanges, helping reduce stuffiness and afternoon dips in alertness. At home it’s a lightweight way to keep bedrooms and living spaces fresh during gatherings or winter months with closed windows. Shared studios and makerspaces also benefit from quick, ambient feedback without the overhead of dashboards or wall displays.

Because the app reads only a single numeric value that HibouAir already broadcasts, it avoids handling personal data and is easy to deploy in privacy-sensitive environments.

Accuracy & practical notes

This is a lightweight indicator, not a calibration tool. CO2 readings in advertisements update periodically and represent the sensor’s current value. Placement matters: keep your HibouAir within a reasonable range of BleuIO to reduce missed packets. If your environment regularly exceeds the default window, you can adjust the display range and threshold in the code.

Extend the project

You can grow this prototype in several practical directions. Start by logging readings to CSV or IndexedDB for simple trend analysis over days or weeks. If you have multiple sensors, add a multi-device view that scans several Board IDs and presents compact tiles in one page. For automation, trigger a webhook or send a serial command to control a fan or relay whenever CO2 exceeds your threshold. You can also pair it with the earlier Noise Bar and show Noise + CO2 side-by-side for a fuller picture of comfort and productivity.

This guide shows how to create a web-only Flutter application that talks to a BleuIO USB BLE dongle directly from the browser. The app is a minimal console: click Connect, send AT commands like AT+CENTRAL or AT+GAPSCAN=3, and watch responses appear in real time. Treat it as a starting point for richer BLE web apps—dashboards, scanners, or device tools—without native installs.

Requirements

• Flutter (stable) with web support enabled
• A BleuIO USB BLE dongle

What this post is about

The focus is Flutter for the web. Instead of a mobile build, you’ll run Flutter in the browser and use the Web Serial API to communicate with BleuIO. The included script acts as an example of how to open the serial port, send AT commands, and stream lines back into a Flutter UI. You can use the same pattern to build any BLE-adjacent web app: scan for devices, filter output, parse manufacturer data, or add visualizations—completely in Flutter Web.

How it works

Flutter Web can call browser APIs through dart:html and dart:js_util. The app asks Chrome/Edge to show the serial-port picker, opens the selected BleuIO port at 115200, and writes commands terminated by \r\n. A small pre-newline and micro delays are used so commands don’t concatenate (avoiding errors like AT+CENTRALA). A read loop collects bytes, splits them into lines, and renders them into a console-style panel. Everything runs locally in the browser; nothing is recorded or sent to a server.

Guide

Create a web-only Flutter app

From Terminal, create a project that targets only the web so you don’t see iOS/Android code-sign prompts:

flutter create --platforms=web bleuio-flutter
cd bleuio-flutter

You’ll run exclusively against Chrome (or Edge). No mobile setup is needed.

Select Chrome as the build target

Use Chrome so the Web Serial API is available:

flutter run -d chrome

If you use an IDE, choose Chrome (web) in the device selector. Safari is not supported for Web Serial.

Add the example script

Open lib/main.dart and replace its contents with the example from the repository. That file defines a tiny Web-Serial service (connect, writeLine, continuous read loop) and a simple UI with a status, quick command buttons, a custom command input, and a full-width terminal output.

Try live commands

Click Connect BleuIO and choose your dongle. Send ATI to verify, then AT+CENTRAL to enter central role, and AT+GAPSCAN=3 to perform a three-second scan. The responses stream into the on-page console immediately. Because it’s just AT over serial, you can experiment with any command that BleuIO supports.

Understanding the example

The script is intentionally small so you can lift it into other projects. The service wraps Web Serial and exposes a line stream you can subscribe to from widgets. The UI is a single page that prints lines to a terminal-style view and keeps the scroll pinned to the bottom.

Extending this into a BLE web app

Once you’re comfortable with the console, you can add features that turn it into a BLE tool. Start by parsing common outputs such as GAP scan lines into structured objects with fields like address, RSSI, and name. Add filters and search to highlight target devices.

Use cases

This web-only approach is ideal for demos, workshops, and quick bring-up labs where you want a zero-install experience. It’s handy for field diagnostics when you need to peek at advertisements, confirm firmware state, or prove connectivity from any machine with Chrome. It also serves as a foundation for privacy-respecting dashboards that only read broadcast data and never require native packaging.

Source code & demo

Repository:
https://github.com/smart-sensor-devices-ab/bleuio-flutter

Live demo (open in Chrome/Edge, connect your dongle, and try AT commands):
https://smart-sensor-devices-ab.github.io/bleuio-flutter/

Output, hosted and real time

The live page streams output as soon as the device is connected. You can keep the tab open as a lightweight serial console while developing other features.

Flutter Web is a great fit for BLE-adjacent tooling when you want the reach of a URL and the feel of a native UI. Start with the example console today, then grow it into the BLE web application your project needs.

In this tutorial, we demonstrate how to connect the BleuIO Bluetooth Low Energy dongle to the Waveshare RP2350A USB Mini development board to create a dual-mode USB serial bridge. This example highlights the process of communicating with BleuIO using AT commands via USB host mode. It serves as a great starting point for anyone looking to build their own BLE application using this compact and powerful board.

About the Waveshare RP2350A USB Mini

The Waveshare RP2350A USB Mini is a development board built around the Raspberry Pi RP2350 microcontroller. It features a dual-core architecture, combining ARM Cortex-M33 and RISC-V Hazard3 cores, running at up to 150 MHz. The chip includes 520KB of SRAM and 2MB of onboard flash, making it suitable for advanced embedded applications.

What sets this board apart is its USB-A connector with support for USB host mode, allowing it to communicate directly with USB peripherals like the BleuIO dongle. This makes it an ideal host controller for Bluetooth Low Energy (BLE) applications.

Project Overview

This project demonstrates a dual-mode USB serial bridge implemented on the RP2350A board. The bridge allows the board to simultaneously function as:

• A USB host using PIO-USB on GPIO 12/13, connected to a device like BleuIO.
• A USB device, appearing as a virtual COM port when connected to a PC.

Data is transparently forwarded between the host and device interfaces, allowing you to communicate with BleuIO from a terminal on your PC.

This example project is useful for anyone looking to build a standalone USB host application using BleuIO. You can use the source code as a base and expand it into a more complex BLE project by sending and receiving AT commands directly from the RP2350A board.

Use Case

Imagine a scenario where you want to build a small, embedded BLE sensor gateway. Using the RP2350A as a USB host and BleuIO as the BLE interface, you can develop a powerful BLE solution without needing a full-sized computer. This approach is ideal for prototyping custom BLE applications, sensor data acquisition, or even building a mini BLE scanner.

Hardware Requirements

• Waveshare RP2350A USB Mini
• BleuIO – Bluetooth Low Energy USB dongle
• UART adapter for debugging (connected to GP0 and GP1)

Software Requirements

• Pico SDK
• ARM GNU toolchain (arm-none-eabi-gcc)
• CMake 3.13 or newer
• VS Code with Pico support (recommended)

Host Mode (PIO-USB on GPIO 12/13)

In host mode, the RP2350 board uses PIO-USB to emulate USB host functionality on GPIO pins 12 (D+) and 13 (D-). You can connect any CDC-compatible device, such as a USB-to-serial adapter or the BleuIO dongle, to these pins.

Once connected, the application automatically detects and configures the device. All incoming and outgoing serial data is forwarded and can be monitored through the debug UART interface.

Device Mode (Native USB Port)

When the RP2350A’s native USB port is connected to your PC, it appears as a virtual serial port. This allows you to communicate with the BLE dongle (connected via host mode) using a terminal application like PuTTY or Tera Term.

This enables full-duplex communication, letting you send AT commands to BleuIO and receive responses directly from your PC.

Debug Output (UART on GP0/GP1)

To observe internal debug messages, connect a UART adapter to GPIO 0 (TX) and GPIO 1 (RX) with a baud rate of 115200. This output includes information such as device enumeration, data flow, and potential errors—essential for troubleshooting and development.

Building the Project

To build the firmware, you can either use the provided build script or follow a manual setup.

You can find the complete source code for this project on GitHub:

GitHub Repository: bleuio-rp2350

Method 1: Using the build script

cd rp2350_serial_bridge
./build.sh

Method 2: Manual build with CMake

mkdir build && cd build
cmake .. -DCMAKE_BUILD_TYPE=Release
make -j4

After building, a rp2350_serial_bridge.uf2 file will be generated.

Flashing the Firmware

1. Hold the BOOTSEL button on the RP2350 board and connect it to your PC via USB.
2. The board will mount as a USB mass storage device.
3. Copy the generated rp2350_serial_bridge.uf2 file to this drive.
4. The board will reboot and start running the dual-mode USB bridge application.

You can now insert the BleuIO dongle into the USB-A port of the RP2350A board and begin communication from your PC.

Code Structure

• main.c – Main entry point of the application.
• serial_host_bridge.c/h – Handles the USB CDC host implementation.
• tusb_config.h – TinyUSB configuration file.
• CMakeLists.txt – Build configuration for CMake.

Getting Started with Your Own BLE App

This project is just a starting point. It demonstrates how to set up USB host/device mode and communicate with a CDC-based USB dongle like BleuIO. From here, you can extend the code to parse responses, interact with BLE devices, or trigger actions based on received data.

By combining the flexible RP2350A platform with BleuIO, developers can create their own powerful standalone BLE applications for IoT, sensors, or industrial control—without relying on a full computer.

Source Code

You can find the complete source code for this project on GitHub:

GitHub Repository: bleuio-rp2350

Indoor air quality is an important factor in workplace health, home comfort, and industrial safety. Monitoring CO2, particulate matter, temperature, humidity, and other environmental metrics can help prevent health issues, optimize HVAC usage, and maintain compliance with building standards. In this tutorial, we’ll walk through building a complete air quality monitoring solution using the BleuIO USB dongle and the HibouAir BLE sensor. We’ll use Python to collect data, InfluxDB to store it, and Grafana to visualize it in real time.

This project works entirely offline, runs on both macOS and Windows, and is suitable for personal, educational, or professional use. Whether you want to monitor a home office or manage sensors in an industrial setup, this system is simple to deploy and easy to scale.

What You Need

You will need one BleuIO USB dongle and one HibouAir BLE sensor. These two devices form the core of the setup. The BleuIO dongle will connect via a serial port and act as a BLE Central, continuously scanning for BLE advertisement packets sent by the HibouAir sensor.

For software, you’ll need Python 3, InfluxDB, and Grafana, all of which are available for both macOS and Windows. You’ll also install a few Python packages (pyserial and influxdb) to allow your script to read data over the serial port and write it to the database.

About Grafana

Grafana is an open-source analytics and visualization platform designed to display time-series data. It integrates seamlessly with databases like InfluxDB, allowing users to create interactive and customizable dashboards. In this project, Grafana serves as the front end for visualizing live air quality data coming from the HibouAir sensor. Its intuitive interface and support for powerful queries make it ideal for monitoring environmental conditions over time, setting alerts, and gaining actionable insights from BLE sensor data.

macOS Installation

On macOS, it’s easiest to install tools using Homebrew. You can install everything with the following commands:

brew install influxdb@1
brew install grafana
brew install python

Start the services:

brew services start influxdb@1
brew services start grafana

Windows Installation

For Windows, download installers from official sites:

• InfluxDB 1.x
• Grafana
• Python

Make sure Python and pip are added to your system path. You can then install Python packages via:

pip install pyserial influxdb

Also, identify your BleuIO COM port by opening Device Manager and checking Ports (COM & LPT). You’ll see something like COM3, which you’ll use in the Python script.

Setting Up InfluxDB

After installing InfluxDB, you need to create a database that will store sensor readings. On macOS, open your terminal. On Windows, use Command Prompt or PowerShell.

To enter the InfluxDB CLI:

influx

Inside the CLI, run:

> CREATE DATABASE hibouair
> SHOW DATABASES
> EXIT

This creates a database called hibouair, which your Python script will use to log environmental data.

You don’t need to set up authentication for local testing. If you do secure your instance later, remember to update Grafana and the Python script with your username and password.

Configuring Grafana

Once Grafana is installed and running, open your browser and go to:

http://localhost:3000

The default username and password are:

Username: admin
Password: admin

After logging in, you’ll be asked to set a new password. Once you’re in the Grafana dashboard:

1. Go to Settings → Data Sources
2. Click Add data source
3. Choose InfluxDB
4. Set the following:
   • URL: http://localhost:8086
   • Database: hibouair
   • User and Password: leave empty unless you’ve enabled authentication
   • HTTP Method: GET or POST (default is fine)
5. Click Save & Test

You should see a success message confirming Grafana can read from InfluxDB.

Connecting BleuIO via Serial Port

Insert your BleuIO USB dongle.

• On macOS, find the port using: ls /dev/cu.usbmodem* Example: /dev/cu.usbmodem4048FDEBA6D01
• On Windows, check Device Manager → Ports (COM & LPT) and find something like COM3 or COM4.

This port will be used in your Python script to open a serial connection to the dongle.

The Python Script

The Python script initializes the BleuIO dongle in Central mode, sends a scan command (AT+FINDSCANDATA), and reads the BLE advertisement packets from the HibouAir sensor. The data, which arrives in hexadecimal format, is decoded to extract values like temperature, humidity, CO2, VOC, PM1, PM2.5, PM10, light, noise, and pressure. The script then writes this data to InfluxDB with a timestamp.

To avoid storing duplicate values, the script only logs the first valid reading per scan cycle. It waits for a configurable period (e.g., 20 seconds) before scanning again.

You can view and copy the complete Python script from the GitHub repository linked below.

GitHub: bleuio-hibouair-influx-grafana

To run the script:

python3 bleuio_to_influx.py

Make sure to replace the serial port path and board ID in the script with your actual values.

Creating a Dashboard in Grafana

With data flowing into InfluxDB, it’s time to visualize it in Grafana. Start by creating a new dashboard:

1. From the left menu, go to Dashboards → New → Add new panel
2. In the query editor, select your InfluxDB data source
3. Enter the following query to display CO2 levels: SELECT last("co2") FROM "air_quality" WHERE $timeFilter GROUP BY time($__interval)

This query fetches the latest CO2 readings from the air_quality measurement. You can change "co2" to "temp", "hum", "voc", "pm25" or any other field depending on what you want to display.

Grafana will automatically plot the data on a line chart. You can switch to a gauge, bar, or other visualizations from the panel settings. You can also set thresholds, value ranges, and colors to improve readability.

Repeat this process to add more panels for temperature, humidity, VOCs, PM2.5, PM10, and other values.

Once your dashboard is complete, click Apply, then Save the dashboard to reuse it later.

Output

How It Works

This system leverages BLE advertisement broadcasting from HibouAir and AT command-based serial communication with the BleuIO dongle. The dongle scans for a specific board ID using AT+FINDSCANDATA=<board_id>=3, and the Python script reads and decodes each advertisement received. The decoded data is immediately sent to InfluxDB using the official client library.

Grafana queries this time-series data and displays it in real time. Since all components are local, there is no dependency on external servers or cloud APIs. The system is also modular, so you can easily scale it to support multiple sensors, extend the decoder for other BLE formats, or forward data to cloud-based platforms in the future.

Use Cases

This setup is ideal for a range of applications. In an office environment, monitoring CO2 and humidity can help optimize ventilation and improve productivity. In factories or workshops, tracking particulate matter and VOCs ensures air quality compliance and safety. For researchers and students, this project provides a hands-on, local, and open-source method to study environmental changes. Even in residential settings, it can help detect poor air circulation or pollutant spikes. The simplicity of this solution makes it accessible to both developers and non-developers alike.

Extending the Project

There are several ways to expand this project:

• Add support for additional BLE data types, such as HibouAir’s type 08 advertisements for NO₂
• Set up Grafana alerts to notify you when CO2 exceeds 800 ppm or humidity drops below 30%
• Export historical data from InfluxDB to CSV for offline analysis
• Run the Python script as a background service on system boot
• Connect multiple sensors to cover multiple rooms or areas

With minimal changes, you can also run this setup on a Raspberry Pi or Linux server.

With just a BleuIO dongle, a HibouAir sensor, and a few open-source tools, you’ve built a fully functional air quality monitoring solution. The system is flexible, lightweight, and runs entirely offline. It provides real-time insights into indoor environmental conditions and can be adapted for a variety of applications.