邦海控制柜

vince

2023-07-01 7d84b6cbf8268a6993f661e22a842ffa12c13732

邦海控制柜

 igds-basic/src/main/java/com/ld/igds/gas/manager/GasManager.java

@@ -206,7 +206,7 @@

        // èŽ·å–分机信息
        DeviceSer deviceSer = coreSerService.getCacheSer(param.getCompanyId(),
                depotConf.getGrainSer());
                depotConf.getGasSer());

        CheckGasRequest request = new CheckGasRequest();
        request.setDepotId(param.getDepotId());

 igds-core/src/main/java/com/ld/igds/io/constant/ProtocolEnum.java

@@ -29,6 +29,7 @@
    TCP_FZZY_QUANTITY_V35("TCP_FZZY_QUANTITY_V35", "数量检测V35"),
    TCP_BHZH_GRAIN_FM_V1("TCP_BHZH_GRAIN_FM_V1", "邦海智能无线主机版V1"),
    TCP_BHZH_GRAIN_V2("TCP_BHZH_GRAIN_V2", "邦海智能有线版V2"),
    TCP_BHZH_VERB_V2("TCP_BHZH_VERB_V2", "邦海控制柜智能有线版V2"),
    FZZY_OPENAPI_HTTP("FZZY_OPENAPI_HTTP", "风正致远API-HTTP协议");
    private String code;
    private String msg;

 igds-core/src/main/java/com/ld/igds/models/DepotConf.java

@@ -43,6 +43,10 @@
    @PropertyDef(label = "能耗分机")
    private String esSer;

    @Column(name = "GAS_SER_", length = 40)
    @PropertyDef(label = "气体分机")
    private String gasSer;

    @Column(name = "GRAIN_FREQ_", length = 4)
    @PropertyDef(label = "粮情保存频率", description = "默认一天多次")
    private String grainFreq = GrainFrequence.FREQ_01.getCode();

 igds-core/src/main/java/com/ld/igds/view/DepotConf.view.xml

@@ -279,6 +279,11 @@
              <Property name="labelSeparator">：</Property>
              <Property name="labelWidth">120</Property>
              <AutoFormElement>
                <Property name="name">gasSer</Property>
                <Property name="property">gasSer</Property>
                <Editor/>
              </AutoFormElement>
              <AutoFormElement>
                <Property name="name">gasStart</Property>
                <Property name="property">gasStart</Property>
                <Editor/>

 igds-core/src/main/java/models/igds.model.xml

@@ -894,6 +894,10 @@
        <Property name="valueProperty">name</Property>
      </Property>
    </PropertyDef>
    <PropertyDef name="gasSer">
      <Property/>
      <Property name="label">气体分机</Property>
    </PropertyDef>
  </DataType>
  <DataType name="dtDicSlogan">
    <Property name="creationType">com.ld.igds.models.DicSlogan</Property>

 igds-protocol-bhzn/src/main/java/com/ld/igds/protocol/bhzn/ServerRunner.java

ÎļþÃû´Ó igds-protocol-bhzn/src/main/java/com/ld/igds/protocol/bhzn/grainv2/ServerRunner.java ÐÞ¸Ä
@@ -1,7 +1,8 @@
package com.ld.igds.protocol.bhzn.grainv2;
package com.ld.igds.protocol.bhzn;

import com.ld.igds.data.ConfigData;
import com.ld.igds.protocol.bhzn.grainv2.server.BhznGrainV2ServerEngine;
import com.ld.igds.protocol.bhzn.verb.server.BhznVerbServerEngine;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.core.annotation.Order;
@@ -20,12 +21,14 @@
    private ConfigData configData;
    @Autowired
    private BhznGrainV2ServerEngine bhznGrainServerEngine;

    @Autowired
    private BhznVerbServerEngine bhznVerbServerEngine;
    @Override
    public void run(String... strings) throws Exception {

        if (configData.getActive().indexOf("pro") >= 0) {
            bhznGrainServerEngine.start(BhznGrainV2ServerEngine.PORT);
            bhznVerbServerEngine.start(BhznVerbServerEngine.PORT);
        }
        if (configData.getActive().indexOf("dev") >= 0) {
            bhznGrainServerEngine.start(BhznGrainV2ServerEngine.PORT);

 igds-protocol-bhzn/src/main/java/com/ld/igds/protocol/bhzn/verb/analysis/AnalysisDevice.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,193 @@
package com.ld.igds.protocol.bhzn.verb.analysis;

import com.alibaba.fastjson.JSONObject;
import com.ld.igds.common.CoreDeviceService;
import com.ld.igds.constant.DeviceStatus;
import com.ld.igds.io.constant.OrderRespEnum;
import com.ld.igds.io.notify.NotifyWebInvoker;
import com.ld.igds.io.request.ExeDevice;
import com.ld.igds.models.Device;
import com.ld.igds.models.DeviceSer;
import com.ld.igds.protocol.bhzn.verb.command.BaseRemoteImpl;
import com.ld.igds.protocol.bhzn.verb.dto.IoMessage;
import com.ld.igds.protocol.bhzn.verb.dto.Res247;
import com.ld.igds.protocol.bhzn.verb.server.BhznVerbServerUtils;
import com.ld.igds.temp.dto.TempParam;
import com.ld.igds.util.BytesUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.List;
/**
 * è®¾å¤‡æ“ä½œç±»
 */
@Slf4j
@Component(AnalysisDevice.BEAN_ID)
public class AnalysisDevice extends BaseRemoteImpl {

    public static final String BEAN_ID = "bhzn.analysisDevice";

    @Autowired
    private CoreDeviceService deviceService;
    @Autowired
    private NotifyWebInvoker notifyInvoker;



    /**
     * è®¾å¤‡çŠ¶æ€
     *
     * @param reMessage
     * @param ser
     */
    public void analysis(IoMessage reMessage, DeviceSer ser) {
        Res247 res247 = JSONObject.parseObject(reMessage.getContentStr(),Res247.class);
        AnalysisWin(ser,res247.getWin_Str());
        AnalysisFan(ser,res247.getFan_Str());
        AnalysisAir(ser,res247.getAir_Str());
        AnalysisLight(ser,res247.getLight_Str());
//        BhznVerbServerUtils.add2StatusMap(ser.getCompanyId(), ser.getId(),0, "");
//        }
        deviceService.updateStatus(ser.getCompanyId(), ser.getId(), BhznVerbServerUtils.getStatusMap());
//
//        notifyInvoker.notifyAnalysisStatusSuccess(ser.getCompanyId(), ser.getId(), OrderRespEnum.MSG_SUCCESS, "设备状态查询成功并完成解析！");
    }

    /**
     * è§£æžçª—户状态
     * @param ser
     * @param winStr
     */
    private void AnalysisWin(DeviceSer ser,Integer[] winStr){
        if(winStr == null || winStr.length == 0)return;
        for (int i=1;i<= winStr.length;i++) {
            BhznVerbServerUtils.add2StatusMap(ser.getCompanyId(), ser.getId(),i, getWinStatus(winStr[i-1]));
        }
    }
    /**
     * è§£æžé£ŽæœºçŠ¶æ€
     * @param ser
     * @param fanStr
     */
    private void AnalysisFan(DeviceSer ser,Integer[] fanStr){
        if(fanStr == null || fanStr.length == 0)return;
        for (int i=1;i<= fanStr.length;i++) {
            BhznVerbServerUtils.add2StatusMap(ser.getCompanyId(), ser.getId(),i+20, getFanStatus(fanStr[i-1]));
        }
    }
    /**
     * è§£æžç©ºè°ƒçŠ¶æ€
     * @param ser
     * @param airStr
     */
    private void AnalysisAir(DeviceSer ser,Integer[] airStr){
        if(airStr == null || airStr.length == 0)return;
        Integer s= 0;
        for (int i=1;i<= airStr.length;i++) {
            List<Device> devices = deviceService.getCacheDeviceBySerId(ser.getCompanyId(),ser.getId());
            // è°ƒæ•´ç¼“å­˜
            if (null == devices || devices.isEmpty())
                return;
            // æ›´æ–°ç¼“å­˜
            Device temp;
            s = airStr[i-1];
            for (int j = 0; j < devices.size(); j++) {
                if(i == (devices.get(j).getPassCode() - 40)){
                    // 4608 -12  00
                    String hexStr = BytesUtil.intToHexStr(s);
                    for (int k =0;k<4;k++){
                        if(hexStr.length() < 16){
                            hexStr = "0" + hexStr;
                        }
                    }
                    // 12
                    String l = hexStr.substring(0,2);
                    //00
                    String h = hexStr.substring(2,4);
                    String hb = BytesUtil.toBinary8String(BytesUtil.hexToInt(h));
                    //00000000 0000 0 000
                    Integer status = Integer.parseInt(hb.substring(4,5));
                    Integer t = BytesUtil.hexToInt(l);
                    BhznVerbServerUtils.add2StatusMap(ser.getCompanyId(), ser.getId(), devices.get(j).getId(), getLightStatus(status));
                    TempParam param = new TempParam();
                    param.setId( devices.get(j).getId());
                    param.setTargetTemp(t+"");
                    param.setTargetStatus(getLightStatus(status));
                    param.setTargetModel("01");
                    List<ExeDevice> exeDeviceList = new ArrayList<>();
                    ExeDevice dev = new ExeDevice();
                    dev.setSerId(ser.getId());
                    exeDeviceList.add(dev);
                    param.setDeviceList(exeDeviceList);
                    param.setCompanyId(ser.getCompanyId());
                    deviceService.updateTempControlInfo(param);

                    log.info("空调状态解析完成："+param.toString());
                    //BhznVerbServerUtils.add2StatusMap(ser.getCompanyId(), ser.getId(),i+40, getWinStatus(airStr[i]));

                }
            }
                  }
    }
    /**
     * è§£æžç…§æ˜ŽçŠ¶æ€
     * @param ser
     * @param lightStr
     */
    private void AnalysisLight(DeviceSer ser,Integer[] lightStr){
        if(lightStr == null || lightStr.length == 0)return;
        for (int i=1;i<= lightStr.length;i++) {
            BhznVerbServerUtils.add2StatusMap(ser.getCompanyId(), ser.getId(),i+60, getLightStatus(lightStr[i-1]));
        }
    }

    private String getWinStatus(Integer s){
        if(s == null)return DeviceStatus.ZERO.getCode();
        String hexStr = BytesUtil.intToHexStr(s);
        for (int i =0;i<4;i++){
            if(hexStr.length() < 4){
                hexStr = "0" + hexStr;
            }
        }
        String h = hexStr.substring(0,2);
        String l = hexStr.substring(2,4);
        h = BytesUtil.toBinary8String(BytesUtil.hexToInt(h));
        int kaidu = (BytesUtil.hexToInt(l));
        String temp = h.substring(6,8);
        if("00".equals(temp ) && kaidu == 100){
            return DeviceStatus.OPEN.getCode();
        }
        if("00".equals(temp ) && kaidu == 0){
            return DeviceStatus.CLOSE.getCode();
        }
        if("01".equals(temp )){
            return DeviceStatus.OPEN.getCode();
        }
        if("10".equals(temp )){
            return DeviceStatus.CLOSE.getCode();
        }

        return DeviceStatus.ZERO.getCode();
    }
    private String getFanStatus(Integer s){
        if(0 == s){
            return DeviceStatus.CLOSE.getCode();
        }
        if(1 == s){
            return DeviceStatus.OPEN.getCode();
        }
        return DeviceStatus.ZERO.getCode();
    }

    private String getLightStatus(Integer s){
        if(0 == s){
            return DeviceStatus.CLOSE.getCode();
        }
        if(1 == s){
            return DeviceStatus.OPEN.getCode();
        }
        return DeviceStatus.ZERO.getCode();
    }

}

 igds-protocol-bhzn/src/main/java/com/ld/igds/protocol/bhzn/verb/analysis/AnalysisGas.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,150 @@
package com.ld.igds.protocol.bhzn.verb.analysis;

import com.alibaba.fastjson.JSONObject;
import com.ld.igds.common.CoreCommonService;
import com.ld.igds.common.CoreDeviceService;
import com.ld.igds.constant.BizType;
import com.ld.igds.constant.DeviceStatus;
import com.ld.igds.gas.CoreGasService;
import com.ld.igds.io.constant.OrderRespEnum;
import com.ld.igds.io.notify.NotifyWebInvoker;
import com.ld.igds.io.request.ExeDevice;
import com.ld.igds.models.*;
import com.ld.igds.protocol.bhzn.verb.command.BaseRemoteImpl;
import com.ld.igds.protocol.bhzn.verb.dto.IoMessage;
import com.ld.igds.protocol.bhzn.verb.dto.Res209;
import com.ld.igds.protocol.bhzn.verb.dto.Res247;
import com.ld.igds.protocol.bhzn.verb.server.BhznVerbServerUtils;
import com.ld.igds.temp.dto.TempParam;
import com.ld.igds.util.BytesUtil;
import com.ld.igds.util.ContextUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * æ°”体解析
 */
@Slf4j
@Component(AnalysisGas.BEAN_ID)
public class AnalysisGas extends BaseRemoteImpl {

    public static final String BEAN_ID = "bhzn.analysisGas";

    @Autowired
    private CoreDeviceService deviceService;
    @Autowired
    private NotifyWebInvoker notifyInvoker;
    @Autowired
    private CoreGasService gasService;
    @Autowired
    private CoreCommonService commonService;


    /**
     * è®¾å¤‡çŠ¶æ€
     *
     * @param reMessage
     * @param ser
     */
    public void analysis(IoMessage reMessage, DeviceSer ser) {

        log.info("气体检测开始解析");
        Res209 res209 = JSONObject.parseObject(reMessage.getContentStr(),Res209.class);

        DepotConf depotConf = commonService.getCacheDepotConfBySerId(ser.getCompanyId(),ser.getId() );
        //主体信息
        Gas gas = new Gas();
        gas.setBatchId(ContextUtil.getDefaultBatchId());
        gas.setCheckNum(res209.getCO2ValArray().length);
        gas.setCompanyId(ser.getCompanyId());
        gas.setDepotId(depotConf.getDepotId());
        gas.setGasEnd(depotConf.getPestEnd());
        gas.setGasStart(depotConf.getPestStart());
        gas.setReceiveDate(new Date());
        StringBuffer sb = new StringBuffer();
        List<GasInfo> items = new ArrayList<>();
        GasInfo info;
        Integer[] n2ValArray = res209.getN2ValArray();
        Integer[] pH3ValArray = res209.getPH3ValArray();
        Integer[] cO2ValArray = res209.getCO2ValArray();
        for (int i=0;i<res209.getCO2ValArray().length;i++){
            info = new GasInfo();
            info.setId(ContextUtil.buildInfoId(gas.getCompanyId(), gas.getDepotId(), gas.getBatchId()));
            info.setPassCode(i+1);
            info.setPerCo2(cO2ValArray[i].doubleValue());
            info.setPerO2(99 - (n2ValArray[i].doubleValue() /10 ));
            info.setPerPh3(pH3ValArray[i].doubleValue());
            info.setPerN2(n2ValArray[i].doubleValue() / 10);
            items.add(info);
            if(i == 0){
                //添加最大值和最小值
                gas.setPerCo2Max(info.getPerCo2());
                gas.setPerCo2Min(info.getPerCo2());
                gas.setPerO2Max(info.getPerO2());
                gas.setPerO2Min(info.getPerO2());
                gas.setPerPh3Max(info.getPerPh3());
                gas.setPerPh3Min(info.getPerPh3());
                gas.setPerN2Max(info.getPerN2());
                gas.setPerN2Min(info.getPerN2());
            }
            if (info.getPerCo2() > gas.getPerCo2Max()) {
                gas.setPerCo2Max(info.getPerCo2());
            }
            if (info.getPerCo2() < gas.getPerCo2Min()) {
                gas.setPerCo2Min(info.getPerCo2());
            }

            if (info.getPerO2() > gas.getPerO2Max()) {
                gas.setPerO2Max(info.getPerO2());
            }

            if (info.getPerO2() < gas.getPerO2Min()) {
                gas.setPerO2Min(info.getPerO2());
            }

            if (info.getPerPh3() > gas.getPerPh3Max()) {
                gas.setPerPh3Max(info.getPerPh3());
            }

            if (info.getPerPh3() < gas.getPerPh3Min()) {
                gas.setPerPh3Min(info.getPerPh3());
            }

            if (info.getPerN2() > gas.getPerN2Max()) {
                gas.setPerN2Max(info.getPerN2());
            }

            if (info.getPerN2() < gas.getPerN2Min()) {
                gas.setPerN2Min(info.getPerN2());
            }

            //固定为：passCode,co2,o2,ph3,n2;passCode,co2,o2,ph3,n2;"
            sb.append(info.getPassCode());
            sb.append(",");
            sb.append(info.getPerCo2());
            sb.append(",");
            sb.append(info.getPerO2());
            sb.append(",");
            sb.append(info.getPerPh3());
            sb.append(",");
            sb.append(info.getPerN2());
            sb.append(";");
        }
        gas.setPoints(sb.toString());
        gasService.saveInfoGas(items);

        gasService.saveOrUpdateData(gas);

        // è°ƒç”¨é€šçŸ¥å‰ç«¯
        notifyInvoker.notifyWeb(gas.getCompanyId(), OrderRespEnum.MSG_SUCCESS, BizType.GAS, depotConf.getDepotName() + " æ°”体检测：结果返回成功.");

        log.info("控制柜----->>>平台：气体解析完成-仓库={}", depotConf.getDepotName());

    }

}

 igds-protocol-bhzn/src/main/java/com/ld/igds/protocol/bhzn/verb/analysis/AnalysisService.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,87 @@
package com.ld.igds.protocol.bhzn.verb.analysis;

import com.ld.igds.common.CoreCommonService;
import com.ld.igds.common.CoreSerService;
import com.ld.igds.common.dto.THDto;
import com.ld.igds.constant.BizType;
import com.ld.igds.constant.Constant;
import com.ld.igds.grain.GrainUtil;
import com.ld.igds.grain.dto.GrainItemInfo;
import com.ld.igds.io.notify.NotifyGrainInvoker;
import com.ld.igds.models.DepotConf;
import com.ld.igds.models.DeviceSer;
import com.ld.igds.models.DicSysConf;
import com.ld.igds.models.Grain;
import com.ld.igds.order.ExeOrderService;
import com.ld.igds.protocol.bhzn.verb.dto.IoMessage;
import com.ld.igds.warn.WarnUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.*;

/**
 * åè®®è§£æž
 *
 * @author vince
 */
@Slf4j
@Component(AnalysisService.BEAN_ID)
public class AnalysisService {


    public static final String BEAN_ID = "bhznVerb.analysisService";

    @Autowired
    private CoreSerService coreSerService;
    @Autowired
    private CoreCommonService commonService;
    @Autowired
    private NotifyGrainInvoker notifyGrainInvoker;
    @Autowired
    private GrainUtil grainUtil;
    @Autowired
    private WarnUtils warnUtils;
    @Autowired
    private ExeOrderService exeOrderService;
    @Autowired
    private AnalysisDevice analysisDevice;
    @Autowired
    private AnalysisGas analysisGas;


    /**
     * @param message
     */
    public void analysis(IoMessage message)  {
        try{
            DeviceSer ser = coreSerService.getCacheSerBySn(message.getCompanyId(), message.getSn());
            if (null == ser) {
                log.warn("控制柜------>>>平台：当前组织编码={}，分机ID={}，系统没有获取到分机信息，报文无法进行解析", message.getCompanyId(), message.getSn());

                return;
            }else{
                    ser.setIp(message.getIp());
                    ser.setPort(message.getPort());
                    ser.setStatus(Constant.YN_Y);
                    coreSerService.updateByData(ser);
            }
            //根据接口编号进行解析路由
            switch (message.getCmd()) {
                case 247:
                    analysisDevice.analysis(message, ser);
                    break;
                case 209:
                    analysisGas.analysis(message, ser);
                    break;
                default:
                    log.error("控制柜命令码解析失败！");
                    break;
            }
        }catch (Exception e){
            log.error("控制柜解析失败出错：" + e.getMessage(),e);
        }
    }

}

 igds-protocol-bhzn/src/main/java/com/ld/igds/protocol/bhzn/verb/builder/CommandBuilder.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,68 @@
package com.ld.igds.protocol.bhzn.verb.builder;

import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.SimplePropertyPreFilter;
import com.ld.igds.io.request.BaseRequest;
import com.ld.igds.protocol.bhzn.verb.dto.IoMessage;
import com.ld.igds.protocol.bhzn.verb.server.BhznVerbServerUtils;


/**
 * å‘½ä»¤ç”Ÿæˆ
 *
 * @author Andy
 */
public abstract class CommandBuilder {

    public IoMessage buildMessage(BaseRequest request) {
        IoMessage message = new IoMessage();
        message.setIp(request.getIp());
        message.setPort(request.getPort());
        message.setBegin(BhznVerbServerUtils.MSG_START1);
        // è°ƒæ•´ä¿¡æ¯
        buildInfo(message, request);
        message.setSign("0000");
        message.setStNum(Integer.parseInt(request.getDepotId()));
        message.setVersion("V1.0000000");
        message.setCmd(248);
        message.setResult("");
        message.setOrderId(request.getOrderId());
        message.setContent(null);
        message.setEnd(BhznVerbServerUtils.MSG_END);

        // ç”Ÿæˆæ•´ä½“命令信息和BYte信息
        build(message);

        return message;
    }

    public void buildInfo(IoMessage message, BaseRequest request) {


    }

    /**
     * æ ¹æ®ç”Ÿæˆçš„命令，进行调整
     *
     * @param message
     */
    public void build(IoMessage message) {
        StringBuffer hexSb = new StringBuffer();
        hexSb.append(message.getBegin());
        SimplePropertyPreFilter filter = new SimplePropertyPreFilter();
        filter.getExcludes().add("ip");
        filter.getExcludes().add("port");
        filter.getExcludes().add("companyId");
        filter.getExcludes().add("strMsg");
        filter.getExcludes().add("begin");
        filter.getExcludes().add("end");
        filter.getExcludes().add("byteMsg");
        filter.getExcludes().add("contentSr");
        message.setContent(JSONObject.parseObject(message.getContentStr()));
        message.setStrMsg(JSONObject.toJSONString(message,filter));
        hexSb.append(message.getStrMsg());
        hexSb.append(message.getEnd());
        message.setByteMsg(hexSb.toString().getBytes());
    }

}

 igds-protocol-bhzn/src/main/java/com/ld/igds/protocol/bhzn/verb/builder/ControlCommandBuilder.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,147 @@
package com.ld.igds.protocol.bhzn.verb.builder;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.ld.igds.constant.DeviceStatus;
import com.ld.igds.constant.DeviceType;
import com.ld.igds.io.request.DeviceControlRequest;
import com.ld.igds.io.request.ExeDevice;
import com.ld.igds.protocol.bhzn.verb.dto.IoMessage;
import com.ld.igds.protocol.bhzn.verb.dto.Req248;
import com.ld.igds.protocol.bhzn.verb.server.BhznVerbServerUtils;
import org.apache.commons.lang3.StringUtils;

import java.util.ArrayList;
import java.util.List;

public class ControlCommandBuilder extends CommandBuilder {

    private final static ControlCommandBuilder instance = new ControlCommandBuilder();

    private ControlCommandBuilder() {
    }

    public static ControlCommandBuilder getInstance() {
        return instance;
    }

    public IoMessage buildMessage(DeviceControlRequest request) {

        IoMessage message = new IoMessage();
        message.setIp(request.getIp());
        message.setPort(request.getPort());
        message.setBegin(BhznVerbServerUtils.MSG_START1);
        // è°ƒæ•´ä¿¡æ¯
        buildInfo(message, request);
        message.setSign("0000");
        message.setVersion("V1.0000000");
        message.setStNum(Integer.parseInt(request.getDepotId()));
        message.setSn(request.getSerId());
        message.setCmd(248);
        message.setResult("");
        message.setOrderId(request.getOrderId());
        message.setEnd(BhznVerbServerUtils.MSG_END);

        // ç”Ÿæˆæ•´ä½“命令信息和BYte信息
        build(message);

        return message;
    }

    public void buildInfo(IoMessage message, DeviceControlRequest request) {
        Req248 info = new Req248();
        Integer[] winStr = new Integer[]{-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
        Integer[] fanStr = new Integer[]{-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
        Integer[] airStr = new Integer[]{-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
        Integer[] lightStr = new Integer[]{-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
        int winCount = 0,fanCount = 0,airCount = 0,lightCount = 0;
        List<ExeDevice> deviceList = request.getDeviceList();
        for (ExeDevice exeDevice : deviceList) {
            //窗户类型设备 åŒ…含
            if(
                    DeviceType.TYPE_0B.getCode().equals(exeDevice.getType())
                    || DeviceType.TYPE_01.getCode().equals(exeDevice.getType())
                    || DeviceType.TYPE_02.getCode().equals(exeDevice.getType())
                    || DeviceType.TYPE_0C.getCode().equals(exeDevice.getType())
            ){
                winStr[exeDevice.getPassCode()-1] = getVinStatus(exeDevice.getTargetStatus());
                if(exeDevice.getPassCode() > winCount){
                    winCount = exeDevice.getPassCode();
                }
                if(StringUtils.isNotEmpty(exeDevice.getLink()) && !"null".equals(exeDevice.getLink())){
                    fanStr[Integer.parseInt(exeDevice.getLink())-21] = getFanStatus(exeDevice.getTargetStatus());
                    if(Integer.parseInt(exeDevice.getLink()) > fanCount){
                        fanCount = exeDevice.getPassCode();
                    }
                }
            }
            //风机类型设备
            if(DeviceType.TYPE_04.getCode().equals(exeDevice.getType())
            ){
                fanStr[exeDevice.getPassCode()-21] = getFanStatus(exeDevice.getTargetStatus());
                if(exeDevice.getPassCode() > fanCount){
                    fanCount = exeDevice.getPassCode();
                }
            }
            //空调类型设备
//            if(DeviceType.TYPE_05.getCode().equals(exeDevice.getType())
//            ){
//                fanStr[exeDevice.getPassCode()-1] = getFanStatus(exeDevice.getTargetStatus());
//                if(exeDevice.getPassCode() > fanCount){
//                    fanCount = exeDevice.getPassCode();
//                }
//            }
            //照明类型设备
            if(DeviceType.TYPE_06.getCode().equals(exeDevice.getType())
            ){
                lightStr[exeDevice.getPassCode()-61] = getFanStatus(exeDevice.getTargetStatus());
                if(exeDevice.getPassCode() > lightCount){
                    lightCount = exeDevice.getPassCode();
                }
            }
        }
        info.setWinCount(winCount);
        info.setWin_Str(winStr);
        info.setFanCount(fanCount);
        info.setFan_Str(fanStr);
        info.setAirCount(airCount);
        info.setAir_Str(airStr);
        info.setLightCount(lightCount);
        info.setLight_Str(lightStr);
        message.setContentStr(JSON.toJSONString(info));
    }


    private int getVinStatus(String deviceStatus){
        if(DeviceStatus.W_OPEN.getCode().equals(deviceStatus) || DeviceStatus.OPEN.getCode().equals(deviceStatus)){
            return 1;
        }
        if(DeviceStatus.W_CLOSE.getCode().equals(deviceStatus) || DeviceStatus.CLOSE.getCode().equals(deviceStatus)){
            return 2;
        }
        if(DeviceStatus.F_CLOSE.getCode().equals(deviceStatus) ){
            return 0;
        }
        if(DeviceStatus.F_OPEN.getCode().equals(deviceStatus) ||DeviceStatus.F_OPEN_F.getCode().equals(deviceStatus) ){
            return 1;
        }
        return -1;
    }

    private int getFanStatus(String deviceStatus){
        if(DeviceStatus.F_CLOSE.getCode().equals(deviceStatus)  ){
            return 0;
        }
        if(DeviceStatus.F_OPEN.getCode().equals(deviceStatus) ||DeviceStatus.F_OPEN_F.getCode().equals(deviceStatus) ){
            return 1;
        }
        return -1;
    }

//    private int getAirStatus(ExeDevice exeDevice){
//        String s = "";
//        s += "001";
//        if(exeDevice.)
//        return 0;
//    }
}

 igds-protocol-bhzn/src/main/java/com/ld/igds/protocol/bhzn/verb/builder/GasCommandBuilder.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,48 @@
package com.ld.igds.protocol.bhzn.verb.builder;

import com.alibaba.fastjson.JSON;
import com.ld.igds.io.request.CheckGasRequest;
import com.ld.igds.protocol.bhzn.verb.dto.IoMessage;
import com.ld.igds.protocol.bhzn.verb.dto.Req209;
import com.ld.igds.protocol.bhzn.verb.server.BhznVerbServerUtils;

public class GasCommandBuilder extends CommandBuilder {
    private final static GasCommandBuilder instance = new GasCommandBuilder();

    private GasCommandBuilder() {
    }

    public static GasCommandBuilder getInstance() {
        return instance;
    }

    public IoMessage buildMessage(CheckGasRequest request) {


        IoMessage message = new IoMessage();
        message.setIp(request.getIp());
        message.setPort(request.getPort());
        message.setBegin(BhznVerbServerUtils.MSG_START1);
        // è°ƒæ•´ä¿¡æ¯
        buildInfo(message, request);
        message.setSign("0000");
        message.setVersion("V1.0000000");
        message.setStNum(Integer.parseInt(request.getDepotId()));
        message.setSn(request.getSerId());
        message.setCmd(209);
        message.setResult("");
        message.setOrderId(request.getOrderId());
        message.setEnd(BhznVerbServerUtils.MSG_END);

        // ç”Ÿæˆæ•´ä½“命令信息和BYte信息
        build(message);
        return message;
    }

    public void buildInfo(IoMessage message, CheckGasRequest request) {
        Req209 info = new Req209();
        info.setStart(1);
        info.setChannel(0);
        message.setContentStr(JSON.toJSONString(info));
    }
}

 igds-protocol-bhzn/src/main/java/com/ld/igds/protocol/bhzn/verb/builder/GasStopCommandBuilder.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,47 @@
package com.ld.igds.protocol.bhzn.verb.builder;

import com.alibaba.fastjson.JSON;
import com.ld.igds.io.request.CheckGasRequest;
import com.ld.igds.protocol.bhzn.verb.dto.IoMessage;
import com.ld.igds.protocol.bhzn.verb.dto.Req209;
import com.ld.igds.protocol.bhzn.verb.server.BhznVerbServerUtils;

public class GasStopCommandBuilder extends CommandBuilder {
    private final static GasStopCommandBuilder instance = new GasStopCommandBuilder();

    private GasStopCommandBuilder() {
    }

    public static GasStopCommandBuilder getInstance() {
        return instance;
    }

    public IoMessage buildMessage(CheckGasRequest request) {

        IoMessage message = new IoMessage();
        message.setIp(request.getIp());
        message.setPort(request.getPort());
        message.setBegin(BhznVerbServerUtils.MSG_START1);
        // è°ƒæ•´ä¿¡æ¯
        buildInfo(message, request);
        message.setSign("0000");
        message.setVersion("V1.0000000");
        message.setStNum(Integer.parseInt(request.getDepotId()));
        message.setSn(request.getSerId());
        message.setCmd(209);
        message.setResult("");
        message.setOrderId(request.getOrderId());
        message.setEnd(BhznVerbServerUtils.MSG_END);

        // ç”Ÿæˆæ•´ä½“命令信息和BYte信息
        build(message);
        return message;
    }

    public void buildInfo(IoMessage message, CheckGasRequest request) {
        Req209 info = new Req209();
        info.setStart(1);
        info.setChannel(0);
        message.setContentStr(JSON.toJSONString(info));
    }
}

 igds-protocol-bhzn/src/main/java/com/ld/igds/protocol/bhzn/verb/builder/TempControlCommandBuilder.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,98 @@
package com.ld.igds.protocol.bhzn.verb.builder;

import com.alibaba.fastjson.JSON;
import com.ld.igds.constant.DeviceStatus;
import com.ld.igds.constant.DeviceType;
import com.ld.igds.io.request.ExeDevice;
import com.ld.igds.io.request.TempControlRequest;
import com.ld.igds.protocol.bhzn.verb.dto.IoMessage;
import com.ld.igds.protocol.bhzn.verb.dto.Req248;
import com.ld.igds.protocol.bhzn.verb.server.BhznVerbServerUtils;
import com.ld.igds.util.BytesUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;

import java.util.List;
@Slf4j
public class TempControlCommandBuilder extends CommandBuilder {

    private final static TempControlCommandBuilder instance = new TempControlCommandBuilder();

    private TempControlCommandBuilder() {
    }

    public static TempControlCommandBuilder getInstance() {
        return instance;
    }

    public IoMessage buildMessage(TempControlRequest request) {

        IoMessage message = new IoMessage();
        message.setIp(request.getIp());
        message.setPort(request.getPort());
        message.setBegin(BhznVerbServerUtils.MSG_START1);
        // è°ƒæ•´ä¿¡æ¯
        buildInfo(message, request);
        message.setSign("0000");
        message.setVersion("V1.0000000");
        message.setStNum(Integer.parseInt(request.getDepotId()));
        message.setSn(request.getSerId());
        message.setCmd(248);
        message.setResult("");
        message.setOrderId(request.getOrderId());
        message.setEnd(BhznVerbServerUtils.MSG_END);
        // ç”Ÿæˆæ•´ä½“命令信息和BYte信息
        build(message);

        return message;
    }

    public void buildInfo(IoMessage message, TempControlRequest request) {
        Req248 info = new Req248();
        Integer[] winStr = new Integer[]{-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
        Integer[] fanStr = new Integer[]{-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
        Integer[] airStr = new Integer[]{-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
        Integer[] lightStr = new Integer[]{-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
        int winCount = 0,fanCount = 0,airCount = 0,lightCount = 0;
        ExeDevice exeDevice = request.getExeDevice();

            //空调类型设备
        airStr[exeDevice.getPassCode()-41] = getAirStatus(request);
        airCount = exeDevice.getPassCode()-41;
            info.setWinCount(winCount);
            info.setWin_Str(winStr);
            info.setFanCount(fanCount);
            info.setFan_Str(fanStr);
            info.setAirCount(airCount);
            info.setAir_Str(airStr);
            info.setLightCount(lightCount);
            info.setLight_Str(lightStr);
            message.setContentStr(JSON.toJSONString(info));
    }


    private Integer getAirStatus(TempControlRequest request){
        try{
            String h = "";
            String l = "";
            h = "001"+h;
            if(DeviceStatus.OPEN.getCode().equals(request.getExeDevice().getTargetStatus())){
                h = "1"+h;
            }else{
                h = "0"+h;
            }
            h = "0000"+h;
            h = BytesUtil.hexToInt(BytesUtil.bin2Hex(h)) + "";
            if (h.length() < 2) {
                h = "0" + h;
            }
            l = BytesUtil.intToHexStr1(Integer.parseInt(request.getTargetTemp()));
            String s=  l+ h ;
            return BytesUtil.hexToInt(s);
        }catch (Exception e){
            log.error(e.getMessage(),e);
            return -1;
        }

    }
}

 igds-protocol-bhzn/src/main/java/com/ld/igds/protocol/bhzn/verb/command/BaseRemoteImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,72 @@
package com.ld.igds.protocol.bhzn.verb.command;

import com.ld.igds.io.constant.ProtocolEnum;
import com.ld.igds.protocol.bhzn.verb.dto.IoMessage;
import com.ld.igds.protocol.bhzn.verb.server.BhznVerbServerEngine;
import com.ld.igds.util.BytesUtil;
import com.ld.igds.util.ContextUtil;
import com.ld.io.api.InvokeResult;
import com.ld.io.api.IoSession;
import com.ld.io.api.IoSessionQuery;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.List;

@Slf4j
@Component(BaseRemoteImpl.BEAN_ID)
public class BaseRemoteImpl {
    public static final String BEAN_ID = "bhzn.remoteBaseCommonService";
    public String getProtocol() {
        return ProtocolEnum.TCP_BHZH_VERB_V2.getCode();
    }

    @Autowired
    private BhznVerbServerEngine bhznVerbServerEngine;

    /**
     * å‘送命令
     *
     * @param ip
     * @param port
     * @param msg
     * @return
     */
    public InvokeResult send(String ip, int port, byte[] msg) {
        log.debug("平台推送报文信息--{}", BytesUtil.bytesToString(msg));
        IoSessionQuery sessionFactory = bhznVerbServerEngine.getSessionQuery();
        List<IoSession> sessions = sessionFactory.getAllSession();
        IoSession session = null;
        for (IoSession ioSession : sessions) {
            if (ContextUtil.getServerKey(ip, port).equals(
                    ioSession.getBusinessKey())) {
                session = ioSession;
                break;
            }
        }
        if (null == session) {
            return InvokeResult.CHANNEL_CLOSED;
        }
        return session.invoke(msg);
    }

    public InvokeResult send(IoMessage message) {
        log.debug("平台推送报文信息--{}", message.toString());
        IoSessionQuery sessionFactory =  bhznVerbServerEngine.getSessionQuery();
        List<IoSession> sessions = sessionFactory.getAllSession();
        IoSession session = null;
        for (IoSession ioSession : sessions) {
            if (ContextUtil.getServerKey(message.getIp(), message.getPort()).equals(
                    ioSession.getBusinessKey())) {
                session = ioSession;
                break;
            }
        }
        if (null == session) {
            return InvokeResult.CHANNEL_CLOSED;
        }
        return session.invoke(message.getByteMsg());
    }

}

 igds-protocol-bhzn/src/main/java/com/ld/igds/protocol/bhzn/verb/command/RemoteCommonImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,99 @@
package com.ld.igds.protocol.bhzn.verb.command;

import com.ld.igds.constant.BizType;
import com.ld.igds.io.RemoteCommonService;
import com.ld.igds.io.constant.OrderRespEnum;
import com.ld.igds.io.notify.NotifyWebInvoker;
import com.ld.igds.io.request.*;
import com.ld.igds.io.response.BaseResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * å½“前协议实现，粮情模块命令接口
 *
 * @author jiazx
 */
@Slf4j
@Component(RemoteCommonImpl.BEAN_ID)
public class RemoteCommonImpl extends BaseRemoteImpl implements RemoteCommonService {

    public static final String BEAN_ID = "bhzn.remoteCommonService";

    @Autowired
    private NotifyWebInvoker notifyWebInvoker;

    @Override
    public BaseResponse checkTh(CheckThRequest request) {
        return new BaseResponse(OrderRespEnum.ORDER_ERROR.getCode(), "协议不支持");
    }

    @Override
    public BaseResponse pullDevice(BaseRequest request) {
        return new BaseResponse(OrderRespEnum.ORDER_ERROR.getCode(), "协议不支持");
    }


    @Override
    public BaseResponse pullDepot(BaseRequest request) {
        return new BaseResponse(OrderRespEnum.ORDER_ERROR.getCode(), "协议不支持");
    }

    @Override
    public BaseResponse pullAccess(AccessRequest request) {
        return new BaseResponse(OrderRespEnum.ORDER_ERROR.getCode(), "协议不支持");
    }

    @Override
    public BaseResponse pullDepotStatus(DepotStatusRequest request) {

        return new BaseResponse(OrderRespEnum.ORDER_ERROR.getCode(), "协议不支持");
    }

    @Override
    public BaseResponse heartBeat(BaseRequest request) {
        return new BaseResponse(OrderRespEnum.ORDER_ERROR.getCode(), "协议不支持");
    }

    @Override
    public BaseResponse readConf(GrainSerConfRequest request) {
        return new BaseResponse(OrderRespEnum.ORDER_ERROR.getCode(), "协议不支持");
    }

    @Override
    public BaseResponse writeConf(GrainSerConfRequest request) {
        return new BaseResponse(OrderRespEnum.ORDER_ERROR.getCode(), "协议不支持");
    }

    @Override
    public BaseResponse initCable(BaseRequest request) {
        return new BaseResponse(OrderRespEnum.ORDER_ERROR.getCode(), "协议不支持");
    }

    @Override
    public BaseResponse updateGrainSerCable(GrainSerConfRequest request) {
        return new BaseResponse(OrderRespEnum.ORDER_ERROR.getCode(), "协议不支持");
    }

    @Override
    public BaseResponse destroyCon(BaseRequest request) {
        return new BaseResponse(OrderRespEnum.ORDER_ERROR.getCode(), "协议不支持");
    }

    @Override
    public BaseResponse checkGrainSerCable(GrainSerConfRequest request) {
        return new BaseResponse(OrderRespEnum.ORDER_ERROR.getCode(), "协议不支持");
    }

    @Override
    public BaseResponse sumGrainSerCable(GrainSerConfRequest request) {
        return new BaseResponse(OrderRespEnum.ORDER_ERROR.getCode(), "协议不支持");
    }

    @Override
    public BaseResponse updateSysDepotConf(BaseRequest request) {
        return null;
    }

}

 igds-protocol-bhzn/src/main/java/com/ld/igds/protocol/bhzn/verb/command/RemoteControlServiceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,177 @@
package com.ld.igds.protocol.bhzn.verb.command;

import com.ld.igds.constant.BizType;
import com.ld.igds.constant.DeviceStatus;
import com.ld.igds.constant.DeviceType;
import com.ld.igds.io.RemoteControlService;
import com.ld.igds.io.constant.OrderRespEnum;
import com.ld.igds.io.notify.NotifyWebInvoker;
import com.ld.igds.io.request.DeviceAutoControlRequest;
import com.ld.igds.io.request.DeviceControlRequest;
import com.ld.igds.io.request.ExeDevice;
import com.ld.igds.io.request.TempControlRequest;
import com.ld.igds.io.response.BaseResponse;
import com.ld.igds.io.response.DeviceControlResponse;
import com.ld.igds.protocol.bhzn.verb.builder.ControlCommandBuilder;
import com.ld.igds.protocol.bhzn.verb.builder.TempControlCommandBuilder;
import com.ld.igds.protocol.bhzn.verb.dto.IoMessage;
import com.ld.io.api.InvokeResult;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.List;

@Slf4j
@Component(RemoteControlServiceImpl.BEAN_ID)
public class RemoteControlServiceImpl extends BaseRemoteImpl implements RemoteControlService {

    public static final String BEAN_ID = "bhzn.remoteControlService";

    @Autowired
    private NotifyWebInvoker notifyWebInvoker;


    @Override
    public DeviceControlResponse deviceControl(DeviceControlRequest request) {
        try {
            controlBatchExe(request);
        } catch (Exception e) {
            log.error("平台------>>>>控制柜：设备操作-后端异常-{}", e);
            return new DeviceControlResponse(OrderRespEnum.ORDER_ERROR.getCode(), e.getMessage());
        }
        return new DeviceControlResponse(OrderRespEnum.ORDER_SUCCESS);
    }


    /**
     * å¤šä¸ªè®¾å¤‡æ‰§è¡Œ
     *
     * @param request
     * @throws Exception
     */
    public void controlBatchExe(DeviceControlRequest request) throws Exception {

        IoMessage message = ControlCommandBuilder.getInstance().buildMessage(request);

        log.info("平台------>>>>控制柜：设备操作-{}", message.toString());

        InvokeResult result = send(request.getIp(), request.getPort(), message.getByteMsg());

        // å¦‚果有执行异常，直接通知到前端
        if (InvokeResult.SUCCESS.getCode() != result.getCode()) {
            log.error("平台------>>>>控制柜：设备操作-执行失败-{}", result.getMessage());
            notifyWeb(request.getCompanyId(), OrderRespEnum.ORDER_ERROR, "设备操作异常：原因：" + result.getMessage());
            
           return;
        }

        List<ExeDevice> listDevice = request.getDeviceList();
        String deviceType = listDevice.get(0).getType();
        String targetStatus = listDevice.get(0).getTargetStatus();

        //间隔时间定义
        long longTime = 1000;

        if (DeviceType.TYPE_01.getCode().equals(deviceType)) {
            longTime = 15 * 1000;
        }
        if (DeviceType.TYPE_0B.getCode().equals(deviceType)) {
            longTime = 15 * 1000;
        }
        if (DeviceType.TYPE_07.getCode().equals(deviceType)) {
            longTime = 15 * 1000;
        }
        if (DeviceType.TYPE_06.getCode().equals(deviceType)) {
            longTime = 500;
        }
        if (DeviceType.TYPE_09.getCode().equals(deviceType)) {
            longTime = 15 * 1000;
        }
        if (DeviceStatus.W_OPEN.getCode().equals(targetStatus) || DeviceStatus.W_CLOSE.getCode().equals(targetStatus)) {
            longTime = 15 * 1000;
        }
        if (DeviceStatus.F_OPEN.getCode().equals(targetStatus) || DeviceStatus.F_OPEN_F.getCode().equals(targetStatus)) {
            longTime = 3 * 1000;
        }

        Thread.sleep(longTime);

        //如果不是系统执行，直接诶获取设备状态
        if (!request.isSysExeTag()) {
            log.debug("--------------------执行完成后，系统自动发送状态查询------------------{}", request.getDepotId());
            //queryStatus(request);
        }
    }

    @Override
    public DeviceControlResponse closeAll(DeviceControlRequest request) {
        return new DeviceControlResponse(OrderRespEnum.ORDER_ERROR.getCode(), "协议不支持");
    }

    @Override
    public DeviceControlResponse queryStatus(DeviceControlRequest request) {

        return new DeviceControlResponse(OrderRespEnum.ORDER_ERROR.getCode(), "协议不支持");
    }


    @Override
    public DeviceControlResponse tempControl(TempControlRequest request) {
        try {
            IoMessage message = TempControlCommandBuilder.getInstance().buildMessage(request);

            log.info("平台------>>>>控制柜：空调设备操作-{}", message.toString());

            InvokeResult result = send(request.getIp(), request.getPort(), message.getByteMsg());

            // å¦‚果有执行异常，直接通知到前端
            if (InvokeResult.SUCCESS.getCode() != result.getCode()) {
                log.error("平台------>>>>控制柜：空调设备操作-执行失败-{}", result.getMessage());

               // notifyWeb(request.getCompanyId(), OrderRespEnum.ORDER_ERROR, "设备操作异常：原因：" + result.getMessage());

                return new DeviceControlResponse(OrderRespEnum.ORDER_ERROR.getCode(), "执行异常：原因：" + result.getMessage());
            }

        } catch (Exception e) {
            log.error("平台------>>>>控制柜：空调设备操作-后端异常-{}", e);
            return new DeviceControlResponse(OrderRespEnum.ORDER_ERROR.getCode(), e.getMessage());
        }

        return new DeviceControlResponse(OrderRespEnum.ORDER_SUCCESS);
    }


    @Override
    public DeviceControlResponse n2AutoControl(DeviceAutoControlRequest request) {
        return new DeviceControlResponse(OrderRespEnum.ORDER_ERROR.getCode(), "协议不支持");
    }


    /**
     * è‡ªåŠ¨é€šé£Žï¼Œæ™ºèƒ½æŽ§åˆ¶æŸœæ‰§è¡Œ
     *
     * @param request
     * @return
     */
    @Override
    public DeviceControlResponse airAutoControl(DeviceAutoControlRequest request) {
        return new DeviceControlResponse(OrderRespEnum.ORDER_ERROR.getCode(), "当前协议不支持当前模式！");
    }

    /**
     * é¡µé¢é€šçŸ¥
     *
     * @param companyId
     * @param orderResp
     * @param notifyMsg
     */
    private void notifyWeb(String companyId, OrderRespEnum orderResp,
                           String notifyMsg) {
        notifyWebInvoker.notifyWeb(companyId, orderResp, BizType.AREATION,
                notifyMsg);
    }


}

 igds-protocol-bhzn/src/main/java/com/ld/igds/protocol/bhzn/verb/command/RemoteGasServiceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,78 @@
package com.ld.igds.protocol.bhzn.verb.command;

import com.ld.igds.io.RemoteGasService;
import com.ld.igds.io.constant.OrderRespEnum;
import com.ld.igds.io.request.CheckGasRequest;
import com.ld.igds.io.response.GasResponse;
import com.ld.igds.protocol.bhzn.verb.builder.GasCommandBuilder;
import com.ld.igds.protocol.bhzn.verb.builder.GasStopCommandBuilder;
import com.ld.igds.protocol.bhzn.verb.dto.IoMessage;
import com.ld.io.api.InvokeResult;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

/**
 * æ°”体采集命令实现
 */
@Slf4j
@Component(RemoteGasServiceImpl.BEAN_ID)
public class RemoteGasServiceImpl extends BaseRemoteImpl implements RemoteGasService {

    public static final String BEAN_ID = "bhzn.remoteGasService";


    @Override
    public GasResponse checkGas(CheckGasRequest request) {
        try {
            IoMessage message = GasCommandBuilder.getInstance().buildMessage(request);

            InvokeResult result = send(request.getIp(), request.getPort(),
                    message.getByteMsg());

            log.error("平台------>>>>控制柜：气体检测-{}", message.toString());

            if (InvokeResult.SUCCESS != result) {
                log.error("平台------>>>>控制柜：气体检测-失败{}", result.getMessage());
                return new GasResponse(OrderRespEnum.ORDER_ERROR.getCode(),
                        "采集执行失败：" + result.getMessage());
            }

        } catch (Exception e) {
            log.error("气体检测异常：{}", e);
            return new GasResponse(OrderRespEnum.ORDER_ERROR.getCode(),
                    "采集异常，原因：" + e.getMessage());
        }
        return new GasResponse(OrderRespEnum.ORDER_SUCCESS.getCode(),
                "气体采集命令发送成功！");
    }

    @Override
    public GasResponse stopCheckGas(CheckGasRequest request) {
        try {
            IoMessage message = GasStopCommandBuilder.getInstance().buildMessage(request);

            InvokeResult result = send(request.getIp(), request.getPort(),
                    message.getByteMsg());

            log.error("平台------>>>>控制柜：气体检测-{}", message.toString());

            if (InvokeResult.SUCCESS != result) {
                log.error("平台------>>>>控制柜：气体检测-失败{}", result.getMessage());
                return new GasResponse(OrderRespEnum.ORDER_ERROR.getCode(),
                        "采集执行失败：" + result.getMessage());
            }

        } catch (Exception e) {
            log.error("气体检测异常：{}", e);
            return new GasResponse(OrderRespEnum.ORDER_ERROR.getCode(),
                    "采集异常，原因：" + e.getMessage());
        }
        return new GasResponse(OrderRespEnum.ORDER_SUCCESS.getCode(),
                "气体采集命令发送成功！");
    }

    @Override
    public GasResponse checkGasByPoint(CheckGasRequest request) {
        return checkGas(request);
    }
}

 igds-protocol-bhzn/src/main/java/com/ld/igds/protocol/bhzn/verb/command/RemoteGrainServiceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,28 @@
package com.ld.igds.protocol.bhzn.verb.command;

import com.ld.igds.io.RemoteGrainService;
import com.ld.igds.io.constant.OrderRespEnum;
import com.ld.igds.io.request.CheckGrainRequest;
import com.ld.igds.io.response.DeviceControlResponse;
import com.ld.igds.io.response.GrainResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

/**
 * å½“前协议实现，粮情模块命令接口
 *
 * @author jiazx
 */
@Slf4j
@Component(RemoteGrainServiceImpl.BEAN_ID)
public class RemoteGrainServiceImpl extends BaseRemoteImpl implements
        RemoteGrainService {

    public static final String BEAN_ID = "bhzn.remoteGrainService";

    @Override
    public GrainResponse checkGrain(CheckGrainRequest request) {

        return new GrainResponse(OrderRespEnum.ORDER_ERROR.getCode(), "协议不支持");
    }
}

 igds-protocol-bhzn/src/main/java/com/ld/igds/protocol/bhzn/verb/command/RemotePestServiceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,35 @@
package com.ld.igds.protocol.bhzn.verb.command;

import com.ld.igds.io.RemotePestService;
import com.ld.igds.io.constant.OrderRespEnum;
import com.ld.igds.io.request.CheckPestRequest;
import com.ld.igds.io.response.GrainResponse;
import com.ld.igds.io.response.PestResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

/**
 * æ£€æµ‹è™«å®³
 */
@Slf4j
@Component(RemotePestServiceImpl.BEAN_ID)
public class RemotePestServiceImpl extends BaseRemoteImpl implements RemotePestService {

    public static final String BEAN_ID = "bhzn.remotePestService";

    @Override
    public PestResponse checkPest(CheckPestRequest request) {
        return new PestResponse(OrderRespEnum.ORDER_ERROR.getCode(), "协议不支持");
    }

    @Override
    public PestResponse stopCheckPest(CheckPestRequest request) {
        return new PestResponse(OrderRespEnum.ORDER_ERROR.getCode(), "协议不支持");
    }

    @Override
    public PestResponse checkPestByPoint(CheckPestRequest request) {
        return checkPest(request);
    }

}

 igds-protocol-bhzn/src/main/java/com/ld/igds/protocol/bhzn/verb/dto/IoMessage.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,35 @@
package com.ld.igds.protocol.bhzn.verb.dto;

import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.annotation.JSONField;
import lombok.Data;

@Data
public class IoMessage {
    @JSONField(serialize = false)
    private String ip;
    @JSONField(serialize = false)
    private int port;
    private String sn;
    private Integer stNum;
    private String sign;
    private String version;
    private Integer cmd;
    private String result;
    private String orderId;

    private JSONObject content;
    @JSONField(serialize = false)
    private  String contentStr;

    @JSONField(serialize = false)
    private String companyId;
    @JSONField(serialize = false)
    private String strMsg;
    @JSONField(serialize = false)
    private String begin;
    @JSONField(serialize = false)
    private String end;
    @JSONField(serialize = false)
    private byte[] byteMsg;
}

 igds-protocol-bhzn/src/main/java/com/ld/igds/protocol/bhzn/verb/dto/Req209.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,16 @@
package com.ld.igds.protocol.bhzn.verb.dto;

import lombok.Data;

/**
 * æ°”体检测命令
 */
@Data
public class Req209 {

   private Integer Start;
   /**
    * 1-10 0或者空表示所有通道
    */
   private Integer Channel = 0;
}

 igds-protocol-bhzn/src/main/java/com/ld/igds/protocol/bhzn/verb/dto/Req248.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,22 @@
package com.ld.igds.protocol.bhzn.verb.dto;

import lombok.Data;

/**
 * è®¾å¤‡æŽ§åˆ¶
 */
@Data
public class Req248 {


 private  Integer WinCount;
 private  Integer[] Win_Str;
 private  Integer FanCount;
 private  Integer[] Fan_Str;
 private  Integer AirCount;
 private  Integer[] Air_Str;
 private  Integer LightCount;
 private  Integer[] Light_Str;


}

 igds-protocol-bhzn/src/main/java/com/ld/igds/protocol/bhzn/verb/dto/Res209.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,24 @@
package com.ld.igds.protocol.bhzn.verb.dto;

import lombok.Data;

/**
 * æ°”体检测返回
 */
@Data
public class Res209 {

   private Integer State;
   private String Error;
   private Integer N2Avage;
   private Integer PH3Avage;
   private Integer CO2Avage;
   private Integer[] N2ValArray;
   private Integer[] PH3ValArray;
   private Integer[] CO2ValArray;
   private Integer[] N2LayAvage;
   private Integer[] PH3LayAvage;
   private Integer[] CO2LayAvage;
   private Integer[] WormVal;

}

 igds-protocol-bhzn/src/main/java/com/ld/igds/protocol/bhzn/verb/dto/Res247.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,36 @@
package com.ld.igds.protocol.bhzn.verb.dto;

import com.alibaba.fastjson.JSONArray;
import lombok.Data;

/**
 * è®¾å¤‡çŠ¶æ€è¿”回
 */
@Data
public class Res247 {

   private Integer State;
   private String Error;
   private Integer THCount;
   private Integer[] TH_Str;
   private Integer WinCount;
   private Integer[] Win_Str;
   private Integer FanCount;
   private Integer[] Fan_Str;
   private Integer AirCount;
   private Integer[] Air_Str;
   private Integer Mode;
   private Integer[] Light_Str;
   private Integer LightCount;
   private Integer GasDev;
   private Integer N2Val;
   private Integer PH3Val;
   private Integer CO2Val;
   private Integer N2Avage;
   private Integer PH3Avage;
   private Integer CO2Avage;
   private Integer AirPVal;
   private Integer[] ValveSt;
   private Integer[] AriSt;

}

 igds-protocol-bhzn/src/main/java/com/ld/igds/protocol/bhzn/verb/dto/Res248.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,15 @@
package com.ld.igds.protocol.bhzn.verb.dto;

import lombok.Data;

/**
 * è®¾å¤‡æŽ§åˆ¶
 */
@Data
public class Res248 {

 private  Integer State;
 private  String Error;


}

 igds-protocol-bhzn/src/main/java/com/ld/igds/protocol/bhzn/verb/msg/ReMessageBuilder.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,35 @@
package com.ld.igds.protocol.bhzn.verb.msg;

import com.ld.igds.protocol.bhzn.verb.dto.IoMessage;
import com.ld.igds.util.BytesUtil;

/**
 * æ ¹æ®æŽ¥æ”¶åˆ°çš„信息进行封装
 *
 * @author vince
 */
public class ReMessageBuilder {


    public final static String ERROR_TAG = "3CF6";
    public static double FAULT_CHECK_TAG = 85.0;
    public static double MAX_TEMP = -50.0;
    public static double MIN_TEMP = 50.0;
    private final static ReMessageBuilder instance = new ReMessageBuilder();

    private ReMessageBuilder() {
    }

    public static ReMessageBuilder getInstance() {
        return instance;
    }

    /**
     * @param message
     * @return
     */
    public IoMessage buildMessage(String message) throws Exception {
        IoMessage ioMessage = new IoMessage();
        return ioMessage;
    }
}

 igds-protocol-bhzn/src/main/java/com/ld/igds/protocol/bhzn/verb/package-info.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,4 @@
/**
 * é‚¦æµ·æŽ§åˆ¶æŸœåè®®
 */
package com.ld.igds.protocol.bhzn.verb;

 igds-protocol-bhzn/src/main/java/com/ld/igds/protocol/bhzn/verb/server/BhznVerbHeartbeatImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,43 @@
package com.ld.igds.protocol.bhzn.verb.server;


import com.ld.igds.protocol.bhzn.verb.server.BhznVerbServerUtils;
import com.ld.io.api.HeartbeatProvider;
import com.ld.io.api.IoSession;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

/**
 * æä¾›å¿ƒè·³ä¿¡æ¯
 *
 * @author Andy
 */
@Slf4j
@Service
public class BhznVerbHeartbeatImpl implements HeartbeatProvider {

    @Override
    public byte[] provide(IoSession session) {


        //直接根据主机SESSIOn判断
        //IoSession session1 = BhznVerbServerUtils.getSession();

        Long lastBeatTime = BhznVerbServerUtils.getHearBeat(session);

        if (null == lastBeatTime) {
            return null;
        }

        //如果最后一次终端心跳时间距离当前时间大于 ç»ˆç«¯å¿ƒè·³æ—¶é—´çš„3次，则判断为离线
        long deTime = System.currentTimeMillis() - lastBeatTime;

        if (deTime > (BhznVerbServerUtils.HEART_BEAT_TIME * 3 * 1000)) {
            log.info("-----------超过{}秒未获取到心跳信息，判定终端离线，踢出连接------------{}-{}", deTime, session.getAddress(), session.getPort());

            session.destroy();
        }

        return null;
    }
}

 igds-protocol-bhzn/src/main/java/com/ld/igds/protocol/bhzn/verb/server/BhznVerbMessageConsumer.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,88 @@
package com.ld.igds.protocol.bhzn.verb.server;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;
import com.ld.igds.protocol.bhzn.verb.analysis.AnalysisService;
import com.ld.igds.protocol.bhzn.verb.dto.IoMessage;
import com.ld.igds.protocol.bhzn.verb.msg.ReMessageBuilder;
import com.ld.igds.util.BytesUtil;
import com.ld.igds.util.ContextUtil;
import com.ld.igds.util.SpringUtil;
import com.ld.io.api.IoMsgConsumer;
import com.ld.io.api.IoSession;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import static com.ld.igds.protocol.bhzn.verb.server.BhznVerbServerUtils.CHARSET;

/**
 *
 */
@Slf4j
@Service
public class BhznVerbMessageConsumer implements IoMsgConsumer {


    @Autowired
    private AnalysisService analysisService;

    /**
     * å¤„理消息
     *
     * @param session
     * @param bytes
     */
    @Override
    public void consume(IoSession session, byte[] bytes) {
        if (null == bytes) {
            log.error("Reply bytes is null");
            return;
        }
        //添加信息心跳标记
        BhznVerbServerUtils.addHeartBeat(session);
        IoMessage reMessage = null;
        try {
            String message = new String(bytes, CHARSET);
            message = message.substring(message.indexOf(BhznVerbServerUtils.MSG_START1) + BhznVerbServerUtils.MSG_START1.length());
            log.info("【"+session.getAddress()+"】控制柜------>>>>平台："+message);
            reMessage = JSON.parseObject(message, IoMessage.class);
            JSONObject jsonObject = JSON.parseObject(message);
            reMessage.setContentStr(jsonObject.getString("content"));
            if (StringUtils.isEmpty(reMessage.getSn()) ||
                    reMessage.getStNum()== null ||
                    reMessage.getCmd() == null) {
                log.error("控制柜------>>>>平台：报文信息不完整，不做解析-IP={}，port={}，msg={}", session.getAddress(), session.getPort(), message);
                return;
            }

            //根据SN获取组织编码
            String companyId = ContextUtil.getCompanyIdBySn(reMessage.getSn());
            if (null == companyId) {
                log.error("控制柜------>>>>平台：报文信息不完整，当前分机系统未注册，不做解析-IP={}，port={}，msg={}", session.getAddress(), session.getPort(), message);
                return;
            }

            reMessage.setCompanyId(companyId);
            reMessage.setIp(session.getAddress());
            reMessage.setPort(session.getPort());
            reMessage.setStrMsg(message);
            session.setCompanyId(companyId);

            log.info("控制柜------>>>>平台：IP={}，PORT={}，message={}", reMessage.getIp(), reMessage.getPort(), message);

        } catch (Exception e) {
            log.error("控制柜------>>>>平台：收到报文解析异常：{}" , e.getMessage());
            log.error(e.getMessage(),e);
            e.printStackTrace();
        }

        //调用解析接口开始解析
        if (null == analysisService) {
            analysisService = (AnalysisService) SpringUtil.getBean(AnalysisService.BEAN_ID);
        }
        analysisService.analysis(reMessage);
    }
}

 igds-protocol-bhzn/src/main/java/com/ld/igds/protocol/bhzn/verb/server/BhznVerbServerEngine.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,118 @@
package com.ld.igds.protocol.bhzn.verb.server;

import com.ld.io.api.*;
import com.ld.io.netty.NettyServer;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @Desc: é‚¦æµ·æ™ºèƒ½çº¯ç²®æƒ…协议
 * @author: Andy
 * @update-time: 2023/5/11
 */
@Slf4j
@Service
public class BhznVerbServerEngine {

    public static final Integer PORT = 9310;

    @Autowired
    private BhznVerbMessageConsumer defaultMessageConsumer;
    @Autowired
    private BhznVerbSessionListener defaultSessionListener;
    // å¿ƒè·³æä¾›
    private static HeartbeatProvider heartbeatProvider = new BhznVerbHeartbeatImpl();

    private IoSessionQuery sessionQuery;

    public void start(Integer port) {
        IoServerOption ioServerOption = new IoServerOption();

        if (null != port) {
            ioServerOption.setPort(port);
        } else {
            ioServerOption.setPort(PORT);
        }

        //确认结尾标志
        ioServerOption.setDelimiter(BhznVerbServerUtils.MSG_END.getBytes());

        // é…ç½®ç³»ç»Ÿå¿ƒè·³é—´éš”
        ioServerOption.setReaderIdleTime(5 * 60);

        NettyServer ioServer = new NettyServer(ioServerOption, defaultMessageConsumer, defaultSessionListener, heartbeatProvider);
        ioServer.startup();

        sessionQuery = ioServer.getSessionQuery();


        log.info("* ");
        log.info("* ========================");
        log.info("* ");
        log.info("* [VERB-SERVER：BHZN_VERB,PORT={}]", PORT);
        log.info("* ");
        log.info("* ========================");
        log.info("* ");

        System.out.println("* ========================");
        System.out.println("* ");
        System.out.println("* [VERB-SERVER：BHZN_VERB,PORT={}]" + port);
        System.out.println("* ");
        System.out.println("* ========================");
    }

    public IoSessionQuery getSessionQuery() {
        return sessionQuery;
    }

    /**
     * å‘送信息
     *
     * @param ip
     * @param port
     * @param msg
     * @return
     */
    public InvokeResult push(String ip, int port, byte[] msg) {
        IoSessionQuery sessionFactory = getSessionQuery();
        List<IoSession> sessions = sessionFactory.getAllSession();
        IoSession session = null;
        for (IoSession ioSession : sessions) {
            if (BhznVerbServerUtils.getServerKey(ip, port).equals(ioSession.getBusinessKey())) {
                session = ioSession;
                break;
            }
        }
        if (null == session) {
            return InvokeResult.CHANNEL_CLOSED;
        }
        return session.invoke(msg);
    }


//    public InvokeResult push(String ip, int port, String hexStr) {
//
//        byte[] msg = BytesUtil.hexStrToBytes(hexStr);
//
//        IoSessionQuery sessionFactory = getSessionQuery();
//        List<IoSession> sessions = sessionFactory.getAllSession();
//        IoSession session = null;
//        for (IoSession ioSession : sessions) {
//            if (BhznGrainV1ServerUtils.getServerKey(ip, port).equals(ioSession.getBusinessKey())) {
//                session = ioSession;
//                break;
//            }
//        }
//
//        if (null == session) {
//            return InvokeResult.CHANNEL_CLOSED;
//        }
//        return session.invoke(msg);
//    }



}

 igds-protocol-bhzn/src/main/java/com/ld/igds/protocol/bhzn/verb/server/BhznVerbServerUtils.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,127 @@
package com.ld.igds.protocol.bhzn.verb.server;


import com.ld.igds.util.BytesUtil;
import com.ld.igds.util.ContextUtil;
import com.ld.io.api.IoSession;

import java.util.HashMap;
import java.util.Map;

/**
 * å·¥å…·ç±»
 *
 * @author vince
 */
public class BhznVerbServerUtils {


    /**
     * è®¾å¤‡çŠ¶æ€è¿”回的结果 KEY= serId + "_STATUS_" + deviceId value = ç»“果状态
     */
    private static Map<String, String> contextStatusMap = new HashMap<>();


    /**
     * è®¾å¤‡è§£æžåŽçš„装法存放
     *
     * @param serId
     * @param passcode è®¾å¤‡é€šé“ID
     * @param status
     */
    public static void add2StatusMap(String companyId, String serId, String passcode, String status) {
        contextStatusMap.put(ContextUtil.buildDeviceStatusKey(companyId, serId, passcode), status);
    }
    public static void add2StatusMap(String companyId, String serId, int passcode, String status) {
        contextStatusMap.put(ContextUtil.buildDeviceStatusKey(companyId, serId, passcode), status);
    }
    public static Map<String, String> getStatusMap() {
        return contextStatusMap;
    }
    /**
     * è®°å½•æ¯ä¸ªè¿žæŽ¥çš„最后一次信息时间 key = è¿žæŽ¥çš„KYE，data =当前时间戳
     */
    public static Map<String, Long> contextMapHeart = new HashMap<>();

    public static Map<String, IoSession> contextIoSession = new HashMap<>();


    public static int HEART_BEAT_TIME = 30;//心跳间隔时间


    public static String MSG_START = "3C42485A4E3E";//<BHZN>
    public static String MSG_START1 = "<BHZN>";//<BHZN>
    public static String MSG_START2 = "AA";
    public static String MSG_END = "<END>";//<END>
    public static String MSG_END_16 = "3C454E443E";//<END>
    public static final String CHARSET = "UTF-8";


    /**
     * é’ˆå¯¹æ— çº¿ç²®æƒ…主机的默认ID配置
     */
    public static String DEFAULT_MAC_ID = "53681";

    public static String FUNCTION_ID_00 = "00";
    public static String FUNCTION_ID_F1 = "F1";
    public static String FUNCTION_ID_F2 = "F2";
    public static String FUNCTION_ID_83 = "83";
    public static String FUNCTION_ID_93 = "93";
    public static String FUNCTION_ID_92 = "92";


    /**
     * ç”ŸæˆTCP连接的KEY
     *
     * @param ip
     * @param port
     * @return
     */
    public static String getServerKey(String ip, Integer port) {
        return ip + ":" + port;
    }


    /**
     * æ·»åŠ æœ€æ–°å¿ƒè·³æ—¶é—´æˆ³
     *
     * @param session
     */
    public static void addHeartBeat(IoSession session) {
        contextMapHeart.put(getServerKey(session.getAddress(), session.getPort()), System.currentTimeMillis());
    }

    public static Long getHearBeat(IoSession session) {
        return contextMapHeart.get(getServerKey(session.getAddress(), session.getPort()));
    }


    /**
     * è®¡ç®—校验
     *
     * @param content
     * @return
     */
    public static String getCheck(String content) {
        int start = BhznVerbServerUtils.MSG_START.length() + BhznVerbServerUtils.MSG_START2.length();
        content = content.substring(start);
        int sum = 0;
        String hex;
        for (int i = 0; i < content.length() / 2; i++) {
            hex = content.substring(i * 2, i * 2 + 2);
            sum += BytesUtil.hexToInt(hex);
        }
        String hexSum = BytesUtil.intToHexStr(sum);
        int check = BytesUtil.hexToInt(hexSum.substring(hexSum.length() - 2));

        return BytesUtil.intToHexStr(256 - check).substring(2);
    }

//    public static void addSession(IoSession session) {
//        contextIoSession.put(DEFAULT_MAC_ID, session);
//    }
//
//    public static IoSession getSession() {
//        return contextIoSession.get(DEFAULT_MAC_ID);
//    }
}

 igds-protocol-bhzn/src/main/java/com/ld/igds/protocol/bhzn/verb/server/BhznVerbSessionListener.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,65 @@
package com.ld.igds.protocol.bhzn.verb.server;

import com.ld.igds.common.CoreSerService;
import com.ld.io.api.IoSession;
import com.ld.io.api.IoSessionListener;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 *
 */
@Slf4j
@Service
public class BhznVerbSessionListener implements IoSessionListener {

    @Autowired
    private CoreSerService coreSerService;

    /**
     * è®¾å¤‡åˆ›å»ºåœ¨çº¿ï¼Œéœ€è¦æ³¨æ„å½“前使用主机模式，主机上线默认所有相同SN配置的分机全部上线
     *
     * @param session
     */
    @Override
    public void onCreate(IoSession session) {

//        //添加到内存
//        BhznVerbServerUtils.addSession(session);

        log.info("++++新建连接++++-IP={}，PORT={}", session.getAddress(), session.getPort());

        // æ·»åŠ è‡ªå®šä¹‰ä¸šåŠ¡ID
        session.setBusinessKey(BhznVerbServerUtils.getServerKey(session.getAddress(), session.getPort()));

        //项目采用无线主机模式，直接获取默认设备
       // DeviceSer deviceSer = coreSerService.getCacheSer(ContextUtil.getDefaultCompanyId(), BhznGrainV1ServerUtils.DEFAULT_MAC_ID);

        //if (null == deviceSer) return;

        //coreSerService.onlineBySn(session.getAddress(), session.getPort(), deviceSer.getSn(), Constant.YN_Y);
        //更新缓存
       // coreSerService.refreshCache(deviceSer.getCompanyId());
    }

    /**
     * æ³¨æ„ï¼Œå½“前采用主机模式，主机离线所有相同SN配置的分机全部离线
     *
     * @param session
     */
    @Override
    public void onDestroy(IoSession session) {
        log.info("----连接断开-----IP={}，PORT={}", session.getAddress(), session.getPort());

//        //项目采用无线主机模式，直接获取默认设备
//        DeviceSer deviceSer = coreSerService.getCacheSer(ContextUtil.getDefaultCompanyId(), BhznGrainV1ServerUtils.DEFAULT_MAC_ID);
//
//        if (null == deviceSer) return;

        //由于设备掉线后自动调整
//        coreSerService.onlineBySn(session.getAddress(), session.getPort(), deviceSer.getSn(), Constant.YN_N);
//        //更新缓存
//        coreSerService.refreshCache(deviceSer.getCompanyId());
    }
}

 igds-protocol-fzzy3/src/main/java/com/ld/igds/protocol/fzzy/CRC16Util.java

@@ -169,7 +169,7 @@
    public static void main(String[] args) {

        int  i = calcCrc16(BytesUtil.hexStrToBytes("01050046000001"));

        System.out.println(BytesUtil.intToHexStr(i));
        String s = "<BHZN>";
        System.out.println(s.length());
    }
}

 igds-web/src/main/resources/static/img/aerial-5324_001.png

 igds-web/src/main/resources/static/img/areation/5324/pfc_a.png

 igds-web/src/main/resources/static/img/areation/5324/pfc_b.png

 igds-web/src/main/resources/verb-conf.properties

@@ -147,3 +147,30 @@
## 5322_001 å¹¿ä¸œå¾é—»
verb.mapImg.5322_001.a=default_pfc_a.png
verb.mapImg.5322_001.b=default_pfc_b.png


## 5322_001 å¹¿ä¸œå¾é—»
verb.mapImg.5324_001.a=default_pfc_a.png
verb.mapImg.5324_001.b=default_pfc_b.png
verb.mapImg.5324_1.a=pfc_a.png
verb.mapImg.5324_1.b=pfc_b.png
verb.mapImg.5324_2.a=pfc_a.png
verb.mapImg.5324_2.b=pfc_b.png
verb.mapImg.5324_3.a=pfc_a.png
verb.mapImg.5324_3.b=pfc_b.png
verb.mapImg.5324_4.a=pfc_a.png
verb.mapImg.5324_4.b=pfc_b.png
verb.mapImg.5324_5.a=pfc_a.png
verb.mapImg.5324_5.b=pfc_b.png
verb.mapImg.5324_6.a=pfc_a.png
verb.mapImg.5324_6.b=pfc_b.png
verb.mapImg.5324_7.a=pfc_a.png
verb.mapImg.5324_7.b=pfc_b.png
verb.mapImg.5324_8.a=pfc_a.png
verb.mapImg.5324_8.b=pfc_b.png
verb.mapImg.5324_9.a=pfc_a.png
verb.mapImg.5324_9.b=pfc_b.png
verb.mapImg.5324_10.a=pfc_a.png
verb.mapImg.5324_10.b=pfc_b.png
verb.mapImg.5324_11.a=pfc_a.png
verb.mapImg.5324_11.b=pfc_b.png