feat：【iot】modbus-tcp 协议接入：10% 初始化：基于 cheeky-plotting-pumpkin.md 规划

YunaiV
1 parent 5086e122
Showing 38 changed files with 2933 additions and 8 deletions
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/api/device/IoTDeviceApiImpl.java
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/controller/admin/device/IotDeviceModbusConfigController.java
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/controller/admin/device/IotDeviceModbusPointController.java
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/controller/admin/device/vo/modbus/IotDeviceModbusConfigPageReqVO.java
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/controller/admin/device/vo/modbus/IotDeviceModbusConfigRespVO.java
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/controller/admin/device/vo/modbus/IotDeviceModbusConfigSaveReqVO.java
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/controller/admin/device/vo/modbus/IotDeviceModbusPointPageReqVO.java
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/controller/admin/device/vo/modbus/IotDeviceModbusPointRespVO.java
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/controller/admin/device/vo/modbus/IotDeviceModbusPointSaveReqVO.java
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/dal/dataobject/device/IotDeviceModbusConfigDO.java
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/dal/dataobject/device/IotDeviceModbusPointDO.java
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/dal/mysql/device/IotDeviceModbusConfigMapper.java
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/dal/mysql/device/IotDeviceModbusPointMapper.java
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/enums/ErrorCodeConstants.java
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/enums/device/IotModbusByteOrderEnum.java
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/enums/device/IotModbusFunctionCodeEnum.java
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/enums/device/IotModbusRawDataTypeEnum.java
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/service/device/IotDeviceModbusConfigService.java
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/service/device/IotDeviceModbusConfigServiceImpl.java
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/service/device/IotDeviceModbusPointService.java
@@ -4,11 +4,13 @@ import cn.iocoder.yudao.framework.common.enums.RpcConstants;
 import cn.iocoder.yudao.framework.common.pojo.CommonResult;
 import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
 import cn.iocoder.yudao.module.iot.core.biz.IotDeviceCommonApi;
-import cn.iocoder.yudao.module.iot.core.biz.dto.IotDeviceAuthReqDTO;
-import cn.iocoder.yudao.module.iot.core.biz.dto.IotDeviceGetReqDTO;
-import cn.iocoder.yudao.module.iot.core.biz.dto.IotDeviceRespDTO;
+import cn.iocoder.yudao.module.iot.core.biz.dto.*;
 import cn.iocoder.yudao.module.iot.dal.dataobject.device.IotDeviceDO;
+import cn.iocoder.yudao.module.iot.dal.dataobject.device.IotDeviceModbusConfigDO;
+import cn.iocoder.yudao.module.iot.dal.dataobject.device.IotDeviceModbusPointDO;
 import cn.iocoder.yudao.module.iot.dal.dataobject.product.IotProductDO;
+import cn.iocoder.yudao.module.iot.service.device.IotDeviceModbusConfigService;
+import cn.iocoder.yudao.module.iot.service.device.IotDeviceModbusPointService;
 import cn.iocoder.yudao.module.iot.service.device.IotDeviceService;
 import cn.iocoder.yudao.module.iot.service.product.IotProductService;
 import jakarta.annotation.Resource;
@@ -19,6 +21,9 @@ import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RestController;
+import java.util.ArrayList;
+import java.util.List;
+
 import static cn.iocoder.yudao.framework.common.pojo.CommonResult.success;
 /**
@@ -35,6 +40,10 @@ public class IoTDeviceApiImpl implements IotDeviceCommonApi {
     private IotDeviceService deviceService;
     @Resource
     private IotProductService productService;
+    @Resource
+    private IotDeviceModbusConfigService modbusConfigService;
+    @Resource
+    private IotDeviceModbusPointService modbusPointService;
     @Override
     @PostMapping(RpcConstants.RPC_API_PREFIX + "/iot/device/auth")
@@ -57,4 +66,47 @@ public class IoTDeviceApiImpl implements IotDeviceCommonApi {
         }));
     }
+    @Override
+    @PostMapping(RpcConstants.RPC_API_PREFIX + "/iot/modbus/enabled-configs")
+    @PermitAll
+    public CommonResult<List<IotModbusDeviceConfigRespDTO>> getEnabledModbusDeviceConfigs() {
+        // 1. 获取所有启用的 Modbus 连接配置
+        List<IotDeviceModbusConfigDO> configList = modbusConfigService.getEnabledModbusConfigList();
+        if (configList.isEmpty()) {
+            return success(new ArrayList<>());
+        }
+
+        // 2. 组装返回结果
+        List<IotModbusDeviceConfigRespDTO> result = new ArrayList<>(configList.size());
+        for (IotDeviceModbusConfigDO config : configList) {
+            // 2.1 获取设备信息
+            // TODO @AI：设备需要批量读取；（先暂时不处理）
+            IotDeviceDO device = deviceService.getDeviceFromCache(config.getDeviceId());
+            if (device == null) {
+                continue;
+            }
+
+            // 2.2 获取启用的点位列表
+            // TODO @AI：看看是不是批量读取；
+            List<IotDeviceModbusPointDO> pointList = modbusPointService.getEnabledModbusPointListByDeviceId(config.getDeviceId());
+
+            // 2.3 构建 DTO
+            IotModbusDeviceConfigRespDTO dto = new IotModbusDeviceConfigRespDTO();
+            dto.setDeviceId(config.getDeviceId());
+            // TODO @AI：这个 productKey、deviceName 这个字段，要不要冗余到 IotDeviceModbusConfigDO 里面？（先暂时不处理）
+            dto.setProductKey(device.getProductKey());
+            dto.setDeviceName(device.getDeviceName());
+            dto.setTenantId(device.getTenantId());
+            // TODO @AI：看看 dto 的转换，能不能通过 beanutils copy
+            dto.setIp(config.getIp());
+            dto.setPort(config.getPort());
+            dto.setSlaveId(config.getSlaveId());
+            dto.setTimeout(config.getTimeout());
+            dto.setRetryInterval(config.getRetryInterval());
+            dto.setPoints(BeanUtils.toBean(pointList, IotModbusPointRespDTO.class));
+            result.add(dto);
+        }
+        return success(result);
+    }
+
 }
 \ No newline at end of file
+package cn.iocoder.yudao.module.iot.controller.admin.device;
+
+import cn.iocoder.yudao.framework.common.pojo.CommonResult;
+import cn.iocoder.yudao.framework.common.pojo.PageResult;
+import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
+import cn.iocoder.yudao.module.iot.controller.admin.device.vo.modbus.IotDeviceModbusConfigPageReqVO;
+import cn.iocoder.yudao.module.iot.controller.admin.device.vo.modbus.IotDeviceModbusConfigRespVO;
+import cn.iocoder.yudao.module.iot.controller.admin.device.vo.modbus.IotDeviceModbusConfigSaveReqVO;
+import cn.iocoder.yudao.module.iot.dal.dataobject.device.IotDeviceModbusConfigDO;
+import cn.iocoder.yudao.module.iot.service.device.IotDeviceModbusConfigService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.annotation.Resource;
+import jakarta.validation.Valid;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+
+import static cn.iocoder.yudao.framework.common.pojo.CommonResult.success;
+
+@Tag(name = "管理后台 - IoT 设备 Modbus 连接配置")
+@RestController
+@RequestMapping("/iot/device-modbus-config")
+@Validated
+public class IotDeviceModbusConfigController {
+
+    @Resource
+    private IotDeviceModbusConfigService modbusConfigService;
+
+    // TODO @AI：create 和 update 合并成 save 接口；
+    @PostMapping("/create")
+    @Operation(summary = "创建设备 Modbus 连接配置")
+    @PreAuthorize("@ss.hasPermission('iot:device-modbus-config:create')")
+    public CommonResult<Long> createModbusConfig(@Valid @RequestBody IotDeviceModbusConfigSaveReqVO createReqVO) {
+        return success(modbusConfigService.createModbusConfig(createReqVO));
+    }
+
+    @PutMapping("/update")
+    @Operation(summary = "更新设备 Modbus 连接配置")
+    @PreAuthorize("@ss.hasPermission('iot:device-modbus-config:update')")
+    public CommonResult<Boolean> updateModbusConfig(@Valid @RequestBody IotDeviceModbusConfigSaveReqVO updateReqVO) {
+        modbusConfigService.updateModbusConfig(updateReqVO);
+        return success(true);
+    }
+
+    @DeleteMapping("/delete")
+    @Operation(summary = "删除设备 Modbus 连接配置")
+    @Parameter(name = "id", description = "编号", required = true)
+    @PreAuthorize("@ss.hasPermission('iot:device-modbus-config:delete')")
+    public CommonResult<Boolean> deleteModbusConfig(@RequestParam("id") Long id) {
+        modbusConfigService.deleteModbusConfig(id);
+        return success(true);
+    }
+
+    // TODO @AI：这个接口改造，支持 id 或者 deviceId；二选一查询；
+    @GetMapping("/get")
+    @Operation(summary = "获得设备 Modbus 连接配置")
+    @Parameter(name = "id", description = "编号", required = true, example = "1024")
+    @PreAuthorize("@ss.hasPermission('iot:device-modbus-config:query')")
+    public CommonResult<IotDeviceModbusConfigRespVO> getModbusConfig(@RequestParam("id") Long id) {
+        IotDeviceModbusConfigDO modbusConfig = modbusConfigService.getModbusConfig(id);
+        return success(BeanUtils.toBean(modbusConfig, IotDeviceModbusConfigRespVO.class));
+    }
+
+    // TODO @AI：合并到 getModbusConfig 接口里；
+    @GetMapping("/get-by-device-id")
+    @Operation(summary = "根据设备编号获得 Modbus 连接配置")
+    @Parameter(name = "deviceId", description = "设备编号", required = true, example = "1024")
+    @PreAuthorize("@ss.hasPermission('iot:device-modbus-config:query')")
+    public CommonResult<IotDeviceModbusConfigRespVO> getModbusConfigByDeviceId(@RequestParam("deviceId") Long deviceId) {
+        IotDeviceModbusConfigDO modbusConfig = modbusConfigService.getModbusConfigByDeviceId(deviceId);
+        return success(BeanUtils.toBean(modbusConfig, IotDeviceModbusConfigRespVO.class));
+    }
+
+    @GetMapping("/page")
+    @Operation(summary = "获得设备 Modbus 连接配置分页")
+    @PreAuthorize("@ss.hasPermission('iot:device-modbus-config:query')")
+    public CommonResult<PageResult<IotDeviceModbusConfigRespVO>> getModbusConfigPage(@Valid IotDeviceModbusConfigPageReqVO pageReqVO) {
+        PageResult<IotDeviceModbusConfigDO> pageResult = modbusConfigService.getModbusConfigPage(pageReqVO);
+        return success(BeanUtils.toBean(pageResult, IotDeviceModbusConfigRespVO.class));
+    }
+
+}
+package cn.iocoder.yudao.module.iot.controller.admin.device;
+
+import cn.iocoder.yudao.framework.common.pojo.CommonResult;
+import cn.iocoder.yudao.framework.common.pojo.PageResult;
+import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
+import cn.iocoder.yudao.module.iot.controller.admin.device.vo.modbus.IotDeviceModbusPointPageReqVO;
+import cn.iocoder.yudao.module.iot.controller.admin.device.vo.modbus.IotDeviceModbusPointRespVO;
+import cn.iocoder.yudao.module.iot.controller.admin.device.vo.modbus.IotDeviceModbusPointSaveReqVO;
+import cn.iocoder.yudao.module.iot.dal.dataobject.device.IotDeviceModbusPointDO;
+import cn.iocoder.yudao.module.iot.service.device.IotDeviceModbusPointService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.annotation.Resource;
+import jakarta.validation.Valid;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+import static cn.iocoder.yudao.framework.common.pojo.CommonResult.success;
+
+@Tag(name = "管理后台 - IoT 设备 Modbus 点位配置")
+@RestController
+@RequestMapping("/iot/device-modbus-point")
+@Validated
+public class IotDeviceModbusPointController {
+
+    @Resource
+    private IotDeviceModbusPointService modbusPointService;
+
+    @PostMapping("/create")
+    @Operation(summary = "创建设备 Modbus 点位配置")
+    @PreAuthorize("@ss.hasPermission('iot:device-modbus-point:create')")
+    public CommonResult<Long> createModbusPoint(@Valid @RequestBody IotDeviceModbusPointSaveReqVO createReqVO) {
+        return success(modbusPointService.createModbusPoint(createReqVO));
+    }
+
+    @PutMapping("/update")
+    @Operation(summary = "更新设备 Modbus 点位配置")
+    @PreAuthorize("@ss.hasPermission('iot:device-modbus-point:update')")
+    public CommonResult<Boolean> updateModbusPoint(@Valid @RequestBody IotDeviceModbusPointSaveReqVO updateReqVO) {
+        modbusPointService.updateModbusPoint(updateReqVO);
+        return success(true);
+    }
+
+    @DeleteMapping("/delete")
+    @Operation(summary = "删除设备 Modbus 点位配置")
+    @Parameter(name = "id", description = "编号", required = true)
+    @PreAuthorize("@ss.hasPermission('iot:device-modbus-point:delete')")
+    public CommonResult<Boolean> deleteModbusPoint(@RequestParam("id") Long id) {
+        modbusPointService.deleteModbusPoint(id);
+        return success(true);
+    }
+
+    @GetMapping("/get")
+    @Operation(summary = "获得设备 Modbus 点位配置")
+    @Parameter(name = "id", description = "编号", required = true, example = "1024")
+    @PreAuthorize("@ss.hasPermission('iot:device-modbus-point:query')")
+    public CommonResult<IotDeviceModbusPointRespVO> getModbusPoint(@RequestParam("id") Long id) {
+        IotDeviceModbusPointDO modbusPoint = modbusPointService.getModbusPoint(id);
+        return success(BeanUtils.toBean(modbusPoint, IotDeviceModbusPointRespVO.class));
+    }
+
+    @GetMapping("/page")
+    @Operation(summary = "获得设备 Modbus 点位配置分页")
+    @PreAuthorize("@ss.hasPermission('iot:device-modbus-point:query')")
+    public CommonResult<PageResult<IotDeviceModbusPointRespVO>> getModbusPointPage(@Valid IotDeviceModbusPointPageReqVO pageReqVO) {
+        PageResult<IotDeviceModbusPointDO> pageResult = modbusPointService.getModbusPointPage(pageReqVO);
+        return success(BeanUtils.toBean(pageResult, IotDeviceModbusPointRespVO.class));
+    }
+
+    // TODO @AI：应该用不上这个接口？只需要 getModbusPointPage 分页
+    @GetMapping("/list-by-device-id")
+    @Operation(summary = "根据设备编号获得 Modbus 点位配置列表")
+    @Parameter(name = "deviceId", description = "设备编号", required = true, example = "1024")
+    @PreAuthorize("@ss.hasPermission('iot:device-modbus-point:query')")
+    public CommonResult<List<IotDeviceModbusPointRespVO>> getModbusPointListByDeviceId(@RequestParam("deviceId") Long deviceId) {
+        List<IotDeviceModbusPointDO> list = modbusPointService.getModbusPointListByDeviceId(deviceId);
+        return success(BeanUtils.toBean(list, IotDeviceModbusPointRespVO.class));
+    }
+
+}
+package cn.iocoder.yudao.module.iot.controller.admin.device.vo.modbus;
+
+import cn.iocoder.yudao.framework.common.pojo.PageParam;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.ToString;
+
+// TODO @AI：不需要分页接口；
+@Schema(description = "管理后台 - IoT 设备 Modbus 连接配置分页 Request VO")
+@Data
+@EqualsAndHashCode(callSuper = true)
+@ToString(callSuper = true)
+public class IotDeviceModbusConfigPageReqVO extends PageParam {
+
+    @Schema(description = "设备编号", example = "1024")
+    private Long deviceId;
+
+    @Schema(description = "Modbus 服务器 IP 地址", example = "192.168.1.100")
+    private String ip;
+
+    @Schema(description = "状态", example = "0")
+    private Integer status;
+
+}
+package cn.iocoder.yudao.module.iot.controller.admin.device.vo.modbus;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+@Schema(description = "管理后台 - IoT 设备 Modbus 连接配置 Response VO")
+@Data
+public class IotDeviceModbusConfigRespVO {
+
+    @Schema(description = "主键", requiredMode = Schema.RequiredMode.REQUIRED, example = "1")
+    private Long id;
+
+    @Schema(description = "设备编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "1024")
+    private Long deviceId;
+
+    @Schema(description = "设备名称", example = "温湿度传感器")
+    private String deviceName;
+
+    @Schema(description = "Modbus 服务器 IP 地址", requiredMode = Schema.RequiredMode.REQUIRED, example = "192.168.1.100")
+    private String ip;
+
+    @Schema(description = "Modbus 端口", requiredMode = Schema.RequiredMode.REQUIRED, example = "502")
+    private Integer port;
+
+    @Schema(description = "从站地址", requiredMode = Schema.RequiredMode.REQUIRED, example = "1")
+    private Integer slaveId;
+
+    @Schema(description = "连接超时时间（毫秒）", example = "3000")
+    private Integer timeout;
+
+    @Schema(description = "重试间隔（毫秒）", example = "1000")
+    private Integer retryInterval;
+
+    @Schema(description = "状态", requiredMode = Schema.RequiredMode.REQUIRED, example = "0")
+    private Integer status;
+
+    @Schema(description = "创建时间", requiredMode = Schema.RequiredMode.REQUIRED)
+    private LocalDateTime createTime;
+
+}
+package cn.iocoder.yudao.module.iot.controller.admin.device.vo.modbus;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.NotEmpty;
+import jakarta.validation.constraints.NotNull;
+import lombok.Data;
+
+@Schema(description = "管理后台 - IoT 设备 Modbus 连接配置新增/修改 Request VO")
+@Data
+public class IotDeviceModbusConfigSaveReqVO {
+
+    @Schema(description = "主键", example = "1")
+    private Long id;
+
+    @Schema(description = "设备编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "1024")
+    @NotNull(message = "设备编号不能为空")
+    private Long deviceId;
+
+    @Schema(description = "Modbus 服务器 IP 地址", requiredMode = Schema.RequiredMode.REQUIRED, example = "192.168.1.100")
+    @NotEmpty(message = "Modbus 服务器 IP 地址不能为空")
+    private String ip;
+
+    @Schema(description = "Modbus 端口", requiredMode = Schema.RequiredMode.REQUIRED, example = "502")
+    @NotNull(message = "Modbus 端口不能为空")
+    private Integer port;
+
+    @Schema(description = "从站地址", requiredMode = Schema.RequiredMode.REQUIRED, example = "1")
+    @NotNull(message = "从站地址不能为空")
+    private Integer slaveId;
+
+    @Schema(description = "连接超时时间（毫秒）", example = "3000")
+    private Integer timeout;
+
+    @Schema(description = "重试间隔（毫秒）", example = "1000")
+    private Integer retryInterval;
+
+    @Schema(description = "状态", requiredMode = Schema.RequiredMode.REQUIRED, example = "0")
+    @NotNull(message = "状态不能为空")
+    private Integer status;
+
+}
+package cn.iocoder.yudao.module.iot.controller.admin.device.vo.modbus;
+
+import cn.iocoder.yudao.framework.common.pojo.PageParam;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.ToString;
+
+@Schema(description = "管理后台 - IoT 设备 Modbus 点位配置分页 Request VO")
+@Data
+@EqualsAndHashCode(callSuper = true)
+@ToString(callSuper = true)
+public class IotDeviceModbusPointPageReqVO extends PageParam {
+
+    @Schema(description = "设备编号", example = "1024")
+    private Long deviceId;
+
+    @Schema(description = "属性标识符", example = "temperature")
+    private String identifier;
+
+    @Schema(description = "属性名称", example = "温度")
+    private String name;
+
+    @Schema(description = "Modbus 功能码", example = "3")
+    private Integer functionCode;
+
+    @Schema(description = "状态", example = "0")
+    private Integer status;
+
+}
+package cn.iocoder.yudao.module.iot.controller.admin.device.vo.modbus;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
+
+@Schema(description = "管理后台 - IoT 设备 Modbus 点位配置 Response VO")
+@Data
+public class IotDeviceModbusPointRespVO {
+
+    @Schema(description = "主键", requiredMode = Schema.RequiredMode.REQUIRED, example = "1")
+    private Long id;
+
+    @Schema(description = "设备编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "1024")
+    private Long deviceId;
+
+    @Schema(description = "物模型属性编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "2048")
+    private Long thingModelId;
+
+    @Schema(description = "属性标识符", requiredMode = Schema.RequiredMode.REQUIRED, example = "temperature")
+    private String identifier;
+
+    @Schema(description = "属性名称", requiredMode = Schema.RequiredMode.REQUIRED, example = "温度")
+    private String name;
+
+    @Schema(description = "Modbus 功能码", requiredMode = Schema.RequiredMode.REQUIRED, example = "3")
+    private Integer functionCode;
+
+    @Schema(description = "寄存器起始地址", requiredMode = Schema.RequiredMode.REQUIRED, example = "0")
+    private Integer registerAddress;
+
+    @Schema(description = "寄存器数量", requiredMode = Schema.RequiredMode.REQUIRED, example = "1")
+    private Integer registerCount;
+
+    @Schema(description = "字节序", requiredMode = Schema.RequiredMode.REQUIRED, example = "AB")
+    private String byteOrder;
+
+    @Schema(description = "原始数据类型", requiredMode = Schema.RequiredMode.REQUIRED, example = "INT16")
+    private String rawDataType;
+
+    @Schema(description = "缩放因子", requiredMode = Schema.RequiredMode.REQUIRED, example = "1.0")
+    private BigDecimal scale;
+
+    @Schema(description = "轮询间隔（毫秒）", requiredMode = Schema.RequiredMode.REQUIRED, example = "5000")
+    private Integer pollInterval;
+
+    @Schema(description = "状态", requiredMode = Schema.RequiredMode.REQUIRED, example = "0")
+    private Integer status;
+
+    @Schema(description = "创建时间", requiredMode = Schema.RequiredMode.REQUIRED)
+    private LocalDateTime createTime;
+
+}
+package cn.iocoder.yudao.module.iot.controller.admin.device.vo.modbus;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.NotEmpty;
+import jakarta.validation.constraints.NotNull;
+import lombok.Data;
+
+import java.math.BigDecimal;
+
+@Schema(description = "管理后台 - IoT 设备 Modbus 点位配置新增/修改 Request VO")
+@Data
+public class IotDeviceModbusPointSaveReqVO {
+
+    @Schema(description = "主键", example = "1")
+    private Long id;
+
+    @Schema(description = "设备编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "1024")
+    @NotNull(message = "设备编号不能为空")
+    private Long deviceId;
+
+    @Schema(description = "物模型属性编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "2048")
+    @NotNull(message = "物模型属性编号不能为空")
+    private Long thingModelId;
+
+    @Schema(description = "Modbus 功能码", requiredMode = Schema.RequiredMode.REQUIRED, example = "3")
+    @NotNull(message = "Modbus 功能码不能为空")
+    private Integer functionCode;
+
+    @Schema(description = "寄存器起始地址", requiredMode = Schema.RequiredMode.REQUIRED, example = "0")
+    @NotNull(message = "寄存器起始地址不能为空")
+    private Integer registerAddress;
+
+    @Schema(description = "寄存器数量", example = "1")
+    private Integer registerCount;
+
+    @Schema(description = "字节序", requiredMode = Schema.RequiredMode.REQUIRED, example = "AB")
+    @NotEmpty(message = "字节序不能为空")
+    private String byteOrder;
+
+    @Schema(description = "原始数据类型", requiredMode = Schema.RequiredMode.REQUIRED, example = "INT16")
+    @NotEmpty(message = "原始数据类型不能为空")
+    private String rawDataType;
+
+    @Schema(description = "缩放因子", example = "1.0")
+    private BigDecimal scale;
+
+    @Schema(description = "轮询间隔（毫秒）", example = "5000")
+    private Integer pollInterval;
+
+    @Schema(description = "状态", requiredMode = Schema.RequiredMode.REQUIRED, example = "0")
+    @NotNull(message = "状态不能为空")
+    private Integer status;
+
+}
+package cn.iocoder.yudao.module.iot.dal.dataobject.device;
+
+import cn.iocoder.yudao.framework.tenant.core.db.TenantBaseDO;
+import com.baomidou.mybatisplus.annotation.KeySequence;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.*;
+
+/**
+ * IoT 设备 Modbus 连接配置 DO
+ *
+ * @author 芋道源码
+ */
+@TableName("iot_device_modbus_config")
+@KeySequence("iot_device_modbus_config_seq")
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class IotDeviceModbusConfigDO extends TenantBaseDO {
+
+    /**
+     * 主键
+     */
+    @TableId
+    private Long id;
+    // TODO @AI：增加 productId；
+    /**
+     * 设备编号
+     *
+     * 关联 {@link IotDeviceDO#getId()}
+     */
+    private Long deviceId;
+
+    /**
+     * Modbus 服务器 IP 地址
+     */
+    private String ip;
+    /**
+     * Modbus 服务器端口
+     */
+    private Integer port;
+    /**
+     * 从站地址
+     */
+    private Integer slaveId;
+    /**
+     * 连接超时时间，单位：毫秒
+     */
+    private Integer timeout;
+    /**
+     * 重试间隔，单位：毫秒
+     */
+    private Integer retryInterval;
+    /**
+     * 状态
+     *
+     * 枚举 {@link cn.iocoder.yudao.framework.common.enums.CommonStatusEnum}
+     */
+    private Integer status;
+
+}
+package cn.iocoder.yudao.module.iot.dal.dataobject.device;
+
+import cn.iocoder.yudao.framework.tenant.core.db.TenantBaseDO;
+import cn.iocoder.yudao.module.iot.dal.dataobject.thingmodel.IotThingModelDO;
+import cn.iocoder.yudao.module.iot.enums.device.IotModbusByteOrderEnum;
+import cn.iocoder.yudao.module.iot.enums.device.IotModbusFunctionCodeEnum;
+import cn.iocoder.yudao.module.iot.enums.device.IotModbusRawDataTypeEnum;
+import com.baomidou.mybatisplus.annotation.KeySequence;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.*;
+
+import java.math.BigDecimal;
+
+/**
+ * IoT 设备 Modbus 点位配置 DO
+ *
+ * @author 芋道源码
+ */
+@TableName("iot_device_modbus_point")
+@KeySequence("iot_device_modbus_point_seq")
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class IotDeviceModbusPointDO extends TenantBaseDO {
+
+    /**
+     * 主键
+     */
+    @TableId
+    private Long id;
+    // TODO @AI：增加 productId；
+    /**
+     * 设备编号
+     *
+     * 关联 {@link IotDeviceDO#getId()}
+     */
+    private Long deviceId;
+    /**
+     * 物模型属性编号
+     *
+     * 关联 {@link IotThingModelDO#getId()}
+     */
+    private Long thingModelId;
+    // TODO @AI：每次物模型的变更时，需要按需刷下 identifier、name 配置；
+    /**
+     * 属性标识符
+     *
+     * 冗余 {@link IotThingModelDO#getIdentifier()}
+     */
+    private String identifier;
+    /**
+     * 属性名称
+     *
+     * 冗余 {@link IotThingModelDO#getName()}
+     */
+    private String name;
+
+    // ========== Modbus 协议配置 ==========
+
+    /**
+     * Modbus 功能码
+     *
+     * 枚举 {@link IotModbusFunctionCodeEnum}
+     */
+    private Integer functionCode;
+    /**
+     * 寄存器起始地址
+     */
+    private Integer registerAddress;
+    /**
+     * 寄存器数量
+     */
+    private Integer registerCount;
+    /**
+     * 字节序
+     *
+     * 枚举 {@link IotModbusByteOrderEnum}
+     */
+    private String byteOrder;
+    /**
+     * 原始数据类型
+     *
+     * 枚举 {@link IotModbusRawDataTypeEnum}
+     */
+    private String rawDataType;
+    /**
+     * 缩放因子
+     */
+    private BigDecimal scale;
+    /**
+     * 轮询间隔（毫秒）
+     */
+    private Integer pollInterval;
+    /**
+     * 状态
+     *
+     * 枚举 {@link cn.iocoder.yudao.framework.common.enums.CommonStatusEnum}
+     */
+    private Integer status;
+
+}
+package cn.iocoder.yudao.module.iot.dal.mysql.device;
+
+import cn.iocoder.yudao.framework.common.pojo.PageResult;
+import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX;
+import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
+import cn.iocoder.yudao.module.iot.controller.admin.device.vo.modbus.IotDeviceModbusConfigPageReqVO;
+import cn.iocoder.yudao.module.iot.dal.dataobject.device.IotDeviceModbusConfigDO;
+import org.apache.ibatis.annotations.Mapper;
+
+import java.util.List;
+
+/**
+ * IoT 设备 Modbus 连接配置 Mapper
+ *
+ * @author 芋道源码
+ */
+@Mapper
+public interface IotDeviceModbusConfigMapper extends BaseMapperX<IotDeviceModbusConfigDO> {
+
+    default PageResult<IotDeviceModbusConfigDO> selectPage(IotDeviceModbusConfigPageReqVO reqVO) {
+        return selectPage(reqVO, new LambdaQueryWrapperX<IotDeviceModbusConfigDO>()
+                .eqIfPresent(IotDeviceModbusConfigDO::getDeviceId, reqVO.getDeviceId())
+                .likeIfPresent(IotDeviceModbusConfigDO::getIp, reqVO.getIp())
+                .eqIfPresent(IotDeviceModbusConfigDO::getStatus, reqVO.getStatus())
+                .orderByDesc(IotDeviceModbusConfigDO::getId));
+    }
+
+    default IotDeviceModbusConfigDO selectByDeviceId(Long deviceId) {
+        return selectOne(IotDeviceModbusConfigDO::getDeviceId, deviceId);
+    }
+
+    default List<IotDeviceModbusConfigDO> selectListByStatus(Integer status) {
+        return selectList(IotDeviceModbusConfigDO::getStatus, status);
+    }
+
+}
+package cn.iocoder.yudao.module.iot.dal.mysql.device;
+
+import cn.iocoder.yudao.framework.common.pojo.PageResult;
+import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX;
+import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
+import cn.iocoder.yudao.module.iot.controller.admin.device.vo.modbus.IotDeviceModbusPointPageReqVO;
+import cn.iocoder.yudao.module.iot.dal.dataobject.device.IotDeviceModbusPointDO;
+import org.apache.ibatis.annotations.Mapper;
+
+import java.util.List;
+
+/**
+ * IoT 设备 Modbus 点位配置 Mapper
+ *
+ * @author 芋道源码
+ */
+@Mapper
+public interface IotDeviceModbusPointMapper extends BaseMapperX<IotDeviceModbusPointDO> {
+
+    default PageResult<IotDeviceModbusPointDO> selectPage(IotDeviceModbusPointPageReqVO reqVO) {
+        return selectPage(reqVO, new LambdaQueryWrapperX<IotDeviceModbusPointDO>()
+                .eqIfPresent(IotDeviceModbusPointDO::getDeviceId, reqVO.getDeviceId())
+                .likeIfPresent(IotDeviceModbusPointDO::getIdentifier, reqVO.getIdentifier())
+                .likeIfPresent(IotDeviceModbusPointDO::getName, reqVO.getName())
+                .eqIfPresent(IotDeviceModbusPointDO::getFunctionCode, reqVO.getFunctionCode())
+                .eqIfPresent(IotDeviceModbusPointDO::getStatus, reqVO.getStatus())
+                .orderByDesc(IotDeviceModbusPointDO::getId));
+    }
+
+    default List<IotDeviceModbusPointDO> selectListByDeviceId(Long deviceId) {
+        return selectList(IotDeviceModbusPointDO::getDeviceId, deviceId);
+    }
+
+    // TODO @AI：是不是 selectList(f1, v1, f2, v2)；
+    default List<IotDeviceModbusPointDO> selectListByDeviceIdAndStatus(Long deviceId, Integer status) {
+        return selectList(new LambdaQueryWrapperX<IotDeviceModbusPointDO>()
+                .eq(IotDeviceModbusPointDO::getDeviceId, deviceId)
+                .eq(IotDeviceModbusPointDO::getStatus, status));
+    }
+
+    // TODO @AI：是不是 selectOne(f1, v1, f2, v2)；
+    default IotDeviceModbusPointDO selectByDeviceIdAndIdentifier(Long deviceId, String identifier) {
+        return selectOne(new LambdaQueryWrapperX<IotDeviceModbusPointDO>()
+                .eq(IotDeviceModbusPointDO::getDeviceId, deviceId)
+                .eq(IotDeviceModbusPointDO::getIdentifier, identifier));
+    }
+
+    // TODO @AI：是不是删除这个方法；
+    default void deleteByDeviceId(Long deviceId) {
+        delete(IotDeviceModbusPointDO::getDeviceId, deviceId);
+    }
+
+}
@@ -41,6 +41,14 @@ public interface ErrorCodeConstants {
     ErrorCode DEVICE_GROUP_NOT_EXISTS = new ErrorCode(1_050_005_000, "设备分组不存在");
     ErrorCode DEVICE_GROUP_DELETE_FAIL_DEVICE_EXISTS = new ErrorCode(1_050_005_001, "设备分组下存在设备，不允许删除");
+    // ========== 设备 Modbus 配置 1-050-006-000 ==========
+    ErrorCode DEVICE_MODBUS_CONFIG_NOT_EXISTS = new ErrorCode(1_050_006_000, "设备 Modbus 连接配置不存在");
+    ErrorCode DEVICE_MODBUS_CONFIG_EXISTS = new ErrorCode(1_050_006_001, "设备 Modbus 连接配置已存在");
+
+    // ========== 设备 Modbus 点位 1-050-007-000 ==========
+    ErrorCode DEVICE_MODBUS_POINT_NOT_EXISTS = new ErrorCode(1_050_007_000, "设备 Modbus 点位配置不存在");
+    ErrorCode DEVICE_MODBUS_POINT_EXISTS = new ErrorCode(1_050_007_001, "设备 Modbus 点位配置已存在");
+
     // ========== OTA 固件相关 1-050-008-000 ==========
     ErrorCode OTA_FIRMWARE_NOT_EXISTS = new ErrorCode(1_050_008_000, "固件信息不存在");
+package cn.iocoder.yudao.module.iot.enums.device;
+
+import cn.iocoder.yudao.framework.common.core.ArrayValuable;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+import java.util.Arrays;
+
+/**
+ * IoT Modbus 字节序枚举
+ *
+ * @author 芋道源码
+ */
+@Getter
+@RequiredArgsConstructor
+public enum IotModbusByteOrderEnum implements ArrayValuable<String> {
+
+    AB("AB", "大端序（16位）", 2),
+    BA("BA", "小端序（16位）", 2),
+    ABCD("ABCD", "大端序（32位）", 4),
+    CDAB("CDAB", "大端字交换（32位）", 4),
+    DCBA("DCBA", "小端序（32位）", 4),
+    BADC("BADC", "小端字交换（32位）", 4);
+
+    public static final String[] ARRAYS = Arrays.stream(values())
+            .map(IotModbusByteOrderEnum::getOrder)
+            .toArray(String[]::new);
+
+    /**
+     * 字节序
+     */
+    private final String order;
+    /**
+     * 名称
+     */
+    private final String name;
+    /**
+     * 字节数
+     */
+    private final Integer byteCount;
+
+    @Override
+    public String[] array() {
+        return ARRAYS;
+    }
+
+    // TODO @AI：如果不需要，可以删除掉这个方法；
+    /**
+     * 根据字节序获取枚举
+     *
+     * @param order 字节序
+     * @return 枚举
+     */
+    public static IotModbusByteOrderEnum getByOrder(String order) {
+        return Arrays.stream(values())
+                .filter(e -> e.getOrder().equals(order))
+                .findFirst()
+                .orElse(null);
+    }
+
+}
+package cn.iocoder.yudao.module.iot.enums.device;
+
+import cn.iocoder.yudao.framework.common.core.ArrayValuable;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+import java.util.Arrays;
+
+/**
+ * IoT Modbus 功能码枚举
+ *
+ * @author 芋道源码
+ */
+@Getter
+@RequiredArgsConstructor
+public enum IotModbusFunctionCodeEnum implements ArrayValuable<Integer> {
+
+    READ_COILS(1, "读线圈", true, 5, 15),
+    READ_DISCRETE_INPUTS(2, "读离散输入", false, null, null),
+    READ_HOLDING_REGISTERS(3, "读保持寄存器", true, 6, 16),
+    READ_INPUT_REGISTERS(4, "读输入寄存器", false, null, null);
+
+    public static final Integer[] ARRAYS = Arrays.stream(values())
+            .map(IotModbusFunctionCodeEnum::getCode)
+            .toArray(Integer[]::new);
+
+    /**
+     * 功能码
+     */
+    private final Integer code;
+    /**
+     * 名称
+     */
+    private final String name;
+    /**
+     * 是否支持写操作
+     */
+    private final Boolean writable;
+    /**
+     * 单个写功能码
+     */
+    private final Integer writeSingleCode;
+    /**
+     * 多个写功能码
+     */
+    private final Integer writeMultipleCode;
+
+    @Override
+    public Integer[] array() {
+        return ARRAYS;
+    }
+
+    /**
+     * 根据功能码获取枚举
+     *
+     * @param code 功能码
+     * @return 枚举
+     */
+    public static IotModbusFunctionCodeEnum valueOf(Integer code) {
+        return Arrays.stream(values())
+                .filter(e -> e.getCode().equals(code))
+                .findFirst()
+                .orElse(null);
+    }
+
+    // TODO @AI：如果用不到，可以暂时删除哈；
+    /**
+     * 获取写功能码
+     *
+     * @param registerCount 寄存器数量
+     * @return 写功能码
+     */
+    public Integer getWriteCode(int registerCount) {
+        if (!writable) {
+            return null;
+        }
+        return registerCount == 1 ? writeSingleCode : writeMultipleCode;
+    }
+
+}
+package cn.iocoder.yudao.module.iot.enums.device;
+
+import cn.iocoder.yudao.framework.common.core.ArrayValuable;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+import java.util.Arrays;
+
+/**
+ * IoT Modbus 原始数据类型枚举
+ *
+ * @author 芋道源码
+ */
+@Getter
+@RequiredArgsConstructor
+public enum IotModbusRawDataTypeEnum implements ArrayValuable<String> {
+
+    INT16("INT16", "有符号 16 位整数", 1),
+    UINT16("UINT16", "无符号 16 位整数", 1),
+    INT32("INT32", "有符号 32 位整数", 2),
+    UINT32("UINT32", "无符号 32 位整数", 2),
+    FLOAT("FLOAT", "32 位浮点数", 2),
+    DOUBLE("DOUBLE", "64 位浮点数", 4),
+    BOOLEAN("BOOLEAN", "布尔值（用于线圈）", 1),
+    STRING("STRING", "字符串", -1); // -1 表示可变长度
+
+    public static final String[] ARRAYS = Arrays.stream(values())
+            .map(IotModbusRawDataTypeEnum::getType)
+            .toArray(String[]::new);
+
+    /**
+     * 数据类型
+     */
+    private final String type;
+    /**
+     * 名称
+     */
+    private final String name;
+    // TODO @AI：去掉 default 会好点。null 表示可变；
+    /**
+     * 默认寄存器数量（-1 表示可变）
+     */
+    private final Integer defaultRegisterCount;
+
+    @Override
+    public String[] array() {
+        return ARRAYS;
+    }
+
+    // TODO @AI：如果不用，可以删除掉
+    /**
+     * 根据类型获取枚举
+     *
+     * @param type 类型
+     * @return 枚举
+     */
+    public static IotModbusRawDataTypeEnum getByType(String type) {
+        return Arrays.stream(values())
+                .filter(e -> e.getType().equals(type))
+                .findFirst()
+                .orElse(null);
+    }
+
+}
+package cn.iocoder.yudao.module.iot.service.device;
+
+import cn.iocoder.yudao.framework.common.pojo.PageResult;
+import cn.iocoder.yudao.module.iot.controller.admin.device.vo.modbus.IotDeviceModbusConfigPageReqVO;
+import cn.iocoder.yudao.module.iot.controller.admin.device.vo.modbus.IotDeviceModbusConfigSaveReqVO;
+import cn.iocoder.yudao.module.iot.dal.dataobject.device.IotDeviceModbusConfigDO;
+import jakarta.validation.Valid;
+
+import java.util.List;
+
+/**
+ * IoT 设备 Modbus 连接配置 Service 接口
+ *
+ * @author 芋道源码
+ */
+public interface IotDeviceModbusConfigService {
+
+    /**
+     * 创建设备 Modbus 连接配置
+     *
+     * @param createReqVO 创建信息
+     * @return 编号
+     */
+    Long createModbusConfig(@Valid IotDeviceModbusConfigSaveReqVO createReqVO);
+
+    /**
+     * 更新设备 Modbus 连接配置
+     *
+     * @param updateReqVO 更新信息
+     */
+    void updateModbusConfig(@Valid IotDeviceModbusConfigSaveReqVO updateReqVO);
+
+    /**
+     * 删除设备 Modbus 连接配置
+     *
+     * @param id 编号
+     */
+    void deleteModbusConfig(Long id);
+
+    /**
+     * 获得设备 Modbus 连接配置
+     *
+     * @param id 编号
+     * @return 设备 Modbus 连接配置
+     */
+    IotDeviceModbusConfigDO getModbusConfig(Long id);
+
+    /**
+     * 根据设备编号获得 Modbus 连接配置
+     *
+     * @param deviceId 设备编号
+     * @return 设备 Modbus 连接配置
+     */
+    IotDeviceModbusConfigDO getModbusConfigByDeviceId(Long deviceId);
+
+    /**
+     * 获得设备 Modbus 连接配置分页
+     *
+     * @param pageReqVO 分页查询
+     * @return 设备 Modbus 连接配置分页
+     */
+    PageResult<IotDeviceModbusConfigDO> getModbusConfigPage(IotDeviceModbusConfigPageReqVO pageReqVO);
+
+    /**
+     * 获得所有启用的 Modbus 连接配置列表
+     *
+     * @return 启用的 Modbus 连接配置列表
+     */
+    List<IotDeviceModbusConfigDO> getEnabledModbusConfigList();
+
+}
+package cn.iocoder.yudao.module.iot.service.device;
+
+import cn.iocoder.yudao.framework.common.enums.CommonStatusEnum;
+import cn.iocoder.yudao.framework.common.pojo.PageResult;
+import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
+import cn.iocoder.yudao.module.iot.controller.admin.device.vo.modbus.IotDeviceModbusConfigPageReqVO;
+import cn.iocoder.yudao.module.iot.controller.admin.device.vo.modbus.IotDeviceModbusConfigSaveReqVO;
+import cn.iocoder.yudao.module.iot.dal.dataobject.device.IotDeviceModbusConfigDO;
+import cn.iocoder.yudao.module.iot.dal.mysql.device.IotDeviceModbusConfigMapper;
+import jakarta.annotation.Resource;
+import org.springframework.stereotype.Service;
+import org.springframework.validation.annotation.Validated;
+
+import java.util.List;
+
+import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
+import static cn.iocoder.yudao.module.iot.enums.ErrorCodeConstants.DEVICE_MODBUS_CONFIG_EXISTS;
+import static cn.iocoder.yudao.module.iot.enums.ErrorCodeConstants.DEVICE_MODBUS_CONFIG_NOT_EXISTS;
+
+/**
+ * IoT 设备 Modbus 连接配置 Service 实现类
+ *
+ * @author 芋道源码
+ */
+@Service
+@Validated
+public class IotDeviceModbusConfigServiceImpl implements IotDeviceModbusConfigService {
+
+    @Resource
+    private IotDeviceModbusConfigMapper modbusConfigMapper;
+
+    @Resource
+    private IotDeviceService deviceService;
+
+    // TODO @AI：是不是搞成 save 接口？因为前端也不知道是 create 还是 update；
+    @Override
+    public Long createModbusConfig(IotDeviceModbusConfigSaveReqVO createReqVO) {
+        // 1.1 校验设备存在
+        deviceService.validateDeviceExists(createReqVO.getDeviceId());
+        // 1.2 校验设备是否已有 Modbus 配置
+        validateModbusConfigUnique(createReqVO.getDeviceId(), null);
+
+        // 2. 插入
+        IotDeviceModbusConfigDO modbusConfig = BeanUtils.toBean(createReqVO, IotDeviceModbusConfigDO.class);
+        setDefaultValues(modbusConfig);
+        modbusConfigMapper.insert(modbusConfig);
+        return modbusConfig.getId();
+    }
+
+    @Override
+    public void updateModbusConfig(IotDeviceModbusConfigSaveReqVO updateReqVO) {
+        // 1.1 校验存在
+        validateModbusConfigExists(updateReqVO.getId());
+        // 1.2 校验设备存在
+        deviceService.validateDeviceExists(updateReqVO.getDeviceId());
+        // 1.3 校验唯一性
+        validateModbusConfigUnique(updateReqVO.getDeviceId(), updateReqVO.getId());
+
+        // 2. 更新
+        IotDeviceModbusConfigDO updateObj = BeanUtils.toBean(updateReqVO, IotDeviceModbusConfigDO.class);
+        modbusConfigMapper.updateById(updateObj);
+    }
+
+    @Override
+    public void deleteModbusConfig(Long id) {
+        // 校验存在
+        validateModbusConfigExists(id);
+        // 删除
+        modbusConfigMapper.deleteById(id);
+    }
+
+    private void validateModbusConfigExists(Long id) {
+        if (modbusConfigMapper.selectById(id) == null) {
+            throw exception(DEVICE_MODBUS_CONFIG_NOT_EXISTS);
+        }
+    }
+
+    private void validateModbusConfigUnique(Long deviceId, Long excludeId) {
+        IotDeviceModbusConfigDO config = modbusConfigMapper.selectByDeviceId(deviceId);
+        // TODO @AI：ObjUtil notequals
+        if (config != null && !config.getId().equals(excludeId)) {
+            throw exception(DEVICE_MODBUS_CONFIG_EXISTS);
+        }
+    }
+
+    // TODO @AI：不要这个；前端都必须传递；
+    private void setDefaultValues(IotDeviceModbusConfigDO config) {
+        if (config.getPort() == null) {
+            config.setPort(502);
+        }
+        if (config.getSlaveId() == null) {
+            config.setSlaveId(1);
+        }
+        if (config.getTimeout() == null) {
+            config.setTimeout(3000);
+        }
+        if (config.getRetryInterval() == null) {
+            config.setRetryInterval(1000);
+        }
+    }
+
+    @Override
+    public IotDeviceModbusConfigDO getModbusConfig(Long id) {
+        return modbusConfigMapper.selectById(id);
+    }
+
+    @Override
+    public IotDeviceModbusConfigDO getModbusConfigByDeviceId(Long deviceId) {
+        return modbusConfigMapper.selectByDeviceId(deviceId);
+    }
+
+    @Override
+    public PageResult<IotDeviceModbusConfigDO> getModbusConfigPage(IotDeviceModbusConfigPageReqVO pageReqVO) {
+        return modbusConfigMapper.selectPage(pageReqVO);
+    }
+
+    @Override
+    public List<IotDeviceModbusConfigDO> getEnabledModbusConfigList() {
+        return modbusConfigMapper.selectListByStatus(CommonStatusEnum.ENABLE.getStatus());
+    }
+
+}
+package cn.iocoder.yudao.module.iot.service.device;
+
+import cn.iocoder.yudao.framework.common.pojo.PageResult;
+import cn.iocoder.yudao.module.iot.controller.admin.device.vo.modbus.IotDeviceModbusPointPageReqVO;
+import cn.iocoder.yudao.module.iot.controller.admin.device.vo.modbus.IotDeviceModbusPointSaveReqVO;
+import cn.iocoder.yudao.module.iot.dal.dataobject.device.IotDeviceModbusPointDO;
+import jakarta.validation.Valid;
+
+import java.util.List;
+
+/**
+ * IoT 设备 Modbus 点位配置 Service 接口
+ *
+ * @author 芋道源码
+ */
+public interface IotDeviceModbusPointService {
+
+    /**
+     * 创建设备 Modbus 点位配置
+     *
+     * @param createReqVO 创建信息
+     * @return 编号
+     */
+    Long createModbusPoint(@Valid IotDeviceModbusPointSaveReqVO createReqVO);
+
+    /**
+     * 更新设备 Modbus 点位配置
+     *
+     * @param updateReqVO 更新信息
+     */
+    void updateModbusPoint(@Valid IotDeviceModbusPointSaveReqVO updateReqVO);
+
+    /**
+     * 删除设备 Modbus 点位配置
+     *
+     * @param id 编号
+     */
+    void deleteModbusPoint(Long id);
+
+    /**
+     * 获得设备 Modbus 点位配置
+     *
+     * @param id 编号
+     * @return 设备 Modbus 点位配置
+     */
+    IotDeviceModbusPointDO getModbusPoint(Long id);
+
+    /**
+     * 获得设备 Modbus 点位配置分页
+     *
+     * @param pageReqVO 分页查询
+     * @return 设备 Modbus 点位配置分页
+     */
+    PageResult<IotDeviceModbusPointDO> getModbusPointPage(IotDeviceModbusPointPageReqVO pageReqVO);
+
+    /**
+     * 根据设备编号获得点位配置列表
+     *
+     * @param deviceId 设备编号
+     * @return 点位配置列表
+     */
+    List<IotDeviceModbusPointDO> getModbusPointListByDeviceId(Long deviceId);
+
+    /**
+     * 根据设备编号获得启用的点位配置列表
+     *
+     * @param deviceId 设备编号
+     * @return 启用的点位配置列表
+     */
+    List<IotDeviceModbusPointDO> getEnabledModbusPointListByDeviceId(Long deviceId);
+
+}
+package cn.iocoder.yudao.module.iot.service.device;
+
+import cn.iocoder.yudao.framework.common.enums.CommonStatusEnum;
+import cn.iocoder.yudao.framework.common.pojo.PageResult;
+import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
+import cn.iocoder.yudao.module.iot.controller.admin.device.vo.modbus.IotDeviceModbusPointPageReqVO;
+import cn.iocoder.yudao.module.iot.controller.admin.device.vo.modbus.IotDeviceModbusPointSaveReqVO;
+import cn.iocoder.yudao.module.iot.dal.dataobject.device.IotDeviceModbusPointDO;
+import cn.iocoder.yudao.module.iot.dal.dataobject.thingmodel.IotThingModelDO;
+import cn.iocoder.yudao.module.iot.dal.mysql.device.IotDeviceModbusPointMapper;
+import cn.iocoder.yudao.module.iot.service.thingmodel.IotThingModelService;
+import jakarta.annotation.Resource;
+import org.springframework.stereotype.Service;
+import org.springframework.validation.annotation.Validated;
+
+import java.math.BigDecimal;
+import java.util.List;
+
+import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
+import static cn.iocoder.yudao.module.iot.enums.ErrorCodeConstants.*;
+
+/**
+ * IoT 设备 Modbus 点位配置 Service 实现类
+ *
+ * @author 芋道源码
+ */
+@Service
+@Validated
+public class IotDeviceModbusPointServiceImpl implements IotDeviceModbusPointService {
+
+    @Resource
+    private IotDeviceModbusPointMapper modbusPointMapper;
+
+    @Resource
+    private IotDeviceService deviceService;
+
+    @Resource
+    private IotThingModelService thingModelService;
+
+    @Override
+    public Long createModbusPoint(IotDeviceModbusPointSaveReqVO createReqVO) {
+        // 1.1 校验设备存在
+        deviceService.validateDeviceExists(createReqVO.getDeviceId());
+        // 1.2 校验物模型属性存在
+        IotThingModelDO thingModel = validateThingModelExists(createReqVO.getThingModelId());
+        // 1.3 校验同一设备下点位唯一性（基于 identifier）
+        validateModbusPointUnique(createReqVO.getDeviceId(), thingModel.getIdentifier(), null);
+
+        // 2. 插入
+        IotDeviceModbusPointDO modbusPoint = BeanUtils.toBean(createReqVO, IotDeviceModbusPointDO.class,
+                o -> o.setIdentifier(thingModel.getIdentifier()).setName(thingModel.getName()));
+        modbusPointMapper.insert(modbusPoint);
+        return modbusPoint.getId();
+    }
+
+    @Override
+    public void updateModbusPoint(IotDeviceModbusPointSaveReqVO updateReqVO) {
+        // 1.1 校验存在
+        validateModbusPointExists(updateReqVO.getId());
+        // 1.2 校验设备存在
+        deviceService.validateDeviceExists(updateReqVO.getDeviceId());
+        // 1.3 校验物模型属性存在
+        IotThingModelDO thingModel = validateThingModelExists(updateReqVO.getThingModelId());
+        // 1.4 校验同一设备下点位唯一性
+        validateModbusPointUnique(updateReqVO.getDeviceId(), thingModel.getIdentifier(), updateReqVO.getId());
+
+        // 2. 更新
+        IotDeviceModbusPointDO updateObj = BeanUtils.toBean(updateReqVO, IotDeviceModbusPointDO.class);
+        // TODO @AI：这块
+        modbusPointMapper.updateById(updateObj);
+    }
+
+    private IotThingModelDO validateThingModelExists(Long id) {
+        IotThingModelDO thingModel = thingModelService.getThingModel(id);
+        if (thingModel == null) {
+            throw exception(THING_MODEL_NOT_EXISTS);
+        }
+        return thingModel;
+    }
+
+    @Override
+    public void deleteModbusPoint(Long id) {
+        // 校验存在
+        validateModbusPointExists(id);
+        // 删除
+        modbusPointMapper.deleteById(id);
+    }
+
+    private IotDeviceModbusPointDO validateModbusPointExists(Long id) {
+        IotDeviceModbusPointDO point = modbusPointMapper.selectById(id);
+        if (point == null) {
+            throw exception(DEVICE_MODBUS_POINT_NOT_EXISTS);
+        }
+        return point;
+    }
+
+    private void validateModbusPointUnique(Long deviceId, String identifier, Long excludeId) {
+        IotDeviceModbusPointDO point = modbusPointMapper.selectByDeviceIdAndIdentifier(deviceId, identifier);
+        // TODO @AI：ObjUtil notequals；
+        if (point != null && !point.getId().equals(excludeId)) {
+            throw exception(DEVICE_MODBUS_POINT_EXISTS);
+        }
+    }
+
+    // TODO @AI：这块
+    private void setDefaultValues(IotDeviceModbusPointDO point) {
+        if (point.getRegisterCount() == null) {
+            point.setRegisterCount(1);
+        }
+        if (point.getScale() == null) {
+            point.setScale(BigDecimal.ONE);
+        }
+        if (point.getPollInterval() == null) {
+            point.setPollInterval(5000);
+        }
+    }
+
+    @Override
+    public IotDeviceModbusPointDO getModbusPoint(Long id) {
+        return modbusPointMapper.selectById(id);
+    }
+
+    @Override
+    public PageResult<IotDeviceModbusPointDO> getModbusPointPage(IotDeviceModbusPointPageReqVO pageReqVO) {
+        return modbusPointMapper.selectPage(pageReqVO);
+    }
+
+    @Override
+    public List<IotDeviceModbusPointDO> getModbusPointListByDeviceId(Long deviceId) {
+        return modbusPointMapper.selectListByDeviceId(deviceId);
+    }
+
+    @Override
+    public List<IotDeviceModbusPointDO> getEnabledModbusPointListByDeviceId(Long deviceId) {
+        return modbusPointMapper.selectListByDeviceIdAndStatus(deviceId, CommonStatusEnum.ENABLE.getStatus());
+    }
+
+}
@@ -4,6 +4,9 @@ import cn.iocoder.yudao.framework.common.pojo.CommonResult;
 import cn.iocoder.yudao.module.iot.core.biz.dto.IotDeviceAuthReqDTO;
 import cn.iocoder.yudao.module.iot.core.biz.dto.IotDeviceGetReqDTO;
 import cn.iocoder.yudao.module.iot.core.biz.dto.IotDeviceRespDTO;
+import cn.iocoder.yudao.module.iot.core.biz.dto.IotModbusDeviceConfigRespDTO;
+
+import java.util.List;
 /**
  * IoT 设备通用 API
@@ -28,4 +31,11 @@ public interface IotDeviceCommonApi {
      */
     CommonResult<IotDeviceRespDTO> getDevice(IotDeviceGetReqDTO infoReqDTO);
+    /**
+     * 获取所有启用的 Modbus 设备配置列表
+     *
+     * @return Modbus 设备配置列表
+     */
+    CommonResult<List<IotModbusDeviceConfigRespDTO>> getEnabledModbusDeviceConfigs();
+
 }
+package cn.iocoder.yudao.module.iot.core.biz.dto;
+
+import lombok.Data;
+
+import java.util.List;
+
+/**
+ * IoT Modbus 设备配置 Response DTO
+ *
+ * @author 芋道源码
+ */
+@Data
+public class IotModbusDeviceConfigRespDTO {
+
+    /**
+     * 设备编号
+     */
+    private Long deviceId;
+    /**
+     * 产品标识
+     */
+    private String productKey;
+    /**
+     * 设备名称
+     */
+    private String deviceName;
+    /**
+     * 租户编号
+     */
+    private Long tenantId;
+
+    // ========== Modbus 连接配置 ==========
+
+    /**
+     * Modbus 服务器 IP 地址
+     */
+    private String ip;
+    /**
+     * Modbus 端口
+     */
+    private Integer port;
+    /**
+     * 从站地址
+     */
+    private Integer slaveId;
+    /**
+     * 连接超时时间（毫秒）
+     */
+    private Integer timeout;
+    /**
+     * 重试间隔（毫秒）
+     */
+    private Integer retryInterval;
+
+    // ========== 点位配置 ==========
+
+    /**
+     * 点位列表
+     */
+    private List<IotModbusPointRespDTO> points;
+
+}
+package cn.iocoder.yudao.module.iot.core.biz.dto;
+
+import lombok.Data;
+
+import java.math.BigDecimal;
+
+/**
+ * IoT Modbus 点位配置 Response DTO
+ *
+ * @author 芋道源码
+ */
+@Data
+public class IotModbusPointRespDTO {
+
+    /**
+     * 点位编号
+     */
+    private Long id;
+    /**
+     * 属性标识符（物模型的 identifier）
+     */
+    private String identifier;
+    /**
+     * 属性名称（物模型的 name）
+     */
+    private String name;
+
+    // ========== Modbus 协议配置 ==========
+
+    // TODO @AI：所有的枚举，通过 @，不要写上去；
+    /**
+     * Modbus 功能码
+     *
+     * 1-ReadCoils 2-ReadDiscreteInputs 3-ReadHoldingRegisters 4-ReadInputRegisters
+     */
+    private Integer functionCode;
+    /**
+     * 寄存器起始地址
+     */
+    private Integer registerAddress;
+    /**
+     * 寄存器数量
+     */
+    private Integer registerCount;
+    /**
+     * 字节序
+     *
+     * AB/BA/ABCD/CDAB/DCBA/BADC
+     */
+    private String byteOrder;
+    /**
+     * 原始数据类型
+     *
+     * INT16/UINT16/INT32/UINT32/FLOAT/DOUBLE/BOOLEAN/STRING
+     */
+    private String rawDataType;
+    /**
+     * 缩放因子
+     */
+    private BigDecimal scale;
+    /**
+     * 轮询间隔（毫秒）
+     */
+    private Integer pollInterval;
+
+    // ========== 物模型相关字段 ==========
+
+    // TODO @AI：分析一下，是否有必要返回
+    /**
+     * 数据类型（来自物模型）
+     */
+    private String dataType;
+
+}
@@ -33,7 +33,7 @@
             <groupId>org.apache.rocketmq</groupId>
             <artifactId>rocketmq-spring-boot-starter</artifactId>
             <!-- TODO @芋艿：消息队列，后续可能去掉，默认不使用 rocketmq -->
-<!--            <optional>true</optional> -->
+            <optional>true</optional>
         </dependency>
         <!-- 工具类相关 -->
@@ -48,6 +48,13 @@
             <artifactId>vertx-mqtt</artifactId>
         </dependency>
+        <!-- Modbus 相关 -->
+        <dependency>
+            <groupId>com.ghgande</groupId>
+            <artifactId>j2mod</artifactId>
+            <version>3.2.1</version>
+        </dependency>
+
         <!-- 测试相关 -->
         <dependency>
             <groupId>cn.iocoder.boot</groupId>
@@ -6,6 +6,7 @@ import cn.iocoder.yudao.module.iot.gateway.protocol.emqx.IotEmqxDownstreamSubscr
 import cn.iocoder.yudao.module.iot.gateway.protocol.emqx.IotEmqxUpstreamProtocol;
 import cn.iocoder.yudao.module.iot.gateway.protocol.http.IotHttpDownstreamSubscriber;
 import cn.iocoder.yudao.module.iot.gateway.protocol.http.IotHttpUpstreamProtocol;
+import cn.iocoder.yudao.module.iot.gateway.protocol.modbustcp.*;
 import cn.iocoder.yudao.module.iot.gateway.protocol.mqtt.IotMqttDownstreamSubscriber;
 import cn.iocoder.yudao.module.iot.gateway.protocol.mqtt.IotMqttUpstreamProtocol;
 import cn.iocoder.yudao.module.iot.gateway.protocol.mqtt.manager.IotMqttConnectionManager;
@@ -194,4 +195,38 @@ public class IotGatewayConfiguration {
     }
+    /**
+     * IoT 网关 Modbus TCP 协议配置类
+     */
+    @Configuration
+    @ConditionalOnProperty(prefix = "yudao.iot.gateway.protocol.modbus-tcp", name = "enabled", havingValue = "true")
+    @Slf4j
+    public static class ModbusTcpProtocolConfiguration {
+
+        @Bean(name = "modbusTcpVertx", destroyMethod = "close")
+        public Vertx modbusTcpVertx() {
+            return Vertx.vertx();
+        }
+
+        @Bean
+        public IotModbusTcpUpstreamProtocol iotModbusTcpUpstreamProtocol(IotGatewayProperties gatewayProperties,
+                                                                         IotDeviceMessageService messageService,
+                                                                         IotModbusTcpConnectionManager connectionManager,
+                                                                         IotModbusTcpPollScheduler pollScheduler,
+                                                                         IotModbusTcpConfigCacheService configCacheService,
+                                                                         IotModbusTcpUpstreamHandler upstreamHandler,
+                                                                         @Qualifier("modbusTcpVertx") Vertx modbusTcpVertx) {
+            return new IotModbusTcpUpstreamProtocol(gatewayProperties.getProtocol().getModbusTcp(),
+                    messageService, connectionManager, pollScheduler, configCacheService, upstreamHandler, modbusTcpVertx);
+        }
+
+        @Bean
+        public IotModbusTcpDownstreamSubscriber iotModbusTcpDownstreamSubscriber(IotModbusTcpUpstreamProtocol upstreamProtocol,
+                                                                                  IotModbusTcpDownstreamHandler downstreamHandler,
+                                                                                  IotMessageBus messageBus) {
+            return new IotModbusTcpDownstreamSubscriber(upstreamProtocol, downstreamHandler, messageBus);
+        }
+
+    }
+
 }
@@ -93,6 +93,11 @@ public class IotGatewayProperties {
          */
         private MqttWsProperties mqttWs;
+        /**
+         * Modbus TCP 组件配置
+         */
+        private ModbusTcpProperties modbusTcp;
+
     }
     @Data
@@ -503,4 +508,21 @@ public class IotGatewayProperties {
     }
+    @Data
+    public static class ModbusTcpProperties {
+
+        /**
+         * 是否开启
+         */
+        @NotNull(message = "是否开启不能为空")
+        private Boolean enabled;
+
+        /**
+         * 配置刷新间隔（秒）
+         */
+        // TODO @AI：需要校验下非空；
+        private Integer configRefreshInterval = 30;
+
+    }
+
 }
+package cn.iocoder.yudao.module.iot.gateway.protocol.modbustcp;
+
+import cn.iocoder.yudao.module.iot.core.biz.dto.IotModbusPointRespDTO;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Component;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+// TODO @AI：注释上：希望 1 和 2，然后 3 只是辅助说明
+/**
+ * IoT Modbus 数据转换器
+ *
+ * 负责：
+ * 1. 将 Modbus 原始寄存器值转换为物模型属性值
+ * 2. 将物模型属性值转换为 Modbus 原始寄存器值
+ * 3. 处理字节序、数据类型、缩放因子
+ *
+ * @author 芋道源码
+ */
+// TODO @AI：希望它的初始化，在 configuration 里；
+@Component
+@Slf4j
+public class IotModbusDataConverter {
+
+    /**
+     * 将原始值转换为物模型属性值
+     *
+     * @param rawValues 原始值数组（寄存器值或线圈值）
+     * @param point     点位配置
+     * @return 转换后的属性值
+     */
+    public Object convertToPropertyValue(int[] rawValues, IotModbusPointRespDTO point) {
+        // TODO @AI：CollUtil.isEmpty；
+        if (rawValues == null || rawValues.length == 0) {
+            return null;
+        }
+        String rawDataType = point.getRawDataType();
+        String byteOrder = point.getByteOrder();
+        // TODO @AI：defaultIfNull；
+        BigDecimal scale = point.getScale() != null ? point.getScale() : BigDecimal.ONE;
+
+        // 1. 根据原始数据类型解析原始数值
+        Number rawNumber = parseRawValue(rawValues, rawDataType, byteOrder);
+        if (rawNumber == null) {
+            return null;
+        }
+
+        // 2. 应用缩放因子：实际值 = 原始值 × scale
+        BigDecimal actualValue = new BigDecimal(rawNumber.toString()).multiply(scale);
+
+        // 3. 根据数据类型返回合适的 Java 类型
+        return formatValue(actualValue, rawDataType);
+    }
+
+    /**
+     * 将物模型属性值转换为原始寄存器值
+     *
+     * @param propertyValue 属性值
+     * @param point         点位配置
+     * @return 原始值数组
+     */
+    public int[] convertToRawValues(Object propertyValue, IotModbusPointRespDTO point) {
+        if (propertyValue == null) {
+            return new int[0];
+        }
+        String rawDataType = point.getRawDataType();
+        String byteOrder = point.getByteOrder();
+        BigDecimal scale = point.getScale() != null ? point.getScale() : BigDecimal.ONE;
+        int registerCount = point.getRegisterCount() != null ? point.getRegisterCount() : 1;
+
+        // 1. 转换为 BigDecimal
+        BigDecimal actualValue = new BigDecimal(propertyValue.toString());
+
+        // 2. 应用缩放因子：原始值 = 实际值 ÷ scale
+        BigDecimal rawValue = actualValue.divide(scale, 0, RoundingMode.HALF_UP);
+
+        // 3. 根据原始数据类型编码为寄存器值
+        return encodeToRegisters(rawValue, rawDataType, byteOrder, registerCount);
+    }
+
+    /**
+     * 解析原始值
+     */
+    private Number parseRawValue(int[] rawValues, String rawDataType, String byteOrder) {
+        // TODO @AI：是不是可以用枚举？复用 IotModbusRawDataTypeEnum 里的；
+        switch (rawDataType.toUpperCase()) {
+            case "BOOLEAN":
+                return rawValues[0] != 0 ? 1 : 0;
+            case "INT16":
+                return (short) rawValues[0];
+            case "UINT16":
+                return rawValues[0] & 0xFFFF;
+            case "INT32":
+                return parseInt32(rawValues, byteOrder);
+            case "UINT32":
+                return parseUint32(rawValues, byteOrder);
+            case "FLOAT":
+                return parseFloat(rawValues, byteOrder);
+            case "DOUBLE":
+                return parseDouble(rawValues, byteOrder);
+            // TODO @AI：未知抛出异常；
+            default:
+                log.warn("[parseRawValue][不支持的数据类型: {}]", rawDataType);
+                return rawValues[0];
+        }
+    }
+
+    // TODO @AI：这些转换，有没一些工具类，可以优化；类似 hutool 的？
+    private int parseInt32(int[] rawValues, String byteOrder) {
+        if (rawValues.length < 2) {
+            return rawValues[0];
+        }
+        byte[] bytes = reorderBytes(registersToBytes(rawValues, 2), byteOrder);
+        return ByteBuffer.wrap(bytes).order(ByteOrder.BIG_ENDIAN).getInt();
+    }
+
+    private long parseUint32(int[] rawValues, String byteOrder) {
+        if (rawValues.length < 2) {
+            return rawValues[0] & 0xFFFFFFFFL;
+        }
+        byte[] bytes = reorderBytes(registersToBytes(rawValues, 2), byteOrder);
+        return ByteBuffer.wrap(bytes).order(ByteOrder.BIG_ENDIAN).getInt() & 0xFFFFFFFFL;
+    }
+
+    private float parseFloat(int[] rawValues, String byteOrder) {
+        if (rawValues.length < 2) {
+            return (float) rawValues[0];
+        }
+        byte[] bytes = reorderBytes(registersToBytes(rawValues, 2), byteOrder);
+        return ByteBuffer.wrap(bytes).order(ByteOrder.BIG_ENDIAN).getFloat();
+    }
+
+    private double parseDouble(int[] rawValues, String byteOrder) {
+        if (rawValues.length < 4) {
+            return rawValues[0];
+        }
+        byte[] bytes = reorderBytes(registersToBytes(rawValues, 4), byteOrder);
+        return ByteBuffer.wrap(bytes).order(ByteOrder.BIG_ENDIAN).getDouble();
+    }
+
+    /**
+     * 将寄存器值转换为字节数组
+     */
+    private byte[] registersToBytes(int[] registers, int count) {
+        byte[] bytes = new byte[count * 2];
+        for (int i = 0; i < Math.min(registers.length, count); i++) {
+            bytes[i * 2] = (byte) ((registers[i] >> 8) & 0xFF);
+            bytes[i * 2 + 1] = (byte) (registers[i] & 0xFF);
+        }
+        return bytes;
+    }
+
+    /**
+     * 根据字节序重排字节
+     */
+    private byte[] reorderBytes(byte[] bytes, String byteOrder) {
+        // 大端序，不需要调整
+        // TODO @AI：StrUtil.equals；null 要抛出异常；
+        if (byteOrder == null || "ABCD".equals(byteOrder) || "AB".equals(byteOrder)) {
+            return bytes;
+        }
+
+        // 其他字节序调整
+        byte[] result = new byte[bytes.length];
+        switch (byteOrder.toUpperCase()) {
+            // TODO @AI：走枚举；sortOrder；
+            case "BA": // 小端序（16 位）
+                if (bytes.length >= 2) {
+                    result[0] = bytes[1];
+                    result[1] = bytes[0];
+                }
+                break;
+            case "CDAB": // 大端字交换（32 位）
+                if (bytes.length >= 4) {
+                    result[0] = bytes[2];
+                    result[1] = bytes[3];
+                    result[2] = bytes[0];
+                    result[3] = bytes[1];
+                }
+                break;
+            case "DCBA": // 小端序（32 位）
+                if (bytes.length >= 4) {
+                    result[0] = bytes[3];
+                    result[1] = bytes[2];
+                    result[2] = bytes[1];
+                    result[3] = bytes[0];
+                }
+                break;
+            case "BADC": // 小端字交换（32 位）
+                if (bytes.length >= 4) {
+                    result[0] = bytes[1];
+                    result[1] = bytes[0];
+                    result[2] = bytes[3];
+                    result[3] = bytes[2];
+                }
+                break;
+            // TODO @AI：未知就抛出异常；
+            default:
+                return bytes;
+        }
+        return result;
+    }
+
+    /**
+     * 编码为寄存器值
+     */
+    private int[] encodeToRegisters(BigDecimal rawValue, String rawDataType, String byteOrder, int registerCount) {
+        // TODO @AI：是不是可以用枚举？复用 IotModbusRawDataTypeEnum 里的；
+        switch (rawDataType.toUpperCase()) {
+            case "BOOLEAN":
+                return new int[]{rawValue.intValue() != 0 ? 1 : 0};
+            case "INT16":
+            case "UINT16":
+                return new int[]{rawValue.intValue() & 0xFFFF};
+            case "INT32":
+            case "UINT32":
+                return encodeInt32(rawValue.intValue(), byteOrder);
+            case "FLOAT":
+                return encodeFloat(rawValue.floatValue(), byteOrder);
+            case "DOUBLE":
+                return encodeDouble(rawValue.doubleValue(), byteOrder);
+            default:
+                return new int[]{rawValue.intValue()};
+        }
+    }
+
+    // TODO @AI：这些转换，有没一些工具类，可以优化；类似 hutool 的？
+    private int[] encodeInt32(int value, String byteOrder) {
+        byte[] bytes = ByteBuffer.allocate(4).order(ByteOrder.BIG_ENDIAN).putInt(value).array();
+        bytes = reorderBytes(bytes, byteOrder);
+        return bytesToRegisters(bytes);
+    }
+
+    private int[] encodeFloat(float value, String byteOrder) {
+        byte[] bytes = ByteBuffer.allocate(4).order(ByteOrder.BIG_ENDIAN).putFloat(value).array();
+        bytes = reorderBytes(bytes, byteOrder);
+        return bytesToRegisters(bytes);
+    }
+
+    private int[] encodeDouble(double value, String byteOrder) {
+        byte[] bytes = ByteBuffer.allocate(8).order(ByteOrder.BIG_ENDIAN).putDouble(value).array();
+        bytes = reorderBytes(bytes, byteOrder);
+        return bytesToRegisters(bytes);
+    }
+
+    private int[] bytesToRegisters(byte[] bytes) {
+        int[] registers = new int[bytes.length / 2];
+        for (int i = 0; i < registers.length; i++) {
+            registers[i] = ((bytes[i * 2] & 0xFF) << 8) | (bytes[i * 2 + 1] & 0xFF);
+        }
+        return registers;
+    }
+
+    /**
+     * 格式化返回值
+     */
+    private Object formatValue(BigDecimal value, String rawDataType) {
+        // TODO @AI：是不是可以用枚举？复用 IotModbusRawDataTypeEnum 里的；
+        switch (rawDataType.toUpperCase()) {
+            case "BOOLEAN":
+                return value.intValue() != 0;
+            case "INT16":
+            case "INT32":
+                return value.intValue();
+            case "UINT16":
+            case "UINT32":
+                return value.longValue();
+            case "FLOAT":
+                return value.floatValue();
+            case "DOUBLE":
+                return value.doubleValue();
+            // TODO @AI：未知抛出异常；
+            default:
+                return value;
+        }
+    }
+
+}
+package cn.iocoder.yudao.module.iot.gateway.protocol.modbustcp;
+
+import cn.iocoder.yudao.module.iot.core.biz.dto.IotModbusPointRespDTO;
+import com.ghgande.j2mod.modbus.io.ModbusTCPTransaction;
+import com.ghgande.j2mod.modbus.msg.*;
+import com.ghgande.j2mod.modbus.procimg.InputRegister;
+import com.ghgande.j2mod.modbus.procimg.Register;
+import com.ghgande.j2mod.modbus.procimg.SimpleRegister;
+import com.ghgande.j2mod.modbus.util.BitVector;
+import io.vertx.core.Future;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Component;
+
+/**
+ * IoT Modbus TCP 客户端
+ *
+ * 负责：
+ * 1. 封装 Modbus 读写操作
+ * 2. 根据功能码执行对应的 Modbus 请求
+ *
+ * @author 芋道源码
+ */
+// TODO @AI：希望它的初始化，在 configuration 里；
+@Component
+@RequiredArgsConstructor // TODO @AI：这个注解，是不是可以去掉？
+@Slf4j
+public class IotModbusTcpClient {
+
+    /**
+     * 读取 Modbus 数据
+     *
+     * @param connection Modbus 连接
+     * @param slaveId    从站地址
+     * @param point      点位配置
+     * @return 原始值（int 数组）
+     */
+    public Future<int[]> read(IotModbusTcpConnectionManager.ModbusConnection connection,
+                              Integer slaveId,
+                              IotModbusPointRespDTO point) {
+        return connection.executeBlocking(tcpConnection -> {
+            try {
+                // 1. 创建请求
+                ModbusRequest request = createReadRequest(point.getFunctionCode(),
+                        point.getRegisterAddress(), point.getRegisterCount());
+                request.setUnitID(slaveId);
+
+                // 2. 执行事务（请求）
+                ModbusTCPTransaction transaction = new ModbusTCPTransaction(tcpConnection);
+                transaction.setRequest(request);
+                transaction.execute();
+
+                // 3. 解析响应
+                ModbusResponse response = transaction.getResponse();
+                return extractValues(response, point.getFunctionCode());
+            } catch (Exception e) {
+                // TODO @AI：抛出异常时，增加更多的上下文信息，比如设备、点位等
+                throw new RuntimeException("Modbus 读取失败", e);
+            }
+        });
+    }
+
+    /**
+     * 写入 Modbus 数据
+     *
+     * @param connection Modbus 连接
+     * @param slaveId    从站地址
+     * @param point      点位配置
+     * @param values     要写入的值
+     * @return 是否成功
+     */
+    public Future<Boolean> write(IotModbusTcpConnectionManager.ModbusConnection connection,
+                                  Integer slaveId,
+                                  IotModbusPointRespDTO point,
+                                  int[] values) {
+        return connection.executeBlocking(tcpConnection -> {
+            try {
+                // 1. 创建请求
+                ModbusRequest request = createWriteRequest(point.getFunctionCode(),
+                        point.getRegisterAddress(), point.getRegisterCount(), values);
+                if (request == null) {
+                    throw new RuntimeException("功能码 " + point.getFunctionCode() + " 不支持写操作");
+                }
+                request.setUnitID(slaveId);
+
+                // 2. 执行事务（请求）
+                ModbusTCPTransaction transaction = new ModbusTCPTransaction(tcpConnection);
+                transaction.setRequest(request);
+                transaction.execute();
+                return true;
+            } catch (Exception e) {
+                // TODO @AI：抛出异常时，增加更多的上下文信息，比如设备、点位等；
+                throw new RuntimeException("Modbus 写入失败", e);
+            }
+        });
+    }
+
+    /**
+     * 创建读取请求
+     */
+    private ModbusRequest createReadRequest(Integer functionCode, Integer address, Integer count) {
+        // TODO @AI：1、2、3、4 能不能有枚举哈？这样 1、2、3、4 那的注释就不用写；
+        switch (functionCode) {
+            case 1: // ReadCoils
+                return new ReadCoilsRequest(address, count);
+            case 2: // ReadDiscreteInputs
+                return new ReadInputDiscretesRequest(address, count);
+            case 3: // ReadHoldingRegisters
+                return new ReadMultipleRegistersRequest(address, count);
+            case 4: // ReadInputRegisters
+                return new ReadInputRegistersRequest(address, count);
+            default:
+                throw new IllegalArgumentException("不支持的功能码: " + functionCode);
+        }
+    }
+
+    /**
+     * 创建写入请求
+     */
+    private ModbusRequest createWriteRequest(Integer functionCode, Integer address, Integer count, int[] values) {
+        // TODO @AI：5、6、15、16 能不能有枚举哈？这样 5、6、15、16 那的注释就不用写；
+        switch (functionCode) {
+            case 1: // WriteCoils (使用 5 或 15)
+                if (count == 1) {
+                    return new WriteCoilRequest(address, values[0] != 0);
+                } else {
+                    // 多线圈写入
+                    BitVector bv = new BitVector(count);
+                    for (int i = 0; i < Math.min(values.length, count); i++) {
+                        bv.setBit(i, values[i] != 0);
+                    }
+                    return new WriteMultipleCoilsRequest(address, bv);
+                }
+            case 3: // WriteHoldingRegisters (使用 6 或 16)
+                if (count == 1) {
+                    return new WriteSingleRegisterRequest(address, new SimpleRegister(values[0]));
+                } else {
+                    Register[] registers = new com.ghgande.j2mod.modbus.procimg.SimpleRegister[count];
+                    for (int i = 0; i < count; i++) {
+                        registers[i] = new SimpleRegister(i < values.length ? values[i] : 0);
+                    }
+                    return new WriteMultipleRegistersRequest(address, registers);
+                }
+            case 2: // ReadDiscreteInputs - 只读
+            case 4: // ReadInputRegisters - 只读
+                return null;
+            default:
+                throw new IllegalArgumentException("不支持的功能码: " + functionCode);
+        }
+    }
+
+    /**
+     * 从响应中提取值
+     */
+    private int[] extractValues(ModbusResponse response, Integer functionCode) {
+        // TODO @AI：1、2、3、4 能不能有枚举哈？这样 1、2、3、4 那的注释就不用写；
+        switch (functionCode) {
+            case 1: // ReadCoils
+                ReadCoilsResponse coilsResponse = (ReadCoilsResponse) response;
+                int bitCount = coilsResponse.getBitCount();
+                int[] coilValues = new int[bitCount];
+                for (int i = 0; i < bitCount; i++) {
+                    coilValues[i] = coilsResponse.getCoilStatus(i) ? 1 : 0;
+                }
+                return coilValues;
+            case 2: // ReadDiscreteInputs
+                ReadInputDiscretesResponse discretesResponse = (ReadInputDiscretesResponse) response;
+                int discreteCount = discretesResponse.getBitCount();
+                int[] discreteValues = new int[discreteCount];
+                for (int i = 0; i < discreteCount; i++) {
+                    discreteValues[i] = discretesResponse.getDiscreteStatus(i) ? 1 : 0;
+                }
+                return discreteValues;
+            case 3: // ReadHoldingRegisters
+                ReadMultipleRegistersResponse holdingResponse = (ReadMultipleRegistersResponse) response;
+                InputRegister[] holdingRegisters = holdingResponse.getRegisters();
+                int[] holdingValues = new int[holdingRegisters.length];
+                for (int i = 0; i < holdingRegisters.length; i++) {
+                    holdingValues[i] = holdingRegisters[i].getValue();
+                }
+                return holdingValues;
+            case 4: // ReadInputRegisters
+                ReadInputRegistersResponse inputResponse = (ReadInputRegistersResponse) response;
+                InputRegister[] inputRegisters = inputResponse.getRegisters();
+                int[] inputValues = new int[inputRegisters.length];
+                for (int i = 0; i < inputRegisters.length; i++) {
+                    inputValues[i] = inputRegisters[i].getValue();
+                }
+                return inputValues;
+            default:
+                throw new IllegalArgumentException("不支持的功能码: " + functionCode);
+        }
+    }
+
+}
+package cn.iocoder.yudao.module.iot.gateway.protocol.modbustcp;
+
+import cn.iocoder.yudao.framework.common.pojo.CommonResult;
+import cn.iocoder.yudao.module.iot.core.biz.IotDeviceCommonApi;
+import cn.iocoder.yudao.module.iot.core.biz.dto.IotModbusDeviceConfigRespDTO;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Consumer;
+
+// TODO @AI：是不是 1、2、3 注释可以合并下；
+/**
+ * IoT Modbus TCP 配置缓存服务
+ *
+ * 负责：
+ * 1. 从 biz 拉取 Modbus 设备配置
+ * 2. 缓存配置数据
+ * 3. 检测配置变更
+ *
+ * @author 芋道源码
+ */
+// TODO @AI：希望它的初始化，在 configuration 里；
+@Service
+@RequiredArgsConstructor
+@Slf4j
+public class IotModbusTcpConfigCacheService {
+
+    private final IotDeviceCommonApi deviceApi;
+
+    /**
+     * 配置缓存：deviceId -> 配置
+     */
+    private final Map<Long, IotModbusDeviceConfigRespDTO> configCache = new ConcurrentHashMap<>();
+
+    /**
+     * 已知的设备 ID 集合
+     */
+    private final Set<Long> knownDeviceIds = ConcurrentHashMap.newKeySet();
+
+    /**
+     * 刷新配置
+     *
+     * @return 最新的配置列表
+     */
+    public List<IotModbusDeviceConfigRespDTO> refreshConfig() {
+        try {
+            // 1. 从远程获取配置
+            CommonResult<List<IotModbusDeviceConfigRespDTO>> result = deviceApi.getEnabledModbusDeviceConfigs();
+            if (result == null || !result.isSuccess() || result.getData() == null) {
+                log.warn("[refreshConfig][获取 Modbus 配置失败: {}]", result);
+                return new ArrayList<>(configCache.values());
+            }
+            List<IotModbusDeviceConfigRespDTO> configs = result.getData();
+
+            // 2. 更新缓存
+            for (IotModbusDeviceConfigRespDTO config : configs) {
+                configCache.put(config.getDeviceId(), config);
+                knownDeviceIds.add(config.getDeviceId());
+            }
+            return configs;
+        } catch (Exception e) {
+            log.error("[refreshConfig][刷新配置失败]", e);
+            return new ArrayList<>(configCache.values());
+        }
+    }
+
+    /**
+     * 获取设备配置
+     *
+     * @param deviceId 设备 ID
+     * @return 配置
+     */
+    public IotModbusDeviceConfigRespDTO getConfig(Long deviceId) {
+        return configCache.get(deviceId);
+    }
+
+    /**
+     * 清理已删除设备的资源
+     *
+     * @param currentConfigs 当前有效的配置列表
+     * @param cleanupAction  清理动作
+     */
+    public void cleanupRemovedDevices(List<IotModbusDeviceConfigRespDTO> currentConfigs, Consumer<Long> cleanupAction) {
+        // 1.1 获取当前有效的设备 ID
+        // TODO @AI：convertSet 简化；
+        Set<Long> currentDeviceIds = new HashSet<>();
+        for (IotModbusDeviceConfigRespDTO config : currentConfigs) {
+            currentDeviceIds.add(config.getDeviceId());
+        }
+        // 1.2 找出已删除的设备
+        Set<Long> removedDeviceIds = new HashSet<>(knownDeviceIds);
+        removedDeviceIds.removeAll(currentDeviceIds);
+
+        // 2. 清理已删除设备
+        for (Long deviceId : removedDeviceIds) {
+            log.info("[cleanupRemovedDevices][清理已删除设备: {}]", deviceId);
+            configCache.remove(deviceId);
+            knownDeviceIds.remove(deviceId);
+            cleanupAction.accept(deviceId);
+        }
+    }
+
+}
+package cn.iocoder.yudao.module.iot.gateway.protocol.modbustcp;
+
+import cn.iocoder.yudao.module.iot.core.biz.dto.IotModbusDeviceConfigRespDTO;
+import com.ghgande.j2mod.modbus.net.TCPMasterConnection;
+import io.vertx.core.Context;
+import io.vertx.core.Future;
+import io.vertx.core.Vertx;
+import lombok.Data;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.redisson.api.RLock;
+import org.redisson.api.RedissonClient;
+import org.springframework.stereotype.Component;
+
+import java.net.InetAddress;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * IoT Modbus TCP 连接管理器
+ *
+ * 负责：
+ * 1. 管理 TCP 连接（相同 ip:port 共用连接）
+ * 2. 分布式锁管理（连接级别）
+ * 3. 连接重试和故障恢复
+ *
+ * @author 芋道源码
+ */
+// TODO @AI：希望它的初始化，在 configuration 里；
+@Component
+@RequiredArgsConstructor
+@Slf4j
+public class IotModbusTcpConnectionManager {
+
+    // TODO @AI：iot:modbus-tcp:connection:
+    private static final String LOCK_KEY_PREFIX = "iot:modbus:connection:";
+
+    private final RedissonClient redissonClient;
+    private final Vertx vertx;
+
+    /**
+     * 连接池：key = ip:port
+     */
+    private final Map<String, ModbusConnection> connectionPool = new ConcurrentHashMap<>();
+
+    /**
+     * 设备 ID 到连接 key 的映射
+     */
+    private final Map<Long, String> deviceConnectionMap = new ConcurrentHashMap<>();
+
+    /**
+     * 确保连接存在
+     *
+     * @param config 设备配置
+     */
+    public void ensureConnection(IotModbusDeviceConfigRespDTO config) {
+        // 1. 记录设备与连接的关系
+        String connectionKey = buildConnectionKey(config.getIp(), config.getPort());
+        deviceConnectionMap.put(config.getDeviceId(), connectionKey);
+
+        // 2. 情况一：连接已存在，添加设备引用
+        ModbusConnection connection = connectionPool.get(connectionKey);
+        if (connection != null) {
+            // 添加设备引用
+            connection.addDevice(config.getDeviceId(), config.getSlaveId());
+            // 更新连接参数（取最小值）
+            // TODO @AI：（不确定）如果后续最小值被移除后，是不是无法灰度到上一个最小值？
+            connection.updateParams(config.getTimeout(), config.getRetryInterval());
+            return;
+        }
+
+        // 3. 情况二：连接不存在，创建新连接
+        // 3.1 尝试获取分布式锁
+        RLock lock = redissonClient.getLock(LOCK_KEY_PREFIX + connectionKey);
+        if (!lock.tryLock()) {
+            log.debug("[ensureConnection][获取锁失败, 由其他节点负责: {}]", connectionKey);
+            return;
+        }
+        // 3.2 创建新连接
+        try {
+            connection = createConnection(config, lock);
+            connectionPool.put(connectionKey, connection);
+            log.info("[ensureConnection][创建 Modbus 连接成功: {}]", connectionKey);
+        } catch (Exception e) {
+            log.error("[ensureConnection][创建 Modbus 连接失败: {}]", connectionKey, e);
+            lock.unlock();
+        }
+    }
+
+    /**
+     * 创建 Modbus TCP 连接
+     */
+    private ModbusConnection createConnection(IotModbusDeviceConfigRespDTO config, RLock lock) throws Exception {
+        // 创建 TCP 连接
+        // TODO @AI：需要重连么？
+        TCPMasterConnection tcpConnection = new TCPMasterConnection(InetAddress.getByName(config.getIp()));
+        tcpConnection.setPort(config.getPort());
+        tcpConnection.setTimeout(config.getTimeout());
+        tcpConnection.connect();
+
+        // 创建 Modbus 连接对象
+        ModbusConnection connection = new ModbusConnection();
+        // TODO @AI：链式调用，简化下；
+        connection.setConnectionKey(buildConnectionKey(config.getIp(), config.getPort()));
+        connection.setTcpConnection(tcpConnection);
+        connection.setLock(lock);
+        connection.setTimeout(config.getTimeout());
+        connection.setRetryInterval(config.getRetryInterval());
+        connection.setContext(vertx.getOrCreateContext());
+        connection.addDevice(config.getDeviceId(), config.getSlaveId());
+        return connection;
+    }
+
+    /**
+     * 获取连接
+     */
+    public ModbusConnection getConnection(Long deviceId) {
+        String connectionKey = deviceConnectionMap.get(deviceId);
+        if (connectionKey == null) {
+            return null;
+        }
+        return connectionPool.get(connectionKey);
+    }
+
+    /**
+     * 获取设备的 slave ID
+     */
+    public Integer getSlaveId(Long deviceId) {
+        ModbusConnection connection = getConnection(deviceId);
+        if (connection == null) {
+            return null;
+        }
+        return connection.getSlaveId(deviceId);
+    }
+
+    /**
+     * 移除设备
+     */
+    public void removeDevice(Long deviceId) {
+        // 1. 移除设备引用
+        String connectionKey = deviceConnectionMap.remove(deviceId);
+        if (connectionKey == null) {
+            return;
+        }
+        ModbusConnection connection = connectionPool.get(connectionKey);
+        if (connection == null) {
+            return;
+        }
+        connection.removeDevice(deviceId);
+
+        // 2. 如果没有设备引用了，关闭连接
+        if (connection.getDeviceCount() == 0) {
+            closeConnection(connectionKey);
+        }
+    }
+
+    /**
+     * 关闭指定连接
+     */
+    private void closeConnection(String connectionKey) {
+        ModbusConnection connection = connectionPool.remove(connectionKey);
+        if (connection == null) {
+            return;
+        }
+
+        try {
+            if (connection.getTcpConnection() != null) {
+                connection.getTcpConnection().close();
+            }
+            // TODO @AI：（不确定）是不是要当前线程？还是当前进程就 ok 了。
+            if (connection.getLock() != null && connection.getLock().isHeldByCurrentThread()) {
+                connection.getLock().unlock();
+            }
+            log.info("[closeConnection][关闭 Modbus 连接: {}]", connectionKey);
+        } catch (Exception e) {
+            log.error("[closeConnection][关闭连接失败: {}]", connectionKey, e);
+        }
+    }
+
+    /**
+     * 关闭所有连接
+     */
+    public void closeAll() {
+        for (String connectionKey : connectionPool.keySet()) {
+            closeConnection(connectionKey);
+        }
+        deviceConnectionMap.clear();
+    }
+
+    private String buildConnectionKey(String ip, Integer port) {
+        return ip + ":" + port;
+    }
+
+    /**
+     * Modbus 连接信息
+     */
+    @Data
+    public static class ModbusConnection {
+
+        private String connectionKey;
+        private TCPMasterConnection tcpConnection;
+        private RLock lock;
+        private Integer timeout;
+        private Integer retryInterval;
+        private Context context;
+
+        /**
+         * 设备 ID 到 slave ID 的映射
+         */
+        private final Map<Long, Integer> deviceSlaveMap = new ConcurrentHashMap<>();
+
+        public void addDevice(Long deviceId, Integer slaveId) {
+            deviceSlaveMap.put(deviceId, slaveId);
+        }
+
+        public void removeDevice(Long deviceId) {
+            deviceSlaveMap.remove(deviceId);
+        }
+
+        public int getDeviceCount() {
+            return deviceSlaveMap.size();
+        }
+
+        public Integer getSlaveId(Long deviceId) {
+            return deviceSlaveMap.get(deviceId);
+        }
+
+        public void updateParams(Integer timeout, Integer retryInterval) {
+            // 取最小值
+            if (timeout != null && (this.timeout == null || timeout < this.timeout)) {
+                this.timeout = timeout;
+            }
+            if (retryInterval != null && (this.retryInterval == null || retryInterval < this.retryInterval)) {
+                this.retryInterval = retryInterval;
+            }
+        }
+
+        /**
+         * 执行 Modbus 读取操作（阻塞方式，在 Vert.x worker 线程执行）
+         */
+        public <T> Future<T> executeBlocking(java.util.function.Function<TCPMasterConnection, T> operation) {
+            // TODO @AI：executeBlocking 方法，已经废弃了，看看要不要替换。
+            // TODO @AI：疑问。这里会不会线程阻塞？多个设备之间，担心性能；
+            return context.executeBlocking(promise -> {
+                try {
+                    T result = operation.apply(tcpConnection);
+                    promise.complete(result);
+                } catch (Exception e) {
+                    promise.fail(e);
+                }
+            }, true); // ordered=true 保证同一连接串行执行
+        }
+    }
+
+}
+package cn.iocoder.yudao.module.iot.gateway.protocol.modbustcp;
+
+import cn.iocoder.yudao.module.iot.core.biz.dto.IotModbusDeviceConfigRespDTO;
+import cn.iocoder.yudao.module.iot.core.biz.dto.IotModbusPointRespDTO;
+import cn.iocoder.yudao.module.iot.core.mq.message.IotDeviceMessage;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Component;
+
+import java.util.Map;
+
+// TODO @AI：看看注释能不能优化下；
+/**
+ * IoT Modbus TCP 下行消息处理器
+ *
+ * 负责：
+ * 1. 处理属性设置消息（thing.service.property.set）
+ * 2. 将属性值转换为 Modbus 原始值
+ * 3. 执行 Modbus 写入操作
+ *
+ * @author 芋道源码
+ */
+// TODO @AI：希望它的初始化，在 configuration 里；
+@Component
+@RequiredArgsConstructor
+@Slf4j
+public class IotModbusTcpDownstreamHandler {
+
+    private final IotModbusTcpConnectionManager connectionManager;
+    private final IotModbusTcpClient modbusClient;
+    private final IotModbusDataConverter dataConverter;
+    private final IotModbusTcpConfigCacheService configCacheService;
+
+    /**
+     * 处理下行消息
+     */
+    @SuppressWarnings("unchecked")
+    public void handle(IotDeviceMessage message) {
+        // 1.1 检查是否是属性设置消息
+        if (!"thing.service.property.set".equals(message.getMethod())) {
+            log.debug("[handle][忽略非属性设置消息: {}]", message.getMethod());
+            return;
+        }
+        // 1.2 获取设备配置
+        IotModbusDeviceConfigRespDTO config = configCacheService.getConfig(message.getDeviceId());
+        if (config == null) {
+            log.warn("[handle][设备 {} 没有 Modbus 配置]", message.getDeviceId());
+            return;
+        }
+
+        // 2. 解析属性值并写入
+        Object params = message.getParams();
+        if (!(params instanceof Map)) {
+            log.warn("[handle][params 不是 Map 类型: {}]", params);
+            return;
+        }
+        Map<String, Object> propertyMap = (Map<String, Object>) params;
+        for (Map.Entry<String, Object> entry : propertyMap.entrySet()) {
+            String identifier = entry.getKey();
+            Object value = entry.getValue();
+            // 2.1.1 查找对应的点位配置
+            IotModbusPointRespDTO point = findPoint(config, identifier);
+            if (point == null) {
+                log.warn("[handle][设备 {} 没有点位配置: {}]", message.getDeviceId(), identifier);
+                continue;
+            }
+            // 2.1.2 检查是否支持写操作
+            if (!isWritable(point.getFunctionCode())) {
+                log.warn("[handle][点位 {} 不支持写操作, 功能码={}]", identifier, point.getFunctionCode());
+                continue;
+            }
+
+            // 2.2 执行写入
+            writeProperty(config, point, value);
+        }
+    }
+
+    /**
+     * 写入属性值
+     */
+    private void writeProperty(IotModbusDeviceConfigRespDTO config, IotModbusPointRespDTO point, Object value) {
+        // 1.1 获取连接
+        IotModbusTcpConnectionManager.ModbusConnection connection = connectionManager.getConnection(config.getDeviceId());
+        if (connection == null) {
+            log.warn("[writeProperty][设备 {} 没有连接]", config.getDeviceId());
+            return;
+        }
+        // 1.2 获取 slave ID
+        Integer slaveId = connectionManager.getSlaveId(config.getDeviceId());
+        if (slaveId == null) {
+            log.warn("[writeProperty][设备 {} 没有 slaveId]", config.getDeviceId());
+            return;
+        }
+
+        // 2.1 转换属性值为原始值
+        int[] rawValues = dataConverter.convertToRawValues(value, point);
+        // 2.2 执行 Modbus 写入
+        modbusClient.write(connection, slaveId, point, rawValues)
+                .onSuccess(success -> log.info("[writeProperty][写入成功, deviceId={}, identifier={}, value={}]",
+                        config.getDeviceId(), point.getIdentifier(), value))
+                .onFailure(e -> log.error("[writeProperty][写入失败, deviceId={}, identifier={}]",
+                        config.getDeviceId(), point.getIdentifier(), e));
+    }
+
+    /**
+     * 查找点位配置
+     */
+    private IotModbusPointRespDTO findPoint(IotModbusDeviceConfigRespDTO config, String identifier) {
+        if (config.getPoints() == null) {
+            return null;
+        }
+        // TODO @AI：hutool findOne？
+        return config.getPoints().stream()
+                .filter(p -> identifier.equals(p.getIdentifier()))
+                .findFirst()
+                .orElse(null);
+    }
+
+    /**
+     * 检查功能码是否支持写操作
+     */
+    private boolean isWritable(Integer functionCode) {
+        // TODO @AI：能不能通过 枚举优化下？
+        // 功能码 1（ReadCoils）和 3（ReadHoldingRegisters）支持写操作
+        return functionCode != null && (functionCode == 1 || functionCode == 3);
+    }
+
+}
+package cn.iocoder.yudao.module.iot.gateway.protocol.modbustcp;
+
+import cn.iocoder.yudao.module.iot.core.messagebus.core.IotMessageBus;
+import cn.iocoder.yudao.module.iot.core.messagebus.core.IotMessageSubscriber;
+import cn.iocoder.yudao.module.iot.core.mq.message.IotDeviceMessage;
+import cn.iocoder.yudao.module.iot.core.util.IotDeviceMessageUtils;
+import jakarta.annotation.PostConstruct;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+
+/**
+ * IoT Modbus TCP 下行消息订阅器
+ *
+ * 负责：
+ * 1. 订阅消息总线的下行消息
+ * 2. 将属性设置消息转发给下行处理器
+ *
+ * @author 芋道源码
+ */
+// TODO @AI：希望它的初始化，在 configuration 里；
+@RequiredArgsConstructor
+@Slf4j
+public class IotModbusTcpDownstreamSubscriber implements IotMessageSubscriber<IotDeviceMessage> {
+
+    private final IotModbusTcpUpstreamProtocol upstreamProtocol;
+    private final IotModbusTcpDownstreamHandler downstreamHandler;
+    private final IotMessageBus messageBus;
+
+    @PostConstruct
+    public void subscribe() {
+        messageBus.register(this);
+        log.info("[subscribe][Modbus TCP 下行消息订阅器已启动, topic={}]", getTopic());
+    }
+
+    @Override
+    public String getTopic() {
+        return IotDeviceMessageUtils.buildMessageBusGatewayDeviceMessageTopic(upstreamProtocol.getServerId());
+    }
+
+    @Override
+    public String getGroup() {
+        return getTopic(); // 点对点消费
+    }
+
+    @Override
+    public void onMessage(IotDeviceMessage message) {
+        log.debug("[onMessage][收到下行消息: {}]", message);
+        try {
+            downstreamHandler.handle(message);
+        } catch (Exception e) {
+            log.error("[onMessage][处理下行消息失败]", e);
+        }
+    }
+
+}
+package cn.iocoder.yudao.module.iot.gateway.protocol.modbustcp;
+
+import cn.iocoder.yudao.module.iot.core.biz.dto.IotModbusDeviceConfigRespDTO;
+import cn.iocoder.yudao.module.iot.core.biz.dto.IotModbusPointRespDTO;
+import io.vertx.core.Vertx;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Component;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * IoT Modbus TCP 轮询调度器
+ *
+ * 负责：
+ * 1. 管理每个点位的轮询定时器
+ * 2. 调度 Modbus 读取任务
+ * 3. 处理读取结果并上报
+ *
+ * @author 芋道源码
+ */
+// TODO @AI：希望它的初始化，在 configuration 里；
+@Component
+@RequiredArgsConstructor
+@Slf4j
+public class IotModbusTcpPollScheduler {
+
+    private final Vertx vertx;
+    private final IotModbusTcpConnectionManager connectionManager;
+    private final IotModbusTcpClient modbusClient;
+    private final IotModbusTcpUpstreamHandler upstreamHandler;
+
+    /**
+     * 设备的定时器列表：deviceId -> timerId 列表
+     */
+    private final Map<Long, List<Long>> deviceTimers = new ConcurrentHashMap<>();
+
+    /**
+     * 更新轮询任务
+     */
+    public void updatePolling(IotModbusDeviceConfigRespDTO config) {
+        Long deviceId = config.getDeviceId();
+
+        // 1. 停止旧的轮询任务
+        stopPolling(deviceId);
+
+        // 2.1 为每个点位创建新的轮询任务
+        List<Long> timerIds = new ArrayList<>();
+        // TODO @AI：if return 简化；上面的 size 加下；config.getPoints()
+        if (config.getPoints() != null) {
+            for (IotModbusPointRespDTO point : config.getPoints()) {
+                Long timerId = createPollTimer(config, point);
+                if (timerId != null) {
+                    timerIds.add(timerId);
+                }
+            }
+        }
+        // 2.2 记录定时器
+        // TODO @AI：CollUtil.isNotEmpty；if return 简化；
+        if (!timerIds.isEmpty()) {
+            deviceTimers.put(deviceId, timerIds);
+            log.debug("[updatePolling][设备 {} 创建了 {} 个轮询定时器]", deviceId, timerIds.size());
+        }
+    }
+
+    /**
+     * 创建轮询定时器
+     */
+    private Long createPollTimer(IotModbusDeviceConfigRespDTO config, IotModbusPointRespDTO point) {
+        if (point.getPollInterval() == null || point.getPollInterval() <= 0) {
+            return null;
+        }
+        return vertx.setPeriodic(point.getPollInterval(), timerId -> {
+            try {
+                pollPoint(config, point);
+            } catch (Exception e) {
+                log.error("[createPollTimer][轮询点位失败, deviceId={}, identifier={}]",
+                        config.getDeviceId(), point.getIdentifier(), e);
+            }
+        });
+    }
+
+    /**
+     * 轮询单个点位
+     */
+    private void pollPoint(IotModbusDeviceConfigRespDTO config, IotModbusPointRespDTO point) {
+        // 1.1 获取连接
+        IotModbusTcpConnectionManager.ModbusConnection connection = connectionManager.getConnection(config.getDeviceId());
+        if (connection == null) {
+            log.warn("[pollPoint][设备 {} 没有连接]", config.getDeviceId());
+            return;
+        }
+        // 1.2 获取 slave ID
+        Integer slaveId = connectionManager.getSlaveId(config.getDeviceId());
+        if (slaveId == null) {
+            log.warn("[pollPoint][设备 {} 没有 slaveId]", config.getDeviceId());
+            return;
+        }
+
+        // 2. 执行 Modbus 读取
+        // TODO @AI：超时时间，有实现么？？？
+        modbusClient.read(connection, slaveId, point)
+                .onSuccess(rawValue -> upstreamHandler.handleReadResult(config, point, rawValue))
+                .onFailure(e -> log.error("[pollPoint][读取点位失败, deviceId={}, identifier={}]",
+                        config.getDeviceId(), point.getIdentifier(), e));
+    }
+
+    /**
+     * 停止设备的轮询
+     */
+    public void stopPolling(Long deviceId) {
+        List<Long> timerIds = deviceTimers.remove(deviceId);
+        // TODO @AI：CollUtil.isNotEmpty；并且 if return；
+        if (timerIds != null) {
+            for (Long timerId : timerIds) {
+                vertx.cancelTimer(timerId);
+            }
+            log.debug("[stopPolling][设备 {} 停止了 {} 个轮询定时器]", deviceId, timerIds.size());
+        }
+    }
+
+    /**
+     * 停止所有轮询
+     */
+    public void stopAll() {
+        for (Long deviceId : deviceTimers.keySet()) {
+            stopPolling(deviceId);
+        }
+    }
+
+}
+package cn.iocoder.yudao.module.iot.gateway.protocol.modbustcp;
+
+import cn.iocoder.yudao.module.iot.core.biz.dto.IotModbusDeviceConfigRespDTO;
+import cn.iocoder.yudao.module.iot.core.biz.dto.IotModbusPointRespDTO;
+import cn.iocoder.yudao.module.iot.core.mq.message.IotDeviceMessage;
+import cn.iocoder.yudao.module.iot.gateway.service.device.message.IotDeviceMessageService;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Component;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * IoT Modbus TCP 上行数据处理器
+ *
+ * 负责：
+ * 1. 将 Modbus 读取的原始值转换为物模型属性值
+ * 2. 构造属性上报消息
+ * 3. 发送消息到消息总线
+ *
+ * @author 芋道源码
+ */
+// TODO @AI：希望它的初始化，在 configuration 里；
+@Component
+@Slf4j
+public class IotModbusTcpUpstreamHandler {
+
+    private final IotDeviceMessageService messageService;
+    private final IotModbusDataConverter dataConverter;
+
+    private String serverId;
+
+    public IotModbusTcpUpstreamHandler(IotDeviceMessageService messageService,
+                                        IotModbusDataConverter dataConverter) {
+        this.messageService = messageService;
+        this.dataConverter = dataConverter;
+    }
+
+    // TODO @AI：lombok 简化
+    /**
+     * 设置 serverId
+     *
+     * @param serverId 服务器 ID
+     */
+    public void setServerId(String serverId) {
+        this.serverId = serverId;
+    }
+
+    /**
+     * 处理 Modbus 读取结果
+     *
+     * @param config   设备配置
+     * @param point    点位配置
+     * @param rawValue 原始值（int 数组）
+     */
+    public void handleReadResult(IotModbusDeviceConfigRespDTO config,
+                                  IotModbusPointRespDTO point,
+                                  int[] rawValue) {
+        try {
+            // 1.1 转换原始值为物模型属性值
+            Object convertedValue = dataConverter.convertToPropertyValue(rawValue, point);
+            log.debug("[handleReadResult][设备={}, 属性={}, 原始值={}, 转换值={}]",
+                    config.getDeviceId(), point.getIdentifier(), rawValue, convertedValue);
+            // 1.2 构造属性上报消息
+            Map<String, Object> params = new HashMap<>();
+            params.put(point.getIdentifier(), convertedValue);
+            IotDeviceMessage message = IotDeviceMessage.requestOf("thing.event.property.post", params);
+
+            // 2. 发送到消息总线
+            messageService.sendDeviceMessage(message, config.getProductKey(),
+                    config.getDeviceName(), serverId);
+        } catch (Exception e) {
+            log.error("[handleReadResult][处理读取结果失败, deviceId={}, identifier={}]",
+                    config.getDeviceId(), point.getIdentifier(), e);
+        }
+    }
+
+}
+package cn.iocoder.yudao.module.iot.gateway.protocol.modbustcp;
+
+import cn.iocoder.yudao.module.iot.core.biz.dto.IotModbusDeviceConfigRespDTO;
+import cn.iocoder.yudao.module.iot.gateway.config.IotGatewayProperties;
+import cn.iocoder.yudao.module.iot.gateway.service.device.message.IotDeviceMessageService;
+import io.vertx.core.Vertx;
+import jakarta.annotation.PostConstruct;
+import jakarta.annotation.PreDestroy;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+
+import java.util.List;
+import java.util.UUID;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * IoT Modbus TCP 上行协议
+ *
+ * 负责：
+ * 1. 定时从 biz 拉取 Modbus 设备配置
+ * 2. 管理 Modbus TCP 连接
+ * 3. 调度轮询任务
+ * 4. 处理采集数据上报
+ *
+ * @author 芋道源码
+ */
+// TODO @AI：希望它的初始化，在 configuration 里；
+@RequiredArgsConstructor
+@Slf4j
+public class IotModbusTcpUpstreamProtocol {
+
+    private final IotGatewayProperties.ModbusTcpProperties modbusTcpProperties;
+    private final IotDeviceMessageService messageService;
+    private final IotModbusTcpConnectionManager connectionManager;
+    private final IotModbusTcpPollScheduler pollScheduler;
+    private final IotModbusTcpConfigCacheService configCacheService;
+    private final IotModbusTcpUpstreamHandler upstreamHandler;
+    private final Vertx vertx;
+
+    // TODO @AI：按照别的模块，生成 serverId；
+    /**
+     * 服务器 ID，用于标识当前网关实例
+     */
+    private final String serverId = UUID.randomUUID().toString();
+
+    /**
+     * 配置刷新定时器 ID
+     */
+    private Long configRefreshTimerId;
+
+    @PostConstruct
+    public void start() {
+        log.info("[start][Modbus TCP 协议启动, serverId={}]", serverId);
+
+        // 0. 设置 serverId 到上行处理器
+        upstreamHandler.setServerId(serverId);
+
+        // 1. 首次加载配置
+        refreshConfig();
+
+        // 2. 启动配置定时刷新
+        int refreshInterval = modbusTcpProperties.getConfigRefreshInterval();
+        configRefreshTimerId = vertx.setPeriodic(
+                TimeUnit.SECONDS.toMillis(refreshInterval),
+                id -> refreshConfig()
+        );
+        log.info("[start][配置刷新定时器已启动, 间隔={}秒]", refreshInterval);
+    }
+
+    @PreDestroy
+    public void stop() {
+        log.info("[stop][Modbus TCP 协议停止]");
+
+        // 1. 取消配置刷新定时器
+        if (configRefreshTimerId != null) {
+            vertx.cancelTimer(configRefreshTimerId);
+        }
+
+        // 2. 停止轮询调度器
+        pollScheduler.stopAll();
+
+        // 3. 关闭所有连接
+        connectionManager.closeAll();
+    }
+
+    /**
+     * 刷新配置
+     */
+    private void refreshConfig() {
+        try {
+            // 1. 从 biz 拉取最新配置
+            List<IotModbusDeviceConfigRespDTO> configs = configCacheService.refreshConfig();
+            log.debug("[refreshConfig][获取到 {} 个 Modbus 设备配置]", configs.size());
+
+            // 2. 更新连接和轮询任务
+            for (IotModbusDeviceConfigRespDTO config : configs) {
+                try {
+                    // 2.1 确保连接存在
+                    connectionManager.ensureConnection(config);
+                    // 2.2 更新轮询任务
+                    // TODO @AI：【重要】如果点位配置没变化，是不是不用 update？
+                    pollScheduler.updatePolling(config);
+                } catch (Exception e) {
+                    log.error("[refreshConfig][处理设备配置失败, deviceId={}]", config.getDeviceId(), e);
+                }
+            }
+
+            // 3. 清理已删除设备的资源
+            configCacheService.cleanupRemovedDevices(configs, deviceId -> {
+                pollScheduler.stopPolling(deviceId);
+                connectionManager.removeDevice(deviceId);
+            });
+        } catch (Exception e) {
+            log.error("[refreshConfig][刷新配置失败]", e);
+        }
+    }
+
+    // TODO @AI：是不是 lombok 简化
+    public String getServerId() {
+        return serverId;
+    }
+
+    // TODO @AI：不需要；可以删除；
+    public IotDeviceMessageService getMessageService() {
+        return messageService;
+    }
+
+}
@@ -6,6 +6,7 @@ import cn.iocoder.yudao.module.iot.core.biz.IotDeviceCommonApi;
 import cn.iocoder.yudao.module.iot.core.biz.dto.IotDeviceAuthReqDTO;
 import cn.iocoder.yudao.module.iot.core.biz.dto.IotDeviceGetReqDTO;
 import cn.iocoder.yudao.module.iot.core.biz.dto.IotDeviceRespDTO;
+import cn.iocoder.yudao.module.iot.core.biz.dto.IotModbusDeviceConfigRespDTO;
 import cn.iocoder.yudao.module.iot.gateway.config.IotGatewayProperties;
 import jakarta.annotation.PostConstruct;
 import jakarta.annotation.Resource;
@@ -18,6 +19,8 @@ import org.springframework.http.ResponseEntity;
 import org.springframework.stereotype.Service;
 import org.springframework.web.client.RestTemplate;
+import java.util.List;
+
 import static cn.iocoder.yudao.framework.common.exception.enums.GlobalErrorCodeConstants.INTERNAL_SERVER_ERROR;
 /**
@@ -33,6 +36,7 @@ public class IotDeviceApiImpl implements IotDeviceCommonApi {
     private IotGatewayProperties gatewayProperties;
     private RestTemplate restTemplate;
+    private RestTemplate modbusRestTemplate;
     @PostConstruct
     public void init() {
@@ -42,24 +46,35 @@ public class IotDeviceApiImpl implements IotDeviceCommonApi {
                 .readTimeout(rpc.getReadTimeout())
                 .connectTimeout(rpc.getConnectTimeout())
                 .build();
+        // TODO @AI：继续复用 rpc.getConnectTimeout()；不需要独立 modbusRestTemplate
+        modbusRestTemplate = new RestTemplateBuilder()
+                .rootUri(rpc.getUrl() + "/rpc-api/iot/modbus")
+                .readTimeout(rpc.getReadTimeout())
+                .connectTimeout(rpc.getConnectTimeout())
+                .build();
     }
     @Override
     public CommonResult<Boolean> authDevice(IotDeviceAuthReqDTO authReqDTO) {
-        return doPost("/auth", authReqDTO, new ParameterizedTypeReference<>() { });
+        return doPost(restTemplate, "/auth", authReqDTO, new ParameterizedTypeReference<>() { });
     }
     @Override
     public CommonResult<IotDeviceRespDTO> getDevice(IotDeviceGetReqDTO getReqDTO) {
-        return doPost("/get", getReqDTO, new ParameterizedTypeReference<>() { });
+        return doPost(restTemplate, "/get", getReqDTO, new ParameterizedTypeReference<>() { });
+    }
+
+    @Override
+    public CommonResult<List<IotModbusDeviceConfigRespDTO>> getEnabledModbusDeviceConfigs() {
+        return doPost(modbusRestTemplate, "/enabled-configs", null, new ParameterizedTypeReference<>() { });
     }
-    private <T, R> CommonResult<R> doPost(String url, T body,
+    private <T, R> CommonResult<R> doPost(RestTemplate template, String url, T body,
                                           ParameterizedTypeReference<CommonResult<R>> responseType) {
         try {
             // 请求
             HttpEntity<T> requestEntity = new HttpEntity<>(body);
-            ResponseEntity<CommonResult<R>> response = restTemplate.exchange(
+            ResponseEntity<CommonResult<R>> response = template.exchange(
                     url, HttpMethod.POST, requestEntity, responseType);
             // 响应
             CommonResult<R> result = response.getBody();
@@ -117,6 +117,9 @@ yudao:
           keep-alive-timeout-seconds: 300      # 保持连接超时时间（秒）
           ssl-enabled: false                   # 是否启用 SSL（wss://）
           sub-protocol: mqtt                   # WebSocket 子协议
+        # TODO @AI：modbus-tcp 组件配置待补充
+        modbus-tcp:
+          enabled: true
 --- #################### 日志相关配置 ####################