diff --git a/README.md b/README.md
index 6e063f5..feff56c 100644
--- a/README.md
+++ b/README.md
@@ -16,6 +16,7 @@ A collection of nodes for controlling Q-Sys.
 
 | Version | Description |
 |---------|-------------------------------------------------|
+| 1.0.5   | Added socket keepalive and timeout handling     |
 | 1.0.4   | Added error catch before parsing JSON PR#9      |
 | 1.0.3   | Added `controlType` to **qsys-controlSet** node |
 | 1.0.2   | Updated dependencies                            |
diff --git a/examples/test_mixer.json b/examples/test_mixer.json
new file mode 100644
index 0000000..ad618b9
--- /dev/null
+++ b/examples/test_mixer.json
@@ -0,0 +1,217 @@
+[
+    {
+        "id": "test_mixer_flow",
+        "type": "tab",
+        "label": "Q-SYS Test - Mixer4x2",
+        "disabled": false,
+        "info": "Test flow for Mixer4x2 controls on Q-SYS Core at 192.168.1.191"
+    },
+    {
+        "id": "mixer_gain_node",
+        "type": "qsys-ControlSet",
+        "z": "test_mixer_flow",
+        "name": "Mixer Gain Ch1",
+        "topic": "",
+        "server": "qsys_core_config",
+        "controlId": "Mixer4x2.gain.1",
+        "changeGroup": "0",
+        "x": 320,
+        "y": 80,
+        "wires": [
+            [
+                "debug_gain"
+            ]
+        ]
+    },
+    {
+        "id": "debug_gain",
+        "type": "debug",
+        "z": "test_mixer_flow",
+        "name": "Gain Feedback",
+        "active": true,
+        "tosidebar": true,
+        "console": true,
+        "tostatus": true,
+        "complete": "payload",
+        "targetType": "msg",
+        "statusVal": "payload",
+        "statusType": "auto",
+        "x": 540,
+        "y": 80,
+        "wires": []
+    },
+    {
+        "id": "inject_0db",
+        "type": "inject",
+        "z": "test_mixer_flow",
+        "name": "0 dB",
+        "props": [
+            {
+                "p": "payload"
+            }
+        ],
+        "repeat": "",
+        "crontab": "",
+        "once": false,
+        "onceDelay": 0.1,
+        "topic": "",
+        "payload": "0",
+        "payloadType": "num",
+        "x": 110,
+        "y": 40,
+        "wires": [
+            [
+                "mixer_gain_node"
+            ]
+        ]
+    },
+    {
+        "id": "inject_minus10db",
+        "type": "inject",
+        "z": "test_mixer_flow",
+        "name": "-10 dB",
+        "props": [
+            {
+                "p": "payload"
+            }
+        ],
+        "repeat": "",
+        "crontab": "",
+        "once": false,
+        "onceDelay": 0.1,
+        "topic": "",
+        "payload": "-10",
+        "payloadType": "num",
+        "x": 110,
+        "y": 80,
+        "wires": [
+            [
+                "mixer_gain_node"
+            ]
+        ]
+    },
+    {
+        "id": "inject_minus20db",
+        "type": "inject",
+        "z": "test_mixer_flow",
+        "name": "-20 dB",
+        "props": [
+            {
+                "p": "payload"
+            }
+        ],
+        "repeat": "",
+        "crontab": "",
+        "once": false,
+        "onceDelay": 0.1,
+        "topic": "",
+        "payload": "-20",
+        "payloadType": "num",
+        "x": 110,
+        "y": 120,
+        "wires": [
+            [
+                "mixer_gain_node"
+            ]
+        ]
+    },
+    {
+        "id": "mixer_mute_node",
+        "type": "qsys-ControlSet",
+        "z": "test_mixer_flow",
+        "name": "Mixer Mute Ch1",
+        "topic": "",
+        "server": "qsys_core_config",
+        "controlId": "Mixer4x2.mute.1",
+        "changeGroup": "0",
+        "x": 320,
+        "y": 220,
+        "wires": [
+            [
+                "debug_mute"
+            ]
+        ]
+    },
+    {
+        "id": "debug_mute",
+        "type": "debug",
+        "z": "test_mixer_flow",
+        "name": "Mute Feedback",
+        "active": true,
+        "tosidebar": true,
+        "console": true,
+        "tostatus": true,
+        "complete": "payload",
+        "targetType": "msg",
+        "statusVal": "payload",
+        "statusType": "auto",
+        "x": 540,
+        "y": 220,
+        "wires": []
+    },
+    {
+        "id": "inject_unmute",
+        "type": "inject",
+        "z": "test_mixer_flow",
+        "name": "Unmute (0)",
+        "props": [
+            {
+                "p": "payload"
+            }
+        ],
+        "repeat": "",
+        "crontab": "",
+        "once": false,
+        "onceDelay": 0.1,
+        "topic": "",
+        "payload": "0",
+        "payloadType": "num",
+        "x": 120,
+        "y": 200,
+        "wires": [
+            [
+                "mixer_mute_node"
+            ]
+        ]
+    },
+    {
+        "id": "inject_mute",
+        "type": "inject",
+        "z": "test_mixer_flow",
+        "name": "Mute (1)",
+        "props": [
+            {
+                "p": "payload"
+            }
+        ],
+        "repeat": "",
+        "crontab": "",
+        "once": false,
+        "onceDelay": 0.1,
+        "topic": "",
+        "payload": "1",
+        "payloadType": "num",
+        "x": 110,
+        "y": 240,
+        "wires": [
+            [
+                "mixer_mute_node"
+            ]
+        ]
+    },
+    {
+        "id": "qsys_core_config",
+        "type": "qsys-core",
+        "host": "192.168.1.191",
+        "port": "1710",
+        "isRedundant": "false",
+        "redundantHost": "",
+        "authentication": "false",
+        "pollTime1": "0.25",
+        "pollTime2": "0.5",
+        "pollTime3": "0.75",
+        "pollTime4": "1",
+        "logConnection": "true",
+        "logCommunications": "false"
+    }
+]
diff --git a/lib/qsys-ControlSet.js b/lib/qsys-ControlSet.js
index 6ace276..c1a2c81 100644
--- a/lib/qsys-ControlSet.js
+++ b/lib/qsys-ControlSet.js
@@ -17,19 +17,23 @@ module.exports = function (RED) {
         this.server = RED.nodes.getNode(config.server);
 
         /*****************************************************************************
-         * Socket Event handlers
+         * Server Event handlers - listen to connection state changes
          *****************************************************************************/
 
-        this.server.socket.on('ready', () => {
+        this.server.on('connected', () => {
             this.status({ fill: 'green', shape: 'dot', text: 'connected' });
         });
 
-        this.server.socket.on('error', (err) => {
+        this.server.on('connecting', () => {
+            this.status({ fill: 'yellow', shape: 'ring', text: 'connecting...' });
+        });
+
+        this.server.on('error', () => {
             this.status({ fill: 'red', shape: 'ring', text: 'error' });
         });
 
-        this.server.socket.on('timeout', () => {
-            this.status({ fill: 'red', shape: 'dot', text: 'error' });
+        this.server.on('disconnected', () => {
+            this.status({ fill: 'red', shape: 'dot', text: 'disconnected' });
         });
 
         /*****************************************************************************
diff --git a/lib/qsys-Presets.js b/lib/qsys-Presets.js
index dd883aa..c3e4a5e 100644
--- a/lib/qsys-Presets.js
+++ b/lib/qsys-Presets.js
@@ -10,19 +10,23 @@ module.exports = function (RED) {
         this.server = RED.nodes.getNode(config.server);
 
         /*****************************************************************************
-         * Socket Event handlers
+         * Server Event handlers - listen to connection state changes
          *****************************************************************************/
 
-        this.server.socket.on('ready', () => {
+        this.server.on('connected', () => {
             this.status({ fill: 'green', shape: 'dot', text: 'connected' });
         });
 
-        this.server.socket.on('error', (err) => {
+        this.server.on('connecting', () => {
+            this.status({ fill: 'yellow', shape: 'ring', text: 'connecting...' });
+        });
+
+        this.server.on('error', () => {
             this.status({ fill: 'red', shape: 'ring', text: 'error' });
         });
 
-        this.server.socket.on('timeout', () => {
-            this.status({ fill: 'red', shape: 'dot', text: 'error' });
+        this.server.on('disconnected', () => {
+            this.status({ fill: 'red', shape: 'dot', text: 'disconnected' });
         });
 
         /*****************************************************************************
diff --git a/lib/qsys-core.html b/lib/qsys-core.html
index 5abb150..2b5ace4 100644
--- a/lib/qsys-core.html
+++ b/lib/qsys-core.html
@@ -89,6 +89,12 @@
 
 <script type="text/html" data-help-name="qsys-core">
     <p>Manages connection to <strong>Q-Sys Core</strong></p>
+    <h3>Debug and Error Handling</h3>
+    <p>Use Node-RED's built-in catch and status nodes to monitor the node:</p>
+    <ul>
+        <li>Add a catch node to handle connection and runtime errors</li>
+        <li>Add a status node to monitor connection state changes</li>
+    </ul>
     <h3>Edit Dialog Properties</h3>
     <ol>
         <li>
@@ -119,7 +125,7 @@ <h3>Edit Dialog Properties</h3>
     </ol>
 </script>
 
-<script type="text/javascript">
+<script>
     RED.nodes.registerType('qsys-core', {
         category: 'config',
         defaults: {
diff --git a/lib/qsys-core.js b/lib/qsys-core.js
index 466c7d6..e72c765 100644
--- a/lib/qsys-core.js
+++ b/lib/qsys-core.js
@@ -1,5 +1,21 @@
 var net = require('net');
 
+const CONFIG = {
+    KEEP_ALIVE_INTERVAL: 10000,      // 10 seconds
+    SOCKET_TIMEOUT: 30000,           // 30 seconds
+    NOOP_INTERVAL: 15000,            // 15 seconds (must be < SOCKET_TIMEOUT to prevent timeouts)
+    RECONNECT_BASE_DELAY: 1000,      // 1 second
+    RECONNECT_MAX_DELAY: 60000,      // 60 seconds (1 minute) max backoff
+    RECONNECT_MAX_RETRIES: 6         // 6 retries = 2^6 = 64 seconds, capped at 60s
+};
+
+const ConnectionState = {
+    DISCONNECTED: 'disconnected',
+    CONNECTING: 'connecting',
+    CONNECTED: 'connected',
+    ERROR: 'error'
+};
+
 module.exports = function (RED) {
     'use strict';
 
@@ -15,197 +31,340 @@ module.exports = function (RED) {
         let logConnection = n.logConnection === 'true';
         let logCommunications = n.logCommunications === 'true';
         let noOp = null;
+        let reconnectAttempts = 0;
+        let reconnectTimer = null;
+        let isReconnecting = false;
+        let hasReachedMaxDelay = false;
+        let connectionState = ConnectionState.DISCONNECTED;
+        let messageBuffer = Buffer.alloc(0);
 
-        this.changeGroup = [{ 'autoPoll': false, 'params': { 'Id': 'group 1', 'Rate': parseFloat(n.pollTime1) } },
-        { 'autoPoll': false, 'params': { 'Id': 'group 2', 'Rate': parseFloat(n.pollTime2) } },
-        { 'autoPoll': false, 'params': { 'Id': 'group 3', 'Rate': parseFloat(n.pollTime3) } },
-        { 'autoPoll': false, 'params': { 'Id': 'group 4', 'Rate': parseFloat(n.pollTime4) } }];
-        
-        this.socket = net.connect(port, host);
-        this.socket.setMaxListeners(0);
-        this.setMaxListeners(0);
+        this.changeGroup = [
+            { 'autoPoll': false, 'params': { 'Id': 'group 1', 'Rate': parseFloat(n.pollTime1) } },
+            { 'autoPoll': false, 'params': { 'Id': 'group 2', 'Rate': parseFloat(n.pollTime2) } },
+            { 'autoPoll': false, 'params': { 'Id': 'group 3', 'Rate': parseFloat(n.pollTime3) } },
+            { 'autoPoll': false, 'params': { 'Id': 'group 4', 'Rate': parseFloat(n.pollTime4) } }
+        ];
 
-        /*****************************************************************************
-         * Helper Functions
-         *****************************************************************************/
-
-        const encapsulate = (obj) => {
-            return Buffer.concat([Buffer.from(JSON.stringify(obj)), Buffer.from([0x0])])
+        const logWithTimestamp = (message, isError = false) => {
+            const timestamp = new Date().toISOString();
+            const formattedMessage = `[${timestamp}] ${message}`;
+            if (isError) {
+                this.error(formattedMessage);
+            } else {
+                this.log(formattedMessage); // Use log instead of trace so messages are visible
+            }
         };
 
-        /*****************************************************************************
-         * Node Functions
-         *****************************************************************************/
+        const initializeSocket = (socket, host, port) => {
+            socket.setKeepAlive(true, CONFIG.KEEP_ALIVE_INTERVAL);
+            socket.setTimeout(CONFIG.SOCKET_TIMEOUT);
+            socket.setMaxListeners(0);
+            updateNodeStatus(ConnectionState.CONNECTING, 'initializing...');
 
-        this.sendToCore = (obj) => {
-            if (logCommunications) {
-                this.log('tx: ' + JSON.stringify(obj));
-            }
+            socket.on('timeout', () => {
+                logWithTimestamp('Socket timeout detected, destroying socket', true);
+                socket.destroy(); // Destroy the socket on timeout
+            });
 
-            if (this.socket !== null) {
-                this.socket.write(encapsulate(obj));
-            }
-        };
+            socket.on('error', (err) => {
+                logWithTimestamp(`Socket error: ${err.toString()}`, true);
+                updateNodeStatus(ConnectionState.ERROR, err.message);
+                if (isRedundant) {
+                    reconnectToRedundantHost();
+                } else {
+                    reconnect();
+                }
+            });
 
-        this.autoPoll = (index) => {
-            if (!this.changeGroup[index].autoPoll) {
-                this.changeGroup[index].autoPoll = true;
-                this.sendToCore({
-                    "jsonrpc": "2.0",
-                    "id": 1234,
-                    "method": "ChangeGroup.AutoPoll",
-                    "params": this.changeGroup[index].params
-                });
-            }
+            socket.on('end', () => {
+                logWithTimestamp('socket end');
+                updateNodeStatus(ConnectionState.DISCONNECTED, 'connection ended');
+            });
+
+            socket.on('close', () => {
+                if (logConnection) {
+                    logWithTimestamp('socket closed');
+                }
+                if (noOp != null) {
+                    clearInterval(noOp);
+                    noOp = null;
+                }
+                reconnect();
+            });
+
+            socket.on('ready', () => {
+                if (logConnection) {
+                    logWithTimestamp('socket ready');
+                }
+                
+                // Update node status to connected
+                updateNodeStatus(ConnectionState.CONNECTED);
+
+                if (authentication) {
+                    try {
+                        if (!username || !password) {
+                            throw new Error('Authentication credentials not provided');
+                        }
+                        const message = encapsulate(createJsonRpcMessage('Logon', {
+                            'User': username,
+                            'Password': password
+                        }));
+                        if (message) {
+                            socket.write(message);
+                        } else {
+                            throw new Error('Failed to create authentication message');
+                        }
+                    } catch (err) {
+                        logWithTimestamp(`Authentication error: ${err.message}`, true);
+                        socket.destroy();
+                        return;
+                    }
+                }
+
+                // Clear any existing NoOp interval before starting a new one
+                if (noOp != null) {
+                    clearInterval(noOp);
+                    noOp = null;
+                }
+                
+                noOp = setInterval(() => {
+                    socket.write(encapsulate(createJsonRpcMessage('NoOp', {})));
+                }, CONFIG.NOOP_INTERVAL);
+            });
+
+            socket.on('connect', () => {
+                if (logConnection) {
+                    logWithTimestamp('Socket connected');
+                }
+                reconnectAttempts = 0;
+            });
+
+            socket.on('data', (data) => {
+                if (logCommunications) {
+                    logWithTimestamp('rx: ' + data.toString(), false);
+                }
+
+                let rx = [];
+                try {
+                    for (let i = 0; i < data.length; i++) {
+                        if (data[i] == 0x0 && data.length != 0) {
+                            let obj = JSON.parse((Buffer.from(rx)).toString());
+                            if ('method' in obj) {
+                                switch (obj.method) {
+                                    case 'EngineStatus':
+                                        if (obj.params.State === 'Active') {
+                                            this.emit('ready');
+                                        } else if (isRedundant && obj.params.State === 'Standby') {
+                                            reconnectToRedundantHost();
+                                        }
+                                        break;
+                                    case 'ChangeGroup.Poll':
+                                        let changes = obj.params.Changes;
+                                        if (changes.length !== 0) {
+                                            for (let change of changes) {
+                                                this.emit('rx', change);
+                                            }
+                                        }
+                                        break;
+                                    default:
+                                        break;
+                                }
+                            }
+                            rx = [];
+                        } else {
+                            rx.push(data[i]);
+                        }
+                    }
+                } catch (err) {
+                    logWithTimestamp(`Error processing data: ${err.message}`, true);
+                }
+            });
+
+            return socket;
         };
 
-        /*****************************************************************************
-         * Socket Event handlers
-         *****************************************************************************/
-        
-        // close
-        this.socket.on('close', () => {
-            if (logConnection) {
-                this.log('socket closed');
+        const cleanup = () => {
+            if (reconnectTimer) {
+                clearTimeout(reconnectTimer);
+                reconnectTimer = null;
             }
-            
             if (noOp != null) {
                 clearInterval(noOp);
                 noOp = null;
             }
+            messageBuffer = Buffer.alloc(0);
+            isReconnecting = false;
+        };
 
-            this.socket.destroy();
-            this.socket = null;
-        });
-        
-        // connect
-        this.socket.on('connect', (data) => {
-            if (logConnection) {
-                this.log('socket connected');
+        const reconnect = () => {
+            if (isReconnecting) {
+                return; // Prevent multiple concurrent reconnection attempts
             }
-        });
-        
-        // data
-        this.socket.on('data', (data) => {
-            if (logCommunications) {
-                this.log('rx: ' + data.toString());
-            }
-
-            let rx = [];
 
-            for (let i = 0; i < data.length; i++) {
-                if (data[i] == 0x0 && data.length != 0) {
-                    try {
-                        let obj = JSON.parse((Buffer.from(rx)).toString());
-                        if ('method' in obj) {
-                            switch (obj.method) {
-                                case 'EngineStatus':
-                                    if (obj.params.State === 'Active') {
-                                        this.emit('ready');
-                                    }
-                                    else if (isRedundant && obj.params.State === 'Standby') {
-                                        this.socket.destroy()
-                                        this.socket = net.connect(port, host);
-                                    }
-                                    
-                                    break;
-                                case 'ChangeGroup.Poll':
-                                    let changes = obj.params.Changes;
-                                    if (changes.length !== 0) {
-                                        for (let i = 0; i < changes.length; i++) {
-                                            this.emit('rx', changes[i]);
-                                        }
-                                    }
-                                    break;
-                                default:
-                                    break;
-                            }
-                        }
-                    rx = [];
-                    } catch (err) {
-                        this.error(err.toString());
-                    }
-                }
-                else {
-                    rx.push(data[i]);
+            isReconnecting = true;
+            updateNodeStatus(ConnectionState.CONNECTING, `Attempt ${reconnectAttempts + 1}`);
+            const retryExponent = Math.min(reconnectAttempts, CONFIG.RECONNECT_MAX_RETRIES);
+            const calculatedDelay = CONFIG.RECONNECT_BASE_DELAY * Math.pow(2, retryExponent);
+            const delay = Math.min(calculatedDelay, CONFIG.RECONNECT_MAX_DELAY); // Cap at 60 seconds
+            
+            // Only log if we haven't reached max delay or just reached it
+            if (!hasReachedMaxDelay) {
+                if (reconnectAttempts >= CONFIG.RECONNECT_MAX_RETRIES) {
+                    logWithTimestamp(`Reconnection backoff reached maximum delay (${CONFIG.RECONNECT_MAX_DELAY/1000} seconds). Further reconnection attempts will continue silently.`);
+                    hasReachedMaxDelay = true;
+                } else {
+                    logWithTimestamp(`Scheduling reconnect attempt ${reconnectAttempts + 1} in ${delay}ms`);
                 }
             }
-        });
+            
+            if (reconnectTimer) {
+                clearTimeout(reconnectTimer);
+            }
 
-        // drain
-        this.socket.on('drain', () => { });
+            reconnectTimer = setTimeout(() => {
+                if (!hasReachedMaxDelay) {
+                    logWithTimestamp(`Attempting to reconnect (attempt ${reconnectAttempts + 1})...`, false);
+                }
+                
+                let newSocket;
+                try {
+                    newSocket = net.connect(port, host);
+                } catch (err) {
+                    logWithTimestamp(`Failed to create socket connection: ${err.message}`, true);
+                    isReconnecting = false;
+                    reconnect();
+                    return;
+                }
+                newSocket.once('connect', () => {
+                    logWithTimestamp('Reconnection successful');
+                    reconnectAttempts = 0;
+                    isReconnecting = false;
+                    hasReachedMaxDelay = false; // Reset on successful connection
+                    this.socket = initializeSocket(newSocket, host, port);
+                });
 
-        // end
-        this.socket.on('end', () => {
-            if (logConnection) {
-                this.log('socket end');
-            }
-        });
+                newSocket.once('error', (err) => {
+                    if (!hasReachedMaxDelay) {
+                        logWithTimestamp(`Reconnection attempt failed: ${err.message}`);
+                    }
+                    reconnectAttempts++;
+                    isReconnecting = false;
+                    newSocket.destroy();
+                    reconnect(); // Schedule next attempt
+                });
+            }, delay);
+        };
 
-        // error
-        this.socket.on('error', (err) => {
-            if (logConnection) {
-                this.error(err.toString());
-            }
-            if (isRedundant) {
+        const reconnectToRedundantHost = () => {
+            logWithTimestamp('Switching to redundant host...');
+            updateNodeStatus(ConnectionState.CONNECTING, 'Switching to redundant host');
+            cleanup();
+            if (this.socket) {
                 this.socket.destroy();
-                this.socket = net.connect(port, redundantHost);
             }
+            reconnectAttempts = 0; // Reset attempts when switching to redundant
+            hasReachedMaxDelay = false; // Reset delay cap when switching to redundant
+            this.socket = initializeSocket(net.connect(port, redundantHost), redundantHost, port);
+        };
+
+        const createJsonRpcMessage = (method, params = {}, id = null) => ({
+            jsonrpc: '2.0',
+            method,
+            params,
+            ...(id !== null && { id })
         });
 
-        // lookup
-        this.socket.on('lookup', () => { });
+        const encapsulate = (obj) => {
+            try {
+                return Buffer.concat([Buffer.from(JSON.stringify(obj)), Buffer.from([0x0])]);
+            } catch (err) {
+                logWithTimestamp(`Failed to encode message: ${err.message}`, true);
+                return null;
+            }
+        };
 
-        // ready
-        this.socket.on('ready', () => {
-            if (logConnection) {
-                this.log('socket ready');
+        const updateNodeStatus = (state, message = '') => {
+            if (logConnection && state !== connectionState) {
+                logWithTimestamp(`Connection state changed from ${connectionState} to ${state}${message ? ': ' + message : ''}`);
+            }
+            connectionState = state;
+            
+            // Emit state change events for child nodes
+            this.emit('state', state);
+            
+            switch (state) {
+                case ConnectionState.CONNECTED:
+                    this.status({fill: 'green', shape: 'dot', text: 'connected'});
+                    this.emit('connected');
+                    break;
+                case ConnectionState.CONNECTING:
+                    this.status({fill: 'yellow', shape: 'ring', text: message || 'connecting...'});
+                    this.emit('connecting');
+                    break;
+                case ConnectionState.ERROR:
+                    this.status({fill: 'red', shape: 'ring', text: message || 'error'});
+                    this.emit('error', message);
+                    break;
+                case ConnectionState.DISCONNECTED:
+                    this.status({fill: 'red', shape: 'dot', text: 'disconnected'});
+                    this.emit('disconnected');
+                    break;
             }
+        };
 
-            if (authentication) {
-                this.socket.write(encapsulate({
-                    'jsonrpc': '2.0',
-                    'method': 'Logon',
-                    'params': {
-                        'User': username,
-                        'Password': password
+        this.sendToCore = (obj) => {
+            try {
+                if (logCommunications) {
+                    logWithTimestamp('tx: ' + JSON.stringify(obj));
+                }
+
+                if (this.socket !== null) {
+                    const message = encapsulate(obj);
+                    if (message) {
+                        this.socket.write(message);
+                    } else {
+                        throw new Error('Failed to encapsulate message');
                     }
-                }));
+                } else {
+                    throw new Error('Socket not connected');
+                }
+            } catch (err) {
+                logWithTimestamp(`Failed to send message: ${err.message}`, true);
             }
+        };
 
-            noOp = setInterval(() => {
-                this.socket.write(encapsulate({
-                    'jsonrpc': '2.0',
-                    'method': 'NoOp',
-                    'params': {}
-                }));
-            }, 30000);
-        });
-
-        // timeout
-        this.socket.on('timeout', () => {
-            if (logConnection) {
-                this.log('socket timeout');
+        this.autoPoll = (index) => {
+            if (!this.changeGroup[index].autoPoll) {
+                this.changeGroup[index].autoPoll = true;
+                this.sendToCore({
+                    "jsonrpc": "2.0",
+                    "id": 1234,
+                    "method": "ChangeGroup.AutoPoll",
+                    "params": this.changeGroup[index].params
+                });
             }
-        });
+        };
+
+        this.socket = initializeSocket(net.connect(port, host), host, port);
 
-        /***************************************************************************
-         * Node Event Listeners
-         ***************************************************************************/
         this.on('close', (removed, done) => {
-            if (removed) {
-                this.socket.destroy();
-            }
-            else {
-                this.socket.end();
+            if (this.socket) {
+                this.socket.removeAllListeners(); // Remove all listeners
+                cleanup();
+                if (removed) {
+                    this.socket.destroy();
+                } else {
+                    this.socket.end();
+                }
             }
             done();
         });
     }
+
     RED.nodes.registerType('qsys-core', QsysCoreNode, {
         credentials: {
             username: { type: 'text' },
             password: { type: 'password' }
         }
     });
-}
\ No newline at end of file
+};
\ No newline at end of file
diff --git a/package.json b/package.json
index 3cd4e06..f272691 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-qsys",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "A collection of nodes for third party control of Q-Sys systems",
   "main": "qsys-core.js",
   "directories": {