实现RTU阀开状态不长级功能设置与实现

liurunyu

2024-12-05 0cbe3bf67b051b6e66861ea97da2aea08e1fb2ad

实现RTU阀开状态不长级功能设置与实现

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/softUpgrade/state/UpgradeRtu.java

@@ -14,6 +14,8 @@
public class UpgradeRtu {

    @JSONField(serialize = false)
    public static final int STATE_OPEN = -2 ;//-1-阀开（泵开）不能升级
    @JSONField(serialize = false)
    public static final int STATE_OFFLINE = -1 ;//-1-离线
    @JSONField(serialize = false)
    public static final int STATE_UNSTART = 0 ;//0-未开始
@@ -28,10 +30,12 @@
    @JSONField(serialize = false)
    public static final int STATE_FAILOFFLINE = 5 ;//4-升级失败（离线）
    @JSONField(serialize = false)
    public static final int STATE_FAILOPEN = 6 ;//4-升级失败（阀开）
    @JSONField(serialize = false)
    public static final int RAMADDRADD = 0x200 ;//程序存储内存在址增量

    public String rtuAddr ;
    public int state ;// -1-离线，0-未开始，1-升级中，2-升级成功，3-升级失败（1包死），4-升级失败（非1包死），5-升级失败（离线）
    public int state ;// -1-离线，0-未开始，1-升级中，2-升级成功，3-升级失败（1包死），4-升级失败（非1包死），5-升级失败（离线），6-升级失败（阀开）
    public int totalPackage ;// æ€»åŒ…æ•°
    public int currentPackage ;// å½“前下发升级包数
    public int currentRamAddr ;// å½“前下发升级包RTU存储地址
@@ -55,6 +59,8 @@

    public static String getStateName(int state){
        switch (state) {
            case STATE_OPEN:
                return "阀开";
            case STATE_OFFLINE:
                return "离线";
            case STATE_UNSTART:
@@ -69,6 +75,8 @@
                return "多包死";
            case STATE_FAILOFFLINE:
                return "离线失败";
            case STATE_FAILOPEN:
                return "阀开失败";
            default:
                return "未知";
        }

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/softUpgrade/state/UpgradeState.java

@@ -20,6 +20,7 @@
    public int dieOneTotal;//所有一包死
    public int dieMultiTotal;//所有多包死
    public int failOffTotal ;//所有离线失败
    public int failOpenTotal ;//所有阀开失败

    public Boolean allOver ;//所有都结束（true:是，false:否）

@@ -38,6 +39,7 @@
        this.dieOneTotal = 0;
        this.dieMultiTotal = 0;
        this.failOffTotal = 0;
        this.failOpenTotal = 0;
        this.allOver = false ;
    }

@@ -54,6 +56,7 @@
        sb.append("    \n一包死失败总数：" + dieOneTotal) ;
        sb.append("    \n多包死失败总数：" + dieMultiTotal) ;
        sb.append("    \n离线失败总数：" + failOffTotal) ;
        sb.append("    \n阀开失败总数：" + failOpenTotal) ;
        sb.append("    \n全结束：" + allOver) ;
        return sb.toString() ;
    }

 pipIrr-platform/pipIrr-mw/pipIrr-mw-rtu/src/main/java/com/dy/rtuMw/Server.java

@@ -336,6 +336,9 @@
            //RTU远程升级模块
            UpgradeUnitConfigVo ugVo = new UpgradeUnitConfigVo();
            ugVo.enable = conf.getSetAttrBoolean(doc, "config.upgrade", "enable", null, null) ;
            ugVo.openNoUpgrade = conf.getSetAttrBoolean(doc, "config.upgrade", "openNoUpgrade", null, null) ;
            ugVo.lastOpenMaxGoOn = conf.getSetAttrPlusInt(doc, "config.upgrade", "lastOpenMaxGoOn", null, 5, 360000, null);
            ugVo.lastOpenMaxGoOn = ugVo.lastOpenMaxGoOn * 1000 ;//变成毫秒
            ugVo.noOneRtuUpgradeMaxDuration = conf.getSetAttrPlusInt(doc, "config.upgrade", "noOneRtuUpgradeMaxDuration", null, 5, 360000, null);
            ugVo.noOneRtuUpgradeMaxDuration = ugVo.noOneRtuUpgradeMaxDuration * 1000 ;//变成毫秒
            ugVo.runningAndIdleDuration = conf.getSetAttrPlusInt(doc, "config.upgrade", "runningAndIdleDuration", null, 5, 360000, null);

 pipIrr-platform/pipIrr-mw/pipIrr-mw-rtu/src/main/java/com/dy/rtuMw/server/upgrade/UpgradeManager.java

@@ -25,13 +25,15 @@

    private static final UpgradeManager INSTANCE = new UpgradeManager();

    private Boolean openNoUpgrade ;//阀开（泵开）不执行升级
    private Integer lastOpenMaxGoOn ;//阀开（泵开）状态设置以来持续最长时间（秒钟），超过这个时间认为状态无效（这个时长取决于工作报间隔）
    private Integer failTryTimes ;//升级失败后，重新偿试升级次数，0表示不重新偿试升级
    private Integer ugMaxRtuSameTime ;//同时升级RTU最大个数
    private Integer notifyTimesAfterOver; //升级结束后，再向web服务系统通知状态的次数
    private int nowNotifyTimesAfterOver; //升级结束后，再向web服务系统通知状态的次数

    private UpgradeTask task ;//升级任务
    private boolean monitorFirst = true ;//是否是第一次监视
    private boolean monitorFirst ;//是否是第一次监视

    private UpgradeManager(){
        monitorFirst = true ;
@@ -45,6 +47,8 @@
     *  åˆå§‹åŒ–配置信息
     */
    public void initOption(UpgradeUnitConfigVo configVo) {
        this.openNoUpgrade = configVo.openNoUpgrade;
        this.lastOpenMaxGoOn = configVo.lastOpenMaxGoOn;
        this.failTryTimes = configVo.failTryTimes;
        this.ugMaxRtuSameTime = configVo.ugMaxRtuAtOnce;
        this.notifyTimesAfterOver = configVo.notifyTimesAfterOver;
@@ -65,9 +69,10 @@
                    this.task.forceOver();
                }
                this.task = new UpgradeTask();
                this.task.initOption(this.failTryTimes, this.ugMaxRtuSameTime);
                this.task.initOption(this.lastOpenMaxGoOn, this.failTryTimes, this.ugMaxRtuSameTime);
                this.task.setTask(vo);
                this.nowNotifyTimesAfterOver = 0 ;
                this.monitorFirst = true ;
                log.info("======================================================") ;
                log.info("=                                                    =") ;
                log.info("=设置了升级任务，涉及RTU" + vo.rtuAddrList.size() + "台                            =") ;
@@ -195,6 +200,12 @@
            this.stop() ;
        }else{
            if(!this.task.taskIsOver){
                if(this.openNoUpgrade != null
                        && this.openNoUpgrade.booleanValue()
                        && this.monitorFirst){
                    //第一次进入，进行阀开不升级处理
                    this.task.openNoUpgrade() ;
                }
                this.nowNotifyTimesAfterOver = 0 ;
                //升级任务未完成
                //工作1：判断是否无任何一个RTU进行过升级，并且达到时限，则认为当前升级任务完成
@@ -309,6 +320,7 @@
        return true ;
    }


    /**
     * å‡çº§çŠ¶æ€é€šçŸ¥
     */

 pipIrr-platform/pipIrr-mw/pipIrr-mw-rtu/src/main/java/com/dy/rtuMw/server/upgrade/UpgradeTask.java

@@ -1,12 +1,14 @@
package com.dy.rtuMw.server.upgrade;

import com.alibaba.fastjson2.annotation.JSONField;
import com.dy.common.mw.protocol.rtuState.RtuStatus;
import com.dy.common.softUpgrade.parse.HexFileParse;
import com.dy.common.softUpgrade.state.UpgradeRtu;
import com.dy.common.softUpgrade.state.UpgradeState;
import com.dy.common.softUpgrade.state.UpgradeTaskVo;
import com.dy.common.util.Callback;
import com.dy.common.util.DateTime;
import com.dy.rtuMw.server.forTcp.RtuStatusDealer;
import lombok.Data;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
@@ -32,6 +34,8 @@
    protected Integer failTryTimes ;//升级失败后，重新偿试升级次数，0表示不重新偿试升级
    @JSONField(serialize = false)
    protected Integer ugMaxRtuSameTime ;//同时升级RTU最大个数
    @JSONField(serialize = false)
    private Integer lastOpenMaxGoOn ;//阀开（泵开）状态设置以来持续最长时间（秒钟），超过这个时间认为状态无效（这个时长取决于工作报间隔）

    public String setupDt ;//设置时间(yyyy-mm-dd HH:MM:SS)
    @JSONField(serialize = false)
@@ -60,7 +64,8 @@
    /**
     *  åˆå§‹åŒ–配置信息
     */
    public void initOption(Integer failTryTimes, Integer ugMaxRtuSameTime) {
    public void initOption(Integer lastOpenMaxGoOn, Integer failTryTimes, Integer ugMaxRtuSameTime) {
        this.lastOpenMaxGoOn = lastOpenMaxGoOn;
        this.failTryTimes = failTryTimes;
        this.ugMaxRtuSameTime = ugMaxRtuSameTime;
    }
@@ -222,6 +227,9 @@
                    }else if(info.state == UpgradeRtu.STATE_FAILOFFLINE) {
                        state.failTotal++;
                        state.failOffTotal++;
                    }else if(info.state == UpgradeRtu.STATE_FAILOPEN) {
                        state.failTotal++;
                        state.failOpenTotal++;
                    }
                    if(info.isOver){
                        state.overTotal++;
@@ -282,6 +290,29 @@
    ///////////////////////////////////////////////////////////

    /**
     * é˜€å¼€ï¼ˆæ³µå¼€ï¼‰ä¸å‡çº§å¤„理
     */
    protected void openNoUpgrade(){
        if(this.upgradeRtus != null && this.upgradeRtus.size() > 0){
            Map<String, RtuStatus> rsAllMap = RtuStatusDealer.allStatus() ;
            Long now = System.currentTimeMillis() ;
            this.upgradeRtus.values().stream().forEach(a -> {
                RtuStatus rs = rsAllMap.get(a.rtuAddr) ;
                if(rs != null
                        && rs.valveOpenTrueCloseFalse != null && rs.valveOpenTrueCloseFalse.booleanValue() == true
                        && rs.valveStatusLastTimeStamp != null){
                    //有状态，并且是阀开（泵开）
                    Long gap = now - rs.valveStatusLastTimeStamp ;
                    if(gap < this.lastOpenMaxGoOn){
                        //这时采纳阀门打开状态不能升级
                        a.isOver = true ;
                        a.state = UpgradeRtu.STATE_FAILOPEN ;
                    }
                }
            });
        }
    }
    /**
     * åˆ¤æ–­æ˜¯å¦æ²¡ç”¨ä»»ä½•ä¸€ä¸ªRTU进行过升级，而且超过了时限
     * @return -1:无一RTU升级且超时，0：无RTU升级但未超时等待，1有RTU升级正常执行
     */

 pipIrr-platform/pipIrr-mw/pipIrr-mw-rtu/src/main/java/com/dy/rtuMw/server/upgrade/UpgradeUnitConfigVo.java

@@ -9,6 +9,8 @@

    public Boolean showStartInfo ;
    public Boolean enable ;//模块是否启动
    public Boolean openNoUpgrade ;//阀开（泵开）不执行升级
    public Integer lastOpenMaxGoOn; //阀开（泵开）状态设置以来持续最长时间（秒钟），超过这个时间认为状态无效（这个时长取决于工作报间隔）
    public Integer noOneRtuUpgradeMaxDuration ;//升级任务设置后，没有设备升级最大时长（毫秒），超过这个时长，认为升级任务完成，取值范围是5分钟~60分钟
    public Integer runningAndIdleDuration ;//rtu升级启动后进入升级中状态，但某种情况下RTU不再通信了，一直处于等待状态，等待达到一定时长（秒）认为升级失败（一包死或多包死），取值范围是5分钟~60分钟
    public Integer failTryTimes ;//升级失败后（针对的是在线进行了升级下发命令），重新偿试升级次数，0表示不重新偿试升级
@@ -19,6 +21,8 @@

    public UpgradeUnitConfigVo(){
        this.enable = false ;
        this.openNoUpgrade = true ;
        this.lastOpenMaxGoOn = 30 * 60 * 1000 ;
        this.noOneRtuUpgradeMaxDuration = 10 * 60 * 1000 ;
        this.runningAndIdleDuration = 10 * 60 * 1000 ;
        this.failTryTimes = 0 ;

 pipIrr-platform/pipIrr-mw/pipIrr-mw-rtu/src/main/resources/config(spɳÅÌ).xml

@@ -56,6 +56,8 @@

    <!-- RTU è½¯ä»¶å‡çº§
    enable: æ¨¡å—是否启动
    openNoUpgrade: é˜€å¼€ï¼ˆæ³µå¼€ï¼‰ä¸æ‰§è¡Œå‡çº§
    lastOpenMaxGoOn: é˜€å¼€ï¼ˆæ³µå¼€ï¼‰çŠ¶æ€è®¾ç½®ä»¥æ¥æŒç»­æœ€é•¿æ—¶é—´ï¼ˆç§’钟），超过这个时间认为状态无效（这个时长取决于工作报间隔）
    noOneRtuUpgradeMaxDuration：升级任务设置后，无一设备升级最大时长（秒），超过这个时长，认为升级任务完成，取值范围是5分钟~60分钟
    runningAndIdleDuration：rtu升级启动后进入升级中状态，但某种情况下RTU不再通信了，一直处于等待状态，等待达到一定时长（秒，一般与noOneRtuUpgradeMaxDuration相等）认为升级失败（一包死或多包死），取值范围是5分钟~60分钟
    failTryTimes：升级失败后（针对的是在线进行了升级下发命令），重新偿试升级次数，当设置为0时表示不重新偿试升级
@@ -65,6 +67,8 @@
    notifyTimesAfterOver: å‡çº§ç»“束后，再向web服务系统通知状态的次数
    -->
    <upgrade enable="true"
             openNoUpgrade="true"
             lastOpenMaxGoOn="1800"
             noOneRtuUpgradeMaxDuration="1200"
             runningAndIdleDuration="1200"
             failTryTimes="2"

 pipIrr-platform/pipIrr-mw/pipIrr-mw-rtu/src/main/resources/config(test²âÊÔ).xml

@@ -56,6 +56,8 @@

    <!-- RTU è½¯ä»¶å‡çº§
    enable: æ¨¡å—是否启动
    openNoUpgrade: é˜€å¼€ï¼ˆæ³µå¼€ï¼‰ä¸æ‰§è¡Œå‡çº§
    lastOpenMaxGoOn: é˜€å¼€ï¼ˆæ³µå¼€ï¼‰çŠ¶æ€è®¾ç½®ä»¥æ¥æŒç»­æœ€é•¿æ—¶é—´ï¼ˆç§’钟），超过这个时间认为状态无效（这个时长取决于工作报间隔）
    noOneRtuUpgradeMaxDuration：升级任务设置后，无一设备升级最大时长（秒），超过这个时长，认为升级任务完成，取值范围是5分钟~60分钟
    runningAndIdleDuration：rtu升级启动后进入升级中状态，但某种情况下RTU不再通信了，一直处于等待状态，等待达到一定时长（秒，一般与noOneRtuUpgradeMaxDuration相等）认为升级失败（一包死或多包死），取值范围是5分钟~60分钟
    failTryTimes：升级失败后（针对的是在线进行了升级下发命令），重新偿试升级次数，当设置为0时表示不重新偿试升级
@@ -65,6 +67,8 @@
    notifyTimesAfterOver: å‡çº§ç»“束后，再向web服务系统通知状态的次数
    -->
    <upgrade enable="true"
             openNoUpgrade="true"
             lastOpenMaxGoOn="1800"
             noOneRtuUpgradeMaxDuration="1200"
             runningAndIdleDuration="1200"
             failTryTimes="2"

 pipIrr-platform/pipIrr-mw/pipIrr-mw-rtu/src/main/resources/config(ymԪı).xml

@@ -56,6 +56,8 @@

    <!-- RTU è½¯ä»¶å‡çº§
    enable: æ¨¡å—是否启动
    openNoUpgrade: é˜€å¼€ï¼ˆæ³µå¼€ï¼‰ä¸æ‰§è¡Œå‡çº§
    lastOpenMaxGoOn: é˜€å¼€ï¼ˆæ³µå¼€ï¼‰çŠ¶æ€è®¾ç½®ä»¥æ¥æŒç»­æœ€é•¿æ—¶é—´ï¼ˆç§’钟），超过这个时间认为状态无效（这个时长取决于工作报间隔）
    noOneRtuUpgradeMaxDuration：升级任务设置后，无一设备升级最大时长（秒），超过这个时长，认为升级任务完成，取值范围是5分钟~60分钟
    runningAndIdleDuration：rtu升级启动后进入升级中状态，但某种情况下RTU不再通信了，一直处于等待状态，等待达到一定时长（秒，一般与noOneRtuUpgradeMaxDuration相等）认为升级失败（一包死或多包死），取值范围是5分钟~60分钟
    failTryTimes：升级失败后（针对的是在线进行了升级下发命令），重新偿试升级次数，当设置为0时表示不重新偿试升级
@@ -65,6 +67,8 @@
    notifyTimesAfterOver: å‡çº§ç»“束后，再向web服务系统通知状态的次数
    -->
    <upgrade enable="true"
             openNoUpgrade="true"
             lastOpenMaxGoOn="1800"
             noOneRtuUpgradeMaxDuration="1200"
             runningAndIdleDuration="1200"
             failTryTimes="2"

 pipIrr-platform/pipIrr-mw/pipIrr-mw-rtu/src/main/resources/config.xml

@@ -56,6 +56,8 @@

    <!-- RTU è½¯ä»¶å‡çº§
    enable: æ¨¡å—是否启动
    openNoUpgrade: é˜€å¼€ï¼ˆæ³µå¼€ï¼‰ä¸æ‰§è¡Œå‡çº§
    lastOpenMaxGoOn: é˜€å¼€ï¼ˆæ³µå¼€ï¼‰çŠ¶æ€è®¾ç½®ä»¥æ¥æŒç»­æœ€é•¿æ—¶é—´ï¼ˆç§’钟），超过这个时间认为状态无效（这个时长取决于工作报间隔）
    noOneRtuUpgradeMaxDuration：升级任务设置后，无一设备升级最大时长（秒），超过这个时长，认为升级任务完成，取值范围是5分钟~60分钟
    runningAndIdleDuration：rtu升级启动后进入升级中状态，但某种情况下RTU不再通信了，一直处于等待状态，等待达到一定时长（秒，一般与noOneRtuUpgradeMaxDuration相等）认为升级失败（一包死或多包死），取值范围是5分钟~60分钟
    failTryTimes：升级失败后（针对的是在线进行了升级下发命令），重新偿试升级次数，当设置为0时表示不重新偿试升级
@@ -65,6 +67,8 @@
    notifyTimesAfterOver: å‡çº§ç»“束后，再向web服务系统通知状态的次数
    -->
    <upgrade enable="true"
             openNoUpgrade="true"
             lastOpenMaxGoOn="1800"
             noOneRtuUpgradeMaxDuration="1200"
             runningAndIdleDuration="1200"
             failTryTimes="2"
@@ -73,6 +77,8 @@
             notifyStateInterval="2"
             notifyTimesAfterOver="1"
    />


    <!--
    æ”¯æŒæ¨¡å—
    çŸ­å·¥ä½œæ—¶é•¿çº¿ç¨‹æ± ï¼Œçº¿ç¨‹è´Ÿè´£ç”¨æ—¶è¾ƒçŸ­çš„工作任务

 pipIrr-platform/pipIrr-web/pipIrr-web-remote/src/main/java/com/dy/pipIrrRemote/rtuUpgrage/RtuUpgradeResSv.java

@@ -87,7 +87,8 @@
                        ok = rtu.state == UpgradeRtu.STATE_OFFLINE
                                || rtu.state == UpgradeRtu.STATE_FAILONE
                                || rtu.state == UpgradeRtu.STATE_FAIL
                                || rtu.state == UpgradeRtu.STATE_FAILOFFLINE;
                                || rtu.state == UpgradeRtu.STATE_FAILOFFLINE
                                || rtu.state == UpgradeRtu.STATE_FAILOPEN;
                    }
                }
                if(qvoRtuAddr != null && !qvoRtuAddr.trim().equals("")){
@@ -117,6 +118,11 @@
                            vo.rtuAddr = rtu.rtuAddr ;
                            vo.result = "离线" ;
                            list.add(vo);
                        }else if(rtu.state == UpgradeRtu.STATE_FAILOPEN){
                            VoUgRtuResult vo = new VoUgRtuResult() ;
                            vo.rtuAddr = rtu.rtuAddr ;
                            vo.result = "阀开" ;
                            list.add(vo);
                        }else if(rtu.state == UpgradeRtu.STATE_FAILONE){
                            VoUgRtuResult vo = new VoUgRtuResult() ;
                            vo.rtuAddr = rtu.rtuAddr ;