星闪SLE透传模块

# 星闪SLE透传模块 STM32驱动代码例程

## 环境说明

- MCU: STM32F103C8T6
- HAL库版本: STM32F1xx HAL Driver
- IDE: Keil MDK / STM32CubeIDE
- 串口: USART2 (PA2 TX, PA3 RX) 连接星闪SLE模块
- 调试串口: USART3 (PB10 TX, PB11 RX) 连接USB-TTL

---

## 1. GPIO和串口初始化

```c
#include "stm32f1xx_hal.h"
#include <stdio.h>
#include <string.h>

// ========== 星闪SLE串口定义 ==========
// USART2: PA2 TX, PA3 RX
UART_HandleTypeDef huart2;

// 接收相关变量
uint8_t sle_rx_buf;                    // 单字节接收缓冲
char sle_cmd[256];                     // 接收命令缓存
uint8_t sle_cmd_idx = 0;               // 当前索引
volatile uint8_t sle_cmd_ready = 0;    // 命令就绪标志
volatile uint8_t at_mode = 0;          // AT模式标志(1=AT模式, 0=透传模式)

void MX_USART2_UART_Init(void)
{
    huart2.Instance = USART2;
    huart2.Init.BaudRate = 115200;
    huart2.Init.WordLength = UART_WORDLENGTH_8B;
    huart2.Init.StopBits = UART_STOPBITS_1;
    huart2.Init.Parity = UART_PARITY_NONE;
    huart2.Init.Mode = UART_MODE_TX_RX;
    huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    huart2.Init.OverSampling = UART_OVERSAMPLING_16;
    HAL_UART_Init(&huart2);
}

void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
{
    GPIO_InitTypeDef GPIO_InitStruct = {0};

    if (uartHandle->Instance == USART2) {
        __HAL_RCC_USART2_CLK_ENABLE();
        __HAL_RCC_GPIOA_CLK_ENABLE();

        // PA2 - TX
        GPIO_InitStruct.Pin = GPIO_PIN_2;
        GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
        GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
        HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

        // PA3 - RX
        GPIO_InitStruct.Pin = GPIO_PIN_3;
        GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
        GPIO_InitStruct.Pull = GPIO_NOPULL;
        HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

        HAL_NVIC_SetPriority(USART2_IRQn, 0, 0);
        HAL_NVIC_EnableIRQ(USART2_IRQn);
    }
}
```

---

## 2. 核心驱动函数

### 2.1 发送AT命令并等待响应

```c
/**
 * @brief  发送AT命令并等待响应
 * @param  cmd        AT命令字符串(需含\r\n)
 * @param  timeout_ms 超时时间(ms)
 * @return 1=收到OK, 0=超时或ERROR
 */
uint8_t SLE_Send_AT(const char* cmd, uint32_t timeout_ms)
{
    uint32_t start_time;
    uint8_t got_ok = 0;

    // 进入AT模式，清空接收缓冲
    at_mode = 1;
    HAL_NVIC_DisableIRQ(USART2_IRQn);
    sle_cmd_idx = 0;
    memset(sle_cmd, 0, sizeof(sle_cmd));
    HAL_UART_Receive_IT(&huart2, &sle_rx_buf, 1);
    HAL_NVIC_EnableIRQ(USART2_IRQn);

    // 发送AT命令
    HAL_UART_Transmit(&huart2, (uint8_t*)cmd, strlen(cmd), 1000);

    // 等待响应
    start_time = HAL_GetTick();
    while (HAL_GetTick() - start_time < timeout_ms) {
        HAL_Delay(50);
        if (sle_cmd_idx > 0) {
            if (strstr(sle_cmd, "OK") != NULL) {
                got_ok = 1;
                break;
            }
            if (strstr(sle_cmd, "ERROR") != NULL) {
                break;
            }
        }
    }

    at_mode = 0;
    return got_ok;
}
```

### 2.2 退出透传模式 (+++)

```c
/**
 * @brief  通过+++退出透传模式，进入AT模式
 * @note   需前后各1.5秒串口空闲
 */
void SLE_Exit_Transparent(void)
{
    at_mode = 1;
    sle_cmd_idx = 0;
    memset(sle_cmd, 0, sizeof(sle_cmd));

    HAL_Delay(1500);                              // 前置空闲
    HAL_UART_Transmit(&huart2, (uint8_t*)"+++", 3, 1000);
    HAL_Delay(1500);                              // 后置空闲

    at_mode = 0;
}
```

### 2.3 星闪SLE模块初始化流程

```c
/**
 * @brief  星闪SLE模块初始化
 * @note   配置为SLE Server(ROLE=3)，进入透传模式
 *         流程: +++退出透传 → AT检测 → ROLE=3 → RST → AT确认 → TRANSMODE
 */
void Init_SLE_Module(void)
{
    int retry;

    // Step 1: 退出透传模式
    SLE_Exit_Transparent();

    // Step 2: AT通信检测(最多重试3次)
    for (retry = 0; retry < 3; retry++) {
        if (SLE_Send_AT("AT\r\n", 2000)) {
            break;
        }
        HAL_Delay(500);
    }

    // Step 3: 设置为SLE Server角色
    SLE_Send_AT("AT+ROLE=3\r\n", 2000);

    // Step 4: 软复位使角色生效
    SLE_Send_AT("AT+RST\r\n", 3000);
    HAL_Delay(2000);  // 等待模块重启完成

    // Step 5: 复位后确认AT通信
    for (retry = 0; retry < 3; retry++) {
        if (SLE_Send_AT("AT\r\n", 2000)) {
            break;
        }
        HAL_Delay(500);
    }

    // Step 6: 进入透传模式
    SLE_Send_AT("AT+TRANSMODE\r\n", 2000);
}
```

### 2.4 透传发送数据

```c
/**
 * @brief  通过星闪SLE模块透传发送数据
 * @param  data 数据指针
 * @param  len  数据长度
 */
void SLE_Transparent_Send(const char* data, uint16_t len)
{
    HAL_UART_Transmit(&huart2, (uint8_t*)data, len, 1000);
}

/**
 * @brief  发送JSON状态到对端设备
 */
void SLE_Send_Status(float temp, float humi,
                     uint8_t light, uint8_t fan,
                     uint8_t curtain, uint8_t ac)
{
    char msg[160];
    snprintf(msg, sizeof(msg),
        "{\"event\":\"status\","
        "\"light\":%s,\"fan\":%s,\"curtain\":%d,\"ac\":%s,"
        "\"temp\":%.1f,\"humi\":%.1f,"
        "\"source\":\"device\"}\r\n",
        light ? "true" : "false",
        fan ? "true" : "false",
        curtain,
        ac ? "true" : "false",
        temp, humi
    );

    HAL_UART_Transmit(&huart2, (uint8_t*)msg, strlen(msg), 1000);
}
```

---

## 3. UART接收中断回调

```c
/**
 * @brief  USART2接收中断回调
 * @note   AT模式下：持续缓存，不按换行分包
 *         透传模式下：按换行符(\n/\r)分包，检测JSON action字段
 */
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
    if (huart->Instance != USART2) return;

    // 写入接收缓冲
    if (sle_cmd_idx < sizeof(sle_cmd) - 1) {
        sle_cmd[sle_cmd_idx++] = (char)sle_rx_buf;
        sle_cmd[sle_cmd_idx] = '\0';
    } else {
        // 缓冲区溢出，重置
        sle_cmd_idx = 0;
        memset(sle_cmd, 0, sizeof(sle_cmd));
        sle_cmd[sle_cmd_idx++] = (char)sle_rx_buf;
        sle_cmd[sle_cmd_idx] = '\0';
    }

    if (at_mode) {
        // AT模式：不按换行分包，由SLE_Send_AT轮询处理
    }
    else if (sle_rx_buf == '\n' || sle_rx_buf == '\r') {
        // 透传模式：按换行分包
        if (sle_cmd_idx > 1) {
            // 检查是否为JSON命令
            if (strstr(sle_cmd, "\"action\"") != NULL) {
                sle_cmd_ready = 1;  // 通知主循环处理
            }
            // 重置缓冲
            sle_cmd_idx = 0;
            memset(sle_cmd, 0, sizeof(sle_cmd));
        }
    }

    // 重新使能接收中断
    HAL_UART_Receive_IT(&huart2, &sle_rx_buf, 1);
}

void USART2_IRQHandler(void)
{
    HAL_UART_IRQHandler(&huart2);
}
```

---

## 4. 完整使用示例 — 智能家居控制

```c
// 全局变量
char sle_cmd_process[256];  // 待处理的SLE命令副本
volatile uint8_t sle_cmd_ready = 0;

// 设备状态
uint8_t light1_state = 0;
uint8_t fan_state = 0;
uint8_t curtain_level = 0;

/**
 * @brief  解析并处理SLE接收到的JSON命令
 */
void Process_SLE_Command(const char* cmd)
{
    uint8_t changed = 0;

    // 忽略心跳包
    if (strstr(cmd, "\"action\":\"heartbeat\"") ||
        strstr(cmd, "\"action\": \"heartbeat\"")) {
        return;
    }

    // 解析 set_light
    if (strstr(cmd, "\"action\":\"set_light\"") ||
        strstr(cmd, "\"action\": \"set_light\"")) {
        if (strstr(cmd, "\"value\":true") || strstr(cmd, "\"value\":1")) {
            light1_state = 1; changed = 1;
        } else if (strstr(cmd, "\"value\":false") || strstr(cmd, "\"value\":0")) {
            light1_state = 0; changed = 1;
        }
    }

    // 解析 set_fan
    if (strstr(cmd, "\"action\":\"set_fan\"") ||
        strstr(cmd, "\"action\": \"set_fan\"")) {
        if (strstr(cmd, "\"value\":true") || strstr(cmd, "\"value\":1")) {
            fan_state = 1; changed = 1;
        } else if (strstr(cmd, "\"value\":false") || strstr(cmd, "\"value\":0")) {
            fan_state = 0; changed = 1;
        }
    }

    // 解析 set_curtain_level
    if (strstr(cmd, "\"action\":\"set_curtain_level\"") ||
        strstr(cmd, "\"action\": \"set_curtain_level\"")) {
        if (strstr(cmd, "\"value\":0"))      { curtain_level = 0; changed = 1; }
        else if (strstr(cmd, "\"value\":1")) { curtain_level = 1; changed = 1; }
        else if (strstr(cmd, "\"value\":2")) { curtain_level = 2; changed = 1; }
    }

    // 变更后回传状态
    if (changed) {
        SLE_Send_Status(25.5f, 60.0f, light1_state, fan_state, curtain_level, 0);
    }
}

int main(void)
{
    HAL_Init();
    SystemClock_Config();
    MX_GPIO_Init();
    MX_USART2_UART_Init();

    // 启动接收中断
    HAL_UART_Receive_IT(&huart2, &sle_rx_buf, 1);

    // 初始化星闪SLE模块
    HAL_Delay(1000);
    Init_SLE_Module();

    uint32_t last_sensor_time = 0;

    while (1)
    {
        // 每2秒上报一次状态
        if (HAL_GetTick() - last_sensor_time >= 2000) {
            last_sensor_time = HAL_GetTick();
            SLE_Send_Status(25.5f, 60.0f,
                            light1_state, fan_state,
                            curtain_level, 0);
        }

        // 处理接收到的SLE命令
        if (sle_cmd_ready) {
            // 复制命令到处理缓冲区(避免中断竞争)
            // sle_cmd已在中断中准备好，此处简化示意
            Process_SLE_Command(sle_cmd);
            sle_cmd_ready = 0;
        }

        HAL_Delay(10);
    }
}
```

---

## 5. 常用AT命令速查

| 命令 | 说明 |
|:---|:---|
| `AT` | 测试通信，返回OK |
| `AT+ROLE=3` | 设为SLE Server |
| `AT+ROLE=4` | 设为SLE Client |
| `AT+TRANSMODE` | 进入透传模式 |
| `AT+RST` | 软复位 |
| `+++` | 退出透传(前后各1.5s空闲) |

---

## 注意事项

1. `+++` 退出透传需要前后各1.5秒串口空闲，在连续发送场景中需先暂停通信
2. AT模式下发送命令后需等待模块回复，不可连续发送多条命令
3. `AT+RST` 后模块需要约2秒重新初始化，期间不可发送命令
4. 透传模式下数据以 `\r\n` 为自然分包边界，JSON协议天然适配
5. 中断回调中不要做耗时操作，仅做数据缓存和标志位置位