Author: BleuIO

In this tutorial, we demonstrate how to use the Renesas EK-RA4M2 MCU, the Renesas RRH62000 All-in-One Air Quality Sensor Module, and the BleuIO Bluetooth Low Energy (BLE) USB Dongle to collect and transmit air quality data wirelessly. The RRH62000 sensor module measures key environmental parameters such as:

• eCO₂ (Equivalent Carbon Dioxide)
• Humidity (%)
• Temperature (°C)
• Particulate Matter (PM1, PM2.5, PM10) (µm/cm³)
• Total Volatile Organic Compounds (TVOC) (mg/m³)
• Indoor Air Quality Index (IAQ)

The EK-RA4M2 MCU reads data from the sensor via I²C, processes the information, and transmits it over BLE using the BleuIO USB dongle. The advertised data can be monitored using BLE scanning applications, and the sensor values can also be displayed in RTTViewer on a connected PC.

Requirements

Before getting started, ensure you have the following hardware and software:

Hardware

• EK-RA4M2 MCU
• BleuIO – Bluetooth Low Energy USB Dongle
• Renesas RRH62000 All-in-One Integrated Air Quality Sensor
• USB OTG Cable (USB-A to micro-B)
• Micro USB cable (for debugging)

Software

• FSP Platform Installer (e² studio IDE & toolchain, FSP version ≥ 5.7.0)
• J-Link RTT Viewer
• BLE Scanning App (e.g., nRF Connect)

You can download the complete example project here:
➡️ GitHub Repository

Hardware Setup

Connecting EK-RA4M2 and BleuIO Dongle

1. Connect EK-RA4M2 to your PC using a micro-USB cable via the J10 (Debug1) port.
2. Plug the BleuIO dongle into a USB OTG cable and connect it to J11 (USB Full Speed) on the EK-RA4M2 board.
3. Set jumpers:
   • Place J12 on pins 1-2.
   • Remove J15 completely.

Reference Diagram:

Connecting RRH62000 Air Quality Sensor

Connect the RRH62000 sensor module to EK-RA4M2 as follows:

• Power: Connect 5V and GND from RRH62000 to 5V and GND on EK-RA4M2.
• I²C Communication:
  • SCL (Clock) → SCL on EK-RA4M2
  • SDA (Data) → SDA on EK-RA4M2
  • GND → GND on EK-RA4M2

Reference Diagrams:

Importing the Project into e² Studio

1. Open e² Studio IDE and choose a workspace. Click Launch.
2. Download or clone the project from GitHub and place the “bleuio_ra4m2_rrh62000_example” folder inside your workspace.
3. Go to File → Import and select Existing Projects into Workspace under the General tab.
4. Click Browse… and locate the project folder.
5. Select the project and click Finish to import it.

Importing Example Project:

Building and Running the Example

1. Build the project by clicking the build icon.
2. Set up debugging:
   • Click the down arrow next to the Debug icon and select Debug Configurations…
   • Under Renesas GDB Hardware Debugging, choose bleuio_ra4m2_sensor_rrh62000_example Debug_Flat and click Debug.
     
     
     
3. Run the program:
   • Open RTTViewer and connect using the following settings:
     • Connection to J-Link: USB
     • Target Device: R7FA4M2AD
     • Interface & Speed: SWD, 4000 kHz
     • RTT Control Block Address: 0x200009dc
       
4. In e² Studio, click Resume twice to start execution.
   
5. The program starts running:
   • All LEDs turn on for 1 second, then only the red LED remains on.
   • The red LED turns off when BleuIO is initialized.
   • The green LED turns on when advertising starts.
6. Sensor data is displayed in RTTViewer.
   

Scanning and Decoding BLE Advertising Data

Scan the Dongle using nRF Connect

Use a BLE scanning app like nRF Connect to view the advertised data:

Decoding the Advertising Message

Example raw BLE advertisement:

02010619FF3600016491803010300030105060306080192

All air quality sensor values except eCO2 is split into two bytes. The first byte is the whole number and the second byte is the decimal. For example
1649 is the temperature value. The whole number is 16 and the decimal is 49. Converting it from hex gives
us: 23.73 °C

The eCO2 value is 2 bytes, big endian.

Breaking it down:

Data	Description	Decoded Value
020106	Advertising flag (connectable)	–
19	Message size	–
FF	Manufacturer Specific Data	–
3600	Renesas Manufacturer ID (Little Endian)	–
	Air Quality Advertised Data
1649	Temperature (°C)	23.73°C
1803	Humidity (%RH)	24.3% RH
0103	IAQ Index	1.3
0003	TVOC (mg/m³)	0.3 mg/m³
0105	PM1 (µm/cm³)	1.5
0603	PM2.5 (µm/cm³)	6.3
0608	PM10 (µm/cm³)	6.8
0192	eCO₂ (ppm)	402 ppm

This project successfully demonstrates how to use the BleuIO Bluetooth dongle, EK-RA4M2 MCU, and Renesas RRH62000 sensor to wirelessly monitor air quality. The BLE advertisements can be scanned and decoded to extract real-time air quality data.

For the full source code and updates, visit:
➡️ GitHub Repository

Indoor air quality is crucial for maintaining a healthy living and working environment. HibouAir is a powerful air quality monitoring device that provides real-time data on CO2 levels, temperature, humidity, and air pressure.  

This project demonstrates how BleuIO enables communication with HibouAir, allowing real-time environmental data to be retrieved, while Google’s Gemma model processes and analyzes the data to provide meaningful, easy-to-understand responses through a chat interface.

Users can interact with HibouAir’s smart assistant and ask questions such as:

• “What is my room temperature?”
• “What is the humidity level?”
• “How is the air quality in my room?”

The system retrieves real-time sensor data from HibouAir and provides contextual recommendations based on environmental conditions.

By leveraging Google’s lightweight Gemma model, this project ensures efficient and intelligent analysis of air quality data, making it accessible for various applications, from smart homes to research.

Features of This Project

• Live CO2, Temperature, Humidity, and Pressure Monitoring
• Google-Powered Analysis for Meaningful Insights
• Conversational Chat Interface (“Chat with HibouAir”)
• Completely Local – No Internet Required
• Lightweight & Efficient Processing with Gemma

Step-by-Step Guide: How It Works

Install Required Software

We need:

• BleuIO for Bluetooth communication.
• Ollama to run Google’s Gemma model locally.
• HibouAir for air quality monitoring
• Gemma for efficient data analysis and meaningful responses.

Install Python Dependencies

pip install flask bleuio

Install Ollama (For Local Processing)
For Mac/Linux:

curl -fsSL https://ollama.com/install.sh | sh

For Windows, download it from Ollama’s official site.

Install Google’s Gemma Model

ollama pull gemma

Why Gemma? What Are the Alternatives?

For this project, we chose Gemma, a lightweight, open-source model developed by Google, because it aligns with Google’s ecosystem and provides efficient, real-time insights for environmental data.

Why Use Google’s Gemma?

• Optimized for Efficiency – Runs well on low-power machines without requiring cloud resources.
• Google-Backed & Open Source – Developed by Google DeepMind, ensuring high-quality performance with full transparency.
• No API Costs & Fully Local – No need for an internet connection or paid APIs, making it a cost-effective solution.
• Designed for Meaningful Responses – Processes real-time air quality data and provides insightful, structured feedback.

Other Model Alternatives

• Phi-2 – Even lighter but lacks detailed contextual understanding.
• Llama3 – More powerful but requires more computational resources.
• Mistral – Previously used, efficient, but not part of the Google ecosystem.

Connecting HibouAir via Bluetooth (BleuIO)

HibouAir continuously broadcasts CO2, temperature, humidity, and pressure via Bluetooth. We use BleuIO to scan and retrieve these values in real-time.

Setting Up the Chat Interface

Users can type questions like:

• “What is the temperature?”
• “What is my CO2 level?”
• “How is the air quality?”

The system fetches real-time sensor data from HibouAir and provides Google-powered analysis and recommendations.

app.py (Backend)

• This script:
• Scans for HibouAir data
• Extracts CO2, temperature, humidity, and pressure
• Uses Google’s Gemma model for intelligent responses
• Serves the chat interface via Flask

def chat():
    """Handles user input, fetches air quality data if needed, and returns response."""
    user_input = request.json.get("message", "").lower()

    with Manager() as manager:
        air_data = manager.dict({"co2": 0, "pressure": 0, "temperature": 0, "humidity": 0})
        process = Process(target=scan_for_air_quality_process, args=(air_data,))
        process.start()
        process.join()

        # Check for specific sensor queries
        if "temperature" in user_input:
            if air_data["temperature"] > 0:
                response = f"The current temperature in your room is {air_data['temperature']}°C."
            else:
                response = "⚠️ Unable to retrieve temperature data. Ensure HibouAir is in range."
            return jsonify({"response": response})

        elif "humidity" in user_input:
            if air_data["humidity"] > 0:
                response = f"The current humidity level in your room is {air_data['humidity']}%."
            else:
                response = "⚠️ Unable to retrieve humidity data. Ensure HibouAir is in range."
            return jsonify({"response": response})

        elif "pressure" in user_input:
            if air_data["pressure"] > 0:
                response = f"The current air pressure in your room is {air_data['pressure']} hPa."
            else:
                response = "⚠️ Unable to retrieve air pressure data. Ensure HibouAir is in range."
            return jsonify({"response": response})
        elif "co2" in user_input:
            if air_data["co2"] > 0:
                response = f"The current CO2 in your room is {air_data['co2']} ppm."
            else:
                response = "⚠️ Unable to retrieve co2 data. Ensure HibouAir is in range."
            return jsonify({"response": response})

        elif "air quality" in user_input :
            if air_data["co2"] > 0:
                prompt = (
                    f"The current air quality readings are:\n"
                    f"- CO2 Level: {air_data['co2']} ppm\n"
                    f"- Temperature: {air_data['temperature']}°C\n"
                    f"- Humidity: {air_data['humidity']}%\n"
                    f"- Pressure: {air_data['pressure']} hPa\n"
                    f"First give all the data. This is my room data. Give me short analysis on this data. and give me short suggestions "
                )
            else:
                return jsonify({"response": "⚠️ Unable to retrieve air quality data. Ensure HibouAir is in range and try again."})
        else:
            # Normal response for non-air quality queries
            prompt = user_input

    ai_response = subprocess.run(
        ["ollama", "run", "gemma", prompt],
        capture_output=True,
        text=True
    ).stdout.strip()

    return jsonify({"response": ai_response})

Get full source code from Github

index.html (Frontend – Chat Interface)

<div class="card">
        <div class="card-header">Chat with HibouAir</div>
        <div class="card-body">
          <div
            id="chatbox"
            class="border rounded p-3"
            style="height: 400px; overflow-y: auto; background: #f8f9fa"
          >
            <div class="alert alert-secondary">
              <b>HibouAir:</b> Ask me about air quality!
            </div>
          </div>
        </div>
      </div>

Expected Responses

You: “What is my CO2 level?”
HibouAir: “The current CO2 level is 850 ppm.”

You: “What is the air quality in my room?”
HibouAir:

CO2 Level: 850 ppm  
Temperature: 24°C  
Humidity: 55%  
Pressure: 1010 hPa  
Based on these readings, the air quality is good.

Using the Chat Interface

The web interface allows users to ask about specific values like temperature, humidity, pressure, CO2, or overall air quality.

Output

Get the Source Code

This project is open-source! You can access the full code and modify it for your own needs.

👉 [GitHub Repository]

This project showcases how HibouAir and BleuIO can be integrated to provide real-time air quality analysis in a way that is easy to understand. Instead of requiring users to interpret raw sensor data, the chat interface translates complex air quality values into clear, meaningful insights. Powered by Google’s Gemma model, it delivers simple and actionable responses—helping users understand their indoor air quality without needing to be experts.  

In modern web development, Bluetooth Low Energy (BLE) integration is becoming increasingly important for IoT applications. With the Web Serial API, we can now directly communicate with hardware devices like BleuIO using just a browser, eliminating the need for native drivers or middleware.

In this tutorial, we will demonstrate how to use Angular 19 and TypeScript to communicate with a BleuIO USB Dongle via Web Serial API. We will build a simple web application that connects to BleuIO, sends AT commands, and displays responses in real time.

This approach is beneficial because:

• No additional backend services are required—everything runs directly in the browser.
• Simplicity—Web Serial API allows communication with serial devices in JavaScript/TypeScript without native code.
• Cross-platform compatibility—Works on any OS with Google Chrome or Microsoft Edge.

Why Use Angular & TypeScript?

Angular is a powerful framework for building scalable, maintainable, and modern web applications. TypeScript, which is the foundation of Angular, brings type safety and better tooling, making development smoother and reducing runtime errors.

By using Angular 19, we ensure that our application is built on the latest and most optimized framework version, taking advantage of standalone components and improved performance features.

Setting Up the Angular Project

To get started, ensure you have Node.js and Angular CLI installed.

Create an Angular Project

Run the following command to generate a new Angular 19 project:

new angular-bleuio --strict
cd angular-bleuio

Choose No for routing and CSS as the styling option.

add Bootstrap to styles.css:

@import url('https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css');

This ensures our application has a clean, professional UI.

Building the BleuIO Web Serial Connection

We will now implement the core functionality:

1. Connect to BleuIO via Web Serial API.
2. Send AT commands and receive responses.
3. Display formatted responses using delimiters.

Creating the Angular Component

In src/app/app.component.ts, replace the contents with:

import { Component } from '@angular/core';
import { FormsModule } from '@angular/forms';

@Component({
  selector: 'app-root',
  standalone: true, //
  imports: [FormsModule],
  templateUrl: './app.component.html',
  styleUrls: ['./app.component.css'],
})
export class AppComponent {
  port: any | undefined;
  writer: WritableStreamDefaultWriter | undefined;
  reader: ReadableStreamDefaultReader | undefined;
  command: string = '';
  response: string = 'Not connected.';

  async connectToBleuIO() {
    try {
      if (!('serial' in navigator)) {
        this.response = 'Web Serial API not supported in this browser.';
        return;
      }

      this.port = await (navigator as any).serial.requestPort();
      await this.port.open({ baudRate: 115200 });

      this.response = 'Connected to BleuIO.';
      this.writer = this.port.writable?.getWriter();
      this.reader = this.port.readable?.getReader();

      this.readData();
    } catch (error) {
      console.error('Connection failed:', error);
      this.response = 'Failed to connect.';
    }
  }

  async sendCommand() {
    if (!this.port || !this.writer || !this.command) {
      this.response = 'Not connected or empty command.';
      return;
    }

    try {
      // Reset the response before sending a new command
      this.response = 'Waiting for response...';

      // Clear any old responses before sending new data
      if (this.reader) {
        await this.reader.cancel();
        this.reader.releaseLock();
        this.reader = this.port.readable?.getReader(); // Reinitialize reader
      }

      // Send the AT command
      const encoder = new TextEncoder();
      await this.writer.write(encoder.encode(this.command + '\r\n'));

      this.response = 'Command sent: ' + this.command;
      this.readData(); // Start reading the new response
    } catch (error) {
      console.error('Send error:', error);
      this.response = 'Error sending command.';
    }
  }

  async readData() {
    if (!this.reader) return;

    const decoder = new TextDecoder();
    let fullResponse = '';

    try {
      while (true) {
        const { value, done } = await this.reader.read();
        if (done) break;

        let textChunk = decoder.decode(value);
        fullResponse += textChunk; // Append new data to the response

        this.response = fullResponse
          .replace(/(\w)\.(\s[A-Z])/g, '$1.\n$2') // Add newline after full stops (but not inside numbers)
          .replace(
            /(BleuIO|Firmware Version|Peripheral role|Central role|Not Connected|Not Advertising)/g,
            '\n$1'
          ); // New line before keywords
      }
    } catch (error) {
      console.error('Read error:', error);
    }
  }
}

Creating the UI

Modify src/app/app.component.html:

<div class="container text-center mt-5">
  <h1 class="mb-4 text-primary">
    Angular & TypeScript: Connect to BleuIO via Serial port
  </h1>

  <!-- Connect Button -->
  <button class="btn btn-primary mb-3" (click)="connectToBleuIO()">
    Connect to BleuIO
  </button>

  <div class="input-group mb-3 w-50 mx-auto">
    <input
      type="text"
      [(ngModel)]="command"
      class="form-control"
      placeholder="Enter AT Command"
    />
    <button class="btn btn-success" (click)="sendCommand()">
      Send Command
    </button>
  </div>

  <h3 class="mt-4">Response:</h3>

  <div
    class="border p-3 w-75 mx-auto bg-light rounded shadow-sm"
    style="white-space: pre-line"
  >
    {{ response }}
  </div>
</div>

Update src/main.ts

Replace its contents with:

import { bootstrapApplication } from '@angular/platform-browser';
import { AppComponent } from './app/app.component';
import { importProvidersFrom } from '@angular/core';
import { FormsModule } from '@angular/forms';

bootstrapApplication(AppComponent, {
  providers: [importProvidersFrom(FormsModule)],
}).catch((err) => console.error(err));

Running the Project

Start the Angular app:

ng serve

Open Google Chrome and go to http://localhost:4200/.
Test by clicking “Connect to BleuIO”, entering an AT command, and clicking “Send Command”.

Complete Source Code

Find the full source code on GitHub:
🔗 GitHub Repository

Output

Use Cases: Why This is Helpful

• This tutorial is beneficial for developers who:
• Want a simple, browser-based way to communicate with BleuIO.
• Need a cross-platform solution that works on Windows, macOS, and Linux.
• Are building IoT applications that require BLE communication.
• Want to use Angular & TypeScript for a scalable frontend solution.

This tutorial demonstrates how to use Angular 19, TypeScript, and the Web Serial API to communicate with BleuIO. The project is lightweight, scalable, and works entirely in the browser—perfect for IoT applications!

This project showcases how to integrate the Renesas EK-RA4M2 microcontroller with a BleuIO BLE USB dongle to create a smart air ventilation system. By using HibouAir‘s CO2 parameter, an air quality monitoring device, the system continuously monitors indoor air quality and automatically controls a fan based on CO2 levels.

The BleuIO dongle scans for HibouAir’s BLE advertising data to retrieve real-time CO2 readings. When the CO2 concentration exceeds 600 ppm, the system activates the fan to improve air circulation. Once the CO2 level drops below 550 ppm, the fan is turned off to conserve energy.

This implementation demonstrates a practical IoT-based air quality control solution, making indoor environments healthier and more efficient.

The EK-RA4M2 board prints the CO2 values, as they change, on the RTTViewer.

Requirements

• EK-RA4M2
• BleuIO – Bluetooth Low Energy USB Dongle
• FSP Platform Installer (Includes e² studio IDE, toolchain, and FSP packs)
• J-Link RTT Viewer
• USB OTG Cable (USB-A, USB-B micro)
• A fan
• A Power adapter
• HibouAir air quality monitor with CO2.
• Our example project [Download from GitHub]

Setup

• Connect a Micro USB device cable (type-A male to micro-B male) between J10 (Debug1) and a Computer USB port.
• Plug in a BleuIO Dongle in the USB OTG Cable (type-A female to micro-B male) and connect it to J11 (USB Full Speed).
• Make sure Jumper J12 is placed on pins 1-2
• Remove Jumper J15 pins
• Connect the fan power adapter to 3V3 and GND on the developer kit like this:

• The fan power adapter will also need to be connected to GPIO pin 505 on the developer kit to turn it on and off:

Importing project

• Open e² studio IDE
• Choose a workspace and click ‘Launch’
• Download or clone the example project. Place the folder ‘bleuio_ra4m2_fan_example’ in workspace.
• Choose Import Project
• Select ‘Existing Projects into Workspace’ under the ‘General’ tab:

• Click the ‘Browse…’ button and open the folder where the ‘bleuio_ra4m2_fan_example’ project folder is located:

• Finally select the project and click ‘Finish’. You have now imported the the project!

Running the example

• Go to file ‘usb_hcdc_app.c’ under ‘src/’ and edit line 41 to the board ID of the HibouAir Sensor:

• #define BOARD_ID_TO_SCAN “2202B3”
• The board ID is printed on the back of the HibouAir sensor:

• You can also threshold values to change when the fan should start and stop.
  
  The defines can be found on row 45 and 47 in ‘usb_hcdc_app.c’ under ‘src/’:
• /* CO2 threshold value 1. If at this value or above, the fan will start. */
  #define CO2_FAN_ROOF 600
  /* CO2 threshold value 2. If at this value or below, the fan will stop. */
  #define CO2_FAN_FLOOR 550

Build the project by clicking the building icon:

• Use Debug to download and run the project. The first time you need to configure the debug settings. Click down arrow to the right of the Debug icon and select ‘Debug Configurations…’

Under ‘Renesas GDB Hardware Debugging’ select ‘bleuio_ra4m2_fan_example.elf’ and click ‘Debug’

• The debug is now configured and the ‘Debug’ icon can be used next time to run the project.
• Open RTTViewer. Connect and use these settings:
  
  Connection to J-Link: USB
  
  Specify Target Device: R7FA4M2AD
  
  Target Interface & Speed: SWD 4000kHz
  
  RTT Control Block: Address 0x2000095c

On the debugger screen in e² studio click the ‘Resume’ icon twice to run the project.

• The application is now running. When starting up you should notice all LEDs lighting up for one second then only the red LED will be on. It will turn off as soon as the BleuIO is configured.
• You should now see the output on the RTTViewer. 

If CO2 value is 600ppm or above, the fan will turn on.

If CO2 value is 550ppm or below, the fan will turn off.


The LEDs will light up like the previous CO2 Monitor Example:

When the CO2 level is less than 600 ppm only the blue LED will be turned on.

If the CO2 level is over 600 ppm but below 1000 ppm then the green LED will be on.

If the CO2 level is above 1000 ppm then the red LED will be on.

Bluetooth Low Energy (BLE) provides a powerful mechanism to enhance security through proximity-based authentication. This tutorial showcases how to create a secure login system using Node.js, Express, and BLE technology. The project demonstrates how BLE scanning can verify the presence of an authorized BLE device (such as Close Beacon) in range before granting access. This offers an extra layer of protection for your applications.

Why This Project?

With the increasing need for secure authentication mechanisms, BLE (Bluetooth Low Energy) offers a lightweight, reliable, and energy-efficient solution. This project demonstrates how you can utilize a BleuIO USB dongle to securely check the proximity of a specific Close Beacon’s mac address before granting access to sensitive resources.

Key Features:

• Node.js Integration: Simplifies server-side logic using JavaScript.
• BLE Device Scanning: Checks for the presence of an authorized device based on its MAC address.
• Flexible Hardware Support: While this project uses Close Beacon, any BLE device can be used for authentication.
• Enhanced Security: Adds an additional layer of security to the login process.
• Practical Example: Serves as a foundation for more advanced BLE-based applications.

Practical Use Cases

• Extra Security Layer: Combine BLE proximity detection with traditional authentication methods for added security.
• Access Control Systems: Enable access to sensitive areas only when an authorized device is nearby.
• BLE-Powered IoT Applications: Use BleuIO for real-time device monitoring and communication.

Project Overview

This project uses:

• Node.js for server-side scripting.
• Express for handling routes and server logic.
• BleuIO USB Dongle for BLE scanning.
• A BLE Device (e.g., Close Beacon): Ensure the device is powered on and within range.
• Bootstrap for a simple and clean UI.

When the user clicks the “Login Securely” button, the application:

• Connects to the BleuIO dongle via a serial port (tested on macOS; Windows code is commented in the source).
• Puts the dongle into central mode with the AT+CENTRAL command.
• Sets an RSSI filter (AT+FRSSI=-56) to filter out weak signals.
• Initiates a BLE scan for nearby devices (AT+GAPSCAN=3).
• Checks if a target device with a specific MAC address is present in the scan results.
• Logs the user into the dashboard if the device is nearby; otherwise, it denies access.

Setting Up the Project

Prerequisites

1. BleuIO Dongle: Ensure the BleuIO dongle is plugged into your computer.
2. Node.js: Install Node.js from nodejs.org.
3. Dependencies: Install express and serialport using npm:
   npm install express serialport

How It Works

Step 1: Frontend (HTML and JavaScript)

The index page displays a button, “Login to dashboard securely.” When clicked, it sends a request to the server to scan for BLE devices.

index.html:

<!-- index.html -->
<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <link
      href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/css/bootstrap.min.css"
      rel="stylesheet"
      integrity="sha384-QWTKZyjpPEjISv5WaRU9OFeRpok6YctnYmDr5pNlyT2bRjXh0JMhjY6hW+ALEwIH"
      crossorigin="anonymous"
    />

    <title>Login Securely</title>
  </head>
  <body>
    <div class="container text-center mt-5">
      <br />
      <div class="row">
        <div class="col-md-6 offset-md-3">
          <p class="lead">
            This login checks if an authorized BLE device is nearby. The
            <strong>BleuIO</strong>
            dongle scans for the authorized device's MAC address. If it is
            nearby, the system will log you into the dashboard.
          </p>
        </div>
      </div>

      <br />
      <button class="btn btn-success btn-lg" id="scanBtn">
        Login to dashboard securely
      </button>
      <div id="listScan"></div>
    </div>

    <script>
      document.getElementById('scanBtn').addEventListener('click', () => {
        fetch('/scanbledevice')
          .then((response) => response.json())
          .then((data) => {
            // Log the response for debugging
            console.log(data.message);

            // Redirect to /dashboard if the device is nearby
            if (data.success) {
              window.location.href = '/dashboard';
            } else {
              alert(data.message); // Show a message if the device is not nearby
            }
          })
          .catch((err) => {
            console.error('Error:', err);
            alert('An error occurred while scanning for devices.');
          });
      });
    </script>
  </body>
</html>

dashboard.html

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <link
      href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/css/bootstrap.min.css"
      rel="stylesheet"
      integrity="sha384-QWTKZyjpPEjISv5WaRU9OFeRpok6YctnYmDr5pNlyT2bRjXh0JMhjY6hW+ALEwIH"
      crossorigin="anonymous"
    />
    <title>Dashboard</title>
  </head>
  <body>
    <div class="container">
      <h3 class="mt-5">Welcome to Smart Dashboard</h3>
      <br /><br />
      <a href="/" class="btn btn-danger btn-lg" id="logoutBtn">Logout</a>
    </div>
    <script>
      document
        .getElementById('logoutBtn')
        .addEventListener('click', (event) => {
          event.preventDefault(); // Prevent default navigation
          fetch('/disconnect')
            .then((response) => response.json())
            .then((data) => {
              if (data.success) {
                console.log(data.message);
                window.location.href = '/'; // Redirect to the index page
              } else {
                alert('Failed to disconnect: ' + data.message);
              }
            })
            .catch((err) => {
              console.error('Error during disconnect:', err);
              alert('An error occurred during logout.');
            });
        });
    </script>
  </body>
</html>

Step 2: Backend Logic

The server handles requests to scan for BLE devices, manage the serial port connection, and redirect users to the dashboard.

server.js:

// server.js
const express = require('express');
const { scanBLE, disconnectBLE } = require('./script');

const app = express();
const port = 3000;

// Serve the HTML file
app.get('/', (req, res) => {
  res.sendFile(__dirname + '/index.html');
});
app.get('/dashboard', (req, res) => {
  res.sendFile(__dirname + '/dashboard.html');
});
app.get('/disconnect', (req, res) => {
  disconnectBLE()
    .then((message) => {
      res.json({ success: true, message });
    })
    .catch((err) => {
      console.error('Error during disconnect:', err);
      res
        .status(500)
        .json({ success: false, message: 'Failed to disconnect serial port' });
    });
});

// Endpoint to fetch the list of serial ports
app.get('/scanbledevice', (req, res) => {
  scanBLE()
    .then((bleDevice) => {
      const targetMacAddress = '[1]D1:79:29:DB:CB:CC';

      // Check if the target device is nearby
      const isNearby = bleDevice.some((line) =>
        line.includes(targetMacAddress)
      );

      // Respond with a message
      if (isNearby) {
        res.json({
          success: true,
          message: `Device ${targetMacAddress} is nearby.`,
        });
      } else {
        res.json({
          success: false,
          message: `Login Failed ! Device ${targetMacAddress} is not nearby.`,
        });
      }
    })
    .catch((err) => {
      console.error('Error during BLE scan:', err);
      res
        .status(500)
        .json({ success: false, message: 'Error fetching BLE devices.' });
    });
});

// Start the server
app.listen(port, () => {
  console.log(`Server is running on http://localhost:${port}`);
});

Step 3: BLE Scanning Logic

The script connects to the BleuIO dongle, configures it, and scans for nearby devices.

script.js:

// script.js
const { SerialPort } = require('serialport');
var firstPort = '';
var readDataArray = [];
var openPort;
// Function to fetch the ble device list
function scanBLE() {
  return new Promise((resolve, reject) => {
    SerialPort.list()
      .then((ports) => {
        //filter ports to get BleuIO path
        // windows
        /* result = ports.filter(
            (portVal) =>
              portVal.pnpId && portVal.pnpId.includes("VID_2DCF&PID_6002")
          ); */
        //Mac
        result = ports.filter(
          (portVal) =>
            portVal.manufacturer &&
            portVal.manufacturer.includes('Smart Sensor Devices')
        );
        // get the first port path of the BleuIO connected to computer
        firstPort = result[0] && result[0].path;
        openPort = new SerialPort({ path: firstPort, baudRate: 115200 });
        // function to read serial port data
        const readData = (dm) => {
          return new Promise((resolve, reject) => {
            openPort.on('readable', () => {
              let data = openPort.read();
              let enc = new TextDecoder();
              let arr = new Uint8Array(data);
              let rawString = enc.decode(arr);

              // Split response into lines and trim extra spaces or empty lines
              let lines = rawString
                .split(/[\r\n]+/)
                .filter((line) => line.trim() !== '');
              readDataArray.push(...lines);

              // Log each line for better readability
              lines.forEach((line) => console.log(line));

              if (rawString.includes(dm)) {
                return resolve(readDataArray);
              } else {
                return resolve(readDataArray);
              }
            });
          });
        };

        // put the dongle to central role
        openPort.write('AT+CENTRAL\r', (err) => {
          if (err) {
            return reject(
              new Error('Error setting dongle to central role ' + err.message)
            );
          } else {
            // Set the RSSI filter
            openPort.write('AT+FRSSI=-56\r', (err) => {
              if (err) {
                return reject(
                  new Error('Error setting RSSI filter ' + err.message)
                );
              } else {
                // Scan for BLE devices for three seconds
                openPort.write('AT+GAPSCAN=3\r', (err) => {
                  if (err) {
                    return reject(
                      new Error('Error initiating BLE scan ' + err.message)
                    );
                  } else {
                    setTimeout(() => {
                      resolve(readData('SCAN COMPLETE'));
                    }, 3500);
                  }
                });
              }
            });
          }
        });
      })
      .catch((err) => {
        console.error('Error listing serial ports:', err);
        reject(err);
      });
  });
}
function disconnectBLE() {
  return new Promise((resolve, reject) => {
    if (openPort && openPort.isOpen) {
      openPort.close((err) => {
        if (err) {
          console.error('Error closing serial port:', err);
          return reject(err);
        }
        console.log('Serial port disconnected.');
        resolve('Disconnected');
      });
    } else {
      console.log('No serial port to disconnect.');
      resolve('No port to disconnect');
    }
  });
}

module.exports = { scanBLE, disconnectBLE };

Full source code is available at github. Source code

Output

This project is an example of how to integrate BleuIO with Node.js to build a BLE-powered secure login system. The source code is available and can be adapted for your use case. Start experimenting with BleuIO today and unlock the potential of BLE in your applications!

Awareness of Air quality monitoring importance for health and productivity has been increasing lately, especially in indoor environments like offices and homes. In this tutorial, we’ll demonstrate how to create a real-time CO₂ monitoring application using Go, a modern programming language with a vibrant community, alongside the BleuIO BLE USB dongle and HibouAir, a BLE-enabled air quality sensor.

This project showcases how to use Go’s simplicity and performance to build an efficient application that scans for CO₂ data, decodes it, and provides real-time notifications on macOS when the CO₂ level exceeds a critical threshold. By using BleuIO’s integrated AT commands, you can focus on your application logic without worrying about complex embedded BLE programming.

Project Overview

The goal of this project is to:

1. Use BleuIO to scan for BLE advertisements from HibouAir, which broadcasts real-time CO₂ levels.
2. Decode the advertised data to extract CO₂ concentration.
3. Send a real-time macOS notification when CO₂ levels exceed a specified threshold (1000 ppm in this example).

Notifications are implemented using the macOS osascript utility, ensuring you are immediately alerted about high CO₂ levels on your laptop screen.

Why This Project Is Useful

When you’re focused on work, you might not notice subtle changes in your environment. This application ensures you’re notified directly on your laptop screen when CO₂ levels become unsafe. This is especially helpful for:

• Office Workers: Monitor meeting rooms or shared spaces where ventilation may be insufficient.
• Remote Workers: Ensure a healthy workspace at home without distractions.
• Educational Settings: Keep classrooms or labs safe for students and staff.

Technical Details

Tools and Devices

• Programming Language: Go – Chosen for its simplicity, performance, and active community.
• BLE USB Dongle: BleuIO – Simplifies BLE communication with built-in AT commands.
• CO₂ Monitoring Device: HibouAir – Provides real-time air quality metrics over BLE.

How It Works

1. Initialize the Dongle:
   • Set the BleuIO dongle to the central role to enable scanning for BLE devices.
2. Scan for Advertised Data:
   • Use the AT+FINDSCANDATA command to scan for HibouAir’s advertisements containing air quality data.
3. Decode CO₂ Information:
   • Extract and convert the relevant part of the advertisement to get the CO₂ level in ppm.
4. Send Notifications:
   • Use Go’s exec.Command to invoke macOS osascript and display a desktop notification if the CO₂ level exceeds the threshold.

Implementation

Here is the source code for the project:

package main

import (
	"bufio"
	"fmt"
	"log"
	"os/exec"
	"strconv"
	"strings"
	"time"

	"go.bug.st/serial"
)

func main() {
	// Open the serial port
	mode := &serial.Mode{
		BaudRate: 9600,
	}
	port, err := serial.Open("/dev/cu.usbmodem4048FDE52CF21", mode)
	if err != nil {
		log.Fatalf("Failed to open port: %v", err)
	}
	defer port.Close()

	// Initial setup: Set the dongle to central mode
	err = setupDongle(port)
	if err != nil {
		log.Fatalf("Failed to set up dongle: %v", err)
	}

	// Repeatedly scan for advertised data and process it
	for {
		err := scanAndProcessData(port)
		if err != nil {
			log.Printf("Error during scan and process: %v", err)
		}
		time.Sleep(10 * time.Second) // Wait before the next scan (interval)
	}
}

// setupDongle sets the dongle to central mode
func setupDongle(port serial.Port) error {
	_, err := port.Write([]byte("AT+CENTRAL\r"))
	if err != nil {
		return fmt.Errorf("failed to write AT+CENTRAL: %w", err)
	}
	time.Sleep(1 * time.Second) // Ensure the command is processed

	buf := make([]byte, 100)
	_, err = port.Read(buf)
	if err != nil {
		return fmt.Errorf("failed to read response from AT+CENTRAL: %w", err)
	}

	fmt.Println("Dongle set to central mode.")
	return nil
}

// scanAndProcessData scans for advertised data and processes it
func scanAndProcessData(port serial.Port) error {
	_, err := port.Write([]byte("AT+FINDSCANDATA=220069=2\r"))
	if err != nil {
		return fmt.Errorf("failed to write AT+FINDSCANDATA: %w", err)
	}

	time.Sleep(3 * time.Second) // Wait for scan to complete

	buf := make([]byte, 1000)
	n, err := port.Read(buf)
	if err != nil {
		return fmt.Errorf("failed to read scan response: %w", err)
	}

	response := string(buf[:n])

	// Extract the first advertised data
	firstAdvertisedData := extractFirstAdvertisedData(response)
	if firstAdvertisedData == "" {
		fmt.Println("No advertised data found.")
		return nil
	}

	// Extract the specific part (6th from last to 3rd from last) and convert to decimal
	if len(firstAdvertisedData) >= 6 {
		extractedHex := firstAdvertisedData[len(firstAdvertisedData)-6 : len(firstAdvertisedData)-2]

		decimalValue, err := strconv.ParseInt(extractedHex, 16, 64)
		if err != nil {
			return fmt.Errorf("failed to convert hex to decimal: %w", err)
		}
		fmt.Printf("CO₂ Value: %d ppm\n", decimalValue)

		// Send notification if CO₂ value exceeds 1000
		if decimalValue > 1000 {
			sendNotification("CO₂ Alert", fmt.Sprintf("High CO₂ level detected: %d ppm", decimalValue))
		}
	} else {
		fmt.Println("Advertised data is too short to extract the desired part.")
	}
	return nil
}

// extractFirstAdvertisedData extracts the first advertised data from the response
func extractFirstAdvertisedData(response string) string {
	scanner := bufio.NewScanner(strings.NewReader(response))
	for scanner.Scan() {
		line := scanner.Text()
		if strings.Contains(line, "Device Data [ADV]:") {
			parts := strings.Split(line, ": ")
			if len(parts) > 1 {
				return parts[1]
			}
		}
	}
	if err := scanner.Err(); err != nil {
		log.Printf("Error scanning response: %v", err)
	}
	return ""
}

// sendNotification sends a macOS notification with the specified title and message
func sendNotification(title, message string) {
	script := `display notification "` + message + `" with title "` + title + `"`
	cmd := exec.Command("osascript", "-e", script)
	err := cmd.Run()
	if err != nil {
		log.Printf("Error sending notification: %v", err)
	}
}

Source code

Source code is available on https://github.com/smart-sensor-devices-ab/monitor-realtime-co2-go

Output

This project demonstrates how to build a real-time CO₂ monitoring application using Go, BleuIO, and HibouAir. By using Go’s capabilities and BleuIO’s ease of use, you can focus on the logic of your application and quickly adapt the solution to your specific needs.

In this tutorial, we will guide you through creating a BLE real-time macOS menu bar application using the BleuIO USB BLE dongle. BleuIO is an incredibly versatile tool that simplifies the development of BLE (Bluetooth Low Energy) applications, making it ideal for developers looking to build innovative projects with ease.

macOS menu bar applications offer a seamless way to monitor and interact with data in real time without requiring a dedicated application window. By leveraging the power of the BleuIO dongle, we can create a menu bar app that provides live updates on environmental metrics like temperature, humidity, and CO2 levels. This project demonstrates how BleuIO can be integrated into real-time applications, showcasing its potential for BLE-based projects.

Why is This Project Useful?

• Real-Time Updates: The app fetches BLE data at regular intervals and updates the macOS menu bar dynamically.
• Ease of Access: The macOS menu bar provides a non-intrusive interface, allowing users to access live data at a glance.
• Extensibility: This tutorial serves as a starting point for developers to explore more advanced BLE applications with BleuIO.

Requirements

To complete this project, you will need:

1. BleuIO USB BLE Dongle: A powerful and easy-to-use BLE dongle for developing BLE applications.
2. HibouAir – Air Quality Monitor: A BLE-enabled air quality monitor that broadcasts real-time environmental data such as temperature,pressure,voc,light, humidity, and CO2 levels.
3. macOS System: A macOS device with Python 3 installed.
4. Python Libraries:
   • rumps: For creating macOS menu bar applications.
   • bleuio: For communicating with the BleuIO dongle.

How Real-Time Updates Are Handled

The app connects to the BleuIO dongle and scans for BLE advertisements air quality data from HibouAir. Using a timer, the app periodically initiates a scan every 2 minutes. The decoded data is then displayed directly in the macOS menu bar, providing real-time updates without user intervention.

Step-by-Step Guide

Step 1: Set Up the Environment

1. Ensure you have a macOS system with Python 3 installed.
2. Install the necessary dependencies using pip:
   pip install rumps bleuio
3. Plug in your BleuIO USB dongle.

Step 2: Project Overview

Our goal is to:

• Connect to the BleuIO dongle.
• Put the dongle in Central Mode to scan for BLE advertisements.
• Scan for real time air quality data from HibouAir
• Decode the advertisement data to extract temperature, humidity, pressure, and CO2 levels.
• Update the macOS menu bar with the decoded data in real time.

Step 3: Writing the Code

Below is the Python script for the macOS menu bar app. This code handles the dongle initialization, data scanning, decoding, and menu updates.

import rumps
import time
import json
from datetime import datetime
from bleuio_lib.bleuio_funcs import BleuIO
boardID="220069"

# Function to decode advertisement data
def adv_data_decode(adv):
    try:
        pos = adv.find("5B0705")
        if pos == -1:
            raise ValueError("Invalid advertisement data: '5B0705' not found.")

        dt = datetime.now()
        current_ts = dt.strftime("%Y/%m/%d %H:%M:%S")

        # Temperature decoding
        temp_hex = int(adv[pos + 22:pos + 26][::-1], 16)  # Reversed bytes
        if temp_hex > 1000:
            temp_hex = (temp_hex - (65535 + 1)) / 10
        else:
            temp_hex = temp_hex / 10

        # Pressure decoding (convert from little-endian)
        pressure_bytes = bytes.fromhex(adv[pos + 18:pos + 22])
        pressure = int.from_bytes(pressure_bytes, byteorder='little') / 10

        # Humidity decoding (convert from little-endian)
        humidity_bytes = bytes.fromhex(adv[pos + 26:pos + 30])
        humidity = int.from_bytes(humidity_bytes, byteorder='little') / 10

        return {
            "boardID": adv[pos + 8:pos + 14],
            "pressure": pressure,
            "temp": temp_hex,
            "hum": humidity,
            "co2": int(adv[pos + 46:pos + 50], 16),
            "ts": current_ts,
        }
    except Exception as e:
        print(f"Error decoding advertisement data: {e}")
        return {}


# Callback function for scan results
def my_scan_callback(scan_input):
    try:
        scan_result = json.loads(scan_input[0])
        data = scan_result.get("data", "")

        decoded_data = adv_data_decode(data)

        # Update menu with decoded data
        app.update_menu(decoded_data)

    except Exception as e:
        print(f"Error parsing scan result: {e}")

# Callback function for events
def my_evt_callback(evt_input):
    cbTime = datetime.now()
    currentTime = cbTime.strftime("%H:%M:%S")
    print(f"\n\n[{currentTime}] Event: {evt_input}")

class AirQualityApp(rumps.App):
    def __init__(self):
        super(AirQualityApp, self).__init__("CO2 : 550")
        self.my_dongle = None  # Placeholder for the dongle object
        self.co2_item = rumps.MenuItem(title="CO2 : 550ppm", callback=lambda _: None)
        self.temp_item = rumps.MenuItem(title="Temperature: 25°C", callback=lambda _: None)
        self.hum_item = rumps.MenuItem(title="Humidity: 65 %rh", callback=lambda _: None)
        self.press_item = rumps.MenuItem(title="Pressure: 1000 mbar", callback=lambda _: None)

        self.menu = [
            self.co2_item,
            self.temp_item,
            self.hum_item,
            self.press_item,
            None  # Separator
        ]

        # Establish connection and start scanning on startup
        self.connect_dongle()
        self.start_periodic_scan()

    def connect_dongle(self):
        try:
            self.my_dongle = BleuIO()  # Initialize the dongle
            self.my_dongle.register_evt_cb(my_evt_callback)  # Register event callback
            self.my_dongle.register_scan_cb(my_scan_callback)  # Register scan callback
            print("Dongle connected successfully.")

            # Set the dongle to central mode
            response = self.my_dongle.at_central()
            print("Dongle is now in central mode.")

        except Exception as e:
            print(f"Error connecting to dongle: {e}")

    def scan(self, _=None):  # Added `_` to accept the timer argument
        try:
            # Start scanning for specific data
            response = self.my_dongle.at_findscandata(boardID, 3)
            print(f"Scan initiated. Response: {response.Rsp}")
        except Exception as e:
            print(f"Error during scan: {e}")

    def start_periodic_scan(self):
        try:
            rumps.timer(120)(self.scan)  # Run the scan method every 30 seconds
        except Exception as e:
            print(f"Error setting up periodic scan: {e}")

    def update_menu(self, decoded_data):
        try:
            self.title = f"CO2 : {decoded_data.get('co2', 'N/A')}ppm"  # Update app title
            self.co2_item.title = f"CO2 : {decoded_data.get('co2', 'N/A')}ppm"
            self.temp_item.title = f"Temperature: {decoded_data.get('temp', 'N/A')}°C"
            self.hum_item.title = f"Humidity: {decoded_data.get('hum', 'N/A')} %rh"
            self.press_item.title = f"Pressure: {decoded_data.get('pressure', 'N/A')} mbar"
        except Exception as e:
            print(f"Error updating menu: {e}")

if __name__ == "__main__":
    app = AirQualityApp()
    app.run()

Note : Make sure to change the BoardID to your HibouAir CO2 device on line 6

Step 4: Run the App

1. Save the script as bleuio.py.
2. Run the script using:
   python bleuio.py
3. The app will appear in the macOS menu bar with latest CO2 value. Click the icon to view the live BLE data updates.

Output

Extending the Project

This project is a foundation for exploring the capabilities of BleuIO. You can extend it to:

• Monitor additional BLE devices.
• Implement alert notifications for specific data thresholds.
• Log the data to a file or send it to a cloud service for further analysis.

This tutorial demonstrates how to create a real-time macOS menu bar application using the BleuIO dongle. By following this guide, you’ll not only learn how to handle BLE data but also understand how to integrate it into user-friendly macOS applications. BleuIO opens up endless possibilities for BLE-based projects, and we’re excited to see what you create next!