Skip to main content

SenseCAP Indicator - LoRa应用开发

介绍​

LoRa®是一种长距离无线通信技术，经过优化以在远距离传输小量数据。它通过使用一种称为Chirp Spread Spectrum (CSS)的方法，在亚GHz频谱中调制无线电信号来工作。

Seeed Studio的SenseCAP Indicator（版本D1L和D1Pro）包含内置的LoRa收发模块（Semtech SX1262 LoRa®芯片），使得向您的项目添加低功耗无线连接变得轻松。在本文中，我们将介绍如何在两个SenseCAP Indicator板之间设置LoRa通信。

概述​

这个演示展示了如何在SenseCAP Indicator和XIAO板之间建立基本的LoRa通信，使用Wio-E5作为中间件。SenseCAP Indicator从XIAO检索传感器数据，然后通过Wio-E5进行传输。传输的数据包随后被SenseCAP Indicator接收，解密并输出结果，并在其屏幕上显示数据。

无LVGL代码：代码 · GitHub

硬件​

SenseCAP Indicator​

从页面Dive_into_the_Hardware上，我们可以看到LoRa收发器通过SPI接口连接到ESP32-S3 MCU。

关键组件包括：
  • Semtech SX1262射频前端
  • ESP32-S3 MCU

LoRa收发器处理LoRa信号的所有低级调制和解调。我们可以使用ESP32-S3的SPI接口与其通信。

XIAO​

在这个演示中，XIAO需要收集传感器数据并通过Wio-E5将其传输到SenseCAP Indicator。XIAO通过UART接口连接到Wio-E5。

  • XIAO
  • Wio-E5
  • SEN5x

软件​

由于SenseCAP_Indicator_ESP32 SDK已经提供了LoRa库，我们可以直接使用它，您可以快速查看页面LoRa®来了解如何使用LoRa库。

入门指南​

这个演示演示了如何设置本地LoRa® Hub以进行物联网连接。

先决条件​

请按照提供的说明设置开发环境。

Step 1: 下载演示代码​

从此链接克隆或下载演示代码。这些代码将作为您的LoRa应用程序的起点。

Step 2: 实现负载编码器（XIAO;Arduino）​

Step 2.1: 实现您的负载结构和编码器​

#ifndef _FRAME_H
#define _FRAME_H
#include <Arduino.h>
#include <vector>

/** payload format
* | topic | dataLength | Data Payload | CRC |
* | 1byte | 1byte      | n byte       | 2byte |
* example:
* | 0x01 | 0x0E | 14 bytes | 2byte | for SEN54
* | 0x01 | 0x10 | 16 bytes | 2byte | for SEN55
*/

#pragma pack(1)
enum topics {
    TOPICS_MIN   = 0x00,
    TOPICS_SEN5x = 0x01,
    TOPIC_MAX,
};

#pragma pack(1)
typedef struct
{
    enum topics topic;         /*msg type*/
    uint8_t dataLength;
    std::vector<uint8_t> data; /*actual data of payload*/
    uint16_t crc;
} Frame_t;
String packFrame(Frame_t frame);
void deleteFrame(Frame_t *frame);
uint16_t crc16_ccitt(const uint8_t *data, size_t length);
#endif
#include "Frame.h"
String packFrame(Frame_t frame) {
    uint8_t *packedData = (uint8_t *)malloc(2 + frame.dataLength + 2);
    if (packedData == NULL) {
        return String(); // Return an empty string if memory allocation fails
    }
    // Pack the frame topic
    packedData[0] = frame.topic;
    packedData[1] = frame.dataLength;
    // Pack the data payload
    for (size_t i = 0; i < frame.dataLength; i++) {
        packedData[2 + i] = frame.data[i];
    }
    // Calculate CRC (for simplicity, we assume CRC is just the sum of all bytes)
    frame.crc = crc16_ccitt(packedData, 2 + frame.dataLength);

    // Pack the CRC
    packedData[2 + frame.dataLength]     = (frame.crc & 0xFF00) >> 8;
    packedData[2 + frame.dataLength + 1] = frame.crc & 0x00FF;
    // String packedFrame; serialize the packed data into a string
    char packedFrameBuffer[(2 + frame.dataLength + 2) * 2];
    for (size_t i = 0; i < 2 + frame.dataLength + 2; i++) {
        snprintf(&packedFrameBuffer[i * 2], 3, "%02X", packedData[i]); // 3 to include null terminator
    }
    free(packedData);

    return String(packedFrameBuffer);
}

void deleteFrame(Frame_t *frame) {
    free(frame);
}

uint16_t crc16_ccitt(const uint8_t *data, size_t length) {
    uint16_t crc = 0xFFFF;

    for (size_t i = 0; i < length; i++) {
        crc ^= (uint8_t)data[i] << 8;
        for (uint8_t j = 0; j < 8; j++) {
            if (crc & 0x8000) {
                crc = (crc << 1) ^ 0x1021;
            } else {
                crc <<= 1;
            }
        }
    }

    return crc & 0xFFFF;
}

Step 2.2: 实现传感器数据结构并适应负载编码器​

#ifndef PAYLOAD_SEN5X_H
#define PAYLOAD_SEN5X_H
#include "Frame.h"
#include "SensorPayload.h"
#include <SensirionI2CSen5x.h>

#define DEVICE_SEN54

#if defined(DEVICE_SEN54)
#elif defined(DEVICE_SEN55)
#else
#error "Please define a device in the compiler options."
#endif

class PayloadSEN5x : public SensorPayload<SensirionI2CSen5x> {
  public:
    PayloadSEN5x(SensirionI2CSen5x handler);
    uint16_t init() override;
    String toPayloadString() override;

  private:
    uint16_t massConcentrationPm1p0;
    uint16_t massConcentrationPm2p5;
    uint16_t massConcentrationPm4p0;
    uint16_t massConcentrationPm10p0;
    int16_t ambientHumidity;
    int16_t ambientTemperature;
    int16_t vocIndex;
#ifdef DEVICE_SEN55
// int16_t noxIndex; // Sensor SEN54 does not support NOx
#endif
    SensirionI2CSen5x _sen5x;
};
#endif // PAYLOAD_SEN5X_H
#include "sensor_sen5x.h"
#include "main.h"

PayloadSEN5x::PayloadSEN5x(SensirionI2CSen5x handler)
    : SensorPayload<SensirionI2CSen5x>(handler), _sen5x(handler) {
    // Initialize specific data members for SEN5X here (if needed)
    _sen5x.begin(Wire);
}

uint16_t PayloadSEN5x::init() {
    // Implement the initialization logic for SEN5X here
    uint16_t error;
    char errorMessage[256];
    error = _sen5x.deviceReset();
    if (error) {
        Serial.print("Error trying to execute deviceReset(): ");
        errorToString(error, errorMessage, 256);
        Serial.println(errorMessage);
    }
    float tempOffset = 0.0;
    error            = _sen5x.setTemperatureOffsetSimple(tempOffset);
    if (error) {
        Serial.print("Error trying to execute setTemperatureOffsetSimple(): ");
        errorToString(error, errorMessage, 256);
        Serial.println(errorMessage);
    } else {
        Serial.print("Temperature Offset set to ");
        Serial.print(tempOffset);
        Serial.println(" deg. Celsius (SEN54/SEN55 only)");
    }

    // Start Measurement
    error = _sen5x.startMeasurement();
    if (error) {
        Serial.print("Error trying to execute startMeasurement(): ");
        errorToString(error, errorMessage, 256);
        Serial.println(errorMessage);
    }
    return 0;
}

String PayloadSEN5x::toPayloadString() {
// Add your code to convert data to payload string here
#ifdef DEVICE_SEN55
    _sen5x.readMeasuredValuesAsIntegers(massConcentrationPm1p0, massConcentrationPm2p5, massConcentrationPm4p0, massConcentrationPm10p0, ambientHumidity, ambientTemperature, vocIndex, noxIndex);
    _frame.dataLength = 16;
#else
    int16_t __noxIndex;
    _sen5x.readMeasuredValuesAsIntegers(massConcentrationPm1p0, massConcentrationPm2p5, massConcentrationPm4p0, massConcentrationPm10p0, ambientHumidity, ambientTemperature, vocIndex, __noxIndex);
    _frame.dataLength = 14;
#endif

    _frame.topic = TOPICS_SEN5x;

    // empty the data vector
    _frame.data.clear();
    // make the value into hex payload string
    _frame.data.push_back((uint8_t)(massConcentrationPm1p0 >> 8));
    _frame.data.push_back((uint8_t)(massConcentrationPm1p0 & 0xFF));
    _frame.data.push_back((uint8_t)(massConcentrationPm2p5 >> 8));
    _frame.data.push_back((uint8_t)(massConcentrationPm2p5 & 0xFF));
    _frame.data.push_back((uint8_t)(massConcentrationPm4p0 >> 8));
    _frame.data.push_back((uint8_t)(massConcentrationPm4p0 & 0xFF));
    _frame.data.push_back((uint8_t)(massConcentrationPm10p0 >> 8));
    _frame.data.push_back((uint8_t)(massConcentrationPm10p0 & 0xFF));
    _frame.data.push_back((uint8_t)(ambientHumidity >> 8));
    _frame.data.push_back((uint8_t)(ambientHumidity & 0xFF));
    _frame.data.push_back((uint8_t)(ambientTemperature >> 8));
    _frame.data.push_back((uint8_t)(ambientTemperature & 0xFF));
    _frame.data.push_back((uint8_t)(vocIndex >> 8));
    _frame.data.push_back((uint8_t)(vocIndex & 0xFF));
#ifdef DEVICE_SEN55
// _frame.data.push_back((uint8_t)(noxIndex >> 8));
// _frame.data.push_back((uint8_t)(noxIndex & 0xFF));
#endif
    char data[256];
    sprintf(data, "%d,%d,%d,%d,%d,%d,%d", massConcentrationPm1p0, massConcentrationPm2p5, massConcentrationPm4p0, massConcentrationPm10p0, ambientHumidity, ambientTemperature, vocIndex);
    Serial.println("String: " + String(data));

    for (int i = 0; i < _frame.dataLength; i++) {
        Serial.print(_frame.data[i], HEX);
        Serial.print(" ");
    }
    Serial.println();

    return packFrame(_frame);
}

函数toPayloadString将数据序列化为字符串，并通过Wio-E5发送到SenseCAP Indicator。

Step 2.3: 编译并将代码上传到XIAO​

#include "sensor_sen5x.h"
#include "wio_e5_at.h"
#include <Arduino.h>
#include <SensirionI2CSen5x.h>
#include <Wire.h>
SoftwareSerial serial_lora( D2, D3 );
Radio radio( serial_lora, RF_FREQUENCY, LORA_SF12, LORA_BW_125, 15, 15, 14, LORA_CRC_ON, LORA_IQ_NORMAL, LORA_PUBLIC_OFF );

SensirionI2CSen5x sen5x;
PayloadSEN5x payloadSEN5x( sen5x );

void setup() {
    delay( 2000 );
    wait_serial();
    Serial.println( "Starting..." );

    radio.begin();

    Wire.begin();
    payloadSEN5x.init();

    Serial.println( "APP begin" );
}

void loop() {
    static int count               = 0;
    static unsigned long task_time = 0;
    static String test_string;

    if ( millis() - task_time > 10000 ) {
        task_time   = millis();

        radio.sendPayload( payloadSEN5x.toPayloadString() );

        Serial.printf( "Send data %d\r\n", count++ );
    }
}

完成负载后，现在我们将深入了解SenseCAP Indicator，以编写负载解码器。

Step 3: 实现负载解码器（SenseCAP Indicator;ESP-IDF）​

负载解码器是将从LoRa收发器接收到的二进制负载转换为人类可读格式的函数。负载解码器特定于您的应用程序，并且必须由您实现。此演示的负载解码器已在演示代码中提供。

Step 3.1: 实现您的负载解码器​

  #ifndef __SIMPLE_FRAME_H
  #define __SIMPLE_FRAME_H
  #include <stdint.h>
  #include <stdio.h>
  #include <stdlib.h>

  /** payload format
  * | topic | dataLength | Data Payload | CRC |
  * | 1byte | 1byte      | n byte       | 2byte |
  * example:
  * | 0x01 | 0x0E | 14 bytes | 2byte | for SEN54
  * | 0x01 | 0x10 | 16 bytes | 2byte | for SEN55
  */

  #pragma pack(1)
  enum topics {
      TOPICS_MIN   = 0x00,
      TOPICS_SEN5x = 0x01,
      TOPIC_MAX,
  };
  typedef struct
  {
      enum topics topic; /*msg type or DataId*/
      uint8_t dataLength;
      uint8_t *data;     /*actual data of payload*/
      uint16_t crc;
  } Frame_t;
  Frame_t *parsePayload( uint8_t *payload, uint8_t length );
  void deleteFrame( Frame_t *frame );
  uint16_t crc16_ccitt( const uint8_t *data, size_t length );
  #endif
  #include "frame.h"
  #include "esp_log.h"

  Frame_t *parsePayload( uint8_t *payload, uint8_t length )
  {
      Frame_t *frame = (Frame_t *)malloc( sizeof( Frame_t ) );
      if ( frame == NULL ) {
          ESP_LOGE( "parsePayload", "Failed to allocate memory for frame" );
          return NULL;
      }

      frame->topic = (enum topics)payload[0];

      frame->dataLength = payload[1];
      frame->data = (uint8_t *)malloc( frame->dataLength );
      if ( frame->data == NULL ) {
          ESP_LOGE( "parsePayload", "Failed to allocate memory for frame data" );
          free( frame ); // Clean up previously allocated memory
          return NULL;
      }
      memcpy( frame->data, payload + 2, frame->dataLength );

      frame->crc = (uint16_t)payload[length - 2] << 8 | (uint16_t)payload[length - 1];

      if ( frame->crc != crc16_ccitt( payload, length - 2 ) ) {
          ESP_LOGE( "parsePayload", "CRC mismatch" );
          free( frame->data );
          free( frame );
          return NULL;
      }

      return frame;
  }

  void deleteFrame( Frame_t *frame )
  {
      free( frame->data );
      free( frame );
  }

  uint16_t crc16_ccitt( const uint8_t *data, size_t length )
  {
      uint16_t crc = 0xFFFF;

      for ( size_t i = 0; i < length; i++ ) {
          crc ^= (uint8_t)data[i] << 8;
          for ( uint8_t j = 0; j < 8; j++ ) {
              if ( crc & 0x8000 ) {
                  crc = ( crc << 1 ) ^ 0x1021;
              } else {
                  crc <<= 1;
              }
          }
      }

      return crc & 0xFFFF;
  }

Step 3.2: 实现传感器数据结构​

  #ifndef PAYLOAD_SEN5X_H
  #define PAYLOAD_SEN5X_H
  #include "SensorPayload.h"

  #define DEVICE_SEN54

  #if defined( DEVICE_SEN54 )
  #elif defined( DEVICE_SEN55 )
  #else
  #error "Please define a device in the compiler options."
  #endif
  #pragma pack(push, 1)
  typedef union {
      struct
      {
          uint16_t massConcentrationPm1p0;
          uint16_t massConcentrationPm2p5;
          uint16_t massConcentrationPm4p0;
          uint16_t massConcentrationPm10p0;
          int16_t  ambientHumidity;
          int16_t  ambientTemperature;
          int16_t  vocIndex;
  #ifdef DEVICE_SEN55
          int16_t noxIndex;
  #endif
      };

  #ifdef DEVICE_SEN55
      int16_t data[8];
  #else
      int16_t data[7];
  #endif
  } SEN5xData_t;
  #pragma pack(pop)
  void phraseSEN5xData( uint8_t *data_arry, SEN5xData_t *SEN5x );
  void prinSEN5xData( const SEN5xData_t *SEN5x );
  #endif // PAYLOAD_SEN5X_H
  #include "sen5x.h"
  #include "esp_log.h"
  void phraseSEN5xData( uint8_t *data_arry, SEN5xData_t *SEN5x )
  {
      for ( uint8_t i = 0; i < sizeof( SEN5xData_t ); i++ ) {
          SEN5x->data[i] = data_arry[2 * i] << 8 | data_arry[2 * i + 1];
      }
  }
  void prinSEN5xData( const SEN5xData_t *SEN5x )
  {
      static const char *TAG = "sen5x_";
      ESP_LOGI( TAG, "massConcentrationPm1p0: %d", SEN5x->massConcentrationPm1p0 );
      ESP_LOGI( TAG, "massConcentrationPm2p5: %d", SEN5x->massConcentrationPm2p5 );
      ESP_LOGI( TAG, "massConcentrationPm4p0: %d", SEN5x->massConcentrationPm4p0 );
      ESP_LOGI( TAG, "massConcentrationPm10p0: %d", SEN5x->massConcentrationPm10p0 );
      ESP_LOGI( TAG, "ambientHumidity: %d", SEN5x->ambientHumidity );
      ESP_LOGI( TAG, "ambientTemperature: %d", SEN5x->ambientTemperature );
      ESP_LOGI( TAG, "vocIndex: %d", SEN5x->vocIndex );
  #ifdef DEVICE_SEN55
      ESP_LOGI( TAG, "noxIndex: %d", SEN5x->noxIndex );
  #endif
  }

Step 3.3: 配置LoRa​

设置LoRa参数​

设置必要的LoRa参数，如频率、扩频因子和带宽。这些设置必须在两个LoRa通道之间匹配，以确保成功的通信。

#define RF_FREQUENCY               868000000 // Hz
#define LORA_BANDWIDTH             0         // [0: 125 kHz, 1: 250 kHz, 2: 500 kHz, 3: Reserved]
#define LORA_SPREADING_FACTOR      12        // [SF7..SF12]
#define LORA_CODINGRATE            1         // [1: 4/5, 2: 4/6, 3: 4/7, 4: 4/8]
#define LORA_PREAMBLE_LENGTH       15        // Same for Tx and Rx
#define LORA_SYMBOL_TIMEOUT        5         // Symbols
#define LORA_FIX_LENGTH_PAYLOAD_ON false
#define LORA_IQ_INVERSION_ON       false
设置LoRa收发器接收器​
void OnRxDone( uint8_t *payload, uint16_t size, int16_t rssi, int8_t snr )
{
    SEN5xData_t sen5x_data;
    Frame_t *frame = parsePayload( payload, size );
    if ( frame == NULL ) {
        ESP_LOGE( TAG, "parsePayload error" );
        return;
    }
    ESP_LOGI( TAG, "frame->type: %s", dataIDToString( frame->topic ) );

    switch ( frame->topic ) {
        case TOPICS_SEN5x:
            phraseSEN5xData( frame->data, &sen5x_data );
            break;
        default:
            break;
    }
    deleteFrame( frame );
}
初始化LoRa收发器​
RadioEvents.RxDone = OnRxDone;
Radio.Init( &RadioEvents );

Radio.SetChannel( RF_FREQUENCY );

Radio.SetRxConfig( MODEM_LORA, LORA_BANDWIDTH, LORA_SPREADING_FACTOR,
                    LORA_CODINGRATE, 0, LORA_PREAMBLE_LENGTH,
                    LORA_SYMBOL_TIMEOUT, LORA_FIX_LENGTH_PAYLOAD_ON,
                    0, true, 0, 0, LORA_IQ_INVERSION_ON, true );
Radio.SetMaxPayloadLength( MODEM_LORA, 255 );

Radio.Rx( 0 ); // Continuous Rx

Step 3.4: 编译并将代码烧录到SenseCAP Indicator​

/**
 * @source: https://github.com/Seeed-Solution/indicator_lora_commu/blob/29624d10643a41ae5e1e24124b81e93b5e3cd3bb/Indicator/main/main.c
 */
#include "bsp_board.h"
#include "esp_log.h"
#include "frame.h"
#include "radio.h"
#include "sen5x.h"

static const char *TAG = "app_main";

#define VERSION "v0.0.1"

#define SENSECAP "\n\
   _____                      _________    ____         \n\
  / ___/___  ____  ________  / ____/   |  / __ \\       \n\
  \\__ \\/ _ \\/ __ \\/ ___/ _ \\/ /   / /| | / /_/ /   \n\
 ___/ /  __/ / / (__  )  __/ /___/ ___ |/ ____/         \n\
/____/\\___/_/ /_/____/\\___/\\____/_/  |_/_/           \n\
--------------------------------------------------------\n\
 Version: %s %s %s\n\
--------------------------------------------------------\n\
"

#define RF_FREQUENCY               868000000 // Hz
#define LORA_BANDWIDTH             0         // [0: 125 kHz, 1: 250 kHz, 2: 500 kHz, 3: Reserved]
#define LORA_SPREADING_FACTOR      12        // [SF7..SF12]
#define LORA_CODINGRATE            1         // [1: 4/5, 2: 4/6, 3: 4/7, 4: 4/8]
#define LORA_PREAMBLE_LENGTH       15        // Same for Tx and Rx
#define LORA_SYMBOL_TIMEOUT        5         // Symbols
#define LORA_FIX_LENGTH_PAYLOAD_ON false
#define LORA_IQ_INVERSION_ON       false

static RadioEvents_t RadioEvents;

SEN5xData_t sen5x_data;

void OnRxDone( uint8_t *payload, uint16_t size, int16_t rssi, int8_t snr ) {
    int i = 0;
    ESP_LOGI( TAG, "rssi:%d dBm, snr:%d dB, len:%d, payload:", rssi, snr, size );
    for ( i = 0; i < size; i++ ) {
        printf( "0x%x ", payload[i] );
    }
    printf( "\n" );

    Frame_t *frame = parsePayload( payload, size );
    if ( frame == NULL ) {
        ESP_LOGE( TAG, "parsePayload error" );
        return;
    }
    ESP_LOGI( TAG, "frame->type: %s", dataIDToString( frame->topic ) );

    switch ( frame->topic ) {
        case TOPICS_SEN5x:
            phraseSEN5xData( frame->data, &sen5x_data );
            prinSEN5xData( &sen5x_data );
            break;

        default:
            break;
    }

    deleteFrame( frame );
}

void app_main( void ) {
    ESP_LOGI( "", SENSECAP, VERSION, __DATE__, __TIME__ );

    ESP_ERROR_CHECK( bsp_board_init() );

    ESP_LOGI( TAG, "APP MAIN START" );

    RadioEvents.RxDone = OnRxDone;
    Radio.Init( &RadioEvents );

    Radio.SetChannel( RF_FREQUENCY );

    Radio.SetRxConfig( MODEM_LORA, LORA_BANDWIDTH, LORA_SPREADING_FACTOR,
                       LORA_CODINGRATE, 0, LORA_PREAMBLE_LENGTH,
                       LORA_SYMBOL_TIMEOUT, LORA_FIX_LENGTH_PAYLOAD_ON,
                       0, true, 0, 0, LORA_IQ_INVERSION_ON, true );
    Radio.SetMaxPayloadLength( MODEM_LORA, 255 );

    Radio.Rx( 0 ); // Continuous Rx

    while ( 1 ) {
        vTaskDelay( pdMS_TO_TICKS( 10000 ) );
    }
}

Step 4: 测试通信​

将两个SenseCAP Indicator板上电并打开串行监视器。您应该看到两个板之间发送和接收的消息。恭喜！您已成功使用SenseCAP Indicator建立了LoRa通信。

Serial Monitor of XIAO
String: 76,80,81,81,5389,5990,980
0 4C 0 50 0 51 0 51 15 D 17 66 3 D4
CRC: 629
<<<AT+TEST=TXLRPKT,"010E004C005000510051150D176603D40629"
>>>+TEST: TX DONE
+TEST: TXLRPKT

Send payload successfully
Send data 1
Serial Monitor of SenseCAP Indicator
I (95490) app_main: rssi:-22 dBm, snr:5 dB, len:18, payload:
0x1 0xe 0x0 0x4c 0x0 0x50 0x0 0x51 0x0 0x51 0x15 0xd 0x17 0x66 0x3 0xd4 0x6 0x29
W (95541) parsePayload: topic: 1
W (95541) parsePayload: dataLength: 14
W (95545) parsePayload: payload[0]: 00
W (95549) parsePayload: payload[1]: 4C
W (95554) parsePayload: payload[2]: 00
W (95558) parsePayload: payload[3]: 50
W (95563) parsePayload: payload[4]: 00
W (95567) parsePayload: payload[5]: 51
W (95572) parsePayload: payload[6]: 00
W (95576) parsePayload: payload[7]: 51
W (95580) parsePayload: payload[8]: 15
W (95585) parsePayload: payload[9]: 0D
W (95589) parsePayload: payload[10]: 17
W (95594) parsePayload: payload[11]: 66
W (95598) parsePayload: payload[12]: 03
W (95603) parsePayload: payload[13]: D4
I (95607) app_main: frame->type: SEN5X
I (95612) sen5x_: massConcentrationPm1p0: 76
I (95617) sen5x_: massConcentrationPm2p5: 80
I (95622) sen5x_: massConcentrationPm4p0: 81
I (95627) sen5x_: massConcentrationPm10p0: 81
I (95632) sen5x_: ambientHumidity: 5389
I (95636) sen5x_: ambientTemperature: 5990
I (95641) sen5x_: vocIndex: 980

资源​

名称 功能
Beep Control 接受字符串"ON" or "OFF", 可以执行相应功能
PingPong 在主从设备和设备之间建立ping-pong通信模式
Multi-Sensor Data Upload XIAOS3收集数据并利用Wio-E5 (带LoRa模块和AT命令)上传传感器数据到Indicator.

有关更多详细信息，请参阅README文件。

技术支持​

需要帮助解决SenseCAP Indicator的问题吗？我们在这里帮助您！

如果您在遵循本教程时遇到任何问题或有任何疑问，请随时联系我们的技术支持。我们始终在此提供帮助！

访问我们的Seeed官方Discord频道提问，或者到GitHub讨论区分享您的想法！

Loading Comments...