@switchbot/homebridge-switchbot 0.2.0-alpha.2 → 1.0.1-beta.2

package/src/devices/curtains.ts

@@ -1,70 +1,60 @@
 /* eslint-disable @typescript-eslint/no-var-requires */
-import { Service, PlatformAccessory, CharacteristicValue, MacAddress } from 'homebridge';
+import { Service, PlatformAccessory, CharacteristicValue } from 'homebridge';
 import { SwitchBotPlatform } from '../platform';
 import { interval, Subject } from 'rxjs';
 import { debounceTime, skipWhile, tap } from 'rxjs/operators';
-import { DeviceURL, device, devicesConfig } from '../settings';
+import { DeviceURL, device, devicesConfig, serviceData, switchbot, deviceStatusResponse } from '../settings';
+import { AxiosResponse } from 'axios';
 
 export class Curtain {
   // Services
   private service: Service;
   private lightSensorService: Service;
+  private batteryService?: Service;
 
   // Characteristic Values
   CurrentPosition!: CharacteristicValue;
   PositionState!: CharacteristicValue;
   TargetPosition!: CharacteristicValue;
   CurrentAmbientLightLevel!: CharacteristicValue;
+  BatteryLevel?: CharacteristicValue;
+  StatusLowBattery?: CharacteristicValue;
 
-  // Others
-  deviceStatus!: any;
-  moveTimer!: NodeJS.Timeout;
-  ScanIntervalId!: NodeJS.Timeout;
-  setNewTargetTimer!: NodeJS.Timeout;
-  AutoDisableFastScanTimeoutId!: NodeJS.Timeout;
+  // OpenAPI Others
+  deviceStatus!: deviceStatusResponse;
   setNewTarget!: boolean;
-  moveTime!: number;
-  ScanDuration: any;
-  ReverseDir: any;
-  FastScanEnabled!: boolean;
-  FastScanInterval!: number;
-  SlowScanInterval!: number;
-  OpenCloseThreshold: any;
-  PreviousPosition: any;
-  Position: any;
-  FastScanDuration: number | undefined;
+  setNewTargetTimer!: NodeJS.Timeout;
+
+  // BLE Others
+  switchbot!: switchbot;
+  serviceData!: serviceData;
+  calibration: serviceData['calibration'];
+  battery: serviceData['battery'];
+  position: serviceData['position'];
+  lightLevel: serviceData['lightLevel'];
+
+  // Config
   set_minStep!: number;
   refreshRate!: number;
-  switchbot!: {
-    discover: (
-      arg0:
-        {
-          duration: any;
-          model: string;
-          quick: boolean;
-          id: MacAddress;
-        }
-    ) => Promise<any>;
-    wait: (
-      arg0: number
-    ) => any;
-  };
 
   // Updates
   curtainUpdateInProgress!: boolean;
-  doCurtainUpdate;
+  doCurtainUpdate!: Subject<void>;
 
   constructor(
     private readonly platform: SwitchBotPlatform,
     private accessory: PlatformAccessory,
     public device: device & devicesConfig,
   ) {
+    // Curtain Config
+    this.platform.device(`[Curtain Config] ble: ${device.ble}, disable_group: ${device.curtain?.disable_group},`
+    + ` refreshRate: ${device.curtain?.refreshRate}, set_max: ${device.curtain?.set_max}, set_min: ${device.curtain?.set_min},`
+    + ` set_minStep: ${device.curtain?.set_minStep}`);
+
     // default placeholders
-    this.setMinMax();
     this.CurrentPosition = 0;
     this.TargetPosition = 0;
     this.PositionState = this.platform.Characteristic.PositionState.STOPPED;
-    this.ScanDuration = this.platform.config.options!.refreshRate!;
 
     // BLE Connection
     if (device.ble) {
@@ -121,7 +111,7 @@ export class Curtain {
         validValueRanges: [0, 100],
       })
       .onGet(() => {
-        return Number.isNaN(this.CurrentPosition);
+        return this.CurrentPosition;
       });
 
     this.service
@@ -137,15 +127,6 @@ export class Curtain {
       accessory.getService(this.platform.Service.LightSensor) ||
       accessory.addService(this.platform.Service.LightSensor)), `${device.deviceName} Light Sensor`;
     this.lightSensorService.setCharacteristic(this.platform.Characteristic.Name, `${device.deviceName} Light Sensor`);
-    // handle on / off events using the On characteristic
-    this.lightSensorService.getCharacteristic(this.platform.Characteristic.CurrentAmbientLightLevel).onGet(() => {
-      if (this.CurrentAmbientLightLevel === 'bright') {
-        return 100000;
-      } else {
-        return 0.0001;
-      }
-    });
-
 
     // Update Homekit
     this.updateHomeKitCharacteristics();
@@ -224,10 +205,80 @@ export class Curtain {
 
   private async BLEparseStatus() {
     this.platform.device('Curtains BLE Device parseStatus');
+    this.CurrentPosition = 100 - Number(this.position);
+    this.setMinMax();
+    this.platform.debug(`Curtain ${this.accessory.displayName} CurrentPosition - Device is Currently: ${this.CurrentPosition}`);
+    if (this.setNewTarget) {
+      this.platform.log.info(`Checking ${this.accessory.displayName} Status ...`);
+    }
+
+    if (this.setNewTarget) {
+      if (this.TargetPosition > this.CurrentPosition) {
+        this.platform.debug(`Curtain ${this.accessory.displayName} - Current position: ${this.CurrentPosition} closing`);
+        this.PositionState = this.platform.Characteristic.PositionState.INCREASING;
+      } else if (this.TargetPosition < this.CurrentPosition) {
+        this.platform.debug(`Curtain ${this.accessory.displayName} - Current position: ${this.CurrentPosition} opening`);
+        this.PositionState = this.platform.Characteristic.PositionState.DECREASING;
+      } else {
+        this.platform.debug(`Curtain ${this.CurrentPosition} - standby`);
+        this.PositionState = this.platform.Characteristic.PositionState.STOPPED;
+      }
+    } else {
+      this.platform.debug(`Curtain ${this.accessory.displayName} - Current position: ${this.CurrentPosition} standby`);
+      if (!this.setNewTarget) {
+        /*If Curtain calibration distance is short, there will be an error between the current percentage and the target percentage.*/
+        this.TargetPosition = this.CurrentPosition;
+        this.PositionState = this.platform.Characteristic.PositionState.STOPPED;
+      }
+    }
+    // Brightness
+    switch (this.lightLevel) {
+      case 1:
+        this.CurrentAmbientLightLevel = 0.0001;
+        break;
+      case 2:
+        this.CurrentAmbientLightLevel = 100;
+        break;
+      case 3:
+        this.CurrentAmbientLightLevel = 200;
+        break;
+      case 4:
+        this.CurrentAmbientLightLevel = 4000;
+        break;
+      case 5:
+        this.CurrentAmbientLightLevel = 12000;
+        break;
+      case 6:
+        this.CurrentAmbientLightLevel = 28000;
+        break;
+      case 7:
+        this.CurrentAmbientLightLevel = 56000;
+        break;
+      case 8:
+        this.CurrentAmbientLightLevel = 75000;
+        break;
+      case 9:
+        this.CurrentAmbientLightLevel = 90000;
+        break;
+      case 10:
+      default:
+        this.CurrentAmbientLightLevel = 100000;
+    }
+    // Battery
+    this.BatteryLevel = Number(this.battery);
+    if (this.BatteryLevel < 10) {
+      this.StatusLowBattery = this.platform.Characteristic.StatusLowBattery.BATTERY_LEVEL_LOW;
+    } else {
+      this.StatusLowBattery = this.platform.Characteristic.StatusLowBattery.BATTERY_LEVEL_NORMAL;
+    }
+    this.platform.debug(
+      `Curtain ${this.accessory.displayName} CurrentPosition: ${this.CurrentPosition},`
+      + ` TargetPosition: ${this.TargetPosition}, PositionState: ${this.PositionState},`
+      + ` CurrentAmbientLightLevel: ${this.CurrentAmbientLightLevel}`);
   }
 
   private async openAPIparseStatus() {
-    this.setMinMax();
+    this.platform.device('Curtains OpenAPI Device parseStatus');
     this.CurrentPosition = 100 - this.deviceStatus.body.slidePosition!;
     this.setMinMax();
     this.platform.debug(`Curtain ${this.accessory.displayName} CurrentPosition - Device is Currently: ${this.CurrentPosition}`);
@@ -260,80 +311,76 @@ export class Curtain {
       case 'dim':
         this.CurrentAmbientLightLevel = 0.0001;
         break;
+      case 'bright':
       default:
         this.CurrentAmbientLightLevel = 100000;
     }
     this.platform.debug(
-      `Curtain ${this.accessory.displayName} CurrentPosition: ${this.CurrentPosition}
-      , TargetPosition: ${this.TargetPosition}, PositionState: ${this.PositionState}
-      , CurrentAmbientLightLevel: ${this.CurrentAmbientLightLevel}`);
+      `Curtain ${this.accessory.displayName} CurrentPosition: ${this.CurrentPosition},`
+      + ` TargetPosition: ${this.TargetPosition}, PositionState: ${this.PositionState},`
+      + ` CurrentAmbientLightLevel: ${this.CurrentAmbientLightLevel}`);
   }
 
   async refreshStatus() {
     if (this.device.ble) {
       this.platform.device('BLE');
-      await this.BLErefreshStatus();
+      await this.BLERefreshStatus();
     } else {
       this.platform.device('OpenAPI');
       await this.openAPIRefreshStatus();
     }
   }
 
-  private async BLErefreshStatus() {
-    this.platform.debug('Curtains BLE Device RefreshStatus');
+  private connectBLE() {
     // eslint-disable-next-line @typescript-eslint/no-var-requires
     const Switchbot = require('node-switchbot');
     const switchbot = new Switchbot();
     const colon = this.device.deviceId!.match(/.{1,2}/g);
     const bleMac = colon!.join(':'); //returns 1A:23:B4:56:78:9A;
     this.device.bleMac = bleMac.toLowerCase();
-    this.platform.debug(this.device.bleMac!);
-    switchbot.onadvertisement = (ad: any) => {
-      this.platform.debug(JSON.stringify(ad, null, '  '));
-      this.platform.device(`ad: ${JSON.stringify(ad)}`);
-    };
-    this.parseStatus();
-    this.updateHomeKitCharacteristics();
-    switchbot
-      .startScan({
-        id: this.device.bleMac,
-      })
-      .then(() => {
-        return switchbot.wait(this.platform.config.options!.refreshRate! * 1000);
-      })
-      .then(() => {
-        switchbot.stopScan();
-      })
-      .catch(async (error: any) => {
-        this.platform.log.error(error);
-        await this.openAPIRefreshStatus();
-      });
-    setInterval(() => {
-      this.platform.log.info('Start scan ' + this.device.deviceName + '(' + this.device.bleMac + ')');
-      switchbot
-        .startScan({
-          mode: 'T',
-          id: bleMac,
-        })
-        .then(() => {
-          return switchbot.wait(this.platform.config.options!.refreshRate! * 1000);
-        })
-        .then(() => {
-          switchbot.stopScan();
-          this.platform.log.info('Stop scan ' + this.device.deviceName + '(' + this.device.bleMac + ')');
-        })
-        .catch(async (error: any) => {
-          this.platform.log.error(error);
-          await this.openAPIRefreshStatus();
-        });
-    }, this.platform.config.options!.refreshRate! * 60000);
+    this.platform.device(this.device.bleMac!);
+    return switchbot;
+  }
+
+  private async BLERefreshStatus() {
+    this.platform.debug('Curtains BLE Device RefreshStatus');
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const switchbot = this.connectBLE();
+    // Start to monitor advertisement packets
+    switchbot.startScan({
+      model: 'c',
+      id: this.device.bleMac,
+    }).then(() => {
+      // Set an event hander
+      switchbot.onadvertisement = (ad: any) => {
+        this.serviceData = ad.serviceData;
+        this.platform.device(`${this.device.bleMac}: ${JSON.stringify(ad.serviceData)}`);
+        this.calibration = ad.serviceData.calibration;
+        this.battery = ad.serviceData.battery;
+        this.position = ad.serviceData.position;
+        this.lightLevel = ad.serviceData.lightLevel;
+        this.platform.device(`${this.accessory.displayName}, Calibration: ${ad.serviceData.calibration}, Position: ${ad.serviceData.position},`
+          + ` Light Level: ${ad.serviceData.lightLevel}, Battery: ${ad.serviceData.battery}`);
+      };
+      // Wait 10 seconds
+      return switchbot.wait(10000);
+    }).then(() => {
+      // Stop to monitor
+      switchbot.stopScan();
+      this.parseStatus();
+      this.updateHomeKitCharacteristics();
+    }).catch(async (e: any) => {
+      this.platform.log.error(`BLE Connection Failed: ${e.message}`);
+      this.platform.log.warn('Using OpenAPI Connection');
+      await this.openAPIRefreshStatus();
+    });
   }
 
   private async openAPIRefreshStatus() {
+    this.platform.debug('Curtains OpenAPI Device RefreshStatus');
     try {
       this.deviceStatus = (await this.platform.axios.get(`${DeviceURL}/${this.device.deviceId}/status`)).data;
       this.platform.debug(`Curtain ${this.accessory.displayName} refreshStatus: ${JSON.stringify(this.deviceStatus)}`);
-      this.setMinMax();
       this.parseStatus();
       this.updateHomeKitCharacteristics();
     } catch (e: any) {
@@ -355,6 +402,15 @@ export class Curtain {
 
   private async BLEpushChanges() {
     this.platform.device('Curtains BLE Device pushChanges');
+    const switchbot = this.connectBLE();
+    switchbot.discover({ model: 'c', quick: true, id: this.device.bleMac }).then((device_list) => {
+      this.platform.log.info(`${this.accessory.displayName}, Target Position: ${this.TargetPosition}`);
+      return device_list[0].runToPos(100 - Number(this.TargetPosition));
+    }).then(() => {
+      this.platform.device('Done.');
+    }).catch((e: any) => {
+      this.platform.log.error(`BLE pushChanges Error Message: ${e.message}`);
+    });
   }
 
   private async OpenAPIpushChanges() {
@@ -380,7 +436,6 @@ export class Curtain {
       this.platform.debug(`Curtain ${this.accessory.displayName} pushchanges: ${JSON.stringify(payload)}`);
 
       // Make the API request
-      this.platform.log.error(this.device.deviceId!);
       const push: any = (await this.platform.axios.post(`${DeviceURL}/${this.device.deviceId!}/commands`, payload));
       this.platform.debug(`Curtain ${this.accessory.displayName} Changes pushed: ${JSON.stringify(push.data)}`);
       this.statusCode(push);
@@ -390,13 +445,12 @@ export class Curtain {
   updateHomeKitCharacteristics() {
     this.platform.debug(
       `Curtain ${this.accessory.displayName} updateHomeKitCharacteristics - ${JSON.stringify({
-        CurrentPosition: Number.isNaN(this.CurrentPosition),
+        CurrentPosition: this.CurrentPosition,
         PositionState: this.PositionState,
-        TargetPosition: Number.isNaN(this.TargetPosition),
+        TargetPosition: this.TargetPosition,
         CurrentAmbientLightLevel: this.CurrentAmbientLightLevel,
       })}`,
     );
-    this.setMinMax();
     if (this.CurrentPosition === undefined) {
       this.platform.debug(`Curtain ${this.accessory.displayName} CurrentPosition: ${this.CurrentPosition}`);
     } else {
@@ -421,6 +475,20 @@ export class Curtain {
       this.lightSensorService.updateCharacteristic(this.platform.Characteristic.CurrentAmbientLightLevel, this.CurrentAmbientLightLevel);
       this.platform.device(`Curtain ${this.accessory.displayName} updateCharacteristic CurrentAmbientLightLevel: ${this.CurrentAmbientLightLevel}`);
     }
+    if (this.device.ble) {
+      if (this.BatteryLevel === undefined) {
+        this.platform.debug(`Curtain ${this.accessory.displayName} BatteryLevel: ${this.BatteryLevel}`);
+      } else {
+        this.batteryService?.updateCharacteristic(this.platform.Characteristic.BatteryLevel, this.BatteryLevel);
+        this.platform.device(`Curtain ${this.accessory.displayName} updateCharacteristic BatteryLevel: ${this.BatteryLevel}`);
+      }
+      if (this.StatusLowBattery === undefined) {
+        this.platform.debug(`Curtain ${this.accessory.displayName} StatusLowBattery: ${this.StatusLowBattery}`);
+      } else {
+        this.batteryService?.updateCharacteristic(this.platform.Characteristic.StatusLowBattery, this.StatusLowBattery);
+        this.platform.device(`Curtain ${this.accessory.displayName} updateCharacteristic StatusLowBattery: ${this.StatusLowBattery}`);
+      }
+    }
   }
 
   public apiError(e: any) {
@@ -428,9 +496,13 @@ export class Curtain {
     this.service.updateCharacteristic(this.platform.Characteristic.PositionState, e);
     this.service.updateCharacteristic(this.platform.Characteristic.TargetPosition, e);
     this.lightSensorService.updateCharacteristic(this.platform.Characteristic.CurrentAmbientLightLevel, e);
+    if (this.device.ble) {
+      this.batteryService!.updateCharacteristic(this.platform.Characteristic.BatteryLevel, e);
+      this.batteryService!.updateCharacteristic(this.platform.Characteristic.StatusLowBattery, e);
+    }
   }
 
-  private statusCode(push: { data: { statusCode: any; }; }) {
+  private statusCode(push: AxiosResponse<{ statusCode: number; }>) {
     switch (push.data.statusCode) {
       case 151:
         this.platform.log.error('Command not supported by this device type.');
@@ -462,215 +534,35 @@ export class Curtain {
    * Handle requests to set the value of the "Target Position" characteristic
    */
   TargetPositionSet(value: CharacteristicValue) {
-    if (this.device.ble) {
-      this.TargetPosition = value as number;
-      this.platform.log.info('Target position of Curtain setting: ' + this.TargetPosition + '%');
-      clearTimeout(this.moveTimer);
-      if (this.TargetPosition > this.CurrentPosition) {
-        this.PositionState = this.platform.Characteristic.PositionState.INCREASING;
-      } else if (this.TargetPosition < this.CurrentPosition) {
-        this.PositionState = this.platform.Characteristic.PositionState.DECREASING;
-      } else {
-        this.PositionState = this.platform.Characteristic.PositionState.STOPPED;
-      }
+    this.platform.debug(`Curtain ${this.accessory.displayName} - Set TargetPosition: ${value}`);
 
-      if (this.PositionState === this.platform.Characteristic.PositionState.STOPPED) {
-        this.service?.getCharacteristic(this.platform.Characteristic.TargetPosition).updateValue(this.TargetPosition);
-        this.service?.getCharacteristic(this.platform.Characteristic.CurrentPosition).updateValue(this.CurrentPosition);
-        this.service?.getCharacteristic(this.platform.Characteristic.PositionState).updateValue(this.PositionState);
-      } else {
-        this.runToPosition(this.convertFromHomeKitPosition(this.TargetPosition))
-          .then(() => {
-            this.platform.log.info('Done.');
-            this.platform.log.info('Target position of Curtain has been set to: ' + this.TargetPosition + '%');
-            this.moveTimer = setTimeout(() => {
-              // log.info("setTimeout", this.positionState.toString(), this.currentPosition.toString(), this.targetPosition.toString());
-              this.PositionState = this.platform.Characteristic.PositionState.STOPPED;
-              // this.curtainService?.getCharacteristic(hap.Characteristic.TargetPosition).updateValue(this.targetPosition);
-              this.service?.getCharacteristic(this.platform.Characteristic.CurrentPosition).updateValue(this.CurrentPosition);
-              this.service?.getCharacteristic(this.platform.Characteristic.PositionState).updateValue(this.PositionState);
-            }, this.moveTime);
-          })
-          .catch((error: any) => {
-            this.platform.log.error(error);
-            this.moveTimer = setTimeout(() => {
-              this.TargetPosition = this.CurrentPosition;
-              this.PositionState = this.platform.Characteristic.PositionState.STOPPED;
-              this.service?.getCharacteristic(this.platform.Characteristic.TargetPosition).updateValue(this.TargetPosition);
-              // this.curtainService?.getCharacteristic(hap.Characteristic.CurrentPosition).updateValue(this.currentPosition);
-              this.service?.getCharacteristic(this.platform.Characteristic.PositionState).updateValue(this.PositionState);
-            }, 1000);
-            this.platform.log.info('Target position of Curtain failed to be set to: ' + this.TargetPosition + '%');
-          });
-      }
-    } else {
-      this.platform.debug(`Curtain ${this.accessory.displayName} - Set TargetPosition: ${value}`);
+    this.TargetPosition = value;
 
-      this.TargetPosition = value;
-
-      if (value > this.CurrentPosition) {
-        this.PositionState = this.platform.Characteristic.PositionState.INCREASING;
-        this.setNewTarget = true;
-        this.setMinMax();
-      } else if (value < this.CurrentPosition) {
-        this.PositionState = this.platform.Characteristic.PositionState.DECREASING;
-        this.setNewTarget = true;
-        this.setMinMax();
-      } else {
-        this.PositionState = this.platform.Characteristic.PositionState.STOPPED;
-        this.setNewTarget = false;
-        this.setMinMax();
-      }
-      this.service.setCharacteristic(this.platform.Characteristic.PositionState, this.PositionState);
-
-      /**
-     * If Curtain movement time is short, the moving flag from backend is always false.
-     * The minimum time depends on the network control latency.
-     */
-      clearTimeout(this.setNewTargetTimer);
-      if (this.setNewTarget) {
-        this.setNewTargetTimer = setTimeout(() => {
-          this.platform.debug(`Curtain ${this.accessory.displayName} - setNewTarget ${this.setNewTarget} timeout`);
-          this.setNewTarget = false;
-        }, 10000);
-      }
-      this.doCurtainUpdate.next();
-    }
-  }
-
-  /**
-   * Convert to/from device/HomeKit's position, since:
-   *
-   * - opened is 0% in HomeKit and 100% in Curtain device.
-   * - closed is 100% in HomeKit, 0% in Curtain device.
-   */
-  convertFromHomeKitPosition(n: number): number {
-    let covertToDevicePosition: number;
-    if (this.ReverseDir) {
-      covertToDevicePosition = n;
+    this.setMinMax();
+    if (value > this.CurrentPosition) {
+      this.PositionState = this.platform.Characteristic.PositionState.INCREASING;
+      this.setNewTarget = true;
+    } else if (value < this.CurrentPosition) {
+      this.PositionState = this.platform.Characteristic.PositionState.DECREASING;
+      this.setNewTarget = true;
     } else {
-      covertToDevicePosition = 100 - n;
+      this.PositionState = this.platform.Characteristic.PositionState.STOPPED;
+      this.setNewTarget = false;
     }
-    return covertToDevicePosition;
-  }
-
-  /**
-   * Ask the device to start moving to the given position (which must be a device value and not an HomeKit value).
-   * Returns a Promise that's resolved as soon as the command was sent to the device.
-   */
-  public async runToPosition(pos: number): Promise<void> {
-    const SwitchBot = require('node-switchbot');
-    const switchbot = new SwitchBot();
-
-    return switchbot
-      .discover({ duration: this.ScanDuration, model: 'c', quick: false })
-      .then((device_list: any) => {
-        let targetDevice: any = null;
-
-        for (const device of device_list) {
-          this.platform.log.info(device.modelName, device.address);
-          if (device.address === this.device.bleMac!.toLowerCase()) {
-            targetDevice = device;
-            break;
-          }
-        }
-
-        if (!targetDevice) {
-          return new Promise((resolve, reject) => {
-            reject(new Error('Curtain \'' + this.device.deviceName + '\' (' + this.device.bleMac!.toLowerCase() + '): device not found.'));
-          });
-        }
-
-        this.startFastScan();
-
-        this.platform.log.info(`Curtain ${this.device.deviceName} (${this.device.bleMac!.toLowerCase()}) is moving to ${pos}...`);
-        return targetDevice.runToPos(pos);
-      });
-  }
+    this.service.setCharacteristic(this.platform.Characteristic.PositionState, this.PositionState);
 
-  /**
-   * Start a faster scan loop (using fastScanInterval). Used in calls to `runToPosition` to
-   * report quicker on device position change. Will disable on its own as soon if the curtain's
-   * device position does not change for more than `fastScanDuration`.
+    /**
+   * If Curtain movement time is short, the moving flag from backend is always false.
+   * The minimum time depends on the network control latency.
    */
-  private startFastScan() {
-    if (this.FastScanEnabled) {
-      return;
-    }
-    this.FastScanEnabled = true;
-    this.startScanLoop();
-  }
-
-  private stopFastScan() {
-    if (!this.FastScanEnabled) {
-      return;
-    }
-    this.FastScanEnabled = false;
-    this.startScanLoop();
-  }
-
-  private get scanInterval(): number {
-    return this.FastScanEnabled ? this.FastScanInterval : this.SlowScanInterval;
-  }
-
-  private startScanLoop() {
-    if (this.ScanIntervalId !== null) {
-      clearInterval(this.ScanIntervalId);
-    }
-
-    this.platform.log.info(`Curtain ${this.device.deviceName}: starting scan loop with interval ${this.scanInterval}`);
-
-    this.ScanIntervalId = setInterval(() => {
-      this.scan().catch((err) => {
-        this.platform.log.error(`error while scanning for Curtain ${this.device.deviceName}: ${err}`);
-      });
-    }, this.scanInterval);
-  }
-
-  private scan(): Promise<void> {
-    return new Promise((resolve, reject) => {
-      const SwitchBot = require('node-switchbot');
-      const switchbot = new SwitchBot();
-      switchbot.onadvertisement = (ad: any) => {
-        this.applyPosition(ad);
-      };
-      switchbot.startScan({ id: this.device.bleMac!.toLowerCase() })
-        .then(() => {
-          return switchbot.wait(this.ScanDuration);
-        })
-        .then(() => {
-          resolve();
-          switchbot.stopScan();
-        })
-        .catch((err: any) => {
-          reject(err);
-        });
-    });
-  }
-
-  private applyPosition(ad: any) {
-    let pos = ad.serviceData.position;
-
-    if (pos + this.OpenCloseThreshold >= 100) {
-      pos = 100;
-    } else if (pos - this.OpenCloseThreshold <= 0) {
-      pos = 0;
-    }
-
-    if (pos === this.PreviousPosition) {
-      return;
-    }
-
-    this.PreviousPosition = this.Position;
-    this.Position = pos;
-
-    if (this.AutoDisableFastScanTimeoutId !== null) {
-      clearTimeout(this.AutoDisableFastScanTimeoutId);
+    clearTimeout(this.setNewTargetTimer);
+    if (this.setNewTarget) {
+      this.setNewTargetTimer = setTimeout(() => {
+        this.platform.debug(`Curtain ${this.accessory.displayName} - setNewTarget ${this.setNewTarget} timeout`);
+        this.setNewTarget = false;
+      }, 10000);
     }
-
-    this.AutoDisableFastScanTimeoutId = setTimeout(() => {
-      this.stopFastScan();
-    }, this.FastScanDuration);
+    this.doCurtainUpdate.next();
   }
 
   public setMinMax() {