Merge branch 'feat/object-model' into 'main_dev'

feat：支持标准modbus_rtu解析

See merge request yunteng/thingskit-front!1209

@@ -29,6 +29,7 @@
     "SNMP",
     "SNMP",
     "TSLV",
     "TSLV",
     "UNACK",
     "UNACK",
+    "UNINT",
     "unref",
     "unref",
     "vben",
     "vben",
     "videojs",
     "videojs",
@@ -36,5 +37,5 @@
     "vnode",
     "vnode",
     "vueuse",
     "vueuse",
     "windicss"
     "windicss"
-  ]
+  ],
 }
 }

-import { DataType } from '../../device/model/modelOfMatterModel';
-import { DataTypeEnum } from '/@/enums/objectModelEnum';
+import { RpcCommandType } from '../../device/model/deviceConfigModel';
+import { DataType, ExtensionDesc } from '../../device/model/modelOfMatterModel';
+import { DataTypeEnum, ObjectModelAccessModeEnum } from '/@/enums/objectModelEnum';
 import { DataSource } from '/@/views/visual/palette/types';
 import { DataSource } from '/@/views/visual/palette/types';
 
 
 export interface AddDataBoardParams {
 export interface AddDataBoardParams {
@@ -154,12 +155,14 @@ export interface DeviceAttributeParams {
 export interface DeviceAttributeRecord {
 export interface DeviceAttributeRecord {
   name: string;
   name: string;
   identifier: string;
   identifier: string;
+  accessMode: ObjectModelAccessModeEnum;
   detail: { dataType: DataType };
   detail: { dataType: DataType };
+  extensionDesc?: ExtensionDesc;
 }
 }
 
 
 export interface SendCommandParams {
 export interface SendCommandParams {
   deviceId: string;
   deviceId: string;
-  value: any;
+  value: RpcCommandType;
 }
 }
 
 
 export interface GetMeetTheConditionsDeviceParams {
 export interface GetMeetTheConditionsDeviceParams {

+import { ProfileData } from './deviceModel';
 import { BasicPageParams } from '/@/api/model/baseModel';
 import { BasicPageParams } from '/@/api/model/baseModel';
 import { CommandTypeEnum, RPCCommandMethodEnum } from '/@/enums/deviceEnum';
 import { CommandTypeEnum, RPCCommandMethodEnum } from '/@/enums/deviceEnum';
 
 
@@ -103,13 +104,6 @@ export interface ProvisionConfiguration {
   provisionDeviceSecret?: any;
   provisionDeviceSecret?: any;
 }
 }
 
 
-export interface ProfileData {
-  configuration: Configuration;
-  transportConfiguration: TransportConfiguration;
-  provisionConfiguration: ProvisionConfiguration;
-  alarms: any;
-}
-
 export interface ProfileRecord {
 export interface ProfileRecord {
   id: string;
   id: string;
   creator: string;
   creator: string;
@@ -168,22 +162,7 @@ export interface DeviceProfileDetail {
   type: string;
   type: string;
   deviceCount: number;
   deviceCount: number;
   default: boolean;
   default: boolean;
-}
-
-export interface ProfileData {
-  configuration: Configuration;
-  transportConfiguration: TransportConfiguration;
-  provisionConfiguration: ProvisionConfiguration;
-  alarms: any;
-  thingsModel: any;
-}
-
-export interface Configuration {
-  type: string;
-}
-
-export interface TransportConfiguration {
-  type: string;
+  ifShowClass?: boolean;
 }
 }
 
 
 export interface RpcCommandType {
 export interface RpcCommandType {

-import { StructJSON } from './modelOfMatterModel';
+import { DataType, ExtensionDesc, ModelOfMatterParams } from './modelOfMatterModel';
 import { BasicPageParams } from '/@/api/model/baseModel';
 import { BasicPageParams } from '/@/api/model/baseModel';
 import { AlarmStatus } from '/@/enums/alarmEnum';
 import { AlarmStatus } from '/@/enums/alarmEnum';
+import { TCPProtocolTypeEnum } from '/@/enums/deviceEnum';
 import { DeviceStatusEnum } from '/@/views/rule/dataFlow/cpns/config';
 import { DeviceStatusEnum } from '/@/views/rule/dataFlow/cpns/config';
 export enum DeviceState {
 export enum DeviceState {
   INACTIVE = 'INACTIVE',
   INACTIVE = 'INACTIVE',
@@ -60,6 +61,7 @@ export interface DeviceProfileModel {
   transportType: string;
   transportType: string;
   createTime: string;
   createTime: string;
   description: string;
   description: string;
+  profileData: ProfileData;
 }
 }
 
 
 export type ChildDeviceParams = BasicPageParams & {
 export type ChildDeviceParams = BasicPageParams & {
@@ -148,6 +150,7 @@ export interface TransportConfiguration {
 
 
   // TCP
   // TCP
   scriptId: string;
   scriptId: string;
+  protocol?: TCPProtocolTypeEnum;
 }
 }
 
 
 export interface ProvisionConfiguration {
 export interface ProvisionConfiguration {
@@ -160,6 +163,7 @@ export interface ProfileData {
   transportConfiguration: TransportConfiguration;
   transportConfiguration: TransportConfiguration;
   provisionConfiguration: ProvisionConfiguration;
   provisionConfiguration: ProvisionConfiguration;
   alarms?: any;
   alarms?: any;
+  thingsModel?: ModelOfMatterParams[];
 }
 }
 
 
 export interface DeviceRecord {
 export interface DeviceRecord {
@@ -176,7 +180,6 @@ export interface DeviceRecord {
   deviceCount: number;
   deviceCount: number;
   tbDeviceId: string;
   tbDeviceId: string;
   tbProfileId: string;
   tbProfileId: string;
-  profileData: ProfileData;
   defaultQueueName: string;
   defaultQueueName: string;
   image: string;
   image: string;
   type: string;
   type: string;
@@ -192,6 +195,7 @@ export interface DeviceRecord {
     default: boolean;
     default: boolean;
     name: string;
     name: string;
     transportType: string;
     transportType: string;
+    profileData: ProfileData;
   };
   };
   customerAdditionalInfo?: {
   customerAdditionalInfo?: {
     isPublic?: boolean;
     isPublic?: boolean;
@@ -203,9 +207,10 @@ export interface DeviceModelOfMatterAttrs {
   name: string;
   name: string;
   identifier: string;
   identifier: string;
   accessMode: string;
   accessMode: string;
-  detail: StructJSON;
-  deviceDetail?: DeviceRecord;
-  extensionDesc?: any;
+  detail: {
+    dataType: DataType;
+  };
+  extensionDesc?: ExtensionDesc;
 }
 }
 
 
 export interface DeviceStateLogModel {
 export interface DeviceStateLogModel {

-import { DataTypeEnum } from '/@/enums/objectModelEnum';
+import {
+  DataTypeEnum,
+  ExtendDescOperationTypeEnum,
+  OriginalDataTypeEnum,
+} from '/@/enums/objectModelEnum';
 import { FunctionTypeEnum } from '/@/enums/objectModelEnum';
 import { FunctionTypeEnum } from '/@/enums/objectModelEnum';
 
 
 export interface Specs {
 export interface Specs {
@@ -27,10 +31,14 @@ export interface DataType {
 }
 }
 
 
 export interface ExtensionDesc {
 export interface ExtensionDesc {
-  zoomFactor?: number;
-  actionType?: string;
-  dataType: string;
-  registerAddress: number;
+  writeOnly?: boolean;
+  bitMask?: number;
+  operationType: ExtendDescOperationTypeEnum;
+  originalDataType: OriginalDataTypeEnum;
+  registerAddress: string;
+  scaling?: number;
+  valueRange?: Record<'min' | 'max', number>;
+  registerCount?: number;
 }
 }
 
 
 export interface StructJSON {
 export interface StructJSON {
@@ -64,7 +72,7 @@ export interface ModelOfMatterParams {
 }
 }
 
 
 export interface GetModelTslParams {
 export interface GetModelTslParams {
-  functionType: FunctionTypeEnum;
+  functionType?: FunctionTypeEnum;
   deviceProfileId: string;
   deviceProfileId: string;
   ifShowClass?: string | Boolean;
   ifShowClass?: string | Boolean;
 }
 }
@@ -108,7 +116,7 @@ export interface Tsl {
   specs?: {
   specs?: {
     dataType: DataType;
     dataType: DataType;
   };
   };
-  extensionDesc: ExtensionDesc;
+  extensionDesc?: ExtensionDesc;
   eventType?: string;
   eventType?: string;
   outputData?: StructJSON[];
   outputData?: StructJSON[];
   callType?: string;
   callType?: string;

@@ -5,6 +5,7 @@ import {
   ImportModelOfMatterType,
   ImportModelOfMatterType,
   ModelOfMatterItemRecordType,
   ModelOfMatterItemRecordType,
   ModelOfMatterParams,
   ModelOfMatterParams,
+  Tsl,
 } from './model/modelOfMatterModel';
 } from './model/modelOfMatterModel';
 import { FunctionTypeEnum } from '/@/enums/objectModelEnum';
 import { FunctionTypeEnum } from '/@/enums/objectModelEnum';
 import { defHttp } from '/@/utils/http/axios';
 import { defHttp } from '/@/utils/http/axios';
@@ -26,7 +27,7 @@ enum ModelOfMatter {
   CATEGORY_EXPORT = '/things_model/categoryGetExport',
   CATEGORY_EXPORT = '/things_model/categoryGetExport',
 
 
   IMPORT_CSV = '/things_model/csvImport',
   IMPORT_CSV = '/things_model/csvImport',
-  EXCEL_EXPORT = '/things_model/downloadTemplate',
+  EXCEL_EXPORT = '/things_model/download/template',
 
 
   BATCH_GET_TSL_BY_DEVICE_PROFILES = '/things_model/batch/get_tsl',
   BATCH_GET_TSL_BY_DEVICE_PROFILES = '/things_model/batch/get_tsl',
 }
 }
@@ -47,8 +48,8 @@ export const getModelList = (
 };
 };
 
 
 export const getModelTsl = (params: GetModelTslParams) => {
 export const getModelTsl = (params: GetModelTslParams) => {
-  const { functionType, deviceProfileId } = params;
-  return defHttp.get({
+  const { functionType = 'all', deviceProfileId } = params;
+  return defHttp.get<Tsl[]>({
     url: `${ModelOfMatter.TSL}/${functionType}/${deviceProfileId}`,
     url: `${ModelOfMatter.TSL}/${functionType}/${deviceProfileId}`,
   });
   });
 };
 };
@@ -149,11 +150,12 @@ export const importCsvCategory = (params: {
   categoryId?: string;
   categoryId?: string;
   deviceProfileId?: string;
   deviceProfileId?: string;
   file: FormData;
   file: FormData;
+  type?: string;
 }) => {
 }) => {
-  const { categoryId } = params || {};
+  const { categoryId, type } = params || {};
 
 
   return defHttp.post<any>({
   return defHttp.post<any>({
-    url: `${ModelOfMatter.IMPORT_CSV}?categoryId=${categoryId}`,
+    url: `${ModelOfMatter.IMPORT_CSV}?categoryId=${categoryId}&type=${type}`,
     params: params.file,
     params: params.file,
   });
   });
 };
 };
@@ -166,11 +168,12 @@ export const importCsvDeviceProfileId = (params: {
   categoryId?: string;
   categoryId?: string;
   deviceProfileId?: string;
   deviceProfileId?: string;
   file: FormData;
   file: FormData;
+  type?: string;
 }) => {
 }) => {
-  const { deviceProfileId } = params || {};
+  const { deviceProfileId, type } = params || {};
 
 
   return defHttp.post<any>({
   return defHttp.post<any>({
-    url: `${ModelOfMatter.IMPORT_CSV}?deviceProfileId=${deviceProfileId}`,
+    url: `${ModelOfMatter.IMPORT_CSV}?deviceProfileId=${deviceProfileId}&type=${type}`,
     params: params.file,
     params: params.file,
   });
   });
 };
 };
@@ -178,9 +181,10 @@ export const importCsvDeviceProfileId = (params: {
 /**
 /**
  * 物模型excel导出模板
  * 物模型excel导出模板
  */
  */
-export const excelExport = () => {
+export const excelExport = (type?: string) => {
   return defHttp.get({
   return defHttp.get({
     url: `${ModelOfMatter.EXCEL_EXPORT}`,
     url: `${ModelOfMatter.EXCEL_EXPORT}`,
+    params: { type },
     responseType: 'blob',
     responseType: 'blob',
   });
   });
 };
 };

@@ -62,6 +62,7 @@ export interface GenModbusCommandType {
   registerAddress: number;
   registerAddress: number;
   registerNumber?: number;
   registerNumber?: number;
   registerValues?: number[];
   registerValues?: number[];
+  hexByteOrderEnum?: string;
 }
 }
 
 
 export interface ImmediateExecuteTaskType {
 export interface ImmediateExecuteTaskType {

@@ -2,6 +2,7 @@
   <div class="flex">
   <div class="flex">
     <InputNumber
     <InputNumber
       placeholder="最小值"
       placeholder="最小值"
+      v-bind="minInputProps"
       :disabled="$props.disabled"
       :disabled="$props.disabled"
       :value="getValue.min!"
       :value="getValue.min!"
       @change="(value) => emitChange(value, 'min')"
       @change="(value) => emitChange(value, 'min')"
@@ -9,6 +10,7 @@
     <div class="text-center flex-shrink-0 w-6">~</div>
     <div class="text-center flex-shrink-0 w-6">~</div>
     <InputNumber
     <InputNumber
       placeholder="最大值"
       placeholder="最大值"
+      v-bind="maxInputProps"
       :disabled="$props.disabled"
       :disabled="$props.disabled"
       :value="getValue.max!"
       :value="getValue.max!"
       @change="(value) => emitChange(value, 'max')"
       @change="(value) => emitChange(value, 'max')"
@@ -22,7 +24,7 @@
 </script>
 </script>
 <script lang="ts" setup>
 <script lang="ts" setup>
   import { computed } from 'vue';
   import { computed } from 'vue';
-  import { InputNumber } from 'ant-design-vue';
+  import { InputNumber, InputNumberProps } from 'ant-design-vue';
 
 
   const emit = defineEmits(['change', 'update:value']);
   const emit = defineEmits(['change', 'update:value']);
   const props = withDefaults(
   const props = withDefaults(
@@ -32,8 +34,12 @@
         max: Nullable<number>;
         max: Nullable<number>;
       };
       };
       disabled: boolean;
       disabled: boolean;
+      maxInputProps?: InputNumberProps;
+      minInputProps?: InputNumberProps;
     }>(),
     }>(),
     {
     {
+      maxInputProps: () => ({}),
+      minInputProps: () => ({}),
       value: () => ({ min: null, max: null }),
       value: () => ({ min: null, max: null }),
     }
     }
   );
   );

@@ -128,6 +128,7 @@ export type ComponentType =
   | 'ProductPicker'
   | 'ProductPicker'
   | 'PollCommandInput'
   | 'PollCommandInput'
   | 'RegisterAddressInput'
   | 'RegisterAddressInput'
+  | 'HexInput'
   | 'ControlGroup'
   | 'ControlGroup'
   | 'JSONEditor'
   | 'JSONEditor'
   | 'OrgTreeSelect'
   | 'OrgTreeSelect'

@@ -48,3 +48,13 @@ export enum CommandTypeNameEnum {
 export enum RPCCommandMethodEnum {
 export enum RPCCommandMethodEnum {
   THINGSKIT = 'methodThingskit',
   THINGSKIT = 'methodThingskit',
 }
 }
+
+export enum TCPProtocolTypeEnum {
+  CUSTOM = 'CUSTOM',
+  MODBUS_RTU = 'MODBUS_RTU',
+}
+
+export enum TCPProtocolTypeNameEnum {
+  CUSTOM = '自定义',
+  MODBUS_RTU = 'MODBUS_RTU',
+}

@@ -31,31 +31,95 @@ export enum ObjectEventTypeNameEnum {
   ERROR = '故障',
   ERROR = '故障',
 }
 }
 
 
-export enum RegisterDataTypeEnum {
-  UN_SHORT = 'unshort',
+export enum ObjectModelAccessModeEnum {
+  READ = 'r',
+  READ_AND_WRITE = 'rw',
 }
 }
 
 
-export enum RegisterDataTypeNameEnum {
-  UN_SHORT = '16位有符号',
+export enum ModbusCRCEnum {
+  CRC_16_LOWER = 'CRC_16_LOWER',
 }
 }
 
 
-export enum RegisterActionTypeEnum {
-  BOOL = '05',
-  INT = '06',
-  DOUBLE = '16',
+export enum BuiltInIdentifierEnum {
+  SOURCE = 'source',
 }
 }
 
 
-export enum RegisterActionTypeNameEnum {
-  BOOL = '05写入单个线圈寄存器',
-  INT = '06写入单个保持寄存器',
-  DOUBLE = '16写入多个保持寄存器',
+export enum ModbusMethodEnum {
+  WRITE_10 = '10',
 }
 }
 
 
-export enum ObjectModelAccessModeEnum {
-  READ = 'r',
-  READ_AND_WRITE = 'rw',
+export enum OriginalDataTypeEnum {
+  INT16_AB = 'INT16_AB',
+  INT16_BA = 'INT16_BA',
+  UINT16_AB = 'UINT16_AB',
+  UINT16_BA = 'UINT16_BA',
+  INT32_AB_CD = 'INT32_AB_CD',
+  INT32_CD_AB = 'INT32_CD_AB',
+  INT32_BA_DC = 'INT32_BA_DC',
+  INT32_DC_BA = 'INT32_DC_BA',
+  UINT32_AB_CD = 'UINT32_AB_CD',
+  UINT32_CD_AB = 'UINT32_CD_AB',
+  UINT32_BA_DC = 'UINT32_BA_DC',
+  UINT32_DC_BA = 'UINT32_DC_BA',
+  FLOAT_AB_CD = 'FLOAT_AB_CD',
+  FLOAT_CD_AB = 'FLOAT_CD_AB',
+  FLOAT_BA_DC = 'FLOAT_BA_DC',
+  FLOAT_DC_BA = 'FLOAT_DC_BA',
+  DOUBLE = 'DOUBLE',
+  STRING = 'STRING',
+  BOOLEAN = 'BOOLEAN',
+  BITS = 'BITS',
 }
 }
 
 
-export enum ModbusCRCEnum {
-  CRC_16_LOWER = 'CRC_16_LOWER',
+export enum OriginalDataTypeNameEnum {
+  INT16_AB = '16位有符号整数AB',
+  INT16_BA = '16位有符号整数BA',
+  UINT16_AB = '16位无符号整数AB',
+  UINT16_BA = '16位无符号整数BA',
+  INT32_AB_CD = '32位有符号整数AB_CD',
+  INT32_CD_AB = '32位有符号整数CD_AB',
+  INT32_BA_DC = '32位有符号整数BA_DC',
+  INT32_DC_BA = '32位有符号整数DC_BA',
+  UINT32_AB_CD = '32位无符号整数AB_CD',
+  UINT32_CD_AB = '32位无符号整数CD_AB',
+  UINT32_BA_DC = '32位无符号整数BA_DC',
+  UINT32_DC_BA = '32位无符号整数DC_BA',
+  FLOAT_AB_CD = '单精度浮点型AB_CD',
+  FLOAT_CD_AB = '单精度浮点型CD_AB',
+  FLOAT_BA_DC = '单精度浮点型BA_DC',
+  FLOAT_DC_BA = '单精度浮点型DC_BA',
+  DOUBLE = '双精度浮点型',
+  STRING = '字符串',
+  BOOLEAN = '布尔型',
+  BITS = '位',
+}
+
+export enum ExtendDescOperationTypeEnum {
+  INPUT_STATUS_R_02 = 'inputStatus_r_02',
+  COIL_STATUS_R_01 = 'coilStatus_r_01',
+  COIL_STATUS_RW_01_05 = 'coilStatus_rw_01_05',
+  COIL_STATUS_RW_01_0F = 'coilStatus_rw_01_0F',
+  COIL_STATUS_W_05 = 'coilStatus_w_05',
+  COIL_STATUS_W_0F = 'coilStatus_w_0F',
+  HOLDING_REGISTER_R_03 = 'holdingRegister_r_03',
+  HOLDING_REGISTER_RW_03_06 = 'holdingRegister_rw_03_06',
+  HOLDING_REGISTER_RW_03_10 = 'holdingRegister_rw_03_10',
+  HOLDING_REGISTER_W_06 = 'holdingRegister_w_06',
+  HOLDING_REGISTER_W_10 = 'holdingRegister_w_10',
+  INPUT_REGISTER_R_04 = 'inputRegister_r_04',
+}
+
+export enum ExtendDescOperationTypeNameEnum {
+  INPUT_STATUS_R_02 = '离散量输入(只读,0x02)',
+  COIL_STATUS_R_01 = '线圈状态(只读,0x01)',
+  COIL_STATUS_RW_01_05 = '线圈状态(读写,读取使用0x01,写入使用0x05)',
+  COIL_STATUS_RW_01_0F = '线圈状态(读写,读取使用0x01,写入使用0x0F)',
+  COIL_STATUS_W_05 = '线圈状态(只写,0x05)',
+  COIL_STATUS_W_0F = '线圈状态(只写,0x0F)',
+  HOLDING_REGISTER_R_03 = '保持寄存器(只读,0x03)',
+  HOLDING_REGISTER_RW_03_06 = '保持寄存器(读写,读取使用0x03,写入使用0x06)',
+  HOLDING_REGISTER_RW_03_10 = '保持寄存器(读写,读取使用0x03,写入使用0x10)',
+  HOLDING_REGISTER_W_06 = '保持寄存器(只写,0x06)',
+  HOLDING_REGISTER_W_10 = '保持寄存器(只写,0x10)',
+  INPUT_REGISTER_R_04 = '输入寄存器(只读,0x04)',
 }
 }

+import { useParseOriginalDataType } from './useParseOriginalDataType';
+import { OriginalDataTypeEnum } from '/@/enums/objectModelEnum';
+
+export function useBaseConversion() {
+  function DecTo32Float(number: number) {
+    const arr = new Uint8Array(4);
+    const view = new DataView(arr.buffer);
+    view.setFloat32(0, +number);
+    return arr;
+  }
+
+  function DecTo64Double(number: number) {
+    const arr = new Uint8Array(8);
+    const view = new DataView(arr.buffer);
+    view.setFloat64(0, +number);
+    return arr;
+  }
+
+  function arrToBase(toBase: number, arr: Uint8Array) {
+    let result = '';
+    for (let i = 0; i < arr.length; i++) {
+      result += (256 + arr[i]).toString(toBase).substring(1).toUpperCase();
+    }
+
+    return result;
+  }
+
+  function DecTo16Uint(number: number) {
+    const arr = new Uint8Array(2);
+    const view = new DataView(arr.buffer);
+    view.setUint16(0, +number);
+    return arr;
+  }
+
+  function DecTo16Int(number: number) {
+    const arr = new Uint8Array(2);
+    const view = new DataView(arr.buffer);
+    view.setInt16(0, +number);
+    return arr;
+  }
+
+  function DecTo32Uint(number: number) {
+    const arr = new Uint8Array(4);
+    const view = new DataView(arr.buffer);
+    view.setUint32(0, +number);
+    return arr;
+  }
+
+  function DecTo32Int(number: number) {
+    const arr = new Uint8Array(4);
+    const view = new DataView(arr.buffer);
+    view.setInt32(0, +number);
+    return arr;
+  }
+
+  function DecToBinaryByType(type: OriginalDataTypeEnum, number: number) {
+    switch (type) {
+      case OriginalDataTypeEnum.INT16_AB:
+      case OriginalDataTypeEnum.INT16_BA:
+        return arrToBase(2, DecTo16Int(number));
+
+      case OriginalDataTypeEnum.UINT16_AB:
+      case OriginalDataTypeEnum.UINT16_BA:
+        return arrToBase(2, DecTo16Uint(number));
+
+      case OriginalDataTypeEnum.INT32_AB_CD:
+      case OriginalDataTypeEnum.INT32_CD_AB:
+      case OriginalDataTypeEnum.INT32_BA_DC:
+      case OriginalDataTypeEnum.INT32_DC_BA:
+        return arrToBase(2, DecTo32Int(number));
+
+      case OriginalDataTypeEnum.UINT32_AB_CD:
+      case OriginalDataTypeEnum.UINT32_CD_AB:
+      case OriginalDataTypeEnum.UINT32_BA_DC:
+      case OriginalDataTypeEnum.UINT32_DC_BA:
+        return arrToBase(2, DecTo32Uint(number));
+
+      case OriginalDataTypeEnum.FLOAT_AB_CD:
+      case OriginalDataTypeEnum.FLOAT_CD_AB:
+      case OriginalDataTypeEnum.FLOAT_BA_DC:
+      case OriginalDataTypeEnum.FLOAT_DC_BA:
+        return arrToBase(2, DecTo32Float(number));
+
+      case OriginalDataTypeEnum.DOUBLE:
+        return arrToBase(2, DecTo64Double(number));
+    }
+  }
+
+  function SplitStringToGroupByItemLength(
+    value: string,
+    itemLength = 8,
+    ignoreLessThan = false
+  ): string[] {
+    const reg = new RegExp(`.{${ignoreLessThan ? '' : '1,'}${itemLength}}`, 'g');
+    return value.match(reg) || [];
+  }
+
+  function ExchangeByteOrder(binary: string, order: string) {
+    const group = SplitStringToGroupByItemLength(binary);
+
+    const BASE_ORDER = {
+      A: 0,
+      B: 1,
+      C: 2,
+      D: 3,
+    };
+
+    const array: string[] = Array.from({ length: binary.length / 8 });
+
+    order
+      .split('')
+      .forEach((bytePosition, index) => (array[index] = group[BASE_ORDER[bytePosition]]));
+
+    return array.join('');
+  }
+
+  function ByteToHex(binary: string) {
+    const group = SplitStringToGroupByItemLength(binary, 16);
+    return group.map((byte) => parseInt(byte, 2).toString(16));
+  }
+
+  function ByteToDec(binary: string) {
+    const group = SplitStringToGroupByItemLength(binary, 16);
+    return group.map((byte) => parseInt(byte, 2));
+  }
+
+  function StringToHEXBuffer(string: string | number) {
+    return string
+      .toString()
+      .split('')
+      .map((string) => string.charCodeAt(0).toString(16))
+      .reverse();
+  }
+
+  function getRegisterValueByOriginalDataType(
+    value: number,
+    type: OriginalDataTypeEnum,
+    additional?: { bitMask?: number; registerNumber?: number }
+  ) {
+    const { exchangeSortFlag } = useParseOriginalDataType(type);
+    // eslint-disable-next-line no-console
+    console.groupCollapsed('Modbus Debug');
+    // eslint-disable-next-line no-console
+    console.table({ input: value, sort: exchangeSortFlag, type });
+
+    let result: number[];
+
+    if (type === OriginalDataTypeEnum.BOOLEAN) {
+      result = [value];
+    } else if (type === OriginalDataTypeEnum.STRING) {
+      let buffer = StringToHEXBuffer(value);
+      const { registerNumber = 0 } = additional || {};
+
+      if (buffer.length < registerNumber * 2) {
+        buffer = [
+          ...Array.from({ length: registerNumber * 2 - buffer.length }, () => '00'),
+          ...buffer,
+        ];
+      }
+
+      result = SplitStringToGroupByItemLength(buffer.join(''), 4).map((hex) => parseInt(hex, 16));
+    } else {
+      let binary = DecToBinaryByType(type, value)!;
+      // eslint-disable-next-line no-console
+      console.table({ beforeExchange: binary });
+
+      if (exchangeSortFlag) binary = ExchangeByteOrder(binary, exchangeSortFlag);
+      result = ByteToDec(binary);
+
+      // eslint-disable-next-line no-console
+      console.table({
+        afterEchange: binary,
+        dec: result.toString(),
+        hex: ByteToHex(binary).toString(),
+      });
+    }
+
+    // eslint-disable-next-line no-console
+    console.groupEnd();
+
+    return result;
+  }
+
+  return {
+    DecToBinaryByType,
+    ByteToDec,
+    ByteToHex,
+    ExchangeByteOrder,
+    SplitStringToGroupByItemLength,
+    getRegisterValueByOriginalDataType,
+    StringToHEXBuffer,
+  };
+}

+import { ref } from 'vue';
+import { useCoverModbusCommand } from './useCoverModbusCommand';
+import { commandIssuanceApi, getDeviceDetail } from '/@/api/device/deviceManager';
+import { RpcCommandType } from '/@/api/device/model/deviceConfigModel';
+import { DeviceProfileModel, DeviceRecord } from '/@/api/device/model/deviceModel';
+import { Tsl } from '/@/api/device/model/modelOfMatterModel';
+import { getModelTsl } from '/@/api/device/modelOfMatter';
+import {
+  CommandDeliveryWayEnum,
+  CommandTypeEnum,
+  RPCCommandMethodEnum,
+  ServiceCallTypeEnum,
+  TCPProtocolTypeEnum,
+  TransportTypeEnum,
+} from '/@/enums/deviceEnum';
+import { FunctionTypeEnum } from '/@/enums/objectModelEnum';
+import { isFunction } from '/@/utils/is';
+import { getDeviceActiveTime } from '/@/api/alarm/position';
+import { useMessage } from '../web/useMessage';
+
+interface SetupType {
+  entityId: string;
+  transportType: TransportTypeEnum;
+  isTCPModbus: boolean;
+  deviceCode: string | undefined;
+  deviceDetail: DeviceRecord;
+  objectModel: Tsl | undefined;
+  identifier: string;
+}
+
+interface DoCommandDeliverParamsType {
+  value: any;
+  deviceDetail?: DeviceRecord;
+  deviceId?: string;
+  identifier?: string;
+  objectModel?: Tsl;
+  deviceProfileId?: string;
+  deviceProfileDetail?: DeviceProfileModel;
+  way?: CommandDeliveryWayEnum;
+  cmdType?: CommandTypeEnum;
+  transportType?: TransportTypeEnum;
+  beforeFetch?: (
+    rpcCommand: RpcCommandType,
+    setup: SetupType
+  ) =>
+    | { rpcCommand: RpcCommandType; way?: CommandDeliveryWayEnum }
+    | Promise<{ rpcCommand: RpcCommandType; way?: CommandDeliveryWayEnum }>;
+}
+
+export function useCommandDelivery() {
+  const loading = ref(false);
+  async function doSetup(params: DoCommandDeliverParamsType) {
+    let { deviceDetail, identifier, deviceProfileId, objectModel, transportType } = params;
+    const { deviceId, deviceProfileDetail } = params;
+
+    const entityId = deviceId || deviceDetail?.tbDeviceId;
+    if (!entityId) {
+      throw new Error('not found entityId');
+    }
+
+    identifier = identifier || objectModel?.identifier;
+
+    if (!identifier) {
+      throw new Error('not found identifier');
+    }
+
+    transportType = transportType || (deviceDetail?.transportType as TransportTypeEnum);
+
+    if (
+      !transportType ||
+      (transportType === TransportTypeEnum.TCP && !deviceDetail) ||
+      !deviceDetail?.deviceProfile
+    ) {
+      deviceDetail = await getDeviceDetail(entityId);
+      transportType = deviceDetail.transportType as TransportTypeEnum;
+    }
+
+    const isTCPModbus =
+      transportType === TransportTypeEnum.TCP &&
+      deviceDetail?.deviceProfile?.profileData?.transportConfiguration?.protocol ===
+        TCPProtocolTypeEnum.MODBUS_RTU;
+
+    if (isTCPModbus && !objectModel?.extensionDesc) {
+      deviceProfileId = deviceDetail.deviceProfileId || deviceProfileId || deviceProfileDetail?.id;
+      if (!deviceProfileId) {
+        throw new Error('not found deviceProfile');
+      }
+
+      const objectModels = await getModelTsl({ deviceProfileId });
+      objectModel = objectModels.find((item) => item.identifier === identifier);
+    }
+
+    const deviceCode = deviceDetail.code;
+
+    return {
+      entityId,
+      transportType,
+      isTCPModbus,
+      deviceCode,
+      deviceDetail,
+      objectModel,
+      identifier,
+    };
+  }
+
+  async function doCommandDelivery(params: DoCommandDeliverParamsType) {
+    try {
+      loading.value = true;
+
+      const setupResult = await doSetup(params);
+
+      const { entityId, transportType, isTCPModbus, deviceCode, objectModel, identifier } =
+        setupResult;
+
+      let command = params.value;
+
+      if (transportType === TransportTypeEnum.TCP) {
+        command = params.value;
+        if (isTCPModbus) {
+          const { doCoverCommand } = useCoverModbusCommand();
+          command = await doCoverCommand(params.value, objectModel!, deviceCode, entityId);
+        }
+      } else {
+        command = {
+          [identifier]: command,
+        };
+      }
+
+      let rpcCommand: RpcCommandType = {
+        persistent: true,
+        method: RPCCommandMethodEnum.THINGSKIT,
+        additionalInfo: {
+          cmdType: params.cmdType ?? CommandTypeEnum.API,
+        },
+        params: command,
+      };
+
+      let way = params.way ?? CommandDeliveryWayEnum.ONE_WAY;
+
+      if (objectModel?.functionType === FunctionTypeEnum.SERVICE) {
+        rpcCommand.additionalInfo.cmdType = CommandTypeEnum.SERVICE;
+        way =
+          objectModel.callType === ServiceCallTypeEnum.ASYNC
+            ? CommandDeliveryWayEnum.ONE_WAY
+            : CommandDeliveryWayEnum.TWO_WAY;
+      }
+
+      const sendApi = commandIssuanceApi;
+
+      if (params.beforeFetch && isFunction(params.beforeFetch)) {
+        const { rpcCommand: _rpcCommand, way: _way } = await params.beforeFetch(
+          rpcCommand,
+          setupResult
+        );
+        rpcCommand = _rpcCommand;
+        if (_way) way = _way;
+      }
+
+      if (way === CommandDeliveryWayEnum.TWO_WAY) {
+        const result = await getDeviceActiveTime(entityId);
+        const [firsetItem] = result || [];
+
+        if (!firsetItem.value) {
+          const { createMessage } = useMessage();
+          const message = '当前设备不在线';
+          createMessage.warning(message);
+          throw Error(message);
+        }
+      }
+      await sendApi(way, entityId, rpcCommand);
+    } finally {
+      loading.value = false;
+    }
+  }
+
+  return {
+    loading,
+    doCommandDelivery,
+  };
+}

+import { useParseOriginalDataType } from './useParseOriginalDataType';
+import { getDeviceHistoryInfo } from '/@/api/alarm/position';
+import { getDeviceDetail } from '/@/api/device/deviceManager';
+import { ExtensionDesc, Specs, Tsl } from '/@/api/device/model/modelOfMatterModel';
+import { genModbusCommand } from '/@/api/task';
+import { GenModbusCommandType } from '/@/api/task/model';
+import { ModbusCRCEnum, OriginalDataTypeEnum } from '/@/enums/objectModelEnum';
+import { useBaseConversion } from '/@/hooks/business/useBaseConversion';
+import { useMessage } from '/@/hooks/web/useMessage';
+import { isNullOrUnDef } from '/@/utils/is';
+import {
+  isFloatType,
+  isNumberType,
+  useParseOperationType,
+} from '/@/views/device/profiles/components/ObjectModelForm/ExtendDesc/useParseOperationType';
+
+const getFloatPart = (number: string | number) => {
+  const isLessZero = Number(number) < 0;
+  number = number.toString();
+  const floatPartStartIndex = number.indexOf('.');
+  const value = ~floatPartStartIndex
+    ? `${isLessZero ? '-' : ''}0.${number.substring(floatPartStartIndex + 1)}`
+    : '0';
+  return Number(value);
+};
+
+function getValueFromValueRange(value: number, valueRange?: Record<'min' | 'max', number>) {
+  const { min, max } = valueRange || {};
+  if (!isNullOrUnDef(min) && value < min) return min;
+  if (!isNullOrUnDef(max) && value > max) return max;
+  return value;
+}
+
+async function getCurrentBitCommand(entityId: string, objectModel: Tsl, value: number) {
+  const deviceDetail = await getDeviceDetail(entityId);
+  const thingsModels = deviceDetail.deviceProfile.profileData.thingsModel;
+
+  const { registerAddress } = objectModel.extensionDesc || {};
+
+  const bitsModel = thingsModels?.filter(
+    (item) =>
+      item.extensionDesc?.originalDataType === OriginalDataTypeEnum.BITS &&
+      item.extensionDesc.registerAddress === registerAddress
+  );
+
+  const valuePositionMap =
+    bitsModel?.reduce((prev, next) => {
+      return { ...prev, [next.identifier]: next.extensionDesc?.bitMask };
+    }, {} as Record<string, number>) || {};
+
+  const attrKeys = Object.keys(valuePositionMap);
+
+  const latestBitsValues = await getDeviceHistoryInfo({ entityId, keys: attrKeys.join(',') });
+
+  const binaryArr = Array.from({ length: 16 }, () => 0);
+
+  for (const key of attrKeys) {
+    const index = valuePositionMap[key];
+
+    if (!isNullOrUnDef(index)) {
+      const [latest] = latestBitsValues[key];
+      const { value } = latest;
+      binaryArr[index] = Number(value);
+    }
+  }
+
+  if (objectModel.extensionDesc?.bitMask) {
+    binaryArr[objectModel.extensionDesc.bitMask] = value;
+  }
+
+  return [parseInt(binaryArr.reverse().join(''), 2)];
+}
+
+export function useCoverModbusCommand() {
+  const { createMessage } = useMessage();
+
+  const doCoverCommand = async (
+    value: number,
+    objectModel: Tsl,
+    deviceAddressCode?: string,
+    entityId?: string
+  ) => {
+    if (!deviceAddressCode) {
+      const message = '当前设备未绑定设备地址码';
+      createMessage.warning(message);
+      throw new Error(message);
+    }
+
+    const {
+      registerAddress,
+      operationType,
+      scaling,
+      originalDataType,
+      bitMask,
+      registerCount: registerNumber,
+    } = objectModel.extensionDesc as Required<ExtensionDesc>;
+
+    const { writeRegisterAddress } = useParseOperationType(operationType);
+    const { unsigned, exchangeSortFlag, registerCount } =
+      useParseOriginalDataType(originalDataType);
+
+    const params: GenModbusCommandType = {
+      crc: ModbusCRCEnum.CRC_16_LOWER,
+      registerNumber: registerCount || registerNumber,
+      deviceCode: deviceAddressCode,
+      registerAddress: parseInt(registerAddress, 16),
+      method: writeRegisterAddress!,
+      registerValues: [value],
+    };
+
+    if (exchangeSortFlag) params.hexByteOrderEnum = exchangeSortFlag;
+
+    const { getRegisterValueByOriginalDataType } = useBaseConversion();
+
+    if (isNumberType(originalDataType)) {
+      let newValue = Math.trunc(value) * scaling + getFloatPart(value) * scaling;
+
+      newValue = unsigned ? newValue : Math.abs(newValue);
+
+      newValue = getValueFromValueRange(
+        newValue,
+        (objectModel.specs?.dataType.specs as Specs).valueRange
+      );
+
+      if (!isFloatType(originalDataType) && newValue % 1 !== 0) {
+        const message = `属性下发类型必须是整数,缩放因子为${scaling}`;
+        createMessage.warning(message);
+        throw Error(message);
+      }
+
+      value = newValue;
+    }
+
+    params.registerValues =
+      originalDataType === OriginalDataTypeEnum.BITS
+        ? await getCurrentBitCommand(entityId!, objectModel, value)
+        : getRegisterValueByOriginalDataType(value, originalDataType, {
+            bitMask,
+            registerNumber,
+          });
+
+    if (!params.method) {
+      const message = '物模型操作类型无法进行写入';
+      createMessage.warning(message);
+      throw Error(message);
+    }
+
+    return await genModbusCommand(params);
+  };
+
+  return {
+    doCoverCommand,
+  };
+}

+import { OriginalDataTypeEnum } from '/@/enums/objectModelEnum';
+
+export type OriginalDataTypePrefixType<S = `${OriginalDataTypeEnum}`> = S extends string
+  ? S extends `${infer D}_${string}`
+    ? D
+    : S
+  : '';
+
+function getRegisterCount(originalDataType: OriginalDataTypeEnum) {
+  switch (originalDataType) {
+    case OriginalDataTypeEnum.INT16_AB:
+    case OriginalDataTypeEnum.INT16_BA:
+    case OriginalDataTypeEnum.UINT16_AB:
+    case OriginalDataTypeEnum.UINT16_BA:
+    case OriginalDataTypeEnum.BITS:
+    case OriginalDataTypeEnum.BOOLEAN:
+      return 1;
+
+    case OriginalDataTypeEnum.INT32_AB_CD:
+    case OriginalDataTypeEnum.INT32_BA_DC:
+    case OriginalDataTypeEnum.INT32_CD_AB:
+    case OriginalDataTypeEnum.INT32_DC_BA:
+    case OriginalDataTypeEnum.UINT32_AB_CD:
+    case OriginalDataTypeEnum.UINT32_BA_DC:
+    case OriginalDataTypeEnum.UINT32_CD_AB:
+    case OriginalDataTypeEnum.UINT32_DC_BA:
+      return 2;
+
+    case OriginalDataTypeEnum.FLOAT_AB_CD:
+    case OriginalDataTypeEnum.FLOAT_BA_DC:
+    case OriginalDataTypeEnum.FLOAT_CD_AB:
+    case OriginalDataTypeEnum.FLOAT_DC_BA:
+      return 2;
+
+    case OriginalDataTypeEnum.DOUBLE:
+      return 4;
+  }
+}
+
+export function useParseOriginalDataType(originalDataType: OriginalDataTypeEnum) {
+  const signedMatchRef = /^UN/;
+
+  const splitArray = originalDataType.split('_') as [OriginalDataTypePrefixType];
+
+  const [dataType] = splitArray;
+
+  const exchangeSortFlag = splitArray.slice(1).join('_');
+
+  return {
+    registerCount: getRegisterCount(originalDataType),
+    unsigned: !signedMatchRef.test(originalDataType),
+    dataType,
+    exchangeSortFlag: exchangeSortFlag || null,
+  };
+}

@@ -5,17 +5,19 @@ import { JSONEditor } from '/@/components/CodeEditor';
 import { DeviceRecord, DeviceTypeEnum } from '/@/api/device/model/deviceModel';
 import { DeviceRecord, DeviceTypeEnum } from '/@/api/device/model/deviceModel';
 import { h } from 'vue';
 import { h } from 'vue';
 import { TaskTypeEnum } from '/@/views/task/center/config';
 import { TaskTypeEnum } from '/@/views/task/center/config';
-import { AddressTypeEnum } from '/@/views/task/center/components/PollCommandInput';
 import { FileItem } from '/@/components/Form/src/components/ApiUpload.vue';
 import { FileItem } from '/@/components/Form/src/components/ApiUpload.vue';
 import { createImgPreview } from '/@/components/Preview';
 import { createImgPreview } from '/@/components/Preview';
 import { uploadThumbnail } from '/@/api/configuration/center/configurationCenter';
 import { uploadThumbnail } from '/@/api/configuration/center/configurationCenter';
 import LockControlGroup from '/@/components/Form/src/components/LockControlGroup.vue';
 import LockControlGroup from '/@/components/Form/src/components/LockControlGroup.vue';
 import { OrgTreeSelect } from '/@/views/common/OrgTreeSelect';
 import { OrgTreeSelect } from '/@/views/common/OrgTreeSelect';
-import { TransportTypeEnum } from '/@/enums/deviceEnum';
+import { TCPProtocolTypeEnum, TransportTypeEnum } from '/@/enums/deviceEnum';
+import { HexInput, InputTypeEnum } from '../../profiles/components/ObjectModelForm/HexInput';
+import { DeviceProfileDetail } from '/@/api/device/model/deviceConfigModel';
 
 
 useComponentRegister('JSONEditor', JSONEditor);
 useComponentRegister('JSONEditor', JSONEditor);
 useComponentRegister('LockControlGroup', LockControlGroup);
 useComponentRegister('LockControlGroup', LockControlGroup);
 useComponentRegister('OrgTreeSelect', OrgTreeSelect);
 useComponentRegister('OrgTreeSelect', OrgTreeSelect);
+useComponentRegister('HexInput', HexInput);
 
 
 export enum TypeEnum {
 export enum TypeEnum {
   IS_GATEWAY = 'GATEWAY',
   IS_GATEWAY = 'GATEWAY',
@@ -108,6 +110,12 @@ export const step1Schemas: FormSchema[] = [
     show: false,
     show: false,
   },
   },
   {
   {
+    field: 'tcpDeviceProtocol',
+    label: 'TCP设备协议类型',
+    component: 'Input',
+    show: false,
+  },
+  {
     field: 'profileId',
     field: 'profileId',
     label: '所属产品',
     label: '所属产品',
     required: true,
     required: true,
@@ -127,30 +135,35 @@ export const step1Schemas: FormSchema[] = [
             const options = await queryDeviceProfileBy({
             const options = await queryDeviceProfileBy({
               deviceType: formModel?.isUpdate ? formModel?.deviceType : null,
               deviceType: formModel?.isUpdate ? formModel?.deviceType : null,
             });
             });
-            const { profileId } = formModel;
-            if (profileId) {
-              const selectRecord = options.find((item) => item.tbProfileId === profileId);
-              selectRecord && setFieldsValue({ transportType: selectRecord!.transportType });
-            }
+
             return options;
             return options;
           },
           },
           labelField: 'name',
           labelField: 'name',
           valueField: 'tbProfileId',
           valueField: 'tbProfileId',
-          onChange(
-            _value: string,
-            option: { deviceType: string; transportType: string; id: string }
-          ) {
+          onChange(_value: string, option: DeviceProfileDetail) {
             const { deviceType, transportType, id } = option;
             const { deviceType, transportType, id } = option;
             setFieldsValue({
             setFieldsValue({
               deviceType: deviceType,
               deviceType: deviceType,
               transportType,
               transportType,
               deviceProfileId: id,
               deviceProfileId: id,
               gatewayId: null,
               gatewayId: null,
-              codeType: transportType === TransportTypeEnum.TCP ? TaskTypeEnum.MODBUS_RTU : null,
               code: null,
               code: null,
               addressCode: null,
               addressCode: null,
+              tcpDeviceProtocol: option?.profileData?.transportConfiguration?.protocol,
             });
             });
           },
           },
+          onOptionsChange(options: (DeviceProfileDetail & Record<'value', string>)[]) {
+            const { profileId } = formModel;
+            if (profileId) {
+              const selectRecord = options.find((item) => item.value === profileId);
+
+              selectRecord &&
+                setFieldsValue({
+                  transportType: selectRecord!.transportType,
+                  tcpDeviceProtocol: selectRecord?.profileData?.transportConfiguration?.protocol,
+                });
+            }
+          },
           showSearch: true,
           showSearch: true,
           placeholder: '请选择产品',
           placeholder: '请选择产品',
           filterOption: (inputValue: string, option: Record<'label' | 'value', string>) =>
           filterOption: (inputValue: string, option: Record<'label' | 'value', string>) =>
@@ -177,35 +190,6 @@ export const step1Schemas: FormSchema[] = [
     },
     },
   },
   },
   {
   {
-    field: 'codeType',
-    label: '标识符类型',
-    component: 'RadioGroup',
-    dynamicRules({ values }) {
-      return [
-        {
-          required: values?.transportType === TransportTypeEnum.TCP,
-          message: '请输入设备标识符',
-        },
-      ];
-    },
-    // ifShow: ({ values }) =>
-    //   values?.transportType === TransportTypeEnum.TCP &&
-    //   (values.deviceType === DeviceTypeEnum.SENSOR || values.deviceType === DeviceTypeEnum.GATEWAY),
-    ifShow: ({ values }) => values?.transportType === TransportTypeEnum.TCP,
-    componentProps: ({ formActionType }) => {
-      const { setFieldsValue } = formActionType;
-      return {
-        options: [
-          { label: '自定义', value: TaskTypeEnum.CUSTOM },
-          { label: 'ModBus', value: TaskTypeEnum.MODBUS_RTU },
-        ],
-        onChange() {
-          setFieldsValue({ addressCode: null });
-        },
-      };
-    },
-  },
-  {
     field: 'addressCode',
     field: 'addressCode',
     label: '地址码',
     label: '地址码',
     dynamicRules({ values }) {
     dynamicRules({ values }) {
@@ -213,32 +197,25 @@ export const step1Schemas: FormSchema[] = [
         {
         {
           required:
           required:
             values?.transportType === TransportTypeEnum.TCP &&
             values?.transportType === TransportTypeEnum.TCP &&
-            values?.deviceType === DeviceTypeEnum.SENSOR,
-          message: '请输入设备地址码',
+            values?.tcpDeviceProtocol === TCPProtocolTypeEnum.MODBUS_RTU,
+          message: '地址码范围为00~FF',
+          pattern: /^[0-9A-Fa-f]{2}$/,
         },
         },
       ];
       ];
     },
     },
-    component: 'RegisterAddressInput',
+    helpMessage: ['地址码范围为00~FF'],
+    component: 'HexInput',
     changeEvent: 'update:value',
     changeEvent: 'update:value',
     valueField: 'value',
     valueField: 'value',
     componentProps: {
     componentProps: {
-      type: AddressTypeEnum.DEC,
-      maxValue: 247,
-      minValue: 0,
-      disabledSwitch: true,
-    },
-    // ifShow: ({ values }) => {
-    //   return (
-    //     values?.transportType === TransportTypeEnum.TCP &&
-    //     (values.deviceType === DeviceTypeEnum.SENSOR ||
-    //       values.deviceType === DeviceTypeEnum.GATEWAY) &&
-    //     values?.codeType === TaskTypeEnum.MODBUS_RTU
-    //   );
-    // },
+      type: InputTypeEnum.HEX,
+      maxValue: parseInt('FF', 16),
+      placeholder: '请输入寄存器地址',
+    },
     ifShow: ({ values }) => {
     ifShow: ({ values }) => {
       return (
       return (
         values?.transportType === TransportTypeEnum.TCP &&
         values?.transportType === TransportTypeEnum.TCP &&
-        values?.codeType === TaskTypeEnum.MODBUS_RTU
+        values?.tcpDeviceProtocol === TCPProtocolTypeEnum.MODBUS_RTU
       );
       );
     },
     },
   },
   },
@@ -264,7 +241,8 @@ export const step1Schemas: FormSchema[] = [
     },
     },
     ifShow: ({ values }) => {
     ifShow: ({ values }) => {
       return (
       return (
-        values?.transportType === TransportTypeEnum.TCP && values?.codeType === TaskTypeEnum.CUSTOM
+        values?.transportType === TransportTypeEnum.TCP &&
+        values?.tcpDeviceProtocol === TaskTypeEnum.CUSTOM
       );
       );
     },
     },
   },
   },

@@ -88,12 +88,12 @@
   import { validatorLongitude, validatorLatitude } from '/@/utils/rules';
   import { validatorLongitude, validatorLatitude } from '/@/utils/rules';
   import { getOrganizationList } from '/@/api/system/system';
   import { getOrganizationList } from '/@/api/system/system';
   import { copyTransFun } from '/@/utils/fnUtils';
   import { copyTransFun } from '/@/utils/fnUtils';
-  import { TaskTypeEnum } from '/@/views/task/center/config';
   import { toRaw } from 'vue';
   import { toRaw } from 'vue';
   import { FileItem } from '/@/components/Form/src/components/ApiUpload.vue';
   import { FileItem } from '/@/components/Form/src/components/ApiUpload.vue';
   import { buildUUID } from '/@/utils/uuid';
   import { buildUUID } from '/@/utils/uuid';
   import { useMessage } from '/@/hooks/web/useMessage';
   import { useMessage } from '/@/hooks/web/useMessage';
   import { computed } from 'vue';
   import { computed } from 'vue';
+  import { TCPProtocolTypeEnum } from '/@/enums/deviceEnum';
 
 
   export default defineComponent({
   export default defineComponent({
     components: {
     components: {
@@ -405,10 +405,11 @@
             icon: [{ uid: buildUUID(), name: 'name', url: deviceInfo.avatar } as FileItem],
             icon: [{ uid: buildUUID(), name: 'name', url: deviceInfo.avatar } as FileItem],
           });
           });
         }
         }
+
         setFieldsValue({
         setFieldsValue({
           ...data,
           ...data,
           code: data?.code,
           code: data?.code,
-          addressCode: parseInt(data?.code || '', 16),
+          addressCode: data?.code,
           isUpdate: unref(isUpdate1),
           isUpdate: unref(isUpdate1),
         });
         });
       }
       }
@@ -424,9 +425,9 @@
           ...(value?.code || value?.addressCode
           ...(value?.code || value?.addressCode
             ? {
             ? {
                 code:
                 code:
-                  value?.codeType === TaskTypeEnum.CUSTOM
+                  value?.tcpDeviceProtocol === TCPProtocolTypeEnum.CUSTOM
                     ? value?.code
                     ? value?.code
-                    : (value?.addressCode || '').toString(16).padStart(2, '0').toUpperCase(),
+                    : value?.addressCode || '',
               }
               }
             : {}),
             : {}),
         };
         };

@@ -10,7 +10,9 @@ import {
   ServiceCallTypeEnum,
   ServiceCallTypeEnum,
   CommandDeliveryWayEnum,
   CommandDeliveryWayEnum,
   CommandDeliveryWayNameEnum,
   CommandDeliveryWayNameEnum,
+  TCPProtocolTypeEnum,
 } from '/@/enums/deviceEnum';
 } from '/@/enums/deviceEnum';
+import { DeviceRecord, DeviceTypeEnum } from '/@/api/device/model/deviceModel';
 
 
 export interface CommandDeliveryFormFieldType {
 export interface CommandDeliveryFormFieldType {
   [CommandFieldsEnum.COMMAND_TYPE]: CommandTypeEnum;
   [CommandFieldsEnum.COMMAND_TYPE]: CommandTypeEnum;
@@ -36,10 +38,16 @@ export enum CommandFieldsEnum {
 
 
 useComponentRegister('JSONEditor', JSONEditor);
 useComponentRegister('JSONEditor', JSONEditor);
 
 
-export const CommandSchemas = (
-  transportType: TransportTypeEnum,
-  deviceProfileId: string
-): FormSchema[] => {
+export const CommandSchemas = (deviceRecord: DeviceRecord): FormSchema[] => {
+  const { transportType, deviceProfileId, deviceType } = deviceRecord;
+
+  const isTCPTransport = transportType === TransportTypeEnum.TCP;
+
+  const isTCPModbus =
+    isTCPTransport &&
+    deviceRecord.deviceProfile?.profileData?.transportConfiguration?.protocol ===
+      TCPProtocolTypeEnum.MODBUS_RTU;
+
   return [
   return [
     {
     {
       field: CommandFieldsEnum.COMMAND_TYPE,
       field: CommandFieldsEnum.COMMAND_TYPE,
@@ -49,11 +57,19 @@ export const CommandSchemas = (
       required: true,
       required: true,
       componentProps: ({ formActionType }) => {
       componentProps: ({ formActionType }) => {
         const { setFieldsValue } = formActionType;
         const { setFieldsValue } = formActionType;
+
+        const getOptions = () => {
+          const options = [{ label: CommandTypeNameEnum.CUSTOM, value: CommandTypeEnum.CUSTOM }];
+
+          if (isTCPModbus || (isTCPTransport && deviceType === DeviceTypeEnum.SENSOR))
+            return options;
+
+          options.push({ label: CommandTypeNameEnum.SERVICE, value: CommandTypeEnum.SERVICE });
+
+          return options;
+        };
         return {
         return {
-          options: [
-            { label: CommandTypeNameEnum.CUSTOM, value: CommandTypeEnum.CUSTOM },
-            { label: CommandTypeNameEnum.SERVICE, value: CommandTypeEnum.SERVICE },
-          ],
+          options: getOptions(),
           onChange() {
           onChange() {
             setFieldsValue({
             setFieldsValue({
               [CommandFieldsEnum.SERVICE]: null,
               [CommandFieldsEnum.SERVICE]: null,

@@ -37,14 +37,15 @@
   defineEmits(['register']);
   defineEmits(['register']);
 
 
   const thingsModelFormRef = ref<InstanceType<typeof ThingsModelForm>>();
   const thingsModelFormRef = ref<InstanceType<typeof ThingsModelForm>>();
-  const deviceDetail = ref<DeviceRecord>();
+  const props = defineProps<{
+    deviceDetail: DeviceRecord;
+  }>();
 
 
   const [registerModal, { setModalProps }] = useModalInner(
   const [registerModal, { setModalProps }] = useModalInner(
     (params: ModalParamsType<DeviceRecord>) => {
     (params: ModalParamsType<DeviceRecord>) => {
       const { record } = params;
       const { record } = params;
-      deviceDetail.value = record;
       setProps({
       setProps({
-        schemas: CommandSchemas(record.transportType as TransportTypeEnum, record.deviceProfileId),
+        schemas: CommandSchemas(record),
       });
       });
     }
     }
   );
   );
@@ -72,7 +73,7 @@
   };
   };
 
 
   const handleValidateDeviceActive = async (): Promise<boolean> => {
   const handleValidateDeviceActive = async (): Promise<boolean> => {
-    const result = await getDeviceActiveTime(unref(deviceDetail)!.tbDeviceId);
+    const result = await getDeviceActiveTime(unref(props.deviceDetail)!.tbDeviceId);
     const [firstItem] = result;
     const [firstItem] = result;
     return !!firstItem.value;
     return !!firstItem.value;
   };
   };
@@ -83,7 +84,7 @@
   ) => {
   ) => {
     const { commandType, service } = values;
     const { commandType, service } = values;
 
 
-    const isTcpDevice = unref(deviceDetail)?.transportType === TransportTypeEnum.TCP;
+    const isTcpDevice = unref(props.deviceDetail)?.transportType === TransportTypeEnum.TCP;
     if (commandType === CommandTypeEnum.CUSTOM) {
     if (commandType === CommandTypeEnum.CUSTOM) {
       if (isTcpDevice) {
       if (isTcpDevice) {
         return values.tcpCommandValue;
         return values.tcpCommandValue;
@@ -124,7 +125,7 @@
         params: handleCommandParams(values, serviceCommand),
         params: handleCommandParams(values, serviceCommand),
       };
       };
 
 
-      await commandIssuanceApi(callType, unref(deviceDetail)!.tbDeviceId, rpcCommands);
+      await commandIssuanceApi(callType, unref(props.deviceDetail)!.tbDeviceId, rpcCommands);
 
 
       createMessage.success('命令下发成功');
       createMessage.success('命令下发成功');
     } finally {
     } finally {

-import { DeviceModelOfMatterAttrs } from '/@/api/device/model/deviceModel';
+import { DeviceModelOfMatterAttrs, DeviceRecord } from '/@/api/device/model/deviceModel';
 import { DataType, Specs } from '/@/api/device/model/modelOfMatterModel';
 import { DataType, Specs } from '/@/api/device/model/modelOfMatterModel';
+import { TCPProtocolTypeEnum, TransportTypeEnum } from '/@/enums/deviceEnum';
 import { DataTypeEnum } from '/@/enums/objectModelEnum';
 import { DataTypeEnum } from '/@/enums/objectModelEnum';
 import { isArray } from '/@/utils/is';
 import { isArray } from '/@/utils/is';
 
 
@@ -31,18 +32,26 @@ export interface SocketInfoDataSourceItemType extends BaseAdditionalInfo {
 }
 }
 
 
 export function buildTableDataSourceByObjectModel(
 export function buildTableDataSourceByObjectModel(
-  models: DeviceModelOfMatterAttrs[]
+  models: DeviceModelOfMatterAttrs[],
+  deviceDetail: DeviceRecord
 ): SocketInfoDataSourceItemType[] {
 ): SocketInfoDataSourceItemType[] {
+  const isTCPTransportType = deviceDetail.transportType === TransportTypeEnum.TCP;
+
+  const isModbusDevice =
+    isTCPTransportType &&
+    deviceDetail?.deviceProfile?.profileData?.transportConfiguration?.protocol ===
+      TCPProtocolTypeEnum.MODBUS_RTU;
+
   function getAdditionalInfoByDataType(dataType?: DataType) {
   function getAdditionalInfoByDataType(dataType?: DataType) {
     const { specs, specsList, type } = dataType || {};
     const { specs, specsList, type } = dataType || {};
     if (isArray(specs)) return {};
     if (isArray(specs)) return {};
     const { unit, boolClose, boolOpen, unitName } = (specs as Partial<Specs>) || {};
     const { unit, boolClose, boolOpen, unitName } = (specs as Partial<Specs>) || {};
     const result = { unit, boolClose, boolOpen, unitName };
     const result = { unit, boolClose, boolOpen, unitName };
-    if (type == DataTypeEnum.ENUM && specsList && specsList.length) {
+    if ((type == DataTypeEnum.ENUM && specsList && specsList.length) || isModbusDevice) {
       Reflect.set(
       Reflect.set(
         result,
         result,
         'enum',
         'enum',
-        specsList.reduce((prev, next) => ({ ...prev, [next.value!]: next.name }), {})
+        (specsList || []).reduce((prev, next) => ({ ...prev, [next.value!]: next.name }), {})
       );
       );
     }
     }
 
 

@@ -19,7 +19,7 @@
   import { ModeSwitchButton, EnumTableCardMode } from '/@/components/Widget';
   import { ModeSwitchButton, EnumTableCardMode } from '/@/components/Widget';
   import { toRaw } from 'vue';
   import { toRaw } from 'vue';
   import { DataActionModeEnum } from '/@/enums/toolEnum';
   import { DataActionModeEnum } from '/@/enums/toolEnum';
-  import { ReadAndWriteEnum } from '/@/enums/deviceEnum';
+  import { ReadAndWriteEnum, TCPProtocolTypeEnum, TransportTypeEnum } from '/@/enums/deviceEnum';
   import { ObjectModelCommandDeliveryModal } from './ObjectModelCommandDeliveryModal';
   import { ObjectModelCommandDeliveryModal } from './ObjectModelCommandDeliveryModal';
   import { ModalParamsType } from '/#/utils';
   import { ModalParamsType } from '/#/utils';
   import { AreaChartOutlined } from '@ant-design/icons-vue';
   import { AreaChartOutlined } from '@ant-design/icons-vue';
@@ -275,17 +275,30 @@
     openModal(true);
     openModal(true);
   };
   };
 
 
+  const getIsModbusDevice = computed(
+    () =>
+      props.deviceDetail.transportType === TransportTypeEnum.TCP &&
+      props.deviceDetail?.deviceProfile?.profileData?.transportConfiguration?.protocol ===
+        TCPProtocolTypeEnum.MODBUS_RTU
+  );
+
   onMounted(async () => {
   onMounted(async () => {
     const { deviceProfileId } = props.deviceDetail;
     const { deviceProfileId } = props.deviceDetail;
     const value = await getDeviceAttrs({ deviceProfileId });
     const value = await getDeviceAttrs({ deviceProfileId });
     socketInfo.attrKeys = isArray(value) ? value.map((item) => item.identifier) : [];
     socketInfo.attrKeys = isArray(value) ? value.map((item) => item.identifier) : [];
-    socketInfo.rawDataSource = buildTableDataSourceByObjectModel(value);
+    socketInfo.rawDataSource = buildTableDataSourceByObjectModel(value, props.deviceDetail);
     setDataSource();
     setDataSource();
     open();
     open();
   });
   });
 
 
   const formatValue = (item: SocketInfoDataSourceItemType) => {
   const formatValue = (item: SocketInfoDataSourceItemType) => {
-    if (isNullOrUnDef(item)) return '--';
+    if (isNullOrUnDef(item) || isNullOrUnDef(item.value)) return '--';
+
+    if (unref(getIsModbusDevice) && item.type === DataTypeEnum.BOOL) {
+      const _result = Reflect.get(item.enum || {}, item.value as string);
+      return isNullOrUnDef(_result) ? item.value : _result;
+    }
+
     switch (item.type) {
     switch (item.type) {
       case DataTypeEnum.BOOL:
       case DataTypeEnum.BOOL:
         return !!Number(item.value) ? item.boolOpen : item.boolClose;
         return !!Number(item.value) ? item.boolOpen : item.boolClose;
@@ -300,7 +313,7 @@
   const handleSendCommandModal = (data: SocketInfoDataSourceItemType) => {
   const handleSendCommandModal = (data: SocketInfoDataSourceItemType) => {
     openSendCommandModal(true, {
     openSendCommandModal(true, {
       mode: DataActionModeEnum.READ,
       mode: DataActionModeEnum.READ,
-      record: { ...toRaw(data.detail), deviceDetail: props.deviceDetail as any },
+      record: { objectModel: toRaw(unref(data.detail)), deviceDetail: props.deviceDetail as any },
     } as ModalParamsType);
     } as ModalParamsType);
   };
   };
 
 

-import { StructJSON } from '/@/api/device/model/modelOfMatterModel';
-import { FormSchema } from '/@/components/Form';
-import { validateTCPCustomCommand } from '/@/components/Form/src/components/ThingsModelForm';
-import { DataTypeEnum } from '/@/enums/objectModelEnum';
-
-const InsertString = (t, c, n) => {
-  const r: string | number[] = [];
-
-  for (let i = 0; i * 2 < t.length; i++) {
-    r.push(t.substr(i * 2, n));
-  }
-  return r.join(c);
-};
-const FillString = (t, c, n, b) => {
-  if (t == '' || c.length != 1 || n <= t.length) {
-    return t;
-  }
-  const l = t.length;
-
-  for (let i = 0; i < n - l; i++) {
-    if (b == true) {
-      t = c + t;
-    } else {
-      t += c;
-    }
-  }
-  return t;
-};
-const SingleToHex = (t) => {
-  if (t == '') {
-    return '';
-  }
-  t = parseFloat(t);
-
-  if (isNaN(t) == true) {
-    return 'Error';
-  }
-  if (t == 0) {
-    return '00000000';
-  }
-  let s, e, m;
-
-  if (t > 0) {
-    s = 0;
-  } else {
-    s = 1;
-
-    t = 0 - t;
-  }
-  m = t.toString(2);
-
-  if (m >= 1) {
-    if (m.indexOf('.') == -1) {
-      m = m + '.0';
-    }
-    e = m.indexOf('.') - 1;
-  } else {
-    e = 1 - m.indexOf('1');
-  }
-  if (e >= 0) {
-    m = m.replace('.', '');
-  } else {
-    m = m.substring(m.indexOf('1'));
-  }
-  if (m.length > 24) {
-    m = m.substr(0, 24);
-  } else {
-    m = FillString(m, '0', 24, false);
-  }
-  m = m.substring(1);
-
-  e = (e + 127).toString(2);
-
-  e = FillString(e, '0', 8, true);
-
-  let r = parseInt(s + e + m, 2).toString(16);
-
-  r = FillString(r, '0', 8, true);
-
-  return InsertString(r, ' ', 2).toUpperCase();
-};
-
-const FormatHex = (t, n, ie) => {
-  const r: string[] = [];
-
-  let s = '';
-
-  let c = 0;
-
-  for (let i = 0; i < t.length; i++) {
-    if (t.charAt(i) != ' ') {
-      s += t.charAt(i);
-
-      c += 1;
-
-      if (c == n) {
-        r.push(s);
-
-        s = '';
-
-        c = 0;
-      }
-    }
-    if (ie == false) {
-      if (i == t.length - 1 && s != '') {
-        r.push(s);
-      }
-    }
-  }
-  return r.join('\n');
-};
-const FormatHexBatch = (t, n, ie) => {
-  const a = t.split('\n');
-
-  const r: string[] = [];
-
-  for (let i = 0; i < a.length; i++) {
-    r[i] = FormatHex(a[i], n, ie);
-  }
-  return r.join('\n');
-};
-const SingleToHexBatch = (t) => {
-  const a = t.split('\n');
-
-  const r: string[] = [];
-
-  for (let i = 0; i < a.length; i++) {
-    r[i] = SingleToHex(a[i]);
-  }
-  return r.join('\r\n');
-};
-
-const formSchemasConfig = (schemas: StructJSON, actionType: string): FormSchema[] => {
-  const { identifier, functionName, dataType } = schemas;
-
-  if (dataType?.type === DataTypeEnum.STRING) {
-    return [
-      {
-        field: identifier,
-        label: functionName!,
-        component: 'Input',
-        rules: [{ required: true, validator: validateTCPCustomCommand }],
-        componentProps: {
-          placeholder: `请输入${functionName}`,
-        },
-      },
-    ];
-  }
-
-  if (actionType == '06') {
-    return [
-      {
-        field: identifier,
-        label: functionName!,
-        component: 'InputNumber',
-        rules: [{ required: true, message: '请输入正数' }],
-        componentProps: {
-          min: 0,
-          precision: 2,
-          placeholder: `请输入正数`,
-        },
-      },
-    ];
-  } else if (actionType == '05') {
-    return [
-      {
-        field: identifier,
-        label: functionName!,
-        component: 'InputNumber',
-        rules: [{ required: true, message: '请输入值' }],
-        componentProps: {
-          min: 0,
-          max: 1,
-          precision: 0,
-          placeholder: `请输入0或1`,
-        },
-      },
-    ];
-  } else {
-    return [
-      {
-        field: identifier,
-        label: functionName!,
-        component: 'InputNumber',
-        rules: [{ required: true, message: '请输入值' }],
-        componentProps: {
-          placeholder: `请输入数字`,
-          precision: 2,
-        },
-      },
-    ];
-  }
-};
-
-export {
-  InsertString,
-  FillString,
-  SingleToHex,
-  FormatHex,
-  FormatHexBatch,
-  SingleToHexBatch,
-  formSchemasConfig,
-};

 <script lang="ts" setup>
 <script lang="ts" setup>
-  import { ref } from 'vue';
-  import { useGenDynamicForm } from './useGenDynamicForm';
+  import { ref, unref } from 'vue';
+  import { useGenerateFormSchemasByObjectModel } from './useGenerateFormSchemasByObjectModel';
   import { ModalParamsType } from '/#/utils';
   import { ModalParamsType } from '/#/utils';
-  import { DeviceModelOfMatterAttrs } from '/@/api/device/model/deviceModel';
-  import { StructJSON } from '/@/api/device/model/modelOfMatterModel';
+  import { DeviceModelOfMatterAttrs, DeviceRecord } from '/@/api/device/model/deviceModel';
   import { BasicForm, useForm } from '/@/components/Form';
   import { BasicForm, useForm } from '/@/components/Form';
   import { BasicModal, useModalInner } from '/@/components/Modal';
   import { BasicModal, useModalInner } from '/@/components/Modal';
-  import { sendCommandOneway } from '/@/api/dataBoard';
+  import { CommandTypeEnum } from '/@/enums/deviceEnum';
+  import { DataTypeEnum, FunctionTypeEnum } from '/@/enums/objectModelEnum';
+  import { useCommandDelivery } from '/@/hooks/business/useCommandDelivery';
   import { useMessage } from '/@/hooks/web/useMessage';
   import { useMessage } from '/@/hooks/web/useMessage';
-  import { unref } from 'vue';
-  import { genModbusCommand } from '/@/api/task';
-  import { TaskTypeEnum } from '/@/views/task/center/config';
-  import { SingleToHex, formSchemasConfig } from './config';
-  import { DataTypeEnum } from '/@/enums/objectModelEnum';
-  import { TransportTypeEnum } from '/@/enums/deviceEnum';
 
 
   defineEmits(['register']);
   defineEmits(['register']);
   const props = defineProps<{ deviceId: string; deviceName: string }>();
   const props = defineProps<{ deviceId: string; deviceName: string }>();
@@ -24,110 +19,25 @@
     layout: 'vertical',
     layout: 'vertical',
   });
   });
 
 
-  const { genForm, transformValue } = useGenDynamicForm();
-
-  const keys = ref<string[]>([]);
-
-  const modBUSForm = ref<any>({});
-  const isShowModBUS = ref<Boolean>(false); //用于判断标识符类型是否时自定义还是modBUS
-  const isShowActionType = ref<Boolean>(true); //判断设备属性标识符为modBus时没有填写扩展描述
-  const formField = ref(''); //存一个表单取值的field
-  const zoomFactorValue = ref<number>(1); //缩放因子
-  const isShowMultiply = ref<Boolean>(false); // 只有tcp --> int和double类型才相乘缩放因子
-  const deviceTransportType = ref<string>();
-  const objectDataType = ref<DataTypeEnum>();
-
-  const [register] = useModalInner(async (params: ModalParamsType<DeviceModelOfMatterAttrs>) => {
-    const { record } = params;
-    const { name, detail, identifier, deviceDetail, extensionDesc } = record;
-    const { dataType } = detail;
-    const { type } = dataType || {};
-    const { codeType, deviceProfile, code } = deviceDetail || {};
-    const { transportType } = deviceProfile || {};
-    const { registerAddress, actionType, zoomFactor } = extensionDesc || {}; //获取扩展描述内容
-    formField.value = identifier;
-    zoomFactorValue.value = zoomFactor ? Number(zoomFactor) : 1;
-    isShowMultiply.value = type == 'INT' || type == 'DOUBLE' ? true : false;
-    deviceTransportType.value = transportType;
-    objectDataType.value = type;
-
-    let schemas = [{ dataType: dataType, identifier, functionName: name } as StructJSON];
-
-    if (type === DataTypeEnum.STRUCT) {
-      schemas = dataType?.specs as StructJSON[];
-    }
-
-    keys.value = schemas.map((item) => {
-      return item.identifier!;
-    });
-    isShowActionType.value = actionType ? true : false; //判断modBUS类型时 物模型是否填写扩展描述
-
-    //是modBUS类型的就用另外的表单
-    //判断是否是TCP ==> modBus的下发命令
-    if (codeType === TaskTypeEnum.MODBUS_RTU && transportType == TransportTypeEnum.TCP) {
-      isShowModBUS.value = true;
-      modBUSForm.value = {
-        crc: 'CRC_16_LOWER',
-        deviceCode: code,
-        method: actionType == '16' ? '10' : actionType,
-        registerAddress,
-        registerNumber: 1,
-        registerValues: [],
-      };
-      setProps({ schemas: formSchemasConfig(schemas[0], actionType) });
-    } else {
-      isShowModBUS.value = false;
-      if (transportType === TransportTypeEnum.TCP) {
-        setProps({
-          schemas: [
-            {
-              field: 'command',
-              label: name,
-              component: 'Input',
-              required: true,
-              rules: [
-                {
-                  pattern: /^[\s0-9a-fA-F]+$/,
-                  required: true,
-                  message: '请输入ASCII或HEX服务命令(0~9/A~F)',
-                },
-              ],
-              componentProps: {
-                placeholder: `请输入${name}`,
-              },
-            },
-          ],
-        });
-      } else {
-        const formSchemas = genForm(schemas);
-        setProps({ schemas: formSchemas });
-      }
-    }
-
-    resetFields();
-  });
-
-  const getArray = (values) => {
-    const str = values.replace(/\s+/g, '');
-    const array: any = [];
-
-    for (let i = 0; i < str.length; i += 4) {
-      const chunk = parseInt(str.substring(i, i + 4), 16);
-      array.push(chunk);
+  const { getFormByObjectModel } = useGenerateFormSchemasByObjectModel();
+
+  const currentParams = ref<{
+    deviceDetail: DeviceRecord;
+    objectModel: DeviceModelOfMatterAttrs;
+  }>();
+
+  const [register] = useModalInner(
+    async (
+      params: ModalParamsType<{ deviceDetail: DeviceRecord; objectModel: DeviceModelOfMatterAttrs }>
+    ) => {
+      const { record } = params;
+      currentParams.value = record;
+      const { objectModel, deviceDetail } = record;
+      const schemas = getFormByObjectModel(objectModel, deviceDetail);
+      setProps({ schemas });
+      resetFields();
     }
     }
-    return array;
-  };
-
-  // 获取小数
-  const getFloatPart = (number: string | number) => {
-    const isLessZero = Number(number) < 0;
-    number = number.toString();
-    const floatPartStartIndex = number.indexOf('.');
-    const value = ~floatPartStartIndex
-      ? `${isLessZero ? '-' : ''}0.${number.substring(floatPartStartIndex + 1)}`
-      : '0';
-    return Number(value);
-  };
+  );
 
 
   const { createMessage } = useMessage();
   const { createMessage } = useMessage();
   const loading = ref(false);
   const loading = ref(false);
@@ -136,82 +46,29 @@
       loading.value = true;
       loading.value = true;
       if (!props.deviceId) return;
       if (!props.deviceId) return;
 
 
-      const sendValue = ref({});
-      //判断tcp类型 标识符是自定义还是ModBus
-      if (unref(objectDataType) === DataTypeEnum.STRING) {
-        const flag = await validate();
-        if (!flag) return;
-        const value = getFieldsValue()[unref(formField)];
-        sendValue.value = value;
-      } else if (unref(isShowModBUS)) {
-        if (!unref(isShowActionType)) {
-          createMessage.warning('当前物模型扩展描述没有填写');
-          return;
-        }
-        const flag = await validate();
-        if (!flag) return;
-
-        const oldValue = getFieldsValue()[unref(formField)];
-        modBUSForm.value.registerNumber = 1;
-        modBUSForm.value.registerValues = [oldValue];
-
-        if (unref(isShowMultiply) && unref(modBUSForm).method == '06') {
-          const newValue =
-            Math.trunc(oldValue) * unref(zoomFactorValue) +
-            getFloatPart(oldValue) * unref(zoomFactorValue);
-          if (newValue % 1 != 0) {
-            createMessage.warning(`属性下发类型必须是整数,缩放因子为${unref(zoomFactorValue)}`);
-            return;
-          }
-
-          if (oldValue * unref(zoomFactorValue) > 65535) {
-            createMessage.warning(`属性下发值不能超过65535,缩放因子是${unref(zoomFactorValue)}`);
-            return;
-          }
-          //bool类型的就不用去乘缩放因子了
-          modBUSForm.value.registerValues = [newValue];
-        }
+      await validate();
+      const { deviceDetail, objectModel } = unref(currentParams) || {};
 
 
-        if (unref(modBUSForm).method == '16' || unref(modBUSForm).method == '10') {
-          const regex = /^-?\d+(\.\d{0,2})?$/;
-          const values =
-            Math.trunc(oldValue) * unref(zoomFactorValue) +
-            getFloatPart(oldValue) * unref(zoomFactorValue);
-
-          if (!regex.test(values as any)) {
-            createMessage.warning(`属性下发值精确到两位小数,缩放因子是${unref(zoomFactorValue)}`);
-            return;
-          }
-
-          const newValue =
-            values == 0 ? [0, 0] : getArray(SingleToHex(unref(isShowMultiply) ? values : oldValue));
-          modBUSForm.value.registerValues = newValue;
-          modBUSForm.value.registerNumber = 2;
-          modBUSForm.value.method = '10';
-        }
-
-        sendValue.value = await genModbusCommand(unref(modBUSForm));
-      } else {
-        await validate();
-        const _value = transformValue(getFieldsValue());
-        sendValue.value = unref(keys).reduce((prev, next) => {
-          return { ...prev, [next]: _value[next] };
-        }, {});
-
-        // tcp 设备下发字符串
-        if (unref(deviceTransportType) === TransportTypeEnum.TCP) {
-          sendValue.value = Object.values(_value).join('').replaceAll(/\s/g, '');
-        }
+      let value = getFieldsValue();
+      if (objectModel?.detail.dataType.type !== DataTypeEnum.STRUCT) {
+        value = value[objectModel!.identifier];
       }
       }
 
 
-      await sendCommandOneway({
-        deviceId: props.deviceId,
-        value: {
-          persistent: true,
-          method: 'methodThingskit',
-          params: unref(sendValue),
+      const { doCommandDelivery } = useCommandDelivery();
+
+      await doCommandDelivery({
+        deviceDetail,
+        objectModel: {
+          ...(objectModel || {}),
+          functionName: objectModel!.name,
+          identifier: objectModel!.identifier,
+          functionType: FunctionTypeEnum.PROPERTIES,
+          specs: objectModel?.detail,
         },
         },
+        cmdType: CommandTypeEnum.ATTRIBUTE,
+        value,
       });
       });
+
       createMessage.success('属性下发成功');
       createMessage.success('属性下发成功');
     } catch (error) {
     } catch (error) {
       throw error;
       throw error;

+import { unref } from 'vue';
+import { DeviceModelOfMatterAttrs, DeviceRecord } from '/@/api/device/model/deviceModel';
 import { DataType, Specs, StructJSON } from '/@/api/device/model/modelOfMatterModel';
 import { DataType, Specs, StructJSON } from '/@/api/device/model/modelOfMatterModel';
-import { JSONEditor } from '/@/components/CodeEditor';
-import { FormSchema, useComponentRegister } from '/@/components/Form';
-import { DataTypeEnum } from '/@/enums/objectModelEnum';
-import { useJsonParse } from '/@/hooks/business/useJsonParse';
+import { FormSchema } from '/@/components/Form';
+import { DataTypeEnum, OriginalDataTypeEnum } from '/@/enums/objectModelEnum';
+import { TCPProtocolTypeEnum } from '/@/enums/deviceEnum';
 
 
 export interface BasicCreateFormParams {
 export interface BasicCreateFormParams {
   identifier: string;
   identifier: string;
@@ -10,11 +11,9 @@ export interface BasicCreateFormParams {
   dataType: DataType;
   dataType: DataType;
 }
 }
 
 
-useComponentRegister('JSONEditor', JSONEditor);
-
 const validateDouble = (value: number, min?: number | string, max?: number | string) => {
 const validateDouble = (value: number, min?: number | string, max?: number | string) => {
-  min = Number(min) || Number.MIN_SAFE_INTEGER;
-  max = Number(max) || Number.MAX_SAFE_INTEGER;
+  min = Number(min) ?? Number.MIN_SAFE_INTEGER;
+  max = Number(max) ?? Number.MAX_SAFE_INTEGER;
 
 
   return {
   return {
     flag: value < min || value > max,
     flag: value < min || value > max,
@@ -22,7 +21,7 @@ const validateDouble = (value: number, min?: number | string, max?: number | str
   };
   };
 };
 };
 
 
-export const useGenDynamicForm = () => {
+export const useGenerateFormSchemasByObjectModel = () => {
   const createInputNumber = ({
   const createInputNumber = ({
     identifier,
     identifier,
     functionName,
     functionName,
@@ -128,24 +127,39 @@ export const useGenDynamicForm = () => {
     };
     };
   };
   };
 
 
-  const createInputJson = ({ identifier, functionName }: BasicCreateFormParams): FormSchema => {
+  const createModbusValueInput = (objectModel: DeviceModelOfMatterAttrs): FormSchema => {
+    const { identifier, name, detail, extensionDesc } = objectModel;
+
+    const { dataType } = detail || {};
+    const { specs } = dataType || {};
+    const { valueRange } = specs as Specs;
+    const { max, min } = valueRange || {};
+
+    const isStringType = extensionDesc?.originalDataType === OriginalDataTypeEnum.STRING;
     return {
     return {
       field: identifier,
       field: identifier,
-      label: functionName,
-      component: 'JSONEditor',
-      valueField: 'value',
-      changeEvent: 'update:value',
-      rules: [
-        {
-          validator: (_rule, value: any) => {
-            if (value) {
-              const { flag } = useJsonParse(value);
-              if (!flag) return Promise.reject(`${functionName} 不是一个有效的JSON对象`);
-            }
-            return Promise.resolve();
-          },
-        },
-      ],
+      label: name,
+      component: isStringType ? 'Input' : 'InputNumber',
+      rules: isStringType
+        ? []
+        : [
+            {
+              type: 'number',
+              validator: (_rule, value) => {
+                const { flag, message } = validateDouble(value, min, max);
+                if (flag) {
+                  return Promise.reject(`${name}${message}`);
+                }
+                return Promise.resolve(value);
+              },
+            },
+          ],
+      componentProps: {
+        max: max ?? Number.MAX_SAFE_INTEGER,
+        min: min ?? Number.MIN_SAFE_INTEGER,
+        placeholder: `请输入${name}`,
+        // precision: floatType.includes(extensionDesc!.originalDataType) ? 2 : 0,
+      },
     };
     };
   };
   };
 
 
@@ -154,48 +168,38 @@ export const useGenDynamicForm = () => {
     [DataTypeEnum.NUMBER_DOUBLE]: createInputNumber,
     [DataTypeEnum.NUMBER_DOUBLE]: createInputNumber,
     [DataTypeEnum.NUMBER_INT]: createInputNumber,
     [DataTypeEnum.NUMBER_INT]: createInputNumber,
     [DataTypeEnum.STRING]: createInput,
     [DataTypeEnum.STRING]: createInput,
-    [DataTypeEnum.STRUCT]: createInputJson,
     [DataTypeEnum.ENUM]: createEnumSelect,
     [DataTypeEnum.ENUM]: createEnumSelect,
   };
   };
 
 
-  const fieldTypeMap = new Map<string, DataTypeEnum>();
-  const genForm = (schemas: StructJSON[]) => {
-    fieldTypeMap.clear();
-    const formSchema = schemas.map((item) => {
-      const { functionName, identifier, dataType } = item;
+  const getFormByObjectModel = (
+    objectModel: DeviceModelOfMatterAttrs,
+    deviceDetail: DeviceRecord
+  ): FormSchema[] => {
+    const { name, identifier, detail } = objectModel;
 
 
-      const { type } = dataType || {};
+    const isTCPModbusProduct =
+      unref(deviceDetail).deviceProfile?.profileData?.transportConfiguration?.protocol ===
+      TCPProtocolTypeEnum.MODBUS_RTU;
 
 
-      fieldTypeMap.set(identifier!, dataType!.type);
-      const method = schemaMethod[type!];
+    const { dataType } = detail;
+    const { type } = dataType || {};
 
 
-      const formSchema = method?.({
-        identifier: identifier!,
-        functionName: functionName!,
-        dataType: dataType!,
-      });
+    if (isTCPModbusProduct) {
+      return [createModbusValueInput(objectModel)];
+    }
 
 
-      return formSchema;
-    });
+    if (type === DataTypeEnum.STRUCT) {
+      return (dataType?.specs as StructJSON[]).map((item) => {
+        const { functionName, identifier, dataType } = item;
+        const { type } = dataType || {};
 
 
-    return formSchema.filter(Boolean);
-  };
+        return schemaMethod[type!]?.({ identifier, functionName, dataType });
+      });
+    }
 
 
-  const transformValue = (value: Recordable) => {
-    return Object.keys(value || {}).reduce((prev, next) => {
-      const dataType = fieldTypeMap.get(next)!;
-
-      let itemValue = value[next];
-      if (dataType === DataTypeEnum.STRUCT) {
-        const { value } = useJsonParse(itemValue);
-        itemValue = value;
-      }
-      return {
-        ...prev,
-        [next]: itemValue,
-      };
-    }, {} as Recordable);
+    const result = schemaMethod[type!]?.({ identifier, functionName: name, dataType: dataType! });
+    return result ? [result] : [];
   };
   };
 
 
-  return { genForm, transformValue };
+  return { getFormByObjectModel };
 };
 };

@@ -39,45 +39,37 @@ export const validateValueRange: ValidatorRule['validator'] = (
   return Promise.resolve();
   return Promise.resolve();
 };
 };
 
 
-export const validateFunctionName: ValidatorRule['validator'] = (_rule, value: any) => {
-  if (/^[a-zA-Z0-9_\-\u4e00-\u9fa5]+$/.test(value)) return Promise.resolve();
-  return Promise.reject('支持中文、大小写字母、数字、短划线、下划线.');
-};
-
-export const validateIdentifier: ValidatorRule['validator'] = (_rule, value: any) => {
-  if (/^[a-zA-Z0-9_]+$/.test(value)) {
-    return Promise.resolve();
-  }
-  return Promise.reject('支持大小写字母、数字和下划线.');
-};
-
 export const createFunctionNameFormItem = (params: Partial<FormSchema> = {}): FormSchema => {
 export const createFunctionNameFormItem = (params: Partial<FormSchema> = {}): FormSchema => {
+  const helpMessage = '支持中文、大小写字母、数字、短划线、下划线。';
   return {
   return {
     field: FormFieldsEnum.FUNCTION_NAME,
     field: FormFieldsEnum.FUNCTION_NAME,
     label: FormFieldsNameEnum.FUNCTION_NAME,
     label: FormFieldsNameEnum.FUNCTION_NAME,
     component: 'Input',
     component: 'Input',
     required: true,
     required: true,
-    helpMessage: '支持中文、大小写字母、数字、短划线、下划线。',
+    helpMessage,
     rules: [
     rules: [
       {
       {
         required: true,
         required: true,
-        validator: validateFunctionName,
+        message: helpMessage,
+        pattern: /^[a-zA-Z0-9_\-\u4e00-\u9fa5\(\)]+$/,
       },
       },
     ],
     ],
     componentProps: {
     componentProps: {
       placeholder: `请输入${FormFieldsNameEnum.FUNCTION_NAME}`,
       placeholder: `请输入${FormFieldsNameEnum.FUNCTION_NAME}`,
+      maxlength: 32,
     },
     },
     ...params,
     ...params,
   };
   };
 };
 };
 
 
 export const createIdentifierFormItem = (params: Partial<FormSchema> = {}): FormSchema => {
 export const createIdentifierFormItem = (params: Partial<FormSchema> = {}): FormSchema => {
+  const helpMessage = '支持大小写字母、数字和下划线.';
   return {
   return {
     field: FormFieldsEnum.IDENTIFIER,
     field: FormFieldsEnum.IDENTIFIER,
     label: FormFieldsNameEnum.IDENTIFIER,
     label: FormFieldsNameEnum.IDENTIFIER,
     required: true,
     required: true,
     component: 'Input',
     component: 'Input',
-    helpMessage: '支持大小写字母、数字和下划线.',
+    helpMessage,
     componentProps: {
     componentProps: {
       maxLength: 128,
       maxLength: 128,
       placeholder: '请输入标识符',
       placeholder: '请输入标识符',
@@ -85,7 +77,8 @@ export const createIdentifierFormItem = (params: Partial<FormSchema> = {}): Form
     rules: [
     rules: [
       {
       {
         required: true,
         required: true,
-        validator: validateIdentifier,
+        message: helpMessage,
+        pattern: /^[a-zA-Z0-9_\-\u4e00-\u9fa5\(\)]+$/,
       },
       },
     ],
     ],
     ...params,
     ...params,
@@ -330,7 +323,6 @@ export const getFormSchemas = (dataType: DataTypeEnum[], showRemark: boolean): F
           model[FormFieldsEnum.FUNCTION_TYPE]
           model[FormFieldsEnum.FUNCTION_TYPE]
         ),
         ),
     },
     },
-
     {
     {
       field: FormFieldsEnum.REMARK,
       field: FormFieldsEnum.REMARK,
       label: FormFieldsNameEnum.REMARK,
       label: FormFieldsNameEnum.REMARK,

@@ -20,7 +20,7 @@
     }
     }
   );
   );
 
 
-  defineEmits<{
+  const emits = defineEmits<{
     (event: 'field-value-change', field: string, value: any): void;
     (event: 'field-value-change', field: string, value: any): void;
   }>();
   }>();
 
 
@@ -37,6 +37,9 @@
     enumListRef,
     enumListRef,
   });
   });
 
 
+  const handleFieldValueChang = (field: string, value: any) =>
+    emits('field-value-change', field, value);
+
   defineExpose({ getFieldsValue, setFieldsValue, validate, resetFieldsValue });
   defineExpose({ getFieldsValue, setFieldsValue, validate, resetFieldsValue });
 </script>
 </script>
 
 
@@ -45,7 +48,7 @@
     @register="register"
     @register="register"
     class="data-type-form"
     class="data-type-form"
     :disabled="mode === DataActionModeEnum.READ"
     :disabled="mode === DataActionModeEnum.READ"
-    @field-value-change="(field, value) => $emit('field-value-change', field, value)"
+    @field-value-change="handleFieldValueChang"
   >
   >
     <template #enumsData="{ model, field }">
     <template #enumsData="{ model, field }">
       <EnumList
       <EnumList
@@ -77,4 +80,3 @@
     }
     }
   }
   }
 </style>
 </style>
-./config

 import { Ref, unref } from 'vue';
 import { Ref, unref } from 'vue';
 import { FormActionType } from '/@/components/Form';
 import { FormActionType } from '/@/components/Form';
-import EnumList from './EnumList.vue';
+import { EnumList } from '../EnumList';
 import { DefineComponentsBasicExpose } from '/#/utils';
 import { DefineComponentsBasicExpose } from '/#/utils';
 import { DataTypeFormGetFieldsValueType } from './config';
 import { DataTypeFormGetFieldsValueType } from './config';
 import { DataType, Specs, StructJSON } from '/@/api/device/model/modelOfMatterModel';
 import { DataType, Specs, StructJSON } from '/@/api/device/model/modelOfMatterModel';

@@ -6,15 +6,21 @@ export enum FormFieldsEnum {
   DATA_TYPE = 'dataType',
   DATA_TYPE = 'dataType',
 }
 }
 
 
-export const getFormSchemas = (): FormSchema[] => {
+export const getFormSchemas = (required: boolean): FormSchema[] => {
   return [
   return [
     {
     {
       field: FormFieldsEnum.VALUE,
       field: FormFieldsEnum.VALUE,
       label: '',
       label: '',
       component: 'InputNumber',
       component: 'InputNumber',
-      rules: [
-        { required: true, message: `支持整型，取值范围：-2147483648 ~ 2147483647`, type: 'number' },
-      ],
+      dynamicRules: ({ model }) => {
+        return [
+          {
+            required: required || model[FormFieldsEnum.NAME],
+            message: `支持整型，取值范围：-2147483648 ~ 2147483647`,
+            type: 'number',
+          },
+        ];
+      },
       componentProps: () => {
       componentProps: () => {
         return {
         return {
           placeholder: '编号如"0"',
           placeholder: '编号如"0"',
@@ -41,7 +47,15 @@ export const getFormSchemas = (): FormSchema[] => {
       field: FormFieldsEnum.NAME,
       field: FormFieldsEnum.NAME,
       label: '',
       label: '',
       component: 'Input',
       component: 'Input',
-      rules: [{ required: true, message: `参数描述不能为空`, type: 'string' }],
+      dynamicRules: ({ model }) => {
+        return [
+          {
+            required: required || model[FormFieldsEnum.VALUE],
+            message: `参数描述不能为空`,
+            type: 'string',
+          },
+        ];
+      },
       componentProps: () => {
       componentProps: () => {
         return {
         return {
           placeholder: '对该枚举项的描述',
           placeholder: '对该枚举项的描述',

@@ -9,7 +9,18 @@
   import { DataTypeEnum } from '/@/enums/objectModelEnum';
   import { DataTypeEnum } from '/@/enums/objectModelEnum';
   import { isNullOrUnDef } from '/@/utils/is';
   import { isNullOrUnDef } from '/@/utils/is';
 
 
-  const props = defineProps<{ disabled?: boolean; value?: Specs[] }>();
+  const props = withDefaults(
+    defineProps<{
+      disabled?: boolean;
+      value?: Specs[];
+      addButtonName?: string;
+      required?: boolean;
+    }>(),
+    {
+      addButtonName: '+添加枚举项',
+      required: true,
+    }
+  );
 
 
   interface EnumElItemType {
   interface EnumElItemType {
     uuid: string;
     uuid: string;
@@ -18,7 +29,7 @@
   }
   }
 
 
   const [registerForm] = useForm({
   const [registerForm] = useForm({
-    schemas: getFormSchemas(),
+    schemas: getFormSchemas(props.required),
     showActionButtonGroup: false,
     showActionButtonGroup: false,
     layout: 'inline',
     layout: 'inline',
   });
   });
@@ -75,6 +86,8 @@
     const index = unref(enumsListElRef).findIndex((temp) => item.uuid === temp.uuid);
     const index = unref(enumsListElRef).findIndex((temp) => item.uuid === temp.uuid);
 
 
     ~index && enumsListElRef.value.splice(index, 1);
     ~index && enumsListElRef.value.splice(index, 1);
+
+    validateSameEnum();
   };
   };
 
 
   const handleAddEnums = () => {
   const handleAddEnums = () => {
@@ -102,14 +115,14 @@
   <section class="w-full">
   <section class="w-full">
     <header class="flex h-8 items-center">
     <header class="flex h-8 items-center">
       <div class="w-1/2">
       <div class="w-1/2">
-        <span class="mr-1 text-red-400">*</span>
+        <span v-if="required" class="mr-1 text-red-400">*</span>
         <span> 参考值 </span>
         <span> 参考值 </span>
         <Tooltip title="支持整型，取值范围：-2147483648 ~ 2147483647">
         <Tooltip title="支持整型，取值范围：-2147483648 ~ 2147483647">
           <Icon icon="ant-design:question-circle-outlined" class="cursor-pointer ml-1" />
           <Icon icon="ant-design:question-circle-outlined" class="cursor-pointer ml-1" />
         </Tooltip>
         </Tooltip>
       </div>
       </div>
       <div class="w-1/2">
       <div class="w-1/2">
-        <span class="mr-1 text-red-400">*</span>
+        <span v-if="required" class="mr-1 text-red-400">*</span>
         <span> 参考描述 </span>
         <span> 参考描述 </span>
         <Tooltip
         <Tooltip
           title="支持中文、英文大小写、日文、数字、下划线和短划线，必须以中文、英文或数字开头，不超过20个字符"
           title="支持中文、英文大小写、日文、数字、下划线和短划线，必须以中文、英文或数字开头，不超过20个字符"
@@ -144,7 +157,7 @@
     <div v-if="hasSameEnum" class="text-red-400">枚举项中存在相同的参数值或参数描述</div>
     <div v-if="hasSameEnum" class="text-red-400">枚举项中存在相同的参数值或参数描述</div>
     <Tooltip title="枚举项最多创建 100 个">
     <Tooltip title="枚举项最多创建 100 个">
       <Button type="link" @click="handleAddEnums" :disabled="disabled || getEnumsLimit">
       <Button type="link" @click="handleAddEnums" :disabled="disabled || getEnumsLimit">
-        +添加枚举项
+        {{ addButtonName }}
       </Button>
       </Button>
     </Tooltip>
     </Tooltip>
   </section>
   </section>

-import { unref } from 'vue';
-import { useObjectModelFormContext } from '../useObjectModelFormContext';
-import { findDictItemByCode } from '/@/api/system/dict';
 import { FormSchema } from '/@/components/Table';
 import { FormSchema } from '/@/components/Table';
-import { DictEnum } from '/@/enums/dictEnum';
 import {
 import {
-  DataTypeEnum,
-  RegisterActionTypeEnum,
-  RegisterActionTypeNameEnum,
-  RegisterDataTypeEnum,
+  ExtendDescOperationTypeEnum,
+  ExtendDescOperationTypeNameEnum,
+  OriginalDataTypeEnum,
+  OriginalDataTypeNameEnum,
 } from '/@/enums/objectModelEnum';
 } from '/@/enums/objectModelEnum';
+import { validateValueRange } from '../DataTypeForm/config';
+import { useComponentRegister } from '/@/components/Form';
+import { HexInput, InputTypeEnum } from '../HexInput';
+import { isFloatType } from './useParseOperationType';
+import { useObjectModelFormContext } from '../useObjectModelFormContext';
+import { unref } from 'vue';
+import { DataActionModeEnum } from '/@/enums/toolEnum';
+
+useComponentRegister('HexInput', HexInput);
 
 
 export enum FormFieldsEnum {
 export enum FormFieldsEnum {
-  REGISTER_ADDRESS = 'registerAddress',
-  DATA_TYPE = 'dataType',
   ACTION_TYPE = 'actionType',
   ACTION_TYPE = 'actionType',
   ZOOM_FACTOR = 'zoomFactor',
   ZOOM_FACTOR = 'zoomFactor',
 
 
   OBJECT_MODEL_TYPE = 'objectModelType',
   OBJECT_MODEL_TYPE = 'objectModelType',
+
+  ORIGINAL_DATA_TYPE = 'originalDataType',
+  REGISTER_ADDRESS = 'registerAddress',
+  OPERATION_TYPE = 'operationType',
+  VALUE_RANGE = 'valueRange',
+  SCALING = 'scaling',
+  BIT_MASK = 'bitMask',
+
+  REGISTER_COUNT = 'registerCount',
+
+  VALUE_MAPPING = 'valueMapping',
 }
 }
 
 
-function getActionTypeByObjectModelType(dataType: DataTypeEnum) {
-  const list: Record<'label' | 'value', string>[] = [];
-  if (dataType === DataTypeEnum.BOOL) {
-    list.push({ label: RegisterActionTypeNameEnum.BOOL, value: RegisterActionTypeEnum.BOOL });
-  } else if (dataType === DataTypeEnum.NUMBER_INT) {
-    list.push({ label: RegisterActionTypeNameEnum.INT, value: RegisterActionTypeEnum.INT });
-  } else if (dataType === DataTypeEnum.NUMBER_DOUBLE) {
-    list.push({ label: RegisterActionTypeNameEnum.DOUBLE, value: RegisterActionTypeEnum.DOUBLE });
-  } else {
-    list.push(
-      ...Object.keys(RegisterActionTypeEnum).map((key) => ({
-        label: RegisterActionTypeNameEnum[key],
-        value: RegisterActionTypeEnum[key],
-      }))
-    );
+export enum FormFieldsNameEnum {
+  ORIGINAL_DATA_TYPE = '数据类型',
+  REGISTER_ADDRESS = '寄存器地址',
+  OPERATION_TYPE = '操作类型',
+  VALUE_RANGE = '取值范围',
+  SCALING = '缩放因子',
+  BIT_MASK = '比特位置',
+
+  REGISTER_COUNT = '寄存器个数',
+  VALUE_MAPPING = '值映射',
+}
+
+export const BOOL_DEFAULT_VALUE_RANGE = { min: 0, max: 1 };
+
+export const INT16_VALUE_RANGE = {
+  min: -(2 ** 15),
+  max: 2 ** 15 - 1,
+};
+
+export const UINT16_VALUE_RANGE = {
+  min: 0,
+  max: 2 ** 16 - 1,
+};
+
+export const INT32_VALUE_RANGE = {
+  min: -(2 ** 31),
+  max: 2 ** 31 - 1,
+};
+
+export const UINT32_VALUE_RANGE = {
+  min: 0,
+  max: 2 ** 32 - 1,
+};
+
+function getValueRangeFromOriginDataType(
+  originalDataType?: OriginalDataTypeEnum
+): Record<'min' | 'max', number> {
+  switch (originalDataType) {
+    case OriginalDataTypeEnum.BOOLEAN:
+    case OriginalDataTypeEnum.BITS:
+      return BOOL_DEFAULT_VALUE_RANGE;
+
+    case OriginalDataTypeEnum.INT16_AB:
+    case OriginalDataTypeEnum.INT16_BA:
+      return INT16_VALUE_RANGE;
+
+    case OriginalDataTypeEnum.UINT16_AB:
+    case OriginalDataTypeEnum.UINT16_BA:
+      return UINT16_VALUE_RANGE;
+
+    case OriginalDataTypeEnum.INT32_AB_CD:
+    case OriginalDataTypeEnum.INT32_BA_DC:
+    case OriginalDataTypeEnum.INT32_CD_AB:
+    case OriginalDataTypeEnum.INT32_DC_BA:
+      return INT32_VALUE_RANGE;
+
+    case OriginalDataTypeEnum.UINT32_AB_CD:
+    case OriginalDataTypeEnum.UINT32_BA_DC:
+    case OriginalDataTypeEnum.UINT32_CD_AB:
+    case OriginalDataTypeEnum.UINT32_DC_BA:
+      return UINT32_VALUE_RANGE;
+
+    default:
+      return INT32_VALUE_RANGE;
   }
   }
+}
 
 
-  return list;
+const BOOL_OPERATION_TYPE = [
+  ExtendDescOperationTypeEnum.INPUT_STATUS_R_02,
+  ExtendDescOperationTypeEnum.COIL_STATUS_R_01,
+  ExtendDescOperationTypeEnum.COIL_STATUS_RW_01_05,
+  ExtendDescOperationTypeEnum.COIL_STATUS_RW_01_0F,
+  ExtendDescOperationTypeEnum.COIL_STATUS_W_05,
+  ExtendDescOperationTypeEnum.COIL_STATUS_W_0F,
+];
+
+function getOriginalDataTypeByOperationType(
+  operationType: ExtendDescOperationTypeEnum
+): Record<'label' | 'value', string>[] {
+  switch (operationType) {
+    case ExtendDescOperationTypeEnum.INPUT_STATUS_R_02:
+    case ExtendDescOperationTypeEnum.COIL_STATUS_R_01:
+    case ExtendDescOperationTypeEnum.COIL_STATUS_RW_01_05:
+    case ExtendDescOperationTypeEnum.COIL_STATUS_RW_01_0F:
+    case ExtendDescOperationTypeEnum.COIL_STATUS_W_05:
+    case ExtendDescOperationTypeEnum.COIL_STATUS_W_0F:
+      return [{ label: OriginalDataTypeNameEnum.BOOLEAN, value: OriginalDataTypeEnum.BOOLEAN }];
+
+    case ExtendDescOperationTypeEnum.HOLDING_REGISTER_RW_03_06:
+    case ExtendDescOperationTypeEnum.HOLDING_REGISTER_W_06:
+      return [
+        { label: OriginalDataTypeNameEnum.INT16_AB, value: OriginalDataTypeEnum.INT16_AB },
+        { label: OriginalDataTypeNameEnum.INT16_BA, value: OriginalDataTypeEnum.INT16_BA },
+        { label: OriginalDataTypeNameEnum.UINT16_AB, value: OriginalDataTypeEnum.UINT16_AB },
+        { label: OriginalDataTypeNameEnum.UINT16_BA, value: OriginalDataTypeEnum.UINT16_BA },
+        { label: OriginalDataTypeNameEnum.BITS, value: OriginalDataTypeEnum.BITS },
+        { label: OriginalDataTypeNameEnum.BOOLEAN, value: OriginalDataTypeEnum.BOOLEAN },
+      ];
+
+    case ExtendDescOperationTypeEnum.HOLDING_REGISTER_RW_03_10:
+    case ExtendDescOperationTypeEnum.HOLDING_REGISTER_W_10:
+    case ExtendDescOperationTypeEnum.HOLDING_REGISTER_R_03:
+    case ExtendDescOperationTypeEnum.INPUT_REGISTER_R_04:
+      return Object.keys(OriginalDataTypeEnum).map((key) => ({
+        label: OriginalDataTypeNameEnum[key],
+        value: OriginalDataTypeEnum[key],
+      }));
+  }
 }
 }
 
 
-export const getFormSchemas = (): FormSchema[] => {
-  const { getDataType } = useObjectModelFormContext();
+export const getExtendDescFormSchemas = (): FormSchema[] => {
+  const DEFAULT_OPERATION_TYPE = ExtendDescOperationTypeEnum.INPUT_STATUS_R_02;
+  const DEFAULT_ORIGINAL_TYPE = OriginalDataTypeEnum.BOOLEAN;
   return [
   return [
     {
     {
+      field: FormFieldsEnum.OPERATION_TYPE,
+      label: FormFieldsNameEnum.OPERATION_TYPE,
+      component: 'Select',
+      required: true,
+      defaultValue: DEFAULT_OPERATION_TYPE,
+      componentProps: ({ formActionType }) => {
+        return {
+          options: Object.keys(ExtendDescOperationTypeEnum).map((key) => ({
+            label: ExtendDescOperationTypeNameEnum[key],
+            value: ExtendDescOperationTypeEnum[key],
+          })),
+          labelField: 'itemText',
+          valueField: 'itemValue',
+          getPopupContainer: () => document.body,
+          placeholder: '请选择操作类型',
+          allowClear: false,
+          onChange(value: ExtendDescOperationTypeEnum) {
+            const isBoolTypeOperationType = BOOL_OPERATION_TYPE.includes(value);
+            const originalDataType = isBoolTypeOperationType
+              ? OriginalDataTypeEnum.BOOLEAN
+              : OriginalDataTypeEnum.INT16_AB;
+
+            formActionType.setFieldsValue({
+              [FormFieldsEnum.ORIGINAL_DATA_TYPE]: originalDataType,
+              [FormFieldsEnum.VALUE_RANGE]: isBoolTypeOperationType
+                ? BOOL_DEFAULT_VALUE_RANGE
+                : INT16_VALUE_RANGE,
+            });
+          },
+        };
+      },
+    },
+    {
       field: FormFieldsEnum.REGISTER_ADDRESS,
       field: FormFieldsEnum.REGISTER_ADDRESS,
-      component: 'RegisterAddressInput',
-      label: '寄存器地址',
+      label: FormFieldsNameEnum.REGISTER_ADDRESS,
+      component: 'HexInput',
       changeEvent: 'update:value',
       changeEvent: 'update:value',
       valueField: 'value',
       valueField: 'value',
-      rules: [{ message: '请输入寄存器地址', required: true, type: 'number' }],
+      helpMessage: ['范围在 0x0-0xFFFF'],
+      rules: [{ message: '请输入寄存器地址', required: true }],
       componentProps: {
       componentProps: {
         placeholder: '请输入寄存器地址',
         placeholder: '请输入寄存器地址',
+        type: InputTypeEnum.HEX,
+        maxValue: parseInt('0xFFFF', 16),
       },
       },
     },
     },
     {
     {
-      field: FormFieldsEnum.DATA_TYPE,
-      component: 'ApiSelect',
-      label: '数据格式',
-      rules: [{ message: '请选择数据格式', required: true }],
-      defaultValue: RegisterDataTypeEnum.UN_SHORT,
-      componentProps: {
-        api: findDictItemByCode,
-        params: {
-          dictCode: DictEnum.REGISTER_DATA_FORMAT,
-        },
-        labelField: 'itemText',
-        valueField: 'itemValue',
-        placeholder: '请选择数据格式',
-        getPopupContainer: () => document.body,
+      field: FormFieldsEnum.ORIGINAL_DATA_TYPE,
+      label: FormFieldsNameEnum.ORIGINAL_DATA_TYPE,
+      component: 'Select',
+      required: true,
+      defaultValue: DEFAULT_ORIGINAL_TYPE,
+      dynamicDisabled: ({ model }) =>
+        BOOL_OPERATION_TYPE.includes(model[FormFieldsEnum.OPERATION_TYPE]) ||
+        unref(useObjectModelFormContext().getModalMode) === DataActionModeEnum.READ,
+      componentProps: ({ formActionType, formModel }) => {
+        const operationType = formModel[FormFieldsEnum.OPERATION_TYPE];
+
+        return {
+          options: getOriginalDataTypeByOperationType(operationType),
+          labelField: 'itemText',
+          valueField: 'itemValue',
+          placeholder: '请选择数据类型',
+          getPopupContainer: () => document.body,
+          onChange(value: OriginalDataTypeEnum) {
+            const { setFieldsValue } = formActionType;
+            setFieldsValue({
+              [FormFieldsEnum.VALUE_RANGE]: getValueRangeFromOriginDataType(
+                value as OriginalDataTypeEnum
+              ),
+            });
+          },
+        };
       },
       },
     },
     },
     {
     {
-      field: FormFieldsEnum.ACTION_TYPE,
+      field: FormFieldsEnum.BIT_MASK,
+      label: FormFieldsNameEnum.BIT_MASK,
       component: 'Select',
       component: 'Select',
-      label: '操作类型',
-      rules: [{ message: '请选择操作类型', required: true }],
+      ifShow: ({ model }) => model[FormFieldsEnum.ORIGINAL_DATA_TYPE] === OriginalDataTypeEnum.BITS,
+      required: true,
+      defaultValue: 7,
       componentProps: () => {
       componentProps: () => {
         return {
         return {
-          options: getActionTypeByObjectModelType(unref(getDataType)),
-          placeholder: '请选择操作类型',
+          options: Array.from({ length: 16 }, (_, index) => ({
+            label: `${index}`,
+            value: index,
+          })),
+          allowClear: false,
           getPopupContainer: () => document.body,
           getPopupContainer: () => document.body,
         };
         };
       },
       },
     },
     },
     {
     {
-      field: FormFieldsEnum.ZOOM_FACTOR,
+      field: FormFieldsEnum.VALUE_RANGE,
+      label: FormFieldsNameEnum.VALUE_RANGE,
+      component: 'CustomMinMaxInput',
+      rules: [{ required: true, validator: validateValueRange }],
+      changeEvent: 'update:value',
+      valueField: 'value',
+      defaultValue: BOOL_DEFAULT_VALUE_RANGE,
+      helpMessage: [
+        '取值范围指的是原始数据经过缩放因子处理之后的取值范围，超出取值范围的数据会被丢弃。',
+      ],
+      ifShow: ({ model }) =>
+        model[FormFieldsEnum.ORIGINAL_DATA_TYPE] !== OriginalDataTypeEnum.STRING,
+      componentProps: ({ formModel }) => {
+        const originalDataType = formModel[FormFieldsEnum.ORIGINAL_DATA_TYPE];
+
+        const { min, max } = getValueRangeFromOriginDataType(
+          originalDataType as OriginalDataTypeEnum
+        );
+
+        const flag = isFloatType(originalDataType);
+
+        return {
+          minInputProps: {
+            precision: 0,
+            min: flag ? undefined : min,
+            max: flag ? undefined : max,
+          },
+          maxInputProps: {
+            precision: 0,
+            min: flag ? undefined : min,
+            max: flag ? undefined : max,
+          },
+        };
+      },
+    },
+
+    {
+      field: FormFieldsEnum.SCALING,
+      label: FormFieldsNameEnum.SCALING,
       component: 'InputNumber',
       component: 'InputNumber',
-      label: '缩放因子',
-      helpMessage: ['缩放因子不能为0,默认为1'],
+      required: true,
       defaultValue: 1,
       defaultValue: 1,
+      helpMessage: ['缩放因子，不能为 0，默认为 1'],
       ifShow: ({ model }) =>
       ifShow: ({ model }) =>
-        ![DataTypeEnum.BOOL, DataTypeEnum.STRING].includes(model[FormFieldsEnum.OBJECT_MODEL_TYPE]),
-      componentProps: {
-        min: 1,
-        placeholder: '请输入缩放因子',
+        ![OriginalDataTypeEnum.STRING, OriginalDataTypeEnum.BOOLEAN].includes(
+          model[FormFieldsEnum.ORIGINAL_DATA_TYPE]
+        ),
+      rules: [
+        {
+          validator: (_rule, value: any) => {
+            if (Number(value) > 0) return Promise.resolve();
+            return Promise.reject(Error('缩放因子不能为0'));
+          },
+        },
+      ],
+      componentProps: () => {},
+    },
+    {
+      field: FormFieldsEnum.REGISTER_COUNT,
+      label: FormFieldsNameEnum.REGISTER_COUNT,
+      component: 'InputNumber',
+      helpMessage: ['操作类型为保持寄存器/输入寄存器时限制为1~125'],
+      ifShow: ({ model }) =>
+        model[FormFieldsEnum.ORIGINAL_DATA_TYPE] === OriginalDataTypeEnum.STRING,
+      required: true,
+      componentProps: () => {
+        return {
+          placeholder: '请输入寄存器个数',
+          min: 1,
+          max: 125,
+          precision: 0,
+        };
       },
       },
     },
     },
+    {
+      field: FormFieldsEnum.VALUE_MAPPING,
+      component: 'Input',
+      label: FormFieldsNameEnum.VALUE_MAPPING,
+      slot: FormFieldsEnum.VALUE_MAPPING,
+      defaultValue: [
+        { value: 0, name: '关' },
+        { value: 1, name: '开' },
+      ],
+      ifShow: ({ model }) =>
+        [OriginalDataTypeEnum.BOOLEAN, OriginalDataTypeEnum.BITS].includes(
+          model[FormFieldsEnum.ORIGINAL_DATA_TYPE]
+        ),
+    },
   ];
   ];
 };
 };

 export { default as ExtendDesc } from './index.vue';
 export { default as ExtendDesc } from './index.vue';
+
+import { FormFieldsEnum } from './config';
+import { Specs } from '/@/api/device/model/modelOfMatterModel';
+import { ExtendDescOperationTypeEnum, OriginalDataTypeEnum } from '/@/enums/objectModelEnum';
+
+export interface ExtendDescFormFieldsValueType {
+  [FormFieldsEnum.BIT_MASK]?: number;
+  [FormFieldsEnum.OPERATION_TYPE]: ExtendDescOperationTypeEnum;
+  [FormFieldsEnum.ORIGINAL_DATA_TYPE]: OriginalDataTypeEnum;
+  [FormFieldsEnum.REGISTER_ADDRESS]: string;
+  [FormFieldsEnum.SCALING]?: number;
+  [FormFieldsEnum.VALUE_RANGE]?: Record<'min' | 'max', number>;
+  [FormFieldsEnum.REGISTER_COUNT]?: number;
+  [FormFieldsEnum.VALUE_MAPPING]?: Specs[];
+}

 <script lang="ts" setup>
 <script lang="ts" setup>
-  import { Button } from 'ant-design-vue';
-  import { nextTick, ref, watch } from 'vue';
+  import { Button, Divider } from 'ant-design-vue';
+  import { nextTick, ref, unref, watch } from 'vue';
   import { BasicForm, useForm } from '/@/components/Form';
   import { BasicForm, useForm } from '/@/components/Form';
-  import { BasicModal } from '/@/components/Modal';
   import { PlusCircleOutlined } from '@ant-design/icons-vue';
   import { PlusCircleOutlined } from '@ant-design/icons-vue';
-  import { getFormSchemas } from './config';
-  import { ExtensionDesc } from '/@/api/device/model/modelOfMatterModel';
+  import { getExtendDescFormSchemas } from './config';
+  import { ExtendDescFormFieldsValueType } from '.';
+  import { BasicModal } from '/@/components/Modal';
+  import { PlusSquareOutlined, MinusSquareOutlined } from '@ant-design/icons-vue';
+  import {
+    ExtendDescOperationTypeEnum,
+    ExtendDescOperationTypeNameEnum,
+    OriginalDataTypeNameEnum,
+  } from '/@/enums/objectModelEnum';
+  import { EnumList } from '../EnumList';
 
 
   const show = ref(false);
   const show = ref(false);
 
 
   const props = withDefaults(
   const props = withDefaults(
     defineProps<{
     defineProps<{
-      value?: ExtensionDesc;
+      value?: ExtendDescFormFieldsValueType;
       disabled?: boolean;
       disabled?: boolean;
     }>(),
     }>(),
     {
     {
-      value: () => ({} as ExtensionDesc),
+      value: () => ({} as ExtendDescFormFieldsValueType),
     }
     }
   );
   );
 
 
-  const emit = defineEmits(['update:value']);
+  const emit = defineEmits(['update:value', 'change']);
 
 
   const [registerForm, { setFieldsValue, getFieldsValue, setProps, validate, resetFields }] =
   const [registerForm, { setFieldsValue, getFieldsValue, setProps, validate, resetFields }] =
     useForm({
     useForm({
-      schemas: getFormSchemas(),
+      schemas: getExtendDescFormSchemas(),
       showActionButtonGroup: false,
       showActionButtonGroup: false,
     });
     });
 
 
+  const infoExpandFlag = ref(false);
+
+  const enumListRef = ref<InstanceType<typeof EnumList>>();
+
   const handleClick = async () => {
   const handleClick = async () => {
     show.value = true;
     show.value = true;
     await nextTick();
     await nextTick();
@@ -37,24 +48,111 @@
 
 
   const handleSubmit = async () => {
   const handleSubmit = async () => {
     await validate();
     await validate();
-    const value = getFieldsValue();
+    await unref(enumListRef)?.validate();
+    const value = getFieldsValue() as ExtendDescFormFieldsValueType;
+    const valueMapping = unref(enumListRef)?.getFieldsValue();
+    value.valueMapping = valueMapping;
     emit('update:value', value);
     emit('update:value', value);
+    emit('change', value);
     show.value = false;
     show.value = false;
   };
   };
 
 
+  const handleDelete = () => {
+    emit('update:value', {});
+    emit('change', {});
+  };
+
   watch(show, async (value) => {
   watch(show, async (value) => {
     if (value) {
     if (value) {
       await nextTick();
       await nextTick();
       setFieldsValue({ ...props.value });
       setFieldsValue({ ...props.value });
     }
     }
   });
   });
+
+  const getOperationTypeName = (operationType: ExtendDescOperationTypeEnum) => {
+    const key = Object.keys(ExtendDescOperationTypeEnum).find(
+      (key) => ExtendDescOperationTypeEnum[key] === operationType
+    );
+
+    return key ? ExtendDescOperationTypeNameEnum[key] : key;
+  };
 </script>
 </script>
 
 
 <template>
 <template>
   <section>
   <section>
-    <Button type="link" @click="handleClick"><PlusCircleOutlined />新增扩展描述</Button>
-    <BasicModal title="扩展描述" v-model:visible="show" @ok="handleSubmit" :show-ok-btn="!disabled">
-      <BasicForm class="extension-form" @register="registerForm" />
+    <Button v-if="!value.operationType" type="link" @click="handleClick">
+      <PlusCircleOutlined />
+      新增扩展描述
+    </Button>
+    <main v-if="value.operationType" class="flex">
+      <div class="flex-auto flex text-gray-400 bg-blue-50 text-xs p-2 border gap-2 border-gray-100">
+        <div text-base>
+          <PlusSquareOutlined
+            v-if="!infoExpandFlag"
+            class="cursor-pointer"
+            @click="infoExpandFlag = !infoExpandFlag"
+          />
+          <MinusSquareOutlined
+            v-else
+            class="cursor-pointer"
+            @click="infoExpandFlag = !infoExpandFlag"
+          />
+        </div>
+        <div>
+          <div class="mb-2">
+            <span class="text-gray-400">操作类型</span>
+            <span class="ml-2">{{ getOperationTypeName(value.operationType) }}</span>
+          </div>
+          <section
+            class="flex flex-col gap-2 overflow-hidden transition"
+            :class="infoExpandFlag ? '' : 'h-0'"
+          >
+            <div>
+              <span>寄存器地址:</span>
+              <span class="ml-2">{{ value.registerAddress }}</span>
+            </div>
+            <div>
+              <span>原始数据类型:</span>
+              <span class="ml-2">{{ OriginalDataTypeNameEnum[value.originalDataType] }}</span>
+            </div>
+            <div v-if="value.scaling">
+              <span>缩放因子:</span>
+              <span class="ml-2">{{ value.scaling }}</span>
+            </div>
+            <div v-if="value.valueRange">
+              <span>取值范围:</span>
+              <span class="ml-2">{{ value.valueRange?.min }} ~ {{ value.valueRange?.max }}</span>
+            </div>
+          </section>
+        </div>
+      </div>
+      <div class="ml-2">
+        <Button class="!px-0" @click="handleClick" type="link">
+          {{ disabled ? '查看' : '编辑' }}
+        </Button>
+        <Divider v-if="!disabled" type="vertical" />
+        <Button class="!px-0" @click="handleDelete" type="link" v-if="!disabled"> 删除 </Button>
+      </div>
+    </main>
+
+    <BasicModal
+      title="扩展描述"
+      v-model:visible="show"
+      @ok="handleSubmit"
+      :show-ok-btn="!disabled"
+      :width="480"
+    >
+      <BasicForm class="extension-form" @register="registerForm">
+        <template #valueMapping="{ model, field }">
+          <EnumList
+            ref="enumListRef"
+            v-model:value="model[field]"
+            :disabled="disabled"
+            :required="false"
+            add-button-name="+添加值映射"
+          />
+        </template>
+      </BasicForm>
     </BasicModal>
     </BasicModal>
   </section>
   </section>
 </template>
 </template>

+import {
+  DataTypeEnum,
+  ExtendDescOperationTypeEnum,
+  ObjectModelAccessModeEnum,
+  OriginalDataTypeEnum,
+} from '/@/enums/objectModelEnum';
+
+export function isNumberType(originalDataType: OriginalDataTypeEnum) {
+  return ![
+    OriginalDataTypeEnum.BITS,
+    OriginalDataTypeEnum.BOOLEAN,
+    OriginalDataTypeEnum.STRING,
+  ].includes(originalDataType);
+}
+
+export function isFloatType(originalDataType: OriginalDataTypeEnum) {
+  return [
+    OriginalDataTypeEnum.FLOAT_AB_CD,
+    OriginalDataTypeEnum.FLOAT_BA_DC,
+    OriginalDataTypeEnum.FLOAT_CD_AB,
+    OriginalDataTypeEnum.FLOAT_DC_BA,
+    OriginalDataTypeEnum.DOUBLE,
+  ].includes(originalDataType);
+}
+
+export function getDataTypeByOriginalDataType(originalDataType: OriginalDataTypeEnum) {
+  if (originalDataType === OriginalDataTypeEnum.STRING) return DataTypeEnum.STRING;
+  else if (originalDataType === OriginalDataTypeEnum.BOOLEAN) return DataTypeEnum.BOOL;
+  else if (isFloatType(originalDataType)) return DataTypeEnum.NUMBER_DOUBLE;
+  else return DataTypeEnum.NUMBER_INT;
+}
+
+export function useParseOperationType(actionType: ExtendDescOperationTypeEnum) {
+  const [_, accessMode, inputOrOutput, output = undefined] = (actionType || '').split('_');
+
+  const _accessMode =
+    accessMode === ObjectModelAccessModeEnum.READ
+      ? ObjectModelAccessModeEnum.READ
+      : ObjectModelAccessModeEnum.READ_AND_WRITE;
+
+  const writeOnly =
+    _accessMode === ObjectModelAccessModeEnum.READ_AND_WRITE &&
+    accessMode !== ObjectModelAccessModeEnum.READ_AND_WRITE;
+
+  return {
+    accessMode: _accessMode,
+    originAccessMode: accessMode,
+    writeOnly,
+    readRegisterAddress: writeOnly ? undefined : inputOrOutput,
+    writeRegisterAddress: writeOnly ? inputOrOutput : output,
+  };
+}

+export enum InputTypeEnum {
+  /**
+   * @description 16进制
+   */
+  HEX = 'HEX',
+
+  /**
+   * @description 10进制
+   */
+  DEC = 'DEC',
+}

+export { default as HexInput } from './index.vue';
+export { InputTypeEnum } from './config';

+<script setup lang="ts">
+  import { InputGroup, Select, Input } from 'ant-design-vue';
+  import { computed, ref, unref } from 'vue';
+  import { InputTypeEnum } from './config';
+  import { isNullOrUnDef } from '/@/utils/is';
+
+  const props = withDefaults(
+    defineProps<{
+      type?: InputTypeEnum;
+      value?: number | string;
+      hexWithPrefix?: boolean;
+      hexUpperCase?: boolean;
+      disabled?: boolean;
+      maxValue?: number;
+      showScaleSelect?: boolean;
+    }>(),
+    {
+      type: InputTypeEnum.HEX,
+      hexWithPrefix: false,
+      hexUpperCase: true,
+      maxValue: Number.MAX_SAFE_INTEGER,
+      showScaleSelect: true,
+    }
+  );
+
+  const emits = defineEmits(['update:value', 'change']);
+
+  const typOptions = Object.values(InputTypeEnum).map((value) => ({ label: value, value }));
+
+  const inputType = ref(props.type);
+
+  const validateDECReg = /^[\d]+$/;
+
+  const validateHEXReg = /^(0x)?[\da-fA-F]+$/;
+
+  const getMaxValue = computed(() => {
+    const { maxValue } = props;
+    return maxValue;
+  });
+
+  const getDecToHex = (value: number | string) => {
+    const { hexUpperCase, hexWithPrefix } = props;
+    let hex = Number(value).toString(16);
+    hex = hexUpperCase ? hex.toUpperCase() : hex;
+    return `${hexWithPrefix ? '0x' : ''}${hex}`;
+  };
+
+  const getHexToDec = (value: number | string) => {
+    return parseInt(value, 16);
+  };
+
+  const getDECValue = (value: number | string) => {
+    return parseInt(value, unref(inputType) === InputTypeEnum.HEX ? 16 : 10);
+  };
+
+  const getFormatValue = (value: number | string) => {
+    if (unref(inputType) === InputTypeEnum.HEX) {
+      const { hexUpperCase, hexWithPrefix } = props;
+      if (hexUpperCase) value = value.toString().toUpperCase();
+      if (hexWithPrefix) value = `0x${value}`;
+      return value;
+    }
+
+    return value;
+  };
+
+  const getInputValue = computed({
+    get() {
+      const { type, value } = props;
+
+      if (isNullOrUnDef(value)) return;
+
+      if (type === unref(inputType)) return value;
+
+      if (type === InputTypeEnum.HEX && unref(inputType) === InputTypeEnum.DEC) {
+        return getHexToDec(value);
+      } else {
+        return getDecToHex(value);
+      }
+    },
+    set(value: string) {
+      const { type } = props;
+
+      if (unref(inputType) === InputTypeEnum.HEX) value = value.replace('0x', '');
+
+      if (!value) {
+        emits('update:value', undefined);
+        return;
+      }
+
+      if (unref(inputType) === InputTypeEnum.HEX && !validateHEXReg.test(value)) return;
+
+      if (unref(inputType) === InputTypeEnum.DEC && !validateDECReg.test(value)) return;
+
+      if (getDECValue(value) > unref(getMaxValue)) return;
+
+      if (type === unref(inputType)) {
+        emits('update:value', getFormatValue(value));
+        return;
+      }
+
+      if (type === InputTypeEnum.HEX && unref(inputType) === InputTypeEnum.DEC) {
+        emits('update:value', getDecToHex(value));
+      } else {
+        emits('update:value', getHexToDec(value));
+      }
+    },
+  });
+
+  const getNegationValue = computed(() => {
+    const { hexWithPrefix } = props;
+    if (isNullOrUnDef(unref(getInputValue))) return 0;
+    return unref(inputType) === InputTypeEnum.HEX
+      ? getHexToDec(unref(getInputValue)!)
+      : `${hexWithPrefix ? '0x' : ''}${Number(unref(getInputValue)).toString(16).toUpperCase()}`;
+  });
+</script>
+
+<template>
+  <InputGroup class="!flex w-full h-full justify-center items-center" compact>
+    <Select
+      v-if="showScaleSelect"
+      v-model:value="inputType"
+      class="min-w-20"
+      :options="typOptions"
+      :disabled="disabled"
+    />
+    <Input v-bind="$attrs" v-model:value="getInputValue" class="!w-full" :disabled="disabled" />
+    <div class="min-w-14 h-full px-2 flex-grow flex-shrink-0 text-center leading-8 bg-gray-200">
+      {{ getNegationValue }}
+    </div>
+  </InputGroup>
+</template>

-import { FormFieldsEnum, FormFieldsNameEnum } from '../config';
-import { findDictItemByCode } from '/@/api/system/dict';
-import { FormSchema } from '/@/components/Form';
-import { DictEnum } from '/@/enums/dictEnum';
-import { DataTypeEnum, FunctionTypeEnum, FunctionTypeNameEnum } from '/@/enums/objectModelEnum';
-import { isNullOrUnDef } from '/@/utils/is';
-
-export const validateValueRange = (_rule, value: Record<'min' | 'max', number>, _callback) => {
-  value = value || {};
-  const { min, max } = value;
-  if (min > max) {
-    return Promise.reject('最大值小于最小值');
-  }
-  return Promise.resolve();
-};
-
-export const getFormSchemas = (): FormSchema[] => {
-  return [
-    {
-      field: FormFieldsEnum.FUNCTION_TYPE,
-      label: FormFieldsNameEnum.FUNCTION_TYPE,
-      component: 'Segmented',
-      defaultValue: FunctionTypeEnum.PROPERTIES,
-      required: true,
-      componentProps: ({ formActionType }) => {
-        return {
-          options: Object.keys(FunctionTypeEnum).map((key) => ({
-            title: FunctionTypeNameEnum[key],
-            value: FunctionTypeEnum[key],
-          })),
-          onChange() {
-            const { setFieldsValue, clearValidate } = formActionType;
-            setFieldsValue({
-              [FormFieldsEnum.INPUT_DATA]: [],
-              [FormFieldsEnum.OUTPUT_DATA]: [],
-              [FormFieldsEnum.STRUCT_DATA]: [],
-              [FormFieldsEnum.SERVICE_COMMAND]: null,
-            });
-            clearValidate();
-          },
-        };
-      },
-    },
-    {
-      field: FormFieldsEnum.FUNCTION_NAME,
-      label: FormFieldsNameEnum.FUNCTION_NAME,
-      component: 'Input',
-      required: true,
-      dynamicRules: ({ values }) => {
-        return [
-          { required: true, message: '请输入功能名称' },
-          {
-            validator: () => {
-              const reg = /[,，]+/;
-              if (reg.test(values?.[FormFieldsEnum.FUNCTION_NAME])) {
-                return Promise.reject(`${FormFieldsNameEnum.FUNCTION_NAME}不能包含逗号`);
-              }
-              return Promise.resolve();
-            },
-          },
-        ];
-      },
-      componentProps: {
-        placeholder: `请输入${FormFieldsNameEnum.FUNCTION_NAME}`,
-      },
-    },
-    {
-      field: FormFieldsEnum.IDENTIFIER,
-      label: FormFieldsNameEnum.IDENTIFIER,
-      required: true,
-      component: 'Input',
-      componentProps: {
-        maxLength: 128,
-        placeholder: '请输入标识符',
-      },
-      dynamicRules: ({ values }) => {
-        return [
-          { required: true, message: '请输入标识符' },
-          {
-            validator: () => {
-              const reg = /[,，]+/;
-              if (reg.test(values?.[FormFieldsEnum.IDENTIFIER])) {
-                return Promise.reject(`${FormFieldsNameEnum.IDENTIFIER}不能包含逗号`);
-              }
-              return Promise.resolve();
-            },
-          },
-        ];
-      },
-    },
-    {
-      field: FormFieldsEnum.DATA_TYPE,
-      label: FormFieldsNameEnum.DATA_TYPE,
-      required: true,
-      component: 'ApiSelect',
-      defaultValue: DataTypeEnum.NUMBER_INT,
-      ifShow: ({ model }) =>
-        ![FunctionTypeEnum.SERVICE, FunctionTypeEnum.EVENTS].includes(
-          model[FormFieldsEnum.FUNCTION_TYPE]
-        ),
-      componentProps: () => {
-        return {
-          placeholder: '请选择数据类型',
-          api: async (params: Recordable) => {
-            const result = await findDictItemByCode(params);
-            return result;
-          },
-          params: {
-            dictCode: DictEnum.DATA_TYPE,
-          },
-          labelField: 'itemText',
-          valueField: 'itemValue',
-          getPopupContainer: () => document.body,
-        };
-      },
-    },
-    {
-      field: FormFieldsEnum.VALUE_RANGE,
-      label: FormFieldsNameEnum.VALUE_RANGE,
-      component: 'CustomMinMaxInput',
-      valueField: 'value',
-      changeEvent: 'update:value',
-      ifShow: ({ model }) =>
-        ![FunctionTypeEnum.SERVICE, FunctionTypeEnum.EVENTS].includes(
-          model[FormFieldsEnum.FUNCTION_TYPE]
-        ) &&
-        (model[FormFieldsEnum.DATA_TYPE] === DataTypeEnum.NUMBER_INT ||
-          model[FormFieldsEnum.DATA_TYPE] === DataTypeEnum.NUMBER_DOUBLE),
-      rules: [{ validator: validateValueRange }],
-    },
-    {
-      field: FormFieldsEnum.STEP,
-      label: FormFieldsNameEnum.STEP,
-      component: 'InputNumber',
-      componentProps: {
-        maxLength: 255,
-        placeholder: '请输入步长',
-        min: 1,
-        formatter: (value: number | string) => {
-          return value ? Math.floor(Number(value)) : value;
-        },
-      },
-      ifShow: ({ model }) =>
-        ![FunctionTypeEnum.SERVICE, FunctionTypeEnum.EVENTS].includes(
-          model[FormFieldsEnum.FUNCTION_TYPE]
-        ) &&
-        (model[FormFieldsEnum.DATA_TYPE] === DataTypeEnum.NUMBER_INT ||
-          model[FormFieldsEnum.DATA_TYPE] === DataTypeEnum.NUMBER_DOUBLE),
-      dynamicRules: ({ model }) => {
-        const valueRange = model[FormFieldsEnum.VALUE_RANGE] || {};
-        const { min, max } = valueRange;
-        const step = model[FormFieldsEnum.STEP];
-        return [
-          {
-            validator: () => {
-              if ([min, max].every(isNullOrUnDef)) return Promise.resolve();
-              if (step > max - min) {
-                return Promise.reject('步长不能大于取值范围的差值');
-              }
-              return Promise.resolve();
-            },
-          },
-        ];
-      },
-    },
-    {
-      field: FormFieldsEnum.UNIT_NAME,
-      label: FormFieldsNameEnum.UNIT_NAME,
-      component: 'Input',
-      show: false,
-    },
-    {
-      field: FormFieldsEnum.UNIT,
-      label: FormFieldsNameEnum.UNIT,
-      component: 'ApiSelect',
-      componentProps: ({ formActionType }) => {
-        const { setFieldsValue } = formActionType;
-        return {
-          placeholder: '请选择单位',
-          api: async (params: Recordable) => {
-            const list = await findDictItemByCode(params);
-            list.map((item) => (item.itemText = `${item.itemText} / ${item.itemValue}`));
-            return list;
-          },
-          params: {
-            dictCode: DictEnum.ATTRIBUTE_UNIT,
-          },
-          labelInValue: true,
-          labelField: 'itemText',
-          valueField: 'itemValue',
-          onChange(_, record: Record<'label' | 'value', string>) {
-            if (record) {
-              const { label } = record;
-              setFieldsValue({ [FormFieldsEnum.UNIT_NAME]: label });
-            }
-          },
-          getPopupContainer: () => document.body,
-          showSearch: true,
-          filterOption: (inputValue: string, option: Record<'label' | 'value', string>) => {
-            let { label, value } = option;
-            label = label.toLowerCase();
-            value = value.toLowerCase();
-            inputValue = inputValue.toLowerCase();
-            return label.includes(inputValue) || value.includes(inputValue);
-          },
-        };
-      },
-      ifShow: ({ model }) =>
-        ![FunctionTypeEnum.SERVICE, FunctionTypeEnum.EVENTS].includes(
-          model[FormFieldsEnum.FUNCTION_TYPE]
-        ) &&
-        (model[FormFieldsEnum.DATA_TYPE] === DataTypeEnum.NUMBER_INT ||
-          model[FormFieldsEnum.DATA_TYPE] === DataTypeEnum.NUMBER_DOUBLE),
-    },
-    {
-      field: FormFieldsEnum.BOOL_CLOSE,
-      component: 'Input',
-      required: true,
-      label: FormFieldsNameEnum.BOOL_CLOSE,
-      componentProps: {
-        placeholder: '如：关',
-      },
-      defaultValue: '关',
-      ifShow: ({ model }) =>
-        ![FunctionTypeEnum.SERVICE, FunctionTypeEnum.EVENTS].includes(
-          model[FormFieldsEnum.FUNCTION_TYPE]
-        ) && model[FormFieldsEnum.DATA_TYPE] === DataTypeEnum.BOOL,
-      dynamicRules: ({ model }) => {
-        const close = model[FormFieldsEnum.BOOL_CLOSE];
-        const open = model[FormFieldsEnum.BOOL_OPEN];
-        return [
-          {
-            required: true,
-            message: `布尔值不能为空`,
-          },
-          {
-            validator() {
-              if (open === close) return Promise.reject('布尔值不能相同');
-              return Promise.resolve();
-            },
-          },
-        ];
-      },
-    },
-    {
-      field: FormFieldsEnum.BOOL_OPEN,
-      component: 'Input',
-      required: true,
-      label: FormFieldsNameEnum.BOOL_OPEN,
-      componentProps: {
-        placeholder: '如：开',
-      },
-      defaultValue: '开',
-      ifShow: ({ model }) =>
-        ![FunctionTypeEnum.SERVICE, FunctionTypeEnum.EVENTS].includes(
-          model[FormFieldsEnum.FUNCTION_TYPE]
-        ) && model[FormFieldsEnum.DATA_TYPE] === DataTypeEnum.BOOL,
-      dynamicRules: ({ model }) => {
-        const close = model[FormFieldsEnum.BOOL_CLOSE];
-        const open = model[FormFieldsEnum.BOOL_OPEN];
-        return [
-          {
-            required: true,
-            message: `布尔值不能为空`,
-          },
-          {
-            validator() {
-              if (open === close) return Promise.reject('布尔值不能相同');
-              return Promise.resolve();
-            },
-          },
-        ];
-      },
-    },
-    {
-      field: FormFieldsEnum.LENGTH,
-      component: 'Input',
-      required: true,
-      label: FormFieldsNameEnum.LENGTH,
-      defaultValue: '10240',
-      colProps: {
-        span: 8,
-      },
-      componentProps: {
-        placeholder: '请输入数据长度',
-      },
-      renderComponentContent: () => {
-        return {
-          suffix: () => '字节',
-        };
-      },
-      ifShow: ({ model }) =>
-        ![FunctionTypeEnum.SERVICE, FunctionTypeEnum.EVENTS].includes(
-          model[FormFieldsEnum.FUNCTION_TYPE]
-        ) && model[FormFieldsEnum.DATA_TYPE] === DataTypeEnum.STRING,
-    },
-    {
-      field: FormFieldsEnum.ENUMS_DATA,
-      label: FormFieldsNameEnum.ENUMS_DATA,
-      component: 'Input',
-      slot: FormFieldsEnum.ENUMS_DATA,
-      changeEvent: 'update:value',
-      valueField: 'value',
-      ifShow: ({ model }) =>
-        ![FunctionTypeEnum.SERVICE, FunctionTypeEnum.EVENTS].includes(
-          model[FormFieldsEnum.FUNCTION_TYPE]
-        ) && model[FormFieldsEnum.DATA_TYPE] === DataTypeEnum.ENUM,
-    },
-    {
-      field: FormFieldsEnum.STRUCT_DATA,
-      label: FormFieldsNameEnum.STRUCT_DATA,
-      component: 'Input',
-      slot: FormFieldsEnum.STRUCT_DATA,
-      changeEvent: 'update:value',
-      valueField: 'value',
-      required: true,
-      ifShow: ({ model }) =>
-        model[FormFieldsEnum.DATA_TYPE] === DataTypeEnum.STRUCT &&
-        ![FunctionTypeEnum.SERVICE, FunctionTypeEnum.EVENTS].includes(
-          model[FormFieldsEnum.FUNCTION_TYPE]
-        ),
-    },
-  ];
-};

@@ -98,4 +98,3 @@
     />
     />
   </section>
   </section>
 </template>
 </template>
-./index.config

@@ -7,6 +7,7 @@ import { FormSchema } from '/@/components/Form';
 import {
 import {
   ServiceCallTypeEnum,
   ServiceCallTypeEnum,
   ServiceCallTypeNameEnum,
   ServiceCallTypeNameEnum,
+  TCPProtocolTypeEnum,
   TransportTypeEnum,
   TransportTypeEnum,
 } from '/@/enums/deviceEnum';
 } from '/@/enums/deviceEnum';
 import { DictEnum } from '/@/enums/dictEnum';
 import { DictEnum } from '/@/enums/dictEnum';
@@ -15,8 +16,11 @@ import {
   FunctionTypeEnum,
   FunctionTypeEnum,
   FunctionTypeNameEnum,
   FunctionTypeNameEnum,
   ObjectEventTypeEnum,
   ObjectEventTypeEnum,
+  BuiltInIdentifierEnum,
 } from '/@/enums/objectModelEnum';
 } from '/@/enums/objectModelEnum';
 import { DataActionModeEnum } from '/@/enums/toolEnum';
 import { DataActionModeEnum } from '/@/enums/toolEnum';
+import { DeviceTypeEnum } from '/@/api/device/model/deviceModel';
+import { DeviceProfileDetail } from '/@/api/device/model/deviceConfigModel';
 
 
 export enum FormFieldsEnum {
 export enum FormFieldsEnum {
   FUNCTION_TYPE = 'functionType',
   FUNCTION_TYPE = 'functionType',
@@ -74,10 +78,18 @@ export enum FormFieldsNameEnum {
 
 
 export const getFormSchemas = ({
 export const getFormSchemas = ({
   transportType,
   transportType,
+  deviceRecord,
 }: {
 }: {
   transportType?: string;
   transportType?: string;
   mode?: DataActionModeEnum;
   mode?: DataActionModeEnum;
+  deviceRecord?: DeviceProfileDetail;
 }): FormSchema[] => {
 }): FormSchema[] => {
+  const isTCPTransport = deviceRecord?.transportType === TransportTypeEnum.TCP;
+
+  const isTCPModbusProduct =
+    isTCPTransport &&
+    deviceRecord?.profileData.transportConfiguration.protocol === TCPProtocolTypeEnum.MODBUS_RTU;
+
   return [
   return [
     {
     {
       field: FormFieldsEnum.FUNCTION_TYPE,
       field: FormFieldsEnum.FUNCTION_TYPE,
@@ -85,16 +97,29 @@ export const getFormSchemas = ({
       component: 'Segmented',
       component: 'Segmented',
       defaultValue: FunctionTypeEnum.PROPERTIES,
       defaultValue: FunctionTypeEnum.PROPERTIES,
       required: true,
       required: true,
+      helpMessage: [
+        '属性一般是指设备的运行状态，如当前温度等；服务是指设备可被调用的方法，支持定义参数，如执行某项任务；事件则是指设备上报的通知，如告警，需要被及时处理。',
+      ],
       dynamicDisabled: () => {
       dynamicDisabled: () => {
         const { getModalMode } = useObjectModelFormContext();
         const { getModalMode } = useObjectModelFormContext();
         return unref(getModalMode) !== DataActionModeEnum.CREATE;
         return unref(getModalMode) !== DataActionModeEnum.CREATE;
       },
       },
       componentProps: ({ formActionType }) => {
       componentProps: ({ formActionType }) => {
+        const isSensor = deviceRecord?.deviceType === DeviceTypeEnum.SENSOR;
         return {
         return {
-          options: Object.keys(FunctionTypeEnum).map((key) => ({
-            title: FunctionTypeNameEnum[key],
-            value: FunctionTypeEnum[key],
-          })),
+          options: [
+            { title: FunctionTypeNameEnum.PROPERTIES, value: FunctionTypeEnum.PROPERTIES },
+            {
+              title: FunctionTypeNameEnum.SERVICE,
+              value: FunctionTypeEnum.SERVICE,
+              disabled: (isTCPTransport && isSensor) || isTCPModbusProduct,
+            },
+            {
+              title: FunctionTypeNameEnum.EVENTS,
+              value: FunctionTypeEnum.EVENTS,
+              disabled: isTCPTransport,
+            },
+          ],
           onChange() {
           onChange() {
             const { setFieldsValue, clearValidate } = formActionType;
             const { setFieldsValue, clearValidate } = formActionType;
             setFieldsValue({
             setFieldsValue({
@@ -112,26 +137,26 @@ export const getFormSchemas = ({
       field: FormFieldsEnum.DATA_TYPE_FORM,
       field: FormFieldsEnum.DATA_TYPE_FORM,
       component: 'Input',
       component: 'Input',
       label: '',
       label: '',
-      ifShow: ({ model }) => model[FormFieldsEnum.FUNCTION_TYPE] === FunctionTypeEnum.PROPERTIES,
+      ifShow: ({ model }) =>
+        model[FormFieldsEnum.FUNCTION_TYPE] === FunctionTypeEnum.PROPERTIES && !isTCPModbusProduct,
       colSlot: FormFieldsEnum.DATA_TYPE_FORM,
       colSlot: FormFieldsEnum.DATA_TYPE_FORM,
     },
     },
     createFunctionNameFormItem({
     createFunctionNameFormItem({
-      ifShow: ({ model }) => model[FormFieldsEnum.FUNCTION_TYPE] !== FunctionTypeEnum.PROPERTIES,
+      ifShow: ({ model }) =>
+        model[FormFieldsEnum.FUNCTION_TYPE] !== FunctionTypeEnum.PROPERTIES || isTCPModbusProduct,
     }),
     }),
     createIdentifierFormItem({
     createIdentifierFormItem({
-      ifShow: ({ model }) => model[FormFieldsEnum.FUNCTION_TYPE] !== FunctionTypeEnum.PROPERTIES,
-    }),
-    {
-      field: FormFieldsEnum.EXTENSION_DESC,
-      component: 'Input',
-      label: FormFieldsNameEnum.EXTENSION_DESC,
-      slot: FormFieldsEnum.EXTENSION_DESC,
+      helpMessage: ['支持大小写字母、数字和下划线', '如要支持原始数据留存,请使用标识符 "source"'],
       ifShow: ({ model }) =>
       ifShow: ({ model }) =>
-        transportType === TransportTypeEnum.TCP &&
-        ![FunctionTypeEnum.SERVICE, FunctionTypeEnum.EVENTS].includes(
-          model[FormFieldsEnum.FUNCTION_TYPE]
-        ),
-    },
+        model[FormFieldsEnum.FUNCTION_TYPE] !== FunctionTypeEnum.PROPERTIES || isTCPModbusProduct,
+      component: 'AutoComplete',
+      defaultValue: '',
+      componentProps: {
+        options: isTCPModbusProduct ? [{ value: BuiltInIdentifierEnum.SOURCE }] : [],
+        placeholder: '请输入功能标识符',
+        autocomplete: false,
+      },
+    }),
     {
     {
       field: FormFieldsEnum.ACCESS_MODE,
       field: FormFieldsEnum.ACCESS_MODE,
       component: 'ApiRadioGroup',
       component: 'ApiRadioGroup',
@@ -140,7 +165,7 @@ export const getFormSchemas = ({
       ifShow: ({ model }) =>
       ifShow: ({ model }) =>
         ![FunctionTypeEnum.SERVICE, FunctionTypeEnum.EVENTS].includes(
         ![FunctionTypeEnum.SERVICE, FunctionTypeEnum.EVENTS].includes(
           model[FormFieldsEnum.FUNCTION_TYPE]
           model[FormFieldsEnum.FUNCTION_TYPE]
-        ),
+        ) && !isTCPModbusProduct,
       defaultValue: ObjectModelAccessModeEnum.READ_AND_WRITE,
       defaultValue: ObjectModelAccessModeEnum.READ_AND_WRITE,
       componentProps: {
       componentProps: {
         placeholder: '请选择读写类型',
         placeholder: '请选择读写类型',
@@ -232,6 +257,70 @@ export const getFormSchemas = ({
         ),
         ),
     },
     },
 
 
+    // TCP Modbus
+    {
+      field: FormFieldsEnum.UNIT_NAME,
+      label: FormFieldsNameEnum.UNIT_NAME,
+      component: 'Input',
+      show: false,
+    },
+    {
+      field: FormFieldsEnum.UNIT,
+      label: FormFieldsNameEnum.UNIT,
+      component: 'ApiSelect',
+      ifShow: () => isTCPModbusProduct,
+      componentProps: ({ formActionType }) => {
+        const { setFieldsValue } = formActionType;
+        return {
+          placeholder: '请选择单位',
+          api: async (params: Recordable) => {
+            const list = await findDictItemByCode(params);
+            list.map((item) => (item.itemText = `${item.itemText} / ${item.itemValue}`));
+            return list;
+          },
+          params: {
+            dictCode: DictEnum.ATTRIBUTE_UNIT,
+          },
+          labelField: 'itemText',
+          valueField: 'itemValue',
+          onChange(_, record: Record<'label' | 'value', string>) {
+            if (record) {
+              const { label } = record;
+              setFieldsValue({ [FormFieldsEnum.UNIT_NAME]: label });
+            }
+          },
+          getPopupContainer: () => document.body,
+          showSearch: true,
+          filterOption: (inputValue: string, option: Record<'label' | 'value', string>) => {
+            let { label, value } = option;
+            label = label.toLowerCase();
+            value = value.toLowerCase();
+            inputValue = inputValue.toLowerCase();
+            return label.includes(inputValue) || value.includes(inputValue);
+          },
+        };
+      },
+    },
+    {
+      field: FormFieldsEnum.EXTENSION_DESC,
+      component: 'Input',
+      label: FormFieldsNameEnum.EXTENSION_DESC,
+      slot: FormFieldsEnum.EXTENSION_DESC,
+      helpMessage: ['扩展描述用于配置设备接入网关协议和物模型定义之间的映射关系。'],
+      rules: [
+        {
+          required: true,
+          validator(_rule, value: any) {
+            return Object.values(value || {}).length
+              ? Promise.resolve()
+              : Promise.reject('请填写拓展描述符');
+          },
+        },
+      ],
+      ifShow: ({ model }) =>
+        isTCPModbusProduct && model[FormFieldsEnum.IDENTIFIER] !== BuiltInIdentifierEnum.SOURCE,
+    },
+
     {
     {
       field: FormFieldsEnum.REMARK,
       field: FormFieldsEnum.REMARK,
       label: FormFieldsNameEnum.REMARK,
       label: FormFieldsNameEnum.REMARK,

@@ -3,18 +3,14 @@
   import { getFormSchemas, FormFieldsEnum } from './config';
   import { getFormSchemas, FormFieldsEnum } from './config';
   import { StructFormItem } from './StructFormItem';
   import { StructFormItem } from './StructFormItem';
   import { useObjectFormData } from './useObjectFormData';
   import { useObjectFormData } from './useObjectFormData';
-  import { computed, ref, unref } from 'vue';
-  import { TransportTypeEnum } from '/@/enums/deviceEnum';
+  import { computed, ref } from 'vue';
   import { DataTypeForm } from './DataTypeForm';
   import { DataTypeForm } from './DataTypeForm';
   import { DataActionModeEnum } from '/@/enums/toolEnum';
   import { DataActionModeEnum } from '/@/enums/toolEnum';
   import { ExtendDesc } from './ExtendDesc';
   import { ExtendDesc } from './ExtendDesc';
   import { createObjectModelFormContext } from './useObjectModelFormContext';
   import { createObjectModelFormContext } from './useObjectModelFormContext';
-  import { DataTypeEnum } from '/@/enums/objectModelEnum';
+  import { ObjectModelFormPropsType } from './types';
 
 
-  const props = defineProps<{
-    transportType?: TransportTypeEnum;
-    mode?: DataActionModeEnum;
-  }>();
+  const props = defineProps<ObjectModelFormPropsType>();
 
 
   const dataTypeFormRef = ref<InstanceType<typeof DataTypeForm>>();
   const dataTypeFormRef = ref<InstanceType<typeof DataTypeForm>>();
 
 
@@ -23,27 +19,20 @@
     layout: 'vertical',
     layout: 'vertical',
     showActionButtonGroup: false,
     showActionButtonGroup: false,
   });
   });
-
   const { getFieldsValue, setFieldsValue, validate, resetFieldsValue } = useObjectFormData({
   const { getFieldsValue, setFieldsValue, validate, resetFieldsValue } = useObjectFormData({
     formActionType,
     formActionType,
     dataTypeFormRef,
     dataTypeFormRef,
-    transportType: props.transportType!,
+    propsRef: props,
   });
   });
 
 
-  const objectModelType = ref(DataTypeEnum.NUMBER_INT);
-
   createObjectModelFormContext({
   createObjectModelFormContext({
     getTransportType: computed(() => props.transportType),
     getTransportType: computed(() => props.transportType),
-    getDataType: computed(() => unref(objectModelType)),
     getModalMode: computed(() => props.mode),
     getModalMode: computed(() => props.mode),
   });
   });
 
 
-  const handleDataTypeFormChange = (field: string, value: any) => {
-    if (field === FormFieldsEnum.DATA_TYPE) {
-      objectModelType.value = value;
-    }
+  const handleValidateExtendDesc = () => {
+    formActionType.clearValidate(FormFieldsEnum.EXTENSION_DESC);
   };
   };
-
   defineExpose({
   defineExpose({
     getFieldsValue,
     getFieldsValue,
     setFieldsValue,
     setFieldsValue,
@@ -55,11 +44,7 @@
 <template>
 <template>
   <BasicForm @register="register" :disabled="mode === DataActionModeEnum.READ">
   <BasicForm @register="register" :disabled="mode === DataActionModeEnum.READ">
     <template #dataTypeForm>
     <template #dataTypeForm>
-      <DataTypeForm
-        ref="dataTypeFormRef"
-        :mode="mode"
-        @field-value-change="handleDataTypeFormChange"
-      />
+      <DataTypeForm ref="dataTypeFormRef" :mode="mode" />
     </template>
     </template>
     <template #inputData="{ model, field }">
     <template #inputData="{ model, field }">
       <StructFormItem v-model:value="model[field]" buttonName="+ 增加参数" :mode="mode" />
       <StructFormItem v-model:value="model[field]" buttonName="+ 增加参数" :mode="mode" />
@@ -68,7 +53,11 @@
       <StructFormItem v-model:value="model[field]" buttonName="+ 增加参数" :mode="mode" />
       <StructFormItem v-model:value="model[field]" buttonName="+ 增加参数" :mode="mode" />
     </template>
     </template>
     <template #extensionDesc="{ model, field }">
     <template #extensionDesc="{ model, field }">
-      <ExtendDesc v-model:value="model[field]" :disabled="mode === DataActionModeEnum.READ" />
+      <ExtendDesc
+        v-model:value="model[field]"
+        :disabled="mode === DataActionModeEnum.READ"
+        @change="handleValidateExtendDesc"
+      />
     </template>
     </template>
   </BasicForm>
   </BasicForm>
 </template>
 </template>

+import { ExtendDescFormFieldsValueType } from './ExtendDesc';
 import { FormFieldsEnum } from './config';
 import { FormFieldsEnum } from './config';
-import { ExtensionDesc, StructJSON } from '/@/api/device/model/modelOfMatterModel';
-import { ServiceCallTypeEnum } from '/@/enums/deviceEnum';
+import { DeviceProfileDetail } from '/@/api/device/model/deviceConfigModel';
+import { StructJSON } from '/@/api/device/model/modelOfMatterModel';
+import { ServiceCallTypeEnum, TransportTypeEnum } from '/@/enums/deviceEnum';
 import {
 import {
   FunctionTypeEnum,
   FunctionTypeEnum,
   ObjectEventTypeEnum,
   ObjectEventTypeEnum,
   ObjectModelAccessModeEnum,
   ObjectModelAccessModeEnum,
 } from '/@/enums/objectModelEnum';
 } from '/@/enums/objectModelEnum';
+import { DataActionModeEnum } from '/@/enums/toolEnum';
+
+export interface ObjectModelFormPropsType {
+  transportType?: TransportTypeEnum;
+  mode?: DataActionModeEnum;
+  deviceRecord?: DeviceProfileDetail;
+}
 
 
 export interface ObjectModelFormGetFieldsValueType {
 export interface ObjectModelFormGetFieldsValueType {
   [FormFieldsEnum.FUNCTION_TYPE]: FunctionTypeEnum;
   [FormFieldsEnum.FUNCTION_TYPE]: FunctionTypeEnum;
@@ -14,16 +23,13 @@ export interface ObjectModelFormGetFieldsValueType {
   [FormFieldsEnum.FUNCTION_NAME]: string;
   [FormFieldsEnum.FUNCTION_NAME]: string;
   [FormFieldsEnum.IDENTIFIER]: string;
   [FormFieldsEnum.IDENTIFIER]: string;
   [FormFieldsEnum.EVENT_TYPE]?: ObjectEventTypeEnum;
   [FormFieldsEnum.EVENT_TYPE]?: ObjectEventTypeEnum;
+  [FormFieldsEnum.UNIT]?: string;
+  [FormFieldsEnum.UNIT_NAME]: string;
 
 
   [FormFieldsEnum.CALL_TYPE]?: ServiceCallTypeEnum;
   [FormFieldsEnum.CALL_TYPE]?: ServiceCallTypeEnum;
   [FormFieldsEnum.INPUT_DATA]?: StructJSON[];
   [FormFieldsEnum.INPUT_DATA]?: StructJSON[];
   [FormFieldsEnum.OUTPUT_DATA]?: StructJSON[];
   [FormFieldsEnum.OUTPUT_DATA]?: StructJSON[];
 
 
   [FormFieldsEnum.SERVICE_COMMAND]?: string;
   [FormFieldsEnum.SERVICE_COMMAND]?: string;
-  [FormFieldsEnum.EXTENSION_DESC]?: ExtensionDesc;
-
-  // EXTENSION_DESC = 'extensionDesc',
-  // STRUCT_DATA = 'structData',
-  // INPUT_DATA = 'inputData',
-  // OUTPUT_DATA = 'outputData',
+  [FormFieldsEnum.EXTENSION_DESC]?: ExtendDescFormFieldsValueType;
 }
 }

 import { DataTypeForm } from './DataTypeForm';
 import { DataTypeForm } from './DataTypeForm';
+import { ExtendDescFormFieldsValueType } from './ExtendDesc';
+import { isFloatType, useParseOperationType } from './ExtendDesc/useParseOperationType';
 import { FormFieldsEnum } from './config';
 import { FormFieldsEnum } from './config';
-import { ObjectModelFormGetFieldsValueType } from './types';
+import { ObjectModelFormGetFieldsValueType, ObjectModelFormPropsType } from './types';
 import { DefineComponentsBasicExpose } from '/#/utils';
 import { DefineComponentsBasicExpose } from '/#/utils';
-import { ModelOfMatterParams, StructJSON } from '/@/api/device/model/modelOfMatterModel';
+import { ModelOfMatterParams, Specs, StructJSON } from '/@/api/device/model/modelOfMatterModel';
 import { FormActionType } from '/@/components/Form';
 import { FormActionType } from '/@/components/Form';
-import { TransportTypeEnum } from '/@/enums/deviceEnum';
-import { FunctionTypeEnum } from '/@/enums/objectModelEnum';
-import { Ref, toRaw, unref } from 'vue';
+import { TCPProtocolTypeEnum, TransportTypeEnum } from '/@/enums/deviceEnum';
+import {
+  BuiltInIdentifierEnum,
+  DataTypeEnum,
+  FunctionTypeEnum,
+  ObjectModelAccessModeEnum,
+  OriginalDataTypeEnum,
+} from '/@/enums/objectModelEnum';
+import { Ref, computed, toRaw, unref } from 'vue';
 
 
 interface UseObjectFormDataParamsType {
 interface UseObjectFormDataParamsType {
   formActionType: FormActionType;
   formActionType: FormActionType;
   dataTypeFormRef: Ref<InstanceType<typeof DataTypeForm> | undefined>;
   dataTypeFormRef: Ref<InstanceType<typeof DataTypeForm> | undefined>;
-  transportType: TransportTypeEnum;
+  propsRef?: ObjectModelFormPropsType;
+}
+
+export function getDataTypeByOriginalDataType(
+  originalDataType: OriginalDataTypeEnum,
+  identifier: string
+) {
+  if (identifier === BuiltInIdentifierEnum.SOURCE) return DataTypeEnum.STRING;
+
+  if (isFloatType(originalDataType)) return DataTypeEnum.NUMBER_DOUBLE;
+  else if (originalDataType === OriginalDataTypeEnum.STRING) return DataTypeEnum.STRING;
+  else if ([OriginalDataTypeEnum.BOOLEAN, OriginalDataTypeEnum.BITS].includes(originalDataType))
+    return DataTypeEnum.BOOL;
+  else return DataTypeEnum.NUMBER_INT;
+}
+
+function handleTCPModbusProductPropertiesType(
+  value: ObjectModelFormGetFieldsValueType
+): ModelOfMatterParams {
+  const { functionName, identifier, functionType, remark, extensionDesc, unit, unitName } = value;
+
+  const {
+    operationType,
+    originalDataType,
+    bitMask,
+    valueRange,
+    registerAddress,
+    scaling,
+    registerCount,
+    valueMapping,
+  } = extensionDesc! || {};
+
+  const { writeOnly, accessMode } = useParseOperationType(operationType);
+
+  const dataType = getDataTypeByOriginalDataType(originalDataType, identifier);
+
+  return {
+    functionType,
+    functionName,
+    identifier,
+    functionJson: {
+      dataType: {
+        type: dataType,
+        specs: {
+          unit,
+          unitName,
+          valueRange,
+        },
+        specsList: valueMapping || [],
+      },
+    },
+    accessMode:
+      identifier === BuiltInIdentifierEnum.SOURCE ? ObjectModelAccessModeEnum.READ : accessMode,
+    remark,
+    extensionDesc: {
+      writeOnly,
+      bitMask,
+      operationType,
+      originalDataType,
+      registerAddress,
+      scaling,
+      registerCount,
+    },
+  };
 }
 }
 
 
 function handlePropertiesType(
 function handlePropertiesType(
   value: ObjectModelFormGetFieldsValueType,
   value: ObjectModelFormGetFieldsValueType,
-  dataTypeFormValue: StructJSON,
-  transportType?: TransportTypeEnum
+  dataTypeFormValue: StructJSON
 ): ModelOfMatterParams {
 ): ModelOfMatterParams {
-  const { functionType, accessMode, remark, extensionDesc } = value;
-  const { functionName, identifier, dataType } = dataTypeFormValue;
+  const { functionType, accessMode, remark } = value;
+  const { functionName, identifier, dataType } = dataTypeFormValue || {};
 
 
   const result: ModelOfMatterParams = {
   const result: ModelOfMatterParams = {
     functionType,
     functionType,
@@ -33,15 +103,12 @@ function handlePropertiesType(
     remark,
     remark,
   };
   };
 
 
-  if (transportType === TransportTypeEnum.TCP && extensionDesc)
-    result.extensionDesc = extensionDesc;
-
   return result;
   return result;
 }
 }
 
 
 function handleServiceType(
 function handleServiceType(
   value: ObjectModelFormGetFieldsValueType,
   value: ObjectModelFormGetFieldsValueType,
-  transportType: TransportTypeEnum
+  transportType?: TransportTypeEnum
 ): ModelOfMatterParams {
 ): ModelOfMatterParams {
   const {
   const {
     functionName,
     functionName,
@@ -51,9 +118,11 @@ function handleServiceType(
     inputData = [],
     inputData = [],
     outputData = [],
     outputData = [],
     serviceCommand,
     serviceCommand,
+    callType,
   } = value;
   } = value;
 
 
   return {
   return {
+    callType,
     functionType,
     functionType,
     functionName,
     functionName,
     identifier,
     identifier,
@@ -86,26 +155,37 @@ function handleEventType(value: ObjectModelFormGetFieldsValueType): ModelOfMatte
 export const useObjectFormData = ({
 export const useObjectFormData = ({
   formActionType,
   formActionType,
   dataTypeFormRef,
   dataTypeFormRef,
-  transportType,
+  propsRef,
 }: UseObjectFormDataParamsType): DefineComponentsBasicExpose<ModelOfMatterParams> => {
 }: UseObjectFormDataParamsType): DefineComponentsBasicExpose<ModelOfMatterParams> => {
+  const getTCPModbusProductFlag = computed(
+    () =>
+      propsRef?.deviceRecord?.profileData.transportConfiguration.protocol ===
+      TCPProtocolTypeEnum.MODBUS_RTU
+  );
+
+  const getTransportType = computed(
+    () => propsRef?.deviceRecord?.transportType as TransportTypeEnum
+  );
+
   const getFieldsValue = (): ModelOfMatterParams => {
   const getFieldsValue = (): ModelOfMatterParams => {
     const value = formActionType.getFieldsValue() as ObjectModelFormGetFieldsValueType;
     const value = formActionType.getFieldsValue() as ObjectModelFormGetFieldsValueType;
     const { functionType } = value;
     const { functionType } = value;
-
     if (functionType === FunctionTypeEnum.PROPERTIES) {
     if (functionType === FunctionTypeEnum.PROPERTIES) {
       const dataTypeFormValue = unref(dataTypeFormRef)?.getFieldsValue?.();
       const dataTypeFormValue = unref(dataTypeFormRef)?.getFieldsValue?.();
-      return handlePropertiesType(value, dataTypeFormValue!, transportType);
+      if (unref(getTCPModbusProductFlag)) return handleTCPModbusProductPropertiesType(value);
+      return handlePropertiesType(value, dataTypeFormValue!);
     }
     }
 
 
     if (functionType === FunctionTypeEnum.EVENTS) {
     if (functionType === FunctionTypeEnum.EVENTS) {
       return handleEventType(value);
       return handleEventType(value);
-    } else {
-      return handleServiceType(value, transportType);
     }
     }
+
+    return handleServiceType(value, unref(getTransportType));
   };
   };
 
 
   const setFieldsValue = (values: ModelOfMatterParams) => {
   const setFieldsValue = (values: ModelOfMatterParams) => {
     values = toRaw(unref(values));
     values = toRaw(unref(values));
+    const transportType = unref(getTransportType);
     const {
     const {
       functionName,
       functionName,
       identifier,
       identifier,
@@ -115,10 +195,11 @@ export const useObjectFormData = ({
       callType,
       callType,
       remark,
       remark,
       extensionDesc,
       extensionDesc,
+      eventType,
     } = values;
     } = values;
     const { dataType, inputData = [], outputData = [] } = functionJson || {};
     const { dataType, inputData = [], outputData = [] } = functionJson || {};
 
 
-    formActionType.setFieldsValue({
+    const setValue = {
       identifier,
       identifier,
       functionName,
       functionName,
       functionType,
       functionType,
@@ -127,9 +208,23 @@ export const useObjectFormData = ({
       inputData,
       inputData,
       outputData,
       outputData,
       remark,
       remark,
+      eventType,
       serviceCommand: transportType === TransportTypeEnum.TCP ? inputData?.[0]?.serviceCommand : '',
       serviceCommand: transportType === TransportTypeEnum.TCP ? inputData?.[0]?.serviceCommand : '',
       extensionDesc,
       extensionDesc,
-    } as ObjectModelFormGetFieldsValueType);
+    } as ObjectModelFormGetFieldsValueType;
+
+    if (unref(getTCPModbusProductFlag)) {
+      const { specs, type, specsList } = dataType || {};
+      const { unit, unitName, valueRange } = (specs as Specs) || {};
+      Object.assign(setValue, { unit, unitName } as ObjectModelFormGetFieldsValueType);
+      Object.assign(setValue.extensionDesc || {}, {
+        valueRange,
+        dataType: type,
+        valueMapping: specsList,
+      } as Partial<ExtendDescFormFieldsValueType>);
+    }
+
+    formActionType.setFieldsValue(setValue);
 
 
     if (functionType === FunctionTypeEnum.PROPERTIES) {
     if (functionType === FunctionTypeEnum.PROPERTIES) {
       unref(dataTypeFormRef)?.setFieldsValue({
       unref(dataTypeFormRef)?.setFieldsValue({
@@ -145,7 +240,7 @@ export const useObjectFormData = ({
     await unref(dataTypeFormRef)?.validate?.();
     await unref(dataTypeFormRef)?.validate?.();
   };
   };
 
 
-  const resetFieldsValue = () => {
+  const resetFieldsValue = async () => {
     formActionType.resetFields();
     formActionType.resetFields();
     unref(dataTypeFormRef)?.resetFieldsValue?.();
     unref(dataTypeFormRef)?.resetFieldsValue?.();
   };
   };

 import type { InjectionKey, ComputedRef } from 'vue';
 import type { InjectionKey, ComputedRef } from 'vue';
 import { createContext, useContext } from '/@/hooks/core/useContext';
 import { createContext, useContext } from '/@/hooks/core/useContext';
 import { TransportTypeEnum } from '/@/enums/deviceEnum';
 import { TransportTypeEnum } from '/@/enums/deviceEnum';
-import { DataTypeEnum } from '/@/enums/objectModelEnum';
 import { DataActionModeEnum } from '/@/enums/toolEnum';
 import { DataActionModeEnum } from '/@/enums/toolEnum';
 
 
 export interface ObjectModelFormContextProps {
 export interface ObjectModelFormContextProps {
   getTransportType: ComputedRef<TransportTypeEnum | undefined>;
   getTransportType: ComputedRef<TransportTypeEnum | undefined>;
-  getDataType: ComputedRef<DataTypeEnum>;
   getModalMode: ComputedRef<DataActionModeEnum | undefined>;
   getModalMode: ComputedRef<DataActionModeEnum | undefined>;
 }
 }
 
 

@@ -28,10 +28,9 @@
   </BasicModal>
   </BasicModal>
 </template>
 </template>
 <script lang="ts" setup>
 <script lang="ts" setup>
-  import { ref, unref } from 'vue';
+  import { computed, ref, unref } from 'vue';
   import { Button, Radio, RadioGroup } from 'ant-design-vue';
   import { Button, Radio, RadioGroup } from 'ant-design-vue';
   import { BasicModal, useModalInner } from '/@/components/Modal';
   import { BasicModal, useModalInner } from '/@/components/Modal';
-  import { DeviceRecord } from '/@/api/device/model/deviceModel';
   import { useMessage } from '/@/hooks/web/useMessage';
   import { useMessage } from '/@/hooks/web/useMessage';
   import { isObject, isString } from '/@/utils/is';
   import { isObject, isString } from '/@/utils/is';
   import {
   import {
@@ -45,11 +44,13 @@
   import { BasicForm, useForm } from '/@/components/Form';
   import { BasicForm, useForm } from '/@/components/Form';
   import { Authority } from '/@/components/Authority';
   import { Authority } from '/@/components/Authority';
   import { usePermission } from '/@/hooks/web/usePermission';
   import { usePermission } from '/@/hooks/web/usePermission';
+  import { TCPProtocolTypeEnum, TransportTypeEnum } from '/@/enums/deviceEnum';
+  import { DeviceProfileDetail } from '/@/api/device/model/deviceConfigModel';
 
 
   const emits = defineEmits(['register', 'handleImportCSV', 'handleReload']);
   const emits = defineEmits(['register', 'handleImportCSV', 'handleReload']);
 
 
-  defineProps<{
-    record: DeviceRecord;
+  const props = defineProps<{
+    record: DeviceProfileDetail;
   }>();
   }>();
 
 
   const { createMessage } = useMessage();
   const { createMessage } = useMessage();
@@ -196,10 +197,14 @@
       const formData = new FormData();
       const formData = new FormData();
       formData.set('file', file);
       formData.set('file', file);
       const flag = isCateGory
       const flag = isCateGory
-        ? await importCsvCategory({ categoryId: id, deviceProfileId: undefined, file: formData })
+        ? await importCsvCategory({
+            categoryId: id,
+            type: unref(getIsModbusDeviceFlag) ? 'modbus' : '',
+            file: formData,
+          })
         : await importCsvDeviceProfileId({
         : await importCsvDeviceProfileId({
-            categoryId: undefined,
             deviceProfileId: id,
             deviceProfileId: id,
+            type: unref(getIsModbusDeviceFlag) ? 'modbus' : '',
             file: formData,
             file: formData,
           });
           });
       flag && createMessage.info(flag?.message);
       flag && createMessage.info(flag?.message);
@@ -224,10 +229,18 @@
     URL.revokeObjectURL(objectURL);
     URL.revokeObjectURL(objectURL);
   };
   };
 
 
+  const getIsModbusDeviceFlag = computed(() => {
+    const isTCPProtocol = props.record.transportType === TransportTypeEnum.TCP;
+    return (
+      isTCPProtocol &&
+      props.record?.profileData?.transportConfiguration?.protocol === TCPProtocolTypeEnum.MODBUS_RTU
+    );
+  });
+
   // 模板下载
   // 模板下载
   const handleTemplateDownload = async () => {
   const handleTemplateDownload = async () => {
-    const res = await excelExport();
-    downloadFile(res, '物模型属性导入模板', 'xls');
+    const res = await excelExport(unref(getIsModbusDeviceFlag) ? 'modbus' : '');
+    downloadFile(res, `${unref(getIsModbusDeviceFlag) ? 'Modbus' : ''}物模型属性导入模板`, 'xls');
   };
   };
 
 
   const handleCancel = () => {
   const handleCancel = () => {

@@ -140,7 +140,6 @@
   import PhysicalModelTsl from './cpns/physical/PhysicalModelTsl.vue';
   import PhysicalModelTsl from './cpns/physical/PhysicalModelTsl.vue';
   import { Popconfirm, Button, Alert } from 'ant-design-vue';
   import { Popconfirm, Button, Alert } from 'ant-design-vue';
   import { useMessage } from '/@/hooks/web/useMessage';
   import { useMessage } from '/@/hooks/web/useMessage';
-  import { DeviceRecord } from '/@/api/device/model/deviceModel';
   import {
   import {
     deleteModel,
     deleteModel,
     deleteModelCategory,
     deleteModelCategory,
@@ -158,12 +157,13 @@
   import { FunctionTypeEnum } from '/@/enums/objectModelEnum';
   import { FunctionTypeEnum } from '/@/enums/objectModelEnum';
   import SelectImport from '../components/SelectImport.vue';
   import SelectImport from '../components/SelectImport.vue';
   import { DataActionModeEnum } from '/@/enums/toolEnum';
   import { DataActionModeEnum } from '/@/enums/toolEnum';
+  import { DeviceProfileDetail } from '/@/api/device/model/deviceConfigModel';
 
 
   const { isPlatformAdmin, isSysadmin } = useRole();
   const { isPlatformAdmin, isSysadmin } = useRole();
   defineEmits(['register']);
   defineEmits(['register']);
 
 
   const props = defineProps<{
   const props = defineProps<{
-    record: DeviceRecord;
+    record: DeviceProfileDetail;
   }>();
   }>();
 
 
   const { createMessage } = useMessage();
   const { createMessage } = useMessage();

@@ -49,7 +49,7 @@
   </div>
   </div>
 </template>
 </template>
 <script lang="ts" setup>
 <script lang="ts" setup>
-  import { reactive, ref, onUnmounted, nextTick } from 'vue';
+  import { reactive, ref, onUnmounted, nextTick, unref } from 'vue';
   import { BasicForm, useForm } from '/@/components/Form';
   import { BasicForm, useForm } from '/@/components/Form';
   import { step2Schemas } from '../device.profile.data';
   import { step2Schemas } from '../device.profile.data';
   import { Button } from '/@/components/Button';
   import { Button } from '/@/components/Button';
@@ -183,6 +183,7 @@
         },
         },
       },
       },
     });
     });
+    unref(tcpRef)?.setProtocolStatus(status);
   };
   };
   const updateDisabled = async () => {
   const updateDisabled = async () => {
     await nextTick();
     await nextTick();

@@ -8,6 +8,7 @@
     <ObjectModelForm
     <ObjectModelForm
       ref="objectModelElRef"
       ref="objectModelElRef"
       :mode="openModalMode"
       :mode="openModalMode"
+      :device-record="record"
       :transport-type="(record.transportType as TransportTypeEnum)"
       :transport-type="(record.transportType as TransportTypeEnum)"
     />
     />
   </BasicModal>
   </BasicModal>
@@ -23,12 +24,12 @@
     createModelCategory,
     createModelCategory,
     updateModelCategory,
     updateModelCategory,
   } from '/@/api/device/modelOfMatter';
   } from '/@/api/device/modelOfMatter';
-  import { DeviceRecord } from '/@/api/device/model/deviceModel';
   import { useMessage } from '/@/hooks/web/useMessage';
   import { useMessage } from '/@/hooks/web/useMessage';
   import { useRole } from '/@/hooks/business/useRole';
   import { useRole } from '/@/hooks/business/useRole';
   import { ObjectModelForm } from '../../../components/ObjectModelForm';
   import { ObjectModelForm } from '../../../components/ObjectModelForm';
   import { TransportTypeEnum } from '/@/enums/deviceEnum';
   import { TransportTypeEnum } from '/@/enums/deviceEnum';
   import { DataActionModeEnum, DataActionModeNameEnum } from '/@/enums/toolEnum';
   import { DataActionModeEnum, DataActionModeNameEnum } from '/@/enums/toolEnum';
+  import { DeviceProfileDetail } from '/@/api/device/model/deviceConfigModel';
 
 
   const { isPlatformAdmin, isSysadmin } = useRole();
   const { isPlatformAdmin, isSysadmin } = useRole();
 
 
@@ -37,7 +38,7 @@
   const objectModelElRef = ref<InstanceType<typeof ObjectModelForm>>();
   const objectModelElRef = ref<InstanceType<typeof ObjectModelForm>>();
 
 
   const props = defineProps<{
   const props = defineProps<{
-    record: DeviceRecord;
+    record: DeviceProfileDetail;
   }>();
   }>();
 
 
   const blockContent = `属性一般是指设备的运行状态，如当前温度等；服务是指设备可被调用的方法，支持定义参数，如执行某项任务；事件则是指设备上报的通知，如告警，需要被及时处理。`;
   const blockContent = `属性一般是指设备的运行状态，如当前温度等；服务是指设备可被调用的方法，支持定义参数，如执行某项任务；事件则是指设备上报的通知，如告警，需要被及时处理。`;
@@ -55,13 +56,14 @@
       if (record) {
       if (record) {
         await nextTick();
         await nextTick();
       }
       }
-      unref(objectModelElRef)?.resetFieldsValue?.();
+
       const title = `${DataActionModeNameEnum[mode]}物模型`;
       const title = `${DataActionModeNameEnum[mode]}物模型`;
       setModalProps({
       setModalProps({
         showOkBtn: mode !== DataActionModeEnum.READ,
         showOkBtn: mode !== DataActionModeEnum.READ,
         title,
         title,
       });
       });
 
 
+      unref(objectModelElRef)?.resetFieldsValue?.();
       if (mode !== DataActionModeEnum.CREATE && record) {
       if (mode !== DataActionModeEnum.CREATE && record) {
         currentActionModel.value = record;
         currentActionModel.value = record;
         unref(objectModelElRef)?.setFieldsValue(record || {});
         unref(objectModelElRef)?.setFieldsValue(record || {});

-<template>
-  <div>
-    <a-form
-      ref="formRef"
-      :model="scriptForm"
-      name="basic"
-      :label-col="{ span: 4 }"
-      :wrapper-col="{ span: 16 }"
-      autocomplete="off"
-      style="margin-left: 2.4rem"
-    >
-      <a-form-item
-        v-if="deviceTypeStr !== TypeEnum.SENSOR"
-        label="鉴权脚本"
-        name="authScriptId"
-        :rules="[{ required: true, message: '请选择鉴权脚本' }]"
-      >
-        <ScriptSelectItem
-          ref="scriptSelectItemAuthRef"
-          v-model:value="scriptForm.authScriptId"
-          :scriptType="ScriptTypeEnum.TRANSPORT_TCP_AUTH"
-        />
-      </a-form-item>
-      <a-form-item
-        label="上行脚本"
-        name="upScriptId"
-        :rules="[{ required: true, message: '请选择上行脚本' }]"
-      >
-        <ScriptSelectItem
-          ref="scriptSelectItemUpRef"
-          v-model:value="scriptForm.upScriptId"
-          :scriptType="ScriptTypeEnum.TRANSPORT_TCP_UP"
-        />
-      </a-form-item>
-    </a-form>
-  </div>
-</template>
-<script lang="ts" setup name="index">
-  import { reactive, ref } from 'vue';
-  import { useMessage } from '/@/hooks/web/useMessage';
-  import { ScriptSelectItem } from './components';
-  import { ScriptTypeEnum } from '/@/views/rule/script/TcpConversionScript/config';
-  import { TypeEnum } from '/@/views/device/list/config/data';
-
-  const props = defineProps({
-    deviceTypeStr: { type: String, default: '' },
-  });
-
-  const scriptForm = reactive({
-    authScriptId: '',
-    upScriptId: '',
-  });
-
-  const { createMessage } = useMessage();
-
-  const scriptSelectItemAuthRef = ref<InstanceType<typeof ScriptSelectItem>>();
-
-  const scriptSelectItemUpRef = ref<InstanceType<typeof ScriptSelectItem>>();
-
-  const getFormData = async () => {
-    scriptForm.authScriptId = scriptSelectItemAuthRef.value?.getValue();
-    scriptForm.upScriptId = scriptSelectItemUpRef.value?.getValue();
-    //业务 网关子设备没有鉴权脚本
-    if (props.deviceTypeStr === TypeEnum.SENSOR) Reflect.deleteProperty(scriptForm, 'authScriptId');
-    if (Object.values(scriptForm).some((item) => !item)) {
-      createMessage.error('请先选择对应脚本');
-      throw new Error('请先选择对应脚本');
-    }
-    return {
-      ...scriptForm,
-      type: 'TCP',
-    };
-  };
-
-  const resetFormData = () => {};
-
-  const setFormData = (data) => {
-    scriptForm.authScriptId = data?.authScriptId;
-    scriptForm.upScriptId = data?.upScriptId;
-    scriptSelectItemAuthRef.value?.setValue(data?.authScriptId);
-    scriptSelectItemUpRef.value?.setValue(data?.upScriptId);
-  };
-  defineExpose({
-    getFormData,
-    resetFormData,
-    setFormData,
-  });
-</script>
-<style lang="less" scoped></style>
+<template>
+  <div>
+    <Form
+      ref="formRef"
+      :model="scriptForm"
+      name="basic"
+      :label-col="{ span: 4 }"
+      :wrapper-col="{ span: 16 }"
+      autocomplete="off"
+      style="margin-left: 2.4rem"
+    >
+      <Form.Item
+        label="类型"
+        :rules="[{ required: true, message: '请选择鉴权脚本' }]"
+        :wrapper-col="{ span: 10 }"
+      >
+        <Select
+          v-model:value="scriptForm.protocol"
+          :options="typeOptions"
+          :disabled="protocolStatus"
+        />
+      </Form.Item>
+      <Form.Item
+        v-if="
+          scriptForm.protocol === TCPProtocolTypeEnum.CUSTOM && deviceTypeStr !== TypeEnum.SENSOR
+        "
+        label="鉴权脚本"
+        name="authScriptId"
+        :rules="[{ required: true, message: '请选择鉴权脚本' }]"
+      >
+        <ScriptSelectItem
+          ref="scriptSelectItemAuthRef"
+          v-model:value="scriptForm.authScriptId"
+          :scriptType="ScriptTypeEnum.TRANSPORT_TCP_AUTH"
+        />
+      </Form.Item>
+      <Form.Item
+        v-if="scriptForm.protocol === TCPProtocolTypeEnum.CUSTOM"
+        label="上行脚本"
+        name="upScriptId"
+        :rules="[{ required: true, message: '请选择上行脚本' }]"
+      >
+        <ScriptSelectItem
+          ref="scriptSelectItemUpRef"
+          v-model:value="scriptForm.upScriptId"
+          :scriptType="ScriptTypeEnum.TRANSPORT_TCP_UP"
+        />
+      </Form.Item>
+    </Form>
+  </div>
+</template>
+<script lang="ts" setup name="index">
+  import { reactive, ref } from 'vue';
+  import { Form, Select } from 'ant-design-vue';
+  import { useMessage } from '/@/hooks/web/useMessage';
+  import { ScriptSelectItem } from './components';
+  import { ScriptTypeEnum } from '/@/views/rule/script/TcpConversionScript/config';
+  import { TypeEnum } from '/@/views/device/list/config/data';
+  import { TCPProtocolTypeEnum, TCPProtocolTypeNameEnum } from '/@/enums/deviceEnum';
+
+  const props = defineProps({
+    deviceTypeStr: { type: String, default: '' },
+  });
+
+  const typeOptions = Object.keys(TCPProtocolTypeEnum).map((key) => ({
+    label: TCPProtocolTypeNameEnum[key],
+    value: TCPProtocolTypeEnum[key],
+  }));
+
+  const scriptForm = reactive({
+    authScriptId: '',
+    upScriptId: '',
+    protocol: TCPProtocolTypeEnum.MODBUS_RTU,
+  });
+
+  const { createMessage } = useMessage();
+
+  const scriptSelectItemAuthRef = ref<InstanceType<typeof ScriptSelectItem>>();
+
+  const scriptSelectItemUpRef = ref<InstanceType<typeof ScriptSelectItem>>();
+
+  const getFormData = async () => {
+    scriptForm.authScriptId = scriptSelectItemAuthRef.value?.getValue();
+    scriptForm.upScriptId = scriptSelectItemUpRef.value?.getValue();
+    //业务 网关子设备没有鉴权脚本
+    if (scriptForm.protocol === TCPProtocolTypeEnum.CUSTOM) {
+      if (props.deviceTypeStr === TypeEnum.SENSOR)
+        Reflect.deleteProperty(scriptForm, 'authScriptId');
+      if (Object.values(scriptForm).some((item) => !item)) {
+        createMessage.error('请先选择对应脚本');
+        throw new Error('请先选择对应脚本');
+      }
+    }
+
+    return {
+      ...scriptForm,
+      type: 'TCP',
+    };
+  };
+
+  const resetFormData = () => {};
+
+  const setFormData = (data) => {
+    scriptForm.protocol = data?.protocol;
+    scriptForm.authScriptId = data?.authScriptId;
+    scriptForm.upScriptId = data?.upScriptId;
+    scriptSelectItemAuthRef.value?.setValue(data?.authScriptId);
+    scriptSelectItemUpRef.value?.setValue(data?.upScriptId);
+  };
+
+  const protocolStatus = ref(false);
+
+  const setProtocolStatus = (flag: boolean) => {
+    protocolStatus.value = flag;
+  };
+
+  defineExpose({
+    getFormData,
+    resetFormData,
+    setFormData,
+    setProtocolStatus,
+  });
+</script>
+<style lang="less" scoped></style>

@@ -5,7 +5,7 @@ import {
   TriggerEntityTypeEnum,
   TriggerEntityTypeEnum,
   TriggerEntityTypeNameEnum,
   TriggerEntityTypeNameEnum,
 } from '/@/enums/linkedgeEnum';
 } from '/@/enums/linkedgeEnum';
-import { CommandTypeEnum, CommandTypeNameEnum } from '/@/enums/deviceEnum';
+import { CommandTypeEnum, CommandTypeNameEnum, TCPProtocolTypeEnum } from '/@/enums/deviceEnum';
 import AlarmProfileSelect from './AlarmProfileSelect.vue';
 import AlarmProfileSelect from './AlarmProfileSelect.vue';
 import {
 import {
   byOrganizationIdGetMasterDevice,
   byOrganizationIdGetMasterDevice,
@@ -50,6 +50,8 @@ export enum FormFieldsEnum {
   TRANSPORT_TYPE = 'transportType',
   TRANSPORT_TYPE = 'transportType',
   ENABLE_CLEAR_RULE = 'enableClearRule',
   ENABLE_CLEAR_RULE = 'enableClearRule',
   CLEAR_RULE = 'clearRule',
   CLEAR_RULE = 'clearRule',
+
+  IS_TCP_MODBUS_PRODUCT = 'isTCPModbusProduct',
 }
 }
 
 
 export enum FormFieldsNameEnum {
 export enum FormFieldsNameEnum {
@@ -199,6 +201,12 @@ export const getFormSchemas = (hasAlarmNotify: Ref<boolean>): FormSchema[] => {
       ifShow: false,
       ifShow: false,
     },
     },
     {
     {
+      field: FormFieldsEnum.IS_TCP_MODBUS_PRODUCT,
+      label: 'TCPModbus产品',
+      component: 'Input',
+      ifShow: false,
+    },
+    {
       field: FormFieldsEnum.DEVICE_PROFILE_ID,
       field: FormFieldsEnum.DEVICE_PROFILE_ID,
       label: '',
       label: '',
       component: 'ApiSelect',
       component: 'ApiSelect',
@@ -216,22 +224,33 @@ export const getFormSchemas = (hasAlarmNotify: Ref<boolean>): FormSchema[] => {
           placeholder: `请选择${FormFieldsNameEnum.DEVICE_PROFILE_ID}`,
           placeholder: `请选择${FormFieldsNameEnum.DEVICE_PROFILE_ID}`,
           ...createPickerSearch(),
           ...createPickerSearch(),
           onChange(_value: string, option: DeviceProfileModel) {
           onChange(_value: string, option: DeviceProfileModel) {
+            const transportType = option?.transportType;
             setFieldsValue({
             setFieldsValue({
               [FormFieldsEnum.ENTITY_ID]: [],
               [FormFieldsEnum.ENTITY_ID]: [],
-              [FormFieldsEnum.TRANSPORT_TYPE]: option?.transportType,
+              [FormFieldsEnum.TRANSPORT_TYPE]: transportType,
               [FormFieldsEnum.SERVICE_ID]: null,
               [FormFieldsEnum.SERVICE_ID]: null,
+              [FormFieldsEnum.COMMAND_TYPE]: CommandTypeEnum.CUSTOM,
               [FormFieldsEnum.CALL_SERVICE]: null,
               [FormFieldsEnum.CALL_SERVICE]: null,
               [FormFieldsEnum.CALL_SERVICE_IDENTIFIER]: null,
               [FormFieldsEnum.CALL_SERVICE_IDENTIFIER]: null,
               [FormFieldsEnum.SERVICE_COMMAND]: null,
               [FormFieldsEnum.SERVICE_COMMAND]: null,
+              [FormFieldsEnum.IS_TCP_MODBUS_PRODUCT]:
+                transportType === TransportTypeEnum.TCP &&
+                option?.profileData?.transportConfiguration?.protocol ===
+                  TCPProtocolTypeEnum.MODBUS_RTU,
             });
             });
           },
           },
           onOptionsChange(options: (DeviceProfileModel & Record<'label' | 'value', string>)[]) {
           onOptionsChange(options: (DeviceProfileModel & Record<'label' | 'value', string>)[]) {
             const deviceProfileId = formModel[FormFieldsEnum.DEVICE_PROFILE_ID];
             const deviceProfileId = formModel[FormFieldsEnum.DEVICE_PROFILE_ID];
             const res = options.find((item) => item.value === deviceProfileId);
             const res = options.find((item) => item.value === deviceProfileId);
-            res &&
-              setFieldsValue({
-                [FormFieldsEnum.TRANSPORT_TYPE]: res.transportType,
-              });
+            if (!res) return;
+            const transportType = res.transportType;
+            setFieldsValue({
+              [FormFieldsEnum.TRANSPORT_TYPE]: transportType,
+              [FormFieldsEnum.IS_TCP_MODBUS_PRODUCT]:
+                transportType === TransportTypeEnum.TCP &&
+                res?.profileData?.transportConfiguration?.protocol ===
+                  TCPProtocolTypeEnum.MODBUS_RTU,
+            });
           },
           },
         };
         };
       },
       },
@@ -295,12 +314,23 @@ export const getFormSchemas = (hasAlarmNotify: Ref<boolean>): FormSchema[] => {
       ],
       ],
       defaultValue: CommandTypeEnum.CUSTOM,
       defaultValue: CommandTypeEnum.CUSTOM,
       ifShow: ({ model }) => model[FormFieldsEnum.OUT_TARGET] === ExecutionActionEnum.DEVICE_OUT,
       ifShow: ({ model }) => model[FormFieldsEnum.OUT_TARGET] === ExecutionActionEnum.DEVICE_OUT,
-      componentProps: ({ formActionType }) => {
+      componentProps: ({ formModel, formActionType }) => {
+        const getOptions = () => {
+          const options = [{ label: CommandTypeNameEnum.CUSTOM, value: CommandTypeEnum.CUSTOM }];
+
+          const isTCPModbusProduct = formModel[FormFieldsEnum.IS_TCP_MODBUS_PRODUCT];
+          const isTCP = formModel[FormFieldsEnum.TRANSPORT_TYPE] === TransportTypeEnum.TCP;
+          const deviceType = formModel[FormFieldsEnum.DEVICE_TYPE];
+
+          // TCPModbus设备 TCP自定义网关子设备
+          if (isTCPModbusProduct || (isTCP && deviceType === DeviceTypeEnum.SENSOR)) return options;
+
+          options.push({ label: CommandTypeNameEnum.SERVICE, value: CommandTypeEnum.SERVICE });
+
+          return options;
+        };
         return {
         return {
-          options: [
-            { label: CommandTypeNameEnum.CUSTOM, value: CommandTypeEnum.CUSTOM },
-            { label: CommandTypeNameEnum.SERVICE, value: CommandTypeEnum.SERVICE },
-          ],
+          options: getOptions(),
           placeholder: `请选择${FormFieldsNameEnum.COMMAND_TYPE}`,
           placeholder: `请选择${FormFieldsNameEnum.COMMAND_TYPE}`,
           onChange() {
           onChange() {
             const { setFieldsValue } = formActionType;
             const { setFieldsValue } = formActionType;

@@ -144,6 +144,7 @@
           [oldCategory, category].some((item) => item === PackagesCategoryEnum.CONTROL) &&
           [oldCategory, category].some((item) => item === PackagesCategoryEnum.CONTROL) &&
           oldCategory !== category &&
           oldCategory !== category &&
           firstEnter;
           firstEnter;
+
         dataSource.value = unref(dataSource).map((item) => ({
         dataSource.value = unref(dataSource).map((item) => ({
           ...item,
           ...item,
           ...(needReset ? { attribute: null } : {}),
           ...(needReset ? { attribute: null } : {}),

@@ -9,8 +9,8 @@
   import { useDataFetch } from '../../../hook/socket/useSocket';
   import { useDataFetch } from '../../../hook/socket/useSocket';
   import { useModal } from '/@/components/Modal';
   import { useModal } from '/@/components/Modal';
   import PasswordModal from '../component/PasswordModal.vue';
   import PasswordModal from '../component/PasswordModal.vue';
-  import { useCommandDelivery } from '../../../hook/useCommandDelivery';
   import { useDeviceProfileQueryContext } from '/@/views/visual/palette/hooks/useDeviceProfileQueryContext';
   import { useDeviceProfileQueryContext } from '/@/views/visual/palette/hooks/useDeviceProfileQueryContext';
+  import { useControlComand } from '../../../hook/useControlCommand';
 
 
   const props = defineProps<{
   const props = defineProps<{
     config: ComponentPropsConfigType<typeof option>;
     config: ComponentPropsConfigType<typeof option>;
@@ -38,12 +38,12 @@
     };
     };
   });
   });
 
 
-  const { doCommandDeliver, loading } = useCommandDelivery();
+  const { loading, doControlSendCommand } = useControlComand();
 
 
   const handleSendCommand = async () => {
   const handleSendCommand = async () => {
     if (props.config.option.mode === ComponentMode.SELECT_PREVIEW) return;
     if (props.config.option.mode === ComponentMode.SELECT_PREVIEW) return;
     const { option } = props.config || {};
     const { option } = props.config || {};
-    const result = await doCommandDeliver(option, Number(!unref(currentValue)));
+    const result = await doControlSendCommand(option, Number(!unref(currentValue)));
     currentValue.value = result ? !unref(currentValue) : unref(currentValue);
     currentValue.value = result ? !unref(currentValue) : unref(currentValue);
   };
   };
 
 

@@ -11,8 +11,8 @@
   import { useDataFetch } from '../../../hook/socket/useSocket';
   import { useDataFetch } from '../../../hook/socket/useSocket';
   import { useModal } from '/@/components/Modal';
   import { useModal } from '/@/components/Modal';
   import PasswordModal from '../component/PasswordModal.vue';
   import PasswordModal from '../component/PasswordModal.vue';
-  import { useCommandDelivery } from '../../../hook/useCommandDelivery';
   import { useDeviceProfileQueryContext } from '/@/views/visual/palette/hooks/useDeviceProfileQueryContext';
   import { useDeviceProfileQueryContext } from '/@/views/visual/palette/hooks/useDeviceProfileQueryContext';
+  import { useControlComand } from '../../../hook/useControlCommand';
 
 
   const props = defineProps<{
   const props = defineProps<{
     config: ComponentPropsConfigType<typeof option>;
     config: ComponentPropsConfigType<typeof option>;
@@ -44,7 +44,7 @@
     };
     };
   });
   });
 
 
-  const { loading, doCommandDeliver } = useCommandDelivery();
+  const { loading, doControlSendCommand } = useControlComand();
 
 
   const handleChange = async () => {
   const handleChange = async () => {
     if (unref(getDesign).password) {
     if (unref(getDesign).password) {
@@ -58,7 +58,7 @@
   const handleSendCommand = async () => {
   const handleSendCommand = async () => {
     if (props.config.option.mode === ComponentMode.SELECT_PREVIEW) return;
     if (props.config.option.mode === ComponentMode.SELECT_PREVIEW) return;
     const { option } = props.config || {};
     const { option } = props.config || {};
-    const result = await doCommandDeliver(option, Number(unref(checked)));
+    const result = await doControlSendCommand(option, Number(unref(checked)));
     if (!result) checked.value = !unref(checked);
     if (!result) checked.value = !unref(checked);
   };
   };
 
 

@@ -9,8 +9,8 @@
   import { useDataFetch } from '../../../hook/socket/useSocket';
   import { useDataFetch } from '../../../hook/socket/useSocket';
   import PasswordModal from '../component/PasswordModal.vue';
   import PasswordModal from '../component/PasswordModal.vue';
   import { useModal } from '/@/components/Modal';
   import { useModal } from '/@/components/Modal';
-  import { useCommandDelivery } from '../../../hook/useCommandDelivery';
   import { useDeviceProfileQueryContext } from '/@/views/visual/palette/hooks/useDeviceProfileQueryContext';
   import { useDeviceProfileQueryContext } from '/@/views/visual/palette/hooks/useDeviceProfileQueryContext';
+  import { useControlComand } from '../../../hook/useControlCommand';
 
 
   const props = defineProps<{
   const props = defineProps<{
     config: ComponentPropsConfigType<typeof option>;
     config: ComponentPropsConfigType<typeof option>;
@@ -37,12 +37,13 @@
       fontSize: fontSize || persetFontSize || 14,
       fontSize: fontSize || persetFontSize || 14,
     };
     };
   });
   });
-  const { doCommandDeliver, loading } = useCommandDelivery();
+
+  const { loading, doControlSendCommand } = useControlComand();
 
 
   const handleSendCommand = async () => {
   const handleSendCommand = async () => {
     if (props.config.option.mode === ComponentMode.SELECT_PREVIEW) return;
     if (props.config.option.mode === ComponentMode.SELECT_PREVIEW) return;
     const { option } = props.config || {};
     const { option } = props.config || {};
-    const result = await doCommandDeliver(option, Number(!unref(currentValue)));
+    const result = await doControlSendCommand(option, Number(!unref(currentValue)));
     currentValue.value = result ? !unref(currentValue) : unref(currentValue);
     currentValue.value = result ? !unref(currentValue) : unref(currentValue);
   };
   };
   const handleChange = async (event: Event) => {
   const handleChange = async (event: Event) => {

@@ -10,8 +10,8 @@
   import { useDataFetch } from '../../../hook/socket/useSocket';
   import { useDataFetch } from '../../../hook/socket/useSocket';
   import PasswordModal from '../component/PasswordModal.vue';
   import PasswordModal from '../component/PasswordModal.vue';
   import { useModal } from '/@/components/Modal';
   import { useModal } from '/@/components/Modal';
-  import { useCommandDelivery } from '../../../hook/useCommandDelivery';
   import { useDeviceProfileQueryContext } from '/@/views/visual/palette/hooks/useDeviceProfileQueryContext';
   import { useDeviceProfileQueryContext } from '/@/views/visual/palette/hooks/useDeviceProfileQueryContext';
+  import { useControlComand } from '../../../hook/useControlCommand';
 
 
   const props = defineProps<{
   const props = defineProps<{
     config: ComponentPropsConfigType<typeof option>;
     config: ComponentPropsConfigType<typeof option>;
@@ -67,7 +67,7 @@
     sendValue.value = value;
     sendValue.value = value;
   };
   };
 
 
-  const { loading, doCommandDeliver } = useCommandDelivery();
+  const { loading, doControlSendCommand } = useControlComand();
 
 
   const handleAfterChange = () => {
   const handleAfterChange = () => {
     if (unref(getDesign).password) {
     if (unref(getDesign).password) {
@@ -82,7 +82,7 @@
     if (props.config.option.mode === ComponentMode.SELECT_PREVIEW) return;
     if (props.config.option.mode === ComponentMode.SELECT_PREVIEW) return;
     const value = unref(sendValue);
     const value = unref(sendValue);
     const { option } = props.config || {};
     const { option } = props.config || {};
-    const result = await doCommandDeliver(option, value);
+    const result = await doControlSendCommand(option, value);
     unref(sliderElRef)?.blur();
     unref(sliderElRef)?.blur();
     sliderValue.value = result ? value : unref(sliderValue);
     sliderValue.value = result ? value : unref(sliderValue);
   };
   };

@@ -13,11 +13,11 @@
   import { useReceiveValue } from '../../../hook/useReceiveValue';
   import { useReceiveValue } from '../../../hook/useReceiveValue';
   import { useModal } from '/@/components/Modal';
   import { useModal } from '/@/components/Modal';
   import PasswordModal from '../component/PasswordModal.vue';
   import PasswordModal from '../component/PasswordModal.vue';
+  import { useDeviceProfileQueryContext } from '/@/views/visual/palette/hooks/useDeviceProfileQueryContext';
   import {
   import {
     DoCommandDeliverDataSourceType,
     DoCommandDeliverDataSourceType,
-    useCommandDelivery,
-  } from '../../../hook/useCommandDelivery';
-  import { useDeviceProfileQueryContext } from '/@/views/visual/palette/hooks/useDeviceProfileQueryContext';
+    useControlComand,
+  } from '../../../hook/useControlCommand';
 
 
   const props = defineProps<{
   const props = defineProps<{
     config: ComponentPropsConfigType<typeof option>;
     config: ComponentPropsConfigType<typeof option>;
@@ -96,10 +96,10 @@
     props.config.option.dataSource ? unref(getDesign).dataSource : DEFAULT_VALUE
     props.config.option.dataSource ? unref(getDesign).dataSource : DEFAULT_VALUE
   );
   );
 
 
-  const { loading, doCommandDeliver } = useCommandDelivery();
+  const { loading, doControlSendCommand } = useControlComand();
   const handleSendCommand = async (modalData: SwitchItemType) => {
   const handleSendCommand = async (modalData: SwitchItemType) => {
     if (props.config.option.mode === ComponentMode.SELECT_PREVIEW) return;
     if (props.config.option.mode === ComponentMode.SELECT_PREVIEW) return;
-    await doCommandDeliver(
+    await doControlSendCommand(
       toRaw(unref(modalData)) as DoCommandDeliverDataSourceType,
       toRaw(unref(modalData)) as DoCommandDeliverDataSourceType,
       Number(unref(modalData).checked)
       Number(unref(modalData).checked)
     );
     );

@@ -9,12 +9,11 @@ import { findDictItemByCode } from '/@/api/system/dict';
 import { ApiCascader, FormSchema, useComponentRegister } from '/@/components/Form';
 import { ApiCascader, FormSchema, useComponentRegister } from '/@/components/Form';
 import { OrgTreeSelect } from '/@/views/common/OrgTreeSelect';
 import { OrgTreeSelect } from '/@/views/common/OrgTreeSelect';
 import { DataActionModeEnum } from '/@/enums/toolEnum';
 import { DataActionModeEnum } from '/@/enums/toolEnum';
-import { TaskTypeEnum } from '/@/views/task/center/config';
 import { createPickerSearch } from '/@/utils/pickerSearch';
 import { createPickerSearch } from '/@/utils/pickerSearch';
-import { DataTypeEnum } from '/@/enums/objectModelEnum';
-import { CommandTypeEnum, CommandTypeNameEnum } from '/@/enums/deviceEnum';
+import { DataTypeEnum, ObjectModelAccessModeEnum } from '/@/enums/objectModelEnum';
+import { CommandTypeEnum, CommandTypeNameEnum, TCPProtocolTypeEnum } from '/@/enums/deviceEnum';
 import { TransportTypeEnum } from '/@/enums/deviceEnum';
 import { TransportTypeEnum } from '/@/enums/deviceEnum';
-import { DeviceTypeEnum } from '/@/api/device/model/deviceModel';
+import { DeviceProfileModel, DeviceTypeEnum } from '/@/api/device/model/deviceModel';
 import { ControlComponentEnum } from '../components/Control';
 import { ControlComponentEnum } from '../components/Control';
 import { isNullOrUnDef } from '/@/utils/is';
 import { isNullOrUnDef } from '/@/utils/is';
 import { validateTCPCustomCommand } from '/@/components/Form/src/components/ThingsModelForm';
 import { validateTCPCustomCommand } from '/@/components/Form/src/components/ThingsModelForm';
@@ -35,20 +34,16 @@ export interface CommonDataSourceBindValueType extends Record<DataSourceField, s
 }
 }
 
 
 export enum DataSourceField {
 export enum DataSourceField {
-  // IS_GATEWAY_DEVICE = 'gatewayDevice',
   DEVICE_TYPE = 'deviceType',
   DEVICE_TYPE = 'deviceType',
   TRANSPORT_TYPE = 'transportType',
   TRANSPORT_TYPE = 'transportType',
   ORIGINATION_ID = 'organizationId',
   ORIGINATION_ID = 'organizationId',
   DEVICE_ID = 'deviceId',
   DEVICE_ID = 'deviceId',
-  // DEVICE_CODE = 'deviceCode', //设备地址码
   DEVICE_PROFILE_ID = 'deviceProfileId',
   DEVICE_PROFILE_ID = 'deviceProfileId',
   ATTRIBUTE = 'attribute',
   ATTRIBUTE = 'attribute',
-  // ATTRIBUTE_NAME = 'attributeName',
   ATTRIBUTE_RENAME = 'attributeRename',
   ATTRIBUTE_RENAME = 'attributeRename',
   DEVICE_NAME = 'deviceName',
   DEVICE_NAME = 'deviceName',
   DEVICE_RENAME = 'deviceRename',
   DEVICE_RENAME = 'deviceRename',
 
 
-  CODE_TYPE = 'codeType',
   // COMMAND = 'command',
   // COMMAND = 'command',
 
 
   OPEN_COMMAND = 'openCommand',
   OPEN_COMMAND = 'openCommand',
@@ -78,8 +73,7 @@ export enum DataSourceField {
    */
    */
   LATITUDE_IDENTIFIER = 'latitudeIdentifier',
   LATITUDE_IDENTIFIER = 'latitudeIdentifier',
 
 
-  // EXTENSION_DESC = 'extensionDesc',
-  // CALL_TYPE = 'callType',
+  IS_TCP_MODBUS_PROFILE = 'isTcpModbusProfile',
 }
 }
 
 
 const isTcpProfile = (transportType: string) => transportType === TransportTypeEnum.TCP;
 const isTcpProfile = (transportType: string) => transportType === TransportTypeEnum.TCP;
@@ -131,6 +125,7 @@ export const commonDataSourceSchemas = (): FormSchema[] => {
               [DataSourceField.DEVICE_ID]: null,
               [DataSourceField.DEVICE_ID]: null,
               [DataSourceField.ATTRIBUTE]: null,
               [DataSourceField.ATTRIBUTE]: null,
               [DataSourceField.TRANSPORT_TYPE]: null,
               [DataSourceField.TRANSPORT_TYPE]: null,
+              [DataSourceField.COMMAND_TYPE]: null,
             });
             });
           },
           },
           getPopupContainer: () => document.body,
           getPopupContainer: () => document.body,
@@ -144,6 +139,12 @@ export const commonDataSourceSchemas = (): FormSchema[] => {
       ifShow: false,
       ifShow: false,
     },
     },
     {
     {
+      field: DataSourceField.IS_TCP_MODBUS_PROFILE,
+      component: 'Input',
+      label: 'TCP Modbus产品',
+      ifShow: false,
+    },
+    {
       field: DataSourceField.DEVICE_PROFILE_ID,
       field: DataSourceField.DEVICE_PROFILE_ID,
       component: 'ApiSelect',
       component: 'ApiSelect',
       label: '产品',
       label: '产品',
@@ -166,14 +167,35 @@ export const commonDataSourceSchemas = (): FormSchema[] => {
           labelField: 'name',
           labelField: 'name',
           valueField: 'id',
           valueField: 'id',
           placeholder: '请选择产品',
           placeholder: '请选择产品',
-          onChange: (_, option: Record<'transportType', string>) => {
+          onChange: (_, option: DeviceProfileModel) => {
+            const transportType = option?.[DataSourceField.TRANSPORT_TYPE];
             setFieldsValue({
             setFieldsValue({
               [DataSourceField.DEVICE_ID]: null,
               [DataSourceField.DEVICE_ID]: null,
               [DataSourceField.ATTRIBUTE]: null,
               [DataSourceField.ATTRIBUTE]: null,
-              [DataSourceField.TRANSPORT_TYPE]: option?.[DataSourceField.TRANSPORT_TYPE],
               [DataSourceField.COMMAND_TYPE]: null,
               [DataSourceField.COMMAND_TYPE]: null,
+              [DataSourceField.TRANSPORT_TYPE]: transportType,
+              [DataSourceField.IS_TCP_MODBUS_PROFILE]:
+                transportType === TransportTypeEnum.TCP &&
+                option?.profileData?.transportConfiguration?.protocol ===
+                  TCPProtocolTypeEnum.MODBUS_RTU,
             });
             });
           },
           },
+          onOptionsChange(options: (DeviceProfileModel & Record<'value' | 'label', string>)[]) {
+            const currentItem = options.find(
+              (item) => item.value === formModel[DataSourceField.DEVICE_PROFILE_ID]
+            );
+
+            if (currentItem) {
+              const transportType = currentItem?.[DataSourceField.TRANSPORT_TYPE];
+              setFieldsValue({
+                [DataSourceField.TRANSPORT_TYPE]: transportType,
+                [DataSourceField.IS_TCP_MODBUS_PROFILE]:
+                  transportType === TransportTypeEnum.TCP &&
+                  currentItem?.profileData?.transportConfiguration?.protocol ===
+                    TCPProtocolTypeEnum.MODBUS_RTU,
+              });
+            }
+          },
           getPopupContainer: () => document.body,
           getPopupContainer: () => document.body,
         };
         };
       },
       },
@@ -236,13 +258,13 @@ export const commonDataSourceSchemas = (): FormSchema[] => {
                     deviceType: item.deviceType,
                     deviceType: item.deviceType,
                   }));
                   }));
 
 
-                  if (
-                    unref(selectWidgetKeys).componentKey ===
-                      ControlComponentEnum.LATERAL_NUMERICAL_CONTROL &&
-                    isTcpProfile(formModel[DataSourceField.TRANSPORT_TYPE])
-                  ) {
-                    return result.filter((item) => item.codeType === TaskTypeEnum.MODBUS_RTU);
-                  }
+                  // if (
+                  //   unref(selectWidgetKeys).componentKey ===
+                  //     ControlComponentEnum.LATERAL_NUMERICAL_CONTROL &&
+                  //   isTcpProfile(formModel[DataSourceField.TRANSPORT_TYPE])
+                  // ) {
+                  //   return result.filter((item) => item.codeType === TaskTypeEnum.MODBUS_RTU);
+                  // }
 
 
                   return result;
                   return result;
                 }
                 }
@@ -254,7 +276,6 @@ export const commonDataSourceSchemas = (): FormSchema[] => {
             setFieldsValue({
             setFieldsValue({
               [DataSourceField.COMMAND_TYPE]: null,
               [DataSourceField.COMMAND_TYPE]: null,
               [DataSourceField.DEVICE_NAME]: options?.label,
               [DataSourceField.DEVICE_NAME]: options?.label,
-              [DataSourceField.CODE_TYPE]: options?.codeType,
             });
             });
           },
           },
           placeholder: '请选择设备',
           placeholder: '请选择设备',
@@ -263,26 +284,19 @@ export const commonDataSourceSchemas = (): FormSchema[] => {
       },
       },
     },
     },
     {
     {
-      field: DataSourceField.CODE_TYPE,
-      label: '设备标识符类型',
-      component: 'Input',
-      ifShow: false,
-    },
-    {
       field: DataSourceField.ATTRIBUTE,
       field: DataSourceField.ATTRIBUTE,
       component: 'ApiSelect',
       component: 'ApiSelect',
       label: '属性',
       label: '属性',
       colProps: { span: 8 },
       colProps: { span: 8 },
       rules: [{ required: true, message: '请选择属性' }],
       rules: [{ required: true, message: '请选择属性' }],
       ifShow: () => category !== CategoryEnum.MAP,
       ifShow: () => category !== CategoryEnum.MAP,
-      componentProps({ formModel, formActionType }) {
-        const { setFieldsValue } = formActionType;
+      componentProps({ formModel }) {
         const deviceProfileId = formModel[DataSourceField.DEVICE_PROFILE_ID];
         const deviceProfileId = formModel[DataSourceField.DEVICE_PROFILE_ID];
         return {
         return {
           api: async () => {
           api: async () => {
             try {
             try {
               if (deviceProfileId) {
               if (deviceProfileId) {
-                const option = await getDeviceAttribute({
+                let option = await getDeviceAttribute({
                   deviceProfileId,
                   deviceProfileId,
                   dataType:
                   dataType:
                     (isControlComponent(category!) &&
                     (isControlComponent(category!) &&
@@ -292,21 +306,26 @@ export const commonDataSourceSchemas = (): FormSchema[] => {
                       ? DataTypeEnum.BOOL
                       ? DataTypeEnum.BOOL
                       : undefined,
                       : undefined,
                 });
                 });
+                // 过滤只读属性
+                option = option.filter(
+                  (item) => item.accessMode !== ObjectModelAccessModeEnum.READ
+                );
 
 
                 // 选择控制组件4的时候只能选择属性且是（int double类型）
                 // 选择控制组件4的时候只能选择属性且是（int double类型）
                 if (
                 if (
                   unref(selectWidgetKeys).componentKey ===
                   unref(selectWidgetKeys).componentKey ===
                   ControlComponentEnum.LATERAL_NUMERICAL_CONTROL
                   ControlComponentEnum.LATERAL_NUMERICAL_CONTROL
                 ) {
                 ) {
-                  setFieldsValue({
-                    [DataSourceField.COMMAND_TYPE]: CommandTypeEnum.ATTRIBUTE.toString(),
-                  });
+                  // setFieldsValue({
+                  //   [DataSourceField.COMMAND_TYPE]: CommandTypeEnum.ATTRIBUTE.toString(),
+                  // });
                   return option.filter(
                   return option.filter(
                     (item) =>
                     (item) =>
                       item.detail.dataType.type === DataTypeEnum.NUMBER_INT ||
                       item.detail.dataType.type === DataTypeEnum.NUMBER_INT ||
                       item.detail.dataType.type == DataTypeEnum.NUMBER_DOUBLE
                       item.detail.dataType.type == DataTypeEnum.NUMBER_DOUBLE
                   );
                   );
                 }
                 }
+
                 return option;
                 return option;
               }
               }
             } catch (error) {}
             } catch (error) {}
@@ -412,18 +431,19 @@ export const commonDataSourceSchemas = (): FormSchema[] => {
           isControlComponent(category!) &&
           isControlComponent(category!) &&
           unref(selectWidgetKeys).componentKey !== ControlComponentEnum.LATERAL_NUMERICAL_CONTROL &&
           unref(selectWidgetKeys).componentKey !== ControlComponentEnum.LATERAL_NUMERICAL_CONTROL &&
           isTcpProfile(model[DataSourceField.TRANSPORT_TYPE]) &&
           isTcpProfile(model[DataSourceField.TRANSPORT_TYPE]) &&
-          model[DataSourceField.CODE_TYPE] === TaskTypeEnum.CUSTOM
+          !model[DataSourceField.IS_TCP_MODBUS_PROFILE]
         );
         );
       },
       },
       componentProps: ({ formActionType, formModel }) => {
       componentProps: ({ formActionType, formModel }) => {
         const { setFieldsValue } = formActionType;
         const { setFieldsValue } = formActionType;
         const deviceType = formModel[DataSourceField.DEVICE_TYPE];
         const deviceType = formModel[DataSourceField.DEVICE_TYPE];
+        const isTCPModbusProfile = formModel[DataSourceField.IS_TCP_MODBUS_PROFILE];
         const options: Record<'label' | 'value', string | number>[] = [
         const options: Record<'label' | 'value', string | number>[] = [
           { label: CommandTypeNameEnum.CUSTOM, value: CommandTypeEnum.CUSTOM },
           { label: CommandTypeNameEnum.CUSTOM, value: CommandTypeEnum.CUSTOM },
         ];
         ];
 
 
-        // 网关子设备无服务
-        if (deviceType !== DeviceTypeEnum.SENSOR)
+        // TCP网关子设备无服务 TCP Modbus类型设备无服务
+        if (deviceType !== DeviceTypeEnum.SENSOR && !isTCPModbusProfile)
           options.push({ label: CommandTypeNameEnum.SERVICE, value: CommandTypeEnum.SERVICE });
           options.push({ label: CommandTypeNameEnum.SERVICE, value: CommandTypeEnum.SERVICE });
 
 
         return {
         return {
@@ -448,9 +468,8 @@ export const commonDataSourceSchemas = (): FormSchema[] => {
       colProps: { span: 8 },
       colProps: { span: 8 },
       rules: [{ required: true, message: '请选择开服务' }],
       rules: [{ required: true, message: '请选择开服务' }],
       ifShow: ({ model }) =>
       ifShow: ({ model }) =>
-        isControlComponent(category!) &&
-        model[DataSourceField.COMMAND_TYPE] === CommandTypeEnum.SERVICE &&
-        isTcpProfile(model[DataSourceField.TRANSPORT_TYPE]),
+        isTcpProfile(model[DataSourceField.TRANSPORT_TYPE]) &&
+        model[DataSourceField.COMMAND_TYPE] === CommandTypeEnum.SERVICE,
       componentProps({ formModel }) {
       componentProps({ formModel }) {
         const deviceProfileId = formModel[DataSourceField.DEVICE_PROFILE_ID];
         const deviceProfileId = formModel[DataSourceField.DEVICE_PROFILE_ID];
         return {
         return {
@@ -472,9 +491,8 @@ export const commonDataSourceSchemas = (): FormSchema[] => {
       colProps: { span: 8 },
       colProps: { span: 8 },
       rules: [{ required: true, message: '请选择关服务' }],
       rules: [{ required: true, message: '请选择关服务' }],
       ifShow: ({ model }) =>
       ifShow: ({ model }) =>
-        isControlComponent(category!) &&
-        model[DataSourceField.COMMAND_TYPE] === CommandTypeEnum.SERVICE &&
-        isTcpProfile(model[DataSourceField.TRANSPORT_TYPE]),
+        isTcpProfile(model[DataSourceField.TRANSPORT_TYPE]) &&
+        model[DataSourceField.COMMAND_TYPE] === CommandTypeEnum.SERVICE,
       componentProps({ formModel }) {
       componentProps({ formModel }) {
         const deviceProfileId = formModel[DataSourceField.DEVICE_PROFILE_ID];
         const deviceProfileId = formModel[DataSourceField.DEVICE_PROFILE_ID];
         return {
         return {
@@ -497,10 +515,8 @@ export const commonDataSourceSchemas = (): FormSchema[] => {
       rules: [{ validator: validateTCPCustomCommand }],
       rules: [{ validator: validateTCPCustomCommand }],
       // 是控制组件  && 自定义命令  && 传输协议为TCP
       // 是控制组件  && 自定义命令  && 传输协议为TCP
       ifShow: ({ model }) =>
       ifShow: ({ model }) =>
-        isControlComponent(category!) &&
-        model[DataSourceField.COMMAND_TYPE] === CommandTypeEnum.CUSTOM &&
-        model[DataSourceField.TRANSPORT_TYPE] &&
-        isTcpProfile(model[DataSourceField.TRANSPORT_TYPE]),
+        isTcpProfile(model[DataSourceField.TRANSPORT_TYPE]) &&
+        model[DataSourceField.COMMAND_TYPE] === CommandTypeEnum.CUSTOM,
       componentProps: {
       componentProps: {
         placeholder: '请输入开下发命令',
         placeholder: '请输入开下发命令',
       },
       },
@@ -513,10 +529,8 @@ export const commonDataSourceSchemas = (): FormSchema[] => {
       rules: [{ validator: validateTCPCustomCommand }],
       rules: [{ validator: validateTCPCustomCommand }],
       // 是控制组件  && 自定义命令  && 传输协议为TCP
       // 是控制组件  && 自定义命令  && 传输协议为TCP
       ifShow: ({ model }) =>
       ifShow: ({ model }) =>
-        isControlComponent(category!) &&
-        model[DataSourceField.COMMAND_TYPE] === CommandTypeEnum.CUSTOM &&
-        model[DataSourceField.TRANSPORT_TYPE] &&
-        isTcpProfile(model[DataSourceField.TRANSPORT_TYPE]),
+        isTcpProfile(model[DataSourceField.TRANSPORT_TYPE]) &&
+        model[DataSourceField.COMMAND_TYPE] === CommandTypeEnum.CUSTOM,
       componentProps: {
       componentProps: {
         placeholder: '请输入关下发命令',
         placeholder: '请输入关下发命令',
       },
       },