Merge branch 'main_dev' into fengtao

@@ -6,6 +6,7 @@
   ],
   ],
   "cSpell.words": [
   "cSpell.words": [
     "ACKS",
     "ACKS",
+    "Cascader",
     "clazz",
     "clazz",
     "Cmds",
     "Cmds",
     "COAP",
     "COAP",

 import { DeviceProfileModel } from '../../device/model/deviceModel';
 import { DeviceProfileModel } from '../../device/model/deviceModel';
-import { HistoryData } from './model';
+import { DeviceAttributeItemType, HistoryData } from './model';
 import { defHttp } from '/@/utils/http/axios';
 import { defHttp } from '/@/utils/http/axios';
 import { isString } from '/@/utils/is';
 import { isString } from '/@/utils/is';
 import { OrderByEnum } from '/@/views/device/localtion/cpns/TimePeriodForm/config';
 import { OrderByEnum } from '/@/views/device/localtion/cpns/TimePeriodForm/config';
@@ -17,7 +17,7 @@ export const getDeviceHistoryInfo = (params: Recordable, orderBy = OrderByEnum.D
   return defHttp.get<HistoryData>(
   return defHttp.get<HistoryData>(
     {
     {
       url: `/plugins/telemetry/DEVICE/${params.entityId}/values/timeseries`,
       url: `/plugins/telemetry/DEVICE/${params.entityId}/values/timeseries`,
-      params: { orderBy, ...params, entityId: null },
+      params: { ...params, entityId: null, orderBy },
     },
     },
     {
     {
       joinPrefix: false,
       joinPrefix: false,
@@ -38,7 +38,7 @@ export const getDeviceDataKeys = (id: string) => {
 };
 };
 // 获取设备状态，在线 or 离线时间
 // 获取设备状态，在线 or 离线时间
 export const getDeviceActiveTime = (entityId: string) => {
 export const getDeviceActiveTime = (entityId: string) => {
-  return defHttp.get(
+  return defHttp.get<DeviceAttributeItemType[]>(
     {
     {
       url: `/plugins/telemetry/DEVICE/${entityId}/values/attributes?keys=active`,
       url: `/plugins/telemetry/DEVICE/${entityId}/values/attributes?keys=active`,
     },
     },

 export interface HistoryData {
 export interface HistoryData {
   [key: string]: { ts: number; value: string }[];
   [key: string]: { ts: number; value: string }[];
 }
 }
+
+export interface DeviceAttributeItemType {
+  key: string;
+  value: boolean;
+  lastUpdateTs: number;
+}

@@ -13,7 +13,7 @@ import { ChildDeviceParams } from './model/deviceModel';
 import { PaginationResult } from '/#/axios';
 import { PaginationResult } from '/#/axios';
 import { AlarmLogItem } from './model/deviceConfigModel';
 import { AlarmLogItem } from './model/deviceConfigModel';
 import { omit } from 'lodash-es';
 import { omit } from 'lodash-es';
-import { CommandDeliveryWayEnum } from '/@/enums/toolEnum';
+import { CommandDeliveryWayEnum } from '/@/enums/deviceEnum';
 enum DeviceManagerApi {
 enum DeviceManagerApi {
   /**
   /**
    * 设备URL
    * 设备URL
@@ -137,7 +137,7 @@ export const createOrEditDevice = (data) => {
 
 
 // 查询设备详情
 // 查询设备详情
 export const getDeviceDetail = (id: string) => {
 export const getDeviceDetail = (id: string) => {
-  return defHttp.get({
+  return defHttp.get<DeviceRecord>({
     url: DeviceManagerApi.DEVICE_URL + `/${id}`,
     url: DeviceManagerApi.DEVICE_URL + `/${id}`,
   });
   });
 };
 };

 import { BasicPageParams } from '/@/api/model/baseModel';
 import { BasicPageParams } from '/@/api/model/baseModel';
+import { CommandTypeEnum, RPCCommandMethodEnum } from '/@/enums/deviceEnum';
 
 
 export type TDeviceConfigPageQueryParam = BasicPageParams & TDeviceConfigParams;
 export type TDeviceConfigPageQueryParam = BasicPageParams & TDeviceConfigParams;
 
 
@@ -184,3 +185,10 @@ export interface Configuration {
 export interface TransportConfiguration {
 export interface TransportConfiguration {
   type: string;
   type: string;
 }
 }
+
+export interface RpcCommandType {
+  additionalInfo: { cmdType: CommandTypeEnum };
+  method: RPCCommandMethodEnum;
+  params: Recordable | string | number;
+  persistent: boolean;
+}

 import { DataTypeEnum } from '/@/enums/objectModelEnum';
 import { DataTypeEnum } from '/@/enums/objectModelEnum';
-import { FunctionType } from '/@/views/device/profiles/step/cpns/physical/cpns/config';
+import { FunctionTypeEnum } from '/@/enums/objectModelEnum';
 
 
 export interface Specs {
 export interface Specs {
-  min: string;
-  max: string;
+  min: number;
+  max: number;
   unit: string;
   unit: string;
   unitName: string;
   unitName: string;
 
 
   dataType?: string;
   dataType?: string;
   name?: string;
   name?: string;
-  value?: string;
-  step: string;
-  length: string;
+  value?: string | number;
+  step: number;
+  length: number;
   boolOpen: string;
   boolOpen: string;
   boolClose: string;
   boolClose: string;
   valueRange?: {
   valueRange?: {
-    min: string;
-    max: string;
+    min: number;
+    max: number;
   };
   };
 }
 }
 
 
@@ -26,17 +26,23 @@ export interface DataType {
   specsList?: Specs[];
   specsList?: Specs[];
 }
 }
 
 
+export interface ExtensionDesc {
+  zoomFactor?: number;
+  actionType?: string;
+  dataType: string;
+  registerAddress: number;
+}
+
 export interface StructJSON {
 export interface StructJSON {
-  functionName?: string;
+  functionName: string;
   identifier: string;
   identifier: string;
-  remark?: string;
   dataType?: DataType;
   dataType?: DataType;
+  remark?: string;
   serviceCommand?: string;
   serviceCommand?: string;
-  accessMode?: string;
 }
 }
 
 
 export interface FunctionJson {
 export interface FunctionJson {
-  dataType?: DataType | DataType[];
+  dataType?: DataType;
   inputData?: StructJSON[];
   inputData?: StructJSON[];
   outputData?: StructJSON[];
   outputData?: StructJSON[];
   serviceCommand?: string;
   serviceCommand?: string;
@@ -46,19 +52,19 @@ export interface ModelOfMatterParams {
   deviceProfileId?: string;
   deviceProfileId?: string;
   functionJson: FunctionJson;
   functionJson: FunctionJson;
   functionName: string;
   functionName: string;
-  functionType: FunctionType;
+  functionType: FunctionTypeEnum;
   identifier: string;
   identifier: string;
-  remark: string;
+  remark?: string;
   id?: string;
   id?: string;
   categoryId?: string;
   categoryId?: string;
   callType?: string;
   callType?: string;
   eventType?: string;
   eventType?: string;
   accessMode?: string;
   accessMode?: string;
-  extensionDesc?: Recordable;
+  extensionDesc?: ExtensionDesc;
 }
 }
 
 
 export interface GetModelTslParams {
 export interface GetModelTslParams {
-  functionType: FunctionType;
+  functionType: FunctionTypeEnum;
   deviceProfileId: string;
   deviceProfileId: string;
   ifShowClass?: string | Boolean;
   ifShowClass?: string | Boolean;
 }
 }
@@ -85,3 +91,26 @@ export interface ModelOfMatterItemRecordType {
   status: number;
   status: number;
   deviceProfileId: string;
   deviceProfileId: string;
 }
 }
+
+export interface BatchGetObjectModelItemType {
+  id: string;
+  name: string;
+  transportType: string;
+  deviceType: string;
+  tsl: Tsl[];
+}
+
+export interface Tsl {
+  functionName: string;
+  identifier: string;
+  functionType: string;
+  accessMode?: string;
+  specs?: {
+    dataType: DataType;
+  };
+  extensionDesc: ExtensionDesc;
+  eventType?: string;
+  outputData?: StructJSON[];
+  callType?: string;
+  inputData?: StructJSON[];
+}

 import { BasicPageParams } from '../model/baseModel';
 import { BasicPageParams } from '../model/baseModel';
 import {
 import {
+  BatchGetObjectModelItemType,
   GetModelTslParams,
   GetModelTslParams,
   ImportModelOfMatterType,
   ImportModelOfMatterType,
   ModelOfMatterItemRecordType,
   ModelOfMatterItemRecordType,
   ModelOfMatterParams,
   ModelOfMatterParams,
 } from './model/modelOfMatterModel';
 } from './model/modelOfMatterModel';
+import { FunctionTypeEnum } from '/@/enums/objectModelEnum';
 import { defHttp } from '/@/utils/http/axios';
 import { defHttp } from '/@/utils/http/axios';
-import { FunctionType } from '/@/views/device/profiles/step/cpns/physical/cpns/config';
 
 
 enum ModelOfMatter {
 enum ModelOfMatter {
   CREATE = '/things_model',
   CREATE = '/things_model',
@@ -26,12 +27,14 @@ enum ModelOfMatter {
 
 
   IMPORT_CSV = '/things_model/csvImport',
   IMPORT_CSV = '/things_model/csvImport',
   EXCEL_EXPORT = '/things_model/downloadTemplate',
   EXCEL_EXPORT = '/things_model/downloadTemplate',
+
+  BATCH_GET_TSL_BY_DEVICE_PROFILES = '/things_model/batch/get_tsl',
 }
 }
 
 
 export const getModelList = (
 export const getModelList = (
   params: BasicPageParams & {
   params: BasicPageParams & {
     deviceProfileId?: string;
     deviceProfileId?: string;
-    functionTyp?: FunctionType;
+    functionTyp?: FunctionTypeEnum;
     nameOrIdentifier?: string;
     nameOrIdentifier?: string;
     selectType?: string | undefined;
     selectType?: string | undefined;
     id?: string;
     id?: string;
@@ -181,3 +184,16 @@ export const excelExport = () => {
     responseType: 'blob',
     responseType: 'blob',
   });
   });
 };
 };
+
+export const batchGetObjectModel = ({
+  deviceProfileIds,
+  functionTypeEnum = 'all',
+}: {
+  deviceProfileIds: string[];
+  functionTypeEnum?: FunctionTypeEnum | 'all';
+}) => {
+  return defHttp.post<BatchGetObjectModelItemType[]>({
+    url: ModelOfMatter.BATCH_GET_TSL_BY_DEVICE_PROFILES,
+    data: { deviceProfileIds, functionTypeEnum },
+  });
+};

@@ -59,7 +59,7 @@ export interface GenModbusCommandType {
   crc: string;
   crc: string;
   deviceCode: string;
   deviceCode: string;
   method: string;
   method: string;
-  registerAddress: string;
+  registerAddress: number;
   registerNumber?: number;
   registerNumber?: number;
   registerValues?: number[];
   registerValues?: number[];
 }
 }

@@ -2,7 +2,7 @@ import { withInstall } from '/@/utils';
 // @ts-ignore
 // @ts-ignore
 import codeEditor from './src/CodeEditor.vue';
 import codeEditor from './src/CodeEditor.vue';
 import jsonPreview from './src/json-preview/JsonPreview.vue';
 import jsonPreview from './src/json-preview/JsonPreview.vue';
-export { JSONEditor } from './src/JSONEditor';
+export { JSONEditor, JSONEditorValidator, parseStringToJSON } from './src/JSONEditor';
 
 
 export const CodeEditor = withInstall(codeEditor);
 export const CodeEditor = withInstall(codeEditor);
 export const JsonPreview = withInstall(jsonPreview);
 export const JsonPreview = withInstall(jsonPreview);

@@ -11,18 +11,18 @@ export { default as RadioButtonGroup } from './src/components/RadioButtonGroup.v
 export { default as ApiTreeSelect } from './src/components/ApiTreeSelect.vue';
 export { default as ApiTreeSelect } from './src/components/ApiTreeSelect.vue';
 export { default as ApiRadioGroup } from './src/components/ApiRadioGroup.vue';
 export { default as ApiRadioGroup } from './src/components/ApiRadioGroup.vue';
 export { default as ApiUpload } from './src/components/ApiUpload.vue';
 export { default as ApiUpload } from './src/components/ApiUpload.vue';
+export { default as ApiCascader } from './src/components/ApiCascader.vue';
 
 
-export { default as StructForm } from './src/externalCompns/components/StructForm/StructForm.vue';
 export { default as JavaScriptFunctionEditor } from './src/components/JavaScriptFunctionEditor.vue';
 export { default as JavaScriptFunctionEditor } from './src/components/JavaScriptFunctionEditor.vue';
 
 
-export { ThingsModelForm } from './src/externalCompns/components/ThingsModelForm';
+export { ThingsModelForm } from './src/components/ThingsModelForm';
 
 
 //注册自定义组件
 //注册自定义组件
 export {
 export {
   JEasyCron,
   JEasyCron,
   JEasyCronInner,
   JEasyCronInner,
   JEasyCronModal,
   JEasyCronModal,
-} from '/@/components/Form/src/externalCompns/components/JEasyCron';
+} from '/@/components/Form/src/components/JEasyCron';
 // Jeecg自定义校验
 // Jeecg自定义校验
-export { JCronValidator } from '/@/components/Form/src/externalCompns/components/JEasyCron';
+export { JCronValidator } from '/@/components/Form/src/components/JEasyCron';
 // export { BasicForm };
 // export { BasicForm };

@@ -29,20 +29,18 @@ import { IconPicker } from '/@/components/Icon';
 import { CountdownInput } from '/@/components/CountDown';
 import { CountdownInput } from '/@/components/CountDown';
 import ApiRadioGroup from './components/ApiRadioGroup.vue';
 import ApiRadioGroup from './components/ApiRadioGroup.vue';
 //自定义组件
 //自定义组件
-import JAddInput from './externalCompns/components/JAddInput.vue';
-import { JEasyCron } from './externalCompns/components/JEasyCron';
+import JAddInput from './components/JAddInput.vue';
+import { JEasyCron } from './components/JEasyCron';
 import ColorPicker from './components/ColorPicker.vue';
 import ColorPicker from './components/ColorPicker.vue';
 import IconDrawer from './components/IconDrawer.vue';
 import IconDrawer from './components/IconDrawer.vue';
 import ApiUpload from './components/ApiUpload.vue';
 import ApiUpload from './components/ApiUpload.vue';
 import ApiSearchSelect from './components/ApiSearchSelect.vue';
 import ApiSearchSelect from './components/ApiSearchSelect.vue';
-import CustomMinMaxInput from './externalCompns/components/CustomMinMaxInput.vue';
-import StructForm from './externalCompns/components/StructForm/StructForm.vue';
+import CustomMinMaxInput from './components/CustomMinMaxInput.vue';
 import ApiSelectScrollLoad from './components/ApiSelectScrollLoad.vue';
 import ApiSelectScrollLoad from './components/ApiSelectScrollLoad.vue';
 import InputGroup from './components/InputGroup.vue';
 import InputGroup from './components/InputGroup.vue';
 import RegisterAddressInput from '/@/views/task/center/components/PollCommandInput/RegisterAddressInput.vue';
 import RegisterAddressInput from '/@/views/task/center/components/PollCommandInput/RegisterAddressInput.vue';
-import ExtendDesc from '/@/components/Form/src/externalCompns/components/ExtendDesc/index.vue';
-import DeviceProfileForm from '/@/components/Form/src/externalCompns/components/DeviceProfileForm/index.vue';
-import EnumList from './externalCompns/components/StructForm/EnumList.vue';
+import DeviceProfileForm from '/@/components/Form/src/components/DeviceProfileForm/index.vue';
+import { Segmented } from './components/Segmented';
 
 
 const componentMap = new Map<ComponentType, Component>();
 const componentMap = new Map<ComponentType, Component>();
 
 
@@ -76,6 +74,7 @@ componentMap.set('TimePicker', TimePicker);
 componentMap.set('StrengthMeter', StrengthMeter);
 componentMap.set('StrengthMeter', StrengthMeter);
 componentMap.set('IconPicker', IconPicker);
 componentMap.set('IconPicker', IconPicker);
 componentMap.set('InputCountDown', CountdownInput);
 componentMap.set('InputCountDown', CountdownInput);
+componentMap.set('Segmented', Segmented);
 
 
 componentMap.set('Upload', BasicUpload);
 componentMap.set('Upload', BasicUpload);
 //注册自定义组件
 //注册自定义组件
@@ -86,12 +85,9 @@ componentMap.set('IconDrawer', IconDrawer);
 componentMap.set('ApiUpload', ApiUpload);
 componentMap.set('ApiUpload', ApiUpload);
 componentMap.set('ApiSearchSelect', ApiSearchSelect);
 componentMap.set('ApiSearchSelect', ApiSearchSelect);
 componentMap.set('CustomMinMaxInput', CustomMinMaxInput);
 componentMap.set('CustomMinMaxInput', CustomMinMaxInput);
-componentMap.set('StructForm', StructForm);
 componentMap.set('ApiSelectScrollLoad', ApiSelectScrollLoad);
 componentMap.set('ApiSelectScrollLoad', ApiSelectScrollLoad);
 componentMap.set('InputGroup', InputGroup);
 componentMap.set('InputGroup', InputGroup);
 componentMap.set('RegisterAddressInput', RegisterAddressInput);
 componentMap.set('RegisterAddressInput', RegisterAddressInput);
-componentMap.set('ExtendDesc', ExtendDesc);
-componentMap.set('EnumList', EnumList);
 componentMap.set('DeviceProfileForm', DeviceProfileForm);
 componentMap.set('DeviceProfileForm', DeviceProfileForm);
 
 
 export function add(compName: ComponentType, component: Component) {
 export function add(compName: ComponentType, component: Component) {

+<script setup lang="ts">
+  import { Cascader } from 'ant-design-vue';
+  import { LoadingOutlined } from '@ant-design/icons-vue';
+  import { CascaderOptionType } from 'ant-design-vue/lib/cascader';
+  import { get } from 'lodash';
+  import { ref, unref, watch, watchEffect } from 'vue';
+  import { useRuleFormItem } from '/@/hooks/component/useFormItem';
+  import { useI18n } from '/@/hooks/web/useI18n';
+  import { isFunction } from '/@/utils/is';
+
+  const { t } = useI18n();
+
+  const props = withDefaults(
+    defineProps<{
+      value?: (string | number)[];
+      immediate?: boolean;
+      params?: any;
+      api?: Fn<any, Promise<any>>;
+      options?: CascaderOptionType[];
+      resultField?: string;
+      fieldNames?: Record<'label' | 'value' | 'children', string>;
+    }>(),
+    {
+      value: () => [],
+      immediate: true,
+      fieldNames: () => ({ label: 'label', value: 'value', children: 'children' }),
+    }
+  );
+
+  const emit = defineEmits(['change', 'options-change', 'update:value']);
+
+  const options = ref<CascaderOptionType[]>([]);
+  const loading = ref(false);
+  const isFirstLoad = ref(true);
+  const emitData = ref<any[]>([]);
+
+  // Embedded in the form, just use the hook binding to perform form verification
+  const [state] = useRuleFormItem(props, 'value', 'update:value', emitData);
+
+  watchEffect(() => {
+    props.immediate && fetch();
+  });
+
+  watch(
+    () => props.params,
+    () => {
+      !unref(isFirstLoad) && fetch();
+    },
+    { deep: true }
+  );
+
+  async function fetch() {
+    const api = props.api;
+    if (!api || !isFunction(api)) return;
+    options.value = [];
+    try {
+      loading.value = true;
+      const res = await api(props.params);
+      if (Array.isArray(res)) {
+        options.value = res;
+        emitChange();
+        return;
+      }
+      if (props.resultField) {
+        options.value = get(res, props.resultField) || [];
+      }
+      emitChange();
+    } catch (error) {
+      console.warn(error);
+    } finally {
+      loading.value = false;
+    }
+  }
+
+  async function handleFetch(open) {
+    if (open) {
+      await fetch();
+    }
+  }
+
+  function emitChange() {
+    emit('options-change', options);
+  }
+
+  function handleChange(_, ...args) {
+    emitData.value = args;
+  }
+</script>
+
+<template>
+  <Cascader
+    v-bind="$attrs"
+    @change="handleChange"
+    :fieldNames="fieldNames"
+    :options="options"
+    v-model:value="state"
+    @popupVisibleChange="handleFetch"
+  >
+    <template #notFoundContent v-if="loading">
+      <span>
+        <LoadingOutlined spin class="mr-1" />
+        {{ t('component.form.apiSelectNotFound') }}
+      </span>
+    </template>
+  </Cascader>
+</template>

@@ -4,17 +4,13 @@
       placeholder="最小值"
       placeholder="最小值"
       :disabled="$props.disabled"
       :disabled="$props.disabled"
       :value="getValue.min!"
       :value="getValue.min!"
-      style="width: 38%"
       @change="(value) => emitChange(value, 'min')"
       @change="(value) => emitChange(value, 'min')"
     />
     />
-    <span style="width: 8px"></span>
-    <span>~</span>
-    <span style="width: 8px"></span>
+    <div class="text-center flex-shrink-0 w-6">~</div>
     <InputNumber
     <InputNumber
       placeholder="最大值"
       placeholder="最大值"
       :disabled="$props.disabled"
       :disabled="$props.disabled"
       :value="getValue.max!"
       :value="getValue.max!"
-      style="width: 38%"
       @change="(value) => emitChange(value, 'max')"
       @change="(value) => emitChange(value, 'max')"
     />
     />
   </div>
   </div>

+<script setup lang="ts">
+  import {
+    computed,
+    CSSProperties,
+    nextTick,
+    onBeforeUnmount,
+    ref,
+    TransitionProps,
+    unref,
+    watch,
+  } from 'vue';
+  import { addClass } from './styleClass';
+  import { ThumbReact } from './type';
+  import { removeClass } from '/@/utils/domUtils';
+
+  const calcThumbStyle = (targetElement: HTMLElement | null | undefined): ThumbReact =>
+    targetElement
+      ? {
+          left: targetElement.offsetLeft,
+          right:
+            (targetElement.parentElement!.clientWidth as number) -
+            targetElement.clientWidth -
+            targetElement.offsetLeft,
+          width: targetElement.clientWidth,
+        }
+      : null;
+
+  const toPX = (value?: number) => (value !== undefined ? `${value}px` : undefined);
+
+  const props = defineProps<{
+    value?: string | number;
+    getValueIndex: (value: string | number) => number;
+    containerRef?: HTMLDivElement;
+    prefixCls: string;
+    direction?: 'rtl' | 'ltr';
+    motionName: string;
+  }>();
+
+  const emits = defineEmits(['motionStart', 'motionEnd']);
+
+  const thumbRef = ref<HTMLDivElement>();
+
+  const findValueElement = (val: string | number) => {
+    const { getValueIndex, prefixCls } = props;
+    const index = getValueIndex(val);
+    const ele = unref(props.containerRef)?.querySelectorAll<HTMLDivElement>(`.${prefixCls}-item`)?.[
+      index
+    ];
+
+    return ele?.offsetParent && ele;
+  };
+
+  const prevStyle = ref<ThumbReact>(null);
+  const nextStyle = ref<ThumbReact>(null);
+
+  watch(
+    () => props.value,
+    (value, prevValue) => {
+      const prev = findValueElement(prevValue as number);
+      const next = findValueElement(value as number);
+
+      const calcPrevStyle = calcThumbStyle(prev);
+      const calcNextStyle = calcThumbStyle(next);
+
+      prevStyle.value = calcPrevStyle;
+      nextStyle.value = calcNextStyle;
+
+      prev && next ? emits('motionStart') : emits('motionEnd');
+    },
+    { flush: 'post' }
+  );
+
+  const thumbStart = computed(() => {
+    const { direction } = props;
+
+    return direction === 'rtl'
+      ? toPX(-(prevStyle.value?.right as number))
+      : toPX(prevStyle.value?.left as number);
+  });
+
+  const thumbActive = computed(() => {
+    const { direction } = props;
+
+    return direction === 'rtl'
+      ? toPX(-(nextStyle.value?.right as number))
+      : toPX(nextStyle.value?.left as number);
+  });
+
+  let timeId: any;
+  const onAppearStart: TransitionProps['onBeforeEnter'] = (el: HTMLDivElement) => {
+    clearTimeout(timeId);
+    nextTick(() => {
+      if (el) {
+        el.style.transform = `translateX(var(--thumb-start-left))`;
+        el.style.width = `var(--thumb-start-width)`;
+      }
+    });
+  };
+
+  const onAppearActive: TransitionProps['onEnter'] = (el: HTMLDivElement) => {
+    timeId = setTimeout(() => {
+      if (el) {
+        addClass(el, `${props.motionName}-appear-active`);
+        el.style.transform = `translateX(var(--thumb-active-left))`;
+        el.style.width = `var(--thumb-active-width)`;
+      }
+    });
+  };
+
+  const onAppearEnd: TransitionProps['onAfterEnter'] = (el: HTMLDivElement) => {
+    prevStyle.value = null;
+    nextStyle.value = null;
+    if (el) {
+      el.style.transform = '';
+      el.style.width = '';
+      removeClass(el, `${props.motionName}-appear-active`);
+    }
+    emits('motionEnd');
+  };
+
+  const mergedStyle = computed(
+    () =>
+      ({
+        '--thumb-start-left': thumbStart.value,
+        '--thumb-start-width': toPX(prevStyle.value?.width),
+        '--thumb-active-left': thumbActive.value,
+        '--thumb-active-width': toPX(nextStyle.value?.width),
+      } as CSSProperties)
+  );
+
+  onBeforeUnmount(() => {
+    clearTimeout(timeId);
+  });
+
+  const motionProps = computed(() => {
+    return {
+      ref: thumbRef,
+      style: mergedStyle.value,
+      class: `${props.prefixCls}-thumb`,
+    };
+  });
+</script>
+
+<template>
+  <Transition
+    appear
+    @before-enter="onAppearStart"
+    @enter="onAppearActive"
+    @after-enter="onAppearEnd"
+  >
+    <div v-if="prevStyle && nextStyle" v-bind="motionProps"></div>
+  </Transition>
+</template>

+<script setup lang="ts">
+  import { computed, ref } from 'vue';
+  import MotionThumb from './MotionThumb.vue';
+  import { SegmentedBaseOption, SegmentedOption } from './type';
+
+  const props = withDefaults(
+    defineProps<{
+      block?: boolean;
+      disabled?: boolean;
+      options?: string[] | number[] | SegmentedOption[];
+      value?: string | number;
+      motionName?: string;
+    }>(),
+    {
+      options: () => [],
+      motionName: 'thumb-motion',
+    }
+  );
+
+  const slots = defineSlots<{ label?(props: SegmentedBaseOption): any }>();
+
+  const prefixCls = 'segmented';
+
+  const thumbShow = ref(false);
+
+  const rootRef = ref<HTMLDivElement>();
+
+  const getOptions = computed<SegmentedBaseOption[]>(() => {
+    const { options } = props;
+    return (options as SegmentedOption[]).map((item) => {
+      return {
+        value: item?.value || item,
+        disabled: item?.disabled || false,
+        payload: item?.payload || {},
+        title: item?.title || item,
+        className: item?.className || '',
+      } as SegmentedBaseOption;
+    });
+  });
+
+  const emits = defineEmits(['change', 'update:value']);
+
+  const handleChange = (value: string | number) => {
+    emits('update:value', value);
+    emits('change', value);
+  };
+</script>
+
+<template>
+  <div :class="prefixCls" ref="rootRef">
+    <div :class="`${prefixCls}-group`">
+      <MotionThumb
+        :containerRef="rootRef"
+        :prefix-cls="prefixCls"
+        :value="value"
+        :motion-name="`${prefixCls}-${motionName}`"
+        direction="ltr"
+        :get-value-index="(val) => getOptions.findIndex((item) => item.value === val)"
+        @motion-start="thumbShow = true"
+        @motion-end="thumbShow = false"
+      />
+      <label
+        v-for="item in getOptions"
+        :key="item.value"
+        :class="[
+          `${prefixCls}-item`,
+          value === item.value && !thumbShow && `${prefixCls}-item-selected`,
+          (disabled || item.disabled) && `${prefixCls}-item-disabled`,
+        ]"
+        @click="!disabled && !item.disabled && handleChange(item.value)"
+      >
+        <input type="radio" class="absolute pointer-events-none w-0 h-0 opacity-0" />
+        <slot v-if="slots.label" name="label" v-bind="item"></slot>
+        <template v-else>
+          <div :class="`${prefixCls}-item-label`"> {{ item.title }}</div>
+        </template>
+      </label>
+    </div>
+  </div>
+</template>
+
+<style lang="less">
+  .segmented {
+    box-sizing: border-box;
+    padding: 2px;
+    color: #000000a6;
+    font-size: 14px;
+    display: inline-block;
+    border-radius: 4px;
+    background-color: #f5f5f5;
+    transition: all 0.2s cubic-bezier(0.645, 0.045, 0.355, 1);
+
+    &-block {
+      display: flex;
+    }
+
+    &-block.segmented-item {
+      flex: 1;
+    }
+
+    &-group {
+      position: relative;
+      display: flex;
+      align-items: stretch;
+      justify-content: flex-start;
+      width: 100%;
+      border-radius: inherit;
+      transition: color 0.2s cubic-bezier(0.645, 0.045, 0.355, 1);
+    }
+
+    &-item {
+      position: relative;
+      cursor: pointer;
+      border-radius: inherit;
+      text-align: center;
+      transition: color 0.2s cubic-bezier(0.645, 0.045, 0.355, 1);
+
+      &-label {
+        min-height: 28px;
+        line-height: 28px;
+        padding: 0 11px;
+        overflow: hidden;
+        white-space: nowrap;
+        text-overflow: ellipsis;
+      }
+
+      &::after {
+        content: '';
+        position: absolute;
+        width: 100%;
+        height: 100%;
+        top: 0;
+        inset-inline-start: 0;
+        border-radius: inherit;
+        transition: background-color 0.2s;
+      }
+
+      &:hover:not(.segmented-item-selected):not(.segmented-item-disabled) {
+        color: #000000e0;
+
+        &::after {
+          background-color: rgba(0, 0, 0, 0.06);
+        }
+      }
+
+      &-disabled {
+        cursor: not-allowed;
+        color: rgba(0, 0, 0, 0.25);
+      }
+
+      &-selected {
+        background-color: #fff;
+
+        ::after {
+          box-shadow: 0 1px 2px 0 rgba(0, 0, 0, 0.03), 0 1px 6px -1px rgba(0, 0, 0, 0.02),
+            0 2px 4px 0 rgba(0, 0, 0, 0.02);
+        }
+      }
+
+      &-selected:not(.segmented-item-disabled) {
+        color: rgba(0, 0, 0, 0.88);
+      }
+    }
+
+    &-thumb {
+      position: absolute;
+      inset-block-start: 0;
+      inset-inline-start: 0;
+      width: 0;
+      height: 100%;
+      background-color: #fff;
+
+      &-motion-appear-active {
+        transition: transform 0.3s cubic-bezier(0.645, 0.045, 0.355, 1),
+          width 0.3s cubic-bezier(0.645, 0.045, 0.355, 1);
+        will-change: transform, width;
+      }
+
+      & ~ .segmented-item:not(.segmented-item-selected):not(.segmented-item-disabled)::after {
+        background-color: transparent;
+      }
+    }
+  }
+</style>

+export { default as Segmented } from './Segmented.vue';

+export function hasClass(node: HTMLElement, className: string) {
+  if (node.classList) {
+    return node.classList.contains(className);
+  }
+  const originClass = node.className;
+  return ` ${originClass} `.indexOf(` ${className} `) > -1;
+}
+
+export function addClass(node: HTMLElement, className: string) {
+  if (node.classList) {
+    node.classList.add(className);
+  } else {
+    if (!hasClass(node, className)) {
+      node.className = `${node.className} ${className}`;
+    }
+  }
+}

+export interface SegmentedBaseOption {
+  value: string | number;
+  disabled?: boolean;
+  payload?: any;
+  title?: string;
+  className?: string;
+}
+
+export interface SegmentedOption extends SegmentedBaseOption {
+  label?: VueNode | ((option: SegmentedBaseOption) => VueNode);
+}
+
+export type ThumbReact = {
+  left: number;
+  right: number;
+  width: number;
+} | null;

-import { FormSchema } from '../../../types/form';
+import { FormSchema } from '/@/components/Form';
 import { Specs, StructJSON } from '/@/api/device/model/modelOfMatterModel';
 import { Specs, StructJSON } from '/@/api/device/model/modelOfMatterModel';
+import { TransportTypeEnum } from '/@/enums/deviceEnum';
 import { DataTypeEnum } from '/@/enums/objectModelEnum';
 import { DataTypeEnum } from '/@/enums/objectModelEnum';
-import { TransportTypeEnum } from '/@/views/device/profiles/components/TransportDescript/const';
+import { validateTCPCustomCommand } from '.';
 
 
 export const getFormSchemas = ({
 export const getFormSchemas = ({
   structJSON: structJson,
   structJSON: structJson,
@@ -127,6 +128,7 @@ export const getFormSchemas = ({
       label: functionName!,
       label: functionName!,
       component: 'Input',
       component: 'Input',
       changeEvent: 'update:value',
       changeEvent: 'update:value',
+      rules: [{ required: required, validator: () => Promise.resolve() }],
       componentProps: () => {
       componentProps: () => {
         return {
         return {
           inputData: dataType?.specs || [],
           inputData: dataType?.specs || [],
@@ -143,6 +145,7 @@ export const getFormSchemas = ({
       component: 'Input',
       component: 'Input',
       required,
       required,
       defaultValue: serviceCommand,
       defaultValue: serviceCommand,
+      rules: [{ validator: validateTCPCustomCommand }],
       componentProps: {
       componentProps: {
         placeholder: `请输入服务命令`,
         placeholder: `请输入服务命令`,
       },
       },

 <script setup lang="ts">
 <script setup lang="ts">
+  import {
+    ComponentPublicInstance,
+    computed,
+    nextTick,
+    reactive,
+    ref,
+    toRaw,
+    unref,
+    watch,
+  } from 'vue';
   import { Card } from 'ant-design-vue';
   import { Card } from 'ant-design-vue';
-  import { ComponentPublicInstance, computed, nextTick, reactive, unref, watch } from 'vue';
   import { getFormSchemas } from './config';
   import { getFormSchemas } from './config';
   import { ThingsModelForm } from '.';
   import { ThingsModelForm } from '.';
-  import { DefineComponentsBasicExpose } from '/#/utils';
   import { StructJSON } from '/@/api/device/model/modelOfMatterModel';
   import { StructJSON } from '/@/api/device/model/modelOfMatterModel';
-  import { useForm } from '../../../hooks/useForm';
+  import { useForm } from '../../hooks/useForm';
   import { DataTypeEnum } from '/@/enums/objectModelEnum';
   import { DataTypeEnum } from '/@/enums/objectModelEnum';
-  import { BasicForm } from '/@/components/Form';
-
-  const props = withDefaults(
-    defineProps<{
-      value?: Recordable;
-      inputData?: StructJSON[];
-      required?: boolean;
-      title?: string;
-      transportType?: string;
-      disabled?: boolean;
-      identifier?: string;
-    }>(),
-    {
-      inputData: () => [],
-      required: true,
-    }
-  );
+  import { BasicForm, FormProps } from '/@/components/Form';
+  import { deepMerge } from '/@/utils';
+
+  interface ThingsModelFormPropsType {
+    value?: Recordable;
+    inputData?: StructJSON[];
+    required?: boolean;
+    title?: string;
+    transportType?: string;
+    disabled?: boolean;
+    identifier?: string;
+    formProps?: FormProps;
+  }
+
+  const props = withDefaults(defineProps<ThingsModelFormPropsType>(), {
+    inputData: () => [],
+    required: true,
+    formProps: () => ({}),
+  });
 
 
   const thingsModelFormListElMap = reactive<
   const thingsModelFormListElMap = reactive<
     Record<string, { el: InstanceType<typeof ThingsModelForm>; structJSON: StructJSON }>
     Record<string, { el: InstanceType<typeof ThingsModelForm>; structJSON: StructJSON }>
   >({});
   >({});
 
 
+  const propsRef = ref<Partial<ThingsModelFormPropsType>>({});
+
+  const getProps = computed<ThingsModelFormPropsType>(
+    () => ({ ...props, ...unref(propsRef) } as ThingsModelFormPropsType)
+  );
+
   const [register, formActionType] = useForm({
   const [register, formActionType] = useForm({
-    schemas: getFormSchemas({
-      structJSON: props.inputData || [],
-      required: props.required,
-      transportType: props.transportType,
-    }),
-    showActionButtonGroup: false,
     layout: 'inline',
     layout: 'inline',
     labelWidth: 100,
     labelWidth: 100,
+    ...toRaw(unref(getProps)),
+    schemas: getFormSchemasByProps(),
+    showActionButtonGroup: false,
   });
   });
 
 
   const getStructFormItem = computed(() => {
   const getStructFormItem = computed(() => {
-    const { inputData } = props;
-    return inputData.filter((item) => item.dataType?.type === DataTypeEnum.STRUCT);
+    const { inputData } = unref(getProps);
+    return (inputData || []).filter((item) => item.dataType?.type === DataTypeEnum.STRUCT);
   });
   });
 
 
   const setFormElRef = (
   const setFormElRef = (
@@ -87,7 +100,7 @@
   };
   };
 
 
   watch(
   watch(
-    () => props.value,
+    () => unref(getProps).value,
     async (value) => {
     async (value) => {
       await nextTick();
       await nextTick();
       formActionType.resetFields();
       formActionType.resetFields();
@@ -97,30 +110,36 @@
   );
   );
 
 
   watch(
   watch(
-    () => [props.inputData, props.identifier],
+    () => [unref(getProps).inputData, unref(getProps).identifier],
     (value) => {
     (value) => {
-      if (value && value.length) {
-        const schemas = getFormSchemas({
-          structJSON: props.inputData || [],
-          required: props.required,
-          transportType: props.transportType,
-        });
-        formActionType.setProps({ schemas });
-      }
+      if (value && value.length) formActionType.setProps({ schemas: getFormSchemasByProps() });
     }
     }
   );
   );
 
 
   watch(
   watch(
-    () => props.disabled,
+    () => unref(getProps).disabled,
     (value) => {
     (value) => {
       formActionType.setProps({ disabled: value });
       formActionType.setProps({ disabled: value });
     }
     }
   );
   );
 
 
-  defineExpose<DefineComponentsBasicExpose>({
+  function getFormSchemasByProps() {
+    return getFormSchemas({
+      structJSON: unref(getProps).inputData || [],
+      required: unref(getProps).required,
+      transportType: unref(getProps).transportType,
+    });
+  }
+
+  function setProps(props: Partial<ThingsModelFormPropsType>) {
+    propsRef.value = deepMerge(unref(propsRef) || {}, props);
+  }
+
+  defineExpose({
     getFieldsValue,
     getFieldsValue,
     setFieldsValue,
     setFieldsValue,
     validate,
     validate,
+    setProps,
   });
   });
 </script>
 </script>
 
 
@@ -155,6 +174,10 @@
       width: 100%;
       width: 100%;
     }
     }
 
 
+    :deep(.ant-col.ant-form-item-control) {
+      min-height: auto;
+    }
+
     :deep(.ant-input-number) {
     :deep(.ant-input-number) {
       width: 100%;
       width: 100%;
     }
     }

-<script lang="ts" setup>
-  import { Card } from 'ant-design-vue';
-  import { computed, nextTick, onMounted, onUpdated, unref, watch } from 'vue';
-  import { BasicCreateFormParams } from './type';
-  import { DynamicProps } from '/#/utils';
-  import { Specs, StructJSON } from '/@/api/device/model/modelOfMatterModel';
-  import { BasicForm, FormProps, FormSchema, useForm } from '/@/components/Form';
-  import { DataTypeEnum } from '/@/enums/objectModelEnum';
-  import { ReadAndWriteEnum } from '/@/enums/toolEnum';
-
-  const props = withDefaults(
-    defineProps<{
-      inputData?: StructJSON[];
-      formProps?: FormProps;
-      value?: Recordable;
-      required?: boolean;
-    }>(),
-    {
-      inputData: () => [] as StructJSON[],
-      formProps: () => ({}),
-      value: () => ({}),
-    }
-  );
-
-  const emit = defineEmits(['update:value']);
-
-  const getCurrentKeys = computed(() => {
-    const { inputData } = props;
-    return (inputData || []).map((item) => item.identifier);
-  });
-
-  const [register, { setProps, getFieldsValue, setFieldsValue }] = useForm({
-    schemas: [],
-    showActionButtonGroup: false,
-    layout: 'inline',
-    labelWidth: 80,
-    wrapperCol: { span: 12 },
-    ...(props.formProps || ({} as unknown as Partial<DynamicProps<FormProps>>)),
-  });
-
-  const syncValue = (key: string, value: any) => {
-    let record = getFieldsValue();
-    record = { ...record, [key]: value };
-    const setValues = {};
-    Object.keys(record).forEach((key) => {
-      const hasKey = unref(getCurrentKeys).includes(key);
-      if (hasKey) {
-        setValues[key] = record[key];
-      }
-    });
-    emit('update:value', setValues);
-  };
-
-  const createInputNumber = ({
-    identifier,
-    functionName,
-    specs,
-  }: BasicCreateFormParams): FormSchema => {
-    const { valueRange } = specs! as Partial<Specs>;
-    const { max = 2147483647, min = -2147483648 } = valueRange || {};
-    return {
-      field: identifier,
-      label: functionName,
-      component: 'InputNumber',
-      rules: [
-        {
-          required: props.required,
-          message: `${functionName}是必填项`,
-        },
-        {
-          type: 'number',
-          trigger: 'change',
-          validator: (_rule, value) => {
-            const reg = /^[0-9]*$/;
-            if (!reg.test(value)) return Promise.reject(`${functionName}不是一个有效的数字`);
-            if (value < min || value > max) {
-              return Promise.reject(`${functionName}取值范围在${min}~${max}之间`);
-            }
-            return Promise.resolve(value);
-          },
-        },
-      ],
-      componentProps: {
-        max,
-        min,
-        // step: step,
-        // formatter: (value: string) => value,
-        // parser: (string: string) => {
-        // if (dataType === DataTypeEnum.NUMBER_INT) {
-        //     return Number(Number(string).toFixed());
-        //   }
-        //   return Number(string);
-        // },
-        onChange: (value: string) => {
-          syncValue(identifier, value);
-        },
-      },
-    } as FormSchema;
-  };
-
-  const createInput = ({ identifier, functionName, specs }: BasicCreateFormParams): FormSchema => {
-    const { length = 10240 } = specs! as Partial<Specs>;
-    return {
-      field: identifier,
-      label: functionName,
-      component: 'Input',
-      rules: [
-        {
-          required: props.required,
-          message: `${functionName}是必填项`,
-        },
-        {
-          type: 'string',
-          trigger: 'change',
-          validator: (_rule, value) => {
-            if (value.length > length) {
-              return Promise.reject(`${functionName}数据长度应该小于${length}`);
-            }
-            return Promise.resolve(value);
-          },
-        },
-      ],
-      componentProps: {
-        maxLength: length,
-        onChange: (value: InputEvent) => {
-          syncValue(identifier, (value.target as HTMLInputElement).value);
-        },
-      },
-    } as FormSchema;
-  };
-
-  const createSelect = ({ identifier, functionName, specs }: BasicCreateFormParams): FormSchema => {
-    const { boolClose, boolOpen } = specs! as Partial<Specs>;
-    return {
-      field: identifier,
-      label: functionName,
-      component: 'Select',
-      rules: [
-        {
-          required: props.required,
-          message: `${functionName}是必填项`,
-          type: 'number',
-        },
-      ],
-      componentProps: {
-        options: [
-          { label: `${boolClose}-0`, value: 0 },
-          { label: `${boolOpen}-1`, value: 1 },
-        ],
-        onChange: (value: string) => {
-          syncValue(identifier, value);
-        },
-      },
-    };
-  };
-
-  const createInputJson = ({ identifier, functionName }: BasicCreateFormParams): FormSchema => {
-    return {
-      field: identifier,
-      label: functionName,
-      component: 'InputTextArea',
-      rules: [
-        {
-          required: props.required,
-          message: `${functionName}是必填项`,
-        },
-      ],
-      componentProps: {
-        onChange: (value: InputEvent) => {
-          syncValue(identifier, (value.target as HTMLInputElement).value);
-        },
-      },
-    };
-  };
-
-  const transformToFormSchema = (inputData: StructJSON[]) => {
-    const schemas: FormSchema[] = [];
-    for (const item of inputData) {
-      const { dataType, identifier, functionName, accessMode } = item;
-      if (accessMode === ReadAndWriteEnum.READ) {
-        continue;
-      }
-      const { type, specs } = dataType! || {};
-
-      const params: BasicCreateFormParams = {
-        identifier: identifier!,
-        functionName: functionName!,
-        dataType: dataType! as unknown as DataTypeEnum,
-        specs: specs as Partial<Specs>,
-      };
-      if (type === DataTypeEnum.NUMBER_INT || type === DataTypeEnum.NUMBER_DOUBLE) {
-        schemas.push(createInputNumber(params));
-      }
-
-      if (type === DataTypeEnum.BOOL) {
-        schemas.push(createSelect(params));
-      }
-
-      if (type === DataTypeEnum.STRING) {
-        schemas.push(createInput(params));
-      }
-
-      if (type === DataTypeEnum.STRUCT) {
-        schemas.push(createInputJson(params));
-      }
-    }
-
-    return schemas;
-  };
-
-  const generateSchemas = (value: StructJSON[]) => {
-    if (value && value.length) {
-      const schemas = transformToFormSchema(value);
-      setProps({ schemas });
-    }
-  };
-
-  onMounted(() => {
-    generateSchemas(props.inputData);
-  });
-
-  onUpdated(async () => {
-    if (props.inputData && props.inputData.length) {
-      await nextTick();
-      setFieldsValue(props.value || {});
-    }
-  });
-
-  watch(
-    () => props.inputData,
-    (value) => {
-      generateSchemas(value);
-    }
-  );
-
-  watch(
-    () => props.formProps,
-    (value) => {
-      setProps(value);
-    }
-  );
-</script>
-
-<template>
-  <Card bordered class="!border-dashed !rounded-lg !border-2px">
-    <!-- <Alert class="!mb-4 w-32" message="服务参数配置" type="info" /> -->
-    <BasicForm class="object-model-validate-form" @register="register" />
-  </Card>
-</template>
-
-<style lang="less">
-  .object-model-validate-form {
-    .ant-input-number {
-      width: 100% !important;
-    }
-  }
-</style>

-import { Specs } from '/@/api/device/model/modelOfMatterModel';
-import { DataTypeEnum } from '/@/enums/objectModelEnum';
-
-export interface BasicCreateFormParams {
-  identifier: string;
-  functionName: string;
-  dataType: DataTypeEnum;
-  specs: Partial<Specs>;
-}

-<script lang="ts">
-  export default {
-    inheritAttrs: false,
-  };
-</script>
-<script lang="ts" setup>
-  import StructFormModel from './StructFormModel.vue';
-  import { useModal } from '/@/components/Modal';
-  import { PlusOutlined } from '@ant-design/icons-vue';
-  import { ModelOfMatterParams } from '/@/api/device/model/modelOfMatterModel';
-  import { computed, unref } from 'vue';
-  import { buildUUID } from '/@/utils/uuid';
-  import { Divider, Button } from 'ant-design-vue';
-  import { OpenModalMode, OpenModalParams, StructRecord } from './type';
-  import { cloneDeep } from 'lodash-es';
-  import { isArray } from '/@/utils/is';
-  import { FormField } from '/@/views/device/profiles/step/cpns/physical/cpns/config';
-  import { DataTypeEnum } from '/@/enums/objectModelEnum';
-
-  const emit = defineEmits(['update:value']);
-
-  const props = withDefaults(
-    defineProps<{
-      value: ModelOfMatterParams[];
-      disabled: boolean;
-      hasStructForm?: boolean;
-      hiddenAccessMode?: boolean;
-    }>(),
-    {
-      value: () => [],
-      hiddenAccessMode: false,
-      hasStructForm: false,
-    }
-  );
-
-  const getValue = computed<StructRecord[]>(() => {
-    const { value } = props;
-
-    return (isArray(value) ? value : []).map((item) => {
-      return {
-        ...(item as StructRecord),
-        ...((item as StructRecord).id ? {} : { id: buildUUID() }),
-      };
-    });
-  });
-
-  const [registerModal, { openModal }] = useModal();
-
-  const handleCreateParams = () => {
-    openModal(true, {
-      mode: OpenModalMode.CREATE,
-    } as OpenModalParams);
-  };
-
-  const handleUpdate = (value: StructRecord) => {
-    openModal(true, {
-      mode: OpenModalMode.UPDATE,
-      record: {
-        ...value,
-        [FormField.HAS_STRUCT_FROM]: value?.dataType?.type === DataTypeEnum.STRUCT,
-      },
-    } as OpenModalParams);
-  };
-
-  const handleDelete = (value: StructRecord) => {
-    const index = unref(getValue).findIndex((item) => item.id === value.id);
-    const _value = cloneDeep(unref(getValue));
-    _value.splice(index, 1);
-    emit('update:value', _value);
-  };
-
-  const handleSaveStruct = (mode: OpenModalMode, value: StructRecord) => {
-    const _value = cloneDeep(unref(getValue));
-
-    if (mode === OpenModalMode.UPDATE) {
-      const index = unref(getValue).findIndex((item) => item.id === value.id);
-      ~index && _value.splice(index, 1, value);
-    } else {
-      _value.push(value);
-    }
-
-    emit('update:value', _value);
-  };
-</script>
-
-<template>
-  <section>
-    <div class="text-blue-500 cursor-pointer">
-      <section>
-        <div
-          class="flex bg-blue-50 mb-2 p-2 text-gray-500 justify-between items-center"
-          v-for="item in getValue"
-          :key="item.id"
-        >
-          <div>参数名称: {{ item.functionName }}</div>
-          <div class="flex">
-            <Button class="!p-0" type="link" @click="handleUpdate(item)">
-              <span>{{ disabled ? '查看' : '编辑' }}</span>
-            </Button>
-            <Divider type="vertical" />
-            <Button :disabled="disabled" class="!p-0" type="link" @click="handleDelete(item)">
-              <span>删除</span>
-            </Button>
-          </div>
-        </div>
-      </section>
-      <div :class="$props.disabled && 'text-gray-400'">
-        <span class="mr-2">
-          <PlusOutlined />
-        </span>
-        <span @click="!disabled && handleCreateParams()">增加参数</span>
-      </div>
-    </div>
-    <StructFormModel
-      :has-struct-form="hasStructForm!"
-      :hidden-access-mode="hiddenAccessMode"
-      :disabled="disabled"
-      :value-list="getValue"
-      @register="registerModal"
-      @submit="handleSaveStruct"
-    />
-  </section>
-</template>
-
-<style lang="less" scoped></style>

-<script lang="ts">
-  export default {
-    inheritAttrs: false,
-  };
-</script>
-<script lang="ts" setup>
-  import { BasicForm, useForm } from '/@/components/Form';
-  import { formSchemas } from './config';
-  import { BasicModal, useModalInner } from '/@/components/Modal';
-  import { OpenModalMode, OpenModalParams, StructRecord } from './type';
-  import { computed, ref, unref } from 'vue';
-  import { transfromToStructJSON } from './util';
-  import { cloneDeep } from 'lodash-es';
-  import { DataType, StructJSON } from '/@/api/device/model/modelOfMatterModel';
-  import { isArray } from '/@/utils/is';
-  import { useMessage } from '/@/hooks/web/useMessage';
-  import EnumList from './EnumList.vue';
-  import { DataTypeEnum } from '/@/enums/objectModelEnum';
-
-  const modalReceiveRecord = ref<OpenModalParams>({
-    mode: OpenModalMode.CREATE,
-  });
-
-  const props = defineProps<{
-    disabled: boolean;
-    hasStructForm: boolean;
-    valueList: StructRecord[];
-    hiddenAccessMode: boolean;
-  }>();
-
-  const enumListRef = ref<InstanceType<typeof EnumList>>();
-
-  const emit = defineEmits(['register', 'submit']);
-
-  const { createMessage } = useMessage();
-
-  const [register, { validate, setFieldsValue, setProps }] = useForm({
-    labelWidth: 100,
-    actionColOptions: {
-      span: 14,
-    },
-    disabled: props.disabled,
-    showResetButton: false,
-    submitOnReset: false,
-    showActionButtonGroup: false,
-  });
-
-  const getFormSchemas = computed(() => {
-    const { hasStructForm, hiddenAccessMode } = props;
-    return formSchemas({
-      hasStructForm,
-      hiddenAccessMode,
-    });
-  });
-
-  const [registerModal, { closeModal }] = useModalInner((record: OpenModalParams) => {
-    modalReceiveRecord.value = record;
-    const data = record.record || {};
-    const { dataType = {} } = data! as StructJSON;
-    const { specs = {}, type, specsList } = dataType as DataType;
-
-    if (record.record) {
-      const value = {
-        type,
-        ...data,
-        ...(isArray(specs) ? { specs } : { ...specs }),
-        enumList: type === DataTypeEnum.ENUM ? specsList : [],
-      };
-
-      setFieldsValue(value);
-    }
-    setProps({ disabled: props.disabled });
-  });
-
-  const validateRepeat = (value: StructRecord, valueList: StructRecord[]) => {
-    return valueList.filter((item) => item.identifier === value.identifier).length >= 1;
-  };
-
-  const handleSubmit = async () => {
-    try {
-      const _value = await validate();
-      await unref(enumListRef)?.validate?.();
-      let structJSON = transfromToStructJSON(_value, unref(enumListRef)?.getFieldsValue?.() || []);
-      const value = {
-        ...structJSON,
-        ...(unref(modalReceiveRecord)?.record?.id
-          ? { id: unref(modalReceiveRecord)?.record?.id }
-          : {}),
-      };
-
-      if (
-        unref(modalReceiveRecord).mode === OpenModalMode.CREATE &&
-        validateRepeat(_value, props.valueList)
-      ) {
-        createMessage.error('存在一致的标识符');
-        return;
-      }
-      emit('submit', unref(modalReceiveRecord).mode, cloneDeep(value));
-      closeModal();
-    } catch (error) {}
-  };
-</script>
-
-<template>
-  <BasicModal
-    @register="registerModal"
-    :title="modalReceiveRecord.mode === OpenModalMode.CREATE ? '创建参数' : '编辑参数'"
-    :width="800"
-    @ok="handleSubmit"
-    destroy-on-close
-    :show-ok-btn="!$props.disabled"
-  >
-    <BasicForm @register="register" :schemas="getFormSchemas">
-      <template #EnumList="{ field, model }">
-        <EnumList ref="enumListRef" :value="model[field]" :disabled="disabled" />
-      </template>
-    </BasicForm>
-  </BasicModal>
-</template>
-
-<style lang="less" scoped></style>

-import { ModelOfMatterParams } from '/@/api/device/model/modelOfMatterModel';
-import { findDictItemByCode } from '/@/api/system/dict';
-import { Rule } from '/@/components/Form';
-import { FormSchema } from '/@/components/Table';
-import { DataTypeEnum } from '/@/enums/objectModelEnum';
-import { isNullOrUnDef } from '/@/utils/is';
-import { FormField } from '/@/views/device/profiles/step/cpns/physical/cpns/config';
-
-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 validateJSON = (_rule, value = [] as ModelOfMatterParams[], _callback) => {
-  if (value.length) {
-    return Promise.resolve();
-  }
-  return Promise.reject('JSON对象不能为空');
-};
-
-interface StructFormSchemasParmasType {
-  hasStructForm: boolean;
-  hiddenAccessMode: boolean;
-  isTcp?: boolean;
-}
-
-//功能名称和标识符 输入框不能包含逗号
-const validateExcludeComma = (field: string, errorName: string): Rule[] => {
-  return [
-    {
-      required: true,
-      trigger: 'blur',
-      validator: () => {
-        const reg = /[,，]+/;
-        if (reg.test(field)) {
-          return Promise.reject(`${errorName}不能包含逗号`);
-        }
-        return Promise.resolve();
-      },
-    },
-  ];
-};
-
-export const formSchemas = ({
-  hasStructForm,
-  hiddenAccessMode,
-  isTcp = false,
-}: StructFormSchemasParmasType): FormSchema[] => {
-  return [
-    {
-      field: FormField.FUNCTION_NAME,
-      label: '功能名称',
-      required: true,
-      component: 'Input',
-      colProps: {
-        span: 18,
-      },
-      componentProps: {
-        maxLength: 32,
-        placeholder: '请输入功能名称',
-      },
-      dynamicRules: ({ values }) => {
-        return [
-          { required: true, message: '请输入功能名称' },
-          ...validateExcludeComma(values[FormField.FUNCTION_NAME], '功能名称'),
-        ];
-      },
-    },
-    {
-      field: FormField.IDENTIFIER,
-      label: '标识符',
-      required: true,
-      component: 'Input',
-      colProps: {
-        span: 18,
-      },
-      componentProps: {
-        maxLength: 128,
-        placeholder: '请输入标识符',
-      },
-      dynamicRules: ({ values }) => {
-        return [
-          { required: true, message: '请输入标识符' },
-          ...validateExcludeComma(values[FormField.IDENTIFIER], '标识符'),
-        ];
-      },
-    },
-    {
-      field: FormField.HAS_STRUCT_FROM,
-      label: '是否已存在结构体',
-      component: 'Input',
-      ifShow: false,
-    },
-    {
-      field: FormField.TYPE,
-      label: '数据类型',
-      required: true,
-      component: 'ApiSelect',
-      colProps: {
-        span: 9,
-      },
-      defaultValue: 'INT',
-      componentProps: ({ formActionType }) => {
-        const { setFieldsValue } = formActionType;
-        return {
-          placeholder: '请选择数据类型',
-          api: async (params: Recordable) => {
-            try {
-              const record = await findDictItemByCode(params);
-
-              if (isTcp) {
-                // TCP 产品 属性可创建范围
-                return record.filter((item) =>
-                  [
-                    DataTypeEnum.BOOL,
-                    DataTypeEnum.NUMBER_DOUBLE,
-                    DataTypeEnum.NUMBER_INT,
-                    DataTypeEnum.STRING,
-                  ].includes(item.itemValue as DataTypeEnum)
-                );
-              }
-
-              return hasStructForm
-                ? record.filter((item) => item.itemValue !== DataTypeEnum.STRUCT)
-                : record;
-            } catch (error) {
-              return [];
-            }
-          },
-          params: {
-            dictCode: 'data_type',
-          },
-          labelField: 'itemText',
-          valueField: 'itemValue',
-          getPopupContainer: () => document.body,
-          onChange: (value: string) => {
-            if (value == DataTypeEnum.STRUCT) {
-              setFieldsValue({ [FormField.SPECS_LIST]: [], [FormField.HAS_STRUCT_FROM]: true });
-            }
-          },
-        };
-      },
-    },
-    {
-      field: FormField.ENUM_LIST,
-      component: 'Input',
-      label: '枚举',
-      ifShow: ({ values }) => values[FormField.TYPE] === DataTypeEnum.ENUM,
-      slot: 'EnumList',
-      colProps: {
-        span: 24,
-      },
-    },
-    {
-      field: FormField.VALUE_RANGE,
-      label: '取值范围',
-      component: 'CustomMinMaxInput',
-      valueField: 'value',
-      changeEvent: 'update:value',
-      colProps: {
-        span: 18,
-      },
-      ifShow: ({ values }) =>
-        values[FormField.TYPE] === DataTypeEnum.NUMBER_INT ||
-        values[FormField.TYPE] === DataTypeEnum.NUMBER_DOUBLE,
-      rules: [{ validator: validateValueRange }],
-    },
-    {
-      field: FormField.STEP,
-      label: '步长',
-      component: 'InputNumber',
-      colProps: {
-        span: 18,
-      },
-      componentProps: {
-        maxLength: 255,
-        placeholder: '请输入步长',
-        min: 1,
-        formatter: (value: number | string) => {
-          return value ? Math.floor(Number(value)) : value;
-        },
-      },
-      ifShow: ({ values }) =>
-        values[FormField.TYPE] === DataTypeEnum.NUMBER_INT ||
-        values[FormField.TYPE] === DataTypeEnum.NUMBER_DOUBLE,
-      dynamicRules: ({ model }) => {
-        const valueRange = model[FormField.VALUE_RANGE] || {};
-        const { min, max } = valueRange;
-        const step = model[FormField.STEP];
-        return [
-          {
-            validator: () => {
-              if ([min, max].every(isNullOrUnDef)) return Promise.resolve();
-              if (step > max - min) {
-                return Promise.reject('步长不能大于取值范围的差值');
-              }
-              return Promise.resolve();
-            },
-          },
-        ];
-      },
-    },
-    {
-      field: FormField.UNIT_NAME,
-      label: '单位名称',
-      component: 'Input',
-      show: false,
-    },
-    {
-      field: FormField.UNIT,
-      label: '单位',
-      component: 'ApiSelect',
-      colProps: {
-        span: 9,
-      },
-      componentProps: ({ formActionType }) => {
-        const { setFieldsValue } = formActionType;
-        return {
-          placeholder: '请选择单位',
-          api: async (params) => {
-            const list = await findDictItemByCode(params);
-            list.map((item) => (item.itemText = `${item.itemText} / ${item.itemValue}`));
-            return list;
-          },
-          params: {
-            dictCode: 'attribute_unit',
-          },
-          labelInValue: true,
-          labelField: 'itemText',
-          valueField: 'itemValue',
-          onChange(_, record: Record<'label' | 'value', string>) {
-            if (record) {
-              const { label } = record;
-              setFieldsValue({ [FormField.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: ({ values }) =>
-        values[FormField.TYPE] === DataTypeEnum.NUMBER_INT ||
-        values[FormField.TYPE] === DataTypeEnum.NUMBER_DOUBLE,
-    },
-    {
-      field: FormField.BOOL_CLOSE,
-      component: 'Input',
-      required: true,
-      label: '0 -',
-      colProps: {
-        span: 18,
-      },
-      componentProps: {
-        placeholder: '如：关',
-      },
-      defaultValue: '关',
-      ifShow: ({ values }) => values[FormField.TYPE] === DataTypeEnum.BOOL,
-      dynamicRules: ({ model }) => {
-        const close = model[FormField.BOOL_CLOSE];
-        const open = model[FormField.BOOL_OPEN];
-        return [
-          {
-            required: true,
-          },
-          {
-            validator() {
-              if (open === close) return Promise.reject('布尔值不能相同');
-              return Promise.resolve();
-            },
-          },
-        ];
-      },
-    },
-    {
-      field: FormField.BOOL_OPEN,
-      component: 'Input',
-      required: true,
-      label: '1 -',
-      colProps: {
-        span: 18,
-      },
-      componentProps: {
-        placeholder: '如：开',
-      },
-      defaultValue: '开',
-      ifShow: ({ values }) => values[FormField.TYPE] === DataTypeEnum.BOOL,
-      dynamicRules: ({ model }) => {
-        const close = model[FormField.BOOL_CLOSE];
-        const open = model[FormField.BOOL_OPEN];
-        return [
-          {
-            required: true,
-          },
-          {
-            validator() {
-              if (open === close) return Promise.reject('布尔值不能相同');
-              return Promise.resolve();
-            },
-          },
-        ];
-      },
-    },
-    {
-      field: FormField.LENGTH,
-      component: 'Input',
-      required: true,
-      label: '数据长度',
-      defaultValue: '10240',
-      colProps: {
-        span: 8,
-      },
-      componentProps: {
-        placeholder: '请输入数据长度',
-      },
-      renderComponentContent: () => {
-        return {
-          suffix: () => '字节',
-        };
-      },
-      ifShow: ({ values }) => values[FormField.TYPE] === DataTypeEnum.STRING,
-    },
-    {
-      field: FormField.EXTENSION_DESC,
-      component: 'ExtendDesc',
-      label: '扩展描述',
-      valueField: 'value',
-      changeEvent: 'update:value',
-      ifShow: isTcp,
-      colProps: {
-        span: 16,
-      },
-      componentProps: ({ formModel }) => {
-        return {
-          dataType: formModel[FormField.TYPE],
-        };
-      },
-    },
-    {
-      field: FormField.ACCESS_MODE,
-      component: 'ApiRadioGroup',
-      label: '读写类型',
-      required: true,
-      colProps: {
-        span: 24,
-      },
-      ifShow: () => !hiddenAccessMode && !hasStructForm,
-      defaultValue: 'r',
-      componentProps: {
-        placeholder: '请选择读写类型',
-        api: findDictItemByCode,
-        params: {
-          dictCode: 'read_write_type',
-        },
-        labelField: 'itemText',
-        valueField: 'itemValue',
-      },
-    },
-    {
-      field: FormField.SPECS_LIST,
-      label: 'JSON对象',
-      component: 'StructForm',
-      valueField: 'value',
-      changeEvent: 'update:value',
-      colProps: { span: 24 },
-      ifShow: ({ values }) => values[FormField.TYPE] === DataTypeEnum.STRUCT,
-      rules: [{ required: true, validator: validateJSON }],
-      componentProps: ({ formModel }) => {
-        return {
-          hasStructForm: formModel[FormField.HAS_STRUCT_FROM],
-        };
-      },
-    },
-    {
-      field: FormField.REFARK,
-      label: '备注',
-      component: 'InputTextArea',
-      componentProps: {
-        rows: 4,
-        maxLength: 100,
-        placeholder: '请输入描述',
-      },
-    },
-  ];
-};

-import { StructJSON } from '/@/api/device/model/modelOfMatterModel';
-import { DataTypeEnum } from '/@/enums/objectModelEnum';
-import { FormField } from '/@/views/device/profiles/step/cpns/physical/cpns/config';
-
-export enum OpenModalMode {
-  CREATE = 'create',
-  UPDATE = 'update',
-}
-
-export interface OpenModalParams {
-  mode: OpenModalMode;
-  record?: StructRecord;
-}
-
-export interface StructFormValue
-  extends Partial<Record<Exclude<FormField, FormField.VALUE_RANGE | FormField.STRUCT>, string>> {
-  [FormField.TYPE]: DataTypeEnum;
-  [FormField.VALUE_RANGE]?: {
-    [FormField.MIN]: string;
-    [FormField.MAX]: string;
-  };
-  [FormField.STRUCT]: StructRecord[];
-}
-
-export interface StructRecord extends StructJSON {
-  id: string;
-}

-import { cloneDeep } from 'lodash-es';
-import { StructFormValue } from './type';
-import {
-  DataType,
-  ModelOfMatterParams,
-  Specs,
-  StructJSON,
-} from '/@/api/device/model/modelOfMatterModel';
-import { isArray } from '/@/utils/is';
-import { DataTypeEnum } from '/@/enums/objectModelEnum';
-
-export function transfromToStructJSON(value: StructFormValue, enumList: Specs[] = []): StructJSON {
-  const {
-    type,
-    valueRange,
-    step,
-    length = '',
-    boolClose,
-    boolOpen,
-    unit,
-    unitName,
-    functionName,
-    identifier,
-    remark,
-    specs,
-    accessMode,
-  } = value;
-  const basic = { functionName, identifier, remark, accessMode };
-  let dataType = {} as unknown as DataType;
-
-  switch (type) {
-    case DataTypeEnum.NUMBER_INT:
-      dataType = {
-        type,
-        specs: { valueRange, step, unit, unitName },
-      };
-      break;
-
-    case DataTypeEnum.NUMBER_DOUBLE:
-      dataType = {
-        type,
-        specs: { valueRange, step, unit, unitName },
-      };
-      break;
-
-    case DataTypeEnum.BOOL:
-      dataType = {
-        type,
-        specs: {
-          boolOpen: boolOpen,
-          boolClose: boolClose,
-        },
-      };
-      break;
-
-    case DataTypeEnum.STRING:
-      dataType = {
-        type,
-        specs: { length },
-      };
-      break;
-
-    case DataTypeEnum.ENUM:
-      dataType = {
-        type,
-        specsList: enumList,
-      };
-      break;
-
-    case DataTypeEnum.STRUCT:
-      dataType = {
-        type,
-        specs: specs! as unknown as ModelOfMatterParams[],
-      };
-      break;
-  }
-  return { ...basic, dataType } as StructJSON;
-}
-
-export const excludeIdInStructJSON = (struct: DataType) => {
-  const _value = cloneDeep(struct);
-  const { specs } = _value;
-  if (!specs) return _value;
-  const list = [specs];
-
-  while (list.length) {
-    for (const item of list) {
-      if (isArray(item)) {
-        (item as StructJSON[]).forEach((temp) => {
-          if (temp.dataType?.specs) {
-            list.push(temp.dataType.specs);
-          }
-          Reflect.has(temp, 'id') && Reflect.deleteProperty(temp, 'id');
-        });
-      } else {
-        Reflect.has(item as Recordable, 'id') && Reflect.deleteProperty(item as Recordable, 'id');
-      }
-      list.shift();
-    }
-  }
-
-  return _value;
-};

@@ -117,12 +117,12 @@ export type ComponentType =
   | 'ColorPicker'
   | 'ColorPicker'
   | 'IconDrawer'
   | 'IconDrawer'
   | 'ApiUpload'
   | 'ApiUpload'
+  | 'ApiCascader'
   | 'ApiSearchSelect'
   | 'ApiSearchSelect'
   | 'StructForm'
   | 'StructForm'
   | 'ApiSelectScrollLoad'
   | 'ApiSelectScrollLoad'
   | 'TransferModal'
   | 'TransferModal'
   | 'TransferTableModal'
   | 'TransferTableModal'
-  | 'ObjectModelValidateForm'
   | 'ThingsModelForm'
   | 'ThingsModelForm'
   | 'DevicePicker'
   | 'DevicePicker'
   | 'ProductPicker'
   | 'ProductPicker'
@@ -145,4 +145,6 @@ export type ComponentType =
   | 'TriggerDurationInput'
   | 'TriggerDurationInput'
   | 'AlarmProfileSelect'
   | 'AlarmProfileSelect'
   | 'LockControlGroup'
   | 'LockControlGroup'
-  | 'EnumList';
+  | 'EnumList'
+  | 'Segmented'
+  | 'StructFormItem';

+export enum TransportTypeEnum {
+  DEFAULT = 'DEFAULT',
+  MQTT = 'MQTT',
+  COAP = 'COAP',
+  LWM2M = 'LWM2M',
+  SNMP = 'SNMP',
+  TCP = 'TCP',
+}
+
+export enum ReadAndWriteEnum {
+  READ = 'r',
+  READ_AND_WRITE = 'rw',
+}
+
+export enum ServiceCallTypeEnum {
+  ASYNC = 'ASYNC',
+  SYNC = 'SYNC',
+}
+
+export enum ServiceCallTypeNameEnum {
+  ASYNC = '异步',
+  SYNC = '同步',
+}
+
+export enum CommandDeliveryWayEnum {
+  ONE_WAY = 'oneway',
+  TWO_WAY = 'twoway',
+}
+
+export enum CommandDeliveryWayNameEnum {
+  ONE_WAY = '单向',
+  TWO_WAY = '双向',
+}
+
+export enum CommandTypeEnum {
+  CUSTOM = 0,
+  SERVICE = 1,
+  ATTRIBUTE = 2,
+  API = 'api',
+}
+
+export enum CommandTypeNameEnum {
+  CUSTOM = '自定义',
+  SERVICE = '服务',
+  ATTRIBUTE = '属性',
+}
+
+export enum RPCCommandMethodEnum {
+  THINGSKIT = 'methodThingskit',
+}

 export enum DictEnum {
 export enum DictEnum {
+  // 物模型数据类型
+  DATA_TYPE = 'data_type',
+
+  // 事件类型
+  EVENT_TYPE = 'event_type',
+  // 物模型单位
+  ATTRIBUTE_UNIT = 'attribute_unit',
+  // 物模型读写类型
+  READ_WRITE_TYP = 'read_write_type',
   // 从机地址
   // 从机地址
   SLAVE_ADDRESS = 'slave_address',
   SLAVE_ADDRESS = 'slave_address',
   // 功能码
   // 功能码

@@ -154,16 +154,3 @@ export enum ExecutionActionNameEnum {
   DEVICE_OUT = '设备输出',
   DEVICE_OUT = '设备输出',
   MSG_NOTIFY = '告警输出',
   MSG_NOTIFY = '告警输出',
 }
 }
-
-export enum CommandTypeEnum {
-  CUSTOM = 0,
-  SERVICE = 1,
-  ATTRIBUTE = 2,
-  API = 'api',
-}
-
-export enum CommandTypeNameEnum {
-  CUSTOM = '自定义',
-  SERVICE = '服务',
-  ATTRIBUTE = '属性',
-}

@@ -7,6 +7,30 @@ export enum DataTypeEnum {
   ENUM = 'ENUM',
   ENUM = 'ENUM',
 }
 }
 
 
+export enum FunctionTypeEnum {
+  PROPERTIES = 'properties',
+  SERVICE = 'services',
+  EVENTS = 'events',
+}
+
+export enum FunctionTypeNameEnum {
+  PROPERTIES = '属性',
+  SERVICE = '服务',
+  EVENTS = '事件',
+}
+
+export enum ObjectEventTypeEnum {
+  INFO = 'INFO',
+  ALERT = 'ALERT',
+  ERROR = 'ERROR',
+}
+
+export enum ObjectEventTypeNameEnum {
+  INFO = '信息',
+  ALERT = '告警',
+  ERROR = '故障',
+}
+
 export enum RegisterDataTypeEnum {
 export enum RegisterDataTypeEnum {
   UN_SHORT = 'unshort',
   UN_SHORT = 'unshort',
 }
 }
@@ -26,3 +50,12 @@ export enum RegisterActionTypeNameEnum {
   INT = '06写入单个保持寄存器',
   INT = '06写入单个保持寄存器',
   DOUBLE = '16写入多个保持寄存器',
   DOUBLE = '16写入多个保持寄存器',
 }
 }
+
+export enum ObjectModelAccessModeEnum {
+  READ = 'r',
+  READ_AND_WRITE = 'rw',
+}
+
+export enum ModbusCRCEnum {
+  CRC_16_LOWER = 'CRC_16_LOWER',
+}

@@ -29,23 +29,3 @@ export enum BooleanStringEnum {
   TRUE = 'true',
   TRUE = 'true',
   FALSE = 'false',
   FALSE = 'false',
 }
 }
-
-export enum ReadAndWriteEnum {
-  READ = 'r',
-  READ_AND_WRITE = 'rw',
-}
-
-export enum ServiceCallTypeEnum {
-  ASYNC = 'ASYNC',
-  SYNC = 'SYNC',
-}
-
-export enum ServiceCallTypeNameEnum {
-  ASYNC = '异步',
-  SYNC = '同步',
-}
-
-export enum CommandDeliveryWayEnum {
-  ONE_WAY = 'oneway',
-  TWO_WAY = 'twoway',
-}

@@ -6,6 +6,7 @@
     :title="getTitle"
     :title="getTitle"
     width="30%"
     width="30%"
     @ok="handleSubmit"
     @ok="handleSubmit"
+    wrapClassName="camera-configration-drawer"
   >
   >
     <BasicForm @register="registerForm">
     <BasicForm @register="registerForm">
       <template #videoPlatformIdSlot="{ model, field }">
       <template #videoPlatformIdSlot="{ model, field }">
@@ -125,7 +126,11 @@
             });
             });
           }
           }
 
 
-          setFieldsValue({ ...record, videoType: record.videoPlatformDTO?.type });
+          setFieldsValue({
+            ...record,
+            videoType: record.videoPlatformDTO?.type,
+            ...(record?.params || {}),
+          });
         } else {
         } else {
           editId.value = '';
           editId.value = '';
         }
         }
@@ -157,6 +162,7 @@
           ) {
           ) {
             values.streamType = values.articulation;
             values.streamType = values.articulation;
             values.playProtocol = values.videoFormat;
             values.playProtocol = values.videoFormat;
+            values.params = values.channelNo ? { channelNo: values.channelNo } : null;
           }
           }
 
 
           await createOrEditCameraManage(values);
           await createOrEditCameraManage(values);
@@ -190,3 +196,11 @@
     },
     },
   });
   });
 </script>
 </script>
+
+<style lang="less">
+  .camera-configration-drawer {
+    .ant-input-number {
+      width: 100% !important;
+    }
+  }
+</style>

@@ -21,11 +21,6 @@ export enum CameraPermission {
   DELETE = 'api:yt:video:delete',
   DELETE = 'api:yt:video:delete',
 }
 }
 
 
-export enum VideoPlatformEnum {
-  HAIKANG = 0,
-  FLUORITE = 1,
-}
-
 export enum AccessMode {
 export enum AccessMode {
   ManuallyEnter = 0,
   ManuallyEnter = 0,
   Streaming = 1,
   Streaming = 1,
@@ -250,16 +245,28 @@ export const formSchema: QFormSchema[] = [
     required: true,
     required: true,
     defaultValue: VideoPlatformEnum.SCI,
     defaultValue: VideoPlatformEnum.SCI,
     ifShow: ({ values }) => values.accessMode === AccessMode.Streaming,
     ifShow: ({ values }) => values.accessMode === AccessMode.Streaming,
-    componentProps: {
-      api: async (params) => {
-        const values = await findDictItemByCode(params);
-        return values.map((item) => ({ label: item.itemText, value: Number(item.itemValue) }));
-      },
-      params: {
-        dictCode: DictEnum.STREAMING_MEDIA_TYPE,
-      },
-      getPopupContainer: () => document.body,
-      placeholder: `请选择平台类型`,
+    componentProps: ({ formActionType }) => {
+      return {
+        api: async (params) => {
+          const values = await findDictItemByCode(params);
+          return values.map((item) => ({ label: item.itemText, value: Number(item.itemValue) }));
+        },
+        params: {
+          dictCode: DictEnum.STREAMING_MEDIA_TYPE,
+        },
+        getPopupContainer: () => document.body,
+        placeholder: `请选择平台类型`,
+        onChange() {
+          const { setFieldsValue } = formActionType;
+          setFieldsValue({
+            articulation: ArticulationEnumType.HIGH_DEFINITION,
+            playProtocol: PlayProtocol.HTTP,
+            sn: null,
+            channelNo: null,
+            videoPlatformId: null,
+          });
+        },
+      };
     },
     },
   },
   },
   {
   {
@@ -384,4 +391,22 @@ export const formSchema: QFormSchema[] = [
       placeholder: '请输入监控点编号',
       placeholder: '请输入监控点编号',
     },
     },
   },
   },
+  {
+    field: 'channelNo',
+    label: '通道号',
+    component: 'InputNumber',
+    ifShow({ values }) {
+      return (
+        values.accessMode === AccessMode.Streaming &&
+        values.videoType === VideoPlatformEnum.FLUORITE
+      );
+    },
+    componentProps: {
+      min: 1,
+      max: 10000,
+      step: 1,
+      placeholder: '请输入通道号',
+      precision: 0,
+    },
+  },
 ];
 ];

-import { FormProps, FormSchema, useComponentRegister } from '/@/components/Form';
+import { FormSchema, useComponentRegister } from '/@/components/Form';
 import { findDictItemByCode } from '/@/api/system/dict';
 import { findDictItemByCode } from '/@/api/system/dict';
 import { getGatewayDevice, queryDeviceProfileBy } from '/@/api/device/deviceManager';
 import { getGatewayDevice, queryDeviceProfileBy } from '/@/api/device/deviceManager';
-import { TransportTypeEnum } from '../../profiles/components/TransportDescript/const';
-import { JSONEditorValidator } from '/@/components/CodeEditor/src/JSONEditor';
 import { JSONEditor } from '/@/components/CodeEditor';
 import { JSONEditor } from '/@/components/CodeEditor';
 import { DeviceRecord, DeviceTypeEnum } from '/@/api/device/model/deviceModel';
 import { DeviceRecord, DeviceTypeEnum } from '/@/api/device/model/deviceModel';
-import { getModelServices } from '/@/api/device/modelOfMatter';
-import { ModelOfMatterParams } from '/@/api/device/model/modelOfMatterModel';
-import { h, toRaw, unref } from 'vue';
-import ObjectModelValidateForm from '/@/components/Form/src/externalCompns/components/ObjectModelValidateForm/ObjectModelValidateForm.vue';
-import { CommandDeliveryWayEnum, ServiceCallTypeEnum } from '/@/enums/toolEnum';
+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 { 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';
@@ -17,9 +11,9 @@ 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';
 
 
 useComponentRegister('JSONEditor', JSONEditor);
 useComponentRegister('JSONEditor', JSONEditor);
-useComponentRegister('ObjectModelValidateForm', ObjectModelValidateForm);
 useComponentRegister('LockControlGroup', LockControlGroup);
 useComponentRegister('LockControlGroup', LockControlGroup);
 useComponentRegister('OrgTreeSelect', OrgTreeSelect);
 useComponentRegister('OrgTreeSelect', OrgTreeSelect);
 
 
@@ -910,214 +904,3 @@ export const TokenSchemas: FormSchema[] = [
     },
     },
   },
   },
 ];
 ];
-
-export enum ValueType {
-  JSON = 'json',
-  STRING = 'string',
-}
-
-export enum CommandFieldsEnum {
-  COMMAND_TYPE = 'commandType',
-  VALUE_TYPE = 'valueType',
-  COMMAND_TEXT = 'commandText',
-  COMAND_VALUE = 'commandValue',
-  SERVICE = 'service',
-  SERVICE_TYPE = 'service_type',
-  TCP_SERVICE = 'tcpService',
-  MODEL_INPUT = 'modelInput',
-  CUSTOM_TYPE = 'customType',
-}
-
-export enum CommandType {
-  CUSTOM = 'custom',
-  SERVICE = 'service',
-}
-
-export const CommandSchemas = (
-  transportType: TransportTypeEnum,
-  deviceProfileId: string
-): FormSchema[] => {
-  return [
-    {
-      field: CommandFieldsEnum.COMMAND_TYPE,
-      component: 'RadioGroup',
-      label: '下发类型',
-      defaultValue: CommandType.CUSTOM,
-      componentProps: ({ formActionType }) => {
-        const { setFieldsValue } = formActionType;
-        return {
-          options: [
-            { label: '自定义', value: CommandType.CUSTOM },
-            { label: '服务', value: CommandType.SERVICE },
-          ],
-          onChange() {
-            setFieldsValue({
-              [CommandFieldsEnum.SERVICE]: null,
-              [CommandFieldsEnum.MODEL_INPUT]: null,
-              [CommandFieldsEnum.COMAND_VALUE]: null,
-              [CommandFieldsEnum.COMMAND_TEXT]: null,
-            });
-          },
-        };
-      },
-    },
-    {
-      field: CommandFieldsEnum.CUSTOM_TYPE,
-      component: 'RadioGroup',
-      label: '单向/双向',
-      defaultValue: CommandDeliveryWayEnum.ONE_WAY,
-      ifShow: ({ model }) => model[CommandFieldsEnum.COMMAND_TYPE] === CommandType.CUSTOM,
-      componentProps: {
-        options: [
-          {
-            label: '单向',
-            value: CommandDeliveryWayEnum.ONE_WAY,
-          },
-          {
-            label: '双向',
-            value: CommandDeliveryWayEnum.TWO_WAY,
-          },
-        ],
-      },
-    },
-    {
-      field: CommandFieldsEnum.VALUE_TYPE,
-      label: '命令类型',
-      component: 'RadioGroup',
-      ifShow: ({ model }) => model[CommandFieldsEnum.COMMAND_TYPE] === CommandType.CUSTOM,
-      defaultValue: transportType === TransportTypeEnum.TCP ? ValueType.STRING : ValueType.JSON,
-      componentProps: () => {
-        const options: Record<'label' | 'value', string>[] = [];
-        if (transportType === TransportTypeEnum.TCP) {
-          options.push({ label: '字符串', value: ValueType.STRING });
-        } else {
-          options.push({ label: 'JSON', value: ValueType.JSON });
-        }
-        return {
-          options,
-        };
-      },
-    },
-    {
-      field: CommandFieldsEnum.COMMAND_TEXT,
-      label: '命令',
-      ifShow: ({ model }) =>
-        model[CommandFieldsEnum.VALUE_TYPE] === ValueType.STRING &&
-        model[CommandFieldsEnum.COMMAND_TYPE] === CommandType.CUSTOM,
-      component: 'InputTextArea',
-      componentProps: {
-        autoSize: {
-          minRows: 3,
-        },
-        placeholder: '请输入命令内容',
-      },
-      dynamicRules: () => {
-        return [
-          {
-            required: false,
-            validator: (_, value) => {
-              const zg = /^[0-9a-zA-Z]*$/;
-              if (!zg.test(value)) {
-                return Promise.reject('输入的内容只能是字母和数字的组合');
-              } else {
-                return Promise.resolve();
-              }
-            },
-          },
-        ];
-      },
-    },
-    {
-      field: CommandFieldsEnum.COMAND_VALUE,
-      label: '命令',
-      component: 'JSONEditor',
-      colProps: { span: 20 },
-      changeEvent: 'update:value',
-      valueField: 'value',
-      rules: [...JSONEditorValidator()],
-      ifShow: ({ model }) =>
-        model[CommandFieldsEnum.VALUE_TYPE] === ValueType.JSON &&
-        model[CommandFieldsEnum.COMMAND_TYPE] === CommandType.CUSTOM,
-
-      componentProps: {
-        height: 250,
-      },
-    },
-    {
-      field: CommandFieldsEnum.SERVICE,
-      label: '服务',
-      component: 'ApiSelect',
-      ifShow: ({ model }) => model[CommandFieldsEnum.COMMAND_TYPE] !== CommandType.CUSTOM,
-      rules: [{ required: true, message: '请选择服务' }],
-      componentProps: ({ formActionType }) => {
-        const { setFieldsValue, updateSchema } = formActionType;
-        return {
-          api: async () => {
-            try {
-              const result = await getModelServices({ deviceProfileId });
-              return result || [];
-            } catch (error) {
-              return [];
-            }
-          },
-          valueField: 'identifier',
-          labelField: 'functionName',
-          getPopupContainer: () => document.body,
-          onChange(value: string, options: ModelOfMatterParams) {
-            if (!value) return;
-
-            const setValues = {
-              [CommandFieldsEnum.CUSTOM_TYPE]:
-                options.callType === ServiceCallTypeEnum.ASYNC
-                  ? CommandDeliveryWayEnum.ONE_WAY
-                  : CommandDeliveryWayEnum.TWO_WAY,
-              [CommandFieldsEnum.MODEL_INPUT]: null,
-            };
-
-            if (transportType !== TransportTypeEnum.TCP) {
-              updateSchema({
-                field: CommandFieldsEnum.MODEL_INPUT,
-                componentProps: {
-                  inputData: toRaw(unref(options.functionJson.inputData)),
-                },
-              });
-            } else {
-              Object.assign(setValues, {
-                [CommandFieldsEnum.TCP_SERVICE]:
-                  options.functionJson?.inputData?.[0]?.serviceCommand,
-              });
-            }
-
-            setFieldsValue(setValues);
-          },
-        };
-      },
-    },
-    {
-      field: CommandFieldsEnum.TCP_SERVICE,
-      component: 'Input',
-      label: '命令',
-      dynamicDisabled: true,
-      ifShow: ({ model }) =>
-        model[CommandFieldsEnum.SERVICE] &&
-        transportType === TransportTypeEnum.TCP &&
-        model[CommandFieldsEnum.COMMAND_TYPE] !== CommandType.CUSTOM,
-    },
-    {
-      field: CommandFieldsEnum.MODEL_INPUT,
-      component: 'ObjectModelValidateForm',
-      label: '输入参数',
-      changeEvent: 'update:value',
-      valueField: 'value',
-      ifShow: ({ model }) =>
-        model[CommandFieldsEnum.SERVICE] &&
-        transportType !== TransportTypeEnum.TCP &&
-        model[CommandFieldsEnum.COMMAND_TYPE] !== CommandType.CUSTOM,
-      componentProps: {
-        formProps: {
-          wrapperCol: { span: 24 },
-        } as FormProps,
-      },
-    },
-  ];
-};

@@ -5,8 +5,8 @@ import { DeviceRecord, DeviceTypeEnum } from '/@/api/device/model/deviceModel';
 import { findDictItemByCode } from '/@/api/system/dict';
 import { findDictItemByCode } from '/@/api/system/dict';
 import { FormSchema, useComponentRegister } from '/@/components/Form';
 import { FormSchema, useComponentRegister } from '/@/components/Form';
 import { BasicColumn } from '/@/components/Table';
 import { BasicColumn } from '/@/components/Table';
+import { TransportTypeEnum } from '/@/enums/deviceEnum';
 import { OrgTreeSelect } from '/@/views/common/OrgTreeSelect';
 import { OrgTreeSelect } from '/@/views/common/OrgTreeSelect';
-import { TransportTypeEnum } from '/@/views/device/profiles/components/TransportDescript/const';
 import XLSX, { CellObject } from 'xlsx';
 import XLSX, { CellObject } from 'xlsx';
 
 
 useComponentRegister('OrgTreeSelect', OrgTreeSelect);
 useComponentRegister('OrgTreeSelect', OrgTreeSelect);

+import { ModelOfMatterParams } from '/@/api/device/model/modelOfMatterModel';
+import { getModelServices } from '/@/api/device/modelOfMatter';
+import { FormProps, FormSchema, useComponentRegister } from '/@/components/Form';
+import { validateTCPCustomCommand } from '/@/components/Form/src/components/ThingsModelForm';
+import { JSONEditor, JSONEditorValidator } from '/@/components/CodeEditor';
+import {
+  TransportTypeEnum,
+  CommandTypeNameEnum,
+  CommandTypeEnum,
+  ServiceCallTypeEnum,
+  CommandDeliveryWayEnum,
+  CommandDeliveryWayNameEnum,
+} from '/@/enums/deviceEnum';
+
+export interface CommandDeliveryFormFieldType {
+  [CommandFieldsEnum.COMMAND_TYPE]: CommandTypeEnum;
+  [CommandFieldsEnum.TCP_COMMAND_VALUE]?: string;
+  [CommandFieldsEnum.COMAND_VALUE]?: string;
+  [CommandFieldsEnum.SERVICE]?: string;
+  [CommandFieldsEnum.MODEL_INPUT]?: ModelOfMatterParams;
+  [CommandFieldsEnum.CALL_TYPE]: CommandDeliveryWayEnum;
+}
+
+export enum CommandFieldsEnum {
+  COMMAND_TYPE = 'commandType',
+  TCP_COMMAND_VALUE = 'tcpCommandValue',
+  COMAND_VALUE = 'commandValue',
+  SERVICE = 'service',
+  MODEL_INPUT = 'modelInput',
+  CALL_TYPE = 'callType',
+
+  SERVICE_COMMAND = 'serviceCommand',
+
+  SERVICE_OBJECT_MODEL = 'serviceObjectModel',
+}
+
+useComponentRegister('JSONEditor', JSONEditor);
+
+export const CommandSchemas = (
+  transportType: TransportTypeEnum,
+  deviceProfileId: string
+): FormSchema[] => {
+  return [
+    {
+      field: CommandFieldsEnum.COMMAND_TYPE,
+      component: 'RadioGroup',
+      label: '下发类型',
+      defaultValue: CommandTypeEnum.CUSTOM,
+      required: true,
+      componentProps: ({ formActionType }) => {
+        const { setFieldsValue } = formActionType;
+        return {
+          options: [
+            { label: CommandTypeNameEnum.CUSTOM, value: CommandTypeEnum.CUSTOM },
+            { label: CommandTypeNameEnum.SERVICE, value: CommandTypeEnum.SERVICE },
+          ],
+          onChange() {
+            setFieldsValue({
+              [CommandFieldsEnum.SERVICE]: null,
+              [CommandFieldsEnum.MODEL_INPUT]: null,
+              [CommandFieldsEnum.COMAND_VALUE]: null,
+              [CommandFieldsEnum.TCP_COMMAND_VALUE]: null,
+            });
+          },
+        };
+      },
+    },
+    {
+      field: CommandFieldsEnum.CALL_TYPE,
+      component: 'RadioGroup',
+      label: '单向/双向',
+      required: true,
+      defaultValue: CommandDeliveryWayEnum.ONE_WAY,
+      ifShow: ({ model }) => model[CommandFieldsEnum.COMMAND_TYPE] === CommandTypeEnum.CUSTOM,
+      componentProps: {
+        options: Object.keys(CommandDeliveryWayEnum).map((key) => ({
+          label: CommandDeliveryWayNameEnum[key],
+          value: CommandDeliveryWayEnum[key],
+        })),
+      },
+    },
+    {
+      field: CommandFieldsEnum.TCP_COMMAND_VALUE,
+      label: '命令',
+      required: true,
+      ifShow: ({ model }) =>
+        transportType === TransportTypeEnum.TCP &&
+        model[CommandFieldsEnum.COMMAND_TYPE] === CommandTypeEnum.CUSTOM,
+      component: 'Input',
+      rules: [{ validator: validateTCPCustomCommand }],
+      componentProps: {
+        placeholder: '请输入命令',
+      },
+    },
+    {
+      field: CommandFieldsEnum.COMAND_VALUE,
+      label: '命令',
+      component: 'JSONEditor',
+      colProps: { span: 20 },
+      changeEvent: 'update:value',
+      valueField: 'value',
+      required: true,
+      rules: JSONEditorValidator(),
+      ifShow: ({ model }) =>
+        transportType !== TransportTypeEnum.TCP &&
+        model[CommandFieldsEnum.COMMAND_TYPE] === CommandTypeEnum.CUSTOM,
+      componentProps: {
+        height: 250,
+      },
+    },
+    {
+      field: CommandFieldsEnum.SERVICE,
+      label: '服务',
+      component: 'ApiSelect',
+      required: true,
+      ifShow: ({ model }) => model[CommandFieldsEnum.COMMAND_TYPE] !== CommandTypeEnum.CUSTOM,
+      rules: [{ required: true, message: '请选择服务' }],
+      componentProps: ({ formActionType }) => {
+        const { setFieldsValue } = formActionType;
+        return {
+          api: getModelServices,
+          params: {
+            deviceProfileId,
+          },
+          valueField: 'identifier',
+          labelField: 'functionName',
+          getPopupContainer: () => document.body,
+          placeholder: '请选择服务',
+          onChange(
+            value: string,
+            options: ModelOfMatterParams & Record<'label' | 'value', string>
+          ) {
+            if (!value) return;
+            setFieldsValue({
+              [CommandFieldsEnum.CALL_TYPE]:
+                options.callType === ServiceCallTypeEnum.ASYNC
+                  ? CommandDeliveryWayEnum.ONE_WAY
+                  : CommandDeliveryWayEnum.TWO_WAY,
+              [CommandFieldsEnum.MODEL_INPUT]: null,
+              [CommandFieldsEnum.SERVICE_OBJECT_MODEL]: Object.assign(options, {
+                functionName: options.label,
+                identifier: options.value,
+              }),
+            });
+          },
+        };
+      },
+    },
+    {
+      field: CommandFieldsEnum.SERVICE_OBJECT_MODEL,
+      label: '服务物模型',
+      component: 'Input',
+      ifShow: false,
+    },
+    {
+      field: CommandFieldsEnum.MODEL_INPUT,
+      component: 'Input',
+      label: '输入参数',
+      changeEvent: 'update:value',
+      valueField: 'value',
+      ifShow: ({ model }) =>
+        model[CommandFieldsEnum.SERVICE] &&
+        model[CommandFieldsEnum.SERVICE_OBJECT_MODEL] &&
+        model[CommandFieldsEnum.COMMAND_TYPE] !== CommandTypeEnum.CUSTOM,
+      componentProps: {
+        formProps: {
+          wrapperCol: { span: 24 },
+        } as FormProps,
+      },
+      slot: 'serviceCommand',
+    },
+  ];
+};

+export { default as CommandDeliveryModal } from './index.vue';

+<template>
+  <BasicModal
+    title="命令下发"
+    :width="650"
+    @register="registerModal"
+    @ok="handleOk"
+    @cancel="handleCancel"
+  >
+    <BasicForm @register="registerForm">
+      <template #serviceCommand="{ field, model }">
+        <ThingsModelForm
+          :disabled="deviceDetail?.transportType === TransportTypeEnum.TCP"
+          ref="thingsModelFormRef"
+          v-model:value="model[field]"
+          :key="model[CommandFieldsEnum.SERVICE_OBJECT_MODEL]?.identifier"
+          :inputData="model[CommandFieldsEnum.SERVICE_OBJECT_MODEL]?.functionJson?.inputData"
+          :transportType="deviceDetail?.transportType"
+        />
+      </template>
+    </BasicForm>
+  </BasicModal>
+</template>
+<script lang="ts" setup>
+  import { nextTick, ref, unref } from 'vue';
+  import { BasicForm, ThingsModelForm, useForm } from '/@/components/Form';
+  import { CommandDeliveryFormFieldType, CommandFieldsEnum, CommandSchemas } from './config';
+  import { useMessage } from '/@/hooks/web/useMessage';
+  import { DeviceRecord } from '/@/api/device/model/deviceModel';
+  import { CommandDeliveryWayEnum } from '/@/enums/deviceEnum';
+  import { CommandTypeEnum, RPCCommandMethodEnum, TransportTypeEnum } from '/@/enums/deviceEnum';
+  import { BasicModal, useModalInner } from '/@/components/Modal';
+  import { getDeviceActiveTime } from '/@/api/alarm/position';
+  import { RpcCommandType } from '/@/api/device/model/deviceConfigModel';
+  import { parseStringToJSON } from '/@/components/CodeEditor';
+  import { commandIssuanceApi } from '/@/api/device/deviceManager';
+
+  defineEmits(['register']);
+
+  const thingsModelFormRef = ref<InstanceType<typeof ThingsModelForm>>();
+  const deviceDetail = ref<DeviceRecord>();
+
+  const [registerModal, { setModalProps }] = useModalInner(
+    (params: ModalParamsType<DeviceRecord>) => {
+      const { record } = params;
+      deviceDetail.value = record;
+      setProps({
+        schemas: CommandSchemas(record.transportType as TransportTypeEnum, record.deviceProfileId),
+      });
+    }
+  );
+
+  const { createMessage } = useMessage();
+
+  const [registerForm, { setProps, getFieldsValue, validate, resetFields, clearValidate }] =
+    useForm({
+      labelWidth: 120,
+      baseColProps: { span: 20 },
+      labelAlign: 'right',
+      showSubmitButton: false,
+      showResetButton: false,
+    });
+
+  const handleCancel = async () => {
+    await resetFields();
+    await nextTick();
+    await clearValidate();
+  };
+
+  const handleValidate = async () => {
+    await validate();
+    await unref(thingsModelFormRef)?.validate?.();
+  };
+
+  const handleValidateDeviceActive = async (): Promise<boolean> => {
+    const result = await getDeviceActiveTime(unref(deviceDetail)!.tbDeviceId);
+    const [firstItem] = result;
+    return !!firstItem.value;
+  };
+
+  const handleCommandParams = (
+    values: CommandDeliveryFormFieldType,
+    serviceCommand: Recordable
+  ) => {
+    const { commandType, service } = values;
+
+    const isTcpDevice = unref(deviceDetail)?.transportType === TransportTypeEnum.TCP;
+    if (commandType === CommandTypeEnum.CUSTOM) {
+      if (isTcpDevice) {
+        return values.tcpCommandValue;
+      }
+      return parseStringToJSON(values.commandValue!).json;
+    } else {
+      if (isTcpDevice) return Reflect.get(serviceCommand, CommandFieldsEnum.SERVICE_COMMAND);
+      return {
+        [service!]: serviceCommand,
+      };
+    }
+  };
+
+  const handleOk = async () => {
+    await handleValidate();
+
+    try {
+      setModalProps({ loading: true, confirmLoading: true });
+
+      const values = getFieldsValue() as CommandDeliveryFormFieldType;
+      const { callType, commandType } = values;
+      const serviceCommand = unref(thingsModelFormRef)?.getFieldsValue() || {};
+
+      if (callType === CommandDeliveryWayEnum.TWO_WAY && !(await handleValidateDeviceActive())) {
+        createMessage.warn('当前设备不在线');
+        return;
+      }
+
+      const rpcCommands: RpcCommandType = {
+        additionalInfo: {
+          cmdType:
+            commandType === CommandTypeEnum.CUSTOM
+              ? CommandTypeEnum.CUSTOM
+              : CommandTypeEnum.SERVICE,
+        },
+        method: RPCCommandMethodEnum.THINGSKIT,
+        persistent: true,
+        params: handleCommandParams(values, serviceCommand),
+      };
+
+      await commandIssuanceApi(callType, unref(deviceDetail)!.tbDeviceId, rpcCommands);
+
+      createMessage.success('命令下发成功');
+    } finally {
+      setModalProps({ loading: false, confirmLoading: false });
+    }
+  };
+</script>
+<style scoped lang="less"></style>

-<template>
-  <div class="tabs-detail">
-    <div>
-      <BasicForm @register="registerForm" />
-      <Space class="w-full justify-end py-2" justify="end">
-        <Button :loading="loading" type="primary" @click="handleOk" class="mr-2">确定</Button>
-        <Button type="default" @click="handleCancel" class="mr-2">重置</Button>
-      </Space>
-    </div>
-  </div>
-</template>
-<script lang="ts">
-  import { defineComponent, nextTick, ref } from 'vue';
-  import { BasicForm, useForm } from '/@/components/Form';
-  import { CommandFieldsEnum, CommandSchemas, CommandType, ValueType } from '../../config/data';
-  import { commandIssuanceApi } from '/@/api/device/deviceManager';
-  import { useMessage } from '/@/hooks/web/useMessage';
-  import { Button } from '/@/components/Button';
-  import { Space } from 'ant-design-vue';
-  import { DeviceRecord } from '/@/api/device/model/deviceModel';
-  import { TransportTypeEnum } from '../../../profiles/components/TransportDescript/const';
-  import { parseStringToJSON } from '/@/components/CodeEditor/src/JSONEditor';
-  import { CommandDeliveryWayEnum } from '/@/enums/toolEnum';
-
-  export default defineComponent({
-    components: { BasicForm, Button, Space },
-    props: {
-      deviceDetail: {
-        type: Object as PropType<DeviceRecord>,
-        required: true,
-      },
-    },
-    emits: ['register'],
-    setup(props) {
-      const { createMessage } = useMessage();
-      const loading = ref(false);
-
-      const [registerForm, { getFieldsValue, validate, resetFields, clearValidate }] = useForm({
-        labelWidth: 120,
-        schemas: CommandSchemas(
-          props.deviceDetail.deviceProfile.transportType as TransportTypeEnum,
-          props.deviceDetail.deviceProfileId
-        ),
-        baseColProps: { span: 20 },
-        labelAlign: 'right',
-        showSubmitButton: false,
-        showResetButton: false,
-      });
-
-      const handleCancel = async () => {
-        await resetFields();
-        await nextTick();
-        await clearValidate();
-      };
-
-      const handleOk = async () => {
-        loading.value = true;
-        try {
-          // 验证
-          const valid = await validate();
-          if (!valid) return;
-          // 收集表单数据
-          const field = getFieldsValue();
-          let command: Recordable = {
-            persistent: true,
-            method: 'methodThingskit',
-            params: field[CommandFieldsEnum.COMMAND_TEXT],
-          };
-
-          if (field[CommandFieldsEnum.COMMAND_TYPE] === CommandType.CUSTOM) {
-            if (field[CommandFieldsEnum.VALUE_TYPE] === ValueType.JSON) {
-              const { json } = parseStringToJSON(field.commandValue);
-              command.params = json;
-            }
-          } else {
-            const { transportType } = props.deviceDetail.deviceProfile;
-            command.params =
-              transportType === TransportTypeEnum.TCP
-                ? field[CommandFieldsEnum.TCP_SERVICE]
-                : {
-                    [field[CommandFieldsEnum.SERVICE]]: field[CommandFieldsEnum.MODEL_INPUT],
-                  };
-            command.additionalInfo = { cmdType: 1 };
-          }
-          commandIssuanceApi(
-            field[CommandFieldsEnum.CUSTOM_TYPE] as CommandDeliveryWayEnum,
-            props.deviceDetail.tbDeviceId,
-            command
-          )
-            .then((res) => {
-              if (!res) return;
-              createMessage.success('命令下发成功');
-              loading.value = true;
-              // 请求
-              handleCancel();
-            })
-            .catch((e) => {
-              if (e?.message) {
-                createMessage.error(e?.message);
-              }
-              handleCancel();
-            })
-            .finally(() => {
-              setTimeout(() => {
-                loading.value = false;
-              }, 300);
-            });
-        } catch (e) {
-          throw e;
-        } finally {
-          loading.value = false;
-        }
-      };
-      return {
-        registerForm,
-        handleCancel,
-        handleOk,
-        loading,
-      };
-    },
-  });
-</script>
-<style scoped lang="less">
-  .jsoneditor-transform {
-    background-position: -144px -96px;
-    display: none !important;
-  }
-
-  .tabs-detail:deep(.object-model-validate-form) {
-    > .ant-row {
-      @apply w-full;
-    }
-  }
-</style>

@@ -14,7 +14,7 @@
   import { ColEx } from '/@/components/Form/src/types';
   import { ColEx } from '/@/components/Form/src/types';
   import { useHistoryData } from '../../hook/useHistoryData';
   import { useHistoryData } from '../../hook/useHistoryData';
   import { formatToDateTime } from '/@/utils/dateUtil';
   import { formatToDateTime } from '/@/utils/dateUtil';
-  import { useTable, BasicTable, BasicColumn } from '/@/components/Table';
+  import { useTable, BasicTable, BasicColumn, SorterResult } from '/@/components/Table';
   import {
   import {
     ModeSwitchButton,
     ModeSwitchButton,
     TABLE_CHART_MODE_LIST,
     TABLE_CHART_MODE_LIST,
@@ -64,7 +64,7 @@
   }
   }
 
 
   const sortOrder = ref<any>('descend');
   const sortOrder = ref<any>('descend');
-  const columns: BasicColumn[] | any = computed(() => {
+  const columns = computed<BasicColumn[]>(() => {
     return [
     return [
       {
       {
         title: '属性',
         title: '属性',
@@ -119,7 +119,7 @@
     loading.value = false;
     loading.value = false;
   };
   };
 
 
-  const handleTableChange = async (_pag, _filters, sorter: any) => {
+  const handleTableChange = async (_pag, _filters, sorter: SorterResult) => {
     sortOrder.value = sorter.order;
     sortOrder.value = sorter.order;
     await setColumns(unref(columns));
     await setColumns(unref(columns));
     if (sorter.field == 'ts') {
     if (sorter.field == 'ts') {

@@ -18,7 +18,8 @@
   import { useGlobSetting } from '/@/hooks/setting';
   import { useGlobSetting } from '/@/hooks/setting';
   import { ModeSwitchButton, EnumTableCardMode } from '/@/components/Widget';
   import { ModeSwitchButton, EnumTableCardMode } from '/@/components/Widget';
   import { toRaw } from 'vue';
   import { toRaw } from 'vue';
-  import { DataActionModeEnum, ReadAndWriteEnum } from '/@/enums/toolEnum';
+  import { DataActionModeEnum } from '/@/enums/toolEnum';
+  import { ReadAndWriteEnum } 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';

 import { StructJSON } from '/@/api/device/model/modelOfMatterModel';
 import { StructJSON } from '/@/api/device/model/modelOfMatterModel';
 import { FormSchema } from '/@/components/Form';
 import { FormSchema } from '/@/components/Form';
-import { validateTCPCustomCommand } from '/@/components/Form/src/externalCompns/components/ThingsModelForm';
+import { validateTCPCustomCommand } from '/@/components/Form/src/components/ThingsModelForm';
 import { DataTypeEnum } from '/@/enums/objectModelEnum';
 import { DataTypeEnum } from '/@/enums/objectModelEnum';
 
 
 const InsertString = (t, c, n) => {
 const InsertString = (t, c, n) => {

@@ -12,8 +12,8 @@
   import { genModbusCommand } from '/@/api/task';
   import { genModbusCommand } from '/@/api/task';
   import { TaskTypeEnum } from '/@/views/task/center/config';
   import { TaskTypeEnum } from '/@/views/task/center/config';
   import { SingleToHex, formSchemasConfig } from './config';
   import { SingleToHex, formSchemasConfig } from './config';
-  import { TransportTypeEnum } from '/@/views/device/profiles/components/TransportDescript/const';
   import { DataTypeEnum } from '/@/enums/objectModelEnum';
   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 }>();

@@ -97,7 +97,7 @@
 
 
   const handleControl = (action: number, direction: string) => {
   const handleControl = (action: number, direction: string) => {
     const organizationId = getId();
     const organizationId = getId();
-    controlling({ cameralndexCode: organizationId, action, command: direction });
+    controlling({ cameraIndexCode: organizationId, action, command: direction });
   };
   };
 
 
   const isPlay = ref<Boolean | null | undefined>(false);
   const isPlay = ref<Boolean | null | undefined>(false);

@@ -6,7 +6,7 @@
     <template #toolbar>
     <template #toolbar>
       <Space>
       <Space>
         <Authority value="api:yt:device:rpc">
         <Authority value="api:yt:device:rpc">
-          <Button type="primary" @click="openModal(true)">命令下发</Button>
+          <Button type="primary" @click="handleOpenModal">命令下发</Button>
         </Authority>
         </Authority>
       </Space>
       </Space>
     </template>
     </template>
@@ -24,16 +24,7 @@
     </template>
     </template>
   </BasicTable>
   </BasicTable>
 
 
-  <BasicModal
-    @register="registerCommandIssuanceModal"
-    width="700px"
-    title="命令下发"
-    :showOkBtn="false"
-    cancelText="关闭"
-    :footer="null"
-  >
-    <CommandIssuance :deviceDetail="deviceDetail" />
-  </BasicModal>
+  <CommandDeliveryModal @register="registerCommandDeliverModal" :deviceDetail="deviceDetail" />
 </template>
 </template>
 <script lang="ts" setup>
 <script lang="ts" setup>
   import { h } from 'vue';
   import { h } from 'vue';
@@ -43,9 +34,10 @@
   import { Button, Modal, Space } from 'ant-design-vue';
   import { Button, Modal, Space } from 'ant-design-vue';
   import { JsonPreview } from '/@/components/CodeEditor';
   import { JsonPreview } from '/@/components/CodeEditor';
   import { DeviceRecord } from '/@/api/device/model/deviceModel';
   import { DeviceRecord } from '/@/api/device/model/deviceModel';
-  import { BasicModal, useModal } from '/@/components/Modal';
-  import CommandIssuance from '../CommandIssuance.vue';
+  import { useModal } from '/@/components/Modal';
+  import { CommandDeliveryModal } from '../CommandDeliveryModal';
   import { Authority } from '/@/components/Authority';
   import { Authority } from '/@/components/Authority';
+  import { DataActionModeEnum } from '/@/enums/toolEnum';
 
 
   const props = defineProps({
   const props = defineProps({
     fromId: {
     fromId: {
@@ -58,7 +50,7 @@
     },
     },
   });
   });
 
 
-  const [registerCommandIssuanceModal, { openModal }] = useModal();
+  const [registerCommandDeliverModal, { openModal }] = useModal();
 
 
   const [registerTable] = useTable({
   const [registerTable] = useTable({
     api: deviceCommandRecordGetQuery,
     api: deviceCommandRecordGetQuery,
@@ -79,6 +71,7 @@
     },
     },
     useSearchForm: true,
     useSearchForm: true,
   });
   });
+
   const commonModalInfo = (title, value) => {
   const commonModalInfo = (title, value) => {
     Modal.info({
     Modal.info({
       title,
       title,
@@ -86,14 +79,23 @@
       content: h(JsonPreview, { data: value }),
       content: h(JsonPreview, { data: value }),
     });
     });
   };
   };
+
   const handleRecordContent = (record) => {
   const handleRecordContent = (record) => {
     if (!record?.request?.body) return;
     if (!record?.request?.body) return;
     if (Object.prototype.toString.call(record?.request?.body) !== '[object Object]') return;
     if (Object.prototype.toString.call(record?.request?.body) !== '[object Object]') return;
     const jsonParams = record?.request?.body?.params;
     const jsonParams = record?.request?.body?.params;
     commonModalInfo('命令下发内容', jsonParams);
     commonModalInfo('命令下发内容', jsonParams);
   };
   };
+
   const handleRecordResponseContent = (record) => {
   const handleRecordResponseContent = (record) => {
     const jsonParams = record?.response;
     const jsonParams = record?.response;
     commonModalInfo('响应内容', jsonParams);
     commonModalInfo('响应内容', jsonParams);
   };
   };
+
+  function handleOpenModal() {
+    openModal(true, {
+      mode: DataActionModeEnum.READ,
+      record: props.deviceDetail,
+    } as ModalParamsType<DeviceRecord>);
+  }
 </script>
 </script>

@@ -287,6 +287,7 @@ export function getPacketIntervalByRange(
         break;
         break;
       }
       }
     }
     }
+    if (!options.length) options = rangeIntervalOption[rangeIntervalOption.length - 1].linkage;
     return options;
     return options;
   }
   }
   return [];
   return [];

+import { unref } from 'vue';
+import { FormFieldsEnum, FormFieldsNameEnum } from '../config';
+import { useObjectModelFormContext } from '../useObjectModelFormContext';
+import { Specs, StructJSON } from '/@/api/device/model/modelOfMatterModel';
+import { findDictItemByCode } from '/@/api/system/dict';
+import { FormSchema } from '/@/components/Form';
+import { TransportTypeEnum } from '/@/enums/deviceEnum';
+import { DictEnum } from '/@/enums/dictEnum';
+import { DataTypeEnum, FunctionTypeEnum } from '/@/enums/objectModelEnum';
+import { isNullOrUnDef } from '/@/utils/is';
+import { ValidatorRule } from 'ant-design-vue/lib/form/interface';
+
+export interface DataTypeFormGetFieldsValueType {
+  [FormFieldsEnum.FUNCTION_NAME]: string;
+  [FormFieldsEnum.IDENTIFIER]: string;
+  [FormFieldsEnum.DATA_TYPE]: DataTypeEnum;
+  [FormFieldsEnum.VALUE_RANGE]?: Record<'min' | 'max', number>;
+  [FormFieldsEnum.STEP]?: number;
+  [FormFieldsEnum.UNIT]?: string;
+  [FormFieldsEnum.UNIT_NAME]?: string;
+  [FormFieldsEnum.BOOL_CLOSE]?: string;
+  [FormFieldsEnum.BOOL_OPEN]?: string;
+  [FormFieldsEnum.LENGTH]?: number;
+  [FormFieldsEnum.ENUMS_DATA]?: Specs[];
+  [FormFieldsEnum.STRUCT_DATA]?: StructJSON[];
+  [FormFieldsEnum.REMARK]?: string;
+}
+
+export const validateValueRange: ValidatorRule['validator'] = (
+  _rule,
+  value: Record<'min' | 'max', number>,
+  _callback
+) => {
+  value = value || {};
+  const { min, max } = value;
+  if (min > max) {
+    return Promise.reject('最大值小于最小值');
+  }
+  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 => {
+  return {
+    field: FormFieldsEnum.FUNCTION_NAME,
+    label: FormFieldsNameEnum.FUNCTION_NAME,
+    component: 'Input',
+    required: true,
+    helpMessage: '支持中文、大小写字母、数字、短划线、下划线。',
+    rules: [
+      {
+        required: true,
+        validator: validateFunctionName,
+      },
+    ],
+    componentProps: {
+      placeholder: `请输入${FormFieldsNameEnum.FUNCTION_NAME}`,
+    },
+    ...params,
+  };
+};
+
+export const createIdentifierFormItem = (params: Partial<FormSchema> = {}): FormSchema => {
+  return {
+    field: FormFieldsEnum.IDENTIFIER,
+    label: FormFieldsNameEnum.IDENTIFIER,
+    required: true,
+    component: 'Input',
+    helpMessage: '支持大小写字母、数字和下划线.',
+    componentProps: {
+      maxLength: 128,
+      placeholder: '请输入标识符',
+    },
+    rules: [
+      {
+        required: true,
+        validator: validateIdentifier,
+      },
+    ],
+    ...params,
+  };
+};
+
+export const getFormSchemas = (dataType: DataTypeEnum[], showRemark: boolean): FormSchema[] => {
+  const { getTransportType } = useObjectModelFormContext();
+  return [
+    createFunctionNameFormItem(),
+    createIdentifierFormItem(),
+    {
+      field: FormFieldsEnum.DATA_TYPE,
+      label: FormFieldsNameEnum.DATA_TYPE,
+      required: true,
+      component: 'ApiSelect',
+      defaultValue: DataTypeEnum.NUMBER_INT,
+      ifShow: () => !!dataType.length,
+      componentProps: () => {
+        return {
+          placeholder: '请选择数据类型',
+          api: async (params: Recordable) => {
+            let result = await findDictItemByCode(params);
+            if (unref(getTransportType) === TransportTypeEnum.TCP) {
+              result = result.filter(
+                (item) =>
+                  ![DataTypeEnum.STRUCT, DataTypeEnum.ENUM].includes(item.itemValue as DataTypeEnum)
+              );
+            }
+            return result.filter((item) => dataType.includes(item.itemValue as DataTypeEnum));
+          },
+          params: {
+            dictCode: DictEnum.DATA_TYPE,
+          },
+          allowClear: false,
+          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),
+      dynamicRules: ({ model }) => [
+        {
+          required:
+            model[FormFieldsEnum.VALUE_RANGE]?.min || model[FormFieldsEnum.VALUE_RANGE]?.max,
+          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',
+      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),
+      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.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: 'InputNumber',
+      required: true,
+      label: FormFieldsNameEnum.LENGTH,
+      defaultValue: 1024,
+      componentProps: {
+        placeholder: '请输入数据长度',
+      },
+      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]
+        ),
+    },
+
+    {
+      field: FormFieldsEnum.REMARK,
+      label: FormFieldsNameEnum.REMARK,
+      component: 'InputTextArea',
+      ifShow: showRemark,
+      componentProps: {
+        rows: 4,
+        maxLength: 100,
+        placeholder: '请输入描述',
+      },
+    },
+  ];
+};

+export { default as DataTypeForm } from './index.vue';

+<script setup lang="ts">
+  import { useForm, BasicForm } from '/@/components/Form';
+  import { getFormSchemas } from './config';
+  import { EnumList } from '../EnumList';
+  import { ref } from 'vue';
+  import { StructFormItem } from '../StructFormItem';
+  import { DataTypeEnum } from '/@/enums/objectModelEnum';
+  import { useDataTypeFormData } from './useDataTypeFormData';
+  import { DataActionModeEnum } from '/@/enums/toolEnum';
+
+  const props = withDefaults(
+    defineProps<{
+      dataType?: DataTypeEnum[];
+      mode?: DataActionModeEnum;
+      showRemark?: boolean;
+    }>(),
+    {
+      dataType: () => Object.values(DataTypeEnum),
+      showRemark: false,
+    }
+  );
+
+  defineEmits<{
+    (event: 'field-value-change', field: string, value: any): void;
+  }>();
+
+  const [register, formActionType] = useForm({
+    schemas: getFormSchemas(props.dataType, props.showRemark),
+    layout: 'vertical',
+    showActionButtonGroup: false,
+  });
+
+  const enumListRef = ref<InstanceType<typeof EnumList>>();
+
+  const { getFieldsValue, setFieldsValue, validate, resetFieldsValue } = useDataTypeFormData({
+    formActionType,
+    enumListRef,
+  });
+
+  defineExpose({ getFieldsValue, setFieldsValue, validate, resetFieldsValue });
+</script>
+
+<template>
+  <BasicForm
+    @register="register"
+    class="data-type-form"
+    :disabled="mode === DataActionModeEnum.READ"
+    @field-value-change="(field, value) => $emit('field-value-change', field, value)"
+  >
+    <template #enumsData="{ model, field }">
+      <EnumList
+        ref="enumListRef"
+        v-model:value="model[field]"
+        :disabled="mode === DataActionModeEnum.READ"
+      />
+    </template>
+    <template #structData="{ model, field }">
+      <StructFormItem
+        v-model:value="model[field]"
+        :mode="mode"
+        :dataType="[
+          DataTypeEnum.BOOL,
+          DataTypeEnum.ENUM,
+          DataTypeEnum.NUMBER_DOUBLE,
+          DataTypeEnum.NUMBER_INT,
+          DataTypeEnum.STRING,
+        ]"
+      />
+    </template>
+  </BasicForm>
+</template>
+
+<style lang="less" scoped>
+  .data-type-form {
+    :deep(.ant-input-number) {
+      width: 100%;
+    }
+  }
+</style>
+./config

+import { Ref, unref } from 'vue';
+import { FormActionType } from '/@/components/Form';
+import EnumList from './EnumList.vue';
+import { DefineComponentsBasicExpose } from '/#/utils';
+import { DataTypeFormGetFieldsValueType } from './config';
+import { DataType, Specs, StructJSON } from '/@/api/device/model/modelOfMatterModel';
+import { DataTypeEnum } from '/@/enums/objectModelEnum';
+import { isObject } from '/@/utils/is';
+
+interface UseDataTypeFormDataParams {
+  formActionType: FormActionType;
+  enumListRef: Ref<InstanceType<typeof EnumList> | undefined>;
+}
+
+function getDataType(value: DataTypeFormGetFieldsValueType, enumListFormValue?: Specs[]): DataType {
+  const { dataType, valueRange, unit, unitName, step, length, boolClose, boolOpen, structData } =
+    value;
+
+  const basic: DataType = { type: dataType };
+
+  if (dataType === DataTypeEnum.BOOL) {
+    basic.specs = {
+      boolClose,
+      boolOpen,
+    };
+  } else if (dataType === DataTypeEnum.ENUM) {
+    basic.specsList = enumListFormValue;
+  } else if ([DataTypeEnum.NUMBER_DOUBLE, DataTypeEnum.NUMBER_INT].includes(dataType)) {
+    basic.specs = {
+      valueRange,
+      unit,
+      unitName,
+      step,
+    };
+  } else if (dataType === DataTypeEnum.STRING) {
+    basic.specs = {
+      length,
+    };
+  } else if (dataType === DataTypeEnum.STRUCT) {
+    basic.specs = structData || [];
+  }
+
+  return basic;
+}
+
+export function useDataTypeFormData({
+  formActionType,
+  enumListRef,
+}: UseDataTypeFormDataParams): DefineComponentsBasicExpose<StructJSON> {
+  const getFieldsValue = (): StructJSON => {
+    const value = formActionType.getFieldsValue() as DataTypeFormGetFieldsValueType;
+    const enumListFormValue = unref(enumListRef)?.getFieldsValue();
+    const { functionName, identifier, remark } = value;
+
+    return {
+      functionName,
+      identifier,
+      remark,
+      dataType: getDataType(value, enumListFormValue),
+    };
+  };
+
+  const setFieldsValue = (record: StructJSON) => {
+    const { dataType, identifier, functionName, remark } = record;
+    const { type, specs, specsList = [] } = dataType || {};
+
+    // 兼容处理 unit
+    if (isObject(specs) && isObject((specs as Specs).unit)) {
+      (specs as Specs).unit = ((specs as Specs).unit as unknown as Record<'value', string>)?.value;
+    }
+
+    // 兼容处理 length 数据长度类型
+    if (isObject(specs) && isObject((specs as Specs).length)) {
+      (specs as Specs).length = Number((specs as Specs).length);
+    }
+
+    formActionType.setFieldsValue({
+      dataType: type,
+      identifier,
+      functionName,
+      remark,
+      ...(isObject(specs) ? specs : {}),
+      structData: type === DataTypeEnum.STRUCT ? specs : [],
+      enumsData: type === DataTypeEnum.ENUM ? specsList : [],
+    } as DataTypeFormGetFieldsValueType);
+  };
+
+  const validate = async () => {
+    await formActionType.validate();
+    await unref(enumListRef)?.validate?.();
+  };
+
+  const resetFieldsValue = () => {
+    formActionType.resetFields();
+  };
+
+  return {
+    validate,
+    getFieldsValue,
+    setFieldsValue,
+    resetFieldsValue,
+  };
+}

-import { FormSchema } from '/@/components/Table';
+import { FormSchema } from '/@/components/Form';
 
 
 export enum FormFieldsEnum {
 export enum FormFieldsEnum {
   VALUE = 'value',
   VALUE = 'value',
@@ -41,14 +41,7 @@ export const getFormSchemas = (): FormSchema[] => {
       field: FormFieldsEnum.NAME,
       field: FormFieldsEnum.NAME,
       label: '',
       label: '',
       component: 'Input',
       component: 'Input',
-      rules: [
-        {
-          required: true,
-          message: `支持中文、英文大小写、数字、下划线和短划线，必须以中文、英文或数字开头，不超过20个字符`,
-          type: 'string',
-          pattern: /^[a-zA-Z0-9\u4e00-\u9fa5a][\u4e00-\u9fa5a-zA-Z0-9_-]*$/,
-        },
-      ],
+      rules: [{ required: true, message: `参数描述不能为空`, type: 'string' }],
       componentProps: () => {
       componentProps: () => {
         return {
         return {
           placeholder: '对该枚举项的描述',
           placeholder: '对该枚举项的描述',

+export { default as EnumList } from './index.vue';

 <script setup lang="ts">
 <script setup lang="ts">
   import { Button, Tooltip } from 'ant-design-vue';
   import { Button, Tooltip } from 'ant-design-vue';
   import { computed, nextTick, ref, unref, watch } from 'vue';
   import { computed, nextTick, ref, unref, watch } from 'vue';
-  import { useForm, BasicForm } from '/@/components/Form';
+  import { useForm, BasicForm, FormActionType } from '/@/components/Form';
   import { Specs } from '/@/api/device/model/modelOfMatterModel';
   import { Specs } from '/@/api/device/model/modelOfMatterModel';
   import { Icon } from '/@/components/Icon';
   import { Icon } from '/@/components/Icon';
-  import { getFormSchemas } from './EnumList.config';
-  import { FormActionType } from '../../../types/form';
+  import { getFormSchemas } from './config';
   import { buildUUID } from '/@/utils/uuid';
   import { buildUUID } from '/@/utils/uuid';
   import { DataTypeEnum } from '/@/enums/objectModelEnum';
   import { DataTypeEnum } from '/@/enums/objectModelEnum';
   import { isNullOrUnDef } from '/@/utils/is';
   import { isNullOrUnDef } from '/@/utils/is';
@@ -65,7 +64,6 @@
 
 
   const setFieldsValue = (spaceList: Specs[]) => {
   const setFieldsValue = (spaceList: Specs[]) => {
     enumsListElRef.value = spaceList.map((item) => ({ uuid: buildUUID(), dataSource: item }));
     enumsListElRef.value = spaceList.map((item) => ({ uuid: buildUUID(), dataSource: item }));
-
     nextTick(() => {
     nextTick(() => {
       unref(enumsListElRef).forEach((item) =>
       unref(enumsListElRef).forEach((item) =>
         item.formActionType?.setFieldsValue?.(item.dataSource)
         item.formActionType?.setFieldsValue?.(item.dataSource)
@@ -76,10 +74,7 @@
   const handleDeleteEnums = (item: EnumElItemType) => {
   const handleDeleteEnums = (item: EnumElItemType) => {
     const index = unref(enumsListElRef).findIndex((temp) => item.uuid === temp.uuid);
     const index = unref(enumsListElRef).findIndex((temp) => item.uuid === temp.uuid);
 
 
-    if (~index) {
-      enumsListElRef.value.splice(index, 1);
-      validateSameEnum();
-    }
+    ~index && enumsListElRef.value.splice(index, 1);
   };
   };
 
 
   const handleAddEnums = () => {
   const handleAddEnums = () => {
@@ -107,15 +102,17 @@
   <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>参考值</span>
+        <span class="mr-1 text-red-400">*</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>参考描述</span>
+        <span class="mr-1 text-red-400">*</span>
+        <span> 参考描述 </span>
         <Tooltip
         <Tooltip
-          title="支持中文、英文大小写、数字、下划线和短划线，必须以中文、英文或数字开头，不超过20个字符"
+          title="支持中文、英文大小写、日文、数字、下划线和短划线，必须以中文、英文或数字开头，不超过20个字符"
         >
         >
           <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>

+import { unref } from 'vue';
+import { useObjectModelFormContext } from '../useObjectModelFormContext';
 import { findDictItemByCode } from '/@/api/system/dict';
 import { findDictItemByCode } from '/@/api/system/dict';
 import { FormSchema } from '/@/components/Table';
 import { FormSchema } from '/@/components/Table';
 import { DictEnum } from '/@/enums/dictEnum';
 import { DictEnum } from '/@/enums/dictEnum';
@@ -37,66 +39,62 @@ function getActionTypeByObjectModelType(dataType: DataTypeEnum) {
   return list;
   return list;
 }
 }
 
 
-export const formSchemas: FormSchema[] = [
-  {
-    field: FormFieldsEnum.OBJECT_MODEL_TYPE,
-    component: 'Input',
-    label: '物模型数据类型',
-    ifShow: false,
-  },
-  {
-    field: FormFieldsEnum.REGISTER_ADDRESS,
-    component: 'RegisterAddressInput',
-    label: '寄存器地址',
-    changeEvent: 'update:value',
-    valueField: 'value',
-    rules: [{ message: '请输入寄存器地址', required: true, type: 'number' }],
-    componentProps: {
-      placeholder: '请输入寄存器地址',
-    },
-  },
-  {
-    field: FormFieldsEnum.DATA_TYPE,
-    component: 'ApiSelect',
-    label: '数据格式',
-    rules: [{ message: '请选择数据格式', required: true }],
-    defaultValue: RegisterDataTypeEnum.UN_SHORT,
-    componentProps: {
-      api: findDictItemByCode,
-      params: {
-        dictCode: DictEnum.REGISTER_DATA_FORMAT,
+export const getFormSchemas = (): FormSchema[] => {
+  const { getDataType } = useObjectModelFormContext();
+  return [
+    {
+      field: FormFieldsEnum.REGISTER_ADDRESS,
+      component: 'RegisterAddressInput',
+      label: '寄存器地址',
+      changeEvent: 'update:value',
+      valueField: 'value',
+      rules: [{ message: '请输入寄存器地址', required: true, type: 'number' }],
+      componentProps: {
+        placeholder: '请输入寄存器地址',
       },
       },
-      labelField: 'itemText',
-      valueField: 'itemValue',
-      placeholder: '请选择数据格式',
-      getPopupContainer: () => document.body,
     },
     },
-  },
-  {
-    field: FormFieldsEnum.ACTION_TYPE,
-    component: 'Select',
-    label: '操作类型',
-    rules: [{ message: '请选择操作类型', required: true }],
-    componentProps: ({ formModel }) => {
-      const objectModelType = formModel[FormFieldsEnum.OBJECT_MODEL_TYPE];
-      return {
-        options: getActionTypeByObjectModelType(objectModelType),
-        placeholder: '请选择操作类型',
+    {
+      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,
         getPopupContainer: () => document.body,
-      };
+      },
     },
     },
-  },
-  {
-    field: FormFieldsEnum.ZOOM_FACTOR,
-    component: 'InputNumber',
-    label: '缩放因子',
-    helpMessage: ['缩放因子不能为0,默认为1'],
-    defaultValue: 1,
-    ifShow: ({ model }) =>
-      ![DataTypeEnum.BOOL, DataTypeEnum.STRING].includes(model[FormFieldsEnum.OBJECT_MODEL_TYPE]),
-    componentProps: {
-      min: 1,
-      placeholder: '请输入缩放因子',
+    {
+      field: FormFieldsEnum.ACTION_TYPE,
+      component: 'Select',
+      label: '操作类型',
+      rules: [{ message: '请选择操作类型', required: true }],
+      componentProps: () => {
+        return {
+          options: getActionTypeByObjectModelType(unref(getDataType)),
+          placeholder: '请选择操作类型',
+          getPopupContainer: () => document.body,
+        };
+      },
+    },
+    {
+      field: FormFieldsEnum.ZOOM_FACTOR,
+      component: 'InputNumber',
+      label: '缩放因子',
+      helpMessage: ['缩放因子不能为0,默认为1'],
+      defaultValue: 1,
+      ifShow: ({ model }) =>
+        ![DataTypeEnum.BOOL, DataTypeEnum.STRING].includes(model[FormFieldsEnum.OBJECT_MODEL_TYPE]),
+      componentProps: {
+        min: 1,
+        placeholder: '请输入缩放因子',
+      },
     },
     },
-  },
-];
+  ];
+};

+export { default as ExtendDesc } from './index.vue';

@@ -4,19 +4,18 @@
   import { BasicForm, useForm } from '/@/components/Form';
   import { BasicForm, useForm } from '/@/components/Form';
   import { BasicModal } from '/@/components/Modal';
   import { BasicModal } from '/@/components/Modal';
   import { PlusCircleOutlined } from '@ant-design/icons-vue';
   import { PlusCircleOutlined } from '@ant-design/icons-vue';
-  import { FormFieldsEnum, formSchemas } from './config';
-  import { DataTypeEnum } from '/@/enums/objectModelEnum';
+  import { getFormSchemas } from './config';
+  import { ExtensionDesc } from '/@/api/device/model/modelOfMatterModel';
 
 
   const show = ref(false);
   const show = ref(false);
 
 
   const props = withDefaults(
   const props = withDefaults(
     defineProps<{
     defineProps<{
-      value?: object;
+      value?: ExtensionDesc;
       disabled?: boolean;
       disabled?: boolean;
-      dataType?: DataTypeEnum;
     }>(),
     }>(),
     {
     {
-      value: () => ({}),
+      value: () => ({} as ExtensionDesc),
     }
     }
   );
   );
 
 
@@ -24,7 +23,7 @@
 
 
   const [registerForm, { setFieldsValue, getFieldsValue, setProps, validate, resetFields }] =
   const [registerForm, { setFieldsValue, getFieldsValue, setProps, validate, resetFields }] =
     useForm({
     useForm({
-      schemas: formSchemas,
+      schemas: getFormSchemas(),
       showActionButtonGroup: false,
       showActionButtonGroup: false,
     });
     });
 
 
@@ -39,7 +38,6 @@
   const handleSubmit = async () => {
   const handleSubmit = async () => {
     await validate();
     await validate();
     const value = getFieldsValue();
     const value = getFieldsValue();
-    Reflect.deleteProperty(value, FormFieldsEnum.OBJECT_MODEL_TYPE);
     emit('update:value', value);
     emit('update:value', value);
     show.value = false;
     show.value = false;
   };
   };
@@ -47,22 +45,15 @@
   watch(show, async (value) => {
   watch(show, async (value) => {
     if (value) {
     if (value) {
       await nextTick();
       await nextTick();
-      setFieldsValue({ [FormFieldsEnum.OBJECT_MODEL_TYPE]: props.dataType });
+      setFieldsValue({ ...props.value });
     }
     }
   });
   });
-
-  watch(
-    () => props.value,
-    (value) => {
-      setFieldsValue(value);
-    }
-  );
 </script>
 </script>
 
 
 <template>
 <template>
   <section>
   <section>
     <Button type="link" @click="handleClick"><PlusCircleOutlined />新增扩展描述</Button>
     <Button type="link" @click="handleClick"><PlusCircleOutlined />新增扩展描述</Button>
-    <BasicModal title="扩展描述" v-model:visible="show" @ok="handleSubmit">
+    <BasicModal title="扩展描述" v-model:visible="show" @ok="handleSubmit" :show-ok-btn="!disabled">
       <BasicForm class="extension-form" @register="registerForm" />
       <BasicForm class="extension-form" @register="registerForm" />
     </BasicModal>
     </BasicModal>
   </section>
   </section>

+<script setup lang="ts">
+  import { BasicModal, useModalInner } from '/@/components/Modal';
+  import { ref, unref } from 'vue';
+  import { StructJSON } from '/@/api/device/model/modelOfMatterModel';
+  import { DataActionModeEnum } from '/@/enums/toolEnum';
+  import { DataTypeForm } from '../DataTypeForm';
+  import { DataTypeEnum } from '/@/enums/objectModelEnum';
+  import { useMessage } from '/@/hooks/web/useMessage';
+
+  const props = withDefaults(
+    defineProps<{ value?: StructJSON[]; dataType?: DataTypeEnum[]; mode?: DataActionModeEnum }>(),
+    {
+      value: () => [],
+      dataType: () => Object.values(DataTypeEnum),
+    }
+  );
+
+  const dataTypeFormRef = ref<InstanceType<typeof DataTypeForm>>();
+
+  const emits = defineEmits(['register', 'complete']);
+
+  const currentMode = ref(DataActionModeEnum.CREATE);
+  const [registerModal] = useModalInner(({ mode, record }: ModalParamsType<StructJSON>) => {
+    unref(dataTypeFormRef)?.resetFieldsValue?.();
+    currentMode.value = mode;
+    if (mode === DataActionModeEnum.UPDATE) {
+      unref(dataTypeFormRef)?.setFieldsValue?.(record);
+    }
+  });
+
+  const { createMessage } = useMessage();
+
+  const handleValidateHasSameIdentifier = (formValue?: StructJSON) => {
+    const { identifier } = formValue || {};
+    if (
+      unref(currentMode) === DataActionModeEnum.CREATE &&
+      props.value.filter((item) => item.identifier === identifier).length >= 1
+    ) {
+      const message = '存在一致的标识符';
+      createMessage.warn(message);
+      return Promise.reject(message);
+    }
+
+    return Promise.resolve();
+  };
+
+  const handleOk = async () => {
+    await unref(dataTypeFormRef)?.validate?.();
+    const value = unref(dataTypeFormRef)?.getFieldsValue?.();
+    await handleValidateHasSameIdentifier(value);
+    emits('complete', value);
+  };
+</script>
+
+<template>
+  <BasicModal
+    @register="registerModal"
+    title="新增参数"
+    @ok="handleOk"
+    :width="480"
+    :show-ok-btn="mode !== DataActionModeEnum.READ"
+  >
+    <DataTypeForm ref="dataTypeFormRef" :data-type="dataType" show-remark :mode="mode" />
+  </BasicModal>
+</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]
+        ),
+    },
+  ];
+};

+export { default as StructFormItem } from './index.vue';

+<script setup lang="ts">
+  import { Button, Divider } from 'ant-design-vue';
+  import { cloneDeep } from 'lodash';
+  import { toRaw, unref } from 'vue';
+  import CreateStructModal from './CreateStructModal.vue';
+  import { StructJSON } from '/@/api/device/model/modelOfMatterModel';
+  import { useModal } from '/@/components/Modal';
+  import { DataTypeEnum } from '/@/enums/objectModelEnum';
+  import { DataActionModeEnum } from '/@/enums/toolEnum';
+
+  const props = withDefaults(
+    defineProps<{
+      buttonName?: string;
+      disabled?: boolean;
+      value?: StructJSON[];
+      dataType?: DataTypeEnum[];
+      mode?: DataActionModeEnum;
+    }>(),
+    {
+      buttonName: '+ 新增参数',
+      value: () => [],
+      dataType: () => Object.values(DataTypeEnum),
+    }
+  );
+
+  const emits = defineEmits(['update:value']);
+
+  const [registerModal, { openModal, closeModal }] = useModal();
+
+  const handleOpenCreateModal = () => {
+    openModal(true, {
+      mode: DataActionModeEnum.CREATE,
+    } as ModalParamsType);
+  };
+
+  const handleEdit = (item: StructJSON) => {
+    openModal(true, {
+      mode: DataActionModeEnum.UPDATE,
+      record: cloneDeep(item),
+    } as ModalParamsType);
+  };
+
+  const handleDelete = (item: StructJSON) => {
+    const index = props.value.findIndex((temp) => item.identifier === temp.identifier);
+
+    if (~index) {
+      const _values = cloneDeep(props.value);
+      _values.splice(index, 1);
+      emits('update:value', _values);
+    }
+  };
+
+  const handleEditComplete = (value: StructJSON) => {
+    const _value = cloneDeep(toRaw(unref(props.value)));
+    const index = _value.findIndex((item) => item.identifier === value.identifier);
+    ~index ? _value.splice(index, 1, value) : _value.push(value);
+    emits('update:value', _value);
+    closeModal();
+  };
+</script>
+
+<template>
+  <section>
+    <main>
+      <div
+        v-for="item in value"
+        :key="item.identifier"
+        class="flex items-center justify-between px-2 py-1 mb-2 bg-blue-50 text-gray-600"
+      >
+        <div>
+          <span>参数名称:</span>
+          <span class="ml-1">{{ item.functionName }}</span>
+        </div>
+        <div>
+          <Button type="link" @click="handleEdit(item)">
+            {{ mode === DataActionModeEnum.READ ? '查看' : '编辑' }}
+          </Button>
+          <Divider type="vertical" />
+          <Button
+            type="link"
+            @click="handleDelete(item)"
+            :disabled="mode === DataActionModeEnum.READ"
+          >
+            删除
+          </Button>
+        </div>
+      </div>
+    </main>
+    <Button type="link" @click="handleOpenCreateModal" :disabled="mode === DataActionModeEnum.READ">
+      {{ buttonName }}
+    </Button>
+    <CreateStructModal
+      :value="value"
+      @register="registerModal"
+      @complete="handleEditComplete"
+      :dataType="dataType"
+      :mode="mode"
+    />
+  </section>
+</template>
+./index.config

+import { unref } from 'vue';
+import { createHexCommandRuleValidator } from '.';
+import { createFunctionNameFormItem, createIdentifierFormItem } from './DataTypeForm/config';
+import { useObjectModelFormContext } from './useObjectModelFormContext';
+import { findDictItemByCode } from '/@/api/system/dict';
+import { FormSchema } from '/@/components/Form';
+import {
+  ServiceCallTypeEnum,
+  ServiceCallTypeNameEnum,
+  TransportTypeEnum,
+} from '/@/enums/deviceEnum';
+import { DictEnum } from '/@/enums/dictEnum';
+import {
+  ObjectModelAccessModeEnum,
+  FunctionTypeEnum,
+  FunctionTypeNameEnum,
+  ObjectEventTypeEnum,
+} from '/@/enums/objectModelEnum';
+import { DataActionModeEnum } from '/@/enums/toolEnum';
+
+export enum FormFieldsEnum {
+  FUNCTION_TYPE = 'functionType',
+  FUNCTION_NAME = 'functionName',
+  IDENTIFIER = 'identifier',
+  DATA_TYPE = 'dataType',
+  ACCESS_MODE = 'accessMode',
+  VALUE_RANGE = 'valueRange',
+  STEP = 'step',
+  UNIT = 'unit',
+  UNIT_NAME = 'unitName',
+  REMARK = 'remark',
+  BOOL_CLOSE = 'boolClose',
+  BOOL_OPEN = 'boolOpen',
+  LENGTH = 'length',
+  EXTENSION_DESC = 'extensionDesc',
+  ENUMS_DATA = 'enumsData',
+  STRUCT_DATA = 'structData',
+
+  CALL_TYPE = 'callType',
+  SERVICE_COMMAND = 'serviceCommand',
+  INPUT_DATA = 'inputData',
+  OUTPUT_DATA = 'outputData',
+
+  EVENT_TYPE = 'eventType',
+
+  DATA_TYPE_FORM = 'dataTypeForm',
+}
+
+export enum FormFieldsNameEnum {
+  FUNCTION_TYPE = '功能类型',
+  FUNCTION_NAME = '功能名称',
+  IDENTIFIER = '功能标识符',
+  DATA_TYPE = '数据类型',
+  ACCESS_MODE = '读写类型',
+  VALUE_RANGE = '取值范围',
+  STEP = '步长',
+  UNIT = '单位',
+  UNIT_NAME = '单位名称',
+  REMARK = '备注',
+  BOOL_CLOSE = '0 - 关',
+  BOOL_OPEN = '1 - 开',
+  LENGTH = '数据长度(字节)',
+  EXTENSION_DESC = '拓展描述符',
+  ENUMS_DATA = '枚举项',
+  STRUCT_DATA = 'JSON对象',
+
+  CALL_TYPE = '调用方式',
+  SERVICE_COMMAND = '输入参数',
+  INPUT_DATA = '输入参数',
+  OUTPUT_DATA = '输出参数',
+
+  EVENT_TYPE = '事件类型',
+}
+
+export const getFormSchemas = ({
+  transportType,
+}: {
+  transportType?: string;
+  mode?: DataActionModeEnum;
+}): FormSchema[] => {
+  return [
+    {
+      field: FormFieldsEnum.FUNCTION_TYPE,
+      label: FormFieldsNameEnum.FUNCTION_TYPE,
+      component: 'Segmented',
+      defaultValue: FunctionTypeEnum.PROPERTIES,
+      required: true,
+      dynamicDisabled: () => {
+        const { getModalMode } = useObjectModelFormContext();
+        return unref(getModalMode) !== DataActionModeEnum.CREATE;
+      },
+      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.DATA_TYPE_FORM,
+      component: 'Input',
+      label: '',
+      ifShow: ({ model }) => model[FormFieldsEnum.FUNCTION_TYPE] === FunctionTypeEnum.PROPERTIES,
+      colSlot: FormFieldsEnum.DATA_TYPE_FORM,
+    },
+    createFunctionNameFormItem({
+      ifShow: ({ model }) => model[FormFieldsEnum.FUNCTION_TYPE] !== FunctionTypeEnum.PROPERTIES,
+    }),
+    createIdentifierFormItem({
+      ifShow: ({ model }) => model[FormFieldsEnum.FUNCTION_TYPE] !== FunctionTypeEnum.PROPERTIES,
+    }),
+    {
+      field: FormFieldsEnum.EXTENSION_DESC,
+      component: 'Input',
+      label: FormFieldsNameEnum.EXTENSION_DESC,
+      slot: FormFieldsEnum.EXTENSION_DESC,
+      ifShow: ({ model }) =>
+        transportType === TransportTypeEnum.TCP &&
+        ![FunctionTypeEnum.SERVICE, FunctionTypeEnum.EVENTS].includes(
+          model[FormFieldsEnum.FUNCTION_TYPE]
+        ),
+    },
+    {
+      field: FormFieldsEnum.ACCESS_MODE,
+      component: 'ApiRadioGroup',
+      label: FormFieldsNameEnum.ACCESS_MODE,
+      required: true,
+      ifShow: ({ model }) =>
+        ![FunctionTypeEnum.SERVICE, FunctionTypeEnum.EVENTS].includes(
+          model[FormFieldsEnum.FUNCTION_TYPE]
+        ),
+      defaultValue: ObjectModelAccessModeEnum.READ_AND_WRITE,
+      componentProps: {
+        placeholder: '请选择读写类型',
+        api: findDictItemByCode,
+        params: {
+          dictCode: DictEnum.READ_WRITE_TYP,
+        },
+        labelField: 'itemText',
+        valueField: 'itemValue',
+      },
+    },
+
+    // 服务
+    {
+      field: FormFieldsEnum.CALL_TYPE,
+      label: FormFieldsNameEnum.CALL_TYPE,
+      component: 'RadioGroup',
+      defaultValue: ServiceCallTypeEnum.ASYNC,
+      required: true,
+      ifShow: ({ model }) => model[FormFieldsEnum.FUNCTION_TYPE] === FunctionTypeEnum.SERVICE,
+      componentProps: () => {
+        return {
+          options: Object.keys(ServiceCallTypeEnum).map((value) => ({
+            label: ServiceCallTypeNameEnum[value],
+            value,
+          })),
+        };
+      },
+    },
+    {
+      field: FormFieldsEnum.SERVICE_COMMAND,
+      label: FormFieldsNameEnum.SERVICE_COMMAND,
+      component: 'Input',
+      required: true,
+      rules: [{ message: '输入参数为必填项', required: true }, ...createHexCommandRuleValidator()],
+      ifShow: ({ model }) =>
+        model[FormFieldsEnum.FUNCTION_TYPE] === FunctionTypeEnum.SERVICE &&
+        transportType === TransportTypeEnum.TCP,
+      componentProps: () => {
+        return {
+          placeholder: '请输入ASCII或HEX服务命令',
+        };
+      },
+    },
+    {
+      field: FormFieldsEnum.INPUT_DATA,
+      label: FormFieldsNameEnum.INPUT_DATA,
+      component: 'Input',
+      slot: FormFieldsEnum.INPUT_DATA,
+      changeEvent: 'update:value',
+      valueField: 'value',
+      required: true,
+      ifShow: ({ model }) =>
+        model[FormFieldsEnum.FUNCTION_TYPE] === FunctionTypeEnum.SERVICE &&
+        transportType !== TransportTypeEnum.TCP,
+    },
+
+    // 事件
+    {
+      field: FormFieldsEnum.EVENT_TYPE,
+      label: FormFieldsNameEnum.EVENT_TYPE,
+      required: true,
+      component: 'ApiRadioGroup',
+      defaultValue: ObjectEventTypeEnum.INFO,
+      ifShow: ({ model }) => model[FormFieldsEnum.FUNCTION_TYPE] === FunctionTypeEnum.EVENTS,
+      componentProps: () => {
+        return {
+          placeholder: '请选择事件类型',
+          api: findDictItemByCode,
+          params: {
+            dictCode: DictEnum.EVENT_TYPE,
+          },
+          labelField: 'itemText',
+          valueField: 'itemValue',
+          getPopupContainer: () => document.body,
+        };
+      },
+    },
+    {
+      field: FormFieldsEnum.OUTPUT_DATA,
+      label: FormFieldsNameEnum.OUTPUT_DATA,
+      component: 'Input',
+      slot: FormFieldsEnum.OUTPUT_DATA,
+      changeEvent: 'update:value',
+      valueField: 'value',
+      ifShow: ({ model }) =>
+        [FunctionTypeEnum.SERVICE, FunctionTypeEnum.EVENTS].includes(
+          model[FormFieldsEnum.FUNCTION_TYPE]
+        ),
+    },
+
+    {
+      field: FormFieldsEnum.REMARK,
+      label: FormFieldsNameEnum.REMARK,
+      component: 'InputTextArea',
+      componentProps: {
+        rows: 4,
+        maxLength: 100,
+        placeholder: '请输入描述',
+      },
+    },
+  ];
+};

+import { Rule } from '/@/components/Form';
+
+export { default as ObjectModelForm } from './index.vue';
+
+export function createHexCommandRuleValidator(): Rule[] {
+  return [
+    {
+      message: '请输入ASCII或HEX服务命令(0~9/A~F)',
+      validator(_rule, value, _callback) {
+        const reg = /^[\s0-9a-fA-F]+$/;
+
+        if (reg.test(value)) return Promise.resolve();
+        return Promise.reject('请输入ASCII或HEX服务命令(0~9/A~F)');
+      },
+    },
+  ];
+}