#include "rtu.h" #include "para.h" #include "main.h" #include "usart.h" #include "pm.h" #include "rtu.h" #include "usart.h" #include "w25qxx.h" #include "crc.h" #include "rec.h" #include "string.h" #include "app_rtc.h" #include "sensor.h" #include "ymodem.h" #define diff_abs(a, b) ((a > b) ? (a - b) : (b - a)) #define CMD_STATUS_REQ 0x01 // 状态查询 #define CMD_UPLOAD_REC 0x02 // 上传记录 #define CMD_TIME_SYNC 0x03 // 校时 #define CMD_PARA_SYNC 0x04 // 参数同步 #define CMD_GET_REALTIME 0x05 // 获取实时数据 #define CMD_POWERDOWN_NOTICE 0x06 // 通知即将掉电 #define CMD_OTA_START 0x07 // 本地串口 YMODEM 升级 typedef enum { RTU_STA_IDLE, RTU_STA_GET_STATUS, RTU_STA_CHK_ONLINE, RTU_STA_CHK_PARA, RTU_STA_CHK_OTA, RTU_STA_TIME_SYNC, RTU_STA_SND_REC, RTU_STA_WAIT_RESP, RTU_STA_WAIT_READY, RTU_STA_NOTYIFY_POWER_DOWN } rtu_sta_t; struct { uint8_t trig_src; // 0:计划 1:按键 rtu_sta_t tsk_sta; rtu_sta_t next_sta; uint8_t last_cmd; uint32_t running_timer; // 总运行时间定时器 uint32_t tsk_timer; uint32_t tsk_tmo; int rx_len; uint32_t rx_timer; uint8_t rx_buf[128]; int key_wakeup; int online; int ota_ongoing; int time_syncd; int ota_chked; int para_chked; int photo_ongoing; int rec_ongoing; uint8_t power_down_ongoing; uint8_t power_down_cnt; // 切断rtu电源的倒计时,单位秒 uint8_t ota_need_reset; // OTA 升级完成后待复位标志 struct { uint16_t count; uint16_t index[24]; } rec_pack; } rtu_ctx; static uint8_t rtu_last_wakeup_hour = 0; void rtu_init(uint8_t trig_src) { if (pm_get_lock("rtu") < 0) { return; } memset(&rtu_ctx, 0, sizeof(rtu_ctx)); MX_USART2_UART_Init(); LL_USART_EnableIT_RXNE(COM_RTU); // 打开电源 HAL_GPIO_WritePin(PWR_RTU_GPIO_Port, PWR_RTU_Pin, GPIO_PIN_SET); rtu_ctx.running_timer = HAL_GetTick(); // 暂时不处理ota rtu_ctx.ota_chked = 1; rtu_ctx.ota_ongoing = 0; rtu_ctx.tsk_sta = RTU_STA_GET_STATUS; rtu_ctx.trig_src = trig_src; rtu_ctx.key_wakeup = trig_src; rtu_ctx.ota_need_reset = 0; } void rtu_deinit(void) { // 关闭rtu电源 HAL_GPIO_WritePin(PWR_RTU_GPIO_Port, PWR_RTU_Pin, GPIO_PIN_RESET); // 关闭所使用到的外设 LL_USART_DisableIT_RXNE(COM_RTU); LL_USART_DeInit(COM_RTU); LL_APB1_GRP1_DisableClock(LL_APB1_GRP1_PERIPH_USART2); // 串口输入设置为模拟输入 LL_GPIO_InitTypeDef GPIO_InitStruct = {0}; GPIO_InitStruct.Pin = LL_GPIO_PIN_2 | LL_GPIO_PIN_3; GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG; LL_GPIO_Init(GPIOA, &GPIO_InitStruct); // 释放功耗锁 pm_release_lock("rtu"); rtu_ctx.tsk_sta = RTU_STA_IDLE; rtu_ctx.key_wakeup = 0; } static void rtu_write(uint8_t *buf, int sz) { if (sz) { for (int i = 0; i < sz; i++) { LL_USART_TransmitData8(COM_RTU, buf[i]); while (!LL_USART_IsActiveFlag_TC(COM_RTU)) ; } } } static int rtu_escape_data(uint8_t *src, int src_len, uint8_t *dst, int dst_size) { int dst_len = 0; for (int i = 0; i < src_len && dst_len < dst_size - 1; i++) { if (src[i] == 0x7E) { if (dst_len + 2 <= dst_size) { *dst++ = 0x7D; *dst++ = 0x5E; dst_len += 2; } else { return -1; // 不足空间进行转义 } } else if (src[i] == 0x7D) { if (dst_len + 2 <= dst_size) { *dst++ = 0x7D; *dst++ = 0x5D; dst_len += 2; } else { return -1; // 不足空间进行转义 } } else { *dst++ = src[i]; dst_len++; } } return dst_len; } int rtu_send_pkt(uint8_t addr, uint8_t cmd, uint8_t *msg, uint16_t len) { uint8_t buf[512]; uint8_t escaped_buf[512]; uint16_t crc; int escaped_len; int data_len = 0; buf[data_len++] = addr; buf[data_len++] = cmd; if (len && msg) { memcpy(buf + data_len, msg, len); data_len += len; } crc = CRC16(buf, data_len); buf[data_len++] = crc & 0xFF; buf[data_len++] = crc >> 8; // 对帧头和帧尾之间的所有数据进行转义 escaped_len = rtu_escape_data(buf, data_len, escaped_buf, sizeof(escaped_buf)); if (escaped_len < 0) { return -1; } int frame_len = 0; buf[frame_len++] = 0x7D; memcpy(buf + frame_len, escaped_buf, escaped_len); frame_len += escaped_len; buf[frame_len++] = 0x7E; rtu_write(buf, frame_len); rtu_ctx.last_cmd = cmd; return 0; } int rtu_read(uint8_t *buf, int sz, int *len) { if (rtu_ctx.rx_len > 0) { int deltT = HAL_GetTick() - rtu_ctx.rx_timer; if (deltT > 20) { *len = rtu_ctx.rx_len; if (*len > sz) { *len = sz; } memcpy(buf, (void *)rtu_ctx.rx_buf, rtu_ctx.rx_len); rtu_ctx.rx_len = 0; return 0; } } return 1; } void rtu_parse_sta(uint32_t sta) { rtu_ctx.online = (sta & 0x01) ? 1 : 0; rtu_ctx.ota_ongoing = (sta & 0x02) ? 1 : 0; rtu_ctx.photo_ongoing = (sta & 0x0c) >> 2; rtu_ctx.rec_ongoing = (sta & 0x30) >> 4; } void rtu_pack_rec(uint8_t *buf, int sz) { uint16_t start_index = 0; rec_data_t rec; rtu_ctx.rec_pack.count = 0; if (!buf) { return; } for (int i = 0; i < RECORD_MAX_COUNT; i++) { if ((rtu_ctx.rec_pack.count + 1) * sizeof(rec_data_t) > sz) { break; } if (rec_read(start_index, &rtu_ctx.rec_pack.index[rtu_ctx.rec_pack.count], &rec) == 0) { uint8_t *p = &buf[sizeof(rec_data_t) * rtu_ctx.rec_pack.count]; *p++ = rec.timestamp >> 24; *p++ = rec.timestamp >> 16; *p++ = rec.timestamp >> 8; *p++ = rec.timestamp; *p++ = rec.temperature >> 8; *p++ = rec.temperature; *p++ = rec.humidity >> 8; *p++ = rec.humidity; *p++ = rec.illuminance >> 24; *p++ = rec.illuminance >> 16; *p++ = rec.illuminance >> 8; *p++ = rec.illuminance; *p++ = rec.voltage >> 8; *p++ = rec.voltage; start_index = rtu_ctx.rec_pack.index[rtu_ctx.rec_pack.count] + 1; rtu_ctx.rec_pack.count++; } else { break; } } } static int rtu_unescape_data(const uint8_t *src, int src_len, uint8_t *dst, int dst_size) { const uint8_t *src_end = src + src_len; uint8_t *dst_start = dst; uint8_t *dst_end = dst + dst_size; while (src < src_end && dst < dst_end) { uint8_t byte = *src++; if (byte == 0x7D) { if (src < src_end) { byte = *src++; if (byte == 0x5E) { byte = 0x7E; } else if (byte == 0x5D) { byte = 0x7D; } else { return -1; // 无效的转义序列 } } else { return -1; // 转义字符后面没有数据 } } *dst++ = byte; } return dst - dst_start; } // 发送一条实时记录 static void rtu_send_realtime_data(void) { uint8_t ack[14]; sensor_data_t data; rtc_time_t time; uint32_t timestamp; rtc_get_time(&time); timestamp = rtc_mktime(&time); sensor_get_data(&data); data.voltage = data.voltage; ack[0] = timestamp >> 24; ack[1] = timestamp >> 16; ack[2] = timestamp >> 8; ack[3] = timestamp; ack[4] = data.temperature >> 8; ack[5] = data.temperature; ack[6] = data.humidity >> 8; ack[7] = data.humidity; ack[8] = data.illuminance >> 24; ack[9] = data.illuminance >> 16; ack[10] = data.illuminance >> 8; ack[11] = data.illuminance; ack[12] = data.voltage >> 8; ack[13] = data.voltage; rtu_send_pkt(1, 0x05, ack, 14); } int rtu_rx_proc(uint8_t *buf, int len) { int processed = 0; while (len > 0) { // 查找帧头0x7D int frame_start = -1; for (int i = 0; i < len; i++) { if (buf[i] == 0x7D) { if (i + 1 < len) { if (buf[i + 1] == 0x5E || buf[i + 1] == 0x5D) { i++; continue; } } frame_start = i; break; } } if (frame_start < 0) { break; } if (frame_start > 0) { buf += frame_start; len -= frame_start; } if (len < 6) { break; } // 查找帧尾 0x7E int frame_end = -1; for (int i = 1; i < len; i++) { if (buf[i] == 0x7E) { frame_end = i; break; } } if (frame_end < 0) { break; } // 提取完整帧进行处理 int frame_len = frame_end + 1; // 检查帧长度有效性 if (frame_len < 6) { buf += frame_len; len -= frame_len; continue; } // 将已经转义的字节恢复 uint8_t unescaped_buf[frame_len - 2]; // 不包括起始符和结束符 int unescaped_len = rtu_unescape_data(buf + 1, frame_len - 2, unescaped_buf, sizeof(unescaped_buf)); if (unescaped_len < 0) { // 解转义错误,跳过此帧继续处理 buf += frame_len; len -= frame_len; continue; } // CRC校验 if (CRC16(unescaped_buf, unescaped_len) != 0) { buf += frame_len; len -= frame_len; continue; } if (unescaped_buf[1] == rtu_ctx.last_cmd) { rtu_ctx.tsk_tmo = 0; } switch (unescaped_buf[1]) { case 0x01: // 状态应答 case 0x06: // 掉电通知的应答 { if (unescaped_len >= 6) { uint32_t sta; sta = (uint32_t)(unescaped_buf[2] << 24 | unescaped_buf[3] << 16 | unescaped_buf[4] << 8 | unescaped_buf[5]); rtu_parse_sta(sta); } } break; case 0x02: // 记录上传的应答 // 记录上传成功,删除已经发送的记录 for (int i = 0; i < rtu_ctx.rec_pack.count; i++) { rec_delete(rtu_ctx.rec_pack.index[i]); } break; case 0x03: // 校时应答 { if (unescaped_len >= 6) { uint32_t server_time, local_time; rtc_time_t time; server_time = (uint32_t)(unescaped_buf[2] << 24 | unescaped_buf[3] << 16 | unescaped_buf[4] << 8 | unescaped_buf[5]); rtc_get_time(&time); local_time = rtc_mktime(&time); // 根据服务器时间校准本机时间 if (diff_abs(server_time, local_time) > 2) { rtc_gmtime(&time, server_time); rtc_set_time(&time); } rtu_ctx.time_syncd = 1; } } break; case 0x04: // 参数同步请求的应答 { if (unescaped_len >= 7) { uint32_t para_ver; // 获取4字节参数版本号,大端模式 para_ver = (uint32_t)((unescaped_buf[2] << 24) | (unescaped_buf[3] << 16) | (unescaped_buf[4] << 8) | unescaped_buf[5]); if (para_ver != para.ver || para.mode != unescaped_buf[6] || para.light_mode_hours != unescaped_buf[7] || para.time_mode_start != unescaped_buf[8] || para.time_mode_end != unescaped_buf[9] || para.photo_interval != ((uint16_t)unescaped_buf[10] << 8) + unescaped_buf[11]) { // 获取新的参数 para.ver = para_ver; para.mode = unescaped_buf[6]; if (unescaped_len >= 8) para.light_mode_hours = unescaped_buf[7]; if (unescaped_len >= 9) para.time_mode_start = unescaped_buf[8]; if (unescaped_len >= 10) para.time_mode_end = unescaped_buf[9]; if (unescaped_len >= 12) para.photo_interval = ((uint16_t)unescaped_buf[10] << 8) + unescaped_buf[11]; para_write(¶); } rtu_ctx.para_chked = 1; } } break; case 0x05: // RTU获取实时数据的请求 { rtu_send_realtime_data(); break; } case CMD_OTA_START: // RTU YMODEM 升级相关 { /* * 升级响应帧示例:7D 01 07 00 22 30 7E * unescaped_buf[0] = addr = 0x01 * unescaped_buf[1] = cmd = 0x07 (CMD_OTA_START) * unescaped_buf[2] = flag = 0x00 / 0x01 * 0x00:不升级(当前版本为最新) * 0x01:需要升级,随后走 YMODEM 传输 * unescaped_buf[3..] = CRC16 */ if (unescaped_len < 3) { // 长度不够,直接丢弃 break; } uint8_t ota_flag = unescaped_buf[2]; // 0x00:不升级,清掉标志后退出 if (ota_flag == 0x00) { rtu_ctx.ota_ongoing = 0; break; } // 只接受 0x01 表示“需要升级”,其它值按“不升级”处理 if (ota_flag != 0x01) { rtu_ctx.ota_ongoing = 0; break; } // 已经在升级过程中,则不重复进入 if (rtu_ctx.ota_ongoing) { break; } rtu_ctx.ota_ongoing = 1; //uint8_t err = 0x01; //rtu_send_pkt(1, CMD_OTA_START, &err, 1); // 需要升级:关闭帧接收中断,进入 YMODEM 升级流程 LL_USART_DisableIT_RXNE(COM_RTU); uint32_t recvSize = 0; // flashStartAddr = 0,flashMaxSize = 0 表示从 0 开始,直到芯片末尾 int32_t ret = Ymodem_ReceiveToW25Qxx(EXT_FLASH_FW_DATA_ADDR, APP_MAX_SIZE, &recvSize); if (ret == 0) { // recvSize 字节的文件已经从 flash 地址 0 开始存好了 // 这里可以做校验、启动应用、更新标志位等操作 // 标志位写入外部 flash,先擦后写,按扇区擦除 W25qxx_EraseSector(EXT_FLASH_FW_FLAG_ADDR); W25qxx_WriteByte(0xAA, EXT_FLASH_FW_FLAG_ADDR); // 文件大小写入外部 flash recvSize(字节数) // 将 uint32_t 的 4 个字节分别写入 W25qxx_WriteByte((recvSize >> 0) & 0xFF, EXT_FLASH_FW_SIZE_ADDR + 0); // 字节0 W25qxx_WriteByte((recvSize >> 8) & 0xFF, EXT_FLASH_FW_SIZE_ADDR + 1); // 字节1 W25qxx_WriteByte((recvSize >> 16) & 0xFF, EXT_FLASH_FW_SIZE_ADDR + 2); // 字节2 W25qxx_WriteByte((recvSize >> 24) & 0xFF, EXT_FLASH_FW_SIZE_ADDR + 3); // 字节3 // 升级成功:恢复串口接收,并标记“待复位” LL_USART_EnableIT_RXNE(COM_RTU); rtu_ctx.ota_ongoing = 0; rtu_ctx.ota_need_reset = 1; } else { // 失败:恢复串口帧接收,清除 ota_ongoing 标记 rtu_ctx.ota_ongoing = 0; LL_USART_EnableIT_RXNE(COM_RTU); // 可选:把错误码返回给上位机,方便调试 uint8_t err = (uint8_t)(ret & 0xFF); rtu_send_pkt(1, CMD_OTA_START, &err, 1); } break; } default: break; } // 移动到下一帧 buf += frame_len; len -= frame_len; processed = 1; } return processed ? 0 : -1; } void rtu_task(void) { uint8_t buf[256]; int len; if (rtu_read(buf, sizeof(buf), &len) == 0) { rtu_rx_proc(buf, len); } // 最大运行时间检查,解决通讯丢失时无法休眠的问题 if(1) { /* * 如果 RTU 处于拍照 / 升级 / 记录上传等忙状态, * 则不断刷新 running_timer,避免在这些长任务过程中 * 被 10 分钟超时逻辑误判为“通讯丢失”而强制掉电。 */ if (rtu_ctx.ota_ongoing || rtu_ctx.photo_ongoing || rtu_ctx.rec_ongoing) { rtu_ctx.running_timer = HAL_GetTick(); } if ((HAL_GetTick() - rtu_ctx.running_timer) > RTU_MAX_RUN_TIME) { // 如果当前不是正在通知掉电或已经空闲,则强制进入掉电流程 if (rtu_ctx.tsk_sta != RTU_STA_NOTYIFY_POWER_DOWN && rtu_ctx.tsk_sta != RTU_STA_IDLE && rtu_ctx.power_down_ongoing == 0) { rtu_ctx.power_down_cnt = 5; rtu_ctx.tsk_sta = RTU_STA_NOTYIFY_POWER_DOWN; // 清除可能的忙标记 rtu_ctx.rec_ongoing = 0; rtu_ctx.ota_ongoing = 0; rtu_ctx.photo_ongoing = 0; } } } switch (rtu_ctx.tsk_sta) { default: case RTU_STA_IDLE: rtu_deinit(); break; case RTU_STA_GET_STATUS: { uint8_t reason = rtu_ctx.trig_src&0x7f; rtu_send_pkt(1, CMD_STATUS_REQ, &reason, 1); rtu_ctx.tsk_sta = RTU_STA_WAIT_RESP; rtu_ctx.tsk_timer = HAL_GetTick(); rtu_ctx.tsk_tmo = 1000; rtu_ctx.next_sta = RTU_STA_CHK_ONLINE; } break; case RTU_STA_CHK_ONLINE: if (rtu_ctx.online == 0) { rtu_ctx.tsk_sta = RTU_STA_GET_STATUS; } else { rtu_ctx.tsk_sta = RTU_STA_CHK_OTA; // rtu_ctx.tsk_sta = RTU_STA_CHK_PARA; // rtu_ctx.para_chked = 0; } //rtu_ctx.tsk_sta = RTU_STA_CHK_OTA; break; case RTU_STA_CHK_OTA: { uint8_t req[5]; req[0] = 0; req[1] = VERSION_MAJOR; req[2] = VERSION_MINOR; req[3] = VERSION_BUILD; req[4] = VERSION_REVISION; rtu_send_pkt(1, CMD_OTA_START, req, 5); rtu_ctx.tsk_sta = RTU_STA_CHK_PARA; rtu_ctx.para_chked = 0; } break; case RTU_STA_CHK_PARA: if (rtu_ctx.para_chked == 0) { uint8_t req[4]; req[0] = para.ver >> 24; req[1] = para.ver >> 16; req[2] = para.ver >> 8; req[3] = para.ver; rtu_send_pkt(1, 4, req, 4); rtu_ctx.tsk_sta = RTU_STA_WAIT_RESP; rtu_ctx.tsk_timer = HAL_GetTick(); rtu_ctx.tsk_tmo = 1000; rtu_ctx.next_sta = RTU_STA_TIME_SYNC; } else { rtu_ctx.tsk_sta = RTU_STA_TIME_SYNC; } break; case RTU_STA_TIME_SYNC: if (rtu_ctx.time_syncd == 0) { uint8_t req[4]; rtc_time_t time; uint32_t timestamp; rtc_get_time(&time); timestamp = rtc_mktime(&time); // 填充本地时间戳 req[0] = timestamp >> 24; req[1] = timestamp >> 16; req[2] = timestamp >> 8; req[3] = timestamp; rtu_send_pkt(1, 3, req, 4); rtu_ctx.tsk_sta = RTU_STA_WAIT_RESP; rtu_ctx.tsk_timer = HAL_GetTick(); rtu_ctx.tsk_tmo = 1000; rtu_ctx.next_sta = RTU_STA_SND_REC; } else { rtu_ctx.tsk_sta = RTU_STA_SND_REC; } break; case RTU_STA_SND_REC: { // 按键触发、0点触发时上传记录 if (rtu_ctx.trig_src != 1) { if (!sensor_is_busy()) { // 0点唤醒时,发送24小时记录 if (rtu_ctx.trig_src == 0) { uint8_t rec_buf[sizeof(rec_data_t) * 24] = {0}; rtu_pack_rec(rec_buf, sizeof(rec_buf)); if (rtu_ctx.rec_pack.count) { rtu_send_pkt(1, 2, rec_buf, sizeof(rec_buf)); rtu_ctx.tsk_sta = RTU_STA_WAIT_RESP; rtu_ctx.tsk_timer = HAL_GetTick(); rtu_ctx.tsk_tmo = 5000; rtu_ctx.next_sta = RTU_STA_GET_STATUS; } else { rtu_ctx.tsk_sta = RTU_STA_WAIT_READY; } } // 按键唤醒时,发送一条实时数据 else if(rtu_ctx.trig_src == 2) { rtu_send_realtime_data(); rtu_ctx.tsk_sta = RTU_STA_WAIT_RESP; rtu_ctx.tsk_timer = HAL_GetTick(); // 延时1S后转到RTU_STA_WAIT_READY状态 rtu_ctx.tsk_tmo = 0; rtu_ctx.next_sta = RTU_STA_WAIT_READY; // 250930增加,防止重复上传 rtu_ctx.trig_src |= 0x80; } else { // 按键唤醒,且已经发送了一条实时数据 rtu_ctx.tsk_sta = RTU_STA_WAIT_READY; } } } else { // 拍照间隔唤醒,不发送记录 rtu_ctx.tsk_sta = RTU_STA_WAIT_READY; } } break; case RTU_STA_WAIT_READY: /* * 按键/手动唤醒(trig_src == 2,或带0x80标记的2): * 不再根据 RTU 状态应答来决定何时掉电,仅由 RTU_MAX_RUN_TIME * 的 10 分钟超时逻辑决定何时进入掉电流程。 */ if ( (rtu_ctx.trig_src & 0x7f) == 2 ) { rtu_ctx.tsk_sta = RTU_STA_GET_STATUS; // /* 仅在 RTU 报 busy 时继续查询状态,避免提前进入掉电判断 */ // if (rtu_ctx.ota_ongoing || rtu_ctx.photo_ongoing || rtu_ctx.rec_ongoing) // { // rtu_ctx.tsk_sta = RTU_STA_GET_STATUS; // } } else { if (rtu_ctx.ota_ongoing == 0 && rtu_ctx.photo_ongoing == 0 && rtu_ctx.rec_ongoing == 0) { rtc_time_t t; int is_in_time_window = 0; rtc_get_time(&t); // 检查是否在10点的特殊窗口期内(时控模式下也要保留) if (t.tm_hour == 0x10 && rtu_last_wakeup_hour != 0x10) { // 每天10点唤醒时,预留10分钟的窗口期 if ((HAL_GetTick() - rtu_ctx.running_timer) < 10 * 60 * 1000ul) { rtu_ctx.tsk_sta = RTU_STA_GET_STATUS; is_in_time_window = 1; } else { rtu_ctx.power_down_cnt = 5; rtu_ctx.tsk_sta = RTU_STA_NOTYIFY_POWER_DOWN; rtu_last_wakeup_hour = t.tm_hour; is_in_time_window = 1; } } // 如果不在10点窗口期,按照原有逻辑处理 if (!is_in_time_window) { // 如果是时控模式,检查当前时间是否在设定的时间范围内 if (para.mode == 1) { uint32_t now_min = t.tm_hour * 60 + t.tm_min; uint32_t start_min = para.time_mode_start * 60; uint32_t end_min = para.time_mode_end * 60 + 59; uint32_t time_range = 0; // 处理跨天情况 if (end_min >= start_min) { // 不跨天 time_range = (now_min > start_min && now_min <= end_min) ? 1 : 0; } else { // 跨天情况 (例如 23:00 到 01:00) time_range = (now_min > start_min || now_min <= end_min) ? 1 : 0; } // 如果当前不在时控时间段内,进入掉电流程 if (!time_range) { rtu_ctx.power_down_cnt = 5; rtu_ctx.tsk_sta = RTU_STA_NOTYIFY_POWER_DOWN; rtu_last_wakeup_hour = t.tm_hour; } else { // 如果在时控时间段内,继续执行原逻辑 rtu_ctx.power_down_cnt = 5; rtu_ctx.tsk_sta = RTU_STA_NOTYIFY_POWER_DOWN; rtu_last_wakeup_hour = t.tm_hour; } } else { // 光控模式,使用原来的逻辑 rtu_ctx.power_down_cnt = 5; rtu_ctx.tsk_sta = RTU_STA_NOTYIFY_POWER_DOWN; rtu_last_wakeup_hour = t.tm_hour; } } } else { rtu_ctx.tsk_sta = RTU_STA_GET_STATUS; } } break; case RTU_STA_NOTYIFY_POWER_DOWN: // 250929增加,rtu应答最新的状态,如果检查状态为busy,则返回到状态查询状态 // 解决RTU任务启动延迟的问题 if (rtu_ctx.ota_ongoing || rtu_ctx.photo_ongoing || rtu_ctx.rec_ongoing) { rtu_ctx.tsk_sta = RTU_STA_GET_STATUS; break; } rtu_ctx.power_down_ongoing = 1; if (rtu_ctx.power_down_cnt) { rtu_send_pkt(1, 0x06, &rtu_ctx.power_down_cnt, 1); rtu_ctx.power_down_cnt--; rtu_ctx.tsk_sta = RTU_STA_WAIT_RESP; rtu_ctx.tsk_timer = HAL_GetTick(); rtu_ctx.tsk_tmo = 0; // 设置超时时间为0,无论超时或收到应答,都会在1S后回到本状态 rtu_ctx.next_sta = RTU_STA_NOTYIFY_POWER_DOWN; } else { rtu_ctx.tsk_sta = RTU_STA_IDLE; } break; case RTU_STA_WAIT_RESP: if (rtu_ctx.tsk_tmo) { if (HAL_GetTick() - rtu_ctx.tsk_timer > rtu_ctx.tsk_tmo) { // 250930增加通信丢失容错处理:设置online为0,解决窗口期通讯丢失后不掉电的问题 rtu_ctx.online = 0; rtu_ctx.tsk_sta = RTU_STA_CHK_ONLINE; } } else if (HAL_GetTick() - rtu_ctx.tsk_timer > 1000) { rtu_ctx.tsk_sta = rtu_ctx.next_sta; } break; } /* * 如果 OTA 升级已经成功完成(ota_need_reset == 1), * 则在 RTU 不再忙(不拍照、不上传记录、不在 OTA 中) * 且状态机已经回到空闲 / 掉电流程时,再执行 MCU 复位。 * 这样可以保证:如果升级结束时正处于拍照过程, * 会等拍照任务结束、RTU 进入空闲后才复位 MCU。 */ if (rtu_ctx.ota_need_reset && rtu_ctx.photo_ongoing == 0 && rtu_ctx.rec_ongoing == 0 && rtu_ctx.ota_ongoing == 0 && (rtu_ctx.tsk_sta == RTU_STA_IDLE || rtu_ctx.tsk_sta == RTU_STA_NOTYIFY_POWER_DOWN || rtu_ctx.tsk_sta == RTU_STA_WAIT_READY)) { rtu_ctx.ota_need_reset = 0; HAL_NVIC_SystemReset(); } } void rtu_irq_handle(void) { if (LL_USART_IsEnabledIT_RXNE(COM_RTU) && LL_USART_IsActiveFlag_RXNE(COM_RTU)) { uint8_t tmp; tmp = LL_USART_ReceiveData8(COM_RTU); if (rtu_ctx.rx_len < sizeof(rtu_ctx.rx_buf)) { rtu_ctx.rx_buf[rtu_ctx.rx_len] = tmp; rtu_ctx.rx_len++; } rtu_ctx.rx_timer = HAL_GetTick(); } if (LL_USART_IsActiveFlag_ORE(COM_RTU)) { LL_USART_ClearFlag_ORE(COM_RTU); LL_USART_DisableIT_ERROR(COM_RTU); } if (LL_USART_IsEnabledIT_TC(COM_RTU) && LL_USART_IsActiveFlag_TC(COM_RTU)) { LL_USART_ClearFlag_TC(COM_RTU); LL_USART_DisableIT_TC(COM_RTU); } }