日理论电量、日损失电量、日五损电量、日平均风速

common/data/src/main/java/com/gyee/gaia/common/data/point/PointData.java

@@ -16,11 +16,25 @@ public class PointData {
      * boolean 数据
      */
     private boolean booleanValue;
+
+    private long longValue;
     /**
      * 状态
      */
     private int status;
 
+    public boolean isBooleanValue() {
+        return booleanValue;
+    }
+
+    public long getLongValue() {
+        return longValue;
+    }
+
+    public void setLongValue(long longValue) {
+        this.longValue = longValue;
+    }
+
     public long getTs() {
         return ts;
     }
@@ -40,6 +54,8 @@ public class PointData {
     public double getValue() {
         if (booleanValue) {
             return 1;
+        }else if(longValue!=0){
+            doubleValue = longValue;
         }
         return doubleValue;
     }

common/data/src/main/java/com/gyee/gaia/common/data/taos/RealtimeAverageTarget.java

@@ -22,17 +22,17 @@ public class RealtimeAverageTarget implements Serializable {
 
     private Timestamp time;
 
-    private Double windSpeed;
+    private Float windSpeed;
 
-    private Double power;
+    private Float power;
 
-    private Double generatorSpeed;
+    private Float generatorSpeed;
 
-    private Double impellerSpeed;
+    private Float impellerSpeed;
 
-    private Double windDirection;
+    private Float windDirection;
 
-    private Double theoryGeneration;
+    private Float theoryGeneration;
 
     private String stationId;
     private String equipmentId;
@@ -63,51 +63,51 @@ public class RealtimeAverageTarget implements Serializable {
         this.equipmentId = equipmentId;
     }
 
-    public Double getWindSpeed() {
+    public Float getWindSpeed() {
         return windSpeed;
     }
 
-    public void setWindSpeed(Double windSpeed) {
+    public void setWindSpeed(Float windSpeed) {
         this.windSpeed = windSpeed;
     }
 
-    public Double getPower() {
+    public Float getPower() {
         return power;
     }
 
-    public void setPower(Double power) {
+    public void setPower(Float power) {
         this.power = power;
     }
 
-    public Double getGeneratorSpeed() {
+    public Float getGeneratorSpeed() {
         return generatorSpeed;
     }
 
-    public void setGeneratorSpeed(Double generatorSpeed) {
+    public void setGeneratorSpeed(Float generatorSpeed) {
         this.generatorSpeed = generatorSpeed;
     }
 
-    public Double getImpellerSpeed() {
+    public Float getImpellerSpeed() {
         return impellerSpeed;
     }
 
-    public void setImpellerSpeed(Double impellerSpeed) {
+    public void setImpellerSpeed(Float impellerSpeed) {
         this.impellerSpeed = impellerSpeed;
     }
 
-    public Double getWindDirection() {
+    public Float getWindDirection() {
         return windDirection;
     }
 
-    public void setWindDirection(Double windDirection) {
+    public void setWindDirection(Float windDirection) {
         this.windDirection = windDirection;
     }
 
-    public Double getTheoryGeneration() {
+    public Float getTheoryGeneration() {
         return theoryGeneration;
     }
 
-    public void setTheoryGeneration(Double theoryGeneration) {
+    public void setTheoryGeneration(Float theoryGeneration) {
         this.theoryGeneration = theoryGeneration;
     }
 

electricity/wind/build.gradle

@@ -33,7 +33,7 @@ dependencies {
     implementation("org.postgresql:postgresql:$postgresqlDriverVersion")
     implementation "com.baomidou:mybatis-plus-boot-starter:$mybatisPlusVersion"
     implementation("com.alibaba:druid:$alibabaDruidVersion")
-    implementation("com.alibaba:fastjson:$fastjsonVersion")
+    //implementation("com.alibaba:fastjson:$fastjsonVersion")
 
     implementation("$bootGroup:spring-boot-starter-test")
     implementation("com.xuxueli:xxl-job-core:$xxlJobVersion")
@@ -41,6 +41,8 @@ dependencies {
     implementation("com.alibaba.cloud:spring-cloud-starter-alibaba-nacos-discovery")
     implementation("com.alibaba.cloud:spring-cloud-starter-alibaba-nacos-config")
 
+    implementation("com.taosdata.jdbc:taos-jdbcdriver:$taosVersion2")
+
     implementation("$cloudGroup:spring-cloud-starter-openfeign")
     implementation("cn.hutool:hutool-all:5.8.18")
     implementation("com.baomidou:dynamic-datasource-spring-boot-starter:$mybatisPlusVersion")

electricity/wind/src/main/java/com/gyee/gaia/electricity/wind/entity/EquipPowerGenDay.java

@@ -144,6 +144,16 @@ public class EquipPowerGenDay implements Serializable {
      */
     private Integer limitTime;
 
+    private BigDecimal meanWindSpeed;
+
+    public BigDecimal getMeanWindSpeed() {
+        return meanWindSpeed;
+    }
+
+    public void setMeanWindSpeed(BigDecimal meanWindSpeed) {
+        this.meanWindSpeed = meanWindSpeed;
+    }
+
     public Integer getId() {
         return id;
     }

electricity/wind/src/main/java/com/gyee/gaia/electricity/wind/entity/StateCause.java

@@ -0,0 +1,173 @@
+package com.gyee.gaia.electricity.wind.entity;
+
+import com.baomidou.mybatisplus.annotation.TableName;
+
+import java.io.Serializable;
+import java.util.Date;
+
+/**
+ * <p>
+ *
+ * </p>
+ *
+ * @author gfhd
+ * @since 2023-05-04
+ */
+@TableName("state_cause")
+public class StateCause implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    private String tbname;
+
+    /**
+     * 开始时间
+     */
+    private Date startTime;
+
+    /**
+     * 结束时间
+     */
+    private Date endTime;
+
+    /**
+     * 事件-运行、限电、故障、受累、计划检修、待机
+     */
+    private String event;
+
+    /**
+     * 事前状态
+     */
+    private String advanceState;
+
+    /**
+     * 事后状态
+     */
+    private String afterState;
+
+    /**
+     * 用户标记
+     */
+    private String userFlag;
+
+    private Long time;
+
+    /**
+     * 场站
+     */
+    private String stationId;
+
+    /**
+     * 设备
+     */
+    private String equipmentId;
+
+    public StateCause() {
+    }
+
+    public StateCause(String tbname, String event, Date startTime, Date endTime, String advanceState, String afterState, Long time) {
+        this.tbname = tbname;
+        this.event = event;
+        this.startTime = startTime;
+        this.endTime = endTime;
+        this.advanceState = advanceState;
+        this.afterState = afterState;
+        this.time = time / 1000;
+        this.userFlag = "";
+    }
+
+    public String getTbname() {
+        return tbname;
+    }
+
+    public void setTbname(String tbname) {
+        this.tbname = tbname;
+    }
+
+    public String getStationId() {
+        return stationId;
+    }
+
+    public void setStationId(String stationId) {
+        this.stationId = stationId;
+    }
+
+    public String getEquipmentId() {
+        return equipmentId;
+    }
+
+    public void setEquipmentId(String equipmentId) {
+        this.equipmentId = equipmentId;
+    }
+
+    public String getEvent() {
+        return event;
+    }
+
+    public void setEvent(String event) {
+        this.event = event;
+    }
+
+    public Date getStartTime() {
+        return startTime;
+    }
+
+    public void setStartTime(Date startTime) {
+        this.startTime = startTime;
+    }
+
+    public Date getEndTime() {
+        return endTime;
+    }
+
+    public void setEndTime(Date endTime) {
+        this.endTime = endTime;
+    }
+
+    public String getAdvanceState() {
+        return advanceState;
+    }
+
+    public void setAdvanceState(String advanceState) {
+        this.advanceState = advanceState;
+    }
+
+    public String getAfterState() {
+        return afterState;
+    }
+
+    public void setAfterState(String afterState) {
+        this.afterState = afterState;
+    }
+
+    public String getUserFlag() {
+        return userFlag;
+    }
+
+    public void setUserFlag(String userFlag) {
+        this.userFlag = userFlag;
+    }
+
+    public Long getTime() {
+        return time;
+    }
+
+    public void setTime(Long time) {
+        this.time = time;
+    }
+
+    @Override
+    public String toString() {
+        return "StateCause{" +
+                "tbname = " + tbname +
+                ", stationId = " + stationId +
+                ", equipmentId = " + equipmentId +
+                ", event = " + event +
+                ", startTime = " + startTime +
+                ", endTime = " + endTime +
+                ", advanceState = " + advanceState +
+                ", afterState = " + afterState +
+                ", userFlag = " + userFlag +
+                "}";
+    }
+}

electricity/wind/src/main/java/com/gyee/gaia/electricity/wind/init/CacheContext.java

@@ -50,10 +50,6 @@ public class CacheContext implements ApplicationRunner {
      * 风机，机型
      */
     public static Map<String, String> equipModelMap;
-    /**
-     * 机型，风速，功率
-     */
-    public static Map<String, Map<Double, Double>> mpdsMapMap;
 
     @Override
     public void run(ApplicationArguments args) throws Exception {
@@ -72,10 +68,6 @@ public class CacheContext implements ApplicationRunner {
         List<Powerstation> stationList = powerstationService.list();
         stationMap = stationList.stream().collect(Collectors.toMap(Powerstation::getId, Function.identity()));
 
-        log.info("查询风速功率匹配！");
-        List<ModelPowerDetails> mpdList = modelPowerDetailsService.list();
-        mpdsMapMap = mpdList.stream().collect(Collectors.groupingBy(ModelPowerDetails::getModelId, Collectors.toMap(ModelPowerDetails::getSpeed, ModelPowerDetails::getTheoryPower)));
-
         calcEquipPowerGenDay.calcEquipPowerGenDay();
     }
 }

electricity/wind/src/main/java/com/gyee/gaia/electricity/wind/iservice/IStateCauseService.java

@@ -0,0 +1,18 @@
+package com.gyee.gaia.electricity.wind.iservice;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.gyee.gaia.electricity.wind.entity.StateCause;
+
+import java.util.List;
+
+/**
+ * <p>
+ * 服务类
+ * </p>
+ *
+ * @author gfhd
+ * @since 2023-05-04
+ */
+public interface IStateCauseService extends IService<StateCause> {
+    int saveBatch(List<StateCause> entityList);
+}

electricity/wind/src/main/java/com/gyee/gaia/electricity/wind/job/CalcEquipPowerGenDay.java

@@ -5,18 +5,14 @@ import cn.hutool.core.date.DateUtil;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.gyee.gaia.common.data.point.PointData;
 import com.gyee.gaia.common.data.point.TestingPoint;
-import com.gyee.gaia.common.data.power.ModelPowerDetails;
 import com.gyee.gaia.common.data.taos.RealtimeAverageTarget;
-import com.gyee.gaia.common.data.windturbine.Equipment;
-import com.gyee.gaia.dao.sql.Windturbine.IEquipmentService;
 import com.gyee.gaia.dao.sql.point.ITestingPointService;
-import com.gyee.gaia.dao.sql.power.IModelPowerDetailsService;
 import com.gyee.gaia.dao.sql.taos.IRealtimeAverageTargetService;
 import com.gyee.gaia.electricity.wind.adapter.IAdapterApi;
-import com.gyee.gaia.electricity.wind.config.AppConfig;
 import com.gyee.gaia.electricity.wind.entity.EquipPowerGenDay;
-import com.gyee.gaia.electricity.wind.init.CacheContext;
+import com.gyee.gaia.electricity.wind.entity.StateCause;
 import com.gyee.gaia.electricity.wind.iservice.IEquipPowerGenDayService;
+import com.gyee.gaia.electricity.wind.iservice.IStateCauseService;
 import com.xxl.job.core.handler.annotation.XxlJob;
 import org.springframework.stereotype.Component;
 
@@ -38,67 +34,166 @@ public class CalcEquipPowerGenDay {
     @Resource
     private ITestingPointService testingPointService;
     @Resource
-    private IEquipmentService equipmentService;
-    @Resource
     private IEquipPowerGenDayService equipPowerGenDayService;
     @Resource
     private IRealtimeAverageTargetService realtimeAverageTargetService;
     @Resource
-    private IModelPowerDetailsService modelPowerDetailsService;
-    @Resource
-    private AppConfig appConfig;
+    private IStateCauseService stateCauseService;
+
+    /**
+     * 风机id,1分钟理论发电量
+     */
+    private Map<String, List<RealtimeAverageTarget>> ratsListMap;
+    /**
+     * 风机id,日信息
+     */
+    private Map<String, EquipPowerGenDay> sepgdMap;
 
     @XxlJob("CalcEquipPowerGenDay")
     public void calcEquipPowerGenDay() {
 
         //2,获取当前日期,当日开始时间
         DateTime startDateTime = DateUtil.beginOfDay(DateUtil.yesterday());
-        DateTime endDateTime = DateUtil.beginOfDay(DateUtil.date());
+        DateTime endDateTime = DateUtil.endOfDay(DateUtil.yesterday());
 
         calcGeneratingCapacity(startDateTime, endDateTime);
         calcTheoryGeneration(startDateTime, endDateTime);
+        calcLossPower(startDateTime, endDateTime);
 
+        equipPowerGenDayService.saveBatch(sepgdMap.values());
     }
 
     /**
      * 计算损失电量
      */
-    private List<EquipPowerGenDay> calcLossPower(DateTime time1, DateTime time2){
+    private void calcLossPower(DateTime time1, DateTime time2) {
+
+        //查询1分钟理论发电量
+        QueryWrapper<RealtimeAverageTarget> ratWrapper = new QueryWrapper<>();
+        ratWrapper.select("time", "theory_generation", "equipment_id").eq("uniform_code", "1FZPJZB")
+                .between("time", time1.getTime(), time2.getTime());
+        List<RealtimeAverageTarget> ratList = realtimeAverageTargetService.list(ratWrapper);
+        ratsListMap = ratList.stream().collect(Collectors.groupingBy(RealtimeAverageTarget::getEquipmentId));
+
+        /*查询日电量信息
+        QueryWrapper<EquipPowerGenDay> epgdWrapper = new QueryWrapper<>();
+        epgdWrapper.eq("date", time1);
+        List<EquipPowerGenDay> epgdList = equipPowerGenDayService.list(epgdWrapper);
+
+        Map<String, EquipPowerGenDay> sepgdMap = new HashMap<>();
+        if (epgdList.size() > 0) {
+            sepgdMap = epgdList.stream().collect(Collectors.toMap(EquipPowerGenDay::getFacilityId, Function.identity()));
+        }*/
+
+        //查询损失时间
+        QueryWrapper<StateCause> scWrapper = new QueryWrapper<>();
+        scWrapper.select("start_time", "end_time", "event", "time", "station_id", "equipment_id").ne("event", "待机")
+                .ge("start_time", time1).le("end_time", time2);
+        List<StateCause> scList = stateCauseService.list(scWrapper);
+        Map<String, List<StateCause>> scsListMap = scList.stream().collect(Collectors.groupingBy(StateCause::getEquipmentId));
+
+        String equipId;
+        EquipPowerGenDay epgd;
+        for (List<StateCause> value : scsListMap.values()) {
+            equipId = value.get(0).getEquipmentId();
+
+            double faultLossPower = 0;//故障损失电量
+            double limitLossPower = 0;//限电损失电量
+            double maintainLossPower = 0;//计划检修损失电量
+            double implicateLossPower = 0;//受累损失电量
+            for (StateCause cause : value) {
+                switch (cause.getEvent()) {
+                    case "故障":
+                        faultLossPower += cause2DoubleSum(cause);
+                        break;
+                    case "限电":
+                        limitLossPower += cause2DoubleSum(cause);
+                        break;
+                    case "计划检修":
+                        maintainLossPower += cause2DoubleSum(cause);
+                        break;
+                    case "受累":
+                        implicateLossPower += cause2DoubleSum(cause);
+                        break;
+                }
+            }
+
+            epgd = sepgdMap.get(equipId);
+            if(epgd==null) continue;
+            //损失电量
+            BigDecimal losspower = epgd.getTheoryGeneration().subtract(epgd.getGeneratingCapacity());
+            if (losspower.compareTo(BigDecimal.ZERO) <= 0) {
+                epgd.setLossPower(BigDecimal.ZERO);
+                epgd.setFaultLossPower(BigDecimal.ZERO);
+                epgd.setMaintainLossPower(BigDecimal.ZERO);
+                epgd.setImplicateLossPower(BigDecimal.ZERO);
+                epgd.setLimitLossPower(BigDecimal.ZERO);
+                epgd.setPerformanceLossPower(BigDecimal.ZERO);
+            } else {
+                epgd.setLossPower(losspower);
+                epgd.setFaultLossPower(BigDecimal.valueOf(faultLossPower).setScale(2, RoundingMode.HALF_UP));
+                epgd.setMaintainLossPower(BigDecimal.valueOf(maintainLossPower).setScale(2, RoundingMode.HALF_UP));
+                epgd.setImplicateLossPower(BigDecimal.valueOf(implicateLossPower).setScale(2, RoundingMode.HALF_UP));
+                epgd.setLimitLossPower(BigDecimal.valueOf(limitLossPower).setScale(2, RoundingMode.HALF_UP));
+
+                BigDecimal performanceLossPower = epgd.getLossPower().subtract(epgd.getFaultLossPower())
+                        .subtract(epgd.getMaintainLossPower()).subtract(epgd.getImplicateLossPower())
+                        .subtract(epgd.getLimitLossPower());
+                epgd.setPerformanceLossPower(performanceLossPower.compareTo(BigDecimal.ZERO) < 0 ? BigDecimal.ZERO : performanceLossPower);
+            }
+            /*if (epgd == null) {
+                epgd = new EquipPowerGenDay();
+                epgd.setDate(time1.toLocalDateTime().toLocalDate());
+                epgd.setStation(value.get(0).getStationId());
+                epgd.setCategory("windturbine");
+                epgd.setFacilityId(equipId);
+
+                epgd.setFaultLossPower(BigDecimal.valueOf(faultLossPower).setScale(2, RoundingMode.HALF_UP));
+                epgd.setMaintainLossPower(BigDecimal.valueOf(maintainLossPower).setScale(2, RoundingMode.HALF_UP));
+                epgd.setImplicateLossPower(BigDecimal.valueOf(implicateLossPower).setScale(2, RoundingMode.HALF_UP));
+                epgd.setLimitLossPower(BigDecimal.valueOf(limitLossPower).setScale(2, RoundingMode.HALF_UP));
+
+                epgdList.add(epgd);
+            } else {
+
+            }*/
+        }
 
-        return null;
+    }
+
+    private double cause2DoubleSum(StateCause cause) {
+        return ratsListMap.get(cause.getEquipmentId()).stream().filter(target -> target.getTime().getTime() >= cause.getStartTime().getTime() &&
+                target.getTime().getTime() <= cause.getEndTime().getTime()).mapToDouble(RealtimeAverageTarget::getTheoryGeneration).sum();
     }
 
     /**
      * 计算理论电量
      */
-    private List<EquipPowerGenDay> calcTheoryGeneration(DateTime time1, DateTime time2) {
+    private void calcTheoryGeneration(DateTime time1, DateTime time2) {
 
         //查询1分钟平均风速
         QueryWrapper<RealtimeAverageTarget> ratWrapper = new QueryWrapper<>();
-        ratWrapper.select("time", "wind_speed", "station_id", "equipment_id").eq("uniform_code", "1FZPJZB")
-                .between("time", time1, time2).orderByAsc("time");
+        ratWrapper.select("AVG(wind_speed) wind_speed", "SUM(theory_generation) theory_generation", "equipment_id").eq("uniform_code", "1FZPJZB")
+                .between("time", time1.getTime(), time2.getTime()).groupBy("equipment_id");//.orderByAsc("time");
         List<RealtimeAverageTarget> ratList = realtimeAverageTargetService.list(ratWrapper);
-        Map<String, List<RealtimeAverageTarget>> ratsListMap = ratList.stream().collect(Collectors.groupingBy(RealtimeAverageTarget::getEquipmentId));
+        Map<String, RealtimeAverageTarget> sratMap = ratList.stream().collect(Collectors.toMap(RealtimeAverageTarget::getEquipmentId, Function.identity()));
+        //Map<String, List<RealtimeAverageTarget>> ratsListMap = ratList.stream().collect(Collectors.groupingBy(RealtimeAverageTarget::getEquipmentId));
 
         //查询日电量信息
-        QueryWrapper<EquipPowerGenDay> epgdWrapper = new QueryWrapper<>();
+        /*QueryWrapper<EquipPowerGenDay> epgdWrapper = new QueryWrapper<>();
         epgdWrapper.eq("date", time1);
         List<EquipPowerGenDay> epgdList = equipPowerGenDayService.list(epgdWrapper);
 
-        Map<String, EquipPowerGenDay> sepgdMap=new HashMap<>();
-        if(epgdList.size()>0){
+        Map<String, EquipPowerGenDay> sepgdMap = new HashMap<>();
+        if (epgdList.size() > 0) {
             sepgdMap = epgdList.stream().collect(Collectors.toMap(EquipPowerGenDay::getFacilityId, Function.identity()));
-        }
+        }*/
 
         String equipId;
-        List<RealtimeAverageTarget> targets;
-        EquipPowerGenDay epgd;
-        for (Map.Entry<String, List<RealtimeAverageTarget>> ratslEntry : ratsListMap.entrySet()) {
-            equipId = ratslEntry.getKey();
-            targets = ratslEntry.getValue();
-
-            epgd = sepgdMap.get(equipId);
-            if(epgd==null) {
+        for (EquipPowerGenDay value : sepgdMap.values()) {
+            equipId = value.getFacilityId();
+            /*epgd = sepgdMap.get(equipId);
+            if (epgd == null) {
                 epgd = new EquipPowerGenDay();
                 epgd.setDate(time1.toLocalDateTime().toLocalDate());
                 epgd.setStation(targets.get(0).getStationId());
@@ -107,7 +202,6 @@ public class CalcEquipPowerGenDay {
                 epgdList.add(epgd);
             }
             double theoryPower = targets.stream().mapToDouble(RealtimeAverageTarget::getTheoryGeneration).sum();
-            /*double theoryPower = 0;
             for (RealtimeAverageTarget target : targets) {
                 Double power = CacheContext.mpdsMapMap.get(CacheContext.equipModelMap.get(equipId)).get(target.getWindSpeed());
                 if(power==null) {
@@ -115,22 +209,23 @@ public class CalcEquipPowerGenDay {
                 }
                 theoryPower += power / 1000 / 60;
             }*/
-            epgd.setGeneratingCapacity(BigDecimal.valueOf(theoryPower/1000).setScale(2, RoundingMode.HALF_UP));
+            value.setTheoryGeneration(BigDecimal.valueOf(sratMap.get(equipId).getTheoryGeneration()).setScale(2, RoundingMode.HALF_UP));
+            value.setMeanWindSpeed(BigDecimal.valueOf(sratMap.get(equipId).getWindSpeed()).setScale(2, RoundingMode.HALF_UP));
         }
-        return epgdList;
+
     }
 
     /**
      * 计算日发电量
      */
-    private List<EquipPowerGenDay> calcGeneratingCapacity(DateTime time1, DateTime time2) {
+    private void calcGeneratingCapacity(DateTime time1, DateTime time2) {
 
         //开始时间00:00:01
-        DateTime dateTime1 = DateUtil.offsetSecond(time1, 1);
+        //DateTime dateTime1 = DateUtil.offsetSecond(time1, 1);
         //结束时间第二天00:00:01
-        DateTime dateTime2 = DateUtil.offsetSecond(time2, 1);
+        //DateTime dateTime2 = DateUtil.offsetSecond(time2, 2);
 
-        List<EquipPowerGenDay> epgdList = new ArrayList<>();
+        sepgdMap = new HashMap<>();
 
         //1,在testingpoint中根据 uniform_code=AI064 和code like "%_FJ_%" 取出所有风机的电量测点code
         List<TestingPoint> testingPointList = testingPointService.list(new QueryWrapper<TestingPoint>().eq("uniform_code", "AI064").eq("thing_type", "windturbine"));
@@ -139,10 +234,10 @@ public class CalcEquipPowerGenDay {
             //获取测点code
             String pointcode = testingPoint.getCode();
             //获取设备ID
-            String thingId = testingPoint.getThingId();
+            //String thingId = testingPoint.getThingId();
 
             //8,通过适配器拿到一天的发电量数据,
-            List<PointData> historyRaw = adapter.getHistoryRaw(pointcode, dateTime1.getTime(), dateTime2.getTime());
+            List<PointData> historyRaw = adapter.getHistoryRaw(pointcode, time1.getTime(), time2.getTime());
 
             //定义日发电量,先给0
             BigDecimal rfdl = new BigDecimal(0);
@@ -151,7 +246,7 @@ public class CalcEquipPowerGenDay {
             if (historyRaw.size() > 0) {
                 BigDecimal bigDecimal1 = new BigDecimal(Double.toString(historyRaw.get(0).getValue()));
                 BigDecimal bigDecimal2 = new BigDecimal(Double.toString(historyRaw.get(historyRaw.size() - 1).getValue()));
-                rfdl = bigDecimal2.subtract(bigDecimal1);
+                rfdl = bigDecimal2.subtract(bigDecimal1).setScale(2, RoundingMode.HALF_UP);
 
                 //如果日发电量大于50000千瓦时或者小于0,说明数据异常进行处理
                 if (rfdl.doubleValue() > 50000 || rfdl.doubleValue() < 0) {
@@ -170,7 +265,7 @@ public class CalcEquipPowerGenDay {
                     for (int j = 1; j < arrayList.size(); j++) {
                         double difference = arrayList.get(j) - arrayList.get(j - 1);
                         //如果变化值difference大于阈值或者小于0,返回当前突变数据的索引
-                        if (difference > threshold || difference < 0) {
+                        if (difference > threshold || difference < -1) {
                             index = j;
                             break;
                         }
@@ -185,7 +280,7 @@ public class CalcEquipPowerGenDay {
                         double valueGrow1 = arrayList.get(index - 1);
                         BigDecimal bigDecimalGrow1 = new BigDecimal(Double.toString(valueGrow1));
                         //计算日发电量(结束值-突变值)+(突变值前值-开始值)
-                        rfdl = (bigDecimal2.subtract(bigDecimalGrow2).add(bigDecimalGrow1).subtract(bigDecimal1));
+                        rfdl = (bigDecimal2.subtract(bigDecimalGrow2).add(bigDecimalGrow1).subtract(bigDecimal1).setScale(2, RoundingMode.HALF_UP));
                     }
                 }
             }
@@ -198,9 +293,8 @@ public class CalcEquipPowerGenDay {
             epgd.setCategory(testingPoint.getThingType());
             epgd.setFacilityId(testingPoint.getThingId());
             epgd.setGeneratingCapacity(rfdl);
-            epgdList.add(epgd);
+            sepgdMap.put(testingPoint.getThingId(), epgd);
         }
-        return epgdList;
     }
 
 }

electricity/wind/src/main/java/com/gyee/gaia/electricity/wind/mapper/StateCauseMapper.java

@@ -0,0 +1,20 @@
+package com.gyee.gaia.electricity.wind.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.gyee.gaia.electricity.wind.entity.StateCause;
+import org.apache.ibatis.annotations.Insert;
+import org.apache.ibatis.annotations.Mapper;
+
+/**
+ * <p>
+ * Mapper 接口
+ * </p>
+ *
+ * @author gfhd
+ * @since 2023-05-04
+ */
+@Mapper
+public interface StateCauseMapper extends BaseMapper<StateCause> {
+    @Insert("insert into ${entity}")
+    int insert(String entity);
+}

electricity/wind/src/main/java/com/gyee/gaia/electricity/wind/serviceimpl/StateCauseServiceImpl.java

@@ -0,0 +1,42 @@
+package com.gyee.gaia.electricity.wind.serviceimpl;
+
+import cn.hutool.core.collection.ListUtil;
+import com.baomidou.dynamic.datasource.annotation.DS;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.gyee.gaia.electricity.wind.entity.StateCause;
+import com.gyee.gaia.electricity.wind.iservice.IStateCauseService;
+import com.gyee.gaia.electricity.wind.mapper.StateCauseMapper;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+/**
+ * <p>
+ * 服务实现类
+ * </p>
+ *
+ * @author gfhd
+ * @since 2023-05-04
+ */
+@DS("jsfw")
+@Service
+public class StateCauseServiceImpl extends ServiceImpl<StateCauseMapper, StateCause> implements IStateCauseService {
+
+    public int saveBatch(List<StateCause> entityList) {
+        List<List<StateCause>> split = ListUtil.split(entityList, 3000);
+
+        int count = 0;
+        for (List<StateCause> targets : split) {
+            StringBuilder sb = new StringBuilder();
+            for (StateCause target : targets) {
+                sb.append(target.getTbname()).append(" values(").append(target.getStartTime().getTime())
+                        .append(",").append(target.getEndTime().getTime()).append(",'").append(target.getEvent())
+                        .append("','").append(target.getAdvanceState()).append("','").append(target.getAfterState())
+                        .append("','").append(target.getUserFlag()).append("',").append(target.getTime())
+                        .append(") ");
+            }
+            count += baseMapper.insert(sb.toString());
+        }
+        return count;
+    }
+}

electricity/wind/src/main/resources/banner.txt

@@ -1,6 +1,6 @@
- ####  #####   ##   ##### ######        ####    ##   #    #  ####  ###### 
-#        #    #  #    #   #            #    #  #  #  #    # #      #      
- ####    #   #    #   #   #####  ##### #      #    # #    #  ####  #####  
-     #   #   ######   #   #            #      ###### #    #      # #      
-#    #   #   #    #   #   #            #    # #    # #    # #    # #      
- ####    #   #    #   #   ######        ####  #    #  ####   ####  ###### 
+#####   ####  #    # ###### #####   ####  ###### #    #       #    # # #    # #####  
+#    # #    # #    # #      #    # #    # #      ##   #       #    # # ##   # #    # 
+#    # #    # #    # #####  #    # #      #####  # #  # ##### #    # # # #  # #    # 
+#####  #    # # ## # #      #####  #  ### #      #  # #       # ## # # #  # # #    # 
+#      #    # ##  ## #      #   #  #    # #      #   ##       ##  ## # #   ## #    # 
+#       ####  #    # ###### #    #  ####  ###### #    #       #    # # #    # #####  

electricity/wind/src/main/resources/bootstrap.yaml

@@ -1,9 +1,9 @@
 server:
-  port: 8022
+  port: 8133
 
 spring:
   application:
-    name: state-cause
+    name: powergen-wind
   profiles:
     # 环境配置
     active: nx
@@ -11,10 +11,10 @@ spring:
     nacos:
       discovery:
         # 服务注册地址
-        server-addr: 192.168.10.18:8848
+        server-addr: 192.168.1.66:8848
       config:
         # 配置中心地址
-        server-addr: 192.168.10.18:8848
+        server-addr: 192.168.1.66:8848
         # 配置文件格式
         file-extension: yml
         # 共享配置
@@ -99,17 +99,17 @@ mybatis-plus:
     #配置JdbcTypeForNull, oracle数据库必须配置
     jdbc-type-for-null: 'null'
     callSettersOnNulls: true
-    #log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
+    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
 
 xxl:
   job:
     admin:
-      addresses: http://192.168.10.18:8080/xxl-job-admin
+      addresses: http://192.168.1.67:8080/xxl-job-admin
     accessToken:
     executor:
-      appname: meter
+      appname: ${spring.application.name}
       address:
       ip:
-      port: 9021
+      port: 9133
       logpath: d:/xxl-job/meter/logs
-      logretentiondays: 30
+      logretentiondays: 30

realtime/wind/src/main/java/com/gyee/gaia/WindRealtimeApp.java

@@ -4,11 +4,13 @@ import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
 import org.springframework.cloud.openfeign.EnableFeignClients;
+import org.springframework.scheduling.annotation.EnableScheduling;
 
 
 @SpringBootApplication
 @EnableDiscoveryClient
 @EnableFeignClients
+@EnableScheduling
 public class WindRealtimeApp {
 
     public static void main(String[] args) {

realtime/wind/src/main/java/com/gyee/gaia/realtime/wind/job/CauseJobHandler.java

@@ -14,6 +14,7 @@ import com.gyee.gaia.realtime.wind.init.CacheContext;
 import org.springframework.boot.ApplicationArguments;
 import org.springframework.boot.ApplicationRunner;
 import org.springframework.core.annotation.Order;
+import org.springframework.scheduling.annotation.Scheduled;
 import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
 import org.springframework.stereotype.Component;
 
@@ -21,6 +22,8 @@ import javax.annotation.Resource;
 import java.time.LocalDateTime;
 import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
 import java.util.stream.Collectors;
 
 @Order(2)
@@ -44,6 +47,8 @@ public class CauseJobHandler implements ApplicationRunner {
      */
     private Map<String, Map<String, String>> equipUcMap = new HashMap<>();
 
+    private boolean isload = false;
+
     @Override
     public void run(ApplicationArguments args) throws Exception {
 
@@ -107,20 +112,21 @@ public class CauseJobHandler implements ApplicationRunner {
         pointCodes = sb.delete(0, 1).toString();
         init();
         taskExecutor.submit(this::refreshQueue);
-        taskExecutor.submit(this::calcRealtimeAverageTarget);
+        isload = true;
+        //taskExecutor.submit(this::calcRealtimeAverageTarget);
     }
 
     private void setRats(RealtimeAverageTarget target, String uc, double value) {
         if (uc.equals(appConfig.getUniformcodeOne().get("wind-speed"))) {
-            target.setWindSpeed(value);
+            target.setWindSpeed((float) value);
         } else if (uc.equals(appConfig.getUniformcodeOne().get("active-power"))) {
-            target.setPower(value);
+            target.setPower((float) value);
         } else if (uc.equals(appConfig.getUniformcodeOne().get("generator_speed"))) {
-            target.setGeneratorSpeed(value);
+            target.setGeneratorSpeed((float) value);
         } else if (uc.equals(appConfig.getUniformcodeOne().get("impeller_speed"))) {
-            target.setImpellerSpeed(value);
+            target.setImpellerSpeed((float) value);
         } else if (uc.equals(appConfig.getUniformcodeOne().get("wind_direction"))) {
-            target.setWindDirection(value);
+            target.setWindDirection((float) value);
         }
     }
 
@@ -160,8 +166,10 @@ public class CauseJobHandler implements ApplicationRunner {
         }
     }
 
+    @Scheduled(fixedRate = 60000)
     private void calcRealtimeAverageTarget() {
 
+        if(!isload) return;
         try {
             String pointCode = null;
             RealtimeAverageTarget target;
@@ -169,64 +177,58 @@ public class CauseJobHandler implements ApplicationRunner {
             //uniformcode,点名
             Map<String, String> entryValue;
             Map<String, String> uniformcodeOne = appConfig.getUniformcodeOne();
-            double speed;
+            float speed;
             Double power;
 
-            while (true) {
-                if (LocalDateTime.now().getSecond() == 59) {
+            List<RealtimeAverageTarget> targets = new ArrayList<>();
+            for (Map.Entry<String, Map<String, String>> entry : equipUcMap.entrySet()) {
 
-                    List<RealtimeAverageTarget> targets = new ArrayList<>();
-                    for (Map.Entry<String, Map<String, String>> entry : equipUcMap.entrySet()) {
+                entryValue = entry.getValue();
 
-                        entryValue = entry.getValue();
+                target = new RealtimeAverageTarget();
+                target.setTime(DateUtil.beginOfMinute(DateUtil.date()).toTimestamp());
+                //target.setEquipmentId(entry.getKey());
+                target.setTbname(CacheContext.pjzb1fzMap.get(entry.getKey()));
 
-                        target = new RealtimeAverageTarget();
-                        target.setTime(DateUtil.beginOfMinute(DateUtil.date()).toTimestamp());
-                        //target.setEquipmentId(entry.getKey());
-                        target.setTbname(CacheContext.pjzb1fzMap.get(entry.getKey()));
-
-                        pointCode = entryValue.get(uniformcodeOne.get("wind-speed"));
-                        if (pointCode != null) {
-                            v = pdaqMap.get(pointCode).stream().mapToDouble(data -> data.getDoubleValue()).average().orElse(0);
-                            speed = NumberUtil.round(v, 2).doubleValue();
-                            target.setWindSpeed(speed);
-                            if(speed<3) {
-                                power = Double.valueOf(0);
-                            }else {
-                                power = CacheContext.mpdsMapMap.get(CacheContext.equipModelMap.get(entry.getKey())).get(speed);
-                            }
-                            if(power==null){
-                                power = Double.valueOf(0);
-                                System.out.println(entry.getKey()+speed);
-                            }
-                            target.setTheoryGeneration(NumberUtil.round(power/60, 3).doubleValue());
-                        }
-                        pointCode = entryValue.get(uniformcodeOne.get("active-power"));
-                        if (pointCode != null) {
-                            v = pdaqMap.get(pointCode).stream().mapToDouble(data -> data.getDoubleValue()).average().orElse(0);
-                            target.setPower(NumberUtil.round(v, 2).doubleValue());
-                        }
-                        pointCode = entryValue.get(uniformcodeOne.get("generator_speed"));
-                        if (pointCode != null) {
-                            v = pdaqMap.get(pointCode).stream().mapToDouble(data -> data.getDoubleValue()).average().orElse(0);
-                            target.setGeneratorSpeed(NumberUtil.round(v, 2).doubleValue());
-                        }
-                        pointCode = entryValue.get(uniformcodeOne.get("impeller_speed"));
-                        if (pointCode != null) {
-                            v = pdaqMap.get(pointCode).stream().mapToDouble(data -> data.getDoubleValue()).average().orElse(0);
-                            target.setImpellerSpeed(NumberUtil.round(v, 2).doubleValue());
-                        }
-                        pointCode = entryValue.get(uniformcodeOne.get("wind_direction"));
-                        if (pointCode != null) {
-                            v = pdaqMap.get(pointCode).stream().mapToDouble(data -> data.getDoubleValue()).average().orElse(0);
-                            target.setWindDirection(NumberUtil.round(v, 2).doubleValue());
-                        }
-                        targets.add(target);
+                pointCode = entryValue.get(uniformcodeOne.get("wind-speed"));
+                if (pointCode != null) {
+                    v = pdaqMap.get(pointCode).stream().mapToDouble(data -> data.getDoubleValue()).average().orElse(0);
+                    speed = NumberUtil.round(v, 2).floatValue();
+                    target.setWindSpeed(speed);
+                    if(speed<3) {
+                        power = Double.valueOf(0);
+                    }else {
+                        power = CacheContext.mpdsMapMap.get(CacheContext.equipModelMap.get(entry.getKey())).get(speed);
+                    }
+                    if(power==null){
+                        power = Double.valueOf(0);
+                        System.out.println(entry.getKey()+speed);
                     }
-                    realtimeAverageTargetService.saveBatch(targets);
+                    target.setTheoryGeneration(NumberUtil.round(power/60, 3).floatValue());
                 }
-                Thread.sleep(1000);
+                pointCode = entryValue.get(uniformcodeOne.get("active-power"));
+                if (pointCode != null) {
+                    v = pdaqMap.get(pointCode).stream().mapToDouble(data -> data.getDoubleValue()).average().orElse(0);
+                    target.setPower(NumberUtil.round(v, 2).floatValue());
+                }
+                pointCode = entryValue.get(uniformcodeOne.get("generator_speed"));
+                if (pointCode != null) {
+                    v = pdaqMap.get(pointCode).stream().mapToDouble(data -> data.getDoubleValue()).average().orElse(0);
+                    target.setGeneratorSpeed(NumberUtil.round(v, 2).floatValue());
+                }
+                pointCode = entryValue.get(uniformcodeOne.get("impeller_speed"));
+                if (pointCode != null) {
+                    v = pdaqMap.get(pointCode).stream().mapToDouble(data -> data.getDoubleValue()).average().orElse(0);
+                    target.setImpellerSpeed(NumberUtil.round(v, 2).floatValue());
+                }
+                pointCode = entryValue.get(uniformcodeOne.get("wind_direction"));
+                if (pointCode != null) {
+                    v = pdaqMap.get(pointCode).stream().mapToDouble(data -> data.getDoubleValue()).average().orElse(0);
+                    target.setWindDirection(NumberUtil.round(v, 2).floatValue());
+                }
+                targets.add(target);
             }
+            //realtimeAverageTargetService.saveBatch(targets);
         } catch (Exception e) {
             e.printStackTrace();
         }

realtime/wind/src/main/resources/banner.txt

@@ -1,6 +1,6 @@
-#    # # #    # #####        #####  ######   ##   #      ##### # #    # ###### 
-#    # # ##   # #    #       #    # #       #  #  #        #   # ##  ## #      
-#    # # # #  # #    # ##### #    # #####  #    # #        #   # # ## # #####  
-# ## # # #  # # #    #       #####  #      ###### #        #   # #    # #      
-##  ## # #   ## #    #       #   #  #      #    # #        #   # #    # #      
-#    # # #    # #####        #    # ###### #    # ######   #   # #    # ###### 
+#####  ######   ##   #      ##### # #    # ######       #    # # #    # #####  
+#    # #       #  #  #        #   # ##  ## #            #    # # ##   # #    # 
+#    # #####  #    # #        #   # # ## # #####  ##### #    # # # #  # #    # 
+#####  #      ###### #        #   # #    # #            # ## # # #  # # #    # 
+#   #  #      #    # #        #   # #    # #            ##  ## # #   ## #    # 
+#    # ###### #    # ######   #   # #    # ######       #    # # #    # #####  

realtime/wind/src/main/resources/bootstrap.yaml

@@ -1,9 +1,9 @@
 server:
-  port: 8022
+  port: 8132
 
 spring:
   application:
-    name: state-cause
+    name: realtime-wind
   profiles:
     # 环境配置
     active: nx
@@ -11,10 +11,10 @@ spring:
     nacos:
       discovery:
         # 服务注册地址
-        server-addr: 192.168.10.18:8848
+        server-addr: 192.168.1.66:8848
       config:
         # 配置中心地址
-        server-addr: 192.168.10.18:8848
+        server-addr: 192.168.1.66:8848
         # 配置文件格式
         file-extension: yml
         # 共享配置
@@ -101,13 +101,13 @@ mybatis-plus:
 xxl:
   job:
     admin:
-      addresses: http://192.168.10.18:8080/xxl-job-admin
+      addresses: http://192.168.1.67:8080/xxl-job-admin
     accessToken:
     executor:
-      appname: meter
+      appname: ${spring.application.name}
       address:
       ip:
-      port: 9021
+      port: 9132
       logpath: d:/xxl-job/meter/logs
       logretentiondays: 30
 

state/cause/build.gradle

@@ -33,7 +33,7 @@ dependencies {
     implementation("org.postgresql:postgresql:$postgresqlDriverVersion")
     implementation "com.baomidou:mybatis-plus-boot-starter:$mybatisPlusVersion"
     implementation("com.alibaba:druid:$alibabaDruidVersion")
-    implementation("com.alibaba:fastjson:$fastjsonVersion")
+    //implementation("com.alibaba:fastjson:$fastjsonVersion")
 
     implementation("$bootGroup:spring-boot-starter-test")
     implementation("com.xuxueli:xxl-job-core:$xxlJobVersion")

state/cause/src/main/java/com/gyee/gaia/cause/config/NacosConfig.java

@@ -1,17 +0,0 @@
-package com.gyee.gaia.cause.config;
-
-import lombok.Data;
-import org.springframework.beans.factory.annotation.Value;
-import org.springframework.cloud.context.config.annotation.RefreshScope;
-import org.springframework.stereotype.Component;
-
-
-@Data
-@Component
-@RefreshScope
-public class NacosConfig {
-
-    @Value("${test.abcd}")
-    private String testttt;
-
-}

state/cause/src/main/java/com/gyee/gaia/cause/entity/StateCause.java

@@ -26,12 +26,12 @@ public class StateCause implements Serializable {
     /**
      * 开始时间
      */
-    private Date startTime;
+    private Timestamp startTime;
 
     /**
      * 结束时间
      */
-    private Date endTime;
+    private Timestamp endTime;
 
     /**
      * 事件-运行、限电、故障、受累、计划检修、待机
@@ -68,7 +68,7 @@ public class StateCause implements Serializable {
     public StateCause() {
     }
 
-    public StateCause(String tbname, String event, Date startTime, Date endTime, String advanceState, String afterState, Long time) {
+    public StateCause(String tbname, String event, Timestamp startTime, Timestamp endTime, String advanceState, String afterState, Long time) {
         this.tbname = tbname;
         this.event = event;
         this.startTime = startTime;
@@ -115,7 +115,7 @@ public class StateCause implements Serializable {
         return startTime;
     }
 
-    public void setStartTime(Date startTime) {
+    public void setStartTime(Timestamp startTime) {
         this.startTime = startTime;
     }
 
@@ -123,7 +123,7 @@ public class StateCause implements Serializable {
         return endTime;
     }
 
-    public void setEndTime(Date endTime) {
+    public void setEndTime(Timestamp endTime) {
         this.endTime = endTime;
     }
 

state/cause/src/main/java/com/gyee/gaia/cause/init/CacheContext.java

@@ -3,6 +3,7 @@ package com.gyee.gaia.cause.init;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.gyee.gaia.cause.config.AppConfig;
 import com.gyee.gaia.cause.entity.StateCause;
+import com.gyee.gaia.cause.job.CauseJobHandler;
 import com.gyee.gaia.cause.service.IStateCauseService;
 import com.gyee.gaia.common.data.point.TestingPoint;
 import com.gyee.gaia.common.data.power.ModelPower;

state/cause/src/main/java/com/gyee/gaia/cause/job/CauseJobHandler.java

@@ -35,7 +35,7 @@ public class CauseJobHandler {
         //String command = XxlJobHelper.getJobParam();
         //Map<String, String> map = JSON.parseObject(command, Map.class);
 
-        run();
+       run();
         return new ReturnT(SUCCESS_CODE, "调度成功!");
     }
 

state/cause/src/main/java/com/gyee/gaia/cause/service/CalculateService.java

@@ -16,6 +16,7 @@ import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
 
 import javax.annotation.Resource;
+import java.sql.Timestamp;
 import java.util.*;
 import java.util.stream.Collectors;
 
@@ -91,11 +92,11 @@ public class CalculateService {
                     StateCause cause;
                     for (Map.Entry<Long, Long> entry : map.entrySet()) {
                         if (ts==entry.getKey()) {
-                            cause = new StateCause(CacheContext.scEquipTbMap.get(thingId), stateMap.get(8.0), new Date(entry.getKey()),
-                                    new Date(entry.getValue()), stateMap.get(4.0), stateMap.get(doubleValue), entry.getValue() - entry.getKey());
+                            cause = new StateCause(CacheContext.scEquipTbMap.get(thingId), stateMap.get(8.0), new Timestamp(entry.getKey()),
+                                    new Timestamp(entry.getValue()), stateMap.get(4.0), stateMap.get(doubleValue), entry.getValue() - entry.getKey());
                         } else {
-                            cause = new StateCause(CacheContext.scEquipTbMap.get(thingId), stateMap.get(8.0), new Date(entry.getKey()),
-                                    new Date(entry.getValue()), stateMap.get(4.0), stateMap.get(4.0), entry.getValue() - entry.getKey());
+                            cause = new StateCause(CacheContext.scEquipTbMap.get(thingId), stateMap.get(8.0), new Timestamp(entry.getKey()),
+                                    new Timestamp(entry.getValue()), stateMap.get(4.0), stateMap.get(4.0), entry.getValue() - entry.getKey());
                         }
                         stateCauseList.add(cause);
                     }
@@ -103,23 +104,23 @@ public class CalculateService {
                     //计算限停
                     if (judgmentStop(thingId, advanceTime, ts)) {
                         StateCause cause = new StateCause(CacheContext.scEquipTbMap.get(thingId), stateMap.get(8.0),
-                                new Date(advanceTime), new Date(ts), stateMap.get(2.0), stateMap.get(doubleValue), ts - advanceTime);
+                                new Timestamp(advanceTime), new Timestamp(ts), stateMap.get(2.0), stateMap.get(doubleValue), ts - advanceTime);
                         stateCauseList.add(cause);
                     } else {
                         StateCause cause = new StateCause(CacheContext.scEquipTbMap.get(thingId), stateMap.get(2.0),
-                                new Date(advanceTime), new Date(ts), stateMap.get(2.0), stateMap.get(doubleValue), ts - advanceTime);
+                                new Timestamp(advanceTime), new Timestamp(ts), stateMap.get(2.0), stateMap.get(doubleValue), ts - advanceTime);
                         stateCauseList.add(cause);
                     }
                 } else if (advanceState == 6) {
                     if (hasFaultEvent(thingId, advanceTime, ts)) {
                         //故障
                         StateCause cause = new StateCause(CacheContext.scEquipTbMap.get(thingId), stateMap.get(5.0),
-                                new Date(advanceTime), new Date(ts), stateMap.get(6.0), stateMap.get(doubleValue), ts - advanceTime);
+                                new Timestamp(advanceTime), new Timestamp(ts), stateMap.get(6.0), stateMap.get(doubleValue), ts - advanceTime);
                         stateCauseList.add(cause);
                     } else {
                         //计划检修
                         StateCause cause = new StateCause(CacheContext.scEquipTbMap.get(thingId), stateMap.get(9.0),
-                                new Date(advanceTime), new Date(ts), stateMap.get(6.0), stateMap.get(doubleValue), ts - advanceTime);
+                                new Timestamp(advanceTime), new Timestamp(ts), stateMap.get(6.0), stateMap.get(doubleValue), ts - advanceTime);
                         stateCauseList.add(cause);
                     }
                 } else if (advanceState == 5) {
@@ -132,7 +133,7 @@ public class CalculateService {
                 } else if (advanceState == 0) {
                     if (ts - advanceTime < appConfig.getLongTime().get("fault-min")) continue;
                     StateCause cause = new StateCause(CacheContext.scEquipTbMap.get(thingId), stateMap.get(5.0),
-                            new Date(advanceTime), new Date(ts), stateMap.get(0.0), stateMap.get(doubleValue), ts - advanceTime);
+                            new Timestamp(advanceTime), new Timestamp(ts), stateMap.get(0.0), stateMap.get(doubleValue), ts - advanceTime);
                     stateCauseList.add(cause);
                 }
 
@@ -349,12 +350,12 @@ public class CalculateService {
         }
         if (k / size > 9.5) {
             //受累
-            StateCause cause = new StateCause(CacheContext.scEquipTbMap.get(thingId), stateMap.get(10.0), new Date(start), new Date(end),
+            StateCause cause = new StateCause(CacheContext.scEquipTbMap.get(thingId), stateMap.get(10.0), new Timestamp(start), new Timestamp(end),
                     stateMap.get(starteventstate), stateMap.get(endeventstate), end - start);
             stateCauseList.add(cause);
         } else {//if(starteventstate==5 || isHasFaultEvent(thingId,start,end)){
             //故障
-            StateCause cause = new StateCause(CacheContext.scEquipTbMap.get(thingId), stateMap.get(5.0), new Date(start), new Date(end),
+            StateCause cause = new StateCause(CacheContext.scEquipTbMap.get(thingId), stateMap.get(5.0), new Timestamp(start), new Timestamp(end),
                     stateMap.get(starteventstate), stateMap.get(endeventstate), end - start);
             stateCauseList.add(cause);
         }/*else {

state/cause/src/main/resources/bootstrap.yaml

@@ -1,5 +1,5 @@
 server:
-  port: 8022
+  port: 8131
 
 spring:
   application:
@@ -11,10 +11,10 @@ spring:
     nacos:
       discovery:
         # 服务注册地址
-        server-addr: 192.168.10.18:8848
+        server-addr: 192.168.1.66:8848
       config:
         # 配置中心地址
-        server-addr: 192.168.10.18:8848
+        server-addr: 192.168.1.66:8848
         # 配置文件格式
         file-extension: yml
         # 共享配置
@@ -118,12 +118,12 @@ mybatis-plus:
 xxl:
   job:
     admin:
-      addresses: http://192.168.10.18:8080/xxl-job-admin
+      addresses: http://192.168.1.67:8080/xxl-job-admin
     accessToken:
     executor:
-      appname: state-cause
+      appname: ${spring.application.name}
       address:
       ip:
-      port: 9021
+      port: 9131
       logpath: d:/xxl-job/statecause/logs
-      logretentiondays: 30
+      logretentiondays: 30

state/wind/src/main/resources/bootstrap.yaml

@@ -1,5 +1,5 @@
 server:
-  port: 8022
+  port: 8130
 
 spring:
   application:
@@ -11,10 +11,10 @@ spring:
     nacos:
       discovery:
         # 服务注册地址
-        server-addr: 192.168.10.18:8848
+        server-addr: 192.168.1.66:8848
       config:
         # 配置中心地址
-        server-addr: 192.168.10.18:8848
+        server-addr: 192.168.1.66:8848
         # 配置文件格式
         file-extension: yml
         # 共享配置
@@ -79,4 +79,4 @@ mybatis-plus:
     #配置JdbcTypeForNull, oracle数据库必须配置
     jdbc-type-for-null: 'null'
     callSettersOnNulls: true
-    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
+    #log-impl: org.apache.ibatis.logging.stdout.StdOutImpl