1、几个测试模块系统的log4j.xml配置中的编码修改； 2、RTU升级模拟器增加命令行设置服务端IP和端口功能； 3、应王江海要求，井电双控协议中...

liurunyu

2024-11-26 bda423b1aae1d5322116511651ae03a54cdcd231

1、几个测试模块系统的log4j.xml配置中的编码修改；
2、RTU升级模拟器增加命令行设置服务端IP和端口功能；
3、应王江海要求，井电双控协议中也实现远程升级功能，因井电双控协议、阀控器协议不同，而双方协议中的升级子协议相同，所以通信中间件做增量开发、适应性修改，以适应这种混合协议情况，同时也提高通信中间件运行效率。

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/channel/tcp/DataDecoder.java

@@ -27,8 +27,9 @@
     *     org.apache.mina.core.buffer.IoBuffer, 
     *     org.apache.mina.filter.codec.ProtocolDecoderOutput)
     */
    @Override
    protected boolean doDecode(IoSession session, IoBuffer in, ProtocolDecoderOutput out) {
        String rtuAddr = (String)session.getAttribute(TcpIoSessionAttrIdIsRtuAddr.sessionArrIdKey) ;
        String rtuAddr = (String)session.getAttribute(TcpIoSessionAttrIdIsRtuAddr.sessionArrRtuAddr) ;
        if(rtuAddr == null){
            //会话未被管理
            //会话管理器中不存在此会话，说明刚建立网络连接，
@@ -52,7 +53,13 @@
        //有一些协议，负责发上线数据，但上线(或心跳)数据中无 Rtu地址，所以这样的数据只能放行，而且不能产生有身份(Rtu地址)的网络会话，即不能把session放入会话缓存中
        //有一些协议，Rtu负责发上线数据，上线数据中有 Rtu地址，所以这样的数据放行后，能产生有身份(Rtu地址)的网络会话，即能把session放入会话缓存中
        //不论何种情形，上线数据的数据量不会很大，一般不会产生断包，所以这里只进行简单断包检查。
        PrefixedDataAvailableStatus dataStatus = this.pdaHandle.forOnLine(in) ;
        PrefixedDataAvailableStatus dataStatus = this.pdaHandle.forOnLine(session, in) ;

        if(dataStatus.protocolName != null && dataStatus.protocolVersion != null){
            session.setAttribute(TcpIoSessionAttrIdIsRtuAddr.sessionArrProtocolName, dataStatus.protocolName) ;
            session.setAttribute(TcpIoSessionAttrIdIsRtuAddr.sessionArrProtocolVersion, dataStatus.protocolVersion) ;
        }

        if(dataStatus.isCompleted() || dataStatus.isAdjoined()){
            //正好或粘包
            this.nextDeal(in, dataStatus.getDataLen(), out) ;
@@ -79,7 +86,7 @@
    @SuppressWarnings("unused")
    private boolean doDecode_data(IoSession session, IoBuffer in, ProtocolDecoderOutput out, String rtuAddr) {
        //非上线数据，可能会出现断包或粘包现象
        PrefixedDataAvailableStatus dataStatus = this.pdaHandle.forUpData(in) ;
        PrefixedDataAvailableStatus dataStatus = this.pdaHandle.forUpData(session, in) ;
        if(dataStatus == null){
            //不可能发生
            log.error("严重错误，Rtu (RTU" + rtuAddr + ")上行数据完整性检查时，返回的对象为空。") ;

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/channel/tcp/PrefixedDataAvailableHandle.java

@@ -1,6 +1,7 @@
package com.dy.common.mw.channel.tcp;

import org.apache.mina.core.buffer.IoBuffer;
import org.apache.mina.core.session.IoSession;

public interface PrefixedDataAvailableHandle {

@@ -9,13 +10,13 @@
     * @param in IoBuffer
     * @return çŠ¶æ€
     */
    PrefixedDataAvailableStatus forOnLine(IoBuffer in) ;
    PrefixedDataAvailableStatus forOnLine(IoSession ioSession,  IoBuffer in) ;
    
    /**
     * é¢„处理上行数据
     * @param in IoBuffer
     * @return çŠ¶æ€
     */
    PrefixedDataAvailableStatus forUpData(IoBuffer in) ;
    PrefixedDataAvailableStatus forUpData(IoSession ioSession, IoBuffer in) ;
    
}

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/channel/tcp/PrefixedDataAvailableStatus.java

@@ -9,6 +9,8 @@
    
    private Integer status ;
    private Integer dataLen ;
    public String protocolName;
    public Short protocolVersion;
    
    public PrefixedDataAvailableStatus(){
        status = null ;
@@ -44,9 +46,11 @@
     * @return çŠ¶æ€
     */
    @SuppressWarnings("unused")
    public PrefixedDataAvailableStatus adjoined(Integer dataLen){
    public PrefixedDataAvailableStatus adjoined(Integer dataLen, String protocolName, Short protocolVersion){
        this.status = status_adjoin ;
        this.dataLen = dataLen ;
        this.protocolName = protocolName ;
        this.protocolVersion = protocolVersion ;
        return this ;
    }
    
@@ -56,9 +60,11 @@
     * @return çŠ¶æ€
     */
    @SuppressWarnings("unused")
    public PrefixedDataAvailableStatus completed(Integer dataLen){
    public PrefixedDataAvailableStatus completed(Integer dataLen, String protocolName, Short protocolVersion){
        this.status = status_complete ;
        this.dataLen = dataLen ;
        this.protocolName = protocolName ;
        this.protocolVersion = protocolVersion ;
        return this ;
    }
    

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/channel/tcp/TcpIoSessionAttrIdIsRtuAddr.java

@@ -7,5 +7,7 @@
 */
public class TcpIoSessionAttrIdIsRtuAddr {

    public static final String sessionArrIdKey = "key_rtuAddr" ; //这个key存储的是Rtu地址
    public static final String sessionArrRtuAddr = "key_rtuAddr" ; //这个key存储的是Rtu地址
    public static final String sessionArrProtocolName = "key_pName" ; //这个key存储的是Rtu协议名称
    public static final String sessionArrProtocolVersion = "key_pVerson" ; //这个key存储的是Rtu协议版本号
}

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/channel/tcp/TcpUnit.java

@@ -30,16 +30,21 @@
    public static TcpUnit getInstance(){
        return instance ;
    }
	

    /**
     * æŠŠIoSession会话的ID属性设置到IoSession属性中
     * æŠŠIoSession会话的ID属性及协议名称版本号设置到IoSession属性中
     * @param session
     * @param rtuAddr
     * @param protocolName
     * @param protocolVersion
     * @throws Exception
     */
    public void setIoSessionArrId(IoSession session, String id) throws Exception {
        session.setAttribute(TcpIoSessionAttrIdIsRtuAddr.sessionArrIdKey, id) ;
    public void setIoSessionArrs(IoSession session, String rtuAddr, String protocolName, Short protocolVersion) throws Exception {
        session.setAttribute(TcpIoSessionAttrIdIsRtuAddr.sessionArrRtuAddr, rtuAddr) ;
        session.setAttribute(TcpIoSessionAttrIdIsRtuAddr.sessionArrProtocolName, protocolName) ;
        session.setAttribute(TcpIoSessionAttrIdIsRtuAddr.sessionArrProtocolVersion, protocolVersion) ;
    }

	
    @Override
    public void setAdapter(UnitAdapterInterface adapter) throws Exception {
        if(adapter == null){

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/AnnotationDriver.java

@@ -10,5 +10,10 @@
     */
    String name() default "" ;

    /**
     * åè®®ç‰ˆæœ¬å·
     */
    short version() default -1 ;

    boolean enable() default true ;
}

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/AnnotationOnLine.java

@@ -13,7 +13,10 @@
     * æ‰€å±žåè®®åç§°
     */
    String protocolName() default "" ;

    /**
     * æ‰€å±žåè®®ç‰ˆæœ¬å·
     */
    short protocolVersion() default -1 ;
    /**
     * é…ç½®æ˜¯å¦å¯åŠ¨
     * @return

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/AnnotationOnLineVo.java

@@ -10,6 +10,10 @@
     * æ‰€å±žåè®®åç§°
     */
    public String protocolName ; 
    /**
     * æ‰€å±žåè®®åç§°
     */
    public short protocolVersion ;
    /**
     * ä¸ºä¼˜å…ˆçº§(从1开始，最小为1，各协议间优先级相差1)，数字越小级别越高。
     * è‹¥æœ‰å¤šä¸ªåè®®ï¼Œå„个协议的上线处理类以优先级进行排序，优先级高的先处理上线数据。
@@ -21,11 +25,13 @@
     * æž„造方法
     * @param clazz ç±»
     * @param protocolName åè®®åç§°
     * @param protocolVersion åè®®ç‰ˆæœ¬å·
     * @param priority ä¼˜å…ˆçº§
     */
    public AnnotationOnLineVo(Class<?> clazz, String protocolName, int priority){
    public AnnotationOnLineVo(Class<?> clazz, String protocolName, short protocolVersion, int priority){
        this.clazz = clazz ;
        this.protocolName = protocolName ;
        this.protocolVersion = protocolVersion ;
        this.priority = priority ;
    }
}

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/AnnotationPrefixedDataAvailable.java

@@ -9,11 +9,14 @@
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface AnnotationPrefixedDataAvailable {
    /**
     * æ‰€å±žåè®®åç§° 
     */
    /**
     * æ‰€å±žåè®®åç§°
     */
    String protocolName() default "" ;

    /**
     * æ‰€å±žåè®®ç‰ˆæœ¬å·
     */
    short protocolVersion() default -1 ;
    /**
     * é…ç½®æ˜¯å¦å¯åŠ¨
     * @return

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/AnnotationPrefixedDataAvailableVo.java

@@ -9,6 +9,10 @@
     * æ‰€å±žåè®®åç§°
     */
    public String protocolName ; 
    /**
     * æ‰€å±žåè®®ç‰ˆæœ¬å·
     */
    public short protocolVersion ;
    /**
     * ä¸ºä¼˜å…ˆçº§(从1开始，最小为1，各协议间优先级相差1)，数字越小级别越高。
     * è‹¥æœ‰å¤šä¸ªåè®®ï¼Œå„个协议的上线处理类以优先级进行排序，优先级高的先处理上线数据。
@@ -33,9 +37,10 @@
     */
    public int errorMaxLength ;
    
    public AnnotationPrefixedDataAvailableVo(Class<?> clazz, String protocolName, int priority, int onLineDataMinLength, int headMinLength, int errorMaxLength){
    public AnnotationPrefixedDataAvailableVo(Class<?> clazz, String protocolName, short protocolVersion, int priority, int onLineDataMinLength, int headMinLength, int errorMaxLength){
        this.clazz = clazz ;
        this.protocolName = protocolName ;
        this.protocolVersion = protocolVersion ;
        this.priority = priority ;
        this.onLineDataMinLength = onLineDataMinLength ;
        this.headMinLength = headMinLength ;

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/AnnotationScan.java

@@ -53,6 +53,8 @@
        Set<Class<?>> driverClasses = reflections.getTypesAnnotatedWith(AnnotationDriver.class);
        if (driverClasses != null && driverClasses.size() > 0) {
            String protocolName;
            short protocolVersion;
            String key ;
            int priority;
            int onLineDataMinLength;
            int headMinLength;
@@ -66,14 +68,18 @@
                if (ann != null) {
                    if (ann.enable()) {
                        protocolName = ann.name();
                        if (!(protocolName.trim().equals(""))) {
                            if (driverMap.containsKey(protocolName)) {
                                throw new Exception("严重错误，协议驱动(名称)" + protocolName + "出现了重复注解！");
                            }
                            driverMap.put(protocolName, new AnnotationDriverVo(clazz));
                        } else {
                        protocolVersion = ann.version() ;
                        if(protocolName == null || protocolName.trim().equals("")){
                            throw new Exception("严重错误，协议驱动名称注解值为空字符串");
                        }
                        if(protocolVersion == -1){
                            throw new Exception("严重错误，协议驱动版本号未配置");
                        }
                        key = protocolName + protocolVersion ;
                        if (driverMap.containsKey(key)) {
                            throw new Exception("严重错误，协议驱动(名称+版本号)" + key + "出现了重复注解！");
                        }
                        driverMap.put(key, new AnnotationDriverVo(clazz));
                    }
                }
            }
@@ -92,6 +98,11 @@
                            throw new Exception("严重错误，上行数据完整性检查所配协议驱动注解值为空字符串");
                        }

                        protocolVersion = ann.protocolVersion();
                        if (protocolVersion == -1) {
                            throw new Exception("严重错误， ä¸Šè¡Œæ•°æ®å®Œæ•´æ€§æ£€æŸ¥æ‰€é…åè®®ç‰ˆæœ¬å·æœªé…ç½®");
                        }

                        priority = ann.priority();
                        if (priority == 0) {
                            throw new Exception("严重错误， ä¸Šè¡Œæ•°æ®å®Œæ•´æ€§æ£€æŸ¥æ‰€é…ä¼˜å…ˆçº§æ³¨è§£ä¸èƒ½ä¸º0");
@@ -101,18 +112,19 @@
                        }

                        onLineDataMinLength = ann.onLineDataMinLength();
                                    /*气象协议为0
                                    if(onLineDataMinLength == 0){
                                        throw new Exception("严重错误， ä¸Šè¡Œæ•°æ®å®Œæ•´æ€§æ£€æŸ¥æ‰€é…ä¸Šçº¿æ•°æ®æœ€å°é•¿åº¦æ³¨è§£ä¸èƒ½ä¸º0") ;
                                    }
                                    */
                        /*气象协议为0
                        if(onLineDataMinLength == 0){
                            throw new Exception("严重错误， ä¸Šè¡Œæ•°æ®å®Œæ•´æ€§æ£€æŸ¥æ‰€é…ä¸Šçº¿æ•°æ®æœ€å°é•¿åº¦æ³¨è§£ä¸èƒ½ä¸º0") ;
                        }
                        */
                        headMinLength = ann.headMinLength();
                                    /*气象协议为0
                                    if(headMinLength == 0){
                                        throw new Exception("严重错误， ä¸Šè¡Œæ•°æ®å®Œæ•´æ€§æ£€æŸ¥æ‰€é…ä¸ŠæŠ¥æ•°æ®çš„头部最小长度注解不能为0") ;
                                    }
                                    */
                        prefixedDataAvailableMap.put(protocolName, new AnnotationPrefixedDataAvailableVo(clazz, protocolName, priority, onLineDataMinLength, headMinLength, ProtocolConstant.errorMaxLength));
                        /*气象协议为0
                        if(headMinLength == 0){
                            throw new Exception("严重错误， ä¸Šè¡Œæ•°æ®å®Œæ•´æ€§æ£€æŸ¥æ‰€é…ä¸ŠæŠ¥æ•°æ®çš„头部最小长度注解不能为0") ;
                        }
                        */
                        key = protocolName + protocolVersion ;
                        prefixedDataAvailableMap.put(key, new AnnotationPrefixedDataAvailableVo(clazz, protocolName, protocolVersion, priority, onLineDataMinLength, headMinLength, ProtocolConstant.errorMaxLength));
                    }
                }
            }
@@ -131,6 +143,11 @@
                            throw new Exception("严重错误，上线数据分析所配协议驱动注解值为空字符串");
                        }

                        protocolVersion = ann.protocolVersion();
                        if (protocolVersion == -1) {
                            throw new Exception("严重错误， ä¸Šçº¿æ•°æ®åˆ†æžæ‰€é…åè®®ç‰ˆæœ¬å·æœªé…ç½®");
                        }

                        priority = ann.priority();
                        if (priority == 0) {
                            throw new Exception("严重错误， ä¸Šçº¿æ•°æ®åˆ†æžæ‰€é…ä¼˜å…ˆçº§æ³¨è§£ä¸èƒ½ä¸º0");
@@ -139,7 +156,8 @@
                            throw new Exception("严重错误， ä¸Šçº¿æ•°æ®åˆ†æžæ‰€é…ä¼˜å…ˆçº§æ³¨è§£(priority)数值" + priority + "重复");
                        }

                        onLineMap.put(protocolName, new AnnotationOnLineVo(clazz, protocolName, priority));
                        key = protocolName + protocolVersion ;
                        onLineMap.put(key, new AnnotationOnLineVo(clazz, protocolName, protocolVersion, priority));
                    }
                }
            }
@@ -204,8 +222,8 @@
                                                   HashMap<String, AnnotationPrefixedDataAvailableVo> prefixedDataAvailableMap){
        Collection<AnnotationPrefixedDataAvailableVo> col = prefixedDataAvailableMap.values();
        for(AnnotationPrefixedDataAvailableVo vo : col){
            if(!driverMap.containsKey(vo.protocolName)){
                return "严重错误，上行数据完整性检查所配驱动名称(" + vo.protocolName + ")在协议驱动中未配置" ;
            if(!driverMap.containsKey(vo.protocolName + vo.protocolVersion)){
                return "严重错误，上行数据完整性检查所配驱动名称(" + (vo.protocolName + vo.protocolVersion) + ")在协议驱动中未配置" ;
            }
        }

@@ -240,8 +258,8 @@
                                    HashMap<String, AnnotationOnLineVo> onLineMap){
        Collection<AnnotationOnLineVo> col = onLineMap.values();
        for(AnnotationOnLineVo vo : col){
            if(!driverMap.containsKey(vo.protocolName)){
                return "严重错误，上线数据分析所配驱动名称(" + vo.protocolName + ")在协议驱动中未配置" ;
            if(!driverMap.containsKey(vo.protocolName + vo.protocolVersion)){
                return "严重错误，上线数据分析所配驱动名称(" + (vo.protocolName + vo.protocolVersion) + ")在协议驱动中未配置" ;
            }
        }


 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/PrefixedDataAvailable.java

@@ -3,6 +3,7 @@
import org.apache.mina.core.buffer.IoBuffer;

import com.dy.common.mw.channel.tcp.PrefixedDataAvailableStatus;
import org.apache.mina.core.session.IoSession;

public interface PrefixedDataAvailable {

@@ -15,10 +16,11 @@
     * @return ä¸æ—¶æœ¬åè®®æ•°æ®æ—¶è¿”回空
     * @throws Exception å¼‚常
     */
    PrefixedDataAvailableStatus forOnLine(IoBuffer in,
            int remain,
            int minDataLength,
            int maxDataLength) throws Exception ;
    PrefixedDataAvailableStatus forOnLine(IoSession ioSession,
                                          IoBuffer in,
                                          int remain,
                                          int minDataLength,
                                          int maxDataLength) throws Exception ;

    /**
     * åˆ†æžä¸Šçº¿åŽ(网络连接后非第一包数据)是否可获得
@@ -29,9 +31,10 @@
     * @return PrefixedDataAvailableStatus
     * @throws Exception å¼‚常
     */
    PrefixedDataAvailableStatus forUpData(IoBuffer in,
            int remain,
            int minDataLength,
            int maxDataLength) throws Exception;
    PrefixedDataAvailableStatus forUpData(IoSession ioSession,
                                          IoBuffer in,
                                          int remain,
                                          int minDataLength,
                                          int maxDataLength) throws Exception;

}

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/PrefixedDataAvailableHandleImp.java

@@ -3,6 +3,7 @@
import java.util.Collection;
import java.util.HashMap;

import com.dy.common.mw.channel.tcp.TcpIoSessionAttrIdIsRtuAddr;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.apache.mina.core.buffer.IoBuffer;
@@ -10,6 +11,7 @@
import com.dy.common.util.ByteUtil;
import com.dy.common.mw.channel.tcp.PrefixedDataAvailableHandle;
import com.dy.common.mw.channel.tcp.PrefixedDataAvailableStatus;
import org.apache.mina.core.session.IoSession;

public class PrefixedDataAvailableHandleImp implements PrefixedDataAvailableHandle {
    
@@ -22,43 +24,63 @@
     * @param in IoBuffer
     * @return PrefixedDataAvailableStatus
     */
    public PrefixedDataAvailableStatus forOnLine(IoBuffer in){
    public PrefixedDataAvailableStatus forOnLine(IoSession ioSession, IoBuffer in){
        int remain = in.remaining() ;
        if(remain == 0){
            return new PrefixedDataAvailableStatus().breaked() ;
        }else{
            try{
                PrefixedDataAvailableStatus pds = null ;
    			
                HashMap<String, AnnotationPrefixedDataAvailableVo> prefixedDataAvailableMap = ProtocolCache.getPrefixedDataAvailableMap() ;
                Collection<AnnotationPrefixedDataAvailableVo> set = prefixedDataAvailableMap.values() ;
                if(set.size() == 0){
                    throw new Exception("上线数据完整性检查时，得到的协议完整性检查类集合为空。") ;
                }
                int priority = ProtocolConstant.firstPriority ;
                PrefixedDataAvailableStatus pds = null ;
                PrefixedDataAvailable pda = null ;

                while(true){
                    Object[] objs = this.getClassObjAndAnnotationVo(priority, set) ;
                    PrefixedDataAvailable pda = (PrefixedDataAvailable)objs[0] ;
                    if(pda == null && priority == ProtocolConstant.firstPriority){
                        throw new Exception("上线数据完整性检查时，未得到优先级为" + priority + "上线数据完整性检查类！") ;
                    }else if(pda == null){
                        //说明上线数据完整性检查类集合已经遍历完了。
                        break ;
                    }
                    //处理完整性检查
                    pds = pda.forOnLine(in, remain, ((AnnotationPrefixedDataAvailableVo)objs[1]).onLineDataMinLength, ((AnnotationPrefixedDataAvailableVo)objs[1]).errorMaxLength) ;
                    //用完对象后，放回池中
                    PrefixedDataAvailablePool.freeInstance(((AnnotationPrefixedDataAvailableVo)objs[1]).clazz, pda);
                    if(pds == null){
                        //说明不是对应的协议数据，需要另外的协议来处理上线
                        //循环继续
                        priority++ ;
                    }else{
                        //停止循环，返回结果
                        break ;
                //从会话缓存得到上次上行数据确定的协议
                String protocolName = (String) ioSession.getAttribute(TcpIoSessionAttrIdIsRtuAddr.sessionArrProtocolName) ;
                Short protocolVersion = (Short) ioSession.getAttribute(TcpIoSessionAttrIdIsRtuAddr.sessionArrProtocolVersion) ;
                //由会话中的协议得到处理类
                //利用缓存的协议，进而对不符合协议的上行数据也能用该协议处理了，例如RTU采用不同数据协议的嵌入式软件升级协议
                //即RTU第一包数据确定下来协议，后面数据都用这个协议处理，那么数据可以变化了，可以不符合第一包数据遵守的协议了
                Object[] objs =  this.getClassObjAndAnnotationVo(protocolName, protocolVersion) ;
                if(objs != null && objs[0] != null && objs[1] != null){
                    pda = (PrefixedDataAvailable)objs[0] ;
                    //处理完整性检查
                    pds = pda.forOnLine(ioSession, in, remain, ((AnnotationPrefixedDataAvailableVo)objs[1]).onLineDataMinLength, ((AnnotationPrefixedDataAvailableVo)objs[1]).errorMaxLength) ;
                    //用完对象后，放回池中
                    PrefixedDataAvailablePool.freeInstance(objs[0].getClass(), pda);
                }
                if(pds == null){
                    //如果会话中缓存的协议未能正确处理
                    HashMap<String, AnnotationPrefixedDataAvailableVo> prefixedDataAvailableMap = ProtocolCache.getPrefixedDataAvailableMap() ;
                    Collection<AnnotationPrefixedDataAvailableVo> set = prefixedDataAvailableMap.values() ;
                    if(set.size() == 0){
                        throw new Exception("上线数据完整性检查时，得到的协议完整性检查类集合为空。") ;
                    }
                }
                    int priority = ProtocolConstant.firstPriority ;

                    while(true){
                        objs = this.getClassObjAndAnnotationVo(priority, set) ;
                        pda = (PrefixedDataAvailable)objs[0] ;
                        if(pda == null && priority == ProtocolConstant.firstPriority){
                            throw new Exception("上线数据完整性检查时，未得到优先级为" + priority + "上线数据完整性检查类！") ;
                        }else if(pda == null){
                            //说明上线数据完整性检查类集合已经遍历完了。
                            break ;
                        }
                        //处理完整性检查
                        pds = pda.forOnLine(ioSession, in, remain, ((AnnotationPrefixedDataAvailableVo)objs[1]).onLineDataMinLength, ((AnnotationPrefixedDataAvailableVo)objs[1]).errorMaxLength) ;
                        //用完对象后，放回池中
                        //2024-11-25下面一行进行了修改
                        //PrefixedDataAvailablePool.freeInstance(((AnnotationPrefixedDataAvailableVo)objs[1]).clazz, pda);
                        PrefixedDataAvailablePool.freeInstance(objs[0].getClass(), pda);
                        if(pds == null){
                            //说明不是对应的协议数据，需要另外的协议来处理上线
                            //循环继续
                            priority++ ;
                        }else{
                            //停止循环，返回结果
                            break ;
                        }
                    }
                }
                if(pds == null){
                    //说明数据不属于任何协议，一般为Rtu数据出错，或网络攻击数据
                    byte[] preByte = new byte[remain];
@@ -82,43 +104,59 @@
     * @param in IoBuffer
     * @return PrefixedDataAvailableStatus
     */
    public PrefixedDataAvailableStatus forUpData(IoBuffer in){
    public PrefixedDataAvailableStatus forUpData(IoSession ioSession, IoBuffer in){
        int remain = in.remaining() ;
        if(remain == 0){
            return new PrefixedDataAvailableStatus().breaked() ;
        }else{
            try{
               PrefixedDataAvailableStatus pds = null ;
    			
                HashMap<String, AnnotationPrefixedDataAvailableVo> prefixedDataAvailableMap = ProtocolCache.getPrefixedDataAvailableMap() ;
                Collection<AnnotationPrefixedDataAvailableVo> set = prefixedDataAvailableMap.values() ;
                if(set.size() == 0){
                    throw new Exception("上线数据完整性检查时，得到的协议集合为空。") ;
                }
                int prority = ProtocolConstant.firstPriority ;
                PrefixedDataAvailableStatus pds = null ;
                PrefixedDataAvailable pda = null ;

                while(true){
                    Object[] objs = this.getClassObjAndAnnotationVo(prority, set) ;
                    PrefixedDataAvailable pda = (PrefixedDataAvailable)objs[0] ;
                    if(pda == null && prority == ProtocolConstant.firstPriority){
                        throw new Exception("上线数据完整性检查时，未得到优先级为" + prority + "上线数据完整性检查类！") ;
                    }else if(pda == null){
                        //说明上线数据完整性检查类集合已经遍历完了。
                        break ;
                    }
                    //处理完整性检查
                    pds = pda.forUpData(in, remain, ((AnnotationPrefixedDataAvailableVo)objs[1]).headMinLength, ((AnnotationPrefixedDataAvailableVo)objs[1]).errorMaxLength) ;
                    //用完对象后，放回池中
                    PrefixedDataAvailablePool.freeInstance(objs[0].getClass(), pda);
                    if(pds == null){
                        //说明不是对应的协议数据，需要另外的协议来处理上线
                        //循环继续
                        prority++ ;
                    }else{
                        //停止循环，返回结果
                        break ;
                    }
                }
                //从会话缓存得到上次上行数据确定的协议
                String protocolName = (String) ioSession.getAttribute(TcpIoSessionAttrIdIsRtuAddr.sessionArrProtocolName) ;
                Short protocolVersion = (Short) ioSession.getAttribute(TcpIoSessionAttrIdIsRtuAddr.sessionArrProtocolVersion) ;
                //由会话中的协议得到处理类
                Object[] objs =  this.getClassObjAndAnnotationVo(protocolName, protocolVersion) ;
                if(objs != null && objs[0] != null && objs[1] != null){
                    pda = (PrefixedDataAvailable)objs[0] ;
                    //处理完整性检查
                    pds = pda.forOnLine(ioSession, in, remain, ((AnnotationPrefixedDataAvailableVo)objs[1]).onLineDataMinLength, ((AnnotationPrefixedDataAvailableVo)objs[1]).errorMaxLength) ;
                    //用完对象后，放回池中
                    PrefixedDataAvailablePool.freeInstance(objs[0].getClass(), pda);
                }
                if(pds == null) {
                    //如果会话中缓存的协议未能正确处理
                    HashMap<String, AnnotationPrefixedDataAvailableVo> prefixedDataAvailableMap = ProtocolCache.getPrefixedDataAvailableMap() ;
                    Collection<AnnotationPrefixedDataAvailableVo> set = prefixedDataAvailableMap.values() ;
                    if(set.size() == 0){
                        throw new Exception("上线数据完整性检查时，得到的协议集合为空。") ;
                    }
                    int priority = ProtocolConstant.firstPriority ;

                    while(true){
                        objs = this.getClassObjAndAnnotationVo(priority, set) ;
                        pda = (PrefixedDataAvailable)objs[0] ;
                        if(pda == null && priority == ProtocolConstant.firstPriority){
                            throw new Exception("上线数据完整性检查时，未得到优先级为" + priority + "上线数据完整性检查类！") ;
                        }else if(pda == null){
                            //说明上线数据完整性检查类集合已经遍历完了。
                            break ;
                        }
                        //处理完整性检查
                        pds = pda.forUpData(ioSession, in, remain, ((AnnotationPrefixedDataAvailableVo)objs[1]).headMinLength, ((AnnotationPrefixedDataAvailableVo)objs[1]).errorMaxLength) ;
                        //用完对象后，放回池中
                        PrefixedDataAvailablePool.freeInstance(objs[0].getClass(), pda);
                        if(pds == null){
                            //说明不是对应的协议数据，需要另外的协议来处理上线
                            //循环继续
                            priority++ ;
                        }else{
                            //停止循环，返回结果
                            break ;
                        }
                    }
                }
                if(pds == null){
                    //说明数据不属于任何协议，一般为Rtu数据出错，或网络攻击数据
                    byte[] preByte = new byte[remain];
@@ -157,5 +195,21 @@
        }
        return new Object[]{obj, rVo} ;
    }
    /**
     * å¾—到处理类对象
     * @param protocolName é€šä¿¡åè®®åç§°
     * @param protocolVersion é€šä¿¡åè®®ç‰ˆæœ¬å·
     * @return Object[]
     * @throws Exception å¼‚常
     */
    private Object[] getClassObjAndAnnotationVo(String protocolName, Short protocolVersion) throws Exception{
        PrefixedDataAvailable obj = null ;
        AnnotationPrefixedDataAvailableVo rVo = null ;
        if(protocolName != null && !protocolName.trim().equals("") && protocolVersion != null){
            rVo =  ProtocolCache.getAnnotationPrefixedDataAvailable(protocolName, protocolVersion) ;
            obj = PrefixedDataAvailablePool.getInstance(rVo.clazz) ;
        }
        return new Object[]{obj, rVo} ;
    }

}

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/PrefixedDataAvailablePool.java

@@ -24,22 +24,21 @@
        List<PrefixedDataAvailable> list = pool.get(className) ;
        if(list == null){
            list = new ArrayList<>() ;
        }else{
            pool.put(className, list) ;
        }else if(list.size() > 0){
            obj = list.get(0) ;
            list.remove(0) ;
        }
        
        if(obj != null){
            list.remove(0) ;
            return obj ;
        }else{
        if(obj == null){
            try {
                obj = (PrefixedDataAvailable)clazz.getDeclaredConstructor().newInstance() ;
                //obj = (PrefixedDataAvailable)clazz.newInstance();
            } catch (Exception e) {
                throw new Exception( "由" + className + "生成实例失败！");
            }
            return obj ;
        }
        return obj ;
    }
    
    /**

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/ProtocolCache.java

@@ -19,17 +19,35 @@
     * åœ¨å•çº¿ç¨‹çŽ¯å¢ƒä¸­è¿è¡Œ
     * é€šè¿‡åè®®é©±åŠ¨çš„类名，得到类单例
     * @param protocolName åè®®åç§°
     * @param protocolVersion åè®®ç‰ˆæœ¬å·
     * @return é©±åŠ¨
     * @throws Exception å¼‚常
     */
    public static Driver getDriver(String protocolName) throws Exception{
        Driver dri = drivers.get(protocolName);
    public static Driver getDriver(String protocolName, short protocolVersion) throws Exception{
        Driver dri = drivers.get(protocolName + protocolVersion) ;
        if(dri == null){
            AnnotationDriverVo vo = driverMap.get(protocolName) ;
            AnnotationDriverVo vo = driverMap.get(protocolName + protocolVersion) ;
            if(vo != null && vo.clazz != null){
                dri = (Driver)vo.clazz.getDeclaredConstructor().newInstance();
                //dri = (Driver)vo.clazz.newInstance() ;
                drivers.put(protocolName, dri) ;
                drivers.put(protocolName + protocolVersion, dri) ;
            }
        }
        return dri ;
    }
    /**
     * åœ¨å•çº¿ç¨‹çŽ¯å¢ƒä¸­è¿è¡Œ
     * é€šè¿‡åè®®é©±åŠ¨çš„类名，得到类单例
     * @param protocolNameVersion åè®®åç§°å’Œç‰ˆæœ¬å·
     * @return é©±åŠ¨
     * @throws Exception å¼‚常
     */
    public static Driver getDriver(String protocolNameVersion) throws Exception{
        Driver dri = drivers.get(protocolNameVersion) ;
        if(dri == null){
            AnnotationDriverVo vo = driverMap.get(protocolNameVersion) ;
            if(vo != null && vo.clazz != null){
                dri = (Driver)vo.clazz.getDeclaredConstructor().newInstance();
                drivers.put(protocolNameVersion, dri) ;
            }
        }
        return dri ;
@@ -79,6 +97,18 @@
        return onLineMap;
    }

    protected AnnotationDriverVo getAnnotationDriver(String protocolName, Short protocolVersion){
        return driverMap.get(protocolName + "" + protocolVersion) ;
    }

    protected static AnnotationPrefixedDataAvailableVo getAnnotationPrefixedDataAvailable(String protocolName, Short protocolVersion){
        return prefixedDataAvailableMap.get(protocolName + "" + protocolVersion) ;
    }

    protected static AnnotationOnLineVo getAnnotationOnLine(String protocolName, Short protocolVersion){
        return onLineMap.get(protocolName + "" + protocolVersion) ;
    }

    /*
    public static void main(String[] args){
        HashMap<String, Integer> mp = new HashMap<>() ;

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/ProtocolUnit.java

@@ -45,17 +45,17 @@
        
        //各个协议驱动类扫描自己的功能码注解
        HashMap<String, AnnotationDriverVo> drivers =  ProtocolCache.getDriverMap() ;
        Collection<String> colDrivers = drivers.keySet() ;
        Collection<String> keys = drivers.keySet() ;
        StringBuilder totalProtocols = new StringBuilder() ;
        for(String protocolName : colDrivers){
        for(String protocolNameVersion : keys){
            if(!totalProtocols.isEmpty()){
                totalProtocols.append("，") ;
            }
            totalProtocols.append(protocolName) ;
            Driver dri = ProtocolCache.getDriver(protocolName) ;
            totalProtocols.append(protocolNameVersion) ;
            Driver dri = ProtocolCache.getDriver(protocolNameVersion) ;
            if(dri != null){
                dri.scanAnnotationCode();
                dri.setNotify(adapter.getSingleRtuInfoNotify(protocolName));
                dri.setNotify(adapter.getSingleRtuInfoNotify(protocolNameVersion));
            }
        }
        if(adapter.getConfig().showStartInfo){

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/ProtocolUnitAdapter.java

@@ -12,10 +12,10 @@

    /**
     * å•çº¿ç¨‹çŽ¯å¢ƒä¸­è¿è¡Œï¼Œå¾—到单个RTU信息通知器
     * @param protocolName åè®®åç§°
     * @param protocolNameVersion åè®®åç§°å’Œç‰ˆæœ¬å·
     * @return MidResultAction
     */
    Notify getSingleRtuInfoNotify(String protocolName) ;
    Notify getSingleRtuInfoNotify(String protocolNameVersion) ;
    /**
     * å•çº¿ç¨‹çŽ¯å¢ƒä¸­è¿è¡Œï¼Œå¾—到单个处理RTU下行数据的action执行对象
     * @param protocolName åè®®åç§°

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V1/CommonV1.java

@@ -1,12 +1,16 @@
package com.dy.common.mw.protocol.p206V1;

import com.dy.common.mw.channel.tcp.TcpIoSessionAttrIdIsRtuAddr;
import com.dy.common.util.ByteUtil;
import com.dy.common.util.ByteUtilUnsigned;
import com.dy.common.util.CRC16;
import com.dy.common.util.CRC8_for_2_0;
import org.apache.mina.core.session.IoSession;


public class CommonV1 {


    /**
     * æ£€æŸ¥å¤´
     * @param bs ä¸Šè¡Œå­—节数组

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V1/DriverV1.java

@@ -3,7 +3,9 @@
import com.dy.common.mw.protocol.*;
import com.dy.common.util.DateTime;

@AnnotationDriver(enable = true, name= ProtocolConstantV206V1.protocolName)
@AnnotationDriver(enable = true,
        name= ProtocolConstantV206V1.protocolName,
        version= ProtocolConstantV206V1.protocolVer)
public class DriverV1 extends Driver {
    
    private static String scanRootPackage = "com.dy.common.mw.protocol.p206V1" ;

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V1/OnLineV1.java

@@ -6,6 +6,7 @@
@AnnotationOnLine(
        enable = true,
        protocolName = ProtocolConstantV206V1.protocolName,
        protocolVersion = ProtocolConstantV206V1.protocolVer,
        priority = ProtocolConstantV206V1.priority)
@SuppressWarnings("unused")
public class OnLineV1 implements OnLine{

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V1/PrefixedDataAvailableV1.java

@@ -8,11 +8,13 @@
import org.apache.logging.log4j.Logger;
import org.apache.mina.core.buffer.BufferDataException;
import org.apache.mina.core.buffer.IoBuffer;
import org.apache.mina.core.session.IoSession;


@AnnotationPrefixedDataAvailable(
        enable = true,
        protocolName = ProtocolConstantV206V1.protocolName,
        protocolVersion = ProtocolConstantV206V1.protocolVer,
        priority = ProtocolConstantV206V1.priority,
        onLineDataMinLength = ProtocolConstantV206V1.onLineDataMinLength,
        headMinLength = ProtocolConstantV206V1.headMinLength)
@@ -22,7 +24,7 @@
    private static final Logger log = LogManager.getLogger(PrefixedDataAvailableV1.class) ;
    
    private static final String protocolName = ProtocolConstantV206V1.protocolName ;

    private static final short protocolVersion = ProtocolConstantV206V1.protocolVer ;

    /**
     * åˆ†æžä¸Šçº¿æ•°æ®(网络连接后第一包数据)是否可获得
@@ -33,11 +35,12 @@
     * @return ä¸æ˜¯æœ¬åè®®æ•°æ®æ—¶è¿”回空
     * @throws Exception å¼‚常
     */
    public PrefixedDataAvailableStatus forOnLine(IoBuffer in, 
            int remain,
            int minDataLength,
            int maxDataLength
            ) throws Exception {
    public PrefixedDataAvailableStatus forOnLine(IoSession ioSession,
                                                 IoBuffer in,
                                                 int remain,
                                                 int minDataLength,
                                                 int maxDataLength
                                                 ) throws Exception {
        
        int oldPosition = in.position() ;
        byte[] preByte = new byte[remain];
@@ -45,7 +48,7 @@
        //in.position(0) ;//错误用法，如果发生粘包数据，将会死循环
        in.position(oldPosition) ;

        return this.doForData(preByte, minDataLength, maxDataLength) ;
        return this.doForData(ioSession, preByte, minDataLength, maxDataLength) ;
    }

    /**
@@ -58,28 +61,30 @@
     * @throws Exception å¼‚常
     */
    @Override
    public PrefixedDataAvailableStatus forUpData(IoBuffer in, 
            int remain,
            int minDataLength,
            int maxDataLength) throws Exception {
    public PrefixedDataAvailableStatus forUpData(IoSession ioSession,
                                                 IoBuffer in,
                                                 int remain,
                                                 int minDataLength,
                                                 int maxDataLength) throws Exception {
        int oldPosition = in.position() ;
        byte[] preByte = new byte[remain];
        in.get(preByte) ;
        //in.position(0) ;//错误用法，如果发生粘包数据，将会死循环
        in.position(oldPosition) ;
        
        return this.doForData(preByte, minDataLength, maxDataLength) ;
        return this.doForData(ioSession, preByte, minDataLength, maxDataLength) ;

    }
    /**
     * è¿›è¡Œåˆ¤æ–­
     * @param ioSession ioSession
     * @param preByte byte[]
     * @param minDataLength æœ€å°æ•°æ®é•¿åº¦
     * @param maxDataLength æœ€å¤§æ•°æ®é•¿åº¦
     * @return PrefixedDataAvailableStatus
     * @throws Exception å¼‚常
     */
    private PrefixedDataAvailableStatus doForData(byte[] preByte, int minDataLength, int maxDataLength) throws Exception{
    private PrefixedDataAvailableStatus doForData(IoSession ioSession, byte[] preByte, int minDataLength, int maxDataLength) throws Exception{
        int remain = preByte.length ;
        
        if (remain < minDataLength) {
@@ -114,11 +119,11 @@
        
        if(remain == dataLen){
            //不断不粘
            return new PrefixedDataAvailableStatus().completed(dataLen) ;
            return new PrefixedDataAvailableStatus().completed(dataLen, protocolName, protocolVersion) ;
        }else if(remain > dataLen){
            String headHex = ByteUtil.bytes2Hex(preByte, true) ;
            log.warn("收到数据之帧前部：" + headHex + "，但发生粘包现象。") ;
            return new PrefixedDataAvailableStatus().adjoined(dataLen) ;
            return new PrefixedDataAvailableStatus().adjoined(dataLen, protocolName, protocolVersion) ;
        }else{
            // remain < dataLen
            String headHex = ByteUtil.bytes2Hex(preByte, true) ;

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V1/ProtocolConstantV206V1.java

@@ -5,7 +5,7 @@
     * æ³¨è§£ç›¸å…³
     */
    public static final String protocolName = "p206V1" ;
    public static final Short protocolVer = 1 ;
    public static final short protocolVer = 1 ;
    public static final int priority = 2 ;//优先级
    /**
     * RTU上线数据（上线后第一包数据）最小长度，设置该属性以备进行完整性检查，

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V2/CommonV2.java

@@ -1,12 +1,24 @@
package com.dy.common.mw.protocol.p206V2;

import com.dy.common.mw.channel.tcp.TcpIoSessionAttrIdIsRtuAddr;
import com.dy.common.mw.protocol.p206V1.ProtocolConstantV206V1;
import com.dy.common.util.ByteUtil;
import com.dy.common.util.ByteUtilUnsigned;
import com.dy.common.util.CRC16;
import com.dy.common.util.CRC8_for_2_0;
import org.apache.mina.core.session.IoSession;


public class CommonV2 {

    /**
     * åœ¨Io会话中设置协议名称及版本号
     * @param ioSession ä¼šè¯
     */
    public void setThisProtocolArr2IoSession(IoSession ioSession){
        ioSession.setAttribute(TcpIoSessionAttrIdIsRtuAddr.sessionArrProtocolName, ProtocolConstantV206V1.protocolName) ;
        ioSession.setAttribute(TcpIoSessionAttrIdIsRtuAddr.sessionArrProtocolName, ProtocolConstantV206V1.protocolVer) ;
    }
    /**
     * æ£€æŸ¥å¤´
     * @param bs ä¸Šè¡Œå­—节数组
@@ -20,7 +32,7 @@
                && bs[ProtocolConstantV206V2.headFlag1Index] == ProtocolConstantV206V2.P_Head_Byte
                && bs[ProtocolConstantV206V2.headFlag2Index] == ProtocolConstantV206V2.P_Head_Byte){
            Short vs = this.parseVersion(bs) ;
            if(vs.shortValue() == ProtocolConstantV206V2.protocolVer.shortValue()){
            if(vs.shortValue() == ProtocolConstantV206V2.protocolVer){
                return new Boolean[]{true, true};
            }else{
                return new Boolean[]{false, true};
@@ -159,6 +171,19 @@
    }

    /**
     * åˆ†æžåŠŸèƒ½ç 
     * @param bs ä¸Šè¡Œå­—节数组
     * @return åŠŸèƒ½ç 
     */
    public String parseCode(byte[] bs, boolean p206TrueUgFalse){
        if(p206TrueUgFalse) {
            return ByteUtil.bytes2Hex(bs, false, ProtocolConstantV206V1.codeIndex, 1);
        }else{
            return ByteUtil.bytes2Hex(bs, false, ProtocolConstantV206V1.UG_codeIndex, 2);
        }
    }

    /**
     * æ ¡éªŒå’Œæ£€æŸ¥
     * @param bs  ä¸Šè¡Œå­—节数组
     * @return é€šè¿‡null，未通过返回原因
@@ -175,6 +200,33 @@
    }


    /**
     * æ ¡éªŒå’Œæ£€æŸ¥
     * @param bs  ä¸Šè¡Œå­—节数组
     * @param p206TrueUgFalse 206协议为true，升级协议为false
     * @return é€šè¿‡null，未通过返回原因
     * @throws Exception å¼‚常
     */
    public String checkCrc_str(byte[] bs, boolean p206TrueUgFalse) throws Exception {
        if(p206TrueUgFalse){
            byte crcCompute = (byte)new CRC8_for_2_0().CRC8(bs, ProtocolConstantV206V1.ctrlIndex, bs.length - 3) ;
            byte crcInBs = bs[bs.length - 2] ;
            if(crcCompute == crcInBs){
                return null ;
            }else{
                return "计算CRC是:" + crcCompute + "，上传CRC是" + crcInBs ;
            }
        }else{
            short crcCompute = new CRC16().CRC(bs, 0, bs.length - 4) ;
            short crcInBs = ByteUtil.bytes2Short_BE(bs,bs.length - 3) ;
            //int crcInBs = ByteUtilUnsigned.bytes2Short_BE(bs, bs.length - 3) ;
            if(crcCompute == crcInBs){
                return null ;
            }else{
                return "计算CRC是:" + crcCompute + "，上传CRC是" + crcInBs ;
            }
        }
    }
    /*
    æž„造控制域
    D7                  D6                  D5～D4            D3～D0

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V2/DriverV2.java

@@ -3,7 +3,9 @@
import com.dy.common.mw.protocol.*;
import com.dy.common.util.DateTime;

@AnnotationDriver(enable = true, name= ProtocolConstantV206V2.protocolName)
@AnnotationDriver(enable = true,
        name= ProtocolConstantV206V2.protocolName,
        version= ProtocolConstantV206V2.protocolVer)
public class DriverV2 extends Driver {
    
    private static String scanRootPackage = "com.dy.common.mw.protocol.p206V2" ;
@@ -60,13 +62,15 @@
        Short protocolVersion = null ;
        try{
            CommonV2 cp = new CommonV2() ;
            Boolean p206TrueUgFalse = cp.protocolType_p206TrueUgFalse(upBuffer) ;
            //到此处了，p206TrueUgFalse不可能为空了
            cp.checkTail(upBuffer) ;
            String crcStr = cp.checkCrc_str(upBuffer) ;
            String crcStr = cp.checkCrc_str(upBuffer, p206TrueUgFalse) ;
            if(crcStr != null){
                return new MidResult[]{(new MidResultError(ProtocolConstantV206V2.protocolName, rtuAddr, "严重错误，上行数据CRC检查失败，" + crcStr, null))} ;
            }
            protocolVersion = cp.parseVersion(upBuffer) ;
            upCode = cp.parseCode(upBuffer) ;
            upCode = cp.parseCode(upBuffer, p206TrueUgFalse) ;
            if(upCode == null){
                return new MidResult[]{(new MidResultError(ProtocolConstantV206V2.protocolName, rtuAddr, "严重错误，未能从上行数据中解析出功能码！", null))} ;
            }

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V2/OnLineV2.java

@@ -2,11 +2,11 @@

import com.dy.common.mw.protocol.AnnotationOnLine;
import com.dy.common.mw.protocol.OnLine;
import com.dy.common.mw.protocol.p206V1.ProtocolConstantV206V1;

@AnnotationOnLine(
        enable = true,
        protocolName = ProtocolConstantV206V2.protocolName,
        protocolVersion = ProtocolConstantV206V2.protocolVer,
        priority = ProtocolConstantV206V2.priority)
@SuppressWarnings("unused")
public class OnLineV2 implements OnLine{

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V2/PrefixedDataAvailableV2.java

@@ -8,11 +8,13 @@
import org.apache.logging.log4j.Logger;
import org.apache.mina.core.buffer.BufferDataException;
import org.apache.mina.core.buffer.IoBuffer;
import org.apache.mina.core.session.IoSession;


@AnnotationPrefixedDataAvailable(
        enable = true,
        protocolName = ProtocolConstantV206V2.protocolName,
        protocolVersion = ProtocolConstantV206V2.protocolVer,
        priority = ProtocolConstantV206V2.priority,
        onLineDataMinLength = ProtocolConstantV206V2.onLineDataMinLength,
        headMinLength = ProtocolConstantV206V2.headMinLength)
@@ -22,7 +24,7 @@
    private static final Logger log = LogManager.getLogger(PrefixedDataAvailableV2.class) ;
    
    private static final String protocolName = ProtocolConstantV206V2.protocolName ;

    private static final short protocolVersion = ProtocolConstantV206V2.protocolVer ;

    /**
     * åˆ†æžä¸Šçº¿æ•°æ®(网络连接后第一包数据)是否可获得
@@ -33,11 +35,12 @@
     * @return ä¸æ˜¯æœ¬åè®®æ•°æ®æ—¶è¿”回空
     * @throws Exception å¼‚常
     */
    public PrefixedDataAvailableStatus forOnLine(IoBuffer in, 
            int remain,
            int minDataLength, //对应ProtocolConstantV2_0.onLineDataMinLength
            int maxDataLength //对应ProtocolConstant.errorMaxLength
            ) throws Exception {
    public PrefixedDataAvailableStatus forOnLine(IoSession ioSession,
                                                 IoBuffer in,
                                                 int remain,
                                                 int minDataLength, //对应ProtocolConstantV2_0.onLineDataMinLength
                                                 int maxDataLength //对应ProtocolConstant.errorMaxLength
                                                 ) throws Exception {
        
        int oldPosition = in.position() ;
        byte[] preByte = new byte[remain];
@@ -45,7 +48,7 @@
        //in.position(0) ;//错误用法，如果发生粘包数据，将会死循环
        in.position(oldPosition) ;

        return this.doForData(preByte, minDataLength, maxDataLength) ;
        return this.doForData(ioSession, preByte, minDataLength, maxDataLength) ;
    }

    /**
@@ -58,32 +61,34 @@
     * @throws Exception å¼‚常
     */
    @Override
    public PrefixedDataAvailableStatus forUpData(IoBuffer in, 
            int remain,
            int minDataLength,
            int maxDataLength) throws Exception {
    public PrefixedDataAvailableStatus forUpData(IoSession ioSession,
                                                 IoBuffer in,
                                                 int remain,
                                                 int minDataLength,
                                                 int maxDataLength) throws Exception {
        int oldPosition = in.position() ;
        byte[] preByte = new byte[remain];
        in.get(preByte) ;
        //in.position(0) ;//错误用法，如果发生粘包数据，将会死循环
        in.position(oldPosition) ;
        
        return this.doForData(preByte, minDataLength, maxDataLength) ;
        return this.doForData(ioSession, preByte, minDataLength, maxDataLength) ;

    }
    /**
     * è¿›è¡Œåˆ¤æ–­
     * @param ioSession ioSession
     * @param preByte byte[]
     * @param minDataLength æœ€å°æ•°æ®é•¿åº¦
     * @param maxDataLength æœ€å¤§æ•°æ®é•¿åº¦
     * @return PrefixedDataAvailableStatus
     * @throws Exception å¼‚常
     */
    private PrefixedDataAvailableStatus doForData(byte[] preByte, int minDataLength, int maxDataLength) throws Exception{
    private PrefixedDataAvailableStatus doForData(IoSession ioSession, byte[] preByte, int minDataLength, int maxDataLength) throws Exception{
        int remain = preByte.length ;
        
        if (remain < minDataLength) {
            log.warn("基于协议（" + protocolName + "）判断数据头部发生断包现象。") ;
            log.warn("基于协议（" + (protocolName + protocolVersion) + "）判断数据头部发生断包现象。") ;
            return new PrefixedDataAvailableStatus().breaked() ;
        }
        
@@ -92,7 +97,6 @@
            return new PrefixedDataAvailableStatus().rubbish(remain) ;
        }

		
        CommonV2 parseCommon = new CommonV2();
        Boolean[] isThisProtocolData = parseCommon.isThisProtocolHead(preByte) ;
        if(isThisProtocolData == null || isThisProtocolData.length != 2 || !isThisProtocolData[0].booleanValue()){
@@ -114,11 +118,11 @@
        
        if(remain == dataLen){
            //不断不粘
            return new PrefixedDataAvailableStatus().completed(dataLen) ;
            return new PrefixedDataAvailableStatus().completed(dataLen, protocolName, protocolVersion) ;
        }else if(remain > dataLen){
            String headHex = ByteUtil.bytes2Hex(preByte, true) ;
            log.warn("收到数据之帧前部：" + headHex + "，但发生粘包现象。") ;
            return new PrefixedDataAvailableStatus().adjoined(dataLen) ;
            return new PrefixedDataAvailableStatus().adjoined(dataLen, protocolName, protocolVersion) ;
        }else{
            // remain < dataLen
            String headHex = ByteUtil.bytes2Hex(preByte, true) ;

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V2/ProtocolConstantV206V2.java

@@ -5,7 +5,7 @@
     * æ³¨è§£ç›¸å…³
     */
    public static final String protocolName = "p206V2" ;
    public static final Short protocolVer = 2 ;
    public static final short protocolVer = 2 ;
    public static final int priority = 3 ;//优先级
    /**
     * RTU上线数据（上线后第一包数据）最小长度，设置该属性以备进行完整性检查，

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V2/parse/Cd_1600_Down.java

@@ -1,6 +1,7 @@
package com.dy.common.mw.protocol.p206V2.parse;

import com.dy.common.mw.protocol.*;
import com.dy.common.mw.protocol.p206V1.ProtocolConstantV206V1;
import com.dy.common.mw.protocol.p206V2.CodeV2;
import com.dy.common.mw.protocol.p206V2.ParseParamsForDownV2;
import com.dy.common.mw.protocol.p206V2.ProtocolConstantV206V2;

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V2/parse/Cd_1601_Down.java

@@ -5,6 +5,7 @@
import com.dy.common.mw.protocol.p206V2.ParseParamsForDownV2;
import com.dy.common.mw.protocol.p206V2.ProtocolConstantV206V2;
import com.dy.common.mw.protocol.p206V2.parse.global.GlCreate;
import com.dy.common.softUpgrade.Com1601Vo;
import com.dy.common.util.ByteUtil;

/**
@@ -32,7 +33,7 @@
        midRs.downCodeName = CodeV2.getCodeName(para.commandCode) ;//下行命令功能码名称;
        midRs.downBuffer = bs ;//下行命令数据
        midRs.downBufHex = ByteUtil.bytes2Hex(bs, true) ;//下行命令数据十六进制形式
        midRs.hasResponse = true ;//是否有应答
        midRs.hasResponse = false ;//是否有应答
        midRs.maxSendTimes = null ;//命令最大发送次数(当收不到应答时，将重发)，如果不设置，命令缓存器进行补充设置
        midRs.isCachForOffLine = false ;//RTU不在线，命令是否缓存，低功耗时为true

@@ -71,7 +72,32 @@
        index += 2 ;
        GlCreate.createRtuAddr4PUg(para.rtuAddr, preBytes, index);

        byte[] bytes = ByteUtil.bytesMerge(preBytes, (byte[])para.attachment) ;
        if(para.param == null){
            throw new Exception("参数为空") ;
        }
        if(!(para.param instanceof Com1601Vo)){
            throw new Exception("参数类型非Com1601Vo") ;
        }
        Com1601Vo vo = (Com1601Vo) para.param ;
        byte[] bs = new byte[4] ;
        ByteUtil.hex2Bytes(vo.softStoreAddr, bs, 0) ;
        byte[] bytes = ByteUtil.bytesMerge(preBytes, bs) ;

        bs = new byte[4] ;
        ByteUtil.int2Bytes_BE(bs, vo.totalByte, 0);
        bytes = ByteUtil.bytesMerge(bytes, bs) ;

        bs = new byte[2] ;
        ByteUtil.short2Bytes_BE(bs, (short)vo.softCrc, 0);
        bytes = ByteUtil.bytesMerge(bytes, bs) ;

        bs = new byte[2] ;
        ByteUtil.short2Bytes_BE(bs, (short)vo.softCrc, 0);
        bytes = ByteUtil.bytesMerge(bytes, bs) ;

        bs = new byte[4] ;
        ByteUtil.hex2Bytes(vo.softStartAddr, bs, 0) ;
        bytes = ByteUtil.bytesMerge(bytes, bs) ;

        byte[] bsTail = GlCreate.createCrcTail4Ug(bytes) ;//CRC和尾叠加字节数组中


 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V2/parse/Cd_1602_Down.java

@@ -32,7 +32,7 @@
        midRs.downCodeName = CodeV2.getCodeName(para.commandCode) ;//下行命令功能码名称;
        midRs.downBuffer = bs ;//下行命令数据
        midRs.downBufHex = ByteUtil.bytes2Hex(bs, true) ;//下行命令数据十六进制形式
        midRs.hasResponse = true ;//是否有应答
        midRs.hasResponse = false ;//是否有应答
        midRs.maxSendTimes = null ;//命令最大发送次数(当收不到应答时，将重发)，如果不设置，命令缓存器进行补充设置
        midRs.isCachForOffLine = false ;//RTU不在线，命令是否缓存，低功耗时为true

@@ -70,8 +70,16 @@

        index += 2 ;
        GlCreate.createRtuAddr4PUg(para.rtuAddr, preBytes, index);
        if(para.param == null){
            throw new Exception("参数为空") ;
        }
        Integer ramAddr = (Integer)para.param ;

        byte[] bytes = ByteUtil.bytesMerge(preBytes, (byte[])para.attachment) ;
        byte[] bs = new byte[4] ;
        ByteUtil.int2Bytes_BE(bs, ramAddr, 0);
        byte[] bytes = ByteUtil.bytesMerge(preBytes, bs) ;

        bytes = ByteUtil.bytesMerge(bytes, (byte[])para.attachment) ;

        byte[] bsTail = GlCreate.createCrcTail4Ug(bytes) ;//CRC和尾叠加字节数组中


 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V2/parse/Cd_1603_Down.java

@@ -32,7 +32,7 @@
        midRs.downCodeName = CodeV2.getCodeName(para.commandCode) ;//下行命令功能码名称;
        midRs.downBuffer = bs ;//下行命令数据
        midRs.downBufHex = ByteUtil.bytes2Hex(bs, true) ;//下行命令数据十六进制形式
        midRs.hasResponse = true ;//是否有应答
        midRs.hasResponse = false ;//是否有应答
        midRs.maxSendTimes = null ;//命令最大发送次数(当收不到应答时，将重发)，如果不设置，命令缓存器进行补充设置
        midRs.isCachForOffLine = false ;//RTU不在线，命令是否缓存，低功耗时为true


 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V2/parse/Cd_9601_Up.java

@@ -43,7 +43,7 @@
        midRs.upBuffer = para.upBuffer ;//上行数据字节数组
        midRs.data = para.data ;//解析后的数据

        midRs.reportOrResponse_trueOrFalse = false ;//主动上报
        midRs.reportOrResponse_trueOrFalse = true ;//升级的，不认为是命令应答

        callback.callback(midRs.reportOrResponse_trueOrFalse);
        if(para.data != null && para.data.getSubData() != null){

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V2/parse/Cd_9602_Up.java

@@ -43,7 +43,7 @@
        midRs.upBuffer = para.upBuffer ;//上行数据字节数组
        midRs.data = para.data ;//解析后的数据

        midRs.reportOrResponse_trueOrFalse = false ;//主动上报
        midRs.reportOrResponse_trueOrFalse = true ;//升级的，不认为是命令应答

        callback.callback(midRs.reportOrResponse_trueOrFalse);
        if(para.data != null && para.data.getSubData() != null){

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V2/parse/Cd_9603_Up.java

@@ -43,7 +43,7 @@
        midRs.upBuffer = para.upBuffer ;//上行数据字节数组
        midRs.data = para.data ;//解析后的数据

        midRs.reportOrResponse_trueOrFalse = false ;//主动上报
        midRs.reportOrResponse_trueOrFalse = true ;//升级的，不认为是命令应答

        callback.callback(midRs.reportOrResponse_trueOrFalse);
        if(para.data != null && para.data.getSubData() != null){

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V202404/CodeV202404.java

@@ -42,6 +42,14 @@
    public static final String cd_9C = "9C" ; //黑名单远程强制关闭水泵/阀门
    public static final String cd_C2 = "C2" ; //开关水泵/阀门成功/失败上报

    public static final String cd_1600 = "1600" ;//升级复位
    public static final String cd_1601 = "1601" ;//升级配置
    public static final String cd_1602 = "1602" ;//升级数据
    public static final String cd_1603 = "1603" ;//升级校验
    public static final String cd_9601 = "9601" ;//升级配置
    public static final String cd_9602 = "9602" ;//升级数据
    public static final String cd_9603 = "9603" ;//升级校验

    public static String getCodeName(String code) {
        String name = (code.equals(cd_02) ? "链路检测" :
            (code.equals(cd_10) ? "设置设备终端地址" :
@@ -82,7 +90,14 @@
            (code.equals(cd_9B) ? "清除设备终端注册号" :
            (code.equals(cd_9C) ? "黑名单远程强制关闭水泵/阀门" :
            (code.equals(cd_C2) ? "开关水泵/阀门结果上报" :
            ""))))))))))))))))))))))))))))))))))))))) ;
            (code.equals(cd_1600) ? "升级复位" :
            (code.equals(cd_1601) ? "升级配置" :
            (code.equals(cd_1602) ? "升级数据" :
            (code.equals(cd_1603) ? "升级校验" :
            (code.equals(cd_9601) ? "升级配置" :
            (code.equals(cd_9602) ? "升级数据" :
            (code.equals(cd_9603) ? "升级校验" :
            "")))))))))))))))))))))))))))))))))))))))))))))) ;
        if(name == null || name.equals("")){
            name = code ;
        }

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V202404/CommonV202404.java

@@ -1,11 +1,25 @@
package com.dy.common.mw.protocol.p206V202404;

import com.dy.common.mw.channel.tcp.TcpIoSessionAttrIdIsRtuAddr;
import com.dy.common.mw.protocol.p206V1.ProtocolConstantV206V1;
import com.dy.common.mw.protocol.p206V2.ProtocolConstantV206V2;
import com.dy.common.util.ByteUtil;
import com.dy.common.util.ByteUtilUnsigned;
import com.dy.common.util.CRC16;
import com.dy.common.util.CRC8_for_2_0;
import org.apache.mina.core.session.IoSession;


public class CommonV202404 {

    /**
     * åœ¨Io会话中设置协议名称及版本号
     * @param ioSession ä¼šè¯
     */
    public void setThisProtocolArr2IoSession(IoSession ioSession){
        ioSession.setAttribute(TcpIoSessionAttrIdIsRtuAddr.sessionArrProtocolName, ProtocolConstantV206V1.protocolName) ;
        ioSession.setAttribute(TcpIoSessionAttrIdIsRtuAddr.sessionArrProtocolName, ProtocolConstantV206V1.protocolVer) ;
    }
    /**
     * æ£€æŸ¥å¤´
     * @param bs ä¸Šè¡Œå­—节数组
@@ -39,6 +53,27 @@
        }
    }

    /**
     * æ£€æŸ¥åè®®ç±»åž‹
     * @param bs ä¸Šè¡Œå­—节数组
     * @return åè®®ç±»åž‹
     * @throws Exception å¼‚常
     */
    public Boolean protocolType_p206TrueUgFalse(byte[] bs){
        if(bs == null){
            return null ;
        }else if(bs.length >= (ProtocolConstantV206V202404.ctrlIndex)
                && bs[0] == ProtocolConstantV206V202404.P_Head_Byte
                && bs[2] == ProtocolConstantV206V202404.P_Head_Byte){
            return true ;
        }else if(bs.length >= (ProtocolConstantV206V202404.UG_codeIndex)
                && bs[0] == ProtocolConstantV206V202404.UG_P_Head_Byte
                && bs[3] == ProtocolConstantV206V202404.UG_P_Head_Byte){
            return false ;
        }else{
            return null ;
        }
    }

    /**
     * æ£€æŸ¥å°¾
@@ -77,8 +112,19 @@
     * @return æ•°æ®é•¿åº¦
     * @throws Exception å¼‚常
     */
    public int parseDataLen(byte[] bs)throws Exception{
    public int parseDataLen4P202404(byte[] bs)throws Exception{
        return parseFrameLen(bs) ;
    }

    /**
     * åˆ†æžç”¨æˆ·æ•°æ®åŸŸå­—节数(升级协议)
     * @param bs ä¸Šè¡Œå­—节数组
     * @return æ•°æ®é•¿åº¦
     * @throws Exception å¼‚常
     */
    public int parseDataLen4Ug(byte[] bs)throws Exception{
        int len = ByteUtilUnsigned.bytes2Short_LE(bs, ProtocolConstantV206V2.UG_dataLenIndex_start) ;
        return len - ProtocolConstantV206V2.UG_lenCmd - ProtocolConstantV206V2.UG_lenRtuAddr ;
    }


@@ -125,6 +171,18 @@
    }

    /**
     * åˆ†æžåŠŸèƒ½ç 
     * @param bs ä¸Šè¡Œå­—节数组
     * @return åŠŸèƒ½ç 
     */
    public String parseCode(byte[] bs, boolean p202404TrueUgFalse){
        if(p202404TrueUgFalse) {
            return ByteUtil.bytes2Hex(bs, false, ProtocolConstantV206V202404.codeIndex, 1);
        }else{
            return ByteUtil.bytes2Hex(bs, false, ProtocolConstantV206V202404.UG_codeIndex, 2);
        }
    }
    /**
     * æ ¡éªŒå’Œæ£€æŸ¥
     * @param bs  ä¸Šè¡Œå­—节数组
     * @return é€šè¿‡null，未通过返回原因
@@ -140,6 +198,33 @@
        }
    }

    /**
     * æ ¡éªŒå’Œæ£€æŸ¥
     * @param bs  ä¸Šè¡Œå­—节数组
     * @param p202404TrueUgFalse 202404协议为true，升级协议为false
     * @return é€šè¿‡null，未通过返回原因
     * @throws Exception å¼‚常
     */
    public String checkCrc_str(byte[] bs, boolean p202404TrueUgFalse) throws Exception {
        if(p202404TrueUgFalse){
            byte crcCompute = (byte)new CRC8_for_2_0().CRC8(bs, ProtocolConstantV206V202404.ctrlIndex, bs.length - 3) ;
            byte crcInBs = bs[bs.length - 2] ;
            if(crcCompute == crcInBs){
                return null ;
            }else{
                return "计算CRC是:" + crcCompute + "，上传CRC是" + crcInBs ;
            }
        }else{
            short crcCompute = new CRC16().CRC(bs, 0, bs.length - 4) ;
            short crcInBs = ByteUtil.bytes2Short_BE(bs,bs.length - 3) ;
            //int crcInBs = ByteUtilUnsigned.bytes2Short_BE(bs, bs.length - 3) ;
            if(crcCompute == crcInBs){
                return null ;
            }else{
                return "计算CRC是:" + crcCompute + "，上传CRC是" + crcInBs ;
            }
        }
    }

    /*
    æž„造控制域

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V202404/DriverV202404.java

@@ -2,9 +2,12 @@

import com.dy.common.mw.protocol.*;
import com.dy.common.mw.protocol.p206V1.ProtocolConstantV206V1;
import com.dy.common.mw.protocol.p206V2.ProtocolConstantV206V2;
import com.dy.common.util.DateTime;

@AnnotationDriver(name= ProtocolConstantV206V202404.protocolName)
@AnnotationDriver(enable = true,
        name= ProtocolConstantV206V202404.protocolName,
        version= ProtocolConstantV206V202404.protocolVer)
public class DriverV202404 extends Driver {
    
    private static String scanRootPackage = "com.dy.common.mw.protocol.p206V202404" ;
@@ -58,8 +61,9 @@
        String upCode = null ;
        try{
            CommonV202404 cp = new CommonV202404() ;
            Boolean p202404TrueUgFalse = cp.protocolType_p206TrueUgFalse(upBuffer) ;
            cp.checkTail(upBuffer) ;
            String crcStr = cp.checkCrc_str(upBuffer) ;
            String crcStr = cp.checkCrc_str(upBuffer, p202404TrueUgFalse) ;
            if(crcStr != null){
                return new MidResult[]{(new MidResultError(ProtocolConstantV206V202404.protocolName, rtuAddr, "严重错误，上行数据CRC检查失败，" + crcStr, null))} ;
            }

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V202404/OnLineV202404.java

@@ -4,7 +4,9 @@
import com.dy.common.mw.protocol.OnLine;

@AnnotationOnLine(
        enable = true,
        protocolName = ProtocolConstantV206V202404.protocolName,
        protocolVersion = ProtocolConstantV206V202404.protocolVer,
        priority = ProtocolConstantV206V202404.priority)
@SuppressWarnings("unused")
public class OnLineV202404 implements OnLine{

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V202404/PrefixedDataAvailableV202404.java

@@ -8,10 +8,12 @@
import org.apache.logging.log4j.Logger;
import org.apache.mina.core.buffer.BufferDataException;
import org.apache.mina.core.buffer.IoBuffer;
import org.apache.mina.core.session.IoSession;


@AnnotationPrefixedDataAvailable(
        protocolName = ProtocolConstantV206V202404.protocolName,
        protocolVersion = ProtocolConstantV206V202404.protocolVer,
        priority = ProtocolConstantV206V202404.priority,
        onLineDataMinLength = ProtocolConstantV206V202404.onLineDataMinLength,
        headMinLength = ProtocolConstantV206V202404.headMinLength)
@@ -21,6 +23,7 @@
    private static final Logger log = LogManager.getLogger(PrefixedDataAvailableV202404.class) ;
    
    private static final String protocolName = ProtocolConstantV206V202404.protocolName ;
    private static final short protocolVersion = ProtocolConstantV206V202404.protocolVer ;


    /**
@@ -32,10 +35,11 @@
     * @return ä¸æ˜¯æœ¬åè®®æ•°æ®æ—¶è¿”回空
     * @throws Exception å¼‚常
     */
    public PrefixedDataAvailableStatus forOnLine(IoBuffer in, 
            int remain,
            int minDataLength, //对应ProtocolConstantV2_0.onLineDataMinLength
            int maxDataLength //对应ProtocolConstant.errorMaxLength
    public PrefixedDataAvailableStatus forOnLine(IoSession ioSession,
                                                 IoBuffer in,
                                                 int remain,
                                                 int minDataLength, //对应ProtocolConstantV2_0.onLineDataMinLength
                                                 int maxDataLength //对应ProtocolConstant.errorMaxLength
            ) throws Exception {
        
        int oldPosition = in.position() ;
@@ -44,7 +48,7 @@
        //in.position(0) ;//错误用法，如果发生粘包数据，将会死循环
        in.position(oldPosition) ;

        return this.doForData(preByte, minDataLength, maxDataLength) ;
        return this.doForData(ioSession, preByte, minDataLength, maxDataLength) ;
    }

    /**
@@ -57,28 +61,30 @@
     * @throws Exception å¼‚常
     */
    @Override
    public PrefixedDataAvailableStatus forUpData(IoBuffer in, 
            int remain,
            int minDataLength,
            int maxDataLength) throws Exception {
    public PrefixedDataAvailableStatus forUpData(IoSession ioSession,
                                                 IoBuffer in,
                                                 int remain,
                                                 int minDataLength,
                                                 int maxDataLength) throws Exception {
        int oldPosition = in.position() ;
        byte[] preByte = new byte[remain];
        in.get(preByte) ;
        //in.position(0) ;//错误用法，如果发生粘包数据，将会死循环
        in.position(oldPosition) ;
        
        return this.doForData(preByte, minDataLength, maxDataLength) ;
        return this.doForData(ioSession, preByte, minDataLength, maxDataLength) ;

    }
    /**
     * è¿›è¡Œåˆ¤æ–­
     * @param ioSession ioSession
     * @param preByte byte[]
     * @param minDataLength æœ€å°æ•°æ®é•¿åº¦
     * @param maxDataLength æœ€å¤§æ•°æ®é•¿åº¦
     * @return PrefixedDataAvailableStatus
     * @throws Exception å¼‚常
     */
    private PrefixedDataAvailableStatus doForData(byte[] preByte, int minDataLength, int maxDataLength) throws Exception{
    private PrefixedDataAvailableStatus doForData(IoSession ioSession, byte[] preByte, int minDataLength, int maxDataLength) throws Exception{
        int remain = preByte.length ;
        
        if (remain < minDataLength) {
@@ -114,11 +120,11 @@
        
        if(remain == frameLen){
            //不断不粘
            return new PrefixedDataAvailableStatus().completed(frameLen) ;
            return new PrefixedDataAvailableStatus().completed(frameLen, protocolName, protocolVersion) ;
        }else if(remain > frameLen){
            String headHex = ByteUtil.bytes2Hex(preByte, true) ;
            log.warn("收到数据之帧前部：" + headHex + "，但发生粘包现象。") ;
            return new PrefixedDataAvailableStatus().adjoined(frameLen) ;
            return new PrefixedDataAvailableStatus().adjoined(frameLen, protocolName, protocolVersion) ;
        }else{
            // remain < dataLen
            String headHex = ByteUtil.bytes2Hex(preByte, true) ;

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V202404/ProtocolConstantV206V202404.java

@@ -8,7 +8,7 @@
     * æ³¨è§£ç›¸å…³
     */
    public static final String protocolName = "p206V202404" ;
    public static final Short protocolVer = 201 ;
    public static final short protocolVer = 201 ;
    public static final int priority = 1 ;//优先级
    /**
     * RTU上线数据（上线后第一包数据）最小长度，设置该属性以备进行完整性检查，
@@ -48,4 +48,27 @@
    public static final int codeIndex = 12 ;//功能码字节数组下标
    public static final int dataIndex = 13 ;//具体数据字节数组下标

    ////////////////////////////////////////////////
    //
    //远程升级相关
    //
    ////////////////////////////////////////////////
    public static final byte UG_P_Head_Byte = (byte)0xAA ;
    public static final byte UG_P_Tail_Byte = (byte)0x16 ;
    public static final int UG_codeIndex = 4 ;//功能码字节数组下标
    public static final int UG_dataIndex = 12 ;//具体数据字节数组下标

    public static final int UG_dataLenIndex_start = 1 ;//帧长度开始所在 å­—节数组起始下标
    public static final int UG_dataLenIndex_end = 2 ;//帧长度结束所在 å­—节数组起始下标

    public static final int UG_rtuAddrIndex_start = 6 ;//控制器地址 å­—节数组开始下标
    public static final int UG_rtuAddrIndex_end = 11 ;//控制器地址 å­—节数组开始下标

    public static final byte UG_lenCmd = 2 ; //功能码字节数组长度
    public static final byte UG_lenRtuAddr = 6 ; //功能码字节数组长度
    public static final byte UG_lenHead2Cmd = 4 ; //从头到功能码（不包括）字节数组长度
    public static final byte UG_lenTail = 3 ; //帧尾部字节数组长度
    public static final byte UG_lenHead2RtuAddr = 12 ; //从头到RTU地址（包括）字节数组长度


}

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V202404/parse/Cd_02_Up.java

@@ -22,7 +22,7 @@
    @Override
    public MidResult[] parse(Boolean isLowPower, CodeParseParams params, CodeParseCallback callback)throws Exception {
        ParseParamsForUpV202404 para = (ParseParamsForUpV202404)params ;
        int bsLen = new CommonV202404().parseDataLen(para.upBuffer) ;
        int bsLen = new CommonV202404().parseDataLen4P202404(para.upBuffer) ;
        if(bsLen > 0){
            this.doParse(para.upBuffer,
                    bsLen,

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V202404/parse/Cd_10_Up.java

@@ -22,7 +22,7 @@
    @Override
    public MidResult[] parse(Boolean isLowPower, CodeParseParams params, CodeParseCallback callback)throws Exception {
        ParseParamsForUpV202404 para = (ParseParamsForUpV202404)params ;
        int bsLen = new CommonV202404().parseDataLen(para.upBuffer) ;
        int bsLen = new CommonV202404().parseDataLen4P202404(para.upBuffer) ;
        if(bsLen > 0){
            this.doParse(para.upBuffer,
                    bsLen,

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V202404/parse/Cd_15_Up.java

@@ -22,7 +22,7 @@
    @Override
    public MidResult[] parse(Boolean isLowPower, CodeParseParams params, CodeParseCallback callback)throws Exception {
        ParseParamsForUpV202404 para = (ParseParamsForUpV202404)params ;
        int bsLen = new CommonV202404().parseDataLen(para.upBuffer) ;
        int bsLen = new CommonV202404().parseDataLen4P202404(para.upBuffer) ;
        if(bsLen > 0){
            this.doParse(para.upBuffer,
                    bsLen,

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V202404/parse/Cd_1600_Down.java

New file
@@ -0,0 +1,79 @@
package com.dy.common.mw.protocol.p206V202404.parse;

import com.dy.common.mw.protocol.*;
import com.dy.common.mw.protocol.p206V202404.CodeV202404;
import com.dy.common.mw.protocol.p206V202404.ParseParamsForDownV202404;
import com.dy.common.mw.protocol.p206V202404.ProtocolConstantV206V202404;
import com.dy.common.mw.protocol.p206V202404.parse.global.GlCreate;
import com.dy.common.util.ByteUtil;

/**
 * @Author liurunyu
 * @Date 2024/06/12 9:30
 * @Description
 */
@AnnotationCodeDown(ifAny={
        CodeV202404.cd_1600
})
public class Cd_1600_Down implements CodeParse {

    @Override
    public MidResult[] parse(Boolean isLowPower, CodeParseParams params, CodeParseCallback callback) throws Exception {
        ParseParamsForDownV202404 para = (ParseParamsForDownV202404) params ;
        MidResultToRtu midRs = new MidResultToRtu() ;
        byte[] bs = this.doParse(midRs, para) ;

        midRs.rtuResultSendWebUrl = para.rtuResultSendWebUrl ;//rtu返回命令结果 å‘向目的地web URL
        midRs.protocolName = para.protocolName ;//协议名称
        midRs.protocolVersion = para.protocolVersion; //协议版本号
        midRs.rtuAddr = para.rtuAddr ;//Rtu地址
        midRs.commandId = para.commandId ;//命令ID，发起命令的客户端(web端)生成，以匹配命令结果
        midRs.downCode = para.commandCode ;//下行命令功能码;
        midRs.downCodeName = CodeV202404.getCodeName(para.commandCode) ;//下行命令功能码名称;
        midRs.downBuffer = bs ;//下行命令数据
        midRs.downBufHex = ByteUtil.bytes2Hex(bs, true) ;//下行命令数据十六进制形式
        midRs.hasResponse = false ;//是否有应答
        midRs.maxSendTimes = null ;//命令最大发送次数(当收不到应答时，将重发)，如果不设置，命令缓存器进行补充设置
        midRs.isCachForOffLine = false ;//RTU不在线，命令是否缓存，低功耗时为true

        if(isLowPower != null && isLowPower.booleanValue()){
            //低功耗时，尽快发送
            midRs.isQuickSend = true ;
        }

        return new MidResult[]{midRs} ;
    }

    /**
     * æž„造下行数据
     * @param midRs å‚æ•°
     * @param para å‚æ•°
     * @return å­—节数组
     * @throws Exception å¼‚常
     */
    public byte[] doParse(MidResultToRtu midRs, ParseParamsForDownV202404 para) throws Exception {
        byte[] preBytes = new byte[ProtocolConstantV206V202404.UG_lenHead2RtuAddr] ;
        byte index = 0 ;
        preBytes[index] = ProtocolConstantV206V202404.UG_P_Head_Byte ;

        index++ ;
        preBytes[index] = 0 ;//帧长度
        index++ ;
        preBytes[index] = 0 ;//帧长度

        index++ ;
        preBytes[index] = ProtocolConstantV206V202404.UG_P_Head_Byte ;

        index++ ;
        ByteUtil.hex2Bytes(para.commandCode, preBytes, index) ;

        index += 2 ;
        GlCreate.createRtuAddr4PUg(para.rtuAddr, preBytes, index);

        byte[] bsTail = GlCreate.createCrcTail4Ug(preBytes) ;//CRC和尾叠加字节数组中

        return ByteUtil.bytesMerge(preBytes, bsTail) ;
    }

}


 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V202404/parse/Cd_1601_Down.java

New file
@@ -0,0 +1,108 @@
package com.dy.common.mw.protocol.p206V202404.parse;

import com.dy.common.mw.protocol.*;
import com.dy.common.mw.protocol.p206V202404.CodeV202404;
import com.dy.common.mw.protocol.p206V202404.ParseParamsForDownV202404;
import com.dy.common.mw.protocol.p206V202404.ProtocolConstantV206V202404;
import com.dy.common.mw.protocol.p206V202404.parse.global.GlCreate;
import com.dy.common.softUpgrade.Com1601Vo;
import com.dy.common.util.ByteUtil;

/**
 * @Author liurunyu
 * @Date 2024/06/12 9:30
 * @Description
 */
@AnnotationCodeDown(ifAny={
        CodeV202404.cd_1601
})
public class Cd_1601_Down implements CodeParse {

    @Override
    public MidResult[] parse(Boolean isLowPower, CodeParseParams params, CodeParseCallback callback) throws Exception {
        ParseParamsForDownV202404 para = (ParseParamsForDownV202404) params ;
        MidResultToRtu midRs = new MidResultToRtu() ;
        byte[] bs = this.doParse(midRs, para) ;

        midRs.rtuResultSendWebUrl = para.rtuResultSendWebUrl ;//rtu返回命令结果 å‘向目的地web URL
        midRs.protocolName = para.protocolName ;//协议名称
        midRs.protocolVersion = para.protocolVersion; //协议版本号
        midRs.rtuAddr = para.rtuAddr ;//Rtu地址
        midRs.commandId = para.commandId ;//命令ID，发起命令的客户端(web端)生成，以匹配命令结果
        midRs.downCode = para.commandCode ;//下行命令功能码;
        midRs.downCodeName = CodeV202404.getCodeName(para.commandCode) ;//下行命令功能码名称;
        midRs.downBuffer = bs ;//下行命令数据
        midRs.downBufHex = ByteUtil.bytes2Hex(bs, true) ;//下行命令数据十六进制形式
        midRs.hasResponse = false ;//是否有应答
        midRs.maxSendTimes = null ;//命令最大发送次数(当收不到应答时，将重发)，如果不设置，命令缓存器进行补充设置
        midRs.isCachForOffLine = false ;//RTU不在线，命令是否缓存，低功耗时为true

        if(isLowPower != null && isLowPower.booleanValue()){
            //低功耗时，尽快发送
            midRs.isQuickSend = true ;
        }

        return new MidResult[]{midRs} ;
    }


    /**
     * æž„造下行数据
     * @param midRs å‚æ•°
     * @param para å‚æ•°
     * @return å­—节数组
     * @throws Exception å¼‚常
     */
    public byte[] doParse(MidResultToRtu midRs, ParseParamsForDownV202404 para) throws Exception {
        byte[] preBytes = new byte[ProtocolConstantV206V202404.UG_lenHead2RtuAddr] ;
        byte index = 0 ;
        preBytes[index] = ProtocolConstantV206V202404.UG_P_Head_Byte ;

        index++ ;
        preBytes[index] = 0 ;//帧长度
        index++ ;
        preBytes[index] = 0 ;//帧长度

        index++ ;
        preBytes[index] = ProtocolConstantV206V202404.UG_P_Head_Byte ;

        index++ ;
        ByteUtil.hex2Bytes(para.commandCode, preBytes, index) ;

        index += 2 ;
        GlCreate.createRtuAddr4PUg(para.rtuAddr, preBytes, index);

        if(para.param == null){
            throw new Exception("参数为空") ;
        }
        if(!(para.param instanceof Com1601Vo)){
            throw new Exception("参数类型非Com1601Vo") ;
        }
        Com1601Vo vo = (Com1601Vo) para.param ;
        byte[] bs = new byte[4] ;
        ByteUtil.hex2Bytes(vo.softStoreAddr, bs, 0) ;
        byte[] bytes = ByteUtil.bytesMerge(preBytes, bs) ;

        bs = new byte[4] ;
        ByteUtil.int2Bytes_BE(bs, vo.totalByte, 0);
        bytes = ByteUtil.bytesMerge(bytes, bs) ;

        bs = new byte[2] ;
        ByteUtil.short2Bytes_BE(bs, (short)vo.softCrc, 0);
        bytes = ByteUtil.bytesMerge(bytes, bs) ;

        bs = new byte[2] ;
        ByteUtil.short2Bytes_BE(bs, (short)vo.softCrc, 0);
        bytes = ByteUtil.bytesMerge(bytes, bs) ;

        bs = new byte[4] ;
        ByteUtil.hex2Bytes(vo.softStartAddr, bs, 0) ;
        bytes = ByteUtil.bytesMerge(bytes, bs) ;

        byte[] bsTail = GlCreate.createCrcTail4Ug(bytes) ;//CRC和尾叠加字节数组中

        return ByteUtil.bytesMerge(bytes, bsTail) ;
    }

}


 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V202404/parse/Cd_1602_Down.java

New file
@@ -0,0 +1,90 @@
package com.dy.common.mw.protocol.p206V202404.parse;

import com.dy.common.mw.protocol.*;
import com.dy.common.mw.protocol.p206V202404.CodeV202404;
import com.dy.common.mw.protocol.p206V202404.ParseParamsForDownV202404;
import com.dy.common.mw.protocol.p206V202404.ProtocolConstantV206V202404;
import com.dy.common.mw.protocol.p206V202404.parse.global.GlCreate;
import com.dy.common.util.ByteUtil;

/**
 * @Author liurunyu
 * @Date 2024/06/12 9:30
 * @Description
 */
@AnnotationCodeDown(ifAny={
        CodeV202404.cd_1602
})
public class Cd_1602_Down implements CodeParse {

    @Override
    public MidResult[] parse(Boolean isLowPower, CodeParseParams params, CodeParseCallback callback) throws Exception {
        ParseParamsForDownV202404 para = (ParseParamsForDownV202404) params ;
        MidResultToRtu midRs = new MidResultToRtu() ;
        byte[] bs = this.doParse(midRs, para) ;

        midRs.rtuResultSendWebUrl = para.rtuResultSendWebUrl ;//rtu返回命令结果 å‘向目的地web URL
        midRs.protocolName = para.protocolName ;//协议名称
        midRs.protocolVersion = para.protocolVersion; //协议版本号
        midRs.rtuAddr = para.rtuAddr ;//Rtu地址
        midRs.commandId = para.commandId ;//命令ID，发起命令的客户端(web端)生成，以匹配命令结果
        midRs.downCode = para.commandCode ;//下行命令功能码;
        midRs.downCodeName = CodeV202404.getCodeName(para.commandCode) ;//下行命令功能码名称;
        midRs.downBuffer = bs ;//下行命令数据
        midRs.downBufHex = ByteUtil.bytes2Hex(bs, true) ;//下行命令数据十六进制形式
        midRs.hasResponse = false ;//是否有应答
        midRs.maxSendTimes = null ;//命令最大发送次数(当收不到应答时，将重发)，如果不设置，命令缓存器进行补充设置
        midRs.isCachForOffLine = false ;//RTU不在线，命令是否缓存，低功耗时为true

        if(isLowPower != null && isLowPower.booleanValue()){
            //低功耗时，尽快发送
            midRs.isQuickSend = true ;
        }

        return new MidResult[]{midRs} ;
    }


    /**
     * æž„造下行数据
     * @param midRs å‚æ•°
     * @param para å‚æ•°
     * @return å­—节数组
     * @throws Exception å¼‚常
     */
    public byte[] doParse(MidResultToRtu midRs, ParseParamsForDownV202404 para) throws Exception {
        byte[] preBytes = new byte[ProtocolConstantV206V202404.UG_lenHead2RtuAddr] ;
        byte index = 0 ;
        preBytes[index] = ProtocolConstantV206V202404.UG_P_Head_Byte ;

        index++ ;
        preBytes[index] = 0 ;//帧长度
        index++ ;
        preBytes[index] = 0 ;//帧长度

        index++ ;
        preBytes[index] = ProtocolConstantV206V202404.UG_P_Head_Byte ;

        index++ ;
        ByteUtil.hex2Bytes(para.commandCode, preBytes, index) ;

        index += 2 ;
        GlCreate.createRtuAddr4PUg(para.rtuAddr, preBytes, index);
        if(para.param == null){
            throw new Exception("参数为空") ;
        }
        Integer ramAddr = (Integer)para.param ;

        byte[] bs = new byte[4] ;
        ByteUtil.int2Bytes_BE(bs, ramAddr, 0);
        byte[] bytes = ByteUtil.bytesMerge(preBytes, bs) ;

        bytes = ByteUtil.bytesMerge(bytes, (byte[])para.attachment) ;

        byte[] bsTail = GlCreate.createCrcTail4Ug(bytes) ;//CRC和尾叠加字节数组中

        return ByteUtil.bytesMerge(bytes, bsTail) ;
    }

}


 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V202404/parse/Cd_1603_Down.java

New file
@@ -0,0 +1,80 @@
package com.dy.common.mw.protocol.p206V202404.parse;

import com.dy.common.mw.protocol.*;
import com.dy.common.mw.protocol.p206V202404.CodeV202404;
import com.dy.common.mw.protocol.p206V202404.ParseParamsForDownV202404;
import com.dy.common.mw.protocol.p206V202404.ProtocolConstantV206V202404;
import com.dy.common.mw.protocol.p206V202404.parse.global.GlCreate;
import com.dy.common.util.ByteUtil;

/**
 * @Author liurunyu
 * @Date 2024/06/12 9:30
 * @Description
 */
@AnnotationCodeDown(ifAny={
        CodeV202404.cd_1603
})
public class Cd_1603_Down implements CodeParse {

    @Override
    public MidResult[] parse(Boolean isLowPower, CodeParseParams params, CodeParseCallback callback) throws Exception {
        ParseParamsForDownV202404 para = (ParseParamsForDownV202404) params ;
        MidResultToRtu midRs = new MidResultToRtu() ;
        byte[] bs = this.doParse(midRs, para) ;

        midRs.rtuResultSendWebUrl = para.rtuResultSendWebUrl ;//rtu返回命令结果 å‘向目的地web URL
        midRs.protocolName = para.protocolName ;//协议名称
        midRs.protocolVersion = para.protocolVersion; //协议版本号
        midRs.rtuAddr = para.rtuAddr ;//Rtu地址
        midRs.commandId = para.commandId ;//命令ID，发起命令的客户端(web端)生成，以匹配命令结果
        midRs.downCode = para.commandCode ;//下行命令功能码;
        midRs.downCodeName = CodeV202404.getCodeName(para.commandCode) ;//下行命令功能码名称;
        midRs.downBuffer = bs ;//下行命令数据
        midRs.downBufHex = ByteUtil.bytes2Hex(bs, true) ;//下行命令数据十六进制形式
        midRs.hasResponse = false ;//是否有应答
        midRs.maxSendTimes = null ;//命令最大发送次数(当收不到应答时，将重发)，如果不设置，命令缓存器进行补充设置
        midRs.isCachForOffLine = false ;//RTU不在线，命令是否缓存，低功耗时为true

        if(isLowPower != null && isLowPower.booleanValue()){
            //低功耗时，尽快发送
            midRs.isQuickSend = true ;
        }

        return new MidResult[]{midRs} ;
    }


    /**
     * æž„造下行数据
     * @param midRs å‚æ•°
     * @param para å‚æ•°
     * @return å­—节数组
     * @throws Exception å¼‚常
     */
    public byte[] doParse(MidResultToRtu midRs, ParseParamsForDownV202404 para) throws Exception {
        byte[] preBytes = new byte[ProtocolConstantV206V202404.UG_lenHead2RtuAddr] ;
        byte index = 0 ;
        preBytes[index] = ProtocolConstantV206V202404.UG_P_Head_Byte ;

        index++ ;
        preBytes[index] = 0 ;//帧长度
        index++ ;
        preBytes[index] = 0 ;//帧长度

        index++ ;
        preBytes[index] = ProtocolConstantV206V202404.UG_P_Head_Byte ;

        index++ ;
        ByteUtil.hex2Bytes(para.commandCode, preBytes, index) ;

        index += 2 ;
        GlCreate.createRtuAddr4PUg(para.rtuAddr, preBytes, index);

        byte[] bsTail = GlCreate.createCrcTail4Ug(preBytes) ;//CRC和尾叠加字节数组中

        return ByteUtil.bytesMerge(preBytes, bsTail) ;
    }

}


 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V202404/parse/Cd_16_Up.java

@@ -21,7 +21,7 @@
    @Override
    public MidResult[] parse(Boolean isLowPower, CodeParseParams params, CodeParseCallback callback)throws Exception {
        ParseParamsForUpV202404 para = (ParseParamsForUpV202404)params ;
        int bsLen = new CommonV202404().parseDataLen(para.upBuffer) ;
        int bsLen = new CommonV202404().parseDataLen4P202404(para.upBuffer) ;
        if(bsLen > 0){
            this.doParse(para.upBuffer,
                    bsLen,

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V202404/parse/Cd_21_Up.java

@@ -21,7 +21,7 @@
    @Override
    public MidResult[] parse(Boolean isLowPower, CodeParseParams params, CodeParseCallback callback)throws Exception {
        ParseParamsForUpV202404 para = (ParseParamsForUpV202404)params ;
        int bsLen = new CommonV202404().parseDataLen(para.upBuffer) ;
        int bsLen = new CommonV202404().parseDataLen4P202404(para.upBuffer) ;
        if(bsLen > 0){
            this.doParse(para.upBuffer,
                    bsLen,

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V202404/parse/Cd_22_Up.java

@@ -21,7 +21,7 @@
    @Override
    public MidResult[] parse(Boolean isLowPower, CodeParseParams params, CodeParseCallback callback)throws Exception {
        ParseParamsForUpV202404 para = (ParseParamsForUpV202404)params ;
        int bsLen = new CommonV202404().parseDataLen(para.upBuffer) ;
        int bsLen = new CommonV202404().parseDataLen4P202404(para.upBuffer) ;
        if(bsLen > 0){
            this.doParse(para.upBuffer,
                    bsLen,

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V202404/parse/Cd_23_Up.java

@@ -21,7 +21,7 @@
    @Override
    public MidResult[] parse(Boolean isLowPower, CodeParseParams params, CodeParseCallback callback)throws Exception {
        ParseParamsForUpV202404 para = (ParseParamsForUpV202404)params ;
        int bsLen = new CommonV202404().parseDataLen(para.upBuffer) ;
        int bsLen = new CommonV202404().parseDataLen4P202404(para.upBuffer) ;
        if(bsLen > 0){
            this.doParse(para.upBuffer,
                    bsLen,

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V202404/parse/Cd_24_Up.java

@@ -21,7 +21,7 @@
    @Override
    public MidResult[] parse(Boolean isLowPower, CodeParseParams params, CodeParseCallback callback)throws Exception {
        ParseParamsForUpV202404 para = (ParseParamsForUpV202404)params ;
        int bsLen = new CommonV202404().parseDataLen(para.upBuffer) ;
        int bsLen = new CommonV202404().parseDataLen4P202404(para.upBuffer) ;
        if(bsLen > 0){
            this.doParse(para.upBuffer,
                    bsLen,

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V202404/parse/Cd_25_Up.java

@@ -21,7 +21,7 @@
    @Override
    public MidResult[] parse(Boolean isLowPower, CodeParseParams params, CodeParseCallback callback)throws Exception {
        ParseParamsForUpV202404 para = (ParseParamsForUpV202404)params ;
        int bsLen = new CommonV202404().parseDataLen(para.upBuffer) ;
        int bsLen = new CommonV202404().parseDataLen4P202404(para.upBuffer) ;
        if(bsLen > 0){
            this.doParse(para.upBuffer,
                    bsLen,

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V202404/parse/Cd_26_Up.java

@@ -21,7 +21,7 @@
    @Override
    public MidResult[] parse(Boolean isLowPower, CodeParseParams params, CodeParseCallback callback)throws Exception {
        ParseParamsForUpV202404 para = (ParseParamsForUpV202404)params ;
        int bsLen = new CommonV202404().parseDataLen(para.upBuffer) ;
        int bsLen = new CommonV202404().parseDataLen4P202404(para.upBuffer) ;
        if(bsLen > 0){
            this.doParse(para.upBuffer,
                    bsLen,

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V202404/parse/Cd_30_Up.java

@@ -21,7 +21,7 @@
    @Override
    public MidResult[] parse(Boolean isLowPower, CodeParseParams params, CodeParseCallback callback)throws Exception {
        ParseParamsForUpV202404 para = (ParseParamsForUpV202404)params ;
        int bsLen = new CommonV202404().parseDataLen(para.upBuffer) ;
        int bsLen = new CommonV202404().parseDataLen4P202404(para.upBuffer) ;
        if(bsLen > 0){
            this.doParse(para.upBuffer,
                    bsLen,

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V202404/parse/Cd_31_Up.java

@@ -21,7 +21,7 @@
    @Override
    public MidResult[] parse(Boolean isLowPower, CodeParseParams params, CodeParseCallback callback)throws Exception {
        ParseParamsForUpV202404 para = (ParseParamsForUpV202404)params ;
        int bsLen = new CommonV202404().parseDataLen(para.upBuffer) ;
        int bsLen = new CommonV202404().parseDataLen4P202404(para.upBuffer) ;
        if(bsLen > 0){
            this.doParse(para.upBuffer,
                    bsLen,

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V202404/parse/Cd_50_Up.java

@@ -22,7 +22,7 @@
    @Override
    public MidResult[] parse(Boolean isLowPower, CodeParseParams params, CodeParseCallback callback)throws Exception {
        ParseParamsForUpV202404 para = (ParseParamsForUpV202404)params ;
        int bsLen = new CommonV202404().parseDataLen(para.upBuffer) ;
        int bsLen = new CommonV202404().parseDataLen4P202404(para.upBuffer) ;
        if(bsLen > 0){
            this.doParse(para.upBuffer,
                    bsLen,

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V202404/parse/Cd_55_Up.java

@@ -26,7 +26,7 @@
    @Override
    public MidResult[] parse(Boolean isLowPower, CodeParseParams params, CodeParseCallback callback)throws Exception {
        ParseParamsForUpV202404 para = (ParseParamsForUpV202404)params ;
        int bsLen = new CommonV202404().parseDataLen(para.upBuffer) ;
        int bsLen = new CommonV202404().parseDataLen4P202404(para.upBuffer) ;
        if(bsLen > 0){
            this.doParse(para.upBuffer,
                    bsLen,

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V202404/parse/Cd_56_Up.java

@@ -22,7 +22,7 @@
    @Override
    public MidResult[] parse(Boolean isLowPower, CodeParseParams params, CodeParseCallback callback)throws Exception {
        ParseParamsForUpV202404 para = (ParseParamsForUpV202404)params ;
        int bsLen = new CommonV202404().parseDataLen(para.upBuffer) ;
        int bsLen = new CommonV202404().parseDataLen4P202404(para.upBuffer) ;
        if(bsLen > 0){
            this.doParse(para.upBuffer,
                    bsLen,

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V202404/parse/Cd_5B_Up.java

@@ -22,7 +22,7 @@
    @Override
    public MidResult[] parse(Boolean isLowPower, CodeParseParams params, CodeParseCallback callback)throws Exception {
        ParseParamsForUpV202404 para = (ParseParamsForUpV202404)params ;
        int bsLen = new CommonV202404().parseDataLen(para.upBuffer) ;
        int bsLen = new CommonV202404().parseDataLen4P202404(para.upBuffer) ;
        if(bsLen > 0){
            this.doParse(para.upBuffer,
                    bsLen,

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V202404/parse/Cd_5C_Up.java

@@ -25,7 +25,7 @@
    @Override
    public MidResult[] parse(Boolean isLowPower, CodeParseParams params, CodeParseCallback callback)throws Exception {
        ParseParamsForUpV202404 para = (ParseParamsForUpV202404)params ;
        int bsLen = new CommonV202404().parseDataLen(para.upBuffer) ;
        int bsLen = new CommonV202404().parseDataLen4P202404(para.upBuffer) ;
        if(bsLen > 0){
            this.doParse(para.upBuffer,
                    bsLen,

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V202404/parse/Cd_65_Up.java

@@ -26,7 +26,7 @@
    @Override
    public MidResult[] parse(Boolean isLowPower, CodeParseParams params, CodeParseCallback callback)throws Exception {
        ParseParamsForUpV202404 para = (ParseParamsForUpV202404)params ;
        int bsLen = new CommonV202404().parseDataLen(para.upBuffer) ;
        int bsLen = new CommonV202404().parseDataLen4P202404(para.upBuffer) ;
        if(bsLen > 0){
            this.doParse(para.upBuffer,
                    bsLen,

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V202404/parse/Cd_68_Up.java

@@ -22,7 +22,7 @@
    @Override
    public MidResult[] parse(Boolean isLowPower, CodeParseParams params, CodeParseCallback callback)throws Exception {
        ParseParamsForUpV202404 para = (ParseParamsForUpV202404)params ;
        int bsLen = new CommonV202404().parseDataLen(para.upBuffer) ;
        int bsLen = new CommonV202404().parseDataLen4P202404(para.upBuffer) ;
        if(bsLen > 0){
            this.doParse(para.upBuffer,
                    bsLen,

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V202404/parse/Cd_80_Up.java

@@ -2,7 +2,6 @@


import com.dy.common.mw.protocol.*;
import com.dy.common.mw.protocol.p206V1.CommonV1;
import com.dy.common.mw.protocol.p206V202404.*;
import com.dy.common.mw.protocol.p206V202404.parse.global.GlParse;
import com.dy.common.mw.protocol.p206V202404.upVos.DataCd80_5BVo;
@@ -25,7 +24,7 @@
    @Override
    public MidResult[] parse(Boolean isLowPower, CodeParseParams params, CodeParseCallback callback)throws Exception {
        ParseParamsForUpV202404 para = (ParseParamsForUpV202404)params ;
        int bsLen = new CommonV202404().parseDataLen(para.upBuffer) ;
        int bsLen = new CommonV202404().parseDataLen4P202404(para.upBuffer) ;
        if(bsLen > 0){
            this.doParse(para.upBuffer,
                    bsLen,

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V202404/parse/Cd_81_Up.java

@@ -24,7 +24,7 @@
    @Override
    public MidResult[] parse(Boolean isLowPower, CodeParseParams params, CodeParseCallback callback)throws Exception {
        ParseParamsForUpV202404 para = (ParseParamsForUpV202404)params ;
        int bsLen = new CommonV202404().parseDataLen(para.upBuffer) ;
        int bsLen = new CommonV202404().parseDataLen4P202404(para.upBuffer) ;
        if(bsLen > 0){
            this.doParse(para.upBuffer,
                    bsLen,

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V202404/parse/Cd_83_Up.java

@@ -4,7 +4,6 @@
import com.dy.common.mw.protocol.*;
import com.dy.common.mw.protocol.p206V202404.*;
import com.dy.common.mw.protocol.p206V202404.upVos.DataCd83Vo;
import com.dy.common.mw.protocol.rtuState.ValveStateInfo;
import com.dy.common.util.ByteUtil;
import com.dy.common.util.DateTime;
import org.apache.logging.log4j.LogManager;
@@ -24,7 +23,7 @@
    @Override
    public MidResult[] parse(Boolean isLowPower, CodeParseParams params, CodeParseCallback callback)throws Exception {
        ParseParamsForUpV202404 para = (ParseParamsForUpV202404)params ;
        int bsLen = new CommonV202404().parseDataLen(para.upBuffer) ;
        int bsLen = new CommonV202404().parseDataLen4P202404(para.upBuffer) ;
        if(bsLen > 0){
            this.doParse(para.upBuffer,
                    bsLen,

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V202404/parse/Cd_84_Up.java

@@ -24,7 +24,7 @@
    @Override
    public MidResult[] parse(Boolean isLowPower, CodeParseParams params, CodeParseCallback callback)throws Exception {
        ParseParamsForUpV202404 para = (ParseParamsForUpV202404)params ;
        int bsLen = new CommonV202404().parseDataLen(para.upBuffer) ;
        int bsLen = new CommonV202404().parseDataLen4P202404(para.upBuffer) ;
        if(bsLen > 0){
            this.doParse(para.upBuffer,
                    bsLen,

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V202404/parse/Cd_85_Up.java

@@ -24,7 +24,7 @@
    @Override
    public MidResult[] parse(Boolean isLowPower, CodeParseParams params, CodeParseCallback callback)throws Exception {
        ParseParamsForUpV202404 para = (ParseParamsForUpV202404)params ;
        int bsLen = new CommonV202404().parseDataLen(para.upBuffer) ;
        int bsLen = new CommonV202404().parseDataLen4P202404(para.upBuffer) ;
        if(bsLen > 0){
            this.doParse(para.upBuffer,
                    bsLen,

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V202404/parse/Cd_86_Up.java

@@ -22,7 +22,7 @@
    @Override
    public MidResult[] parse(Boolean isLowPower, CodeParseParams params, CodeParseCallback callback)throws Exception {
        ParseParamsForUpV202404 para = (ParseParamsForUpV202404)params ;
        int bsLen = new CommonV202404().parseDataLen(para.upBuffer) ;
        int bsLen = new CommonV202404().parseDataLen4P202404(para.upBuffer) ;
        if(bsLen > 0){
            this.doParse(para.upBuffer,
                    bsLen,

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V202404/parse/Cd_87_Up.java

@@ -22,7 +22,7 @@
    @Override
    public MidResult[] parse(Boolean isLowPower, CodeParseParams params, CodeParseCallback callback)throws Exception {
        ParseParamsForUpV202404 para = (ParseParamsForUpV202404)params ;
        int bsLen = new CommonV202404().parseDataLen(para.upBuffer) ;
        int bsLen = new CommonV202404().parseDataLen4P202404(para.upBuffer) ;
        if(bsLen > 0){
            this.doParse(para.upBuffer,
                    bsLen,

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V202404/parse/Cd_88_Up.java

@@ -22,7 +22,7 @@
    @Override
    public MidResult[] parse(Boolean isLowPower, CodeParseParams params, CodeParseCallback callback)throws Exception {
        ParseParamsForUpV202404 para = (ParseParamsForUpV202404)params ;
        int bsLen = new CommonV202404().parseDataLen(para.upBuffer) ;
        int bsLen = new CommonV202404().parseDataLen4P202404(para.upBuffer) ;
        if(bsLen > 0){
            this.doParse(para.upBuffer,
                    bsLen,

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V202404/parse/Cd_8A_Up.java

@@ -22,7 +22,7 @@
    @Override
    public MidResult[] parse(Boolean isLowPower, CodeParseParams params, CodeParseCallback callback)throws Exception {
        ParseParamsForUpV202404 para = (ParseParamsForUpV202404)params ;
        int bsLen = new CommonV202404().parseDataLen(para.upBuffer) ;
        int bsLen = new CommonV202404().parseDataLen4P202404(para.upBuffer) ;
        if(bsLen > 0){
            this.doParse(para.upBuffer,
                    bsLen,

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V202404/parse/Cd_92_A2_Up.java

@@ -25,7 +25,7 @@
    @Override
    public MidResult[] parse(Boolean isLowPower, CodeParseParams params, CodeParseCallback callback)throws Exception {
        ParseParamsForUpV202404 para = (ParseParamsForUpV202404)params ;
        int bsLen = new CommonV202404().parseDataLen(para.upBuffer) ;
        int bsLen = new CommonV202404().parseDataLen4P202404(para.upBuffer) ;
        if(bsLen > 0){
            this.doParse(para.upBuffer,
                    bsLen,

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V202404/parse/Cd_93_A3_Up.java

@@ -2,7 +2,6 @@


import com.dy.common.mw.protocol.*;
import com.dy.common.mw.protocol.p206V2.upVos.DataCd93Vo;
import com.dy.common.mw.protocol.p206V202404.*;
import com.dy.common.mw.protocol.p206V202404.parse.global.GlParse;
import com.dy.common.mw.protocol.p206V202404.upVos.DataCd93_A3Vo;
@@ -25,7 +24,7 @@
    @Override
    public MidResult[] parse(Boolean isLowPower, CodeParseParams params, CodeParseCallback callback)throws Exception {
        ParseParamsForUpV202404 para = (ParseParamsForUpV202404)params ;
        int bsLen = new CommonV202404().parseDataLen(para.upBuffer) ;
        int bsLen = new CommonV202404().parseDataLen4P202404(para.upBuffer) ;
        if(bsLen > 0){
            this.doParse(para.upBuffer,
                    bsLen,

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V202404/parse/Cd_9601_Up.java

New file
@@ -0,0 +1,73 @@
package com.dy.common.mw.protocol.p206V202404.parse;

import com.dy.common.mw.protocol.*;
import com.dy.common.mw.protocol.p206V202404.*;
import com.dy.common.mw.protocol.p206V202404.upVos.DataCd960XVo;
import com.dy.common.mw.protocol.rtuState.UpgradeStateInfo;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

/**
 * @Author: liurunyu
 * @Date: 2024/11/4 10:58
 * @Description
 */
@AnnotationCodeUp(ifAny={
        CodeV202404.cd_9601
})
public class Cd_9601_Up implements CodeParse {

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

    /**
     * åˆ†æžä¸Šè¡Œæ•°æ®
     */
    @Override
    public MidResult[] parse(Boolean isLowPower, CodeParseParams params, CodeParseCallback callback)throws Exception {
        ParseParamsForUpV202404 para = (ParseParamsForUpV202404)params ;
        int bsLen = new CommonV202404().parseDataLen4Ug(para.upBuffer) ;
        if(bsLen > 0){
            this.doParse(para.upBuffer,
                    bsLen,
                    para.upCode,
                    para.data) ;
        }
        log.info("\n分析命令应答数据<" + CodeV202404.getCodeName(para.upCode) + " RTU地址=" + para.rtuAddr + ">:\n" + para.data.toString());

        MidResultFromRtu midRs = new MidResultFromRtu() ;
        midRs.protocolName = para.protocolName ;//协议名称
        midRs.protocolVersion = para.protocolVersion; //协议版本号
        midRs.rtuAddr = para.rtuAddr ;//Rtu地址
        midRs.upCode = para.upCode ;//上行数据中的功能码
        midRs.upHex = para.upHex ;//上行数据十六进制形式
        midRs.upBuffer = para.upBuffer ;//上行数据字节数组
        midRs.data = para.data ;//解析后的数据

        midRs.reportOrResponse_trueOrFalse = true ;//升级的，不认为是命令应答

        callback.callback(midRs.reportOrResponse_trueOrFalse);
        if(para.data != null && para.data.getSubData() != null){
            DataCd960XVo subData = (DataCd960XVo)((DataV202404)para.data.getSubData()).subData ;
            callback.notify(new UpgradeStateInfo(subData.success));
        }
        return new MidResult[]{midRs} ;
    }
    /**
     * æ‰§è¡Œåˆ†æž
     * @param bs å­—节数组
     * @param bsLen å­—节长度（总包长，包括包头和包尾）
     * @param dataCode åŠŸèƒ½ç 
     * @param data æ•°æ®
     * @throws Exception å¼‚常
     */
    protected void doParse(byte[] bs, int bsLen, String dataCode, Data data) throws Exception {
        DataV202404 dV2 = (DataV202404)data.getSubData() ;
        DataCd960XVo cdData = new DataCd960XVo() ;
        dV2.subData = cdData ;
        if(bs[ProtocolConstantV206V202404.UG_dataIndex] == (byte)0x00){
            cdData.success = true ;
        }else{
            cdData.success = false ;
        }
    }
}

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V202404/parse/Cd_9602_Up.java

New file
@@ -0,0 +1,73 @@
package com.dy.common.mw.protocol.p206V202404.parse;

import com.dy.common.mw.protocol.*;
import com.dy.common.mw.protocol.p206V202404.*;
import com.dy.common.mw.protocol.p206V202404.upVos.DataCd960XVo;
import com.dy.common.mw.protocol.rtuState.UpgradeStateInfo;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

/**
 * @Author: liurunyu
 * @Date: 2024/11/4 10:58
 * @Description
 */
@AnnotationCodeUp(ifAny={
        CodeV202404.cd_9602
})
public class Cd_9602_Up implements CodeParse {

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

    /**
     * åˆ†æžä¸Šè¡Œæ•°æ®
     */
    @Override
    public MidResult[] parse(Boolean isLowPower, CodeParseParams params, CodeParseCallback callback)throws Exception {
        ParseParamsForUpV202404 para = (ParseParamsForUpV202404)params ;
        int bsLen = new CommonV202404().parseDataLen4Ug(para.upBuffer) ;
        if(bsLen > 0){
            this.doParse(para.upBuffer,
                    bsLen,
                    para.upCode,
                    para.data) ;
        }
        log.info("\n分析命令应答数据<" + CodeV202404.getCodeName(para.upCode) + " RTU地址=" + para.rtuAddr + ">:\n" + para.data.toString());

        MidResultFromRtu midRs = new MidResultFromRtu() ;
        midRs.protocolName = para.protocolName ;//协议名称
        midRs.protocolVersion = para.protocolVersion; //协议版本号
        midRs.rtuAddr = para.rtuAddr ;//Rtu地址
        midRs.upCode = para.upCode ;//上行数据中的功能码
        midRs.upHex = para.upHex ;//上行数据十六进制形式
        midRs.upBuffer = para.upBuffer ;//上行数据字节数组
        midRs.data = para.data ;//解析后的数据

        midRs.reportOrResponse_trueOrFalse = true ;//升级的，不认为是命令应答

        callback.callback(midRs.reportOrResponse_trueOrFalse);
        if(para.data != null && para.data.getSubData() != null){
            DataCd960XVo subData = (DataCd960XVo)((DataV202404)para.data.getSubData()).subData ;
            callback.notify(new UpgradeStateInfo(subData.success));
        }
        return new MidResult[]{midRs} ;
    }
    /**
     * æ‰§è¡Œåˆ†æž
     * @param bs å­—节数组
     * @param bsLen å­—节长度（总包长，包括包头和包尾）
     * @param dataCode åŠŸèƒ½ç 
     * @param data æ•°æ®
     * @throws Exception å¼‚常
     */
    protected void doParse(byte[] bs, int bsLen, String dataCode, Data data) throws Exception {
        DataV202404 dV2 = (DataV202404)data.getSubData() ;
        DataCd960XVo cdData = new DataCd960XVo() ;
        dV2.subData = cdData ;
        if(bs[ProtocolConstantV206V202404.UG_dataIndex] == (byte)0x00){
            cdData.success = true ;
        }else{
            cdData.success = false ;
        }
    }
}

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V202404/parse/Cd_9603_Up.java

New file
@@ -0,0 +1,73 @@
package com.dy.common.mw.protocol.p206V202404.parse;

import com.dy.common.mw.protocol.*;
import com.dy.common.mw.protocol.p206V202404.*;
import com.dy.common.mw.protocol.p206V202404.upVos.DataCd960XVo;
import com.dy.common.mw.protocol.rtuState.UpgradeStateInfo;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

/**
 * @Author: liurunyu
 * @Date: 2024/11/4 10:58
 * @Description
 */
@AnnotationCodeUp(ifAny={
        CodeV202404.cd_9603
})
public class Cd_9603_Up implements CodeParse {

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

    /**
     * åˆ†æžä¸Šè¡Œæ•°æ®
     */
    @Override
    public MidResult[] parse(Boolean isLowPower, CodeParseParams params, CodeParseCallback callback)throws Exception {
        ParseParamsForUpV202404 para = (ParseParamsForUpV202404)params ;
        int bsLen = new CommonV202404().parseDataLen4Ug(para.upBuffer) ;
        if(bsLen > 0){
            this.doParse(para.upBuffer,
                    bsLen,
                    para.upCode,
                    para.data) ;
        }
        log.info("\n分析命令应答数据<" + CodeV202404.getCodeName(para.upCode) + " RTU地址=" + para.rtuAddr + ">:\n" + para.data.toString());

        MidResultFromRtu midRs = new MidResultFromRtu() ;
        midRs.protocolName = para.protocolName ;//协议名称
        midRs.protocolVersion = para.protocolVersion; //协议版本号
        midRs.rtuAddr = para.rtuAddr ;//Rtu地址
        midRs.upCode = para.upCode ;//上行数据中的功能码
        midRs.upHex = para.upHex ;//上行数据十六进制形式
        midRs.upBuffer = para.upBuffer ;//上行数据字节数组
        midRs.data = para.data ;//解析后的数据

        midRs.reportOrResponse_trueOrFalse = true ;//升级的，不认为是命令应答

        callback.callback(midRs.reportOrResponse_trueOrFalse);
        if(para.data != null && para.data.getSubData() != null){
            DataCd960XVo subData = (DataCd960XVo)((DataV202404)para.data.getSubData()).subData ;
            callback.notify(new UpgradeStateInfo(subData.success));
        }
        return new MidResult[]{midRs} ;
    }
    /**
     * æ‰§è¡Œåˆ†æž
     * @param bs å­—节数组
     * @param bsLen å­—节长度（总包长，包括包头和包尾）
     * @param dataCode åŠŸèƒ½ç 
     * @param data æ•°æ®
     * @throws Exception å¼‚常
     */
    protected void doParse(byte[] bs, int bsLen, String dataCode, Data data) throws Exception {
        DataV202404 dV2 = (DataV202404)data.getSubData() ;
        DataCd960XVo cdData = new DataCd960XVo() ;
        dV2.subData = cdData ;
        if(bs[ProtocolConstantV206V202404.UG_dataIndex] == (byte)0x00){
            cdData.success = true ;
        }else{
            cdData.success = false ;
        }
    }
}

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V202404/parse/Cd_97_Up.java

@@ -22,7 +22,7 @@
    @Override
    public MidResult[] parse(Boolean isLowPower, CodeParseParams params, CodeParseCallback callback)throws Exception {
        ParseParamsForUpV202404 para = (ParseParamsForUpV202404)params ;
        int bsLen = new CommonV202404().parseDataLen(para.upBuffer) ;
        int bsLen = new CommonV202404().parseDataLen4P202404(para.upBuffer) ;
        if(bsLen > 0){
            this.doParse(para.upBuffer,
                    bsLen,

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V202404/parse/Cd_98_Up.java

@@ -22,7 +22,7 @@
    @Override
    public MidResult[] parse(Boolean isLowPower, CodeParseParams params, CodeParseCallback callback)throws Exception {
        ParseParamsForUpV202404 para = (ParseParamsForUpV202404)params ;
        int bsLen = new CommonV202404().parseDataLen(para.upBuffer) ;
        int bsLen = new CommonV202404().parseDataLen4P202404(para.upBuffer) ;
        if(bsLen > 0){
            this.doParse(para.upBuffer,
                    bsLen,

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V202404/parse/Cd_99_Up.java

@@ -21,7 +21,7 @@
    @Override
    public MidResult[] parse(Boolean isLowPower, CodeParseParams params, CodeParseCallback callback)throws Exception {
        ParseParamsForUpV202404 para = (ParseParamsForUpV202404)params ;
        int bsLen = new CommonV202404().parseDataLen(para.upBuffer) ;
        int bsLen = new CommonV202404().parseDataLen4P202404(para.upBuffer) ;
        if(bsLen > 0){
            this.doParse(para.upBuffer,
                    bsLen,

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V202404/parse/Cd_9A_Up.java

@@ -21,7 +21,7 @@
    @Override
    public MidResult[] parse(Boolean isLowPower, CodeParseParams params, CodeParseCallback callback)throws Exception {
        ParseParamsForUpV202404 para = (ParseParamsForUpV202404)params ;
        int bsLen = new CommonV202404().parseDataLen(para.upBuffer) ;
        int bsLen = new CommonV202404().parseDataLen4P202404(para.upBuffer) ;
        if(bsLen > 0){
            this.doParse(para.upBuffer,
                    bsLen,

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V202404/parse/Cd_9C_Up.java

@@ -21,7 +21,7 @@
    @Override
    public MidResult[] parse(Boolean isLowPower, CodeParseParams params, CodeParseCallback callback)throws Exception {
        ParseParamsForUpV202404 para = (ParseParamsForUpV202404)params ;
        int bsLen = new CommonV202404().parseDataLen(para.upBuffer) ;
        int bsLen = new CommonV202404().parseDataLen4P202404(para.upBuffer) ;
        if(bsLen > 0){
            this.doParse(para.upBuffer,
                    bsLen,

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V202404/parse/Cd_C2_Up.java

@@ -2,8 +2,6 @@


import com.dy.common.mw.protocol.*;
import com.dy.common.mw.protocol.p206V2.upVos.DataCd83CloseVo;
import com.dy.common.mw.protocol.p206V2.upVos.DataCd83OpenVo;
import com.dy.common.mw.protocol.p206V202404.*;
import com.dy.common.mw.protocol.p206V202404.parse.global.GlParse;
import com.dy.common.mw.protocol.p206V202404.upVos.DataCdC2Vo;
@@ -26,7 +24,7 @@
    @Override
    public MidResult[] parse(Boolean isLowPower, CodeParseParams params, CodeParseCallback callback)throws Exception {
        ParseParamsForUpV202404 para = (ParseParamsForUpV202404)params ;
        int bsLen = new CommonV202404().parseDataLen(para.upBuffer) ;
        int bsLen = new CommonV202404().parseDataLen4P202404(para.upBuffer) ;
        if(bsLen > 0){
            this.doParse(para.upBuffer,
                    bsLen,

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V202404/parse/global/GlCreate.java

@@ -1,12 +1,10 @@
package com.dy.common.mw.protocol.p206V202404.parse.global;

import com.dy.common.mw.protocol.p206V1.ProtocolConstantV206V1;
import com.dy.common.mw.protocol.p206V2.ProtocolConstantV206V2;
import com.dy.common.mw.protocol.p206V202404.CommonV202404;
import com.dy.common.mw.protocol.p206V202404.ProtocolConstantV206V202404;
import com.dy.common.util.ByteUtil;
import com.dy.common.util.ByteUtilUnsigned;
import com.dy.common.util.CRC8_for_2_0;
import com.dy.common.util.DateTime;
import com.dy.common.util.*;

public class GlCreate {
    /**
@@ -55,6 +53,16 @@

        Integer rtuAddr2Int = Integer.parseInt(rtuAddr2) ;
        ByteUtilUnsigned.short2Bytes_LE(bs, rtuAddr2Int.shortValue(), index);
    }
    /**
     * ä¸ºå‡çº§åè®®
     * @param rtuAddr
     * @param bs
     * @param index
     * @throws Exception
     */
    public static void createRtuAddr4PUg(String rtuAddr, byte[] bs, int index) throws Exception {
        ByteUtil.string2BCD_BE(bs, rtuAddr, index) ;
    }

    /**
@@ -146,6 +154,14 @@
        return bytes ;
    }

    public static byte[] createCrcTail4Ug(byte[] bsNoTail) throws Exception {
        int crc = new CRC16().CRC(bsNoTail, 0, bsNoTail.length -1) ;
        byte[] bytes = new byte[ProtocolConstantV206V2.UG_lenTail] ;
        ByteUtilUnsigned.short2Bytes_BE(bytes, crc, 0);
        bytes[2] = ProtocolConstantV206V2.P_Tail_Byte ;
        return bytes ;
    }

    public static void main(String[] args)throws Exception{
        byte[] bs = new byte[6] ;
        createTp(bs, 0) ;

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V202404/upVos/DataCd960XVo.java

New file
@@ -0,0 +1,23 @@
package com.dy.common.mw.protocol.p206V202404.upVos;

import com.dy.common.mw.protocol.UpDataVo;

/**
 * @Author: liurunyu
 * @Date: 2024/11/4 11:14
 * @Description
 */
public class DataCd960XVo implements UpDataVo {
    public boolean success;

    public String toString(){
        StringBuilder sb = new StringBuilder() ;
        sb.append("   å‡çº§åº”ç­”:\n");
        sb.append("      ç»“果：");
        sb.append(success?"正确":"错误");
        sb.append("\n");

        return sb.toString() ;
    }

}

 pipIrr-platform/pipIrr-mw/pipIrr-mw-rtu/src/main/java/com/dy/rtuMw/server/forTcp/TcpIoSessionCallback.java

@@ -19,7 +19,7 @@
    public void sessionOpened(IoSession session) throws Exception {
        log.info("网络连接建立，终端网址是：" + session.getRemoteAddress().toString()) ;
        if(session != null) {
            String rtuAddr = (String) session.getAttribute(TcpIoSessionAttrIdIsRtuAddr.sessionArrIdKey);
            String rtuAddr = (String) session.getAttribute(TcpIoSessionAttrIdIsRtuAddr.sessionArrRtuAddr);
            if(rtuAddr != null && !rtuAddr.trim().equals("")){
                RtuLogDealer.log(rtuAddr, "网络接入");
            }
@@ -32,7 +32,7 @@
    @Override
    public void sessionClosed(IoSession session) throws Exception {
        if(session != null){
             String rtuAddr = (String)session.getAttribute(TcpIoSessionAttrIdIsRtuAddr.sessionArrIdKey) ;
             String rtuAddr = (String)session.getAttribute(TcpIoSessionAttrIdIsRtuAddr.sessionArrRtuAddr) ;

             if(rtuAddr != null && !rtuAddr.trim().equals("")){
                 //记录状态
@@ -49,7 +49,7 @@
     */
    public void exceptionCaught(IoSession session, Throwable cause) throws Exception {
        if(session != null && cause != null){
            String rtuAddr = (String)session.getAttribute(TcpIoSessionAttrIdIsRtuAddr.sessionArrIdKey) ;
            String rtuAddr = (String)session.getAttribute(TcpIoSessionAttrIdIsRtuAddr.sessionArrRtuAddr) ;
            log.error("网络会话发生异常，"
                    + (rtuAddr==null?"":("终端地址是：" + rtuAddr))
                    + (session==null?"":(session.getRemoteAddress() != null?("，终端网址是：" + session.getRemoteAddress().toString()):""))
@@ -61,7 +61,7 @@
     * TCP通道发送完数据后，回调的方法，进行后续数据处理
     */
    public void messageSended(IoSession session, Object message) throws Exception  {
          String rtuAddr = (String)session.getAttribute(TcpIoSessionAttrIdIsRtuAddr.sessionArrIdKey) ;
          String rtuAddr = (String)session.getAttribute(TcpIoSessionAttrIdIsRtuAddr.sessionArrRtuAddr) ;
        log.info("网络发送了数据，"
                + (rtuAddr==null?"":("终端地址是：" + rtuAddr))
                + (session==null?"":(session.getRemoteAddress() != null?("，终端网址是：" + session.getRemoteAddress().toString()):"")) );

 pipIrr-platform/pipIrr-mw/pipIrr-mw-rtu/src/main/java/com/dy/rtuMw/server/forTcp/TcpSession.java

@@ -6,8 +6,8 @@
public class TcpSession {
    
    public IoSession ioSession ;//IoSession对象
    public String protocolName ;//通信协议名称
    public Short protocolVersion ;//通信协议版本号
//    public String protocolName ;//通信协议名称
//    public Short protocolVersion ;//通信协议版本号
    public Long lastDownComTime ;//上次下发命令时刻(毫秒时刻 System.currentTimeMillis())
    public Long lastUpDataTime ;//上次收到上行数据时刻(毫秒时刻 System.currentTimeMillis())
    public Long lastUpDataTimeForOnlineCtrl ;//上次收到上行数据时刻(毫秒时刻 System.currentTimeMillis())，用于上线情况控制

 pipIrr-platform/pipIrr-mw/pipIrr-mw-rtu/src/main/java/com/dy/rtuMw/server/forTcp/TcpSessionCache.java

@@ -3,6 +3,7 @@
import java.util.*;
import java.util.Map.Entry;

import com.dy.common.mw.channel.tcp.TcpIoSessionAttrIdIsRtuAddr;
import org.apache.mina.core.session.IoSession;

import com.dy.rtuMw.server.ServerProperties;
@@ -60,16 +61,16 @@
    /**
     * åŠ å…¥æ–°çš„IoSession
     * @param rtuAddr
     * @param protocolName
     * @param ioSession
     */
    public static void putNewTcpSession(String rtuAddr, String protocolName, Short protocolVersion, IoSession ioSession){
    //public static void putNewTcpSession(String rtuAddr, String protocolName, Short protocolVersion, IoSession ioSession){
    public static void putNewTcpSession(String rtuAddr, IoSession ioSession){
        synchronized (map){
            TcpSession tcpSe = map.get(rtuAddr) ;
            if(tcpSe == null){
                tcpSe = new TcpSession() ;
                tcpSe.protocolName = protocolName ;
                tcpSe.protocolVersion = protocolVersion ;
                //tcpSe.protocolName = protocolName ;
                //tcpSe.protocolVersion = protocolVersion ;
                tcpSe.ioSession = ioSession ;
                map.put(rtuAddr, tcpSe) ;
            }else{
@@ -82,16 +83,15 @@
     * æ›´æ–°IoSession对应的rtuAddr
     * @param oldRtuAddr
     * @param newRtuAddr
     * @param protocolName
     * @param protocolVersion
     * @param ioSession
     */
    public static void changeRtuAddr(String oldRtuAddr, String newRtuAddr, String protocolName, Short protocolVersion, IoSession ioSession){
    //public static void changeRtuAddr(String oldRtuAddr, String newRtuAddr, String protocolName, Short protocolVersion, IoSession ioSession){
    public static void changeRtuAddr(String oldRtuAddr, String newRtuAddr, IoSession ioSession){
        if(oldRtuAddr != null && newRtuAddr != null && !oldRtuAddr.equals(newRtuAddr)){
            synchronized (map){
                TcpSession tcpSe = map.get(oldRtuAddr) ;
                if(tcpSe == null){
                    putNewTcpSession(newRtuAddr, protocolName, protocolVersion, ioSession) ;
                    putNewTcpSession(newRtuAddr, ioSession) ;
                }else{
                    map.remove(oldRtuAddr) ;
                    map.put(newRtuAddr, tcpSe) ;
@@ -113,7 +113,6 @@
     * å¾—到Tcp通信协议名称
     * @param rtuAddr
     * @return

    public static String getTcpProtocolName(String rtuAddr){
        TcpSession tcpSe = sessionTable.get(rtuAddr) ;
        if(tcpSe != null){
@@ -127,16 +126,19 @@
     * å¾—到Tcp通信协议名称
     * @param rtuAddr
     * @return
     */
     * */
    public static Object[] getTcpProtocolNameVersion(String rtuAddr){
        TcpSession tcpSe = map.get(rtuAddr) ;
        if(tcpSe != null){
            return new Object[]{tcpSe.protocolName, tcpSe.protocolVersion};
            return new Object[]{
                    tcpSe.ioSession.getAttribute(TcpIoSessionAttrIdIsRtuAddr.sessionArrProtocolName),
                    tcpSe.ioSession.getAttribute(TcpIoSessionAttrIdIsRtuAddr.sessionArrProtocolVersion)};
        }else{
            return null ;
        }
    }


    /**
     * å¾—到所有在线与离线数量统计
     * @return [0]=在线数量，[2]上线过，但当前离线的数量

 pipIrr-platform/pipIrr-mw/pipIrr-mw-rtu/src/main/java/com/dy/rtuMw/server/forTcp/TcpSessionCacheBk.java

@@ -32,7 +32,6 @@
        TcpSession tcpSe = sessionTable.get(rtuAddr) ;
        if(tcpSe == null){
            tcpSe = new TcpSession() ;
            tcpSe.protocolName = protocolName ;
            tcpSe.ioSession = ioSession ;
            sessionTable.put(rtuAddr, tcpSe) ;
        }else{
@@ -68,20 +67,7 @@
        return sessionTable.get(rtuAddr) ;
    }
    
    /**
     * å¾—到Tcp通信协议名称
     * @param rtuAddr
     * @return
     */
    public static String getTcpProtocolName(String rtuAddr){
        TcpSession tcpSe = sessionTable.get(rtuAddr) ;
        if(tcpSe != null){
            return tcpSe.protocolName ;
        }else{
            return null ;
        }
    }
	

    /**
     * å¾—到所有在线情况
     * @return

 pipIrr-platform/pipIrr-mw/pipIrr-mw-rtu/src/main/java/com/dy/rtuMw/server/tasks/RtuUpTask.java

@@ -55,9 +55,9 @@
            e.printStackTrace();
            log.error("将数据转换为十六进制时出错！" ) ;
        }
        String rtuAddr = (String)session.getAttribute(TcpIoSessionAttrIdIsRtuAddr.sessionArrIdKey) ;
        String protocolName = null ;
        Short protocolVersion = null ;
        String rtuAddr = (String)session.getAttribute(TcpIoSessionAttrIdIsRtuAddr.sessionArrRtuAddr) ;
        String protocolName = (String)session.getAttribute(TcpIoSessionAttrIdIsRtuAddr.sessionArrProtocolName) ;
        Short protocolVersion = (Short)session.getAttribute(TcpIoSessionAttrIdIsRtuAddr.sessionArrProtocolVersion) ;
        boolean isOnLine = false ;
        if(rtuAddr == null){
            //说明刚建立网络连接，此数据应该是上线数据
@@ -69,13 +69,13 @@
                protocolName = (String)rtuAddrProtocolNameVersion[1] ;
                protocolVersion = (Short)rtuAddrProtocolNameVersion[2] ;

                if(rtuAddr != null && protocolName != null){
                if(rtuAddr != null && protocolName != null && protocolVersion != null){
                    //设置session的属性ID
                    TcpUnit.getInstance().setIoSessionArrId(session, rtuAddr);
                    TcpUnit.getInstance().setIoSessionArrs(session, rtuAddr, protocolName, protocolVersion) ;
                    //缓存session
                    TcpSessionCache.putNewTcpSession(rtuAddr, protocolName, protocolVersion, session);
                    TcpSessionCache.putNewTcpSession(rtuAddr, session);
                    
                    log.info("RTU(地址：" + rtuAddr + "，协议：" + protocolName + "，协议版本号：" + protocolVersion + ")上线了。") ;
                    log.info("RTU(地址：" + rtuAddr + "，协议：" + protocolName + "，版本号：" + protocolVersion + ")上线了。") ;
                }
            }
        }
@@ -95,11 +95,13 @@
                }
            }
            if(toDeal){
                /*
                if(protocolName == null){
                    Object[] objs = TcpSessionCache.getTcpProtocolNameVersion(rtuAddr) ;
                    protocolName = (String)objs[0] ;
                    protocolVersion = (Short)objs[1] ;
                }
                */

                //设置收到数据时刻
                TcpSessionCache.cacheUpDataTime(rtuAddr);
@@ -171,7 +173,7 @@
                            boolean isOnLine,
                            byte[] upBuf,
                            String upHex) throws Exception{
        Driver dri = ProtocolCache.getDriver(protocolName) ;
        Driver dri = ProtocolCache.getDriver(protocolName, protocolVersion) ;
        if(dri == null){
            log.error("严重错误，未能得到协议" + protocolName + "驱动类实例！");
        }else{
@@ -181,8 +183,8 @@
                    //更新终端状态
                    if(rtuAddrInData != null && !rtuAddrInData.equals(rtuAddrAtHead)){
                        //数据头中的RTU地址与数据中的RTU地址不一致，更换成数据中的RTU地址
                        TcpSessionCache.changeRtuAddr(rtuAddrAtHead, rtuAddrInData, protocolName, protocolVersion, session);
                        session.setAttribute(TcpIoSessionAttrIdIsRtuAddr.sessionArrIdKey, rtuAddrInData) ;
                        TcpSessionCache.changeRtuAddr(rtuAddrAtHead, rtuAddrInData, session);
                        session.setAttribute(TcpIoSessionAttrIdIsRtuAddr.sessionArrRtuAddr, rtuAddrInData) ;
                    }

                    String rtuAddr ;

 pipIrr-platform/pipIrr-mw/pipIrr-mw-rtu/src/main/java/com/dy/rtuMw/server/tasks/WebDownComTask.java

@@ -44,29 +44,27 @@
        Object[] objs =  TcpSessionCache.getTcpProtocolNameVersion(rtuAddr) ;
        if(objs == null || objs.length == 0 || objs[0] == null){
            //RTU未曾上线
            /* 2024-11-02 å¢žåŠ äº†åè®®ç‰ˆæœ¬å·ï¼Œä¸”一个协议可以有多个版本号，所以下面得到唯一协议驱动实现方式不可用了，因为确定不了版本号
            int count = ProtocolCache.driverCount() ;
            if(count == 1){
                //只有一个协议
                dri = ProtocolCache.getFirstDriver() ;
            }
            */
        }else{
            String protocolName = (String)objs[0];
            com.protocolVersion = (Short)objs[1];
            dri = ProtocolCache.getDriver(protocolName) ;
            if(dri == null){
                log.error("严重错误，未能得到协议" + protocolName + "驱动类实例！");
            }else{
                MidResult[] actions = dri.createCommand(ServerProperties.isLowPower, com)  ;
                log.info("下发远程命令" + com.getCode() + "由协议驱动构造完成");
                if(actions != null){
                    for(MidResult act : actions){
                        act.action();
                    }
            dri = ProtocolCache.getDriver(protocolName, com.protocolVersion) ;
        }
        if(dri == null){
            log.error("严重错误，未能得到RTU(" + rtuAddr + ")驱动类实例！");
        }else{
            MidResult[] actions = dri.createCommand(ServerProperties.isLowPower, com)  ;
            log.info("下发远程命令" + com.getCode() + "由协议驱动构造完成");
            if(actions != null){
                for(MidResult act : actions){
                    act.action();
                }
            }
        }	
        }
    }

}

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

@@ -63,10 +63,10 @@
    notifyStateInterval: å‡çº§çŠ¶æ€é€šçŸ¥é—´éš”（秒）
    -->
    <upgrade enable="true"
             noOneRtuUpgradeMaxDuration="600"
             failTryTimes="1"
             ugMaxRtuAtOnce="1000"
             rtuOffLineWaitDuration="1200"
             noOneRtuUpgradeMaxDuration="1200"
             failTryTimes="2"
             ugMaxRtuAtOnce="5000"
             rtuOffLineWaitDuration="1800"
             notifyStateInterval="2"
    />


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

@@ -63,10 +63,10 @@
    notifyStateInterval: å‡çº§çŠ¶æ€é€šçŸ¥é—´éš”（秒）
    -->
    <upgrade enable="true"
             noOneRtuUpgradeMaxDuration="600"
             failTryTimes="1"
             ugMaxRtuAtOnce="1000"
             rtuOffLineWaitDuration="1200"
             noOneRtuUpgradeMaxDuration="1200"
             failTryTimes="2"
             ugMaxRtuAtOnce="5000"
             rtuOffLineWaitDuration="1800"
             notifyStateInterval="2"
    />


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

@@ -63,10 +63,10 @@
    notifyStateInterval: å‡çº§çŠ¶æ€é€šçŸ¥é—´éš”（秒）
    -->
    <upgrade enable="true"
             noOneRtuUpgradeMaxDuration="600"
             failTryTimes="1"
             ugMaxRtuAtOnce="1000"
             rtuOffLineWaitDuration="1200"
             noOneRtuUpgradeMaxDuration="1200"
             failTryTimes="2"
             ugMaxRtuAtOnce="5000"
             rtuOffLineWaitDuration="1800"
             notifyStateInterval="2"
    />


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

@@ -64,8 +64,8 @@
    -->
    <upgrade enable="true"
             noOneRtuUpgradeMaxDuration="1200"
             failTryTimes="1"
             ugMaxRtuAtOnce="1000"
             failTryTimes="2"
             ugMaxRtuAtOnce="5000"
             rtuOffLineWaitDuration="1800"
             notifyStateInterval="2"
    />

 pipIrr-platform/pipIrr-mw/pipIrr-mw-simulate-rtu/src/main/java/com/dy/simRtu/PipIrrMwSimulateRtuApplication.java

@@ -35,30 +35,71 @@

    public static void main(String[] args) {
        if(args != null && args.length > 0){
            if(args.length == 3){
                if(args[0] instanceof String){
                    if(args[0] != null && !args[0].trim().equals("")){
                        String rtuAddr = (String)args[0] ;//本模拟器模拟RTU地址
                        ServerProperties.argRtuAddr = rtuAddr ;
                    }
                    if(args[1] != null && !args[1].trim().equals("")){
                        Integer oneDie = Integer.parseInt(args[1]) ;//一包死：1是，0否
                        ServerProperties.argOneDie = oneDie == 1?true:false ;
                    }
                    if(args[2] != null && !args[2].trim().equals("")){
                        Integer multiDie = Integer.parseInt(args[2]) ;//多包死：1是，0否
                        ServerProperties.argMultiDie = multiDie == 1?true:false ;
                    }
                    if(ServerProperties.argOneDie && ServerProperties.argMultiDie){
                        ServerProperties.argOneDie = false ;
                    }
                }
            if(args.length == 1){
                getArg0(args) ;
            }else if(args.length == 2){
                getArg0(args) ;
                getArg1(args) ;
            }else if(args.length == 3){
                getArg0(args) ;
                getArg1(args) ;
                getArg2(args) ;
            }else if(args.length == 4){
                getArg0(args) ;
                getArg1(args) ;
                getArg2(args) ;
                getArg3(args) ;
            }else if(args.length == 5){
                getArg0(args) ;
                getArg1(args) ;
                getArg2(args) ;
                getArg3(args) ;
                getArg4(args) ;
            }

            if(ServerProperties.argOneDie && ServerProperties.argMultiDie){
                ServerProperties.argOneDie = false ;
            }
        }
        new SpringApplicationBuilder(PipIrrMwSimulateRtuApplication.class)
                .web(WebApplicationType.NONE)//不启动web服务
                .run(args);
    }
    private static void getArg0(String[] args){
        if(args[0] instanceof String){
            if(args[0] != null && !args[0].trim().equals("")){
                String rtuAddr = (String)args[0] ;//本模拟器模拟RTU地址
                ServerProperties.argRtuAddr = rtuAddr ;
            }
        }
    }
    private static void getArg1(String[] args){
        if(args[1] != null && !args[1].trim().equals("")){
            Integer oneDie = Integer.parseInt(args[1]) ;//一包死：1是，0否
            ServerProperties.argOneDie = oneDie == 1?true:false ;
        }
    }
    private static void getArg2(String[] args){
        if(args[2] != null && !args[2].trim().equals("")){
            Integer multiDie = Integer.parseInt(args[2]) ;//多包死：1是，0否
            ServerProperties.argMultiDie = multiDie == 1?true:false ;
        }
    }
    private static void getArg3(String[] args){
        if(args[3] instanceof String){
            if(args[3] != null && !args[3].trim().equals("")){
                String serverIp = (String)args[3] ;//服务端IP
                ServerProperties.serverIp = serverIp ;
            }
        }
    }
    private static void getArg4(String[] args){
        if(args[4] != null && !args[4].trim().equals("")){
            Integer serverPort = Integer.parseInt(args[4]) ;//服务端port
            ServerProperties.serverPort = serverPort ;
        }
    }


    /**
     * Spring容器启动完成后，执行下面方法

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

@@ -54,6 +54,8 @@
            System.out.println("启动一包死：" + (ServerProperties.argOneDie==null?"否":(ServerProperties.argOneDie?"是":"否"))) ;
            System.out.println("启动多包死：" + (ServerProperties.argMultiDie==null?"否":(ServerProperties.argMultiDie?"是":"否"))) ;



            String svName ;
            try{
                svName = this.conf.getSetAttrTxt(this.doc, "config.server", "name", null, false, null) ;
@@ -103,8 +105,16 @@
            // ///////////////
            // TCP æ¨¡å—
            TcpClUnitConfigVo tcpVo = new TcpClUnitConfigVo();
            tcpVo.mwServerIp = conf.getSetAttrTxt(doc, "config.tcpCl", "mwServerIp", null, false, null);
            tcpVo.mwServerPort = conf.getSetAttrPlusInt(doc, "config.tcpCl", "mwServerPort", null, 100, 65535, null);
            if(ServerProperties.serverIp != null && !ServerProperties.serverIp.trim().equals("")){
                tcpVo.mwServerIp = ServerProperties.serverIp ;
            }else{
                tcpVo.mwServerIp = conf.getSetAttrTxt(doc, "config.tcpCl", "mwServerIp", null, false, null);
            }
            if(ServerProperties.serverPort != null){
                tcpVo.mwServerPort = ServerProperties.serverPort ;
            }else{
                tcpVo.mwServerPort = conf.getSetAttrPlusInt(doc, "config.tcpCl", "mwServerPort", null, 100, 65535, null);
            }
            tcpVo.connectTimeout = conf.getSetAttrPlusInt(doc, "config.tcpCl", "connectTimeout", null, 1000, 10000, null);
            this.mwServerUrl = tcpVo.mwServerIp + ":" + tcpVo.mwServerPort ;
            AdapterImp_TcpClUnit tcpAdap = new AdapterImp_TcpClUnit();

 pipIrr-platform/pipIrr-mw/pipIrr-mw-simulate-rtu/src/main/java/com/dy/simRtu/ServerProperties.java

@@ -15,4 +15,7 @@
    public static Boolean argOneDie = false ;
    public static Boolean argMultiDie = false ;

    public static String serverIp ;
    public static Integer serverPort ;

}

 pipIrr-platform/pipIrr-mw/pipIrr-mw-simulate-rtu/src/main/resources/log4j2.xml

@@ -2,7 +2,7 @@
<Configuration status="OFF">
  <Appenders>
    <Console name="Console" target="SYSTEM_OUT">
      <PatternLayout charset="GBK" pattern="%d %-5p [%t] (%F:%L) - %m%n%throwable"/>
      <PatternLayout charset="UTF-8" pattern="%d %-5p [%t] (%F:%L) - %m%n%throwable"/>
    </Console>
    <RollingFile name="File" fileName="logs/simRtu.log" filePattern="logs/simRtu-%d{yyyyMMdd}-%i.log">
      <PatternLayout charset="UTF-8" pattern="%d %-5p [%t] (%class.%method:%L) - %m%n%throwable"/>

 pipIrr-platform/pipIrr-mw/pipIrr-mwTest-client/src/main/resources/log4j2.xml

@@ -2,7 +2,7 @@
<Configuration status="OFF">
  <Appenders>
    <Console name="Console" target="SYSTEM_OUT">
      <PatternLayout charset="GBK" pattern="%d %-5p [%t] (%F:%L) - %m%n%throwable"/>
      <PatternLayout charset="UTF-8" pattern="%d %-5p [%t] (%F:%L) - %m%n%throwable"/>
    </Console>
    <!-- 
        fileName="${sys:user.home}/logs/aepTest.log" filePattern="${sys:user.home}/logs/aepTest-%d{yyyy-MM}-%i.log.gz"

 pipIrr-platform/pipIrr-mw/pipIrr-mwTest-server/src/main/resources/log4j2.xml

@@ -2,7 +2,7 @@
<Configuration status="OFF">
  <Appenders>
    <Console name="Console" target="SYSTEM_OUT">
      <PatternLayout charset="GBK" pattern="%d %-5p [%t] (%F:%L) - %m%n%throwable"/>
      <PatternLayout charset="UTF-8" pattern="%d %-5p [%t] (%F:%L) - %m%n%throwable"/>
    </Console>
    <!-- 
        fileName="${sys:user.home}/logs/aepTest.log" filePattern="${sys:user.home}/logs/aepTest-%d{yyyy-MM}-%i.log.gz"

 pipIrr-platform/pipIrr-web/pipIrr-mwTest-rtu/src/main/resources/log4j2.xml

@@ -2,7 +2,7 @@
<Configuration status="OFF">
  <Appenders>
    <Console name="Console" target="SYSTEM_OUT">
      <PatternLayout charset="GBK" pattern="%d %-5p [%t] (%F:%L) - %m%n%throwable"/>
      <PatternLayout charset="UTF-8" pattern="%d %-5p [%t] (%F:%L) - %m%n%throwable"/>
    </Console>
    <!-- 
        fileName="${sys:user.home}/logs/aepTest.log" filePattern="${sys:user.home}/logs/aepTest-%d{yyyy-MM}-%i.log.gz"