mini_program_gizwits_sdk 3.0.2-beta → 3.0.7

package/src/protocol/dataPoint.ts

@@ -0,0 +1,663 @@
+import productConfigFileManage from "../productConfigFileManage";
+import { arrayToString, checkHeader, fillString, getProtocolLen } from "./tool";
+
+export interface IDataPointConfig {
+  name: string;
+  protocolType: 'var_len' | 'standard';
+  entities: IDataPointEntitie[];
+}
+
+
+
+interface IDataPointEntitie {
+  display_name: string;
+  attrs: IDataPointAttr[];
+}
+
+interface IDataPointPosition {
+  byte_offset: number;
+  unit: 'bit' | 'byte';
+  len: number;
+  bit_offset: number;
+}
+
+type TDataType = 'bool' | 'uint8' | 'uint16' | 'uint32' | 'binary' | 'enum' | 'number';
+
+
+interface IUnitSpec {
+  addition: number;
+  max: number;
+  ratio: number;
+  min: number;
+}
+
+type TDataOptionType = 'status_writable' | 'status_readonly' | 'alert' | 'fault' | 'ALL';
+export interface IDataPointAttr {
+  display_name: string;
+  uint_spec: IUnitSpec;
+  name:string;
+  data_type: TDataType;
+  position: IDataPointPosition;
+  type: TDataOptionType;
+  id: number;
+  enum: string[];
+  desc: string;
+}
+
+// 从协议计算一个区块的数据
+const completeBlock = (cmd: string) => {
+  // 补0到8的倍数
+  const newCmd = fillString(cmd, Math.ceil(cmd.length / 8) * 8);
+  const data: number[] = [];
+  for (let i = 0; i < newCmd.length; i += 8) {
+    data.push(parseInt(newCmd.substring(i, i + 8), 2));
+  }
+  return data;
+};
+const fixType = (type: TDataType) => {
+  return type.indexOf('uint') !== -1 ? 'number' : type;
+};
+
+// 从数据点转换到二进制
+const getData = (type: TDataType, data: any, item: IDataPointAttr) => {
+  let cmd = '';
+  switch (type) {
+    case 'bool': {
+      const value = data[item.name] === true ? 1 : 0;
+      cmd = `${value}`;
+      break;
+    }
+    case 'enum': {
+      const index = item.enum.findIndex(itemEnum => data[item.name] === itemEnum);
+      const value = index === -1 ? 0 : index;
+      cmd = fillString(value.toString(2), item.position.len);
+      break;
+    }
+    case 'number': {
+      // 加上增量
+      let value = 0;
+      if (data[item.name] != undefined) {
+        value = Math.round(((data[item.name]) - item.uint_spec.addition) / item.uint_spec.ratio);
+      }
+      // 还有偏移
+      cmd = fillString(value.toString(2), item.position.len * 8);
+      break;
+    }
+    case 'binary': {
+      const value = data[item.name] || '';
+      // 数量不够在后面补0
+      const newValue = fillString(value, item.position.len * 2, true);
+      for (let i = 0; i < newValue.length / 2; i++) {
+        const newI = i * 2;
+        const string = newValue[newI] + newValue[newI + 1];
+        cmd += fillString(parseInt(string, 16).toString(2), 8);
+      }
+      break;
+    }
+    default: {
+      break;
+    }
+  }
+  // 补全长度
+  const length = item.position.len * (item.position.unit === 'byte' ? 8 : 1);
+  const offset = length - cmd.length;
+  if (offset > 0) {
+    for (let i = 0; i < offset; i++) {
+      cmd = `0${cmd}`;
+    }
+  }
+  return `${cmd}`;
+};
+
+// 从p0转换到数据点
+const getPData = (type: TDataType, valueString: string, item: IDataPointAttr) => {
+  switch (type) {
+    case 'bool': {
+      return valueString === '1';
+    }
+    case 'enum': {
+      const enumIndex = parseInt(valueString, 2);
+      return enumIndex;
+    }
+    case 'binary': {
+      // 补全长度
+      const length = item.position.len;
+      // 8个来解
+      let newValue = '';
+      for (let i = 0; i < valueString.length / 8; i++) {
+        const realI = i * 8;
+        const string = valueString.substring(realI, realI + 8);
+        newValue += fillString(parseInt(string, 2).toString(16), 2);
+      }
+      return fillString(newValue, length * 2, true);
+    }
+    case 'number': {
+      // 增量
+      // 还有偏移
+      // 浮点运算问题，先换成整数
+      return (parseInt(valueString, 2) / (1 / item.uint_spec.ratio) + item.uint_spec.addition);
+    }
+    default: {
+      return '';
+    }
+  }
+};
+
+
+interface IDataPointToP0Params {
+  config: IDataPointAttr[];
+  data: any;
+  isAdaptiveDatapoint: boolean;
+}
+/**
+ * json转 p0
+ * @param {*} config
+ * @param {*} data
+ * @param {boolean} isAdaptiveDatapoint  // 定长 或着 变长
+ */
+const DataPointToP = ({ config, data, isAdaptiveDatapoint }: IDataPointToP0Params) => {
+  const handleBoolEnum = (item, boolEnumString) => {
+    const type = fixType(item.data_type);
+    const cmdString = getData(type, data, item);
+    boolEnumString = cmdString + boolEnumString;
+    return boolEnumString;
+  };
+  const handleOther = (item, cmd) => {
+    const type = fixType(item.data_type);
+    const cmdString = getData(type, data, item);
+    cmd = cmd.concat(completeBlock(cmdString));
+    return cmd;
+  };
+
+  let attrsConfig = config;
+
+  /**
+   * 包头
+   */
+  const header = [0, 0, 0, 3];
+
+  /**
+   * 固定包头的headerCmd 和 flag
+   */
+  const flag = [0];
+  const headerCmd = [0, 147]; // cmd
+  const sn = [0,0,0,0];
+
+  // 业务指令命令字 定长上报是4，变长上报是14
+  let cmd = [0x1];
+
+  let flagString = '';
+  // 根据传入的数据算出flag
+
+  // 记录有效的数据点
+  const activeAttrs: IDataPointAttr[] = [];
+
+  // 找到可写
+  if (!isAdaptiveDatapoint) {
+    attrsConfig = attrsConfig.filter(item => item.type ==='status_writable')
+  }
+
+  attrsConfig.map((item) => {
+    if (data[item.name] !== undefined) {
+      flagString = `1${flagString}`;
+      activeAttrs.push(item);
+    } else {
+      flagString = `0${flagString}`;
+    }
+  });
+
+  if (isAdaptiveDatapoint) {
+    cmd = [0x11];
+    attrsConfig = activeAttrs;
+  }
+  // 补全
+  flagString = fillString(flagString, Math.ceil(flagString.length / 8) * 8);
+  for (let i = 0; i < (flagString.length / 8); i++) {
+    cmd.push(parseInt(flagString.substring(i * 8, (i + 1) * 8), 2));
+  }
+
+  let boolEnumString = '';
+  let preItem: IDataPointAttr;
+  try {
+    preItem = attrsConfig[0];
+  } catch (error) {
+    //
+  }
+
+  attrsConfig.map((item) => {
+    if (item.data_type === 'bool' || item.data_type === 'enum') {
+      // 只读、可写、alert、fault的字节都要分开
+      if (preItem.type !== item.type) {
+        // 先合并一次数据，再重新计算当前的bool和枚举
+        cmd = cmd.concat(completeBlock(boolEnumString));
+        boolEnumString = '';
+      }
+
+      boolEnumString = handleBoolEnum(item, boolEnumString);
+    } else {
+      if (boolEnumString.length > 0) {
+        cmd = cmd.concat(completeBlock(boolEnumString));
+        boolEnumString = '';
+      }
+      cmd = handleOther(item, cmd);
+    }
+
+    preItem = item;
+  });
+
+  if (boolEnumString.length > 0) {
+    cmd = cmd.concat(completeBlock(boolEnumString));
+    boolEnumString = '';
+  }
+
+  const flagToCmd = flag.concat(headerCmd).concat(sn).concat(cmd);
+  const flagToCmdLength = flagToCmd.length.toString(2);
+
+  /**
+   * 2进制 如果后面还有数据，最高位为1，没有数据的时候最高位为0
+   * 先把10进制转2进制，然后从右边开始
+   * 取7位，如果还有数据，flag为1 没有则0
+   * 以此类推
+   */
+
+  const lengthArr: number[] = [];
+  for (let i = flagToCmdLength.length; i > 0; i -= 7) {
+    const start = i - 7;
+    const end = i;
+    let lengthValue = flagToCmdLength.substring(start, end);
+    lengthValue = `${start > 0 ? '1' : '0'}${lengthValue}`;
+    lengthArr.push(parseInt(lengthValue, 2));
+  }
+
+  header.push(...lengthArr);
+  const packageData = header.concat(flagToCmd);
+  return packageData;
+};
+
+/**
+ * p0 转json
+ * @param {*} config
+ * @param {*} data
+ * 设备到app
+ * header len flag cmd sn action data
+ * action 0x04定长上报 0x05定长下发 0x11变长下发 0x14变长上报 0x12变长下发读数据点 0x02定长读数据点
+ */
+ 
+interface IPToDataPointParams {
+  config: IDataPointAttr[];
+  data: number[];
+}
+interface IRawData {
+  header: string;
+  len: string;
+  flag: string;
+  cmd: string;
+  sn: string;
+  action: string;
+  payload: string;
+}
+
+type messageType = 'APP2DEV' | 'DEV2APP' | 'UNKNOW';
+
+function PToDataPoint({ config = [], data }: IPToDataPointParams) {
+  let action: number;
+  let message = '';
+  let messageType: messageType;
+  const rawData: IRawData = { header: arrayToString(data.slice(0, 4)), flag: '', len: '', cmd: '', sn: '',action: '', payload: '' };
+
+  // 获取数据长度 0,0,0,3 到 0 这一段都是长度 校验长度可以忽略
+  const attrs = config;
+
+  let pointer = checkHeader(data);
+  // 先识别固定包头
+  if (pointer === false) {
+    // 数据不合法
+    return;
+  }
+
+  /**
+   * 插入len
+   * 计算方法，从第一位开始往下算，直到找到一个字节的最高位不为1
+   */
+  const nextData = data.slice(pointer, data.length);
+
+  const lengthIndex = getProtocolLen(nextData);
+  pointer += lengthIndex;
+
+  rawData.len = arrayToString(nextData.slice(0, lengthIndex));
+
+  // 跳过flag
+  pointer += 1;
+
+  rawData.flag = arrayToString(data.slice(pointer - 1, pointer));
+
+  // 跳过命令字
+  pointer += 2;
+  rawData.cmd = arrayToString(data.slice(pointer - 2, pointer));
+
+  rawData.sn = '';
+  // cmd 是93 的带sn
+  if (rawData.cmd === '0093' || rawData.cmd === '0094') {
+    rawData.sn = arrayToString(data.slice(pointer, pointer + 4));
+    // 跳过sn
+    pointer += 4;
+  }
+
+  rawData.action = arrayToString(data.slice(pointer, pointer + 1));
+
+  action = data[pointer];
+
+  // 跳过action
+  pointer += 1;
+
+  rawData.payload = arrayToString(data.slice(pointer, data.length));
+
+  // 开始处理数据
+  const businessData = data.slice(pointer, data.length);
+
+  let activeAttrs = attrs;
+
+  /**
+   * 定长下发时是可写数据点 上报是所有
+   */
+  if (action === 0x01) {
+    activeAttrs = attrs.filter(item => item.type === 'status_writable');
+  }
+
+  const flagAttrs = JSON.parse(JSON.stringify(activeAttrs));
+  const flagLen = Math.ceil(activeAttrs.length / 8);
+  let flag = businessData.slice(0, flagLen);
+  let cmdData = businessData.slice(flagLen, businessData.length);
+
+  // 设备定长上报才需要填充这段数据处理 这样就可以和变长统一行为，都有flag位
+  if (action === 0x03 || action === 0x04) {
+    flag = new Array(flagLen).fill(255);
+    cmdData = businessData;
+  }
+  // flag 转换成2进制，开始读取数据
+  let flagString = '';
+  flag.map((item) => {
+    flagString += fillString(item.toString(2), 8);
+    return null;
+  });
+
+  // 临时保存 如果是变长 需要过滤有效数据点
+  if (action >= 0x11 && action <= 0x14) {
+    activeAttrs = activeAttrs.filter((_item, index) => {
+      const flagLenTmp = (flagString.length - 1) - index;
+      return flagString[flagLenTmp] === '1';
+    });
+  }
+
+  // 写入默认值
+  if (rawData.cmd === '0090' || rawData.cmd === '0093') {
+    message = 'App 透传数据到 Dev';
+    messageType = 'APP2DEV';
+  } else if (rawData.cmd === '0091' || rawData.cmd === '0094') {
+    // 特殊处理 上报如果数据是空 就是应答
+    message = 'Dev 收到控制命令后应答到 App';
+    messageType = 'DEV2APP';
+  } else {
+    message = '非法数据';
+    messageType = 'UNKNOW';
+  }
+
+
+  let cmd = {};
+
+  /**
+   * 定长分三段计算
+   * 可读写
+   * 只读
+   * 故障
+   *
+   * 变长直接计算
+   */
+  switch (action) {
+    case 0x01: {
+      message = 'App 下发数据到 Dev';
+      cmd = getCmd({ attrs: flagAttrs, activeAttrs, flagString: flagString.split('').reverse().join(''), cmdData, accumulate: true });
+      break;
+    }
+    case 0x02: {
+      message = 'App 下发查询指令到 Dev';
+      // 直接返回
+      return { kvData: null, rawData, message, messageType };
+    }
+    case 0x03: {
+      message = 'Dev 回复查询指令到 App';
+      cmd = getCmd({ attrs: flagAttrs, activeAttrs, flagString: flagString.split('').reverse().join(''), cmdData, accumulate: true });
+      break;
+    }
+    case 0x04: {
+      message = 'Dev 上报状态到 App';
+      cmd = getCmd({ attrs: flagAttrs, activeAttrs, flagString: flagString.split('').reverse().join(''), cmdData, accumulate: true });
+      break;
+    }
+    case 0x05: {
+      message = 'App 透传数据到 Dev';
+      return { kvData: null, rawData, message, messageType };
+    }
+    case 0x06: {
+      message = 'Dev 透传数据到 App';
+      return { kvData: null, rawData, message, messageType };
+    }
+    case 0x07: {
+      message = 'App 下发控制子设备';
+      return { kvData: null, rawData, message, messageType };
+    }
+    case 0x08: {
+      message = 'App 读取子设备数据';
+      return { kvData: null, rawData, message, messageType };
+    }
+    case 0x09: {
+      message = 'Dev 中控回复ACK';
+      return { kvData: null, rawData, message, messageType };
+    }
+    case 0x0a: {
+      message = '子设备上报状态到 App';
+      return { kvData: null, rawData, message, messageType };
+    }
+    case 0x0b: {
+      message = 'App 下发添加子设备指令';
+      return { kvData: null, rawData, message, messageType };
+    }
+    case 0x0c: {
+      message = 'App 下发删除子设备';
+      return { kvData: null, rawData, message, messageType };
+    }
+    case 0x0d: {
+      message = 'App 获取中控子设备列表';
+      return { kvData: null, rawData, message, messageType };
+    }
+    case 0x0e: {
+      message = '中控响应字设备查询到 App';
+      return { kvData: null, rawData, message, messageType };
+    }
+    case 0x0f: {
+      message = '子设备列表变更通知到 App';
+      return { kvData: null, rawData, message, messageType };
+    }
+    case 0x10: {
+      message = 'Dev 子设备上下线状态变更通知';
+      return { kvData: null, rawData, message, messageType };
+    }
+    case 0x11: {
+      message = 'App 下发变长数据到 Dev';
+      cmd = calculationForType({ type: 'ALL', attrs: flagAttrs, activeAttrs, flagString: flagString.split('').reverse().join(''), cmdData }).cmd;
+      break;
+    }
+    case 0x12: {
+      message = 'App 下发变长查询到 Dev';
+      // 直接返回
+      return { kvData: null, rawData, message, messageType };
+    }
+    case 0x13: {
+      message = 'Dev 变长回复查询指令到 App';
+      cmd = calculationForType({ type: 'ALL', attrs: flagAttrs, activeAttrs, flagString: flagString.split('').reverse().join(''), cmdData }).cmd;
+      break;
+    }
+    case 0x14: {
+      message = 'Dev 变长上报状态到 App';
+      cmd = calculationForType({ type: 'ALL', attrs: flagAttrs, activeAttrs, flagString: flagString.split('').reverse().join(''), cmdData }).cmd;
+      break;
+    }
+    case 0x72: {
+      message = 'App 向网关发送数据';
+      return { kvData: null, rawData, message, messageType };
+    }
+    case 0x73: {
+      message = 'Dev 网关上报数据到 App';
+      return { kvData: null, rawData, message, messageType };
+    }
+    case 0x74: {
+      message = 'App 通知网关删除子设备';
+      return { kvData: null, rawData, message, messageType };
+    }
+    default: {
+      // 如果都不匹配
+      return { kvData: null, rawData, message, messageType };
+    }
+  }
+
+  if (attrs.length === 0) {
+    // 没有数据点直接返回
+    return { kvData: null, rawData, message, messageType };
+  }
+  return { kvData: cmd, rawData, message, messageType };
+}
+
+function isMatchType(type, targetType) {
+  return type === targetType || type === 'ALL';
+}
+
+function getCmd({ attrs, activeAttrs, flagString, cmdData, accumulate }) {
+  const list: TDataOptionType[] = ['status_writable', 'status_readonly', 'alert', 'fault'];
+  let cmdDataConsumeLenght = 0;
+  let kv = {};
+  let flagStart = 0;
+  list.map((item) => {
+    const flagLength = attrs.filter(attrItem => isMatchType(item, attrItem.type)).length;
+    const { cmd, cmdDataLength } = calculationForType({
+      type: item,
+      attrs: attrs.slice(flagStart, flagStart + flagLength),
+      activeAttrs,
+      flagString: flagString.substring(flagStart, flagStart + flagLength),
+      cmdData: cmdData.slice(cmdDataConsumeLenght, cmdData.length),
+      accumulate,
+    });
+    cmdDataConsumeLenght += cmdDataLength;
+    kv = { ...kv, ...cmd };
+    flagStart += flagLength;
+    return null;
+  });
+  return kv;
+}
+
+/**
+ * 根据类型
+ * status_writable
+ * status_readonly
+ * alert fault
+ */
+interface ICalculationForTypeParams {
+  type: TDataOptionType;
+  attrs: IDataPointAttr[];
+  activeAttrs: IDataPointAttr[];
+  cmdData: number[];
+  flagString: string;
+  accumulate?: boolean;
+}
+function calculationForType({ type, attrs, activeAttrs, cmdData, flagString, accumulate }: ICalculationForTypeParams) {
+  let cmdDataLength = 0;
+  let boolEnumLength = 0;
+  let otherLength = 0;
+  activeAttrs.map((item) => {
+    // 合并布尔和枚举的长度
+    const isMatch = isMatchType(type, item.type);
+    if (isMatch) {
+      const bitLength = item.position.len * (item.position.unit === 'bit' ? 1 : 8);
+      if (item.data_type === 'bool' || item.data_type === 'enum') {
+        boolEnumLength += bitLength;
+      } else {
+        otherLength += bitLength;
+      }
+    }
+    return null;
+  });
+  cmdDataLength = Math.ceil(otherLength / 8) + Math.ceil(boolEnumLength / 8);
+  const cmd = calculationCmdData({
+    attrs,
+    flagString,
+    boolEnumLength: Math.ceil(boolEnumLength / 8),
+    cmdData,
+    accumulate,
+  });
+  return { cmdDataLength, cmd };
+}
+
+/**
+ * 根据 accumulate 判断是定长还是变成 true 定长
+ * 变长的解析顺序不同
+ */
+function calculationCmdData({ attrs, flagString, boolEnumLength, cmdData, accumulate }) {
+  const cmd = {};
+  let bitOffset = 0;
+  for (let i = 0; i < flagString.length; i++) {
+    if (attrs[i] && flagString[i] === '1') {
+      const { data_type, position: { len } } = attrs[i];
+      let valueString = '';
+      // 有效 如果是布尔或者枚举 需要特别计算
+      if (data_type === 'bool' || data_type === 'enum') {
+        let boolEnumString = '';
+        cmdData.slice(0, boolEnumLength).map((item) => {
+          boolEnumString += fillString(item.toString(2), 8);
+          return null;
+        });
+        const end = boolEnumString.length - bitOffset;
+        valueString = boolEnumString.substring(end - len, end);
+        bitOffset += len;
+      } else {
+        // 普通的值
+        const start = boolEnumLength;
+        const end = boolEnumLength + len;
+        cmdData.slice(start, end).map((item) => {
+          valueString += fillString(item.toString(2), 8);
+          return null;
+        });
+        boolEnumLength += len;
+      }
+      // 再根据不同的数据格式，进行转换
+      const type = fixType(data_type);
+      cmd[attrs[i].name] = getPData(type, valueString, attrs[i]);
+    } else if (accumulate) {
+      // 定长需要累加
+      const attr = attrs[i] || { position: { len: 0 } };
+      if (attr.position.unit === 'byte') {
+        boolEnumLength += attr.position.len;
+      } else {
+        bitOffset += attr.position.len;
+      }
+    }
+  }
+  return cmd;
+}
+
+
+const unpack = async (data: number[], pk: string) => {
+  const productConfig = await productConfigFileManage.getConfigFile(pk);
+  if (productConfig) {
+    return PToDataPoint({config: (await productConfig).entities[0].attrs, data})
+  }
+  return null;
+}
+const pack = async (data: object, pk: string) => {
+  const productConfig = await productConfigFileManage.getConfigFile(pk);
+  if (productConfig) {
+    const isAdaptiveDatapoint = productConfig.protocolType === 'var_len';
+    return DataPointToP({data, config: (await productConfig).entities[0].attrs, isAdaptiveDatapoint});
+  }
+  return null;
+}
+
+export {pack, unpack};