提交邦海智能粮情协议解析--1

jiazx0107@163.com

2023-12-13 3a56308b1a8f3f453a56da52af64ad4ba669aec1

提交邦海智能粮情协议解析--1

 src/main/java/com/fzzy/api/Constant.java

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

import com.fzzy.api.data.ApiCommonDevice;

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

@@ -335,6 +336,22 @@
        return null;
    }

    public static ApiCommonDevice updateCacheOnline(String ip, Integer port) {
        ApiCommonDevice device = getCommonDeviceCacheByIp(ip);

        if (null == device) {
            device = new ApiCommonDevice();
        }
        device.setIp(ip);
        device.setPort(port);
        device.setStatus(Constant.YN_Y);
        device.setCode("SUCCESS");
        device.setMsg("设备上线");
        device.setOnlineTime(new Date());
        contextDeviceMap.put(device.getSn(), device);
        return device;
    }

    public static ApiCommonDevice updateCacheOffline(String ip, Integer port) {
        ApiCommonDevice device = getCommonDeviceCacheByIp(ip);


 src/main/java/com/fzzy/api/data/GatewayDeviceProtocol.java

@@ -13,6 +13,7 @@

    TCP_FZZY_V3("TCP_FZZY_V3", "粮情-风正致远控制柜协议V3"),
    GRAIN_FZZY_IGDS_V40("GRAIN_FZZY_IGDS_V40", "粮情-风正致远系统V40"),
    GRAIN_FZZY_BHZN_WEB("GRAIN_FZZY_BHZN_WEB", "粮情-风正致远邦海网口协议"),
    DEVICE_WEIGHT_HTTP("DEVICE_WEIGHT_HTTP", "地磅-HTTP协议"),
    DEVICE_WEIGHT_TCP_YH("DEVICE_WEIGHT_TCP_YH", "地磅-耀华TCP协议"),
    DEVICE_IDCARD_HTTP("DEVICE_IDCARD_HTTP", "身份证-HTTP协议"),
@@ -28,6 +29,7 @@
        List<ApiTrigger> list = new ArrayList<>();
        list.add(new ApiTrigger(TCP_FZZY_V3.getCode(), TCP_FZZY_V3.getName()));
        list.add(new ApiTrigger(GRAIN_FZZY_IGDS_V40.getCode(), GRAIN_FZZY_IGDS_V40.getName()));
        list.add(new ApiTrigger(GRAIN_FZZY_BHZN_WEB.getCode(), GRAIN_FZZY_BHZN_WEB.getName()));
        list.add(new ApiTrigger(DEVICE_WEIGHT_HTTP.getCode(), DEVICE_WEIGHT_HTTP.getName()));
        list.add(new ApiTrigger(DEVICE_WEIGHT_TCP_YH.getCode(), DEVICE_WEIGHT_TCP_YH.getName()));
        list.add(new ApiTrigger(DEVICE_IDCARD_HTTP.getCode(), DEVICE_IDCARD_HTTP.getName()));

 src/main/java/com/fzzy/api/utils/BytesUtil.java

@@ -401,4 +401,64 @@
    public static String folatToHexString(Float value) {
        return Integer.toHexString(Float.floatToIntBits(value));
    }

    /**
     * int转16进制字符串 1位置 00
     *
     * @param num
     * @return
     */
    public static String intToHexStr1(int num) {
        // éœ€è¦ä½¿ç”¨2字节表示b
        return String.format("%02x", num).toUpperCase();
    }

    public static String hexString2binaryString(String hexString, int num) {
        //16进制转10进制
        BigInteger sint = new BigInteger(hexString, num);
        //10进制转2进制
        String str = sint.toString(2);
        if(str.length() < num){
            for (int i = str.length(); i < num; i++) {
                str = "0" + str;
            }
        }
        return str;
    }

    /**
     * å°†äºŒè¿›åˆ¶è½¬æ¢ä¸º10进制
     * @param binStr
     * @return
     */
    public  static  Integer biannary2Decimal(String binStr){

        Integer sum = 0;
        int len = binStr.length();

        for (int i=1;i<=len;i++){
            //第i位 çš„数字为：
            int dt = Integer.parseInt(binStr.substring(i-1,i));
            sum+=(int)Math.pow(2,len-i)*dt;
        }
        return  sum;
    }

    /**
     * äºŒè¿›åˆ¶è¡¥ç ï¼šå–反口加1
     * @param str
     * @return
     */
    public static Integer twoToString(String str) {
        String two = "";
        String[] split = str.split("");
        for (int i = 0;i< split.length;i++){
            if("1".equals(split[i])){
                two += "0";
            }else if("0".equals(split[i])){
                two += "1";
            }
        }
        return biannary2Decimal(two) + 1;
    }
}

 src/main/java/com/fzzy/gateway/GatewayUtils.java

@@ -42,6 +42,13 @@
        return cacheMapDeviceId.get(deviceId);
    }


    /**
     * é’ˆå¯¹ä¸€ä¸ªåˆ†æœºå¯¹å»’间的情况
     *
     * @param deviceSn
     * @return
     */
    public static GatewayDevice getCacheByDeviceSn(String deviceSn) {
        Collection<GatewayDevice> list = allCacheDevice();
        if (null == list || list.isEmpty()) return null;

 src/main/java/com/fzzy/protocol/ConstantProtocol.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,15 @@
package com.fzzy.protocol;


/**
 * åè®®è§£æžå…¨å±€å¸¸é‡
 */
public class ConstantProtocol {

    //-粮温备用点
    public static final double ERROR_TEMP = -100;
    //-粮温故障点
    public static final double FAULT_TEMP = -101;
    //-粮温补偿点-针对锥形仓补点使用
    public static final double ADD_TEMP = -102;
}

 src/main/java/com/fzzy/protocol/bhzn/analysis/AnalysisService.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,431 @@
package com.fzzy.protocol.bhzn.analysis;

import com.alibaba.fastjson.JSONObject;
import com.fzzy.api.Constant;
import com.fzzy.api.data.ApiCommonDevice;
import com.fzzy.api.data.GatewayDeviceType;
import com.fzzy.api.utils.BytesUtil;
import com.fzzy.api.utils.NumberUtil;
import com.fzzy.gateway.GatewayUtils;
import com.fzzy.gateway.api.GatewayDeviceReportService;
import com.fzzy.gateway.api.GatewayRemoteManager;
import com.fzzy.gateway.data.BaseReqData;
import com.fzzy.gateway.data.WeatherWebDto;
import com.fzzy.gateway.entity.GatewayDevice;
import com.fzzy.gateway.hx2023.ScConstant;
import com.fzzy.gateway.hx2023.data.*;
import com.fzzy.protocol.ConstantProtocol;
import com.fzzy.protocol.bhzn.cmd.CommandBuild;
import com.fzzy.protocol.bhzn.cmd.ReMessageBuilder;
import com.fzzy.protocol.bhzn.data.IoMessage;
import com.fzzy.protocol.bhzn.data.THDto;
import com.fzzy.protocol.bhzn.server.BhznGrainV2ServerEngine;
import com.fzzy.protocol.bhzn.server.BhznGrainV2ServerUtils;
import com.fzzy.protocol.fzzy.server.ServerUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.*;

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


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

    @Resource
    private GatewayRemoteManager gatewayRemoteManager;

    /**
     * é’ˆå¯¹åˆ†åŒ…粮情报文进行封装
     */
    public static Map<String, String> contextMapGrain = new HashMap<>();

    /**
     * ç”¨äºŽå­˜æ”¾è¿”回的仓温仓湿信息
     */
    public static Map<String, THDto> contextMapTH = new HashMap<>();

    /**
     * @param sessionKey ip:port
     */
    public void analysis(String sessionKey, IoMessage message) throws Exception {

        //注册
        if (BhznGrainV2ServerUtils.FUNCTION_ID_F1.equals(message.getFunctionId())) {

            log.info("主机------->>平台：注册信息报文={}", message);

            //DO NOTHING

            return;
        }

        //心跳
        if (BhznGrainV2ServerUtils.FUNCTION_ID_F2.equals(message.getFunctionId())) {

            //DO NOTHING

            return;
        }

        // 93 è§£æžä»“温仓湿，并返回收到报文
        if (BhznGrainV2ServerUtils.FUNCTION_ID_93.equals(message.getFunctionId())) {
            log.info("主机------->>平台：温湿度信息报文={}", message);
            analysisTh(message);
            return;
        }

        // 92 è§£æžç²®æ¸©ï¼Œå¹¶è¿”回收到报文
        if (BhznGrainV2ServerUtils.FUNCTION_ID_92.equals(message.getFunctionId())) {
            log.info("主机------->>平台：粮情信息报文={}", message);
            analysisGrain(message);
        }
    }


    /**
     * æš‚时不支持义分机多仓模式，--平房仓
     *
     * @param message
     */
    private void analysisGrain(IoMessage message) {
        try {

            //根据分机地址获取分机信息
            ApiCommonDevice commonDevice = Constant.getCommonDeviceCache(message.getAddr());
            if (commonDevice == null) {
                replayGrain(message);
                log.error("主机-------->>平台，解析粮情失败，未获取到系统粮情主机配置：" + message.getAddr());
                return;
            }

            //根据分机SN获取设备配置信息
            GatewayDevice gatewayDevice = GatewayUtils.getCacheByDeviceSn(commonDevice.getSn());
            if (null == gatewayDevice) {
                replayGrain(message);
                log.error("主机-------->>平台，解析粮情失败，未获取到系统设备配置信息：" + message.getAddr());
                return;
            }

            //获取请求信息
            BaseReqData reqData = BhznGrainV2ServerUtils.getSyncReq(gatewayDevice.getDepotIdSys());
            if (null == reqData) {
                replayGrain(message);
                log.error("主机-------->>平台，解析粮情失败，未获取到粮情请求信息：" + message.getAddr());
                return;
            }

            // åˆ¤æ–­æ•°æ®æœ‰æ²¡æœ‰æ”¶å–完整
            String[] attCable = gatewayDevice.getCableRule().split("-");
            int cableZ = Integer.valueOf(attCable[0]);
            int cableY = Integer.valueOf(attCable[1]);
            int cableX = Integer.valueOf(attCable[2]);
            int sumPoint = cableZ * cableY * cableX;

            //获取当前粮情温度报文
            String grainHex = message.getContent().substring(16);

            //当前报文温度点数
            int curPoint = BytesUtil.hexToInt(BytesUtil.tran_LH(message.getContent().substring(4, 8)));

            //如果当前包的数据个数大于等于当前仓库的配置点位则表示单包返回
            if (curPoint >= sumPoint) {
                log.info("分机------>>>平台：粮情数据单包=" + grainHex);
                //返回粮情接收信息
                replayGrain(message);
                analysisGrain2(message, reqData, grainHex);
                return;
            }

            //表示分包传递
            String key = "GRAIN_" + message.getAddr();
            String oldGrainHex = contextMapGrain.get(key) == null ? "" : contextMapGrain.get(key);

            //获取当前包起始点的层行列
            int hang = BytesUtil.hexToInt(BytesUtil.tran_LH(message.getContent().substring(8, 10)));
            int lie = BytesUtil.hexToInt(BytesUtil.tran_LH(message.getContent().substring(10, 12)));
            int ceng = BytesUtil.hexToInt(BytesUtil.tran_LH(message.getContent().substring(12, 14)));
            if (hang > 0 || lie > 0 || ceng > 0) {
                //说明非第一包数据
                grainHex = oldGrainHex + grainHex;
            }

            if (grainHex.length() >= sumPoint * 4) {
                //返回粮情接收信息
                replayGrain(message);
                log.info("分机------>>>平台：粮情数据多包，完整数据=" + grainHex);
                analysisGrain2(message, reqData, grainHex);
                return;

            } else {
                log.info("分机------>>>平台：将第一包数据存入内存=" + grainHex);
                contextMapGrain.put(key, grainHex);
                replayGrain(message);
            }

        } catch (Exception e) {
            log.error(e.getMessage(), e);
        }
    }

    /**
     * è¿”回粮情收到报文信息，需要注意：如果存在分包情况下，需要等所有包收到后返回
     *
     * @param message
     */
    private void replayGrain(IoMessage message) throws InterruptedException {
        Thread.sleep(50);
        String hexStr = CommandBuild.getMsgGrainReply(message.getAddr());
        log.info("平台--------->>>主机，返回粮情报文收到信息，报文={}", hexStr);

        BhznGrainV2ServerEngine.push(message.getIp(), message.getPort(), BytesUtil.hexStrToBytes(hexStr));
    }

    private void analysisGrain2(IoMessage message, BaseReqData reqData, String grainStr) {

        GatewayDevice device = reqData.getDevice();
        // èŽ·å–完整的粮情包信息
        String[] attCable = device.getCableRule().split("-");
        int cableZ = Integer.valueOf(attCable[0]);
        int cableY = Integer.valueOf(attCable[1]);
        int cableX = Integer.valueOf(attCable[2]);

        // æ ¹æ®å±‚行列获取指定长度
        int start = 0;
        int len = 4 * cableZ * cableY * cableX;

        log.info("分机------>>>平台：返回粮情完整信息，分机={}", device.getDeviceName());

        String strPoints = grainStr.substring(start, start + len);

        // å°†ç²®æƒ…解析成数组
        List<Double> temps = new ArrayList<>();
        double tempValue;
        String temp;
        for (int i = 0; i < strPoints.length() / 4; i++) {
            temp = strPoints.substring(i * 4, i * 4 + 4);
            if (temp == null) {
                temp = "0000";
            }
            if (ReMessageBuilder.ERROR_TAG.equals(temp)) {
                tempValue = ConstantProtocol.ERROR_TEMP;
            } else {
                tempValue = BytesUtil.hexToInt(BytesUtil.tran_LH(temp)) / 10.0;
            }
            // æ•…障值处理
            if (tempValue >= ReMessageBuilder.FAULT_CHECK_TAG) {
                tempValue = ConstantProtocol.FAULT_TEMP;
            }
            temps.add(tempValue);
        }


        THDto thDto = this.getTH(message);
        if (null != thDto) {
            log.debug("-------THDto--={}", thDto);
        }
        //清空
        String key = "GRAIN_" + message.getAddr();
        contextMapGrain.put(key, null);

        // å°†é›†åˆè§£æžæˆåæ ‡æ•°æ®
        addPoint1(temps, reqData, thDto);
    }


    /**
     * å¹³æˆ¿ä»“，解析第二步，解析到坐标数据
     *
     * @param temps
     * @throws Exception
     */
    private void addPoint1(List<Double> temps, BaseReqData reqData, THDto thDto) {

        GatewayDevice device = reqData.getDevice();

        String[] attCable = device.getCableRule().split("-");
        int cableZ = Integer.valueOf(attCable[0]);
        int cableY = Integer.valueOf(attCable[1]);
        int cableX = Integer.valueOf(attCable[2]);

        //数据封装
        GrainData grain = new GrainData();
        grain.setMessageId(ScConstant.getMessageId());
        grain.setDeviceId(device.getDeviceId());
        grain.setTimestamp(System.currentTimeMillis() + "");

        ClientHeaders headers = new ClientHeaders();
        headers.setDeviceName(device.getDeviceName());
        headers.setProductId(device.getProductId());
        headers.setOrgId(device.getOrgId());
        headers.setMsgId(reqData.getMessageId());
        grain.setHeaders(headers);


        GrainOutPut outPut = new GrainOutPut();


        double max = ReMessageBuilder.MAX_TEMP, min = ReMessageBuilder.MIN_TEMP, sumT = 0.0, sumNum = cableX
                * cableY * cableZ;

        List<GrainTemp> temperature = new ArrayList<>();
        //根号
        int cableNum = 1, position = 0;

        double curTemp;
        int x = 0, y = 0, z = 0;
        for (int i = 0; i < temps.size(); i++) {
            curTemp = temps.get(i);
            position = i;
            z = i % cableZ + 1;
            x = i / (cableZ * cableY);
            y = x * (cableZ * cableY);
            y = (i - y) / cableZ;
            //根号
            cableNum = (i / cableZ) + 1;

            temperature.add(new GrainTemp(cableNum + "", z + "", curTemp + "", position + ""));

            //求最大最小值
            if (curTemp < -900) {
                sumNum--;
            } else {
                sumT += curTemp;
                if (curTemp > max) {
                    max = curTemp;
                }
                if (curTemp < min) {
                    min = curTemp;
                }
            }
        }

        if (sumNum == 0) {
            sumNum = 1;
            log.warn("---当前粮情采集异常--");
        }
        //过滤比较用的最大最小值
        if (max == ReMessageBuilder.MAX_TEMP) {
            max = 0.0;
        }
        if (min == ReMessageBuilder.MIN_TEMP) {
            min = 0.0;
        }

        outPut.setTemperature(temperature);
        outPut.setAvgTemperature(NumberUtil.keepPrecision((sumT / sumNum), 1) + "");
        outPut.setMinTemperature(min + "");
        outPut.setMaxTemperature(min + "");

        grain.setOutput(JSONObject.toJSONString(outPut));

        GatewayDevice gatewayDeviceWeather = GatewayUtils.getCacheByDeviceTypeOne(GatewayDeviceType.TYPE_09.getCode());

        //系统气象站信息
        WeatherWebDto weather = WeatherWebDto.contextMap.get("default");

        //气象信息
        GrainWeather weatherStation = new GrainWeather();
        weatherStation.setMessageId(ScConstant.getMessageId());
        weatherStation.setMessgeId(weatherStation.getMessageId());

        if (null != gatewayDeviceWeather) {
            weatherStation.setId(gatewayDeviceWeather.getDeviceId());
        } else {
            weatherStation.setId(device.getDeviceId());
        }
        weatherStation.setAirPressure(weather.getPressure());
        weatherStation.setHumidity(weather.getHumidity());
        weatherStation.setPm(weather.getAir_pm25());
        weatherStation.setRadiation("0");
        weatherStation.setRainfallAmount(weather.getWea());
        weatherStation.setTemperature(weather.getTem());
        weatherStation.setWindDirection(weather.getWin());
        weatherStation.setWindPower(weather.getWin_meter());
        weatherStation.setWindSpeed(weather.getWin_speed());

        grain.setWeatherStation(JSONObject.toJSONString(weatherStation));

        //封装好的数据
        log.info("---粮情机械封装完成----开始执行推送");

        reqData.setData(JSONObject.toJSONString(grain));

        doPushGrain(reqData);
    }

    private void doPushGrain(BaseReqData reqData) {

        GatewayDeviceReportService reportService = gatewayRemoteManager.getDeviceReportService(reqData.getDevice().getPushProtocol());
        if (null == reportService) {
            log.error("------------粮情推送失败，系统不存在当前协议执行类----{}", reqData.getDevice().getDeviceName());
            return;
        }
        reportService.reportGrainData(reqData);
    }


    private void analysisTh(IoMessage message) {
        try {
            THDto th = new THDto();
            String data = message.getContent();
            String houseNo = data.substring(0, 4);
            int depotId = BytesUtil.hexToInt(BytesUtil.tran_LH(houseNo));
            String t = data.substring(4, 8);
            String h = data.substring(8, 12);
            double humy;
            String temp;
            int symbol = 0; //符号位
            double tempValue;
            if (ReMessageBuilder.ERROR_TAG.equals(t)) {
                temp = "0000";
            } else {
                temp = BytesUtil.tran_LH(t);
            }
            temp = BytesUtil.hexString2binaryString(temp, 16);

            //符号位
            symbol = Integer.valueOf(temp.substring(0, 1));
            //获取温度值
            tempValue = BytesUtil.biannary2Decimal(temp.substring(6)) / 10;
            //若为负，则补码：取反加1
            if (symbol == 1) {
                tempValue = 0.0 - BytesUtil.twoToString(temp) / 10;
            }
            th.setTempIn(tempValue);
            if (ReMessageBuilder.ERROR_TAG.equals(h)) {
                humy = 0.0;
            } else {
                humy = (double) BytesUtil.hexToBigInt(BytesUtil.tran_LH(h)) / 10;
            }
            th.setHumidityIn(humy);
            log.info("主机--------->>>平台，解析仓温仓湿信息，仓库={},结果={}", depotId, th.toString());

            String key = "TH_" + depotId;
            contextMapTH.put(key, th);

        } catch (Exception e) {
            log.error(e.getMessage(), e);
        } finally {
            String hexStr = CommandBuild.getMsgTHReply(message.getAddr());
            log.info("平台--------->>>主机，返回仓温仓湿收到信息，报文={}", hexStr);
            BhznGrainV2ServerEngine.push(message.getIp(), message.getPort(), BytesUtil.hexStrToBytes(hexStr));
        }
    }

    private THDto getTH(IoMessage message) {
        String data = message.getContent();
        String houseNo = data.substring(0, 2);
        Integer depotId = BytesUtil.hexToInt(houseNo);
        String key = "TH_" + depotId;
        return contextMapTH.get(key);
    }
}

 src/main/java/com/fzzy/protocol/bhzn/cmd/CommandBuild.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,179 @@
package com.fzzy.protocol.bhzn.cmd;


import com.fzzy.api.utils.BytesUtil;
import com.fzzy.protocol.bhzn.server.BhznGrainV2ServerUtils;

/**
 * å‘½ä»¤ç”Ÿæˆ
 *
 * @author vince
 */
public class CommandBuild {

    private final static CommandBuild instance = new CommandBuild();

    private CommandBuild() {
    }

    public static CommandBuild getInstance() {
        return instance;
    }

    /**
     * PC回复 å¿ƒè·³å•Š æ”¶åˆ°ä¿¡æ¯
     *
     * @param grainAddr
     * @return
     */
    public static String getMsgHeartReply(String grainAddr) {

        StringBuffer sb = new StringBuffer();

        //开始符号
        sb.append(BhznGrainV2ServerUtils.MSG_START);
        sb.append(BhznGrainV2ServerUtils.MSG_START2);

        //分机地址
        int i = Integer.parseInt(grainAddr);
        sb.append(BytesUtil.tran_LH(BytesUtil.intToHexStr(i)));

        //发送方地址
        sb.append("0001");

        //命令ID
        sb.append(BhznGrainV2ServerUtils.FUNCTION_ID_F2);

        //数据长度-01
        sb.append("01");

        //数据区--任意值
        sb.append("01");

        //获取校验码
        sb.append(BhznGrainV2ServerUtils.getCheck(sb.toString()));

        //结尾符
        sb.append(BhznGrainV2ServerUtils.MSG_END_16);

        return sb.toString();
    }

    /**
     * ç²®æƒ…采集命令
     *
     * @param grainAddr ç²®æƒ…分机地址
     * @param deptId    ä»“库编号地址
     * @return
     */
    public static String getMsgCheck(String grainAddr, String deptId) {

        StringBuffer sb = new StringBuffer();

        //开始符号
        sb.append(BhznGrainV2ServerUtils.MSG_START);
        sb.append(BhznGrainV2ServerUtils.MSG_START2);

        //分机地址
        int i = Integer.parseInt(grainAddr);
        sb.append(BytesUtil.tran_LH(BytesUtil.intToHexStr(i)));

        //发送方地址
        sb.append("0001");

        //命令ID
        sb.append(BhznGrainV2ServerUtils.FUNCTION_ID_83);

        //数据长度-01
        sb.append("01");

        //数据区--主机里面配置的仓库编码
        i = Integer.parseInt(deptId);
        sb.append(BytesUtil.intToHexStr1(i));

        //获取校验码
        sb.append(BhznGrainV2ServerUtils.getCheck(sb.toString()));

        //结尾符
        sb.append(BhznGrainV2ServerUtils.MSG_END_16);

        return sb.toString();
    }

    /**
     * PC回复 ä»“温仓湿 æ”¶åˆ°ä¿¡æ¯
     *
     * @param grainAddr
     * @return
     */
    public static String getMsgTHReply(String grainAddr) {

        StringBuffer sb = new StringBuffer();

        //开始符号
        sb.append(BhznGrainV2ServerUtils.MSG_START);
        sb.append(BhznGrainV2ServerUtils.MSG_START2);

        //分机地址
        int i = Integer.parseInt(grainAddr);
        sb.append(BytesUtil.tran_LH(BytesUtil.intToHexStr(i)));

        //发送方地址
        sb.append("0001");

        //命令ID
        sb.append(BhznGrainV2ServerUtils.FUNCTION_ID_93);

        //数据长度-01
        sb.append("01");

        //数据区--任意值
        sb.append("01");

        //获取校验码
        sb.append(BhznGrainV2ServerUtils.getCheck(sb.toString()));

        //结尾符
        sb.append(BhznGrainV2ServerUtils.MSG_END_16);

        return sb.toString();
    }

    /**
     * PC回复粮温收到信息
     *
     * @param grainAddr
     * @return
     */
    public static String getMsgGrainReply(String grainAddr) {
        StringBuffer sb = new StringBuffer();

        //开始符号
        sb.append(BhznGrainV2ServerUtils.MSG_START);
        sb.append(BhznGrainV2ServerUtils.MSG_START2);

        //分机地址
        int i = Integer.parseInt(grainAddr);
        sb.append(BytesUtil.tran_LH(BytesUtil.intToHexStr(i)));

        //发送方地址
        sb.append("0001");

        //命令ID
        sb.append(BhznGrainV2ServerUtils.FUNCTION_ID_92);

        //数据长度-01
        sb.append("01");

        //数据区--任意值
        sb.append("01");

        //获取校验码
        sb.append(BhznGrainV2ServerUtils.getCheck(sb.toString()));

        //结尾符
        sb.append(BhznGrainV2ServerUtils.MSG_END_16);

        return sb.toString();
    }
}

 src/main/java/com/fzzy/protocol/bhzn/cmd/ReMessageBuilder.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,52 @@
package com.fzzy.protocol.bhzn.cmd;


import com.fzzy.api.utils.BytesUtil;
import com.fzzy.protocol.bhzn.data.IoMessage;

/**
 * æ ¹æ®æŽ¥æ”¶åˆ°çš„信息进行封装
 *
 * @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();

        //转换为数字，高低位转换(4位)
        int i = BytesUtil.hexToBigInt(BytesUtil.tran_LH(message.substring(2, 6)));
        ioMessage.setPcAddr(i + "");
        i = BytesUtil.hexToBigInt(BytesUtil.tran_LH(message.substring(6, 10)));//高低位转换(4位)
        ioMessage.setAddr(i + "");

        ioMessage.setFunctionId(message.substring(10, 12));//功能码(2位)，不用高低位转换

        i = BytesUtil.hexToBigInt(message.substring(12, 14));//长度(1位)
        ioMessage.setLength(i);

        //获取消息体
        ioMessage.setContent(message.substring(14, 14 + (i * 2)));

        ioMessage.setCheck(message.substring(message.length() - 2));
        return ioMessage;
    }
}

 src/main/java/com/fzzy/protocol/bhzn/data/Content.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,43 @@
package com.fzzy.protocol.bhzn.data;

import lombok.Data;

/**
 * @author vince.xu
 * @Title: Content
 * @ProjectName igds-35
 * @Description: TODO
 * @date 2022-12-715:48
 */
@Data
public class Content {
    /**
     * çŠ¶æ€åå›ž
     */
    public  String result;
    /**
     * çº¯åº¦
     */
    public String purity;
    /**
     * æµé‡
     */
    public String flow;
    /**
     * åŽ‹åŠ›
     */
    public String pressure;
    /**
     * æ¸©åº¦
     */
    public String temperature;
    /**
     * æµé‡ç´¯è®¡
     */
    public String flowAll;
    /**
     * è¿è¡ŒçŠ¶æ€
     */
    public String isRun;

}

 src/main/java/com/fzzy/protocol/bhzn/data/IoMessage.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,20 @@
package com.fzzy.protocol.bhzn.data;

import lombok.Data;

@Data
public class IoMessage {


    private String ip;

    private int port;

    private String pcAddr;
    private String addr;
    private String functionId;
    private int length;
    private String content;
    private String check;

}

 src/main/java/com/fzzy/protocol/bhzn/data/THDto.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,39 @@
package com.fzzy.protocol.bhzn.data;

import com.bstek.dorado.annotation.PropertyDef;
import lombok.Data;

import java.io.Serializable;
import java.util.Date;

/**
 * ä¸šåŠ¡æ•°æ®ï¼šç²®é£Ÿæ¸©åº¦æ¹¿åº¦ç»Ÿè®¡ä¿¡æ¯
 * 
 * @author Andy
 *
 */
@Data
public class THDto implements Serializable {

	
    private static final long serialVersionUID = 1L;

    private String serId;//所属分机

    private String thConf = "1";//所属通道

    @PropertyDef(label = "所属仓库", description = "仓库编号")
    private String depotId;

    @PropertyDef(label = "仓内温度", description = "单位℃")
    private Double tempIn;

    @PropertyDef(label = "仓内湿度", description = "单位%RH")
    private Double humidityIn;
	
    @PropertyDef(label = "接收时间", description = "")
    private Date receiveDate = new Date();

    private String remark;

}

 src/main/java/com/fzzy/protocol/bhzn/package-info.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,4 @@
/**
 * é‚¦æµ·æ™ºèƒ½çº¯ç²®æƒ…分机协议-网口设备
 */
package com.fzzy.protocol.bhzn;

 src/main/java/com/fzzy/protocol/bhzn/server/BhznGrainV2HeartbeatImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,36 @@
package com.fzzy.protocol.bhzn.server;


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 BhznGrainV2HeartbeatImpl implements HeartbeatProvider {

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

        Long lastBeatTime = BhznGrainV2ServerUtils.getHearBeat(session);

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

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

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

 src/main/java/com/fzzy/protocol/bhzn/server/BhznGrainV2MessageConsumer.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,56 @@
package com.fzzy.protocol.bhzn.server;

import com.fzzy.api.utils.BytesUtil;
import com.fzzy.api.utils.SpringUtil;
import com.fzzy.protocol.bhzn.analysis.AnalysisService;
import com.fzzy.protocol.bhzn.cmd.ReMessageBuilder;
import com.fzzy.protocol.bhzn.data.IoMessage;
import com.ld.io.api.IoMsgConsumer;
import com.ld.io.api.IoSession;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

/**
 *
 */
@Slf4j
public class BhznGrainV2MessageConsumer implements IoMsgConsumer {


    private AnalysisService analysis;

    /**
     * å¤„理消息
     *
     * @param ioSession
     * @param bytes
     */
    @Override
    public void consume(IoSession ioSession, byte[] bytes) {
        if (null == bytes) {
            log.error("Reply bytes is null");
            return;
        }

        //添加信息心跳标记
        BhznGrainV2ServerUtils.addHeartBeat(ioSession);

        try {
            String hexStr = BytesUtil.bytesToString(bytes);

            log.info("【"+ioSession.getAddress()+"】主机------->>平台：报文：" + hexStr);
            hexStr = hexStr.substring(BhznGrainV2ServerUtils.MSG_START.length());

            IoMessage ioMessage = ReMessageBuilder.getInstance().buildMessage(hexStr);
            ioMessage.setIp(ioSession.getAddress());
            ioMessage.setPort(ioSession.getPort());

            if(null == analysis) analysis = SpringUtil.getBean(AnalysisService.class);

            analysis.analysis(ioSession.getBusinessKey(), ioMessage);

        } catch (Exception e) {
            log.error(e.getMessage(), e);
        }
    }
}

 src/main/java/com/fzzy/protocol/bhzn/server/BhznGrainV2ServerEngine.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,91 @@
package com.fzzy.protocol.bhzn.server;

import com.fzzy.protocol.fzzy.server.ServerUtils;
import com.ld.io.api.*;
import com.ld.io.netty.NettyServer;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import java.util.List;

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

    public static final Integer PORT = 19309;

    public static NettyServer ioServer = null;


    // é…ç½®æ¶ˆæ¯æŽ¥æ”¶ç±»
    private static BhznGrainV2MessageConsumer messageConsume = new BhznGrainV2MessageConsumer();
    // ç›‘听会话的创建与销毁
    private static BhznGrainV2SessionListener ioSessionListener = new BhznGrainV2SessionListener();
    // å¿ƒè·³æä¾›
    private static HeartbeatProvider heartbeatProvider = new BhznGrainV2HeartbeatImpl();


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

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

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

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

        NettyServer ioServer = new NettyServer(ioServerOption, messageConsume, ioSessionListener, heartbeatProvider);
        ioServer.startup();


        log.info("* ");
        log.info("* ========================");
        log.info("* ");
        log.info("* [GRAIN-SERVER：BHZN_GRAIN,PORT={}]" + port);
        log.info("* ");
        log.info("* ========================");
        log.info("* ");

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

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

}

 src/main/java/com/fzzy/protocol/bhzn/server/BhznGrainV2ServerUtils.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,116 @@
package com.fzzy.protocol.bhzn.server;


import com.fzzy.api.utils.BytesUtil;
import com.fzzy.gateway.data.BaseReqData;
import com.ld.io.api.IoSession;

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

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


    /**
     * è®°å½•æ¯ä¸ªè¿žæŽ¥çš„最后一次信息时间 key = è¿žæŽ¥çš„KYE，data =当前时间戳
     */
    public static Map<String, Long> contextMapHeart = new HashMap<>();

    /**
     * è¯·æ±‚缓存 key = deviceId,value = requData
     */
    private static Map<String, BaseReqData> contextSyncReqMap = new HashMap<>();



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


    public static String MSG_START = "3C42485A4E3E";//<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";


    /**
     * å°†æ‰§è¡Œå‘½ä»¤ä¿¡æ¯å­˜æ”¾åœ¨ç¼“å­˜
     *
     * @param depotId ä»“库编码
     * @param reqData è¯·æ±‚参数信息
     */
    public static void addSyncReq2Map(String depotId, BaseReqData reqData) {
        contextSyncReqMap.put(depotId, reqData);
    }

    public static BaseReqData getSyncReq(String depotId) {
        return contextSyncReqMap.get(depotId);
    }


    /**
     * ç”Ÿæˆ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 = BhznGrainV2ServerUtils.MSG_START.length() + BhznGrainV2ServerUtils.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);
    }

}

 src/main/java/com/fzzy/protocol/bhzn/server/BhznGrainV2SessionListener.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,62 @@
package com.fzzy.protocol.bhzn.server;

import com.fzzy.api.Constant;
import com.fzzy.api.data.ApiCommonDevice;
import com.fzzy.api.utils.SpringUtil;
import com.fzzy.gateway.service.GatewayDeviceService;
import com.ld.io.api.IoSession;
import com.ld.io.api.IoSessionListener;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

/**
 * è¿žæŽ¥ä¸Šçº¿å’Œä¸‹é™é€šçŸ¥
 */
@Slf4j
public class BhznGrainV2SessionListener implements IoSessionListener {


    private GatewayDeviceService gatewayDeviceService;

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

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

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

        //执行分机上线
        ApiCommonDevice commonDevice = Constant.updateCacheOnline(session.getAddress(), session.getPort());
        if (null == commonDevice.getSn()) {
            log.error("------设备上线，系统中未发现当前配置-------");
        }
    }

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

        //设置分机掉线
        ApiCommonDevice commonDevice = Constant.updateCacheOffline(session.getAddress(), session.getPort());

        if (null == commonDevice) return;

        if (null == gatewayDeviceService) {
            gatewayDeviceService = SpringUtil.getBean(GatewayDeviceService.class);

            gatewayDeviceService.OfflineByCommonDevice(commonDevice);
        }

    }
}

 src/main/java/com/fzzy/protocol/bhzn/service/Bhzn2GatewayGrainService.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,85 @@
package com.fzzy.protocol.bhzn.service;

import com.fzzy.api.Constant;
import com.fzzy.api.data.ApiCommonDevice;
import com.fzzy.api.data.GatewayDeviceProtocol;
import com.fzzy.api.utils.BytesUtil;
import com.fzzy.gateway.api.GatewaySyncGranService;
import com.fzzy.gateway.data.BaseReqData;
import com.fzzy.gateway.data.BaseResp;
import com.fzzy.gateway.entity.GatewayDevice;
import com.fzzy.protocol.bhzn.cmd.CommandBuild;
import com.fzzy.protocol.bhzn.server.BhznGrainV2ServerEngine;
import com.fzzy.protocol.bhzn.server.BhznGrainV2ServerUtils;
import com.ld.io.api.InvokeResult;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

/**
 * é£Žæ­£è‡´è¿œæŽ§åˆ¶æŸœåè®®
 */
@Slf4j
@Component
public class Bhzn2GatewayGrainService implements GatewaySyncGranService {

    @Override
    public String getGrainProtocol() {
        return GatewayDeviceProtocol.GRAIN_FZZY_BHZN_WEB.getCode();
    }

    @Override
    public BaseResp syncGrain(BaseReqData reqData) {

        BaseResp resp = new BaseResp();

        GatewayDevice device = reqData.getDevice();

        //获取连接中的设备信息
        ApiCommonDevice apiCommonDevice = Constant.getCommonDeviceCache(device.getDeviceSn());

        if (null == apiCommonDevice) {
            resp.setCode(500);
            resp.setMsg("系统未获取到下行连接设备信息，无法执行");
            log.error("----------------系统未获取到下行连接设备信息,无法执行---------");
            return resp;
        }

        if (Constant.YN_N.equals(apiCommonDevice.getStatus())) {
            resp.setCode(500);
            resp.setMsg("下行设备不在线---无法执行----" + device.getDeviceName());
            log.error("下行设备不在线---无法执行----" + device.getDeviceName());
            return resp;
        }

        device.setIp(apiCommonDevice.getIp());
        device.setPort(apiCommonDevice.getPort());

        reqData.setDevice(device);

        try {
            //Step è¯·æ±‚信息放入内存
            BhznGrainV2ServerUtils.addSyncReq2Map(device.getDepotIdSys(), reqData);

            // ç”Ÿæˆç²®æƒ…信息
            String hexStr = CommandBuild.getInstance().getMsgCheck(device.getDeviceSn(), device.getDepotIdSys());
            // å‘送命令
            InvokeResult message = BhznGrainV2ServerEngine.push(device.getIp(), device.getPort(), BytesUtil.hexStrToBytes(hexStr));

            log.error("平台------>>>>控制柜：发送粮情检测命令-{}", message);

            // å°è£…返回信息
            if (!InvokeResult.SUCCESS.getCode().equals(message.getCode())) {
                log.error("平台------>>>>控制柜：发送粮情检测命令-失败{}", message.getMessage());
                resp.setCode(500);
                resp.setMsg("平台------>>>>控制柜：发送粮情检测命令-失败：" + message.getMessage());
            }

        } catch (Exception e) {
            log.error("粮情检测异常：{}", e);
            resp.setCode(500);
            resp.setMsg("平台------>>>>控制柜：发送粮情检测命令：" + e.getMessage());
            return resp;
        }
        return resp;
    }
}

 src/main/java/com/fzzy/protocol/fzzy/analysis/AnalysisGrain.java

@@ -202,6 +202,7 @@
        GatewayDeviceReportService reportService = gatewayRemoteManager.getDeviceReportService(reqData.getDevice().getPushProtocol());
        if (null == reportService) {
            log.error("------------粮情推送失败，系统不存在当前协议执行类----{}", reqData.getDevice().getDeviceName());
            return;
        }
        reportService.reportGrainData(reqData);
    }

 src/main/java/com/fzzy/protocol/fzzy/server/ServerUtils.java

@@ -1,8 +1,6 @@
package com.fzzy.protocol.fzzy.server;

import com.fzzy.api.utils.ContextUtil;
import com.fzzy.gateway.data.BaseReqData;
import com.fzzy.gateway.data.BaseResp;

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

 src/main/java/com/fzzy/protocol/fzzy/server/SessionListener.java

@@ -34,7 +34,6 @@

        if (null == commonDevice) return;


        if (null == gatewayDeviceService) {
            gatewayDeviceService = SpringUtil.getBean(GatewayDeviceService.class);