整理版本

zhubaomin

2025-04-07 1a2b07f01ba4616fd9e894dddf474b56d020158c

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

New file
@@ -0,0 +1,280 @@
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 上行字节数组
    * @return [【0】->true:是本协议P206，false:不是本协议;  【1】->true:是水资源协议，false:是升级协议]
    * @throws Exception  异常
    */
   public Boolean[] isThisProtocolHead(byte[] bs) throws Exception{
      if(bs == null){
         return null ;
      }else if(bs.length >= (ProtocolConstantV206V1.ctrlIndex)
            && bs[0] == ProtocolConstantV206V1.P_Head_Byte
            && bs[2] == ProtocolConstantV206V1.P_Head_Byte){
         return new Boolean[]{true, true} ;
      }else if(bs.length >= (ProtocolConstantV206V1.UG_codeIndex)
            && bs[0] == ProtocolConstantV206V1.UG_P_Head_Byte
            && bs[3] == ProtocolConstantV206V1.UG_P_Head_Byte){
         return new Boolean[]{true, false} ;
      }else{
         return new Boolean[]{false, false} ;
      }
   }

   /**
     * 检查协议类型
     * @param bs 上行字节数组
     * @return 协议类型
     * @throws Exception 异常
    */
   public Boolean protocolType_p206TrueUgFalse(byte[] bs){
      if(bs == null){
         return null ;
      }else if(bs.length >= (ProtocolConstantV206V1.ctrlIndex)
            && bs[0] == ProtocolConstantV206V1.P_Head_Byte
            && bs[2] == ProtocolConstantV206V1.P_Head_Byte){
         return true ;
      }else if(bs.length >= (ProtocolConstantV206V1.UG_codeIndex)
            && bs[0] == ProtocolConstantV206V1.UG_P_Head_Byte
            && bs[3] == ProtocolConstantV206V1.UG_P_Head_Byte){
         return false ;
      }else{
         return null ;
      }
   }

   /**
    * 检查尾
    * @param bs 上行字节数组
    * @throws Exception 异常
    */
   public void checkTail(byte[] bs) throws Exception{
      if(bs.length < 1 || bs[bs.length - 1] != ProtocolConstantV206V1.P_Tail_Byte){
         throw new Exception("上行数据尾不正确！") ;
      }
   }


   /**
    * 分析帧长度
    * @param bs 上行字节数组
    * @param p206TrueUgFalse 206协议为true，升级协议为false
    * @return 数据长度
    * @throws Exception 异常
    */
   public int parseFrameLen(byte[] bs, boolean p206TrueUgFalse)throws Exception{
      if(p206TrueUgFalse) {
         int len = ByteUtilUnsigned.byte2Byte(bs, ProtocolConstantV206V1.dataLenIndex);
         return len + ProtocolConstantV206V1.lenHead2ctrl + ProtocolConstantV206V1.lenTail;
      }else{
         int len = ByteUtilUnsigned.bytes2Short_BE(bs, ProtocolConstantV206V1.UG_dataLenIndex_start);
         return len + ProtocolConstantV206V1.UG_lenHead2Cmd + ProtocolConstantV206V1.UG_lenTail;
      }
   }


   /**
    * 分析用户数据域字节数(默认是非升级协议)
    * @param bs 上行字节数组
    * @return 数据长度
    * @throws Exception 异常
    */
   public int parseDataLen4P206(byte[] bs)throws Exception{
      int len = ByteUtilUnsigned.byte2Byte(bs, ProtocolConstantV206V1.dataLenIndex) ;
      return len - ProtocolConstantV206V1.lenCtrl - ProtocolConstantV206V1.lenRtuAddr ;
   }

   /**
    * 分析用户数据域字节数(升级协议)
    * @param bs 上行字节数组
    * @return 数据长度
    * @throws Exception 异常
    */
   public int parseDataLen4Ug(byte[] bs)throws Exception{
      int len = ByteUtilUnsigned.bytes2Short_LE(bs, ProtocolConstantV206V1.UG_dataLenIndex_start) ;
      return len - ProtocolConstantV206V1.UG_lenCmd - ProtocolConstantV206V1.UG_lenRtuAddr ;
   }


   /**
    * 分析Rtu地址
    * @param bs 上行字节数组
    * @param p206TrueUgFalse 206协议为true，升级协议为false
    * @return 控制器地址
    * @throws Exception 异常
    */
   public String parseRtuAddr(byte[] bs, boolean p206TrueUgFalse)throws Exception{
      if(p206TrueUgFalse){
         String rtuAddrBCD = "" + ByteUtil.BCD2Long_BE(bs, ProtocolConstantV206V1.rtuAddr1Index_start, ProtocolConstantV206V1.rtuAddr1Index_end) ;
         String rtuAddrStr = "" + ByteUtilUnsigned.bytes2Short_LE(bs, ProtocolConstantV206V1.rtuAddr2Index_start) ;
         while(rtuAddrStr.length() <= 5){
            rtuAddrStr = "0" + rtuAddrStr ;
         }
         return rtuAddrBCD + rtuAddrStr ;
      }else{
         return ("" + ByteUtil.BCD2Long_BE(bs, ProtocolConstantV206V1.UG_rtuAddrIndex_start, ProtocolConstantV206V1.UG_rtuAddrIndex_end)) ;
      }
   }


   /**
    * 分析Rtu地址
    * @param bs 上行字节数组
    * @param index 启始位
    * @return 控制器地址
    * @throws Exception 异常
    */
   public String parseRtuAddr(byte[] bs, int index, boolean p206TrueUgFalse)throws Exception{
      if(p206TrueUgFalse){
         String rtuAddrBCD = "" + ByteUtil.BCD2Long_BE(bs, index, index + 2) ;//地址是大端模式
         String rtuAddrStr = "" + ByteUtilUnsigned.bytes2Short_LE(bs, index + 3) ;
         while(rtuAddrStr.length() <= 5){
            rtuAddrStr = "0" + rtuAddrStr ;
         }
         return rtuAddrBCD + rtuAddrStr ;
      }else{
         throw new Exception("升级协议无设置地址") ;
      }
   }


   /**
    * 分析功能码
    * @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  上行字节数组
    * @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
   传输方向位 DIR        拆分标志位 DIV       帧计数位 FCB       功能码
   */
   public byte createCtrl(byte dir, byte funcCode){
      byte b = dir;//(byte)0x80//控制域：DIR=1，表示此帧报文是由终端发出的上行报文；
      b = (byte)(b | funcCode) ;
      //FCB == 3
      b = (byte)(b | (byte)0x18) ;
      //DIV = 0
      //DIR = 0
      return b ;
   }
   /**
    * 得到IC卡类型名称 （ 卡类型(1:用户卡；2：管理员卡；3：调试卡；4：巡检卡；5：清空卡)）
    * @param type 字节
    * @return 名称
    */
   public static String icCardType(byte type){
      return switch (type) {
         case 0 -> "无卡";
         case 1 -> "用户卡";
         case 2 -> "管理员卡";
         case 3 -> "调试卡";
         case 4 -> "巡检卡";
         case 5 -> "清空卡";
         default -> "未知";
      };
   }

   /**
    * 得到关开阀类型名称
    * 开关阀类型(
    * 1:刷卡开阀；
    * 2:刷卡关阀；
    * 3:中心站开阀；
    * 4:中心站关阀；
    * 5:余额不足关阀；
    * 6:流量计故障关阀；
    * 7:紧急关闭；
    * 8:用户远程开阀；
    * 9:用户远程关阀；
    * 10:巡检卡关阀；
    * 11:巡检卡刷卡卡开阀；
    * 12:黑名单命令关阀；
    * 13:远程定时关阀；
    * 14:远程定量关阀；
    * 16:管道无水自动关阀；(王江海协议)
    * )
    * @param type 字节
    * @return 名称
    */
   public static String openCloseValveType(Byte type){
      if(type == null){
         return "" ;
      }
      return switch (type) {
         case 1 -> "刷卡开阀";
         case 2 -> "刷卡关阀";
         case 3 -> "中心站开阀";
         case 4 -> "中心站关阀";
         case 5 -> "余额不足关阀";
         case 6 -> "流量计故障关阀";
         case 7 -> "紧急关阀";
         case 8 -> "用户远程开阀";
         case 9 -> "用户远程关阀";
         case 10 -> "巡检卡关阀";
         case 11 -> "巡检卡开阀";
         case 12 -> "黑名单命令关阀";
         case 13 -> "远程定时关阀";
         case 14 -> "远程定量关阀";
         case 16 -> "管道无水自动关阀";
         default -> "未知";
      };
   }
   public static Boolean isCloseValveType(byte type){
      return switch (type) {
         case 1, 3, 8, 11 -> false ;
         case 2, 4, 5, 6, 7, 9, 10, 12, 13, 14 -> true ;
         default -> null ;
      };
   }


}