Category: BleuIO

In this project, we will look at how the BleuIO SSD025 Bluetooth Low Energy USB dongle can add BLE communication to an Adafruit Fruit Jam powered by the RP2350.

The project takes an unusual software approach. Instead of running the HibouAir scanner as part of the native firmware, the Fruit Jam runs a custom real-time operating system called myRTOS .

A myRTOS application module, hibouair.c, written in C, communicates with the BleuIO dongle over USB, scans for nearby HibouAir air-quality sensors, decodes their Bluetooth Low Energy advertisements and displays the latest measurements in real time in a terminal window.

The result is a compact embedded BLE air-quality gateway running on the RP2350.

Requirements

For this project, we use:

• Adafruit Fruit Jam with RP2350B
• BleuIO SSD025 Bluetooth Low Energy USB dongle
• One or more HibouAir SSD002 air-quality sensors
• myRTOS
• USB data cable
• Computer with a serial terminal such as PuTTY

The Fruit Jam is particularly suitable for this project because it has a built-in USB hub with two exposed USB host ports.

What does this project do?

1. HibouAir broadcasts sensor data

2. BleuIO receives the BLE advertisements

3. Fruit Jam receives the data over USB

4. myRTOS decodes and displays the measurements

The HibouAir sensor periodically broadcasts its measurements using BLE advertising packets. The SSD025 receives these packets and makes the information available to the RP2350 over USB.

The myRTOS application then scans for HibouAir devices, interprets the received information and maintains a live list of detected sensors.

The terminal provides an easy way to observe the air-quality information as it arrives.

Hardware

The project is built around three main pieces of hardware.

Adafruit Fruit Jam with the BleuIO SSD025 connected directly to the USB Type-A host port.

Adafruit Fruit Jam

The Fruit Jam is a compact computer based on the RP2350B microcontroller. Adafruit provides two USB Type-A host ports through an onboard USB hub, making it possible to connect USB peripherals directly to the board.

The board provides considerably more functionality than is required for this simple gateway. In addition to the RP2350B, it includes flash storage, PSRAM, USB host capability, microSD, DVI output, audio hardware and an ESP32-C6 for wireless connectivity.

For this project, however, the important feature is the USB host interface .

BleuIO SSD025

The BleuIO SSD025 is used as the Bluetooth Low Energy interface.

This means the RP2350 application does not need to implement the Bluetooth Low Energy stack itself.

The dongle supports Bluetooth 5.2 and USB Full Speed, can operate in Bluetooth central or peripheral roles, and is controlled through its USB interface.

The application can therefore access BLE functionality through BleuIO’s USB interface while leaving the Bluetooth communication to the dongle.

HibouAir SSD002

The HibouAir SSD002 is the wireless air-quality sensor.

HibouAir’s documentation describes the SSD002/2B as a CO2 air-quality monitor using an NDIR CO2 sensor, with wireless Bluetooth connectivity. The sensor family can provide environmental parameters including CO2, temperature, humidity, particulate matter and VOC-related measurements depending on the model.

www.hibouair.com

Why use BleuIO?

The BleuIO acts as the bridge between the USB host implemented by the Fruit Jam and the Bluetooth Low Energy devices in the surrounding environment.

The application processor can concentrate on:

• USB communication
• RTOS scheduling
• data parsing
• terminal output

while the BleuIO handles the Bluetooth side.

BleuIO’s own HibouAir gateway example similarly uses BleuIO to provide BLE communication to RP2040/RP2350 development boards through USB.

The Software Architecture

The software in this project is based on myRTOS , a small real-time operating system environment running on the Fruit Jam.

The HibouAir application is started from the RTOS command interface:

myrtos:/> hibouair

Once started, the application enters scanning mode:

scanning; ctrl-C to stop

The application then continuously processes incoming BLE data.

Conceptually, the software pipeline looks like this:

HibouAir → BLE advertisements → BleuIO SSD025 → USB → Fruit Jam / myRTOS → HibouAir packet decoding → Terminal display

The important point is that this is not simply a raw BLE packet monitor.

The application turns the incoming wireless data into a human-readable sensor table .

How to Run the Project

The complete project is available on GitHub:

https://github.com/smart-sensor-devices-ab/Adafruit-Fruit-Jam-with-BleuIO

1. Connect the board: Connect the Adafruit Fruit Jam to your computer using a USB-C cable and turn the power switch ON.
2. Hold down Button #1 (the UF2 BOOT button located on GPIO0), press and release the reset button while continuing to hold Button #1, and release Button #1 only after the bootloader drive appears.
3. Drag the project’s .uf2 file onto the board’s bootloader drive. The image includes myRTOS and the hibouair.c application module.
4. Press the reset button to reboot the board.
5. Connect the BleuIO SSD025: Plug the BleuIO SSD025 into one of the Fruit Jam’s USB Type-A host ports.
6. Power the HibouAir sensor: Make sure one or more HibouAir sensors are powered on and within Bluetooth range of the BleuIO dongle.

Button Locations on the Adafruit Fruit Jam

To enter UF2 bootloader mode, this project uses two buttons on the Fruit Jam:

• Button #1 (UF2 BOOT) — located on GPIO0 towards the bottom-right edge of the board.
• Reset button — located on the left edge of the board.

The image below shows the location of both buttons.

After rebooting, open a terminal window and connect to the board.

Windows

After rebooting, open Device Manager and identify the COM port assigned to the Fruit Jam. Connect to this port using a serial terminal such as PuTTY.

macOS

To find the Fruit Jam’s serial port, open a terminal and run:

ls /dev/cu.usbmodem*

The command should return a device similar to:

/dev/cu.usbmodem2351xxxx

Connect to it using:

screen /dev/cu.usbmodem2351xxxx

Real-Time HibouAir Scanning

After connecting to the Fruit Jam, start the HibouAir application from the myRTOS command interface:

myrtos:/> hibouair

scanning; ctrl-C to stop

The program then prints a table containing the detected HibouAir devices.

This gives the user an immediate overview of all the HibouAir sensors currently being received.

Expected Output

For example, the output below shows several HibouAir devices detected during a scan. The table shows each detected device’s board identifier, Bluetooth address, sensor type and latest environmental measurements.

Where Could This Go Next?

The current application concentrates on the essential task: receiving HibouAir advertisements and presenting the decoded measurements in real time.

Logging the data to the Fruit Jam’s microSD card would also make it possible to create long-term air-quality datasets without requiring a permanently connected computer.

The Fruit Jam’s USB host capability, microSD storage and RP2350B processor make this type of expansion practical.

Conclusion

This project demonstrates how the Adafruit Fruit Jam, BleuIO SSD025 and HibouAir SSD002 can be combined to create a compact RP2350-based Bluetooth Low Energy air-quality gateway.

HibouAir sensors broadcast their environmental measurements over BLE. BleuIO receives these advertisements and transfers the data to the Fruit Jam over USB, where the myRTOS hibouair application decodes the sensor data and presents the latest measurements in real time.

The project shows how BleuIO can add BLE communication to an RP2350-based embedded system while keeping the Bluetooth interface separate from the main application.

In this tutorial, we will look at how the BleuIO USB dongle can add Bluetooth Low Energy communication to an RP2040 or RP2350 development board.

The project uses the open-source Pico I/O Bridge firmware. It allows a supported development board to work as a USB host for BleuIO. BleuIO scans nearby HibouAir sensors, and the board displays the latest sensor data through a simple browser interface.

The board also creates a small USB network connection with the computer. This means the dashboard can be opened directly in a web browser without installing a desktop application or connecting the board to Wi-Fi. The firmware is written in Rust and exposes its interfaces through a local .local address.

This project is a useful example of how BleuIO can provide BLE communication to development boards that do not have built-in Bluetooth. The board handles USB hosting and networking, while BleuIO handles Bluetooth scanning.

Requirements

You will need:

• BleuIO USB dongle
• One or more HibouAir sensors
• A supported board with a USB host connection:
  • Adafruit Feather RP2040 USB Host
  • Waveshare RP2350 USB-A
• A USB data cable for connecting the board to your computer
• A computer with a modern web browser
• The Pico I/O Bridge firmware

What Does This Project Do?

The project creates a simple connection between HibouAir sensors, BleuIO and your computer.

1. HibouAir broadcasts sensor data

HibouAir sensors regularly broadcast their measurements using Bluetooth Low Energy advertising packets.

Depending on the HibouAir model, these broadcasts can contain parameters such as: Temperature, Humidity, Pressure, CO2, VOC, Noise, PM1.0, PM2.5, PM10, Ambient light

Because the project reads BLE advertising data, the HibouAir sensors do not need to be paired with the development board.

2. BleuIO receives the BLE advertisements

BleuIO is connected to the USB-A host port of the development board.

After BleuIO is detected, the firmware manages the scanning process automatically. BleuIO searches for nearby HibouAir advertisements and sends the received data to the board.

This is an important part of the project: the RP2040 or RP2350 board does not need its own Bluetooth radio. BleuIO provides the Bluetooth Low Energy functionality through USB.

3. The board decodes the HibouAir data

The firmware reads the BLE scan results from BleuIO and decodes the HibouAir manufacturer data.

It identifies the HibouAir sensor ID and sensor type before extracting the measurements supported by that particular model.

The firmware keeps the latest readings for up to eight HibouAir sensors in memory. When no sensor filter has been configured, sensors are discovered automatically.

4. The results appear in a web browser

The development board appears on the computer as a small USB Ethernet device. It provides its own local IP network and advertises a unique .local hostname.

The browser dashboard shows: BleuIO connection status, USB transfer status, Number of HibouAir sensors discovered, HibouAir sensor IDs, Sensor types, Latest measurements, Time since the last advertisement, Number of reports received

The dashboard updates automatically while BleuIO continues scanning.

How to Run the Project

The complete project is available on GitHub:

Pico I/O Bridge GitHub repository

There are two ways to run it:

1. Flash a pre-built firmware file.
2. Build the firmware from the Rust source code.

Using a pre-built firmware file is the easiest method.

Method 1: Use the Pre-Built Firmware

Step 1: Download the firmware

Open the project’s release page:

Pico I/O Bridge v0.2.0 release

The release contains pre-built UF2 firmware files for the supported board profiles, together with a checksum file.

Download the UF2 file that matches your board.

For this project, select the firmware for either:

Adafruit Feather RP2040 USB Host

or:

Waveshare RP2350 USB-A

Do not flash firmware intended for a different board model.

Step 2: Put the board into bootloader mode

Disconnect the board from the computer.

Put the board into its normal UF2 or BOOTSEL flashing mode. The exact button combination depends on the board, so follow the normal bootloader procedure for your development board.

When the board enters bootloader mode, it should appear on the computer as a removable USB drive.

Step 3: Flash the UF2 file

Copy the downloaded UF2 file to the board’s removable drive.

The board should restart automatically after the file has been copied.

Wait a few seconds for the firmware to start and for the USB network connection to become available.

Step 4: Connect BleuIO

Insert the BleuIO USB dongle into the USB-A host port of the development board.

The physical connection should look like this:

Do not connect BleuIO directly to the computer for this setup. It needs to be connected to the USB host port on the development board.

Step 5: Power the HibouAir sensors

Make sure your HibouAir sensors are powered on and located within Bluetooth range of BleuIO.

No Bluetooth pairing process is required. The sensors simply need to be broadcasting their normal BLE advertisement data.

Step 6: Find the board hostname

Each board creates a unique .local hostname.

For the Adafruit Feather RP2040 USB Host, it will follow this format:

pico-io-usb-host-xxxxxx.local

For the Waveshare RP2350 USB-A, it will follow this format:

pico-io-waveshare-rp2350-xxxxxx.local

Replace xxxxxx with the unique identifier assigned to your board.

On macOS, the board can also be discovered through the built-in dns-sd utility:

dns-sd -B _http._tcp

The project advertises its web interface through mDNS and DNS Service Discovery.

On Windows, the optional mDNS Discovery utility can be used to view available mDNS and DNS-SD services.

Step 7: Open the web interface

Open a browser and enter the board hostname.

For example:

http://pico-io-usb-host-244c29.local/usb-host.html

Use your board’s actual hostname rather than the example above.

The USB-host-enabled profiles expose the USB status page at:

/usb-host.html

The web interface and the USB-host API are included whenever the firmware is built with the pio-usb-host feature.

Step 8: Wait for BleuIO to become ready

After opening the page, check the USB section.

You should see a status similar to:

BleuIO Ready

You should also see:

BleuIO HibouAir scanner ready

Once BleuIO is ready, the managed HibouAir scan begins automatically.

Nearby HibouAir sensors should start appearing as individual cards. The first results may take a few seconds, depending on the sensors’ advertisement intervals.

Expected Output

The page should show each discovered HibouAir sensor with its sensor ID, sensor model and latest measurements.

Method 2: Build the Firmware from Source

Developers can also clone the complete project and build the firmware using Rust.

Clone the repository:

git clone https://github.com/ulso/pico-io-bridge.git
cd pico-io-bridge

Build for the Adafruit Feather RP2040 USB Host

cargo build --locked --release \
  --no-default-features \
  --features board-adafruit-rp2040-usb-host

Build for the Waveshare RP2350 USB-A

cargo build --locked --release \
  --target thumbv8m.main-none-eabihf \
  --no-default-features \
  --features board-waveshare-rp2350-usb-a

The RP2040 and RP2350 profiles use different Rust target configurations, so it is important to use the command intended for your board.

With the board in BOOTSEL mode, the project can also be built and flashed using the appropriate cargo run command. The repository contains the full toolchain and flashing details for developers who want to modify the firmware.

The complete source code, build instructions and examples are available in the Pico I/O Bridge GitHub repository. Additional project screenshots can be found in the Pico I/O Bridge Wiki.

In this project, we are going to build a simple air quality data-sharing system using a BleuIO USB dongle, a HibouAir sensor, Python, and openSenseMap.

The goal of this project is to collect temperature and humidity data from a HibouAir sensor over Bluetooth Low Energy and publish the values online using openSenseMap. Once the data is uploaded to openSenseMap, it can be viewed publicly and shared with others.

This is a minimal project designed to show how BleuIO can be used as a BLE gateway for collecting environmental sensor data and sending it to an online platform. The same idea can later be expanded to include other air quality parameters such as CO2, VOC, particulate matter, pressure, or other sensor values.

What is openSenseMap?

openSenseMap is an open data platform for environmental sensor data. It allows users to create a virtual sensor station, called a senseBox, and upload measurements from different sensors.

By using openSenseMap, we can make our air quality data public and easy to access. This is useful for projects related to environmental monitoring, smart cities, classrooms, research, and IoT demonstrations.

In this project, we will create a senseBox on openSenseMap and add two sensors:

• Temperature
• Relative humidity

The Python script will read these values from the HibouAir BLE advertisement and upload them to the correct openSenseMap sensor IDs.

Project Requirements

To complete this project, we need the following hardware and software:

• BleuIO USB dongle
• HibouAir sensor
• openSenseMap account

No extra microcontroller, BLE pairing, database, or web server is required. BleuIO connects directly to the computer through USB and is controlled using AT commands from the Python script.

Setting Up openSenseMap

First, create an account on openSenseMap. After logging in, create a new senseBox. This senseBox will represent the sensor station where our HibouAir measurements will be uploaded.

Inside the senseBox, create two sensors:

• Temperature with unit °C
• Relative humidity with unit %RH

After creating the senseBox and sensors, openSenseMap will provide different IDs. We need to copy and save the following values:

• senseBox ID
• Temperature sensor ID
• Humidity sensor ID

These IDs are important because the Python script uses them to know where to upload each measurement. The senseBox ID identifies the box, while each sensor ID identifies the individual measurement field.

Configuring the Project

The project uses an info.txt file to store the required IDs and configuration values.

If info.txt does not already exist, copy the example file:

cp info.example.txt info.txt

Then add the openSenseMap IDs and the HibouAir board ID:

OPENSENSEMAP_BOX_ID=your_box_id_here
SENSOR_ID_TEMPERATURE=your_temperature_sensor_id_here
SENSOR_ID_HUMIDITY=your_humidity_sensor_id_here
HIBOUAIR_SENSOR_ID=220069

# Optional on macOS:
# BLEUIO_PORT=/dev/cu.usbmodemXXXX

The HIBOUAIR_SENSOR_ID is the board ID printed on the HibouAir sensor. The script uses this ID to filter BLE advertisements and make sure it is reading data from the correct device.

Normally, the script automatically finds the BleuIO serial port on macOS by checking /dev/cu.usbmodem* and /dev/cu.usbserial*. If needed, the port can also be added manually in info.txt.

The info.txt file is excluded from Git using .gitignore, so private box IDs and sensor IDs are not committed to the repository.

Installing Dependencies

Open Terminal, go to the project directory, and run:

python3 -m venv .venv
source .venv/bin/activate
python3 -m pip install -r requirements.txt

The project uses only two Python packages:

• pyserial
• requests

pyserial is used to communicate with the BleuIO dongle over the serial port, and requests is used to upload data to openSenseMap.

How the Project Works

The BleuIO USB dongle is connected directly to the Mac. The Python script opens the BleuIO serial port and sends AT commands to scan for BLE advertisements from the HibouAir sensor.

The script uses the HibouAir board ID to filter the scan result. For example:

AT+FINDSCANDATA=220069=5

This command asks BleuIO to search for advertised data containing the board ID 220069 for five seconds.

When the scan response is received, the script decodes the latest valid HibouAir advertisement. It extracts only two values. Temperature and Relative humidity,

After decoding the values, the script uploads them to the configured openSenseMap senseBox using the temperature and humidity sensor IDs.

The upload process repeats every 60 seconds.

Only temperature and humidity are uploaded. Bluetooth addresses, raw advertising payloads, and other sensor values are not sent to openSenseMap or saved to a file.

Running the Script

Connect BleuIO to the Computer and run:

python3 main.py

Press Ctrl+C to stop the logger.

Example output:

## BleuIO HibouAir openSenseMap Logger

Using port: /dev/cu.usbmodem4048FDE52CF21
Checking BleuIO...
BleuIO responded OK

Scanning for HibouAir sensor ID: 220069
Scan command: AT+FINDSCANDATA=220069=5
Waiting for BleuIO scan response...

Decoded HibouAir data:
Temperature: 24.3 °C
Humidity: 42.8 %RH

Uploading to openSenseMap...
Temperature uploaded successfully
Humidity uploaded successfully

Waiting 60 seconds before next scan...

The script reads the BleuIO response, decodes the temperature and humidity values, uploads them to openSenseMap, and then waits before starting the next scan.

Outputs

Source Code

The full source code for this project is available on GitHub.

Users can download the project, configure their own openSenseMap IDs, add their HibouAir board ID, and run the script on their own system.

GitHub URL:

https://github.com/smart-sensor-devices-ab/bleuio_opensensemap

Expanding the Project

This project currently uploads only temperature and humidity, but it can be expanded easily.

Users can modify the script to decode and upload more environmental parameters, such as: CO2, VOC, Particulate matter, Air pressure, Light level etc.

Additional sensors can also be created in openSenseMap, and their sensor IDs can be added to the configuration file. This makes the project flexible for different air quality monitoring and IoT applications.

With only a BleuIO USB dongle, a HibouAir sensor, and a Python script, we can collect temperature and humidity data and make it publicly available. The project is easy to set up, requires no BLE pairing, and can be extended for more advanced air quality monitoring applications.

Bluetooth Low Energy devices are everywhere, from smart sensors and beacons to IoT devices and proximity-based applications. When working with BLE, developers often need a quick way to scan nearby advertising devices and understand their signal strength.

In this project, we build a simple BLE RSSI Heatmap Visualizer using the BleuIO USB dongle. The application runs directly in the browser and connects to BleuIO through the serial port. It performs a BLE scan, reads nearby advertising devices, extracts their RSSI values, and displays them in a visual heatmap.

This is helpful because raw BLE scan output can be difficult to read, especially when many devices are advertising at the same time. With this visualizer, developers can quickly see which devices have strong, medium, or weak signal strength.

BleuIO makes this project simple because it handles the BLE scanning through easy AT commands. Instead of writing low-level Bluetooth code, we can send commands from JavaScript and focus on building the visualization.

Requirements

To try this project, you need:

• A BleuIO USB dongle
• The project source code from GitHub

How It Works

The application connects to the BleuIO dongle using the browser’s Web Serial API. Once connected, it sends BleuIO AT commands to put the dongle into central scanning mode and start a BLE GAP scan.

The main commands used are:

AT+CENTRAL
AT+SHOWRSSI=1
AT+GAPSCAN=5

AT+CENTRAL prepares BleuIO for scanning. AT+SHOWRSSI=1 enables RSSI values in the scan output. AT+GAPSCAN=5 scans nearby BLE devices for 5 seconds.

The browser app then reads the serial output and looks for device information such as MAC address, RSSI value, and device name if available. Each device is grouped based on RSSI strength.

The signal categories are simple:

Strong signal: RSSI >= -50
Medium signal: RSSI between -51 and -70
Weak signal: RSSI <= -71

The heatmap places BleuIO at the center and displays nearby BLE devices around it. Stronger devices appear closer to the center, while weaker devices appear farther away. The device bubbles are also color-coded, making it easier to understand the BLE environment at a glance.

A table below the heatmap shows the detected devices with MAC address, RSSI, name, signal category, and last seen time.

GitHub Project Code

The full source code is available here:

https://github.com/smart-sensor-devices-ab/ble-rss-heatmap-visualizer

You can download or clone the project and open it in a supported browser.

Live Testing

You can also try the live version here:

https://smart-sensor-devices-ab.github.io/ble-rss-heatmap-visualizer/

To test it:

1. Plug in the BleuIO USB dongle.
2. Open the live page in your browser.
3. Click Connect.
4. Select the BleuIO serial port.
5. Click Scan.
6. View the BLE RSSI heatmap and detected device table.

Output Screenshot

Add output screenshot here.

This is an example project showing how BleuIO can be used with the Web Serial API to build a practical BLE scanning and visualization tool. Developers can use the source code as a starting point and modify it for their own use cases.

For example, the project can be extended to scan for a longer period of time, change the RSSI threshold values, filter specific devices, highlight known BLE sensors, or integrate the scan results into a larger web dashboard.

Because BleuIO works with simple AT commands over serial, it is easy to integrate with different programming languages, platforms, and browser-based tools like this one.

Bluetooth Low Energy development is often associated with languages like C, Python, JavaScript, or mobile frameworks. But with BleuIO, BLE communication becomes accessible from almost any programming language that can work with a serial port. In this tutorial, we will build a simple Fortran terminal application that connects to a BleuIO USB dongle, sends AT commands, scans for nearby HibouAir BLE advertisements, decodes the advertising data, and prints the sensor values directly in the terminal.

This project is intentionally small and beginner-friendly. The goal is not to build a full production BLE application, but to demonstrate how Fortran can communicate with BLE devices through BleuIO using simple serial communication.

Why Fortran for a BLE Example?

Fortran is one of the oldest programming languages still actively used today, especially in scientific computing, engineering, numerical modelling, and high-performance applications. While Fortran is not normally the first language people think of for BLE development, this example shows an interesting advantage of using BleuIO.

What We Are Building

The application does the following:

It connects to a BleuIO USB dongle using serial terminal. Then it configures the serial port and sends BleuIO AT commands. After that, it starts a filtered BLE scan for HibouAir advertisements using the command:

AT+FINDSCANDATA=FF5B07

The program then reads the incoming scan data, extracts the advertising payload, decodes the HibouAir manufacturer data, and prints values such as sensor ID, light or noise, pressure, temperature, humidity, CO2, and particulate matter values where available. The README also notes that the program automatically searches for a BleuIO dongle using VID 0x2dcf and PID 0x6002.

Project Requirements

Before running the project, install the required packages on macOS using Homebrew:

brew install gcc libserialport pkg-config

You will also need the following hardware:

1. BleuIO USB dongle
2. HibouAir CO2 Sensor

Getting the Project

The full source code is available on GitHub:

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

Building the Project

Build the project with:

make

This creates the executable:

./bleuio_fortran_scanner

The README confirms that the project is built using make and creates the bleuio_fortran_scanner binary.

Running the Project

Run the scanner from the terminal:

./bleuio_fortran_scanner

Once started, the program searches for the connected BleuIO dongle, opens the serial port, prepares the dongle, and starts scanning for HibouAir BLE advertisements.

You can stop the program at any time using:

Ctrl-C

How It Works

The project is split into small Fortran source files to keep the example easy to understand.

The libserialport_bindings.f90 file contains the small ISO_C_BINDING interface required to call libserialport. The serial_utils.f90 file handles finding, opening, configuring, reading from, writing to, and closing the serial port. The bleuio_commands.f90 file contains helper procedures for sending BleuIO AT commands. The simple_json.f90 file extracts the predictable fields needed from the BleuIO scan response. The hibouair_decoder.f90 file decodes HibouAir manufacturer data and prints the sensor values. Finally, main.f90 contains the main scanner flow.

The main idea is simple. BleuIO receives BLE advertising data and returns it through the serial port. The Fortran application reads each line, checks whether it contains valid scan data, extracts the advertisement payload, and decodes the bytes according to the HibouAir data format.

Because BleuIO handles the BLE communication, the Fortran code does not need to manage Bluetooth scanning directly. It only sends AT commands and reads the response.

Example Output

When a HibouAir CO₂ sensor is found, the terminal output looks like this:

BleuIO Fortran HibouAir Scanner
--------------------------------
Searching for BleuIO dongle...
Connected: /dev/tty.usbmodemXXXX

  Sensor ID: 123ABC
      Light: 52 Lux
   Pressure: 1012.4 hPA
Temperature: 23.6 C
   Humidity: 45.1 %rh
        CO2: 612 ppm

For a PM sensor board, the output includes particulate matter values:

  Sensor ID: 456DEF
      Light: 38 Lux
   Pressure: 1011.8 hPA
Temperature: 22.9 C
   Humidity: 47.2 %rh
     PM 1.0: 2.1 ug/m3
     PM 2.5: 4.8 ug/m3
      PM 10: 7.3 ug/m3
        CO2: 0 ppm

These sample outputs are also included in the project README.

Output Screenshot

Add a screenshot here showing the terminal running the Fortran application and printing decoded HibouAir sensor values.

Further Development

This project is a simple example showing how BleuIO can be used with Fortran when building BLE applications. It demonstrates the basic workflow: connect to BleuIO through a serial port, send AT commands, scan for BLE advertisements, read the response, and decode the data.

Developers can use this example as a starting point and expand it for their own projects. For example, the script could be extended to save sensor readings to a file, export data as CSV, monitor multiple HibouAir devices, trigger alerts when CO₂ or PM values are high, or integrate the data with scientific and engineering workflows where Fortran is already used.