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

feat：支持标准modbus_rtu解析及命令下发

See merge request yunteng/thingskit-scada!216

-import type { AlarmStatusEnum } from '@/enums/datasource'
+import type { AlarmStatusEnum } from '@/enums/alarmEnum'
 
 /**
  * 告警列表

 import type { DeviceActiveType, DeviceAttributeItemType, DeviceItemType, DeviceProfileItemType, OrganizationItemType, ProductsDetailWithThingsModelType, RpcCommandType, SendValue, ThingsModel, ThingsModelItemType } from './model'
 import { CommandWayEnum } from '@/enums/commandEnum'
-import type { DeviceTypeEnum } from '@/enums/datasource'
-import { FunctionTypeEnum } from '@/enums/datasource'
+import type { DeviceTypeEnum } from '@/enums/deviceEnum'
+import { FunctionTypeEnum } from '@/enums/objectModelEnum'
 import { isShareMode } from '@/utils/env'
 import { defHttp } from '@/utils/http'
 
@@ -24,6 +24,7 @@ enum Api {
   GET_LIST_BY_CONFIGURATION_ID = '/configuration/center/getListByConfigurationId',
 
   GET_PRODUCTS_DETAIL_WITH_THINGS_MODEL = '/things_model/batch/get_tsl',
+
 }
 
 export interface GenModbusCommandType {
@@ -33,6 +34,7 @@ export interface GenModbusCommandType {
   registerAddress: number
   registerNumber?: number
   registerValues?: number[]
+  hexByteOrderEnum?: string
 }
 
 export const getDeviceProfile = (deviceType?: DeviceTypeEnum) => {
@@ -128,6 +130,17 @@ export const getDeviceActiveTime = (entityId: string) => {
   )
 }
 
+export const getDeviceTelemetryValue = (params: { entityId: string; keys: string }) => {
+  return defHttp.get({
+    url: `${Api.GET_DEVICE_ACTIVE}${params.entityId}/values/timeseries`,
+    params: {
+      keys: params.keys,
+    },
+  }, {
+    joinPrefix: false,
+  })
+}
+
 // 获取设备详情
 export const getDeviceInfo = (deviceId: string) => {
   return defHttp.get<DeviceItemType>(

-import type { DataTypeEnum, FunctionTypeEnum, TransportTypeEnum } from '@/enums/datasource'
+import type { CommandCallWayEnum } from '@/enums/commandEnum'
+import type { TCPProtocolTypeEnum, TransportTypeEnum } from '@/enums/deviceEnum'
+import type { DataTypeEnum, ExtendDescOperationTypeEnum, FunctionTypeEnum, OriginalDataTypeEnum } from '@/enums/objectModelEnum'
 
 export interface DeviceProfileItemType {
   id: string
@@ -41,6 +43,7 @@ export interface Configuration {
 
 export interface TransportConfiguration {
   type: string
+  protocol: TCPProtocolTypeEnum
 }
 
 export interface ProvisionConfiguration {
@@ -116,6 +119,10 @@ export interface DeviceItemType {
   deviceType: string
   alarmStatus: number
   enable: boolean
+  deviceProfile: {
+    transportType: TransportTypeEnum
+    profileData: ProfileData
+  }
 
   transportType: TransportTypeEnum
 }
@@ -135,10 +142,14 @@ export interface ThingsModelItemType {
 }
 
 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 Detail {
@@ -146,7 +157,7 @@ export interface Detail {
 }
 
 export interface DataType {
-  type: string
+  type: DataTypeEnum
   specs: Specs | StructJSON[]
   specsList: Specs[]
 }
@@ -163,6 +174,7 @@ export interface Specs {
   name?: string
   value?: any
   dataType?: DataTypeEnum
+  step?: number
 }
 
 export interface ValueRange {
@@ -207,6 +219,8 @@ export interface Tsl {
   functionName: string
   identifier: string
   accessMode: string
+  functionType: FunctionTypeEnum
+  callType: CommandCallWayEnum
   specs: {
     dataType: DataType
   }

 import type { ThingsModelItemType } from '@/api/device/model'
 import type { ImageSelectorDataType } from '@/core/Library/components/ImageSelector'
-import type { CommandWayEnum } from '@/enums/commandEnum'
-import type { ActRangListItemTypeEnum, ActTypeEnum, AggregateTypeEnum, CommandDeliveryWayEnum, DeviceTypeEnum, EventActionTypeEnum, EventTypeEnum, SocketSubscriberEnum } from '@/enums/datasource'
+import type { CommandDeliveryWayEnum, CommandWayEnum } from '@/enums/commandEnum'
+import type { ActRangListItemTypeEnum, ActTypeEnum, AggregateTypeEnum, EventActionTypeEnum, EventTypeEnum, SocketSubscriberEnum } from '@/enums/datasource'
+import type { DeviceTypeEnum } from '@/enums/deviceEnum'
 
 export enum DeleteNodeDataTypeEnum {
   DATASOURCE = 'DATASOURCE',

@@ -2,7 +2,9 @@ import type { FormSchema } from '@/components/Form'
 import { ComponentEnum } from '@/components/Form/src/enum'
 import type { BasicColumn } from '@/components/Table'
 import type { CommandWayEnum } from '@/enums/commandEnum'
-import { ActTypeEnum, type CodeTypeEnum, type ContentDataFieldsEnum, type DeviceTypeEnum } from '@/enums/datasource'
+import { ActTypeEnum, type ContentDataFieldsEnum } from '@/enums/datasource'
+import type { DeviceTypeEnum, TCPProtocolTypeEnum } from '@/enums/deviceEnum'
+
 export enum TableColumnFieldEnum {
   DEVICE_ID = 'deviceId',
   WAY = 'way',
@@ -15,7 +17,7 @@ export interface TableRecordItemType {
   [TableColumnFieldEnum.WAY]?: Nullable<CommandWayEnum>
   [TableColumnFieldEnum.COMMAND]?: Nullable<string | Recordable>
   [ContentDataFieldsEnum.DEVICE_TYPE]?: Nullable<DeviceTypeEnum>
-  [ContentDataFieldsEnum.CODE_TYPE]?: Nullable<CodeTypeEnum>
+  [ContentDataFieldsEnum.CODE_TYPE]?: Nullable<TCPProtocolTypeEnum>
 }
 
 export const getFormSchemas = (): FormSchema[] => {

@@ -2,10 +2,10 @@ import type { DeviceItemType, Specs, StructJSON, Tsl } from '@/api/device/model'
 import type { NodeDataDataSourceJsonType, OperationPasswordDataType, SingleClickEventDataType } from '@/api/node/model'
 import { type FormSchema, useComponentRegister } from '@/components/Form'
 import { ComponentEnum } from '@/components/Form/src/enum'
-import { ThingsModelForm, validateTCPCustomCommand } from '@/core/Library/components/ThingsModelForm'
+import { ThingsModelForm } from '@/core/Library/components/ThingsModelForm'
 import { getFormSchemas } from '@/core/Library/components/ThingsModelForm/config'
-import { CodeTypeEnum, DataTypeEnum, TransportTypeEnum } from '@/enums/datasource'
-import { TCPObjectModelActionTypeEnum } from '@/enums/objectModelEnum'
+import { TCPProtocolTypeEnum, TransportTypeEnum } from '@/enums/deviceEnum'
+import { DataTypeEnum, OriginalDataTypeEnum } from '@/enums/objectModelEnum'
 
 useComponentRegister(ComponentEnum.THINGS_MODEL_FORM, ThingsModelForm)
 
@@ -35,59 +35,57 @@ function getStructJsonFromDataSourceJson(objectModelTsl: Tsl): StructJSON {
   }
 }
 
-function getTCPModbusSchemas({ objectModelTsl, required }: { objectModelTsl: Tsl; required?: boolean }): FormSchema {
-  const { specs: tslSpecs, extensionDesc } = objectModelTsl
-  const { dataType } = tslSpecs
-  const { specs, type } = dataType || {}
-  const { valueRange, length = 10240 } = specs! as Specs
-  const { max = Number.MAX_SAFE_INTEGER, min = Number.MIN_SAFE_INTEGER } = valueRange || {}
-  const { actionType } = extensionDesc || {}
+const validateDouble = (value: number, min?: number | string, max?: number | string) => {
+  min = Number(min) ?? Number.MIN_SAFE_INTEGER
+  max = Number(max) ?? Number.MAX_SAFE_INTEGER
 
-  function createInputNumber({
-    identifier,
-    functionName,
-  }: Tsl): FormSchema {
-    return {
-      field: identifier,
-      label: functionName,
-      component: ComponentEnum.INPUT_NUMBER,
-      required,
-      componentProps: {
-        max: actionType === TCPObjectModelActionTypeEnum.BOOL ? 1 : max,
-        min: actionType === TCPObjectModelActionTypeEnum.BOOL ? 0 : min,
-        precision: actionType === TCPObjectModelActionTypeEnum.BOOL ? 0 : 2,
-      },
-    }
+  return {
+    flag: value < min || value > max,
+    message: `取值范围在${min}~${max}之间`,
   }
+}
 
-  const createInput = ({ identifier, functionName }: Tsl): FormSchema => {
-    return {
-      field: identifier,
-      label: functionName,
-      component: ComponentEnum.INPUT,
-      rules: [
-        {
-          required,
-          message: `${functionName}是必填项`,
-        },
-        {
-          validator: validateTCPCustomCommand,
-        },
-      ],
-      componentProps: {
-        maxLength: length,
-      },
-    } as FormSchema
-  }
+export const createModbusValueInput = (objectModel: Tsl): FormSchema => {
+  const { identifier, functionName, extensionDesc } = objectModel
+
+  const { dataType } = objectModel.specs || {}
+  const { specs } = dataType || {}
+  const { valueRange } = specs as Specs
+  const { max, min } = valueRange || {}
 
-  return type === DataTypeEnum.STRING ? createInput(objectModelTsl) : createInputNumber(objectModelTsl)
+  const isStringType = extensionDesc?.originalDataType === OriginalDataTypeEnum.STRING
+  return {
+    field: identifier,
+    label: functionName,
+    component: isStringType ? ComponentEnum.INPUT : ComponentEnum.INPUT_NUMBER,
+    rules: isStringType
+      ? []
+      : [
+          {
+            type: 'number',
+            validator: (_rule, value) => {
+              const { flag, message } = validateDouble(value, min, max)
+              if (flag)
+                return Promise.reject(Error(`${functionName}${message}`))
+
+              return Promise.resolve(value)
+            },
+          },
+        ],
+    componentProps: {
+      // max: max ?? Number.MAX_SAFE_INTEGER,
+      // min: min ?? Number.MIN_SAFE_INTEGER,
+      placeholder: `请输入${functionName}`,
+      precision: 0,
+    },
+  }
 }
 
 export const createFormSchemas = ({ operationPasswordInfo, objectModelTsl, deviceInfo }: CreateFormSchemasParamsType): FormSchema[] => {
   const schemas: FormSchema[] = []
 
-  if (deviceInfo?.transportType === TransportTypeEnum.TCP && deviceInfo.codeType === CodeTypeEnum.MODBUS_RTU && deviceInfo.code) {
-    schemas.push(getTCPModbusSchemas({ required: true, objectModelTsl }))
+  if (deviceInfo?.transportType === TransportTypeEnum.TCP && deviceInfo.deviceProfile?.profileData?.transportConfiguration?.protocol === TCPProtocolTypeEnum.MODBUS_RTU) {
+    schemas.push(createModbusValueInput(objectModelTsl))
   }
   else {
     const isStructType = objectModelTsl.specs.dataType.type === DataTypeEnum.STRUCT

 <script setup lang="ts">
 import { Modal } from 'ant-design-vue'
 import { nextTick, ref, toRaw, unref } from 'vue'
-import type { AttributeDeliverModalOpenParamsType } from './AttributeDeliverModal.config'
-import { createFormSchemas } from './AttributeDeliverModal.config'
-import { useCommandDeliver } from './useCommadDeliver'
+import { type AttributeDeliverModalOpenParamsType, createFormSchemas } from './AttributeDeliverModal.config'
 import { BasicForm, useForm } from '@/components/Form'
 import { FormLayoutEnum } from '@/components/Form/src/enum'
-import { DataTypeEnum } from '@/enums/datasource'
+import type { DeviceItemType, Tsl } from '@/api/device/model'
+import { useProductsStore } from '@/store/modules/products'
+import { getDeviceInfo } from '@/api/device'
+import type { CommandWayEnum } from '@/enums/commandEnum'
+import { useCommandDelivery } from '@/hooks/business/useCommandDelivery'
+import { DataTypeEnum } from '@/enums/objectModelEnum'
+import { useMessage } from '@/hooks/web/useMessage'
 
 const visible = ref(false)
 
@@ -15,25 +19,41 @@ const [register, { getFieldsValue, resetFields, validate, setProps, clearValidat
   showActionButtonGroup: false,
 })
 
-const { setup, getDeviceInfo, getObjectModelTsl, doCommandDeliver } = useCommandDeliver()
+const deviceInfo = ref<DeviceItemType>()
+const objectModelTsl = ref<Tsl>()
+const productsStore = useProductsStore()
+const commandWay = ref<CommandWayEnum>()
 
 const open = async ({ operationPasswordInfo, dataSourceJson, eventBindData }: AttributeDeliverModalOpenParamsType) => {
   visible.value = true
   const { deviceId, deviceProfileId, attr } = dataSourceJson
   const { way } = eventBindData
-  await setup({ deviceId, deviceProfileId, attr, callType: way })
+  commandWay.value = way
+  objectModelTsl.value = productsStore.getObjectModelByIdWithIdentifier(deviceProfileId, attr as string)!
+  deviceInfo.value = await getDeviceInfo(deviceId)
 
   nextTick(() => {
-    const schemas = createFormSchemas({ operationPasswordInfo, deviceInfo: toRaw(unref(getDeviceInfo)!), objectModelTsl: toRaw(unref(getObjectModelTsl)!) })
+    const schemas = createFormSchemas({ operationPasswordInfo, deviceInfo: toRaw(unref(deviceInfo)!), objectModelTsl: toRaw(unref(objectModelTsl)!) })
     setProps({ schemas })
   })
 }
 
 async function getResult() {
-  const result = getFieldsValue()
-  const isStructJSON = unref(getObjectModelTsl)?.specs.dataType.type === DataTypeEnum.STRUCT
-  const identifier = unref(getObjectModelTsl)!.identifier
-  await doCommandDeliver(isStructJSON ? result : result[identifier])
+  let value = getFieldsValue()
+  const { doCommandDelivery } = useCommandDelivery()
+
+  const isStructJSON = unref(objectModelTsl)?.specs.dataType.type === DataTypeEnum.STRUCT
+  const identifier = unref(objectModelTsl)!.identifier
+  value = isStructJSON ? value : value[identifier]
+
+  await doCommandDelivery({
+    objectModel: unref(objectModelTsl),
+    deviceDetail: unref(deviceInfo),
+    value,
+  })
+
+  const { createMessage } = useMessage()
+  createMessage.success('命令下发成功')
 }
 
 const handleOk = async () => {
@@ -53,7 +73,7 @@ defineExpose({ open })
 
 <template>
   <Modal
-    v-model:open="visible" :title="`属性下发 / ${getDeviceInfo?.alias || getDeviceInfo?.name}`" ok-text="确认" :width="400" cancel-text="取消" @cancel="handleCancel"
+    v-model:open="visible" :title="`属性下发 / ${deviceInfo?.alias || deviceInfo?.name}`" ok-text="确认" :width="400" cancel-text="取消" @cancel="handleCancel"
     @ok="handleOk"
   >
     <BasicForm @register="register" />

@@ -2,10 +2,16 @@
 import { Modal } from 'ant-design-vue'
 import { computed, nextTick, ref, unref } from 'vue'
 import { Icon } from '@iconify/vue'
-import { useCommandDeliver } from './useCommadDeliver'
 import { BasicForm, type FormSchema, useForm } from '@/components/Form'
 import { ComponentEnum, FormLayoutEnum } from '@/components/Form/src/enum'
 import type { NodeDataDataSourceJsonType, OperationPasswordDataType, SingleClickEventDataType } from '@/api/node/model'
+import type { DoCommandDeliverParamsType } from '@/hooks/business/useCommandDelivery'
+import { useCommandDelivery } from '@/hooks/business/useCommandDelivery'
+import { CommandDeliveryWayEnum } from '@/enums/commandEnum'
+import { useProductsStore } from '@/store/modules/products'
+import { getDeviceInfo } from '@/api/device'
+import { TransportTypeEnum } from '@/enums/deviceEnum'
+import { useMessage } from '@/hooks/web/useMessage'
 
 interface SwitchCommandDeliveryModalParamsType {
   operationPasswordInfo?: OperationPasswordDataType
@@ -18,8 +24,6 @@ const visible = ref(false)
 
 const currentOperationPasswordInfo = ref<OperationPasswordDataType>()
 
-const currendSendValue = ref()
-
 const [register, { resetFields, validate, setProps }] = useForm({
   showActionButtonGroup: false,
   layout: FormLayoutEnum.VERTICAL,
@@ -45,17 +49,17 @@ const createFormSchemas = (password: string): FormSchema[] => {
   ]
 }
 
-const getHasEnableOperationPassword = computed(() => !!(unref(currentOperationPasswordInfo)?.checked && unref(currentOperationPasswordInfo)?.value))
+const productsStore = useProductsStore()
 
-const { setup, doCommandDeliver, getDeviceInfo } = useCommandDeliver()
+const getHasEnableOperationPassword = computed(() => !!(unref(currentOperationPasswordInfo)?.checked && unref(currentOperationPasswordInfo)?.value))
 
-const open = async ({ operationPasswordInfo, dataSourceJson, eventBindData, sendValue }: SwitchCommandDeliveryModalParamsType) => {
+const currentParams = ref<SwitchCommandDeliveryModalParamsType>()
+const open = async (params: SwitchCommandDeliveryModalParamsType) => {
+  const { operationPasswordInfo } = params
   visible.value = true
+  currentParams.value = params
   currentOperationPasswordInfo.value = operationPasswordInfo
-  currendSendValue.value = sendValue
-  const { deviceId, deviceProfileId, attr } = unref(dataSourceJson)
-  const { way } = eventBindData
-  await setup({ deviceId, deviceProfileId, attr, callType: way })
+
   nextTick(() => {
     unref(getHasEnableOperationPassword) && setProps({ schemas: createFormSchemas(operationPasswordInfo!.value!) })
   })
@@ -64,7 +68,36 @@ const open = async ({ operationPasswordInfo, dataSourceJson, eventBindData, send
 const handlerOk = async () => {
   if (unref(getHasEnableOperationPassword))
     await validate()
-  await doCommandDeliver(unref(currendSendValue))
+  const { doCommandDelivery } = useCommandDelivery()
+
+  const { sendValue, eventBindData, dataSourceJson } = unref(currentParams)!
+  const { way, commandWay } = eventBindData
+  const { deviceProfileId, attr, deviceId } = dataSourceJson
+
+  const deviceDetail = await getDeviceInfo(deviceId)
+
+  const doCommandParams: DoCommandDeliverParamsType = {
+    value: sendValue,
+    identifier: attr as string,
+    deviceDetail,
+    deviceProfileId,
+    way,
+  }
+
+  if (commandWay === CommandDeliveryWayEnum.CUSTOM) {
+    doCommandParams.penetration = true
+  }
+  else if (commandWay === CommandDeliveryWayEnum.SERVICE) {
+    const { service } = eventBindData
+    doCommandParams.objectModel = productsStore.getObjectModelByIdWithIdentifier(deviceProfileId, service!)!
+    doCommandParams.value = deviceDetail?.transportType === TransportTypeEnum.TCP ? doCommandParams.value : { [doCommandParams.objectModel.identifier]: doCommandParams.value }
+  }
+
+  await doCommandDelivery(doCommandParams)
+
+  const { createMessage } = useMessage()
+  createMessage.success('命令下发成功')
+
   if (unref(getHasEnableOperationPassword)) resetFields()
   visible.value = false
 }
@@ -73,22 +106,7 @@ defineExpose({ open })
 </script>
 
 <template>
-  <Modal
-    v-model:open="visible"
-    :title="`属性下发 / ${getDeviceInfo?.alias || getDeviceInfo?.name}`"
-    :width="300"
-    ok-text="确认"
-    cancel-text="取消"
-    destroy-on-close
-    @ok="handlerOk"
-  >
-    <!-- <template #title>
-      <div v-if="getHasEnableOperationPassword" />
-      <div v-else class="flex">
-        <span><Icon icon="ant-design:exclamation-circle-filled" class="text-yellow-300 text-xl" /></span>
-        <span class="font-bold ml-2">属性下发 / 提示</span>
-      </div>
-    </template> -->
+  <Modal v-model:open="visible" :width="300" ok-text="确认" cancel-text="取消" destroy-on-close @ok="handlerOk">
     <BasicForm v-if="getHasEnableOperationPassword" @register="register" />
     <div v-else class="flex items-center">
       <Icon icon="ant-design:exclamation-circle-filled" class="text-yellow-300 text-xl" />

 import { ComponentEnum } from '@/components/Form/src/enum'
 import type { FormSchema } from '@/components/Form'
-import type { Tsl } from '@/api/device/model'
 import type { OperationPasswordDataType } from '@/api/node/model'
 import { validateTCPCustomCommand } from '@/core/Library/components/ThingsModelForm'
 import { JSONEditorValidator } from '@/components/CodeEditor/src/JSONEditor'
-import { DataTypeEnum } from '@/enums/datasource'
 
 export enum FormFieldsEnum {
   CUSTOM_COMMAND = 'customCommand',
@@ -22,75 +20,6 @@ export const formSchemas: FormSchema[] = [
   },
 ]
 
-export const getModbusSchemas = (objectModelTsl: Tsl): FormSchema[] => {
-  const { functionName, identifier, specs } = objectModelTsl
-  const { type } = specs.dataType!
-  const HEX_MAX_VALUE = Number(0xffff)
-
-  const _formSchema: FormSchema = {
-    field: identifier,
-    label: functionName,
-    component: ComponentEnum.INPUT_NUMBER,
-  }
-
-  const getIntSchema = () => {
-    return Object.assign(_formSchema, {
-      required: true,
-      componentProps: {
-        min: 0,
-        max: HEX_MAX_VALUE,
-        precision: 2,
-        placeholder: '请输入正数',
-      },
-    } as Partial<FormSchema>)
-  }
-
-  const getBoolSchema = () => {
-    return Object.assign(_formSchema, {
-      required: true,
-      componentProps: {
-        min: 0,
-        max: 1,
-        precision: 0,
-        placeholder: '请输入0或1',
-      },
-    } as Partial<FormSchema>)
-  }
-
-  const getDoubleSchema = () => {
-    return Object.assign(_formSchema, {
-      required: true,
-      componentProps: {
-        placeholder: '请输入数字',
-        precision: 2,
-        max: HEX_MAX_VALUE,
-      },
-    } as Partial<FormSchema>)
-  }
-
-  const getStringSchema = () => {
-    return Object.assign(_formSchema, {
-      component: ComponentEnum.INPUT,
-      required: true,
-      rules: [{ validator: validateTCPCustomCommand }],
-      componentProps: {
-        placeholder: '请输入自定义命令',
-      },
-    } as Partial<FormSchema>)
-  }
-
-  const schemasMap: Partial<Record<DataTypeEnum, Fn<any, FormSchema>>> = {
-    [DataTypeEnum.NUMBER_INT]: getIntSchema,
-    [DataTypeEnum.BOOL]: getBoolSchema,
-    [DataTypeEnum.NUMBER_DOUBLE]: getDoubleSchema,
-    [DataTypeEnum.STRING]: getStringSchema,
-  }
-
-  const schemas = schemasMap[type as DataTypeEnum]?.()
-
-  return [schemas!]
-}
-
 export const getOperationPasswordSchemas = (operationPasswordInfo: OperationPasswordDataType): FormSchema[] => {
   return [
     {

 <script setup lang="ts">
 import { nextTick, reactive, ref, toRaw, unref } from 'vue'
 import { Button } from 'ant-design-vue'
-import { FormFieldsEnum, formSchemas, getJSONCommandSchemas, getModbusSchemas, getOperationPasswordSchemas, getTcpCustomCommandSchemas } from './config.ts'
-import { useCommandDeliver } from './useCommadDeliver'
+import { FormFieldsEnum, formSchemas, getJSONCommandSchemas, getOperationPasswordSchemas, getTcpCustomCommandSchemas } from './config.ts'
+import { createModbusValueInput } from './AttributeDeliverModal.config'
 import { BasicModal, useModalInner } from '@/components/Modal'
 import type { NodeDataDataSourceJsonType, OperationPasswordDataType, SingleClickEventDataType } from '@/api/node/model'
 import { BasicForm, useForm } from '@/components/Form'
 import { FormLayoutEnum } from '@/components/Form/src/enum'
-import { CommandDeliveryWayEnum, TransportTypeEnum } from '@/enums/datasource'
 import { ThingsModelForm } from '@/core/Library/components/ThingsModelForm'
 import type { DeviceItemType, Tsl } from '@/api/device/model'
-import { useProductsStoreWithOut } from '@/store/modules/products'
+import { useProductsStore, useProductsStoreWithOut } from '@/store/modules/products'
 import { useJsonParse } from '@/hooks/business/useJSONParse'
-import { CommandCallWayEnum, CommandWayEnum } from '@/enums/commandEnum'
+import { CommandDeliveryWayEnum } from '@/enums/commandEnum'
+import { TransportTypeEnum } from '@/enums/deviceEnum'
+import { getDeviceInfo } from '@/api/device'
+import type { DoCommandDeliverParamsType } from '@/hooks/business/useCommandDelivery'
+import { useCommandDelivery } from '@/hooks/business/useCommandDelivery'
+import { useMessage } from '@/hooks/web/useMessage'
 
 interface OpenParamsType {
   dataSource: NodeDataDataSourceJsonType
@@ -82,66 +86,60 @@ function handleOpenServiceCommandModal(deviceInfo: DeviceItemType, eventBindData
 
 function handleOpenModbusCommandModal(objectModelTsl: Tsl) {
   const { setProps } = customCommandFormAction
-  setProps({ schemas: getModbusSchemas(objectModelTsl) })
+  setProps({ schemas: [createModbusValueInput(objectModelTsl)] })
 }
 
-const { setup, getDeviceInfo, getObjectModelTsl, doCommandDeliver } = useCommandDeliver()
+const deviceInfo = ref<DeviceItemType>()
+const objectModelTsl = ref<Tsl>()
+const currentParams = ref<OpenParamsType>()
+const productsStore = useProductsStore()
 
-const open = async ({ eventBindData, operationPasswordInfo, dataSource }: OpenParamsType) => {
+const open = async (params: OpenParamsType) => {
+  const { eventBindData, operationPasswordInfo, dataSource } = params
   const { deviceId, deviceProfileId, attr } = dataSource
-  const { commandWay, callType, way, service } = eventBindData
+  const { commandWay } = eventBindData
   const { checked, value: operationPassword } = operationPasswordInfo || {}
   configuration.commandDeliveryWay = commandWay!
-
+  currentParams.value = params
+  deviceInfo.value = await getDeviceInfo(deviceId)
+  objectModelTsl.value = productsStore.getObjectModelByIdWithIdentifier(deviceProfileId, attr as string)!
   setModalProps({
     open: true,
     loading: true,
   })
 
-  await setup({
-    deviceId,
-    deviceProfileId,
-    attr,
-    commandDeliverWay: commandWay,
-    callType: configuration.commandDeliveryWay === CommandDeliveryWayEnum.SERVICE
-      ? callType === CommandCallWayEnum.SYNC
-        ? CommandWayEnum.TWO_WAY
-        : CommandWayEnum.ONE_WAY
-      : way,
-    serviceIdentifier: service,
-  })
-
   if (checked && operationPassword)
     handleHasOperationPassword(operationPasswordInfo!)
 
+  await nextTick()
+
   if (commandWay === CommandDeliveryWayEnum.CUSTOM)
-    handleOpenCustomCommandModal(toRaw(unref(getDeviceInfo)!), eventBindData)
+    handleOpenCustomCommandModal(toRaw(unref(deviceInfo)!), eventBindData)
   else if (commandWay === CommandDeliveryWayEnum.SERVICE)
-    handleOpenServiceCommandModal(toRaw(unref(getDeviceInfo)!), eventBindData)
+    handleOpenServiceCommandModal(toRaw(unref(deviceInfo)!), eventBindData)
   else if (commandWay === CommandDeliveryWayEnum.MODBUS)
-    handleOpenModbusCommandModal(toRaw(unref(getObjectModelTsl)!))
+    handleOpenModbusCommandModal(toRaw(unref(objectModelTsl)!))
 
   setModalProps({
     loading: false,
-    title: `参数设置 / ${unref(getDeviceInfo)?.alias || unref(getDeviceInfo)?.name}`,
+    title: `参数设置 / ${unref(deviceInfo)?.alias || unref(deviceInfo)?.name}`,
   })
 }
 
 function handleGetCustomCommand() {
   const res = customCommandFormAction.getFieldsValue()
   const command = res[FormFieldsEnum.CUSTOM_COMMAND]
-  return unref(getDeviceInfo)?.transportType === TransportTypeEnum.TCP ? command : useJsonParse(command).value
+  return unref(deviceInfo)?.transportType === TransportTypeEnum.TCP ? command : useJsonParse(command).value
 }
 
 function handleGetServiceCommand() {
   const res = unref(thingsModelElRef)!.getFieldsValue()
-
-  return unref(getDeviceInfo)?.transportType === TransportTypeEnum.TCP ? res[FormFieldsEnum.SERVICE_COMMAND] : res
+  return unref(deviceInfo)?.transportType === TransportTypeEnum.TCP ? res[FormFieldsEnum.SERVICE_COMMAND] : res
 }
 
 function handleGetModbusCommand() {
   const res = customCommandFormAction.getFieldsValue()
-  const identifier = unref(getObjectModelTsl)!.identifier
+  const identifier = unref(objectModelTsl)!.identifier
   return res[identifier]
 }
 
@@ -156,7 +154,31 @@ const handleSubmit = async () => {
         ? handleGetModbusCommand()
         : handleGetServiceCommand()
 
-  await doCommandDeliver(res)
+  const { doCommandDelivery } = useCommandDelivery()
+
+  const { eventBindData, dataSource } = unref(currentParams)!
+  const { deviceProfileId } = dataSource
+  const { commandWay, way } = eventBindData
+
+  const params: DoCommandDeliverParamsType = {
+    value: res,
+    deviceDetail: unref(deviceInfo),
+    objectModel: unref(objectModelTsl),
+    way,
+  }
+
+  if (commandWay === CommandDeliveryWayEnum.CUSTOM) {
+    params.penetration = true
+  }
+  else if (commandWay === CommandDeliveryWayEnum.SERVICE) {
+    const { service } = eventBindData
+    params.objectModel = productsStore.getObjectModelByIdWithIdentifier(deviceProfileId, service!)!
+    params.value = unref(deviceInfo)?.transportType === TransportTypeEnum.TCP ? params.value : { [params.objectModel.identifier]: params.value }
+  }
+
+  await doCommandDelivery(params)
+  const { createMessage } = useMessage()
+  createMessage.success('命令下发成功')
   closeModal()
 }
 

-import { computed, ref, unref } from 'vue'
-import { useGetModbusCommand } from './useGetModbusCommand'
-import { CodeTypeEnum, CommandDeliveryWayEnum, CommandTypeEnum, DataTypeEnum, TransportTypeEnum } from '@/enums/datasource'
-import type { DeviceItemType, RpcCommandType, Tsl } from '@/api/device/model'
-import { getDeviceActive, getDeviceInfo, sendRpcOneway } from '@/api/device'
-import { useProductsStoreWithOut } from '@/store/modules/products'
-import { CommandMethodEnum, CommandWayEnum } from '@/enums/commandEnum'
-import { useMessage } from '@/hooks/web/useMessage'
-
-interface UseCommandDeliverParamsType {
-  deviceProfileId: string
-  deviceId: string
-  attr: string
-  callType?: CommandWayEnum
-  commandDeliverWay?: CommandDeliveryWayEnum
-  serviceIdentifier?: string
-}
-
-/**
- * @description 命令下发流程
- * - TCP设备(下发命令为String):
- *  > - Modbus类型(INT,DOUBLE,BOOL,TEXT):
- *    >> 1. 验证设备是否绑定地址码与物模型是否绑定寄存器地址
- *    >> 2. 物模型类型为INT,DOUBLE,BOOL: 调用接口生成Modbus命令
- *        >>> 1. 数据类型为INT,DOUBLE时需要进行乘以缩放因子后验证值是否为整型与浮点型
- *        >>> 2. 数据类型为INT,DOUBLE缩放处理后进行HEX转码
- *        >>> 3. DOUBLE类型寄存器个数为2
- *        >>> 4. BOOL类型值为0与1
- *    >> 3. 物模型类型为TEXT: 输入值为自定义Modbus命令
- *    >> 4. 物模型类型为服务: 服务命令为下发值
- *  > - 自定义类型: 输入值为Modubs命令
- * - 非TCP设备(下发命令为(Object), {[identifier]: value}):
- *  > - 自定义命令下发: JSON格式命令下发
- *  > - 属性下发与服务下发:
- *    >> -
- *
- * @returns
- */
-export function useCommandDeliver(params?: UseCommandDeliverParamsType) {
-  const deviceInfo = ref<DeviceItemType>()
-  const objectModelTsl = ref<Nullable<Tsl>>(null)
-  const { createMessage } = useMessage()
-
-  const configuration: Partial<UseCommandDeliverParamsType> = {
-    deviceId: undefined,
-    deviceProfileId: undefined,
-    attr: undefined,
-  }
-
-  const getDeviceInfoById = async () => {
-    const res = await getDeviceInfo(configuration.deviceId!)
-    deviceInfo.value = res
-  }
-
-  const getObjectModelTslByIdWithIdentifier = () => {
-    const productStore = useProductsStoreWithOut()
-    const { deviceProfileId, attr } = configuration
-    objectModelTsl.value = productStore.getObjectModelByIdWithIdentifier(deviceProfileId!, attr!)
-  }
-
-  const setup = async (params?: UseCommandDeliverParamsType) => {
-    Object.assign(configuration, params || {})
-    const { deviceId, deviceProfileId, attr } = configuration
-    if (!deviceId || !deviceProfileId || !attr) return
-    getObjectModelTslByIdWithIdentifier()
-    await getDeviceInfoById()
-  }
-
-  if (params && params.deviceId && params.deviceProfileId && params.attr) setup()
-
-  const getCommand = async (command: any) => {
-    const { commandDeliverWay, serviceIdentifier } = configuration
-
-    const isTcpDevice = unref(deviceInfo)?.transportType === TransportTypeEnum.TCP
-
-    // 指定下发命令方式
-    if (commandDeliverWay) {
-      if (commandDeliverWay === CommandDeliveryWayEnum.CUSTOM) return command
-
-      if (commandDeliverWay === CommandDeliveryWayEnum.SERVICE && serviceIdentifier) {
-        return isTcpDevice
-          ? command
-          : {
-              [serviceIdentifier]: command,
-            }
-      }
-    }
-
-    const isTCPModbusDevice = isTcpDevice && unref(deviceInfo)?.codeType === CodeTypeEnum.MODBUS_RTU
-    const identifier = unref(objectModelTsl)!.identifier
-
-    if (!isTCPModbusDevice) {
-      return {
-        [identifier]: command,
-      }
-    }
-    else {
-      const isString = objectModelTsl.value?.specs.dataType.type === DataTypeEnum.STRING
-
-      if (isString) return command
-
-      const { extensionDesc } = unref(objectModelTsl)!
-      const { code } = unref(deviceInfo)!
-
-      const { getModbusCommand, validateCanGetCommand } = useGetModbusCommand()
-      if (!validateCanGetCommand(extensionDesc, code).flag) return
-
-      const res = await getModbusCommand(command as number, extensionDesc!, code)
-      return res
-    }
-  }
-
-  async function doCommandDeliver(command: any) {
-    const { callType = CommandWayEnum.ONE_WAY, commandDeliverWay } = configuration
-
-    if (callType === CommandWayEnum.TWO_WAY) {
-      const res = await getDeviceActive(unref(deviceInfo)!.tbDeviceId!)
-      const [firstItem] = res
-      const { value } = firstItem
-
-      if (!value) {
-        createMessage.warning('设备不在线')
-        return Promise.reject(Error('设备不在线'))
-      }
-    }
-
-    const res = await getCommand(command)
-
-    const rpcCommandParams: RpcCommandType = {
-      additionalInfo: {
-        cmdType:
-          unref(commandDeliverWay) === CommandDeliveryWayEnum.SERVICE
-            ? CommandTypeEnum.SERVICE
-            : CommandTypeEnum.API,
-      },
-      persistent: true,
-      method: CommandMethodEnum.THINGSKIT,
-      params: res,
-    }
-
-    await sendRpcOneway(rpcCommandParams, unref(deviceInfo)?.tbDeviceId, callType)
-    createMessage.success('命令下发成功')
-  }
-
-  return {
-    getDeviceInfo: computed(() => unref(deviceInfo)),
-    getObjectModelTsl: computed(() => unref(objectModelTsl)),
-    setup,
-    getCommand,
-    doCommandDeliver,
-  }
-}

+import { unref } from 'vue'
+import { DataTypeEnum, OriginalDataTypeEnum } from '@/enums/objectModelEnum'
+import type { FormSchema } from '@/components/Form'
+import type { DataType, DeviceItemType, Specs, StructJSON, Tsl } from '@/api/device/model'
+import { ComponentEnum } from '@/components/Form/src/enum'
+import { TCPProtocolTypeEnum } from '@/enums/deviceEnum'
+
+export interface BasicCreateFormParams {
+  identifier: string
+  functionName: string
+  dataType: DataType
+}
+
+const validateDouble = (value: number, min?: number | string, max?: number | string) => {
+  min = Number(min) ?? Number.MIN_SAFE_INTEGER
+  max = Number(max) ?? Number.MAX_SAFE_INTEGER
+
+  return {
+    flag: value < min || value > max,
+    message: `取值范围在${min}~${max}之间`,
+  }
+}
+
+export const useGenerateFormSchemasByObjectModel = () => {
+  const createInputNumber = ({
+    identifier,
+    functionName,
+    dataType,
+  }: BasicCreateFormParams): FormSchema => {
+    const { specs, type } = dataType
+    const { valueRange, step } = specs! as Partial<Specs>
+    const { max, min } = valueRange || {}
+    return {
+      field: identifier,
+      label: functionName,
+      component: 'InputNumber',
+      rules: [
+        {
+          type: 'number',
+          trigger: 'change',
+          validator: (_rule, value) => {
+            const { flag, message } = validateDouble(value, min, max)
+            if (flag)
+              return Promise.reject(Error(`${functionName}${message}`))
+
+            return Promise.resolve(value)
+          },
+        },
+      ],
+      componentProps: {
+        max: max ?? Number.MAX_SAFE_INTEGER,
+        min: min ?? Number.MIN_SAFE_INTEGER,
+        step,
+        placeholder: `请输入${functionName}`,
+        precision: type === DataTypeEnum.NUMBER_INT ? 0 : 2,
+      },
+    } as FormSchema
+  }
+
+  const createInput = ({
+    identifier,
+    functionName,
+    dataType,
+  }: BasicCreateFormParams): FormSchema => {
+    const { specs } = dataType
+    const { length = 10240 } = specs! as Partial<Specs>
+    return {
+      field: identifier,
+      label: functionName,
+      component: 'Input',
+      rules: [
+        {
+          type: 'string',
+          trigger: 'change',
+          validator: (_rule, value) => {
+            if (value?.length > length)
+              return Promise.reject(Error(`${functionName}数据长度应该小于${length}`))
+
+            return Promise.resolve(value)
+          },
+        },
+      ],
+      componentProps: {
+        maxLength: length,
+        placeholder: `请输入${functionName}`,
+      },
+    } as FormSchema
+  }
+
+  const createSelect = ({
+    identifier,
+    functionName,
+    dataType,
+  }: BasicCreateFormParams): FormSchema => {
+    const { specs } = dataType
+    const { boolClose, boolOpen } = specs! as Partial<Specs>
+    return {
+      field: identifier,
+      label: functionName,
+      component: ComponentEnum.SELECT,
+      componentProps: {
+        options: [
+          { label: `${boolClose}-0`, value: 0 },
+          { label: `${boolOpen}-1`, value: 1 },
+        ],
+        placeholder: `请选择${functionName}`,
+        getPopupContainer: () => document.body,
+      },
+    }
+  }
+
+  const createEnumSelect = ({
+    identifier,
+    functionName,
+    dataType,
+  }: BasicCreateFormParams): FormSchema => {
+    const { specsList } = dataType
+    return {
+      field: identifier,
+      label: functionName,
+      component: ComponentEnum.SELECT,
+      componentProps: {
+        options: specsList?.map(item => ({ label: item.name, value: item.value })),
+        placeholder: `请选择${functionName}`,
+        getPopupContainer: () => document.body,
+      },
+    }
+  }
+
+  const createModbusValueInput = (objectModel: Tsl): FormSchema => {
+    const { identifier, functionName, extensionDesc } = objectModel
+
+    const { dataType } = objectModel.specs || {}
+    const { specs } = dataType || {}
+    const { valueRange } = specs as Specs
+    const { max, min } = valueRange || {}
+
+    const isStringType = extensionDesc?.originalDataType === OriginalDataTypeEnum.STRING
+    return {
+      field: identifier,
+      label: functionName,
+      component: isStringType ? ComponentEnum.INPUT : ComponentEnum.INPUT_NUMBER,
+      rules: isStringType
+        ? []
+        : [
+            {
+              type: 'number',
+              validator: (_rule, value) => {
+                const { flag, message } = validateDouble(value, min, max)
+                if (flag)
+                  return Promise.reject(Error(`${functionName}${message}`))
+
+                return Promise.resolve(value)
+              },
+            },
+          ],
+      componentProps: {
+        max: max ?? Number.MAX_SAFE_INTEGER,
+        min: min ?? Number.MIN_SAFE_INTEGER,
+        placeholder: `请输入${functionName}`,
+        precision: 0,
+      },
+    }
+  }
+
+  const schemaMethod: Partial<Record<DataTypeEnum, (...args: any[]) => FormSchema>> = {
+    [DataTypeEnum.BOOL]: createSelect,
+    [DataTypeEnum.NUMBER_DOUBLE]: createInputNumber,
+    [DataTypeEnum.NUMBER_INT]: createInputNumber,
+    [DataTypeEnum.STRING]: createInput,
+    [DataTypeEnum.ENUM]: createEnumSelect,
+  }
+
+  const getFormByObjectModel = (
+    objectModel: Tsl,
+    deviceDetail: DeviceItemType,
+  ): FormSchema[] => {
+    const { functionName, identifier, specs } = objectModel
+
+    const isTCPModbusProduct
+      = unref(deviceDetail).deviceProfile?.profileData?.transportConfiguration?.protocol
+      === TCPProtocolTypeEnum.MODBUS_RTU
+
+    const { dataType } = specs
+    const { type } = dataType || {}
+
+    if (isTCPModbusProduct)
+      return [createModbusValueInput(objectModel)]
+
+    if (type === DataTypeEnum.STRUCT) {
+      return (dataType?.specs as StructJSON[]).map((item) => {
+        const { functionName, identifier, dataType } = item
+        const { type } = dataType || {}
+
+        return schemaMethod[type!]?.({ identifier, functionName, dataType })
+      }) as FormSchema[]
+    }
+
+    const result = schemaMethod[type!]?.({ identifier, functionName, dataType: dataType! })
+    return result ? [result] : []
+  }
+
+  return { getFormByObjectModel }
+}

-import { type GenModbusCommandType, genModbusCommand } from '@/api/device'
-import type { ExtensionDesc } from '@/api/device/model'
-import { ModbusCRCEnum } from '@/enums/commandEnum'
-import { TCPObjectModelActionTypeEnum } from '@/enums/objectModelEnum'
-import { useMessage } from '@/hooks/web/useMessage'
-
-export const InsertString = (t: any, c: any, n: any) => {
-  const r: string | number[] = []
-
-  for (let i = 0; i * 2 < t.length; i++)
-    r.push(t.substr(i * 2, n))
-
-  return r.join(c)
-}
-
-export const FillString = (t: any, c: any, n: any, b: any) => {
-  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
-}
-
-export const SingleToHex = (t: any) => {
-  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()
-}
-
-export const FormatHex = (t: any, n: any, ie: any) => {
-  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')
-}
-
-export const FormatHexBatch = (t: any, n: any, ie: any) => {
-  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')
-}
-
-export const SingleToHexBatch = (t: any) => {
-  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 getArray = (values: any) => {
-  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)
-  }
-  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 REGISTER_MAX_VALUE = Number(0xffff)
-
-export function useGetModbusCommand() {
-  const { createMessage } = useMessage()
-
-  const getModbusCommand = async (value: number, extensionDesc: ExtensionDesc, deviceAddressCode: string) => {
-    const { registerAddress, actionType, zoomFactor } = extensionDesc as Required<ExtensionDesc>
-
-    const params: GenModbusCommandType = {
-      crc: ModbusCRCEnum.CRC_16_LOWER,
-      registerNumber: 1,
-      deviceCode: deviceAddressCode,
-      registerAddress,
-      method: actionType,
-      registerValues: [value],
-    }
-
-    if (actionType === TCPObjectModelActionTypeEnum.INT) {
-      const newValue
-        = Math.trunc(value) * zoomFactor
-        + getFloatPart(value) * zoomFactor
-
-      if (newValue % 1 !== 0) {
-        createMessage.warning(`属性下发类型必须是整数,缩放因子为${zoomFactor}`)
-        return
-      }
-
-      if (value * zoomFactor > REGISTER_MAX_VALUE) {
-        createMessage.warning(`属性下发值不能超过${REGISTER_MAX_VALUE},缩放因子为${zoomFactor}`)
-        return
-      }
-
-      params.registerValues = [newValue]
-    }
-    else if (actionType === TCPObjectModelActionTypeEnum.DOUBLE) {
-      const regex = /^-?\d+(\.\d{0,2})?$/
-      const values
-        = Math.trunc(value) * zoomFactor
-        + getFloatPart(value) * zoomFactor
-
-      if (!regex.test(values.toString())) {
-        createMessage.warning(`属性下发值精确到两位小数,缩放因子为${zoomFactor}`)
-        return
-      }
-
-      const newValue
-        = values === 0 ? [0, 0] : getArray(SingleToHex(values))
-      params.registerValues = newValue
-      params.registerNumber = 2
-      params.method = '10'
-    }
-
-    return await genModbusCommand(params)
-  }
-
-  /**
-   *
-   * @param extensionDesc 物模型拓展描述符
-   * @param deviceAddressCode 设备地址码
-   */
-  const validateCanGetCommand = (extensionDesc?: ExtensionDesc, deviceAddressCode?: string, createValidateMessage = true) => {
-    const result = { flag: true, message: '' }
-    if (!extensionDesc) {
-      result.flag = false
-      result.message = '当前物模型扩展描述没有填写'
-    }
-
-    if (!deviceAddressCode) {
-      result.flag = false
-      result.message = '当前设备未绑定设备地址码'
-    }
-
-    if (result.message && createValidateMessage)
-      createMessage.warning(result.message)
-
-    return result
-  }
-
-  return {
-    getModbusCommand,
-    validateCanGetCommand,
-  }
-}

@@ -6,7 +6,7 @@ import { JSONEditor } from '@/components/CodeEditor/src/JSONEditor'
 import { BasicModal, useModalInner } from '@/components/Modal'
 import { useMessage } from '@/hooks/web/useMessage'
 import { useJsonParse } from '@/hooks/business/useJSONParse'
-import { TransportTypeEnum } from '@/enums/datasource'
+import { TransportTypeEnum } from '@/enums/deviceEnum'
 
 const emit = defineEmits(['register', 'editComplete'])
 

@@ -2,8 +2,9 @@ import type { FormSchema } from '@/components/Form'
 import { ComponentEnum } from '@/components/Form/src/enum'
 import type { BasicColumn } from '@/components/Table'
 import type { CommandWayEnum } from '@/enums/commandEnum'
-import type { CodeTypeEnum, ContentDataFieldsEnum, DeviceTypeEnum, TransportTypeEnum } from '@/enums/datasource'
+import type { ContentDataFieldsEnum } from '@/enums/datasource'
 import { EventActionTypeEnum, EventActionTypeNameEnum, EventTypeEnum, EventTypeNameEnum } from '@/enums/datasource'
+import type { DeviceTypeEnum, TCPProtocolTypeEnum } from '@/enums/deviceEnum'
 
 export enum TableColumnFieldEnum {
   DEVICE_ID = 'deviceId',
@@ -18,9 +19,8 @@ export interface TableRecordItemType {
   [TableColumnFieldEnum.WAY]?: Nullable<CommandWayEnum>
   [TableColumnFieldEnum.COMMAND]?: Nullable<string | Recordable>
   [ContentDataFieldsEnum.DEVICE_TYPE]?: Nullable<DeviceTypeEnum>
-  [ContentDataFieldsEnum.CODE_TYPE]?: Nullable<CodeTypeEnum>
+  [ContentDataFieldsEnum.CODE_TYPE]?: Nullable<TCPProtocolTypeEnum>
   [ContentDataFieldsEnum.DEVICE_PROFILE_ID]: Nullable<string>
-  [ContentDataFieldsEnum.TRANSPORT_TYPE]?: Nullable<TransportTypeEnum>
 }
 
 export const getFormSchemas = (event: EventTypeEnum): FormSchema[] => {

@@ -4,13 +4,13 @@ import { usePublicFormContext } from '../../../usePublicFormContext'
 import { getThingsModelServices } from '@/api/device'
 import { type FormSchema } from '@/components/Form'
 import { ComponentEnum } from '@/components/Form/src/enum'
-import { CommandWayEnum, CommandWayNameEnum } from '@/enums/commandEnum'
-import { CommandDeliveryWayEnum, CommandDeliveryWayNameEnum, DeviceTypeEnum, EventActionTypeEnum, EventActionTypeNameEnum, EventTypeEnum, EventTypeNameEnum, TransportTypeEnum } from '@/enums/datasource'
+import { CommandDeliveryWayEnum, CommandDeliveryWayNameEnum, CommandWayEnum, CommandWayNameEnum } from '@/enums/commandEnum'
+import { EventActionTypeEnum, EventActionTypeNameEnum, EventTypeEnum, EventTypeNameEnum } from '@/enums/datasource'
 import type { ThingsModel } from '@/api/device/model'
 import { PackageCategoryEnum } from '@/core/Library/enum'
-import { useContentDataStoreWithOut } from '@/store/modules/contentData'
 import { validateTCPCustomCommand } from '@/core/Library/components/ThingsModelForm'
 import { JSONEditorValidator } from '@/components/CodeEditor/src/JSONEditor'
+import { DeviceTypeEnum, TCPProtocolTypeEnum, TransportTypeEnum } from '@/enums/deviceEnum'
 
 export enum FormFieldsEnum {
   ACTION_TYPE = 'actionType',
@@ -35,16 +35,11 @@ export enum FormFieldsNameEnum {
   SERVICE = '服务',
 }
 
-const contentDataStore = useContentDataStoreWithOut()
-
 export const getFormSchemas = (event: EventTypeEnum): FormSchema[] => {
   const { getNodeData, getCellInfo, getDeviceInfo } = usePublicFormContext()
   const { dataSourceJson } = unref(getNodeData) || {}
   const { deviceProfileId } = dataSourceJson || {}
-  // transportType:判断是什么类型的设备 code:设备地址码  deviceType:设备类型
-  const { transportType, deviceType, codeType } = unref(getDeviceInfo) || {}
-
-  const isTemplate = contentDataStore.isTemplate // 判断是否是模板
+  const { transportType } = unref(getDeviceInfo) || {}
 
   return [
     {
@@ -115,39 +110,30 @@ export const getFormSchemas = (event: EventTypeEnum): FormSchema[] => {
       component: ComponentEnum.SELECT,
       required: true,
       ifShow: ({ model }) => model[FormFieldsEnum.ACTION_TYPE] === EventActionTypeEnum.PARAMS_SETTING,
+      defaultValue: CommandDeliveryWayEnum.CUSTOM,
       componentProps: ({ formActionType }) => {
         function getOptions() {
           const options = [
             { label: CommandDeliveryWayNameEnum.CUSTOM, value: CommandDeliveryWayEnum.CUSTOM },
           ]
 
-          const serviceOption = { label: CommandDeliveryWayNameEnum.SERVICE, value: CommandDeliveryWayEnum.SERVICE }
-          const modbusOption = { label: CommandDeliveryWayNameEnum.MODBUS, value: CommandDeliveryWayEnum.MODBUS }
-
-          function setOptions() {
-            // 是模板的话选择不到设备标识符类型所以就判断为放开自定义命令
-            if (isTemplate) {
-              if (transportType !== TransportTypeEnum.TCP)
-                options.push(serviceOption)
-              return
-            }
-
-            if (transportType !== TransportTypeEnum.TCP && deviceType === DeviceTypeEnum.SENSOR) {
-              // 判断不是TCP但是是网关子
-              options.push(serviceOption)
-              return
-            }
-
-            if (deviceType !== DeviceTypeEnum.SENSOR)
-              options.push(serviceOption)
+          const isTCPDevice = unref(getDeviceInfo)?.transportType === TransportTypeEnum.TCP
+          const isTCPModbusDevice = isTCPDevice && unref(getDeviceInfo)?.deviceProfile?.profileData?.transportConfiguration?.protocol === TCPProtocolTypeEnum.MODBUS_RTU
 
-            if (transportType !== TransportTypeEnum.TCP) return
+          // TCP 自定义设备 自定义
+          if (isTCPDevice && !isTCPModbusDevice && unref(getDeviceInfo)?.deviceType === DeviceTypeEnum.SENSOR)
+            return options
 
-            if (codeType !== CommandDeliveryWayEnum.CUSTOM)
-              options.push(modbusOption)
+          // TCP Modbus设备 自定义&Modbus
+          if (isTCPModbusDevice) {
+            const modbusOption = { label: CommandDeliveryWayNameEnum.MODBUS, value: CommandDeliveryWayEnum.MODBUS }
+            options.push(modbusOption)
+            return options
           }
 
-          setOptions()
+          // 其他 自定义&服务
+          options.push({ label: CommandDeliveryWayNameEnum.SERVICE, value: CommandDeliveryWayEnum.SERVICE })
+
           return options
         }
 

@@ -3,11 +3,12 @@ import { getDeviceAttributes, getListByConfigurationId, getListByDeviceProfileId
 import type { DeviceItemType, ThingsModelItemType } from '@/api/device/model'
 import type { FormSchema } from '@/components/Form'
 import { ComponentEnum } from '@/components/Form/src/enum'
-import { ContentDataFieldsEnum, ContentDataFieldsNameEnum, DataTypeEnum } from '@/enums/datasource'
+import { ContentDataFieldsEnum, ContentDataFieldsNameEnum } from '@/enums/datasource'
 import { useContentDataStoreWithOut } from '@/store/modules/contentData'
 import type { ProductAndDevice } from '@/api/content/model'
 import { ControlComponentEnum } from '@/core/Library/packages/Control'
 import { useParseParams } from '@/core/LoadData'
+import { DataTypeEnum } from '@/enums/objectModelEnum'
 
 const contentDataStore = useContentDataStoreWithOut()
 export const formSchemas = (componentKey?: string): FormSchema[] => {
@@ -88,12 +89,13 @@ export const formSchemas = (componentKey?: string): FormSchema[] => {
           showSearch: true,
           api: async (params: string) => {
             if (!deviceProfileId) return []
-            const options = await getDeviceAttributes(params)
+            let options = await getDeviceAttributes(params)
             if (componentKey === ControlComponentEnum.SWITCH) { // 开关只返回bool
-              return options.filter((item) => {
+              options = options.filter((item) => {
                 return item.detail.dataType.type === DataTypeEnum.BOOL
               })
             }
+
             return options
           },
           params: deviceProfileId,

@@ -2,7 +2,8 @@ import { validateTCPCustomCommand } from '.'
 import type { Specs, StructJSON } from '@/api/device/model'
 import { type FormSchema } from '@/components/Form'
 import { ComponentEnum } from '@/components/Form/src/enum'
-import { DataTypeEnum, TransportTypeEnum } from '@/enums/datasource'
+import { TransportTypeEnum } from '@/enums/deviceEnum'
+import { DataTypeEnum } from '@/enums/objectModelEnum'
 
 export enum FormFieldsEnum {
   SERVICE_COMMAND = 'serviceCommand',

@@ -5,9 +5,9 @@ import { getFormSchemas } from './config'
 import { ThingsModelForm } from '.'
 import type { StructJSON } from '@/api/device/model'
 import { BasicForm, useForm } from '@/components/Form'
-import { DataTypeEnum } from '@/enums/datasource'
 import { FormLabelAlignEnum, FormLayoutEnum } from '@/components/Form/src/enum'
 import { deepMerge } from '@/utils'
+import { DataTypeEnum } from '@/enums/objectModelEnum'
 
 interface ThingsModelFormPropsType {
   value?: Recordable

@@ -67,7 +67,7 @@ export function useNodeData({ cell, immediate = true }: UseNodeDataParamsType) {
   })
 
   const getDeviceDetail = async () => {
-    if (!unref(nodeData)?.dataSourceJson.deviceId) return
+    if (!unref(nodeData)?.dataSourceJson?.deviceId) return
     deviceInfo.value = await getDeviceInfo(unref(nodeData)!.dataSourceJson.deviceId)
   }
 

@@ -2,8 +2,8 @@ import { h, render, toRaw, unref } from 'vue'
 import { ControlComponentEnum } from '../packages/Control'
 import { doCommandDelivery, getDeviceActive } from '@/api/device'
 import type { MouseUpEventDataType, NodeDataDataSourceJsonType, NodeDataEventJsonType, SingleClickEventDataType } from '@/api/node/model'
-import { CommandMethodEnum, CommandWayEnum } from '@/enums/commandEnum'
-import { ActRangListItemTypeEnum, CommandTypeEnum, EventActionTypeEnum } from '@/enums/datasource'
+import { CommandMethodEnum, CommandTypeEnum, CommandWayEnum } from '@/enums/commandEnum'
+import { ActRangListItemTypeEnum, EventActionTypeEnum } from '@/enums/datasource'
 import { useMessage } from '@/hooks/web/useMessage'
 import { AttributeDeliverModal, CommandDeliveryModal, SwitchCommandDeliveryModal } from '@/core/Library/components/PublicForm/components/DataEvents/CommandDeliveryModal'
 import type { MxCell } from '@/fitCore/types'

@@ -8,8 +8,10 @@ import { ComponentEnum } from '@/components/Form/src/enum'
 import { useContentDataStoreWithOut } from '@/store/modules/contentData'
 import { DateFormatEnum } from '@/enums/timeEnum'
 import type { BasicColumn } from '@/components/Table'
-import { AlarmStatusEnum, type CodeTypeEnum, type ContentDataFieldsEnum } from '@/enums/datasource'
+import { type ContentDataFieldsEnum } from '@/enums/datasource'
 import { useParseParams } from '@/core/LoadData'
+import type { TCPProtocolTypeEnum } from '@/enums/deviceEnum'
+import { AlarmStatusEnum } from '@/enums/alarmEnum'
 
 export const tableColumns: BasicColumn[] = [
   {
@@ -27,7 +29,7 @@ export const tableColumns: BasicColumn[] = [
 export interface TableRecordItemType {
   uuid: string
   [TableColumnFieldEnum.DEVICE_ID]?: Nullable<string>
-  [ContentDataFieldsEnum.CODE_TYPE]?: Nullable<CodeTypeEnum>
+  [ContentDataFieldsEnum.CODE_TYPE]?: Nullable<TCPProtocolTypeEnum>
 }
 
 export const AlarmColorMap = {

@@ -8,8 +8,8 @@ import type { AlarmListItemType } from '@/api/alarm/model'
 import type { CreateComponentType } from '@/core/Library/types'
 import { useContentDataStore } from '@/store/modules/contentData'
 import { isLightboxMode, isShareMode } from '@/utils/env'
-import { AlarmStatusColorEnum, AlarmStatusEnum, AlarmStatusNameEnum } from '@/enums/datasource'
 import { formatToDateTime } from '@/utils/dateUtil'
+import { AlarmStatusColorEnum, AlarmStatusNameEnum } from '@/enums/alarmEnum'
 
 const props = defineProps<{
   config: CreateComponentType
@@ -67,7 +67,7 @@ onMounted(async () => {
       useIntervalFn(initFetchAlarmList, (initOptions.polling || 30) * 1000)
   }
   else {
-    const statusList = Object.values(AlarmStatusEnum)
+    const statusList = Object.values(AlarmStatusNameEnum)
     Object.assign(initOptions, {
       scroll: false,
       interval: 0,

@@ -75,6 +75,15 @@ const init = () => {
   videoPlayInstance.value = videoJs(unref(videoPlayEl)!, unref(getOptions), () => {
     emit('ready', unref(videoPlayInstance))
   })
+
+  unref(videoPlayInstance)?.on('timeupdate', () => {
+    if (!unref(videoPlayInstance)) return
+
+    const differTime = unref(videoPlayInstance)!.buffered().end(0) - unref(videoPlayInstance)!.currentTime()
+
+    if (differTime > 10)
+      init()
+  })
 }
 
 const customInit = (getOptionsFn: (optios: VideoJsPlayerOptions) => VideoJsPlayerOptions) => {

@@ -3,11 +3,12 @@ import { getDeviceAttributes, getListByConfigurationId, getListByDeviceProfileId
 import type { DeviceItemType, ThingsModelItemType } from '@/api/device/model'
 import type { FormSchema } from '@/components/Form'
 import { ComponentEnum } from '@/components/Form/src/enum'
-import { ContentDataFieldsEnum, ContentDataFieldsNameEnum, DataTypeEnum } from '@/enums/datasource'
+import { ContentDataFieldsEnum, ContentDataFieldsNameEnum } from '@/enums/datasource'
 import { useContentDataStoreWithOut } from '@/store/modules/contentData'
 import type { ProductAndDevice } from '@/api/content/model'
 import { ControlComponentEnum } from '@/core/Library/packages/Control'
 import { useParseParams } from '@/core/LoadData'
+import { DataTypeEnum } from '@/enums/objectModelEnum'
 
 const contentDataStore = useContentDataStoreWithOut()
 export const formSchemas = (componentKey?: string): FormSchema[] => {

@@ -84,11 +84,13 @@ export class DataDynamicEffectHandler {
     if (flag) {
       const nodeEl = this.nodeUtils.getNodesForCells([cell])
       const { type } = record!
+
       if (type === ActRangListItemTypeEnum.SHOW) {
         nodeEl.forEach((node) => {
           node.classList.add(ActAnimationName.VISIBLE)
           node.classList.remove(ActAnimationName.HIDDEN)
         })
+        this.nodeUtils.updateCellValue(cell, record?.title ? record.title : latestValue)
       }
       else if (type === ActRangListItemTypeEnum.HIDDEN) {
         nodeEl.forEach((node) => {

@@ -55,9 +55,9 @@ export class MessageHandler {
     const { data, node } = commandSource
     const { attr, deviceProfileId } = data as NodeDataDataSourceJsonType
 
-    let { latestValue } = useLatestMessageValue(message.data, attr)
+    let { latestValue } = useLatestMessageValue(message.data, attr as string)
     if (isNull(latestValue)) return
-    latestValue = useObjectModelValue(deviceProfileId, attr, latestValue)
+    latestValue = useObjectModelValue(deviceProfileId, attr as string, latestValue)
     const cell = this.nodeUtils.getCellById(node)
 
     const cellValue = cell.getValue() as Element

 import type { DataType, Specs, StructJSON } from '@/api/device/model'
-import { DataTypeEnum } from '@/enums/datasource'
+import { TransportTypeEnum } from '@/enums/deviceEnum'
+import { DataTypeEnum } from '@/enums/objectModelEnum'
 import { useJsonParse } from '@/hooks/business/useJSONParse'
 import { useProductsStoreWithOut } from '@/store/modules/products'
 
@@ -45,6 +46,13 @@ function getValueByType(type: string, value: any, dataType: DataType) {
   }
 }
 
+function getModbusDeviceValueByType(value: any, dataType: DataType) {
+  if (dataType.type === DataTypeEnum.BOOL && dataType.specsList && dataType.specsList.length)
+    return getEnumTypeValue(value, dataType.specsList as Specs[])
+
+  return value
+}
+
 export function useObjectModelValue(deviceProfileId: string, attr: string, value: any) {
   const productsStore = useProductsStoreWithOut()
 
@@ -52,5 +60,8 @@ export function useObjectModelValue(deviceProfileId: string, attr: string, value
   if (!result)
     return value
 
-  return getValueByType(result.specs.dataType.type as DataTypeEnum, value, result.specs.dataType)
+  const products = productsStore.getProductDetailById(deviceProfileId)
+  const isTCPModbus = products.transportType === TransportTypeEnum.TCP && result.extensionDesc?.originalDataType
+
+  return isTCPModbus ? getModbusDeviceValueByType(value, result.specs.dataType) : getValueByType(result.specs.dataType.type as DataTypeEnum, value, result.specs.dataType)
 }

+export enum AlarmStatusEnum {
+  CLEARED_UN_ACK = 'CLEARED_UNACK',
+  ACTIVE_UN_ACK = 'ACTIVE_UNACK',
+  CLEARED_ACK = 'CLEARED_ACK',
+  ACTIVE_ACK = 'ACTIVE_ACK',
+}
+
+export enum AlarmStatusColorEnum {
+  CLEARED_UNACK = 'red',
+  ACTIVE_UNACK = 'orange',
+  CLEARED_ACK = 'cyan',
+  ACTIVE_ACK = 'green',
+}
+
+export enum AlarmStatusNameEnum {
+  CLEARED_UNACK = '清除未确认',
+  ACTIVE_UNACK = '激活未确认',
+  CLEARED_ACK = '清除已确认',
+  ACTIVE_ACK = '激活已确认',
+}

@@ -13,6 +13,31 @@ export enum CommandCallWayEnum {
   ASYNC = 'ASYNC',
 }
 
+export enum CommandTypeEnum {
+  CUSTOM = 0,
+  SERVICE = 1,
+  ATTRIBUTE = 2,
+  API = 'api',
+}
+
+export enum CommandTypeNameEnum {
+  CUSTOM = '自定义',
+  SERVICE = '服务',
+  ATTRIBUTE = '属性',
+}
+
+export enum CommandDeliveryWayEnum {
+  CUSTOM = 'CUSTOM',
+  SERVICE = 'SERVICE',
+  MODBUS = 'MODBUS',
+}
+
+export enum CommandDeliveryWayNameEnum {
+  CUSTOM = '自定义命令',
+  SERVICE = '服务调用',
+  MODBUS = 'MODBUS',
+}
+
 export enum CommandMethodEnum {
   THINGSKIT = 'methodThingskit',
 }

@@ -64,50 +64,6 @@ export enum ActTypeNameEnum {
   VARIABLE_IMAGE = '变量图片',
 }
 
-export enum DeviceTypeEnum {
-  /**
-   * @description 网关设备
-   */
-  GATEWAY = 'GATEWAY',
-
-  /**
-   * @description 直连设备
-   */
-  DIRECT_CONNECTION = 'DIRECT_CONNECTION',
-
-  /**
-   * @description 网关子设备
-   */
-  SENSOR = 'SENSOR',
-}
-
-export enum DeviceTypeNameEnum {
-  /**
-   * @description 网关设备
-   */
-  GATEWAY = '网关设备',
-
-  /**
-   * @description 直连设备
-   */
-  DIRECT_CONNECTION = '直连设备',
-
-  /**
-   * @description 网关子设备
-   */
-  SENSOR = '网关子设备',
-}
-
-export enum TransportTypeEnum {
-  MQTT = 'MQTT',
-  TCP = 'TCP',
-}
-
-export enum CodeTypeEnum {
-  CUSTOM = 'CUSTOM',
-  MODBUS_RTU = 'MODBUS_RTU',
-}
-
 export enum EventTypeEnum {
   /**
    * @description 鼠标抬起
@@ -271,46 +227,6 @@ export enum VariableImageSourceNameEnum {
   GALLERY = '图库图形',
 }
 
-export enum CommandDeliveryWayEnum {
-  CUSTOM = 'CUSTOM',
-  SERVICE = 'SERVICE',
-  MODBUS = 'MODBUS',
-}
-
-export enum CommandDeliveryWayNameEnum {
-  CUSTOM = '自定义命令',
-  SERVICE = '服务调用',
-  MODBUS = 'MODBUS',
-}
-
-export enum FunctionTypeEnum {
-  PROPERTIES = 'properties',
-  EVENTS = 'events',
-  SERVICE = 'services',
-}
-
-export enum AssessMode {
-  READ = 'r',
-  WRITE = 'w',
-}
-
-export enum CommandTypeEnum {
-  SERVICE = 1,
-  API = 'API',
-}
-
-/**
- * 新增参数 动态显示表单
- */
-export enum DataTypeEnum {
-  NUMBER_INT = 'INT',
-  NUMBER_DOUBLE = 'DOUBLE',
-  STRING = 'TEXT',
-  STRUCT = 'STRUCT',
-  BOOL = 'BOOL',
-  ENUM = 'ENUM',
-}
-
 export enum AggregateTypeEnum {
   MIN = 'MIN',
   MAX = 'MAX',
@@ -333,24 +249,3 @@ export enum SocketSubscriberEnum {
   HISTORY_CMDS = 'historyCmds',
 }
 
-export enum AlarmStatusEnum {
-  CLEARED_UN_ACK = 'CLEARED_UNACK',
-  ACTIVE_UN_ACK = 'ACTIVE_UNACK',
-  CLEARED_ACK = 'CLEARED_ACK',
-  ACTIVE_ACK = 'ACTIVE_ACK',
-}
-
-export enum AlarmStatusColorEnum {
-  CLEARED_UNACK = 'red',
-  ACTIVE_UNACK = 'orange',
-  CLEARED_ACK = 'cyan',
-  ACTIVE_ACK = 'green',
-}
-
-export enum AlarmStatusNameEnum {
-  CLEARED_UNACK = '清除未确认',
-  ACTIVE_UNACK = '激活未确认',
-  CLEARED_ACK = '清除已确认',
-  ACTIVE_ACK = '激活已确认',
-}
-

+export enum DeviceTypeEnum {
+  /**
+   * @description 网关设备
+   */
+  GATEWAY = 'GATEWAY',
+
+  /**
+   * @description 直连设备
+   */
+  DIRECT_CONNECTION = 'DIRECT_CONNECTION',
+
+  /**
+   * @description 网关子设备
+   */
+  SENSOR = 'SENSOR',
+}
+
+export enum DeviceTypeNameEnum {
+  /**
+   * @description 网关设备
+   */
+  GATEWAY = '网关设备',
+
+  /**
+   * @description 直连设备
+   */
+  DIRECT_CONNECTION = '直连设备',
+
+  /**
+   * @description 网关子设备
+   */
+  SENSOR = '网关子设备',
+}
+
+export enum TransportTypeEnum {
+  DEFAULT = 'DEFAULT',
+  MQTT = 'MQTT',
+  COAP = 'COAP',
+  LWM2M = 'LWM2M',
+  SNMP = 'SNMP',
+  TCP = 'TCP',
+}
+
+export enum TCPProtocolTypeEnum {
+  CUSTOM = 'CUSTOM',
+  MODBUS_RTU = 'MODBUS_RTU',
+}
+
+export enum TCPProtocolTypeNameEnum {
+  CUSTOM = '自定义',
+  MODBUS_RTU = 'MODBUS_RTU',
+}

 /**
- * @description TCP物模型拓展描述符数据格式
+ * 新增参数 动态显示表单
  */
-export enum TCPObjectModelActionTypeEnum {
-  BOOL = '05',
-  INT = '06',
-  DOUBLE = '16',
+export enum DataTypeEnum {
+  NUMBER_INT = 'INT',
+  NUMBER_DOUBLE = 'DOUBLE',
+  STRING = 'TEXT',
+  STRUCT = 'STRUCT',
+  BOOL = 'BOOL',
+  ENUM = 'ENUM',
+}
+
+export enum FunctionTypeEnum {
+  PROPERTIES = 'properties',
+  EVENTS = 'events',
+  SERVICE = 'services',
+}
+
+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 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 { OriginalDataTypeEnum } from '@/enums/objectModelEnum'
+import { useParseOriginalDataType } from '@/hooks/business/useParseOriginalDataType'
+
+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 as keyof typeof BASE_ORDER] as number]))
+
+    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')
+
+    let result: number[]
+
+    if (type === OriginalDataTypeEnum.BOOLEAN) {
+      result = [value]
+    }
+    else if (type === OriginalDataTypeEnum.BITS) {
+      const { bitMask = 0 } = additional || {}
+      const binaryArray = Array.from({ length: 16 }, () => 0)
+      binaryArray[15 - bitMask] = value
+      result = [parseInt(binaryArray.join(''), 2)]
+    }
+    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 {
+      // eslint-disable-next-line no-console
+      console.table({ input: value, sort: exchangeSortFlag, type })
+
+      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 { isFunction } from '@wry-smile/utils-is'
+import { useMessage } from '../web/useMessage'
+import { useCoverModbusCommand } from './useCoverModbusCommand'
+import {
+  TCPProtocolTypeEnum,
+  TransportTypeEnum,
+} from '@/enums/deviceEnum'
+import { FunctionTypeEnum } from '@/enums/objectModelEnum'
+import { CommandCallWayEnum, CommandMethodEnum, CommandTypeEnum, CommandWayEnum } from '@/enums/commandEnum'
+import type { DeviceItemType, DeviceProfileItemType, RpcCommandType, Tsl } from '@/api/device/model'
+import { getDeviceActive, getDeviceInfo, doCommandDelivery as rpcCommandApi } from '@/api/device'
+import { useProductsStoreWithOut } from '@/store/modules/products'
+
+interface SetupType {
+  entityId: string
+  transportType: TransportTypeEnum
+  isTCPModbus: boolean
+  deviceCode: string | undefined
+  deviceDetail: DeviceItemType
+  objectModel: Tsl | undefined
+  identifier: string
+}
+
+export interface DoCommandDeliverParamsType {
+  value: any
+  deviceDetail?: DeviceItemType
+  deviceId?: string
+  identifier?: string
+  objectModel?: Tsl
+  deviceProfileId?: string
+  deviceProfileDetail?: DeviceProfileItemType
+  way?: CommandWayEnum
+  cmdType?: CommandTypeEnum
+  transportType?: TransportTypeEnum
+  penetration?: boolean
+
+  beforeFetch?: (
+    rpcCommand: RpcCommandType,
+    setup: SetupType
+  ) => RpcCommandType | Promise<RpcCommandType>
+}
+
+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 getDeviceInfo(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 productStore = useProductsStoreWithOut()
+      objectModel = productStore.getObjectModelByIdWithIdentifier(deviceProfileId!, 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
+
+      let rpcCommand: RpcCommandType = {
+        persistent: true,
+        method: CommandMethodEnum.THINGSKIT,
+        additionalInfo: {
+          cmdType: params.cmdType ?? CommandTypeEnum.API,
+        },
+        params: command,
+      }
+
+      let way = params.way ?? CommandWayEnum.ONE_WAY
+
+      if (!params.penetration) {
+        if (transportType === TransportTypeEnum.TCP) {
+          command = params.value
+          if (isTCPModbus) {
+            const { doCoverCommand } = useCoverModbusCommand()
+            command = await doCoverCommand(params.value, objectModel!, deviceCode, entityId)
+          }
+        }
+        else {
+          command = {
+            [identifier]: command,
+          }
+        }
+
+        if (objectModel?.functionType === FunctionTypeEnum.SERVICE) {
+          rpcCommand.additionalInfo.cmdType = CommandTypeEnum.SERVICE
+          way
+            = objectModel.callType === CommandCallWayEnum.ASYNC
+              ? CommandWayEnum.ONE_WAY
+              : CommandWayEnum.TWO_WAY
+        }
+
+        rpcCommand.params = command
+      }
+
+      const sendApi = rpcCommandApi
+
+      if (params.beforeFetch && isFunction(params.beforeFetch))
+        rpcCommand = await params.beforeFetch(rpcCommand, setupResult)
+
+      if (way === CommandWayEnum.TWO_WAY) {
+        const result = await getDeviceActive(entityId)
+        const [firsetItem] = result || []
+
+        if (!firsetItem.value) {
+          const { createMessage } = useMessage()
+          createMessage.warning('当前设备不在线')
+          return
+        }
+      }
+      await sendApi({ way, deviceId: entityId, command: rpcCommand })
+    }
+    finally {
+      loading.value = false
+    }
+  }
+
+  return {
+    loading,
+    doCommandDelivery,
+  }
+}

+import { isNullOrUnDef } from '@wry-smile/utils-is'
+import { useParseOriginalDataType } from './useParseOriginalDataType'
+
+import { isFloatType, isNumberType, useParseOperationType } from './useParseOperationType'
+import { useBaseConversion } from '@/hooks/business/useBaseConversion'
+import { useMessage } from '@/hooks/web/useMessage'
+import type { ExtensionDesc, Specs, Tsl } from '@/api/device/model'
+import { type GenModbusCommandType, genModbusCommand, getDeviceInfo, getDeviceTelemetryValue } from '@/api/device'
+import { ModbusCRCEnum } from '@/enums/commandEnum'
+import { OriginalDataTypeEnum } from '@/enums/objectModelEnum'
+
+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 getDeviceInfo(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 getDeviceTelemetryValue({ 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 (!isNullOrUnDef(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 type { ExtendDescOperationTypeEnum } from '@/enums/objectModelEnum'
+import {
+  DataTypeEnum,
+  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,
+  }
+}

+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,
+  }
+}

@@ -43,11 +43,11 @@ foreignObject[thingskit-component] > div > div > div {
 }
 
 .act-visible {
-  visibility: visible;
+  display: block;
 }
 
 .act-hidden {
-  visibility: hidden;
+  display: none;
 }
 
 .act-spin-animation {