Edge Impulse training data acquisition over LTE with Particle

In machine learning, it’s vital that the system used to generate the training data closely mimics the system that will be running the inferencing. For example, if you’re building an object recognition solution, it is important to use the same camera module in both acquisition and inferencing. Particle’s Muon development board enables us to do both. Let’s explore how to build the dataset. We’ll be using the Muon’s onboard temperature sensor as our data stream. But, this could easily be reproduced with any external sensor module connected with the onboard Qwiic/STEMMA connector or a standard Raspberry Pi HAT.

To set up our Edge Impulse data acquisition over LTE, the Particle module will publish a sensor reading, then a custom webhook will be configured to make an API request to Edge Impulse with the sensor information.

The firmware for this example is really straightforward. You can view the completed firmware repository for more details.

Some interesting things to point out:

The Muon uses the TMP112 I2C temperature sensor with an address of 0x48. The driver for this sensor is located in the /src/temperature directory with temperature.h and temperature.cpp.

We’ve defined a struct in temperature.h to hold both a Fahrenheit and Celsius reading:

typedef struct
{
    float degreesF;
    float degreesC;
} TemperatureReading;

And that struct gets updated via readTemperature in temperature.cpp:

void readTemperature(TemperatureReading *reading)
{
  unsigned data[2] = {0, 0};

  // Start I2C Transmission
  Wire.beginTransmission(Addr);
  // Select data register
  Wire.write(0x00);
  // Stop I2C Transmission
  Wire.endTransmission();
  delay(300);

  // Request 2 bytes of data
  Wire.requestFrom(Addr, 2);

  // Read 2 bytes of data
  // temp msb, temp lsb
  if (Wire.available() == 2)
  {
    data[0] = Wire.read();
    data[1] = Wire.read();
  }

  // Convert the data to 12-bits
  int temp = ((data[0] * 256) + data[1]) / 16;
  if (temp > 2048)
  {
    temp -= 4096;
  }
  float cTemp = temp * 0.0625;
  float fTemp = cTemp * 1.8 + 32;

  reading->degreesC = cTemp;
  reading->degreesF = fTemp;
}

Back in the main cpp file, we pass a pointer of our global temperatureReading struct into the readTemperature function. Then we can publish the reading to the training-data event.

void loop()
{
  readTemperature(&temperatureReading);
  Log.info("Temperature reading: %f", temperatureReading.degreesF);
  Particle.publish("training-data", temperatureReading.degreesF);
  delay(15000);
}

That’s it for the firmware! This can be used as a starting point for more complex sensing systems training more complex AI models.

From the Edge Impulse console, create a new project. Then, head over the the “Devices” page and select “Keys.” Create a new API key if necessary and save it for later. We’ll need it in the next step.

In the Particle Console, we need to configure a custom webhook to forward the training-data events to Edge Impulse. First, navigate to the integrations section of the console. Then, select “Add new integration.”

Scroll down to “Custom Webhook” and choose “Start now.”

Fill out the settings for the custom webhook as shown below. Edge Impulse’s endpoint for adding training data is: http://ingestion.edgeimpulse.com/api/training/data. center

Make sure to expand "Extra settings" and add the following JSON to the "JSON Data" textbox.

Note how we describe details about our temperature sensor in the sensors array. The values that correspond to this sensor are pulled from the event value.

The device_name and device_type can be anything, as they are used to identify this device in the Edge Impulse console. center

{
  "payload": {
    "device_name": "test-som",
    "device_type": "msom",
    "interval_ms": 15000,
    "sensors": [
      {
        "name": "temp",
        "units": "F"
      }
    ],
    "values": [
        {{{PARTICLE_EVENT_VALUE}}}
    ]
  },
  "protected": {
    "alg": "none",
    "ver": "v1"
  },
  "signature": "00"
}

Finally, include the following key / value pairs in the “HTTP Headers” section. They provide additional information about your data stream as well as your Edge Impulse API key that was created in the previous step. center

Save and enable your new custom Edge Impulse webhook.

Program your Muon with the provided firmware and make sure that the temperature readings from the serial logs look correct.

Then, we can head over to the integrations page on the Particle Console to view the traffic on the webhook. Confirm there are no errors being generated.

Since there are no errors, the data should be starting to show up in the Edge Impulse console!

This is a really simple example showing how you could use an LTE-enabled Particle module to remotely gather training data for an Edge Impulse AI model. An AI model is only as good as the data that was used to train it. With this configuration, it would be trivial to deploy dozens of battery-operated data acquisition devices in realistic environments anywhere in the world.