@ray-js/lamp-schedule-core 1.0.0-beta-1

package/lib/dpParser/rhythms.js

@@ -0,0 +1,116 @@
+import "core-js/modules/esnext.iterator.map.js";
+import { generateDpStrStep, numToHexString } from '@ray-js/panel-sdk/lib/utils';
+import { padStart } from 'lodash-es';
+import { defaultValue } from '../config/rhythms/defaultValue';
+import { scheduleDpCodes } from '../config/dpCodes';
+import { scheduleLogger as ScheduleLogger } from '../utils/ScheduleLogger';
+import { getSupportIns } from '../hooks/useCommonSupport';
+const {
+  RHYTHM_MODE,
+  TEMPERATURE
+} = scheduleDpCodes;
+const to16 = num => {
+  return numToHexString(num);
+};
+export default class RhythmFormatter {
+  constructor() {
+    let uuid = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : RHYTHM_MODE;
+    let defaultValue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+    this.defaultValue = {};
+    this.uuid = uuid;
+    if (defaultValue) {
+      this.defaultValue = defaultValue;
+    }
+  }
+  parser() {
+    let dpValue = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+    const support = getSupportIns();
+    if (!support || !dpValue || dpValue.length <= 10 || (dpValue.length - 10) % 18 !== 0) {
+      return {
+        version: 0,
+        power: false,
+        mode: 0,
+        weeks: [1, 1, 1, 1, 1, 1, 1],
+        number: 1,
+        rhythms: defaultValue
+      };
+    }
+    const step = generateDpStrStep(dpValue);
+    const version = step().value;
+    const power = !!step().value;
+    const mode = step().value;
+    const weekNum = step().value;
+    const weeks = padStart(Number(weekNum).toString(2), 8, '0').split('').reverse().map(v => parseInt(v, 10));
+    const number = step().value;
+    const rhythms = [];
+    for (let i = 0; i < number; i++) {
+      const valid = !!step().value;
+      const hour = step().value;
+      const minute = step().value;
+      const hue1 = step().value;
+      const hue2 = step().value;
+      const saturation = step().value;
+      const v = step().value;
+      const brightness = step().value;
+      const temperature = step().value;
+      rhythms.push({
+        power: valid,
+        hour,
+        minute,
+        hue: hue1 * 100 + hue2,
+        saturation,
+        value: v,
+        brightness,
+        temperature
+      });
+    }
+    return {
+      version,
+      power,
+      mode,
+      weeks,
+      number,
+      rhythms
+    };
+  }
+  formatter(data) {
+    const support = getSupportIns();
+    if (!data || !support) {
+      ScheduleLogger.error('协议解析 rhythms formatter =====', '数据为空');
+      return '';
+    }
+    const {
+      version,
+      power,
+      mode,
+      weeks,
+      rhythms
+    } = data;
+    ScheduleLogger.debug('协议解析 rhythms formatter:', data);
+    const weekStr = [...weeks].reverse().join('').padStart(8, '0');
+    const number = rhythms.length;
+    const weeksValue = parseInt(weekStr, 2);
+    const isSupportWhiteTemp = support.isSupportDp(TEMPERATURE);
+    return `${to16(version)}${to16(Number(power))}${to16(mode)}${to16(weeksValue)}${to16(number)}${rhythms.map(_ref => {
+      let {
+        power,
+        hour,
+        minute,
+        hue,
+        saturation,
+        value: v,
+        temperature,
+        brightness
+      } = _ref;
+      const hue1 = Math.floor(hue / 100); // 百分位
+
+      // 十位与个位
+      // 不支持色温时，色温值传100
+      return `${to16(Number(power))}${to16(hour)}${to16(minute)}${to16(hue1)}${to16(hue % 100)}${to16(saturation)}${to16(v)}${to16(brightness)}${to16(isSupportWhiteTemp ? temperature : 100)}`;
+    }).join('')}`;
+  }
+}
+export const rhythmParser = new RhythmFormatter();
+export const getRhythmParser = () => {
+  return rhythmParser;
+};

package/lib/dpParser/rtcTimer.d.ts

@@ -0,0 +1,17 @@
+import { TRtcTimer } from '../types';
+export declare class RtcTimerFormatter {
+    defaultValue: TRtcTimer;
+    constructor(defaultValue?: null);
+    equal(source: any, target: any): boolean;
+    parser(val?: string): TRtcTimer;
+    to16(value: any, length: any): string;
+    formatter(data: TRtcTimer): string;
+}
+export declare const rtcTimerParser: {
+    parser: (dpValue: string) => Record<string, any>;
+    formatter: (data: TRtcTimer) => string;
+};
+export declare const getRtcParser: () => {
+    parser: (dpValue: string) => Record<string, any>;
+    formatter: (data: TRtcTimer) => string;
+};

package/lib/dpParser/rtcTimer.js

@@ -0,0 +1,300 @@
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.for-each.js";
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable camelcase */
+import { padEnd, padStart } from 'lodash-es';
+import { generateDpStrStep, numToHexString } from '@ray-js/panel-sdk/lib/utils';
+import { scheduleDpCodes } from '../config/dpCodes';
+import { scheduleLogger as ScheduleLogger } from '../utils/ScheduleLogger';
+import { numToBinStrPad8 } from './utils';
+import { getDpCodeByDpId } from '../utils/ScheduleUtils';
+const {
+  RTC_TIMER
+} = scheduleDpCodes;
+
+// 分钟数转 "HH:mm"
+const minuteToTime = minute => {
+  const hour = Math.floor(minute / 60);
+  return `${padStart(hour.toString(), 2, '0')}:${padStart((minute % 60).toString(), 2, '0')}`;
+};
+const _defaultValue = {
+  timerId: '1',
+  status: false,
+  loops: '1111111',
+  time: '08:30',
+  dps: {
+    switch_led: false
+  }
+};
+var EDpCodes = /*#__PURE__*/function (EDpCodes) {
+  EDpCodes["bright_value"] = "bright_value";
+  EDpCodes["colour_data"] = "colour_data";
+  EDpCodes["temp_value"] = "temp_value";
+  EDpCodes["switch_led"] = "switch_led";
+  return EDpCodes;
+}(EDpCodes || {});
+export class RtcTimerFormatter {
+  constructor() {
+    let defaultValue = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+    // @ts-ignore
+    this.defaultValue = _defaultValue;
+    if (defaultValue) {
+      this.defaultValue = defaultValue;
+    }
+  }
+  equal(source, target) {
+    return source === target;
+  }
+  parser() {
+    let val = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+    if (!val) {
+      ScheduleLogger.warn('RtcTimerFormatter parser，value is empty, return defaultValue', this.defaultValue);
+      return this.defaultValue;
+    }
+    const {
+      length
+    } = val;
+    const mixLightLen = 26; // 混光长度
+    const colourLightLen = 22; // 彩光长度
+    const brightLightLen = 18; // 白光长度
+    const powerLen = 14; // 纯开关长度
+
+    // 删除定时
+
+    if (length !== 4 && length !== powerLen && length !== brightLightLen && length !== colourLightLen && length !== mixLightLen) {
+      // 数据位数不定, 可能是14位或18位22位26位, 删除定时指令为4位
+      ScheduleLogger.warn('RtcTimerFormatter parser fail:', RTC_TIMER, '=>', val);
+      return this.defaultValue;
+    }
+    const step = generateDpStrStep(val);
+    if (length === powerLen || length === brightLightLen || length === colourLightLen || length === mixLightLen) {
+      const id = step(2); //  // 定时任务ID, ABBBBBBB：A：定时任务开关，0-关闭，1-开启；BBBBBBB：定时ID：1-10，最多支持10条
+      const idBinaryStr = numToBinStrPad8(id.value); // 转为二进制的八位 => ABBBBBBB
+      const status = idBinaryStr.slice(0, 1) === '1'; // 0-关闭，1-开启
+      const timerId = parseInt(idBinaryStr.slice(1), 2); // 定时ID：1-10
+
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      step(2).value; // 定时类型, 普通定时选择：0x01
+      const repeatInt = step(2).value; // 单次定时任务bit0-bit6全为0，bit0-bit6某位为1时，表示对应周几周期定时 bit0 => 周日
+      const loops = padEnd(repeatInt.toString(2).split('').reverse().join(''), 7, '0');
+
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      step(2).value; // 时间类型 => 0x00：精确时间 0x01：日出前 0x02：日出后 0x03：日落前 0x04：日落后 0x05：倒计时
+      const time = step(4).value; // 时间 => 一天为 24H*60=1440
+
+      /**
+       * A：设备动作
+       * A=0x00，关灯，
+         A=0x01，开灯，
+         A=0x02，白光，
+         A=0x03，彩光，
+         A=0x04，混光，
+         A=0x05，情景，
+         A=0x06，节能，
+         A=0x07，太阳能
+      */
+      step(2).value;
+      let dps = {}; // 设备动作
+      // 白光模式 dp
+      if (length === brightLightLen) {
+        const bright_value = step(2).value;
+        const temp_value = step(2).value;
+        dps = {
+          [EDpCodes.bright_value]: bright_value,
+          [EDpCodes.temp_value]: temp_value
+        };
+      } else if (length === colourLightLen) {
+        // 彩光模式dp
+        const hue = step(4).value;
+        const saturation = step(2).value;
+        const _value = step(2).value;
+        dps = {
+          [EDpCodes.colour_data]: {
+            hue,
+            saturation,
+            value: _value
+          }
+        };
+      } else if (length === mixLightLen) {
+        // 混光模式
+        const hue = step(4).value;
+        const saturation = step(2).value;
+        const _value = step(2).value;
+        const bright_value = step(2).value;
+        const temp_value = step(2).value;
+        dps = {
+          [EDpCodes.colour_data]: {
+            hue,
+            saturation,
+            value: _value
+          },
+          [EDpCodes.bright_value]: bright_value,
+          [EDpCodes.temp_value]: temp_value
+        };
+      } else {
+        // 开关灯模式
+        // 开灯
+        // 01
+        const startDpDataInt = step(2).value;
+        const startDpDataHex = this.to16(startDpDataInt, 2);
+        const switch_led = startDpDataHex.slice(0, 2) === '01';
+        dps = {
+          [EDpCodes.switch_led]: switch_led
+        };
+      }
+      return {
+        timerId: `${timerId}`,
+        status,
+        loops,
+        time: minuteToTime(time),
+        dps
+      };
+    }
+
+    // 删除时 dp 数据
+    const id = step(2).value;
+    const idBinaryStr = numToBinStrPad8(id);
+    const status = idBinaryStr.slice(0, 1) === '1';
+    const timerId = parseInt(idBinaryStr.slice(1), 2);
+    return {
+      timerId: `${timerId}`,
+      status
+    };
+  }
+  to16(value, length) {
+    return numToHexString(value, length);
+  }
+  formatter(data) {
+    if (typeof data === 'string') {
+      return data;
+    }
+    // 自定义格式转为16进制
+    const {
+      timerId,
+      // 定时任务ID
+      status,
+      // type, // 定时类型,普通定时选择：0x01
+      loops,
+      // 单次定时任务bit0-bit6全为0，bit0-bit6某位为1时，表示对应周几周期定时，0 => 周日
+      // startTimeType, // 定时任务开始时间类型，0x00 => 固定时间
+      time,
+      dps
+    } = data;
+    ScheduleLogger.debug('rtcTimer formatter data:', data);
+    if (loops) {
+      const _dps = {};
+      Object.keys(dps).forEach(key => {
+        // eslint-disable-next-line no-self-compare
+        if (+key === +key) {
+          const dpCode = getDpCodeByDpId(key);
+          dpCode && (_dps[dpCode] = dps[key]);
+        } else {
+          _dps[key] = dps[key];
+        }
+      });
+      const statusStr = status ? '1' : '0';
+      const timerIdStr = padStart(Number(timerId).toString(2), 7, '0');
+      const idStr = this.to16(parseInt(`${statusStr}${timerIdStr}`, 2), 2);
+      const typeStr = this.to16('01', 2);
+      const repeatStr = this.to16(parseInt(loops.split('').reverse().join(''), 2), 2);
+      const startTimeTypeStr = this.to16('00', 2);
+      let timeNum = +time;
+      if (isNaN(time) && typeof time === 'string') {
+        const [min, second] = time === null || time === void 0 ? void 0 : time.split(':');
+        timeNum = +min * 60 + Number(second);
+      }
+      const startTimeStr = this.to16(timeNum, 4);
+      let dpDataStr;
+      /**
+       * ABCDEFG 7字节； A：设备动作；BCDEFG：动作参数；
+       * A=0x00，关灯，BCDEFG无效；
+       * A=0x01，开灯，BCDEFG无效；
+       * A=0x02，白光，B：亮度，1-100，C：色温，0-100，DEFG无效；
+       * A=0x03，彩光，BC：色度，0-360，D：饱和度，0-100，E：彩光亮度，0-100，FG无效；
+       * A=0x04，混光，RGBCW全亮，BC：色度，0-360，D：饱和度，0-100，E：彩光亮度，1-100，F：白光亮度，1-100，G：色温，0-100；
+       * A=0x05，情景，B：场景ID，0-15，CDEFG无效；
+       * A=0x06，节能，B：场景ID，0-15，C：节能开关，0-关，1-开，DEFG无效；
+       * A=0x07，太阳能，BC：色度，0-360，D：饱和度，0-100，E：彩光亮度，1-100，F：白光亮度，1-100，G：色温，0-100；
+       * A=0x08，执行定时前状态，BCDEFG无效；
+       */
+      if (_dps[EDpCodes.switch_led] === false) {
+        dpDataStr = '00';
+      } else if (Object.keys(_dps).includes(EDpCodes.colour_data) && Object.keys(_dps).includes(EDpCodes.temp_value)) {
+        const bright_value = _dps[EDpCodes.bright_value];
+        const temp_value = _dps[EDpCodes.temp_value];
+        const {
+          hue,
+          saturation,
+          value
+        } = _dps[EDpCodes.colour_data];
+        const hueStr = this.to16(hue, 4);
+        const saturationStr = this.to16(saturation, 2);
+        const valueStr = this.to16(value, 2);
+        const brightStr = this.to16(bright_value, 2);
+        const tempStr = this.to16(temp_value, 2);
+        dpDataStr = `04${hueStr}${saturationStr}${valueStr}${brightStr}${tempStr}`;
+      } else if (Object.keys(_dps).includes(EDpCodes.colour_data)) {
+        const {
+          hue = 0,
+          saturation = 100,
+          value = 100
+        } = _dps[EDpCodes.colour_data];
+        const hueStr = this.to16(hue, 4);
+        const saturationStr = this.to16(saturation, 2);
+        const valueStr = this.to16(value, 2);
+        dpDataStr = `03${hueStr}${saturationStr}${valueStr}`;
+      } else if (Object.keys(_dps).includes(EDpCodes.bright_value)) {
+        var _dps$EDpCodes$bright_, _dps$EDpCodes$temp_va;
+        const bright_value = (_dps$EDpCodes$bright_ = _dps[EDpCodes.bright_value]) !== null && _dps$EDpCodes$bright_ !== void 0 ? _dps$EDpCodes$bright_ : 100;
+        const temp_value = (_dps$EDpCodes$temp_va = _dps[EDpCodes.temp_value]) !== null && _dps$EDpCodes$temp_va !== void 0 ? _dps$EDpCodes$temp_va : 0;
+        const brightStr = this.to16(bright_value, 2);
+        const temperatureStr = this.to16(temp_value, 2);
+        dpDataStr = `02${brightStr}${temperatureStr}`;
+      } else {
+        const powerStr = _dps[EDpCodes.switch_led] ? '01' : '00';
+        dpDataStr = `${powerStr}`;
+      }
+      const _res = `${idStr}${typeStr}${repeatStr}${startTimeTypeStr}${startTimeStr}${dpDataStr}`;
+      ScheduleLogger.debug('rtcTimer formatter dpStr1:', dpDataStr);
+      ScheduleLogger.debug('rtcTimer formatter dpStr2:', _res);
+      return _res;
+    }
+    const statusStr = status ? '1' : '0';
+    const timerIdStr = padStart(Number(timerId).toString(2), 7, '0');
+    const idStr = this.to16(parseInt(`${statusStr}${timerIdStr}`, 2), 2);
+    const _res = `${idStr}00`;
+    ScheduleLogger.debug('rtcTimer remove formatter2 data:', _res);
+    return _res;
+  }
+}
+export const rtcTimerParser = new RtcTimerFormatter();
+export const getRtcParser = () => {
+  return rtcTimerParser;
+};
+
+// if (isInIDEFun()) {
+//   const dps = {
+//     // switch_led: true,
+//     bright_value: 96,
+//     temp_value: 95,
+//     colour_data: {
+//       hue: 338,
+//       saturation: 0,
+//       value: 100,
+//     },
+//   };
+//   const demoData = {
+//     ..._defaultValue,
+//     dps,
+//   };
+
+//   const newRtcStr = rtcTimerParser.formatter(demoData);
+
+//   const newRtcData = rtcTimerParser.parser(newRtcStr);
+
+//   if (!isEqual(demoData, newRtcData)) {
+//     console.warn(demoData, 'rtcTimerParser demoData');
+//     console.warn(newRtcData, 'rtcTimerParser newRtcData');
+//     throw new Error('rtcTimerParser parser demo err!!!');
+//   }
+// }

package/lib/dpParser/sleep/index.d.ts

@@ -0,0 +1,9 @@
+import { Support } from '../../utils/ScheduleSupport';
+export { sleepParser as sleepParserCommon, Sleep as SleepCommon } from './sleepCommon';
+import { TSleepDataSigmesh, TSleepData } from '../../types';
+export declare class SleepParser {
+    support: Support;
+    parser(dpStr: string): TSleepData | TSleepDataSigmesh;
+    formatter(dpData: TSleepDataSigmesh | TSleepData): string;
+}
+export declare const getSleepParser: () => SleepParser;

package/lib/dpParser/sleep/index.js

@@ -0,0 +1,29 @@
+export { sleepParser as sleepParserCommon, Sleep as SleepCommon } from './sleepCommon';
+import { sleepParser as sleepParserCommon } from './sleepCommon';
+export class SleepParser {
+  parser(dpStr) {
+    // FIXME: 暂时不支持 Sigmesh 设备
+    // const support = getSupportIns();
+    // const isSigmesh = support.isSigMeshDevice();
+    // if (isSigmesh) {
+    //   return sleepParserSigmesh.parser(dpStr) as TSleepDataSigmesh;
+    // }
+    return sleepParserCommon.parser(dpStr);
+  }
+  formatter(dpData) {
+    // FIXME: 暂时不支持 Sigmesh 设备
+    // const support = getSupportIns();
+    // const isSigmesh = support.isSigMeshDevice();
+    // if (isSigmesh) {
+    //   return sleepParserSigmesh.formatter(dpData as TSleepDataSigmesh);
+    // }
+    return sleepParserCommon.formatter(dpData);
+  }
+}
+let sleepParser = null;
+export const getSleepParser = () => {
+  if (!sleepParser) {
+    sleepParser = new SleepParser();
+  }
+  return sleepParser;
+};

package/lib/dpParser/sleep/sleepCommon.d.ts

@@ -0,0 +1,11 @@
+import { TSleepData, TSleepNode } from '../../types';
+export declare class Sleep {
+    defaultValue: TSleepData;
+    parser(dpStr: string): TSleepData | {
+        version: any;
+        length: 4;
+        nodes: TSleepNode[];
+    };
+    formatter(data: TSleepData): string;
+}
+export declare const sleepParser: Sleep;

package/lib/dpParser/sleep/sleepCommon.js

@@ -0,0 +1,117 @@
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.for-each.js";
+import { generateDpStrStep, numToHexString } from '@ray-js/panel-sdk/lib/utils';
+import { padEnd } from 'lodash-es';
+import { scheduleLogger } from '../../utils/ScheduleLogger';
+const defaultColor = {
+  hue: 0,
+  saturation: 0,
+  value: 0,
+  brightness: 0,
+  temperature: 0
+};
+export class Sleep {
+  defaultValue = {
+    version: 0,
+    length: 0,
+    nodes: []
+  };
+  parser(dpStr) {
+    scheduleLogger.debug('Sleep parser dpStr: ', dpStr);
+    if (!dpStr) {
+      return this.defaultValue;
+    }
+    const dpLength = dpStr.length;
+    if (!dpLength || (dpLength - 4) % 22 !== 0) {
+      scheduleLogger.error('数据有问题，无法解析');
+      return this.defaultValue;
+    }
+    const step = generateDpStrStep(dpStr);
+    const version = step(2).value;
+    let length = step(2).value;
+    length = Math.min(length, 4);
+    const nodes = [];
+    // 解析循环节点
+    for (let i = 0; i < length; i++) {
+      const onOff = !!step(2).value;
+      const repeatInt = step(2).value; // 单次定时任务bit0-bit6全为0，bit0-bit6某位为1时，表示对应周几周期定时 bit0 => 周日
+      const loops = padEnd(repeatInt.toString(2).split('').reverse().join(''), 7, '0');
+      const stepNum = step(2).value;
+      const hour = step(2).value;
+      const minute = step(2).value;
+
+      // 解析色相值(组合百位和十个位)
+      const hundreds = step(2).value;
+      const tensOnes = step(2).value;
+      const saturation = step(2).value;
+      const val = step(2).value;
+      const brightness = step(2).value;
+      const temperatureStep = step(2);
+      const temperature = temperatureStep.value;
+      nodes.push({
+        onOff,
+        loops,
+        step: stepNum,
+        hour,
+        minute,
+        hue: Math.round(hundreds * 100 + tensOnes),
+        // 0-360
+        saturation,
+        value: val,
+        brightness,
+        temperature,
+        index: i
+      });
+      if (temperatureStep.done) {
+        break;
+      }
+    }
+    return {
+      version,
+      length,
+      nodes
+    };
+  }
+  formatter(data) {
+    var _data$nodes, _data$nodes2;
+    const result = [numToHexString(data.version), numToHexString((_data$nodes = data.nodes) === null || _data$nodes === void 0 ? void 0 : _data$nodes.length)];
+    scheduleLogger.debug('sleep formatter data', data);
+    data === null || data === void 0 || (_data$nodes2 = data.nodes) === null || _data$nodes2 === void 0 || _data$nodes2.forEach(node => {
+      // 拆分色相值为百位和十个位
+      const hueHundreds = Math.floor(node.hue / 100);
+      const hueTensOnes = node.hue % 100;
+      const {
+        saturation,
+        value,
+        brightness,
+        temperature
+      } = node;
+      let saturation1 = node.saturation;
+      let value1 = node.value;
+      let brightness1 = node.brightness;
+      let temperature1 = node.temperature;
+      if (saturation === 0 && value === 0 && brightness === 0 && temperature === 0) {
+        saturation1 = defaultColor.saturation;
+        value1 = defaultColor.value;
+        brightness1 = defaultColor.brightness;
+        temperature1 = defaultColor.temperature;
+      }
+      result.push(numToHexString(node.onOff ? 1 : 0), numToHexString(parseInt(node.loops.split('').reverse().join(''), 2), 2), numToHexString(node.step), numToHexString(node.hour), numToHexString(node.minute), numToHexString(hueHundreds), numToHexString(hueTensOnes), numToHexString(saturation1), numToHexString(value1), numToHexString(brightness1), numToHexString(temperature1));
+    });
+    return result.join('');
+  }
+}
+export const sleepParser = new Sleep();
+
+// if (isInIDEFun()) {
+//   // 使用示例
+//   const dpStr = '00 01 01 42 01 0b 15 00 00 00 00 00'.replaceAll(' ', '');
+//   const result = sleepParser.parser(dpStr);
+//   const formatted = sleepParser.formatter(result);
+//   console.log(result, 'resultresult');
+//   console.log(formatted, 'formattedformatted');
+//   console.log(dpStr, 'dpStrdpStr');
+//   if (formatted !== dpStr) {
+//     throw new Error('sleep dp format error');
+//   }
+// }