@switchbot/homebridge-switchbot 1.12.7-beta.5 → 1.12.7

package/package.json

@@ -1,80 +1,80 @@
 {
-    "displayName": "Homebridge SwitchBot",
-    "name": "@switchbot/homebridge-switchbot",
-    "version": "1.12.7-beta.5",
-    "description": "The [Homebridge](https://homebridge.io) SwitchBot plugin allows you to access your [SwitchBot](https://www.switch-bot.com) device(s) from HomeKit.",
-    "author": "SwitchBot <support@wondertechlabs.com> (https://github.com/SwitchBot)",
-    "license": "ISC",
-    "repository": {
-        "type": "git",
-        "url": "git://github.com/OpenWonderLabs/homebridge-switchbot.git"
+  "displayName": "Homebridge SwitchBot",
+  "name": "@switchbot/homebridge-switchbot",
+  "version": "1.12.7",
+  "description": "The [Homebridge](https://homebridge.io) SwitchBot plugin allows you to access your [SwitchBot](https://www.switch-bot.com) device(s) from HomeKit.",
+  "author": "SwitchBot <support@wondertechlabs.com> (https://github.com/SwitchBot)",
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/OpenWonderLabs/homebridge-switchbot.git"
+  },
+  "bugs": {
+    "url": "https://github.com/OpenWonderLabs/homebridge-switchbot/issues"
+  },
+  "engines": {
+    "homebridge": "^1.4.0",
+    "node": "^14.19.0 || ^16.14.0"
+  },
+  "main": "dist/index.js",
+  "scripts": {
+    "check": "npm install && npm outdated",
+    "update": "ncu -u && npm update && npm install",
+    "lint": "eslint src/**.ts",
+    "watch": "npm run build && npm link && nodemon",
+    "build": "rimraf ./dist && tsc",
+    "prepublishOnly": "npm run lint && npm run build",
+    "postpublish": "npm run clean",
+    "clean": "rimraf ./dist",
+    "test": "eslint src/**.ts"
+  },
+  "funding": [
+    {
+      "type": "Paypal",
+      "url": "https://paypal.me/donavanbecker"
     },
-    "bugs": {
-        "url": "https://github.com/OpenWonderLabs/homebridge-switchbot/issues"
-    },
-    "engines": {
-        "homebridge": "^1.4.0",
-        "node": "^14.19.0 || ^16.14.0"
-    },
-    "main": "dist/index.js",
-    "scripts": {
-        "check": "npm install && npm outdated",
-        "update": "ncu -u && npm update && npm install",
-        "lint": "eslint src/**.ts",
-        "watch": "npm run build && npm link && nodemon",
-        "build": "rimraf ./dist && tsc",
-        "prepublishOnly": "npm run lint && npm run build",
-        "postpublish": "npm run clean",
-        "clean": "rimraf ./dist",
-        "test": "eslint src/**.ts"
-    },
-    "funding": [
-        {
-            "type": "Paypal",
-            "url": "https://paypal.me/donavanbecker"
-        },
-        {
-            "type": "GitHub",
-            "url": "https://github.com/sponsors/donavanbecker"
-        }
-    ],
-    "publishConfig": {
-        "access": "public"
-    },
-    "keywords": [
-        "homebridge-plugin",
-        "switchbot",
-        "humidifier",
-        "humidity",
-        "temperature",
-        "bot",
-        "curtains",
-        "windows",
-        "ble",
-        "ir"
-    ],
-    "dependencies": {
-        "@homebridge/plugin-ui-utils": "^0.0.19",
-        "axios": "^0.26.0",
-        "rxjs": "^7.5.4"
-    },
-    "devDependencies": {
-        "@types/node": "^17.0.21",
-        "@typescript-eslint/eslint-plugin": "^5.13.0",
-        "@typescript-eslint/parser": "^5.13.0",
-        "eslint": "^8.10.0",
-        "eslint-config-prettier": "8.5.0",
-        "eslint-plugin-prettier": "4.0.0",
-        "homebridge": "^1.4.0",
-        "nodemon": "^2.0.15",
-        "npm-check-updates": "^12.5.2",
-        "prettier": "2.5.1",
-        "rimraf": "^3.0.2",
-        "ts-node": "^10.6.0",
-        "typescript": "^4.6.2",
-        "typescript-axios-wb": "^1.0.3"
-    },
-    "optionalDependencies": {
-        "node-switchbot": "^1.2.1-beta.0"
+    {
+      "type": "GitHub",
+      "url": "https://github.com/sponsors/donavanbecker"
     }
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "homebridge-plugin",
+    "switchbot",
+    "humidifier",
+    "humidity",
+    "temperature",
+    "bot",
+    "curtains",
+    "windows",
+    "ble",
+    "ir"
+  ],
+  "dependencies": {
+    "@homebridge/plugin-ui-utils": "^0.0.19",
+    "axios": "^0.26.0",
+    "rxjs": "^7.5.4"
+  },
+  "devDependencies": {
+    "@types/node": "^17.0.21",
+    "@typescript-eslint/eslint-plugin": "^5.14.0",
+    "@typescript-eslint/parser": "^5.14.0",
+    "eslint": "^8.10.0",
+    "eslint-config-prettier": "8.5.0",
+    "eslint-plugin-prettier": "4.0.0",
+    "homebridge": "^1.4.0",
+    "nodemon": "^2.0.15",
+    "npm-check-updates": "^12.5.2",
+    "prettier": "2.5.1",
+    "rimraf": "^3.0.2",
+    "ts-node": "^10.7.0",
+    "typescript": "^4.6.2",
+    "typescript-axios-wb": "^1.0.3"
+  },
+  "optionalDependencies": {
+    "node-switchbot": "^1.2.0"
+  }
 }

package/src/device/bot.ts

@@ -95,7 +95,7 @@ export class Bot {
       .setCharacteristic(this.platform.Characteristic.Model, 'SWITCHBOT-BOT-S1')
       .setCharacteristic(this.platform.Characteristic.SerialNumber, device.deviceId!);
 
-    // get the LightBulb service if it exists, otherwise create a new LightBulb service
+    // get the service if it exists, otherwise create a new service
     // you can create multiple services for each accessory
     if (device.bot?.deviceType === 'switch') {
       this.removeFanService(accessory);
@@ -602,7 +602,7 @@ export class Bot {
         .deviceId!.match(/.{1,2}/g)!
         .join(':')
         .toLowerCase();
-      this.debugLog(`Curtain: ${this.accessory.displayName} BLE Address: ${this.device.bleMac}`);
+      this.debugLog(`Bot: ${this.accessory.displayName} BLE Address: ${this.device.bleMac}`);
       //if (switchbot !== false) {
       if (this.botMode === 'press') {
         this.debugLog(`Bot: ${this.accessory.displayName} Bot Mode: ${this.botMode}`);

package/src/device/colorbulb.ts

@@ -82,7 +82,7 @@ export class ColorBulb {
     accessory
       .getService(this.platform.Service.AccessoryInformation)!
       .setCharacteristic(this.platform.Characteristic.Manufacturer, 'SwitchBot')
-      .setCharacteristic(this.platform.Characteristic.Model, this.model(device))
+      .setCharacteristic(this.platform.Characteristic.Model, 'W1401400')
       .setCharacteristic(this.platform.Characteristic.SerialNumber, device.deviceId!);
 
     // get the Lightbulb service if it exists, otherwise create a new Lightbulb service
@@ -94,7 +94,7 @@ export class ColorBulb {
       this.accessory.removeService(this.lightBulbService);
       this.lightBulbService = this.accessory.addService(this.platform.Service.Lightbulb);
       this.accessory.context.adaptiveLighting = false;
-      this.debugLog(`${device.deviceType}: ${this.accessory.displayName} adaptiveLighting: ${this.accessory.context.adaptiveLighting}`);
+      this.debugLog(`Color Bulb: ${this.accessory.displayName} adaptiveLighting: ${this.accessory.context.adaptiveLighting}`);
     }
 
     // To avoid "Cannot add a Service with the same UUID another Service without also defining a unique 'subtype' property." error,
@@ -162,7 +162,7 @@ export class ColorBulb {
       })
       .onSet(this.SaturationSet.bind(this));
 
-    this.debugLog(`${device.deviceType}: ${this.accessory.displayName} adaptiveLightingShift: ${this.adaptiveLightingShift}`);
+    this.debugLog(`Color Bulb: ${this.accessory.displayName} adaptiveLightingShift: ${this.adaptiveLightingShift}`);
     if (this.adaptiveLightingShift !== -1) {
       this.AdaptiveLightingController = new platform.api.hap.AdaptiveLightingController(this.lightBulbService, {
         customTemperatureAdjustment: this.adaptiveLightingShift,
@@ -170,7 +170,7 @@ export class ColorBulb {
       this.accessory.configureController(this.AdaptiveLightingController);
       this.accessory.context.adaptiveLighting = true;
       this.debugLog(
-        `${device.deviceType}: ${this.accessory.displayName} adaptiveLighting: ${this.accessory.context.adaptiveLighting},` +
+        `Color Bulb: ${this.accessory.displayName} adaptiveLighting: ${this.accessory.context.adaptiveLighting},` +
           ` adaptiveLightingShift: ${this.adaptiveLightingShift}`,
       );
     }
@@ -198,9 +198,9 @@ export class ColorBulb {
         try {
           await this.pushChanges();
         } catch (e: any) {
-          this.errorLog(`${device.deviceType}: ${this.accessory.displayName} failed pushChanges`);
+          this.errorLog(`Color Bulb: ${this.accessory.displayName} failed pushChanges`);
           if (this.deviceLogging.includes('debug')) {
-            this.errorLog(`${device.deviceType}: ${this.accessory.displayName} failed pushChanges,` + ` Error Message: ${JSON.stringify(e.message)}`);
+            this.errorLog(`Color Bulb: ${this.accessory.displayName} failed pushChanges,` + ` Error Message: ${JSON.stringify(e.message)}`);
           }
           this.apiError(e);
         }
@@ -216,43 +216,43 @@ export class ColorBulb {
       default:
         this.On = false;
     }
-    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} On: ${this.On}`);
+    this.debugLog(`Color Bulb: ${this.accessory.displayName} On: ${this.On}`);
 
     // Brightness
     this.Brightness = Number(this.brightness);
-    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Brightness: ${this.Brightness}`);
+    this.debugLog(`Color Bulb: ${this.accessory.displayName} Brightness: ${this.Brightness}`);
 
     // Color, Hue & Brightness
     if (this.color) {
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} color: ${JSON.stringify(this.color)}`);
+      this.debugLog(`Color Bulb: ${this.accessory.displayName} color: ${JSON.stringify(this.color)}`);
       const [red, green, blue] = this.color!.split(':');
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} red: ${JSON.stringify(red)}`);
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} green: ${JSON.stringify(green)}`);
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} blue: ${JSON.stringify(blue)}`);
+      this.debugLog(`Color Bulb: ${this.accessory.displayName} red: ${JSON.stringify(red)}`);
+      this.debugLog(`Color Bulb: ${this.accessory.displayName} green: ${JSON.stringify(green)}`);
+      this.debugLog(`Color Bulb: ${this.accessory.displayName} blue: ${JSON.stringify(blue)}`);
 
       const [hue, saturation] = rgb2hs(Number(red), Number(green), Number(blue));
       this.debugLog(
-        `${this.device.deviceType}: ${this.accessory.displayName} hs: ${JSON.stringify(rgb2hs(Number(red), Number(green), Number(blue)))}`,
+        `Color Bulb: ${this.accessory.displayName} hs: ${JSON.stringify(rgb2hs(Number(red), Number(green), Number(blue)))}`,
       );
 
       // Hue
       this.Hue = hue;
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Hue: ${this.Hue}`);
+      this.debugLog(`Color Bulb: ${this.accessory.displayName} Hue: ${this.Hue}`);
 
       // Saturation
       this.Saturation = saturation;
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Saturation: ${this.Saturation}`);
+      this.debugLog(`Color Bulb: ${this.accessory.displayName} Saturation: ${this.Saturation}`);
     }
 
     // ColorTemperature
     if (!Number.isNaN(this.colorTemperature)) {
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} OpenAPI ColorTemperature: ${this.colorTemperature}`);
+      this.debugLog(`Color Bulb: ${this.accessory.displayName} OpenAPI ColorTemperature: ${this.colorTemperature}`);
       const mired = Math.round(1000000 / this.colorTemperature!);
 
       this.ColorTemperature = Number(mired);
 
       this.ColorTemperature = Math.max(Math.min(this.ColorTemperature, 500), 140);
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} ColorTemperature: ${this.ColorTemperature}`);
+      this.debugLog(`Color Bulb: ${this.accessory.displayName} ColorTemperature: ${this.ColorTemperature}`);
     }
 
   }
@@ -260,7 +260,7 @@ export class ColorBulb {
   async refreshStatus(): Promise<void> {
     try {
       this.deviceStatus = (await this.platform.axios.get(`${DeviceURL}/${this.device.deviceId}/status`)).data;
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} refreshStatus: ${JSON.stringify(this.deviceStatus)}`);
+      this.debugLog(`Color Bulb: ${this.accessory.displayName} refreshStatus: ${JSON.stringify(this.deviceStatus)}`);
       this.power = this.deviceStatus.body.power;
       this.color = this.deviceStatus.body.color;
       this.brightness = this.deviceStatus.body.brightness;
@@ -269,10 +269,10 @@ export class ColorBulb {
       this.parseStatus();
       this.updateHomeKitCharacteristics();
     } catch (e: any) {
-      this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed refreshStatus with OpenAPI Connection`);
+      this.errorLog(`Color Bulb: ${this.accessory.displayName} failed refreshStatus with OpenAPI Connection`);
       if (this.deviceLogging.includes('debug')) {
         this.errorLog(
-          `${this.device.deviceType}: ${this.accessory.displayName} failed refreshStatus with OpenAPI Connection,` +
+          `Color Bulb: ${this.accessory.displayName} failed refreshStatus with OpenAPI Connection,` +
             ` Error Message: ${JSON.stringify(e.message)}`,
         );
       }
@@ -289,11 +289,6 @@ export class ColorBulb {
    * Color Bulb   -    "command"         "setBrightness"	             "{1-100}"	              =        set brightness
    * Color Bulb   -    "command"           "setColor"	         "{0-255}:{0-255}:{0-255}"	      =        set RGB color value
    * Color Bulb   -    "command"     "setColorTemperature"	         "{2700-6500}"	            =        set color temperature
-   * Strip Light  -    "command"            "turnOn"                   "default"                =        set to ON state |
-   * Strip Light  -    "command"           "turnOff"                   "default"                =        set to OFF state |
-   * Strip Light  -    "command"            "toggle"                   "default"                =        toggle state |
-   * Strip Light  -    "command"        "setBrightness"               "`{1-100}`"               =        set brightness |
-   * Strip Light  -    "command"          "setColor"           "`"{0-255}:{0-255}:{0-255}"`"    =        set RGB color value |
    *
    */
   async pushChanges(): Promise<void> {
@@ -312,13 +307,13 @@ export class ColorBulb {
         }
 
         this.infoLog(
-          `${this.device.deviceType}: ${this.accessory.displayName} Sending request to SwitchBot API. command: ${payload.command},` +
+          `Color Bulb: ${this.accessory.displayName} Sending request to SwitchBot API. command: ${payload.command},` +
             ` parameter: ${payload.parameter}, commandType: ${payload.commandType}`,
         );
 
         // Make the API request
         const push: any = await this.platform.axios.post(`${DeviceURL}/${this.device.deviceId}/commands`, payload);
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} pushChanges: ${JSON.stringify(push.data)}`);
+        this.debugLog(`Color Bulb: ${this.accessory.displayName} pushChanges: ${JSON.stringify(push.data)}`);
         this.statusCode(push);
         this.OnCached = this.On;
         this.accessory.context.On = this.OnCached;
@@ -338,10 +333,10 @@ export class ColorBulb {
         await this.pushHueSaturationChanges();
       }
     } catch (e: any) {
-      this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed pushChanges with OpenAPI Connection`);
+      this.errorLog(`Color Bulb: ${this.accessory.displayName} failed pushChanges with OpenAPI Connection`);
       if (this.deviceLogging.includes('debug')) {
         this.errorLog(
-          `${this.device.deviceType}: ${this.accessory.displayName} failed pushChanges with OpenAPI Connection,` +
+          `Color Bulb: ${this.accessory.displayName} failed pushChanges with OpenAPI Connection,` +
             ` Error Message: ${JSON.stringify(e.message)}`,
         );
       }
@@ -352,11 +347,11 @@ export class ColorBulb {
   async pushHueSaturationChanges(): Promise<void> {
     try {
       if (this.Hue !== this.HueCached || this.Saturation !== this.SaturationCached) {
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Hue: ${JSON.stringify(this.Hue)}`);
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Saturation: ${JSON.stringify(this.Saturation)}`);
+        this.debugLog(`Color Bulb: ${this.accessory.displayName} Hue: ${JSON.stringify(this.Hue)}`);
+        this.debugLog(`Color Bulb: ${this.accessory.displayName} Saturation: ${JSON.stringify(this.Saturation)}`);
 
         const [red, green, blue] = hs2rgb(Number(this.Hue), Number(this.Saturation));
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} rgb: ${JSON.stringify([red, green, blue])}`);
+        this.debugLog(`Color Bulb: ${this.accessory.displayName} rgb: ${JSON.stringify([red, green, blue])}`);
 
         const payload = {
           commandType: 'command',
@@ -365,27 +360,27 @@ export class ColorBulb {
         } as payload;
 
         this.infoLog(
-          `${this.device.deviceType}: ${this.accessory.displayName} Sending request to SwitchBot API. command: ${payload.command},` +
+          `Color Bulb: ${this.accessory.displayName} Sending request to SwitchBot API. command: ${payload.command},` +
             ` parameter: ${payload.parameter}, commandType: ${payload.commandType}`,
         );
 
         // Make the API request
         const push: any = await this.platform.axios.post(`${DeviceURL}/${this.device.deviceId}/commands`, payload);
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} pushChanges: ${JSON.stringify(push.data)}`);
+        this.debugLog(`Color Bulb: ${this.accessory.displayName} pushChanges: ${JSON.stringify(push.data)}`);
         this.statusCode(push);
         this.HueCached = this.Hue;
         this.SaturationCached = this.Saturation;
       } else {
         this.debugLog(
-          `${this.device.deviceType}: ${this.accessory.displayName} No Changes.` +
+          `Color Bulb: ${this.accessory.displayName} No Changes.` +
             `Hue: ${this.Hue}, HueCached: ${this.HueCached}, Saturation: ${this.Saturation}, SaturationCached: ${this.SaturationCached}`,
         );
       }
     } catch (e: any) {
-      this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed pushChanges with OpenAPI Connection`);
+      this.errorLog(`Color Bulb: ${this.accessory.displayName} failed pushChanges with OpenAPI Connection`);
       if (this.deviceLogging.includes('debug')) {
         this.errorLog(
-          `${this.device.deviceType}: ${this.accessory.displayName} failed pushChanges with OpenAPI Connection,` +
+          `Color Bulb: ${this.accessory.displayName} failed pushChanges with OpenAPI Connection,` +
             ` Error Message: ${JSON.stringify(e.message)}`,
         );
       }
@@ -406,26 +401,26 @@ export class ColorBulb {
         } as payload;
 
         this.infoLog(
-          `${this.device.deviceType}: ${this.accessory.displayName} Sending request to SwitchBot API. command: ${payload.command},` +
+          `Color Bulb: ${this.accessory.displayName} Sending request to SwitchBot API. command: ${payload.command},` +
             ` parameter: ${payload.parameter}, commandType: ${payload.commandType}`,
         );
 
         // Make the API request
         const push: any = await this.platform.axios.post(`${DeviceURL}/${this.device.deviceId}/commands`, payload);
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} pushChanges: ${JSON.stringify(push.data)}`);
+        this.debugLog(`Color Bulb: ${this.accessory.displayName} pushChanges: ${JSON.stringify(push.data)}`);
         this.statusCode(push);
         this.ColorTemperatureCached = this.ColorTemperature;
       } else {
         this.debugLog(
-          `${this.device.deviceType}: ${this.accessory.displayName} No Changes.` +
+          `Color Bulb: ${this.accessory.displayName} No Changes.` +
             `ColorTemperature: ${this.ColorTemperature}, ColorTemperatureCached: ${this.ColorTemperatureCached}`,
         );
       }
     } catch (e: any) {
-      this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed pushChanges with OpenAPI Connection`);
+      this.errorLog(`Color Bulb: ${this.accessory.displayName} failed pushChanges with OpenAPI Connection`);
       if (this.deviceLogging.includes('debug')) {
         this.errorLog(
-          `${this.device.deviceType}: ${this.accessory.displayName} failed pushChanges with OpenAPI Connection,` +
+          `Color Bulb: ${this.accessory.displayName} failed pushChanges with OpenAPI Connection,` +
             ` Error Message: ${JSON.stringify(e.message)}`,
         );
       }
@@ -443,26 +438,26 @@ export class ColorBulb {
         } as payload;
 
         this.infoLog(
-          `${this.device.deviceType}: ${this.accessory.displayName} Sending request to SwitchBot API. command: ${payload.command},` +
+          `Color Bulb: ${this.accessory.displayName} Sending request to SwitchBot API. command: ${payload.command},` +
             ` parameter: ${payload.parameter}, commandType: ${payload.commandType}`,
         );
 
         // Make the API request
         const push: any = await this.platform.axios.post(`${DeviceURL}/${this.device.deviceId}/commands`, payload);
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} pushChanges: ${JSON.stringify(push.data)}`);
+        this.debugLog(`Color Bulb: ${this.accessory.displayName} pushChanges: ${JSON.stringify(push.data)}`);
         this.statusCode(push);
         this.BrightnessCached = this.Brightness;
       } else {
         this.debugLog(
-          `${this.device.deviceType}: ${this.accessory.displayName} No Changes.` +
+          `Color Bulb: ${this.accessory.displayName} No Changes.` +
             `Brightness: ${this.Brightness}, BrightnessCached: ${this.BrightnessCached}`,
         );
       }
     } catch (e: any) {
-      this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed pushChanges with OpenAPI Connection`);
+      this.errorLog(`Color Bulb: ${this.accessory.displayName} failed pushChanges with OpenAPI Connection`);
       if (this.deviceLogging.includes('debug')) {
         this.errorLog(
-          `${this.device.deviceType}: ${this.accessory.displayName} failed pushChanges with OpenAPI Connection,` +
+          `Color Bulb: ${this.accessory.displayName} failed pushChanges with OpenAPI Connection,` +
             ` Error Message: ${JSON.stringify(e.message)}`,
         );
       }
@@ -472,34 +467,34 @@ export class ColorBulb {
 
   async updateHomeKitCharacteristics(): Promise<void> {
     if (this.On === undefined) {
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} On: ${this.On}`);
+      this.debugLog(`Color Bulb: ${this.accessory.displayName} On: ${this.On}`);
     } else {
       this.lightBulbService.updateCharacteristic(this.platform.Characteristic.On, this.On);
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic On: ${this.On}`);
+      this.debugLog(`Color Bulb: ${this.accessory.displayName} updateCharacteristic On: ${this.On}`);
     }
     if (this.Brightness === undefined) {
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Brightness: ${this.Brightness}`);
+      this.debugLog(`Color Bulb: ${this.accessory.displayName} Brightness: ${this.Brightness}`);
     } else {
       this.lightBulbService.updateCharacteristic(this.platform.Characteristic.Brightness, this.Brightness);
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic Brightness: ${this.Brightness}`);
+      this.debugLog(`Color Bulb: ${this.accessory.displayName} updateCharacteristic Brightness: ${this.Brightness}`);
     }
     if (this.ColorTemperature === undefined) {
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} ColorTemperature: ${this.ColorTemperature}`);
+      this.debugLog(`Color Bulb: ${this.accessory.displayName} ColorTemperature: ${this.ColorTemperature}`);
     } else {
       this.lightBulbService.updateCharacteristic(this.platform.Characteristic.ColorTemperature, this.ColorTemperature);
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic ColorTemperature: ${this.ColorTemperature}`);
+      this.debugLog(`Color Bulb: ${this.accessory.displayName} updateCharacteristic ColorTemperature: ${this.ColorTemperature}`);
     }
     if (this.Hue === undefined) {
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Hue: ${this.Hue}`);
+      this.debugLog(`Color Bulb: ${this.accessory.displayName} Hue: ${this.Hue}`);
     } else {
       this.lightBulbService.updateCharacteristic(this.platform.Characteristic.Hue, this.Hue);
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic Hue: ${this.Hue}`);
+      this.debugLog(`Color Bulb: ${this.accessory.displayName} updateCharacteristic Hue: ${this.Hue}`);
     }
     if (this.Saturation === undefined) {
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Saturation: ${this.Saturation}`);
+      this.debugLog(`Color Bulb: ${this.accessory.displayName} Saturation: ${this.Saturation}`);
     } else {
       this.lightBulbService.updateCharacteristic(this.platform.Characteristic.Saturation, this.Saturation);
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic Saturation: ${this.Saturation}`);
+      this.debugLog(`Color Bulb: ${this.accessory.displayName} updateCharacteristic Saturation: ${this.Saturation}`);
     }
   }
 
@@ -515,36 +510,36 @@ export class ColorBulb {
   statusCode(push: AxiosResponse<{ statusCode: number }>): void {
     switch (push.data.statusCode) {
       case 151:
-        this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} Command not supported by this device type.`);
+        this.errorLog(`Color Bulb: ${this.accessory.displayName} Command not supported by this device type.`);
         break;
       case 152:
-        this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} Device not found.`);
+        this.errorLog(`Color Bulb: ${this.accessory.displayName} Device not found.`);
         break;
       case 160:
-        this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} Command is not supported.`);
+        this.errorLog(`Color Bulb: ${this.accessory.displayName} Command is not supported.`);
         break;
       case 161:
-        this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} Device is offline.`);
+        this.errorLog(`Color Bulb: ${this.accessory.displayName} Device is offline.`);
         this.offlineOff();
         break;
       case 171:
-        this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} is offline. Hub: ${this.device.hubDeviceId}`);
+        this.errorLog(`Color Bulb: ${this.accessory.displayName} is offline. Hub: ${this.device.hubDeviceId}`);
         this.offlineOff();
         break;
       case 190:
         this.errorLog(
-          `${this.device.deviceType}: ${this.accessory.displayName} Device internal error due to device states not synchronized with server,` +
+          `Color Bulb: ${this.accessory.displayName} Device internal error due to device states not synchronized with server,` +
             ` Or command: ${JSON.stringify(push.data)} format is invalid`,
         );
         break;
       case 100:
         if (this.platform.debugMode) {
-          this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Command successfully sent.`);
+          this.debugLog(`Color Bulb: ${this.accessory.displayName} Command successfully sent.`);
         }
         break;
       default:
         if (this.platform.debugMode) {
-          this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Unknown statusCode.`);
+          this.debugLog(`Color Bulb: ${this.accessory.displayName} Unknown statusCode.`);
         }
     }
   }
@@ -560,7 +555,7 @@ export class ColorBulb {
    * Handle requests to set the value of the "On" characteristic
    */
   async OnSet(value: CharacteristicValue): Promise<void> {
-    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} On: ${value}`);
+    this.debugLog(`Color Bulb: ${this.accessory.displayName} On: ${value}`);
 
     this.On = value;
     this.doColorBulbUpdate.next();
@@ -570,7 +565,7 @@ export class ColorBulb {
    * Handle requests to set the value of the "Brightness" characteristic
    */
   async BrightnessSet(value: CharacteristicValue): Promise<void> {
-    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Brightness: ${value}`);
+    this.debugLog(`Color Bulb: ${this.accessory.displayName} Brightness: ${value}`);
 
     this.Brightness = value;
     this.doColorBulbUpdate.next();
@@ -580,7 +575,7 @@ export class ColorBulb {
    * Handle requests to set the value of the "ColorTemperature" characteristic
    */
   async ColorTemperatureSet(value: CharacteristicValue): Promise<void> {
-    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} ColorTemperature: ${value}`);
+    this.debugLog(`Color Bulb: ${this.accessory.displayName} ColorTemperature: ${value}`);
 
     // Convert mired to kelvin to nearest 100 (SwitchBot seems to need this)
     const kelvin = Math.round(1000000 / Number(value) / 100) * 100;
@@ -605,7 +600,7 @@ export class ColorBulb {
    * Handle requests to set the value of the "Hue" characteristic
    */
   async HueSet(value: CharacteristicValue): Promise<void> {
-    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Hue: ${value}`);
+    this.debugLog(`Color Bulb: ${this.accessory.displayName} Hue: ${value}`);
 
     this.lightBulbService.updateCharacteristic(this.platform.Characteristic.ColorTemperature, 140);
 
@@ -617,7 +612,7 @@ export class ColorBulb {
    * Handle requests to set the value of the "Saturation" characteristic
    */
   async SaturationSet(value: CharacteristicValue): Promise<void> {
-    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Saturation: ${value}`);
+    this.debugLog(`Color Bulb: ${this.accessory.displayName} Saturation: ${value}`);
 
     this.lightBulbService.updateCharacteristic(this.platform.Characteristic.ColorTemperature, 140);
 
@@ -625,16 +620,6 @@ export class ColorBulb {
     this.doColorBulbUpdate.next();
   }
 
-  model(device: device & devicesConfig): string {
-    let model: string;
-    if (device.deviceType === 'Strip Light') {
-      model = 'W1701100';
-    } else {
-      model = 'W1401400';
-    }
-    return model;
-  }
-
   async config(device: device & devicesConfig): Promise<void> {
     let config = {};
     if (device.colorbulb) {
@@ -656,43 +641,43 @@ export class ColorBulb {
       config['offline'] = device.offline;
     }
     if (Object.entries(config).length !== 0) {
-      this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} Config: ${JSON.stringify(config)}`);
+      this.infoLog(`Color Bulb: ${this.accessory.displayName} Config: ${JSON.stringify(config)}`);
     }
   }
 
   async refreshRate(device: device & devicesConfig): Promise<void> {
     if (device.refreshRate) {
       this.deviceRefreshRate = this.accessory.context.refreshRate = device.refreshRate;
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Device Config refreshRate: ${this.deviceRefreshRate}`);
+      this.debugLog(`Color Bulb: ${this.accessory.displayName} Using Device Config refreshRate: ${this.deviceRefreshRate}`);
     } else if (this.platform.config.options!.refreshRate) {
       this.deviceRefreshRate = this.accessory.context.refreshRate = this.platform.config.options!.refreshRate;
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Platform Config refreshRate: ${this.deviceRefreshRate}`);
+      this.debugLog(`Color Bulb: ${this.accessory.displayName} Using Platform Config refreshRate: ${this.deviceRefreshRate}`);
     }
   }
 
   async logs(device: device & devicesConfig): Promise<void> {
     if (this.platform.debugMode) {
       this.deviceLogging = this.accessory.context.logging = 'debugMode';
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Debug Mode Logging: ${this.deviceLogging}`);
+      this.debugLog(`Color Bulb: ${this.accessory.displayName} Using Debug Mode Logging: ${this.deviceLogging}`);
     } else if (device.logging) {
       this.deviceLogging = this.accessory.context.logging = device.logging;
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Device Config Logging: ${this.deviceLogging}`);
+      this.debugLog(`Color Bulb: ${this.accessory.displayName} Using Device Config Logging: ${this.deviceLogging}`);
     } else if (this.platform.config.options?.logging) {
       this.deviceLogging = this.accessory.context.logging = this.platform.config.options?.logging;
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Platform Config Logging: ${this.deviceLogging}`);
+      this.debugLog(`Color Bulb: ${this.accessory.displayName} Using Platform Config Logging: ${this.deviceLogging}`);
     } else {
       this.deviceLogging = this.accessory.context.logging = 'standard';
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Logging Not Set, Using: ${this.deviceLogging}`);
+      this.debugLog(`Color Bulb: ${this.accessory.displayName} Logging Not Set, Using: ${this.deviceLogging}`);
     }
   }
 
   async adaptiveLighting(device: device & devicesConfig): Promise<void> {
     if (device.colorbulb?.adaptiveLightingShift) {
       this.adaptiveLightingShift = device.colorbulb.adaptiveLightingShift;
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} adaptiveLightingShift: ${this.adaptiveLightingShift}`);
+      this.debugLog(`Color Bulb: ${this.accessory.displayName} adaptiveLightingShift: ${this.adaptiveLightingShift}`);
     } else {
       this.adaptiveLightingShift = 0;
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} adaptiveLightingShift: ${this.adaptiveLightingShift}`);
+      this.debugLog(`Color Bulb: ${this.accessory.displayName} adaptiveLightingShift: ${this.adaptiveLightingShift}`);
     }
   }