Merge branch 'master' of http://8.140.179.55:20000/r/pipIrr-SV

zhubaomin

2024-11-11 ae430b46ddafab21c1de3592aeb0ae3886aaf4e6

Merge branch 'master' of http://8.140.179.55:20000/r/pipIrr-SV

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/softUpgrade/parse/HexFileParse.java

@@ -4,6 +4,7 @@
import com.dy.common.util.ByteUtil;

import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;

@@ -156,6 +157,27 @@

    /**
     * ä»¥512为单位分割数据包
     * @param bytes
     */
    public List<byte[]> splitBytesByUnit512(byte[] bytes){
        List<byte[]> listByte512 = new ArrayList<>();
        if(bytes != null && bytes.length > 0){
            int index = 0 ;
            while (true){
                if(index < bytes.length){
                    byte[] bs = ByteUtil.bytesSplit(bytes, index, bytesSplitUnit512) ;
                    listByte512.add(bs) ;
                }else{
                    break ;
                }
                index += bytesSplitUnit512;
            }
        }
        return listByte512 ;
    }

    /**
     * ä»¥512为单位分割数据包
     * @param vo
     */
    private void split(HexFileVo vo){

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

New file
@@ -0,0 +1,20 @@
package com.dy.common.softUpgrade.state;

import lombok.Data;

import java.util.List;

/**
 * @Author: liurunyu
 * @Date: 2024/11/11 17:32
 * @Description
 */
@Data
public class UpgradeInfo {
    //升级任务ID
    public String ugTaskId;
    //升级任务总体状态
    public UpgradeState ugOverallState;
    //升级任务RTU状态列表
    public List<UpgradeRtu> ugRtuStateList;
}

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

New file
@@ -0,0 +1,78 @@
package com.dy.common.softUpgrade.state;

import com.alibaba.fastjson2.annotation.JSONField;
import com.dy.common.mw.protocol.Command;
import com.dy.common.util.Callback;
import lombok.Data;

/**
 * @Author: liurunyu
 * @Date: 2024/11/11 17:33
 * @Description
 */
@Data
public class UpgradeRtu {

    @JSONField(serialize = false)
    public static final int STATE_OFFLINE = -1 ;//-1-离线
    @JSONField(serialize = false)
    public static final int STATE_UNSTART = 0 ;//0-未开始
    @JSONField(serialize = false)
    public static final int STATE_RUNNING = 1 ;//1-升级中
    @JSONField(serialize = false)
    public static final int STATE_SUCCESS = 2 ;//2-升级成功
    @JSONField(serialize = false)
    public static final int STATE_FAILONE = 3 ;//3-升级失败（1包死）
    @JSONField(serialize = false)
    public static final int STATE_FAIL = 4 ;//4-升级失败（非1包死）
    @JSONField(serialize = false)
    public static final int STATE_FAILOFFLINE = 5 ;//4-升级失败（离线）
    @JSONField(serialize = false)
    public static final int RAMADDRADD = 0x20 ;//程序存储内存在址增量

    public String rtuAddr ;
    public int state ;// -1-离线，0-未开始，1-升级中，2-升级成功，3-升级失败（1包死），4-升级失败（非1包死），5-升级失败（离线）
    public int totalPackage ;// æ€»åŒ…æ•°
    public int currentPackage ;// å½“前下发升级包数
    public int currentRamAddr ;// å½“前下发升级包RTU存储地址
    public String lastDownDt ;// æœ€åŽä¸‹å‘升级数据包时间（yyyy-mm-dd HH:HH:SS）
    public int reTryTimes ;//升级不成功，重试次数
    public boolean isOver ;

    /**
     * è§¦å‘升级
     * @param code
     * @param softData
     * @param callbackCom
     */
    public void trigger(String code,
                        String protocolName,
                        Short protocolVersion,
                        byte[][] softData,
                        Callback callbackCom){
        return ;
    }

    public Command createCommand1601(String protocolName,
                                     Short protocolVersion){
        return null ;
    }

    public Command createCommand1602(String protocolName,
                                     Short protocolVersion,
                                     int currentPackage,
                                     Integer ramAddr,
                                     byte[][] softData){
        return null ;
    }

    public Command createCommand1603(String protocolName,
                                     Short protocolVersion){
        return null ;
    }

    public Command createCommand1600(String protocolName,
                                     Short protocolVersion){
        return null ;
    }
}

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

New file
@@ -0,0 +1,33 @@
package com.dy.common.softUpgrade.state;

import lombok.Data;

/**
 * @Author: liurunyu
 * @Date: 2024/11/4 15:14
 * @Description
 */
@Data
public class UpgradeState {

    public int rtuTotal ;//设置升级RTU数
    public int offLineTotal ;//所有离线的
    public int unStartTotal ;//所有未开始
    public int runningTotal ;//所有正在升级
    public int overTotal ;//所有结束（包括成功与所有失败）
    public int successTotal ;//所有成功
    public int failTotal ;//所有失败
    public int failOneTotal ;//所有一包死失败

    public UpgradeState() {
        this.rtuTotal = 0;
        this.offLineTotal = 0;
        this.unStartTotal = 0;
        this.runningTotal = 0;
        this.overTotal = 0;
        this.successTotal = 0;
        this.failTotal = 0;
    }


}

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

New file
@@ -0,0 +1,36 @@
package com.dy.common.softUpgrade.state;

import lombok.Data;

import java.util.List;

/**
 * @Author: liurunyu
 * @Date: 2024/11/8 13:40
 * @Description
 */
@Data
public class UpgradeTaskVo {
    public String id ;//升级任务ID
    public String softFileName ;//升级程序文件名
    public String softStoreAddr ;//升级程序存放地址
    public String softStartAddr ;//程序覆盖起始地址
    public byte[] softFileData ;//有效升级程序字节数组
    public Integer softBytesCalculate ;//根据公式计算得到的有效升级程序字节数
    public Integer softByteSrc16 ;//有效升级程序字节数CRC16校验值
    public List<String> rtuAddrList ;//所在升级的控制器地址
    public String callbackWebUrl ;//回调URL

    public String toString(){
        return "升级任务:" +
                "   å‡çº§ä»»åŠ¡ID=" + id + "\n" +
                "   å‡çº§ç¨‹åºæ–‡ä»¶å=" + softFileName + "\n" +
                "   å‡çº§ç¨‹åºå­˜æ”¾åœ°å€=" + softStoreAddr + "\n" +
                "   ç¨‹åºè¦†ç›–起始地址=" + softStartAddr + "\n" +
                "   æœ‰æ•ˆå‡çº§ç¨‹åºå­—节数=" + softFileData.length + "\n" +
                "   å…¬å¼è®¡ç®—程序字节数=" + softBytesCalculate +
                "   ç¨‹åºCRC16校验值=" + softByteSrc16 + "\n" +
                "   å‡çº§æŽ§åˆ¶å™¨æ•°é‡=" + rtuAddrList.size() + "\n" +
                "   å‡çº§çŠ¶æ€é€šçŸ¥URL=" + callbackWebUrl + "\n" ;
    }
}

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/util/ThreadJob.java

@@ -3,8 +3,19 @@

@SuppressWarnings("unused")
public abstract class ThreadJob {
    public void start(Callback callback){
        new Thread(() -> {
    protected Thread thread ;
    protected boolean stop = false ;
    public void stop(){
        this.stop = true ;
    }
    public boolean isStop(){
        return this.stop ;
    }
    public Thread getThread(){
        return this.thread ;
    }
    public void start(Callback callback) throws Exception {
        this.thread = new Thread(() -> {
            Exception[] exe = {null} ;
            Object[] obj = {null} ;
            try {
@@ -21,9 +32,9 @@
                    }
                }
            }
        }).start();
        });
        thread.start() ;
    }

    public abstract Object execute() throws Exception ;
}


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

@@ -337,7 +337,11 @@
            UpgradeUnitConfigVo ugVo = new UpgradeUnitConfigVo();
            ugVo.enable = conf.getSetAttrBoolean(doc, "config.upgrade", "enable", null, null) ;
            ugVo.failTryTimes = conf.getSetAttrPlusInt(doc, "config.upgrade", "failTryTimes", null, 0, 100, null);
            ugVo.ugMaxRtuSameTime = conf.getSetAttrPlusInt(doc, "config.upgrade", "ugMaxRtuSameTime", null, 1, 1000000, null);
            ugVo.ugMaxRtuAtOnce = conf.getSetAttrPlusInt(doc, "config.upgrade", "ugMaxRtuSameTime", null, 0, 1000000, null);
            ugVo.rtuOffLineWaitDuration = conf.getSetAttrPlusInt(doc, "config.upgrade", "rtuOffLineWaitDuration", null, 1, 36000, null);
            ugVo.rtuOffLineWaitDuration = ugVo.rtuOffLineWaitDuration + 1000;//变成毫秒
            ugVo.notifyStateInterval = conf.getSetAttrPlusInt(doc, "config.upgrade", "notifyStateInterval", null, 1, 300, null);
            ugVo.notifyStateInterval = ugVo.notifyStateInterval + 1000;//变成毫秒
            ugVo.showStartInfo = showStartInfo ;
            AdapterImp_UpgradeUnit ugAdap = new AdapterImp_UpgradeUnit();
            ugAdap.setConfig(ugVo);

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

@@ -1,6 +1,16 @@
package com.dy.rtuMw.server.upgrade;

import com.dy.common.softUpgrade.state.UpgradeInfo;
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.springUtil.SpringContextUtil;
import com.dy.common.util.Callback;
import com.dy.common.util.DateTime;
import com.dy.common.util.ThreadJob;
import com.dy.rtuMw.web.webRequest.WebRequestDeal;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

import java.util.List;

@@ -9,7 +19,9 @@
 * @Date: 2024/11/4 16:03
 * @Description
 */
public class UpgradeManager {
public class UpgradeManager extends ThreadJob implements Callback {

    private static final Logger log = LogManager.getLogger(UpgradeManager.class.getName());

    private static final UpgradeManager INSTANCE = new UpgradeManager();

@@ -17,9 +29,6 @@
    private Integer ugMaxRtuSameTime ;//同时升级RTU最大个数

    private UpgradeTask task ;//升级任务

    private boolean taskIsOver = false ;//升级任务是否结束
    private int triggerTimes = 0 ;//连接触发次数

    private UpgradeManager(){}

@@ -32,46 +41,33 @@
     */
    public void initOption(UpgradeUnitConfigVo configVo) {
        this.failTryTimes = configVo.failTryTimes;
        this.ugMaxRtuSameTime = configVo.ugMaxRtuSameTime;
        this.ugMaxRtuSameTime = configVo.ugMaxRtuAtOnce;
    }

    /**
     * è®¾ç½®å‡çº§ä»»åŠ¡
     * @param softFileName å‡çº§ç¨‹åºæ–‡ä»¶å
     * @param softStoreAddr å‡çº§ç¨‹åºå­˜æ”¾åœ°å€
     * @param softStartAddr ç¨‹åºè¦†ç›–起始地址
     * @param softFileData å‡çº§ç¨‹åºå­—节数组
     * @param softBytesCalculate å‡çº§ç¨‹åºå­—节数(按公式计算)
     * @param rtuAddrList å‡çº§RTU
     * @param vo UpgradeTaskVo å‡çº§ä»»åŠ¡å¯¹è±¡
     * @throws Exception
     */
    public void setUpgradeTask(String softFileName,
                               String softStoreAddr,
                               String softStartAddr,
                               byte[] softFileData,
                               Integer softBytesCalculate,
                               List<String> rtuAddrList) throws Exception {
        if(this.task != null && !this.task.isOver()){
            throw new Exception("当前存在升级任务，请等待当前任务执行完或强制停止当前任务");
        }else{
    public void setUpgradeTask(UpgradeTaskVo vo) throws Exception {
        if(this.task != null && !this.task.taskIsOver){
            throw new Exception("当前存在升级任务，请等待当前任务执行完或强制结束当前任务");
        }else {
            this.task.forceOver();
            this.task = new UpgradeTask();
            this.task.initOption(this.failTryTimes, this.ugMaxRtuSameTime);
            this.task.setTask(softFileName,
                    softStoreAddr,
                    softStartAddr,
                    softFileData,
                    softBytesCalculate,
                    rtuAddrList);
            this.task.setTask(vo);
            this.start(this);
        }
    }

    /**
     * åœæ­¢å½“前升级任务
     * ç»“束当前升级任务
     * @throws Exception
     */
    public void stopUpgradeTask() throws Exception {
    public void overUpgradeTask() throws Exception {
        if(this.task != null){
            this.stop();
            this.task.forceOver();
        }
        this.task = null ;
@@ -83,20 +79,11 @@
     * @param code
     * @param protocolName
     * @param protocolVersion
     * @param callback
     * @param callbackCom
     */
    public void trigger(String rtuAddr, String code, String protocolName, Short protocolVersion, Callback callback){
        if(task != null && !taskIsOver){
            triggerTimes ++ ;
            if(triggerTimes == 100){
                triggerTimes = 0 ;
                if(this.task.isOver()){
                    taskIsOver = true ;
                }
            }
            if(!taskIsOver){
                this.task.trigger(rtuAddr, code, protocolName, protocolVersion, callback);
            }
    public void trigger(String rtuAddr, String code, String protocolName, Short protocolVersion, Callback callbackCom){
        if(task != null && !task.taskIsOver){
            this.task.trigger(rtuAddr, code, protocolName, protocolVersion, callbackCom);
        }
    }

@@ -122,7 +109,7 @@
     * @param rtuAddr
     * @return
     */
    public UpgradeRtu upgradeInfos(String rtuAddr){
    public UpgradeRtu upgradeRtuInfo(String rtuAddr){
        if(task != null){
            return task.upgradeInfos(rtuAddr) ;
        }else{
@@ -135,7 +122,7 @@
     * @param rtuAddrList
     * @return
     */
    public List<UpgradeRtu> upgradeInfos(List<String> rtuAddrList){
    public List<UpgradeRtu> upgradeRtuInfos(List<String> rtuAddrList){
        if(task != null){
            return task.upgradeInfos(rtuAddrList) ;
        }else{
@@ -144,4 +131,124 @@
    }


    /**
     * Rtu升级信息
     * @return
     */
    public List<UpgradeRtu> upgradeRtuInfoAll(){
        if(task != null){
            return task.upgradeInfoAll() ;
        }else{
            return null ;
        }
    }


    ////////////////////////////////////////////////////
    //
    // å‡çº§æœåŠ¡å·¥ä½œçº¿ç¨‹æ‰§è¡Œçš„方法
    // ç»Ÿè®¡çŠ¶æ€ + çŠ¶æ€é€šçŸ¥
    //
    ////////////////////////////////////////////////////
    @Override
    public Object execute() throws Exception {
        boolean first = true ;
        while (true){
            if(this.isStop()){
                break ;
            }
            if(first){
                try{
                    //首次启动，停1秒
                    Thread.sleep(1000L);
                }catch (Exception e){
                }
            }else{
                try{
                    //停X毫秒
                    Thread.sleep(UpgradeUnit.confVo.notifyStateInterval);
                }catch (Exception e){
                }
            }
            if(this.task == null
                    || this.task.taskVo == null
                    || this.task.taskVo.rtuAddrList == null
                    || this.task.taskVo.rtuAddrList.size() == 0){
                //任务为空
                break ;
            }else{
                if(!this.task.taskIsOver){
                    //升级任务未完成
                    //工作1：统计当前正在升级的RTU数量，为受限同时升级数量做准备
                    this.task.statisticsRunningRtuCount() ;

                    //工作2：统计需要升级但当前离线RTU的情况
                    this.task.statisticsOffRtuCountAndSet() ;

                    //工作3：统计是否全部升级完成
                    this.task.taskIsOver = this.task.statisticsIsAllOver() ;

                    if(this.task.taskIsOver){
                        if(!this.task.taskOverType.equals(UpgradeTask.TaskOverType_Force)){
                            //任务不是强制结束的
                            this.task.taskOverType = UpgradeTask.TaskOverType_Natural ;//任务完成方式（自然，强制）
                            this.task.taskOverDt = DateTime.yyyy_MM_dd_HH_mm_ss() ;//任务完成时间(yyyy-mm-dd HH:MM:SS)
                        }
                        //任务完成，执行最后一次升级状态通知
                        //工作4：升级状态通知
                        if(!first){
                            this.notifyUpgradeStatus() ;
                        }
                    }else{
                        //任务未完成，继续执行升级状态通知
                        //工作4： å‡çº§çŠ¶æ€é€šçŸ¥
                        if(!first){
                            this.notifyUpgradeStatus() ;
                        }
                    }
                }else{
                    //任务已经完成
                    this.stop();
                }
            }
            if(first){
                first = false ;
            }
        }
        return true ;
    }

    /**
     * å‡çº§çŠ¶æ€é€šçŸ¥
     */
    private void notifyUpgradeStatus(){
        if(this.task.taskVo.callbackWebUrl != null && this.task.taskVo.callbackWebUrl.length() > 0){
            UpgradeInfo info = new UpgradeInfo() ;
            info.ugTaskId = this.task.taskVo.id ;//任务ID
            info.ugOverallState = this.currentUpgradeState() ;
            info.ugRtuStateList = this.upgradeRtuInfoAll() ;
            WebRequestDeal deal = SpringContextUtil.getBean(WebRequestDeal.class) ;
            deal.deal(this.task.taskVo.callbackWebUrl, info);
        }
    }

    ////////////////////////////////////////////////////
    //
    // å‡çº§çŠ¶æ€é€šçŸ¥å·¥ä½œçº¿ç¨‹æ‰§è¡Œå®ŒæˆåŽå›žè°ƒçš„方法，
    // ä¹Ÿå°±æ˜¯ä¸Šé¢execute方法执行完成返回或抛出异常后，执行下面三个方法
    //
    ////////////////////////////////////////////////////
    @Override
    public void call(Object obj) {
        //线程工作执行完了，obj = Boolean(true)
        this.thread = null ;//赋值为null，使线程对象被垃圾回收器回收
    }
    @Override
    public void call(Object... objs) {
    }
    @Override
    public void exception(Exception e) {
        log.error("远程升级伺服线程发生异常", e);
    }

}

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

File was deleted

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

New file
@@ -0,0 +1,194 @@
package com.dy.rtuMw.server.upgrade;

import com.alibaba.fastjson2.annotation.JSONField;
import com.dy.common.mw.protocol.Command;
import com.dy.common.mw.protocol.CommandType;
import com.dy.common.softUpgrade.Com1601Vo;
import com.dy.common.softUpgrade.state.UpgradeRtu;
import com.dy.common.util.Callback;
import com.dy.common.util.DateTime;
import lombok.Data;

/**
 * @Author: liurunyu
 * @Date: 2024/11/4 15:00
 * @Description
 */
@Data
public class UpgradeRtuDev extends UpgradeRtu {

    @JSONField(serialize = false)
    private UpgradeTask task ;

    private UpgradeRtuDev(){
    }

    public UpgradeRtuDev(UpgradeTask task, String rtuAddr, int totalPackage) {
        super();
        this.task = task ;
        this.rtuAddr = rtuAddr ;
        this.state = STATE_UNSTART ;
        this.totalPackage = totalPackage ;
        this.currentPackage = 0 ;
        this.currentRamAddr = 0 ;
        this.lastDownDt = "" ;
        this.reTryTimes = 0 ;
        this.isOver = false ;
    }

    public UpgradeRtuDev(UpgradeTask task, String rtuAddr, int totalPackage, int state) {
        super();
        this.task = task ;
        this.rtuAddr = rtuAddr ;
        this.state = state ;
        this.totalPackage = totalPackage ;
        this.currentPackage = 0 ;
        this.currentRamAddr = 0 ;
        this.lastDownDt = "" ;
        this.reTryTimes = 0 ;
        this.isOver = false ;
    }

    /**
     * è§¦å‘升级
     * @param code
     * @param softData
     * @param callbackCom
     */
    @Override
    public void trigger(String code, String protocolName, Short protocolVersion, byte[][] softData, Callback callbackCom){
        if(this.state == STATE_OFFLINE || this.state == STATE_UNSTART){
            //当前未开始升级过程，下发升级配置指令
            this.setStateAtCom1601Time();
            callbackCom.call(createCommand1601(protocolName, protocolVersion));
        }else if(this.state == STATE_RUNNING){
            //当前升级过程中
            if(code.equals(UpgradeCode.cd_1601)){
                //下发配置返回
                this.lastDownDt = DateTime.yyyy_MM_dd_HH_mm_ss() ;
                callbackCom.call(createCommand1602(protocolName, protocolVersion, currentPackage, currentRamAddr, softData));//下发数据包指令
            }else if(code.equals(UpgradeCode.cd_1602)){
                //下发数据包返回
                currentPackage++ ;
                currentRamAddr += RAMADDRADD ;
                if(currentPackage < totalPackage){
                    this.lastDownDt = DateTime.yyyy_MM_dd_HH_mm_ss() ;
                    callbackCom.call(createCommand1602(protocolName, protocolVersion, currentPackage, currentRamAddr, softData));
                }else{
                    this.lastDownDt = DateTime.yyyy_MM_dd_HH_mm_ss() ;
                    callbackCom.call(createCommand1603(protocolName, protocolVersion));//下发校验指令
                }
            }else if(code.equals(UpgradeCode.cd_1603)){
                //下发校验返回
                this.isOver = true ;//升级完成
                this.state = STATE_SUCCESS ;
                this.lastDownDt = DateTime.yyyy_MM_dd_HH_mm_ss() ;
                callbackCom.call(createCommand1600(protocolName, protocolVersion));//下发复位指令，此指令无应答
            }else{
                if(!this.isOver){
                    //升级未完成
                    if(this.state == STATE_FAILONE || this.state == STATE_FAIL){
                        //已经是升级失败态
                        if(this.reTryTimes < task.failTryTimes){
                            //重试次数未达到上限，继续重试
                            this.reTryTimes += 1 ;
                            this.setStateAtCom1601Time();
                            callbackCom.call(createCommand1601(protocolName, protocolVersion));//下发配置指令
                        }else{
                            this.isOver = true ;//升级完成
                        }
                    }else{
                        //非升级功能码，如果在升级过程中收到这个功能码的上行数据，说明升级失败了
                        if(currentPackage == 0 || currentPackage == 1){
                            //1包死，升级失败
                            this.state = STATE_FAILONE ;
                        }else{
                            //非1包死，升级失败
                            this.state = STATE_FAIL ;
                        }
                    }
                }else{
                    //升级完成，无业务逻辑
                }
            }
        }else{
            //在其他状态下，不触发任务工作
        }
    }

    /**
     * è®¾ç½®å‘送配置命令时刻的状态
     */
    private void setStateAtCom1601Time(){
        this.state = STATE_RUNNING;
        this.currentPackage = 0 ;
        this.currentRamAddr = 0 ;
        this.isOver = false ;
        this.lastDownDt = DateTime.yyyy_MM_dd_HH_mm_ss() ;
    }

    @Override
    public Command createCommand1601(String protocolName, Short protocolVersion){
        Command com = new Command() ;
        com.id = Command.defaultId ;
        com.type = CommandType.outerCommand ;
        com.rtuAddr = this.rtuAddr ;
        com.code = UpgradeCode.cd_1601 ;
        com.protocol = protocolName ;
        com.protocolVersion = protocolVersion ;
        com.rtuResultSendWebUrl = Command.ignoreRtuResultSendWebUrl ;

        Com1601Vo vo = new Com1601Vo() ;
        vo.softStoreAddr = this.task.taskVo.softStoreAddr ;
        vo.softStartAddr = this.task.taskVo.softStartAddr ;
        vo.totalByte =  this.task.taskVo.softBytesCalculate ;
        vo.softCrc = this.task.taskVo.softByteSrc16;
        com.param = vo ;
        return com ;
    }

    @Override
    public Command createCommand1602(String protocolName, Short protocolVersion, int currentPackage, Integer ramAddr, byte[][] softData){
        Command com = new Command() ;
        com.id = Command.defaultId ;
        com.type = CommandType.outerCommand ;
        com.rtuAddr = this.rtuAddr ;
        com.code = UpgradeCode.cd_1602 ;
        com.protocol = protocolName ;
        com.protocolVersion = protocolVersion ;

        com.param = ramAddr ;

        if(currentPackage < softData.length){
            com.attachment = softData[currentPackage] ;
        }
        com.rtuResultSendWebUrl = Command.ignoreRtuResultSendWebUrl ;
        return com ;
    }

    @Override
    public Command createCommand1603(String protocolName, Short protocolVersion){
        Command com = new Command() ;
        com.id = Command.defaultId ;
        com.type = CommandType.outerCommand ;
        com.rtuAddr = this.rtuAddr ;
        com.code = UpgradeCode.cd_1603 ;
        com.protocol = protocolName ;
        com.protocolVersion = protocolVersion ;
        com.rtuResultSendWebUrl = Command.ignoreRtuResultSendWebUrl ;
        return com ;
    }

    @Override
    public Command createCommand1600(String protocolName, Short protocolVersion){
        Command com = new Command() ;
        com.id = Command.defaultId ;
        com.type = CommandType.outerCommand ;
        com.rtuAddr = this.rtuAddr ;
        com.code = UpgradeCode.cd_1600 ;
        com.protocol = protocolName ;
        com.protocolVersion = protocolVersion ;
        com.rtuResultSendWebUrl = Command.ignoreRtuResultSendWebUrl ;
        return com ;
    }
}

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

File was deleted

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

@@ -2,7 +2,9 @@

import com.alibaba.fastjson2.annotation.JSONField;
import com.dy.common.softUpgrade.parse.HexFileParse;
import com.dy.common.softUpgrade.parse.HexFileVo;
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 lombok.Data;
@@ -17,30 +19,37 @@
@Data
public class UpgradeTask {

    protected static final String TaskOverType_Natural = "自然" ;
    protected static final String TaskOverType_Force = "强制" ;

    @JSONField(serialize = false)
    protected Integer failTryTimes ;//升级失败后，重新偿试升级次数，0表示不重新偿试升级
    @JSONField(serialize = false)
    protected Integer ugMaxRtuSameTime ;//同时升级RTU最大个数

    public String setupDt ;//设置时间(yyyy-mm-dd HH:MM:SS)
    @JSONField(serialize = false)
    private Long setupDtLong ;//设置时间

    public String softFileName ;//升级软件（hex）文件名称
    public String softStoreAddr ;//升级程序存放地址(4字节，8字符HEX字符串)，升级程序在FLASH中存放地址
    public String softStartAddr ;//程序覆盖起始地址(4字节，8字符HEX字符串)，被刷新程序的起始地址高字节在前 ï¼Œä½Žå­—节在后
    public UpgradeTaskVo taskVo ;//升级任务值对象

    @JSONField(serialize = false)
    public byte[][] softData ;//升级程序数据(每包数据是512字节)
    @JSONField(serialize = false)
    public int softByteSrc16;//升级程序校验码 CRC16

    public int softBytesCalculate;//升级程序字节数(按公式计算)

    public List<String> rtuAddrList ;//需要升级的RTU地址集合
    protected byte[][] softFileDataGrp ;//以512字节为单位把升级程序数据分组

    @JSONField(serialize = false)
    public Map<String, UpgradeRtu> upgradeState ;//升级状态
    protected Map<String, UpgradeRtu> upgradeRtus;//升级状态

    public boolean taskIsOver = false ;//任务是否完成
    public String taskOverType = "" ;//任务完成方式（自然，强制）
    public String taskOverDt = "" ;//任务完成时间(yyyy-mm-dd HH:MM:SS)

    ///////////////////////////////////////////////////
    //以下内部控制用
    @JSONField(serialize = false)
    private int curUgRunningRtuTotal = 0 ;//当前正在升级的RTU个数

    public UpgradeTask() {
        this.curUgRunningRtuTotal = 0 ;
    }
    /**
     *  åˆå§‹åŒ–配置信息
@@ -51,70 +60,112 @@
    }
    /**
     * è®¾ç½®å‡çº§ä»»åŠ¡
     * @param softFileName å‡çº§ç¨‹åºæ–‡ä»¶å
     * @param softStoreAddr å‡çº§ç¨‹åºå­˜æ”¾åœ°å€
     * @param softStartAddr ç¨‹åºè¦†ç›–起始地址
     * @param softFileData å‡çº§ç¨‹åºå­—节数组
     * @param softBytesCalculate å‡çº§ç¨‹åºå­—节数(按公式计算)
     * @param rtuAddrList å‡çº§RTU
     * @param taskVo UpgradeTaskVo å‡çº§ä»»åŠ¡å¯¹è±¡
     * @throws Exception
     */
    public void setTask(String softFileName,
                       String softStoreAddr,
                       String softStartAddr,
                       byte[] softFileData,
                       Integer softBytesCalculate,
                       List<String> rtuAddrList) throws Exception {
        if(softFileName == null || softFileName.trim().length() == 0){
    public void setTask(UpgradeTaskVo taskVo) throws Exception {
        if(taskVo.id == null || taskVo.id.trim().length() == 0){
            throw new Exception("升级任务id必须提供") ;
        }
       if(taskVo.softFileName == null || taskVo.softFileName.trim().length() == 0){
            throw new Exception("升级软件（hex）文件名称必须提供") ;
        }
        if(softStoreAddr == null || softStoreAddr.trim().length() != 8){
        if(taskVo.softStoreAddr == null || taskVo.softStoreAddr.trim().length() != 8){
            throw new Exception("升级程序存放地址不合法，必须是8字符（十六进制）的字符串") ;
        }
        if(softStartAddr == null || softStartAddr.trim().length() != 8){
        if(taskVo.softStartAddr == null || taskVo.softStartAddr.trim().length() != 8){
            throw new Exception("程序覆盖起始地址不合法，必须是8字符（十六进制）的字符串") ;
        }
        if(softFileData == null || softFileData.length <= 0){
        if(taskVo.softFileData == null || taskVo.softFileData.length <= 0){
            throw new Exception("升级程序内容必须提供") ;
        }
        if(rtuAddrList == null || rtuAddrList.size() <= 0){
        if(taskVo.softBytesCalculate == null){
            throw new Exception("公式计算升级程序有效序字节数必须提供") ;
        }
       if(taskVo.softByteSrc16 == null){
            throw new Exception("有效升级程序字节数CRC16校验值必须提供") ;
        }
        if(taskVo.rtuAddrList == null || taskVo.rtuAddrList.size() <= 0){
            throw new Exception("升级设备RTU地址必须提供") ;
        }
        if(taskVo.callbackWebUrl == null || taskVo.callbackWebUrl.trim().equals("")){
            throw new Exception("回调网址必须提供") ;
        }
        this.setupDt = DateTime.yyyy_MM_dd_HH_mm_ss() ;
        this.softFileName = softFileName;
        this.softStoreAddr = softStoreAddr;
        this.softStartAddr = softStartAddr;
        this.softBytesCalculate = softBytesCalculate;
        this.rtuAddrList = rtuAddrList;
        this.setupDtLong = System.currentTimeMillis() ;
        this.taskVo = taskVo ;

        this.upgradeState = new HashMap<>();
        if(softFileData != null && softFileData.length >0){
            HexFileVo vo = new HexFileParse().doParse(softFileData);
            this.softData = vo.listByte512.toArray(new byte[0][]);
            this.softByteSrc16 = vo.bytesCrc16 ;
        this.upgradeRtus = new HashMap<>();
        if(taskVo.softFileData != null && taskVo.softFileData.length >0){
            List<byte[]> listBytes = new HexFileParse().splitBytesByUnit512(taskVo.softFileData);
            this.softFileDataGrp = listBytes.toArray(new byte[0][]);
            for(String rtuAddr : this.taskVo.rtuAddrList){
                //此时状态设置成离线状态
                UpgradeRtuDev ugRtu = new UpgradeRtuDev(this, rtuAddr, this.taskVo.softFileData.length, UpgradeRtuDev.STATE_OFFLINE) ;
                this.upgradeRtus.put(rtuAddr, ugRtu) ;
            }
        }
    }
    /**
     * RTU有上行数据了，触发下发升级数据
     * @param rtuAddr
     * @param code
     * @param callback
     * @param callbackCom
     */
    public void trigger(String rtuAddr, String code, String protocolName, Short protocolVersion, Callback callback){
        if(upgradeState != null && upgradeState.size() > 0
                && rtuAddrList != null && rtuAddrList.size() > 0){
            UpgradeRtu info = upgradeState.get(rtuAddr) ;
            if(info == null){
                if(rtuAddrList.contains(rtuAddr)){
                    info = new UpgradeRtu(this, rtuAddr, softData.length) ;
                    upgradeState.put(rtuAddr, info) ;
    public void trigger(String rtuAddr, String code, String protocolName, Short protocolVersion, Callback callbackCom){
        if(this.upgradeRtus != null && this.upgradeRtus.size() > 0
                && this.taskVo.rtuAddrList != null && this.taskVo.rtuAddrList.size() > 0){
            UpgradeRtu ugRtu = this.upgradeRtus.get(rtuAddr) ;
            if(ugRtu == null){
                //根据方法setTask的逻辑，只要RTU在升级之列，此处ugRtuState一定不为null
                //为保险，实现下面逻辑
                if(taskVo.rtuAddrList.contains(rtuAddr)){
                    ugRtu = new UpgradeRtuDev(this, rtuAddr, this.taskVo.softFileData.length) ;
                    upgradeRtus.put(rtuAddr, ugRtu) ;
                }else{
                    //rtu不在升级之列
                    return ;
                }
            }
            if(info != null){
                info.trigger(code, protocolName, protocolVersion, this.softData, callback) ;
            if(ugRtu != null){
                if(ugRtu.isOver){
                    //当前RTU已经升级完成，无需再升级
                    return;
                }else{
                    if(UpgradeUnit.confVo.ugMaxRtuAtOnce > 0){
                        //设置了同时升级的RTU最大数量的限制
                        if(ugRtu.state == UpgradeRtuDev.STATE_OFFLINE){
                            //初始态，说明升级任务设置以来，该RTU第一次上行数据
                            if(this.curUgRunningRtuTotal <= UpgradeUnit.confVo.ugMaxRtuAtOnce){
                                //当前正在升级的RTU数量还未受限
                                ugRtu.trigger(code, protocolName, protocolVersion, this.softFileDataGrp, callbackCom) ;
                            }else{
                                //同时升级的RTU数量受限，等待下次机会
                                //但先表明一下状态
                                ugRtu.state = UpgradeRtuDev.STATE_UNSTART ;
                                return ;
                            }
                        }else if(ugRtu.state == UpgradeRtuDev.STATE_UNSTART){
                            //根据上面逻辑， è¯´æ˜Žå¿…然在线了
                            if(this.curUgRunningRtuTotal <= UpgradeUnit.confVo.ugMaxRtuAtOnce){
                                //当前正在升级的RTU数量还未受限
                                ugRtu.trigger(code, protocolName, protocolVersion, this.softFileDataGrp, callbackCom) ;
                            }else{
                                //同时升级的RTU数量受限，等待下次机会
                                return ;
                            }
                        }else{
                            //RTU已经处于升级过程中
                            ugRtu.trigger(code, protocolName, protocolVersion, this.softFileDataGrp, callbackCom) ;
                        }
                    }else{
                        //没有设置同时升级的RTU最大数量的限制
                         ugRtu.trigger(code, protocolName, protocolVersion, this.softFileDataGrp, callbackCom) ;
                    }
                }
            }else{
                //rtu不在升级之列
                return ;
            }
        }
    }
@@ -123,29 +174,11 @@
     * å¼ºåˆ¶ç»“束升级任务
     */
    public void forceOver(){
        this.rtuAddrList.clear();
        this.upgradeState.clear();
    }

    /**
     * å‡çº§ä»»åŠ¡æ˜¯å¦å®Œæˆ
     * @return
     */
    public boolean isOver() {
        boolean isOver = true ;
        if(upgradeState != null && upgradeState.size() > 0){
            Collection<UpgradeRtu> col = upgradeState.values() ;
            for(UpgradeRtu info : col){
                if(info.state == UpgradeRtu.STATE_UNSTART){
                    isOver = false ;
                    break ;
                }else if(info.state == UpgradeRtu.STATE_RUNNING){
                    isOver = false ;
                    break ;
                }
            }
        }
        return isOver ;
        this.taskIsOver = true ;//强制设置任务完成
        this.taskOverType = TaskOverType_Force ;//任务完成方式（自然，强制）
        this.taskOverDt = DateTime.yyyy_MM_dd_HH_mm_ss() ;//任务完成时间(yyyy-mm-dd HH:MM:SS)
        //this.taskVo.rtuAddrList.clear();
        //this.upgradeState.clear();
    }

    /**
@@ -154,24 +187,26 @@
     */
    public UpgradeState currentUpgradeState() {
        UpgradeState state = new UpgradeState() ;
        if(rtuAddrList != null && rtuAddrList.size() > 0){
            state.rtuTotal = rtuAddrList.size() ;
            if(upgradeState != null && upgradeState.size() > 0){
                Collection<UpgradeRtu> col = upgradeState.values() ;
        if(this.taskVo.rtuAddrList != null && this.taskVo.rtuAddrList.size() > 0){
            state.rtuTotal = this.taskVo.rtuAddrList.size() ;
            if(this.upgradeRtus != null && this.upgradeRtus.size() > 0){
                Collection<UpgradeRtu> col = this.upgradeRtus.values() ;
                for(UpgradeRtu info : col){
                    if(info.state == UpgradeRtu.STATE_UNSTART){
                    if(info.state == UpgradeRtuDev.STATE_OFFLINE){
                        state.offLineTotal ++ ;
                    }else if(info.state == UpgradeRtuDev.STATE_UNSTART){
                        state.unStartTotal ++ ;
                    }else if(info.state == UpgradeRtu.STATE_RUNNING){
                    }else if(info.state == UpgradeRtuDev.STATE_RUNNING){
                        state.runningTotal ++ ;
                    }else if(info.state == UpgradeRtu.STATE_SUCCESS) {
                    }else if(info.state == UpgradeRtuDev.STATE_SUCCESS) {
                        state.successTotal++;
                        state.overTotal++;
                    }else if(info.state == UpgradeRtu.STATE_FAILONE) {
                    }else if(info.state == UpgradeRtuDev.STATE_FAILONE) {
                        state.failOneTotal++;
                        state.failTotal++;
                        state.overTotal++;
                    }else if(info.state == UpgradeRtu.STATE_FAIL) {
                    }else if(info.state == UpgradeRtuDev.STATE_FAIL) {
                        state.failTotal++;
                    }
                    if(info.isOver){
                        state.overTotal++;
                    }
                }
@@ -186,23 +221,84 @@
     * @return
    */
    public UpgradeRtu upgradeInfos(String rtuAddr){
        return upgradeState.get(rtuAddr) ;
        return this.upgradeRtus.get(rtuAddr) ;
    }

    /**
     * Rtu升级信息
     * ä¸€äº›Rtu升级信息
     * @param rtuAddrList
     * @return
     */
    public List<UpgradeRtu> upgradeInfos(List<String> rtuAddrList){
        List<UpgradeRtu> list = new ArrayList<>() ;
        for(String rtuAddr : rtuAddrList){
            UpgradeRtu info = upgradeState.get(rtuAddr) ;
            UpgradeRtu info = this.upgradeRtus.get(rtuAddr) ;
            if(info != null){
                list.add(info) ;
            }
        }
        return list ;
    }
    /**
     * å…¨éƒ¨Rtu升级信息
     * @return
     */
    public List<UpgradeRtu> upgradeInfoAll(){
        if(this.upgradeRtus != null && this.upgradeRtus.size() > 0){
            return this.upgradeRtus.values().stream().toList();
        }else{
            return null ;
        }
    }

    ///////////////////////////////////////////////////////////
    //以下方法为内部服务，不对外提供服务
    ///////////////////////////////////////////////////////////
    /**
     * ç»Ÿè®¡å½“前正在升级的RTU数量，为受限同时升级数量做准备
     */
    protected void statisticsRunningRtuCount(){
        int runningTotal = 0 ;
        Collection<UpgradeRtu> col = this.upgradeRtus.values() ;
        for(UpgradeRtu info : col){
            if(info.state == UpgradeRtu.STATE_RUNNING){
                runningTotal ++ ;
            }
        }
        this.curUgRunningRtuTotal = runningTotal ;
    }

    /**
     * ç»Ÿè®¡éœ€è¦å‡çº§ä½†å½“前离线RTU的情况
     */
    protected void statisticsOffRtuCountAndSet() {
        Long now = System.currentTimeMillis() ;
        if(now - this.setupDtLong > UpgradeUnit.confVo.rtuOffLineWaitDuration){
            //rtu离线，等待其升级的时长(毫秒)，超过配置的最大时长，设置其升级失败，且设置升级任务完成
            if (this.taskVo.rtuAddrList != null && this.taskVo.rtuAddrList.size() > 0) {
                Collection<UpgradeRtu> col = this.upgradeRtus.values() ;
                for(UpgradeRtu info : col){
                    if(info.state == UpgradeRtu.STATE_OFFLINE){
                        info.isOver = true ;
                        info.state = UpgradeRtu.STATE_FAILOFFLINE ;
                    }
                }
            }
        }
    }

    /**
     * ç»Ÿè®¡æ˜¯å¦å‡çº§å…¨éƒ¨ç»“束
     */
    protected boolean statisticsIsAllOver() {
        if (this.taskVo.rtuAddrList != null && this.taskVo.rtuAddrList.size() > 0) {
            Collection<UpgradeRtu> col = this.upgradeRtus.values() ;
            for(UpgradeRtu info : col){
                if(info.isOver == false){
                    return false ;
                }
            }
        }
        return true ;
    }
}

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

@@ -3,9 +3,8 @@
import com.dy.common.mw.UnitAdapterInterface;
import com.dy.common.mw.UnitCallbackInterface;
import com.dy.common.mw.UnitInterface;
import com.dy.common.softUpgrade.state.UpgradeTaskVo;
import com.dy.common.util.Callback;

import java.util.List;

/**
 * @Author: liurunyu
@@ -57,34 +56,19 @@

    @Override
    public void stop(UnitCallbackInterface callback) throws Exception {
        stopUpgradeTask() ;
        overUpgradeTask() ;
    }



    /**
     * è®¾ç½®å‡çº§ä»»åŠ¡
     * @param softFileName å‡çº§ç¨‹åºæ–‡ä»¶å
     * @param softStoreAddr å‡çº§ç¨‹åºå­˜æ”¾åœ°å€
     * @param softStartAddr ç¨‹åºè¦†ç›–起始地址
     * @param softFileData å‡çº§ç¨‹åºå­—节数组
     * @param softBytesCalculate å‡çº§ç¨‹åºå­—节数(按公式计算)
    * @param rtuAddrList å‡çº§RTU
     * @param vo UpgradeTaskVo å‡çº§ä»»åŠ¡å¯¹è±¡
     * @throws Exception
     */
    public void setUpgradeTask(String softFileName,
                               String softStoreAddr,
                               String softStartAddr,
                               byte[] softFileData,
                               Integer softBytesCalculate,
                               List<String> rtuAddrList) throws Exception {
    public void setUpgradeTask(UpgradeTaskVo vo) throws Exception {
        if(manager != null ){
            manager.setUpgradeTask(softFileName,
                    softStoreAddr,
                    softStartAddr,
                    softFileData,
                    softBytesCalculate,
                    rtuAddrList) ;
            manager.setUpgradeTask(vo) ;
        }
    }

@@ -92,9 +76,9 @@
     * åœæ­¢å½“前升级任务
     * @throws Exception
     */
    public void stopUpgradeTask() throws Exception {
    public void overUpgradeTask() throws Exception {
        if(manager != null ){
            manager.stopUpgradeTask() ;
            manager.overUpgradeTask() ;
        }
    }

@@ -118,37 +102,44 @@
    /**
     * å½“前升级状态
     * @return
     */
    public UpgradeState currentUpgradeState() {
        if(manager != null ){
            return manager.currentUpgradeState();
        }
        return null ;
    }
    }*/

    /**
     * Rtu升级信息
     * @param rtuAddr
     * @return
     */
    public UpgradeRtu upgradeInfos(String rtuAddr){
    public UpgradeRtuDev upgradeRtuInfo(String rtuAddr){
        if(manager != null ){
            return manager.upgradeInfos(rtuAddr);
        }
        return null ;
    }
    }*/

    /**
     * Rtu升级信息
     * @param rtuAddrList
     * @return
     */
    public List<UpgradeRtu> upgradeInfos(List<String> rtuAddrList){
    public List<UpgradeRtuDev> upgradeRtuInfos(List<String> rtuAddrList){
        if(manager != null ){
            return manager.upgradeInfos(rtuAddrList);
        }
        return null ;
    }
    }*/

    /**
     * Rtu升级信息
     * @return
    public List<UpgradeRtuDev> upgradeRtuInfoAll(){
        if(manager != null ){
            return manager.upgradeInfoAll();
        }
        return null ;
    }*/

}


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

@@ -9,12 +9,16 @@

    public Boolean showStartInfo ;
    public Boolean enable ;//模块是否启动
    public Integer failTryTimes ;//升级失败后，重新偿试升级次数，0表示不重新偿试升级
    public Integer ugMaxRtuSameTime ;//同时升级RTU最大个数
    public Integer failTryTimes ;//升级失败后（针对的是在线进行了升级下发命令），重新偿试升级次数，0表示不重新偿试升级
    public Integer ugMaxRtuAtOnce;//为了缓解通信中间件的压力，同时支持升级的RTU台数
    public Integer rtuOffLineWaitDuration;//rtu离线，等待其升级的时长(毫秒)，超过这个时间，设置其升级失败，且设置升级任务完成
    public Integer notifyStateInterval;//升级状态通知间隔（毫秒）

    public UpgradeUnitConfigVo(){
        this.enable = false ;
        this.failTryTimes = 0 ;
        this.failTryTimes = 1000000 ;
        this.ugMaxRtuAtOnce = Integer.MAX_VALUE ;
        this.rtuOffLineWaitDuration = 10 * 60 * 60 * 1000 ;
        this.notifyStateInterval = 2000 ;
    }
}

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

@@ -1,5 +1,6 @@
package com.dy.rtuMw.web.com;

import com.dy.common.softUpgrade.state.UpgradeTaskVo;
import com.dy.rtuMw.resource.ResourceUnit;
import com.dy.rtuMw.server.ServerProperties;
import com.dy.rtuMw.server.forTcp.TcpSessionCache;
@@ -11,6 +12,7 @@
import com.dy.common.mw.protocol.CommandType;
import com.dy.common.webUtil.BaseResponse;
import com.dy.common.webUtil.BaseResponseUtils;
import com.dy.rtuMw.server.upgrade.UpgradeUnit;
import jakarta.servlet.ServletOutputStream;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
@@ -142,6 +144,23 @@
        }
    }
    /**
     * æŽ¥æ”¶web系统发来升级任务
     * @param vo
     * @return
     */
    @PostMapping(path = "upgradeRtu", consumes = MediaType.APPLICATION_JSON_VALUE)
    public BaseResponse<Boolean> upgradeRtu(@RequestBody UpgradeTaskVo vo) {
        log.info("收到RTU升级任务：\n" + vo.toString()) ;
        try{
            UpgradeUnit.getInstance().setUpgradeTask(vo);
        }catch (Exception e){
            log.error("设置RTU升级任务时发生异常", e);
            return BaseResponseUtils.buildError("设置RTU升级任务时发生异常" + (e.getMessage() == null?"":("：" + e.getMessage())));
        }
        return BaseResponseUtils.buildSuccess(true);
    }

    /**
     * æŽ¥æ”¶web系统发来的命令
     * @param com
     * @return

 pipIrr-platform/pipIrr-mw/pipIrr-mw-rtu/src/main/java/com/dy/rtuMw/web/comResult/CommandResultDeal.java

@@ -47,6 +47,7 @@
                // é€šè¿‡Post方式调用接口
                response = restTemplate.exchange(url, HttpMethod.POST, httpEntity, WebResponseVo.class);
            } catch (Exception e) {
                log.error("命令结果回调发生异常", e);
                e.printStackTrace();
            }
            //assert response != null;

 pipIrr-platform/pipIrr-mw/pipIrr-mw-rtu/src/main/java/com/dy/rtuMw/web/webRequest/WebRequestDeal.java

New file
@@ -0,0 +1,56 @@
package com.dy.rtuMw.web.webRequest;

import com.dy.common.mw.protocol.Command;
import com.dy.rtuMw.web.comResult.WebResponseVo;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.*;
import org.springframework.http.converter.StringHttpMessageConverter;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.util.UriComponentsBuilder;

import java.nio.charset.StandardCharsets;

/**
 * @Author: liurunyu
 * @Date: 2024/11/11 16:29
 * @Description
 */
@Component()
public class WebRequestDeal {

    private static final Logger log = LogManager.getLogger(WebRequestDeal.class.getName());

    private RestTemplate restTemplate;

    @Autowired
    public void setRestTemplate(RestTemplate restTemplate){
        this.restTemplate = restTemplate ;
    }

    public void deal(String webUrl, Object obj) {
        if (webUrl != null
                && !webUrl.trim().equals("")
                && !webUrl.trim().equals(Command.ignoreRtuResultSendWebUrl)) {
            String url = UriComponentsBuilder.fromUriString(webUrl)
                    .build()
                    .toUriString();
            restTemplate.getMessageConverters().set(1,new StringHttpMessageConverter(StandardCharsets.UTF_8));
            HttpHeaders headers = new HttpHeaders();
            headers.setContentType(MediaType.parseMediaType("application/json;charset=UTF-8"));
            HttpEntity<?> httpEntity = new HttpEntity<>(obj, headers);
            ResponseEntity<WebResponseVo> response = null;
            try {
                // é€šè¿‡Post方式调用接口
                response = restTemplate.exchange(url, HttpMethod.POST, httpEntity, WebResponseVo.class);
            } catch (Exception e) {
                log.error("web访问请求发生异常", e);
            }
            //assert response != null;
        } else {
            log.error("严重错误，web访问的URL为空");
        }
    }
}

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

@@ -56,9 +56,17 @@

    <!-- RTU è½¯ä»¶å‡çº§
    enable: æ¨¡å—是否启动
    failTryTimes：升级失败后，重新偿试升级次数，0表示不重新偿试升级
    failTryTimes：升级失败后（针对的是在线进行了升级下发命令），重新偿试升级次数，当设置为0时表示不重新偿试升级
    ugMaxRtuAtOnce：为了缓解通信中间件的压力，同时支持升级的RTU台数，当设置为0时表示不受限制
    rtuOffLineWaitDuration: rtu离线，等待其升级的时长（秒），超过这个时间，设置其升级失败，且设置升级任务完成
    notifyStateInterval: å‡çº§çŠ¶æ€é€šçŸ¥é—´éš”（秒）
    -->
    <upgrade enable="true" failTryTimes="0" ugMaxRtuSameTime="1000" />
    <upgrade enable="true"
             failTryTimes="1"
             ugMaxRtuAtOnce="1000"
             rtuOffLineWaitDuration="1200"
             notifyStateInterval="2"
    />

    <!--
    æ”¯æŒæ¨¡å—

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

@@ -56,9 +56,17 @@

    <!-- RTU è½¯ä»¶å‡çº§
    enable: æ¨¡å—是否启动
    failTryTimes：升级失败后，重新偿试升级次数，0表示不重新偿试升级
    failTryTimes：升级失败后（针对的是在线进行了升级下发命令），重新偿试升级次数，当设置为0时表示不重新偿试升级
    ugMaxRtuAtOnce：为了缓解通信中间件的压力，同时支持升级的RTU台数，当设置为0时表示不受限制
    rtuOffLineWaitDuration: rtu离线，等待其升级的时长（秒），超过这个时间，设置其升级失败，且设置升级任务完成
    notifyStateInterval: å‡çº§çŠ¶æ€é€šçŸ¥é—´éš”（秒）
    -->
    <upgrade enable="true" failTryTimes="0" ugMaxRtuSameTime="1000" />
    <upgrade enable="true"
             failTryTimes="1"
             ugMaxRtuAtOnce="1000"
             rtuOffLineWaitDuration="1200"
             notifyStateInterval="2"
    />

    <!--
    æ”¯æŒæ¨¡å—

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

@@ -56,9 +56,17 @@

    <!-- RTU è½¯ä»¶å‡çº§
    enable: æ¨¡å—是否启动
    failTryTimes：升级失败后，重新偿试升级次数，0表示不重新偿试升级
    failTryTimes：升级失败后（针对的是在线进行了升级下发命令），重新偿试升级次数，当设置为0时表示不重新偿试升级
    ugMaxRtuAtOnce：为了缓解通信中间件的压力，同时支持升级的RTU台数，当设置为0时表示不受限制
    rtuOffLineWaitDuration: rtu离线，等待其升级的时长（秒），超过这个时间，设置其升级失败，且设置升级任务完成
    notifyStateInterval: å‡çº§çŠ¶æ€é€šçŸ¥é—´éš”（秒）
    -->
    <upgrade enable="true" failTryTimes="0" ugMaxRtuSameTime="1000" />
    <upgrade enable="true"
             failTryTimes="1"
             ugMaxRtuAtOnce="1000"
             rtuOffLineWaitDuration="1200"
             notifyStateInterval="2"
    />

    <!--
    æ”¯æŒæ¨¡å—

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

@@ -56,9 +56,17 @@

    <!-- RTU è½¯ä»¶å‡çº§
    enable: æ¨¡å—是否启动
    failTryTimes：升级失败后，重新偿试升级次数，0表示不重新偿试升级
    failTryTimes：升级失败后（针对的是在线进行了升级下发命令），重新偿试升级次数，当设置为0时表示不重新偿试升级
    ugMaxRtuAtOnce：为了缓解通信中间件的压力，同时支持升级的RTU台数，当设置为0时表示不受限制
    rtuOffLineWaitDuration: rtu离线，等待其升级的时长（秒），超过这个时间，设置其升级失败，且设置升级任务完成
    notifyStateInterval: å‡çº§çŠ¶æ€é€šçŸ¥é—´éš”（秒）
    -->
    <upgrade enable="true" failTryTimes="0" ugMaxRtuSameTime="1000" />
    <upgrade enable="true"
             failTryTimes="1"
             ugMaxRtuAtOnce="1000"
             rtuOffLineWaitDuration="1200"
             notifyStateInterval="2"
    />

    <!--
    æ”¯æŒæ¨¡å—