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.

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.