开发 Edge Impulse 应用到云端

可升级为工业级传感器

借助 SenseCAP S2110 controller 和 S2100 data logger，你可以轻松将 Grove 打造成 LoRaWAN® 传感器。Seeed 不仅帮助你完成原型开发，还为你提供使用 SenseCAP 系列坚固工业传感器扩展项目的可能性。

IP66 外壳、蓝牙配置、与全球 LoRaWAN® 网络的兼容性、内置 19 Ah 电池以及来自 APP 的强大支持，使得 SenseCAP S210x 成为工业应用的最佳选择。该系列包括用于土壤湿度、空气温度和湿度、光照强度、CO2、EC 的传感器，以及一款 8 合 1 气象站。尝试最新的 SenseCAP S210x，为你的下一个工业项目保驾护航。

SenseCAP 工业传感器

S2100 数据记录仪	S2101 空气温度和湿度	S2102 光照	S2103 空气温度、湿度和 CO2

S2104 土壤湿度和温度	S2105 土壤湿度、温度和 EC	S2110 LoRaWAN® 控制器	S2120 8 合 1 气象站

我们使用的工具

note

在开始本节之前，请确保你已经了解 Wio Terminal 产品更多详情，请阅读

Wio Terminal 入门

本文展示了一个解决方案，适用于想要使用 edgeimpulse 生成模型并连接到云端的用户。在我们的演示中，我们将使用 Google Sheet。这是最直接且

配置

步骤 1. 创建一个支持 Google Form 的 Integrations

此步骤与文章 Integrate into Google Sheets 中的步骤类似。

我们需要做的事情是为该集成命名，并简单地保存配置。

连接到 Google Form

创建
连接到 Google Sheets
关联 Google Form ID

步骤 2. 使用 Google Form API 和 Decoder 功能创建一个 Fuction

确保 Google Form 已连接到 Fuction，并填写了我们在上述步骤中获得的 ID。

我们需要创建一个带有 Decoder 支持的 Fuction，用于我们的数据流传输，如下所示。

function Decoder(bytes, port) {

    var decoded = {};

    function transformers(bytes) {
        if (bytes[0] == 255 || bytes[0] == 0) {
            value = bytes[2] * 256 + bytes[3];
        }
        return value;
    }

    if (port == 8) {
        decoded.class = transformers(bytes.slice(0, 4));
    }

  var decodedPayload = {
    "class": decoded.class 
  };

  // END TODO

  return Serialize(decodedPayload)
}

var field_mapping = {
  "class": "entry.39410305"
};

function Serialize(payload) {
  var str = [];
  for (var key in payload) {
    if (payload.hasOwnProperty(key)) {
      var name = encodeURIComponent(field_mapping[key]);
      var value = encodeURIComponent(payload[key]);
      str.push(name + "=" + value);
    }
  }
  return str.join("&");
}
// DO NOT REMOVE: Google Form Function\

步骤 3. 配置 Flows

确保连接

Edge Impulse 配置

note

Ardiuno（Wio Terminal）配置

note

由于传感器和环境不同，直接烧录在不同载板上训练的模型并不总是理想的。可靠的模型需要用户自己训练，因此这里只提供测试代码以便快速体验。

体验一下

在我们从 Edge Impulse 生成库之后，需要修改代码，以便在 Wio Terminal 上通过 Lora 发送数据。如果你只是想先体验一下，只需复制下面的代码，并通过 Arduino IDE 将其烧录到你的 Wio Terminal 上。

烧录下面的测试代码。

#include <AIot_Example_inferencing.h>
#include"LIS3DHTR.h"
#include"TFT_eSPI.h"
LIS3DHTR<TwoWire> lis;
TFT_eSPI tft;
#include <SoftwareSerial.h>
#include <Arduino.h>
#include <SensirionI2CSht4x.h>
#include <Wire.h>

SoftwareSerial mySerial(A0, A1); // RX, TX

SensirionI2CSht4x sht4x;

static char recv_buf[512];
static bool is_exist = false;
static bool is_join = false;

static int at_send_check_response(char *p_ack, int timeout_ms, char *p_cmd, ...)
{
    int ch;
    int num = 0;
    int index = 0;
    int startMillis = 0;
    va_list args;
    memset(recv_buf, 0, sizeof(recv_buf));
    va_start(args, p_cmd);
    mySerial.printf(p_cmd, args);
    Serial.printf(p_cmd, args);
    va_end(args);
    delay(200);
    startMillis = millis();

    if (p_ack == NULL)
    {
        return 0;
    }

    do
    {
        while (mySerial.available() > 0)
        {
            ch = mySerial.read();
            recv_buf[index++] = ch;
            Serial.print((char)ch);
            delay(2);
        }

        if (strstr(recv_buf, p_ack) != NULL)
        {
            return 1;
        }

    } while (millis() - startMillis < timeout_ms);
    return 0;
}

static void recv_prase(char *p_msg)
{
    if (p_msg == NULL)
    {
        return;
    }
    char *p_start = NULL;
    int data = 0;
    int rssi = 0;
    int snr = 0;

    p_start = strstr(p_msg, "RX");
    if (p_start && (1 == sscanf(p_start, "RX: \"%d\"\r\n", &data)))
    {
        Serial.println(data);
    }

    p_start = strstr(p_msg, "RSSI");
    if (p_start && (1 == sscanf(p_start, "RSSI %d,", &rssi)))
    {
        Serial.println(rssi);
    }

    p_start = strstr(p_msg, "SNR");
    if (p_start && (1 == sscanf(p_start, "SNR %d", &snr)))
    {
        Serial.println(snr);
    }
}
////// Send message block end


/* Constant defines -------------------------------------------------------- */
#define CONVERT_G_TO_MS2    9.80665f
#define MAX_ACCEPTED_RANGE  2.0f        // starting 03/2022, models are generated setting range to +-2, but this example use Arudino library which set range to +-4g. If you are using an older model, ignore this value and use 4.0f instead

/* Private variables ------------------------------------------------------- */
static bool debug_nn = false; // Set this to true to see e.g. features generated from the raw signal

/**
* @brief      Arduino setup function
*/
void setup()
{
    // put your setup code here, to run once:
    Serial.begin(115200);
    Serial.println("Edge Impulse Inferencing Demo");

    tft.begin();
    tft.setRotation(3);
    tft.fillScreen(TFT_WHITE);

    lis.begin(Wire1);

    if (!lis.available()) {
    Serial.println("Failed to initialize IMU!");
    while (1);
    }
    else {
        ei_printf("IMU initialized\r\n");
    }
    lis.setOutputDataRate(LIS3DHTR_DATARATE_100HZ); // Setting output data rage to 25Hz, can be set up tp 5kHz 
    lis.setFullScaleRange(LIS3DHTR_RANGE_16G); // Setting scale range to 2g, select from 2,4,8,16g


    if (EI_CLASSIFIER_RAW_SAMPLES_PER_FRAME != 3) {
        ei_printf("ERR: EI_CLASSIFIER_RAW_SAMPLES_PER_FRAME should be equal to 3 (the 3 sensor axes)\n");
        return;
    }

    mySerial.begin(9600);

    Wire.begin();

    uint16_t error;
    char errorMessage[256];

    sht4x.begin(Wire);

    uint32_t serialNumber;
    error = sht4x.serialNumber(serialNumber);
    delay(5000);
    if (error) {
        Serial.print("Error trying to execute serialNumber(): ");
        errorToString(error, errorMessage, 256);
        Serial.println(errorMessage);
    } else {
        Serial.print("Serial Number: ");
        Serial.println(serialNumber);
    }

    Serial.print("E5 LORAWAN TEST\r\n");

    if (at_send_check_response("+AT: OK", 100, "AT\r\n"))
    {
        is_exist = true;
        at_send_check_response("+ID: DevEui", 1000, "AT+ID=DevEui,\"608XXXXXXXXEE7\"\r\n");
        at_send_check_response("+ID: AppEui", 1000, "AT+ID=AppEui,\"608XXXXXXXX85D\"\r\n");
        at_send_check_response("+MODE: LWOTAA", 1000, "AT+MODE=LWOTAA\r\n");
        at_send_check_response("+DR: EU868", 1000, "AT+DR=EU868\r\n");
        at_send_check_response("+CH: NUM", 1000, "AT+CH=NUM,0-2\r\n");
        at_send_check_response("+KEY: APPKEY", 1000, "AT+KEY=APPKEY,\"E1EF1AC8XXXXXXXXXXXXXXXX05C5\"\r\n");
        at_send_check_response("+CLASS: A", 1000, "AT+CLASS=A\r\n");
        at_send_check_response("+PORT: 8", 1000, "AT+PORT=8\r\n");
        delay(200);
        is_join = true;
    }
    else
    {
        is_exist = false;
        Serial.print("No E5 module found.\r\n");
    }
}

/**
 * @brief Return the sign of the number
 * 
 * @param number 
 * @return int 1 if positive (or 0) -1 if negative
 */
float ei_get_sign(float number) {
    return (number >= 0.0) ? 1.0 : -1.0;
}

/**
* @brief      Get data and run inferencing
*
* @param[in]  debug  Get debug info if true
*/
void loop()
{
    ei_printf("\nStarting inferencing in 2 seconds...\n");

    delay(2000);

    ei_printf("Sampling...\n");

    // Allocate a buffer here for the values we'll read from the IMU
    float buffer[EI_CLASSIFIER_DSP_INPUT_FRAME_SIZE] = { 0 };

    for (size_t ix = 0; ix < EI_CLASSIFIER_DSP_INPUT_FRAME_SIZE; ix += 3) {
        // Determine the next tick (and then sleep later)
        uint64_t next_tick = micros() + (EI_CLASSIFIER_INTERVAL_MS * 1000);
        lis.getAcceleration(&buffer[ix], &buffer[ix + 1], &buffer[ix + 2]);

        for (int i = 0; i < 3; i++) {
            if (fabs(buffer[ix + i]) > MAX_ACCEPTED_RANGE) {
                buffer[ix + i] = ei_get_sign(buffer[ix + i]) * MAX_ACCEPTED_RANGE;
            }
        }

        buffer[ix + 0] *= CONVERT_G_TO_MS2;
        buffer[ix + 1] *= CONVERT_G_TO_MS2;
        buffer[ix + 2] *= CONVERT_G_TO_MS2;

        delayMicroseconds(next_tick - micros());
    }

    // Turn the raw buffer in a signal which we can the classify
    signal_t signal;
    int err = numpy::signal_from_buffer(buffer, EI_CLASSIFIER_DSP_INPUT_FRAME_SIZE, &signal);
    if (err != 0) {
        ei_printf("Failed to create signal from buffer (%d)\n", err);
        return;
    }

    // Run the classifier
    ei_impulse_result_t result = { 0 };

    err = run_classifier(&signal, &result, debug_nn);
    if (err != EI_IMPULSE_OK) {
        ei_printf("ERR: Failed to run classifier (%d)\n", err);
        return;
    }

    // print the predictions
    ei_printf("Predictions ");
    ei_printf("(DSP: %d ms., Classification: %d ms., Anomaly: %d ms.)",
        result.timing.dsp, result.timing.classification, result.timing.anomaly);
    ei_printf(": \n");
    for (size_t ix = 0; ix < EI_CLASSIFIER_LABEL_COUNT; ix++) {
        ei_printf("    %s: %.5f\n", result.classification[ix].label, result.classification[ix].value);
    }
#if EI_CLASSIFIER_HAS_ANOMALY == 1
    ei_printf("    anomaly score: %.3f\n", result.anomaly);
#endif

   int classification_flag = 0;

   if (result.classification[1].value > 0.7) {
    tft.fillScreen(TFT_PURPLE);
    tft.setFreeFont(&FreeSansBoldOblique12pt7b);
    tft.drawString("Wave", 20, 80);
    delay(1000);
    tft.fillScreen(TFT_WHITE);
    classification_flag = 1;
   }

   if (result.classification[2].value > 0.7) {
    tft.fillScreen(TFT_RED);
    tft.setFreeFont(&FreeSansBoldOblique12pt7b);
    tft.drawString("Circle", 20, 80);
    delay(1000);
    tft.fillScreen(TFT_WHITE);
    classification_flag = 2;
   }


    if (is_exist){
        int ret = 0;
        if (is_join){
            ret = at_send_check_response("+JOIN: Network joined", 12000, "AT+JOIN\r\n");
            if (ret){
              is_join = false;
            }
            else{
                Serial.println("");
                Serial.print("JOIN failed!\r\n\r\n");
                delay(5000);
            }
        }
        else{
            char cmd[128];
            sprintf(cmd, "AT+CMSGHEX=\"%08X %08X\"\r\n", classification_flag);
            ret = at_send_check_response("Done", 10000, cmd);
            if (ret){
              Serial.print("classification_flag:");
              Serial.print(classification_flag);
              Serial.print("\t");
              recv_prase(recv_buf);
            }
            else{
              Serial.print("Send failed!\r\n\r\n");
            }
            delay(5000);
        }
    }
    else
    {
      delay(500);
    }

}

#if !defined(EI_CLASSIFIER_SENSOR) || EI_CLASSIFIER_SENSOR != EI_CLASSIFIER_SENSOR_ACCELEROMETER
#error "Invalid model for current sensor"
#endif

自己动手实现更多功能

note

更多详细信息，请参阅下面的文档。

Connection

有些内容我们可能需要更加注意：

存储分类结果：

我们可以设置一个阈值，当满足某个条件时改变标志位，并为不同类别分配不同的标签。

为了提高速度，我们可以注释掉 tft 函数。

int classification_flag = 0;
if (result.classification[1].value > 0.7) {
    tft.fillScreen(TFT_PURPLE);
    tft.setFreeFont(&FreeSansBoldOblique12pt7b);
    tft.drawString("Wave", 20, 80);
    delay(1000);
    tft.fillScreen(TFT_WHITE);
    classification_flag = 1;
}
if (result.classification[2].value > 0.7) {
    tft.fillScreen(TFT_RED);
    tft.setFreeFont(&FreeSansBoldOblique12pt7b);
    tft.drawString("Circle", 20, 80);
    delay(1000);
    tft.fillScreen(TFT_WHITE);
    classification_flag = 2;
}
....

数据发送代码块：

在 Lora 网络可用的情况下，我们可以使用该函数发送标签，并通过我们编写的 Decoder 将其解析出来。

if (is_exist){
    int ret = 0;
    if (is_join){
        ret = at_send_check_response("+JOIN: Network joined", 12000, "AT+JOIN\r\n");
        if (ret){
          is_join = false;
        }
        else{
            Serial.println("");
            Serial.print("JOIN failed!\r\n\r\n");
            delay(5000);
        }
    }
    else{
        char cmd[128];
        sprintf(cmd, "AT+CMSGHEX=\"%08X %08X\"\r\n", classification_flag); // Change classification_flag to data wanna transfer
        ret = at_send_check_response("Done", 10000, cmd);
        if (ret){
          Serial.print("classification_flag:");s
          Serial.print(classification_flag);
          Serial.print("\t");
          recv_prase(recv_buf);
        }
        else{
          Serial.print("Send failed!\r\n\r\n");
        }
        delay(5000);
    }
}
else
{
  delay(500);
}

技术支持与产品讨论

感谢您选择我们的产品！我们将为您提供多种支持，以确保您在使用我们产品时拥有尽可能顺畅的体验。我们提供多种沟通渠道，以满足不同的偏好和需求。

可升级为工业级传感器​

我们使用的工具​

配置​

步骤 1. 创建一个支持 Google Form 的 Integrations​

步骤 2. 使用 Google Form API 和 Decoder 功能创建一个 Fuction​

步骤 3. 配置 Flows​

Edge Impulse 配置​

Ardiuno（Wio Terminal）配置​

体验一下​

自己动手实现更多功能​

技术支持与产品讨论​

可升级为工业级传感器

我们使用的工具

配置

步骤 1. 创建一个支持 Google Form 的 Integrations

步骤 2. 使用 Google Form API 和 Decoder 功能创建一个 Fuction

步骤 3. 配置 Flows

Edge Impulse 配置

Ardiuno（Wio Terminal）配置

体验一下

自己动手实现更多功能

技术支持与产品讨论