add：重构数据自检

controllers/TaskData.go

@@ -889,7 +889,7 @@ func (c *TaskDataController) TaskData_Add() {
 		c.ServeJSON()
 		return
 	}
-	// 同步设备到线上
+	// 同步设备到线上,添加终端，不在本地添加数据
 	if T_t == 0 && T_rh == 0 {
 		err = NatsServer.Add_DeviceClassList(T_task_id, T_sn, T_id)
 		if err != nil {
@@ -897,6 +897,10 @@ func (c *TaskDataController) TaskData_Add() {
 			c.ServeJSON()
 			return
 		}
+		taskData := Task.Read_TaskData_first(T_task_id, "", "")
+		T_t = float64(taskData.T_t)
+		T_rh = float64(taskData.T_rh)
+		T_time = taskData.T_time
 	}
 	is := Task.Add_TaskData(Task_r.T_task_id, T_sn, T_id, fmt.Sprintf("%.2f", T_t), fmt.Sprintf("%.2f", T_rh), T_time)
 	if !is {
@@ -1630,7 +1634,7 @@ func (c *TaskDataController) CopyFromPosition() {
 		c.ServeJSON()
 		return
 	}
-	CopyEndTime := copyTime.Add(endTime.Sub(startTime)).Format("2006-01-02 15:04:05")
+	CopyEndTime := copyTime.Add(endTime.Sub(startTime)).Format("2006-01-02 15:04")
 	// 时间间隔 分钟
 	T_saveT, _ := c.GetInt("T_saveT")
 
@@ -1660,7 +1664,7 @@ func (c *TaskDataController) CopyFromPosition() {
 		ct := copyTime
 		var valueStrings []string
 		for _, data := range List {
-			valueStrings = append(valueStrings, fmt.Sprintf("('%s','%s',%v,%v,'%s')", data.T_sn, data.T_id, data.T_t, data.T_rh, ct.Format("2006-01-02 15:04:05")))
+			valueStrings = append(valueStrings, fmt.Sprintf("('%s','%s',%v,%v,'%s')", data.T_sn, data.T_id, data.T_t, data.T_rh, ct.Format("2006-01-02 15:04")))
 			ct = ct.Add(time.Second * time.Duration(T_saveT))
 		}
 		err = Task.Batch_Adds_TaskData(T_task_id, valueStrings)
@@ -1729,8 +1733,8 @@ func (c *TaskDataController) RepairSensorData() {
 		for i := 0; i < len(list)-1; i++ {
 			current := list[i].T_time
 			next := list[i+1].T_time
-			c, _ := time.Parse("2006-01-02 15:04:05", current)
-			n, _ := time.Parse("2006-01-02 15:04:05", next)
+			c, _ := time.Parse("2006-01-02 15:04", current)
+			n, _ := time.Parse("2006-01-02 15:04", next)
 			interval := n.Unix() - c.Unix()
 			//logs.Debug("时间间隔：", interval, "保存时间：", saveTime)
 			//fmt.Println("当前：", current, "下一个：", next)
@@ -1745,7 +1749,7 @@ func (c *TaskDataController) RepairSensorData() {
 				}
 				num += count
 				for k := 0; k < count; k++ {
-					t := c.Add(time.Second * time.Duration(saveTime)).Format("2006-01-02 15:04:05") //时间临时变量
+					t := c.Add(time.Second * time.Duration(saveTime)).Format("2006-01-02 15:04") //时间临时变量
 					ttt += ttInterval / float32(count)
 					trht += trhInterval / float32(count)
 					Task.InsertTaskData(Task_r.T_task_id, Task.TaskData_{
@@ -1823,8 +1827,8 @@ func (c *TaskDataController) DataSensorDataTrend() {
 		first := list[0]
 		last := list[len(list)-1]
 
-		current, _ := time.Parse("2006-01-02 15:04:05", first.T_time)
-		next, _ := time.Parse("2006-01-02 15:04:05", last.T_time)
+		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)
@@ -1835,7 +1839,7 @@ func (c *TaskDataController) DataSensorDataTrend() {
 		for current.Unix() < next.Unix() {
 			tt += ttInterval
 			ttrh += trhInterval
-			ttime := current.Format("2006-01-02 15:04:05")
+			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))
 		}
@@ -2090,7 +2094,6 @@ func (c *TaskDataController) CopyFromPositionAverageSN() {
 		c.ServeJSON()
 		return
 	}
-	//CopyEndTime := copyTime.Add(endTime.Sub(startTime)).Format("2006-01-02 15:04:05")
 
 	T_switch_t, _ := c.GetBool("T_switch_t", true)
 	T_switch_h, _ := c.GetBool("T_switch_h", true)
@@ -2150,7 +2153,7 @@ func (c *TaskDataController) CopyFromPositionAverageSN() {
 			T_id:   CopyID,
 			T_t:    T_t,
 			T_rh:   T_rh,
-			T_time: ct.Format("2006-01-02 15:04:05"),
+			T_time: ct.Format("2006-01-02 15:04"),
 		})
 		ct = ct.Add(time.Second * time.Duration(T_saveT))
 	}
@@ -2201,7 +2204,7 @@ func (c *TaskDataController) CopyFromPositionSN() {
 		c.ServeJSON()
 		return
 	}
-	CopyEndTime := copyTime.Add(endTime.Sub(startTime)).Format("2006-01-02 15:04:05")
+	CopyEndTime := copyTime.Add(endTime.Sub(startTime)).Format("2006-01-02 15:04")
 	// 时间间隔 分钟
 	T_saveT, _ := c.GetInt("T_saveT")
 
@@ -2236,7 +2239,7 @@ func (c *TaskDataController) CopyFromPositionSN() {
 	ct := copyTime
 	var valueStrings []string
 	for _, data := range List {
-		valueStrings = append(valueStrings, fmt.Sprintf("('%s','%s',%v,%v,'%s')", CopySN, CopyID, data.T_t, data.T_rh, ct.Format("2006-01-02 15:04:05")))
+		valueStrings = append(valueStrings, fmt.Sprintf("('%s','%s',%v,%v,'%s')", CopySN, CopyID, data.T_t, data.T_rh, ct.Format("2006-01-02 15:04")))
 		ct = ct.Add(time.Second * time.Duration(T_saveT))
 	}
 	err = Task.Batch_Adds_TaskData(T_task_id, valueStrings)
@@ -2792,7 +2795,6 @@ func TaskDataJPG(StartTime, EndTime, T_task_id, snList string, TemperatureMin, T
 
 	p.X.Min, p.X.Max = xmin, xmax
 	p.Y.Tick.Marker = lib.CommaTicks{}
-	//p.X.Tick.Marker = plot.TimeTicks{Format: "2006-01-02 15:04:05"}
 	p.X.Tick.Marker = lib.TimeTicks{}
 	p.X.Tick.Label.Rotation = math.Pi / 5
 	p.X.Tick.Label.YAlign = draw.YCenter
@@ -2977,6 +2979,9 @@ func (c *TaskDataController) ListJson() {
 		"温度分布特性的测试与分析（空载）结束时间",
 	}
 
+	// 现场测试结束时间放在最后
+	mySlice = append(mySlice, "现场测试结束时间")
+
 	c.Data["json"] = mySlice
 	c.ServeJSON() // 使用 ServeJSON
 }
@@ -3153,7 +3158,6 @@ func (c *TaskDataController) A满载风机停止时间点() {
 	//start := CalculateHumps_list[0]["start"].(Task.TaskData)  // 驼峰开始
 	//peak := CalculateHumps_list[0]["peak"].(Task.TaskData) // 驼峰最高
 	end := CalculateHumps_list[0].End // 驼峰结束
-	// .Format("2006-01-02 15:04:05")
 	fmt.Println(end)
 	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: end.T_time})
 
@@ -3210,7 +3214,6 @@ func (c *TaskDataController) A空载风机停止时间点() {
 	//start := CalculateHumps_list[0]["start"].(Task.TaskData)  // 驼峰开始
 	//peak := CalculateHumps_list[0]["peak"].(Task.TaskData) // 驼峰最高
 	end := CalculateHumps_list[0].End // 驼峰结束
-	// .Format("2006-01-02 15:04:05")
 
 	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: end.T_time})
 
@@ -3266,7 +3269,6 @@ func (c *TaskDataController) A空载风机启动时间点() {
 	//start := CalculateHumps_list[0]["start"].(Task.TaskData)  // 驼峰开始
 	peak := CalculateHumps_list[0].Peak // 驼峰最高
 	//end := CalculateHumps_list[0]["end"].(Task.TaskData)    // 驼峰结束
-	// .Format("2006-01-02 15:04:05")
 
 	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: peak.T_time})
 
@@ -3322,7 +3324,6 @@ func (c *TaskDataController) A满载风机启动时间点() {
 	//start := CalculateHumps_list[0]["start"].(Task.TaskData)  // 驼峰开始
 	peak := CalculateHumps_list[0].Peak // 驼峰最高
 	//end := CalculateHumps_list[0]["end"].(Task.TaskData)    // 驼峰结束
-	// .Format("2006-01-02 15:04:05")
 
 	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: peak.T_time})
 
@@ -4403,7 +4404,7 @@ func (c *TaskDataController) A风机温度设定值() {
 		return
 	}
 	T := (lib.To_float32(温度控制范围最高值) + lib.To_float32(温度控制范围最小值)) / 2
-	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: lib.To2(T)})
+	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: lib.To_string(lib.RoundToDecimal(float64(T), 1))})
 	// Close the connection
 	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
 }
@@ -5010,7 +5011,7 @@ func (c *TaskDataController) A满载第一次关门温度恢复时间() {
 	for x := 0; x < 60; x++ {
 		第一次开门结束时间_b = 第一次开门结束时间_a.Add(time.Minute * 60)
 
-		maps_Time_Min_Max_GROUP := Task.Read_TaskData_T_Min_Max_Time_Min_Max_ListGROUP(Task_r.T_task_id, 柜内所有测点, 第一次开门结束时间_a.Format("2006-01-02 15:04:05"), 第一次开门结束时间_b.Format("2006-01-02 15:04:05"))
+		maps_Time_Min_Max_GROUP := Task.Read_TaskData_T_Min_Max_Time_Min_Max_ListGROUP(Task_r.T_task_id, 柜内所有测点, 第一次开门结束时间_a.Format("2006-01-02 15:04"), 第一次开门结束时间_b.Format("2006-01-02 15:04"))
 
 		//  判断拐点
 		if maps_Time_Min_Max_GROUP[0].T_max <= maps_Time_Min_Max_GROUP[1].T_max &&
@@ -5030,7 +5031,7 @@ func (c *TaskDataController) A满载第一次关门温度恢复时间() {
 			} else {
 				// 情况2：开门无超标的情况：
 				// 柜内所有测点中温度持续下降连续5分钟内，取第一条时间作为此时间点
-				list := Task.Read_TaskData_ById_AVG(Task_r.T_task_id, 柜内所有测点, maps_Time_Min_Max_GROUP[1].T_times, 第一次开门结束时间_a.Add(time.Minute*30).Format("2006-01-02 15:04:05"))
+				list := Task.Read_TaskData_ById_AVG(Task_r.T_task_id, 柜内所有测点, maps_Time_Min_Max_GROUP[1].T_times, 第一次开门结束时间_a.Add(time.Minute*30).Format("2006-01-02 15:04"))
 
 				for i := 0; i < len(list)-6; i++ {
 					if maps_Time_Min_Max_GROUP[i].T_max <= maps_Time_Min_Max_GROUP[i+1].T_max &&
@@ -5102,7 +5103,7 @@ func (c *TaskDataController) A空载第一次关门温度恢复时间() {
 	for x := 0; x < 60; x++ {
 		第一次开门结束时间_b = 第一次开门结束时间_a.Add(time.Minute * 20)
 
-		maps_Time_Min_Max_GROUP := Task.Read_TaskData_T_Min_Max_Time_Min_Max_ListGROUP(Task_r.T_task_id, 柜内所有测点, 第一次开门结束时间_a.Format("2006-01-02 15:04:05"), 第一次开门结束时间_b.Format("2006-01-02 15:04:05"))
+		maps_Time_Min_Max_GROUP := Task.Read_TaskData_T_Min_Max_Time_Min_Max_ListGROUP(Task_r.T_task_id, 柜内所有测点, 第一次开门结束时间_a.Format("2006-01-02 15:04"), 第一次开门结束时间_b.Format("2006-01-02 15:04"))
 
 		//  判断拐点
 		if maps_Time_Min_Max_GROUP[0].T_max <= maps_Time_Min_Max_GROUP[1].T_max &&
@@ -5122,7 +5123,7 @@ func (c *TaskDataController) A空载第一次关门温度恢复时间() {
 			} else {
 				// 情况2：开门无超标的情况：
 				// 柜内所有测点中温度持续下降连续5分钟内，取第一条时间作为此时间点
-				list := Task.Read_TaskData_ById_AVG(Task_r.T_task_id, 柜内所有测点, maps_Time_Min_Max_GROUP[1].T_times, 第一次开门结束时间_a.Add(time.Minute*30).Format("2006-01-02 15:04:05"))
+				list := Task.Read_TaskData_ById_AVG(Task_r.T_task_id, 柜内所有测点, maps_Time_Min_Max_GROUP[1].T_times, 第一次开门结束时间_a.Add(time.Minute*30).Format("2006-01-02 15:04"))
 
 				for i := 0; i < len(list)-6; i++ {
 					if maps_Time_Min_Max_GROUP[i].T_max <= maps_Time_Min_Max_GROUP[i+1].T_max &&
@@ -5196,7 +5197,7 @@ func (c *TaskDataController) A满载第二次关门温度恢复时间() {
 	第二次开门结束时间_a, _ := time.Parse("2006-01-02 15:04", 第二次开门结束时间)
 	第三次开门开始时间_a, _ := time.Parse("2006-01-02 15:04", 第三次开门开始时间)
 
-	maps_Time_Min_Max_GROUP := Task.Read_TaskData_T_Min_Max_Time_Min_Max_ListGROUP(Task_r.T_task_id, 柜内所有测点, 第二次开门结束时间_a.Format("2006-01-02 15:04:05"), 第三次开门开始时间_a.Format("2006-01-02 15:04:05"))
+	maps_Time_Min_Max_GROUP := Task.Read_TaskData_T_Min_Max_Time_Min_Max_ListGROUP(Task_r.T_task_id, 柜内所有测点, 第二次开门结束时间_a.Format("2006-01-02 15:04"), 第三次开门开始时间_a.Format("2006-01-02 15:04"))
 
 	if maps_Time_Min_Max_GROUP == nil {
 		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "没找到 柜内所有测点 最大最小值 数据 !"})
@@ -5221,7 +5222,7 @@ func (c *TaskDataController) A满载第二次关门温度恢复时间() {
 		} else {
 			// 情况2：开门无超标的情况：
 			// 柜内所有测点中温度持续下降连续5分钟内，取第一条时间作为此时间点
-			list := Task.Read_TaskData_ById_AVG(Task_r.T_task_id, 柜内所有测点, maps_Time_Min_Max_GROUP[1].T_times, 第二次开门结束时间_a.Add(time.Minute*30).Format("2006-01-02 15:04:05"))
+			list := Task.Read_TaskData_ById_AVG(Task_r.T_task_id, 柜内所有测点, maps_Time_Min_Max_GROUP[1].T_times, 第二次开门结束时间_a.Add(time.Minute*30).Format("2006-01-02 15:04"))
 
 			for i := 0; i < len(list)-6; i++ {
 				if maps_Time_Min_Max_GROUP[i].T_max <= maps_Time_Min_Max_GROUP[i+1].T_max &&
@@ -5291,7 +5292,7 @@ func (c *TaskDataController) A空载第二次关门温度恢复时间() {
 	第二次开门结束时间_a, _ := time.Parse("2006-01-02 15:04", 第二次开门结束时间)
 	第三次开门开始时间_a, _ := time.Parse("2006-01-02 15:04", 第三次开门开始时间)
 
-	maps_Time_Min_Max_GROUP := Task.Read_TaskData_T_Min_Max_Time_Min_Max_ListGROUP(Task_r.T_task_id, 柜内所有测点, 第二次开门结束时间_a.Format("2006-01-02 15:04:05"), 第三次开门开始时间_a.Format("2006-01-02 15:04:05"))
+	maps_Time_Min_Max_GROUP := Task.Read_TaskData_T_Min_Max_Time_Min_Max_ListGROUP(Task_r.T_task_id, 柜内所有测点, 第二次开门结束时间_a.Format("2006-01-02 15:04"), 第三次开门开始时间_a.Format("2006-01-02 15:04"))
 	if maps_Time_Min_Max_GROUP == nil {
 		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "没找到 柜内所有测点 最大最小值 数据 !"})
 		return
@@ -5314,7 +5315,7 @@ func (c *TaskDataController) A空载第二次关门温度恢复时间() {
 		} else {
 			// 情况2：开门无超标的情况：
 			// 柜内所有测点中温度持续下降连续5分钟内，取第一条时间作为此时间点
-			list := Task.Read_TaskData_ById_AVG(Task_r.T_task_id, 柜内所有测点, maps_Time_Min_Max_GROUP[1].T_times, 第二次开门结束时间_a.Add(time.Minute*30).Format("2006-01-02 15:04:05"))
+			list := Task.Read_TaskData_ById_AVG(Task_r.T_task_id, 柜内所有测点, maps_Time_Min_Max_GROUP[1].T_times, 第二次开门结束时间_a.Add(time.Minute*30).Format("2006-01-02 15:04"))
 
 			for i := 0; i < len(list)-6; i++ {
 				if maps_Time_Min_Max_GROUP[i].T_max <= maps_Time_Min_Max_GROUP[i+1].T_max &&
@@ -5385,7 +5386,7 @@ func (c *TaskDataController) A满载第三次关门温度恢复时间() {
 	第三次开门结束时间_a, _ := time.Parse("2006-01-02 15:04", 第三次开门结束时间)
 	现场测试结束时间_a, _ := time.Parse("2006-01-02 15:04", 现场测试结束时间)
 
-	maps_Time_Min_Max_GROUP := Task.Read_TaskData_T_Min_Max_Time_Min_Max_ListGROUP(Task_r.T_task_id, 柜内所有测点, 第三次开门结束时间_a.Format("2006-01-02 15:04:05"), 现场测试结束时间_a.Format("2006-01-02 15:04:05"))
+	maps_Time_Min_Max_GROUP := Task.Read_TaskData_T_Min_Max_Time_Min_Max_ListGROUP(Task_r.T_task_id, 柜内所有测点, 第三次开门结束时间_a.Format("2006-01-02 15:04"), 现场测试结束时间_a.Format("2006-01-02 15:04"))
 	if maps_Time_Min_Max_GROUP == nil {
 		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "没找到 柜内所有测点 最大最小值 数据 !"})
 		return
@@ -5408,7 +5409,7 @@ func (c *TaskDataController) A满载第三次关门温度恢复时间() {
 		} else {
 			// 情况2：开门无超标的情况：
 			// 柜内所有测点中温度持续下降连续5分钟内，取第一条时间作为此时间点
-			list := Task.Read_TaskData_ById_AVG(Task_r.T_task_id, 柜内所有测点, maps_Time_Min_Max_GROUP[1].T_times, 第三次开门结束时间_a.Add(time.Minute*30).Format("2006-01-02 15:04:05"))
+			list := Task.Read_TaskData_ById_AVG(Task_r.T_task_id, 柜内所有测点, maps_Time_Min_Max_GROUP[1].T_times, 第三次开门结束时间_a.Add(time.Minute*30).Format("2006-01-02 15:04"))
 
 			for i := 0; i < len(list)-6; i++ {
 				if maps_Time_Min_Max_GROUP[i].T_max <= maps_Time_Min_Max_GROUP[i+1].T_max &&
@@ -5478,7 +5479,7 @@ func (c *TaskDataController) A空载第三次关门温度恢复时间() {
 	第三次开门结束时间_a, _ := time.Parse("2006-01-02 15:04", 第三次开门结束时间)
 	现场测试结束时间_a, _ := time.Parse("2006-01-02 15:04", 现场测试结束时间)
 
-	maps_Time_Min_Max_GROUP := Task.Read_TaskData_T_Min_Max_Time_Min_Max_ListGROUP(Task_r.T_task_id, 柜内所有测点, 第三次开门结束时间_a.Format("2006-01-02 15:04:05"), 现场测试结束时间_a.Format("2006-01-02 15:04:05"))
+	maps_Time_Min_Max_GROUP := Task.Read_TaskData_T_Min_Max_Time_Min_Max_ListGROUP(Task_r.T_task_id, 柜内所有测点, 第三次开门结束时间_a.Format("2006-01-02 15:04"), 现场测试结束时间_a.Format("2006-01-02 15:04"))
 	if maps_Time_Min_Max_GROUP == nil {
 		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "没找到 柜内所有测点 最大最小值 数据 !"})
 		return
@@ -5501,7 +5502,7 @@ func (c *TaskDataController) A空载第三次关门温度恢复时间() {
 		} else {
 			// 情况2：开门无超标的情况：
 			// 柜内所有测点中温度持续下降连续5分钟内，取第一条时间作为此时间点
-			list := Task.Read_TaskData_ById_AVG(Task_r.T_task_id, 柜内所有测点, maps_Time_Min_Max_GROUP[1].T_times, 第三次开门结束时间_a.Add(time.Minute*30).Format("2006-01-02 15:04:05"))
+			list := Task.Read_TaskData_ById_AVG(Task_r.T_task_id, 柜内所有测点, maps_Time_Min_Max_GROUP[1].T_times, 第三次开门结束时间_a.Add(time.Minute*30).Format("2006-01-02 15:04"))
 
 			for i := 0; i < len(list)-6; i++ {
 				if maps_Time_Min_Max_GROUP[i].T_max <= maps_Time_Min_Max_GROUP[i+1].T_max &&
@@ -6308,8 +6309,8 @@ func (c *TaskDataController) A风机布点总测点() {
 	c.Ctx.ResponseWriter.Header().Set("Cache-Control", "no-cache")
 	c.Ctx.ResponseWriter.Header().Set("Connection", "keep-alive")
 
-	一号风机测点 := c.GetString("1号风机测点")     //  v26nplogbwt1
-	二号风机测点 := c.GetString("2号风机测点")     //  v26nplogbwt1
+	一号风机测点 := c.GetString("1号风机测点")   //  v26nplogbwt1
+	二号风机测点 := c.GetString("2号风机测点")   //  v26nplogbwt1
 	一号风机回风口 := c.GetString("1号风机回风口") //  v26nplogbwt1
 	二号风机回风口 := c.GetString("2号风机回风口") //  v26nplogbwt1
 
@@ -6337,7 +6338,7 @@ func (c *TaskDataController) A库内除风机出风口回风口外总测点() {
 	c.Ctx.ResponseWriter.Header().Set("Cache-Control", "no-cache")
 	c.Ctx.ResponseWriter.Header().Set("Connection", "keep-alive")
 
-	库内所有测点 := c.GetString("库内所有测点")     //  v26nplogbwt1
+	库内所有测点 := c.GetString("库内所有测点")   //  v26nplogbwt1
 	风机布点总测点 := c.GetString("风机布点总测点") //  v26nplogbwt1
 
 	parts1 := strings.Split(库内所有测点, "|")
@@ -6368,9 +6369,9 @@ func (c *TaskDataController) A库内除风机出风口回风口特殊位置布
 	c.Ctx.ResponseWriter.Header().Set("Cache-Control", "no-cache")
 	c.Ctx.ResponseWriter.Header().Set("Connection", "keep-alive")
 
-	库内所有测点 := c.GetString("库内所有测点")                                           //  v26nplogbwt1
-	风机布点总测点 := c.GetString("风机布点总测点")                                       //  v26nplogbwt1
-	作业出入口总测点 := c.GetString("作业出入口总测点")                                   //  v26nplogbwt1
+	库内所有测点 := c.GetString("库内所有测点")                       //  v26nplogbwt1
+	风机布点总测点 := c.GetString("风机布点总测点")                     //  v26nplogbwt1
+	作业出入口总测点 := c.GetString("作业出入口总测点")                   //  v26nplogbwt1
 	照明灯除湿机风幕机等特殊区域测点 := c.GetString("照明灯、除湿机、风幕机等特殊区域测点") //  v26nplogbwt1
 
 	parts1 := strings.Split(strings.Trim(库内所有测点, "|"), "|")
@@ -6409,7 +6410,7 @@ func (c *TaskDataController) A车内除风机出风口回风口外总测点() {
 	c.Ctx.ResponseWriter.Header().Set("Cache-Control", "no-cache")
 	c.Ctx.ResponseWriter.Header().Set("Connection", "keep-alive")
 
-	车内所有测点 := c.GetString("车内所有测点")     //  v26nplogbwt1
+	车内所有测点 := c.GetString("车内所有测点")   //  v26nplogbwt1
 	风机布点总测点 := c.GetString("风机布点总测点") //  v26nplogbwt1
 
 	parts1 := strings.Split(车内所有测点, "|")
@@ -6520,3 +6521,29 @@ func (c *TaskDataController) A预冷结束时间() {
 	// Close the connection
 	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
 }
+func (c *TaskDataController) A现场测试结束时间() {
+
+	T_task_id := c.GetString("T_task_id") //  v26nplogbwt1
+	println("T_task_id:", 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")
+
+	保空结 := c.GetString("保空结") //  v26nplogbwt1
+	if len(保空结) == 0 {
+		保满结 := c.GetString("保满结")
+		if len(保满结) == 0 {
+			lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 保空结|保满结 失败!"})
+			return
+		}
+		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 保满结})
+
+		// Close the connection
+		c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
+	}
+
+	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 保空结})
+
+	// Close the connection
+	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
+}

lib/lib.go

@@ -12,6 +12,7 @@ import (
 	"github.com/signintech/gopdf"
 	"io/ioutil"
 	"log"
+	"math"
 	"math/rand"
 	"os"
 	"os/exec"
@@ -541,3 +542,8 @@ func To2(number float32) string {
 	return formatted
 
 }
+
+func RoundToDecimal(num float64, decimal int) float64 {
+	shift := math.Pow(10, float64(decimal))
+	return math.Round(num*shift) / shift
+}

lib/libString.go

@@ -40,7 +40,16 @@ func IsDateStr(date string) bool {
 
 // 转化
 func TimeStrToTime(T_time string) (time.Time, bool) {
-	stamp, err := time.ParseInLocation("2006-01-02 15:04:05", T_time, time.Local) // +8
+	if len(T_time) == 19 {
+		stamp, err := time.ParseInLocation("2006-01-02 15:04:05", T_time, time.Local) // +8
+		if err != nil {
+			return time.Time{}, false
+		}
+
+		return stamp, true
+	}
+
+	stamp, err := time.ParseInLocation("2006-01-02 15:04", T_time, time.Local) // +8
 	if err != nil {
 		return time.Time{}, false
 	}

models/Device/DeviceClassList.go

@@ -334,6 +334,9 @@ func Read_DeviceClassList_List_id_T_remark(T_class_Id int, T_remark string) (r [
 
 	var conditions []string
 	for _, v := range T_remark_s {
+		if v == "" {
+			continue
+		}
 		conditions = append(conditions, fmt.Sprintf("t_remark LIKE '%%%s%%'", v))
 	}
 	if len(conditions) > 0 {
@@ -402,6 +405,22 @@ func DeduplicateById(devices []DeviceClassList) []DeviceClassList {
 	}
 	return result
 }
+func ExcludeDevicesById(devices []DeviceClassList, excludeDevices []DeviceClassList) []DeviceClassList {
+	filteredList := make([]DeviceClassList, 0)
+	for _, device := range devices {
+		exclude := false
+		for _, excludeDevice := range excludeDevices {
+			if device.T_id == excludeDevice.T_id {
+				exclude = true
+				break
+			}
+		}
+		if !exclude {
+			filteredList = append(filteredList, device)
+		}
+	}
+	return filteredList
+}
 
 func JoinDeviceClassListSnToString(devices []DeviceClassList) string {
 	var builder strings.Builder

models/Task/TaskData.go

@@ -180,6 +180,12 @@ type TaskData_Total struct {
 	Total int64
 }
 
+type TaskData_Average struct {
+	T_sn    string
+	T_id    string
+	Average float64
+}
+
 func Read_TaskData_ById_List(T_task_id string, SN string, T_id string, Time_start_ string, Time_end_ string, page int, page_z int) ([]TaskData_, int64) {
 	o := orm.NewOrm()
 	var maps []TaskData_
@@ -225,7 +231,7 @@ func Read_TaskData_ById_List(T_task_id string, SN string, T_id string, Time_star
 	}
 
 	//fmt.Println("maps_z；",maps_z[0][0])
-	sql = "SELECT ID,t_sn,t_id,t_t,t_rh,DATE_FORMAT(t_time,'%Y-%m-%d %H:%i:%s') AS t_times,t_time FROM z_task_data_" + T_task_id + sql_condition + " ORDER BY t_time DESC"
+	sql = "SELECT ID,t_sn,t_id,t_t,t_rh,DATE_FORMAT(t_time,'%Y-%m-%d %H:%i') AS t_times,t_time FROM z_task_data_" + T_task_id + sql_condition + " ORDER BY t_time DESC"
 	if page_z != 9999 {
 		sql = sql + " LIMIT " + strconv.Itoa(offset) + "," + strconv.Itoa(pagez)
 	}
@@ -304,7 +310,7 @@ func Read_TaskData_ById_List_AES(T_task_id string, SN string, T_id string, Time_
 	}
 
 	//fmt.Println("maps_z；",maps_z[0][0])
-	sql = "SELECT ID,t_sn,t_id,t_t,t_rh,DATE_FORMAT(t_time,'%Y-%m-%d %H:%i:%s') AS t_times,t_time FROM z_task_data_" + T_task_id + sql_condition + " ORDER BY t_time"
+	sql = "SELECT ID,t_sn,t_id,t_t,t_rh,DATE_FORMAT(t_time,'%Y-%m-%d %H:%i') AS t_times,t_time FROM z_task_data_" + T_task_id + sql_condition + " ORDER BY t_time"
 	if page_z != 9999 {
 		sql = sql + " LIMIT " + strconv.Itoa(offset) + "," + strconv.Itoa(pagez)
 	}
@@ -386,7 +392,7 @@ func Read_TaskData_ById_List_SQL(T_task_id string, SQL, SN string, T_id string,
 	}
 
 	//fmt.Println("maps_z；",maps_z[0][0])
-	sql = "SELECT ID,t_sn,t_id,t_t,t_rh,DATE_FORMAT(t_time,'%Y-%m-%d %H:%i:%s') AS t_times,t_time FROM z_task_data_" + T_task_id + sql_condition + " ORDER BY t_time"
+	sql = "SELECT ID,t_sn,t_id,t_t,t_rh,DATE_FORMAT(t_time,'%Y-%m-%d %H:%i') AS t_times,t_time FROM z_task_data_" + T_task_id + sql_condition + " ORDER BY t_time"
 	if page_z != 9999 {
 		sql = sql + " LIMIT " + strconv.Itoa(offset) + "," + strconv.Itoa(pagez)
 	}
@@ -460,7 +466,51 @@ func Read_TaskData_ById_AVG(T_task_id string, SN string, Time_start_ string, Tim
 		sql_condition = " WHERE " + strings.TrimLeft(sql_condition, " AND ")
 	}
 
-	sql := "SELECT DATE_FORMAT(t_time,'%Y-%m-%d %H:%i:%s') AS t_times, AVG(t_t) AS t_t FROM z_task_data_" + T_task_id + sql_condition + "  GROUP BY t_time  ORDER BY t_time"
+	sql := "SELECT DATE_FORMAT(t_time,'%Y-%m-%d %H:%i') AS t_times, AVG(t_t) AS t_t FROM z_task_data_" + T_task_id + sql_condition + "  GROUP BY t_time  ORDER BY t_time"
+
+	fmt.Println(sql)
+	o.Raw(sql).QueryRows(&maps)
+
+	return maps
+}
+func Read_TaskData_ById_AVG_DESC(T_task_id string, SN string, Time_start_ string, Time_end_ string) []TaskData_AVG {
+	o := orm.NewOrm()
+	var maps []TaskData_AVG
+
+	sql_condition := ""
+	if len(Time_start_) > 1 {
+		sql_condition += " AND t_time >= '" + Time_start_ + "'"
+	}
+
+	if len(Time_end_) > 1 {
+		sql_condition += " AND t_time <= '" + Time_end_ + "'"
+	}
+
+	if len(SN) > 0 {
+		if strings.Contains(SN, "|") {
+			// 将字符串按 | 分割
+			ids := strings.Split(strings.TrimSuffix(SN, "|"), "|")
+
+			// 构建 SQL 查询
+			query := " AND t_sn IN ("
+			// 动态添加每个 id
+			for i, id := range ids {
+				query += "'" + id + "'"
+				if i < len(ids)-1 {
+					query += ", " // 添加逗号分隔
+				}
+			}
+			query += ") " // 结束 SQL 查询
+			sql_condition += query
+		} else {
+			sql_condition += " AND t_sn = '" + SN + "'"
+		}
+	}
+	if len(sql_condition) > 0 {
+		sql_condition = " WHERE " + strings.TrimLeft(sql_condition, " AND ")
+	}
+
+	sql := "SELECT DATE_FORMAT(t_time,'%Y-%m-%d %H:%i') AS t_times, AVG(t_t) AS t_t FROM z_task_data_" + T_task_id + sql_condition + "  GROUP BY t_time  ORDER BY t_time DESC"
 
 	fmt.Println(sql)
 	o.Raw(sql).QueryRows(&maps)
@@ -884,6 +934,101 @@ func Read_TaskData_Total_GroupBySnId(T_task_id string, SN string, Time_start_ st
 
 	return maps
 }
+func Read_TaskData_Average_GroupBySnId(T_task_id string, SN string, Time_start_ string, Time_end_ string) []TaskData_Average {
+	o := orm.NewOrm()
+
+	var maps []TaskData_Average
+	sql_condition := ""
+	if len(Time_start_) > 1 {
+		sql_condition += " AND t_time >= '" + Time_start_ + "'"
+	}
+
+	if len(Time_end_) > 1 {
+		sql_condition += " AND t_time <= '" + Time_end_ + "'"
+	}
+
+	if len(SN) > 0 {
+		if strings.Contains(SN, "|") {
+			// 将字符串按 | 分割
+			ids := strings.Split(strings.TrimSuffix(SN, "|"), "|")
+
+			// 构建 SQL 查询
+			query := " AND t_sn IN ("
+			// 动态添加每个 id
+			for i, id := range ids {
+				query += "'" + id + "'"
+				if i < len(ids)-1 {
+					query += ", " // 添加逗号分隔
+				}
+			}
+			query += ") " // 结束 SQL 查询
+			sql_condition += query
+
+		} else {
+			sql_condition += " AND t_sn = '" + SN + "'"
+		}
+	}
+	if len(sql_condition) > 0 {
+		sql_condition = " WHERE " + strings.TrimLeft(sql_condition, " AND ")
+	}
+
+	sql := "SELECT t_sn,t_id, AVG(t_t) AS average FROM z_task_data_" + T_task_id + sql_condition + " GROUP BY T_sn,T_id ORDER BY average DESC"
+	fmt.Println(sql)
+	_, err := o.Raw(sql).QueryRows(&maps)
+	if err != nil {
+		logs.Error(lib.FuncName(), err)
+		return maps
+	}
+
+	return maps
+}
+func Read_TaskData_Average(T_task_id string, SN string, Time_start_ string, Time_end_ string) float64 {
+	o := orm.NewOrm()
+
+	sql_condition := ""
+	if len(Time_start_) > 1 {
+		sql_condition += " AND t_time >= '" + Time_start_ + "'"
+	}
+
+	if len(Time_end_) > 1 {
+		sql_condition += " AND t_time <= '" + Time_end_ + "'"
+	}
+
+	if len(SN) > 0 {
+		if strings.Contains(SN, "|") {
+			// 将字符串按 | 分割
+			ids := strings.Split(strings.TrimSuffix(SN, "|"), "|")
+
+			// 构建 SQL 查询
+			query := " AND t_sn IN ("
+			// 动态添加每个 id
+			for i, id := range ids {
+				query += "'" + id + "'"
+				if i < len(ids)-1 {
+					query += ", " // 添加逗号分隔
+				}
+			}
+			query += ") " // 结束 SQL 查询
+			sql_condition += query
+
+		} else {
+			sql_condition += " AND t_sn = '" + SN + "'"
+		}
+	}
+	if len(sql_condition) > 0 {
+		sql_condition = " WHERE " + strings.TrimLeft(sql_condition, " AND ")
+	}
+	var v float64
+	sql := "SELECT  AVG(t_t)  FROM z_task_data_" + T_task_id + sql_condition
+	fmt.Println(sql)
+	err := o.Raw(sql).QueryRow(&v)
+	if err != nil {
+		logs.Error(lib.FuncName(), err)
+		return v
+	}
+
+	return v
+}
 
 func Dump_TaskData(T_task_id, root, password, url_port, database, sql_file string) (string, error) {
 	// url_port 127.0.0.1:3306
@@ -968,7 +1113,7 @@ func Import_TaskData(T_task_id string, offset, pagez int) bool {
 	tb_name := "z_task_data_" + T_task_id
 
 	// 开从先上版查询数据
-	sql := "select `ID`, `t_sn`, `t_id`, `t_t`, `t_rh`, DATE_FORMAT(t_time,'%Y-%m-%d %H:%i:%s') AS t_times from " + tb_name + " LIMIT " + strconv.Itoa(offset) + "," + strconv.Itoa(pagez)
+	sql := "select `ID`, `t_sn`, `t_id`, `t_t`, `t_rh`, DATE_FORMAT(t_time,'%Y-%m-%d %H:%i') AS t_times from " + tb_name + " LIMIT " + strconv.Itoa(offset) + "," + strconv.Itoa(pagez)
 	logs.Println(sql)
 	_, err := serverOrm.Raw(sql).QueryRows(&maps)
 	if err != nil {
@@ -1061,8 +1206,11 @@ func InsertTaskData_TH(T_task_id string, T_switch_t, T_switch_h bool, d TaskData
 // DeleteTaskDataByTimeRange 删除时间范围内的数据
 func DeleteTaskDataByTimeRange(T_task_id, sn string, id string, startTime, endTime string) {
 	sqlStatement := fmt.Sprintf("delete from z_task_data_%s where t_id = '%s' and t_sn = '%s'", T_task_id, id, sn)
-	if len(startTime) > 0 && len(endTime) > 0 {
-		sqlStatement += " AND t_time BETWEEN '" + startTime + "' AND '" + endTime + "'"
+	if len(startTime) > 0 {
+		sqlStatement += " AND t_time >='" + startTime + "'"
+	}
+	if len(endTime) > 0 {
+		sqlStatement += " AND t_time <= '" + endTime + "'"
 	}
 	o := orm.NewOrm()
 	exec, err := o.Raw(sqlStatement).Exec()
@@ -1177,7 +1325,7 @@ func Read_TaskData_T_time_T_Min_Max(T_task_id string, SN string, T_id string, Ti
 		sql_condition = " WHERE " + strings.TrimLeft(sql_condition, " AND ")
 	}
 	//fmt.Println("maps_z；",maps_z[0][0])
-	sql := "SELECT DATE_FORMAT(MIN(t_time), '%Y-%m-%d %H:%i:%s') AS min_t, DATE_FORMAT(MAX(t_time), '%Y-%m-%d %H:%i:%s') AS max_t FROM z_task_data_" + T_task_id + sql_condition
+	sql := "SELECT DATE_FORMAT(MIN(t_time), '%Y-%m-%d %H:%i') AS min_t, DATE_FORMAT(MAX(t_time), '%Y-%m-%d %H:%i') AS max_t FROM z_task_data_" + T_task_id + sql_condition
 
 	fmt.Println(sql)
 	err := o.Raw(sql).QueryRow(&minT, &maxT)
@@ -1351,8 +1499,8 @@ func Read_TaskData_T_Min_Max_Time_Min_Max_ListGROUP(T_task_id string, SN string,
 	o := orm.NewOrm()
 	var maps_Time_Min_Max_GROUP []TaskData_Time_Min_Max_GROUP
 
-	时间_a, _ := time.Parse("2006-01-02 15:04:05", Time_start_)
-	时间_b, _ := time.Parse("2006-01-02 15:04:05", Time_end_)
+	时间_a, _ := time.Parse("2006-01-02 15:04", Time_start_)
+	时间_b, _ := time.Parse("2006-01-02 15:04", Time_end_)
 
 	for 时间_a.Unix() <= 时间_b.Unix() {
 
@@ -1360,11 +1508,11 @@ func Read_TaskData_T_Min_Max_Time_Min_Max_ListGROUP(T_task_id string, SN string,
 		maps_Time_Min_Max_GROUP_ := TaskData_Time_Min_Max_GROUP{
 			T_max:   -100,
 			T_min:   100,
-			T_times: 时间_a.Format("2006-01-02 15:04:05"),
+			T_times: 时间_a.Format("2006-01-02 15:04"),
 		}
 		sql_condition := ""
-		Time_start_ = 时间_a.Format("2006-01-02 15:04:05")
-		Time_end_ = 时间_b.Format("2006-01-02 15:04:05")
+		Time_start_ = 时间_a.Format("2006-01-02 15:04")
+		Time_end_ = 时间_b.Format("2006-01-02 15:04")
 		if len(Time_start_) > 1 {
 			sql_condition += " AND t_time >= '" + Time_start_ + "'"
 		}
@@ -1398,7 +1546,7 @@ func Read_TaskData_T_Min_Max_Time_Min_Max_ListGROUP(T_task_id string, SN string,
 		}
 
 		//fmt.Println("maps_z；",maps_z[0][0])
-		sql := "SELECT ID,t_sn,t_id,t_t,t_rh,DATE_FORMAT(t_time,'%Y-%m-%d %H:%i:%s') AS t_times,t_time FROM z_task_data_" + T_task_id + sql_condition + " ORDER BY t_time DESC"
+		sql := "SELECT ID,t_sn,t_id,t_t,t_rh,DATE_FORMAT(t_time,'%Y-%m-%d %H:%i') AS t_times,t_time FROM z_task_data_" + T_task_id + sql_condition + " ORDER BY t_time DESC"
 
 		fmt.Println(sql)
 		_, err := o.Raw(sql).QueryRows(&maps)
@@ -1546,6 +1694,26 @@ func Read_TaskData_min(T_task_id, T_sn, T_id, startTime, endTime string) float64
 	return v
 }
 
+// 获取第一条数据
+func Read_TaskData_first(T_task_id, startTime, endTime string) TaskData_ {
+	o := orm.NewOrm()
+
+	sql := "select ID,t_sn,t_id,t_t,t_rh,DATE_FORMAT(t_time,'%Y-%m-%d %H:%i') AS t_times,t_time  FROM z_task_data_" + T_task_id
+	if len(startTime) > 0 && len(endTime) > 0 {
+		sql += " where t_time BETWEEN '" + startTime + "' AND '" + endTime + "'"
+	}
+	sql = sql + " LIMIT 0,1"
+	fmt.Println(sql)
+	var maps TaskData_
+	err := o.Raw(sql).QueryRow(&maps)
+	if err != nil {
+		logs.Error(lib.FuncName(), err)
+		return maps
+	}
+
+	return maps
+}
+
 // 重置 SN数据
 
 func Import_TaskData_Back(Sn string, T_id string, T_task_id string, Time_start string, Time_end string) error {
@@ -1695,11 +1863,11 @@ func CalculateHumps(data []TaskData_AVG) []CalculateHumps_R {
 
 	if len(humps) == 0 {
 		i = 0
-		for i < n-3 {
+		for i < n-4 {
 			// 寻找开始的最低点
 			for !(data[i].T_t <= data[i+1].T_t && data[i+1].T_t <= data[i+2].T_t) {
 				i++
-				if i > n-3 {
+				if i > n-4 {
 					break
 				}
 			}
@@ -1708,7 +1876,7 @@ func CalculateHumps(data []TaskData_AVG) []CalculateHumps_R {
 			// 寻找最高点
 			for !(data[i].T_t >= data[i+1].T_t && data[i+1].T_t > data[i+2].T_t) {
 				i++
-				if i > n-3 {
+				if i > n-4 {
 					break
 				}
 			}
@@ -1721,7 +1889,7 @@ func CalculateHumps(data []TaskData_AVG) []CalculateHumps_R {
 			// 寻找结束的最低点
 			for !(data[i].T_t <= data[i+1].T_t && data[i+1].T_t < data[i+2].T_t) {
 				i++
-				if i > n-3 {
+				if i > n-4 {
 					break
 				}
 			}
@@ -1744,6 +1912,63 @@ func CalculateHumps(data []TaskData_AVG) []CalculateHumps_R {
 
 	return humps
 }
+func CalculateHumpsByThreeDots(data []TaskData_AVG) []CalculateHumps_R {
+	var humps []CalculateHumps_R
+	n := len(data)
+	if n < 3 {
+		return humps
+	}
+
+	i := 0
+
+	for i < n-4 {
+		// 寻找开始的最低点
+		for !(data[i].T_t <= data[i+1].T_t && data[i+1].T_t <= data[i+2].T_t) {
+			i++
+			if i > n-4 {
+				break
+			}
+		}
+		start := i
+
+		// 寻找最高点
+		for !(data[i].T_t >= data[i+1].T_t && data[i+1].T_t > data[i+2].T_t) {
+			i++
+			if i > n-4 {
+				break
+			}
+		}
+		peak := i
+		Abs_peak := math.Abs(float64(data[start].T_t - data[peak].T_t))
+		if Abs_peak < 0.2 {
+			continue
+		}
+
+		// 寻找结束的最低点
+		for !(data[i].T_t <= data[i+1].T_t && data[i+1].T_t < data[i+2].T_t) {
+			i++
+			if i > n-4 {
+				break
+			}
+		}
+		end := i
+		Abs_end := math.Abs(float64(data[end].T_t - data[peak].T_t))
+		if Abs_end < 0.3 {
+			continue
+		}
+		// 如果找到了一个完整的驼峰
+		if start < peak && peak < end {
+			CalculateHumps_ := CalculateHumps_R{
+				Start: data[start],
+				Peak:  data[peak],
+				End:   data[end],
+			}
+			humps = append(humps, CalculateHumps_)
+		}
+	}
+
+	return humps
+}
 
 // 根据温度获取列表
 func Read_TaskData_ByT_t_List_AES(T_task_id string, SN string, T_t float32, Time_start_ string, Time_end_ string) ([]TaskData_, int64) {
@@ -1799,7 +2024,7 @@ func Read_TaskData_ByT_t_List_AES(T_task_id string, SN string, T_t float32, Time
 	}
 
 	//fmt.Println("maps_z；",maps_z[0][0])
-	sql = "SELECT ID,t_sn,t_id,t_t,t_rh,DATE_FORMAT(t_time,'%Y-%m-%d %H:%i:%s') AS t_times,t_time FROM z_task_data_" + T_task_id + sql_condition + " ORDER BY t_time"
+	sql = "SELECT ID,t_sn,t_id,t_t,t_rh,DATE_FORMAT(t_time,'%Y-%m-%d %H:%i') AS t_times,t_time FROM z_task_data_" + T_task_id + sql_condition + " ORDER BY t_time"
 
 	fmt.Println(sql)
 	_, err = o.Raw(sql).QueryRows(&maps)

routers/TaskData.go

@@ -62,6 +62,7 @@ func init() {
 	beego.Router("/TaskData/SSE_Interval_data_correction", &controllers.TaskDataHandleController{}, "*:SSE_Interval_data_correction")                                               // 区间数据校正  （布点区域数据自检）
 	beego.Router("/TaskData/SSE_Comparison_between_binding_points_and_terminals", &controllers.TaskDataHandleController{}, "*:SSE_Comparison_between_binding_points_and_terminals") // 绑定点与终端比对  （绑定点数据自检）
 	beego.Router("/TaskData/SSE_Compare_binding_points_with_cold_and_hot_spots", &controllers.TaskDataHandleController{}, "*:SSE_Compare_binding_points_with_cold_and_hot_spots")   // 绑定点与冷热点比对  （冷热点数据自检）
+	beego.Router("/TaskData/SSE_Compare_binding_points_with_Average", &controllers.TaskDataHandleController{}, "*:SSE_Compare_binding_points_with_Average")                         // 绑定点与冷热点比对  （冷热点数据自检）
 
 	// 自动处理
 	beego.Router("/TaskDataContent/ListJson", &controllers.TaskDataController{}, "*:ListJson") // 根据id删除任务数据
@@ -168,5 +169,6 @@ func init() {
 	beego.Router("/TaskDataContent/SSE_车内除风机出风口回风口外总测点", &controllers.TaskDataController{}, "*:A车内除风机出风口回风口外总测点")
 	beego.Router("/TaskDataContent/SSE_预冷开始时间", &controllers.TaskDataController{}, "*:A预冷开始时间")
 	beego.Router("/TaskDataContent/SSE_预冷结束时间", &controllers.TaskDataController{}, "*:A预冷结束时间")
+	beego.Router("/TaskDataContent/SSE_现场测试结束时间", &controllers.TaskDataController{}, "*:A现场测试结束时间")
 
 }

tests/default_test.go

@@ -1,17 +1,176 @@
 package main
 
 import (
-	"ColdVerify_local/lib"
 	"fmt"
+	"math"
 	"testing"
 )
 
 // 测试函数
 func TestBeego(t *testing.T) {
-	制冷机组温控设定最低值_, _ := lib.StringToFloat32("-25")
-	制冷机组温控设定最高值_, _ := lib.StringToFloat32("-25")
+	//制冷机组温控设定最低值_, _ := lib.StringToFloat32("-25")
+	//制冷机组温控设定最高值_, _ := lib.StringToFloat32("-25")
+	//
+	//T := (lib.To_float32(制冷机组温控设定最低值_) + lib.To_float32(制冷机组温控设定最高值_)) / 2
+	//fmt.Printf("转换后的 float32 值: %s\n", lib.To2(T))
+	// 测试用例1
+	//A1, B1 := 3.5, 6.5
+	//a1s, b1s := findValidValues(A1, B1)
+	//fmt.Printf("当A=%.1f, B=%.1f时:\n", A1, B1)
+	//for i := range a1s {
+	//	fmt.Printf("A1=%.1f, B1=%.1f\n", a1s[i], b1s[i])
+	//}
+	//
+	//// 测试用例2
+	//A2, B2 := 4.0, 6.0
+	//a1s, b1s = findValidValues(A2, B2)
+	//fmt.Printf("\n当A=%.1f, B=%.1f时:\n", A2, B2)
+	//for i := range a1s {
+	//	fmt.Printf("A1=%.1f, B1=%.1f\n", a1s[i], b1s[i])
+	//}
+
+	//A1, B1 := 3.5, 6.5
+	//C1, D1 := 6.5, 3.5
+	//a1s1, b1s1 := findOptimalAdjustment(A1, B1, C1, D1)
+	//fmt.Printf("当A=%.1f, B=%.1f时:\n", A1, B1)
+	//fmt.Printf("最优解 A1=%.1f, B1=%.1f\n", a1s1, b1s1)
+	//
+	//// 测试用例2
+	//A2, B2 := 4.0, 6.0
+	//C2, D2 := 3.5, 6.5
+	//a1s2, b1s2 := findOptimalAdjustment(A2, B2, C2, D2)
+	//fmt.Printf("\n当A=%.1f, B=%.1f时:\n", A2, B2)
+	//fmt.Printf("最优解 A1=%.1f, B1=%.1f\n", a1s2, b1s2)
+
+	a, b, _ := findBindingPointsOptimalAdjustment(5.0, 5.0, 4.9, 6.5, 0.5)
+	fmt.Printf("最优解 A1=%.1f, B1=%.1f\n", a, b)
+}
+func TestAverageOptimalAdjustment(t *testing.T) {
+	// 输入参数
+	A1 := 4.0
+	B1 := 5.0
+	C := 6.0
+
+	// 计算有效区间
+	minA := A1 - 0.5
+	maxA := A1 + 0.5
+	minB := B1 - 0.5
+	maxB := B1 + 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 // 已在区间内无需调整
+	}
 
-	T := (lib.To_float32(制冷机组温控设定最低值_) + lib.To_float32(制冷机组温控设定最高值_)) / 2
 	// 输出结果
-	fmt.Printf("转换后的 float32 值: %s\n", lib.To2(T))
+	fmt.Printf("调整前C值: %.1f\n", C)
+	fmt.Printf("有效区间: [%.1f, %.1f]\n", lowerBound, upperBound)
+	fmt.Printf("最优调整值: %.1f\n", optimalC)
+	fmt.Printf("调整幅度: %.1f\n", math.Abs(C-optimalC))
+
+}
+
+func findOptimalAdjustment(A, B, C, D float64) (float64, float64) {
+
+	type DataPair struct {
+		A1 float64
+		B1 float64
+	}
+	var dataPairs []DataPair
+
+	var A1, B1 float64 = -100, -100
+
+	// 生成A1和B1的可能值
+	for a1 := A - 1; a1 <= A+1; a1 += 0.5 {
+		for b1 := B - 1; b1 <= B+1; b1 += 0.5 {
+			// 检查是否存在满足条件的C值
+			minC := math.Max(a1-0.5, b1-0.5)
+			maxC := math.Min(a1+0.5, b1+0.5)
+
+			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
+	}
+
+	return A1, B1
+}
+
+func findBindingPointsOptimalAdjustment(A, B, C, D, T_deviation float64) (float64, float64, bool) {
+
+	type DataPair struct {
+		A1 float64
+		B1 float64
+	}
+	T_deviation_half := T_deviation / 2
+	var dataPairs []DataPair
+
+	var A1, B1 float64 = -100, -100
+
+	// 生成A1和B1的可能值
+	for a1 := A - T_deviation; a1 <= A+T_deviation; a1 += 0.1 {
+		for b1 := B - T_deviation; b1 <= B+T_deviation; b1 += 0.1 {
+			// 检查是否存在满足条件的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
 }