1、修改首页；

2、修改rabbitmq生产消费；

mh-admin/src/main/resources/application-dev.yml

@@ -98,10 +98,10 @@ spring:
       # 主库数据源
       master:
         #添加allowMultiQueries=true 在批量更新时才不会出错
-        url: jdbc:postgresql://127.0.0.1:5432/eemcs_bl_dev
+        url: jdbc:postgresql://127.0.0.1:5432/bl_eems
 #        url: jdbc:postgresql://106.55.173.225:5505/eemcs
         username: postgres
-        password: mh@803
+        password: 123456
       # 从库数据源
       slave:
         # 从数据源开关/默认关闭

mh-admin/src/test/java/com/mh/MHApplicationTest.java

@@ -10,10 +10,7 @@ import com.mh.common.core.domain.entity.WeatherData;
 import com.mh.common.core.domain.vo.EnergyQueryVO;
 import com.mh.common.utils.DateUtils;
 import com.mh.common.utils.StringUtils;
-import com.mh.quartz.task.DealDataTask;
-import com.mh.quartz.task.DealOnOrOffData;
-import com.mh.quartz.task.GetWeatherDataTask;
-import com.mh.quartz.task.HotWaterTask;
+import com.mh.quartz.task.*;
 import com.mh.system.mapper.device.DataProcessMapper;
 import com.mh.system.service.ISysParamsService;
 import com.mh.system.service.ISysUserService;
@@ -73,6 +70,14 @@ public class MHApplicationTest {
     @Autowired
     private DealOnOrOffData dealOnOrOffData;
 
+    @Autowired
+    private GetOtherSysDataJob getOtherSysDataJob;
+
+    @Test
+    public void getBSDData() {
+        getOtherSysDataJob.getBSDData("","");
+    }
+
     @Test
     public void setDealOnOrOffData() throws Exception {
         dealOnOrOffData.dealDeviceLedger();

mh-common/src/main/java/com/mh/common/utils/http/HttpUtils.java

@@ -132,13 +132,14 @@ public class HttpUtils
         try
         {
             log.info("sendPost - {}", url);
+            log.info("sendPost param - {}", param);
             URL realUrl = new URL(url);
             URLConnection conn = realUrl.openConnection();
             conn.setRequestProperty("accept", "*/*");
             conn.setRequestProperty("connection", "Keep-Alive");
             conn.setRequestProperty("user-agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64)");
             conn.setRequestProperty("Accept-Charset", "utf-8");
-            conn.setRequestProperty("contentType", "utf-8");
+            conn.setRequestProperty("Content-Type", "application/json;charset=utf-8");
             conn.setDoOutput(true);
             conn.setDoInput(true);
             out = new PrintWriter(conn.getOutputStream());

mh-framework/src/main/java/com/mh/framework/dealdata/impl/DataProcessServiceImpl.java

@@ -200,10 +200,22 @@ public class DataProcessServiceImpl implements DataProcessService {
         Object dObject = data.getD();
 
         if (dObject instanceof List) {
-            // 如果已经是List类型，直接转换
-            @SuppressWarnings("unchecked")
-            List<AdvantechDatas> tempList = (List<AdvantechDatas>) dObject;
-            list = tempList;
+            List<?> tempList = (List<?>) dObject;
+            list = tempList.stream()
+                    .map(item -> {
+                        if (item instanceof AdvantechDatas) {
+                            return (AdvantechDatas) item;
+                        } else {
+                            try {
+                                return JSON.parseObject(JSON.toJSONString(item), AdvantechDatas.class);
+                            } catch (Exception e) {
+                                log.error("转换AdvantechDatas失败，item: {}", item, e);
+                                return null;
+                            }
+                        }
+                    })
+                    .filter(Objects::nonNull)
+                    .collect(Collectors.toList());
         } else {
             // 如果是其他类型（如String），则进行JSON解析
             String dString = dObject.toString();

mh-framework/src/main/java/com/mh/framework/rabbitmq/RabbitMqConfig.java

@@ -156,12 +156,12 @@ public class RabbitMqConfig {
     }
 
     // 延迟交换机（使用自定义类型x-delayed-message）
-    @Bean
-    public CustomExchange delayedExchange() {
-        Map<String, Object> args = new HashMap<>();
-        args.put("x-delayed-type", "direct");  // 底层转发类型
-        return new CustomExchange(DELAY_EXCHANGE_NAME, "x-delayed-message", true, false, args);
-    }
+//    @Bean
+//    public CustomExchange delayedExchange() {
+//        Map<String, Object> args = new HashMap<>();
+//        args.put("x-delayed-type", "direct");  // 底层转发类型
+//        return new CustomExchange(DELAY_EXCHANGE_NAME, "x-delayed-message", true, false, args);
+//    }
 
     // 报警队列
     @Bean
@@ -170,12 +170,12 @@ public class RabbitMqConfig {
     }
 
     // 绑定延迟交换机与队列
-    @Bean
-    public Binding binding(Queue alarmQueue, CustomExchange delayedExchange) {
-        return BindingBuilder.bind(alarmQueue)
-                .to(delayedExchange)
-                .with(ROUTING_KEY_ALARM)
-                .noargs();
-    }
+//    @Bean
+//    public Binding binding(Queue alarmQueue, CustomExchange delayedExchange) {
+//        return BindingBuilder.bind(alarmQueue)
+//                .to(delayedExchange)
+//                .with(ROUTING_KEY_ALARM)
+//                .noargs();
+//    }
 
 }

mh-quartz/src/main/java/com/mh/quartz/task/GetOtherSysDataJob.java

@@ -9,6 +9,7 @@ import com.mh.common.core.domain.entity.CollectionParamsManage;
 import com.mh.common.model.request.AdvantechDatas;
 import com.mh.common.model.request.AdvantechReceiver;
 import com.mh.common.utils.DateUtils;
+import com.mh.common.utils.StringUtils;
 import com.mh.common.utils.http.HttpUtils;
 import com.mh.framework.rabbitmq.producer.SendMsgByTopic;
 import com.mh.system.service.device.ICollectionParamsManageService;
@@ -88,6 +89,16 @@ public class GetOtherSysDataJob {
     public void getBSDData(String realUrl, String realValuesUrl) {
         log.info("获取BSD数据");
         try {
+            if (StringUtils.isEmpty(realUrl)) {
+                realUrl = "http://192.168.1.80:5002/data/get_real";
+            } else {
+                realUrl = "http://" + realUrl;
+            }
+            if (StringUtils.isEmpty(realValuesUrl)) {
+                realValuesUrl = "http://192.168.1.80:5002/data/get_real_values";
+            } else {
+                realValuesUrl = "http://" + realValuesUrl;
+            }
             // 获取实时读数\累计读数的所有点位
             HashMap<String, Object> params = new HashMap<>();
             params.put("systemType", "0");
@@ -122,20 +133,21 @@ public class GetOtherSysDataJob {
                 }
             }
 
-            List<AdvantechDatas> allAdvantechDatas = new ArrayList<>();
+            List<AdvantechDatas<BigDecimal>> allAdvantechDatas = new ArrayList<>();
+
+            CompletableFuture<List<AdvantechDatas<BigDecimal>>> cumulativeFuture = null;
+            CompletableFuture<List<AdvantechDatas<BigDecimal>>> powerFuture = null;
 
-            // 使用CompletableFuture并发请求累计读数和功率读数
-            CompletableFuture<List<AdvantechDatas>> cumulativeFuture = null;
-            CompletableFuture<List<AdvantechDatas>> powerFuture = null;
 
             // 并发请求累计读数 (grade=40)
             if (!cumulativeMtCodes.isEmpty()) {
                 final List<String> finalCumulativeMtCodes = new ArrayList<>(cumulativeMtCodes);
                 final HashMap<String, String> finalMtCodeToOtherNameMap = new HashMap<>(mtCodeToOtherNameMap);
+                String finalRealUrl = realUrl;
                 cumulativeFuture = CompletableFuture.supplyAsync(() -> {
                     log.info("[线程-{}] 请求累计读数，点位数量: {}", Thread.currentThread().getName(), finalCumulativeMtCodes.size());
                     // http://192.168.1.80:5002/data/get_real
-                    return fetchCumulativeData(finalCumulativeMtCodes, finalMtCodeToOtherNameMap, realUrl);
+                    return fetchCumulativeData(finalCumulativeMtCodes, finalMtCodeToOtherNameMap, finalRealUrl);
                 }, executor);
             }
             
@@ -143,50 +155,49 @@ public class GetOtherSysDataJob {
             if (!powerMtCodes.isEmpty()) {
                 final List<String> finalPowerMtCodes = new ArrayList<>(powerMtCodes);
                 final HashMap<String, String> finalMtCodeToOtherNameMap = new HashMap<>(mtCodeToOtherNameMap);
+                String finalRealValuesUrl = realValuesUrl;
                 powerFuture = CompletableFuture.supplyAsync(() -> {
                     log.info("[线程-{}] 请求功率读数，点位数量: {}", Thread.currentThread().getName(), finalPowerMtCodes.size());
                     // http://192.168.1.80:5002/data/get_real_values
-                    return fetchPowerData(finalPowerMtCodes, finalMtCodeToOtherNameMap, realValuesUrl);
+                    return fetchPowerData(finalPowerMtCodes, finalMtCodeToOtherNameMap, finalRealValuesUrl);
                 }, executor);
             }
             
             // 等待两个任务完成并合并结果
             try {
+                List<AdvantechDatas<BigDecimal>> cumulativeDatas = null;
+                List<AdvantechDatas<BigDecimal>> powerDatas = null;
+                
                 if (cumulativeFuture != null) {
-                    List<AdvantechDatas> cumulativeDatas = cumulativeFuture.get(30, TimeUnit.SECONDS);
-                    // 累计读数
-                    // cumulativeDatas.遍历计算得出机房总累计读数、主机总累计读数、冷冻泵总累计读数、冷却泵总累计读数、冷却塔总累计读数
-                    // 新建一个主机总电表的AdvantechDatas对象，tag为mtCodeToOtherNameMap，key值为"PowerTotal_CH"的value值，quality为0，value为cumulativeDatas中tag包含"主机*累计读数"的value和值
-                    // 新建一个冷冻泵总电表的AdvantechDatas对象，tag为mtCodeToOtherNameMap，key值为"PowerTotal_ChWPump"的value值，quality为0，value为cumulativeDatas中tag包含"冷冻泵*累计读数"的value和值
-                    // 新建一个冷却泵总电表的AdvantechDatas对象，tag为mtCodeToOtherNameMap，key值为"PowerTotal_CWPump"的value值，quality为0，value为cumulativeDatas中tag包含"冷却泵*累计读数"的value和值
-                    // 新建一个冷却塔总电表的AdvantechDatas对象，tag为mtCodeToOtherNameMap，key值为"PowerTotal_CT"的value值，quality为0，value为cumulativeDatas中tag包含"冷却塔*累计读数"的value和值
-                    // 新建一个机房总电表的AdvantechDatas对象，tag为mtCodeToOtherNameMap，key值为"PowerTotal"的value值，quality为0，value为cumulativeDatas中tag包含"累计读数"的value和值
-                    // 瞬时功率
-                    // cumulativeDatas.遍历计算得出机房总瞬时功率、主机总瞬时功率、冷冻泵总瞬时功率、冷却泵总瞬时功率、冷却塔总瞬时功率
-                    // 新建一个主机总电表的AdvantechDatas对象，tag为mtCodeToOtherNameMap，key值为"ChPower"的value值，quality为0，value为cumulativeDatas中tag包含"主机*瞬时功率"的value和值
-                    // 新建一个冷冻泵总电表的AdvantechDatas对象，tag为mtCodeToOtherNameMap，key值为"PriChWPPower"的value值，quality为0，value为cumulativeDatas中tag包含"冷冻泵*瞬时功率"的value和值
-                    // 新建一个冷却泵总电表的AdvantechDatas对象，tag为mtCodeToOtherNameMap，key值为"CWPPower"的value值，quality为0，value为cumulativeDatas中tag包含"冷却泵*瞬时功率"的value和值
-                    // 新建一个冷却塔总电表的AdvantechDatas对象，tag为mtCodeToOtherNameMap，key值为"CTPower"的value值，quality为0，value为cumulativeDatas中tag包含"冷却塔*瞬时功率"的value和值
-                    // 新建一个机房总电表的AdvantechDatas对象，tag为mtCodeToOtherNameMap，key值为"Power"的value值，quality为0，value为cumulativeDatas中tag包含"瞬时功率"的value和值
-                    // 再插入到cumulativeDatas中
+                    cumulativeDatas = cumulativeFuture.get(30, TimeUnit.SECONDS);
+                    log.info("累计读数获取完成，数据点数: {}", cumulativeDatas.size());
+                }
+                
+                if (powerFuture != null) {
+                    powerDatas = powerFuture.get(30, TimeUnit.SECONDS);
+                    log.info("功率读数获取完成，数据点数: {}", powerDatas.size());
+                }
                 
+                // 合并累计读数和功率读数后进行汇总计算
+                if (cumulativeDatas != null && !cumulativeDatas.isEmpty()) {
+                    // 将功率读数添加到累计读数列表中，以便一起进行汇总计算
+                    if (powerDatas != null && !powerDatas.isEmpty()) {
+                        cumulativeDatas.addAll(powerDatas);
+                    }
+                    
+                    // 计算汇总数据并添加到cumulativeDatas（包括累计读数和瞬时功率的汇总）
                     try {
-                        // 计算汇总数据并添加到cumulativeDatas
                         calculateAndAddSummaryData(cumulativeDatas, mtCodeToOtherNameMap);
                     } catch (Exception e) {
-                        log.error("累计读数汇总计算异常，但不影响后续流程", e);
+                        log.error("数据汇总计算异常，但不影响后续流程", e);
                     }
                     
                     allAdvantechDatas.addAll(cumulativeDatas);
-                    log.info("累计读数获取完成，数据点数: {}", cumulativeDatas.size());
-                }
-                
-                if (powerFuture != null) {
-                    List<AdvantechDatas> powerDatas = powerFuture.get(30, TimeUnit.SECONDS);
+                } else if (powerDatas != null && !powerDatas.isEmpty()) {
+                    // 如果只有功率读数，直接添加
                     allAdvantechDatas.addAll(powerDatas);
-                    // 实时功率
-                    log.info("功率读数获取完成，数据点数: {}", powerDatas.size());
                 }
+                
             } catch (Exception e) {
                 log.error("等待异步任务完成时异常", e);
             }
@@ -215,7 +226,8 @@ public class GetOtherSysDataJob {
      * @param cumulativeDatas 累计读数数据列表
      * @param mtCodeToOtherNameMap mtCode到otherName的映射关系
      */
-    private void calculateAndAddSummaryData(List<AdvantechDatas> cumulativeDatas, HashMap<String, String> mtCodeToOtherNameMap) {
+    private void calculateAndAddSummaryData(List<AdvantechDatas<BigDecimal>> cumulativeDatas, HashMap<String, String> mtCodeToOtherNameMap) {
+
         // 定义汇总类型枚举
         enum SummaryType {
             CH_CUMULATIVE("主机", "累计读数", "PowerTotal_CH", "主机总累计读数"),
@@ -286,7 +298,7 @@ public class GetOtherSysDataJob {
             }
         }
         
-        log.info("累计读数汇总完成，成功添加{}/{}个汇总数据点", successCount, SummaryType.values().length);
+        log.info("数据汇总完成，成功添加{}/{}个汇总数据点", successCount, SummaryType.values().length);
     }
     
     /**
@@ -296,8 +308,8 @@ public class GetOtherSysDataJob {
      * @param realUrl 请求URL
      * @return 解析后的数据列表
      */
-    private List<AdvantechDatas> fetchCumulativeData(List<String> mtCodes, HashMap<String, String> mtCodeToOtherNameMap, String realUrl) {
-        List<AdvantechDatas> dataList = new ArrayList<>();
+    private List<AdvantechDatas<BigDecimal>> fetchCumulativeData(List<String> mtCodes, HashMap<String, String> mtCodeToOtherNameMap, String realUrl) {
+        List<AdvantechDatas<BigDecimal>> dataList = new ArrayList<>();
         try {
             JSONObject cumulativeRequest = new JSONObject();
             cumulativeRequest.put("names", mtCodes);
@@ -321,12 +333,11 @@ public class GetOtherSysDataJob {
                                 String valueStr = valueArray.getString(0);
                                 try {
                                     BigDecimal value = new BigDecimal(valueStr);
-                                    AdvantechDatas datas = new AdvantechDatas();
-                                    // 使用otherName作为tag，如果不存在则使用mtCode
+                                    AdvantechDatas<BigDecimal> datas = new AdvantechDatas<>();
                                     String tag = mtCodeToOtherNameMap.getOrDefault(mtCode, mtCode);
                                     datas.setTag(tag);
                                     datas.setValue(value);
-                                    datas.setQuality(0);
+                                    datas.setQuality(BigDecimal.valueOf(0));
                                     dataList.add(datas);
                                 } catch (NumberFormatException e) {
                                     log.error("解析累计读数失败，mtCode: {}, value: {}", mtCode, valueStr, e);
@@ -342,6 +353,7 @@ public class GetOtherSysDataJob {
         return dataList;
     }
 
+
     /**
      * 获取功率读数数据
      *
@@ -350,8 +362,8 @@ public class GetOtherSysDataJob {
      * @param realValuesUrl 请求URL
      * @return 解析后的数据列表
      */
-    private List<AdvantechDatas> fetchPowerData(List<String> mtCodes, HashMap<String, String> mtCodeToOtherNameMap, String realValuesUrl) {
-        List<AdvantechDatas> dataList = new ArrayList<>();
+    private List<AdvantechDatas<BigDecimal>> fetchPowerData(List<String> mtCodes, HashMap<String, String> mtCodeToOtherNameMap, String realValuesUrl) {
+        List<AdvantechDatas<BigDecimal>> dataList = new ArrayList<>();
         try {
             JSONObject powerRequest = new JSONObject();
             powerRequest.put("expresss", mtCodes);
@@ -370,12 +382,11 @@ public class GetOtherSysDataJob {
                             String valueStr = dataObj.getString(mtCode);
                             try {
                                 BigDecimal value = new BigDecimal(valueStr);
-                                AdvantechDatas datas = new AdvantechDatas();
-                                // 使用otherName作为tag，如果不存在则使用mtCode
+                                AdvantechDatas<BigDecimal> datas = new AdvantechDatas<>();
                                 String tag = mtCodeToOtherNameMap.getOrDefault(mtCode, mtCode);
                                 datas.setTag(tag);
                                 datas.setValue(value);
-                                datas.setQuality(0);
+                                datas.setQuality(BigDecimal.valueOf(0));
                                 dataList.add(datas);
                             } catch (NumberFormatException e) {
                                 log.error("解析功率读数失败，mtCode: {}, value: {}", mtCode, valueStr, e);
@@ -389,4 +400,5 @@ public class GetOtherSysDataJob {
         }
         return dataList;
     }
+
 }

mh-system/src/main/java/com/mh/system/mapper/overview/HomeMapper.java

@@ -60,7 +60,7 @@ public interface HomeMapper {
      * @param otherNamePrefix other_name 前缀
      * @return mt_num 列表
      */
-    @Select("SELECT mt_code FROM collection_params_manage WHERE grade = #{grade} AND mt_num LIKE CONCAT(#{otherNamePrefix}, '%') AND is_use = 0")
+    @Select("SELECT mt_code FROM collection_params_manage WHERE grade = #{grade} AND mt_num = #{otherNamePrefix} AND is_use = 0")
     List<String> queryMtNumsByGradeAndOtherNamePrefix(@Param("grade") Integer grade,
                                                       @Param("otherNamePrefix") String otherNamePrefix);
 

mh-system/src/main/java/com/mh/system/service/energy/impl/EnergyAnalyzeServiceImpl.java

@@ -109,17 +109,6 @@ public class EnergyAnalyzeServiceImpl implements EnergyAnalyzeService {
                         HashMap::new
                 ));
         List<ColumnFilter> results = new ArrayList<>();
-        for (String value : Constants.DEVICE_TYPE) {
-            ColumnFilter columnFilter = new ColumnFilter();
-            columnFilter.setName(value);
-            if (result.containsKey(value)) {
-                columnFilter.setValue(String.valueOf(result.get(value).setScale(2, RoundingMode.HALF_UP)));
-                results.add(columnFilter);
-            } else {
-                columnFilter.setValue("0.00");
-                results.add(columnFilter);
-            }
-        }
 
         // 查询各个冷水机组的 0-9
         List<DeviceTypeEnergy> chiller = createDeviceTypeData(deviceTypeEnergyEntities, 0, 0);
@@ -162,6 +151,46 @@ public class EnergyAnalyzeServiceImpl implements EnergyAnalyzeService {
 
         List<ColumnFilter> coolTowerData = getResultData(coolTower);
 
+        // results需要重新赋值，chillerData：主机，chillerPumpData：冷冻泵，coolPumpData：冷却泵，coolTowerData：冷却塔
+        for (String value : Constants.DEVICE_TYPE) {
+            ColumnFilter columnFilter = new ColumnFilter();
+            columnFilter.setName(value);
+            // 计算累积和
+            if ("冷水机组(kwh)".equals(value)) {
+                BigDecimal sum = chillerData.stream()
+                        .map(ColumnFilter::getValue)
+                        .filter(v -> v != null && !v.isEmpty())
+                        .map(BigDecimal::new)
+                        .reduce(BigDecimal.ZERO, BigDecimal::add);
+                columnFilter.setValue(sum.setScale(2, RoundingMode.HALF_UP).toString());
+            } else if ("冷冻泵(kwh)".equals(value)) {
+                BigDecimal sum = chillerPumpData.stream()
+                        .map(ColumnFilter::getValue)
+                        .filter(v -> v != null && !v.isEmpty())
+                        .map(BigDecimal::new)
+                        .reduce(BigDecimal.ZERO, BigDecimal::add);
+                columnFilter.setValue(sum.setScale(2, RoundingMode.HALF_UP).toString());
+            } else if ("冷却泵(kwh)".equals(value)) {
+                BigDecimal sum = coolPumpData.stream()
+                        .map(ColumnFilter::getValue)
+                        .filter(v -> v != null && !v.isEmpty())
+                        .map(BigDecimal::new)
+                        .reduce(BigDecimal.ZERO, BigDecimal::add);
+                columnFilter.setValue(sum.setScale(2, RoundingMode.HALF_UP).toString());
+            } else if ("冷却塔(kwh)".equals(value)) {
+                BigDecimal sum = coolTowerData.stream()
+                        .map(ColumnFilter::getValue)
+                        .filter(v -> v != null && !v.isEmpty())
+                        .map(BigDecimal::new)
+                        .reduce(BigDecimal.ZERO, BigDecimal::add);
+                columnFilter.setValue(sum.setScale(2, RoundingMode.HALF_UP).toString());
+            } else {
+                columnFilter.setValue("0.00");
+            }
+            results.add(columnFilter);
+        }
+
+
         JSONObject resultJson = new JSONObject();
         resultJson.put("all", results);
         resultJson.put("chiller", chillerData);

mh-system/src/main/java/com/mh/system/service/overview/impl/HomeServiceImpl.java

@@ -95,7 +95,7 @@ public class HomeServiceImpl implements HomeService {
             List<String> eleMtNums = safeList(
                     homeMapper.queryMtNumsByGradeAndOtherNamePrefix(GRADE_CUMULATIVE, ON_POWER_CUMULATIVE_PREFIX));
             // 过滤掉数组totalMeter的值
-            eleMtNums.removeAll(totalMeter);
+//            eleMtNums.removeAll(totalMeter);
             List<HistoryEntity> eleHistory = queryOrEmpty(() ->
                     homeMapper.querySumHistoryByMtNums(tableName, eleMtNums));
             resultMap.put("eleChart", buildSingleChart("设备总用电量", eleHistory));
@@ -112,8 +112,10 @@ public class HomeServiceImpl implements HomeService {
             resultMap.put("tempChart", buildChart(tempHistoryList));
 
             // 3）设备瞬时功率：瞬时值（grade=140）所有非冷量表的电力设备汇总
+//            List<String> powerMtNums = safeList(
+//                    homeMapper.queryMtNumsByGradeExcludeMtNumPrefix(GRADE_INSTANT, MT_COLD_PREFIX));
             List<String> powerMtNums = safeList(
-                    homeMapper.queryMtNumsByGradeExcludeMtNumPrefix(GRADE_INSTANT, MT_COLD_PREFIX));
+                    homeMapper.queryMtNumsByGradeAndOtherNamePrefix(GRADE_INSTANT, ON_SYSTEM_POWER));
             List<HistoryEntity> powerHistory = queryOrEmpty(() ->
                     homeMapper.querySumHistoryByMtNums(tableName, powerMtNums));
             resultMap.put("eleRateChart", buildSingleChart("设备瞬时功率", powerHistory));
@@ -148,7 +150,7 @@ public class HomeServiceImpl implements HomeService {
             List<String> eleMtNums = safeList(
                     homeMapper.queryMtNumsByGradeAndOtherNamePrefix(GRADE_CUMULATIVE, ON_POWER_CUMULATIVE_PREFIX));
             // 过滤掉数组totalMeter的值
-            eleMtNums.removeAll(totalMeter);
+//            eleMtNums.removeAll(totalMeter);
 
             Map<String, BigDecimal> allCap = homeMapper.selectAllTypeCap(dayTable, coldMtNums);
             Map<String, BigDecimal> allEle = homeMapper.selectAllTypeEle(dayTable, eleMtNums);
@@ -250,8 +252,11 @@ public class HomeServiceImpl implements HomeService {
         String tableName = "data_min" + year;
 
         // 实时总用电量：瞬时值（grade=140）所有电力设备最新 calc_value 之和
-        List<String> powerMtNums = safeList(
-                homeMapper.queryMtNumsByGradeExcludeMtNumPrefix(GRADE_INSTANT, MT_COLD_PREFIX));
+//        List<String> powerMtNums = safeList(
+//                homeMapper.queryMtNumsByGradeExcludeMtNumPrefix(GRADE_INSTANT, MT_COLD_PREFIX));
+        // 直接取总累积
+        String powerNum = "Power";
+        List<String> powerMtNums = Collections.singletonList(powerNum);
         double eleUsed = homeMapper.selectLastEle(tableName, powerMtNums);
         BigDecimal power = BigDecimal.valueOf(eleUsed).setScale(2, RoundingMode.HALF_UP);