1、修改rtuAddr注释 2、实现开关阀自报协议 3、实现开阀工作报 4、《编码设计》

liurunyu

2023-11-23 52952d6feed8a9df738c652cda6c7d1ca50d2921

1、修改rtuAddr注释
2、实现开关阀自报协议
3、实现开阀工作报
4、《编码设计》

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

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

    public static final String sessionArrIdKey = "key_rtuAddr" ; //这个key存储的是IMEI号
    public static final String sessionArrIdKey = "key_rtuAddr" ; //这个key存储的是Rtu地址
}

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

@@ -62,7 +62,7 @@
    public String toString(){
        String s = "命令id=" + id + "\n" ;
        s += (protocol == null ? "" : ("协议=" + protocol + "\n"));
        s += (rtuAddr == null ? "" : ("IMEI号=" + rtuAddr + "\n"));
        s += (rtuAddr == null ? "" : ("Rtu地址=" + rtuAddr + "\n"));
        s += "命令类型=" + (type.equals(CommandType.innerCommand)?"内部命令":"终端命令") + "\n" ;
        s += (code == null ? "" : ("功能码=" + code + "\n")) ;
        s += "返回中间件对命令处理结果=" + (noRtMwDealRes == null?"返回":(noRtMwDealRes?"不返回":"返回") + "\n") ;

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

@@ -22,7 +22,7 @@
    public String toString() {
        StringBuilder sb = new StringBuilder() ;
        sb.append("上行报文(十六进制): ").append((hex == null?"":hex)).append("\n") ; //
        sb.append("IMEI号 : ").append((rtuAddr==null?"":rtuAddr)).append("\n") ;
        sb.append("Rtu地址 : ").append((rtuAddr==null?"":rtuAddr)).append("\n") ;
        if(commandId != null){
            sb.append("命令ID : ").append(commandId).append("\n") ; //命令ID
        }

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

@@ -9,9 +9,9 @@
     * @param upHex ä¸Šè¡Œæ•°æ®
     * @param reportOrResponse_trueOrFalse ä¸Šè¡Œæ•°æ®æ˜¯ä¸»åŠ¨ä¸ŠæŠ¥è¿˜æ˜¯å‘½ä»¤ç»“æžœ
     * @param parseFail ä¸Šè¡Œæ•°æ®è§£æžæ˜¯å¦å¤±è´¥
     * @param rtuAddrInData ä¸Šè¡Œæ•°æ®ä¸­åœ¨åè®®æ•°æ®ä¸­çš„IMEI号，
     *     â€œä¿®æ”¹RTU终端管理配置参数”命令的返回数据，其协议头中的IMEI号与数据中的IMEI号不一样，
     *  å¦‚æžœRTU不能关闭网络，那么sessionCach中的IMEI号总是用修改前的IMEI号，使得以后上行数据的不能找到缓存中的Session
     * @param rtuAddrInData ä¸Šè¡Œæ•°æ®ä¸­åœ¨åè®®æ•°æ®ä¸­çš„Rtu地址，
     *     â€œä¿®æ”¹RTU终端管理配置参数”命令的返回数据，其协议头中的Rtu地址与数据中的Rtu地址不一样，
     *  å¦‚æžœRTU不能关闭网络，那么sessionCach中的Rtu地址总是用修改前的Rtu地址，使得以后上行数据的不能找到缓存中的Session
     */
    void callback(String rtuAddr,
            String code,

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

@@ -11,7 +11,7 @@
    }

    public String protocolName ;//协议名称
    public String rtuAddr ;//IMEI号，注意rtuAddr可能为null
    public String rtuAddr ;//Rtu地址，注意rtuAddr可能为null
    public String message ;//出错消息
    public Exception e ;//异常
    

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

@@ -13,7 +13,7 @@
    public String commandId ;//发送命令的ID，如果是命令结果，并且匹配了下发命令，此值不为空
    
    public String protocolName ;//协议名称
    public String rtuAddr ;//IMEI号
    public String rtuAddr ;//Rtu地址
    public String upCode ;//上行数据中的功能码
    public String upHex ;//上行数据十六进制形式
    public byte[] upBuffer ;//上行数据字节数组

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

@@ -11,7 +11,7 @@
    }

    public String protocolName ;//协议名称
    public String rtuAddr ;//IMEI号(电信平台IMEI)
    public String rtuAddr ;//Rtu地址
    public String commandId ;//命令ID，发起命令的客户端(web端)生成，以匹配命令结果
    public String downCode ;//下行命令功能码;
    public byte[] downBuffer ;//下行命令数据

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

@@ -16,7 +16,7 @@
    class OnLineResult{
        public int result ;//分析结果
        public String protocolName ;//协议名称
        public String rtuAddr ;//IMEI号
        public String rtuAddr ;//Rtu地址
        public byte[] remoteData;//需要向Rtu回写的数据
        public OnLineResult(){
            result = OnLineAction_fail ;
@@ -26,7 +26,7 @@
    }
    
    int OnLineAction_fail = 0; //分析上线数据失败，如提供的数据为null等原因
    int OnLineAction_success = 1; //分析上线数据成功，并能得到IMEI号
    int OnLineAction_success = 1; //分析上线数据成功，并能得到Rtu地址
    int OnLineAction_success_noMe = 2; //分析上线数据成功，识别出不是本协议数据
    int OnLineAction_success_response = 3; //分析上线数据成功，并需要向Rtu回写数据
    

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

@@ -47,7 +47,7 @@
            }
        }
        if(rs == null){
            throw new Exception("处理上线时出错，未能成功分析出IMEI号！") ;
            throw new Exception("处理上线时出错，未能成功分析出Rtu地址！") ;
        }
        return rs ;
    }

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

@@ -2,17 +2,17 @@

public class CodeV1_0_1 {
    //功能码为字符串，十六进制数据
    public static final String cd_02 = "02" ;//链路检测
    public static final String cd_03 = "03" ;//事件上报
    public static final String cd_04 = "04" ;//开阀
    public static final String cd_05 = "05" ;//关阀
    public static final String cd_02 = "02" ;//遥测站链路检测
    public static final String cd_C0 = "C0" ;//遥测站自报实时数据
    public static final String cd_83 = "83" ;//遥测站开关阀自报
    public static final String cd_84 = "84" ;//开阀工作报
    public static final String cd_06 = "06" ;//阀门动作结果

    public static String getCodeName(String code) {
        String name = (code.equals(cd_02) ? "链路检测" :
            (code.equals(cd_03) ? "事件上报" :
            (code.equals(cd_04) ? "开阀" : 
            (code.equals(cd_05) ? "关阀" : 
            (code.equals(cd_C0) ? "自报实时数据" :
            (code.equals(cd_83) ? "开关阀自报" :
            (code.equals(cd_84) ? "开阀工作报" :
            (code.equals(cd_06) ? "阀门动作结果" : 
            ""))))) ;
        return name ;

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

@@ -60,7 +60,7 @@


    /**
     * åˆ†æžIMEI号
     * åˆ†æžRtu地址
     * @param bs ä¸Šè¡Œå­—节数组
     * @return æŽ§åˆ¶å™¨åœ°å€
     * @throws Exception å¼‚常
@@ -132,6 +132,26 @@
        //DIR = 0
        return b ;
    }

    /**
     * å¾—到关开阀类型名称
     * @param type å­—节
     * @return åç§°
     */
    public static String openCloseValveType(byte type){
        return switch (type) {
            case 1 -> "刷卡开阀";
            case 2 -> "刷卡关阀";
            case 3 -> "中心站开阀";
            case 4 -> "中心站关阀";
            case 5 -> "欠费关阀";
            case 6 -> "流量计故障关阀";
            case 7 -> "紧急关阀";
            case 8 -> "用户远程开阀";
            case 9 -> "用户远程关阀";
            default -> "未知";
        };
    }
    
    /*
     * åˆ†æžç‰ˆæœ¬å·

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

New file
@@ -0,0 +1,28 @@
package com.dy.common.mw.protocol.p206V1_0_0;

import lombok.Data;

@Data
public class DataAlarmVo {
    public Byte batteryVolt ;// è“„电池电压
    public Byte loss ;//漏损
    public Byte meter ;//仪表
    public Byte valve ;//阀门

    public String toString(){
        StringBuilder str = new StringBuilder() ;
        str.append("      æŠ¥è­¦:\n");
        str.append("         è“„电池电压：");
        str.append(batteryVolt==null?"":(batteryVolt==1?"报警":"正常"));
        str.append("\n");
        str.append("         æ¼æŸï¼š");
        str.append(loss==null?"":(loss==1?"报警":"正常"));
        str.append("\n");
        str.append("         ä»ªè¡¨ï¼š");
        str.append(meter==null?"":(meter==1?"报警":"正常"));
        str.append("\n");
        str.append("         é˜€é—¨ï¼š");
        str.append(valve==null?"":(valve==1?"报警":"正常"));
        return str.toString() ;
    }
}

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

New file
@@ -0,0 +1,61 @@
package com.dy.common.mw.protocol.p206V1_0_0;

import lombok.Data;

@Data
public class DataCd83CloseVo {
    // å¼€å…³é˜€ç±»åž‹ï¼š
    // 1、刷卡开阀；2刷卡关阀；3、中心站开阀；4、中心站关阀；5、欠费关阀；
    // 6、流量计故障关阀；7、紧急关阀；8、用户远程开阀；9、用户远程关阀；
    public Byte type ;
    public Double totalAmount; //累计流量：5字节BCD码，取值范围0~9999999999，单位为m3。
    public String clientNum ;//农户编号
    public String icAddr ;//ic卡地址
    public Double remainMoney ;//剩余金额：用户余额4字节BCD码，取值范围0.00~999999.99，单位为元
    public String openDt ;//用水户用水开始时间：6字节BCD码，顺序是年月日时分秒，其中公元年=2000+年。
    public String closeDt ;//用水户用水结束时间：6字节BCD码，顺序是年月日时分秒，其中公元年=2000+年。
    public Double thisAmount ;//用水户本次用水量：累计流量5字节BCD码，取值范围0~9999999999，单位为m3。
    public Double thisMoney ;//用水户本次消费金额：用户余额4字节BCD码，取值范围0.00~999999.99，单位为元。
    public Integer thisTime ;//用水户本次用水时长：用水时长2字节BCD码，取值范围0~9999，单位为分钟。
    public String rtuDt ;//控制器时钟

    public String toString(){
        StringBuilder sb = new StringBuilder() ;
        sb.append("   ç»ˆç«¯å…³é˜€è‡ªæŠ¥:\n");
        sb.append("      å…³é˜€ç±»åž‹ï¼š");
        sb.append(CommonV1_0_1.openCloseValveType(type)) ;
        sb.append("\n");
        sb.append("      ç´¯è®¡æµé‡ï¼š");
        sb.append(totalAmount==null?"":totalAmount);
        sb.append("\n");
        sb.append("      å†œæˆ·ç¼–号：");
        sb.append(clientNum);
        sb.append("\n");
        sb.append("      ic卡地址：");
        sb.append(icAddr);
        sb.append("\n");
        sb.append("      å‰©ä½™é‡‘额（元）：");
        sb.append(remainMoney ==null?"": remainMoney);
        sb.append("\n");
        sb.append("      å¼€é˜€æ—¶é—´ï¼š");
        sb.append(openDt);
        sb.append("\n");
        sb.append("      å…³é˜€æ—¶é—´ï¼š");
        sb.append(closeDt);
        sb.append("\n");
        sb.append("      æœ¬æ¬¡ç”¨æ°´é‡ï¼š");
        sb.append(thisAmount==null?"":thisAmount);
        sb.append("\n");
        sb.append("      æœ¬æ¬¡èŠ±è´¹é‡‘额（元）：");
        sb.append(thisMoney==null?"":thisMoney);
        sb.append("\n");
        sb.append("      æœ¬æ¬¡ç”¨æ°´æ—¶é•¿ï¼ˆåˆ†é’Ÿï¼‰ï¼š");
        sb.append(thisTime==null?"":thisTime);
        sb.append("\n");
        sb.append("      æŽ§åˆ¶å™¨æ—¶é’Ÿï¼š");
        sb.append(rtuDt==null?"":rtuDt);
        sb.append("\n");

        return sb.toString() ;
    }
}

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

New file
@@ -0,0 +1,46 @@
package com.dy.common.mw.protocol.p206V1_0_0;


import lombok.Data;

@Data
public class DataCd83OpenVo {
    // å¼€å…³é˜€ç±»åž‹ï¼š
    // 1、刷卡开阀；2刷卡关阀；3、中心站开阀；4、中心站关阀；5、欠费关阀；
    // 6、流量计故障关阀；7、紧急关阀；8、用户远程开阀；9、用户远程关阀；
    public Byte type ;
    public Double totalAmount; //累计流量：5字节BCD码，取值范围0~9999999999，单位为m3。
    public String clientNum ;//农户编号
    public String icAddr ;//ic卡地址
    public Double remainMoney;//剩余金额：用户余额4字节BCD码，取值范围0.00~999999.99，单位为元
    public String openDt ;//用水户开阀时间：6字节BCD码，顺序是年月日时分秒，其中公元年=2000+年。
    public String rtuDt ;//控制器时钟

    public String toString(){
        StringBuilder sb = new StringBuilder() ;
        sb.append("   ç»ˆç«¯å¼€é˜€è‡ªæŠ¥:\n");
        sb.append("      å¼€é˜€ç±»åž‹ï¼š");
        sb.append(CommonV1_0_1.openCloseValveType(type)) ;
        sb.append("\n");
        sb.append("      ç´¯è®¡æµé‡ï¼š");
        sb.append(totalAmount==null?"":totalAmount);
        sb.append("\n");
        sb.append("      å†œæˆ·ç¼–号：");
        sb.append(clientNum);
        sb.append("\n");
        sb.append("      ic卡地址：");
        sb.append(icAddr);
        sb.append("\n");
        sb.append("      å‰©ä½™é‡‘额（元）：");
        sb.append(remainMoney ==null?"": remainMoney);
        sb.append("\n");
        sb.append("      å¼€é˜€æ—¶é—´ï¼š");
        sb.append(openDt);
        sb.append("\n");
        sb.append("      æŽ§åˆ¶å™¨æ—¶é’Ÿï¼š");
        sb.append(rtuDt==null?"":rtuDt);
        sb.append("\n");

        return sb.toString() ;
    }
}

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

New file
@@ -0,0 +1,33 @@
package com.dy.common.mw.protocol.p206V1_0_0;

import lombok.Data;

@Data
public class DataCd84Vo {
    public String clientNum ;//农户编号
    public Double remainMoney ;//剩余金额：用户余额4字节BCD码，取值范围0.00~999999.99，单位为元
    public Double totalAmount; //累计流量：5字节BCD码，取值范围0~9999999999，单位为m3。
    public Double instantAmount; //瞬时流量：5字节BCD码，取值范围0~9999999.999，单位为m3/h。
    public String rtuDt ;//控制器时钟

    public String toString(){
        StringBuilder sb = new StringBuilder() ;
        sb.append("   ç»ˆç«¯å¼€é˜€å·¥ä½œæŠ¥:\n");
        sb.append("      å†œæˆ·ç¼–号：");
        sb.append(clientNum);
        sb.append("\n");
        sb.append("      å‰©ä½™é‡‘额（元）：");
        sb.append(remainMoney==null?"":remainMoney);
        sb.append("\n");
        sb.append("      ç´¯è®¡æµé‡ï¼š");
        sb.append(totalAmount==null?"":totalAmount);
        sb.append("\n");
        sb.append("      çž¬æ—¶æµé‡ï¼š");
        sb.append(instantAmount==null?"":instantAmount);
        sb.append("\n");
        sb.append("      æŽ§åˆ¶å™¨æ—¶é’Ÿï¼š");
        sb.append(rtuDt==null?"":rtuDt);
        sb.append("\n");
        return sb.toString() ;
    }
}

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

@@ -4,4 +4,49 @@

@Data
public class DataCdC0Vo {
    public Double instantAmount; //瞬时流量：5字节BCD码，取值范围0~9999999.999，单位为m3/h。
    public Double totalAmount; //累计流量：5字节BCD码，取值范围0~9999999999，单位为m3。
    public Double lossAmount; //损失流量：5字节BCD码，取值范围0~9999999999，单位为m3。
    public Double waterPress; //水压：4字节BCD码，取值范围0~999999.99，单位为KPa。
    public Double batteryVolt;//蓄电池电压:4字节BCD码，取值范围0~99.99，单位为V。
    public Double sunVolt ;//太阳能电压:4字节BCD码，取值范围0~99.99，单位为V。
    public Integer signal; //信号强度：1字节BCD码，取值范围0~99。
    public String rtuDt ;//控制器时钟
    public DataAlarmVo alarmVo ;//报警
    public DataStateVo stateVo ;//状态
    public String toString(){
        StringBuilder sb = new StringBuilder() ;
        sb.append("   ç»ˆç«¯è‡ªæŠ¥å®žæ—¶æ•°æ®:\n");
        sb.append("      çž¬æ—¶æµé‡ï¼š");
        sb.append(instantAmount==null?"":instantAmount);
        sb.append("\n");
        sb.append("      ç´¯è®¡æµé‡ï¼š");
        sb.append(totalAmount==null?"":totalAmount);
        sb.append("\n");
        sb.append("      æŸå¤±æµé‡ï¼š");
        sb.append(lossAmount==null?"":lossAmount);
        sb.append("\n");
        sb.append("      æ°´åŽ‹ï¼š");
        sb.append(waterPress==null?"":waterPress);
        sb.append("\n");
        sb.append("      è“„电池电压：");
        sb.append(batteryVolt==null?"":batteryVolt);
        sb.append("\n");
        sb.append("      å¤ªé˜³èƒ½ç”µåŽ‹ï¼š");
        sb.append(sunVolt==null?"":sunVolt);
        sb.append("\n");
        sb.append("      ä¿¡å·å¼ºåº¦ï¼š");
        sb.append(signal==null?"":signal);
        sb.append("\n");
        sb.append("      æŽ§åˆ¶å™¨æ—¶é’Ÿï¼š");
        sb.append(rtuDt==null?"":rtuDt);
        sb.append("\n");
        sb.append(alarmVo==null?"":alarmVo.toString());
        sb.append("\n");
        sb.append(stateVo==null?"":stateVo.toString());
        sb.append("\n");

        return sb.toString() ;
    }

}

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

New file
@@ -0,0 +1,24 @@
package com.dy.common.mw.protocol.p206V1_0_0;

import lombok.Data;

@Data
public class DataStateVo  {
    public Byte idCard ;// è“„电池电压
    public Byte work;//工作状态
    public Byte valve ;//阀门

    public String toString(){
        StringBuilder str = new StringBuilder() ;
        str.append("      çŠ¶æ€:\n");
        str.append("         IC å¡åŠŸèƒ½ï¼š");
        str.append(idCard==null?"":(idCard==1?"有效":"无效"));
        str.append("\n");
        str.append("         å·¥ä½œçŠ¶æ€ï¼š");
        str.append(work ==null?"":(work==1?"启动":"停止"));
        str.append("\n");
        str.append("         é˜€é—¨ï¼š");
        str.append(valve==null?"":(valve==1?"打开":"关闭"));
        return str.toString() ;
    }
}

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

@@ -11,6 +11,9 @@

    public DataCd02Vo dataCd02Vo;//链路检测
    public DataCdC0Vo dataCdC0Vo;//终端自报实时数据
    public DataCd83OpenVo dataCd83OpenVo;//开阀自报
    public DataCd83CloseVo dataCd83CloseVo;//关阀自报
    public DataCd84Vo dataCd84Vo;//开阀工作报

    public String dt ;//通信中间件产生发报时间(yyyy-MM-dd hh:mm:ss)


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

@@ -116,7 +116,7 @@
    public MidResult[] createCommand(Boolean isLowPower, Command command, Object... params) {
        String rtuAddr = command.getRtuAddr() ;
        if(rtuAddr == null){
            return new MidResult[]{(new MidResultError(ProtocolConstantV206V1_0_0.protocolName, null, "严重错误，命令中IMEI号为空，不能构建任何命令！", null))} ;
            return new MidResult[]{(new MidResultError(ProtocolConstantV206V1_0_0.protocolName, null, "严重错误，命令中Rtu地址为空，不能构建任何命令！", null))} ;
        }
        try {
            String commandCode = command.getCode() ;

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

@@ -28,6 +28,8 @@
    public static final byte P_Head_Byte = (byte)0x68 ;
    public static final byte P_Tail_Byte = (byte)0x16 ;

    public static final byte P_Default_mode = (byte)0x0F ;//默认工作模式

    public static final String P_Head_Hex = "68" ;
    public static final String P_Tail_Hex = "16" ;


 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V1_0_0/parse/Cd_02_Down.java

@@ -2,17 +2,15 @@

import com.dy.common.mw.protocol.*;
import com.dy.common.mw.protocol.p206V1_0_0.*;
import com.dy.common.mw.protocol.p206V1_0_0.parse.global.GlCreate;
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;

@AnnotationCodeDown(ifAny={
        CodeV1_0_1.cd_06
})
public class Cd_02_Down  implements CodeParse {

    //private static Logger log = LogManager.getLogger(Cd_XY_Down.class);
    //private static Logger log = LogManager.getLogger(Cd_02_Down.class);

    @Override
    public MidResult[] parse(Boolean isLowPower, CodeParseParams params, CodeParseCallback callback) throws Exception {
@@ -21,7 +19,7 @@

        MidResultToRtu midRs = new MidResultToRtu() ;
        midRs.protocolName = para.protocolName ;//协议名称
        midRs.rtuAddr = para.rtuAddr ;//IMEI号（电信平台设备IMEI）
        midRs.rtuAddr = para.rtuAddr ;//Rtu地址（电信平台设备IMEI）
        midRs.commandId = para.commandId ;//命令ID，发起命令的客户端(web端)生成，以匹配命令结果
        midRs.downCode = para.commandCode ;//下行命令功能码;
        midRs.downBuffer = bs ;//下行命令数据
@@ -42,9 +40,9 @@
    }
    /**
     * æž„造下行数据
     * @param para
     * @return
     * @throws Exception
     * @param para å‚æ•°
     * @return å­—节数组
     * @throws Exception å¼‚常
     */
    public byte[] doParse(ParseParamsForDownV1_0_1 para) throws Exception {
        CommonV1_0_1 commonV1_0_1 = new CommonV1_0_1() ;
@@ -62,34 +60,21 @@
        index++ ;
        bsHead[index] = commonV1_0_1.createCtrl((byte)0) ;

        String rtuAddr = para.rtuAddr ;
        String rtuAddr1 = rtuAddr.substring(0, 6) ;
        String rtuAddr2 = rtuAddr.substring(6) ;

        index++ ;
        ByteUtil.string2BCD_BE(bsHead, rtuAddr1, index) ;
        index += 3 ;

        Integer rtuAddr2Int = Integer.parseInt(rtuAddr2) ;
        ByteUtilUnsigned.short2Bytes_BE(bsHead, rtuAddr2Int.shortValue(), index);
        index += 2 ;
        GlCreate.createRtuAddr(para.rtuAddr, bsHead, index);
        index += 5 ;

        ByteUtil.hex2Bytes(para.commandCode, bsHead, index) ;

        byte[] bs = new byte[7] ;
        bs[0] = (byte)0xF2 ;
        ByteUtil.string2BCD_BE(bs, DateTime.yyMMddhhmmss(), 1) ;
        bs[0] = (byte)0xF2 ;//数据域： 1 ä¸ªå­—节，F0 ç™»å½•ï¼Œ F1 é€€å‡ºç™»å½•ï¼ŒF2 åœ¨çº¿ä¿æŒã€‚
        GlCreate.createTp(bs, 1);

        bytes = ByteUtil.bytesMerge(bsHead, bs) ;

        int len = bytes.length + ProtocolConstantV206V1_0_0.lenTail;
        bytes[ProtocolConstantV206V1_0_0.dataLenIndex] = (byte)len ;
        GlCreate.createLen(bytes);//长度放字节数组中

        int crc = new CRC8_for_2_0().CRC8(bytes, ProtocolConstantV206V1_0_0.ctrlIndex, bytes.length -1) ;
        bs = new byte[ProtocolConstantV206V1_0_0.lenTail] ;
        bs[0] = (byte)crc ;
        bs[1] = ProtocolConstantV206V1_0_0.P_Tail_Byte ;
        bytes = ByteUtil.bytesMerge(bytes, bs) ;
        bytes = GlCreate.createCrcTail(bytes) ;//CRC和尾叠加字节数组中

        return bytes ;
    }

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

@@ -14,7 +14,7 @@
@SuppressWarnings("unused")
public class Cd_02_Up implements CodeParse{

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

    /**
     * åˆ†æžä¸Šè¡Œæ•°æ®
@@ -33,7 +33,7 @@

        MidResultFromRtu midRs = new MidResultFromRtu() ;
        midRs.protocolName = para.protocolName ;//协议名称
        midRs.rtuAddr = para.rtuAddr ;//IMEI号
        midRs.rtuAddr = para.rtuAddr ;//Rtu地址
        midRs.upCode = para.upCode ;//上行数据中的功能码
        midRs.upHex = para.upHex ;//上行数据十六进制形式
        midRs.upBuffer = para.upBuffer ;//上行数据字节数组
@@ -55,7 +55,7 @@

        MidResultToRtu confirmCommand = new MidResultToRtu() ;
        confirmCommand.protocolName = para.protocolName ;//协议名称
        confirmCommand.rtuAddr = para.rtuAddr ;//IMEI号
        confirmCommand.rtuAddr = para.rtuAddr ;//Rtu地址
        confirmCommand.commandId = Command.defaultId ;//命令ID，发起命令的客户端(web端)生成，以匹配命令结果
        confirmCommand.downCode = confirmComCode ;//下行命令功能码;
        confirmCommand.downBuffer = data ;//下行命令数据

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V1_0_0/parse/Cd_83_Down.java

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

import com.dy.common.mw.protocol.*;
import com.dy.common.mw.protocol.p206V1_0_0.CodeV1_0_1;
import com.dy.common.mw.protocol.p206V1_0_0.CommonV1_0_1;
import com.dy.common.mw.protocol.p206V1_0_0.ParseParamsForDownV1_0_1;
import com.dy.common.mw.protocol.p206V1_0_0.ProtocolConstantV206V1_0_0;
import com.dy.common.mw.protocol.p206V1_0_0.parse.global.GlCreate;
import com.dy.common.util.ByteUtil;

@AnnotationCodeDown(ifAny={
        CodeV1_0_1.cd_83
})
public class Cd_83_Down implements CodeParse {

    //private static Logger log = LogManager.getLogger(Cd_C0_Down.class);

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

        MidResultToRtu midRs = new MidResultToRtu() ;
        midRs.protocolName = para.protocolName ;//协议名称
        midRs.rtuAddr = para.rtuAddr ;//Rtu地址（电信平台设备IMEI）
        midRs.commandId = para.commandId ;//命令ID，发起命令的客户端(web端)生成，以匹配命令结果
        midRs.downCode = para.commandCode ;//下行命令功能码;
        midRs.downBuffer = bs ;//下行命令数据
        midRs.downBufHex = ByteUtil.bytes2Hex(bs, true) ;//下行命令数据十六进制形式
        midRs.hasResponse = true ;//是否有应答
        midRs.maxSendTimes = null ;//命令最大发送次数(当收不到应答时，将重发)，如果不设置，命令缓存器进行补充设置
        midRs.isCachForOffLine = true ;//RTU不在线，命令是否缓存，低功耗时为true

        //对RTU上行数据的应答
        midRs.hasResponse = false ;//是否有应答
        midRs.maxSendTimes = 1 ;//对RTU上行数据应答，所以只需发一次
        if(isLowPower != null && isLowPower.booleanValue()){
            //低功耗时
            midRs.isQuickSend = true ;
        }

        return new MidResult[]{midRs} ;
    }

    /**
     * æž„造下行数据
     * @param para å‚æ•°
     * @return å­—节数组
     * @throws Exception å¼‚常
     */
    public byte[] doParse(ParseParamsForDownV1_0_1 para) throws Exception {
        CommonV1_0_1 commonV1_0_1 = new CommonV1_0_1() ;
        byte[] bytes ;
        byte[] bsHead = new byte[ProtocolConstantV206V1_0_0.lenHead2Code] ;
        byte index = 0 ;
        bsHead[index] = ProtocolConstantV206V1_0_0.P_Head_Byte ;

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

        index++ ;
        bsHead[index] = ProtocolConstantV206V1_0_0.P_Head_Byte ;

        index++ ;
        bsHead[index] = commonV1_0_1.createCtrl((byte)0) ;

        index++ ;
        GlCreate.createRtuAddr(para.rtuAddr, bsHead, index);
        index += 5 ;

        ByteUtil.hex2Bytes(para.commandCode, bsHead, index) ;

        byte[] bs = new byte[7] ;
        //确认帧的数据域用于遥测终端工作模式的确认或转换。数据为 1 ä¸ªå­—节 HEX，00H æ—¶é¥æµ‹ç»ˆ
        //端在兼容工作状态； 01H æ—¶é¥æµ‹ç»ˆç«¯åœ¨è‡ªæŠ¥å·¥ä½œçŠ¶æ€ï¼› 02H æ—¶é¥æµ‹ç»ˆç«¯åœ¨æŸ¥è¯¢/应答工作
        //状态； 03H æ—¶é¥æµ‹ç»ˆç«¯åœ¨è°ƒè¯•/维修状态。
        bs[0] = ProtocolConstantV206V1_0_0.P_Default_mode;//数据域
        GlCreate.createTp(bs, 1);

        bytes = ByteUtil.bytesMerge(bsHead, bs) ;

        GlCreate.createLen(bytes);//长度放字节数组中

        bytes = GlCreate.createCrcTail(bytes) ;//CRC和尾叠加字节数组中

        return bytes ;
    }

}

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

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

import com.dy.common.mw.protocol.*;
import com.dy.common.mw.protocol.p206V1_0_0.*;
import com.dy.common.mw.protocol.p206V1_0_0.parse.global.GlParse;
import com.dy.common.util.ByteUtil;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

@AnnotationCodeUp(ifAny={
        CodeV1_0_1.cd_83
})
@SuppressWarnings("unused")
public class Cd_83_Up implements CodeParse {

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

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

        MidResultFromRtu midRs = new MidResultFromRtu() ;
        midRs.protocolName = para.protocolName ;//协议名称
        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 ;//主动上报

        String confirmComCode = CodeV1_0_1.cd_C0 ;
        ParseParamsForDownV1_0_1 downCpParams  = new ParseParamsForDownV1_0_1() ;
        downCpParams.setValue(
                ProtocolConstantV206V1_0_0.protocolName,
                para.rtuAddr,
                Command.defaultId,
                confirmComCode,
                null,
                null);
        //构造应答
        byte[] data = new Cd_83_Down().doParse(downCpParams) ;

        MidResultToRtu confirmCommand = new MidResultToRtu() ;
        confirmCommand.protocolName = para.protocolName ;//协议名称
        confirmCommand.rtuAddr = para.rtuAddr ;//Rtu地址
        confirmCommand.commandId = Command.defaultId ;//命令ID，发起命令的客户端(web端)生成，以匹配命令结果
        confirmCommand.downCode = confirmComCode ;//下行命令功能码;
        confirmCommand.downBuffer = data ;//下行命令数据
        confirmCommand.downBufHex = ByteUtil.bytes2Hex(data, true) ;//下行命令数据十六进制形式
        confirmCommand.hasResponse = false ;//是否有应答
        confirmCommand.maxSendTimes = 1 ;//命令最大发送次数(当收不到应答时，将重发2次)，如果不设置，命令缓存器进行补充设置
        confirmCommand.isSendFirst = true ;//确认命令，优先发送
        confirmCommand.isCachForOffLine = false ;//RTU不在线，命令是否缓存

        callback.callback(midRs.reportOrResponse_trueOrFalse);
        return new MidResult[]{midRs, confirmCommand} ;
    }
    /**
     * æ‰§è¡Œåˆ†æž
     * @param bs å­—节数组
     * @param bsLen å­—节长度（总包长，包括包头和包尾）
     * @param dataCode åŠŸèƒ½ç 
     * @param data æ•°æ®
     * @throws Exception å¼‚常
     */
    protected void doParse(byte[] bs, int bsLen, String dataCode, Data data) throws Exception {
        short index = ProtocolConstantV206V1_0_0.dataIndex ;
        byte opType = bs[ProtocolConstantV206V1_0_0.dataIndex];
        if(opType == 1 || opType == 3 || opType == 8){
            this.doParseOpen(opType, bs, bsLen, dataCode, data);
        }else{
            this.doParseClose(opType, bs, bsLen, dataCode, data);
        }
    }
    private void doParseOpen(byte opType, byte[] bs, int bsLen, String dataCode, Data data) throws Exception {
        DataV1_0_1 dV1 = (DataV1_0_1)data.getSubData() ;
        DataCd83OpenVo cdData = new DataCd83OpenVo() ;
        dV1.dataCd83OpenVo = cdData ;

        cdData.type = opType ;

        short index = ProtocolConstantV206V1_0_0.dataIndex + 1 ;
        //累计流量：5字节BCD码，取值范围0~9999999999，单位为m3。
        cdData.totalAmount = 0.0D ;
        int tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
        index++ ;
        cdData.totalAmount += tpInt;
        tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
        index++ ;
        cdData.totalAmount += tpInt * 100.0 ;
        tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
        index++ ;
        cdData.totalAmount += tpInt * 10000.0 ;
        tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
        index++ ;
        cdData.totalAmount += tpInt * 1000000.0 ;
        tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
        index++ ;
        cdData.totalAmount += tpInt * 100000000.0 ;

        //用水户号数据格式：5字节BCD码低位在前高位在后。
        cdData.clientNum = ByteUtil.BCD2String_LE(bs, index, index + 4) ;
        index += 5 ;

        //IC卡号格式：4字节HEX码低位在前高位在后。
        cdData.clientNum = ByteUtil.bytesToHex(bs, index, index + 3) ;
        index += 4 ;

        //用水户余额：用户余额4字节BCD码，取值范围0.00~999999.99，单位为元。
        cdData.remainMoney = 0.0D ;
        tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
        index++ ;
        cdData.remainMoney += tpInt/100.0 ;
        tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
        index++ ;
        cdData.remainMoney += tpInt;
        tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
        index++ ;
        cdData.remainMoney += tpInt * 100.0 ;
        tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
        index++ ;
        cdData.remainMoney += tpInt * 10000.0 ;

        //用水户用水开始时间：6字节BCD码，顺序是年月日时分秒，其中公元年=2000+年。
        cdData.openDt = GlParse.parseTp(bs, index) ;
        index += 6 ;

        //控制器时钟
        cdData.rtuDt = GlParse.parseTp(bs, index) ;
        //index += 6 ;
    }

    private void doParseClose(byte opType, byte[] bs, int bsLen, String dataCode, Data data) throws Exception {
        DataV1_0_1 dV1 = (DataV1_0_1)data.getSubData() ;
        DataCd83CloseVo cdData = new DataCd83CloseVo() ;
        dV1.dataCd83CloseVo = cdData ;

        cdData.type = opType ;

        short index = ProtocolConstantV206V1_0_0.dataIndex + 1 ;
        //累计流量：5字节BCD码，取值范围0~9999999999，单位为m3。
        cdData.totalAmount = 0.0D ;
        int tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
        index++ ;
        cdData.totalAmount += tpInt;
        tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
        index++ ;
        cdData.totalAmount += tpInt * 100.0 ;
        tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
        index++ ;
        cdData.totalAmount += tpInt * 10000.0 ;
        tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
        index++ ;
        cdData.totalAmount += tpInt * 1000000.0 ;
        tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
        index++ ;
        cdData.totalAmount += tpInt * 100000000.0 ;

        //用水户号数据格式：5字节BCD码低位在前高位在后。
        cdData.clientNum = ByteUtil.BCD2String_LE(bs, index, index + 4) ;
        index += 5 ;

        //IC卡号格式：4字节HEX码低位在前高位在后。
        cdData.clientNum = ByteUtil.bytesToHex(bs, index, index + 3) ;
        index += 4 ;

        //用水户余额：用户余额4字节BCD码，取值范围0.00~999999.99，单位为元。
        cdData.remainMoney = 0.0D ;
        tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
        index++ ;
        cdData.remainMoney += tpInt/100.0 ;
        tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
        index++ ;
        cdData.remainMoney += tpInt;
        tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
        index++ ;
        cdData.remainMoney += tpInt * 100.0 ;
        tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
        index++ ;
        cdData.remainMoney += tpInt * 10000.0 ;

        //用水户用水开始时间：6字节BCD码，顺序是年月日时分秒，其中公元年=2000+年。
        cdData.openDt = GlParse.parseTp(bs, index) ;
        index += 6 ;

        //用水户用水结束时间：6字节BCD码，顺序是年月日时分秒，其中公元年=2000+年。
        cdData.closeDt = GlParse.parseTp(bs, index) ;
        index += 6 ;

        //用水户本次用水量：累计流量5字节BCD码，取值范围0~9999999999，单位为m3。
        cdData.thisAmount = 0.0D ;
        tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
        index++ ;
        cdData.thisAmount += tpInt;
        tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
        index++ ;
        cdData.thisAmount += tpInt * 100.0 ;
        tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
        index++ ;
        cdData.thisAmount += tpInt * 10000.0 ;
        tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
        index++ ;
        cdData.thisAmount += tpInt * 1000000.0 ;
        tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
        index++ ;
        cdData.thisAmount += tpInt * 100000000.0 ;

        //用水户本次消费金额：用户余额4字节BCD码，取值范围0.00~999999.99，单位为元。
        cdData.thisMoney = 0.0D ;
        tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
        index++ ;
        cdData.thisMoney += tpInt/100.0 ;
        tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
        index++ ;
        cdData.thisMoney += tpInt;
        tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
        index++ ;
        cdData.thisMoney += tpInt * 100.0 ;
        tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
        index++ ;
        cdData.thisMoney += tpInt * 10000.0 ;

        //用水户本次用水时长：用水时长2字节BCD码，取值范围0~9999，单位为分钟。
        cdData.thisTime = 0 ;
        tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
        index++ ;
        cdData.thisTime += tpInt;
        tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
        index++ ;
        cdData.thisTime += tpInt * 100 ;

        //控制器时钟
        cdData.rtuDt = GlParse.parseTp(bs, index) ;
        //index += 6 ;
    }
}

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V1_0_0/parse/Cd_84_Down.java

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

import com.dy.common.mw.protocol.*;
import com.dy.common.mw.protocol.p206V1_0_0.CodeV1_0_1;
import com.dy.common.mw.protocol.p206V1_0_0.CommonV1_0_1;
import com.dy.common.mw.protocol.p206V1_0_0.ParseParamsForDownV1_0_1;
import com.dy.common.mw.protocol.p206V1_0_0.ProtocolConstantV206V1_0_0;
import com.dy.common.mw.protocol.p206V1_0_0.parse.global.GlCreate;
import com.dy.common.util.ByteUtil;

@AnnotationCodeDown(ifAny={
        CodeV1_0_1.cd_83
})
public class Cd_84_Down implements CodeParse {

    //private static Logger log = LogManager.getLogger(Cd_C0_Down.class);

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

        MidResultToRtu midRs = new MidResultToRtu() ;
        midRs.protocolName = para.protocolName ;//协议名称
        midRs.rtuAddr = para.rtuAddr ;//Rtu地址（电信平台设备IMEI）
        midRs.commandId = para.commandId ;//命令ID，发起命令的客户端(web端)生成，以匹配命令结果
        midRs.downCode = para.commandCode ;//下行命令功能码;
        midRs.downBuffer = bs ;//下行命令数据
        midRs.downBufHex = ByteUtil.bytes2Hex(bs, true) ;//下行命令数据十六进制形式
        midRs.hasResponse = true ;//是否有应答
        midRs.maxSendTimes = null ;//命令最大发送次数(当收不到应答时，将重发)，如果不设置，命令缓存器进行补充设置
        midRs.isCachForOffLine = true ;//RTU不在线，命令是否缓存，低功耗时为true

        //对RTU上行数据的应答
        midRs.hasResponse = false ;//是否有应答
        midRs.maxSendTimes = 1 ;//对RTU上行数据应答，所以只需发一次
        if(isLowPower != null && isLowPower.booleanValue()){
            //低功耗时
            midRs.isQuickSend = true ;
        }

        return new MidResult[]{midRs} ;
    }

    /**
     * æž„造下行数据
     * @param para å‚æ•°
     * @return å­—节数组
     * @throws Exception å¼‚常
     */
    public byte[] doParse(ParseParamsForDownV1_0_1 para) throws Exception {
        CommonV1_0_1 commonV1_0_1 = new CommonV1_0_1() ;
        byte[] bytes ;
        byte[] bsHead = new byte[ProtocolConstantV206V1_0_0.lenHead2Code] ;
        byte index = 0 ;
        bsHead[index] = ProtocolConstantV206V1_0_0.P_Head_Byte ;

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

        index++ ;
        bsHead[index] = ProtocolConstantV206V1_0_0.P_Head_Byte ;

        index++ ;
        bsHead[index] = commonV1_0_1.createCtrl((byte)0) ;

        index++ ;
        GlCreate.createRtuAddr(para.rtuAddr, bsHead, index);
        index += 5 ;

        ByteUtil.hex2Bytes(para.commandCode, bsHead, index) ;

        byte[] bs = new byte[7] ;
        //确认帧的数据域用于遥测终端工作模式的确认或转换。数据为 1 ä¸ªå­—节 HEX，00H æ—¶é¥æµ‹ç»ˆ
        //端在兼容工作状态； 01H æ—¶é¥æµ‹ç»ˆç«¯åœ¨è‡ªæŠ¥å·¥ä½œçŠ¶æ€ï¼› 02H æ—¶é¥æµ‹ç»ˆç«¯åœ¨æŸ¥è¯¢/应答工作
        //状态； 03H æ—¶é¥æµ‹ç»ˆç«¯åœ¨è°ƒè¯•/维修状态。
        bs[0] = ProtocolConstantV206V1_0_0.P_Default_mode;//数据域
        GlCreate.createTp(bs, 1);

        bytes = ByteUtil.bytesMerge(bsHead, bs) ;

        GlCreate.createLen(bytes);//长度放字节数组中

        bytes = GlCreate.createCrcTail(bytes) ;//CRC和尾叠加字节数组中

        return bytes ;
    }

}

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

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

import com.dy.common.mw.protocol.*;
import com.dy.common.mw.protocol.p206V1_0_0.*;
import com.dy.common.mw.protocol.p206V1_0_0.parse.global.GlParse;
import com.dy.common.util.ByteUtil;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

@AnnotationCodeUp(ifAny={
        CodeV1_0_1.cd_83
})
@SuppressWarnings("unused")
public class Cd_84_Up implements CodeParse {

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

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

        MidResultFromRtu midRs = new MidResultFromRtu() ;
        midRs.protocolName = para.protocolName ;//协议名称
        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 ;//主动上报

        String confirmComCode = CodeV1_0_1.cd_C0 ;
        ParseParamsForDownV1_0_1 downCpParams  = new ParseParamsForDownV1_0_1() ;
        downCpParams.setValue(
                ProtocolConstantV206V1_0_0.protocolName,
                para.rtuAddr,
                Command.defaultId,
                confirmComCode,
                null,
                null);
        //构造应答
        byte[] data = new Cd_84_Down().doParse(downCpParams) ;

        MidResultToRtu confirmCommand = new MidResultToRtu() ;
        confirmCommand.protocolName = para.protocolName ;//协议名称
        confirmCommand.rtuAddr = para.rtuAddr ;//Rtu地址
        confirmCommand.commandId = Command.defaultId ;//命令ID，发起命令的客户端(web端)生成，以匹配命令结果
        confirmCommand.downCode = confirmComCode ;//下行命令功能码;
        confirmCommand.downBuffer = data ;//下行命令数据
        confirmCommand.downBufHex = ByteUtil.bytes2Hex(data, true) ;//下行命令数据十六进制形式
        confirmCommand.hasResponse = false ;//是否有应答
        confirmCommand.maxSendTimes = 1 ;//命令最大发送次数(当收不到应答时，将重发2次)，如果不设置，命令缓存器进行补充设置
        confirmCommand.isSendFirst = true ;//确认命令，优先发送
        confirmCommand.isCachForOffLine = false ;//RTU不在线，命令是否缓存

        callback.callback(midRs.reportOrResponse_trueOrFalse);
        return new MidResult[]{midRs, confirmCommand} ;
    }
    /**
     * æ‰§è¡Œåˆ†æž
     * @param bs å­—节数组
     * @param bsLen å­—节长度（总包长，包括包头和包尾）
     * @param dataCode åŠŸèƒ½ç 
     * @param data æ•°æ®
     * @throws Exception å¼‚常
     */
    protected void doParse(byte[] bs, int bsLen, String dataCode, Data data) throws Exception {
        DataV1_0_1 dV1 = (DataV1_0_1)data.getSubData() ;
        DataCd84Vo cdData = new DataCd84Vo() ;
        dV1.dataCd84Vo = cdData ;

        short index = ProtocolConstantV206V1_0_0.dataIndex ;
        //用水户号数据格式：5字节BCD码低位在前高位在后。
        cdData.clientNum = ByteUtil.BCD2String_LE(bs, index, index + 4) ;
        index += 5 ;

        //用水户余额：用户余额4字节BCD码，取值范围0.00~999999.99，单位为元。
        cdData.remainMoney = 0.0D ;
        int tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
        index++ ;
        cdData.remainMoney += tpInt/100.0 ;
        tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
        index++ ;
        cdData.remainMoney += tpInt;
        tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
        index++ ;
        cdData.remainMoney += tpInt * 100.0 ;
        tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
        index++ ;
        cdData.remainMoney += tpInt * 10000.0 ;

        //累计流量：5字节BCD码，取值范围0~9999999999，单位为m3。
        cdData.totalAmount = 0.0D ;
        tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
        index++ ;
        cdData.totalAmount += tpInt;
        tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
        index++ ;
        cdData.totalAmount += tpInt * 100.0 ;
        tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
        index++ ;
        cdData.totalAmount += tpInt * 10000.0 ;
        tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
        index++ ;
        cdData.totalAmount += tpInt * 1000000.0 ;
        tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
        index++ ;
        cdData.totalAmount += tpInt * 100000000.0 ;

        //瞬时流量：5字节BCD码，取值范围0~9999999.999，单位为m3/h。
        cdData.instantAmount = 0.0D ;
        tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
        index++ ;
        cdData.instantAmount += tpInt/1000.0 ;
        tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
        index++ ;
        cdData.instantAmount += tpInt/10.0 ;
        tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
        index++ ;
        cdData.instantAmount += tpInt * 10.0 ;
        tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
        index++ ;
        cdData.instantAmount += tpInt * 1000.0 ;
        tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
        index++ ;
        cdData.instantAmount += tpInt * 100000.0 ;

        //控制器时钟
        cdData.rtuDt = GlParse.parseTp(bs, index) ;
        //index += 6 ;
    }

}

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V1_0_0/parse/Cd_C0_Down.java

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

import com.dy.common.mw.protocol.*;
import com.dy.common.mw.protocol.p206V1_0_0.CodeV1_0_1;
import com.dy.common.mw.protocol.p206V1_0_0.CommonV1_0_1;
import com.dy.common.mw.protocol.p206V1_0_0.ParseParamsForDownV1_0_1;
import com.dy.common.mw.protocol.p206V1_0_0.ProtocolConstantV206V1_0_0;
import com.dy.common.mw.protocol.p206V1_0_0.parse.global.GlCreate;
import com.dy.common.util.ByteUtil;

@AnnotationCodeDown(ifAny={
        CodeV1_0_1.cd_C0
})
public class Cd_C0_Down  implements CodeParse {

    //private static Logger log = LogManager.getLogger(Cd_C0_Down.class);

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

        MidResultToRtu midRs = new MidResultToRtu() ;
        midRs.protocolName = para.protocolName ;//协议名称
        midRs.rtuAddr = para.rtuAddr ;//Rtu地址（电信平台设备IMEI）
        midRs.commandId = para.commandId ;//命令ID，发起命令的客户端(web端)生成，以匹配命令结果
        midRs.downCode = para.commandCode ;//下行命令功能码;
        midRs.downBuffer = bs ;//下行命令数据
        midRs.downBufHex = ByteUtil.bytes2Hex(bs, true) ;//下行命令数据十六进制形式
        midRs.hasResponse = true ;//是否有应答
        midRs.maxSendTimes = null ;//命令最大发送次数(当收不到应答时，将重发)，如果不设置，命令缓存器进行补充设置
        midRs.isCachForOffLine = true ;//RTU不在线，命令是否缓存，低功耗时为true

        //对RTU上行数据的应答
        midRs.hasResponse = false ;//是否有应答
        midRs.maxSendTimes = 1 ;//对RTU上行数据应答，所以只需发一次
        if(isLowPower != null && isLowPower.booleanValue()){
            //低功耗时
            midRs.isQuickSend = true ;
        }

        return new MidResult[]{midRs} ;
    }

    /**
     * æž„造下行数据
     * @param para å‚æ•°
     * @return å­—节数组
     * @throws Exception å¼‚常
     */
    public byte[] doParse(ParseParamsForDownV1_0_1 para) throws Exception {
        CommonV1_0_1 commonV1_0_1 = new CommonV1_0_1() ;
        byte[] bytes ;
        byte[] bsHead = new byte[ProtocolConstantV206V1_0_0.lenHead2Code] ;
        byte index = 0 ;
        bsHead[index] = ProtocolConstantV206V1_0_0.P_Head_Byte ;

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

        index++ ;
        bsHead[index] = ProtocolConstantV206V1_0_0.P_Head_Byte ;

        index++ ;
        bsHead[index] = commonV1_0_1.createCtrl((byte)0) ;

        index++ ;
        GlCreate.createRtuAddr(para.rtuAddr, bsHead, index);
        index += 5 ;

        ByteUtil.hex2Bytes(para.commandCode, bsHead, index) ;

        byte[] bs = new byte[7] ;
        //确认帧的数据域用于遥测终端工作模式的确认或转换。数据为 1 ä¸ªå­—节 HEX，00H æ—¶é¥æµ‹ç»ˆ
        //端在兼容工作状态； 01H æ—¶é¥æµ‹ç»ˆç«¯åœ¨è‡ªæŠ¥å·¥ä½œçŠ¶æ€ï¼› 02H æ—¶é¥æµ‹ç»ˆç«¯åœ¨æŸ¥è¯¢/应答工作
        //状态； 03H æ—¶é¥æµ‹ç»ˆç«¯åœ¨è°ƒè¯•/维修状态。
        bs[0] = ProtocolConstantV206V1_0_0.P_Default_mode;//数据域
        GlCreate.createTp(bs, 1);

        bytes = ByteUtil.bytesMerge(bsHead, bs) ;

        GlCreate.createLen(bytes);//长度放字节数组中

        bytes = GlCreate.createCrcTail(bytes) ;//CRC和尾叠加字节数组中

        return bytes ;
    }

}

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V1_0_0/parse/Cd_C0_Up.java

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


import com.dy.common.mw.protocol.*;
import com.dy.common.mw.protocol.p206V1_0_0.*;
import com.dy.common.mw.protocol.p206V1_0_0.parse.global.GlParse;
import com.dy.common.util.ByteUtil;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

@AnnotationCodeUp(ifAny={
        CodeV1_0_1.cd_C0
})
@SuppressWarnings("unused")
public class Cd_C0_Up implements CodeParse {

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

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

        MidResultFromRtu midRs = new MidResultFromRtu() ;
        midRs.protocolName = para.protocolName ;//协议名称
        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 ;//主动上报

        String confirmComCode = CodeV1_0_1.cd_C0 ;
        ParseParamsForDownV1_0_1 downCpParams  = new ParseParamsForDownV1_0_1() ;
        downCpParams.setValue(
                ProtocolConstantV206V1_0_0.protocolName,
                para.rtuAddr,
                Command.defaultId,
                confirmComCode,
                null,
                null);
        //构造应答
        byte[] data = new Cd_02_Down().doParse(downCpParams) ;

        MidResultToRtu confirmCommand = new MidResultToRtu() ;
        confirmCommand.protocolName = para.protocolName ;//协议名称
        confirmCommand.rtuAddr = para.rtuAddr ;//Rtu地址
        confirmCommand.commandId = Command.defaultId ;//命令ID，发起命令的客户端(web端)生成，以匹配命令结果
        confirmCommand.downCode = confirmComCode ;//下行命令功能码;
        confirmCommand.downBuffer = data ;//下行命令数据
        confirmCommand.downBufHex = ByteUtil.bytes2Hex(data, true) ;//下行命令数据十六进制形式
        confirmCommand.hasResponse = false ;//是否有应答
        confirmCommand.maxSendTimes = 1 ;//命令最大发送次数(当收不到应答时，将重发2次)，如果不设置，命令缓存器进行补充设置
        confirmCommand.isSendFirst = true ;//确认命令，优先发送
        confirmCommand.isCachForOffLine = false ;//RTU不在线，命令是否缓存

        callback.callback(midRs.reportOrResponse_trueOrFalse);
        return new MidResult[]{midRs, confirmCommand} ;
    }
    /**
     * æ‰§è¡Œåˆ†æž
     * @param bs å­—节数组
     * @param bsLen å­—节长度（总包长，包括包头和包尾）
     * @param dataCode åŠŸèƒ½ç 
     * @param data æ•°æ®
     * @throws Exception å¼‚常
     */
    protected void doParse(byte[] bs, int bsLen, String dataCode, Data data) throws Exception {
        DataV1_0_1 dV1 = (DataV1_0_1)data.getSubData() ;
        DataCdC0Vo cdData = new DataCdC0Vo() ;
        dV1.dataCdC0Vo = cdData ;

        boolean hasWaterAmount = false ;//是否有流量数据
        boolean hasWaterPress = false ;//是否有水压数据
        boolean hasEleVolt = false ;//是否有电压数据
        boolean hasSignal = false ;//是否有信号强度数据
        boolean hasAlarmStatus = false ;//是否有数据

        short index = ProtocolConstantV206V1_0_0.dataIndex ;

        byte tmpBt1 = bs[index] ;
        index++ ;
        if(((tmpBt1 & 4) >> 2) == 1){
            hasWaterAmount = true ;
        }

        byte tmpBt2 = bs[index] ;
        index++ ;
        if(((tmpBt2 & 0x10) >> 4) == 1){
            hasAlarmStatus = true ;
        }
        if(((tmpBt2 & 0x20) >> 5) == 1){
            hasWaterPress = true ;
        }
        if(((tmpBt2 & 0x40) >> 6) == 1){
            hasEleVolt = true ;
        }
        if(((tmpBt2 & 0x80) >> 7) == 1){
            hasSignal = true ;
        }

        if(hasWaterAmount){
            //瞬时流量：5字节BCD码，取值范围0~9999999.999，单位为m3/h。
            cdData.instantAmount = 0.0D ;
            int tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
            index++ ;
            cdData.instantAmount += tpInt/1000.0 ;
            tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
            index++ ;
            cdData.instantAmount += tpInt/10.0 ;
            tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
            index++ ;
            cdData.instantAmount += tpInt * 10.0 ;
            tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
            index++ ;
            cdData.instantAmount += tpInt * 1000.0 ;
            tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
            index++ ;
            cdData.instantAmount += tpInt * 100000.0 ;

            //累计流量：5字节BCD码，取值范围0~9999999999，单位为m3。
            cdData.totalAmount = 0.0D ;
            tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
            index++ ;
            cdData.totalAmount += tpInt;
            tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
            index++ ;
            cdData.totalAmount += tpInt * 100.0 ;
            tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
            index++ ;
            cdData.totalAmount += tpInt * 10000.0 ;
            tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
            index++ ;
            cdData.totalAmount += tpInt * 1000000.0 ;
            tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
            index++ ;
            cdData.totalAmount += tpInt * 100000000.0 ;

            //损失流量：5字节BCD码，取值范围0~9999999999，单位为m3。
            cdData.lossAmount = 0.0D ;
            tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
            index++ ;
            cdData.lossAmount += tpInt;
            tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
            index++ ;
            cdData.lossAmount += tpInt * 100.0 ;
            tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
            index++ ;
            cdData.lossAmount += tpInt * 10000.0 ;
            tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
            index++ ;
            cdData.lossAmount += tpInt * 1000000.0 ;
            tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
            index++ ;
            cdData.lossAmount += tpInt * 100000000.0 ;
        }
        if(hasWaterPress){
            //水压：4字节BCD码，取值范围0~999999.99，单位为KPa。
            cdData.waterPress = 0.0D ;
            int tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
            index++ ;
            cdData.waterPress += tpInt/100.0 ;
            tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
            index++ ;
            cdData.waterPress += tpInt;
            tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
            index++ ;
            cdData.waterPress += tpInt * 100.0 ;
            tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
            index++ ;
            cdData.waterPress += tpInt * 10000.0 ;
        }
        if(hasEleVolt){
            //电池电压：4字节BCD码，取值范围0~99.99，单位为V。
            cdData.batteryVolt = 0.0D ;//蓄电池电压
            cdData.sunVolt = 0.0D ;//太阳能电压
            int tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
            index++ ;
            cdData.batteryVolt += tpInt/100.0 ;
            tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
            index++ ;
            cdData.batteryVolt += tpInt;
            //太阳能电压：4字节BCD码，取值范围0~99.99，单位为V。
            tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
            index++ ;
            cdData.sunVolt += tpInt/100.0 ;
            tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
            index++ ;
            cdData.sunVolt += tpInt;
        }
        if(hasSignal){
            //信号强度：1字节BCD码，取值范围0~99。
            cdData.signal = 0 ;
            int tpInt = ByteUtil.BCD2Int_LE(bs, index, index) ;
            index++ ;
            cdData.signal += tpInt  ;
        }
        if(hasAlarmStatus){
            //报警数据
            cdData.alarmVo = GlParse.parseAlarm(bs, index) ;
            index += 2 ;
            //状态数据
            cdData.stateVo = GlParse.parseState(bs, index) ;
            index += 2 ;
        }
        cdData.rtuDt = GlParse.parseTp(bs, index) ;

    }
}

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

New file
@@ -0,0 +1,39 @@
package com.dy.common.mw.protocol.p206V1_0_0.parse.global;

import com.dy.common.mw.protocol.p206V1_0_0.ProtocolConstantV206V1_0_0;
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;

public class GlCreate {

    public static void createRtuAddr(String rtuAddr, byte[] bs, int index) throws Exception {
        String rtuAddr1 = rtuAddr.substring(0, 6) ;
        String rtuAddr2 = rtuAddr.substring(6) ;

        index++ ;
        ByteUtil.string2BCD_BE(bs, rtuAddr1, index) ;
        index += 3 ;

        Integer rtuAddr2Int = Integer.parseInt(rtuAddr2) ;
        ByteUtilUnsigned.short2Bytes_BE(bs, rtuAddr2Int.shortValue(), index);
    }

    public static void createTp(byte[] bs, int index) throws Exception {
        ByteUtil.string2BCD_BE(bs, DateTime.yyMMddhhmmss(), index) ;
    }

    public static void createLen(byte[] bs) throws Exception {
        int len = bs.length + ProtocolConstantV206V1_0_0.lenTail;
        bs[ProtocolConstantV206V1_0_0.dataLenIndex] = (byte)len ;
    }

    public static byte[] createCrcTail(byte[] bs) throws Exception {
        int crc = new CRC8_for_2_0().CRC8(bs, ProtocolConstantV206V1_0_0.ctrlIndex, bs.length -1) ;
        bs = new byte[ProtocolConstantV206V1_0_0.lenTail] ;
        bs[0] = (byte)crc ;
        bs[1] = ProtocolConstantV206V1_0_0.P_Tail_Byte ;
        return ByteUtil.bytesMerge(bs, bs) ;
    }
}

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/protocol/p206V1_0_0/parse/global/GlParse.java

New file
@@ -0,0 +1,56 @@
package com.dy.common.mw.protocol.p206V1_0_0.parse.global;

import com.dy.common.mw.protocol.p206V1_0_0.DataAlarmVo;
import com.dy.common.mw.protocol.p206V1_0_0.DataStateVo;
import com.dy.common.util.ByteUtil;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

public class GlParse {

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

    public static DataAlarmVo parseAlarm(byte[] bs, short index){
        DataAlarmVo avo = new DataAlarmVo() ;
        byte b = bs[index] ;
        index++ ;
        avo.batteryVolt = (byte)(b & 0x2) ;
        avo.loss = (byte)(b & 0x8) ;
        avo.meter = (byte)(b & 0x20) ;

        b = bs[index] ;
        avo.valve = (byte)(b & 0x20) ;
        return avo ;
    }

    public static DataStateVo parseState(byte[] bs, short index){
        DataStateVo avo = new DataStateVo() ;
        byte b = bs[index] ;
        index++ ;
        avo.idCard = (byte)(b & 0x4) ;
        avo.work = (byte)(b & 0x8) ;
        avo.valve = (byte)(b & 0x20) ;
        return avo ;
    }

    public static String parseTp(byte[] bs, short index){
        String dt = "" ;
        try{
            dt = dt + ByteUtil.BCD2String_BE(bs, index, index) ;//秒
            index++ ;
            dt = ByteUtil.BCD2String_BE(bs, index, index) + ":" + dt ;//分
            index++ ;
            dt = ByteUtil.BCD2String_BE(bs, index, index) + " " + dt ;//时
            index++ ;
            dt = ByteUtil.BCD2String_BE(bs, index, index) + "-" + dt ;//日
            index++ ;
            bs[index] = (byte)(bs[index] & 0x10);
            dt = ByteUtil.BCD2String_BE(bs, index, index) + "-" + dt ;//月
            index++ ;
            dt = "20" + ByteUtil.BCD2String_BE(bs, index, index) + "-" + dt ;//å¹´
        }catch (Exception e){
            log.error("解析控制器时钟时异常：" + e.getMessage(), e);
        }
        return dt ;
    }
}

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

@@ -1027,6 +1027,34 @@
        }
        return new String(buf);
    }
    /**
     * å°†byte[]转换为16进制字符串
     *
     * @param bytes å¾…转换byte[]
     * @return è¿”回 è½¬æ¢åŽçš„字符串
     */
    public static String bytesToHex(byte[] bytes, int startIndex, int endIndex) {
        byte[] bs = new byte[endIndex - startIndex + 1] ;
        byte j = 0 ;
        for(int i = startIndex; i <= endIndex; i++){
            bs[j++] = bytes[i] ;
        }
        //一个byte为8位，可用两个十六进制位标识
        char[] buf = new char[bs.length * 2];
        int a = 0;
        int index = 0;
        for (byte b : bs) { // ä½¿ç”¨é™¤ä¸Žå–余进行转换
            if (b < 0) {
                a = 256 + b;
            } else {
                a = b;
            }

            buf[index++] = HEX_CHAR[a / 16];
            buf[index++] = HEX_CHAR[a % 16];
        }
        return new String(buf);
    }

    /**
     * å°†16进制字符串转换为byte[]

 pipIrr-platform/pipIrr-mw/pipIrr-mw-accept/src/main/java/com/dy/aceMw/server/busi/deal/dbSv/RtuSv.java

New file
@@ -0,0 +1,7 @@
package com.dy.aceMw.server.busi.deal.dbSv;

import org.springframework.stereotype.Service;

@Service
public class RtuSv {
}

 pipIrr-platform/pipIrr-mw/pipIrr-mw-accept/src/main/java/com/dy/aceMw/server/busi/deal/dbSv/˵Ã÷.txt

New file
@@ -0,0 +1 @@
springboot容器中的Server bean

 pipIrr-platform/Îĵµ/±àÂëÉè¼Æ.docx

Binary files differ