Merge remote-tracking branch 'origin/master'

Core/Inc/E52.h

@@ -174,10 +174,13 @@ void E104_BT5005A_DST_ADDR_Fun(void);
 void E52_CtlPowerOn_Fun();
 //关闭lora电源
 void E52_CtlPowerOff_Fun();
+//获取睡眠延时时间
+void E52_Get_Sleep_Time_Fun();
 
 void schedule_Fun(void);
 
 void Enter_Sleep_ACK_Fun(void);
 
 void E52_AT_TYPE_Fun(uint8_t type);
+void E52_Heartbeat_Fun1();
 #endif //E52_H

Core/Inc/Global.h

@@ -10,20 +10,22 @@
 #include <sys/types.h>
 
 #include "ring_buffer.h"
+
 // 设备信息结构体
-typedef struct {
-    uint8_t isOnline;            // 设备是否就绪
-    uint8_t broadcast_type;         // 广播类型             01:单波 02:广播 03:多播
-    uint8_t loraDeviceAddress_H;    //设备地址高位           默认0
-    uint8_t loraDeviceAddress_L;    //设备地址低位           默认0
-    uint8_t target_addr_H;          // 目标地址高字节         默认FF
-    uint8_t target_addr_L;          // 目标地址低字节         默认FF
-    uint8_t powerValue;             //电量                  默认0
+typedef struct
+{
+    uint8_t isOnline; // 设备是否就绪
+    uint8_t broadcast_type; // 广播类型             01:单波 02:广播 03:多播
+    uint8_t loraDeviceAddress_H; //设备地址高位           默认0
+    uint8_t loraDeviceAddress_L; //设备地址低位           默认0
+    uint8_t target_addr_H; // 目标地址高字节         默认FF
+    uint8_t target_addr_L; // 目标地址低字节         默认FF
+    uint8_t powerValue; //电量                  默认0
     // uint8_t isSOS;
     // uint8_t receivingNewDataFlag;       //接收lora新数据
 
     //使能蓝牙收发数据
-    uint8_t BlDataFlag;         //BL_START:开始接收新蓝牙数据，BL_STOP.停止接收新蓝牙数据
+    uint8_t BlDataFlag; //BL_START:开始接收新蓝牙数据，BL_STOP.停止接收新蓝牙数据
 
     //后台的远程命令
     uint8_t commandFromCloud; //从云端接收到的命令     1.请求蓝牙数据，2.请求lora数据，3.睡眠 4，重新发送点卯数据
@@ -34,13 +36,13 @@ typedef struct {
     //rtc定时唤醒时间
     uint32_t rtc_wake_up_time;
 
-    uint16_t forwardBLAndLoraDataDuration;   //发送蓝牙间隔时间
-    uint8_t forwardBLAndLoraDataCount;   //发送蓝牙数量
-    uint8_t forwardBLAndLoraDataCountMax;  //发送蓝牙数量最大值
-
-    RingBuffer queueBLData;                 //蓝牙数据队列
-    RingBuffer queueLoraCommandData;        //命令数据队列
+    uint16_t forwardBLAndLoraDataDuration; //发送蓝牙间隔时间
+    uint8_t forwardBLAndLoraDataCount; //发送蓝牙数量
+    uint8_t forwardBLAndLoraDataCountMax; //发送蓝牙数量最大值
 
+    RingBuffer queueBLData;                         //蓝牙数据队列
+    RingBuffer queueLoraCommandData;                //命令数据队列
+    uint32_t sleepDelayDataDuration;                //睡眠延时时间
 } Device_structure;
 
 #endif //GLOBAL_H

Core/Src/E52.c

@@ -181,8 +181,8 @@ void E52_Send_Sleep_Fun() {
                              ((uint32_t)rx_buf_uart2[7]);
 
     if (sleep_seconds == 0 || sleep_seconds > 86399) {
-        printf("睡眠时间无效, 使用默认3000ms\r\n");
-        deviceInfo.rtc_wake_up_time = 3000;
+        printf("睡眠时间无效, 使用默认60s\r\n");
+        deviceInfo.rtc_wake_up_time = 60;//1分钟
     } else {
         deviceInfo.rtc_wake_up_time = sleep_seconds;
         printf("接收到睡眠时间: %lu 秒\r\n", sleep_seconds);
@@ -190,13 +190,31 @@ void E52_Send_Sleep_Fun() {
     // TODO: command:05
 }
 
+void E52_Get_Sleep_Time_Fun() {
+    printf("获取设备延时睡眠的时间\r\n");
+
+    // 解析睡眠时间 24小时秒数
+    uint32_t sleep_delay_seconds = ((uint32_t)rx_buf_uart2[5] << 16) |
+                             ((uint32_t)rx_buf_uart2[6] << 8)  |
+                             ((uint32_t)rx_buf_uart2[7]);
+
+    if (sleep_delay_seconds == 0 || sleep_delay_seconds > 86399) {
+        printf("延时睡眠时间无效, 使用默认60s\r\n");
+        deviceInfo.sleepDelayDataDuration = 60; //默认1分钟睡眠
+    } else {
+        deviceInfo.sleepDelayDataDuration = sleep_delay_seconds;
+        printf("接收到睡眠时间: %lu 秒\r\n", sleep_delay_seconds);
+    }
+    // TODO: command:06
+}
+
 void E52_Heartbeat_Fun1() {
     printf("这是让设备重新发送点卯命令\r\n");
     Heartbeat_structure heartbeat_structure;
 
     heartbeat_structure.frame_header_H = 0x55;
     heartbeat_structure.frame_header_L = 0xAA;
-    heartbeat_structure.function_code = 0x01;
+    heartbeat_structure.function_code = 0x03; //这里改成03 区别与01。这是请求上线才发的。
     heartbeat_structure.badge_addr_high = deviceInfo.loraDeviceAddress_H;
     heartbeat_structure.badge_addr_low = deviceInfo.loraDeviceAddress_L;
     heartbeat_structure.broadcast_type = deviceInfo.broadcast_type;
@@ -244,7 +262,6 @@ void E52_Analyze_Data() {
             deviceInfo.commandFromCloud = COMBINE_CMD_STEP(E52_ENTER_SLEEP, RTC_SLEEP_STEP);
             break;
         case E52_HEARTBEAT:// 完成
-            E52_Heartbeat_Fun1();
             deviceInfo.commandFromCloud = COMBINE_CMD_STEP(E52_HEARTBEAT, HEARTBEAT_SEND);
             break;
         case IS_ONLINE: //完成

Core/Src/main.c

@@ -88,10 +88,11 @@ void Device_Info_Init_Fun() {
     RingBuffer_Init(&deviceInfo.queueBLData);
     RingBuffer_Init(&deviceInfo.queueLoraCommandData);
 
+    deviceInfo.sleepDelayDataDuration = 60;
     deviceInfo.isOnline = FALSE;
     deviceInfo.broadcast_type = BROADCAST_ALL;
-    deviceInfo.loraDeviceAddress_H = 0xFE; //默认地址高位
-    deviceInfo.loraDeviceAddress_L = 0xEF; //默认地址低位
+    deviceInfo.loraDeviceAddress_H = 0xFF; //默认地址高位
+    deviceInfo.loraDeviceAddress_L = 0xFF; //默认地址低位
     deviceInfo.powerValue = 0;
     deviceInfo.target_addr_H = 0xFF;
     deviceInfo.target_addr_L = 0xFF;
@@ -203,13 +204,17 @@ int main(void)
     E52_CtlPowerOn_Fun();
     Device_Info_Init_Fun();
     Flash_Read_LoraAddr(&deviceInfo.loraDeviceAddress_H, &deviceInfo.loraDeviceAddress_L);
-    HAL_Delay(4000);
+    HAL_Delay(5000);
     // 启动 USART2 DMA 接收
     HAL_UART_Receive_DMA(&huart3, rx_buf_uart3, sizeof(rx_buf_uart3));
     __HAL_UART_ENABLE_IT(&huart3, UART_IT_IDLE);
     HAL_UART_Receive_DMA(&huart2, rx_buf_uart2_DMA, sizeof(rx_buf_uart2_DMA));
     __HAL_UART_ENABLE_IT(&huart2, UART_IT_IDLE);
 
+    //重启蓝牙
+    E104_BT5005A_WAKE_UP_Fun();
+    HAL_Delay(500);
+
     // 判断是否第一次启动（没有配置地址）
     if (deviceInfo.loraDeviceAddress_H == 0xFF || deviceInfo.loraDeviceAddress_L == 0xFF ||
         deviceInfo.loraDeviceAddress_H == 0x00 || deviceInfo.loraDeviceAddress_L == 0x00) {
@@ -248,6 +253,7 @@ int main(void)
                 deviceInfo.loraDeviceAddress_H != 0x00 && deviceInfo.loraDeviceAddress_L != 0x00) {
                 printf("LoRa 地址配置完成: 0x%02X%02X\r\n",
                        deviceInfo.loraDeviceAddress_H, deviceInfo.loraDeviceAddress_L);
+                Flash_Write_LoraAddr(deviceInfo.loraDeviceAddress_H, deviceInfo.loraDeviceAddress_L);
                 break;
             }
 
@@ -276,7 +282,12 @@ int main(void)
     } else {
         printf("LoRa 地址已存在: 0x%02X%02X\r\n",
                deviceInfo.loraDeviceAddress_H, deviceInfo.loraDeviceAddress_L);
-        E52_Heartbeat_Fun();
+
+        const char *lora_msg4 = "AT+ROUTER_CLR=1"; //删除路由信息表
+        HAL_UART_Transmit(&huart2, (uint8_t *) lora_msg4, strlen(lora_msg4), HAL_MAX_DELAY);
+        HAL_Delay(500);
+
+        // E52_Heartbeat_Fun();
     }
     // srand(HAL_GetTick()); // 设置随机数种子
   /* USER CODE END 2 */
@@ -285,7 +296,7 @@ int main(void)
   /* USER CODE BEGIN WHILE */
 
     // printf("设备地址：0x%02X%02X\n", deviceInfo.loraDeviceAddress_H, deviceInfo.loraDeviceAddress_L);
-
+    deviceInfo.commandFromCloud = COMBINE_CMD_STEP(IDLE, STEP_INIT);//进入流程前，初始化状态
 
     while (1) {
     /* USER CODE END WHILE */
@@ -318,6 +329,7 @@ int main(void)
         // 解析后台命令
         if (GET_CMD(deviceInfo.commandFromCloud) == IDLE && GET_STEP(deviceInfo.commandFromCloud) == STEP_VERIFY) {
             E52_Analyze_Data();
+            memset(rx_buf_uart2, 0, 25);//使用完毕，清除数据
         }
 
         // 03:请求蓝牙数据
@@ -371,8 +383,8 @@ int main(void)
             switch (GET_STEP(deviceInfo.commandFromCloud)) {
                 case HEARTBEAT_SEND:
                     printf("心跳发送2\r\n");
-                    E52_Heartbeat_Fun();
-                    deviceInfo.commandFromCloud = COMBINE_CMD_STEP(REQUEST_BLUETOOTH_DATA, STEP_COMPLETE);
+                    E52_Heartbeat_Fun1();
+                    deviceInfo.commandFromCloud = COMBINE_CMD_STEP(E52_HEARTBEAT, STEP_COMPLETE);
                     break;
                 case STEP_COMPLETE:
                     deviceInfo.commandFromCloud = COMBINE_CMD_STEP(IDLE, STEP_INIT);
@@ -408,7 +420,7 @@ int main(void)
                     break; //如果是单波，多播，配置目标地址
 
                 case STEP_COMPLETE:
-                    printf("心跳发送3\r\n");
+                    // printf("心跳发送3\r\n");
 //                    E52_Heartbeat_Fun(); //配置完成，发送心跳包会导致后台循环发布配置命令
                     deviceInfo.commandFromCloud = COMBINE_CMD_STEP(IDLE, STEP_INIT);
                     break;
@@ -419,12 +431,27 @@ int main(void)
                     break;
             }
         }
-
+        // 05:睡眠时间
         if (GET_CMD(deviceInfo.commandFromCloud) == E52_ENTER_SLEEP && deviceInfo.isOnline) {
-            Enter_Sleep_ACK_Fun();
-            HAL_Delay(2000);
+            // Enter_Sleep_ACK_Fun();
+            // HAL_Delay(2000);
             E104_BT5005A_SLEEP_Fun();
-            HAL_Delay(2000);
+            uint32_t sleepDelayTime = 0;  // 当前等待时间（32位）
+            // deviceInfo.sleepDelayDataDuration 为总时间（32位）
+
+            while (sleepDelayTime < deviceInfo.sleepDelayDataDuration)
+            {
+                // 显示当前进度和总时间，使用%lu匹配32位无符号整数
+                printf("睡眠倒计时：%lu/%lu秒 [剩余%lu秒]\r\n",
+                       sleepDelayTime,
+                       deviceInfo.sleepDelayDataDuration,
+                       deviceInfo.sleepDelayDataDuration - sleepDelayTime);
+                HAL_GPIO_TogglePin(PowerLED_GPIO_Port, PowerLED_Pin);
+                sleepDelayTime++;
+                HAL_Delay(1000);
+            }
+
+
             Set_Alarm_After(deviceInfo.rtc_wake_up_time);
         }
     }

Core/Src/stm32f1xx_it.c

@@ -267,8 +267,8 @@ void USART2_IRQHandler(void)
   /* USER CODE BEGIN USART2_IRQn 1 */
   if (__HAL_UART_GET_FLAG(&huart2, UART_FLAG_IDLE))
   {
-    __HAL_UART_CLEAR_IDLEFLAG(&huart2);    // 清除空闲标志
-    HAL_UART_DMAStop(&huart2);             // 停止 DMA
+    __HAL_UART_CLEAR_IDLEFLAG(&huart2); // 清除空闲标志
+    HAL_UART_DMAStop(&huart2); // 停止 DMA
 
     // 实际接收长度
     uint16_t rx_len = UART2_DMA_BUF_LEN - __HAL_DMA_GET_COUNTER(huart2.hdmarx);
@@ -277,34 +277,55 @@ void USART2_IRQHandler(void)
     {
       // ====== 协议帧校验 ======
       if (rx_len == 12 &&
-          rx_buf_uart2_DMA[0] == 0x55 &&
-          rx_buf_uart2_DMA[1] == 0xBB &&
-          rx_buf_uart2_DMA[3] == deviceInfo.loraDeviceAddress_H &&
-          rx_buf_uart2_DMA[4] == deviceInfo.loraDeviceAddress_L &&
-          rx_buf_uart2_DMA[10] == 0xFF &&
-          rx_buf_uart2_DMA[11] == 0xEE)
+        rx_buf_uart2_DMA[0] == 0x55 &&
+        rx_buf_uart2_DMA[1] == 0xBB &&
+        rx_buf_uart2_DMA[3] == deviceInfo.loraDeviceAddress_H &&
+        rx_buf_uart2_DMA[4] == deviceInfo.loraDeviceAddress_L &&
+        rx_buf_uart2_DMA[10] == 0xFF &&
+        rx_buf_uart2_DMA[11] == 0xEE)
       {
-        if (rx_buf_uart2_DMA[2] == 0x0A || (GET_CMD(deviceInfo.commandFromCloud) == IDLE &&
-            GET_STEP(deviceInfo.commandFromCloud) == STEP_INIT))
+        if (rx_buf_uart2_DMA[2] == 0x0A || rx_buf_uart2_DMA[2] == 0x05 || (GET_CMD(deviceInfo.commandFromCloud) == IDLE
+          &&
+          GET_STEP(deviceInfo.commandFromCloud) == STEP_INIT))
         {
-            deviceInfo.isOnline = TRUE;
-          memcpy(rx_buf_uart2, rx_buf_uart2_DMA, rx_len);   // 拷贝实际接收数据
+          deviceInfo.isOnline = TRUE;
+          if (rx_buf_uart2_DMA[2] == 0x05)
+          {
+            deviceInfo.sleepDelayDataDuration = 0;//单独对某个设备进行睡眠，等待时间改为5秒
+          }
+          memcpy(rx_buf_uart2, rx_buf_uart2_DMA, rx_len); // 拷贝实际接收数据
           deviceInfo.commandFromCloud = COMBINE_CMD_STEP(IDLE, STEP_VERIFY);
         }
       }
+      else if (rx_buf_uart2_DMA[2] == 0x05) //睡眠最高权限
+      {
+        deviceInfo.isOnline = TRUE;
+        if (deviceInfo.sleepDelayDataDuration == 0)
+        {
+          deviceInfo.sleepDelayDataDuration = 60;//集体睡眠，而且没有配置时间，默认是1分钟
+        }
+        memcpy(rx_buf_uart2, rx_buf_uart2_DMA, rx_len); // 拷贝实际接收数据
+        deviceInfo.commandFromCloud = COMBINE_CMD_STEP(IDLE, STEP_VERIFY);
+      }
+      else if (rx_buf_uart2_DMA[2] == 0x06) //获取睡眠延时时间
+      {
+        deviceInfo.isOnline = TRUE;
+        memcpy(rx_buf_uart2, rx_buf_uart2_DMA, rx_len); // 拷贝实际接收数据
+        E52_Get_Sleep_Time_Fun();
+      }
       // ====== 判断 "SUCCESS" ======
-      else if (rx_len >= 7 && strncmp((char *)rx_buf_uart2_DMA, "SUCCESS", 7) == 0)
+      else if (rx_len >= 7 && strncmp((char*)rx_buf_uart2_DMA, "SUCCESS", 7) == 0)
       {
-         deviceInfo.loraSendSuccessFlag = 0;
+        deviceInfo.loraSendSuccessFlag = 0;
       }
       // ====== 判断 "AT" 指令 ======
-      else if (rx_len >= 2 && strncmp((char *)rx_buf_uart2_DMA, "AT", 2) == 0)
+      else if (rx_len >= 2 && strncmp((char*)rx_buf_uart2_DMA, "AT", 2) == 0)
       {
-        char *ptr = strstr((char *)rx_buf_uart2_DMA, "SRC_ADDR=0x");
+        char* ptr = strstr((char*)rx_buf_uart2_DMA, "SRC_ADDR=0x");
         if (ptr != NULL)
         {
           ptr += strlen("SRC_ADDR=0x");
-          if ((ptr - (char *)rx_buf_uart2_DMA) + 4 <= rx_len) // 确保数据够长
+          if ((ptr + 4) <= ((char*)rx_buf_uart2_DMA + rx_len)) // 确保数据够长
           {
             char hexStr[5] = {0};
             strncpy(hexStr, ptr, 4);
@@ -312,14 +333,14 @@ void USART2_IRQHandler(void)
 
             deviceInfo.loraDeviceAddress_H = (addr >> 8) & 0x7F; //首位置空：因为修改type会改变地址
             deviceInfo.loraDeviceAddress_L = addr & 0xFF;
-            Flash_Write_LoraAddr(deviceInfo.loraDeviceAddress_H, deviceInfo.loraDeviceAddress_L);
+            // Flash_Write_LoraAddr(deviceInfo.loraDeviceAddress_H, deviceInfo.loraDeviceAddress_L);
           }
         }
       }
     }
 
     // 统一清空并重启 DMA
-    memset(rx_buf_uart2_DMA, 0, UART2_DMA_BUF_LEN);
+    // memset(rx_buf_uart2_DMA, 0, UART2_DMA_BUF_LEN);
     HAL_UART_Receive_DMA(&huart2, rx_buf_uart2_DMA, UART2_DMA_BUF_LEN);
   }
   /* USER CODE END USART2_IRQn 1 */

README.md

@@ -52,8 +52,8 @@
         FF EE       : 帧尾
     }
 
-5.中继休眠
-55 BB 05 BA 8F 00 00 00 34 60 FF EE  ->  55 AA 05 AC 95 03 34 60 FF EE(返回值：确认睡眠)
+5.0中继休眠（对单，立刻睡眠）
+55 BB 05 BA 8F 00 00 00 34 60 FF EE
 
     {
         55 BB       : 帧头
@@ -64,7 +64,28 @@
         FF EE       : 帧尾
     }
 
+5.1中继休眠（对群默认1分钟）
+55 BB 05 FF FF 00 00 00 34 60 FF EE
 
+    {
+        55 BB       : 帧头
+        05          : 命令（睡眠）
+        FF FF       : 设备地址
+        00 00 00    : 睡眠时间 24小时（1 ~ 86399）秒
+        34 60       : 目标地址
+        FF EE       : 帧尾
+
+6.延时睡眠(对群，任何时候都可以发送)
+55 BB 06 FF FF 00 00 00 34 60 FF EE
+
+    {
+        55 BB       : 帧头
+        06          : 命令（睡眠时间）
+        FF FF       : 设备地址
+        00 00 00    : 延时睡眠时间 24小时（1 ~ 86399）秒
+        34 60       : 目标地址
+        FF EE       : 帧尾
+    }
 
 ----------------------------------------------------------------------------------------------------------
 向后台发送的命令