调整DEVICE的字段和缓存，增加支持根据ID直接获取设备信息，优化MODBUS-TCP协议 实现

jiazx0107@163.com

2023-08-12 61b40ca50044c8b20b6ea21028398e068ca103a0

调整DEVICE的字段和缓存，增加支持根据ID直接获取设备信息，优化MODBUS-TCP协议 实现

 igds-core/src/main/java/com/ld/igds/common/CoreDeviceService.java

@@ -39,6 +39,16 @@
     */
    List<Device> getCacheDeviceBySerId(String companyId, String serId);


    /**
     * æ ¹æ®åˆ†æœºä¿¡æ¯èŽ·å–设备
     *
     * @param companyId
     * @param id
     * @return
     */
    Device getCacheDeviceById(String companyId, String id);

    /**
     * åˆ·æ–°ç¼“å­˜
     *

 igds-core/src/main/java/com/ld/igds/common/impl/CoreDeviceServiceImpl.java

@@ -1,15 +1,14 @@
package com.ld.igds.common.impl;

import java.util.*;
import java.util.stream.Collectors;

import com.ld.igds.common.CoreDeviceService;
import com.ld.igds.common.dto.DepotSerData;
import com.ld.igds.common.mapper.DeviceMapper;
import com.ld.igds.constant.Constant;
import com.ld.igds.constant.DeviceStatus;

import com.ld.igds.constant.DeviceType;

import lombok.extern.slf4j.Slf4j;

import org.apache.commons.lang3.StringUtils;
@@ -32,37 +31,63 @@
    private DeviceMapper deviceMapper;


    @Override
    @SuppressWarnings({ "unchecked", "rawtypes" })
    @Override
    public void setCacheAllDevice(List<Device> listAll, String companyId) {
        // é¦–先按照分机分组，然后存更新缓存。
        Map<String, List<Device>> map = listAll.stream().collect(Collectors.groupingBy(Device::getSerId));

        if (null == map || map.isEmpty()) {
            log.error("字典信息：所有设备按照分机分组保存缓存失败，没有分组成功=={}", companyId);
            return;
        }
        if (null == listAll || listAll.isEmpty()) return;

        for (String serId : map.keySet()) {
            updateCacheDeviceBySerId(map.get(serId), companyId, serId);
        }
        //按照分机分类
        Map<String, List<Device>> mapSer = new HashMap<>();

        this.setCacheDepotDeviceSer(listAll, companyId);
    }
        //仓库-设备-分机对象分类
        Map<String, DepotSerData> mapDepot = new HashMap<>();

    @SuppressWarnings({"unchecked", "rawtypes"})
    private void setCacheDepotDeviceSer(List<Device> listAll, String companyId) {
        // å¤„理仓库与分机的关系缓存
        Map<String, DepotSerData> tempMap = new HashMap<>();
        String key;
        for (Device item : listAll) {
            key = companyId + "-" + item.getDepotId() + "-" + item.getSerId();
            if (tempMap.get(key) == null) {
                tempMap.put(key, new DepotSerData(companyId, item.getDepotId(), item.getSerId()));

        //把设备按照分机进行分组，同事吧设备添加到缓存列表中
        String deviceKey, depotDataKey;
        for (Device device : listAll) {

            //封装仓库-设备-分机对象关系
            depotDataKey = companyId + "-" + device.getDepotId() + "-" + device.getSerId();
            if (mapDepot.get(depotDataKey) == null) {
                mapDepot.put(depotDataKey, new DepotSerData(companyId, device.getDepotId(), device.getSerId()));
            }


            //单个设备进行缓存
            deviceKey = RedisConst.buildKey(companyId, RedisConst.KEY_DEVICE, device.getId());
            redisUtil.set(deviceKey, device);

            //按照分机分类
            if (null == mapSer.get(device.getSerId())) mapSer.put(device.getSerId(), new ArrayList<Device>());
            mapSer.get(device.getSerId()).add(device);

        }

        redisUtil.set(RedisConst.buildKey(companyId, RedisConst.KEY_DEPOT_SER_LIST), new ArrayList(tempMap.values()));
        //以分机为单位缓存设备
        for (String serId : mapSer.keySet()) {
            updateCacheDeviceBySerId(mapSer.get(serId), companyId, serId);
        }


        redisUtil.set(RedisConst.buildKey(companyId, RedisConst.KEY_DEPOT_SER_LIST), new ArrayList(mapDepot.values()));
    }


//    private void setCacheDepotDeviceSer(List<Device> listAll, String companyId) {
//        // å¤„理仓库与分机的关系缓存
//        Map<String, DepotSerData> tempMap = new HashMap<>();
//        String key;
//        for (Device item : listAll) {
//            key = companyId + "-" + item.getDepotId() + "-" + item.getSerId();
//            if (tempMap.get(key) == null) {
//                tempMap.put(key, new DepotSerData(companyId, item.getDepotId(), item.getSerId()));
//            }
//        }
//
//        redisUtil.set(RedisConst.buildKey(companyId, RedisConst.KEY_DEPOT_SER_LIST), new ArrayList(tempMap.values()));
//    }

    @Override
    public void updateCacheDeviceBySerId(List<Device> listBySer, String companyId, String serId) {
@@ -85,6 +110,12 @@
            return null;
        }
        return list;
    }

    @Override
    public Device getCacheDeviceById(String companyId, String id) {
        String key = RedisConst.buildDeviceKey(companyId, RedisConst.KEY_DEVICE, id);
        return (Device) redisUtil.get(key);
    }

    @Override
@@ -173,7 +204,7 @@
            }
            log.debug("解析设备状态--主通道={}---关联通道={}--解析后状态={}", curDevice.getPassCode(), curDevice.getLink(), curDevice.getStatus());
        }
        

        // æ›´æ–°ç¼“å­˜
        this.updateCacheDeviceBySerId(listCache, companyId, serId);
    }
@@ -279,7 +310,7 @@
    }

    @Override
    public List<Device> getDeviceByTimId(String companyId,String timId){
        return deviceMapper.queryByTimId(companyId,timId);
    public List<Device> getDeviceByTimId(String companyId, String timId) {
        return deviceMapper.queryByTimId(companyId, timId);
    }
}

 igds-core/src/main/java/com/ld/igds/constant/RedisConst.java

@@ -88,6 +88,12 @@
     * è®¾å¤‡åˆ—表
     */
    public static final String KEY_DEVICE_LIST = "DEVICE_LIST";

    /**
     * å•ä¸ªè‰²å·å§
     */
    public static final String KEY_DEVICE = "DEVICE";

    /**
     * è®¾å¤‡åˆ—表
     */

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

@@ -32,7 +32,8 @@
    TCP_BHZH_VERB_V2("TCP_BHZH_VERB_V2", "邦海控制柜智能有线版V2"),
    TCP_BHZH_INOUT_V1("TCP_BHZH_INOUT_V1", "邦海智能出入库控制器协议"),
    TCP_BEIBO_GRAIN_V1("TCP_BEIBO_GRAIN_V1", "贝博粮情分机服务端协议"),
    FZZY_OPENAPI_HTTP("FZZY_OPENAPI_HTTP", "风正致远API-HTTP协议");
    FZZY_OPENAPI_HTTP("FZZY_OPENAPI_HTTP", "风正致远API-HTTP协议"),
    MODBUS_TCP("MODBUS_TCP", "Modbus-TCP协议");


    private String code;

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

@@ -66,6 +66,10 @@
    @PropertyDef(label = "设备功率", description = "设备功率，没有可不填写:KW/H")
    private Double power;

    @Column(name = "MODBUS_",length = 100)
    @PropertyDef(label = "Modbus配置")
    private String modbus;

    @Column(name = "REMARK_", length = 250)
    @PropertyDef(label = "备注", description = "备注信息")
    private String remark;

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

@@ -228,6 +228,18 @@
            <Editor/>
          </AutoFormElement>
          <AutoFormElement layoutConstraint="colSpan:2">
            <Property name="name">modbus</Property>
            <Property name="property">modbus</Property>
            <Editor/>
          </AutoFormElement>
          <Label layoutConstraint="colSpan:2">
            <Property name="text">modbus规则：开地址-关地址-停地址-开到位-关到位-开故障-关故障，无地址用N代替</Property>
            <Property name="style">
              <Property name="padding-left">100px</Property>
              <Property name="color">blue</Property>
            </Property>
          </Label>
          <AutoFormElement layoutConstraint="colSpan:2">
            <Property name="name">remark</Property>
            <Property name="property">remark</Property>
            <Property name="editorType">TextArea</Property>

 igds-core/src/main/java/com/ld/igds/view/service/HDicAreaService.java

@@ -84,11 +84,8 @@
    }

    public void pageList(Page<DicArea> page, String key) throws Exception {

        String hql = " from " + DicArea.class.getName();

        Map<String, Object> args = new HashMap<>();
        List<DicArea> list;
        String countHql;
        if (StringUtils.isNotEmpty(key)) {
            hql += " where (name like :key1 or simple like:key2)";

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

@@ -155,7 +155,7 @@
      </Property>
    </PropertyDef>
    <PropertyDef name="ggm">
      <Property/>
      <Property></Property>
      <Property name="label">国规码</Property>
    </PropertyDef>
  </DataType>
@@ -567,6 +567,26 @@
      <Property></Property>
      <Property name="label">位置</Property>
    </PropertyDef>
    <PropertyDef name="modbus">
      <Property/>
      <Property name="label">Modbus配置</Property>
    </PropertyDef>
    <PropertyDef name="ext1">
      <Property/>
      <Property name="label">扩展字段1</Property>
    </PropertyDef>
    <PropertyDef name="ext2">
      <Property/>
      <Property name="label">扩展字段2</Property>
    </PropertyDef>
    <PropertyDef name="ext3">
      <Property/>
      <Property name="label">扩展字段3</Property>
    </PropertyDef>
    <PropertyDef name="statusName">
      <Property/>
      <Property name="label">当前状态</Property>
    </PropertyDef>
  </DataType>
  <DataType name="dtDeviceSer">
    <Property name="creationType">com.ld.igds.models.DeviceSer</Property>

 igds-core/src/main/resources/mapper/DeviceMapper.xml

@@ -17,6 +17,7 @@
        g.LOCATION_ AS location,
        g.STATUS_ AS status,
        g.POWER_ AS power,
        g.MODBUS_ AS modbus,
        g.LINK_ AS link,
        g.EXT1_ AS ext1,
        g.EXT2_ AS ext2,

 igds-protocol-modbus/src/main/java/com/ld/igds/protocol/modbus/ModbusConfig.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,69 @@
package com.ld.igds.protocol.modbus;

import com.serotonin.modbus4j.ModbusFactory;
import com.serotonin.modbus4j.ModbusMaster;
import com.serotonin.modbus4j.exception.ModbusInitException;
import com.serotonin.modbus4j.ip.IpParameters;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

import java.util.HashMap;

@Configuration
@Import(com.serotonin.modbus4j.ModbusFactory.class)
public class ModbusConfig {


    @Bean
    public HashMap<String, ModbusMaster> contextModbusMap() {
        return new HashMap<>();
    }

    @Autowired
    private ModbusFactory modbusFactory;

    @Autowired
    @Qualifier("contextModbusMap")
    private HashMap<String, ModbusMaster> masterMap;

    /**
     * @Description: é€šè¿‡ip获取对应的modbus连接器
     */
    public ModbusMaster getMaster(String ip, int port) {
        ModbusMaster modbusMaster = masterMap.get(ip);
        if (modbusMaster == null || !modbusMaster.isConnected()) {
            setMaster(ip, port);
            modbusMaster = masterMap.get(ip);
        }
        return modbusMaster;


    }

    /**
     * @Description: è®¾ç½®ip对应的modbus连接器
     */
    private void setMaster(String ip, Integer port) {
        ModbusMaster master;
        IpParameters params = new IpParameters();
        params.setHost(ip);
        params.setPort(port);
        //设置为true，会导致TimeoutException: request=com.serotonin.modbus4j.ip.encap.EncapMessageRequest@774dfba5",
        //params.setEncapsulated(true);
        master = modbusFactory.createTcpMaster(params, true);// TCP åè®®
        try {
            //设置超时时间
            master.setTimeout(3 * 1000);
            //设置重连次数
            master.setRetries(3);
            //初始化
            master.init();
        } catch (ModbusInitException e) {
            e.printStackTrace();
        }
        masterMap.put(ip, master);
    }
}

 igds-protocol-modbus/src/main/java/com/ld/igds/protocol/modbus/ModbusUtil.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,186 @@
package com.ld.igds.protocol.modbus;

import com.serotonin.modbus4j.ModbusMaster;
import com.serotonin.modbus4j.exception.ModbusInitException;
import com.serotonin.modbus4j.exception.ModbusTransportException;
import com.serotonin.modbus4j.msg.ReadCoilsRequest;
import com.serotonin.modbus4j.msg.ReadCoilsResponse;
import com.serotonin.modbus4j.msg.ReadDiscreteInputsRequest;
import com.serotonin.modbus4j.msg.ReadDiscreteInputsResponse;
import com.serotonin.modbus4j.msg.ReadHoldingRegistersRequest;
import com.serotonin.modbus4j.msg.ReadHoldingRegistersResponse;
import com.serotonin.modbus4j.msg.ReadInputRegistersRequest;
import com.serotonin.modbus4j.msg.ReadInputRegistersResponse;
import com.serotonin.modbus4j.msg.WriteCoilRequest;
import com.serotonin.modbus4j.msg.WriteCoilResponse;
import com.serotonin.modbus4j.msg.WriteCoilsRequest;
import com.serotonin.modbus4j.msg.WriteCoilsResponse;
import com.serotonin.modbus4j.msg.WriteRegisterRequest;
import com.serotonin.modbus4j.msg.WriteRegisterResponse;
import com.serotonin.modbus4j.msg.WriteRegistersRequest;
import com.serotonin.modbus4j.msg.WriteRegistersResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * @Desc: å·¥å…·ç±»
 * @author: Andy
 * @update-time: 2023/8/11
 */
@Component
public class ModbusUtil {

    //从机默认值
    private Integer slaveId = 1;

    @Autowired
    private ModbusConfig modbusConfig;


    public boolean[] readCoilStatus(String ip, int port, int offset, int numberOfRegister) throws ModbusTransportException {

        ModbusMaster master = modbusConfig.getMaster(ip, port);
        ReadCoilsRequest request = new ReadCoilsRequest(slaveId, offset, numberOfRegister);
        ReadCoilsResponse response = (ReadCoilsResponse) master.send(request);
        boolean[] booleans = response.getBooleanData();

        return valueRegroup(numberOfRegister, booleans);
    }

    /**
     * @Description: è¯»å–外围设备输入的开关量，相当于功能码：02H-读离散输入状态
     * @Param: [ip, offset, numberOfRegister]
     * @return: boolean[]
     * @throws:
     * @Author: Ricardo.Liu
     * @Date: 2020/5/8
     */
    public boolean[] readInputStatus(String ip, int port, int offset, int numberOfRegister) throws ModbusTransportException {

        ModbusMaster master = modbusConfig.getMaster(ip, port);
        ReadDiscreteInputsRequest request = new ReadDiscreteInputsRequest(slaveId, offset, numberOfRegister);
        ReadDiscreteInputsResponse response = (ReadDiscreteInputsResponse) master.send(request);
        boolean[] booleans = response.getBooleanData();

        return valueRegroup(numberOfRegister, booleans);
    }

    /**
     * @Description: è¯»å–保持寄存器数据，相当于功能码：03H-读保持寄存器
     * @Param: [ip, offset, numberOfRegister]
     * @return: short[]
     * @throws:
     * @Author: Ricardo.Liu
     * @Date: 2020/5/8
     */
    public short[] readHoldingRegister(String ip, int port, int offset, int numberOfRegister) throws ModbusTransportException {

        ModbusMaster master = modbusConfig.getMaster(ip, port);
        ReadHoldingRegistersRequest request = new ReadHoldingRegistersRequest(slaveId, offset, numberOfRegister);
        ReadHoldingRegistersResponse response = (ReadHoldingRegistersResponse) master.send(request);
        return response.getShortData();
    }

    /**
     * @Description: è¯»å–外围设备输入的数据，相当于功能码：04H-读输入寄存器
     * @Param: [ip, offset, numberOfRegister]
     * @return: short[]
     * @throws:
     * @Author: Ricardo.Liu
     * @Date: 2020/5/8
     */
    public short[] readInputRegisters(String ip, int port, int offset, int numberOfRegister) throws ModbusTransportException {

        ModbusMaster master = modbusConfig.getMaster(ip, port);
        ReadInputRegistersRequest request = new ReadInputRegistersRequest(slaveId, offset, numberOfRegister);
        ReadInputRegistersResponse response = (ReadInputRegistersResponse) master.send(request);
        return response.getShortData();
    }

    /**
     * @Description: å†™å•ä¸ªï¼ˆçº¿åœˆï¼‰å¼€å…³é‡æ•°æ®ï¼Œç›¸å½“于功能码：05H-写单个线圈
     * @Param: [ip, writeOffset, writeValue]
     * @return: boolean
     * @throws:
     * @Author: Ricardo.Liu
     * @Date: 2020/5/8
     */
    public boolean writeCoil(String ip, int port, int writeOffset, boolean writeValue) throws ModbusTransportException {

        ModbusMaster tcpMaster = modbusConfig.getMaster(ip, port);
        WriteCoilRequest request = new WriteCoilRequest(slaveId, writeOffset, writeValue);
        WriteCoilResponse response = (WriteCoilResponse) tcpMaster.send(request);
        return !response.isException();
    }

    /**
     * @Description: å†™å¤šä¸ªå¼€å…³é‡æ•°æ®ï¼ˆçº¿åœˆï¼‰ï¼Œç›¸å½“于功能码：0FH-写多个线圈
     * @Param: [ip, startOffset, data]
     * @return: boolean
     * @throws:
     * @Author: Ricardo.Liu
     * @Date: 2020/5/8
     */
    public boolean writeCoils(String ip, int port, int startOffset, boolean[] data) throws ModbusTransportException {

        ModbusMaster tcpMaster = modbusConfig.getMaster(ip, port);
        WriteCoilsRequest request = new WriteCoilsRequest(slaveId, startOffset, data);
        WriteCoilsResponse response = (WriteCoilsResponse) tcpMaster.send(request);
        return !response.isException();

    }

    /**
     * @Description: å†™å•ä¸ªä¿æŒå¯„存器，相当于功能码：06H-写单个保持寄存器
     * @Param: [ip, writeOffset, writeValue]
     * @return: boolean
     * @throws:
     * @Author: Ricardo.Liu
     * @Date: 2020/5/8
     */
    public boolean writeHoldingRegister(String ip, int port,int writeOffset, short writeValue) throws ModbusTransportException, ModbusInitException {

        ModbusMaster tcpMaster = modbusConfig.getMaster(ip, port);
        WriteRegisterRequest request = new WriteRegisterRequest(slaveId, writeOffset, writeValue);
        WriteRegisterResponse response = (WriteRegisterResponse) tcpMaster.send(request);
        return !response.isException();

    }

    /**
     * @Description: å†™å¤šä¸ªä¿æŒå¯„存器，相当于功能码：10H-写多个保持寄存器
     * @Param: [ip, startOffset, data]
     * @return: boolean
     * @throws:
     * @Author: Ricardo.Liu
     * @Date: 2020/5/8
     */
    public boolean writeHoldingRegisters(String ip,int port, int startOffset, short[] data) throws ModbusTransportException, ModbusInitException {

        ModbusMaster tcpMaster = modbusConfig.getMaster(ip, port);
        WriteRegistersRequest request = new WriteRegistersRequest(slaveId, startOffset, data);
        WriteRegistersResponse response = (WriteRegistersResponse) tcpMaster.send(request);
        return !response.isException();
    }

    /**
     * @Description: è½¬æ¢å·¥å…·ï¼Œå°†Boolean转换成0，1
     * @Param: [numberOfBits, values]
     * @return: boolean[]
     * @throws:
     * @Author: Ricardo.Liu
     * @Date: 2020/5/8
     */
    private boolean[] valueRegroup(int numberOfBits, boolean[] values) {
        boolean[] bs = new boolean[numberOfBits];
        int temp = 1;
        for (boolean b : values) {
            bs[temp - 1] = b;
            temp++;
            if (temp > numberOfBits) {
                break;
            }
        }
        return bs;
    }
}

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

@@ -1,12 +1,23 @@
package com.ld.igds.protocol.modbus.command;

import com.ld.igds.common.CoreDeviceService;
import com.ld.igds.constant.Constant;
import com.ld.igds.io.RemoteControlService;
import com.ld.igds.io.constant.OrderRespEnum;
import com.ld.igds.io.constant.ProtocolEnum;
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.DeviceControlResponse;
import com.ld.igds.models.Device;
import com.ld.igds.protocol.modbus.ModbusUtil;
import com.ld.igds.protocol.modbus.data.ModbusTcp;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

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

/**
 * å½“前协议针对标准Modbus-TCP协议
@@ -21,15 +32,75 @@

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

    @Resource
    private CoreDeviceService deviceService;
    @Resource
    private ModbusUtil modbusUtil;

    @Override
    public String getProtocol() {
        return null;
        return ProtocolEnum.MODBUS_TCP.getCode();
    }

    @Override
    public DeviceControlResponse deviceControl(DeviceControlRequest request) {
        return null;
        List<ExeDevice> deviceList = request.getDeviceList();

        if (null == deviceList || deviceList.isEmpty()) {
            return new DeviceControlResponse(OrderRespEnum.ORDER_ERROR.getCode(), "没有需要执行的设备");
        }


        try {


            Device device;
            ModbusTcp modbusTcp;
            String[] addr;
            String temp;
            for (ExeDevice exeDevice : deviceList) {
                device = deviceService.getCacheDeviceById(exeDevice.getCompanyId(), exeDevice.getId());

                if (null == device) continue;

                if (null == device.getModbus()) continue;

                modbusTcp = new ModbusTcp();
                modbusTcp.setIp(request.getIp());
                modbusTcp.setPort(request.getPort());
                modbusTcp.setDeviceId(device.getId());
                modbusTcp.setSerId(request.getSerId());

                //modbus规则：开地址-关地址-停地址-开到位-关到位-开故障-关故障，无地址用N代替
                addr = device.getModbus().split("-");
                temp = addr[0];
                if (!Constant.YN_N.equals(temp)) modbusTcp.setAddrOpen(Integer.valueOf(temp));
                temp = addr[1];
                if (!Constant.YN_N.equals(temp)) modbusTcp.setAddrClose(Integer.valueOf(temp));
                temp = addr[2];
                if (!Constant.YN_N.equals(temp)) modbusTcp.setAddrStop(Integer.valueOf(temp));
                temp = addr[3];
                if (!Constant.YN_N.equals(temp)) modbusTcp.setAddrOpenEnd(Integer.valueOf(temp));
                temp = addr[4];
                if (!Constant.YN_N.equals(temp)) modbusTcp.setAddrCloseEnd(Integer.valueOf(temp));
                temp = addr[5];
                if (!Constant.YN_N.equals(temp)) modbusTcp.setAddrOpenError(Integer.valueOf(temp));
                temp = addr[6];
                if (!Constant.YN_N.equals(temp)) modbusTcp.setAddrCloseError(Integer.valueOf(temp));


                //根据设备目标状态，调用MODBUS执行
                modbusUtil.writeCoil(modbusTcp.getIp(), modbusTcp.getPort(), modbusTcp.getAddrOpen(), true);


            }
        } catch (Exception e) {

        }

        return new DeviceControlResponse(OrderRespEnum.ORDER_SUCCESS);
    }


    @Override
    public DeviceControlResponse closeAll(DeviceControlRequest request) {
@@ -48,11 +119,14 @@

    @Override
    public DeviceControlResponse airAutoControl(DeviceAutoControlRequest request) {


        return null;
    }

    @Override
    public DeviceControlResponse n2AutoControl(DeviceAutoControlRequest request) {

        return null;
    }
}

 igds-protocol-modbus/src/main/java/com/ld/igds/protocol/modbus/data/ModbusTcp.java

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

import lombok.Data;

/**
 * @Desc: ç”¨äºŽå°è£…ModBUsTCP的信息
 * @author: andy.jia
 * @update-time: 2023/8/12 15:29
 */
@Data
public class ModbusTcp {

    private String deviceId;

    private String serId;

    private String ip;

    private int port;

    private int addrOpen;

    private int addrClose;

    private int addrStop;

    private int addrOpenEnd;

    private int addrCloseEnd;

    private int addrOpenError;

    private int addrCloseError;

}