LoRa私有协议对接ChirpStack全攻略

最新推荐文章于 2025-11-30 22:25:41 发布

原创最新推荐文章于 2025-11-30 22:25:41 发布 · 952 阅读

23 ·

CC 4.0 BY-SA版权

文章标签：

#php #开发语言 #LoRa #LoRaWan #网关 #ChirpStack

LoRa私有协议对接ChirpStack服务器

准备工作

确保ChirpStack服务器已部署并正常运行，获取服务器地址、端口、MQTT配置等信息。私有设备需支持LoRaWAN协议，并准备好DevEUI、AppKey等参数。

配置ChirpStack网络服务器

登录ChirpStack管理界面，创建新的应用（Application）。添加设备时选择"Overwrite existing device"，填写DevEUI、AppKey等参数。在"Device-profile"中选择适合的配置（如Class A/C）。

私有设备端配置

设备需实现LoRaWAN协议栈，以下为关键代码示例：

// LoRaWAN初始化
LMIC_init();
LMIC_setSession(0x1, DEVADDR, NWKSKEY, APPSKEY);
LMIC_setupChannel(0, 868100000, DR_RANGE_MAP(DR_SF12, DR_SF7), BAND_CENTI);
LMIC_setAdrMode(1);
LMIC_setLinkCheckMode(0);

数据格式转换

私有协议数据需转换为ChirpStack兼容格式：

def convert_to_chirpstack(payload):
    # 示例转换逻辑
    chirpstack_msg = {
        "devEUI": "00-80-00-00-00-00-00-01",
        "data": base64.b64encode(payload).decode('utf-8'),
        "fCnt": 1,
        "fPort": 1,
        "rxInfo": [{
            "gatewayID": "B827EBFFFE87BD22",
            "rssi": -57,
            "loRaSNR": 10
        }]
    }
    return json.dumps(chirpstack_msg)

MQTT连接示例

使用MQTT协议上传数据到ChirpStack：

import paho.mqtt.client as mqtt

client = mqtt.Client()
client.username_pw_set("username", "password")
client.connect("chirpstack.example.com", 1883)

topic = "application/1/device/0000000000000001/rx"
payload = convert_to_chirpstack(bytearray([0x01, 0x02, 0x03]))
client.publish(topic, payload)

下行数据处理

接收ChirpStack下发指令的示例：

def on_message(client, userdata, msg):
    print(f"Received message on {msg.topic}: {msg.payload}")

client.on_message = on_message
client.subscribe("application/1/device/+/tx")
client.loop_forever()

调试与验证

使用ChirpStack控制台查看设备状态和数据接收情况。验证设备激活状态（OTAA或ABP），检查帧计数器同步情况。使用MQTT客户端工具如MQTT.fx辅助调试通信流程。

注意事项

确保设备与服务器使用相同的LoRaWAN版本（如1.0.2）。 ABP模式需严格同步DevAddr、NwkSKey和AppSKey。 OTAA模式需确认JoinEUI、DevEUI和AppKey匹配。帧计数器（FCnt）需保持同步，避免重复计数导致丢包。

LoRa端侧代码实现

LoRa端侧代码通常运行在嵌入式设备上，使用LoRa模块（如SX1276/SX1278）与ChirpStack服务器通信。以下是一个基于STM32和LoRa模块的实现示例：

#include "stm32f1xx_hal.h"
#include "lora.h"

#define LORA_DEV_EUI {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07}
#define LORA_APP_EUI {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
#define LORA_APP_KEY {0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6, 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C}

void LoRa_Init() {
    LoRa_Reset();
    LoRa_SetFrequency(868000000);
    LoRa_SetSpreadingFactor(12);
    LoRa_SetSignalBandwidth(125000);
    LoRa_SetCodingRate(5);
    LoRa_SetPreambleLength(8);
    LoRa_SetSyncWord(0x34);
    LoRa_EnableCRC();
}

void LoRa_SendData(uint8_t *data, uint8_t length) {
    LoRa_BeginPacket();
    LoRa_Write(data, length);
    LoRa_EndPacket();
}

void LoRa_ReceiveData() {
    if (LoRa_ParsePacket() > 0) {
        uint8_t buffer[256];
        int length = LoRa_Read(buffer, sizeof(buffer));
        // 处理接收到的数据
    }
}

私有协议设计

私有协议通常在LoRaWAN应用层之上实现，可以自定义数据格式：

typedef struct {
    uint8_t device_id;
    uint8_t cmd_type;
    uint16_t data_len;
    uint8_t data[248];
    uint8_t checksum;
} PrivateProtocolPacket;

uint8_t CalculateChecksum(PrivateProtocolPacket *packet) {
    uint8_t checksum = 0;
    checksum ^= packet->device_id;
    checksum ^= packet->cmd_type;
    checksum ^= (packet->data_len >> 8);
    checksum ^= (packet->data_len & 0xFF);
    for (int i = 0; i < packet->data_len; i++) {
        checksum ^= packet->data[i];
    }
    return checksum;
}

ChirpStack协议对接

ChirpStack使用LoRaWAN协议，对接时需要配置设备参数：

{
  "device": {
    "devEui": "0001020304050607",
    "name": "PrivateDevice",
    "applicationKey": "2B7E151628AED2A6ABF7158809CF4F3C",
    "deviceProfileId": "fef1a599-3d1f-4b9e-a0c5-456d7e7716b4",
    "skipFCntCheck": true
  }
}

数据编解码示例

在ChirpStack中实现自定义解码器（JavaScript）：

function decodeUplink(input) {
    var bytes = input.bytes;
    var data = {};
    
    data.device_id = bytes[0];
    data.cmd_type = bytes[1];
    data.data_len = (bytes[2] << 8) | bytes[3];
    data.payload = bytes.slice(4, 4 + data.data_len);
    data.checksum = bytes[bytes.length - 1];
    
    return {
        data: data,
        warnings: [],
        errors: []
    };
}

function encodeDownlink(input) {
    var bytes = [];
    bytes.push(input.data.device_id);
    bytes.push(input.data.cmd_type);
    bytes.push((input.data.data_len >> 8) & 0xFF);
    bytes.push(input.data.data_len & 0xFF);
    bytes = bytes.concat(input.data.payload);
    bytes.push(calculateChecksum(input.data));
    
    return {
        bytes: bytes,
        fPort: 1
    };
}

嵌入式端定时任务处理

实现定时数据采集和发送：

void Process_TimerCallback() {
    static uint32_t last_send_time = 0;
    uint32_t current_time = HAL_GetTick();
    
    if (current_time - last_send_time >= 60000) {  // 每分钟发送一次
        SensorData sensor_data = CollectSensorData();
        PrivateProtocolPacket packet = {
            .device_id = 0x01,
            .cmd_type = 0xA1,
            .data_len = sizeof(SensorData),
            .data = {0}
        };
        memcpy(packet.data, &sensor_data, sizeof(SensorData));
        packet.checksum = CalculateChecksum(&packet);
        
        LoRa_SendData((uint8_t*)&packet, sizeof(PrivateProtocolPacket));
        last_send_time = current_time;
    }
    
    LoRa_ReceiveData();  // 检查下行数据
}

注意事项

确保设备EUI、应用EUI和应用密钥与ChirpStack服务器配置一致
私有协议设计时应考虑LoRaWAN的MTU限制（通常242字节）
实现完善的错误处理和重试机制
考虑设备低功耗设计，合理设置发送间隔
服务器端解码器应与设备端编码格式严格匹配

ESP32与Sx1262 LoRa模块的硬件连接

确保ESP32与Sx1262模块的SPI引脚正确连接：

SX1262的SCK接ESP32的GPIO18
MISO接GPIO19
MOSI接GPIO23
NSS接GPIO5
RESET接GPIO14
BUSY接GPIO26
DIO1接GPIO25（用于中断）

初始化SX1262与LoRa配置

使用RadioLib库进行初始化：

#include <RadioLib.h>
SX1262 radio = new Module(5, 25, 14, 26);  // NSS, DIO1, RESET, BUSY

void setup() {
  Serial.begin(115200);
  
  // 初始化SX1262
  int state = radio.begin(868.0, 125.0, 9, 7, 0x34, 20);
  if (state == ERR_NONE) {
    Serial.println("SX1262初始化成功");
  } else {
    Serial.print("初始化失败，错误码：");
    Serial.println(state);
    while (true);
  }

  // 设置LoRa参数
  radio.setOutputPower(14);  // 设置发射功率（dBm）
  radio.setCurrentLimit(100); // 设置电流限制（mA）
}

私有协议数据包结构设计

定义与ChirpStack兼容的数据包格式：

#pragma pack(push, 1)
typedef struct {
  uint8_t  devAddr[4];   // 设备地址
  uint8_t  fCtrl;        // 帧控制
  uint16_t fCnt;         // 帧计数器
  uint8_t  payload[50];  // 有效载荷（最大50字节）
  int16_t  rssi;         // 信号强度
  uint8_t  crc;          // CRC校验
} LoRaPacket_t;
#pragma pack(pop)

数据发送实现

封装发送函数：

void sendLoRaPacket(uint8_t* payload, size_t len) {
  LoRaPacket_t packet;
  memcpy(packet.devAddr, "\x01\x02\x03\x04", 4); // 示例设备地址
  packet.fCtrl = 0x80;  // ADR enabled
  packet.fCnt = getFrameCount(); // 实现帧计数递增
  
  memcpy(packet.payload, payload, len);
  packet.crc = calculateCRC((uint8_t*)&packet, sizeof(packet) - 1);

  // 发送数据
  int state = radio.transmit((uint8_t*)&packet, sizeof(packet));
  if (state == ERR_NONE) {
    Serial.println("数据发送成功");
  }
}

数据接收处理

实现接收中断处理：

volatile bool receivedFlag = false;

// 中断服务函数
void setFlag(void) {
  receivedFlag = true;
}

void loop() {
  if (receivedFlag) {
    receivedFlag = false;
    
    uint8_t buffer[64];
    int state = radio.readData(buffer, sizeof(buffer));
    
    if (state == ERR_NONE) {
      LoRaPacket_t* packet = (LoRaPacket_t*)buffer;
      processIncomingPacket(packet); // 处理接收到的数据
    }
  }
}

// 初始化时设置中断
radio.setDio1Action(setFlag);
radio.startReceive();

ChirpStack协议对接

实现ChirpStack上行数据解析：

void processIncomingPacket(LoRaPacket_t* packet) {
  // 验证设备地址
  if (memcmp(packet->devAddr, "\x01\x02\x03\x04", 4) != 0) {
    return; // 非法设备
  }

  // 验证CRC
  uint8_t crc = calculateCRC((uint8_t*)packet, sizeof(*packet) - 1);
  if (crc != packet->crc) {
    return; // CRC校验失败
  }

  // 构造ChirpStack JSON格式
  String json = "{\"rxInfo\":{\"rssi\":" + String(packet->rssi) + 
                "},\"phyPayload\":\"" + base64Encode(packet) + "\"}";
  
  // 通过HTTP或MQTT发送到ChirpStack
  sendToChirpStack(json);
}

关键函数实现

CRC校验算法示例：

uint8_t calculateCRC(uint8_t *data, size_t len) {
  uint8_t crc = 0xFF;
  for (size_t i = 0; i < len; i++) {
    crc ^= data[i];
    for (uint8_t bit = 0; bit < 8; bit++) {
      if (crc & 0x80) {
        crc = (crc << 1) ^ 0x31;
      } else {
        crc <<= 1;
      }
    }
  }
  return crc;
}

注意事项

频率合规性：确保使用的频段符合当地无线电法规（如EU 868MHz/AS 923MHz）
帧计数持久化：将fCnt保存到EEPROM或Flash，防止断电丢失
安全增强：建议实现MIC（Message Integrity Code）校验
低功耗优化：在电池供电场景下，需配置SX1262进入睡眠模式

完整实现需要结合具体硬件设计调整引脚定义，并通过ChirpStack控制台配置匹配的Device Profile。对于生产环境，建议增加加密传输（如AES-128）和OTAA入网流程支持。

LoRaWAN Class C模式端侧实现

Class C模式设备持续开启接收窗口，适合需要低延迟下行通信的场景。以下是基于STM32和Semtech SX1262的示例代码框架：

// LoRaWAN堆栈初始化
LoRaMacStatus_t status;
MibRequestConfirm_t mibReq;

mibReq.Type = MIB_PUBLIC_NETWORK;
mibReq.Param.EnablePublicNetwork = LORAWAN_PUBLIC_NETWORK;
LoRaMacMibSetRequestConfirm(&mibReq);

mibReq.Type = MIB_DEVICE_CLASS;
mibReq.Param.Class = CLASS_C;
LoRaMacMibSetRequestConfirm(&mibReq);

// 设置RX2窗口参数
mibReq.Type = MIB_RX2_CHANNEL;
mibReq.Param.Rx2Channel.Frequency = 869525000;
mibReq.Param.Rx2Channel.Datarate = DR_3;
LoRaMacMibSetRequestConfirm(&mibReq);

// 启动持续监听
LoRaMacTestRxWindowsOn(true);

私有协议对接ChirpStack实现

私有协议需要实现以下关键组件：

协议转换层

typedef struct {
    uint8_t  devAddr[4];
    uint8_t  fPort;
    uint8_t* payload;
    uint8_t  payloadSize;
} CustomProtocolPacket_t;

void ProcessPrivateProtocol(CustomProtocolPacket_t* packet) {
    McpsReq_t mcpsReq;
    mcpsReq.Type = MCPS_UNCONFIRMED;
    mcpsReq.Req.Unconfirmed.fPort = packet->fPort;
    mcpsReq.Req.Unconfirmed.fBuffer = packet->payload;
    mcpsReq.Req.Unconfirmed.fBufferSize = packet->payloadSize;
    
    memcpy(mcpsReq.Req.Unconfirmed.DstAddr, packet->devAddr, 4);
    
    LoRaMacMcpsRequest(&mcpsReq);
}

ChirpStack数据格式转换

// 上行数据示例
{
  "phyPayload": "ABCDEF0123456789", // Base64编码的LoRaWAN帧
  "rxInfo": {
    "gatewayID": "0123456789ABCDEF",
    "rssi": -60,
    "snr": 10.5,
    "location": {
      "latitude": 39.9042,
      "longitude": 116.4074
    }
  }
}

// 下行数据示例
{
  "devEUI": "0123456789ABCDEF",
  "confirmed": false,
  "fPort": 1,
  "data": "SGVsbG8=" // Base64编码
}

完整通信流程实现

void OnMacMcpsIndication(McpsIndication_t* mcpsIndication) {
    if(mcpsIndication->Status != LORAMAC_EVENT_INFO_STATUS_OK) {
        return;
    }

    CustomProtocolPacket_t customPacket;
    memcpy(customPacket.devAddr, mcpsIndication->DevAddr, 4);
    customPacket.fPort = mcpsIndication->Port;
    customPacket.payload = mcpsIndication->Buffer;
    customPacket.payloadSize = mcpsIndication->BufferSize;

    ConvertToPrivateProtocol(&customPacket);
}

void SendToChirpStack(uint8_t* data, uint8_t size) {
    // 使用MQTT或HTTP协议发送到ChirpStack
    char topic[64];
    sprintf(topic, "gateway/%s/event/up", GATEWAY_ID);

    char payload[256];
    CreateJsonPayload(data, size, payload);

    MqttPublish(topic, payload);
}

关键配置参数

// LoRaWAN参数配置
static LoRaMacRegion_t g_CurrentRegion = LORAMAC_REGION_CN470;
static uint8_t g_AppEui[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
static uint8_t g_DevEui[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 };
static uint8_t g_AppKey[] = { 0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6, 
                             0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C };

// ChirpStack MQTT配置
#define CHIRPSTACK_MQTT_BROKER "mqtt.example.com"
#define CHIRPSTACK_MQTT_PORT 1883
#define CHIRPSTACK_MQTT_USER "gateway"
#define CHIRPSTACK_MQTT_PASS "password"

注意事项

Class C设备需要处理频繁的下行消息，建议实现消息队列机制：

#define MAX_DOWNLINK_QUEUE 5

typedef struct {
    uint8_t  data[LORAMAC_PHY_MAXPAYLOAD];
    uint8_t  size;
    uint32_t timestamp;
} DownlinkMsg_t;

DownlinkMsg_t g_DownlinkQueue[MAX_DOWNLINK_QUEUE];

void ProcessDownlinkQueue(void) {
    for(int i=0; i<MAX_DOWNLINK_QUEUE; i++) {
        if(g_DownlinkQueue[i].size > 0) {
            HandlePrivateProtocolMessage(
                g_DownlinkQueue[i].data, 
                g_DownlinkQueue[i].size);
            g_DownlinkQueue[i].size = 0;
        }
    }
}

实现时需要特别注意：