Virtualized sensors for esp32 emulator

Okay so you’ve got your esp32 emulator running on qemu. What next? I need to virtualize sensors. That cannot be done really because sensors return environmental parameters, so you can either simulate environmental parameters or generate mock data instead.

For context I would suggest to read the previous post. I started off simple trying to generate mock data for the bmp280 sensor. Now to have your firmware behave with the virtualized sensor to be exactly like the real sensor you would have to create a new c++ library with the same classes, interfaces, and functions which take in the same parameters, and give out the same outputs so that there are no problems in migrating from testing it on real hardware and the emulator. The goal is to be able to run the same code on the emulator without changing it.

For this the most appropriate way would be to find the source code for the c++ library of the sensor that you would be using. In my case that would be the Adafruit_BMP280.h and replicate it entirely, replacing the data it returns from the real hardware with any data you’d like.

You can save a lot of time by just implementing a couple of commonly used functions that you are using in your code. A lot of these libraries are pretty big and repeating this for every library would be very time consuming.

Here is what i did

// utils/sensors/bmp280.hpp

#ifndef BMP280_HPP
#define BMP280_HPP

#include <stdbool.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"

#ifdef __cplusplus
extern "C" {
#endif

class bmp280 {
public:
    bmp280();
    bool begin(uint8_t addr = 0x77, uint8_t chipid = 0x58); 
    void bmp280_init(); 
    float readPressure(); 
    float readTemperature(); 
    float readAltitude(float seaLevelhPa = 1013.25); 
};

#ifdef __cplusplus
}
#endif

#endif

// utils/sensors/bmp280.cpp

#include "bmp280.hpp"
#include <math.h>
#include <stdio.h>

static float time = 0.0;

bmp280::bmp280() {}

bool bmp280::begin(uint8_t addr, uint8_t chipid) {
    vTaskDelay(pdMS_TO_TICKS(200)); 
    return true;
}

void bmp280::bmp280_init() {
    printf("BMP280 Initialized\n");
}

float bmp280::readPressure() {
    float pressure = 1013.25 + 10 * sin(time);
    time += 0.1; 
    return pressure;
}

float bmp280::readTemperature() {
    float temperature = 25.0 + 5 * sin(time);
    return temperature;
}

float bmp280::readAltitude(float seaLevelhPa) {
    float altitude = 44330 * (1 - pow(readPressure() / seaLevelhPa, 0.1903));
    return altitude;
}

And this can be used in your main/main.cpp like so

// main/main.cpp

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "bmp280.hpp"

extern "C" void app_main() {
    bmp280 bmp;

    if (!bmp.begin()) {
        printf("Failed to initialize BMP280\n");
        return;
    }
    printf("BMP280 Ready!\n");

    while (1) {
        float temperature = bmp.readTemperature();
        printf("Temperature = %.2f *C\n", temperature);

        float pressure = bmp.readPressure();
        printf("Pressure = %.2f hPa\n", pressure);

        float altitude = bmp.readAltitude();
        printf("Altitude = %.2f m\n", altitude);

        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}

Be sure to add the dependancies in main/CMakeLists.txtlike so

idf_component_register(SRCS "main.cpp" "../utils/sensors/bmp280.cpp"
INCLUDE_DIRS "../utils/sensors/")

This is a very simple demonstation which is actually very intuitive. I plan on creating libraries like such for all the sensors and data storage modules I will be needing. Then the plan is to figure out a way to write tests and have the data returned by these sensor libraries to main/main.cpp based on the tests.

So I would be able to write the tests once which would include multiple scenarios and edge cases and just run a command to see if the firmware I have written passes the test cases on the emulator itself without actually going and performing the tests with the real hardware – saving me a lot of time.