perf: 优化物模型自定义和ModBUS属性下发方式

@@ -166,6 +166,7 @@ export interface DeviceRecord {
   id: string;
   id: string;
   creator: string;
   creator: string;
   createTime: string;
   createTime: string;
+  codeType?: string;
   name: string;
   name: string;
   tenantId: string;
   tenantId: string;
   transportType: string;
   transportType: string;
@@ -199,6 +200,8 @@ export interface DeviceModelOfMatterAttrs {
   identifier: string;
   identifier: string;
   accessMode: string;
   accessMode: string;
   detail: StructJSON;
   detail: StructJSON;
+  deviceDetail?: DeviceRecord;
+  extensionDesc?: any;
 }
 }
 
 
 export interface DeviceStateLogModel {
 export interface DeviceStateLogModel {

@@ -238,7 +238,7 @@
   const handleSendCommandModal = (data: DataSource) => {
   const handleSendCommandModal = (data: DataSource) => {
     openSendCommandModal(true, {
     openSendCommandModal(true, {
       mode: DataActionModeEnum.READ,
       mode: DataActionModeEnum.READ,
-      record: { ...toRaw(data.detail) },
+      record: { ...toRaw(data.detail), deviceDetail: props.deviceDetail as any },
     } as ModalParamsType);
     } as ModalParamsType);
   };
   };
 
 

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

@@ -10,6 +10,9 @@
   import { sendCommandOneway } from '/@/api/dataBoard';
   import { sendCommandOneway } from '/@/api/dataBoard';
   import { useMessage } from '/@/hooks/web/useMessage';
   import { useMessage } from '/@/hooks/web/useMessage';
   import { unref } from 'vue';
   import { unref } from 'vue';
+  import { genModbusCommand } from '/@/api/task';
+  import { TaskTypeEnum } from '/@/views/task/center/config';
+  import { SingleToHex, formSchemasConfig } from './config';
 
 
   defineEmits(['register']);
   defineEmits(['register']);
   const props = defineProps<{ deviceId: string; deviceName: string }>();
   const props = defineProps<{ deviceId: string; deviceName: string }>();
@@ -24,45 +27,93 @@
 
 
   const keys = ref<string[]>([]);
   const keys = ref<string[]>([]);
 
 
-  const [register] = useModalInner((params: ModalParamsType<DeviceModelOfMatterAttrs>) => {
+  const modBUSForm = ref<any>({});
+  const isShowModBUS = ref<Boolean>(false);
+  const formField = ref('');
+
+  const [register] = useModalInner(async (params: ModalParamsType<DeviceModelOfMatterAttrs>) => {
     const { record } = params;
     const { record } = params;
-    const { name, detail, identifier } = record;
+    const { name, detail, identifier, deviceDetail, extensionDesc } = record;
     const { dataType } = detail;
     const { dataType } = detail;
     const { type } = dataType || {};
     const { type } = dataType || {};
+    const { codeType } = deviceDetail || {};
+    const { registerAddress, actionType } = extensionDesc || {};
+    formField.value = identifier;
 
 
     let schemas = [{ dataType: dataType, identifier, functionName: name } as StructJSON];
     let schemas = [{ dataType: dataType, identifier, functionName: name } as StructJSON];
 
 
     if (type === DataTypeEnum.IS_STRUCT) {
     if (type === DataTypeEnum.IS_STRUCT) {
       schemas = dataType?.specs as StructJSON[];
       schemas = dataType?.specs as StructJSON[];
     }
     }
+    if (codeType == TaskTypeEnum.MODBUS) {
+      isShowModBUS.value = true;
+      modBUSForm.value = {
+        crc: 'CRC_16_LOWER',
+        deviceCode: '01',
+        method: actionType,
+        registerAddress,
+        registerNumber: 1,
+        registerValues: [],
+      };
+      setProps({ schemas: formSchemasConfig(schemas[0]) });
+    } else {
+      isShowModBUS.value = false;
+      const formSchemas = genForm(schemas);
+      keys.value = schemas.map((item) => {
+        return item.identifier!;
+      });
+      setProps({ schemas: formSchemas });
+    }
 
 
-    const formSchemas = genForm(schemas);
-
-    keys.value = schemas.map((item) => {
-      return item.identifier!;
-    });
-    setProps({ schemas: formSchemas });
     resetFields();
     resetFields();
   });
   });
 
 
+  const getArray = (values) => {
+    const str = values.replace(/\s+/g, '');
+    const array: any = [];
+
+    for (let i = 0; i < str.length; i += 4) {
+      const chunk = parseInt(str.substring(i, i + 4), 16);
+      array.push(chunk);
+    }
+    return array;
+  };
+
   const { createMessage } = useMessage();
   const { createMessage } = useMessage();
   const loading = ref(false);
   const loading = ref(false);
   const handleSend = async () => {
   const handleSend = async () => {
     try {
     try {
       loading.value = true;
       loading.value = true;
       if (!props.deviceId) return;
       if (!props.deviceId) return;
-      const _value = getFieldsValue();
-      const value = unref(keys).reduce((prev, next) => {
-        return { ...prev, [next]: _value[next] };
-      }, {});
+      const sendValue = ref({});
+      if (unref(isShowModBUS)) {
+        //判断tcp类型 标识符是自定义还是ModBus
+        const oldValue = getFieldsValue()[unref(formField)];
+        const newValue = getArray(SingleToHex(oldValue));
+
+        modBUSForm.value.registerValues =
+          unref(modBUSForm).method != '16' ? [newValue[0]] : newValue;
+        modBUSForm.value.registerNumber = unref(modBUSForm).method != '16' ? 1 : 2;
+
+        sendValue.value = await genModbusCommand(unref(modBUSForm));
+      } else {
+        const _value = getFieldsValue();
+
+        sendValue.value = unref(keys).reduce((prev, next) => {
+          return { ...prev, [next]: _value[next] };
+        }, {});
+      }
+
       await sendCommandOneway({
       await sendCommandOneway({
         deviceId: props.deviceId,
         deviceId: props.deviceId,
         value: {
         value: {
           persistent: true,
           persistent: true,
           method: 'methodThingskit',
           method: 'methodThingskit',
-          params: {
-            ...value,
-          },
+          params: unref(isShowModBUS)
+            ? unref(sendValue)
+            : {
+                ...unref(sendValue),
+              },
         },
         },
       });
       });
       createMessage.success('属性下发成功~');
       createMessage.success('属性下发成功~');

@@ -69,7 +69,6 @@
         return hexToDec(props.minValue);
         return hexToDec(props.minValue);
       }
       }
     }
     }
-
     if (unref(inputType) === AddressTypeEnum.DEC)
     if (unref(inputType) === AddressTypeEnum.DEC)
       return `0x${decToHex(unref(getInputValue)!)
       return `0x${decToHex(unref(getInputValue)!)
         .toString()
         .toString()