Category: BleuIO

Home automation involves automating household environment equipment. To achieve that, we have created a smart bulb that can be controlled remotely using smart phone app. The aim of this project is to control different home appliances using smartphone at your home.

Introduction

This example is showing how to control a GPIO pin on a RaspberryPi remotely from a smart phone (or another BleuIO Dongle).

For this example we will need:

• A RaspberryPi
• A BleuIO Dongle (https://www.bleuio.com/)
• Our example python script (https://github.com/smart-sensor-devices-ab/bleuio_rpi_switch_example)
• A way to connect to the GPIO Pin (Like a 5V Relay and a Lightbulb)

WARNING – THIS PROJECT INVOLVES HIGH VOLTAGES THAT CAN CAUSE SERIOUS INJURY OR DEATH. PLEASE TAKE ALL NECESSARY PRECAUTIONS, AND TURN OFF ALL POWER TO A CIRCUIT BEFORE WORKING ON IT.

Connecting the relay

Beware:

Always be very careful when experimenting with AC, electrical shock can result in serious injuries! NOTICE OF RISK; DISCLAIMER OF LIABILITY

Instructions for bleuio_rpi_switch_example.py

• Connect the BleuIO Dongle to your RaspberryPi.
• Edit the variable ‘switch’ in the script to the GPIO pin you want to use. (You can use the command pinout to get a graphical view showing you the GPIO pins for the board)

• Finally just run python script and and use your phone to connect to the BleuIO Dongle and send on/off messages to controll the GPIO!

Instructions for connecting to the BleuIO from mobile

• Download a BLE scanning App that can connect and read/write to a device. (Like nRFConnect or BLEScanner)
  Android, IOS

• Look for the dongle, it will be advertising as ‘BleuIO’.

• Connect to the BleuIO Dongle.

• To enable BleuIO to recieve commands you must first write 0x01 to the Flow Control characteristic (UUID: 0783b03e-8535-b5a0-7140-a304d2495cb9)

• Now you can write to the Server RX Data characteristic (UUID: 0783b03e-8535-b5a0-7140-a304d2495cba) to control the GPIO.
  |CMD|Effect|
  |–|–|
  |“SW=1”| ON|
  |“SW=0”| OFF|

The script

Here is the python script that receives the messages from smart phone app and helps control the light.

#!/usr/bin/python3
# Copyright 2022 Smart Sensor Devices in Sweden AB
#
# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"),
# to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
# and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

import time
import serial.tools.list_ports
import serial
import RPi.GPIO as io


switch = 7  # Edit this to suit your setup! (7 = GPIO 04), use command pinout to graphically show you the GPIO pins for the board
io.setmode(io.BOARD)
io.setup(switch, io.OUT)

master_array = []
index = 1
dongle_port = ""

print("\nWelcome to BleuIO RaspberryPi Switch Example!\n")

print("\nPlease insert dongle...")
try:
    while len(master_array) == 0:
        m_ports = serial.tools.list_ports.comports(include_links=False)
        for port in m_ports:
            if str(port.hwid).__contains__("VID:PID=2DCF"):
                master = port.device + " " + port.hwid
                if master.__contains__("VID:PID=2DCF:6002"):
                    print("Found dongle in port: %s" % port.device)
                    master_array.append(master)
                    dongle_port = port
                    break

    for dongle in master_array:
        print("\nConnecting to BleuIO @ %s\n" % dongle)

    time.sleep(0.5)
    dongle_conn = serial.Serial(
        dongle_port.device,
        115200,
        timeout=1,
    )

    if not dongle_conn.is_open:
        dongle_conn.open()

    print("Starting Advertising...")
    dongle_conn.write("AT+GAPDISCONNECTALL\rAT+DUAL\rAT+ADVSTART\rATI\r".encode())
    read_tries = 0
    dongle_resp = ""
    while read_tries < 20:
        dongle_resp = dongle_conn.readline().decode()
        if "Not Advertising" in dongle_resp:
            dongle_conn.write("AT+ADVSTART\r")
        if b"Advertising\r\n" in dongle_resp.encode():
            break
        read_tries += 1
        time.sleep(0.01)

    if dongle_resp:
        print("BleuIO is %s" % dongle_resp)
    else:
        print("ERROR! No response...")
        exit()

    print(
        "Going into loop, waiting for signal to turn switch on/off...\n(Press Ctrl+C to abort)"
    )
    while True:
        try:
            dongle_resp = dongle_conn.readline().decode()
            if "SW=0" in dongle_resp:
                print("Turn Switch off!")
                io.output(switch, io.LOW)
            if "SW=1" in dongle_resp:
                print("Turn Switch on!")
                io.output(switch, io.HIGH)
        except KeyboardInterrupt:
            if dongle_conn.is_open:
                dongle_conn.write("AT+GAPDISCONNECTALL\rAT+ADVSTOP\r".encode())
                dongle_conn.close()
                io.cleanup()
            print("\nBye!")
            exit()

except Exception as e:
    print("(ERROR: %s)" % (e))

Output

We have tested the script using nRFConnect app from both IOS and Android phone to turn on/off the light bulb. Here is the output of this project.

Introduction

Here we will describe two quick ways of measuring the data throughput of the BleuIO Dongle.
For both examples we are going to need a BleuIO Dongle, another Bluetooth device (like another Bleuio Dongle) and a computer with Python (minimum version: 3.6) installed.

For the first measurement example, measuring the BLE data throughput, you will need one of the following supported development kits from Nordic Semiconductor:

• nRF52840 DK (PCA10056)
• nRF52840 Dongle (PCA10059)
• nRF52833 DK (PCA10100)
• nRF52 DK (PCA10040)
• nRF51 DK (PCA10028)
• nRF51 Dongle (PCA10031)

The first measurement example is the actual BLE data throughput. For this we will use a BleuIO Dongle and Wireshark. (For help on how to setup Wireshark and requirements go to this link: https://infocenter.nordicsemi.com/topic/ug_sniffer_ble/UG/sniffer_ble/intro.html ).
We will also utilize a simple python script that sends a set amount of data. For this measurement you can ignore the throughput print at the end of the script.

The second measurement example is for measuring the actual data being transferred over the USB as a Virtual COM port (via the CDC protocol).
We will be using the same simple script that will send a set amount of data and time when the transfer starts and then stops. Then divide the amount of data with the time the transfer took to get the throughput.

Notice : Interference can be caused by other wireless networks, other 2.4 GHz frequency devices, and high voltage devices that generate electromagnetic interference. This have impact on the measurement of throughput. To avoid interference, select wireless free space or use a shield box.

Instructions for BLE data throughput

• For best result place the nRF Dev Kit between the BleuIO Dongle and your target device.
• Open Wireshark and double-click the ‘nRF Sniffer for Bluetooth LE’.

• Make sure the target Bluetooth device is advertising and find in the the scroll-down list.

• Choose ‘IO/Data’ under the ‘Analysis’ menu tab.

• Click the ‘+’ button to add new graphs. Add ‘bytes per seconds’ and/or ‘bit per seconds’.

• Modify the script by filling in the relevant information into the variables ‘your_com_port’, ‘target_mac_addr’ and ‘write_handle’.
• Run the python script.
• You can now observe the graph showing the BLE Data throughput!

Instructions for USB port data throughput

This is the second measurement example for measuring the actual point to point data transfer between the two USB ports.

• Connect the dongle to your computer. (Look up the COM port your dongle uses and paste it in the script in the variable ‘your_com_port’)
• Scan (Using AT+GAPSCAN) after the device you wish to send the data to. Copy the mac address of the device into the script in the variable ‘target_mac_addr’.
• Connect to the device and look up the handle of the characteristic you want to write to and paste into the script in the variable ‘write_handle’.
• Finally just run python script and the throughput will be displayed at the end!

The script

import datetime
import serial
import time
import string
import random

connecting_to_dongle = True
trying_to_connect = False

# Change this to the com port your dongle is connected to.
your_com_port = "COM20"
# Change this to the mac address of your target device.
target_mac_addr = "[0]40:48:FD:E5:2C:F2"
# Change this to the handle of the characteristic on your target device.
write_handle = "0011"

# You can experiment with the packet length, increasing or decreasing it and see how that effect the throughput
packet_length = 150
# 1 Megabytes = 1000000 Bytes
file_size = 0.5 * 1000000
end_when = file_size / packet_length
send_counter = 0

# Random data string generator
def random_data_generator(size=packet_length, chars=string.digits + string.digits):
    return "".join(random.choice(chars) for _ in range(size))


print("Connecting to dongle...")
while connecting_to_dongle:
    try:
        console = serial.Serial(
            port=your_com_port,
            baudrate=115200,
            parity="N",
            stopbits=1,
            bytesize=8,
            timeout=0,
        )
        if console.is_open.__bool__():
            connecting_to_dongle = False
    except:
        print("Dongle not connected. Please reconnect Dongle.")
        time.sleep(5)

print("Connected to Dongle.")
console.write(str.encode("AT+GAPDISCONNECT\r"))
start = input("Press Enter to start.\n\r>> ")

console.write(str.encode("ATE0\r"))
console.write(str.encode("AT+DUAL\r"))
connected = "0"
while connected == "0":
    time.sleep(0.5)
    if not trying_to_connect:
        # change to Mac address of the device you want to connect to
        console.write(str.encode("AT+GAPCONNECT=" + target_mac_addr + "\r"))
        trying_to_connect = True
    dongle_output2 = console.read(console.in_waiting)
    time.sleep(2)
    print("Trying to connect to Peripheral...")
    if not dongle_output2.isspace():
        if dongle_output2.decode().__contains__("\r\nCONNECTED."):
            connected = "1"
            print("Connected!")
            time.sleep(8)
        if dongle_output2.decode().__contains__("\r\nDISCONNECTED."):
            connected = "0"
            print("Disconnected!")
            trying_to_connect = False
        dongle_output2 = " "

start2 = input("Press Enter to sending.\n\r>> ")
start_time = time.mktime(datetime.datetime.today().timetuple())
console.write(
    str.encode(
        "AT+GATTCWRITEWRB=" + write_handle + " " + random_data_generator() + "\r"
    )
)
while 1:
    dongle_output = console.read(console.in_waiting)
    if send_counter > end_when:
        end_time = time.mktime(datetime.datetime.today().timetuple())
        break
    # Change to the handle of the characteristic you want to write to
    if "handle_evt_gattc_write_completed" in str(dongle_output):
        console.write(
            str.encode(
                "AT+GATTCWRITEWR=" + write_handle + " " + random_data_generator() + "\r"
            )
        )
        send_counter = send_counter + 1
    try:
        if not dongle_output.decode() == "":
            print(dongle_output.decode())
    except:
        print(dongle_output)

time_elapsed = end_time - start_time
time.sleep(0.1)

print("*" * 25)
print("Transfer Complete in: " + str(time_elapsed) + " seconds")
print(str(packet_length * send_counter) + "bytes sent.")
print("*" * 25)
print(
    "Throughput via USB (Virtual COM port): "
    + str((packet_length * send_counter) / time_elapsed)
    + " Bytes per seconds"
)
print("*" * 25)

We’re living in the world of connected devices. The internet of things helps us live and work smarter, as well as gain complete control over our lives. One of the latest technological advancements in IoT is the MQTT gateway, which acts as a mediator between the cloud and IoT platforms.

MQTT stands for Message Queuing Telemetry Transport. It’s among the key communication protocols for the internet of things devices and local networks. It’s an ideal protocol for communication between smart devices or machine-to-machine communication.

What Is MQTT Gateway?

Generally, the MQTT gateway can be defined as an intermediary between any internet of things platform and sensors. It works by getting data from these sensors or smart devices and translating it into MQTT. It then transmits that data to either the internet of things platform or to the MQTT broker.

The publish/subscribe pattern

The publish/subscribe pattern (also known as pub/sub) provides an alternative to a traditional client-server architecture. In the client-server model, a client communicates directly with an endpoint. The pub/sub model decouples the client that sends a message (the publisher) from the client or clients that receive the messages (the subscribers). The publishers and subscribers never contact each other directly. In fact, they are not even aware that the other exists. The connection between them is handled by a third component (the broker). The job of the broker is to filter all incoming messages and distribute them correctly to subscribers.

MQTT Broker

A broker helps in handling clients in MQTT technology. It can manage hundreds, thousands, or millions of connected MQTT clients at once, depending on the implementation. Its main functions are;

• Receiving information
• Decoding and filtering the messages received
• Determining which client will be interested in which message
• Transmitting these messages to clients depending on their interests

The project

Let’s make a simple BLE 2 MQTT project that collects sensor data from a BLE Air quality monitor device called HibouAir and sends it to a free public MQTT broker.

For this project, we will use Flespi. You can choose any public or private MQTT broker as you like.

Steps

Requirments 

• A BleuIO dongle.
• A air quality monitor device HibouAir.
• A public MQTT broker (Flepsi token) https://flespi.com/mqtt-broker
• BleuIO Javascript library. https://www.npmjs.com/package/bleuio
• A build tool for Javascript (parcel) https://parceljs.org/docs/

Get the Flespi token

• Create an account at Flespi.
• Log into the Flespi dashboard.
• Copy the token

Download source file

Get the source file from https://github.com/smart-sensor-devices-ab/ble2mqtt_bleuio.git

And run npm install

In the root folder, we will see two Html files called index.html and subscribe.html and two js files called pub.js and sub.js

Index.html file collects sensor data from a BLE Air quality monitor device called HibouAir with the help of BleuIO. It has three buttons. connect, device info and Scan and Send BLE Data.

First we need to connect a BleuIO dongle into the computer and connect to it using connect button. The device info button will show BleuIO dongle status on console log. And the Scan and Send BLE data will scan for Air quality data and send it to the cloud. For this script I am scanning and collecting a fixed device with the board id of 0578E0. You can change the value in pub.js file line number 4

Here is the index.html file

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <link
      href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/css/bootstrap.min.css"
      rel="stylesheet"
      integrity="sha384-1BmE4kWBq78iYhFldvKuhfTAU6auU8tT94WrHftjDbrCEXSU1oBoqyl2QvZ6jIW3"
      crossorigin="anonymous"
    />
    <title>Publish</title>
  </head>
  <body>
    <div class="container mt-5">
      <button id="connect" class="btn btn-secondary">Connect</button>
      <button id="deviceinfo" class="btn btn-success d-none">
        Device Info
      </button>
      <button id="sendData" class="btn btn-primary">
        Scan and Send BLE Data
      </button>

      <h3 class="mt-5">Message Sent</h3>
      <div id="output"></div>
    </div>
  </body>
  <script src="./pub.js"></script>
</html>

After collecting advertised data, we try to decode it and get meaningful air quality data with co2, pressure, temperature, humidity, light values. Then we publish the data to Flepsi broker using topic name HibouAirTopic

The process is done in pub.js file.

Here is the pub.js file

const clientId = 'hibouair_' + Math.random().toString(16).substr(2, 8)
import * as my_dongle from 'bleuio'
import 'regenerator-runtime/runtime'
const sensorID = '0578E0'
import * as mqtt from "mqtt" 
document.getElementById('connect').addEventListener('click', function(){
  my_dongle.at_connect()
})
document.getElementById('deviceinfo').addEventListener('click', function(){
  my_dongle.ati().then((data)=>console.log(data))
})

const getTheBLEData = ( async()=>{
  return my_dongle.at_dual().then(()=>{
    return my_dongle.at_findscandata(sensorID,6).then((x)=>{
      let advData = x[x.length - 1].split(" ").pop()
      let positionOfID= advData.indexOf(sensorID);
      let tempHex = advData.substring(positionOfID+14, positionOfID+18)
      let temp = parseInt('0x'+tempHex.match(/../g).reverse().join(''))/10;

      let pressHex = advData.substring(positionOfID+10, positionOfID+14)
      let press = parseInt('0x'+pressHex.match(/../g).reverse().join(''))/10;

      let humHex = advData.substring(positionOfID+18, positionOfID+22)
      let hum = parseInt('0x'+humHex.match(/../g).reverse().join(''))/10;

      let lightHex = advData.substring(positionOfID+6, positionOfID+10)
      let light = parseInt('0x'+lightHex.match(/../g).reverse().join(''));

      let co2Hex = advData.substring(positionOfID+38, positionOfID+42)
      let co2 = parseInt('0x'+co2Hex);
      

      return {
        'CO2' :co2,
        'Temp' :temp,
        'Pressure':press,
        'Humidity':hum,        
        'Light':light,        
      }
    })
  })
})



//pass data
document.getElementById('sendData').addEventListener('click', function(){
    const host = 'wss://mqtt.flespi.io:443'

    const options = {
      keepalive: 60,
      clientId: clientId,
      protocolId: 'MQTT',
      username:'SET_YOUR_USERNAME',
      password:'SET_YOUR_PASSWORD',
      protocolVersion: 4,
      clean: true,
      reconnectPeriod: 1000,
      connectTimeout: 30 * 1000,
      will: {
        topic: 'HibouAirMsg',
        payload: 'Connection Closed abnormally..!',
        qos: 0,
        retain: false
      },
    }
    const client  = mqtt.connect(host, options)
    client.on('connect',()=>{
        console.log('connected mqtt client',clientId)

    })

    client.on('error', (err) => {
      console.log('Connection error: ', err)
      client.end()
    })

    client.on('reconnect', () => {
      console.log('Reconnecting...')
    })

    var topic = 'HibouAirTopic'

    // Publish
    setInterval(() => {

        getTheBLEData().then((x)=>{
          client.publish(topic, JSON.stringify(x), { qos: 0, retain: false })
        console.log("Message sent!", JSON.stringify(x));
        document.getElementById('output').innerHTML += JSON.stringify(x)+"<br>";
        })
      }, 5000);

    })

Make sure to set your username and password and change the Board ID of your device on pub.js file.

Subscribe.html file works as a subscriber which reads sensor data from the broker and shows it on the screen.

here is the subscribe.html file

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Subscribe</title>
  </head>
  <body>
    <h3>Message Received</h3>
    <div id="output"></div>
  </body>
  <script src="https://unpkg.com/mqtt/dist/mqtt.min.js"></script>

  <script src="sub.js"></script>
</html>

Again we need a js script that fetch data from cloud and show it on html file. Here is the sub.js file

const clientId = 'hibouair_' + Math.random().toString(16).substr(2, 8)

//const host = 'ws://broker.emqx.io:8083/mqtt'
const host = 'wss://mqtt.flespi.io:443'

const options = {
  keepalive: 60,
  clientId: clientId,
  protocolId: 'MQTT',
  username:'YOUR_USERNAME',
  password:'YOUR_PASSWORD',
  protocolVersion: 4,
  clean: true,
  reconnectPeriod: 1000,
  connectTimeout: 30 * 1000,
  will: {
    topic: 'HibouAirMsg',
    payload: 'Connection Closed abnormally..!',
    qos: 0,
    retain: false
  },
}

const client = mqtt.connect(host, options)
client.on('connect',()=>{
  console.log('connected mqtt client',clientId)
  client.subscribe('HibouAirTopic', { qos: 0 })
})
client.on('error', (err) => {
  console.log('Connection error: ', err)
  client.end()
})

client.on('reconnect', () => {
  console.log('Reconnecting...')
})


  
  // Received
client.on('message', (topic, message, packet) => {
  console.log(JSON.parse(message))
  //console.log('Received Message: ' + message + '\nOn topic: ' + topic)
  document.getElementById('output').innerHTML += message.toString()+"<br>";

})

To run the index.html we can just type

parcel index.html

Parcel JS can be installed from https://parceljs.org/

Project Video

The project is showcasing a simple way of using the the BleuIO Dongle to advertise data that the STM32 reads from a sensor which is connected to the STM32 Nucleo-144.

Requirments :

• A BleuIO dongle (https://www.bleuio.com/)
• A SHT85 sensor (https://sensirion.com/products/catalog/SHT85/)
• A board with a STM32 Microcontroller with a USB port. (A Nucleo-144 development board: NUCLEO-H743ZI2, was used developing this example. (https://www.st.com/en/evaluation-tools/nucleo-h743zi.html)
• To connect the dongle to the Nucleo board we used a “USB A to Micro USB B”-cable with a USB A female-to-female adapter.)
• STM32CubeIDE (https://www.st.com/en/development-tools/stm32cubeide.html)

When the BleuIO Dongle is connected to the Nucleo boards USB port, the STM32 will recognize it and start advertising the sensor values that it reads from the SHT85 along with the sensor serial number. It will update these values every 10 seconds.

Setup the project

Part 1 : Download the project

Get project HERE

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

Either clone the project, or download it as a zip file and unzip it, into your STM32CubeIDE workspace.

Part 2 : Importing as an Existing Project

From STM32CubeIDE choose File>Import…

Then choose General>Existing Projects into Workspace then click ‘Next >’

Make sure you’ve choosen your workspace in ‘Select root directory:’

You should see the project “stm32_bleuio_SHT85_example”, check it and click ‘Finish’.

If you download the project as a zip file you will need to rename the project folder from ‘stm32_bleuio_SHT85_example-master’ to ‘stm32_bleuio_SHT85_example’

Connect the SDA to PF0 on the Nucleo board and SCL to PF1.

Then setup I2C2 in the STM32Cube ioc file like this:

Running the example

In STMCubeIDE click the hammer icon to build the project.

• Open up the ‘STMicroelectronics STLink Viritual COM Port’ with a serial terminal emulation program like TeraTerm, Putty or CoolTerm.

Baudrate: 115200

Data Bits: 8

Parity: None

Stop Bits: 1

Flow Control: None

• In STMCubeIDE click the green play button to flash and run it on your board. The first time you click it the ‘Run Configuration’ window will appear. You can just leave it as is and click run.
• Connect the BleuIO Dongle.

Access sensor data from a web browser

We wrote a simple script that connects to the BleuIO dongle and reads advertised data from STM32.

For this script to work, we need

• BleuIO USB dongle connected to the computer.
• BleuIO javascript library
• Chrome 78 or later, and you need to enable the #enable-experimental-web-platform-features flag in chrome://flags
• A web bundler – (parcel js)

Steps

Create a simple Html file called index.html which will serve as the frontend of the script. This Html file contains some buttons that help connect and read advertised data from the remote dongle, which is connected to stm32.

<!DOCTYPE html>
<html lang="en">
  <head>
    <!-- Required meta tags -->
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1" />

    <!-- Bootstrap CSS -->
    <link
      href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/css/bootstrap.min.css"
      rel="stylesheet"
      integrity="sha384-1BmE4kWBq78iYhFldvKuhfTAU6auU8tT94WrHftjDbrCEXSU1oBoqyl2QvZ6jIW3"
      crossorigin="anonymous"
    />

    <title>STM32 Read sensor value</title>
  </head>
  <body>
    <div class="container mt-5">
      <h1>Sensor data collection from stm32 using Bluetooth Low Energy</h1>
      <button id="connect" class="btn btn-primary">Connect</button>
      <button id="getdata" class="btn btn-success">Get device data</button>
      <div id="loader"></div>
      <br />
      <div id="response" class="fw-bold"></div>

      <script src="./index.js"></script>
    </div>
  </body>
</html>

Create a js file called script.js and include it at the bottom of the Html file. This js file uses the BleuIO js library to write AT commands and communicate with the other dongle.

import * as my_dongle from 'bleuio'

//connect to BleuIO
document.getElementById('connect').addEventListener('click', function(){
  my_dongle.at_connect()
})
//get sensor data
document.getElementById('getdata').addEventListener('click', function(){
  document.getElementById('loader').innerHTML = 'Loading'
  //set the BleuIO dongle into dual role
    my_dongle.at_dual().then(()=>{
      // sensor id of the device that we are trying to get data from
      let sensorID='05084FA3'

      //look for advertised data of with the sensor id
        my_dongle.at_findscandata(sensorID,4).then(x=>{        

          //split the advertised data from the respnse
          let advdata= x[x.length-1].split(" ").pop()

          //trim the advertised string to only get sensor response
          const result = advdata.split(sensorID).slice(1).join(sensorID) 

          //get temperature and humidity value
          let temp = result.substring(0, 4);
          let hum = result.substring(4, 8);

          //convert from hex to decimal and device by 100
          temp = parseInt(temp, 16)/100
          hum = (parseInt(hum, 16)/100).toFixed(1)  

          document.getElementById('loader').innerHTML = ''
          document.getElementById('response').innerHTML = `Sensor ID : 05084FA3 <br/>
          Temperature : ${temp} °C<br/>
          Humidity : ${hum} %rH<br/>`              
        })
    })
    
  })

The script js file has two button actions; connect and read advertised data.

We also need to update the Sensor ID on line 13 of script js. The Sensor ID of this example project is 05084FA3, which we got from SHT85.

Therefore this script looks for advertised data that contains sensor ID 05084FA3. After getting advertised data , we split the temperature and humidity information and show it on our index.html page.

Now we need a web bundler. We can use parcel.js

Once parcel js installed, lets go to the root directory and type “parcel index.html”. This will start our development environment.

Lets open the script on a browser and select the right port where the dongle is connected.

The web script is available on web script folder of the GitHub repository.