Author: BleuIO

Bluetooth Low Energy (BLE) has become a key technology in modern wireless applications—from IoT devices and sensors to wearables, smart tools, and more. While BLE development can traditionally require time, experience, and familiarity with complex protocols, BleuIO dramatically simplifies the process.

BleuIO is a powerful USB BLE dongle designed to help developers of all levels build BLE applications quickly and efficiently. With straightforward AT commands, intuitive documentation, and cross-platform flexibility, it allows users to prototype and develop BLE solutions without the usual learning curve.

But now, with the rapid growth of AI tools such as ChatGPT and Gemini, the development workflow becomes even smoother. AI can help generate ready-to-run scripts, automate coding tasks, and speed up BLE experiments—making the combination of BleuIO + AI incredibly valuable for developers.

Common Challenges in BLE Development

Developing Bluetooth Low Energy applications often requires a solid understanding of BLE protocols and command structures, which can be intimidating for beginners. Developers must also write code that interfaces correctly with hardware such as dongles or embedded devices, and this process can involve repetitive boilerplate code—especially when handling tasks like scanning, connecting, and transferring data. Another common challenge is ensuring that code works consistently across different languages and platforms. These factors can slow down development and create barriers for those who simply want to prototype or test BLE functionality quickly.

How BleuIO and AI Solve These Problems

BleuIO addresses many of these challenges by offering straightforward AT commands that simplify common BLE operations. When paired with modern AI tools, the development process becomes even more efficient. AI systems can read the BleuIO AT Command List and instantly generate complete scripts that integrate these commands correctly, significantly speeding up prototyping. This eliminates the need for manually writing repetitive code, allowing developers to focus on their application rather than the setup. Because BleuIO works seamlessly with Python, JavaScript, C#, Node.js, and many other environments, developers can choose the language they prefer. Even newcomers can get started easily, as AI-generated scripts help bridge any knowledge gaps and provide a smooth entry point into BLE development.

Example: Using ChatGPT and Gemini to Generate a BLE Scan Script

To demonstrate how effectively BleuIO and AI work together, we created a simple test scenario. We began by downloading the BleuIO AT Command List PDF from the Getting Started guide and then asked both ChatGPT and Gemini to generate a Python script that communicates with the BleuIO BLE USB dongle. The script needed to use the correct AT commands, include the appropriate COM port, and perform a scan for nearby BLE devices lasting five seconds. After generating the scripts, we ran them to compare the output produced by the two AI tools.

Video Demonstration

You can watch the full demonstration below, where we walk through the entire process—from downloading the command list to generating and testing the scripts:

This example demonstrates just how powerful the combination of BleuIO and modern AI tools can be. By letting AI generate boilerplate code and BLE scripts, you can focus on building features, testing ideas, or integrating wireless communication into your products.

BleuIO already makes BLE development easy—but with AI, it becomes even more efficient, accessible, and developer-friendly.

Outdoor air quality is a major focus in Europe in 2025, with tighter standards placing greater emphasis on fine particulate matter—especially PM2.5. Elevated PM levels are linked to asthma, reduced cognitive performance, and increased cardiovascular risk, making reliable monitoring essential. This project demonstrates a simple, browser-based way to visualize PM1.0, PM2.5, and PM10 in real time—supporting better ventilation decisions and aligning with evolving EU air-quality expectations.

What you’ll build

A single HTML file styled with Tailwind CSS that:

• Puts BleuIO in a central scanning role
• Periodically runs a targeted scan for your HibouAir Board ID
• Decodes PM1.0 / PM2.5 / PM10 from the manufacturer data inside BLE advertisements
• Maps the values to three horizontal bars (default display windows: PM1.0/PM2.5 → 0–150 µg/m³, PM10 → 0–200 µg/m³)
• Shows a high particulate banner when any value exceeds your thresholds

Source code: https://github.com/smart-sensor-devices-ab/pm-monitor-bleuio
Live demo: https://smart-sensor-devices-ab.github.io/pm-monitor-bleuio/

Hardware & software

• BleuIO USB BLE dongle
• HibouAir air quality monitor with particle sensor

How it works

HibouAir broadcast short advertisement packets that includes real-time air quality data. We can read them without pairing.

Scan cadence. The dongle sends:

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

Decoding. HibouAir advertises a compact environmental frame beginning with the marker 5B 07 05. PM values are 16-bit little-endian fields. In this build we anchor to the marker and read:

• PM1.0 (raw ÷ 10 → µg/m³)
• PM2.5 (raw ÷ 10 → µg/m³)
• PM10 (raw ÷ 10 → µg/m³)

UI behavior. Each metric drives a bar that fills left-to-right as the value rises within its display window. Thresholds are configurable (defaults: PM1.0 1, PM2.5 2, PM10 5 µg/m³). If any metric is at or above its threshold, the page shows “High particulate levels detected.”

Customize & extend

You can tailor this monitor to your space and workflow in several practical ways. If you anticipate larger spikes, widen the display windows—for example, expand PM2.5 to 0–200 µg/m³—to keep the bar responsive at higher ranges. For lightweight analytics, append readings to a CSV file or store them in IndexedDB to explore trends over hours or days. If you’re tracking multiple HibouAir units, build a wallboard that scans a list of Board IDs and renders compact tiles for each sensor in a single view. To act on thresholds, add automation hooks that trigger a webhook or drive a fan/relay from a companion script when levels rise. Finally, pair this particulate display with your existing CO₂ or Noise monitors to create a more complete picture of indoor conditions and ventilation effectiveness.

Output

In the video , the session starts at 0.0 µg/m³ across PM1.0/PM2.5/PM10. To demonstrate responsiveness, we briefly spray aerosol near the HibouAir device. Within seconds, the bars respond and the page displays “High particulate levels detected.” After stopping the aerosol and allowing air to clear, values decay back down, the bars recede, and the banner disappears. This sequence illustrates typical behavior you’ll see during quick particulate events (e.g., cleaning sprays, dust disturbances, smoke from cooking) and their recovery.

This project turns HibouAir’s BLE adverts into a clear view of PM1.0, PM2.5, and PM10 using a BleuIO dongle. In minutes, you get live bars, thresholds, and a simple alert that makes particulate spikes obvious. It’s easy to tune—adjust display windows, tweak thresholds, and adapt the layout for different rooms. As EU air-quality expectations tighten, this lightweight monitor helps you spot issues and validate ventilation quickly. From here, you can add data export, multi-device dashboards, or pair it with your CO2 monitor for a fuller picture.

Have you ever wanted to stream real-time air quality data from a Bluetooth sensor straight into the cloud — without any expensive gateway or IoT server?
In this tutorial, we’ll show you how to use the BleuIO USB dongle and a HibouAir sensor to capture CO2, temperature, and humidity readings over Bluetooth Low Energy (BLE), then automatically log them into Google Sheets for easy tracking and visualization.

By the end, you’ll have a live data logger that updates your Google Sheet every few seconds with real environmental readings — and you’ll even learn how to create charts directly inside Google Sheets.

What is Google Sheets?

Google Sheets is a free, cloud-based spreadsheet application that lets you create, edit, and share data online in real time. It’s part of Google’s Workspace tools and is accessible from any device with an internet connection. Because it stores data in the cloud, it’s ideal for data logging, quick testing, and lightweight analysis — especially for IoT projects. You can capture sensor readings, visualize trends with charts, and even connect Sheets to other platforms like Google Looker Studio or BigQuery for deeper analytics. For developers and makers, Google Sheets serves as an excellent starting point for collecting and analyzing data without needing a dedicated server or database.

What You’ll Need

• A BleuIO USB dongle
• A HibouAir CO2 sensor
• A Google account (for Sheets and Apps Script)

You’ll also need a few Python libraries, which we’ll install below.

Step 1 — Set Up Your Google Sheet

We’ll use Google Sheets as our cloud storage for the data.

1. Go to Google Sheets and create a new spreadsheet.
2. Name it something like BleuIO_HibouAir_Data.
3. Rename the first tab to data.
4. In the first row, add the following headers: timestamp, CO2, temperature, humidity

Step 2 — Create a Google Apps Script Webhook

Next, we’ll build a small Google Apps Script that accepts POST requests and appends data to your sheet.

1. Open https://script.google.com/home and click New Project.
2. Paste this code into the editor:

// ===== CONFIG =====
const SPREADSHEET_ID = 'YOUR_SHEET_ID_HERE'; // from your sheet URL
const SHEET_NAME = 'data'; // tab name
// ==================

function doPost(e) {
  const sheet = SpreadsheetApp.openById(SPREADSHEET_ID).getSheetByName(SHEET_NAME);
  if (!e || !e.postData || !e.postData.contents) {
    return ContentService.createTextOutput('NO_BODY');
  }
  let payload = JSON.parse(e.postData.contents);
  const rows = Array.isArray(payload) ? payload : [payload];
  const toRow = o => [
    o.timestamp || new Date().toISOString(),
    Number(o.CO2),
    Number(o.temperature),
    Number(o.humidity)
  ];
  const values = rows.map(toRow);
  sheet.getRange(sheet.getLastRow() + 1, 1, values.length, values[0].length).setValues(values);
  return ContentService.createTextOutput('OK');
}

3. Replace YOUR_SHEET_ID_HERE with your sheet’s ID — it’s the long string between /d/ and /edit in your Sheet URL.
4. Click Deploy → New Deployment → choose Web app.
5. Under settings:
   • Execute as: Me
   • Who has access: Anyone with the link
6. Click Deploy, then copy the Web app URL.
   This will be your WEBHOOK_URL.

Step 3 — Install Python Libraries

Open your terminal (or PowerShell) and install the required dependencies:

pip install pyserial requests

These will let Python talk to the BleuIO dongle and send HTTPS requests to Google Sheets.

Step 4 — Connect and Configure the BleuIO Dongle

Plug in your BleuIO USB dongle.

• On macOS, it will appear as something like /dev/cu.usbmodemXXXX.
• On Windows, it will show up as COMX.

You can list serial ports to confirm:

ls /dev/cu.usbmodem*    # macOS

or

Get-WMIObject Win32_SerialPort | Select-Object DeviceID,Name  # Windows

Step 5 — Run the Python Script

Now we’ll use a Python script that handles the entire process automatically. The script first connects to the BleuIO dongle and sets it to central mode using the AT+CENTRAL command, which allows it to scan for nearby BLE devices. It then searches for HibouAir BLE advertisements using the AT+FINDSCANDATA=220069=3 command, which filters packets matching the HibouAir sensor’s unique identifier. Once it receives a valid advertisement, the script decodes the CO2, temperature, and humidity values from the data packet. Finally, it packages these readings along with a timestamp and pushes them to your Google Apps Script webhook, which automatically logs them into your Google Sheet.

📂 GitHub Repository: View Source Code on GitHub

Before running, update:

• SERIAL_PORT → your BleuIO port
• WEBHOOK_URL → your Google Apps Script Web App URL

Step 6 — Watch Your Data Flow!

Open your Google Sheet. You’ll see new rows appear every few seconds:

timestamp	CO2	temperature	humidity
2025-10-10T14:48:07.849Z	514	23.8	46.1

Step 7 — Create Charts in Google Sheets

Once your data is flowing into Google Sheets, you can easily visualize it without using any external tools. Start by highlighting the range of data you want to analyze, then go to Insert → Chart in the menu. Google Sheets will automatically suggest a chart type, but you can switch to a Line Chart or Combo Chart to better visualize trends over time. For a more dashboard-like view, you can also add a Gauge Chart to display real-time values for CO₂ or temperature. Customize the chart’s colors, titles, and formatting to match your preferences, and adjust refresh settings so your visuals update automatically as new data arrives.

And that’s it! You’ve built a real-time BLE air-quality logger with BleuIO and Google Sheets — no servers, no databases, no fuss.
This setup is perfect for classrooms, offices, or research labs that need quick, visual environmental monitoring.

Use Cases

This project demonstrates how you can use BleuIO and Google Sheets to quickly prototype and test IoT ideas. For example, it’s perfect for indoor air-quality monitoring in offices, classrooms, or labs, allowing you to observe changes in CO₂ levels, temperature, and humidity over time. Researchers can use it to log environmental data during experiments or field studies. It’s also useful for IoT developers who want to validate BLE sensors or test new device firmware without setting up a backend system. Teachers can turn this setup into an educational project, helping students understand Bluetooth communication, data logging, and visualization. Overall, pairing BleuIO with Google Sheets offers a fast, free, and flexible way to monitor and analyze real-world sensor data.

Whether you’re analyzing indoor air quality, tracking sensor performance, or just exploring IoT data pipelines, BleuIO makes BLE integration simple and powerful.

In this project, we’ll show how to build a real-time air quality monitoring system using the BleuIO USB dongle and Ubidots. The setup listens for Bluetooth Low Energy (BLE) advertising packets from a HibouAir sensor, decodes the CO2, temperature, and humidity data, and sends them directly to Ubidots, where you can visualize and analyze the readings on a live dashboard.

The result is a seamless pipeline from BLE sensor to Ubidots’ cloud platform. This makes it easy to track air quality in real time and share the results with colleagues, clients, or your own IoT applications.

What is Ubidots?

Ubidots is a powerful industrial IoT platform designed to help developers, researchers, and businesses transform raw sensor readings into meaningful insights. More than just a place to store data, Ubidots provides tools to build custom dashboards, alerts, and reports that can be shared across teams or even embedded into products. It is widely used in industries such as smart cities, agriculture, energy, logistics, and healthcare, where real-time monitoring and automation are critical.

By integrating BleuIO with Ubidots, you gain the ability to collect real-time BLE sensor data without the need for complex gateways. The values captured from your sensors can be pushed directly to Ubidots variables through simple HTTPS POST requests, making the process both fast and reliable. Once the data is in Ubidots, you can take advantage of its powerful dashboard features to create professional visualizations with gauges, charts, and triggers, giving you an intuitive way to monitor and analyze your environment.

In short, BleuIO acts as the BLE gateway, and Ubidots becomes the visualization and analytics layer.

Requirements

To complete this project, you’ll need:

• BleuIO USB Dongle – to capture BLE advertising packets.
• HibouAir Sensor – broadcasts CO2, temperature, and humidity.
• Python libraries: pip install pyserial requests
• Ubidots account (a free version is available).
• Ubidots API Token – used to authenticate when posting data to your account.

The Script and How It Works

We’ve written a Python script that automates the whole process from BLE scan to Ubidots push. You can find the full code on GitHub:
GitHub Link for Script

Here’s how the script works step by step:

1. Connects to the BleuIO dongle over the serial port you specify (e.g., /dev/cu.usbmodemXXXX on macOS or COMX on Windows).
2. Switches the dongle into central mode with the AT+CENTRAL command (done only once).
3. Scans for HibouAir packets using AT+FINDSCANDATA=220069=3, which looks for advertising data that matches HibouAir’s manufacturer ID.
4. Selects the last valid packet that contains the expected pattern (5B070504). This ensures we work with the freshest data.
5. Decodes the advertising data into usable values:
   • CO in parts per million (ppm).
   • Temperature in Celsius (°C).
   • Humidity in relative percent (%RH).
     The script also applies sanity checks to ignore invalid readings.
6. Pushes the values to Ubidots via HTTPS POST requests. The request format looks like this:
   { "co2": { "value": 415 }, "temperature": { "value": 23.4 }, "humidity": { "value": 52.1 } }
   Each key (co2, temperature, humidity) becomes a variable in Ubidots.
7. The script repeats this process every 10 seconds, so your dashboard stays updated in real time.

This approach keeps everything lightweight and avoids any need for complex backend servers or brokers.

Output

Once the script is running, your Ubidots device (e.g., bleuio-hibouair) will automatically appear in the Devices section. It will have variables for CO2, temperature, and humidity.

Use Cases

This project can be applied in many real-world scenarios where air quality and environmental monitoring are essential. For example, it can be used for indoor air quality monitoring in offices, classrooms, or laboratories to ensure a healthy environment for occupants. In smart building management, the integration of CO₂ and temperature readings into HVAC systems can help optimize ventilation and energy use. The approach also fits perfectly into cold chain logistics, where continuous temperature and humidity tracking is critical for maintaining the safety and quality of sensitive shipments. In the field of environmental research, this setup provides a quick and reliable way to capture and visualize field data without the need for heavy infrastructure. Finally, it is also ideal for IoT prototyping, as Ubidots makes it easy to build dashboards and visualize sensor data quickly without writing or maintaining a backend system.

With just a BleuIO dongle, a BLE sensor, and a few lines of Python, you can build a real-time IoT dashboard in Ubidots. This project demonstrates how easy it is to collect, decode, and visualize BLE data without needing extra hardware or complicated setups.