package controllers import ( "ColdVerify_local/lib" "ColdVerify_local/logs" "ColdVerify_local/models/Device" "ColdVerify_local/models/Task" "ColdVerify_local/models/VerifyTemplate" "errors" "fmt" "math" "math/rand" "net/http" "sort" "strconv" "strings" "time" "github.com/beego/beego/v2/client/orm" beego "github.com/beego/beego/v2/server/web" ) type TaskDataHandleController struct { beego.Controller } /* 同区域数据缺失 */ // 测点自检 自动添加缺失终端，取关联绑定终端平均复制 func (c *TaskDataHandleController) SSE_Automatically_add_missing_terminal() { T_task_id := c.GetString("T_task_id") // v26nplogbwt1 T_start := c.GetString("T_start") // 开始测点编号 T_end := c.GetString("T_end") // 结束测点编号 println("T_task_id:", T_task_id, "T_start:", T_start, "T_end:", T_end) c.Ctx.ResponseWriter.Header().Set("Content-Type", "text/event-stream") c.Ctx.ResponseWriter.Header().Set("Cache-Control", "no-cache") c.Ctx.ResponseWriter.Header().Set("Connection", "keep-alive") lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "任务开始......"}) Task_r, err := Task.Read_Task(T_task_id) if err != nil { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取任务信息失败!"}) return } // 解析开始/结束编号 var startId, endId int hasRange := false if T_start != "" { startId, _ = strconv.Atoi(T_start) hasRange = true } if T_end != "" { endId, _ = strconv.Atoi(T_end) hasRange = true } if !hasRange || startId <= 0 || endId <= 0 || startId > endId { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "请指定有效的开始和结束测点编号!"}) return } // 获取所有设备，构建T_id -> Device映射 DeviceClassList_r := Device.Read_DeviceClassList_List_id_By_Terminal(Task_r.T_class, false) deviceMap := make(map[int]Device.DeviceClassList) for _, d := range DeviceClassList_r { tId, err := strconv.Atoi(d.T_id) if err == nil { deviceMap[tId] = d } } lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: fmt.Sprintf("终端总共：%d 个，检查范围: %03d ~ %03d，正在检查自检探头...", len(DeviceClassList_r), startId, endId)}) // 获取第一个设备用于获取T_remark参考 var firstRemark string if len(DeviceClassList_r) > 0 { firstRemark = DeviceClassList_r[len(DeviceClassList_r)-1].T_remark } // 遍历完整范围，不限于设备列表 for id := startId; id <= endId; id++ { tidStr := fmt.Sprintf("%03d", id) var class_ Device.DeviceClassList device, exists := deviceMap[id] if exists { class_ = device } else { // 虚拟设备：T_sn和T_id保持一致 class_ = Device.DeviceClassList{ T_class: Task_r.T_class, T_id: tidStr, T_sn: tidStr, T_remark: firstRemark, } } // 检查该测点是否已有数据 // 真实设备用实际T_sn查询，虚拟设备用T_id查询 querySn := tidStr if exists { querySn = class_.T_sn } _, cnt := Task.Read_TaskData_ById_List(Task_r.T_task_id, querySn, class_.T_id, "", "", 0, 1) if cnt == 0 { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "找到" + class_.T_id + " " + class_.T_remark + " 自检探头"}) // 使用T_id作为T_sn，确保补充的数据sn=编号 device := Device.DeviceClassList{ T_class: class_.T_class, T_id: class_.T_id, T_sn: tidStr, T_remark: class_.T_remark, } c.SetAdjacentDeviceAVGTaskData(T_task_id, device, "", "") // -----------开始平均复制到结束 } } lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: "完成！"}) // Close the connection c.Ctx.ResponseWriter.WriteHeader(http.StatusOK) } // selectReferenceSensor 选择最稳定的传感器作为参考（标准差最小） func selectReferenceSensor(allData map[string]map[string]float32, devices []Device.DeviceClassList) string { var bestId string bestStddev := float32(math.MaxFloat32) for _, dev := range devices { tm := allData[dev.T_id] if tm == nil || len(tm) < 10 { continue } var sum, sumSq float32 var count int for _, v := range tm { sum += v sumSq += v * v count++ } if count < 10 { continue } mean := sum / float32(count) variance := sumSq/float32(count) - mean*mean stddev := float32(math.Sqrt(float64(variance))) if stddev < bestStddev { bestStddev = stddev bestId = dev.T_id } } return bestId } // calcBaselineDiff 计算传感器与参考传感器的基准差值（取前N分钟数据的均值） func calcBaselineDiff(sensorData, refData map[string]float32, allTimes []string, minutes int) float32 { if len(allTimes) == 0 { return 0 } startTime := allTimes[0] st, _ := time.Parse("2006-01-02 15:04", startTime) endTime := st.Add(time.Duration(minutes) * time.Minute) var sum float32 var count int for _, t := range allTimes { ct, _ := time.Parse("2006-01-02 15:04", t) if ct.After(endTime) { break } sp, ok1 := sensorData[t] rp, ok2 := refData[t] if ok1 && ok2 { sum += sp - rp count++ } } if count == 0 { return 0 } return sum / float32(count) } // getDeviceById 根据T_id查找设备 func getDeviceById(devices []Device.DeviceClassList, id string) (Device.DeviceClassList, bool) { for _, d := range devices { if d.T_id == id { return d, true } } return Device.DeviceClassList{}, false } // findNearestTime 在时间列表中找目标时间前后最近的两个时间点 func findNearestTime(allTimes []string, target string) (string, string) { var prev, next string for _, t := range allTimes { if t < target { prev = t } else if t > target && next == "" { next = t } } return prev, next } // 测点数据自检 自动添加缺失数据，取关联绑定终端平均复制 func (c *TaskDataHandleController) SSE_Automatically_add_missing_data() { T_task_id := c.GetString("T_task_id") // v26nplogbwt1 c.Ctx.ResponseWriter.Header().Set("Content-Type", "text/event-stream") c.Ctx.ResponseWriter.Header().Set("Cache-Control", "no-cache") c.Ctx.ResponseWriter.Header().Set("Connection", "keep-alive") lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "任务开始......"}) Task_r, err := Task.Read_Task(T_task_id) if err != nil { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取任务信息失败!"}) return } // 时间间隔 s T_saveT := 60 DeviceClassList_list := Device.Read_DeviceClassList_List_id_By_Terminal(Task_r.T_class, false) // 分组统计每个sn的数据数量 snList := Device.JoinDeviceClassListSnToString(DeviceClassList_list) TaskData_Total_GroupBySnId := Task.Read_TaskData_Total_GroupBySnId(Task_r.T_task_id, snList, "", "") if len(TaskData_Total_GroupBySnId) == 0 { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: "暂无测点需要自检！"}) } Devicedata_list_MAX := TaskData_Total_GroupBySnId[0].Total TaskData_Total_GroupBySnId_Map := make(map[string]int64) for _, v := range TaskData_Total_GroupBySnId { TaskData_Total_GroupBySnId_Map[v.T_sn] = v.Total } startTime, endTime := Task.Read_TaskData_T_time_T_Min_Max(Task_r.T_task_id, TaskData_Total_GroupBySnId[0].T_sn, TaskData_Total_GroupBySnId[0].T_id, "", "") logs.Println("数据标准数量：", Devicedata_list_MAX) // 选择 数据缺失的终端 for _, DeviceClassList_r := range DeviceClassList_list { total, ok := TaskData_Total_GroupBySnId_Map[DeviceClassList_r.T_sn] if !ok { // 测点自检事再处理 lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: DeviceClassList_r.T_id + " 终端自检数据 , 测点缺失，跳过"}) continue } if Devicedata_list_MAX == total { continue } list, cnt := Task.Read_TaskData_ById_List_AES(Task_r.T_task_id, DeviceClassList_r.T_sn, DeviceClassList_r.T_id, "", "", 0, 9999) lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: DeviceClassList_r.T_id + " 终端自检数据 ,数据差值：" + lib.To_string(Devicedata_list_MAX-cnt) + " "}) // 开始结束时间不同，直接执行平均复制到 if startTime != list[0].T_time || endTime != list[len(list)-1].T_time { if Devicedata_list_MAX-cnt != 1 { // -----------开始平均复制到 device := Device.DeviceClassList{ T_class: DeviceClassList_r.T_class, T_id: DeviceClassList_r.T_id, T_sn: DeviceClassList_r.T_sn, T_remark: DeviceClassList_r.T_remark, } c.SetAdjacentDeviceAVGTaskData(T_task_id, device, "", "") // -----------开始平均复制到结束 continue } else { if startTime != list[0].T_time { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: DeviceClassList_r.T_id + " 找到到自检时间点 " + startTime + " ~ " + list[0].T_time + " 开始自检"}) Task.InsertTaskData(Task_r.T_task_id, Task.TaskData_{ T_sn: list[0].T_sn, T_id: list[0].T_id, T_t: list[0].T_t, T_rh: list[0].T_rh, T_time: startTime, }) continue } if endTime != list[len(list)-1].T_time { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: DeviceClassList_r.T_id + " 找到自检时间点 " + list[len(list)-1].T_time + " ~ " + endTime + " 开始自检"}) Task.InsertTaskData(Task_r.T_task_id, Task.TaskData_{ T_sn: list[len(list)-1].T_sn, T_id: list[len(list)-1].T_id, T_t: list[len(list)-1].T_t, T_rh: list[len(list)-1].T_rh, T_time: endTime, }) continue } } } for i := 0; i < len(list)-1; i++ { current := list[i].T_time next := list[i+1].T_time ct, _ := time.Parse("2006-01-02 15:04:05", current) nt, _ := time.Parse("2006-01-02 15:04:05", next) interval := nt.Unix() - ct.Unix() //logs.Debug("时间间隔：", interval, "保存时间：", saveTime) //fmt.Println("当前：", current, "下一个：", next) // 缺一个时间点 补漏 if int(interval) == 2*T_saveT { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: list[i].T_id + " 找到自检时间点 " + current + " ~ " + next + " 开始自检"}) t := ct.Add(time.Second * time.Duration(T_saveT)).Format("2006-01-02 15:04") //时间临时变量 ttt := (list[i].T_t + list[i+1].T_t) / 2 trht := (list[i].T_rh + list[i+1].T_rh) / 2 Task.InsertTaskData(Task_r.T_task_id, Task.TaskData_{ T_sn: list[i].T_sn, T_id: list[i].T_id, T_t: ttt, T_rh: trht, T_time: t, }) continue } // 缺的数据大于一个时间点，执行平均复制到 if int(interval) > T_saveT { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: list[i].T_id + " 找到自检时间点 " + current + " ~ " + next + " 开始自检"}) // -----------开始平均复制到 device := Device.DeviceClassList{ T_class: DeviceClassList_r.T_class, T_id: DeviceClassList_r.T_id, T_sn: DeviceClassList_r.T_sn, T_remark: DeviceClassList_r.T_remark, } c.SetAdjacentDeviceAVGTaskData(T_task_id, device, "", "") // -----------开始平均复制到结束 // 平均复制结束，跳出循环 break } } } lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: "完成！"}) // Close the connection c.Ctx.ResponseWriter.WriteHeader(http.StatusOK) } // 数据持续时间 x 分钟 没有变化 func (c *TaskDataHandleController) SSE_Continuously_unchanged_data() { T_task_id := c.GetString("T_task_id") // v26nplogbwt1 T_timeout, _ := c.GetInt("T_timeout", 30) // 持续时间 c.Ctx.ResponseWriter.Header().Set("Content-Type", "text/event-stream") c.Ctx.ResponseWriter.Header().Set("Cache-Control", "no-cache") c.Ctx.ResponseWriter.Header().Set("Connection", "keep-alive") lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "任务开始......"}) Task_r, err := Task.Read_Task(T_task_id) if err != nil { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取任务信息失败!"}) return } // 获取 备注 下面关联设备，数量 DeviceClassList_list := Device.Read_DeviceClassList_List_id_By_Terminal(Task_r.T_class, false) // 选择 数据缺失的终端 var DeleteDeviceClassList []Device.DeviceClassList for _, DeviceClassList_r := range DeviceClassList_list { TaskData_list, _ := Task.Read_TaskData_ById_List_AES(Task_r.T_task_id, DeviceClassList_r.T_sn, DeviceClassList_r.T_id, "", "", 0, 9999) if len(TaskData_list) == 0 { continue } maxCount, start, end := Task.FindUnchangedInterval(TaskData_list) if strings.Contains(DeviceClassList_r.T_remark, "保温箱外环境测点") || strings.Contains(DeviceClassList_r.T_remark, "冷藏库作业口外部环境测点") || strings.Contains(DeviceClassList_r.T_remark, "冷藏库外部环境测点") || strings.Contains(DeviceClassList_r.T_remark, "冷藏柜外部环境测点") || strings.Contains(DeviceClassList_r.T_remark, "冷藏车外部环境测点") || strings.Contains(DeviceClassList_r.T_remark, "仓库室外测点") { continue } if maxCount > T_timeout { Task.DeleteTaskDataByTimeRange(T_task_id, DeviceClassList_r.T_sn, DeviceClassList_r.T_id, "", "") DeleteDeviceClassList = append(DeleteDeviceClassList, DeviceClassList_r) lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "找到" + DeviceClassList_r.T_id + " 探头, " + "最多连续 " + lib.To_string(maxCount) + " 分钟没有变化，" + "开始时间：" + start + " 结束时间：" + end + "," + "开始自检"}) } } for _, class_ := range DeleteDeviceClassList { // -----------开始平均复制到 device := Device.DeviceClassList{ T_class: class_.T_class, T_id: class_.T_id, T_sn: class_.T_sn, T_remark: class_.T_remark, } c.SetAdjacentDeviceAVGTaskData(T_task_id, device, "", "") // -----------开始平均复制到结束 } lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: "完成！"}) // Close the connection c.Ctx.ResponseWriter.WriteHeader(http.StatusOK) } // 区间数据校正 （布点区域数据自检） 均匀性布点,产品存放区域测点 区间数据超标校正 超标数据偏移到区间内 func (c *TaskDataHandleController) SSE_Interval_data_correction() { T_task_id := c.GetString("T_task_id") // v26nplogbwt1 c.Ctx.ResponseWriter.Header().Set("Content-Type", "text/event-stream") c.Ctx.ResponseWriter.Header().Set("Cache-Control", "no-cache") c.Ctx.ResponseWriter.Header().Set("Connection", "keep-alive") lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "任务开始......"}) Task_r, err := Task.Read_Task(T_task_id) if err != nil { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取任务信息失败!"}) return } 温度控制范围最小值 := float64(lib.To_float32(VerifyTemplate.Read_VerifyTemplateMapData_T_name(Task_r.T_task_id, Task_r.T_VerifyTemplate_id, "温度控制范围最小值"))) 温度控制范围最高值 := float64(lib.To_float32(VerifyTemplate.Read_VerifyTemplateMapData_T_name(Task_r.T_task_id, Task_r.T_VerifyTemplate_id, "温度控制范围最高值"))) if 温度控制范围最小值 == 0 || 温度控制范围最高值 == 0 { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "温度控制范围 标签值不正确！"}) return } // 均匀性布点 产品存放区域测点 部点终端_list := Device.Read_DeviceClassList_List_id_T_remark(Task_r.T_class, "均匀性布点|产品存放区域测点|作业出入口总测点") if len(部点终端_list) <= 2 { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "均匀性布点|产品存放区域测点|作业出入口总测点 太少了，至少两条以上！"}) return } 部点终端_sn_list := Device.JoinDeviceClassListSnToString(部点终端_list) var 开始时间, 结束时间, 趋势时间 string 开始时间, 结束时间, 趋势时间 = c.GetStartTimeAndEndTime(Task_r, 部点终端_sn_list, 温度控制范围最高值) if 开始时间 == "" || 结束时间 == "" { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "未找到 开始时间 或 结束时间！"}) return } type AVGClassList struct { T_sn string T_id string T_max float64 T_min float64 T_diff float64 // 最大最小值差异 } fmt.Println("数据准备:", 开始时间, 结束时间, 温度控制范围最小值, 温度控制范围最高值) // -------------------- 温湿度绑定点vga_H -------------------- lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "--- 进行处理 数据！---"}) lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: fmt.Sprintf("开始时间：%s 结束时间:%s", 开始时间, 结束时间)}) // 先整体向上偏移 for _, i2 := range 部点终端_list { T_min := Task.Read_TaskData_min(T_task_id, i2.T_sn, i2.T_id, "", "") if T_min < RoundToDecimal(温度控制范围最小值+0.1, 1) { Task.UpdateTaskDataTemperatureAndHumidity(Task_r.T_task_id, i2.T_sn, i2.T_id, "", "", RoundToDecimal(温度控制范围最小值+0.1-T_min, 1), 0) } } // ----------获取保留数据------------ //var 开空开, 保空开 string //var 开空开驼峰, 保空开驼峰 Task.CalculateHumps_R //var valueStrings1, valueStrings2 []string var BWXValueStrings []string if Task_r.T_device_type != "X" { //valueStrings1, valueStrings2, 开空开, 保空开, 开空开驼峰, 保空开驼峰 = c.GetRetainData(Task_r, 部点终端_list, false) } else { BWXValueStrings = c.GetBWXRetainData(Task_r, 部点终端_sn_list, 结束时间, 趋势时间) } // ----------获取保留数据结束------------ var AVGClassList_r []AVGClassList for _, i2 := range 部点终端_list { T_max := Task.Read_TaskData_max(T_task_id, i2.T_sn, i2.T_id, 开始时间, 结束时间) T_min := Task.Read_TaskData_min(T_task_id, i2.T_sn, i2.T_id, "", "") AVGClassList_r = append(AVGClassList_r, AVGClassList{T_sn: i2.T_sn, T_id: i2.T_id, T_max: T_max, T_min: T_min, T_diff: T_max - T_min}) } for _, AVGClassList_i := range AVGClassList_r { if AVGClassList_i.T_max < 温度控制范围最高值 && AVGClassList_i.T_min > 温度控制范围最小值 { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "测点 " + lib.To_string(AVGClassList_i.T_id) + " 最大值:" + lib.To_string(AVGClassList_i.T_max) + "℃ " + " 最小值:" + lib.To_string(AVGClassList_i.T_min) + "℃ " + " 符合要求！"}) continue } var vgaca float64 if RoundToDecimal(AVGClassList_i.T_max-AVGClassList_i.T_min, 1) > RoundToDecimal(温度控制范围最高值-温度控制范围最小值-0.4, 1) { // 压缩 diff := RoundToDecimal(AVGClassList_i.T_max-AVGClassList_i.T_min, 1) // 获取压缩度 compress := RoundToDecimal((温度控制范围最高值-温度控制范围最小值-0.6)/diff, 2) // 压缩 Task.UpdateTaskDataTemperatureAndHumidityByGeometric(Task_r.T_task_id, AVGClassList_i.T_sn, AVGClassList_i.T_id, "", "", compress, 1) T_max_compress := RoundToDecimal(AVGClassList_i.T_max*compress, 1) T_min_compress := RoundToDecimal(AVGClassList_i.T_min*compress, 1) // 判断压缩后是否在 温度控制范围最小值-温度控制范围最高值范围内 不做处理 if T_max_compress <= RoundToDecimal(温度控制范围最高值-0.1, 1) && T_min_compress >= RoundToDecimal(温度控制范围最小值+0.1, 1) { 参考值 := RoundToDecimal((温度控制范围最高值+温度控制范围最小值)/2, 1) 中间值 := RoundToDecimal((AVGClassList_i.T_max+AVGClassList_i.T_min)/2, 1) if 参考值 > 中间值 { // 向上偏移 vgaca = 参考值 - 中间值 Task.UpdateTaskDataTemperatureAndHumidity(Task_r.T_task_id, AVGClassList_i.T_sn, AVGClassList_i.T_id, "", "", vgaca, 0) lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "进行处理 数据！" + lib.To_string(AVGClassList_i.T_id) + " 最大值:" + lib.To_string(AVGClassList_i.T_max) + "℃ " + " 最小值:" + lib.To_string(AVGClassList_i.T_min) + "℃ " + " 压缩：" + lib.To_string(compress) + " 压缩后最大值:" + lib.To_string(T_max_compress) + "℃ " + " 压缩后最小值:" + lib.To_string(T_min_compress) + "℃ " + " 向上偏移：" + lib.To_string(vgaca) + "℃ "}) continue } if 参考值 < 中间值 { // 向下偏移 vgaca = 中间值 - 参考值 Task.UpdateTaskDataTemperatureAndHumidity(Task_r.T_task_id, AVGClassList_i.T_sn, AVGClassList_i.T_id, "", "", -vgaca, 0) lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "进行处理 数据！" + lib.To_string(AVGClassList_i.T_id) + " 最大值:" + lib.To_string(AVGClassList_i.T_max) + "℃ " + " 最小值:" + lib.To_string(AVGClassList_i.T_min) + "℃ " + " 压缩：" + lib.To_string(compress) + " 压缩后最大值:" + lib.To_string(T_max_compress) + "℃ " + " 压缩后最小值:" + lib.To_string(T_min_compress) + "℃ " + " 向下偏移：" + lib.To_string(vgaca) + "℃ "}) continue } lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "进行处理 数据！" + lib.To_string(AVGClassList_i.T_id) + " 最大值:" + lib.To_string(AVGClassList_i.T_max) + "℃ " + " 最小值:" + lib.To_string(AVGClassList_i.T_min) + "℃ " + " 压缩：" + lib.To_string(compress) + " 压缩后最大值:" + lib.To_string(T_max_compress) + "℃ " + " 压缩后最小值:" + lib.To_string(T_min_compress) + "℃ "}) continue } // 压缩后仍高于 温度控制范围最高值，向下偏移 if T_max_compress >= 温度控制范围最高值 { vgaca = RoundToDecimal((T_max_compress+T_min_compress)/2-(温度控制范围最高值+温度控制范围最小值)/2, 1) //vgaca = RoundToDecimal(T_max_compress-温度控制范围最高值+0.1, 1) lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "进行处理 数据！" + lib.To_string(AVGClassList_i.T_id) + " 最大值:" + lib.To_string(AVGClassList_i.T_max) + "℃ " + " 最小值:" + lib.To_string(AVGClassList_i.T_min) + "℃ " + " 压缩：" + lib.To_string(compress) + " 压缩后最大值:" + lib.To_string(RoundToDecimal(AVGClassList_i.T_max*compress, 1)) + "℃ " + " 压缩后最小值:" + lib.To_string(RoundToDecimal(AVGClassList_i.T_min*compress, 1)) + "℃ " + " 数据偏差：" + lib.To_string(vgaca) + "℃ " + " 向下偏移：" + lib.To_string(vgaca) + "℃ "}) Task.UpdateTaskDataTemperatureAndHumidity(Task_r.T_task_id, AVGClassList_i.T_sn, AVGClassList_i.T_id, "", "", -vgaca, 0) continue } // 压缩后仍低于 温度控制范围最小值，向上偏移 if T_min_compress <= 温度控制范围最小值 { // 向上偏移 vgaca = RoundToDecimal((温度控制范围最高值+温度控制范围最小值)/2-(T_max_compress+T_min_compress)/2, 1) //vgaca = RoundToDecimal(温度控制范围最小值-AVGClassList_i.T_min*compress+0.1, 1) lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "进行处理 数据！" + lib.To_string(AVGClassList_i.T_id) + " 最大值:" + lib.To_string(AVGClassList_i.T_max) + "℃ " + " 最小值:" + lib.To_string(AVGClassList_i.T_min) + "℃ " + " 压缩：" + lib.To_string(compress) + " 压缩后最大值:" + lib.To_string(RoundToDecimal(AVGClassList_i.T_max*compress, 1)) + "℃ " + " 压缩后最小值:" + lib.To_string(RoundToDecimal(AVGClassList_i.T_min*compress, 1)) + "℃ " + " 数据偏差：" + lib.To_string(vgaca) + "℃ " + " 向上偏移：" + lib.To_string(vgaca) + "℃ "}) Task.UpdateTaskDataTemperatureAndHumidity(Task_r.T_task_id, AVGClassList_i.T_sn, AVGClassList_i.T_id, "", "", vgaca, 0) } continue } else { // 向下偏移 if AVGClassList_i.T_max >= 温度控制范围最高值 { vgaca = RoundToDecimal(AVGClassList_i.T_max-温度控制范围最高值+0.2, 1) lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "进行处理 数据！" + lib.To_string(AVGClassList_i.T_id) + " 最大值:" + lib.To_string(AVGClassList_i.T_max) + "℃ " + " 最小值:" + lib.To_string(AVGClassList_i.T_min) + "℃ " + " 数据偏差：" + lib.To_string(vgaca) + "℃ " + " 向下偏移：" + lib.To_string(vgaca) + "℃ "}) // 偏移 Task.UpdateTaskDataTemperatureAndHumidity(Task_r.T_task_id, AVGClassList_i.T_sn, AVGClassList_i.T_id, "", "", -vgaca, 0) continue } if AVGClassList_i.T_min <= 温度控制范围最小值 { vgaca = RoundToDecimal(温度控制范围最小值-AVGClassList_i.T_min+0.2, 1) lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "进行处理 数据！" + lib.To_string(AVGClassList_i.T_id) + " 最大值:" + lib.To_string(AVGClassList_i.T_max) + "℃ " + " 最小值:" + lib.To_string(AVGClassList_i.T_min) + "℃ " + " 数据偏差： " + lib.To_string(vgaca) + "℃ " + " 向上偏移：" + lib.To_string(vgaca) + "℃ "}) Task.UpdateTaskDataTemperatureAndHumidity(Task_r.T_task_id, AVGClassList_i.T_sn, AVGClassList_i.T_id, "", "", vgaca, 0) } } } // ----------恢复保留数据------------ if Task_r.T_device_type != "X" { //c.SaveRetainData(Task_r, 部点终端_list, valueStrings1, valueStrings2, 开空开, 保空开, 开空开驼峰, 保空开驼峰, 温度控制范围最高值, 60) } else { c.SaveBWXRetainData(Task_r, 部点终端_list, BWXValueStrings, 结束时间, 趋势时间, 60) } // ----------恢复保留数据结束------------ lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: "完成！"}) // Close the connection c.Ctx.ResponseWriter.WriteHeader(http.StatusOK) } // 绑定点与终端比对 （绑定点数据自检） 终端数据为参照物，绑定点数据在终端偏差±1℃，保温箱为±0.5℃ func (c *TaskDataHandleController) SSE_Comparison_between_binding_points_and_terminals() { T_task_id := c.GetString("T_task_id") //T_deviation, _ := c.GetFloat("T_deviation", 1.0) // 默认偏差1.0 T_deviation := 0.5 c.Ctx.ResponseWriter.Header().Set("Content-Type", "text/event-stream") c.Ctx.ResponseWriter.Header().Set("Cache-Control", "no-cache") c.Ctx.ResponseWriter.Header().Set("Connection", "keep-alive") lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "任务开始......"}) Task_r, err := Task.Read_Task(T_task_id) if err != nil { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取任务信息失败!"}) return } // 保温箱偏差强制为0.5 if Task_r.T_device_type == "X" { T_deviation = 0.5 } // 温度控制范围 温度控制范围最高值 := float64(lib.To_float32(VerifyTemplate.Read_VerifyTemplateMapData_T_name(Task_r.T_task_id, Task_r.T_VerifyTemplate_id, "温度控制范围最高值"))) if 温度控制范围最高值 == 0 { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "温度控制范围最高值 标签值不正确！"}) return } 温度控制范围最小值 := float64(lib.To_float32(VerifyTemplate.Read_VerifyTemplateMapData_T_name(Task_r.T_task_id, Task_r.T_VerifyTemplate_id, "温度控制范围最小值"))) if 温度控制范围最小值 == 0 { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "温度控制范围最小值 标签值不正确！"}) return } // 均匀性布点 (用于获取保留数据) 部点终端_list := Device.Read_DeviceClassList_List_id_T_remark(Task_r.T_class, "均匀性布点|产品存放区域测点") 部点终端_sn_list := Device.JoinDeviceClassListSnToString(部点终端_list) var 开始时间, 结束时间, 趋势时间 string 开始时间, 结束时间, 趋势时间 = c.GetStartTimeAndEndTime(Task_r, 部点终端_sn_list, 温度控制范围最高值) if 开始时间 == "" || 结束时间 == "" { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "未找到 开始时间 或 结束时间！"}) return } // ----------获取保留数据------------ var 开空开, 保空开 string var 开空开驼峰, 保空开驼峰 Task.CalculateHumps_R var BWXValueStrings []string var valueStrings1, valueStrings2 []string if Task_r.T_device_type != "X" { valueStrings1, valueStrings2, 开空开, 保空开, 开空开驼峰, 保空开驼峰 = c.GetRetainData(Task_r, 部点终端_list, true) } else { BWXValueStrings = c.GetBWXRetainData(Task_r, 部点终端_sn_list, 结束时间, 趋势时间) } // ----------获取保留数据结束------------ 监测终端_list := Device.Read_DeviceClassList_List_id_By_Terminal(Task_r.T_class, true) if len(监测终端_list) < 1 { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "未找到 监测终端！"}) return } 温湿度绑定点_list := Device.Read_DeviceClassList_List_id_T_remark(Task_r.T_class, "温湿度绑定点") if len(温湿度绑定点_list) < 1 { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "未找到 温湿度绑定点！"}) return } // ================= 计算监测终端的整体平均值作为唯一基准 ================= var 监测终端总温度 float64 var 监测终端有效数量 int for _, term := range 监测终端_list { avg := Task.Read_TaskData_AVG(T_task_id, term.T_sn, term.T_id, 开始时间, 结束时间) if avg > 0 { 监测终端总温度 += avg 监测终端有效数量++ } } if 监测终端有效数量 == 0 { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "监测终端无有效数据！"}) return } 监测终端整体Avg := RoundToDecimal(监测终端总温度/float64(监测终端有效数量), 1) lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: fmt.Sprintf("基准确定：监测终端整体平均值 = %.1f℃, 允许偏差 = ±%.1f℃", 监测终端整体Avg, T_deviation)}) // ================= 逐个遍历温湿度绑定点，超标则随机偏移到 0.5 或 0.4 ================= rand.Seed(time.Now().UnixNano()) // 确保每次随机不同 for _, bindPoint := range 温湿度绑定点_list { 绑定点_id := bindPoint.T_id 绑定点_sn := bindPoint.T_sn 绑定点_remark := bindPoint.T_remark // 1. 计算该绑定点的平均值 绑定点Avg_raw := Task.Read_TaskData_AVG(T_task_id, 绑定点_sn, 绑定点_id, 开始时间, 结束时间) 绑定点Avg := RoundToDecimal(绑定点Avg_raw, 1) // 2. 计算与监测终端基准的偏差 偏差 := RoundToDecimal(math.Abs(绑定点Avg-监测终端整体Avg), 1) lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: fmt.Sprintf("测点[%s] 当前平均值:%.1f, 与监测终端偏差:%.1f", 绑定点_remark, 绑定点Avg, 偏差)}) // 3. 判断是否在合规范围内 (偏差 > 0.5 才处理) if 偏差 <= T_deviation { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: fmt.Sprintf("测点[%s] 偏差 %.1f <= %.1f，已在合规范围内，跳过不处理", 绑定点_remark, 偏差, T_deviation)}) continue } // 4. 不在合规范围内，需要单独处理该测点 T_max := Task.Read_TaskData_max(T_task_id, 绑定点_sn, 绑定点_id, 开始时间, 结束时间) T_min := Task.Read_TaskData_min(T_task_id, 绑定点_sn, 绑定点_id, 开始时间, 结束时间) var targetAvg float64 var 偏移量 float64 var 动作 string // 随机选择处理后的“目标偏差值”为 0.5 或 0.4 目标偏差 := 0.5 if rand.Intn(2) == 1 { 目标偏差 = 0.4 } if 绑定点Avg > 监测终端整体Avg { // 偏高，需要向下压。目标值 = 基准 + 目标偏差 (例如 3.9 + 0.5 = 4.4 或 3.9 + 0.4 = 4.3) targetAvg = RoundToDecimal(监测终端整体Avg+目标偏差, 1) 偏移量 = RoundToDecimal(绑定点Avg-targetAvg, 1) 动作 = "下移" // 注意：T_deviation 传 0.0，防止底层函数重复叠加偏差 c.SetAverageShiftedDownward(T_task_id, 绑定点_id, 0.0, targetAvg, 绑定点Avg, T_min, T_max, 温度控制范围最小值, 温度控制范围最高值, "", "") } else { // 偏低，需要向上拉。目标值 = 基准 - 目标偏差 (例如 3.9 - 0.5 = 3.4 或 3.9 - 0.4 = 3.5) targetAvg = RoundToDecimal(监测终端整体Avg-目标偏差, 1) 偏移量 = RoundToDecimal(targetAvg-绑定点Avg, 1) 动作 = "上移" // 注意：T_deviation 传 0.0 c.SetAverageShiftedUpward(T_task_id, 绑定点_id, 0.0, targetAvg, 绑定点Avg, T_min, T_max, 温度控制范围最小值, 温度控制范围最高值, "", "") } lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: fmt.Sprintf(" 测点[%s] 偏差:%.1f > %.1f → %s%.1f → 动态目标Avg:%.1f (目标偏差:%.1f)", 绑定点_remark, 偏差, T_deviation, 动作, 偏移量, targetAvg, 目标偏差)}) } // ----------恢复保留数据------------ if Task_r.T_device_type != "X" { c.SaveRetainData(Task_r, 部点终端_list, valueStrings1, valueStrings2, 开空开, 保空开, 开空开驼峰, 保空开驼峰, 温度控制范围最高值, 60) } else { c.SaveBWXRetainData(Task_r, 部点终端_list, BWXValueStrings, 结束时间, 趋势时间, 60) } // ----------恢复保留数据结束------------ lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: "完成！"}) c.Ctx.ResponseWriter.WriteHeader(http.StatusOK) } /* 绑定点与冷热点比对 （冷热点数据自检） 策略：以“温湿度绑定点”数据为参照物基准，部点终端数据在基准偏差±T_deviation℃以内。 若超出，则固定偏移一固定值，使差值降至合规范围内（目标差值随机取 0.7, 0.8, 0.9, 1.0）。 */ func (c *TaskDataHandleController) SSE_Compare_binding_points_with_cold_and_hot_spots() { T_task_id := c.GetString("T_task_id") T_deviation, _ := c.GetFloat("T_deviation", 1.0) c.Ctx.ResponseWriter.Header().Set("Content-Type", "text/event-stream") c.Ctx.ResponseWriter.Header().Set("Cache-Control", "no-cache") c.Ctx.ResponseWriter.Header().Set("Connection", "keep-alive") lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "任务开始......"}) Task_r, err := Task.Read_Task(T_task_id) if err != nil { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取任务信息失败!"}) return } if Task_r.T_device_type == "X" { T_deviation = 0.5 } 温度控制范围最高值 := float64(lib.To_float32(VerifyTemplate.Read_VerifyTemplateMapData_T_name(Task_r.T_task_id, Task_r.T_VerifyTemplate_id, "温度控制范围最高值"))) if 温度控制范围最高值 == 0 { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "温度控制范围最高值 标签值不正确！"}) return } 温度控制范围最小值 := float64(lib.To_float32(VerifyTemplate.Read_VerifyTemplateMapData_T_name(Task_r.T_task_id, Task_r.T_VerifyTemplate_id, "温度控制范围最小值"))) if 温度控制范围最小值 == 0 { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "温度控制范围最小值 标签值不正确！"}) return } // ========== 【核心修改】：读取任务终端（温湿度绑定点）作为基准 ========== 任务终端_list := make([]Device.DeviceClassList, 0) // 兼容 "温湿度绑定点01" 和 "温湿度绑定点1" 绑定点01_list := Device.Read_DeviceClassList_List_id_T_remark(Task_r.T_class, "温湿度绑定点01|温湿度绑定点1") if len(绑定点01_list) == 0 { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "没有找到 温湿度绑定点01 或 温湿度绑定点1 数据！"}) return } 任务终端_list = append(任务终端_list, 绑定点01_list...) lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: fmt.Sprintf("基准点1 (%s): %s (%s)", 绑定点01_list[0].T_remark, 绑定点01_list[0].T_id, 绑定点01_list[0].T_sn)}) // 兼容 "温湿度绑定点02" 和 "温湿度绑定点2" 绑定点02_list := Device.Read_DeviceClassList_List_id_T_remark(Task_r.T_class, "温湿度绑定点02|温湿度绑定点2") if len(绑定点02_list) > 0 { 任务终端_list = append(任务终端_list, 绑定点02_list...) lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: fmt.Sprintf("基准点2 (%s): %s (%s)", 绑定点02_list[0].T_remark, 绑定点02_list[0].T_id, 绑定点02_list[0].T_sn)}) } else { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "未找到 温湿度绑定点02/2，仅使用 温湿度绑定点01/1 作为基准"}) } // 均匀性布点 产品存放区域测点 (需要被修正的测点) 部点终端_list := Device.Read_DeviceClassList_List_id_T_remark(Task_r.T_class, "均匀性布点|产品存放区域测点") if len(部点终端_list) == 0 { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "没有找到 均匀性布点/产品存放区域测点 数据！"}) return } 部点终端_sn_list := Device.JoinDeviceClassListSnToString(部点终端_list) var 开始时间, 结束时间, 趋势时间 string 开始时间, 结束时间, 趋势时间 = c.GetStartTimeAndEndTime(Task_r, 部点终端_sn_list, 温度控制范围最高值) if 开始时间 == "" || 结束时间 == "" { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "未找到 开始时间 或 结束时间！"}) return } // ----------获取保留数据------------ var 开空开, 保空开 string var 开空开驼峰, 保空开驼峰 Task.CalculateHumps_R var BWXValueStrings []string var valueStrings1, valueStrings2 []string if Task_r.T_device_type != "X" { valueStrings1, valueStrings2, 开空开, 保空开, 开空开驼峰, 保空开驼峰 = c.GetRetainData(Task_r, 部点终端_list, true) } else { BWXValueStrings = c.GetBWXRetainData(Task_r, 部点终端_sn_list, 结束时间, 趋势时间) } // ----------获取保留数据结束------------ lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "--- 开始时间: " + 开始时间 + " ---"}) lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "--- 结束时间: " + 结束时间 + " ---"}) // ========== 第一步：计算基准点平均值 ========== lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "------ 第一步：计算温湿度绑定点基准 ------"}) var 任务终端总Avg float64 var 任务终端数量 int for _, dev := range 任务终端_list { avg := Task.Read_TaskData_AVG(T_task_id, dev.T_sn, dev.T_id, 开始时间, 结束时间) if avg != 0 { 任务终端总Avg += avg 任务终端数量++ lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: fmt.Sprintf("基准点 %s Avg: %.1f", dev.T_id, RoundToDecimal(avg, 1))}) } } if 任务终端数量 == 0 { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "温湿度绑定点无数据！"}) return } 基准点 := RoundToDecimal(任务终端总Avg/float64(任务终端数量), 1) lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: fmt.Sprintf("最终基准点（绑定点Avg）: %.1f, 允许偏差阈值: ±%.1f", 基准点, T_deviation)}) // ========== 第二步：逐终端对比并修正 ========== lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "------ 第二步：逐终端对比与修正 ------"}) // 随机选择的目标差值（确保修正后严格在合规范围内，且不贴死边界） 可选差值 := []float64{0.7, 0.8, 0.9, 1.0} // 如果是保温箱 (T_deviation = 0.5)，目标差值应调整为 0.3, 0.4, 0.5 if Task_r.T_device_type == "X" { 可选差值 = []float64{0.3, 0.4, 0.5} } 修正数量 := 0 跳过数量 := 0 for _, dev := range 部点终端_list { 终端_id := dev.T_id 终端_Avg := Task.Read_TaskData_AVG(T_task_id, dev.T_sn, 终端_id, 开始时间, 结束时间) 终端_Avg = RoundToDecimal(终端_Avg, 1) 差值 := RoundToDecimal(math.Abs(终端_Avg-基准点), 1) if 差值 <= T_deviation { // ✓ 在范围内，不动 跳过数量++ lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: fmt.Sprintf("测点 %s Avg:%.1f 基准:%.1f 差值:%.1f ≤ %.1f 合规，不处理", 终端_id, 终端_Avg, 基准点, 差值, T_deviation)}) continue } // 超出范围，随机取目标差值 目标差值 := RoundToDecimal(可选差值[rand.Intn(len(可选差值))], 1) 偏移量 := RoundToDecimal(差值-目标差值, 1) if 终端_Avg > 基准点 { // 偏高，统一下移 Task.UpdateTaskDataTemperatureAndHumidityByGeometricAVG( T_task_id, 终端_id, "", "", -偏移量) newAvg := RoundToDecimal(终端_Avg-偏移量, 1) newDiff := RoundToDecimal(math.Abs(newAvg-基准点), 1) 修正数量++ lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: fmt.Sprintf("测点 %s Avg:%.1f→%.1f 下移:%.1f 差值:%.1f→%.1f(目标%.1f) ✓", 终端_id, 终端_Avg, newAvg, 偏移量, 差值, newDiff, 目标差值)}) } else { // 偏低，统一上移 Task.UpdateTaskDataTemperatureAndHumidityByGeometricAVG( T_task_id, 终端_id, "", "", 偏移量) newAvg := RoundToDecimal(终端_Avg+偏移量, 1) newDiff := RoundToDecimal(math.Abs(newAvg-基准点), 1) 修正数量++ lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: fmt.Sprintf("测点 %s Avg:%.1f→%.1f 上移:%.1f 差值:%.1f→%.1f(目标%.1f) ✓", 终端_id, 终端_Avg, newAvg, 偏移量, 差值, newDiff, 目标差值)}) } } lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: fmt.Sprintf("处理完成: %d 个终端在范围内未处理, %d 个终端已修正", 跳过数量, 修正数量)}) // ========== 校验 ========== lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "------ 校验修正结果 ------"}) for _, dev := range 部点终端_list { 终端_Avg := Task.Read_TaskData_AVG(T_task_id, dev.T_sn, dev.T_id, 开始时间, 结束时间) 终端_Avg = RoundToDecimal(终端_Avg, 1) 差值 := RoundToDecimal(math.Abs(终端_Avg-基准点), 1) status := "✓ 合规" if 差值 > T_deviation { status = "✗ 仍超出" } lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: fmt.Sprintf("校验: 测点 %s Avg:%.1f 差值:%.1f %s", dev.T_id, 终端_Avg, 差值, status)}) } // ----------恢复保留数据------------ if Task_r.T_device_type != "X" { c.SaveRetainData(Task_r, 部点终端_list, valueStrings1, valueStrings2, 开空开, 保空开, 开空开驼峰, 保空开驼峰, 温度控制范围最高值, 60) } else { c.SaveBWXRetainData(Task_r, 部点终端_list, BWXValueStrings, 结束时间, 趋势时间, 60) } // ----------恢复保留数据结束------------ lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: "完成！"}) c.Ctx.ResponseWriter.WriteHeader(http.StatusOK) } // 获取相邻2个终端值平均复制到 func (c *TaskDataHandleController) SetAdjacentDeviceAVGTaskData(T_task_id string, device Device.DeviceClassList, StartTime, EndTime string) { DeviceClassListT_remark_r := Device.Read_DeviceClassList_List_id_T_remark(device.T_class, device.T_remark) // 分组统计每个sn的数据数量 snList := Device.JoinDeviceClassListSnToString(DeviceClassListT_remark_r) TaskData_Total_GroupBySnId := Task.Read_TaskData_Total_GroupBySnId(T_task_id, snList, StartTime, EndTime) // 如果同组设备不足，扩大到整个终端类型 if len(TaskData_Total_GroupBySnId) < 2 { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "[" + device.T_remark + "]同组数据不足，扩大到全部终端搜索..."}) DeviceClassListT_remark_r = Device.Read_DeviceClassList_List_id_By_Terminal(device.T_class, false) snList = Device.JoinDeviceClassListSnToString(DeviceClassListT_remark_r) TaskData_Total_GroupBySnId = Task.Read_TaskData_Total_GroupBySnId(T_task_id, snList, StartTime, EndTime) } if len(TaskData_Total_GroupBySnId) < 2 { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "[" + device.T_remark + "]中没有找到 至少2条 可用数据"}) return } // 获取 备注 下面关联设备，数量 DeviceClassListT_remark_r_list_MAX := TaskData_Total_GroupBySnId[0].Total TaskData_Total_GroupBySnId_Map := make(map[string]int64) for _, v := range TaskData_Total_GroupBySnId { TaskData_Total_GroupBySnId_Map[v.T_sn] = v.Total } var completeDataDeviceClassList []Device.DeviceClassList for _, v := range DeviceClassListT_remark_r { // 排除目标设备本身，只使用其他有完整数据的设备作为平均源 if TaskData_Total_GroupBySnId_Map[v.T_sn] == DeviceClassListT_remark_r_list_MAX && v.T_sn != device.T_sn { completeDataDeviceClassList = append(completeDataDeviceClassList, v) } } if len(completeDataDeviceClassList) < 2 { // 如果只有1个设备有数据，直接用该设备的数据复制（不平均） if len(completeDataDeviceClassList) == 1 { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "[" + device.T_remark + "]仅1个完整数据源，直接复制数据"}) sn1, id_str1 := completeDataDeviceClassList[0].T_sn, completeDataDeviceClassList[0].T_id lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: device.T_sn + "," + device.T_id + "开始复制" + fmt.Sprintf("%s,%s", sn1, id_str1)}) List1, _ := Task.Read_TaskData_ById_List_AES(T_task_id, sn1, id_str1, StartTime, EndTime, 0, 9999) // 如果源设备数据被更新为T_id作为T_sn，用T_id回退查询 if len(List1) == 0 { List1, _ = Task.Read_TaskData_ById_List_AES(T_task_id, id_str1, id_str1, StartTime, EndTime, 0, 9999) } if len(List1) == 0 { return } T_saveT := 60 ct, _ := lib.TimeStrToTime(List1[0].T_time) var valueStrings []string for i := 0; i < len(List1); i++ { valueStrings = append(valueStrings, fmt.Sprintf("('%s','%s',%v,%v,'%s')", device.T_sn, device.T_id, List1[i].T_t, List1[i].T_rh, ct.Format("2006-01-02 15:04:05"))) ct = ct.Add(time.Second * time.Duration(T_saveT)) } Task.DeleteTaskDataByTimeRange(T_task_id, device.T_sn, device.T_id, StartTime, EndTime) err := Task.Batch_Adds_TaskData(T_task_id, valueStrings) if err == nil { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: fmt.Sprintf("%d/%d", len(valueStrings), len(valueStrings))}) } return } lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "[" + device.T_remark + "]中没有找到 至少2条 完整可用数据"}) return } //twoDevice := getBeforeAndAfter(device.T_id, completeDataDeviceClassList) //sn1, id_str1 := twoDevice[0].T_sn, twoDevice[0].T_id //sn2, id_str2 := twoDevice[1].T_sn, twoDevice[1].T_id // 根据目标T_id选最近的2个设备做平均，避免所有设备数据相同 sn1, id_str1, sn2, id_str2 := findClosestTwo(device.T_id, completeDataDeviceClassList) lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: device.T_sn + "," + device.T_id + "开始平均复制到" + fmt.Sprintf("%s,%s|%s,%s", sn1, id_str1, sn2, id_str2)}) List1, _ := Task.Read_TaskData_ById_List_AES(T_task_id, sn1, id_str1, StartTime, EndTime, 0, 9999) List2, _ := Task.Read_TaskData_ById_List_AES(T_task_id, sn2, id_str2, StartTime, EndTime, 0, 9999) // 如果源设备数据被更新为T_id作为T_sn，用T_id回退查询 if len(List1) == 0 { List1, _ = Task.Read_TaskData_ById_List_AES(T_task_id, id_str1, id_str1, StartTime, EndTime, 0, 9999) } if len(List2) == 0 { List2, _ = Task.Read_TaskData_ById_List_AES(T_task_id, id_str2, id_str2, StartTime, EndTime, 0, 9999) } num := len(List1) if len(List2) < len(List1) { num = len(List2) } if num == 0 { return } T_saveT := 60 //var list []Task.TaskData_ ct, _ := lib.TimeStrToTime(List1[0].T_time) var valueStrings []string for i := 0; i < num; i++ { if List1[i].T_time != List2[i].T_time { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: fmt.Sprintf("%s【%s】、%s【%s】时间不一致", List1[i].T_id, List1[i].T_time, List2[i].T_id, List2[i].T_time)}) return } T_t := (List1[i].T_t + List2[i].T_t) / 2 T_rh := (List1[i].T_rh + List2[i].T_rh) / 2 valueStrings = append(valueStrings, fmt.Sprintf("('%s','%s',%v,%v,'%s')", device.T_sn, device.T_id, T_t, T_rh, ct.Format("2006-01-02 15:04:05"))) ct = ct.Add(time.Second * time.Duration(T_saveT)) } Task.DeleteTaskDataByTimeRange(T_task_id, device.T_sn, device.T_id, StartTime, EndTime) err := Task.Batch_Adds_TaskData(T_task_id, valueStrings) if err == nil { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: fmt.Sprintf("%d/%d", len(valueStrings), len(valueStrings))}) } } func getBeforeAndAfter(T_id string, data []Device.DeviceClassList) []Device.DeviceClassList { var result []Device.DeviceClassList var index int for i, d := range data { if d.T_id == T_id { index = i break } } if index == 0 { result = append(result, data[len(data)-1], data[1]) } else if index == len(data)-1 { result = append(result, data[len(data)-2], data[0]) } else { result = append(result, data[index-1], data[index+1]) } return result } // findClosestTwo 根据目标T_id找最近的2个设备，用于平均源选择 func findClosestTwo(targetId string, data []Device.DeviceClassList) (string, string, string, string) { target, _ := strconv.Atoi(targetId) // 按T_id排序 sorted := make([]Device.DeviceClassList, len(data)) copy(sorted, data) for i := 0; i < len(sorted); i++ { for j := i + 1; j < len(sorted); j++ { idI, _ := strconv.Atoi(sorted[i].T_id) idJ, _ := strconv.Atoi(sorted[j].T_id) if idI > idJ { sorted[i], sorted[j] = sorted[j], sorted[i] } } } // 找最近的两个设备 var closest1, closest2 Device.DeviceClassList minDiff1, minDiff2 := 99999, 99999 for _, d := range sorted { id, err := strconv.Atoi(d.T_id) if err != nil { id = 0 } diff := id - target if diff < 0 { diff = -diff } if diff < minDiff1 { minDiff2 = minDiff1 closest2 = closest1 minDiff1 = diff closest1 = d } else if diff < minDiff2 { minDiff2 = diff closest2 = d } } return closest1.T_sn, closest1.T_id, closest2.T_sn, closest2.T_id } func RoundToDecimal(num float64, decimal int) float64 { shift := math.Pow(10, float64(decimal)) return math.Round(num*shift) / shift } /* 数据自检名称：平均值数据自检 测点：柜内所有测点|箱内所有测点|均匀性布点和产品存放区域测点、温湿度绑定点01、温湿度绑定点02 时间：采用“绑定点数据自检”的时间 策略：先执行完成“绑定点数据自检”后，温湿度绑定点01和温湿度绑定点02的数据就作为基准数据不变，温湿度绑定点01平均值与柜内所有测点平均值之间的差异在±0.5℃范围以内，温湿度绑定点02平均值与柜内所有测点平均值之间的差异在±0.5℃范围以内，若柜内所有测点的平均值较大或较小，则对柜内所有测点中平均值较大或较小的测点曲线进行偏移调整，使柜内所有测点的平均值靠近温湿度绑定点的平均值，从而达到绑定点与柜内所有测点的平均值差异在±0.5℃。以上“柜内所有测点”要分别换成“箱内所有测点”、“均匀性布点和产品存放区域测点”；“平均值数据自检”和“冷热点数据自检”可以同时勾选（冷库和冷车会用到）进行自检也可以单独执行（冷柜和保温箱只执行“平均值数据自检”） */ func RoundToDecimalHalfUp(val float64, n int) float64 { pow := math.Pow(10, float64(n)) return math.Round(val*pow) / pow } /* 数据自检名称：平均值数据自检 策略：逐个测点计算平均值，与绑定点平均值对比。 若偏差 > 0.5，则单独对该测点进行偏移（目标设为 基准±0.3，留出0.2安全余量避免贴边界）。 若偏差 ≤ 0.5，则合规，不处理。 */ func (c *TaskDataHandleController) SSE_Compare_binding_points_with_Average() { T_task_id := c.GetString("T_task_id") 偏移阈值 := 0.5 c.Ctx.ResponseWriter.Header().Set("Content-Type", "text/event-stream") c.Ctx.ResponseWriter.Header().Set("Cache-Control", "no-cache") c.Ctx.ResponseWriter.Header().Set("Connection", "keep-alive") lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "任务开始......"}) Task_r, err := Task.Read_Task(T_task_id) if err != nil { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取任务信息失败!"}) return } // 温度控制范围 温度控制范围最高值 := float64(lib.To_float32(VerifyTemplate.Read_VerifyTemplateMapData_T_name(Task_r.T_task_id, Task_r.T_VerifyTemplate_id, "温度控制范围最高值"))) if 温度控制范围最高值 == 0 { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "温度控制范围最高值 标签值不正确！"}) return } 温度控制范围最小值 := float64(lib.To_float32(VerifyTemplate.Read_VerifyTemplateMapData_T_name(Task_r.T_task_id, Task_r.T_VerifyTemplate_id, "温度控制范围最小值"))) if 温度控制范围最小值 == 0 { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "温度控制范围最小值 标签值不正确！"}) return } // 布点终端 部点终端_list := Device.Read_DeviceClassList_List_id_T_remark(Task_r.T_class, "均匀性布点|柜内所有测点|箱内所有测点|产品存放区域测点") if len(部点终端_list) == 0 { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "没有找到 柜内所有测点|箱内所有测点|均匀性布点|产品存放区域测点 测点数据！"}) return } 部点终端_sn_list := Device.JoinDeviceClassListSnToString(部点终端_list) // 动态兼容“满载”和“空载”的时间范围 开始时间 := VerifyTemplate.Read_VerifyTemplateMapData_T_name(Task_r.T_task_id, Task_r.T_VerifyTemplate_id, "温度分布特性的测试与分析（满载）开始时间") 结束时间 := VerifyTemplate.Read_VerifyTemplateMapData_T_name(Task_r.T_task_id, Task_r.T_VerifyTemplate_id, "温度分布特性的测试与分析（满载）结束时间") if 开始时间 == "" || 结束时间 == "" { 开始时间 = VerifyTemplate.Read_VerifyTemplateMapData_T_name(Task_r.T_task_id, Task_r.T_VerifyTemplate_id, "温度分布特性的测试与分析（空载）开始时间") 结束时间 = VerifyTemplate.Read_VerifyTemplateMapData_T_name(Task_r.T_task_id, Task_r.T_VerifyTemplate_id, "温度分布特性的测试与分析（空载）结束时间") } if 开始时间 == "" || 结束时间 == "" { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "未找到 温度分布特性的测试与分析（满载/空载）的开始时间 或 结束时间！"}) return } lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "--- 实际使用测试时间范围: " + 开始时间 + " 至 " + 结束时间 + " ---"}) // ----------获取保留数据------------ var valueStrings1, valueStrings2 []string var 开空开, 保空开 string var 开空开驼峰, 保空开驼峰 Task.CalculateHumps_R var BWXValueStrings []string if Task_r.T_device_type != "X" { valueStrings1, valueStrings2, 开空开, 保空开, 开空开驼峰, 保空开驼峰 = c.GetRetainData(Task_r, 部点终端_list, true) } else { BWXValueStrings = c.GetBWXRetainData(Task_r, 部点终端_sn_list, 结束时间, 结束时间) } // ----------获取保留数据结束------------ // 温湿度绑定点 温湿度绑定点_list := Device.Read_DeviceClassList_List_id_T_remark(Task_r.T_class, "温湿度绑定点") if len(温湿度绑定点_list) < 1 { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "未找到 温湿度绑定点！"}) return } var 温湿度绑定点1, _ Device.DeviceClassList for _, list := range 温湿度绑定点_list { if strings.Contains(list.T_remark, "温湿度绑定点1") { 温湿度绑定点1 = list } if strings.Contains(list.T_remark, "温湿度绑定点2") { _ = list } } // 1. 绑定点1的平均值作为基准 绑定点1_Avg_raw := Task.Read_TaskData_AVG(T_task_id, 温湿度绑定点1.T_sn, 温湿度绑定点1.T_id, 开始时间, 结束时间) 绑定点1_Avg := RoundToDecimalHalfUp(绑定点1_Avg_raw, 1) if 绑定点1_Avg == 0 { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "温湿度绑定点1 无平均值数据！"}) return } 压缩上限 := RoundToDecimalHalfUp(绑定点1_Avg+偏移阈值, 1) // 基准 + 0.5 压缩下限 := RoundToDecimalHalfUp(绑定点1_Avg-偏移阈值, 1) // 基准 - 0.5 lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: fmt.Sprintf("定点1 = %.1f, 合规范围 [%.1f, %.1f]", 绑定点1_Avg, 压缩下限, 压缩上限)}) lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "逐终端检查:"}) // 初始化随机数种子 rand.Seed(time.Now().UnixNano()) // 定义安全边界：0.4 或 0.5 二选一 随机偏移量 := 0.4 if rand.Intn(2) == 1 { 随机偏移量 = 0.5 } // 提前解析时间，用于后续的防断崖校验 endTimeObj, err := time.Parse("2006-01-02 15:04", 结束时间) if err != nil { endTimeObj, err = time.Parse("2006-01-02 15:04:05", 结束时间+":00") } compareTimeStr := endTimeObj.Format("2006-01-02 15:04") targetTimeObj := endTimeObj.Add(1 * time.Minute) targetTimeStr := targetTimeObj.Format("2006-01-02 15:04") lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: fmt.Sprintf("------ 开始校验 %s 之后的数据防断崖处理 ------", 结束时间)}) // 获取 ORM 实例用于执行原生 SQL 更新 //o := orm.NewOrm() for _, dev := range 部点终端_list { 终端_id := dev.T_id 终端_sn := dev.T_sn // ================= 步骤 1：先执行平均值偏移 ================= 终端_Avg_raw := Task.Read_TaskData_AVG(T_task_id, 终端_sn, 终端_id, 开始时间, 结束时间) 终端_Avg := RoundToDecimalHalfUp(终端_Avg_raw, 1) 偏差 := RoundToDecimalHalfUp(math.Abs(终端_Avg-绑定点1_Avg), 1) lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: fmt.Sprintf("测点[%s] 当前平均值:%.1f, 偏差:%.1f", 终端_id, 终端_Avg, 偏差)}) if 偏差 > 偏移阈值 { 终端_Min := Task.Read_TaskData_min(T_task_id, 终端_sn, 终端_id, 开始时间, 结束时间) 终端_Max := Task.Read_TaskData_max(T_task_id, 终端_sn, 终端_id, 开始时间, 结束时间) var targetAvg, 偏移量 float64 var 动作 string if 终端_Avg > 绑定点1_Avg { // 降：目标值 = 基准 + 0.4 或 基准 + 0.5 targetAvg = RoundToDecimalHalfUp(绑定点1_Avg+随机偏移量, 1) 偏移量 = RoundToDecimalHalfUp(终端_Avg-targetAvg, 1) 动作 = "下移" c.SetAverageShiftedDownward(T_task_id, 终端_id, 0.0, targetAvg, 终端_Avg, 终端_Min, 终端_Max, 温度控制范围最小值, 温度控制范围最高值, "", "") } else { // 升：目标值 = 基准 - 0.4 或 基准 - 0.5 targetAvg = RoundToDecimalHalfUp(绑定点1_Avg-随机偏移量, 1) 偏移量 = RoundToDecimalHalfUp(targetAvg-终端_Avg, 1) 动作 = "上移" c.SetAverageShiftedUpward(T_task_id, 终端_id, 0.0, targetAvg, 终端_Avg, 终端_Min, 终端_Max, 温度控制范围最小值, 温度控制范围最高值, "", "") } lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: fmt.Sprintf(" 测点[%s] 偏差:%.1f > 0.5 → %s%.1f → 动态目标Avg:%.1f (随机安全值)", 终端_id, 偏差, 动作, 偏移量, targetAvg)}) } else { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: fmt.Sprintf("测点[%s] 偏差 %.1f <= 0.5，已在合规范围内，跳过不处理", 终端_id, 偏差)}) } } // 重新获取处理后的整体平均值用于后续对比 处理后整体Avg := Task.Read_TaskData_Average(Task_r.T_task_id, 部点终端_sn_list, 开始时间, 结束时间) 处理后整体Avg = RoundToDecimalHalfUp(处理后整体Avg, 1) T_deviation := 1.0 温控传感器绑定点_list := Device.Read_DeviceClassList_List_id_T_remark(Task_r.T_class, "温控传感器绑定点1|温控传感器绑定点2") if len(温控传感器绑定点_list) == 0 { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "没有找到温控传感器绑定点！"}) } for i, classList := range 温控传感器绑定点_list { 温控传感器绑定点OriginalAvg := Task.Read_TaskData_Average(Task_r.T_task_id, classList.T_sn, 开始时间, 结束时间) 温控传感器绑定点OriginalAvg = RoundToDecimalHalfUp(温控传感器绑定点OriginalAvg, 1) lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "------ 进行 温控传感器绑定点" + strconv.Itoa(i+1) + " 平均值处理 ------"}) if (温控传感器绑定点OriginalAvg >= 处理后整体Avg && 温控传感器绑定点OriginalAvg <= 处理后整体Avg+T_deviation) || (温控传感器绑定点OriginalAvg <= 处理后整体Avg && 温控传感器绑定点OriginalAvg >= 处理后整体Avg-T_deviation) { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: " 温控传感器绑定点" + lib.To_string(i+1) + " 平均值:" + lib.To_string(温控传感器绑定点OriginalAvg) + "℃ " + " 测点平均值" + lib.To_string(处理后整体Avg) + "℃ " + " 数据偏差： " + lib.To_string(RoundToDecimalHalfUp(math.Abs(温控传感器绑定点OriginalAvg-处理后整体Avg), 1)) + "℃ " + " 设置：" + lib.To_string(T_deviation) + "℃" + " 符合要求！"}) } else { if 温控传感器绑定点OriginalAvg < 处理后整体Avg-T_deviation { T_max := Task.Read_TaskData_max(T_task_id, classList.T_sn, classList.T_id, 开始时间, 结束时间) T_min := Task.Read_TaskData_min(T_task_id, classList.T_sn, classList.T_id, 开始时间, 结束时间) c.SetAverageShiftedUpward(T_task_id, classList.T_id, T_deviation, RoundToDecimalHalfUp(处理后整体Avg-T_deviation, 1), 温控传感器绑定点OriginalAvg, T_min, T_max, 温度控制范围最小值, 温度控制范围最高值, "", "") lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "温控传感器绑定点" + lib.To_string(i+1) + " 平均值向上偏移"}) } if 温控传感器绑定点OriginalAvg > 处理后整体Avg+T_deviation { T_max := Task.Read_TaskData_max(T_task_id, classList.T_sn, classList.T_id, 开始时间, 结束时间) T_min := Task.Read_TaskData_min(T_task_id, classList.T_sn, classList.T_id, 开始时间, 结束时间) c.SetAverageShiftedDownward(T_task_id, classList.T_id, T_deviation, RoundToDecimalHalfUp(处理后整体Avg+T_deviation, 1), 温控传感器绑定点OriginalAvg, T_min, T_max, 温度控制范围最小值, 温度控制范围最高值, "", "") lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "温控传感器绑定点" + lib.To_string(i+1) + " 平均值向下偏移"}) } } } // ----------恢复保留数据------------ if Task_r.T_device_type != "X" { c.SaveRetainData(Task_r, 部点终端_list, valueStrings1, valueStrings2, 开空开, 保空开, 开空开驼峰, 保空开驼峰, 温度控制范围最高值, 60) } else { c.SaveBWXRetainData(Task_r, 部点终端_list, BWXValueStrings, 结束时间, 结束时间, 60) } // ----------恢复保留数据结束------------ lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: fmt.Sprintf("------ 开始校验 %s 之后的数据防断崖处理 ------", 结束时间)}) o := orm.NewOrm() for _, dev := range 部点终端_list { 终端_id := dev.T_id 终端_sn := dev.T_sn var temp46, temp47 float64 // 查询该测点在 结束时间(如 16:46) 的最后一条温度值 sql46 := fmt.Sprintf("SELECT t_t FROM z_task_data_%s WHERE t_sn = ? AND DATE_FORMAT(t_time, '%%Y-%%m-%%d %%H:%%i') = ? ORDER BY t_time DESC LIMIT 1", Task_r.T_task_id) err46 := o.Raw(sql46, 终端_sn, compareTimeStr).QueryRow(&temp46) if err46 == nil { // 查询该测点在 结束时间+1分钟(如 16:47) 的第一条温度值 sql47 := fmt.Sprintf("SELECT t_t FROM z_task_data_%s WHERE t_sn = ? AND DATE_FORMAT(t_time, '%%Y-%%m-%%d %%H:%%i') = ? ORDER BY t_time ASC LIMIT 1", Task_r.T_task_id) err47 := o.Raw(sql47, 终端_sn, targetTimeStr).QueryRow(&temp47) // 对比并修正 if err47 == nil && temp47 < temp46 { updateSql := fmt.Sprintf("UPDATE z_task_data_%s SET t_t = ? WHERE t_sn = ? AND DATE_FORMAT(t_time, '%%Y-%%m-%%d %%H:%%i') = ?", Task_r.T_task_id) _, updateErr := o.Raw(updateSql, temp46, 终端_sn, targetTimeStr).Exec() if updateErr == nil { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: fmt.Sprintf(" 测点[%s] 防断崖兜底: %s 温度 %.1f℃ < %s 温度 %.1f℃，已强制拉平至 %.1f℃", 终端_id, targetTimeStr, temp47, compareTimeStr, temp46, temp46)}) } } } } lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: "完成！"}) c.Ctx.ResponseWriter.WriteHeader(http.StatusOK) } /* 平均值下移 targetAvg 参考平均值 originalAvg 原始平均值 T_min 整段数据最小值 T_max 整段数据最大值 minLimit 温度控制范围最小值 maxLimit 温度控制范围最大值 */ func (c *TaskDataHandleController) SetAverageShiftedDownward(T_task_id, T_id string, T_deviation, targetAvg, originalAvg, T_min, T_max, minLimit, maxLimit float64, StartTime, EndTime string) { 目标avg := RoundToDecimal(targetAvg+T_deviation, 1) vgaca := RoundToDecimal(originalAvg-目标avg, 1) //向下偏移后整段数据最小值大于温度控制范围最小值 if RoundToDecimal(T_min-vgaca, 1) > RoundToDecimal(minLimit, 1) && RoundToDecimal(T_max-vgaca, 1) < RoundToDecimal(maxLimit, 1) { Task.UpdateTaskDataTemperatureAndHumidityByGeometricAVG(T_task_id, T_id, "", "", -vgaca) lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "进行处理 数据！" + " 测点 " + lib.To_string(T_id) + " 最大值:" + lib.To_string(T_max) + "℃ " + " 最小值:" + lib.To_string(T_min) + "℃ " + " 参考平均值:" + lib.To_string(RoundToDecimal(targetAvg, 1)) + "℃ " + " 原始平均值:" + lib.To_string(RoundToDecimal(originalAvg, 1)) + "℃ " + " 数据偏差：" + lib.To_string(vgaca) + "℃ " + " 向下偏移：" + lib.To_string(vgaca) + "℃ "}) } else { var err error var compress float64 compress, vgaca, err = GetLinearTransformationValue(目标avg, originalAvg, T_min, T_max, minLimit, maxLimit) if err != nil { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "进行处理 数据！" + " 测点" + lib.To_string(T_id) + " 最大值:" + lib.To_string(T_max) + "℃ " + " 最小值:" + lib.To_string(T_min) + "℃ " + " 参考平均值:" + lib.To_string(RoundToDecimal(targetAvg, 1)) + "℃ " + " 原始平均值:" + lib.To_string(RoundToDecimal(originalAvg, 1)) + "℃ " + " 无合法解: 无法满足所有约束条件!"}) return } lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "进行处理 数据！" + " 测点" + lib.To_string(T_id) + " 最大值:" + lib.To_string(T_max) + "℃ " + " 最小值:" + lib.To_string(T_min) + "℃ " + " 参考平均值:" + lib.To_string(RoundToDecimal(targetAvg, 1)) + "℃ " + " 原始平均值:" + lib.To_string(RoundToDecimal(originalAvg, 1)) + "℃ " + " 缩放：" + lib.To_string(compress) + " 缩放后最大值:" + lib.To_string(RoundToDecimal(T_max*compress, 1)) + "℃ " + " 缩放后最小值:" + lib.To_string(RoundToDecimal(T_min*compress, 1)) + "℃ " + " 数据偏差：" + lib.To_string(vgaca) + "℃ " + " 偏移：" + lib.To_string(vgaca) + "℃ "}) // 压缩 Task.UpdateTaskDataTemperatureAndHumidityByGeometric_id(T_task_id, T_id, "", "", compress) // 偏移 if vgaca != 0 { Task.UpdateTaskDataTemperatureAndHumidityByGeometricAVG(T_task_id, T_id, "", "", vgaca) } } } func GetLinearTransformationValue(targetAvg, originalAvg, T_min, T_max, minLimit, maxLimit float64) (float64, float64, error) { //var vgaca float64 //compress1 := RoundToDecimal((minLimit+0.3-targetAvg)/(T_min-originalAvg), 1) //compress2 := RoundToDecimal((maxLimit-0.3-targetAvg)/(T_max-originalAvg), 1) //compress := math.Min(compress1, compress2) //if RoundToDecimal(T_max*compress, 1) < RoundToDecimal(maxLimit, 1) && RoundToDecimal(T_min*compress, 1) > RoundToDecimal(minLimit, 1) { // vgaca = 0 //} else { // vgaca = RoundToDecimal(targetAvg-compress*originalAvg, 1) //} //for _, x := range []float64{T_min, T_max} { // newVal := RoundToDecimal(compress*x+vgaca, 1) // if newVal < minLimit || newVal > maxLimit { // return 0, 0, errors.New("无合法解: 无法满足所有约束条件") // } //} // //return compress, vgaca, nil minLimit = RoundToDecimal(minLimit+0.2, 1) maxLimit = RoundToDecimal(maxLimit-0.2, 1) // 策略1: 使用最小边界值 (使变换后最小值 = minBound) k1 := (targetAvg - minLimit) / (originalAvg - T_min) b1 := minLimit - k1*T_min valid1 := true for _, x := range []float64{T_min, T_max} { newVal := RoundToDecimal(k1*x+b1, 1) if newVal < minLimit || newVal > maxLimit { valid1 = false break } } // 策略2: 使用最大边界值 (使变换后最大值 = maxBound)，策略1失败时使用 k2 := float64(0) b2 := float64(0) valid2 := false if !valid1 { k2 = (maxLimit - targetAvg) / (T_max - originalAvg) b2 = targetAvg - k2*originalAvg valid2 = true for _, x := range []float64{T_min, T_max} { newVal := RoundToDecimal(k2*x+b2, 1) if newVal < minLimit || newVal > maxLimit { valid2 = false break } } } // 根据结果选择有效策略 switch { case valid1: return k1, b1, nil case valid2: return k2, b2, nil default: return 0, 0, errors.New("无合法解: 无法满足所有约束条件") } } /* 平均值上移 targetAvg 参考平均值 originalAvg 原始平均值 T_min 整段数据最小值 T_max 整段数据最大值 minLimit 温度控制范围最小值 maxLimit 温度控制范围最大值 */ func (c *TaskDataHandleController) SetAverageShiftedUpward(T_task_id, T_id string, T_deviation, targetAvg, originalAvg, T_min, T_max, minLimit, maxLimit float64, StartTime, EndTime string) { 目标avg := RoundToDecimal(targetAvg-T_deviation, 1) vgaca := RoundToDecimal(目标avg-originalAvg, 1) if RoundToDecimal(T_max+vgaca, 1) < RoundToDecimal(maxLimit, 1) && RoundToDecimal(T_min+vgaca, 1) > RoundToDecimal(minLimit, 1) { Task.UpdateTaskDataTemperatureAndHumidityByGeometricAVG(T_task_id, T_id, "", "", vgaca) lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "进行处理 数据！" + " 测点 " + lib.To_string(T_id) + " 最大值:" + lib.To_string(T_max) + "℃ " + " 最小值:" + lib.To_string(T_min) + "℃ " + " 参考平均值:" + lib.To_string(RoundToDecimal(targetAvg, 1)) + "℃ " + " 原始平均值:" + lib.To_string(RoundToDecimal(originalAvg, 1)) + "℃ " + " 数据偏差：" + lib.To_string(vgaca) + "℃ " + " 向上偏移：" + lib.To_string(vgaca) + "℃ "}) } else { var err error var compress float64 compress, vgaca, err = GetLinearTransformationValue(目标avg, originalAvg, T_min, T_max, minLimit, maxLimit) if err != nil { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "进行处理 数据！" + " 测点" + lib.To_string(T_id) + " 最大值:" + lib.To_string(T_max) + "℃ " + " 最小值:" + lib.To_string(T_min) + "℃ " + " 参考平均值:" + lib.To_string(RoundToDecimal(targetAvg, 1)) + "℃ " + " 原始平均值:" + lib.To_string(RoundToDecimal(originalAvg, 1)) + "℃ " + " 无合法解: 无法满足所有约束条件!"}) return } lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "进行处理 数据！" + " 测点" + lib.To_string(T_id) + " 最大值:" + lib.To_string(T_max) + "℃ " + " 最小值:" + lib.To_string(T_min) + "℃ " + " 参考平均值:" + lib.To_string(RoundToDecimal(targetAvg, 1)) + "℃ " + " 原始平均值:" + lib.To_string(RoundToDecimal(originalAvg, 1)) + "℃ " + " 缩放：" + lib.To_string(compress) + " 缩放后最大值:" + lib.To_string(RoundToDecimal(T_max*compress, 1)) + "℃ " + " 缩放后最小值:" + lib.To_string(RoundToDecimal(T_min*compress, 1)) + "℃ " + " 数据偏差：" + lib.To_string(vgaca) + "℃ " + " 偏移：" + lib.To_string(vgaca) + "℃ "}) // 压缩 Task.UpdateTaskDataTemperatureAndHumidityByGeometric_id(T_task_id, T_id, "", "", compress) // 偏移 if vgaca != 0 { Task.UpdateTaskDataTemperatureAndHumidityByGeometricAVG(T_task_id, T_id, "", "", vgaca) } } } func (c *TaskDataHandleController) GetCalculateHumps(T_task_id string, SN_list []Device.DeviceClassList, startTime, types string) (calculateHumps Task.CalculateHumps_R) { SN := Device.JoinDeviceClassListSnToString(SN_list) var is bool calculateHumps, is = Task.Redis_CalculateHumps_Get(T_task_id + types) if !is { list := Task.Read_TaskData_ById_AVG(T_task_id, SN, startTime, "") // 获取第一个驼峰结束时间点 CalculateHumps_list := Task.CalculateHumpsByThreeDots(list) if len(CalculateHumps_list) < 1 { return } calculateHumps = CalculateHumps_list[0] Task.Redis_CalculateHumps_Set(T_task_id+types, calculateHumps) } return calculateHumps } func (c *TaskDataHandleController) GetMetadata(T_task_id string, SN_list []Device.DeviceClassList, startTime, types string) (valueStrings []string, calculateHumps Task.CalculateHumps_R) { SN := Device.JoinDeviceClassListSnToString(SN_list) var is bool calculateHumps, is = Task.Redis_CalculateHumps_Get(T_task_id + types) if !is { return } endTime := calculateHumps.End.T_time data1, _ := Task.Read_TaskData_ById_List_AES(T_task_id, SN, "", startTime, endTime, 0, 9999) for _, v := range data1 { valueStrings = append(valueStrings, fmt.Sprintf("('%s','%s',%v,%v,'%s')", v.T_sn, v.T_id, v.T_t, v.T_rh, v.T_time)) } return valueStrings, calculateHumps } func (c *TaskDataHandleController) GetCalculateHumpsMaps(T_task_id string, SN_list []Device.DeviceClassList, startTime string) map[string]Task.CalculateHumps_R { var CalculateHumpsMaps = make(map[string]Task.CalculateHumps_R) SN := Device.JoinDeviceClassListSnToString(SN_list) allList := Task.Read_TaskData_ById_AVG(T_task_id, SN, startTime, "") // 获取第一个驼峰结束时间点 CalculateHumps_list := Task.CalculateHumpsByThreeDots(allList) if len(CalculateHumps_list) < 1 { return CalculateHumpsMaps } for _, device := range SN_list { list := Task.Read_TaskData_ById_AVG(T_task_id, device.T_sn, startTime, "") //获取第一个驼峰结束时间点 CalculateHumps := Task.CalculateHumpsByThreeDots(list) if len(CalculateHumps) < 1 { CalculateHumpsMaps[device.T_sn] = CalculateHumps_list[0] continue } if CalculateHumps[0].Peak.T_time != CalculateHumps_list[0].Peak.T_time { CalculateHumps[0].Peak.T_time = CalculateHumps_list[0].Peak.T_time } et1, _ := lib.TimeStrToTime(CalculateHumps_list[0].End.T_time) et2, _ := lib.TimeStrToTime(CalculateHumps[0].End.T_time) if et1.Before(et2) { CalculateHumps[0].End.T_time = CalculateHumps_list[0].End.T_time } CalculateHumpsMaps[device.T_sn] = CalculateHumps[0] } return CalculateHumpsMaps } // 获取保留数据 func (c *TaskDataHandleController) GetRetainData(Task_r Task.Task, SN_list []Device.DeviceClassList, useCache bool) (valueStrings1, valueStrings2 []string, kkkStartTime, bkkStartTime string, kkkCalculateHumps, bkkCalculateHumps Task.CalculateHumps_R) { var 开空开, 保空开 string var 开空开驼峰, 保空开驼峰 Task.CalculateHumps_R if Task_r.T_device_type != "X" { 开空开 = VerifyTemplate.Read_VerifyTemplateMapData_T_name(Task_r.T_task_id, Task_r.T_VerifyTemplate_id, "开空开") if len(开空开) == 0 { 开空开 = VerifyTemplate.Read_VerifyTemplateMapData_T_name(Task_r.T_task_id, Task_r.T_VerifyTemplate_id, "开满开") } if len(开空开) == 0 { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "未找到 开空开/开满开 时间 标签！"}) return } //保空开 = VerifyTemplate.Read_VerifyTemplateMapData_T_name(Task_r.T_task_id, Task_r.T_VerifyTemplate_id, "保空开") //if len(保空开) == 0 { // 保空开 = VerifyTemplate.Read_VerifyTemplateMapData_T_name(Task_r.T_task_id, Task_r.T_VerifyTemplate_id, "保满开") //} //if len(保空开) == 0 { // lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "未找到 保空开/保满开 时间 标签！"}) // return //} //if !useCache { // 开空开驼峰 = c.GetCalculateHumps(Task_r.T_task_id, SN_list, 开空开, "kkk") // 保空开驼峰 = c.GetCalculateHumps(Task_r.T_task_id, SN_list, 保空开, "bkk") //} // //valueStrings1, 开空开驼峰 = c.GetMetadata(Task_r.T_task_id, SN_list, 开空开, "kkk") //valueStrings2, 保空开驼峰 = c.GetMetadata(Task_r.T_task_id, SN_list, 保空开, "bkk") SN := Device.JoinDeviceClassListSnToString(SN_list) data1, _ := Task.Read_TaskData_ById_List_AES(Task_r.T_task_id, SN, "", 开空开, "", 0, 9999) for _, v := range data1 { valueStrings1 = append(valueStrings1, fmt.Sprintf("('%s','%s',%v,%v,'%s')", v.T_sn, v.T_id, v.T_t, v.T_rh, v.T_time)) } } return valueStrings1, valueStrings2, 开空开, 保空开, 开空开驼峰, 保空开驼峰 } // 获取保留数据 func (c *TaskDataHandleController) SaveRetainData(Task_r Task.Task, SN_list []Device.DeviceClassList, valueStrings1, valueStrings2 []string, kkkStartTime, bkkStartTime string, kkkCalculateHumps, bkkCalculateHumps Task.CalculateHumps_R, maxLimit float64, saveTime int) { var err error if len(valueStrings1) > 0 { //将开空开/开满开时间开始第一个驼峰 写入原始数据 //将 开空开/开满开时间 后时间写入原始数据 SN := Device.JoinDeviceClassListSnToString(SN_list) Task.DeleteTaskAllDataByTimeRange(Task_r.T_task_id, SN, kkkStartTime, kkkCalculateHumps.End.T_time) err = Task.Batch_Adds_TaskData(Task_r.T_task_id, valueStrings1) if err == nil { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: fmt.Sprintf("恢复 开空开/开满开 时间点后驼峰 %s ~ %s 数据 %d/%d", kkkStartTime, kkkCalculateHumps.End.T_time, len(valueStrings1), len(valueStrings1))}) } } if len(valueStrings2) > 0 { //将开空开/开满开时间开始第一个驼峰 写入原始数据 SN := Device.JoinDeviceClassListSnToString(SN_list) Task.DeleteTaskAllDataByTimeRange(Task_r.T_task_id, SN, bkkStartTime, bkkCalculateHumps.End.T_time) err = Task.Batch_Adds_TaskData(Task_r.T_task_id, valueStrings2) if err == nil { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: fmt.Sprintf("恢复 保空开/保满开 时间点后驼峰 %s ~ %s 数据 %d/%d", kkkStartTime, kkkCalculateHumps.End.T_time, len(valueStrings1), len(valueStrings1))}) } } //c.SaveRetainDataAndTrend(Task_r, SN_list, valueStrings1, kkkStartTime, kkkCalculateHumps, maxLimit, saveTime) //c.SaveRetainDataAndTrend(Task_r, SN_list, valueStrings2, bkkStartTime, bkkCalculateHumps, maxLimit, saveTime) } // 获取保留数据 func (c *TaskDataHandleController) SaveRetainDataTrend(Task_r Task.Task, SN_list []Device.DeviceClassList, valueStrings1, valueStrings2 []string, kkkStartTime, bkkStartTime string, kkkCalculateHumps, bkkCalculateHumps Task.CalculateHumps_R, maxLimit float64, saveTime int) { c.SaveRetainDataAndTrend(Task_r, SN_list, valueStrings1, kkkStartTime, kkkCalculateHumps, maxLimit, saveTime) c.SaveRetainDataAndTrend(Task_r, SN_list, valueStrings2, bkkStartTime, bkkCalculateHumps, maxLimit, saveTime) } func (c *TaskDataHandleController) SaveRetainDataAndTrend(Task_r Task.Task, SN_list []Device.DeviceClassList, valueStrings1 []string, kkkStartTime string, kkkCalculateHumps Task.CalculateHumps_R, maxLimit float64, saveTime int) { var err error if len(valueStrings1) > 0 { //将开空开/开满开时间开始第一个驼峰 写入原始数据 SN := Device.JoinDeviceClassListSnToString(SN_list) Task.DeleteTaskAllDataByTimeRange(Task_r.T_task_id, SN, kkkStartTime, kkkCalculateHumps.End.T_time) err = Task.Batch_Adds_TaskData(Task_r.T_task_id, valueStrings1) if err == nil { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: fmt.Sprintf("恢复 开空开/开满开 保空开/保满开 时间点后驼峰 %s ~ %s 数据 %d/%d", kkkStartTime, kkkCalculateHumps.End.T_time, len(valueStrings1), len(valueStrings1))}) } startTimeT, _ := lib.TimeStrToTime(kkkStartTime) startTime := startTimeT.Add(-time.Minute).Format("2006-01-02 15:04") endTimeT, _ := lib.TimeStrToTime(kkkCalculateHumps.End.T_time) endTime := endTimeT.Add(time.Minute).Format("2006-01-02 15:04") // 执行数据平滑 for _, v := range SN_list { sn := v.T_sn id_str := v.T_id //AllList, _ := Task.Read_TaskData_ById_List_AES(Task_r.T_task_id, sn, id_str, startTime, kkkCalculateHumps.End.T_time, 0, 9999) var trendTime, declineTrendTime string trendTime = kkkCalculateHumps.Peak.T_time declineTrendTime = kkkCalculateHumps.Peak.T_time lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "执行数据上升趋势"}) if len(trendTime) > 0 { list, _ := Task.Read_TaskData_ById_List_AES(Task_r.T_task_id, sn, id_str, startTime, trendTime, 0, 9999) if len(list) <= 2 { continue } first := list[0] var last Task.TaskData_ if len(list) > 10 { last = list[len(list)-2] } else { last = list[len(list)-1] } current, _ := time.Parse("2006-01-02 15:04", first.T_time) next, _ := time.Parse("2006-01-02 15:04", last.T_time) interval := next.Sub(current).Seconds() / float64(saveTime) //ttInterval := (last.T_t - first.T_t) / float32(interval) trhInterval := (last.T_rh - first.T_rh) / float32(interval) ttList := generateRisingCurve(float64(first.T_t), float64(last.T_t), int(interval+1)) //tt := first.T_t ttrh := first.T_rh var valueStrings []string for i := 0; i <= int(interval); i++ { //tt += ttInterval ttrh += trhInterval ttime := current.Format("2006-01-02 15:04") valueStrings = append(valueStrings, fmt.Sprintf("('%s','%s',%v,%v,'%s')", first.T_sn, id_str, ttList[i], ttrh, ttime)) current = current.Add(time.Second * time.Duration(saveTime)) } //for current.Unix() <= next.Unix() { // // tt += ttInterval // ttrh += trhInterval // ttime := current.Format("2006-01-02 15:04") // valueStrings = append(valueStrings, fmt.Sprintf("('%s','%s',%v,%v,'%s')", first.T_sn, id_str, tt, ttrh, ttime)) // current = current.Add(time.Second * time.Duration(saveTime)) //} Task.DeleteTaskDataByTimeRange(Task_r.T_task_id, sn, id_str, first.T_time, last.T_time) Task.Batch_Adds_TaskData(Task_r.T_task_id, valueStrings) } lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "执行数据下降趋势"}) if len(declineTrendTime) > 0 { list, _ := Task.Read_TaskData_ById_List_AES(Task_r.T_task_id, sn, id_str, declineTrendTime, endTime, 0, 9999) if len(list) <= 2 { continue } if list[len(list)-1].T_t > list[len(list)-2].T_t { continue } var first Task.TaskData_ if len(list) > 10 { first = list[1] } else { first = list[0] } last := list[len(list)-1] current, _ := time.Parse("2006-01-02 15:04", first.T_time) next, _ := time.Parse("2006-01-02 15:04", last.T_time) interval := next.Sub(current).Seconds() / float64(saveTime) //ttInterval := (last.T_t - first.T_t) / float32(interval) trhInterval := (last.T_rh - first.T_rh) / float32(interval) ttList := generateTemperatureCurve(float64(first.T_t), float64(last.T_t), int(interval+1)) //tt := first.T_t ttrh := first.T_rh var valueStrings []string for i := 0; i <= int(interval); i++ { //tt += ttInterval ttrh += trhInterval ttime := current.Format("2006-01-02 15:04") valueStrings = append(valueStrings, fmt.Sprintf("('%s','%s',%v,%v,'%s')", first.T_sn, id_str, ttList[i], ttrh, ttime)) current = current.Add(time.Second * time.Duration(saveTime)) } Task.DeleteTaskDataByTimeRange(Task_r.T_task_id, sn, id_str, first.T_time, last.T_time) Task.Batch_Adds_TaskData(Task_r.T_task_id, valueStrings) } } } } // 获取保留数据 func (c *TaskDataHandleController) GetBWXRetainData(Task_r Task.Task, SN string, endTime, trendTime string) (BWXValueStrings []string) { if endTime != trendTime { data1, _ := Task.Read_TaskData_ById_List_AES(Task_r.T_task_id, SN, "", trendTime, "", 0, 9999) for _, v := range data1 { BWXValueStrings = append(BWXValueStrings, fmt.Sprintf("('%s','%s',%v,%v,'%s')", v.T_sn, v.T_id, v.T_t, v.T_rh, v.T_time)) } } return } func (c *TaskDataHandleController) SaveBWXRetainData(Task_r Task.Task, SN_list []Device.DeviceClassList, BWXValueStrings []string, endTime, trendTime string, saveTime int) { var err error if endTime != trendTime && len(BWXValueStrings) > 0 { //将开空开/开满开时间开始第一个驼峰 写入原始数据 for _, device := range SN_list { Task.DeleteTaskDataByTimeRange(Task_r.T_task_id, device.T_sn, device.T_id, trendTime, "") } err = Task.Batch_Adds_TaskData(Task_r.T_task_id, BWXValueStrings) if err == nil { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: fmt.Sprintf("恢复 保温箱 原始数据 %d/%d", len(BWXValueStrings), len(BWXValueStrings))}) } var startTime string startTime = VerifyTemplate.Read_VerifyTemplateMapData_T_name(Task_r.T_task_id, Task_r.T_VerifyTemplate_id, "静态开箱作业开箱结束时间") if len(startTime) == 0 { startTime = VerifyTemplate.Read_VerifyTemplateMapData_T_name(Task_r.T_task_id, Task_r.T_VerifyTemplate_id, "动态开箱作业开箱结束时间") } if len(startTime) == 0 { startTime = VerifyTemplate.Read_VerifyTemplateMapData_T_name(Task_r.T_task_id, Task_r.T_VerifyTemplate_id, "开箱作业开箱结束时间") } if len(startTime) == 0 { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 静态开箱作业开箱结束时间|动态开箱作业开箱结束时间|开箱作业开箱结束时间 失败"}) return } startTimeT, _ := lib.TimeStrToTime(startTime) startTime = startTimeT.Add(30 * time.Minute).Format("2006-01-02 15:04") // 执行数据平滑 for _, v := range SN_list { sn := v.T_sn id_str := v.T_id list, _ := Task.Read_TaskData_ById_List_AES(Task_r.T_task_id, sn, id_str, startTime, trendTime, 0, 9999) first := list[0] last := list[len(list)-1] current, _ := time.Parse("2006-01-02 15:04", first.T_time) next, _ := time.Parse("2006-01-02 15:04", last.T_time) interval := next.Sub(current).Seconds() / float64(saveTime) ttInterval := (last.T_t - first.T_t) / float32(interval) trhInterval := (last.T_rh - first.T_rh) / float32(interval) tt := first.T_t ttrh := first.T_rh var valueStrings []string for current.Unix() <= next.Unix() { tt += ttInterval ttrh += trhInterval ttime := current.Format("2006-01-02 15:04") valueStrings = append(valueStrings, fmt.Sprintf("('%s','%s',%v,%v,'%s')", first.T_sn, id_str, tt, ttrh, ttime)) current = current.Add(time.Second * time.Duration(saveTime)) } Task.DeleteTaskDataByTimeRange(Task_r.T_task_id, sn, id_str, startTime, trendTime) err = Task.Batch_Adds_TaskData(Task_r.T_task_id, valueStrings) if err == nil { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: fmt.Sprintf("保温箱数据趋势 %d/%d", len(valueStrings), len(valueStrings))}) } } } } // 获取开始结束时间 func (c *TaskDataHandleController) GetStartTimeAndEndTime(Task_r Task.Task, SN string, maxLimit float64) (startTime, endTime, trendTime string) { // 开始时间 获取温度下降到第二个低点时间 // 1. 获取温度平均值 list := Task.Read_TaskData_ById_AVG(Task_r.T_task_id, SN, "", "") if len(list) < 2 { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "均匀性布点+产品存放区域测点+作业出入口总测点 数据平均值 少于2条!"}) return } // 找平均值低于温度控制范围最高值的第二个最低点 lowPoint := 0 for i := 1; i <= len(list)-2; i++ { if list[i].T_t < list[i-1].T_t && list[i].T_t < list[i+1].T_t && list[i].T_t < float32(maxLimit) { lowPoint += 1 } if lowPoint == 2 { startTime = list[i].T_time break } } // 保温箱没有开空开，开满开 // 结束时间温度超限取没有超限时间点，结束时间温度未超限取最后一个时间点 if Task_r.T_device_type == "X" { list2 := Task.Read_TaskData_ById_AVG_DESC(Task_r.T_task_id, SN, "", "") if len(list) == 0 { return } if float64(list2[0].T_t) < maxLimit { endTime = list2[0].T_time trendTime = list2[0].T_time return } for i, avg := range list2 { if RoundToDecimal(float64(avg.T_t), 1) < maxLimit { endTime = avg.T_time trendTime = list2[i-1].T_time break } } } else { endTime = VerifyTemplate.Read_VerifyTemplateMapData_T_name(Task_r.T_task_id, Task_r.T_VerifyTemplate_id, "开空开") if len(endTime) == 0 { endTime = VerifyTemplate.Read_VerifyTemplateMapData_T_name(Task_r.T_task_id, Task_r.T_VerifyTemplate_id, "开满开") } if len(endTime) == 0 { endTime = VerifyTemplate.Read_VerifyTemplateMapData_T_name(Task_r.T_task_id, Task_r.T_VerifyTemplate_id, "现场测试结束时间") } if len(endTime) == 0 { return } } return } /* 计算绑定点的值 A 监测终端01平均值 B 监测终端02平均值 C 温湿度绑定点01平均值 D 温湿度绑定点02平均值 */ func findBindingPointsOptimalAdjustment(A, B, C, D, T_deviation float64) (float64, float64, bool) { type DataPair struct { A1 float64 B1 float64 } T_deviation_half := 0.1 var dataPairs []DataPair var A1, B1 float64 = -100, -100 // 生成A1和B1的可能值 for a1 := A - T_deviation; a1 <= A+T_deviation; a1 += T_deviation_half { for b1 := B - T_deviation; b1 <= B+T_deviation; b1 += T_deviation_half { // 检查是否存在满足条件的C值 minC := math.Max(a1-T_deviation_half, b1-T_deviation_half) maxC := math.Min(a1+T_deviation_half, b1+T_deviation_half) if minC <= maxC { dataPairs = append(dataPairs, DataPair{A1: a1, B1: b1}) } } } if len(dataPairs) == 1 { A1 = dataPairs[0].A1 B1 = dataPairs[0].B1 } if len(dataPairs) > 1 { // 寻找最优解 minAdjustment := math.MaxFloat64 var optimalPair DataPair for _, pair := range dataPairs { adjustment := math.Abs(pair.A1-C) + math.Abs(pair.B1-D) if adjustment < minAdjustment { minAdjustment = adjustment optimalPair = pair } } A1 = optimalPair.A1 B1 = optimalPair.B1 } if A1 == -100 || B1 == -100 { return A1, B1, false } return A1, B1, true } /* 计算绑定点的值 A 温湿度绑定点1平均值 B 温湿度绑定点2平均值 C 测点平均值 */ func findAverageOptimalAdjustment(A, B, C float64) float64 { // 计算有效区间 minA := A - 0.5 maxA := A + 0.5 minB := B - 0.5 maxB := B + 0.5 // 求交集范围 lowerBound := math.Max(minA, minB) upperBound := math.Min(maxA, maxB) // 确定最优调整值 var optimalC float64 if C < lowerBound { optimalC = lowerBound // 取区间下限 } else if C > upperBound { optimalC = upperBound // 取区间上限 } else { optimalC = C // 已在区间内无需调整 } return optimalC } func generateTemperatureCurve(startTemp, minTemp float64, steps int) []float64 { if steps <= 0 { return []float64{} } // 计算动态参数确保严格递减且高于最低温度 base := minTemp + 0.1 // 确保所有值高于minTemp decayFactor := math.Log((startTemp-base)/(minTemp+0.5-base)) / float64(steps-1) temperatures := make([]float64, steps) prevTemp := startTemp for i := 0; i < steps; i++ { // 使用指数衰减模型确保严格单调递减 temp := base + (startTemp-base)*math.Exp(-decayFactor*float64(i)) // 确保严格递减且高于最低温度 if temp >= prevTemp { temp = prevTemp - 0.1 } if temp <= minTemp { temp = minTemp + 0.01 + 0.05*float64(steps-i)/float64(steps) } // 保持精度并确保唯一性 temp = math.Round(temp*100) / 100 temperatures[i] = temp prevTemp = temp } return temperatures } func generateRisingCurve(minTemp, maxTemp float64, steps int) []float64 { if steps <= 0 { return []float64{} } // 计算动态参数确保严格递增且低于最高温度 growthFactor := math.Log((maxTemp-minTemp-0.1)/0.1) / float64(steps-1) temperatures := make([]float64, steps) prevTemp := minTemp for i := 0; i < steps; i++ { // 使用指数增长模型确保严格单调递增 temp := minTemp + (maxTemp-minTemp)*(1-math.Exp(-growthFactor*float64(i))) // 确保严格递增且低于最高温度 if temp <= prevTemp { temp = prevTemp + 0.1 } if temp >= maxTemp { temp = maxTemp - 0.01 - 0.05*float64(steps-i-1)/float64(steps) } // 保持精度并确保唯一性 temp = math.Round(temp*100) / 100 temperatures[i] = temp prevTemp = temp } return temperatures } // 鼓包/缺数据及超上下限处理 // 处理顺序：1. 超高温修复 -> 2. 超低温修复 -> 3. 鼓包修复 -> 4. 兜底裁剪 func (c *TaskDataHandleController) SSE_Process_hump_data() { T_task_id := c.GetString("T_task_id") c.Ctx.ResponseWriter.Header().Set("Content-Type", "text/event-stream") c.Ctx.ResponseWriter.Header().Set("Cache-Control", "no-cache") c.Ctx.ResponseWriter.Header().Set("Connection", "keep-alive") lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "综合异常检测与修复任务开始......"}) Task_r, err := Task.Read_Task(T_task_id) if err != nil { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取任务信息失败!"}) return } // 从表单中获取时间范围 开始时间 := VerifyTemplate.Read_VerifyTemplateMapData_T_name(Task_r.T_task_id, Task_r.T_VerifyTemplate_id, "温度分布特性的测试与分析（满载）开始时间") 结束时间 := VerifyTemplate.Read_VerifyTemplateMapData_T_name(Task_r.T_task_id, Task_r.T_VerifyTemplate_id, "温度分布特性的测试与分析（满载）结束时间") if len(开始时间) == 0 || len(结束时间) == 0 || 开始时间 == "null" || 结束时间 == "null" { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取表单中'温度分布特性的测试与分析（满载）开始/结束时间'失败，请先填写表单时间字段!"}) return } lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "时间范围: " + 开始时间 + " ~ " + 结束时间}) DeviceClassList_list := Device.Read_DeviceClassList_List_id_By_Terminal(Task_r.T_class, false) lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "终端总共：" + lib.To_string(len(DeviceClassList_list)) + " 个，开始检测..."}) if len(DeviceClassList_list) == 0 { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "没有找到终端设备!"}) return } // ========== 步骤1：加载所有传感器数据 ========== allData := make(map[string]map[string]float32) for _, dev := range DeviceClassList_list { dataList, cnt := Task.Read_TaskData_ById_List_AES(Task_r.T_task_id, dev.T_sn, dev.T_id, 开始时间, 结束时间, 0, 9999) if cnt < 10 { continue } timeMap := make(map[string]float32) for _, d := range dataList { timeMap[d.T_time] = d.T_t } allData[dev.T_id] = timeMap } // ========== 步骤2：收集所有时间点并排序 ========== timeSet := make(map[string]bool) for _, tm := range allData { for t := range tm { timeSet[t] = true } } allTimes := make([]string, 0, len(timeSet)) for t := range timeSet { allTimes = append(allTimes, t) } sort.Strings(allTimes) if len(allTimes) < 5 { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "时间点不足，无法检测"}) } else { // ========== 步骤2.5：从数据库表单读取温度控制范围 ========== // 1. 兼容读取最高值/最大值 最高值Str := VerifyTemplate.Read_VerifyTemplateMapData_T_name(Task_r.T_task_id, Task_r.T_VerifyTemplate_id, "温度控制范围最高值") if 最高值Str == "" { 最高值Str = VerifyTemplate.Read_VerifyTemplateMapData_T_name(Task_r.T_task_id, Task_r.T_VerifyTemplate_id, "温度控制范围最大值") } 温度控制范围最高值 := lib.To_float32(最高值Str) // 2. 兼容读取最低值/最小值 最低值Str := VerifyTemplate.Read_VerifyTemplateMapData_T_name(Task_r.T_task_id, Task_r.T_VerifyTemplate_id, "温度控制范围最低值") if 最低值Str == "" { 最低值Str = VerifyTemplate.Read_VerifyTemplateMapData_T_name(Task_r.T_task_id, Task_r.T_VerifyTemplate_id, "温度控制范围最小值") } 温度控制范围最低值 := lib.To_float32(最低值Str) // 3. 校验读取结果 if 温度控制范围最高值 <= 0 || 温度控制范围最低值 >= 温度控制范围最高值 { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取表单中'温度控制范围最高值/最低值'失败或逻辑无效，请先填写!"}) return } // 4. 留出 0.1 的安全余量 (防止浮点数精度导致刚好等于上限被误判) upperLimit := 温度控制范围最高值 - 0.1 lowerLimit := 温度控制范围最低值 + 0.1 lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: fmt.Sprintf("温度控制范围: %.2f°C ~ %.2f°C (已含0.1安全余量)", lowerLimit, upperLimit)}) // ========== 检测参数 ========== const DEVIATION_THRESHOLD float32 = 0.8 const MIN_DURATION = 5 const MERGE_GAP = 5 const MIN_RISE_FOR_BULGE float32 = 0.5 const MAX_MONOTONIC_EXPAND = 120 const TREND_WINDOW = 20 const TREND_SLOPE_THRESHOLD float32 = 0.01 const TREND_MIN_DURATION = 30 const MONOTONIC_MIN_DURATION = 20 const MONOTONIC_TOLERANCE = 2 type BulgeSegment struct { Device string StartTime string EndTime string } var allBulges []BulgeSegment // ========== 步骤3：鼓包检测 (基于原始数据) ========== for _, dev := range DeviceClassList_list { tm := allData[dev.T_id] if tm == nil || len(tm) < 10 { continue } type DataPoint struct { Time string Temp float32 Deviation float32 IsBulge bool } var points []DataPoint var temps []float32 for _, t := range allTimes { if v, ok := tm[t]; ok { refAll := medianOfAllDevices(allData, t) deviation := v - refAll points = append(points, DataPoint{t, v, deviation, deviation > DEVIATION_THRESHOLD}) temps = append(temps, v) } } n := len(points) if n < MIN_DURATION { continue } // 1. 偏差鼓包检测 i := 0 for i < n { if points[i].IsBulge { i++ continue } j := i for j+1 < n && !points[j+1].IsBulge { j++ } leftTrue := i-1 >= 0 && points[i-1].IsBulge rightTrue := j+1 < n && points[j+1].IsBulge gapLen := j - i + 1 if leftTrue && rightTrue && gapLen <= MERGE_GAP { for k := i; k <= j; k++ { points[k].IsBulge = true } } i = j + 1 } type Seg struct{ Start, End int } var bulgeSegs []Seg start := -1 for i, p := range points { if p.IsBulge && start == -1 { start = i } else if !p.IsBulge && start != -1 { bulgeSegs = append(bulgeSegs, Seg{start, i - 1}) start = -1 } } if start != -1 { bulgeSegs = append(bulgeSegs, Seg{start, n - 1}) } // 2. 斜率趋势检测 trendMask := detectTrends(temps, TREND_WINDOW, TREND_SLOPE_THRESHOLD, TREND_MIN_DURATION) var trendSegs []Seg start = -1 for i, v := range trendMask { if v && start == -1 { start = i } else if !v && start != -1 { trendSegs = append(trendSegs, Seg{start, i - 1}) start = -1 } } if start != -1 { trendSegs = append(trendSegs, Seg{start, n - 1}) } // 3. 单调趋势检测 monoMask := detectMonotonicTrends(temps, MONOTONIC_MIN_DURATION, MONOTONIC_TOLERANCE) var monoSegs []Seg start = -1 for i, v := range monoMask { if v && start == -1 { start = i } else if !v && start != -1 { monoSegs = append(monoSegs, Seg{start, i - 1}) start = -1 } } if start != -1 { monoSegs = append(monoSegs, Seg{start, n - 1}) } // 合并所有段 allSegs := append(bulgeSegs, trendSegs...) allSegs = append(allSegs, monoSegs...) if len(allSegs) == 0 { continue } sort.Slice(allSegs, func(i, j int) bool { return allSegs[i].Start < allSegs[j].Start }) var merged []Seg for _, seg := range allSegs { if len(merged) == 0 { merged = append(merged, seg) } else { last := &merged[len(merged)-1] if seg.Start <= last.End+MERGE_GAP { if seg.End > last.End { last.End = seg.End } } else { merged = append(merged, seg) } } } for _, seg := range merged { if seg.End-seg.Start+1 < MIN_DURATION { continue } peakIdx := seg.Start peakVal := points[seg.Start].Temp for k := seg.Start + 1; k <= seg.End; k++ { if points[k].Temp > peakVal { peakVal = points[k].Temp peakIdx = k } } startIdx := seg.Start steps := 0 for startIdx > 0 && steps < MAX_MONOTONIC_EXPAND && points[startIdx-1].Temp < points[startIdx].Temp { startIdx-- steps++ } endIdx := peakIdx steps = 0 for endIdx < len(points)-1 && steps < MAX_MONOTONIC_EXPAND && points[endIdx+1].Temp <= points[endIdx].Temp { endIdx++ steps++ } if endIdx-startIdx+1 < MIN_DURATION { continue } maxDev := float32(0) for k := startIdx; k <= endIdx; k++ { if float32(math.Abs(float64(points[k].Deviation))) > maxDev { maxDev = float32(math.Abs(float64(points[k].Deviation))) } } if maxDev < 0.3 { continue } rise := points[peakIdx].Temp - points[startIdx].Temp minTemp := points[startIdx].Temp for k := startIdx; k <= endIdx; k++ { if points[k].Temp < minTemp { minTemp = points[k].Temp } } drop := points[startIdx].Temp - minTemp if rise >= MIN_RISE_FOR_BULGE || drop >= MIN_RISE_FOR_BULGE { allBulges = append(allBulges, BulgeSegment{ Device: dev.T_id, StartTime: points[startIdx].Time, EndTime: points[endIdx].Time, }) } } } // 输出鼓包检测结果 if len(allBulges) > 0 { deviceBulges := make(map[string][]BulgeSegment) for _, b := range allBulges { deviceBulges[b.Device] = append(deviceBulges[b.Device], b) } for deviceId, bulges := range deviceBulges { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: fmt.Sprintf("%s 检测到 %d 个鼓包段", deviceId, len(bulges))}) } } // ========== 步骤4：按顺序修复 (先上下限，后鼓包) ========== const BLEND = 10 const TARGET_SMOOTH = 7 const EPS float32 = 0.03 const STABLE_N = 4 const MAX_EXPAND = 30 for _, dev := range DeviceClassList_list { tm := allData[dev.T_id] if tm == nil || len(tm) < 10 { continue } var fixTimes []string var fixTemps []float32 var fixRefExcl []float32 for _, t := range allTimes { if v, ok := tm[t]; ok { refExcl := leaveOneOutMedian(allData, dev.T_id, t) fixTimes = append(fixTimes, t) fixTemps = append(fixTemps, v) fixRefExcl = append(fixRefExcl, refExcl) } } n := len(fixTimes) if n < 10 { continue } offsetWindow := 241 if n/2 < offsetWindow { offsetWindow = n / 2 } if offsetWindow < 11 { offsetWindow = 11 } diff := make([]float32, n) for i := 0; i < n; i++ { diff[i] = fixTemps[i] - fixRefExcl[i] } offset := medianRolling(diff, offsetWindow) target := make([]float32, n) for i := 0; i < n; i++ { target[i] = fixRefExcl[i] + offset[i] } targetS := meanRolling(target, TARGET_SMOOTH) yFixed := make([]float32, n) copy(yFixed, fixTemps) // 【第1步】修复超高温段 highSegs := findAndMergeLimitSegments(fixTemps, upperLimit, true, MERGE_GAP) for _, seg := range highSegs { s2, e2 := expandByLimitCondition(yFixed, seg.Start, seg.End, upperLimit, MAX_EXPAND, STABLE_N, true) yFixed = compressSegment(yFixed, targetS, s2, e2, n, upperLimit, BLEND) } // 【第2步】修复超低温段 lowSegs := findAndMergeLimitSegments(fixTemps, lowerLimit, false, MERGE_GAP) for _, seg := range lowSegs { s2, e2 := expandByLimitCondition(yFixed, seg.Start, seg.End, lowerLimit, MAX_EXPAND, STABLE_N, false) // 低温修复技巧：取负值，复用 compressSegment 将其压到 -lowerLimit 之下，然后再取负还原 yNeg := make([]float32, n) targetNeg := make([]float32, n) for i := 0; i < n; i++ { yNeg[i] = -yFixed[i] targetNeg[i] = -targetS[i] } yNegFixed := compressSegment(yNeg, targetNeg, s2, e2, n, -lowerLimit, BLEND) for i := 0; i < n; i++ { yFixed[i] = -yNegFixed[i] } } // 【第3步】修复鼓包段 devBulges := false for _, bulge := range allBulges { if bulge.Device != dev.T_id { continue } devBulges = true s, e := -1, -1 for i, ft := range fixTimes { if ft == bulge.StartTime { s = i } if ft == bulge.EndTime { e = i } } if s < 0 || e < 0 || e <= s { continue } residual := make([]float32, n) for i := 0; i < n; i++ { residual[i] = yFixed[i] - targetS[i] } s2, e2 := expandByResidual(residual, s, e, EPS, STABLE_N, MAX_EXPAND) yFixed = compressSegment(yFixed, targetS, s2, e2, n, upperLimit, BLEND) } // 【第4步】兜底裁剪：确保绝对不超限 for i := 0; i < n; i++ { if yFixed[i] > upperLimit { yFixed[i] = upperLimit } else if yFixed[i] < lowerLimit { yFixed[i] = lowerLimit } } // 写入数据库 if devBulges || len(highSegs) > 0 || len(lowSegs) > 0 { Task.DeleteTaskDataByTimeRange(Task_r.T_task_id, dev.T_sn, dev.T_id, fixTimes[0], fixTimes[n-1]) var valueStrings []string for i := 0; i < n; i++ { valueStrings = append(valueStrings, fmt.Sprintf("('%s','%s',%.2f,0,'%s')", dev.T_sn, dev.T_id, yFixed[i], fixTimes[i])) } err = Task.Batch_Adds_TaskData(T_task_id, valueStrings) if err != nil { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: dev.T_id + " 数据修复失败: " + err.Error()}) } else { lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: fmt.Sprintf(" %s 修复完成 (共%d个数据点)", dev.T_id, n)}) } } } } // ========== 步骤5：缺数据检测 (保持不变) ========== lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "开始缺数据检测..."}) totalMissing := 0 for _, dev := range DeviceClassList_list { dataList, cnt := Task.Read_TaskData_ById_List_AES(Task_r.T_task_id, dev.T_sn, dev.T_id, 开始时间, 结束时间, 0, 9999) if cnt < 2 { continue } missingCount := 0 for i := 0; i < len(dataList)-1; i++ { ct, _ := time.Parse("2006-01-02 15:04", dataList[i].T_time) nt, _ := time.Parse("2006-01-02 15:04", dataList[i+1].T_time) interval := int(nt.Unix() - ct.Unix()) if interval == 120 { t := ct.Add(60 * time.Second).Format("2006-01-02 15:04") ttt := (dataList[i].T_t + dataList[i+1].T_t) / 2 trht := (dataList[i].T_rh + dataList[i+1].T_rh) / 2 Task.InsertTaskData(Task_r.T_task_id, Task.TaskData_{ T_sn: dataList[i].T_sn, T_id: dataList[i].T_id, T_t: ttt, T_rh: trht, T_time: t, }) missingCount++ } else if interval > 120 { device := Device.DeviceClassList{ T_class: dev.T_class, T_id: dev.T_id, T_sn: dev.T_sn, T_remark: dev.T_remark, } c.SetAdjacentDeviceAVGTaskData(T_task_id, device, 开始时间, 结束时间) missingCount++ break } } if missingCount > 0 { totalMissing += missingCount } } lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: fmt.Sprintf("完成！缺数据补全: %d处", totalMissing)}) c.Ctx.ResponseWriter.WriteHeader(http.StatusOK) } // ==================== 新增辅助函数：上下限修复专用 ==================== // findAndMergeLimitSegments 查找并合并超出限值的连续段 func findAndMergeLimitSegments(temps []float32, limit float32, isHigh bool, mergeGap int) []struct{ Start, End int } { n := len(temps) mask := make([]bool, n) for i := 0; i < n; i++ { if isHigh && temps[i] > limit { mask[i] = true } else if !isHigh && temps[i] < limit { mask[i] = true } } var segs []struct{ Start, End int } start := -1 for i := 0; i < n; i++ { if mask[i] && start == -1 { start = i } else if !mask[i] && start != -1 { segs = append(segs, struct{ Start, End int }{start, i - 1}) start = -1 } } if start != -1 { segs = append(segs, struct{ Start, End int }{start, n - 1}) } if len(segs) == 0 { return segs } // 合并间隔 <= mergeGap 的段 var merged []struct{ Start, End int } merged = append(merged, segs[0]) for i := 1; i < len(segs); i++ { last := &merged[len(merged)-1] if segs[i].Start <= last.End+mergeGap { if segs[i].End > last.End { last.End = segs[i].End } } else { merged = append(merged, segs[i]) } } return merged } // expandByLimitCondition 基于限值条件向外扩展区间 func expandByLimitCondition(yFixed []float32, s, e int, limit float32, maxExpand, stableN int, isHigh bool) (int, int) { n := len(yFixed) s2, e2 := s, e // 向左扩 steps := 0 for s2 > 0 && steps < maxExpand { l := s2 - stableN if l < 0 { l = 0 } window := yFixed[l:s2] allOk := len(window) == stableN if allOk { for _, v := range window { if isHigh && v > limit+0.01 { allOk = false break } else if !isHigh && v < limit-0.01 { allOk = false break } } } if allOk { break } s2-- steps++ } // 向右扩 steps = 0 for e2 < n-1 && steps < maxExpand { r := e2 + 1 + stableN if r > n { r = n } window := yFixed[e2+1 : r] allOk := len(window) == stableN if allOk { for _, v := range window { if isHigh && v > limit+0.01 { allOk = false break } else if !isHigh && v < limit-0.01 { allOk = false break } } } if allOk { break } e2++ steps++ } return s2, e2 } // ==================== 以下保留您原有的辅助函数 ==================== // detectTrends 斜率趋势检测（线性回归斜率绝对值 > 阈值，持续时间 >= minDuration） func detectTrends(series []float32, window int, slopeThresh float32, minDuration int) []bool { n := len(series) mask := make([]bool, n) if n < window { return mask } slopes := make([]float32, n) for i := 0; i <= n-window; i++ { // 计算线性回归斜率 x := make([]float64, window) y := make([]float64, window) for k := 0; k < window; k++ { x[k] = float64(k) y[k] = float64(series[i+k]) } // 最小二乘法 sumX, sumY, sumXY, sumX2 := 0.0, 0.0, 0.0, 0.0 for k := 0; k < window; k++ { sumX += x[k] sumY += y[k] sumXY += x[k] * y[k] sumX2 += x[k] * x[k] } denom := float64(window)*sumX2 - sumX*sumX if denom == 0 { slopes[i+window/2] = 0 } else { slope := float32((float64(window)*sumXY - sumX*sumY) / denom) slopes[i+window/2] = slope } } // 强斜率标记 strong := make([]bool, n) for i := 0; i < n; i++ { if math.Abs(float64(slopes[i])) > float64(slopeThresh) { strong[i] = true } } // 找连续强斜率段（长度 >= minDuration） count := 0 for i := 0; i < n; i++ { if strong[i] { count++ } else { if count >= minDuration { for j := i - count; j < i; j++ { mask[j] = true } } count = 0 } } if count >= minDuration { for j := n - count; j < n; j++ { mask[j] = true } } return mask } // detectMonotonicTrends 单调趋势检测（同向比例 >= 0.8，持续 >= minDuration） func detectMonotonicTrends(series []float32, minDuration int, tolerance int) []bool { n := len(series) mask := make([]bool, n) if n < minDuration { return mask } // 计算差分符号 signs := make([]int, n-1) for i := 0; i < n-1; i++ { if series[i+1] > series[i] { signs[i] = 1 } else if series[i+1] < series[i] { signs[i] = -1 } else { signs[i] = 0 } } window := minDuration half := window / 2 for i := 0; i < n; i++ { l := i - half if l < 0 { l = 0 } r := i + half + 1 if r > n-1 { r = n - 1 } if l > r { continue } seg := signs[l:r] pos, neg := 0, 0 for _, s := range seg { if s > 0 { pos++ } else if s < 0 { neg++ } } total := pos + neg if total < window/2 { continue } ratio := float32(max(pos, neg)) / float32(total) if ratio >= 0.8 { mask[i] = true } } // 合并连续段，去除长度小于 minDuration 的 // 简单做法：先找到段，再过滤 var segs []struct{ s, e int } start := -1 for i, v := range mask { if v && start == -1 { start = i } else if !v && start != -1 { segs = append(segs, struct{ s, e int }{start, i - 1}) start = -1 } } if start != -1 { segs = append(segs, struct{ s, e int }{start, n - 1}) } finalMask := make([]bool, n) for _, seg := range segs { if seg.e-seg.s+1 >= minDuration { for i := seg.s; i <= seg.e; i++ { finalMask[i] = true } } } return finalMask } // 辅助函数：max func max(a, b int) int { if a > b { return a } return b } // medianOfSlice 计算float32切片的中位数 func medianOfSlice(vals []float32) float32 { if len(vals) == 0 { return 0 } sorted := make([]float32, len(vals)) copy(sorted, vals) sort.Slice(sorted, func(i, j int) bool { return sorted[i] < sorted[j] }) n := len(sorted) if n%2 == 0 { return (sorted[n/2-1] + sorted[n/2]) / 2 } return sorted[n/2] } // medianOfAllDevices 计算所有设备在某个时间点的中位数 func medianOfAllDevices(allData map[string]map[string]float32, t string) float32 { var vals []float32 for _, tm := range allData { if v, ok := tm[t]; ok { vals = append(vals, v) } } return medianOfSlice(vals) } // leaveOneOutMedian 计算排除当前设备后其他设备的中位数 // 与c.txt一致：在所有值中找到与当前值最接近的值，排除它，取剩余的中位数 func leaveOneOutMedian(allData map[string]map[string]float32, deviceId string, t string) float32 { var vals []float32 for _, tm := range allData { if v, ok := tm[t]; ok { vals = append(vals, v) } } if len(vals) <= 1 { return medianOfAllDevices(allData, t) } // 获取当前设备的值 currentVal := float32(0) if tm, ok := allData[deviceId]; ok { if v, ok2 := tm[t]; ok2 { currentVal = v } } // 找到与当前值最接近的值的索引，排除它 closestIdx := 0 closestDiff := float32(math.MaxFloat32) for i, v := range vals { diff := float32(math.Abs(float64(v - currentVal))) if diff < closestDiff { closestDiff = diff closestIdx = i } } // 排除最接近的值 vv := append(vals[:closestIdx], vals[closestIdx+1:]...) if len(vv) == 0 { return medianOfAllDevices(allData, t) } return medianOfSlice(vv) } // medianRolling 滚动中位数 func medianRolling(arr []float32, window int) []float32 { n := len(arr) result := make([]float32, n) half := window / 2 minPeriods := window / 5 if minPeriods < 5 { minPeriods = 5 } for i := 0; i < n; i++ { start := i - half if start < 0 { start = 0 } end := i + half + 1 if end > n { end = n } if end-start < minPeriods { if n >= minPeriods { // 边界用可用数据 start = 0 end = n } else { result[i] = arr[i] continue } } vals := arr[start:end] result[i] = medianOfSlice(vals) } return result } // meanRolling 滚动均值 func meanRolling(arr []float32, window int) []float32 { n := len(arr) result := make([]float32, n) half := window / 2 minPeriods := window / 3 if minPeriods < 3 { minPeriods = 3 } for i := 0; i < n; i++ { start := i - half if start < 0 { start = 0 } end := i + half + 1 if end > n { end = n } if end-start < minPeriods { start = 0 end = n } sum := float32(0) count := 0 for j := start; j < end; j++ { sum += arr[j] count++ } if count > 0 { result[i] = sum / float32(count) } } return result } // smoothW 生成平滑混合权重 // w[s:e] = 1.0, 前后blend点线性过渡到0 func smoothW(n, s, e, blend int) []float32 { w := make([]float32, n) if e <= s { return w } // 核心区间 = 1.0 for i := s; i <= e; i++ { w[i] = 1.0 } // 左侧过渡 ls := s - blend if ls < 0 { ls = 0 } if ls < s { length := s - ls + 1 // length >= 2 for i := 0; i < length; i++ { w[ls+i] = float32(i) / float32(length-1) } } // 右侧过渡 re := e + blend if re >= n { re = n - 1 } if e < re { length := re - e + 1 // length >= 2 for i := 0; i < length; i++ { w[e+i] = float32(length-1-i) / float32(length-1) } } return w } // expandByResidual 以residual为依据扩展区间 // 向两侧扩展直到 residual<=eps 连续stable_n个点 func expandByResidual(residual []float32, s, e int, eps float32, stableN, maxExpand int) (int, int) { n := len(residual) s2, e2 := s, e // 向左扩 steps := 0 for s2 > 0 && steps < maxExpand { l := s2 - stableN if l < 0 { l = 0 } window := residual[l:s2] allOk := len(window) == stableN if allOk { for _, v := range window { if v > eps { allOk = false break } } } if allOk { break } s2-- steps++ } // 向右扩 steps = 0 for e2 < n-1 && steps < maxExpand { r := e2 + 1 + stableN if r > n { r = n } window := residual[e2+1 : r] allOk := len(window) == stableN if allOk { for _, v := range window { if v > eps { allOk = false break } } } if allOk { break } e2++ steps++ } return s2, e2 } // compressSegment 保形压缩（c.txt算法） // 把[s,e]（含超限外扩）整体压到 upperLimit 之下 // 1) 基准峰(target_s)若超限，先按形状等比压矮（保留尖峰，不削平） // 2) 鼓包偏差(dev)再按剩余余量等比压缩 // 数学保证：区间内 inner <= upperLimit；blend 为凸组合，不超限 func compressSegment(yFixed, targetS []float32, s, e, n int, upperLimit float32, blend int) []float32 { // 1. 超限外扩：肩膀上所有 >上限 的点都包进区间 guard := 0 for s > 0 && guard < 500 && yFixed[s-1] > upperLimit { s-- guard++ } guard = 0 for e < n-1 && guard < 500 && yFixed[e+1] > upperLimit { e++ guard++ } w := smoothW(n, s, e, blend) // 2. 基准峰保形压缩 baseMin := float32(math.MaxFloat32) for i := s; i <= e; i++ { if targetS[i] < baseMin { baseMin = targetS[i] } } // 【关键修复】baseDev 必须是全局的，模仿 Python 的 target_s - base_min baseDev := make([]float32, n) maxBaseDev := float32(0) for i := 0; i < n; i++ { baseDev[i] = targetS[i] - baseMin // 仅统计区间内的最大偏差用于计算缩放比例 if i >= s && i <= e { if baseDev[i] > maxBaseDev { maxBaseDev = baseDev[i] } } } allowBase := upperLimit - baseMin if allowBase < 0 { allowBase = 0 } scaleB := float32(1.0) if maxBaseDev > 0 { scaleB = allowBase / maxBaseDev if scaleB > 1 { scaleB = 1 } } targetC := make([]float32, n) for i := 0; i < n; i++ { targetC[i] = baseMin + baseDev[i]*scaleB } // 3. 鼓包偏差保形压缩 // 【关键修复】dev 必须是全局的，模仿 Python 的 y_fixed - target_s dev := make([]float32, n) maxDev := float32(0) for i := 0; i < n; i++ { dev[i] = yFixed[i] - targetS[i] // 仅统计区间内的最大偏差 if i >= s && i <= e { if dev[i] > maxDev { maxDev = dev[i] } } } maxTargetC := float32(0) for i := s; i <= e; i++ { if targetC[i] > maxTargetC { maxTargetC = targetC[i] } } headroom := upperLimit - maxTargetC if headroom < 0 { headroom = 0 } scale := float32(1.0) if maxDev > 0 { scale = headroom / maxDev if scale > 1 { scale = 1 } } inner := make([]float32, n) for i := 0; i < n; i++ { inner[i] = targetC[i] + dev[i]*scale } // 4. 混合 result := make([]float32, n) for i := 0; i < n; i++ { result[i] = (1-w[i])*yFixed[i] + w[i]*inner[i] } return result }