Team Ubidots:

•

UbiMaker

Published March 25, 2023 © LGPL

BME688 + NavQPlus + Ubidots

Connects the BME688 sensor to the NavQPlus board and sends the data to Ubidots for display.

IntermediateWork in progress2 hours271

Things used in this project

Hardware components

Adafruit bme688

The BME688 is a sensor containing temperature, humidity, barometric pressure and VOC gas detection capabilities. It is specially developed for mobile and connected applications where size and low power consumption are critical requirements.

NXP NavQPlus

NavQPlus is an open source reference design provided by NXP® that anyone can build. It focuses on the common needs of mobile robotics systems. The board comes pre-installed with a version of Ubuntu LTS.

Software apps and online services

Ubidots

Industrial companies use Ubidots IoT software to launch beautiful web and mobile applications for Condition Monitoring, Smart Manufacturing, Cloud SCADAs, Vibration Analysis, and more.

Story

This tutorial will show you how to connect to the BME688 sensor and NavQPlus board, install and use the Python library and suggest some uses for it. We will review how to receive information from the sensor and send the data to Ubidots.

The NavQPlus board focuses on the common needs of mobile robotics systems. Robotic platforms such as the iRobot® Create® 3 have integrated this board into their systems and even competitions such as NXP HoverGames are increasingly driving its use. This board comes with a pre-installed version of Ubuntu, and is ROS2 compatible, which says it was very well prepared to support robotics development for machine learning, vision, computation, path planning, and low-power navigation among other applications. In addition to connection possibilities such as WiFi 5 / BTLE 5.0, it provides display interfaces such as HDMI, LVDS, MIPI DSI, for applications requiring the same (display and connectivity). For our case, we will use the NavQPlus board, to read incoming data from the i2c interface where our BME688 sensor will be connected and through the WiFi network connection, we will send these measurements to Ubidots, to visualize the information.

The BME688 sensor gives us all the environmental sensing we want in a small package. This small sensor contains temperature, humidity, barometric pressure and VOC gas detection capabilities. The use cases for this sensor are various and some of the typical applications are such as indoor and outdoor air quality measurement, detection of unusual gases and odors, which could indicate, for example, a leak or a fire, even in diaper condition detection, e.g. for baby care. And if we add to this target devices such as, home appliances, mobile devices, sensor networks / sensor nodes the applications become more interesting. For our case, our BME688 sensor will be in the work office and will take measurements of all these variables, in order to analyze the data in the future and make decisions based on this information.

The Ubidots platform is an IoT (Internet of Things) platform that enables decision making for systems integration companies globally. This product allows sending sensor data to the cloud, configuring dashboards and alerts, connecting with other platforms, using analytics tools and providing real-time data maps. All these tools save a lot of time and money, enabling better data-driven decisions. For our case, creating a dashboard to visualize the information is a good option, in fact we will leave an example of a dashboard for inspiration. Now that you understand all the tools that Ubidots offers, feel free to try them and integrate them into your project.

Connecting a NavQPlus for the first time

If this is your first time trying to power up the NavQPlus board, we recommend you to follow the following tutorial to access the board and perform the wifi configuration:

Tutorial(Optional):https://www.hackster.io/crubio/connecting-a-navqplus-for-the-first-time-3cea3f

Accessing the external I2C bus

AUX connector: i2c bus is multiplexed with UART4 pins to the six-pin JST-GH connector and the external i2c bus is enabled on the NavQPlus AUX port. By default, these are configured for i2c and not UART4 (internal MCU).

A table of pinout is shown below. Note that pin 1 is on the left side of the connector:

You only need to use pins 1, 2, 3 and 6 for i2c.

More information: https://nxp.gitbook.io/8mpnavq/dev-guide/hardware-interfaces/i2c

I2C device detection

You may need to install i2c-tools by running the following:

sudo apt-get install i2c-tools

To detect that a device is present on the bus, you can execute the following command:

i2cdetect -y 5

You should see a device at address 0x77. If there is no device at address 0x77, you should check your wiring.

You may need to add user <user> to the i2c group to access the bus (to use i2c commands without root). To do this, run the following command, then log out and log back in:

sudo usermod -aG i2c <user>

I2C Locator

The Adafruit BME688 module has two "STEMMA QT" JST SH 4 pin sockets (Also called Qwiic/ Sparkfun QT) for I2C access to the sensor.

Location of i2c on AUX port.

Installing the software

Then, in the terminal, type the following to clone the repository and install it:

git clone https://github.com/cristianrubioa/bme68x-python
cd bme68x-python/library 
sudo python setup.py install

You can also use pip to install the library, as follows, although you will have to download the examples separately:

sudo pip install bme680

The library should now be installed.

Running the built-in example

The library includes some examples that print sensor readings (temperature, pressure, humidity and gas resistance value) continuously. You will find the examples in bme68x-python/examples.

As a recommendation, it is useful to run the sensor for at least 20 minutes the first time you use it. The sensor readings will vary gradually and then stabilize after a while. This drift will occur each time you start taking readings, but after that, the readings should stabilize fairly quickly each time, usually after a couple of minutes.

To run the example, type the following:

cd bme68x-python/examples
python read-all.py

You can press CTRL + c to stop the execution of the example.

If you want to record the sensor values in a text file, it is easy to do so by redirecting the program output to a text file in the terminal, as follows:

python read-all.py > bme68x-data.txt

Note that the values are comma separated, so you should be able to import them into a spreadsheet to plot them fairly easily.

Imports and configuring the sensor for NavQPlus

Reading the sensor values on the BME688 is fairly straightforward, but requires some configuration values to be set initially.

First, you will need to install smbus. To do this, simply run it in your terminal:

pip install smbus

In the example bme68x-python/examples/read-all.py we must import the smbus library and define the bus where our sensor is located, in order to pass it as a parameter to the BME688 function.

import bme680
import time
from smbus import SMBus

BUS = SMBus(5)

try:
    sensor = bme680.BME680(bme680.I2C_ADDR_PRIMARY, BUS)
except (RuntimeError, IOError):
    sensor = bme680.BME680(bme680.I2C_ADDR_SECONDARY, BUS)

With this, we should now see our BME688 sensor reading in our NavQPlus.

Sending data to Ubidots for visualization

At this point, you must create an Ubidots account.

requests is a popular Python library that simplifies making HTTP requests.

pip install requests

Create and run a Python script in your computer's terminal:

nano bme688_ubidots.py

Then copy and paste the below code in your terminal (review Code section), Or Or you can open this example in the folder bme68x-python/examples/. You must assign your Ubidots TOKEN. For more information, please see the Ubidots REST API Reference.

Once the code has been completed with your Ubidots TOKEN and coordinates, press CTRL + o and ENTER to save. To exit the Python editor, press CTRL + x and return to the computer's terminal.

Now, run the below script in your computer's terminal:

python bme688_ubidots.py

If successful, your terminal will immediate begin reporting server responses:

Server responses.

To visualize your work in Ubidots, go to the Device Management tab of your account and visualize the device created:

Device Management tab.

Feel free to create a dashboard to your liking, you can take the following dashboard for inspiration.

Code

bm688_ubidots.py

import requests
import time
import bme680
from smbus import SMBus

# Ubidots
TOKEN = ""
DEVICE_LABEL = "bm688"  
BASE_URL = "http://industrial.api.ubidots.com/api/v1.6/devices/"

# I2C
I2C_ADDR = 0x77
BUS = SMBus(5)


class BME688(bme680.BME680):
    def __init__(self, i2c_addr=I2C_ADDR, i2c_bus=BUS) -> None:
        super().__init__(i2c_addr, i2c_bus)
        self.calibration()

        # oversampling settings
        self.set_humidity_oversample(bme680.OS_2X)
        self.set_pressure_oversample(bme680.OS_4X)
        self.set_temperature_oversample(bme680.OS_8X)
        self.set_filter(bme680.FILTER_SIZE_3)
        self.set_gas_status(bme680.ENABLE_GAS_MEAS)
        
        self.initial_reading()
        self.set_gas_heater_temperature(320)
        self.set_gas_heater_duration(150)
        self.select_gas_heater_profile(0)


    def calibration(self) -> None:
        print("Calibration data:")
        calibration_data = self.calibration_data
        for name in dir(calibration_data):
            if not name.startswith("_"):
                value = getattr(calibration_data, name)

                if isinstance(value, int):
                    print(f"{name}: {value}")


    def initial_reading(self) -> None:
        print("\n\nInitial reading:")
        sensor_data = self.data
        for name in dir(sensor_data):
            value = getattr(sensor_data, name)

            if not name.startswith("_"):
                print(f"{name}: {value}")

    def build_payload(self):
        sensor_data = self.data
        payload = {
            "temperature": sensor_data.temperature,
            "pressure": sensor_data.pressure,
            "humidity": sensor_data.humidity,
        }
        if sensor_data.heat_stable:
            payload["gas_resistance"] = sensor_data.gas_resistance

        return payload 


def send_ubidots(payload):
    # Make the HTTP request to Ubidots
    url = f"{BASE_URL}{DEVICE_LABEL}/?token={TOKEN}"
    status = 400
    attempts = 0

    while status >= 400 and attempts <= 5:
        req = requests.post(url, json=payload)
        status = req.status_code
        attempts += 1

    response = req.json()

    return response
    

if __name__ == "__main__":
    bme688 = BME688()
    print("\n\nPolling:")

    try:
        while True:
            if bme688.get_sensor_data():
                payload = bme688.build_payload()
                response = send_ubidots(payload)
                print(f"response json from server: \n{response}")

            time.sleep(1)

    except KeyboardInterrupt:
        pass