mini_program_gizwits_sdk 3.2.30 → 3.2.32-FeiSiMan

package/dist/src/aepApi/aepApiRequest.d.ts

@@ -0,0 +1,7 @@
+export interface IServiceResult<T> {
+    success: boolean;
+    data?: T;
+    err?: IError;
+}
+declare const aepApiRequest: <T>(url: string, options: any, needToken?: boolean) => Promise<IServiceResult<T>>;
+export default aepApiRequest;

package/dist/src/handler/ble.d.ts

@@ -44,6 +44,7 @@ export declare class BleHandle extends EventListener<TBleHandleEvent> {
     private connectingDevId;
     pks: string[];
     private listenDevOfflineTimer;
+    private methodQueue;
     private boradcastTimer;
     private boradcastDataCache;
     private baseServices;
@@ -52,6 +53,8 @@ export declare class BleHandle extends EventListener<TBleHandleEvent> {
     private disableScanFlag;
     private peripheralServer;
     private isActive;
+    private isInitSuccess;
+    private isRunInit;
     private _offlineThreshold;
     set offlineThreshold(value: any);
     get offlineThreshold(): any;
@@ -79,12 +82,7 @@ export declare class BleHandle extends EventListener<TBleHandleEvent> {
         success: boolean;
     }>;
     private getBluetoothAdapterState;
-    getDeviceStatus: (deviceId: string, productKey: string, gwDid?: string, attrNames?: string[]) => Promise<import("../wechatApi").IWechatResult | {
-        success: boolean;
-        message: string;
-    } | {
-        success: boolean;
-    }>;
+    getDeviceStatus: (deviceId: string, productKey: string, gwDid?: string, attrNames?: string[]) => Promise<any>;
     private updateDevice;
     private updateCtime;
     private checkDeviceIsChange;
@@ -125,10 +123,7 @@ export declare class BleHandle extends EventListener<TBleHandleEvent> {
         success: boolean;
         message?: undefined;
     }>;
-    write: (bleDeviceID: string, value: ArrayBuffer) => Promise<import("../wechatApi").IWechatResult | {
-        success: boolean;
-        message: string;
-    }>;
+    write: (bleDeviceID: any, value: any) => Promise<any>;
     disConnectDevice: (deviceId: string) => Promise<{
         err: string;
         success: boolean;

package/dist/src/protocol/Reset.d.ts

@@ -0,0 +1,8 @@
+import ProtocolBase from "./ProtocolBase";
+type IStatus = 0 | 1;
+declare class Reset extends ProtocolBase {
+    status: IStatus;
+    constructor(data: number[]);
+    static pack: () => number[];
+}
+export default Reset;

package/dist/src/protocol/SetReset.d.ts

@@ -0,0 +1,7 @@
+import ProtocolBase from "./ProtocolBase";
+type IStatus = 0 | 1;
+declare class SetReset extends ProtocolBase {
+    status: IStatus;
+    static pack: (status: IStatus) => number[];
+}
+export default SetReset;

package/dist/src/sdk.d.ts

@@ -0,0 +1,204 @@
+import { TLogType } from './GizLog';
+import { IDataPointConfig } from './protocol/DataPoint';
+import { IOpenApiDevice, ISafeRegisterReturn, IUnbindReturn } from './services/devices';
+import { ILoginRes } from './services/login';
+interface SyncCallBackParams {
+    event: TSyncEvnet;
+    currentNum?: number;
+    totalNum?: number;
+    message?: string;
+}
+type TSyncEvnet = 'SYNC_START' | 'SYNC_END' | 'SYNC_FAIL' | 'SYNC_CANCEL' | 'SYNC_PROGRESS';
+export type SyncCallBack = (data: SyncCallBackParams) => void;
+export interface ISDKResult<T> {
+    data?: T;
+    err?: IError;
+    message?: string;
+    success: boolean;
+}
+export interface ISetCommonDeviceOnboardingDeployProps {
+    ssid: string;
+    bssid?: string;
+    password: string;
+    timeout: number;
+    isBind?: boolean;
+    mode?: 0 | 3 | 5;
+    softAPSSIDPrefix?: string;
+}
+export interface ISetDeviceOnboardingDeployProps extends ISetCommonDeviceOnboardingDeployProps {
+    softAPSSIDPrefix: string;
+}
+export interface IConfigResult {
+    mac: string;
+    productKey: string;
+}
+export interface IRandomCodesResult {
+    random_code: string;
+    product_key: string;
+    mac: string;
+    did: string;
+    user_id: string;
+    timestamp: number;
+    type: string;
+    wifi_soft_ver: string;
+    lan_proto_ver: string;
+}
+interface IBindRemoteDeviceParams {
+    productKey: string;
+    mac: string;
+    beOwner?: boolean;
+    alias?: string;
+}
+interface IDeviceStatusNoti {
+    device: IDevice;
+    connectType: TConnectType;
+}
+interface IDeviceAttrsNoti {
+    device: IDevice;
+    data: object;
+}
+export interface TListenerType {
+    GizDeviceListNotifications: TDeviceListNotifications;
+    GizDeviceStatusNotifications: TDeviceStatusNotifications;
+    GizDeviceAttrsNotifications: TDeviceAttrsNotifications;
+    onScanListChange: OnScanListChange;
+    onBleHandleError: OnBleHandleError;
+}
+type TDeviceListNotifications = (devices: IDevice[]) => void;
+type TDeviceStatusNotifications = (data: IDeviceStatusNoti) => void;
+type TDeviceAttrsNotifications = (data: IDeviceAttrsNoti) => void;
+type OnScanListChange = (devices: IDevice[]) => void;
+type OnBleHandleError = (error: IError) => void;
+interface IDeviceSafetyRegisterParams {
+    mac: string;
+    productKey: string;
+}
+export interface IResult<T> {
+    success: boolean;
+    data?: T;
+    err?: IError;
+}
+interface ICloudServiceInfo {
+    openAPIInfo: string;
+    aepAPIInfo: string;
+}
+export type TimeoutHandle = ReturnType<typeof setTimeout> | null;
+export type IntervalHandle = ReturnType<typeof setInterval> | null;
+export interface IProductInfo {
+    productKey: string;
+    productSecret: string;
+}
+interface GizwitsSdkOption {
+    appID: string;
+    appSecret: string;
+    productInfo: IProductInfo[];
+    cloudServiceInfo?: ICloudServiceInfo;
+    token?: string;
+    uid?: string;
+    offlineThreshold?: number;
+    accessKey?: string;
+    secretKey?: string;
+}
+declare class GizwitsMiniSDK {
+    private listenerMap;
+    private keepScanTimer;
+    private _deviceList;
+    private get deviceList();
+    private set deviceList(value);
+    private _bleDevices;
+    get bleDevices(): IDevice[];
+    set bleDevices(data: IDevice[]);
+    private _lanDevices;
+    private get lanDevices();
+    private set lanDevices(value);
+    private get allDevices();
+    private get bleScanDevice();
+    private productInfo;
+    private currentWifiConfigHandle;
+    private _bleHandle;
+    private _lanHandle;
+    private _gizSocket;
+    private offlineThreshold?;
+    private syncDataCallBack?;
+    private syncDataLengthCallback?;
+    private syncTotalNum;
+    private syncCurrnetNum;
+    private syncDataTimoutTimer;
+    private SYNC_TIMEOUT;
+    private syncDevice?;
+    constructor(props: GizwitsSdkOption);
+    private get bleHandle();
+    private get lanHandle();
+    private get socketHandle();
+    private init;
+    reInit(props: GizwitsSdkOption): void;
+    get specialProductKeys(): string[];
+    get specialProductKeySecrets(): string[];
+    private handleBleError;
+    private handleBleDevices;
+    handleLanDevices: (devices: IDevice[]) => void;
+    private handleLanDeviceData;
+    private handleBleDeviceData;
+    private handleSocketDeviceData;
+    private handleSocketStatus;
+    private notiDeviceList;
+    private initLan;
+    startAutoScan: (services?: string[]) => void;
+    stopAutoScan: () => void;
+    setDeviceMeta: <K extends keyof IDevice>(curDev: IDevice, key: K, value: IDevice[K], force?: boolean) => void;
+    static getVersion: () => {
+        success: boolean;
+        data: string;
+    };
+    initBle: () => Promise<ISDKResult<null>>;
+    scanBleDevice: (delay: number, services?: string[]) => Promise<ISDKResult<IDevice[]>>;
+    write: (device: IDevice, attrs: object) => Promise<any>;
+    writeRaw: (device: IDevice, data: number[]) => Promise<any>;
+    setDeviceTimeStamp: (device: IDevice) => Promise<any>;
+    syncDeviceData: (device: IDevice, callback?: SyncCallBack) => Promise<any>;
+    queryNeedSyncDataLength: (device: IDevice) => Promise<ISDKResult<number>>;
+    cancelSyncDeviceData: () => Promise<void>;
+    private cleanSyncDeviceData;
+    getProductConfig: (pk: string) => Promise<ISDKResult<IDataPointConfig>>;
+    stopScanBleDevice: () => void;
+    login: (openID: string) => Promise<ISDKResult<ILoginRes>>;
+    getDeviceStatus: (device: IDevice, attrNames?: string[]) => Promise<any>;
+    subscribe: (device: IDevice, connectType?: TConnectType, _autoGetDeviceStatus?: boolean) => Promise<IResult<any> | {
+        success: boolean;
+        message: string;
+    }>;
+    unSubscribe: (device: IDevice) => Promise<{
+        success: boolean;
+        err: any;
+    } | {
+        success: boolean;
+    }>;
+    bindRemoteDevice: ({ mac, productKey, alias, beOwner, }: IBindRemoteDeviceParams) => Promise<ISDKResult<IOpenApiDevice>>;
+    unbindDevice: ({ devices, }: {
+        devices: IDevice[];
+    }) => Promise<ISDKResult<IUnbindReturn>>;
+    deviceSafetyRegister: ({ mac, productKey, }: IDeviceSafetyRegisterParams) => Promise<ISDKResult<ISafeRegisterReturn>>;
+    deviceSafetyUnbind: ({ mac, productKey, }: IDeviceSafetyRegisterParams) => Promise<ISDKResult<ISafeRegisterReturn>>;
+    setDeviceOnboardingDeploy: ({ ssid, bssid, password, mode, timeout, isBind, softAPSSIDPrefix, }: ISetDeviceOnboardingDeployProps) => Promise<ISDKResult<IDevice[]>>;
+    private setDomain;
+    private deviceSafetyApi;
+    getBindingList: () => Promise<{}>;
+    getDevices: () => Promise<ISDKResult<IDevice[]>>;
+    stopDeviceOnboardingDeploy: () => void;
+    setLogLevel: (level: TLogType) => {
+        success: boolean;
+        err: IError;
+    };
+    renameDevice: (device: IDevice, name: string) => Promise<import("./openApiRequest").IServiceResult<import("./services/devices").IRenamePropsReturn> | {
+        success: boolean;
+        message: string;
+    }>;
+    removeEventListener: <K extends keyof TListenerType>(type: K, func: TListenerType[K]) => {
+        success: boolean;
+    };
+    addEventListener: <K extends keyof TListenerType>(type: K, func: TListenerType[K]) => Promise<{
+        success: boolean;
+    }>;
+    destory: () => void;
+}
+export default GizwitsMiniSDK;

package/dist/src/wifiConfig/ConfigBase.d.ts

@@ -4,13 +4,14 @@ interface IRejectCallback {
 }
 declare class ConfigBase {
     ssid: string;
+    bssid: string;
     password: string;
     specialProductKeys: string[];
     disableSearchDevice: boolean;
     specialProductKeySecrets: string[];
     private timeoutHandler;
     private setDeviceOnboardingDeployRej?;
-    constructor(ssid: string, password: string, specialProductKeys: string[], specialProductKeySecrets: string[]);
+    constructor(ssid: string, bssid: string, password: string, specialProductKeys: string[], specialProductKeySecrets: string[]);
     cleanTimeout: () => void;
     stopDeviceOnboardingDeploy: () => void;
     hasTimeoutHandler: (cb?: IRejectCallback) => boolean;

package/dist/src/wifiConfig/ble.d.ts

@@ -1,6 +1,11 @@
-import { IRandomCodesResult, IResult } from "../sdk";
+import { IConfigResult, IResult } from "../sdk";
 import { BleHandle } from "../handler/ble";
 import ConfigBase from "./ConfigBase";
+interface IVerifyOnlineResult {
+    data: {
+        status: number;
+    };
+}
 interface IArgs {
     bleDeviceId: string;
     arrayBuffer: ArrayBuffer;
@@ -22,7 +27,7 @@ interface ISetDeviceOnboardingDeployProps {
 }
 declare class BLEConfig extends ConfigBase {
     bleHandle: BleHandle;
-    constructor(ssid: string, password: string, specialProductKeys: string[], specialProductKeySecrets: string[], bleHandle: BleHandle);
+    constructor(ssid: string, bssid: string, password: string, specialProductKeys: string[], specialProductKeySecrets: string[], bleHandle: BleHandle);
     destroy: () => void;
     isValidBleDevice: (bleDevice: WechatMiniprogram.BlueToothDevice, softAPSSIDPrefix?: string) => boolean;
     enableBluetoothDevicesDescovery: () => Promise<{
@@ -31,6 +36,14 @@ declare class BLEConfig extends ConfigBase {
     } | {
         success: true;
     }>;
+    getDeviceLastestOnlineTime: ({ productKey, mac }: {
+        productKey: string;
+        mac: string;
+    }) => Promise<import("../aepApi/aepApiRequest").IServiceResult<IVerifyOnlineResult>>;
+    verifyDeviceOnline: ({ productKey, mac }: {
+        productKey: string;
+        mac: string;
+    }) => Promise<IResult<IVerifyOnlineResult>>;
     enableAndGetBluetoothDevices: (softAPSSIDPrefix?: string) => Promise<{
         success: false;
         err: IError;
@@ -39,6 +52,6 @@ declare class BLEConfig extends ConfigBase {
         bleDevices?: WechatMiniprogram.BlueToothDevice[];
     }>;
     setDeviceOnboardingDeploy: ({ timeout, isBind, softAPSSIDPrefix, }: ISetDeviceOnboardingDeployProps) => Promise<IResult<IDevice[]>>;
-    configBLEDevice: ({ ssid, password, softAPSSIDPrefix, }: configBLEDeviceParams) => Promise<IResult<IRandomCodesResult[]>>;
+    configBLEDevice: ({ ssid, password, softAPSSIDPrefix, }: configBLEDeviceParams) => Promise<IResult<IConfigResult>>;
 }
 export default BLEConfig;

package/dist/src/wifiConfig/nfc/disposeData.d.ts

@@ -0,0 +1,2 @@
+import { IDATA } from './types';
+export declare const disposeData: (SSID: Uint8Array, isSSIDincludeCH: boolean, pwd: Uint8Array, passIP: Uint8Array, BSSID: Uint8Array) => IDATA;

package/dist/src/wifiConfig/nfc/formatData.d.ts

@@ -0,0 +1,3 @@
+type IType = 'BSSID' | 'pwd' | 'address';
+export declare const formatData: (data: string, type: IType) => Uint8Array;
+export {};

package/dist/src/wifiConfig/nfc/formatSSID.d.ts

@@ -0,0 +1,6 @@
+interface IExport {
+    SSIDTLV: any;
+    isSSIDIncludedCH: boolean;
+}
+export declare const formatSSID: (SSID: string) => IExport;
+export {};

package/dist/src/wifiConfig/nfc/index.d.ts

@@ -0,0 +1,22 @@
+import { IRandomCodesResult, IResult } from "../../sdk";
+import ConfigBase from "../ConfigBase";
+interface configDeviceParams {
+    ssid: string;
+    password: string;
+    bssid: string;
+    address: string;
+}
+interface ISetDeviceOnboardingDeployProps {
+    timeout: number;
+    isBind: boolean;
+    BSSID: string;
+    softAPSSIDPrefix: string;
+}
+declare class NFCConfig extends ConfigBase {
+    address: string;
+    constructor(ssid: string, bssid: string, password: string, specialProductKeys: string[], specialProductKeySecrets: string[], address: string);
+    destroy: () => void;
+    configDevice: ({ ssid, password, bssid, address }: configDeviceParams) => Promise<IResult<IRandomCodesResult[]>>;
+    setDeviceOnboardingDeploy: ({ timeout, isBind, }: ISetDeviceOnboardingDeployProps) => Promise<IResult<IDevice[]>>;
+}
+export default NFCConfig;

package/dist/src/wifiConfig/nfc/isIncludedCH.d.ts

@@ -0,0 +1 @@
+export default function isIncludedCH(str: string): boolean;

package/dist/src/wifiConfig/nfc/nfcAConnect.d.ts

@@ -0,0 +1,6 @@
+type T = {
+    success: boolean;
+    nfcA: any;
+};
+export declare const nfcAConnect: (NFCAdapter: any) => Promise<T>;
+export {};

package/dist/src/wifiConfig/nfc/nfcATransceive.d.ts

@@ -0,0 +1,5 @@
+type T = {
+    transceiveSuccess: boolean;
+};
+export declare const nfcATransceive: (nfcA: any, buffer: ArrayBuffer) => Promise<T>;
+export {};

package/dist/src/wifiConfig/nfc/ssIDToASC.d.ts

@@ -0,0 +1 @@
+export declare const ssIDToASC: (SSID: string) => Uint8Array;

package/dist/src/wifiConfig/nfc/stringToGbk.d.ts

@@ -0,0 +1 @@
+export default function stringToGbk(str: string): Uint8Array;

package/dist/src/wifiConfig/nfc/transceive.wx.d.ts

@@ -0,0 +1,2 @@
+import { IDATA } from './types';
+export declare const transceive: (DATA: IDATA) => void;

package/dist/src/wifiConfig/nfc/types.d.ts

@@ -0,0 +1,15 @@
+type PageStateProps = {
+    store: {};
+};
+interface WifiInfo {
+    SSID: string;
+    BSSID: string;
+    secure: boolean;
+    signalStrength: number;
+    frequency: number;
+}
+type IDATA = {
+    ArrayBuffer_sign: ArrayBuffer;
+    ArrayBuffer_others: ArrayBuffer;
+};
+export { PageStateProps, WifiInfo, IDATA };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mini_program_gizwits_sdk",
-  "version": "3.2.30",
+  "version": "3.2.32-FeiSiMan",
   "description": "修正flag转换",
   "main": "./dist/index.js",
   "scripts": {

package/src/aepApi/aepApiRequest.ts

@@ -0,0 +1,62 @@
+import request from '../request';
+import { getGlobalData } from "../globalData";
+import errorCode from '../errorCode';
+
+interface IResult<T> {
+  data: T;
+  errMsg: string;
+  statusCode: number;
+}
+
+export interface IServiceResult<T> {
+  success: boolean;
+  data?: T;
+  err?: IError;
+}
+
+const aepApiRequest = async <T>(url: string, options: any, needToken: boolean = true): Promise<IServiceResult<T>> => {
+  const requestOptions = { ...options };
+  const headers: any = {
+    'Content-Type': 'application/json',
+    'accessKey': getGlobalData('accessKey'),
+    'secretKey': getGlobalData('secretKey'),
+  };
+  if (needToken) {
+    headers['Authorization'] = getGlobalData('token');
+  }
+  requestOptions.header = { ...headers, ...options.headers };
+  delete requestOptions.headers;
+  const aepApiUrl = getGlobalData('cloudServiceInfo').aepAPIInfo;
+  console.log('aepApiRequest', aepApiUrl + url, requestOptions);
+  const res = await request<IResult<T>>(aepApiUrl + url, requestOptions);
+  console.log('aepApiRequest res', res);
+  // 统一封装OPEN API的错误码
+  if (res.statusCode >= 200 && res.statusCode < 300) {
+    return {
+      success: true,
+      data: res.data
+    }
+  }
+
+  let baseError = {
+    success: false,
+    err: {
+      errorCode: errorCode.GIZ_SDK_HTTP_REQUEST_FAILED.errorCode,
+      errorMessage: '',
+    }
+  }
+  try {
+    baseError = {
+      success: false,
+      err: {
+        errorCode: (res.data as any).error_code,
+        errorMessage: (res.data as any).error_message,
+      }
+    }
+  } catch (error) {
+
+  }
+  return baseError;
+}
+
+export default aepApiRequest;

package/src/handler/ble.ts

@@ -144,6 +144,7 @@ export class BleHandle extends EventListener<TBleHandleEvent> {
   public pks: string[] = [];
   private listenDevOfflineTimer: any = null;
 
+  private methodQueue: any = Promise.resolve();  // 发送指令的队列
   private boradcastTimer: any;
   private boradcastDataCache: any = {}
   private baseServices: string[] = ['ABF8', 'ABF0', 'F0AB', 'F8AB'];
@@ -155,6 +156,8 @@ export class BleHandle extends EventListener<TBleHandleEvent> {
   private peripheralServer: WechatMiniprogram.BLEPeripheralServer | null = null;
 
   private isActive = true; // 小程序是否活跃
+  private isInitSuccess = false;
+  private isRunInit = false;
 
   private _offlineThreshold = null;
   public set offlineThreshold(value) {
@@ -199,7 +202,10 @@ export class BleHandle extends EventListener<TBleHandleEvent> {
   private onBluetoothAdapterStateChange = (res: WechatMiniprogram.OnBluetoothAdapterStateChangeListenerResult) => {
     GizLog.debug("onBluetoothAdapterStateChange", res)
     if (res.available) {
-      // this.startScan(() => {}, 4000);
+      if (this.isRunInit && this.isInitSuccess === false) {
+        // 重新初始化蓝牙
+        this.init();
+      }
     } else {
       // 不可用状态
       this.scanList = [];
@@ -352,6 +358,7 @@ export class BleHandle extends EventListener<TBleHandleEvent> {
   };
 
   private init = async () => {
+    this.isRunInit = true;
     const { platform } = wx.getSystemInfoSync();
     await this.openBluetoothAdapter();
     if (platform === 'ios') {
@@ -366,6 +373,7 @@ export class BleHandle extends EventListener<TBleHandleEvent> {
       GizLog.error('GIZ_SDK: 广播初始化失败', new Error(JSON.stringify(error)))
     }
     const res = await this.getBluetoothAdapterState();
+    this.isInitSuccess = true
     return res;
   }
 
@@ -502,7 +510,6 @@ export class BleHandle extends EventListener<TBleHandleEvent> {
       if (targetBleDev) {
         // 存在设备，更新ctime 并更新属性
         const newDevice = BTDevice2GDevice(device, this.pks);
-
         if (newDevice.productKey && newDevice.mac) {
           // 广播设备没有 bleWorkStatus
           const isChange = this.checkDeviceIsChange(newDevice, targetBleDev);
@@ -860,24 +867,32 @@ export class BleHandle extends EventListener<TBleHandleEvent> {
 
   }
 
-  public write = async (bleDeviceID: string, value: ArrayBuffer) => {
-    GizLog.log('app => dev:', ab2hex(value));
-    const targetDevice = this.getTargetDevice(bleDeviceID);
-    if (targetDevice.serviceId && targetDevice.characteristicId) {
-      const unpackRes = await unpackWriteBLECharacteristicValue(
-        bleDeviceID,
-        targetDevice.serviceId,
-        targetDevice.characteristicId,
-        value
-      );
-      return unpackRes;
-    }
-    return {
-      success: false,
-      message: 'send cmd error',
+  write = async (bleDeviceID, value) => {
+    const writeMethod = async () => {
+      GizLog.log('app => dev:', ab2hex(value));
+      const targetDevice = this.getTargetDevice(bleDeviceID);
+      if (targetDevice.serviceId && targetDevice.characteristicId) {
+        const unpackRes = await unpackWriteBLECharacteristicValue(
+          bleDeviceID,
+          targetDevice.serviceId,
+          targetDevice.characteristicId,
+          value
+        );
+        return unpackRes;
+      }
+      return {
+        success: false,
+        message: 'send cmd error',
+      };
     };
+
+    // 将当前方法添加到方法队列中，并等待前一个方法执行完成后再执行
+    this.methodQueue = this.methodQueue.then(writeMethod);
+
+    return this.methodQueue;
   };
 
+
   /**
    * @description 断开设备连接
    */

package/src/protocol/Reset.ts

@@ -0,0 +1,16 @@
+import ProtocolBase from "./ProtocolBase";
+import { arrayToString } from "./tool";
+
+type IStatus = 0 | 1;
+class Reset extends ProtocolBase {
+  status: IStatus = 0; // 0 没有进入重置 1 进入了重置状态
+  constructor(data: number[]) {
+    super(data);
+    this.status = this.content[0] as IStatus;
+  }
+  static pack = () => {
+    return [0,0,0,3,3,0,0,0x61];
+  }
+}
+
+export default Reset;

package/src/protocol/SetReset.ts

@@ -0,0 +1,13 @@
+import ProtocolBase from "./ProtocolBase";
+import { arrayToString } from "./tool";
+
+
+type IStatus = 0 | 1;
+class SetReset extends ProtocolBase {
+  status: IStatus = 0; // 0 没有进入重置 1 进入了重置状态
+  static pack = (status: IStatus) => {
+    return [0,0,0,3,3,0,0,0x63, status];
+  }
+}
+
+export default SetReset;