homebridge-nest-accfactory 0.0.5 → 0.2.0

package/dist/system.js

@@ -1,7 +1,7 @@
 // Nest System communications
 // Part of homebridge-nest-accfactory
 //
-// Code version 13/9/2024
+// Code version 3/10/2024
 // Mark Hulskamp
 'use strict';
 
@@ -11,7 +11,7 @@ import protobuf from 'protobufjs';
 // Define nodejs module requirements
 import EventEmitter from 'node:events';
 import { Buffer } from 'node:buffer';
-import { setInterval, clearInterval, setTimeout } from 'node:timers';
+import { setInterval, clearInterval, setTimeout, clearTimeout } from 'node:timers';
 import fs from 'node:fs';
 import path from 'node:path';
 import crypto from 'node:crypto';
@@ -55,11 +55,11 @@ export default class NestAccfactory {
 
   static DataSource = {
     REST: 'REST', // From the REST API
-    PROTOBUF: 'PROTOBUF', // From the protobuf API
+    PROTOBUF: 'Protobuf', // From the Protobuf API
   };
 
-  static GoogleConnection = 'google'; // Google account connection
-  static NestConnection = 'nest'; // Nest account connection
+  static GoogleAccount = 'google'; // Google account connection
+  static NestAccount = 'nest'; // Nest account connection
 
   cachedAccessories = []; // Track restored cached accessories
 
@@ -67,6 +67,9 @@ export default class NestAccfactory {
   #connections = {}; // Object of confirmed connections
   #rawData = {}; // Cached copy of data from both Rest and Protobuf APIs
   #eventEmitter = new EventEmitter(); // Used for object messaging from this platform
+  #connectionTimer = undefined;
+  #protobufRoot = null; // Protobuf loaded protos
+  #trackedDevices = {}; // Object of devices we've created. used to track data source type, comms uuid. key'd by serial #
 
   constructor(log, config, api) {
     this.config = config;
@@ -80,7 +83,7 @@ export default class NestAccfactory {
       if (this.config[key]?.access_token !== undefined && this.config[key].access_token !== '') {
         // Nest account connection, assign a random UUID for each connection
         this.#connections[crypto.randomUUID()] = {
-          type: NestAccfactory.NestConnection,
+          type: NestAccfactory.NestAccount,
           authorised: false,
           access_token: this.config[key].access_token,
           fieldTest: this.config[key]?.fieldTest === true,
@@ -98,7 +101,7 @@ export default class NestAccfactory {
       ) {
         // Google account connection, assign a random UUID for each connection
         this.#connections[crypto.randomUUID()] = {
-          type: NestAccfactory.GoogleConnection,
+          type: NestAccfactory.GoogleAccount,
           authorised: false,
           issuetoken: this.config[key].issuetoken,
           cookie: this.config[key].cookie,
@@ -122,14 +125,14 @@ export default class NestAccfactory {
     }
 
     this.config.options.eveHistory = typeof this.config.options?.eveHistory === 'boolean' ? this.config.options.eveHistory : false;
-    this.config.options.elevation = typeof this.config.options?.elevation === 'number' ? this.config.options.elevation : 0;
+    this.config.options.elevation = isNaN(this.config.options?.elevation) === false ? Number(this.config.options.elevation) : 0;
     this.config.options.weather = typeof this.config.options?.weather === 'boolean' ? this.config.options.weather : false;
     this.config.options.hksv = typeof this.config.options?.hksv === 'boolean' ? this.config.options.hksv : false;
 
     // Get configuration for max number of concurrent 'live view' streams. For HomeKit Secure Video, this will always be 1
     this.config.options.maxStreams =
-      typeof this.config.options?.maxStreams === 'number' && this.deviceData?.hksv === false
-        ? this.config.options.maxStreams
+      isNaN(this.config.options?.maxStreams) === false && this.deviceData?.hksv === false
+        ? Number(this.config.options.maxStreams)
         : this.deviceData?.hksv === true
           ? 1
           : 2;
@@ -137,30 +140,37 @@ export default class NestAccfactory {
     // Check if a ffmpeg binary exists in current path OR the specific path via configuration
     // If using HomeBridge, the default path will be where the Homebridge user folder is, otherwise the current directory
     this.config.options.ffmpeg = {};
-    this.config.options.ffmpeg['path'] =
+    this.config.options.ffmpeg.binary = path.resolve(
       typeof this.config.options?.ffmpegPath === 'string' && this.config.options.ffmpegPath !== ''
         ? this.config.options.ffmpegPath
         : typeof api?.user?.storagePath === 'function'
           ? api.user.storagePath()
-          : __dirname;
+          : __dirname,
+    );
+
+    // If the path doesn't include 'ffmpeg' on the end, we'll add it here
+    if (this.config.options.ffmpeg.binary.endsWith('/ffmpeg') === false) {
+      this.config.options.ffmpeg.binary = this.config.options.ffmpeg.binary + '/ffmpeg';
+    }
 
-    this.config.options.ffmpeg['version'] = undefined;
+    this.config.options.ffmpeg.version = undefined;
     this.config.options.ffmpeg.libspeex = false;
+    this.config.options.ffmpeg.libopus = false;
     this.config.options.ffmpeg.libx264 = false;
     this.config.options.ffmpeg.libfdk_aac = false;
 
-    if (fs.existsSync(path.resolve(this.config.options.ffmpeg.path + '/ffmpeg')) === false) {
+    if (fs.existsSync(this.config.options.ffmpeg.binary) === false) {
       if (this?.log?.warn) {
-        this.log.warn('No ffmpeg binary found in "%s"', this.config.options.ffmpeg.path);
+        this.log.warn('Specified ffmpeg binary "%s" was not found', this.config.options.ffmpeg.binary);
         this.log.warn('Stream video/recording from camera/doorbells will be unavailable');
       }
 
       // If we flag ffmpegPath as undefined, no video streaming/record support enabled for camers/doorbells
-      this.config.options.ffmpeg.path = undefined;
+      this.config.options.ffmpeg.binary = undefined;
     }
 
-    if (fs.existsSync(path.resolve(this.config.options.ffmpeg.path + '/ffmpeg')) === true) {
-      let ffmpegProcess = child_process.spawnSync(path.resolve(this.config.options.ffmpeg.path + '/ffmpeg'), ['-version'], {
+    if (fs.existsSync(this.config.options.ffmpeg.binary) === true) {
+      let ffmpegProcess = child_process.spawnSync(this.config.options.ffmpeg.binary, ['-version'], {
         env: process.env,
       });
       if (ffmpegProcess.stdout !== null) {
@@ -171,17 +181,18 @@ export default class NestAccfactory {
 
         // Determine what libraries ffmpeg is compiled with
         this.config.options.ffmpeg.libspeex = ffmpegProcess.stdout.toString().includes('--enable-libspeex') === true;
+        this.config.options.ffmpeg.libopus = ffmpegProcess.stdout.toString().includes('--enable-libopus') === true;
         this.config.options.ffmpeg.libx264 = ffmpegProcess.stdout.toString().includes('--enable-libx264') === true;
         this.config.options.ffmpeg.libfdk_aac = ffmpegProcess.stdout.toString().includes('--enable-libfdk-aac') === true;
-
         if (
           this.config.options.ffmpeg.version.replace(/\./gi, '') < parseFloat(FFMPEGVERSION.toString().replace(/\./gi, '')) ||
           this.config.options.ffmpeg.libspeex === false ||
+          this.config.options.ffmpeg.libopus === false ||
           this.config.options.ffmpeg.libx264 === false ||
           this.config.options.ffmpeg.libfdk_aac === false
         ) {
           this?.log?.warn &&
-            this.log.warn('ffmpeg binary in "%s" does not meet the minimum support requirements', this.config.options.ffmpeg.path);
+            this.log.warn('ffmpeg binary "%s" does not meet the minimum support requirements', this.config.options.ffmpeg.binary);
           if (this.config.options.ffmpeg.version.replace(/\./gi, '') < parseFloat(FFMPEGVERSION.toString().replace(/\./gi, ''))) {
             this?.log?.warn &&
               this.log.warn(
@@ -191,22 +202,41 @@ export default class NestAccfactory {
               );
             this?.log?.warn && this.log.warn('Stream video/recording from camera/doorbells will be unavailable');
 
-            this.config.options.ffmpeg.path = undefined; // No ffmpeg since below min version
+            this.config.options.ffmpeg.binary = undefined; // No ffmpeg since below min version
           }
           if (
             this.config.options.ffmpeg.libspeex === false &&
-            (this.config.options.ffmpeg.libx264 === true && this.config.options.ffmpeg.libfdk_aac) === true
+            this.config.options.ffmpeg.libx264 === true &&
+            this.config.options.ffmpeg.libfdk_aac === true
           ) {
-            this?.log?.warn && this.log.warn('Missing libspeex in ffmpeg binary, two-way audio on camera/doorbells will be unavailable');
+            this?.log?.warn && this.log.warn('Missing libspeex in ffmpeg binary, talkback on certain camera/doorbells will be unavailable');
+          }
+          if (
+            this.config.options.ffmpeg.libx264 === true &&
+            this.config.options.ffmpeg.libfdk_aac === false &&
+            this.config.options.ffmpeg.libopus === false
+          ) {
+            this?.log?.warn &&
+              this.log.warn('Missing libfdk_aac and libopus in ffmpeg binary, audio from camera/doorbells will be unavailable');
           }
           if (this.config.options.ffmpeg.libx264 === true && this.config.options.ffmpeg.libfdk_aac === false) {
             this?.log?.warn && this.log.warn('Missing libfdk_aac in ffmpeg binary, audio from camera/doorbells will be unavailable');
           }
+          if (
+            this.config.options.ffmpeg.libx264 === true &&
+            this.config.options.ffmpeg.libfdk_aac === true &&
+            this.config.options.ffmpeg.libopus === false
+          ) {
+            this?.log?.warn &&
+              this.log.warn(
+                'Missing libopus in ffmpeg binary, audio (including talkback) from certain camera/doorbells will be unavailable',
+              );
+          }
           if (this.config.options.ffmpeg.libx264 === false) {
             this?.log?.warn &&
               this.log.warn('Missing libx264 in ffmpeg binary, stream video/recording from camera/doorbells will be unavailable');
 
-            this.config.options.ffmpeg.path = undefined; // No ffmpeg since we do not have all the required libraries
+            this.config.options.ffmpeg.binary = undefined; // No ffmpeg since we do not have all the required libraries
           }
         }
       }
@@ -216,14 +246,43 @@ export default class NestAccfactory {
       this.api.on('didFinishLaunching', async () => {
         // We got notified that Homebridge has finished loading, so we are ready to process
         this.discoverDevices();
+
+        // We'll check connection status every 15 seconds. We'll also handle token expiry/refresh this way
+        clearInterval(this.#connectionTimer);
+        this.#connectionTimer = setInterval(this.discoverDevices.bind(this), 15000);
       });
 
       this.api.on('shutdown', async () => {
-        // We got notified that Homebridge is shutting down. Perform cleanup??
-        this.#eventEmitter.removeAllListeners(HomeKitDevice.SET);
-        this.#eventEmitter.removeAllListeners(HomeKitDevice.GET);
+        // We got notified that Homebridge is shutting down
+        // Perform cleanup some internal cleaning up
+        this.#eventEmitter.removeAllListeners();
+        Object.values(this.#trackedDevices).forEach((value) => {
+          if (value?.timers !== undefined) {
+            Object.values(value?.timers).forEach((timers) => {
+              clearInterval(timers);
+            });
+          }
+        });
+        this.#trackedDevices = {};
+        clearInterval(this.#connectionTimer);
+        this.#connectionTimer = undefined;
+        this.#rawData = {};
+        this.#protobufRoot = null;
+        this.#eventEmitter = undefined;
       });
     }
+
+    // Setup event listeners for set/get calls from devices if not already done so
+    this.#eventEmitter.addListener(HomeKitDevice.SET, (uuid, values) => {
+      this.#set(uuid, values);
+    });
+    this.#eventEmitter.addListener(HomeKitDevice.GET, async (uuid, values) => {
+      let results = await this.#get(uuid, values);
+      // Send the results back to the device via a special event (only if still active)
+      if (this.#eventEmitter !== undefined) {
+        this.#eventEmitter.emit(HomeKitDevice.GET + '->' + uuid, results);
+      }
+    });
   }
 
   configureAccessory(accessory) {
@@ -235,24 +294,21 @@ export default class NestAccfactory {
   }
 
   async discoverDevices() {
-    // Setup event listeners for set/get calls from devices
-    this.#eventEmitter.addListener(HomeKitDevice.SET, (deviceUUID, values) => this.#set(deviceUUID, values));
-    this.#eventEmitter.addListener(HomeKitDevice.GET, (deviceUUID, values) => this.#get(deviceUUID, values));
-
     Object.keys(this.#connections).forEach((uuid) => {
-      this.#connect(uuid).then(() => {
-        if (this.#connections[uuid].authorised === true) {
-          this.#subscribeREST(uuid, true);
-          this.#subscribeProtobuf(uuid);
-        }
-      });
+      if (this.#connections[uuid].authorised === false) {
+        this.#connect(uuid).then(() => {
+          if (this.#connections[uuid].authorised === true) {
+            this.#subscribeREST(uuid, true);
+            this.#subscribeProtobuf(uuid, true);
+          }
+        });
+      }
     });
   }
 
   async #connect(connectionUUID) {
     if (typeof this.#connections?.[connectionUUID] === 'object') {
-      this.#connections[connectionUUID].authorised === false; // Mark connection as no-longer authorised
-      if (this.#connections[connectionUUID].type === NestAccfactory.GoogleConnection) {
+      if (this.#connections[connectionUUID].type === NestAccfactory.GoogleAccount) {
         // Google cookie method as refresh token method no longer supported by Google since October 2022
         // Instructions from homebridge_nest or homebridge_nest_cam to obtain this
         this?.log?.info &&
@@ -308,7 +364,6 @@ export default class NestAccfactory {
                     this.#connections[connectionUUID].userID = data.userid;
                     this.#connections[connectionUUID].transport_url = data.urls.transport_url;
                     this.#connections[connectionUUID].weather_url = data.urls.weather_url;
-                    this.#connections[connectionUUID].protobufRoot = null;
                     this.#connections[connectionUUID].token = googleToken;
                     this.#connections[connectionUUID].cameraAPI = {
                       key: 'Authorization',
@@ -318,7 +373,7 @@ export default class NestAccfactory {
                     };
 
                     // Set timeout for token expiry refresh
-                    this.#connections[connectionUUID].timer = clearInterval(this.#connections[connectionUUID].timer);
+                    clearTimeout(this.#connections[connectionUUID].timer);
                     this.#connections[connectionUUID].timer = setTimeout(
                       () => {
                         this?.log?.info && this.log.info('Performing periodic token refresh for Google account');
@@ -334,11 +389,17 @@ export default class NestAccfactory {
           // eslint-disable-next-line no-unused-vars
           .catch((error) => {
             // The token we used to obtained a Nest session failed, so overall authorisation failed
+            this.#connections[connectionUUID].authorised = false;
+            this?.log?.debug &&
+              this.log.debug(
+                'Failed to connect using credential details for connection uuid "%s". A periodic retry event will be triggered',
+                connectionUUID,
+              );
             this?.log?.error && this.log.error('Authorisation failed using Google account');
           });
       }
 
-      if (this.#connections[connectionUUID].type === NestAccfactory.NestConnection) {
+      if (this.#connections[connectionUUID].type === NestAccfactory.NestAccount) {
         // Nest access token method. Get WEBSITE2 cookie for use with camera API calls if needed later
         this?.log?.info &&
           this.log.info(
@@ -381,7 +442,6 @@ export default class NestAccfactory {
                 this.#connections[connectionUUID].userID = data.userid;
                 this.#connections[connectionUUID].transport_url = data.urls.transport_url;
                 this.#connections[connectionUUID].weather_url = data.urls.weather_url;
-                this.#connections[connectionUUID].protobufRoot = null;
                 this.#connections[connectionUUID].token = this.#connections[connectionUUID].access_token;
                 this.#connections[connectionUUID].cameraAPI = {
                   key: 'cookie',
@@ -390,7 +450,7 @@ export default class NestAccfactory {
                 };
 
                 // Set timeout for token expiry refresh
-                this.#connections[connectionUUID].timer = clearInterval(this.#connections[connectionUUID].timer);
+                clearTimeout(this.#connections[connectionUUID].timer);
                 this.#connections[connectionUUID].timer = setTimeout(
                   () => {
                     this?.log?.info && this.log.info('Performing periodic token refresh for Nest account');
@@ -405,6 +465,8 @@ export default class NestAccfactory {
           // eslint-disable-next-line no-unused-vars
           .catch((error) => {
             // The token we used to obtained a Nest session failed, so overall authorisation failed
+            this.#connections[connectionUUID].authorised = false;
+            this?.log?.debug && this.log.debug('Failed to connect using credential details for connection uuid "%s"', connectionUUID);
             this?.log?.error && this.log.error('Authorisation failed using Nest account');
           });
       }
@@ -433,13 +495,6 @@ export default class NestAccfactory {
       'widget_track',
       'quartz',
     ];
-    const DEVICEBUCKETS = {
-      structure: ['latitude', 'longitude'],
-      device: ['where_id'],
-      kryptonite: ['where_id', 'structure_id'],
-      topaz: ['where_id', 'structure_id'],
-      quartz: ['where_id', 'structure_id', 'nexus_api_http_server_url'],
-    };
 
     // By default, setup for a full data read from the REST API
     let subscribeURL =
@@ -451,7 +506,7 @@ export default class NestAccfactory {
     let subscribeJSONData = { known_bucket_types: REQUIREDBUCKETS, known_bucket_versions: [] };
 
     if (fullRefresh === false) {
-      // We have data stored from ths REST API, so setup read using known objects
+      // We have data stored from this REST API, so setup read using known object
       subscribeURL = this.#connections[connectionUUID].transport_url + '/v6/subscribe';
       subscribeJSONData = { objects: [] };
 
@@ -467,6 +522,10 @@ export default class NestAccfactory {
         });
     }
 
+    if (fullRefresh === true) {
+      this?.log?.debug && this.log.debug('Starting REST API subscribe for connection uuid "%s"', connectionUUID);
+    }
+
     fetchWrapper(
       'post',
       subscribeURL,
@@ -477,13 +536,12 @@ export default class NestAccfactory {
           Authorization: 'Basic ' + this.#connections[connectionUUID].token,
         },
         keepalive: true,
-        timeout: 300 * 60,
+        //timeout: (5 * 60000),
       },
       JSON.stringify(subscribeJSONData),
     )
       .then((response) => response.json())
       .then(async (data) => {
-        let deviceChanges = []; // No REST API devices changes to start with
         if (typeof data?.updated_buckets === 'object') {
           // This response is full data read
           data = data.updated_buckets;
@@ -555,7 +613,11 @@ export default class NestAccfactory {
                   value.value.properties = data.items[0].properties;
                 })
                 .catch((error) => {
-                  if (error?.name !== 'TimeoutError' && this?.log?.debug) {
+                  if (
+                    error?.cause !== undefined &&
+                    JSON.stringify(error.cause).toUpperCase().includes('TIMEOUT') === false &&
+                    this?.log?.debug
+                  ) {
                     this.log.debug('REST API had error retrieving camera/doorbell details during subscribe. Error was "%s"', error?.code);
                   }
                 });
@@ -591,7 +653,11 @@ export default class NestAccfactory {
                   value.value.activity_zones = zones;
                 })
                 .catch((error) => {
-                  if (error?.name !== 'TimeoutError' && this?.log?.debug) {
+                  if (
+                    error?.cause !== undefined &&
+                    JSON.stringify(error.cause).toUpperCase().includes('TIMEOUT') === false &&
+                    this?.log?.debug
+                  ) {
                     this.log.debug(
                       'REST API had error retrieving camera/doorbell activity zones during subscribe. Error was "%s"',
                       error?.code,
@@ -619,8 +685,30 @@ export default class NestAccfactory {
                     // Object is present in the old buckets list, but not in the new buckets list
                     // so we assume it has been removed
                     // It also could mean device(s) have been removed from Nest
-                    if (Object.keys(DEVICEBUCKETS).includes(object_key.split('.')[0]) === true) {
-                      deviceChanges.push({ object_key: object_key, change: 'remove' });
+                    if (
+                      object_key.startsWith('structure.') === true ||
+                      object_key.startsWith('device.') === true ||
+                      object_key.startsWith('kryptonite.') === true ||
+                      object_key.startsWith('topaz.') === true ||
+                      object_key.startsWith('quartz.') === true
+                    ) {
+                      // Tidy up tracked devices since this one is removed
+                      if (this.#trackedDevices[this.#rawData?.[object_key]?.value?.serial_number] !== undefined) {
+                        // Remove any active running timers we have for this device
+                        Object.values(this.#trackedDevices[this.#rawData[object_key].value.serial_number].timers).forEach((timers) => {
+                          clearInterval(timers);
+                        });
+
+                        // Send removed notice onto HomeKit device for it to process
+                        this.#eventEmitter.emit(
+                          this.#trackedDevices[this.#rawData[object_key].value.serial_number].uuid,
+                          HomeKitDevice.REMOVE,
+                          {},
+                        );
+
+                        // Finally, remove from tracked devices
+                        delete this.#trackedDevices[this.#rawData[object_key].value.serial_number];
+                      }
                     }
                     delete this.#rawData[object_key];
                   }
@@ -635,21 +723,9 @@ export default class NestAccfactory {
               this.#rawData[value.object_key].object_timestamp = value.object_timestamp;
               this.#rawData[value.object_key].connection = connectionUUID;
               this.#rawData[value.object_key].source = NestAccfactory.DataSource.REST;
-              this.#rawData[value.object_key].timers = {}; // No timers running for this object
               this.#rawData[value.object_key].value = {};
             }
 
-            // Need to check for a possible device addition to the raw REST API data.
-            // We expect the devices we want to add, have certain minimum properties present in the data
-            // We'll perform that check here
-            if (
-              Object.keys(DEVICEBUCKETS).includes(value.object_key.split('.')[0]) === true &&
-              DEVICEBUCKETS[value.object_key.split('.')[0]].every((key) => key in value.value) === true &&
-              DEVICEBUCKETS[value.object_key.split('.')[0]].every((key) => key in this.#rawData[value.object_key].value) === false
-            ) {
-              deviceChanges.push({ object_key: value.object_key, change: 'add' });
-            }
-
             // Finally, update our internal raw REST API data with the new values
             this.#rawData[value.object_key].object_revision = value.object_revision; // Used for future subscribes
             this.#rawData[value.object_key].object_timestamp = value.object_timestamp; // Used for future subscribes
@@ -659,19 +735,21 @@ export default class NestAccfactory {
           }),
         );
 
-        await this.#processPostSubscribe(deviceChanges);
+        await this.#processPostSubscribe();
       })
       .catch((error) => {
-        if (error?.name !== 'TimeoutError' && this?.log?.debug) {
-          this.log.debug('REST API had an error performing subscription. Will restart subscription');
+        if (error?.cause !== undefined && JSON.stringify(error.cause).toUpperCase().includes('TIMEOUT') === false && this?.log?.debug) {
+          this.log.debug('REST API had an error performing subscription with connection uuid "%s"', connectionUUID);
+          this.log.debug('Error was "%s"', error);
         }
       })
       .finally(() => {
+        this?.log?.debug && this.log.debug('Restarting REST API subscribe for connection uuid "%s"', connectionUUID);
         setTimeout(this.#subscribeREST.bind(this, connectionUUID, fullRefresh), 1000);
       });
   }
 
-  async #subscribeProtobuf(connectionUUID) {
+  async #subscribeProtobuf(connectionUUID, firstRun) {
     if (typeof this.#connections?.[connectionUUID] !== 'object' || this.#connections?.[connectionUUID]?.authorised !== true) {
       // Not a valid connection object and/or we're not authorised
       return;
@@ -712,510 +790,535 @@ export default class NestAccfactory {
       }
     };
 
-    // Attempt to load in protobuf files if not already done so for this connection
-    if (
-      this.#connections[connectionUUID].protobufRoot === null &&
-      fs.existsSync(path.resolve(__dirname + '/protobuf/root.proto')) === true
-    ) {
+    // Attempt to load in protobuf files if not already done so
+    if (this.#protobufRoot === null && fs.existsSync(path.resolve(__dirname + '/protobuf/root.proto')) === true) {
       protobuf.util.Long = null;
       protobuf.configure();
-      this.#connections[connectionUUID].protobufRoot = protobuf.loadSync(path.resolve(__dirname + '/protobuf/root.proto'));
+      this.#protobufRoot = protobuf.loadSync(path.resolve(__dirname + '/protobuf/root.proto'));
+      if (this.#protobufRoot !== null) {
+        this?.log?.debug && this.log.debug('Loaded protobuf support files for Protobuf API');
+      }
     }
 
-    if (this.#connections[connectionUUID].protobufRoot !== null) {
-      // Loaded in the Protobuf files, so now dynamically build the 'observe' post body data based on what we have loaded
-      let observeTraitsList = [];
-      let observeBody = Buffer.alloc(0);
-      let traitTypeObserveParam = this.#connections[connectionUUID].protobufRoot.lookup('nestlabs.gateway.v2.TraitTypeObserveParams');
-      let observeRequest = this.#connections[connectionUUID].protobufRoot.lookup('nestlabs.gateway.v2.ObserveRequest');
-      if (traitTypeObserveParam !== null && observeRequest !== null) {
-        traverseTypes(this.#connections[connectionUUID].protobufRoot, (type) => {
-          // We only want to have certain trait'families' in our observe reponse we are building
-          // This also depends on the account type we connected with
-          // Nest accounts cannot observe camera/doorbell product traits
-          if (
-            (this.#connections[connectionUUID].type === NestAccfactory.NestConnection &&
-              type.fullName.startsWith('.nest.trait.product.camera') === false &&
-              type.fullName.startsWith('.nest.trait.product.doorbell') === false &&
-              (type.fullName.startsWith('.nest.trait') === true || type.fullName.startsWith('.weave.') === true)) ||
-            (this.#connections[connectionUUID].type === NestAccfactory.GoogleConnection &&
-              (type.fullName.startsWith('.nest.trait') === true ||
-                type.fullName.startsWith('.weave.') === true ||
-                type.fullName.startsWith('.google.trait.product.camera') === true))
-          ) {
-            observeTraitsList.push(traitTypeObserveParam.create({ traitType: type.fullName.replace(/^\.*|\.*$/g, '') }));
-          }
-        });
-        observeBody = observeRequest.encode(observeRequest.create({ stateTypes: [1, 2], traitTypeParams: observeTraitsList })).finish();
-      }
+    if (this.#protobufRoot === null) {
+      this?.log?.warn &&
+        this.log.warn('Failed to loaded Protobuf API support files. This will cause certain Nest/Google devices to be un-supported');
+      return;
+    }
 
-      fetchWrapper(
-        'post',
-        'https://' + this.#connections[connectionUUID].protobufAPIHost + '/nestlabs.gateway.v2.GatewayService/Observe',
-        {
-          headers: {
-            referer: 'https://' + this.#connections[connectionUUID].referer,
-            'User-Agent': USERAGENT,
-            Authorization: 'Basic ' + this.#connections[connectionUUID].token,
-            'Content-Type': 'application/x-protobuf',
-            'X-Accept-Content-Transfer-Encoding': 'binary',
-            'X-Accept-Response-Streaming': 'true',
-          },
-          keepalive: true,
-          timeout: 300 * 60,
+    // We have loaded Protobuf proto files, so now dynamically build the 'observe' post body data
+    let observeTraitsList = [];
+    let observeBody = Buffer.alloc(0);
+    let traitTypeObserveParam = this.#protobufRoot.lookup('nestlabs.gateway.v2.TraitTypeObserveParams');
+    let observeRequest = this.#protobufRoot.lookup('nestlabs.gateway.v2.ObserveRequest');
+    if (traitTypeObserveParam !== null && observeRequest !== null) {
+      traverseTypes(this.#protobufRoot, (type) => {
+        // We only want to have certain trait'families' in our observe reponse we are building
+        // This also depends on the account type we connected with
+        // Nest accounts cannot observe camera/doorbell product traits
+        if (
+          (this.#connections[connectionUUID].type === NestAccfactory.NestAccount &&
+            type.fullName.startsWith('.nest.trait.product.camera') === false &&
+            type.fullName.startsWith('.nest.trait.product.doorbell') === false &&
+            (type.fullName.startsWith('.nest.trait') === true || type.fullName.startsWith('.weave.') === true)) ||
+          (this.#connections[connectionUUID].type === NestAccfactory.GoogleAccount &&
+            (type.fullName.startsWith('.nest.trait') === true ||
+              type.fullName.startsWith('.weave.') === true ||
+              type.fullName.startsWith('.google.trait.product.camera') === true))
+        ) {
+          observeTraitsList.push(traitTypeObserveParam.create({ traitType: type.fullName.replace(/^\.*|\.*$/g, '') }));
+        }
+      });
+      observeBody = observeRequest.encode(observeRequest.create({ stateTypes: [1, 2], traitTypeParams: observeTraitsList })).finish();
+    }
+
+    if (firstRun === true) {
+      this?.log?.debug && this.log.debug('Starting Protobuf API trait observe for connection uuid "%s"', connectionUUID);
+    }
+
+    fetchWrapper(
+      'post',
+      'https://' + this.#connections[connectionUUID].protobufAPIHost + '/nestlabs.gateway.v2.GatewayService/Observe',
+      {
+        headers: {
+          referer: 'https://' + this.#connections[connectionUUID].referer,
+          'User-Agent': USERAGENT,
+          Authorization: 'Basic ' + this.#connections[connectionUUID].token,
+          'Content-Type': 'application/x-protobuf',
+          'X-Accept-Content-Transfer-Encoding': 'binary',
+          'X-Accept-Response-Streaming': 'true',
         },
-        observeBody,
-      )
-        .then((response) => response.body)
-        .then(async (data) => {
-          let deviceChanges = []; // No Protobuf API devices changes to start with
-          let buffer = Buffer.alloc(0);
-          for await (const chunk of data) {
-            buffer = Buffer.concat([buffer, Buffer.from(chunk)]);
-            let messageSize = calculate_message_size(buffer);
-            if (buffer.length >= messageSize) {
-              let decodedMessage = {};
-              try {
-                // Attempt to decode the Protobuf message(s) we extracted from the stream and get a JSON object representation
-                decodedMessage = this.#connections[connectionUUID].protobufRoot
-                  .lookup('nestlabs.gateway.v2.ObserveResponse')
-                  .decode(buffer.subarray(0, messageSize))
-                  .toJSON();
-
-                // Tidy up our received messages. This ensures we only have one status for the trait in the data we process
-                // We'll favour a trait with accepted status over the same with confirmed status
-                if (decodedMessage?.observeResponse?.[0]?.traitStates !== undefined) {
-                  let notAcceptedStatus = decodedMessage.observeResponse[0].traitStates.filter(
-                    (trait) => trait.stateTypes.includes('ACCEPTED') === false,
-                  );
-                  let acceptedStatus = decodedMessage.observeResponse[0].traitStates.filter(
-                    (trait) => trait.stateTypes.includes('ACCEPTED') === true,
-                  );
-                  let difference = acceptedStatus.map((trait) => trait.traitId.resourceId + '/' + trait.traitId.traitLabel);
-                  decodedMessage.observeResponse[0].traitStates =
-                    ((notAcceptedStatus = notAcceptedStatus.filter(
-                      (trait) => difference.includes(trait.traitId.resourceId + '/' + trait.traitId.traitLabel) === false,
-                    )),
-                    [...notAcceptedStatus, ...acceptedStatus]);
-                }
-                // We'll use the resource status message to look for structure and/or device removals
-                // We could also check for structure and/or device additions here, but we'll want to be flagged
-                // that a device is 'ready' for use before we add in. This data is populated in the trait data
-                if (decodedMessage?.observeResponse?.[0]?.resourceMetas !== undefined) {
-                  decodedMessage.observeResponse[0].resourceMetas.map(async (resource) => {
-                    if (
-                      resource.status === 'REMOVED' &&
-                      (resource.resourceId.startsWith('STRUCTURE_') || resource.resourceId.startsWith('DEVICE_'))
-                    ) {
-                      // We have the removal of a 'home' and/ device
-                      deviceChanges.push({ object_key: resource.resourceId, change: 'removed' });
-                    }
-                  });
-                }
-                // eslint-disable-next-line no-unused-vars
-              } catch (error) {
-                // Empty
+        keepalive: true,
+        //timeout: (5 * 60000),
+      },
+      observeBody,
+    )
+      .then((response) => response.body)
+      .then(async (data) => {
+        let buffer = Buffer.alloc(0);
+        for await (const chunk of data) {
+          buffer = Buffer.concat([buffer, Buffer.from(chunk)]);
+          let messageSize = calculate_message_size(buffer);
+          if (buffer.length >= messageSize) {
+            let decodedMessage = {};
+            try {
+              // Attempt to decode the Protobuf message(s) we extracted from the stream and get a JSON object representation
+              decodedMessage = this.#protobufRoot
+                .lookup('nestlabs.gateway.v2.ObserveResponse')
+                .decode(buffer.subarray(0, messageSize))
+                .toJSON();
+
+              // Tidy up our received messages. This ensures we only have one status for the trait in the data we process
+              // We'll favour a trait with accepted status over the same with confirmed status
+              if (decodedMessage?.observeResponse?.[0]?.traitStates !== undefined) {
+                let notAcceptedStatus = decodedMessage.observeResponse[0].traitStates.filter(
+                  (trait) => trait.stateTypes.includes('ACCEPTED') === false,
+                );
+                let acceptedStatus = decodedMessage.observeResponse[0].traitStates.filter(
+                  (trait) => trait.stateTypes.includes('ACCEPTED') === true,
+                );
+                let difference = acceptedStatus.map((trait) => trait.traitId.resourceId + '/' + trait.traitId.traitLabel);
+                decodedMessage.observeResponse[0].traitStates =
+                  ((notAcceptedStatus = notAcceptedStatus.filter(
+                    (trait) => difference.includes(trait.traitId.resourceId + '/' + trait.traitId.traitLabel) === false,
+                  )),
+                  [...notAcceptedStatus, ...acceptedStatus]);
               }
-              buffer = buffer.subarray(messageSize); // Remove the message from the beginning of the buffer
+              // We'll use the resource status message to look for structure and/or device removals
+              // We could also check for structure and/or device additions here, but we'll want to be flagged
+              // that a device is 'ready' for use before we add in. This data is populated in the trait data
+              if (decodedMessage?.observeResponse?.[0]?.resourceMetas !== undefined) {
+                decodedMessage.observeResponse[0].resourceMetas.map(async (resource) => {
+                  if (
+                    resource.status === 'REMOVED' &&
+                    (resource.resourceId.startsWith('STRUCTURE_') || resource.resourceId.startsWith('DEVICE_'))
+                  ) {
+                    // We have the removal of a 'home' and/or device
+                    // Tidy up tracked devices since this one is removed
+                    if (this.#trackedDevices[this.#rawData?.[resource.resourceId]?.value?.device_identity?.serialNumber] !== undefined) {
+                      // Remove any active running timers we have for this device
+                      Object.values(
+                        this.#trackedDevices[this.#rawData[resource.resourceId].value.device_identity.serialNumber]?.timers,
+                      ).forEach((timers) => {
+                        clearInterval(timers);
+                      });
 
-              if (typeof decodedMessage?.observeResponse?.[0]?.traitStates === 'object') {
-                await Promise.all(
-                  decodedMessage.observeResponse[0].traitStates.map(async (trait) => {
-                    if (trait.traitId.traitLabel === 'configuration_done') {
-                      if (
-                        this.#rawData[trait.traitId.resourceId]?.value?.configuration_done?.deviceReady !== true &&
-                        trait.patch.values?.deviceReady === true
-                      ) {
-                        deviceChanges.push({ object_key: trait.traitId.resourceId, change: 'add' });
-                      }
-                    }
-                    if (trait.traitId.traitLabel === 'camera_migration_status') {
-                      // Handle case of camera/doorbell(s) which have been migrated from Nest to Google Home
-                      if (
-                        this.#rawData[trait.traitId.resourceId]?.value?.camera_migration_status?.state?.where !==
-                          'MIGRATED_TO_GOOGLE_HOME' &&
-                        trait.patch.values?.state?.where === 'MIGRATED_TO_GOOGLE_HOME' &&
-                        this.#rawData[trait.traitId.resourceId]?.value?.camera_migration_status?.state?.progress !== 'PROGRESS_COMPLETE' &&
-                        trait.patch.values?.state?.progress === 'PROGRESS_COMPLETE'
-                      ) {
-                        deviceChanges.push({ object_key: trait.traitId.resourceId, change: 'add' });
-                      }
-                    }
+                      // Send removed notice onto HomeKit device for it to process
+                      this.#eventEmitter.emit(
+                        this.#trackedDevices[this.#rawData[resource.resourceId].value.device_identity.serialNumber].uuid,
+                        HomeKitDevice.REMOVE,
+                        {},
+                      );
 
-                    if (typeof this.#rawData[trait.traitId.resourceId] === 'undefined') {
-                      this.#rawData[trait.traitId.resourceId] = {};
-                      this.#rawData[trait.traitId.resourceId].connection = connectionUUID;
-                      this.#rawData[trait.traitId.resourceId].source = NestAccfactory.DataSource.PROTOBUF;
-                      this.#rawData[trait.traitId.resourceId].timers = {}; // No timers running for this object
-                      this.#rawData[trait.traitId.resourceId].value = {};
+                      // Finally, remove from tracked devices
+                      delete this.#trackedDevices[this.#rawData?.[resource.resourceId].value.device_identity.serialNumber];
                     }
-                    this.#rawData[trait.traitId.resourceId]['value'][trait.traitId.traitLabel] =
-                      typeof trait.patch.values !== 'undefined' ? trait.patch.values : {};
+                    delete this.#rawData[resource.resourceId];
+                  }
+                });
+              }
+              // eslint-disable-next-line no-unused-vars
+            } catch (error) {
+              // Empty
+            }
+            buffer = buffer.subarray(messageSize); // Remove the message from the beginning of the buffer
+
+            if (typeof decodedMessage?.observeResponse?.[0]?.traitStates === 'object') {
+              await Promise.all(
+                decodedMessage.observeResponse[0].traitStates.map(async (trait) => {
+                  if (typeof this.#rawData[trait.traitId.resourceId] === 'undefined') {
+                    this.#rawData[trait.traitId.resourceId] = {};
+                    this.#rawData[trait.traitId.resourceId].connection = connectionUUID;
+                    this.#rawData[trait.traitId.resourceId].source = NestAccfactory.DataSource.PROTOBUF;
+                    this.#rawData[trait.traitId.resourceId].value = {};
+                  }
+                  this.#rawData[trait.traitId.resourceId]['value'][trait.traitId.traitLabel] =
+                    typeof trait.patch.values !== 'undefined' ? trait.patch.values : {};
 
-                    // We don't need to store the trait type, so remove it
-                    delete this.#rawData[trait.traitId.resourceId]['value'][trait.traitId.traitLabel]['@type'];
+                  // We don't need to store the trait type, so remove it
+                  delete this.#rawData[trait.traitId.resourceId]['value'][trait.traitId.traitLabel]['@type'];
 
-                    // If we have structure location details and associated geo-location details, get the weather data for the location
-                    // We'll store this in the object key/value as per REST API
-                    if (
-                      trait.traitId.resourceId.startsWith('STRUCTURE_') === true &&
-                      trait.traitId.traitLabel === 'structure_location' &&
-                      typeof trait.patch.values?.geoCoordinate?.latitude === 'number' &&
-                      typeof trait.patch.values?.geoCoordinate?.longitude === 'number'
-                    ) {
-                      this.#rawData[trait.traitId.resourceId].value.weather = await this.#getWeatherData(
-                        connectionUUID,
-                        trait.traitId.resourceId,
-                        trait.patch.values.geoCoordinate.latitude,
-                        trait.patch.values.geoCoordinate.longitude,
-                      );
-                    }
-                  }),
-                );
+                  // If we have structure location details and associated geo-location details, get the weather data for the location
+                  // We'll store this in the object key/value as per REST API
+                  if (
+                    trait.traitId.resourceId.startsWith('STRUCTURE_') === true &&
+                    trait.traitId.traitLabel === 'structure_location' &&
+                    isNaN(trait.patch.values?.geoCoordinate?.latitude) === false &&
+                    isNaN(trait.patch.values?.geoCoordinate?.longitude) === false
+                  ) {
+                    this.#rawData[trait.traitId.resourceId].value.weather = await this.#getWeatherData(
+                      connectionUUID,
+                      trait.traitId.resourceId,
+                      Number(trait.patch.values.geoCoordinate.latitude),
+                      Number(trait.patch.values.geoCoordinate.longitude),
+                    );
+                  }
+                }),
+              );
 
-                await this.#processPostSubscribe(deviceChanges);
-                deviceChanges = []; // No more device changes now
-              }
+              await this.#processPostSubscribe();
             }
           }
-        })
-        .catch((error) => {
-          if (error?.name !== 'TimeoutError' && this?.log?.debug) {
-            this.log.debug('Protobuf API had an error performing trait observe. Will restart observe');
-          }
-        })
-        .finally(() => {
-          setTimeout(this.#subscribeProtobuf.bind(this, connectionUUID), 1000);
-        });
-    }
+        }
+      })
+      .catch((error) => {
+        if (error?.cause !== undefined && JSON.stringify(error.cause).toUpperCase().includes('TIMEOUT') === false && this?.log?.debug) {
+          this.log.debug('Protobuf API had an error performing trait observe with connection uuid "%s"', connectionUUID);
+          this.log.debug('Error was "%s"', error);
+        }
+      })
+      .finally(() => {
+        this?.log?.debug && this.log.debug('Restarting Protobuf API trait observe for connection uuid "%s"', connectionUUID);
+        setTimeout(this.#subscribeProtobuf.bind(this, connectionUUID, false), 1000);
+      });
   }
 
-  async #processPostSubscribe(deviceChanges) {
-    // Process any device removals we have
-    Object.values(deviceChanges)
-      .filter((object) => object.change === 'remove')
-      .forEach((object) => {
-        if (typeof this.#rawData[object.object_key] === 'object') {
-          // Remove any timers that might have been associated with this device
-          Object.values(this.#rawData[object.object_key].timers).forEach((timerObject) => {
-            clearInterval(timerObject);
-          });
+  async #processPostSubscribe() {
+    Object.values(this.#processData('')).forEach((deviceData) => {
+      if (this.#trackedDevices?.[deviceData?.serialNumber] === undefined && deviceData?.excluded === true) {
+        // We haven't tracked this device before (ie: should be a new one) and but its excluded
+        this?.log?.warn && this.log.warn('Device "%s" is ignored due to it being marked as excluded', deviceData.description);
+      }
+      if (this.#trackedDevices?.[deviceData?.serialNumber] === undefined && deviceData?.excluded === false) {
+        // We haven't tracked this device before (ie: should be a new one) and its not excluded
+        // so create the required HomeKit accessories based upon the device data
+        if (deviceData.device_type === NestAccfactory.DeviceType.THERMOSTAT && typeof NestThermostat === 'function') {
+          // Nest Thermostat(s) - Categories.THERMOSTAT = 9
+          let tempDevice = new NestThermostat(this.cachedAccessories, this.api, this.log, this.#eventEmitter, deviceData);
+          tempDevice.add('Nest Thermostat', 9, true);
+          // Track this device once created
+          this.#trackedDevices[deviceData.serialNumber] = {
+            uuid: tempDevice.uuid,
+            rawDataUuid: deviceData.nest_google_uuid,
+            source: undefined,
+          };
+        }
 
-          // Clean up structure
-          delete this.#rawData[object.object_key];
+        if (deviceData.device_type === NestAccfactory.DeviceType.TEMPSENSOR && typeof NestTemperatureSensor === 'function') {
+          // Nest Temperature Sensor - Categories.SENSOR = 10;
+          let tempDevice = new NestTemperatureSensor(this.cachedAccessories, this.api, this.log, this.#eventEmitter, deviceData);
+          tempDevice.add('Nest Temperature Sensor', 10, true);
+          // Track this device once created
+          this.#trackedDevices[deviceData.serialNumber] = {
+            uuid: tempDevice.uuid,
+            rawDataUuid: deviceData.nest_google_uuid,
+            source: undefined,
+          };
         }
 
-        // Send removed notice onto HomeKit device for it to process
-        // This allows handling removal of a device without knowing its previous data
-        this.#eventEmitter.emit(object.object_key, HomeKitDevice.REMOVE, {});
-      });
+        if (deviceData.device_type === NestAccfactory.DeviceType.SMOKESENSOR && typeof NestProtect === 'function') {
+          // Nest Protect(s) - Categories.SENSOR = 10
+          let tempDevice = new NestProtect(this.cachedAccessories, this.api, this.log, this.#eventEmitter, deviceData);
+          tempDevice.add('Nest Protect', 10, true);
+          // Track this device once created
+          this.#trackedDevices[deviceData.serialNumber] = {
+            uuid: tempDevice.uuid,
+            rawDataUuid: deviceData.nest_google_uuid,
+            source: undefined,
+          };
+        }
 
-    Object.values(this.#processData('')).forEach((deviceData) => {
-      // Process any device additions we have
-      Object.values(deviceChanges)
-        .filter((object) => object.change === 'add')
-        .forEach((object) => {
-          if (object.object_key === deviceData.uuid && deviceData.excluded === true) {
-            this?.log?.warn && this.log.warn('Device "%s" ignored due to it being marked as excluded', deviceData.description);
+        if (
+          (deviceData.device_type === NestAccfactory.DeviceType.CAMERA ||
+            deviceData.device_type === NestAccfactory.DeviceType.DOORBELL ||
+            deviceData.device_type === NestAccfactory.DeviceType.FLOODLIGHT) &&
+          (typeof NestCamera === 'function' || typeof NestDoorbell === 'function' || typeof NestFloodlight === 'function')
+        ) {
+          let accessoryName = 'Nest ' + deviceData.model.replace(/\s*(?:\([^()]*\))/gi, '');
+          let tempDevice = undefined;
+          if (deviceData.device_type === NestAccfactory.DeviceType.CAMERA) {
+            // Nest Camera(s) - Categories.IP_CAMERA = 17
+            tempDevice = new NestCamera(this.cachedAccessories, this.api, this.log, this.#eventEmitter, deviceData);
+            tempDevice.add(accessoryName, 17, true);
+          }
+          if (deviceData.device_type === NestAccfactory.DeviceType.DOORBELL) {
+            // Nest Doorbell(s) - Categories.VIDEO_DOORBELL = 18
+            tempDevice = new NestDoorbell(this.cachedAccessories, this.api, this.log, this.#eventEmitter, deviceData);
+            tempDevice.add(accessoryName, 18, true);
+          }
+          if (deviceData.device_type === NestAccfactory.DeviceType.FLOODLIGHT) {
+            // Nest Camera(s) with Floodlight - Categories.IP_CAMERA = 17
+            tempDevice = new NestFloodlight(this.cachedAccessories, this.api, this.log, this.#eventEmitter, deviceData);
+            tempDevice.add(accessoryName, 17, true);
           }
-          if (object.object_key === deviceData.uuid && deviceData.excluded === false) {
-            // Device isn't marked as excluded, so create the required HomeKit accessories based upon the device data
-            if (deviceData.device_type === NestAccfactory.DeviceType.THERMOSTAT && typeof NestThermostat === 'function') {
-              // Nest Thermostat(s) - Categories.THERMOSTAT = 9
-              this?.log?.debug &&
-                this.log.debug('Using "%s" data source for "%s"', this.#rawData[object.object_key]?.source, deviceData.description);
-              let tempDevice = new NestThermostat(this.cachedAccessories, this.api, this.log, this.#eventEmitter, deviceData);
-              tempDevice.add('Nest Thermostat', 9, true);
-            }
-
-            if (deviceData.device_type === NestAccfactory.DeviceType.TEMPSENSOR && typeof NestTemperatureSensor === 'function') {
-              // Nest Temperature Sensor - Categories.SENSOR = 10
-              this?.log?.debug &&
-                this.log.debug('Using "%s" data source for "%s"', this.#rawData[object.object_key]?.source, deviceData.description);
-              let tempDevice = new NestTemperatureSensor(this.cachedAccessories, this.api, this.log, this.#eventEmitter, deviceData);
-              tempDevice.add('Nest Temperature Sensor', 10, true);
-            }
 
-            if (deviceData.device_type === NestAccfactory.DeviceType.SMOKESENSOR && typeof NestProtect === 'function') {
-              // Nest Protect(s) - Categories.SENSOR = 10
-              this?.log?.debug &&
-                this.log.debug('Using "%s" data source for "%s"', this.#rawData[object.object_key]?.source, deviceData.description);
-              let tempDevice = new NestProtect(this.cachedAccessories, this.api, this.log, this.#eventEmitter, deviceData);
-              tempDevice.add('Nest Protect', 10, true);
-            }
+          // Track this device once created
+          this.#trackedDevices[deviceData.serialNumber] = {
+            uuid: tempDevice.uuid,
+            rawDataUuid: deviceData.nest_google_uuid,
+            source: undefined,
+            timers: {},
+          };
 
+          // Setup polling loop for camera/doorbell zone data
+          // This is only required for REST API data sources as these details are present in Protobuf API
+          this.#trackedDevices[deviceData.serialNumber].timers.zones = setInterval(async () => {
+            let nest_google_uuid = this.#trackedDevices?.[deviceData?.serialNumber]?.rawDataUuid;
             if (
-              (deviceData.device_type === NestAccfactory.DeviceType.CAMERA ||
-                deviceData.device_type === NestAccfactory.DeviceType.DOORBELL ||
-                deviceData.device_type === NestAccfactory.DeviceType.FLOODLIGHT) &&
-              (typeof NestCamera === 'function' || typeof NestDoorbell === 'function' || typeof NestFloodlight === 'function')
+              this.#rawData?.[nest_google_uuid]?.value !== undefined &&
+              this.#trackedDevices?.[deviceData?.serialNumber]?.source === NestAccfactory.DataSource.REST
             ) {
-              this?.log?.debug &&
-                this.log.debug('Using "%s" data source for "%s"', this.#rawData[object.object_key]?.source, deviceData.description);
-
-              let accessoryName = 'Nest ' + deviceData.model.replace(/\s*(?:\([^()]*\))/gi, '');
-              if (deviceData.device_type === NestAccfactory.DeviceType.CAMERA) {
-                // Nest Camera(s) - Categories.IP_CAMERA = 17
-                let tempDevice = new NestCamera(this.cachedAccessories, this.api, this.log, this.#eventEmitter, deviceData);
-                tempDevice.add(accessoryName, 17, true);
-              }
-              if (deviceData.device_type === NestAccfactory.DeviceType.DOORBELL) {
-                // Nest Doorbell(s) - Categories.VIDEO_DOORBELL = 18
-                let tempDevice = new NestDoorbell(this.cachedAccessories, this.api, this.log, this.#eventEmitter, deviceData);
-                tempDevice.add(accessoryName, 18, true);
-              }
-              if (deviceData.device_type === NestAccfactory.DeviceType.FLOODLIGHT) {
-                // Nest Camera(s) with Floodlight - Categories.IP_CAMERA = 17
-                let tempDevice = new NestFloodlight(this.cachedAccessories, this.api, this.log, this.#eventEmitter, deviceData);
-                tempDevice.add(accessoryName, 17, true);
-              }
-
-              // Setup polling loop for camera/doorbell zone data if not already created.
-              // This is only required for REST API data sources as these details are present in Protobuf API
-              if (
-                this.#rawData?.[object.object_key] !== undefined &&
-                this.#rawData[object.object_key]?.timers?.zones === undefined &&
-                this.#rawData[object.object_key].source === NestAccfactory.DataSource.REST
-              ) {
-                this.#rawData[object.object_key].timers.zones = setInterval(async () => {
-                  if (this.#rawData?.[object.object_key]?.value?.nexus_api_http_server_url !== undefined) {
-                    await fetchWrapper(
-                      'get',
-                      this.#rawData[object.object_key].value.nexus_api_http_server_url +
-                        '/cuepoint_category/' +
-                        object.object_key.split('.')[1],
-                      {
-                        headers: {
-                          referer: 'https://' + this.#connections[this.#rawData[object.object_key].connection].referer,
-                          'User-Agent': USERAGENT,
-                          [this.#connections[this.#rawData[object.object_key].connection].cameraAPI.key]:
-                            this.#connections[this.#rawData[object.object_key].connection].cameraAPI.value +
-                            this.#connections[this.#rawData[object.object_key].connection].cameraAPI.token,
-                        },
-                        timeout: CAMERAZONEPOLLING,
-                      },
-                    )
-                      .then((response) => response.json())
-                      .then((data) => {
-                        let zones = [];
-                        data.forEach((zone) => {
-                          if (zone.type.toUpperCase() === 'ACTIVITY' || zone.type.toUpperCase() === 'REGION') {
-                            zones.push({
-                              id: zone.id === 0 ? 1 : zone.id,
-                              name: makeHomeKitName(zone.label),
-                              hidden: zone.hidden === true,
-                              uri: zone.nexusapi_image_uri,
-                            });
-                          }
-                        });
+              await fetchWrapper(
+                'get',
+                this.#rawData[nest_google_uuid].value.nexus_api_http_server_url + '/cuepoint_category/' + nest_google_uuid.split('.')[1],
+                {
+                  headers: {
+                    referer: 'https://' + this.#connections[this.#rawData[nest_google_uuid].connection].referer,
+                    'User-Agent': USERAGENT,
+                    [this.#connections[this.#rawData[nest_google_uuid].connection].cameraAPI.key]:
+                      this.#connections[this.#rawData[nest_google_uuid].connection].cameraAPI.value +
+                      this.#connections[this.#rawData[nest_google_uuid].connection].cameraAPI.token,
+                  },
+                  timeout: CAMERAZONEPOLLING,
+                },
+              )
+                .then((response) => response.json())
+                .then((data) => {
+                  let zones = [];
+                  data.forEach((zone) => {
+                    if (zone.type.toUpperCase() === 'ACTIVITY' || zone.type.toUpperCase() === 'REGION') {
+                      zones.push({
+                        id: zone.id === 0 ? 1 : zone.id,
+                        name: makeHomeKitName(zone.label),
+                        hidden: zone.hidden === true,
+                        uri: zone.nexusapi_image_uri,
+                      });
+                    }
+                  });
 
-                        this.#rawData[object.object_key].value.activity_zones = zones;
+                  // Update internal structure with new zone details.
+                  // We do a test to see if its still present not interval loop not finished or device removed
+                  if (this.#rawData?.[nest_google_uuid]?.value !== undefined) {
+                    this.#rawData[nest_google_uuid].value.activity_zones = zones;
 
-                        // Send updated data onto HomeKit device for it to process
-                        this.#eventEmitter.emit(object.object_key, HomeKitDevice.UPDATE, {
-                          activity_zones: this.#rawData[object.object_key].value.activity_zones,
-                        });
-                      })
-                      .catch((error) => {
-                        // Log debug message if wasn't a timeout
-                        if (error?.name !== 'TimeoutError' && this?.log?.debug) {
-                          this.log.debug(
-                            'REST API had error retrieving camera/doorbell activity zones for uuid "%s". Error was "%s"',
-                            object.object_key,
-                            error?.code,
-                          );
-                        }
+                    // Send updated data onto HomeKit device for it to process
+                    if (this.#trackedDevices?.[deviceData?.serialNumber]?.uuid !== undefined) {
+                      this.#eventEmitter.emit(this.#trackedDevices[deviceData.serialNumber].uuid, HomeKitDevice.UPDATE, {
+                        activity_zones: zones,
                       });
+                    }
                   }
-                }, CAMERAZONEPOLLING);
-              }
-
-              // Setup polling loop for camera/doorbell alert data if not already created
-              if (this.#rawData?.[object.object_key] !== undefined && this.#rawData?.[object.object_key]?.timers?.alerts === undefined) {
-                this.#rawData[object.object_key].timers.alerts = setInterval(async () => {
+                })
+                .catch((error) => {
+                  // Log debug message if wasn't a timeout
                   if (
-                    typeof this.#rawData[object.object_key]?.value === 'object' &&
-                    this.#rawData[object.object_key]?.source === NestAccfactory.DataSource.PROTOBUF
+                    error?.cause !== undefined &&
+                    JSON.stringify(error.cause).toUpperCase().includes('TIMEOUT') === false &&
+                    this?.log?.debug
                   ) {
-                    let alerts = []; // No alerts yet
-
-                    let commandResponse = await this.#protobufCommand(
-                      this.#rawData[object.object_key].connection,
-                      'ResourceApi',
-                      'SendCommand',
-                      {
-                        resourceRequest: {
-                          resourceId: object.object_key,
-                          requestId: crypto.randomUUID(),
-                        },
-                        resourceCommands: [
-                          {
-                            traitLabel: 'camera_observation_history',
-                            command: {
-                              type_url:
-                                'type.nestlabs.com/nest.trait.history.CameraObservationHistoryTrait.CameraObservationHistoryRequest',
-                              value: {
-                                // We want camera history from now for upto 30secs from now
-                                queryStartTime: { seconds: Math.floor(Date.now() / 1000), nanos: (Math.round(Date.now()) % 1000) * 1e6 },
-                                queryEndTime: {
-                                  seconds: Math.floor((Date.now() + 30000) / 1000),
-                                  nanos: (Math.round(Date.now() + 30000) % 1000) * 1e6,
-                                },
-                              },
-                            },
-                          },
-                        ],
-                      },
+                    this.log.debug(
+                      'REST API had error retrieving camera/doorbell activity zones for "%s". Error was "%s"',
+                      deviceData.description,
+                      error?.code,
                     );
-
-                    if (
-                      typeof commandResponse?.sendCommandResponse?.[0]?.traitOperations?.[0]?.event?.event?.cameraEventWindow
-                        ?.cameraEvent === 'object'
-                    ) {
-                      commandResponse.sendCommandResponse[0].traitOperations[0].event.event.cameraEventWindow.cameraEvent.forEach(
-                        (event) => {
-                          alerts.push({
-                            playback_time: parseInt(event.startTime.seconds) * 1000 + parseInt(event.startTime.nanos) / 1000000,
-                            start_time: parseInt(event.startTime.seconds) * 1000 + parseInt(event.startTime.nanos) / 1000000,
-                            end_time: parseInt(event.endTime.seconds) * 1000 + parseInt(event.endTime.nanos) / 1000000,
-                            id: event.eventId,
-                            zone_ids:
-                              typeof event.activityZone === 'object'
-                                ? event.activityZone.map((zone) =>
-                                    typeof zone?.zoneIndex === 'number' ? zone.zoneIndex : zone.internalIndex,
-                                  )
-                                : [],
-                            types: event.eventType
-                              .map((event) => (event.startsWith('EVENT_') === true ? event.split('EVENT_')[1].toLowerCase() : ''))
-                              .filter((event) => event),
-                          });
-
-                          // Fix up event types to match REST API
-                          // 'EVENT_UNFAMILIAR_FACE' = 'unfamiliar-face'
-                          // 'EVENT_PERSON_TALKING' = 'personHeard'
-                          // 'EVENT_DOG_BARKING' = 'dogBarking'
-                          // <---- TODO (as the ones we use match from Protobuf)
-                        },
-                      );
-
-                      // Sort alerts to be most recent first
-                      alerts = alerts.sort((a, b) => {
-                        if (a.start_time > b.start_time) {
-                          return -1;
-                        }
-                      });
-                    }
-
-                    this.#rawData[object.object_key].value.alerts = alerts;
-
-                    // Send updated data onto HomeKit device for it to process
-                    this.#eventEmitter.emit(object.object_key, HomeKitDevice.UPDATE, {
-                      alerts: this.#rawData[object.object_key].value.alerts,
-                    });
                   }
+                });
+            }
+          }, CAMERAZONEPOLLING);
 
-                  if (
-                    typeof this.#rawData[object.object_key]?.value === 'object' &&
-                    this.#rawData[object.object_key]?.source === NestAccfactory.DataSource.REST
-                  ) {
-                    let alerts = []; // No alerts yet
-                    await fetchWrapper(
-                      'get',
-                      this.#rawData[object.object_key].value.nexus_api_http_server_url +
-                        '/cuepoint/' +
-                        object.object_key.split('.')[1] +
-                        '/2?start_time=' +
-                        Math.floor(Date.now() / 1000 - 30),
-                      {
-                        headers: {
-                          referer: 'https://' + this.#connections[this.#rawData[object.object_key].connection].referer,
-                          'User-Agent': USERAGENT,
-                          [this.#connections[this.#rawData[object.object_key].connection].cameraAPI.key]:
-                            this.#connections[this.#rawData[object.object_key].connection].cameraAPI.value +
-                            this.#connections[this.#rawData[object.object_key].connection].cameraAPI.token,
+          // Setup polling loop for camera/doorbell alert data
+          this.#trackedDevices[deviceData.serialNumber].timers.alerts = setInterval(async () => {
+            let alerts = []; // No alerts to processed yet
+            let nest_google_uuid = this.#trackedDevices?.[deviceData?.serialNumber]?.rawDataUuid;
+            if (
+              this.#rawData?.[nest_google_uuid]?.value !== undefined &&
+              this.#trackedDevices?.[deviceData?.serialNumber]?.source === NestAccfactory.DataSource.PROTOBUF
+            ) {
+              let commandResponse = await this.#protobufCommand(this.#rawData[nest_google_uuid].connection, 'ResourceApi', 'SendCommand', {
+                resourceRequest: {
+                  resourceId: nest_google_uuid,
+                  requestId: crypto.randomUUID(),
+                },
+                resourceCommands: [
+                  {
+                    traitLabel: 'camera_observation_history',
+                    command: {
+                      type_url: 'type.nestlabs.com/nest.trait.history.CameraObservationHistoryTrait.CameraObservationHistoryRequest',
+                      value: {
+                        // We want camera history from now for upto 30secs from now
+                        queryStartTime: { seconds: Math.floor(Date.now() / 1000), nanos: (Math.round(Date.now()) % 1000) * 1e6 },
+                        queryEndTime: {
+                          seconds: Math.floor((Date.now() + 30000) / 1000),
+                          nanos: (Math.round(Date.now() + 30000) % 1000) * 1e6,
                         },
-                        timeout: CAMERAALERTPOLLING,
                       },
-                    )
-                      .then((response) => response.json())
-                      .then((data) => {
-                        data.forEach((alert) => {
-                          // Fix up alert zone IDs. If there is an ID of 0, we'll transform to 1. ie: main zone
-                          // If there are NO zone IDs, we'll put a 1 in there ie: main zone
-                          alert.zone_ids = alert.zone_ids.map((id) => (id !== 0 ? id : 1));
-                          if (alert.zone_ids.length === 0) {
-                            alert.zone_ids.push(1);
-                          }
-                          alerts.push({
-                            playback_time: alert.playback_time,
-                            start_time: alert.start_time,
-                            end_time: alert.end_time,
-                            id: alert.id,
-                            zone_ids: alert.zone_ids,
-                            types: alert.types,
-                          });
-                        });
+                    },
+                  },
+                ],
+              });
 
-                        // Sort alerts to be most recent first
-                        alerts = alerts.sort((a, b) => {
-                          if (a.start_time > b.start_time) {
-                            return -1;
-                          }
-                        });
-                      })
-                      .catch((error) => {
-                        // Log debug message if wasn't a timeout
-                        if (error?.name !== 'TimeoutError' && this?.log?.debug) {
-                          this.log.debug(
-                            'REST API had error retrieving camera/doorbell activity notifications for uuid "%s". Error was "%s"',
-                            object.object_key,
-                            error?.code,
-                          );
-                        }
-                      });
+              if (
+                typeof commandResponse?.sendCommandResponse?.[0]?.traitOperations?.[0]?.event?.event?.cameraEventWindow?.cameraEvent ===
+                'object'
+              ) {
+                commandResponse.sendCommandResponse[0].traitOperations[0].event.event.cameraEventWindow.cameraEvent.forEach((event) => {
+                  alerts.push({
+                    playback_time: parseInt(event.startTime.seconds) * 1000 + parseInt(event.startTime.nanos) / 1000000,
+                    start_time: parseInt(event.startTime.seconds) * 1000 + parseInt(event.startTime.nanos) / 1000000,
+                    end_time: parseInt(event.endTime.seconds) * 1000 + parseInt(event.endTime.nanos) / 1000000,
+                    id: event.eventId,
+                    zone_ids:
+                      typeof event.activityZone === 'object'
+                        ? event.activityZone.map((zone) => (zone?.zoneIndex !== undefined ? zone.zoneIndex : zone.internalIndex))
+                        : [],
+                    types: event.eventType
+                      .map((event) => (event.startsWith('EVENT_') === true ? event.split('EVENT_')[1].toLowerCase() : ''))
+                      .filter((event) => event),
+                  });
 
-                    this.#rawData[object.object_key].value.alerts = alerts;
+                  // Fix up event types to match REST API
+                  // 'EVENT_UNFAMILIAR_FACE' = 'unfamiliar-face'
+                  // 'EVENT_PERSON_TALKING' = 'personHeard'
+                  // 'EVENT_DOG_BARKING' = 'dogBarking'
+                  // <---- TODO (as the ones we use match from Protobuf)
+                });
 
-                    // Send updated data onto HomeKit device for it to process
-                    this.#eventEmitter.emit(object.object_key, HomeKitDevice.UPDATE, {
-                      alerts: this.#rawData[object.object_key].value.alerts,
-                    });
+                // Sort alerts to be most recent first
+                alerts = alerts.sort((a, b) => {
+                  if (a.start_time > b.start_time) {
+                    return -1;
                   }
-                }, CAMERAALERTPOLLING);
+                });
               }
             }
-            if (deviceData.device_type === NestAccfactory.DeviceType.WEATHER && typeof NestWeather === 'function') {
-              // Nest 'Virtual' weather station - Categories.SENSOR = 10
-              this?.log?.debug &&
-                this.log.debug('Using "%s" data source for "%s"', this.#rawData[object.object_key]?.source, deviceData.description);
-              let tempDevice = new NestWeather(this.cachedAccessories, this.api, this.log, this.#eventEmitter, deviceData);
-              tempDevice.add('Nest Weather', 10, true);
-
-              // Setup polling loop for weather data if not already created
-              if (typeof this.#rawData[object.object_key]?.timers?.weather === 'undefined') {
-                this.#rawData[object.object_key].timers.weather = setInterval(async () => {
-                  this.#rawData[object.object_key].value.weather = await this.#getWeatherData(
-                    this.#rawData[object.object_key].connection,
-                    object.object_key,
-                    this.#rawData[object.object_key].value.weather.latitude,
-                    this.#rawData[object.object_key].value.weather.longitude,
-                  );
 
-                  // Send updated data onto HomeKit device for it to process
-                  this.#eventEmitter.emit(
-                    object.object_key,
-                    HomeKitDevice.UPDATE,
-                    this.#processData(object.object_key)[deviceData.serial_number],
-                  );
-                }, WEATHERPOLLING);
-              }
-            }
-          }
-        });
+            if (
+              this.#rawData?.[nest_google_uuid]?.value !== undefined &&
+              this.#trackedDevices?.[deviceData?.serialNumber]?.source === NestAccfactory.DataSource.REST
+            ) {
+              await fetchWrapper(
+                'get',
+                this.#rawData[nest_google_uuid].value.nexus_api_http_server_url +
+                  '/cuepoint/' +
+                  nest_google_uuid.split('.')[1] +
+                  '/2?start_time=' +
+                  Math.floor(Date.now() / 1000 - 30),
+                {
+                  headers: {
+                    referer: 'https://' + this.#connections[this.#rawData[nest_google_uuid].connection].referer,
+                    'User-Agent': USERAGENT,
+                    [this.#connections[this.#rawData[nest_google_uuid].connection].cameraAPI.key]:
+                      this.#connections[this.#rawData[nest_google_uuid].connection].cameraAPI.value +
+                      this.#connections[this.#rawData[nest_google_uuid].connection].cameraAPI.token,
+                  },
+                  timeout: CAMERAALERTPOLLING,
+                  retry: 3,
+                },
+              )
+                .then((response) => response.json())
+                .then((data) => {
+                  data.forEach((alert) => {
+                    // Fix up alert zone IDs. If there is an ID of 0, we'll transform to 1. ie: main zone
+                    // If there are NO zone IDs, we'll put a 1 in there ie: main zone
+                    alert.zone_ids = alert.zone_ids.map((id) => (id !== 0 ? id : 1));
+                    if (alert.zone_ids.length === 0) {
+                      alert.zone_ids.push(1);
+                    }
+                    alerts.push({
+                      playback_time: alert.playback_time,
+                      start_time: alert.start_time,
+                      end_time: alert.end_time,
+                      id: alert.id,
+                      zone_ids: alert.zone_ids,
+                      types: alert.types,
+                    });
+                  });
 
-      // Finally, after processing device additions, if device is not excluded, send updated data to device for it to process
-      if (deviceData.excluded === false) {
-        this.#eventEmitter.emit(deviceData.uuid, HomeKitDevice.UPDATE, deviceData);
+                  // Sort alerts to be most recent first
+                  alerts = alerts.sort((a, b) => {
+                    if (a.start_time > b.start_time) {
+                      return -1;
+                    }
+                  });
+                })
+                .catch((error) => {
+                  // Log debug message if wasn't a timeout
+                  if (
+                    error?.cause !== undefined &&
+                    JSON.stringify(error.cause).toUpperCase().includes('TIMEOUT') === false &&
+                    this?.log?.debug
+                  ) {
+                    this.log.debug(
+                      'REST API had error retrieving camera/doorbell activity notifications for "%s". Error was "%s"',
+                      deviceData.description,
+                      error?.code,
+                    );
+                  }
+                });
+            }
+
+            // Update internal structure with new alerts.
+            // We do a test to see if its still present not interval loop not finished or device removed
+            if (this.#rawData?.[nest_google_uuid]?.value !== undefined) {
+              this.#rawData[nest_google_uuid].value.alerts = alerts;
+
+              // Send updated alerts onto HomeKit device for it to process
+              if (this.#trackedDevices?.[deviceData?.serialNumber]?.uuid !== undefined) {
+                this.#eventEmitter.emit(this.#trackedDevices[deviceData.serialNumber].uuid, HomeKitDevice.UPDATE, {
+                  alerts: alerts,
+                });
+              }
+            }
+          }, CAMERAALERTPOLLING);
+        }
+
+        if (deviceData.device_type === NestAccfactory.DeviceType.WEATHER && typeof NestWeather === 'function') {
+          // Nest 'Virtual' weather station - Categories.SENSOR = 10
+          let tempDevice = new NestWeather(this.cachedAccessories, this.api, this.log, this.#eventEmitter, deviceData);
+          tempDevice.add('Nest Weather', 10, true);
+
+          // Track this device once created
+          this.#trackedDevices[deviceData.serialNumber] = {
+            uuid: tempDevice.uuid,
+            rawDataUuid: deviceData.nest_google_uuid,
+            source: undefined,
+            timers: {},
+          };
+
+          // Setup polling loop for weather data
+          this.#trackedDevices[deviceData.serialNumber].timers.weather = setInterval(async () => {
+            let nest_google_uuid = this.#trackedDevices?.[deviceData?.serialNumber]?.rawDataUuid;
+            if (this.#rawData?.[nest_google_uuid] !== undefined) {
+              this.#rawData[nest_google_uuid].value.weather = await this.#getWeatherData(
+                this.#rawData[nest_google_uuid].connection,
+                nest_google_uuid,
+                this.#rawData[nest_google_uuid].value.weather.latitude,
+                this.#rawData[nest_google_uuid].value.weather.longitude,
+              );
+
+              // Send updated weather data onto HomeKit device for it to process
+              if (this.#trackedDevices?.[deviceData?.serialNumber]?.uuid !== undefined) {
+                this.#eventEmitter.emit(
+                  this.#trackedDevices[deviceData.serialNumber].uuid,
+                  HomeKitDevice.UPDATE,
+                  this.#processData(nest_google_uuid)[deviceData.serialNumber],
+                );
+              }
+            }
+          }, WEATHERPOLLING);
+        }
+      }
+
+      // Finally, after device data for anything we havent tracked yet, if device is not excluded, send updated data to device for it to process
+      if (deviceData.excluded === false && this.#trackedDevices?.[deviceData?.serialNumber] !== undefined) {
+        if (
+          this.#rawData[deviceData?.nest_google_uuid]?.source !== undefined &&
+          this.#rawData[deviceData.nest_google_uuid].source !== this.#trackedDevices[deviceData.serialNumber].source
+        ) {
+          // Data source for this device has been updated
+          this?.log?.debug &&
+            this.log.debug(
+              'Using %s API as data source for "%s" from connection uuid "%s"',
+              this.#rawData[deviceData.nest_google_uuid]?.source,
+              deviceData.description,
+              this.#rawData[deviceData.nest_google_uuid].connection,
+            );
+
+          this.#trackedDevices[deviceData.serialNumber].source = this.#rawData[deviceData.nest_google_uuid].source;
+          this.#trackedDevices[deviceData.serialNumber].rawDataUuid = deviceData.nest_google_uuid;
+        }
+
+        this.#eventEmitter.emit(this.#trackedDevices[deviceData.serialNumber].uuid, HomeKitDevice.UPDATE, deviceData);
       }
     });
   }
@@ -1259,26 +1362,17 @@ export default class NestAccfactory {
       return location;
     };
 
-    // Process data for any thermostat(s) we have in the raw data
-    const process_thermostat_data = (object_key, data) => {
+    // Process common data for all devices
+    const process_common_data = (object_key, data) => {
       let processed = {};
       try {
         // Fix up data we need to
-        data.serial_number = data.serial_number.toUpperCase(); // ensure serial numbers are in upper case
-        data.excluded =
-          typeof this.config?.devices?.[data.serial_number]?.exclude === 'boolean'
-            ? this.config.devices[data.serial_number].exclude
-            : false; // Mark device as excluded or not
-        data.device_type = NestAccfactory.DeviceType.THERMOSTAT; // Nest Thermostat
-        data.uuid = object_key; // Internal structure ID
+        data.nest_google_uuid = object_key;
+        data.serialNumber = data.serialNumber.toUpperCase(); // ensure serial numbers are in upper case
+        data.excluded = this.config?.devices?.[data?.serialNumber]?.exclude === true; // Mark device as excluded or not
         data.manufacturer = typeof data?.manufacturer === 'string' ? data.manufacturer : 'Nest';
-        data.software_version = typeof data?.software_version === 'string' ? data.software_version.replace(/-/g, '.') : '0.0.0';
-        data.target_temperature_high = adjustTemperature(data.target_temperature_high, 'C', 'C', true);
-        data.target_temperature_low = adjustTemperature(data.target_temperature_low, 'C', 'C', true);
-        data.target_temperature = adjustTemperature(data.target_temperature, 'C', 'C', true);
-        data.backplate_temperature = adjustTemperature(data.backplate_temperature, 'C', 'C', true);
-        data.current_temperature = adjustTemperature(data.current_temperature, 'C', 'C', true);
-        data.battery_level = scaleValue(data.battery_level, 3.6, 3.9, 0, 100);
+        data.softwareVersion =
+          typeof data?.softwareVersion === 'string' ? data.softwareVersion.replace(/([a-zA-Z]+)/g, '.').replace(/-/g, '.') : '0.0.0';
         let description = typeof data?.description === 'string' ? data.description : '';
         let location = typeof data?.location === 'string' ? data.location : '';
         if (description === '') {
@@ -1288,26 +1382,20 @@ export default class NestAccfactory {
         data.description = makeHomeKitName(location === '' ? description : description + ' - ' + location);
         delete data.location;
 
-        // Insert details for when using HAP-NodeJS library rather than Homebridge
-        if (typeof this.config?.options?.hkPairingCode === 'string' && this.config.options.hkPairingCode !== '') {
+        // Insert HomeKit pairing code for when using HAP-NodeJS library rather than Homebridge
+        // Validate the pairing code is in the format of "xxx-xx-xxx" or "xxxx-xxxx"
+        if (
+          new RegExp(/^([0-9]{3}-[0-9]{2}-[0-9]{3})$/).test(this.config?.options?.hkPairingCode) === true ||
+          new RegExp(/^([0-9]{4}-[0-9]{4})$/).test(this.config?.options?.hkPairingCode) === true
+        ) {
           data.hkPairingCode = this.config.options.hkPairingCode;
         }
         if (
-          typeof this.config?.devices?.[data.serial_number]?.hkPairingCode === 'string' &&
-          this.config.devices[data.serial_number].hkPairingCode !== ''
+          new RegExp(/^([0-9]{3}-[0-9]{2}-[0-9]{3})$/).test(this.config?.devices?.[data.serialNumber]?.hkPairingCode) === true ||
+          new RegExp(/^([0-9]{4}-[0-9]{4})$/).test(this.config?.devices?.[data.serialNumber]?.hkPairingCode) === true
         ) {
-          data.hkPairingCode = this.config.devices[data.serial_number].hkPairingCode;
-        }
-        if (data?.hkPairingCode !== undefined && data?.mac_address !== undefined) {
-          // Create mac_address in format of xx:xx:xx:xx:xx:xx
-          data.hkUsername = data.mac_address
-            .toString('hex')
-            .split(/(..)/)
-            .filter((s) => s)
-            .join(':')
-            .toUpperCase();
+          data.hkPairingCode = this.config.devices[data.serialNumber].hkPairingCode;
         }
-        delete data.mac_address;
 
         processed = data;
         // eslint-disable-next-line no-unused-vars
@@ -1317,6 +1405,27 @@ export default class NestAccfactory {
       return processed;
     };
 
+    // Process data for any thermostat(s) we have in the raw data
+    const process_thermostat_data = (object_key, data) => {
+      let processed = {};
+      try {
+        // Fix up data we need to
+        data = process_common_data(object_key, data);
+        data.device_type = NestAccfactory.DeviceType.THERMOSTAT; // Nest Thermostat
+        data.target_temperature_high = adjustTemperature(data.target_temperature_high, 'C', 'C', true);
+        data.target_temperature_low = adjustTemperature(data.target_temperature_low, 'C', 'C', true);
+        data.target_temperature = adjustTemperature(data.target_temperature, 'C', 'C', true);
+        data.backplate_temperature = adjustTemperature(data.backplate_temperature, 'C', 'C', true);
+        data.current_temperature = adjustTemperature(data.current_temperature, 'C', 'C', true);
+        data.battery_level = scaleValue(data.battery_level, 3.6, 3.9, 0, 100);
+        processed = data;
+        // eslint-disable-next-line no-unused-vars
+      } catch (error) {
+        // Empty
+      }
+      return processed;
+    };
+
     const PROTOBUF_THERMOSTAT_RESOURCES = [
       'nest.resource.NestLearningThermostat3Resource',
       'nest.resource.NestAgateDisplayResource',
@@ -1334,11 +1443,13 @@ export default class NestAccfactory {
       .forEach(([object_key, value]) => {
         let tempDevice = {};
         try {
-          if (value?.source === NestAccfactory.DataSource.PROTOBUF) {
+          if (value?.source === NestAccfactory.DataSource.PROTOBUF && value.value?.configuration_done?.deviceReady === true) {
             let RESTTypeData = {};
-            RESTTypeData.mac_address = Buffer.from(value.value.wifi_interface.macAddress, 'base64');
-            RESTTypeData.serial_number = value.value.device_identity.serialNumber;
-            RESTTypeData.software_version = value.value.device_identity.softwareVersion;
+            RESTTypeData.serialNumber = value.value.device_identity.serialNumber;
+            RESTTypeData.softwareVersion =
+              value.value.device_identity.softwareVersion.split(/\s+/)?.[3] !== undefined
+                ? value.value.device_identity.softwareVersion.split(/\s+/)?.[3]
+                : value.value.device_identity.softwareVersion;
             RESTTypeData.model = 'Thermostat';
             if (value.value.device_info.typeName === 'nest.resource.NestLearningThermostat3Resource') {
               RESTTypeData.model = 'Learning Thermostat (3rd gen)';
@@ -1356,8 +1467,8 @@ export default class NestAccfactory {
               RESTTypeData.model = 'Thermostat (2020 Model)';
             }
             RESTTypeData.current_humidity =
-              typeof value.value.current_humidity.humidityValue.humidity.value === 'number'
-                ? value.value.current_humidity.humidityValue.humidity.value
+              isNaN(value.value.current_humidity.humidityValue.humidity.value) === false
+                ? Number(value.value.current_humidity.humidityValue.humidity.value)
                 : 0.0;
             RESTTypeData.temperature_scale = value.value.display_settings.temperatureScale === 'TEMPERATURE_SCALE_F' ? 'F' : 'C';
             RESTTypeData.removed_from_base = value.value.display.thermostatState.includes('bpd') === true;
@@ -1401,25 +1512,25 @@ export default class NestAccfactory {
                 ? value.value.target_temperature_settings.targetTemperature.setpointType.split('SET_POINT_TYPE_')[1].toLowerCase()
                 : 'off';
             RESTTypeData.target_temperature_low =
-              typeof value.value?.target_temperature_settings?.targetTemperature?.heatingTarget?.value === 'number'
-                ? value.value.target_temperature_settings.targetTemperature.heatingTarget.value
+              isNaN(value.value?.target_temperature_settings?.targetTemperature?.heatingTarget?.value) === false
+                ? Number(value.value.target_temperature_settings.targetTemperature.heatingTarget.value)
                 : 0.0;
             RESTTypeData.target_temperature_high =
-              typeof value.value?.target_temperature_settings?.targetTemperature?.coolingTarget?.value === 'number'
-                ? value.value.target_temperature_settings.targetTemperature.coolingTarget.value
+              isNaN(value.value?.target_temperature_settings?.targetTemperature?.coolingTarget?.value) === false
+                ? Number(value.value.target_temperature_settings.targetTemperature.coolingTarget.value)
                 : 0.0;
             RESTTypeData.target_temperature =
               value.value?.target_temperature_settings?.targetTemperature?.setpointType === 'SET_POINT_TYPE_COOL' &&
-              typeof value.value?.target_temperature_settings?.targetTemperature?.coolingTarget?.value === 'number'
-                ? value.value.target_temperature_settings.targetTemperature.coolingTarget.value
+              isNaN(value.value?.target_temperature_settings?.targetTemperature?.coolingTarget?.value) === false
+                ? Number(value.value.target_temperature_settings.targetTemperature.coolingTarget.value)
                 : value.value?.target_temperature_settings?.targetTemperature?.setpointType === 'SET_POINT_TYPE_HEAT' &&
-                    typeof value.value?.target_temperature_settings?.targetTemperature?.heatingTarget?.value === 'number'
-                  ? value.value.target_temperature_settings.targetTemperature.heatingTarget.value
+                    isNaN(value.value?.target_temperature_settings?.targetTemperature?.heatingTarget?.value) === false
+                  ? Number(value.value.target_temperature_settings.targetTemperature.heatingTarget.value)
                   : value.value?.target_temperature_settings?.targetTemperature?.setpointType === 'SET_POINT_TYPE_RANGE' &&
-                      typeof value.value?.target_temperature_settings?.targetTemperature?.coolingTarget?.value === 'number' &&
-                      typeof value.value?.target_temperature_settings?.targetTemperature?.heatingTarget?.value === 'number'
-                    ? (value.value.target_temperature_settings.targetTemperature.coolingTarget.value +
-                        value.value.target_temperature_settings.targetTemperature.heatingTarget.value) *
+                      isNaN(value.value?.target_temperature_settings?.targetTemperature?.coolingTarget?.value) === false &&
+                      isNaN(value.value?.target_temperature_settings?.targetTemperature?.heatingTarget?.value) === false
+                    ? (Number(value.value.target_temperature_settings.targetTemperature.coolingTarget.value) +
+                        Number(value.value.target_temperature_settings.targetTemperature.heatingTarget.value)) *
                       0.5
                     : 0.0;
 
@@ -1478,13 +1589,15 @@ export default class NestAccfactory {
 
             // Update fan status, on or off and max number of speeds supported
             RESTTypeData.fan_state = parseInt(value.value.fan_control_settings.timerEnd?.seconds) > 0 ? true : false;
-            RESTTypeData.fan_current_speed =
-              value.value.fan_control_settings.timerSpeed.includes('FAN_SPEED_SETTING_STAGE') === true
-                ? parseInt(value.value.fan_control_settings.timerSpeed.split('FAN_SPEED_SETTING_STAGE')[1])
+            RESTTypeData.fan_timer_speed =
+              value.value.fan_control_settings.timerSpeed.includes('FAN_SPEED_SETTING_STAGE') === true &&
+              isNaN(value.value.fan_control_settings.timerSpeed.split('FAN_SPEED_SETTING_STAGE')[1]) === false
+                ? Number(value.value.fan_control_settings.timerSpeed.split('FAN_SPEED_SETTING_STAGE')[1])
                 : 0;
             RESTTypeData.fan_max_speed =
-              value.value.fan_control_capabilities.maxAvailableSpeed.includes('FAN_SPEED_SETTING_STAGE') === true
-                ? parseInt(value.value.fan_control_capabilities.maxAvailableSpeed.split('FAN_SPEED_SETTING_STAGE')[1])
+              value.value.fan_control_capabilities.maxAvailableSpeed.includes('FAN_SPEED_SETTING_STAGE') === true &&
+              isNaN(value.value.fan_control_capabilities.maxAvailableSpeed.split('FAN_SPEED_SETTING_STAGE')[1]) === false
+                ? Number(value.value.fan_control_capabilities.maxAvailableSpeed.split('FAN_SPEED_SETTING_STAGE')[1])
                 : 0;
 
             // Humidifier/dehumidifier details
@@ -1550,7 +1663,7 @@ export default class NestAccfactory {
                 RESTTypeData.schedules[dayofWeekIndex][Object.entries(RESTTypeData.schedules[dayofWeekIndex]).length] = {
                   'temp-min': adjustTemperature(schedule.heatingTarget.value, 'C', 'C', true),
                   'temp-max': adjustTemperature(schedule.coolingTarget.value, 'C', 'C', true),
-                  time: typeof schedule.secondsInDay === 'number' ? schedule.secondsInDay : 0,
+                  time: isNaN(schedule.secondsInDay) === false ? Number(schedule.secondsInDay) : 0,
                   type: RESTTypeData.schedule_mode.toUpperCase(),
                   entry_type: 'setpoint',
                 };
@@ -1560,22 +1673,21 @@ export default class NestAccfactory {
             tempDevice = process_thermostat_data(object_key, RESTTypeData);
           }
 
-          if (value?.source === NestAccfactory.DataSource.REST) {
+          if (value?.source === NestAccfactory.DataSource.REST && value.value?.where_id !== undefined) {
             let RESTTypeData = {};
-            RESTTypeData.mac_address = value.value.mac_address;
-            RESTTypeData.serial_number = value.value.serial_number;
-            RESTTypeData.software_version = value.value.current_version;
+            RESTTypeData.serialNumber = value.value.serial_number;
+            RESTTypeData.softwareVersion = value.value.current_version;
             RESTTypeData.model = 'Thermostat';
-            if (value.value.serial_number.serial_number.substring(0, 2) === '15') {
+            if (value.value.serial_number.substring(0, 2) === '15') {
               RESTTypeData.model = 'Thermostat E (1st gen)'; // Nest Thermostat E
             }
-            if (value.value.serial_number.serial_number.substring(0, 2) === '09') {
+            if (value.value.serial_number.substring(0, 2) === '09') {
               RESTTypeData.model = 'Thermostat (3rd gen)'; // Nest Thermostat 3rd Gen
             }
-            if (value.value.serial_number.serial_number.substring(0, 2) === '02') {
+            if (value.value.serial_number.substring(0, 2) === '02') {
               RESTTypeData.model = 'Thermostat (2nd gen)'; // Nest Thermostat 2nd Gen
             }
-            if (value.value.serial_number.serial_number.substring(0, 2) === '01') {
+            if (value.value.serial_number.substring(0, 2) === '01') {
               RESTTypeData.model = 'Thermostat (1st gen)'; // Nest Thermostat 1st Gen
             }
             RESTTypeData.current_humidity = value.value.current_humidity;
@@ -1682,13 +1794,17 @@ export default class NestAccfactory {
 
             // Update fan status, on or off
             RESTTypeData.fan_state = value.value.fan_timer_timeout > 0 ? true : false;
-            RESTTypeData.fan_current_speed =
-              value.value.fan_timer_speed.includes('stage') === true ? parseInt(value.value.fan_timer_speed.split('stage')[1]) : 0;
+            RESTTypeData.fan_timer_speed =
+              value.value.fan_timer_speed.includes('stage') === true && isNaN(value.value.fan_timer_speed.split('stage')[1]) === false
+                ? Number(value.value.fan_timer_speed.split('stage')[1])
+                : 0;
             RESTTypeData.fan_max_speed =
-              value.value.fan_capabilities.includes('stage') === true ? parseInt(value.value.fan_capabilities.split('stage')[1]) : 0;
+              value.value.fan_capabilities.includes('stage') === true && isNaN(value.value.fan_capabilities.split('stage')[1]) === false
+                ? Number(value.value.fan_capabilities.split('stage')[1])
+                : 0;
 
             // Humidifier/dehumidifier details
-            RESTTypeData.target_humidity = typeof value.value.target_humidity === 'number' ? value.value.target_humidity : 0.0;
+            RESTTypeData.target_humidity = isNaN(value.value.target_humidity) === false ? Number(value.value.target_humidity) : 0.0;
             RESTTypeData.humidifier_state = value.value.humidifier_state === true;
             RESTTypeData.dehumidifier_state = value.value.dehumidifier_state === true;
 
@@ -1722,14 +1838,14 @@ export default class NestAccfactory {
               Object.values(this.#rawData['schedule.' + value.value.serial_number].value.days).forEach((schedules) => {
                 Object.values(schedules).forEach((schedule) => {
                   // Fix up temperatures in the schedule
-                  if (typeof schedule['temp'] === 'number') {
-                    schedule.temp = adjustTemperature(schedule.temp, 'C', 'C', true);
+                  if (isNaN(schedule['temp']) === false) {
+                    schedule.temp = adjustTemperature(Number(schedule.temp), 'C', 'C', true);
                   }
-                  if (typeof schedule['temp-min'] === 'number') {
-                    schedule['temp-min'] = adjustTemperature(schedule['temp-min'], 'C', 'C', true);
+                  if (isNaN(schedule['temp-min']) === false) {
+                    schedule['temp-min'] = adjustTemperature(Number(schedule['temp-min']), 'C', 'C', true);
                   }
-                  if (typeof schedule['temp-max'] === 'number') {
-                    schedule['temp-max'] = adjustTemperature(schedule['temp-max'], 'C', 'C', true);
+                  if (isNaN(schedule['temp-max']) === false) {
+                    schedule['temp-max'] = adjustTemperature(Number(schedule['temp-max']), 'C', 'C', true);
                   }
                 });
               });
@@ -1744,28 +1860,28 @@ export default class NestAccfactory {
           this?.log?.debug && this.log.debug('Error processing data for thermostat(s)');
         }
 
-        if (Object.entries(tempDevice).length !== 0 && typeof devices[tempDevice.serial_number] === 'undefined') {
+        if (Object.entries(tempDevice).length !== 0 && typeof devices[tempDevice.serialNumber] === 'undefined') {
           // Insert any extra options we've read in from configuration file for this device
           tempDevice.eveHistory =
-            this.config.options.eveHistory === true || this.config?.devices?.[tempDevice.serial_number]?.eveHistory === true;
-          tempDevice.humiditySensor = this.config?.devices?.[tempDevice.serial_number]?.humiditySensor === true;
+            this.config.options.eveHistory === true || this.config?.devices?.[tempDevice.serialNumber]?.eveHistory === true;
+          tempDevice.humiditySensor = this.config?.devices?.[tempDevice.serialNumber]?.humiditySensor === true;
           tempDevice.externalCool =
-            typeof this.config?.devices?.[tempDevice.serial_number]?.externalCool === 'string'
-              ? this.config.devices[tempDevice.serial_number].externalCool
+            typeof this.config?.devices?.[tempDevice.serialNumber]?.externalCool === 'string'
+              ? this.config.devices[tempDevice.serialNumber].externalCool
               : undefined; // Config option for external cooling source
           tempDevice.externalHeat =
-            typeof this.config?.devices?.[tempDevice.serial_number]?.externalHeat === 'string'
-              ? this.config.devices[tempDevice.serial_number].externalHeat
+            typeof this.config?.devices?.[tempDevice.serialNumber]?.externalHeat === 'string'
+              ? this.config.devices[tempDevice.serialNumber].externalHeat
               : undefined; // Config option for external heating source
           tempDevice.externalFan =
-            typeof this.config?.devices?.[tempDevice.serial_number]?.externalFan === 'string'
-              ? this.config.devices[tempDevice.serial_number].externalFan
+            typeof this.config?.devices?.[tempDevice.serialNumber]?.externalFan === 'string'
+              ? this.config.devices[tempDevice.serialNumber].externalFan
               : undefined; // Config option for external fan source
           tempDevice.externalDehumidifier =
-            typeof this.config?.devices?.[tempDevice.serial_number]?.externalDehumidifier === 'string'
-              ? this.config.devices[tempDevice.serial_number].externalDehumidifier
+            typeof this.config?.devices?.[tempDevice.serialNumber]?.externalDehumidifier === 'string'
+              ? this.config.devices[tempDevice.serialNumber].externalDehumidifier
               : undefined; // Config option for external dehumidifier source
-          devices[tempDevice.serial_number] = tempDevice; // Store processed device
+          devices[tempDevice.serialNumber] = tempDevice; // Store processed device
         }
       });
 
@@ -1776,48 +1892,10 @@ export default class NestAccfactory {
       let processed = {};
       try {
         // Fix up data we need to
-        data.serial_number = data.serial_number.toUpperCase();
-        data.excluded =
-          typeof this.config?.devices?.[data.serial_number]?.exclude === 'boolean'
-            ? this.config.devices[data.serial_number].exclude
-            : false; // Mark device as excluded or not
+        data = process_common_data(object_key, data);
         data.device_type = NestAccfactory.DeviceType.TEMPSENSOR; // Nest Temperature sensor
-        data.uuid = object_key; // Internal structure ID
-        data.manufacturer = typeof data?.manufacturer === 'string' ? data.manufacturer : 'Nest';
-        data.software_version = typeof data?.software_version === 'string' ? data.software_version.replace(/-/g, '.') : '0.0.0';
         data.model = 'Temperature Sensor';
         data.current_temperature = adjustTemperature(data.current_temperature, 'C', 'C', true);
-        let description = typeof data?.description === 'string' ? data.description : '';
-        let location = typeof data?.location === 'string' ? data.location : '';
-        if (description === '') {
-          description = location;
-          location = '';
-        }
-        data.description = makeHomeKitName(location === '' ? description : description + ' - ' + location);
-        delete data.location;
-
-        // Insert details for when using HAP-NodeJS library rather than Homebridge
-        if (typeof this.config?.options?.hkPairingCode === 'string' && this.config.options.hkPairingCode !== '') {
-          data.hkPairingCode = this.config.options.hkPairingCode;
-        }
-        if (
-          typeof this.config?.devices?.[data.serial_number]?.hkPairingCode === 'string' &&
-          this.config.devices[data.serial_number].hkPairingCode !== ''
-        ) {
-          data.hkPairingCode = this.config.devices[data.serial_number].hkPairingCode;
-        }
-        if (data?.hkPairingCode !== undefined) {
-          // Use a Nest Labs prefix for first 6 digits, followed by a CRC24 based off serial number for last 6 digits.
-          let tempMACAddress = '18B430' + crc24(data.serial_number).toUpperCase();
-          data.hkUsername = tempMACAddress
-            .toString('hex')
-            .split(/(..)/)
-            .filter((s) => s)
-            .join(':')
-            .toUpperCase(); // Create mac_address in format of xx:xx:xx:xx:xx:xx
-        }
-        delete data.mac_address;
-
         processed = data;
         // eslint-disable-next-line no-unused-vars
       } catch (error) {
@@ -1838,13 +1916,14 @@ export default class NestAccfactory {
         try {
           if (
             value?.source === NestAccfactory.DataSource.PROTOBUF &&
+            value.value?.configuration_done?.deviceReady === true &&
             typeof value?.value?.associated_thermostat === 'string' &&
             value?.value?.associated_thermostat !== ''
           ) {
             let RESTTypeData = {};
-            RESTTypeData.serial_number = value.value.device_identity.serialNumber;
+            RESTTypeData.serialNumber = value.value.device_identity.serialNumber;
             // Guessing battery minimum voltage is 2v??
-            RESTTypeData.battery_level = scaleValue(value.value.battery.assessedVoltage.value, 2.0, 3.0, 0, 100);
+            RESTTypeData.battery_level = scaleValue(Number(value.value.battery.assessedVoltage.value), 2.0, 3.0, 0, 100);
             RESTTypeData.current_temperature = value.value.current_temperature.temperatureValue.temperature.value;
             // Online status we 'faked' when processing Thermostat Protobuf data
             RESTTypeData.online = value.value?.liveness?.status === 'LIVENESS_DEVICE_STATUS_ONLINE';
@@ -1861,12 +1940,14 @@ export default class NestAccfactory {
           }
           if (
             value?.source === NestAccfactory.DataSource.REST &&
+            value.value?.where_id !== undefined &&
+            value.value?.structure_id !== undefined &&
             typeof value?.value?.associated_thermostat === 'string' &&
             value?.value?.associated_thermostat !== ''
           ) {
             let RESTTypeData = {};
-            RESTTypeData.serial_number = value.value.sserial_number;
-            RESTTypeData.battery_level = scaleValue(value.value.battery_level, 0, 100, 0, 100);
+            RESTTypeData.serialNumber = value.value.serial_number;
+            RESTTypeData.battery_level = scaleValue(Number(value.value.battery_level), 0, 100, 0, 100);
             RESTTypeData.current_temperature = value.value.current_temperature;
             RESTTypeData.online = Math.floor(Date.now() / 1000) - value.value.last_updated_at < 3600 * 4 ? true : false;
             RESTTypeData.associated_thermostat = value.value.associated_thermostat;
@@ -1881,11 +1962,11 @@ export default class NestAccfactory {
         } catch (error) {
           this?.log?.debug && this.log.debug('Error processing data for temperature sensor(s)');
         }
-        if (Object.entries(tempDevice).length !== 0 && typeof devices[tempDevice.serial_number] === 'undefined') {
+        if (Object.entries(tempDevice).length !== 0 && typeof devices[tempDevice.serialNumber] === 'undefined') {
           // Insert any extra options we've read in from configuration file for this device
           tempDevice.eveHistory =
-            this.config.options.eveHistory === true || this.config?.devices?.[tempDevice.serial_number]?.eveHistory === true;
-          devices[tempDevice.serial_number] = tempDevice; // Store processed device
+            this.config.options.eveHistory === true || this.config?.devices?.[tempDevice.serialNumber]?.eveHistory === true;
+          devices[tempDevice.serialNumber] = tempDevice; // Store processed device
         }
       });
 
@@ -1894,15 +1975,8 @@ export default class NestAccfactory {
       let processed = {};
       try {
         // Fix up data we need to
-        data.serial_number = data.serial_number.toUpperCase(); // ensure serial numbers are in upper case
-        data.excluded =
-          typeof this.config?.devices?.[data.serial_number]?.exclude === 'boolean'
-            ? this.config.devices[data.serial_number].exclude
-            : false; // Mark device as excluded or not
+        data = process_common_data(object_key, data);
         data.device_type = NestAccfactory.DeviceType.SMOKESENSOR; // Nest Protect
-        data.uuid = object_key; // Internal structure ID
-        data.manufacturer = typeof data?.manufacturer === 'string' ? data.manufacturer : 'Nest';
-        data.software_version = typeof data?.software_version === 'string' ? data.software_version.replace(/-/g, '.') : '0.0.0';
         data.battery_level = scaleValue(data.battery_level, 0, 5400, 0, 100);
         data.model = 'Protect';
         if (data.wired_or_battery === 0) {
@@ -1911,42 +1985,12 @@ export default class NestAccfactory {
         if (data.wired_or_battery === 1) {
           data.model = data.model + ' (battery'; // Battery powered
         }
-        if (data.serial_number.substring(0, 2) === '06') {
+        if (data.serialNumber.substring(0, 2) === '06') {
           data.model = data.model + ', 2nd gen)'; // Nest Protect 2nd Gen
         }
-        if (data.serial_number.substring(0, 2) === '05') {
+        if (data.serialNumber.substring(0, 2) === '05') {
           data.model = data.model + ', 1st gen)'; // Nest Protect 1st Gen
         }
-        let description = typeof data?.description === 'string' ? data.description : '';
-        let location = typeof data?.location === 'string' ? data.location : '';
-        if (description === '') {
-          description = location;
-          location = '';
-        }
-        data.description = makeHomeKitName(location === '' ? description : description + ' - ' + location);
-        delete data.location;
-
-        // Insert details for when using HAP-NodeJS library rather than Homebridge
-        if (typeof this.config?.options?.hkPairingCode === 'string' && this.config.options.hkPairingCode !== '') {
-          data.hkPairingCode = this.config.options.hkPairingCode;
-        }
-        if (
-          typeof this.config?.devices?.[data.serial_number]?.hkPairingCode === 'string' &&
-          this.config.devices[data.serial_number].hkPairingCode !== ''
-        ) {
-          data.hkPairingCode = this.config.devices[data.serial_number].hkPairingCode;
-        }
-        if (data?.hkPairingCode !== undefined && data?.mac_address !== undefined) {
-          // Create mac_address in format of xx:xx:xx:xx:xx:xx
-          data.hkUsername = data.mac_address
-            .toString('hex')
-            .split(/(..)/)
-            .filter((s) => s)
-            .join(':')
-            .toUpperCase();
-        }
-        delete data.mac_address;
-
         processed = data;
         // eslint-disable-next-line no-unused-vars
       } catch (error) {
@@ -1965,57 +2009,18 @@ export default class NestAccfactory {
       .forEach(([object_key, value]) => {
         let tempDevice = {};
         try {
-          if (value?.source === NestAccfactory.DataSource.PROTOBUF) {
-            /*
-            let RESTTypeData = {};
-            RESTTypeData.mac_address = Buffer.from(value.value.wifi_interface.macAddress, 'base64');
-            RESTTypeData.serial_number = value.value.device_identity.serialNumber;
-            RESTTypeData.software_version = value.value.device_identity.softwareVersion;
-            RESTTypeData.online = value.value?.liveness?.status === 'LIVENESS_DEVICE_STATUS_ONLINE';
-            RESTTypeData.line_power_present = value.value?.wall_power?.status === 'POWER_SOURCE_STATUS_ACTIVE';
-            RESTTypeData.wired_or_battery = typeof value.value?.wall_power === 'object' ? 0 : 1;
-            RESTTypeData.battery_level = parseFloat(value.value.battery_voltage_bank1.batteryValue.batteryVoltage.value);
-            RESTTypeData.battery_health_state = value.value.battery_voltage_bank1.faultInformation;
-            RESTTypeData.smoke_status = value.value.safety_alarm_smoke.alarmState === 'ALARM_STATE_ALARM' ? 2 : 0; // matches REST data
-            RESTTypeData.co_status = value.value.safety_alarm_co.alarmState === 'ALARM_STATE_ALARM' ? 2 : 0; // matches REST data
-            // RESTTypeData.heat_status =
-            RESTTypeData.hushed_state =
-              value.value.safety_alarm_smoke.silenceState === 'SILENCE_STATE_SILENCED' ||
-              value.value.safety_alarm_co.silenceState === 'SILENCE_STATE_SILENCED';
-            RESTTypeData.ntp_green_led_enable = value.value.night_time_promise_settings.greenLedEnabled === true;
-            RESTTypeData.smoke_test_passed = value.value.safety_summary.warningDevices.failures.includes('FAILURE_TYPE_SMOKE') === false;
-            RESTTypeData.heat_test_passed = value.value.safety_summary.warningDevices.failures.includes('FAILURE_TYPE_TEMP') === false;
-            RESTTypeData.latest_alarm_test =
-              parseInt(value.value.self_test.lastMstEnd?.second) > 0 ? parseInt(value.value.self_test.lastMstEnd.seconds) : 0;
-            RESTTypeData.self_test_in_progress =
-              value.value.legacy_structure_self_test.mstInProgress === true ||
-              value.value.legacy_structure_self_test.astInProgress === true;
-            RESTTypeData.replacement_date =
-              value.value.legacy_protect_device_settings.replaceByDate.hasOwnProperty('seconds') === true
-                ? parseInt(value.value.legacy_protect_device_settings.replaceByDate.seconds)
-                : 0;
-
-            // RESTTypeData.removed_from_base =
-            RESTTypeData.topaz_hush_key =
-              typeof value.value.safety_structure_settings.structureHushKey === 'string'
-                ? value.value.safety_structure_settings.structureHushKey
-                : '';
-            RESTTypeData.detected_motion = value.value.legacy_protect_device_info.autoAway === false;
-            RESTTypeData.description = typeof value.value?.label?.label === 'string' ? value.value.label.label : '';
-            RESTTypeData.location = get_location_name(
-              value.value?.device_info?.pairerId?.resourceId,
-              value.value?.device_located_settings?.whereAnnotationRid?.resourceId,
-            );
-            tempDevice = process_protect_data(object_key, RESTTypeData);
-            */
-          }
-
-          if (value?.source === NestAccfactory.DataSource.REST) {
+          if (
+            value?.source === NestAccfactory.DataSource.REST &&
+            value.value?.where_id !== undefined &&
+            value.value?.structure_id !== undefined
+          ) {
             let RESTTypeData = {};
-            RESTTypeData.mac_address = value.value.wifi_mac_address;
-            RESTTypeData.serial_number = value.value.serial_number;
-            RESTTypeData.software_version = value.value.software_version;
-            RESTTypeData.online = this.#rawData?.['widget_track.' + value?.value?.thread_mac_address.toUpperCase()]?.value?.online === true;
+            RESTTypeData.serialNumber = value.value.serial_number;
+            RESTTypeData.softwareVersion = value.value.software_version;
+            RESTTypeData.online =
+              typeof value?.value?.thread_mac_address === 'string'
+                ? this.#rawData?.['widget_track.' + value?.value?.thread_mac_address.toUpperCase()]?.value?.online === true
+                : false;
             RESTTypeData.line_power_present = value.value.line_power_present === true;
             RESTTypeData.wired_or_battery = value.value.wired_or_battery;
             RESTTypeData.battery_level = value.value.battery_level;
@@ -2046,11 +2051,11 @@ export default class NestAccfactory {
           this?.log?.debug && this.log.debug('Error processing data for smoke sensor(s)');
         }
 
-        if (Object.entries(tempDevice).length !== 0 && typeof devices[tempDevice.serial_number] === 'undefined') {
+        if (Object.entries(tempDevice).length !== 0 && typeof devices[tempDevice.serialNumber] === 'undefined') {
           // Insert any extra options we've read in from configuration file for this device
           tempDevice.eveHistory =
-            this.config.options.eveHistory === true || this.config?.devices?.[tempDevice.serial_number]?.eveHistory === true;
-          devices[tempDevice.serial_number] = tempDevice; // Store processed device
+            this.config.options.eveHistory === true || this.config?.devices?.[tempDevice.serialNumber]?.eveHistory === true;
+          devices[tempDevice.serialNumber] = tempDevice; // Store processed device
         }
       });
 
@@ -2059,11 +2064,7 @@ export default class NestAccfactory {
       let processed = {};
       try {
         // Fix up data we need to
-        data.serial_number = data.serial_number.toUpperCase(); // ensure serial numbers are in upper case
-        data.excluded =
-          typeof this.config?.devices?.[data.serial_number]?.exclude === 'boolean'
-            ? this.config.devices[data.serial_number].exclude
-            : false; // Mark device as excluded or not
+        data = process_common_data(object_key, data);
         data.device_type = NestAccfactory.DeviceType.CAMERA;
         if (data.model.toUpperCase().includes('DOORBELL') === true) {
           data.device_type = NestAccfactory.DeviceType.DOORBELL;
@@ -2071,39 +2072,6 @@ export default class NestAccfactory {
         if (data.model.toUpperCase().includes('FLOODLIGHT') === true) {
           data.device_type = NestAccfactory.DeviceType.FLOODLIGHT;
         }
-        data.uuid = object_key; // Internal structure ID
-        data.manufacturer = typeof data?.manufacturer === 'string' ? data.manufacturer : 'Nest';
-        data.software_version = typeof data?.software_version === 'string' ? data.software_version.replace(/-/g, '.') : '0.0.0';
-        let description = typeof data?.description === 'string' ? data.description : '';
-        let location = typeof data?.location === 'string' ? data.location : '';
-        if (description === '') {
-          description = location;
-          location = '';
-        }
-        data.description = makeHomeKitName(location === '' ? description : description + ' - ' + location);
-        delete data.location;
-
-        // Insert details for when using HAP-NodeJS library rather than Homebridge
-        if (typeof this.config?.options?.hkPairingCode === 'string' && this.config.options.hkPairingCode !== '') {
-          data.hkPairingCode = this.config.options.hkPairingCode;
-        }
-        if (
-          typeof this.config?.devices?.[data.serial_number]?.hkPairingCode === 'string' &&
-          this.config.devices[data.serial_number].hkPairingCode !== ''
-        ) {
-          data.hkPairingCode = this.config.devices[data.serial_number].hkPairingCode;
-        }
-        if (data?.hkPairingCode !== undefined && data?.mac_address !== undefined) {
-          // Create mac_address in format of xx:xx:xx:xx:xx:xx
-          data.hkUsername = data.mac_address
-            .toString('hex')
-            .split(/(..)/)
-            .filter((s) => s)
-            .join(':')
-            .toUpperCase();
-        }
-        delete data.mac_address;
-
         processed = data;
         // eslint-disable-next-line no-unused-vars
       } catch (error) {
@@ -2134,18 +2102,22 @@ export default class NestAccfactory {
       .forEach(([object_key, value]) => {
         let tempDevice = {};
         try {
-          if (value?.source === NestAccfactory.DataSource.PROTOBUF && value.value?.streaming_protocol !== undefined) {
+          if (
+            value?.source === NestAccfactory.DataSource.PROTOBUF &&
+            value.value?.streaming_protocol?.supportedProtocols !== undefined &&
+            (value.value?.configuration_done?.deviceReady === true ||
+              value.value?.camera_migration_status?.state?.where === 'MIGRATED_TO_GOOGLE_HOME')
+          ) {
             let RESTTypeData = {};
-            // If we haven't found a macaddress, ase a Nest Labs prefix for first 6 digits followed by a CRC24 based off serial number for last 6 digits.
-            RESTTypeData.mac_address =
-              value.value?.wifi_interface?.macAddress !== undefined
-                ? Buffer.from(value.value.wifi_interface.macAddress, 'base64')
-                : '18B430' + crc24(value.value.device_identity.serialNumber.toUpperCase());
-            RESTTypeData.serial_number = value.value.device_identity.serialNumber;
-            RESTTypeData.software_version =
-              value.value?.floodlight_settings?.associatedFloodlightFirmwareVersion !== undefined
-                ? value.value.floodlight_settings.associatedFloodlightFirmwareVersion
-                : value.value.device_identity.softwareVersion.replace(/[^0-9.]/g, '');
+            RESTTypeData.serialNumber = value.value.device_identity.serialNumber;
+
+            // Protobuf camera firmware versions appear in alonger string. Seems the '4th' word in the string is the actual number version
+            // ie: rquartz-user 1 OPENMASTER 507800056 test-keys stable-channel stable-channel
+            // ie: nq-user 1.73 OPENMASTER 422270 release-keys stable-channel stable-channel
+            RESTTypeData.softwareVersion =
+              value.value.device_identity.softwareVersion.split(/\s+/)?.[3] !== undefined
+                ? value.value.device_identity.softwareVersion.split(/\s+/)?.[3]
+                : value.value.device_identity.softwareVersion;
             RESTTypeData.model = 'Camera';
             if (
               value.value.device_info.typeName === 'google.resource.NeonQuartzResource' &&
@@ -2200,13 +2172,13 @@ export default class NestAccfactory {
             //RESTTypeData.has_statusled =
             //RESTTypeData.statusled_brightness =
             RESTTypeData.has_microphone = value.value?.microphone_settings?.enableMicrophone === true;
-            RESTTypeData.has_speaker = value.value?.speaker_volume?.volume === true;
+            RESTTypeData.has_speaker = value.value?.speaker_volume?.volume !== undefined;
             RESTTypeData.has_motion_detection = value.value?.observation_trigger_capabilities?.videoEventTypes?.motion?.value === true;
             RESTTypeData.activity_zones = [];
             if (value.value?.activity_zone_settings?.activityZones !== undefined) {
               value.value.activity_zone_settings.activityZones.forEach((zone) => {
                 RESTTypeData.activity_zones.push({
-                  id: typeof zone.zoneProperties?.zoneId === 'number' ? zone.zoneProperties.zoneId : zone.zoneProperties.internalIndex,
+                  id: zone.zoneProperties?.zoneId !== undefined ? zone.zoneProperties.zoneId : zone.zoneProperties.internalIndex,
                   name: makeHomeKitName(zone.zoneProperties?.name !== undefined ? zone.zoneProperties.name : ''),
                   hidden: false,
                   uri: '',
@@ -2228,18 +2200,33 @@ export default class NestAccfactory {
             RESTTypeData.light_enabled = value.value?.floodlight_state?.currentState === 'LIGHT_STATE_ON';
             RESTTypeData.light_brightness =
               value.value?.floodlight_settings?.brightness !== undefined
-                ? scaleValue(value.value.floodlight_settings.brightness, 0, 10, 0, 100)
+                ? scaleValue(Number(value.value.floodlight_settings.brightness), 0, 10, 0, 100)
                 : 0;
 
+            // Status of where the device sites between Nest/Google Home App
+            RESTTypeData.migrating =
+              value.value?.camera_migration_status?.state?.progress !== undefined &&
+              value.value?.camera_migration_status?.state?.progress !== 'PROGRESS_COMPLETE' &&
+              value.value?.camera_migration_status?.state?.progress !== 'PROGRESS_NONE';
+
+            // Details to allow access to camera API calls for the device
+            RESTTypeData.apiAccess = this.#connections?.[value.connection]?.cameraAPI;
+
             tempDevice = process_camera_doorbell_data(object_key, RESTTypeData);
           }
 
-          if (value?.source === NestAccfactory.DataSource.REST && value.value?.properties?.['cc2migration.overview_state'] === 'NORMAL') {
+          if (
+            value?.source === NestAccfactory.DataSource.REST &&
+            value.value?.where_id !== undefined &&
+            value.value?.structure_id !== undefined &&
+            value.value?.nexus_api_http_server_url !== undefined &&
+            (value.value?.properties?.['cc2migration.overview_state'] === 'NORMAL' ||
+              value.value?.properties?.['cc2migration.overview_state'] === 'REVERSE_MIGRATION_IN_PROGRESS')
+          ) {
             // We'll only use the REST API data for Camera's which have NOT been migrated to Google Home
             let RESTTypeData = {};
-            RESTTypeData.mac_address = value.value.mac_address;
-            RESTTypeData.serial_number = value.value.serial_number;
-            RESTTypeData.software_version = value.value.software_version;
+            RESTTypeData.serialNumber = value.value.serial_number;
+            RESTTypeData.softwareVersion = value.value.software_version;
             RESTTypeData.model = value.value.model.replace(/nest\s*/gi, ''); // Use camera/doorbell model that Nest supplies
             RESTTypeData.description = value.value?.description;
             RESTTypeData.location = get_location_name(value.value.structure_id, value.value.where_id);
@@ -2254,7 +2241,10 @@ export default class NestAccfactory {
             RESTTypeData.has_statusled = value.value?.capabilities.includes('statusled') === true;
             RESTTypeData.has_video_flip = value.value?.capabilities.includes('video.flip') === true;
             RESTTypeData.video_flipped = value.value?.properties['video.flipped'] === true;
-            RESTTypeData.statusled_brightness = value.value?.properties['statusled.brightness'];
+            RESTTypeData.statusled_brightness =
+              isNaN(value.value?.properties?.['statusled.brightness']) === false
+                ? Number(value.value?.properties['statusled.brightness'])
+                : 0;
             RESTTypeData.has_microphone = value.value?.capabilities.includes('audio.microphone') === true;
             RESTTypeData.has_speaker = value.value?.capabilities.includes('audio.speaker') === true;
             RESTTypeData.has_motion_detection = value.value?.capabilities.includes('detectors.on_camera') === true;
@@ -2265,6 +2255,14 @@ export default class NestAccfactory {
             RESTTypeData.quiet_time_enabled = false;
             RESTTypeData.camera_type = value.value.camera_type;
 
+            // Active migration status between Nest/Google Home App
+            RESTTypeData.migrating =
+              value.value?.properties?.['cc2migration.overview_state'] !== undefined &&
+              value.value?.properties?.['cc2migration.overview_state'] !== 'NORMAL';
+
+            // Details to allow access to camera API calls for the device
+            RESTTypeData.apiAccess = this.#connections?.[value.connection]?.cameraAPI;
+
             tempDevice = process_camera_doorbell_data(object_key, RESTTypeData);
           }
           // eslint-disable-next-line no-unused-vars
@@ -2272,34 +2270,34 @@ export default class NestAccfactory {
           this?.log?.debug && this.log.debug('Error processing data for camera/doorbell(s)');
         }
 
-        if (Object.entries(tempDevice).length !== 0 && typeof devices[tempDevice.serial_number] === 'undefined') {
-          // Insert details to allow access to camera API calls for the device
-          if (value.connection !== undefined && typeof this.#connections?.[value.connection]?.cameraAPI === 'object') {
-            tempDevice.apiAccess = this.#connections[value.connection].cameraAPI;
-          }
-
+        if (Object.entries(tempDevice).length !== 0 && typeof devices[tempDevice.serialNumber] === 'undefined') {
           // Insert any extra options we've read in from configuration file for this device
           tempDevice.eveHistory =
-            this.config.options.eveHistory === true || this.config?.devices?.[tempDevice.serial_number]?.eveHistory === true;
-          tempDevice.hksv = this.config.options.hksv === true || this.config?.devices?.[tempDevice.serial_number]?.hksv === true;
+            this.config.options.eveHistory === true || this.config?.devices?.[tempDevice.serialNumber]?.eveHistory === true;
+          tempDevice.hksv = this.config.options.hksv === true || this.config?.devices?.[tempDevice.serialNumber]?.hksv === true;
           tempDevice.doorbellCooldown =
-            typeof this.config?.devices?.[tempDevice.serial_number]?.doorbellCooldown === 'number'
-              ? this.config.devices[tempDevice.serial_number].doorbellCooldown
+            isNaN(this.config?.devices?.[tempDevice.serialNumber]?.doorbellCooldown) === false
+              ? Number(this.config.devices[tempDevice.serialNumber].doorbellCooldown)
               : 60;
           tempDevice.motionCooldown =
-            typeof this.config?.devices?.[tempDevice.serial_number]?.motionCooldown === 'number'
-              ? this.config.devices[tempDevice.serial_number].motionCooldown
+            isNaN(this.config?.devices?.[tempDevice.serialNumber]?.motionCooldown) === false
+              ? Number(this.config.devices[tempDevice.serialNumber].motionCooldown)
               : 60;
           tempDevice.personCooldown =
-            typeof this.config?.devices?.[tempDevice.serial_number]?.personCooldown === 'number'
-              ? this.config.devices[tempDevice.serial_number].personCooldown
+            isNaN(this.config?.devices?.[tempDevice.serialNumber]?.personCooldown) === false
+              ? Number(this.config.devices[tempDevice.serialNumber].personCooldown)
               : 120;
-          tempDevice.chimeSwitch = this.config?.devices?.[tempDevice.serial_number]?.chimeSwitch === true; // Control 'indoor' chime by switch
-          tempDevice.localAccess = this.config?.devices?.[tempDevice.serial_number]?.localAccess === true; // Local network video streaming rather than from cloud from camera/doorbells
+          tempDevice.chimeSwitch = this.config?.devices?.[tempDevice.serialNumber]?.chimeSwitch === true; // Control 'indoor' chime by switch
+          tempDevice.localAccess = this.config?.devices?.[tempDevice.serialNumber]?.localAccess === true; // Local network video streaming rather than from cloud from camera/doorbells
           tempDevice.ffmpeg = this.config.options.ffmpeg; // ffmpeg details, path, libraries. No ffmpeg = undefined
           tempDevice.maxStreams =
-            typeof this.config.options?.maxStreams === 'number' ? this.config.options.maxStreams : this.deviceData.hksv === true ? 1 : 2;
-          devices[tempDevice.serial_number] = tempDevice; // Store processed device
+            isNaN(this.config.options?.maxStreams) === false
+              ? Number(this.config.options.maxStreams)
+              : this.deviceData.hksv === true
+                ? 1
+                : 2;
+
+          devices[tempDevice.serialNumber] = tempDevice; // Store processed device
         }
       });
 
@@ -2309,15 +2307,8 @@ export default class NestAccfactory {
       let processed = {};
       try {
         // Fix up data we need to
-
-        // For the serial number, use a Nest Labs prefix for first 6 digits, followed by a CRC24 based off structure for last 6 digits.
-        data.serial_number = '18B430' + crc24(object_key).toUpperCase();
-        data.excluded = this.config?.options?.weather === false; // Mark device as excluded or not
+        data = process_common_data(object_key, data);
         data.device_type = NestAccfactory.DeviceType.WEATHER;
-        data.uuid = object_key; // Internal structure ID
-        data.manufacturer = typeof data?.manufacturer === 'string' ? data.manufacturer : 'Nest';
-        data.software_version = typeof data?.software_version === 'string' ? data.software_version.replace(/-/g, '.') : '0.0.0';
-        data.description = typeof data?.description === 'string' ? makeHomeKitName(data.description) : '';
         data.model = 'Weather';
         data.current_temperature = data.weather.current_temperature;
         data.current_humidity = data.weather.current_humidity;
@@ -2328,41 +2319,12 @@ export default class NestAccfactory {
         data.sunset = data.weather.sunset;
         data.station = data.weather.station;
         data.forecast = data.weather.forecast;
-        data.elevation = 0;
-
-        // Either use global elevation setting or one specific for device
-        if (typeof this.config?.devices?.[data.serial_number]?.elevation === 'number') {
-          data.elevation = this.config.devices[data.serial_number].elevation;
-        }
-
-        if (data.elevation === 0 && typeof this.config?.options?.elevation === 'number') {
-          // Elevation from configuration
-          data.elevation = this.config.options.elevation;
-        }
-
-        // Insert details for when using HAP-NodeJS library rather than Homebridge
-        if (typeof this.config?.options?.hkPairingCode === 'string' && this.config.options.hkPairingCode !== '') {
-          data.hkPairingCode = this.config.options.hkPairingCode;
-        }
-        if (
-          typeof this.config?.devices?.[data.serial_number]?.hkPairingCode === 'string' &&
-          this.config.devices[data.serial_number].hkPairingCode !== ''
-        ) {
-          data.hkPairingCode = this.config.devices[data.serial_number].hkPairingCode;
-        }
-        if (data?.hkPairingCode !== undefined) {
-          // Use a Nest Labs prefix for first 6 digits, followed by a CRC24 based off serial number for last 6 digits.
-          let tempMACAddress = '18B430' + crc24(object_key).toUpperCase();
-          data.hkUsername = tempMACAddress
-            .toString('hex')
-            .split(/(..)/)
-            .filter((s) => s)
-            .join(':')
-            .toUpperCase(); // Create mac_address in format of xx:xx:xx:xx:xx:xx
-        }
-
-        delete data.weather; // Don't need the 'weather' object in our output
-
+        data.elevation =
+          isNaN(this.config?.devices?.[data?.serial_number]?.elevation) === false
+            ? Number(this.config.devices[data.serial_number].elevation)
+            : isNaN(this.config?.options?.elevation) === false
+              ? Number(this.config.options.elevation)
+              : 0;
         processed = data;
         // eslint-disable-next-line no-unused-vars
       } catch (error) {
@@ -2374,13 +2336,20 @@ export default class NestAccfactory {
     Object.entries(this.#rawData)
       .filter(
         ([key]) =>
-          (key.startsWith('structure.') === true || key.startsWith('STRUCTURE_') === true) && (deviceUUID === '' || deviceUUID === key),
+          (key.startsWith('structure.') === true || key.startsWith('STRUCTURE_') === true) &&
+          (deviceUUID === '' || deviceUUID === key) &&
+          this.config?.options?.weather === true, // Only if weather enabled
       )
       .forEach(([object_key, value]) => {
         let tempDevice = {};
         try {
-          if (value?.source === NestAccfactory.DataSource.PROTOBUF) {
+          if (
+            value?.source === NestAccfactory.DataSource.PROTOBUF &&
+            value.value?.structure_location?.geoCoordinate?.latitude !== undefined &&
+            value.value?.structure_location?.geoCoordinate?.longitude !== undefined
+          ) {
             let RESTTypeData = {};
+            RESTTypeData.serialNumber = '18B430' + crc24(value.value.structure_info.rtsStructureId.toUpperCase()).toUpperCase();
             RESTTypeData.postal_code = value.value.structure_location.postalCode.value;
             RESTTypeData.country_code = value.value.structure_location.countryCode.value;
             RESTTypeData.city = value.value?.structure_location?.city !== undefined ? value.value.structure_location.city.value : '';
@@ -2393,12 +2362,18 @@ export default class NestAccfactory {
                 : value.value.structure_info.name;
             RESTTypeData.weather = value.value.weather;
 
-            // Use the REST API structure ID from the Protobuf structure. This should prevent two 'weather' objects being created
-            let tempDevice = process_structure_data(value.value.structure_info.rtsStructureId, RESTTypeData);
-            tempDevice.uuid = object_key; // Use the Protobuf structure ID post processing
+            // Use the REST API structure ID from the Protobuf structure. This will ensure we generate the same serial number
+            // This should prevent two 'weather' objects being created
+            tempDevice = process_structure_data(object_key, RESTTypeData);
           }
-          if (value?.source === NestAccfactory.DataSource.REST) {
+
+          if (
+            value?.source === NestAccfactory.DataSource.REST &&
+            value.value?.latitude !== undefined &&
+            value.value?.longitude !== undefined
+          ) {
             let RESTTypeData = {};
+            RESTTypeData.serialNumber = '18B430' + crc24(object_key.toUpperCase()).toUpperCase();
             RESTTypeData.postal_code = value.value.postal_code;
             RESTTypeData.country_code = value.value.country_code;
             RESTTypeData.city = value.value?.city !== undefined ? value.value.city : '';
@@ -2415,35 +2390,37 @@ export default class NestAccfactory {
           this?.log?.debug && this.log.debug('Error processing data for weather');
         }
 
-        if (Object.entries(tempDevice).length !== 0 && typeof devices[tempDevice.serial_number] === 'undefined') {
+        if (Object.entries(tempDevice).length !== 0 && typeof devices[tempDevice.serialNumber] === 'undefined') {
           // Insert any extra options we've read in from configuration file for this device
           tempDevice.eveHistory =
-            this.config.options.eveHistory === true || this.config?.devices?.[tempDevice.serial_number]?.eveHistory === true;
-          devices[tempDevice.serial_number] = tempDevice; // Store processed device
+            this.config.options.eveHistory === true || this.config?.devices?.[tempDevice.serialNumber]?.eveHistory === true;
+          devices[tempDevice.serialNumber] = tempDevice; // Store processed device
         }
       });
 
     return devices; // Return our processed data
   }
 
-  async #set(deviceUUID, values) {
+  async #set(uuid, values) {
     if (
-      typeof deviceUUID !== 'string' ||
-      typeof this.#rawData?.[deviceUUID] !== 'object' ||
+      typeof uuid !== 'string' ||
+      uuid === '' ||
       typeof values !== 'object' ||
-      typeof this.#connections[this.#rawData?.[deviceUUID]?.connection] !== 'object'
+      values?.uuid === undefined ||
+      typeof this.#rawData?.[values?.uuid] !== 'object' ||
+      typeof this.#connections?.[this.#rawData?.[values?.uuid]?.connection] !== 'object'
     ) {
       return;
     }
 
-    if (
-      this.#connections[this.#rawData[deviceUUID].connection].protobufRoot !== null &&
-      this.#rawData?.[deviceUUID]?.source === NestAccfactory.DataSource.PROTOBUF
-    ) {
+    let nest_google_uuid = values.uuid; // Nest/Google structure uuid for this get request
+    let connectionUuid = this.#rawData[values.uuid].connection; // Associated connection uuid for the uuid
+
+    if (this.#protobufRoot !== null && this.#rawData?.[nest_google_uuid]?.source === NestAccfactory.DataSource.PROTOBUF) {
       let updatedTraits = [];
       let protobufElement = {
         traitRequest: {
-          resourceId: deviceUUID,
+          resourceId: nest_google_uuid,
           traitLabel: '',
           requestId: crypto.randomUUID(),
         },
@@ -2454,444 +2431,508 @@ export default class NestAccfactory {
       };
 
       await Promise.all(
-        Object.entries(values).map(async ([key, value]) => {
-          // Reset elements at start of loop
-          protobufElement.traitRequest.traitLabel = '';
-          protobufElement.state.type_url = '';
-          protobufElement.state.value = {};
-
-          if (
-            (key === 'hvac_mode' &&
-              typeof value === 'string' &&
-              (value.toUpperCase() === 'OFF' ||
-                value.toUpperCase() === 'COOL' ||
-                value.toUpperCase() === 'HEAT' ||
-                value.toUpperCase() === 'RANGE')) ||
-            (key === 'target_temperature' &&
-              this.#rawData?.[deviceUUID]?.value?.eco_mode_state?.ecoMode === 'ECO_MODE_INACTIVE' &&
-              typeof value === 'number') ||
-            (key === 'target_temperature_low' &&
-              this.#rawData?.[deviceUUID]?.value?.eco_mode_state?.ecoMode === 'ECO_MODE_INACTIVE' &&
-              typeof value === 'number') ||
-            (key === 'target_temperature_high' &&
-              this.#rawData?.[deviceUUID]?.value?.eco_mode_state?.ecoMode === 'ECO_MODE_INACTIVE' &&
-              typeof value === 'number')
-          ) {
-            // Set either the 'mode' and/or non-eco temperatures on the target thermostat
-            protobufElement.traitRequest.traitLabel = 'target_temperature_settings';
-            protobufElement.state.type_url = 'type.nestlabs.com/nest.trait.hvac.TargetTemperatureSettingsTrait';
-            protobufElement.state.value = this.#rawData[deviceUUID].value.target_temperature_settings;
+        Object.entries(values)
+          .filter(([key]) => key !== 'uuid')
+          .map(async ([key, value]) => {
+            // Reset elements at start of loop
+            protobufElement.traitRequest.traitLabel = '';
+            protobufElement.state.type_url = '';
+            protobufElement.state.value = {};
 
             if (
-              (key === 'target_temperature_low' || key === 'target_temperature') &&
-              (protobufElement.state.value.targetTemperature.setpointType === 'SET_POINT_TYPE_HEAT' ||
-                protobufElement.state.value.targetTemperature.setpointType === 'SET_POINT_TYPE_RANGE')
+              (key === 'hvac_mode' &&
+                typeof value === 'string' &&
+                (value.toUpperCase() === 'OFF' ||
+                  value.toUpperCase() === 'COOL' ||
+                  value.toUpperCase() === 'HEAT' ||
+                  value.toUpperCase() === 'RANGE')) ||
+              (key === 'target_temperature' &&
+                this.#rawData?.[nest_google_uuid]?.value?.eco_mode_state?.ecoMode === 'ECO_MODE_INACTIVE' &&
+                isNaN(value) === false) ||
+              (key === 'target_temperature_low' &&
+                this.#rawData?.[nest_google_uuid]?.value?.eco_mode_state?.ecoMode === 'ECO_MODE_INACTIVE' &&
+                isNaN(value) === false) ||
+              (key === 'target_temperature_high' &&
+                this.#rawData?.[nest_google_uuid]?.value?.eco_mode_state?.ecoMode === 'ECO_MODE_INACTIVE' &&
+                isNaN(value) === false)
             ) {
-              // Changing heating target temperature
-              protobufElement.state.value.targetTemperature.heatingTarget = { value: value };
+              // Set either the 'mode' and/or non-eco temperatures on the target thermostat
+              protobufElement.traitRequest.traitLabel = 'target_temperature_settings';
+              protobufElement.state.type_url = 'type.nestlabs.com/nest.trait.hvac.TargetTemperatureSettingsTrait';
+              protobufElement.state.value = this.#rawData[nest_google_uuid].value.target_temperature_settings;
+
+              if (
+                (key === 'target_temperature_low' || key === 'target_temperature') &&
+                (protobufElement.state.value.targetTemperature.setpointType === 'SET_POINT_TYPE_HEAT' ||
+                  protobufElement.state.value.targetTemperature.setpointType === 'SET_POINT_TYPE_RANGE')
+              ) {
+                // Changing heating target temperature
+                protobufElement.state.value.targetTemperature.heatingTarget = { value: value };
+              }
+              if (
+                (key === 'target_temperature_high' || key === 'target_temperature') &&
+                (protobufElement.state.value.targetTemperature.setpointType === 'SET_POINT_TYPE_COOL' ||
+                  protobufElement.state.value.targetTemperature.setpointType === 'SET_POINT_TYPE_RANGE')
+              ) {
+                // Changing cooling target temperature
+                protobufElement.state.value.targetTemperature.coolingTarget = { value: value };
+              }
+
+              if (key === 'hvac_mode' && value.toUpperCase() !== 'OFF') {
+                protobufElement.state.value.targetTemperature.setpointType = 'SET_POINT_TYPE_' + value.toUpperCase();
+                protobufElement.state.value.enabled = { value: true };
+              }
+
+              if (key === 'hvac_mode' && value.toUpperCase() === 'OFF') {
+                protobufElement.state.value.enabled = { value: false };
+              }
+
+              // Tag 'who is doing the temperature/mode change. We are :-)
+              protobufElement.state.value.targetTemperature.currentActorInfo = {
+                method: 'HVAC_ACTOR_METHOD_IOS',
+                originator: this.#rawData[nest_google_uuid].value.target_temperature_settings.targetTemperature.currentActorInfo.originator,
+                timeOfAction: { seconds: Math.floor(Date.now() / 1000), nanos: (Date.now() % 1000) * 1e6 },
+                originatorRtsId: '',
+              };
             }
+
             if (
-              (key === 'target_temperature_high' || key === 'target_temperature') &&
-              (protobufElement.state.value.targetTemperature.setpointType === 'SET_POINT_TYPE_COOL' ||
-                protobufElement.state.value.targetTemperature.setpointType === 'SET_POINT_TYPE_RANGE')
+              (key === 'target_temperature' &&
+                this.#rawData?.[nest_google_uuid]?.value?.eco_mode_state?.ecoMode !== 'ECO_MODE_INACTIVE' &&
+                isNaN(value) === false) ||
+              (key === 'target_temperature_low' &&
+                this.#rawData?.[nest_google_uuid]?.value?.eco_mode_state?.ecoMode !== 'ECO_MODE_INACTIVE' &&
+                isNaN(value) === false) ||
+              (key === 'target_temperature_high' &&
+                this.#rawData?.[nest_google_uuid]?.value?.eco_mode_state?.ecoMode !== 'ECO_MODE_INACTIVE' &&
+                isNaN(value) === false)
             ) {
-              // Changing cooling target temperature
-              protobufElement.state.value.targetTemperature.coolingTarget = { value: value };
+              // Set eco mode temperatures on the target thermostat
+              protobufElement.traitRequest.traitLabel = 'eco_mode_settings';
+              protobufElement.state.type_url = 'type.nestlabs.com/nest.trait.hvac.EcoModeSettingsTrait';
+              protobufElement.state.value = this.#rawData[nest_google_uuid].value.eco_mode_settings;
+
+              protobufElement.state.value.ecoTemperatureHeat.value.value =
+                protobufElement.state.value.ecoTemperatureHeat.enabled === true &&
+                protobufElement.state.value.ecoTemperatureCool.enabled === false
+                  ? value
+                  : protobufElement.state.value.ecoTemperatureHeat.value.value;
+              protobufElement.state.value.ecoTemperatureCool.value.value =
+                protobufElement.state.value.ecoTemperatureHeat.enabled === false &&
+                protobufElement.state.value.ecoTemperatureCool.enabled === true
+                  ? value
+                  : protobufElement.state.value.ecoTemperatureCool.value.value;
+              protobufElement.state.value.ecoTemperatureHeat.value.value =
+                protobufElement.state.value.ecoTemperatureHeat.enabled === true &&
+                protobufElement.state.value.ecoTemperatureCool.enabled === true &&
+                key === 'target_temperature_low'
+                  ? value
+                  : protobufElement.state.value.ecoTemperatureHeat.value.value;
+              protobufElement.state.value.ecoTemperatureCool.value.value =
+                protobufElement.state.value.ecoTemperatureHeat.enabled === true &&
+                protobufElement.state.value.ecoTemperatureCool.enabled === true &&
+                key === 'target_temperature_high'
+                  ? value
+                  : protobufElement.state.value.ecoTemperatureCool.value.value;
             }
 
-            if (key === 'hvac_mode' && value.toUpperCase() !== 'OFF') {
-              protobufElement.state.value.targetTemperature.setpointType = 'SET_POINT_TYPE_' + value.toUpperCase();
-              protobufElement.state.value.enabled = { value: true };
+            if (key === 'temperature_scale' && typeof value === 'string' && (value.toUpperCase() === 'C' || value.toUpperCase() === 'F')) {
+              // Set the temperature scale on the target thermostat
+              protobufElement.traitRequest.traitLabel = 'display_settings';
+              protobufElement.state.type_url = 'type.nestlabs.com/nest.trait.hvac.DisplaySettingsTrait';
+              protobufElement.state.value = this.#rawData[nest_google_uuid].value.display_settings;
+              protobufElement.state.value.temperatureScale = value.toUpperCase() === 'F' ? 'TEMPERATURE_SCALE_F' : 'TEMPERATURE_SCALE_C';
             }
 
-            if (key === 'hvac_mode' && value.toUpperCase() === 'OFF') {
-              protobufElement.state.value.enabled = { value: false };
+            if (key === 'temperature_lock' && typeof value === 'boolean') {
+              // Set lock mode on the target thermostat
+              protobufElement.traitRequest.traitLabel = 'temperature_lock_settings';
+              protobufElement.state.type_url = 'type.nestlabs.com/nest.trait.hvac.TemperatureLockSettingsTrait';
+              protobufElement.state.value = this.#rawData[nest_google_uuid].value.temperature_lock_settings;
+              protobufElement.state.value.enabled = value === true;
             }
 
-            // Tage 'who is doing the temperature/mode change. We are :-)
-            protobufElement.state.value.targetTemperature.currentActorInfo = {
-              method: 'HVAC_ACTOR_METHOD_IOS',
-              originator: {
-                resourceId: Object.keys(this.#rawData)
-                  .filter((key) => key.includes('USER_'))
-                  .toString(),
-              },
-              timeOfAction: { seconds: Math.floor(Date.now() / 1000), nanos: (Date.now() % 1000) * 1e6 },
-              originatorRtsId: '',
-            };
-          }
-
-          if (
-            (key === 'target_temperature' &&
-              this.#rawData?.[deviceUUID]?.value?.eco_mode_state?.ecoMode !== 'ECO_MODE_INACTIVE' &&
-              typeof value === 'number') ||
-            (key === 'target_temperature_low' &&
-              this.#rawData?.[deviceUUID]?.value?.eco_mode_state?.ecoMode !== 'ECO_MODE_INACTIVE' &&
-              typeof value === 'number') ||
-            (key === 'target_temperature_high' &&
-              this.#rawData?.[deviceUUID]?.value?.eco_mode_state?.ecoMode !== 'ECO_MODE_INACTIVE' &&
-              typeof value === 'number')
-          ) {
-            // Set eco mode temperatures on the target thermostat
-            protobufElement.traitRequest.traitLabel = 'eco_mode_settings';
-            protobufElement.state.type_url = 'type.nestlabs.com/nest.trait.hvac.EcoModeSettingsTrait';
-            protobufElement.state.value = this.#rawData[deviceUUID].value.eco_mode_settings;
-
-            protobufElement.state.value.ecoTemperatureHeat.value.value =
-              protobufElement.state.value.ecoTemperatureHeat.enabled === true &&
-              protobufElement.state.value.ecoTemperatureCool.enabled === false
-                ? value
-                : protobufElement.state.value.ecoTemperatureHeat.value.value;
-            protobufElement.state.value.ecoTemperatureCool.value.value =
-              protobufElement.state.value.ecoTemperatureHeat.enabled === false &&
-              protobufElement.state.value.ecoTemperatureCool.enabled === true
-                ? value
-                : protobufElement.state.value.ecoTemperatureCool.value.value;
-            protobufElement.state.value.ecoTemperatureHeat.value.value =
-              protobufElement.state.value.ecoTemperatureHeat.enabled === true &&
-              protobufElement.state.value.ecoTemperatureCool.enabled === true &&
-              key === 'target_temperature_low'
-                ? value
-                : protobufElement.state.value.ecoTemperatureHeat.value.value;
-            protobufElement.state.value.ecoTemperatureCool.value.value =
-              protobufElement.state.value.ecoTemperatureHeat.enabled === true &&
-              protobufElement.state.value.ecoTemperatureCool.enabled === true &&
-              key === 'target_temperature_high'
-                ? value
-                : protobufElement.state.value.ecoTemperatureCool.value.value;
-          }
-
-          if (key === 'temperature_scale' && typeof value === 'string' && (value.toUpperCase() === 'C' || value.toUpperCase() === 'F')) {
-            // Set the temperature scale on the target thermostat
-            protobufElement.traitRequest.traitLabel = 'display_settings';
-            protobufElement.state.type_url = 'type.nestlabs.com/nest.trait.hvac.DisplaySettingsTrait';
-            protobufElement.state.value = this.#rawData[deviceUUID].value.display_settings;
-            protobufElement.state.value.temperatureScale = value.toUpperCase() === 'F' ? 'TEMPERATURE_SCALE_F' : 'TEMPERATURE_SCALE_C';
-          }
+            if (key === 'fan_state' && typeof value === 'boolean') {
+              // Set fan mode on the target thermostat
+              protobufElement.traitRequest.traitLabel = 'fan_control_settings';
+              protobufElement.state.type_url = 'type.nestlabs.com/nest.trait.hvac.FanControlSettingsTrait';
+              protobufElement.state.value = this.#rawData[nest_google_uuid].value.fan_control_settings;
+              protobufElement.state.value.timerEnd =
+                value === true
+                  ? {
+                      seconds: Number(Math.floor(Date.now() / 1000 + Number(protobufElement.state.value.timerDuration.seconds))),
+                      nanos: (Math.floor(Date.now() / 1000 + Number(protobufElement.state.value.timerDuration.seconds)) % 1000) * 1e6,
+                    }
+                  : { seconds: 0, nanos: 0 };
+              if (values?.fan_timer_speed !== undefined) {
+                // We have a value to set fan speed also, so handle here as combined setting
+                protobufElement.state.value.timerSpeed =
+                  values?.fan_timer_speed !== 0
+                    ? 'FAN_SPEED_SETTING_STAGE' + values?.fan_timer_speed
+                    : this.#rawData[nest_google_uuid].value.fan_control_settings.timerSpeed;
+              }
+            }
 
-          if (key === 'temperature_lock' && typeof value === 'boolean') {
-            // Set lock mode on the target thermostat
-            protobufElement.traitRequest.traitLabel = 'temperature_lock_settings';
-            protobufElement.state.type_url = 'type.nestlabs.com/nest.trait.hvac.TemperatureLockSettingsTrait';
-            protobufElement.state.value = this.#rawData[deviceUUID].value.temperature_lock_settings;
-            protobufElement.state.value.enabled = value === true;
-          }
+            if (key === 'fan_timer_speed' && isNaN(value) === false && values?.fan_state === undefined) {
+              // Set fan speed on the target thermostat only if we're not changing fan on/off state also
+              protobufElement.traitRequest.traitLabel = 'fan_control_settings';
+              protobufElement.state.type_url = 'type.nestlabs.com/nest.trait.hvac.FanControlSettingsTrait';
+              protobufElement.state.value = this.#rawData[nest_google_uuid].value.fan_control_settings;
+              protobufElement.state.value.timerSpeed =
+                value !== 0 ? 'FAN_SPEED_SETTING_STAGE' + value : this.#rawData[nest_google_uuid].value.fan_control_settings.timerSpeed;
+            }
 
-          if (key === 'fan_state' && typeof value === 'boolean') {
-            // Set fan mode on the target thermostat
-            let endTime =
-              value === true
-                ? Math.floor(Date.now() / 1000) + this.#rawData[deviceUUID].value.fan_control_settings.timerDuration.seconds
-                : 0;
+            if (key === 'statusled_brightness' && isNaN(value) === false) {
+              // 0
+              // 1
+            }
 
-            protobufElement.traitRequest.traitLabel = 'fan_control_settings';
-            protobufElement.state.type_url = 'type.nestlabs.com/nest.trait.hvac.FanControlSettingsTrait';
-            protobufElement.state.value = this.#rawData[deviceUUID].value.fan_control_settings;
-            protobufElement.state.value.timerEnd = { seconds: endTime, nanos: (endTime % 1000) * 1e6 };
-          }
+            if (key === 'irled_enabled' && typeof value === 'string') {
+              // 'auto_on'
+              // 'always_off'
+            }
 
-          //if (key === 'statusled.brightness'
-          //if (key === 'irled.state'
-
-          if (key === 'streaming.enabled' && typeof value === 'boolean') {
-            // Turn camera video on/off
-            protobufElement.traitRequest.traitLabel = 'recording_toggle_settings';
-            protobufElement.state.type_url = 'type.nestlabs.com/nest.trait.product.camera.RecordingToggleSettingsTrait';
-            protobufElement.state.value = this.#rawData[deviceUUID].value.recording_toggle_settings;
-            protobufElement.state.value.targetCameraState = value === true ? 'CAMERA_ON' : 'CAMERA_OFF';
-            protobufElement.state.value.changeModeReason = 2;
-            protobufElement.state.value.settingsUpdated = { seconds: Math.floor(Date.now() / 1000), nanos: (Date.now() % 1000) * 1e6 };
-          }
+            if (key === 'streaming_enabled' && typeof value === 'boolean') {
+              // Turn camera video on/off
+              protobufElement.traitRequest.traitLabel = 'recording_toggle_settings';
+              protobufElement.state.type_url = 'type.nestlabs.com/nest.trait.product.camera.RecordingToggleSettingsTrait';
+              protobufElement.state.value = this.#rawData[nest_google_uuid].value.recording_toggle_settings;
+              protobufElement.state.value.targetCameraState = value === true ? 'CAMERA_ON' : 'CAMERA_OFF';
+              protobufElement.state.value.changeModeReason = 2;
+              protobufElement.state.value.settingsUpdated = { seconds: Math.floor(Date.now() / 1000), nanos: (Date.now() % 1000) * 1e6 };
+            }
 
-          if (key === 'audio.enabled' && typeof value === 'boolean') {
-            // Enable/disable microphone on camera/doorbell
-            protobufElement.traitRequest.traitLabel = 'microphone_settings';
-            protobufElement.state.type_url = 'type.nestlabs.com/nest.trait.audio.MicrophoneSettingsTrait';
-            protobufElement.state.value = this.#rawData[deviceUUID].value.microphone_settings;
-            protobufElement.state.value.enableMicrophone = value;
-          }
+            if (key === 'audio_enabled' && typeof value === 'boolean') {
+              // Enable/disable microphone on camera/doorbell
+              protobufElement.traitRequest.traitLabel = 'microphone_settings';
+              protobufElement.state.type_url = 'type.nestlabs.com/nest.trait.audio.MicrophoneSettingsTrait';
+              protobufElement.state.value = this.#rawData[nest_google_uuid].value.microphone_settings;
+              protobufElement.state.value.enableMicrophone = value;
+            }
 
-          if (key === 'indoor_chime_enabled' && typeof value === 'boolean') {
-            // Enable/disable chime status on doorbell
-            protobufElement.traitRequest.traitLabel = 'doorbell_indoor_chime_settings';
-            protobufElement.state.type_url = 'type.nestlabs.com/nest.trait.product.doorbell.DoorbellIndoorChimeSettingsTrait';
-            protobufElement.state.value = this.#rawData[deviceUUID].value.doorbell_indoor_chime_settings;
-            protobufElement.state.value.chimeEnabled = value;
-          }
+            if (key === 'indoor_chime_enabled' && typeof value === 'boolean') {
+              // Enable/disable chime status on doorbell
+              protobufElement.traitRequest.traitLabel = 'doorbell_indoor_chime_settings';
+              protobufElement.state.type_url = 'type.nestlabs.com/nest.trait.product.doorbell.DoorbellIndoorChimeSettingsTrait';
+              protobufElement.state.value = this.#rawData[nest_google_uuid].value.doorbell_indoor_chime_settings;
+              protobufElement.state.value.chimeEnabled = value;
+            }
 
-          if (key === 'light_enabled' && typeof value === 'boolean') {
-            // Turn on/off light on supported camera devices. Need to find the related or SERVICE__ object for teh device
-            let serviceUUID = undefined;
-            if (this.#rawData[deviceUUID].value?.related_resources?.relatedResources !== undefined) {
-              Object.values(this.#rawData[deviceUUID].value?.related_resources?.relatedResources).forEach((values) => {
-                if (
-                  values?.resourceTypeName?.resourceName === 'google.resource.AzizResource' &&
-                  values?.resourceId?.resourceId.startsWith('SERVICE_') === true
-                ) {
-                  serviceUUID = values.resourceId.resourceId;
-                }
-              });
+            if (key === 'light_enabled' && typeof value === 'boolean') {
+              // Turn on/off light on supported camera devices. Need to find the related or 'SERVICE_' object for the device
+              let serviceUUID = undefined;
+              if (this.#rawData[nest_google_uuid].value?.related_resources?.relatedResources !== undefined) {
+                Object.values(this.#rawData[nest_google_uuid].value?.related_resources?.relatedResources).forEach((values) => {
+                  if (
+                    values?.resourceTypeName?.resourceName === 'google.resource.AzizResource' &&
+                    values?.resourceId?.resourceId.startsWith('SERVICE_') === true
+                  ) {
+                    serviceUUID = values.resourceId.resourceId;
+                  }
+                });
 
-              if (serviceUUID !== undefined) {
-                let commandResponse = await this.#protobufCommand(this.#rawData[deviceUUID].connection, 'ResourceApi', 'SendCommand', {
-                  resourceRequest: {
-                    resourceId: serviceUUID,
-                    requestId: crypto.randomUUID(),
-                  },
-                  resourceCommands: [
-                    {
-                      traitLabel: 'on_off',
-                      command: {
-                        type_url: 'type.nestlabs.com/weave.trait.actuator.OnOffTrait.SetStateRequest',
-                        value: {
-                          on: value,
+                if (serviceUUID !== undefined) {
+                  let commandResponse = await this.#protobufCommand(connectionUuid, 'ResourceApi', 'SendCommand', {
+                    resourceRequest: {
+                      resourceId: serviceUUID,
+                      requestId: crypto.randomUUID(),
+                    },
+                    resourceCommands: [
+                      {
+                        traitLabel: 'on_off',
+                        command: {
+                          type_url: 'type.nestlabs.com/weave.trait.actuator.OnOffTrait.SetStateRequest',
+                          value: {
+                            on: value,
+                          },
                         },
                       },
-                    },
-                  ],
-                });
+                    ],
+                  });
 
-                if (commandResponse.sendCommandResponse?.[0]?.traitOperations?.[0]?.progress !== 'COMPLETE') {
-                  this?.log?.debug && this.log.debug('Protobuf API had error setting light status on uuid "%s"', deviceUUID);
+                  if (commandResponse.sendCommandResponse?.[0]?.traitOperations?.[0]?.progress !== 'COMPLETE') {
+                    this?.log?.debug && this.log.debug('Protobuf API had error setting light status on uuid "%s"', nest_google_uuid);
+                  }
                 }
               }
             }
-          }
 
-          if (key === 'light_brightness' && typeof value === 'number') {
-            // Set light brightness on supported camera devices
-            protobufElement.traitRequest.traitLabel = 'floodlight_settings';
-            protobufElement.state.type_url = 'type.nestlabs.com/google.trait.product.camera.FloodlightSettingsTrait';
-            protobufElement.state.value = this.#rawData[deviceUUID].value.floodlight_settings;
-            protobufElement.state.value.brightness = scaleValue(value, 0, 100, 0, 10); // Scale to required level
-          }
+            if (key === 'light_brightness' && isNaN(value) === false) {
+              // Set light brightness on supported camera devices
+              protobufElement.traitRequest.traitLabel = 'floodlight_settings';
+              protobufElement.state.type_url = 'type.nestlabs.com/google.trait.product.camera.FloodlightSettingsTrait';
+              protobufElement.state.value = this.#rawData[nest_google_uuid].value.floodlight_settings;
+              protobufElement.state.value.brightness = scaleValue(Number(value), 0, 100, 0, 10); // Scale to required level
+            }
 
-          if (protobufElement.traitRequest.traitLabel === '' || protobufElement.state.type_url === '') {
-            this?.log?.debug && this.log.debug('Unknown Protobuf set key "%s" for device uuid "%s"', key, deviceUUID);
-          }
+            if (protobufElement.traitRequest.traitLabel === '' || protobufElement.state.type_url === '') {
+              this?.log?.debug && this.log.debug('Unknown Protobuf set key "%s" for device uuid "%s"', key, nest_google_uuid);
+            }
 
-          if (protobufElement.traitRequest.traitLabel !== '' && protobufElement.state.type_url !== '') {
-            // eslint-disable-next-line no-undef
-            updatedTraits.push(structuredClone(protobufElement));
-          }
-        }),
+            if (protobufElement.traitRequest.traitLabel !== '' && protobufElement.state.type_url !== '') {
+              // eslint-disable-next-line no-undef
+              updatedTraits.push(structuredClone(protobufElement));
+            }
+          }),
       );
 
       if (updatedTraits.length !== 0) {
-        let commandResponse = await this.#protobufCommand(this.#rawData[deviceUUID].connection, 'TraitBatchApi', 'BatchUpdateState', {
+        let commandResponse = await this.#protobufCommand(connectionUuid, 'TraitBatchApi', 'BatchUpdateState', {
           batchUpdateStateRequest: updatedTraits,
         });
         if (
           commandResponse === undefined ||
           commandResponse?.batchUpdateStateResponse?.[0]?.traitOperations?.[0]?.progress !== 'COMPLETE'
         ) {
-          this?.log?.debug && this.log.debug('Protobuf API had error updating device traits for uuid "%s"', deviceUUID);
+          this?.log?.debug && this.log.debug('Protobuf API had error updating device traits for uuid "%s"', nest_google_uuid);
         }
       }
     }
 
-    if (this.#rawData?.[deviceUUID]?.source === NestAccfactory.DataSource.REST && deviceUUID.startsWith('quartz.') === true) {
+    if (this.#rawData?.[nest_google_uuid]?.source === NestAccfactory.DataSource.REST && nest_google_uuid.startsWith('quartz.') === true) {
       // Set value on Nest Camera/Doorbell
       await Promise.all(
-        Object.entries(values).map(async ([key, value]) => {
-          const SETPROPERTIES = {
-            indoor_chime_enabled: 'doorbell.indoor_chime.enabled',
-            statusled_brightness: 'statusled.brightness',
-            irled_enabled: 'irled.state',
-            streaming_enabled: 'streaming.enabled',
-            audio_enabled: 'audio.enabled',
-          };
+        Object.entries(values)
+          .filter(([key]) => key !== 'uuid')
+          .map(async ([key, value]) => {
+            const SETPROPERTIES = {
+              indoor_chime_enabled: 'doorbell.indoor_chime.enabled',
+              statusled_brightness: 'statusled.brightness',
+              irled_enabled: 'irled.state',
+              streaming_enabled: 'streaming.enabled',
+              audio_enabled: 'audio.enabled',
+            };
 
-          // Transform key to correct set camera properties key
-          key = SETPROPERTIES[key] !== undefined ? SETPROPERTIES[key] : key;
+            // Transform key to correct set camera properties key
+            key = SETPROPERTIES[key] !== undefined ? SETPROPERTIES[key] : key;
 
-          await fetchWrapper(
-            'post',
-            'https://webapi.' + this.#connections[this.#rawData[deviceUUID].connection].cameraAPIHost + '/api/dropcams.set_properties',
-            {
-              headers: {
-                referer: 'https://' + this.#connections[this.#rawData[deviceUUID].connection].referer,
-                'User-Agent': USERAGENT,
-                'Content-Type': 'application/x-www-form-urlencoded',
-                [this.#connections[this.#rawData[deviceUUID].connection].cameraAPI.key]:
-                  this.#connections[this.#rawData[deviceUUID].connection].cameraAPI.value +
-                  this.#connections[this.#rawData[deviceUUID].connection].cameraAPI.token,
+            await fetchWrapper(
+              'post',
+              'https://webapi.' + this.#connections[connectionUuid].cameraAPIHost + '/api/dropcams.set_properties',
+              {
+                headers: {
+                  referer: 'https://' + this.#connections[connectionUuid].referer,
+                  'User-Agent': USERAGENT,
+                  'Content-Type': 'application/x-www-form-urlencoded',
+                  [this.#connections[connectionUuid].cameraAPI.key]:
+                    this.#connections[connectionUuid].cameraAPI.value + this.#connections[connectionUuid].cameraAPI.token,
+                },
+                timeout: NESTAPITIMEOUT,
               },
-              timeout: NESTAPITIMEOUT,
-            },
-            [key] + '=' + value + '&uuid=' + deviceUUID.split('.')[1],
-          )
-            .then((response) => response.json())
-            .then((data) => {
-              if (data?.status !== 0) {
-                throw new Error('REST API camera update for failed with error');
-              }
-            })
-            .catch((error) => {
-              if (error?.name !== 'TimeoutError' && this?.log?.debug) {
-                this.log.debug('REST API camera update for failed with error for uuid "%s". Error was "%s"', deviceUUID, error?.code);
-              }
-            });
-        }),
+              [key] + '=' + value + '&uuid=' + nest_google_uuid.split('.')[1],
+            )
+              .then((response) => response.json())
+              .then((data) => {
+                if (data?.status !== 0) {
+                  throw new Error('REST API camera update for failed with error');
+                }
+              })
+              .catch((error) => {
+                if (
+                  error?.cause !== undefined &&
+                  JSON.stringify(error.cause).toUpperCase().includes('TIMEOUT') === false &&
+                  this?.log?.debug
+                ) {
+                  this.log.debug(
+                    'REST API camera update for failed with error for uuid "%s". Error was "%s"',
+                    nest_google_uuid,
+                    error?.code,
+                  );
+                }
+              });
+          }),
       );
     }
 
-    if (this.#rawData?.[deviceUUID]?.source === NestAccfactory.DataSource.REST && deviceUUID.startsWith('quartz.') === false) {
+    if (this.#rawData?.[nest_google_uuid]?.source === NestAccfactory.DataSource.REST && nest_google_uuid.startsWith('quartz.') === false) {
       // set values on other Nest devices besides cameras/doorbells
       await Promise.all(
-        Object.entries(values).map(async ([key, value]) => {
-          let subscribeJSONData = { objects: [] };
+        Object.entries(values)
+          .filter(([key]) => key !== 'uuid')
+          .map(async ([key, value]) => {
+            let subscribeJSONData = { objects: [] };
 
-          if (deviceUUID.startsWith('device.') === false) {
-            subscribeJSONData.objects.push({ object_key: deviceUUID, op: 'MERGE', value: { [key]: value } });
-          }
+            if (nest_google_uuid.startsWith('device.') === false) {
+              subscribeJSONData.objects.push({ object_key: nest_google_uuid, op: 'MERGE', value: { [key]: value } });
+            }
 
-          // Some elements when setting thermostat data are located in a different object locations than with the device object
-          // Handle this scenario below
-          if (deviceUUID.startsWith('device.') === true) {
-            let RESTStructureUUID = deviceUUID;
+            // Some elements when setting thermostat data are located in a different object locations than with the device object
+            // Handle this scenario below
+            if (nest_google_uuid.startsWith('device.') === true) {
+              let RESTStructureUUID = nest_google_uuid;
 
-            if (
-              (key === 'hvac_mode' &&
-                typeof value === 'string' &&
-                (value.toUpperCase() === 'OFF' ||
-                  value.toUpperCase() === 'COOL' ||
-                  value.toUpperCase() === 'HEAT' ||
-                  value.toUpperCase() === 'RANGE')) ||
-              (key === 'target_temperature' && typeof value === 'number') ||
-              (key === 'target_temperature_low' && typeof value === 'number') ||
-              (key === 'target_temperature_high' && typeof value === 'number')
-            ) {
-              RESTStructureUUID = 'shared.' + deviceUUID.split('.')[1];
+              if (
+                (key === 'hvac_mode' &&
+                  typeof value === 'string' &&
+                  (value.toUpperCase() === 'OFF' ||
+                    value.toUpperCase() === 'COOL' ||
+                    value.toUpperCase() === 'HEAT' ||
+                    value.toUpperCase() === 'RANGE')) ||
+                (key === 'target_temperature' && isNaN(value) === false) ||
+                (key === 'target_temperature_low' && isNaN(value) === false) ||
+                (key === 'target_temperature_high' && isNaN(value) === false)
+              ) {
+                RESTStructureUUID = 'shared.' + nest_google_uuid.split('.')[1];
+              }
+
+              if (key === 'fan_state' && typeof value === 'boolean') {
+                key = 'fan_timer_timeout';
+                value = value === true ? this.#rawData[nest_google_uuid].value.fan_duration + Math.floor(Date.now() / 1000) : 0;
+              }
+
+              if (key === 'fan_timer_speed' && isNaN(value) === false) {
+                value = value !== 0 ? 'stage' + value : 'stage1';
+              }
+
+              subscribeJSONData.objects.push({ object_key: RESTStructureUUID, op: 'MERGE', value: { [key]: value } });
             }
-            subscribeJSONData.objects.push({ object_key: RESTStructureUUID, op: 'MERGE', value: { [key]: value } });
-          }
 
-          if (subscribeJSONData.objects.length !== 0) {
-            await fetchWrapper(
-              'post',
-              this.#connections[this.#rawData[deviceUUID].connection].transport_url + '/v5/put',
-              {
-                referer: 'https://' + this.#connections[this.#rawData[deviceUUID].connection].referer,
-                headers: {
-                  'User-Agent': USERAGENT,
-                  Authorization: 'Basic ' + this.#connections[this.#rawData[deviceUUID].connection].token,
+            if (subscribeJSONData.objects.length !== 0) {
+              await fetchWrapper(
+                'post',
+                this.#connections[connectionUuid].transport_url + '/v5/put',
+                {
+                  referer: 'https://' + this.#connections[connectionUuid].referer,
+                  headers: {
+                    'User-Agent': USERAGENT,
+                    Authorization: 'Basic ' + this.#connections[connectionUuid].token,
+                  },
                 },
-              },
-              JSON.stringify(subscribeJSONData),
-            ).catch((error) => {
-              this?.log?.debug &&
-                this.log.debug('REST API property update for failed with error for uuid "%s". Error was "%s"', deviceUUID, error?.code);
-            });
-          }
-        }),
+                JSON.stringify(subscribeJSONData),
+              ).catch((error) => {
+                this?.log?.debug &&
+                  this.log.debug(
+                    'REST API property update for failed with error for uuid "%s". Error was "%s"',
+                    nest_google_uuid,
+                    error?.code,
+                  );
+              });
+            }
+          }),
       );
     }
   }
 
-  async #get(deviceUUID, values) {
+  async #get(uuid, values) {
     if (
-      typeof deviceUUID !== 'string' ||
-      typeof this.#rawData?.[deviceUUID] !== 'object' ||
+      typeof uuid !== 'string' ||
+      uuid === '' ||
       typeof values !== 'object' ||
-      typeof this.#connections[this.#rawData?.[deviceUUID]?.connection] !== 'object'
+      values?.uuid === undefined ||
+      typeof this.#rawData?.[values?.uuid] !== 'object' ||
+      typeof this.#connections?.[this.#rawData?.[values?.uuid]?.connection] !== 'object'
     ) {
-      values = {};
+      return;
     }
 
-    await Promise.all(
-      Object.entries(values).map(async ([key]) => {
-        // We'll return the data under the original key value
-        // By default, the returned value will be undefined. If call is successful, the key value will have the data requested
-        values[key] = undefined;
-
-        if (
-          this.#rawData?.[deviceUUID]?.source === NestAccfactory.DataSource.REST &&
-          key === 'camera_snapshot' &&
-          deviceUUID.startsWith('quartz.') === true &&
-          typeof this.#rawData?.[deviceUUID]?.value?.nexus_api_http_server_url === 'string' &&
-          this.#rawData[deviceUUID].value.nexus_api_http_server_url !== ''
-        ) {
-          // Attempt to retrieve snapshot from camera via REST API
-          await fetchWrapper(
-            'get',
-            this.#rawData[deviceUUID].value.nexus_api_http_server_url + '/get_image?uuid=' + deviceUUID.split('.')[1],
-            {
-              headers: {
-                referer: 'https://' + this.#connections[this.#rawData[deviceUUID].connection].referer,
-                'User-Agent': USERAGENT,
-                [this.#connections[this.#rawData[deviceUUID].connection].cameraAPI.key]:
-                  this.#connections[this.#rawData[deviceUUID].connection].cameraAPI.value +
-                  this.#connections[this.#rawData[deviceUUID].connection].cameraAPI.token,
-              },
-              timeout: 3000,
-            },
-          )
-            .then((response) => response.arrayBuffer())
-            .then((data) => {
-              values[key] = Buffer.from(data);
-            })
-            .catch((error) => {
-              if (error?.name !== 'TimeoutError' && this?.log?.debug) {
-                this.log.debug('REST API camera snapshot failed with error for uuid "%s". Error was "%s"', deviceUUID, error?.code);
-              }
-            });
-        }
+    let nest_google_uuid = values.uuid; // Nest/Google structure uuid for this get request
+    let connectionUuid = this.#rawData[values.uuid].connection; // Associated connection uuid for the uuid
 
-        if (
-          this.#rawData?.[deviceUUID]?.source === NestAccfactory.DataSource.PROTOBUF &&
-          this.#connections[this.#rawData[deviceUUID].connection].protobufRoot !== null &&
-          this.#rawData[deviceUUID]?.value?.device_identity?.vendorProductId !== undefined &&
-          key === 'camera_snapshot'
-        ) {
-          // Attempt to retrieve snapshot from camera via Protobuf API
-          // First, request to get snapshot url image updated
-          let commandResponse = await this.#protobufCommand(this.#rawData[deviceUUID].connection, 'ResourceApi', 'SendCommand', {
-            resourceRequest: {
-              resourceId: deviceUUID,
-              requestId: crypto.randomUUID(),
-            },
-            resourceCommands: [
-              {
-                traitLabel: 'upload_live_image',
-                command: {
-                  type_url: 'type.nestlabs.com/nest.trait.product.camera.UploadLiveImageTrait.UploadLiveImageRequest',
-                  value: {},
-                },
-              },
-            ],
-          });
+    await Promise.all(
+      Object.entries(values)
+        .filter(([key]) => key !== 'uuid')
+        .map(async ([key]) => {
+          // We'll return the data under the original key value
+          // By default, the returned value will be undefined. If call is successful, the key value will have the data requested
+          values[key] = undefined;
 
           if (
-            commandResponse?.sendCommandResponse?.[0]?.traitOperations?.[0]?.progress === 'COMPLETE' &&
-            typeof this.#rawData?.[deviceUUID]?.value?.upload_live_image?.liveImageUrl === 'string' &&
-            this.#rawData[deviceUUID].value.upload_live_image.liveImageUrl !== ''
+            this.#rawData?.[nest_google_uuid]?.source === NestAccfactory.DataSource.REST &&
+            key === 'camera_snapshot' &&
+            nest_google_uuid.startsWith('quartz.') === true &&
+            typeof this.#rawData?.[nest_google_uuid]?.value?.nexus_api_http_server_url === 'string' &&
+            this.#rawData[nest_google_uuid].value.nexus_api_http_server_url !== ''
           ) {
-            // Snapshot url image has beeen updated, so no retrieve it
-            await fetchWrapper('get', this.#rawData[deviceUUID].value.upload_live_image.liveImageUrl, {
-              referer: 'https://' + this.#connections[this.#rawData[deviceUUID].connection].referer,
-              headers: {
-                'User-Agent': USERAGENT,
-                Authorization: 'Basic ' + this.#connections[this.#rawData[deviceUUID].connection].token,
+            // Attempt to retrieve snapshot from camera via REST API
+            await fetchWrapper(
+              'get',
+              this.#rawData[nest_google_uuid].value.nexus_api_http_server_url + '/get_image?uuid=' + nest_google_uuid.split('.')[1],
+              {
+                headers: {
+                  referer: 'https://' + this.#connections[connectionUuid].referer,
+                  'User-Agent': USERAGENT,
+                  [this.#connections[connectionUuid].cameraAPI.key]:
+                    this.#connections[connectionUuid].cameraAPI.value + this.#connections[connectionUuid].cameraAPI.token,
+                },
+                timeout: 3000,
               },
-              timeout: 3000,
-            })
+            )
               .then((response) => response.arrayBuffer())
               .then((data) => {
                 values[key] = Buffer.from(data);
               })
               .catch((error) => {
-                if (error?.name !== 'TimeoutError' && this?.log?.debug) {
-                  this.log.debug('Protobuf API camera snapshot failed with error for uuid "%s". Error was "%s"', deviceUUID, error?.code);
+                if (
+                  error?.cause !== undefined &&
+                  JSON.stringify(error.cause).toUpperCase().includes('TIMEOUT') === false &&
+                  this?.log?.debug
+                ) {
+                  this.log.debug('REST API camera snapshot failed with error for uuid "%s". Error was "%s"', nest_google_uuid, error?.code);
                 }
               });
           }
-        }
-      }),
+
+          if (
+            this.#rawData?.[nest_google_uuid]?.source === NestAccfactory.DataSource.PROTOBUF &&
+            this.#protobufRoot !== null &&
+            this.#rawData[nest_google_uuid]?.value?.device_identity?.vendorProductId !== undefined &&
+            key === 'camera_snapshot'
+          ) {
+            // Attempt to retrieve snapshot from camera via Protobuf API
+            // First, request to get snapshot url image updated
+            let commandResponse = await this.#protobufCommand(connectionUuid, 'ResourceApi', 'SendCommand', {
+              resourceRequest: {
+                resourceId: nest_google_uuid,
+                requestId: crypto.randomUUID(),
+              },
+              resourceCommands: [
+                {
+                  traitLabel: 'upload_live_image',
+                  command: {
+                    type_url: 'type.nestlabs.com/nest.trait.product.camera.UploadLiveImageTrait.UploadLiveImageRequest',
+                    value: {},
+                  },
+                },
+              ],
+            });
+
+            if (
+              commandResponse?.sendCommandResponse?.[0]?.traitOperations?.[0]?.progress === 'COMPLETE' &&
+              typeof this.#rawData?.[nest_google_uuid]?.value?.upload_live_image?.liveImageUrl === 'string' &&
+              this.#rawData[nest_google_uuid].value.upload_live_image.liveImageUrl !== ''
+            ) {
+              // Snapshot url image has beeen updated, so no retrieve it
+              await fetchWrapper('get', this.#rawData[nest_google_uuid].value.upload_live_image.liveImageUrl, {
+                referer: 'https://' + this.#connections[connectionUuid].referer,
+                headers: {
+                  'User-Agent': USERAGENT,
+                  Authorization: 'Basic ' + this.#connections[connectionUuid].token,
+                },
+                timeout: 3000,
+              })
+                .then((response) => response.arrayBuffer())
+                .then((data) => {
+                  values[key] = Buffer.from(data);
+                })
+                .catch((error) => {
+                  if (
+                    error?.cause !== undefined &&
+                    JSON.stringify(error.cause).toUpperCase().includes('TIMEOUT') === false &&
+                    this?.log?.debug
+                  ) {
+                    this.log.debug(
+                      'Protobuf API camera snapshot failed with error for uuid "%s". Error was "%s"',
+                      nest_google_uuid,
+                      error?.code,
+                    );
+                  }
+                });
+            }
+          }
+        }),
     );
 
-    // Send results back via event
-    this.#eventEmitter.emit(HomeKitDevice.GET + '->' + deviceUUID, values);
+    return values;
   }
 
   async #getWeatherData(connectionUUID, deviceUUID, latitude, longitude) {
@@ -2934,7 +2975,7 @@ export default class NestAccfactory {
               : '';
         })
         .catch((error) => {
-          if (error?.name !== 'TimeoutError' && this?.log?.debug) {
+          if (error?.cause !== undefined && JSON.stringify(error.cause).toUpperCase().includes('TIMEOUT') === false && this?.log?.debug) {
             this.log.debug('REST API failed to retrieve weather details for uuid "%s". Error was "%s"', deviceUUID, error?.code);
           }
         });
@@ -2945,7 +2986,7 @@ export default class NestAccfactory {
 
   async #protobufCommand(connectionUUID, service, command, values) {
     if (
-      this.#connections?.[connectionUUID]?.protobufRoot === null ||
+      this.#protobufRoot === null ||
       typeof service !== 'string' ||
       service === '' ||
       typeof command !== 'string' ||
@@ -2959,7 +3000,7 @@ export default class NestAccfactory {
       if (typeof object === 'object' && object !== null) {
         if ('type_url' in object && 'value' in object) {
           // We have a type_url and value object at this same level, we'll treat this a trait requiring encoding
-          let TraitMap = this.#connections[connectionUUID].protobufRoot.lookup(object.type_url.split('/')[1]);
+          let TraitMap = this.#protobufRoot.lookup(object.type_url.split('/')[1]);
           if (TraitMap !== null) {
             object.value = TraitMap.encode(TraitMap.fromObject(object.value)).finish();
           }
@@ -2974,8 +3015,8 @@ export default class NestAccfactory {
     };
 
     // Attempt to retrieve both 'Request' and 'Reponse' traits for the associated service and command
-    let TraitMapRequest = this.#connections[connectionUUID].protobufRoot.lookup('nestlabs.gateway.v1.' + command + 'Request');
-    let TraitMapResponse = this.#connections[connectionUUID].protobufRoot.lookup('nestlabs.gateway.v1.' + command + 'Response');
+    let TraitMapRequest = this.#protobufRoot.lookup('nestlabs.gateway.v1.' + command + 'Request');
+    let TraitMapResponse = this.#protobufRoot.lookup('nestlabs.gateway.v1.' + command + 'Response');
     let commandResponse = undefined;
 
     if (TraitMapRequest !== null && TraitMapResponse !== null) {
@@ -3093,15 +3134,20 @@ function scaleValue(value, sourceRangeMin, sourceRangeMax, targetRangeMin, targe
   return ((value - sourceRangeMin) * (targetRangeMax - targetRangeMin)) / (sourceRangeMax - sourceRangeMin) + targetRangeMin;
 }
 
-async function fetchWrapper(method, url, options, data) {
+async function fetchWrapper(method, url, options, data, response) {
   if ((method !== 'get' && method !== 'post') || typeof url !== 'string' || url === '' || typeof options !== 'object') {
     return;
   }
 
-  if (typeof options?.timeout === 'number' && options?.timeout > 0) {
+  if (isNaN(options?.timeout) === false && Number(options?.timeout) > 0) {
     // If a timeout is specified in the options, setup here
     // eslint-disable-next-line no-undef
-    options.signal = AbortSignal.timeout(options.timeout);
+    options.signal = AbortSignal.timeout(Number(options.timeout));
+  }
+
+  if (options?.retry === undefined) {
+    // If not retry option specifed , we'll do just once
+    options.retry = 1;
   }
 
   options.method = method; // Set the HTTP method to use
@@ -3111,12 +3157,24 @@ async function fetchWrapper(method, url, options, data) {
     options.body = data;
   }
 
-  // eslint-disable-next-line no-undef
-  let response = await fetch(url, options);
-  if (response.ok === false) {
-    let error = new Error(response.statusText);
-    error.code = response.status;
-    throw error;
+  if (options.retry > 0) {
+    // eslint-disable-next-line no-undef
+    response = await fetch(url, options);
+    if (response.ok === false && options.retry > 1) {
+      options.retry--; // One less retry to go
+
+      // Try again after short delay (500ms)
+      // We pass back in this response also for when we reach zero retries and still not successful
+      await new Promise((resolve) => setTimeout(resolve, 500));
+      // eslint-disable-next-line no-undef
+      response = await fetchWrapper(method, url, options, data, structuredClone(response));
+    }
+    if (response.ok === false && options.retry === 0) {
+      let error = new Error(response.statusText);
+      error.code = response.status;
+      throw error;
+    }
   }
+
   return response;
 }