ads-client 1.11.4 → 1.12.0

package/CHANGELOG.md

@@ -4,6 +4,14 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.12.0] - 28.12.2021
+### Changed
+- Improving handling of connection losses ([See pull request #78](https://github.com/jisotalo/ads-client/pull/78))
+  - Thank you [Hopperpop](https://github.com/Hopperpop) for contribution!
+  - Re-design of connection, reconnection and disconnection system
+  - Re-design of automatic reconnection
+- Calling `reconnect()` now automatically re-subscribes all existing subscriptions
+
 ## [1.11.4] - 17.10.2021
 ### Added
 - Added optional `targetAdsPort` parameter to basic raw read and write methods. ([Pull request #79](https://github.com/jisotalo/ads-client/pull/79))

package/README.md

@@ -22,60 +22,65 @@ Check out the [node-red-contrib-ads-client](https://www.npmjs.com/package/node-r
 
 
 # Table of contents
-
 - [Installation](#installation)
-- [Features](#installation)
+- [Features](#features)
 - [Supported and tested platforms](#supported-and-tested-platforms)
 - [Connection setups and possibilities](#connection-setups-and-possibilities)
-- [Enabling localhost support](#enabling-localhost-support)
+- [Enabling localhost support on TwinCAT 3](#enabling-localhost-support-on-twincat-3)
 - [IMPORTANT: Writing STRUCT variables](#important-writing-struct-variables)
 - [IMPORTANT: Things to know when using with TwinCAT 2](#important-things-to-know-when-using-with-twincat-2)
 - [Getting started](#getting-started)
-  - [Data types used in getting started](data-types-used-in-getting-started)
-  - [Creating a new Client instance](#creating-a-new-client-instance)
-  - [Connecting and disconnecting](#connecting-and-disconnecting)
-  - [Reading any type PLC variable](#reading-any-type-plc-variable)
-    - [Example: Reading INT type variable](#example-reading-int-type-variable)
-    - [Example: Reading STRING type variable](#example-reading-string-type-variable)
-    - [Example: Reading ENUM type variable](#example-reading-enum-type-variable)
-    - [Example: Reading STRUCT type variable](#example-reading-struct-type-variable)
-    - [Example: Reading ARRAY OF INT type variable](#example-reading-array-of-int-type-variable)
-    - [Example: Reading ARRAY OF STRUCT type variable](#example-reading-array-of-struct-type-variable)
-    - [Example: Reading FUNCTION BLOCK type variable](#example-reading-function-block-type-variable)
-  - [Writing any type PLC variable](#writing-any-type-plc-variable)
-    - [Example: Writing INT type variable](#example-writing-int-type-variable)
-    - [Example: Writing STRING type variable](#example-writing-string-type-variable)
-    - [Example: Writing ENUM type variable](#example-writing-enum-type-variable)
-    - [Example: Writing STRUCT type variable](#example-writing-struct-type-variable)
-    - [Example: Writing STRUCT type variable (with autoFill parameter)](#example-writing-struct-type-variable-with-autofill-parameter)
-    - [Example: Writing ARRAY OF INT type variable](#example-writing-array-of-int-type-variable)
-    - [Example: Writing ARRAY of STRUCT type variable](#example-writing-array-of-struct-type-variable)
-    - [Example: Writing FUNCTION BLOCK type variable](#example-writing-function-block-type-variable)
-  - [Subscribing to PLC variables (device notifications)](#subscribing-to-plc-variables-device-notifications)
-    - [Subcribe to variable value (on-change)](#subcribe-to-variable-value-on-change)
-    - [Subcribe to variable value (cyclic)](#subcribe-to-variable-value-cyclic)
-  - [Reading and writing raw data](#reading-and-writing-raw-data)
-    - [Getting symbol index group, offset and size](#getting-symbol-index-group-offset-and-size)
-    - [Reading a single raw value](#reading-a-single-raw-value)
-    - [Writing a single raw value](#writing-a-single-raw-value)
-    - [Reading multiple raw values](#reading-multiple-raw-values)
-    - [Writing multiple raw values](#writing-multiple-raw-values)
-    - [Creating a variable handle and reading a raw value](#creating-a-variable-handle-and-reading-a-raw-value)
-    - [Creating a variable handle and writing a raw value](#creating-a-variable-handle-and-writing-a-raw-value)
-    - [Creating and deleting multiple variable handles](#creating-and-deleting-multiple-variable-handles)
-    - [Converting a raw value to Javascript object](#converting-a-raw-value-to-javascript-object)
-    - [Converting a Javascript object to raw value](#converting-a-javascript-object-to-raw-value)
-  - [Reading and writing POINTER TO and REFERENCE TO variables](#reading-and-writing-pointer-to-and-reference-to-variables)
-    - [Reading a REFERENCE TO value](#reading-a-reference-to-value)
-    - [Writing a REFERENCE TO value](#writing-a-reference-to-value)
-    - [Reading a POINTER TO value](#reading-a-pointer-to-value)
-    - [Writing a POINTER TO value](#writing-a-pointer-to-value)
-  - [Calling a function block method with parameters using RPC (remote procedure call)](#calling-a-function-block-method-with-parameters-using-rpc-remote-procedure-call)
-  - [Starting and stopping the PLC](#starting-and-stopping-the-plc)
-  - [Starting and stopping the TwinCAT system](#starting-and-stopping-the-twincat-system)
-  - [Sending custom ADS commands](#sending-custom-ads-commands)
-  - [Available ads-client events](#available-ads-client-events)
+  * [Data types used in getting started](#data-types-used-in-getting-started)
+  * [Creating a new Client instance](#creating-a-new-client-instance)
+  * [Connecting and disconnecting](#connecting-and-disconnecting)
+  * [Reading any type PLC variable](#reading-any-type-plc-variable)
+    + [Example: Reading `INT` type variable](#example-reading-int-type-variable)
+    + [Example: Reading `STRING` type variable](#example-reading-string-type-variable)
+    + [Example: Reading `ENUM` type variable](#example-reading-enum-type-variable)
+    + [Example: Reading `STRUCT` type variable](#example-reading-struct-type-variable)
+    + [Example: Reading `ARRAY OF INT` type variable](#example-reading-array-of-int-type-variable)
+    + [Example: Reading `ARRAY OF STRUCT` type variable](#example-reading-array-of-struct-type-variable)
+    + [Example: Reading `FUNCTION BLOCK` type variable](#example-reading-function-block-type-variable)
+  * [Writing any type PLC variable](#writing-any-type-plc-variable)
+    + [Example: Writing `INT` type variable](#example-writing-int-type-variable)
+    + [Example: Writing `STRING` type variable](#example-writing-string-type-variable)
+    + [Example: Writing `ENUM` type variable](#example-writing-enum-type-variable)
+    + [Example: Writing `STRUCT` type variable](#example-writing-struct-type-variable)
+    + [Example: Writing `STRUCT` type variable (with autoFill parameter)](#example-writing-struct-type-variable-with-autofill-parameter-)
+    + [Example: Writing `ARRAY OF INT` type variable](#example-writing-array-of-int-type-variable)
+    + [Example: Writing `ARRAY of STRUCT` type variable](#example-writing-array-of-struct-type-variable)
+    + [Example: Writing `FUNCTION BLOCK` type variable](#example-writing-function-block-type-variable)
+  * [Subscribing to PLC variables (device notifications)](#subscribing-to-plc-variables-device-notifications-)
+    + [Subcribe to variable value (on-change)](#subcribe-to-variable-value-on-change-)
+    + [Subcribe to variable value (cyclic)](#subcribe-to-variable-value-cyclic-)
+  * [Reading and writing raw data](#reading-and-writing-raw-data)
+    + [Getting symbol index group, offset and size](#getting-symbol-index-group-offset-and-size)
+    + [Reading a single raw value](#reading-a-single-raw-value)
+    + [Writing a single raw value](#writing-a-single-raw-value)
+    + [Reading multiple raw values](#reading-multiple-raw-values)
+    + [Writing multiple raw values](#writing-multiple-raw-values)
+    + [Creating a variable handle and reading a raw value](#creating-a-variable-handle-and-reading-a-raw-value)
+    + [Creating a variable handle and writing a raw value](#creating-a-variable-handle-and-writing-a-raw-value)
+    + [Creating and deleting multiple variable handles](#creating-and-deleting-multiple-variable-handles)
+    + [Converting a raw value to Javascript object](#converting-a-raw-value-to-javascript-object)
+    + [Converting a Javascript object to raw value](#converting-a-javascript-object-to-raw-value)
+  * [Reading and writing `POINTER TO` and `REFERENCE TO` variables](#reading-and-writing-pointer-to-and-reference-to-variables)
+    + [Reading a `REFERENCE TO` value](#reading-a-reference-to-value)
+    + [Writing a `REFERENCE TO` value](#writing-a-reference-to-value)
+    + [Reading a `POINTER TO` value](#reading-a-pointer-to-value)
+    + [Writing a `POINTER TO` value](#writing-a-pointer-to-value)
+  * [Calling a function block method with parameters using RPC (remote procedure call)](#calling-a-function-block-method-with-parameters-using-rpc-remote-procedure-call-)
+    + [Calling a simple RPC method](#calling-a-simple-rpc-method)
+    + [Using structs with RPC methods](#using-structs-with-rpc-methods)
+  * [Starting and stopping the PLC](#starting-and-stopping-the-plc)
+  * [Starting and stopping the TwinCAT system](#starting-and-stopping-the-twincat-system)
+  * [Sending custom ADS commands](#sending-custom-ads-commands)
+- [Available ads-client events](#available-ads-client-events)
+  * [Example: Printing to console when PLC runtime state changes:](#example-printing-to-console-when-plc-runtime-state-changes-)
+  * [Example: Catching an error that is not directly from a method call](#example-catching-an-error-that-is-not-directly-from-a-method-call)
 - [Debugging](#debugging)
+  * [Enabling debug from code](#enabling-debug-from-code)
+  * [Enabling debugging from terminal](#enabling-debugging-from-terminal)
 - [FAQ](#faq)
 - [Documentation](#documentation)
 - [License](#license)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ads-client",
-  "version": "1.11.4",
+  "version": "1.12.0",
   "description": "Beckhoff TwinCAT ADS client library for Node.js (unofficial). Connects to Beckhoff TwinCAT automation systems using ADS protocol.",
   "main": "./src/ads-client.js",
   "scripts": {

package/src/ads-client.js

@@ -161,12 +161,12 @@ class Client extends EventEmitter {
       activeAdsRequests: {}, //Active ADS requests that wait for answer from router
       activeSubscriptions: {}, //Active device notifications
       symbolVersionNotification: null, //Notification handle of the symbol version changed subscription (used to unsubscribe)
-      systemManagerStatePoller: null, //Timer that reads the system manager state (run/config) - This is not available through ADS notifications
+      systemManagerStatePoller: { id: 0, timer: null }, //Timer that reads the system manager state (run/config) - This is not available through ADS notifications
       firstStateReadFaultTime: null, //Date when system manager state read failed for the first time
       socketConnectionLostHandler: null, //Handler for socket connection lost event
       socketErrorHandler: null, //Handler for socket error event
       oldSubscriptions: null, //Old subscriptions that were active before connection was lost
-      reconnectionTimer: null, //Timer that tries to reconnect intervally
+      reconnectionTimer: { id: 0, timer: null }, //Timer that tries to reconnect intervally
       portRegisterTimeoutTimer: null, //Timeout timer of registerAdsPort()
     }
 
@@ -290,205 +290,7 @@ class Client extends EventEmitter {
    * - If rejected, something went wrong and error info is returned (object)
    */
   connect() {
-
-    return new Promise(async (resolve, reject) => {
-
-      if (this._internals.socket !== null) {
-        debug(`connect(): Socket already assigned`)
-        return reject(new ClientException(this, 'connect()', 'Connection is already opened. Close the connection first using disconnect()'))
-      }
-
-      debug(`connect(): Starting to connect ${this.settings.routerAddress}:${this.settings.routerTcpPort}`)
-
-      //Creating a socket and setting it up
-      let socket = new net.Socket()
-      socket.setNoDelay(true) //Sends data without delay
-
-
-
-      //----- Connecting error events -----
-
-      //Listening error event during connection
-      socket.once('error', err => {
-        debug('connect(): Socket connect failed: %O', err)
-
-        //Remove all events from socket
-        socket.removeAllListeners()
-        socket = null
-
-        //Reset connection flag
-        this.connection.connected = false
-
-        reject(new ClientException(this, 'connect()', `Connection to ${this.settings.routerAddress}:${this.settings.routerTcpPort} failed (socket error ${err.errno})`, err))
-      })
-
-
-
-      //Listening close event during connection
-      socket.once('close', hadError => {
-        debug(`connect(): Socket closed by remote, connection failed`)
-
-        //Remove all events from socket
-        socket.removeAllListeners()
-        socket = null
-
-        //Reset connection flag
-        this.connection.connected = false
-
-        reject(new ClientException(this, 'connect()', `Connection to ${this.settings.routerAddress}:${this.settings.routerTcpPort} failed - socket closed by remote (hadError = ${hadError})`))
-      })
-
-
-      //Listening end event during connection
-      socket.once('end', () => {
-        debug(`connect(): Socket connection ended by remote, connection failed.`)
-
-        //Remove all events from socket
-        socket.removeAllListeners()
-        socket = null
-
-        //Reset connection flag
-        this.connection.connected = false
-
-        if (this.settings.localAdsPort != null)
-          reject(new ClientException(this, 'connect()', `Connection to ${this.settings.routerAddress}:${this.settings.routerTcpPort} failed - socket ended by remote (is the given local ADS port ${this.settings.localAdsPort} already in use?)`))
-        else
-          reject(new ClientException(this, 'connect()', `Connection to ${this.settings.routerAddress}:${this.settings.routerTcpPort} failed - socket ended by remote`))
-      })
-
-      //Listening timeout event during connection
-      socket.once('timeout', () => {
-        debug(`connect(): Socket timeout`)
-
-        //No more timeout needed
-        socket.setTimeout(0);
-        socket.destroy()
-
-        //Remove all events from socket
-        socket.removeAllListeners()
-        socket = null
-
-        //Reset connection flag
-        this.connection.connected = false
-
-        reject(new ClientException(this, 'connect()', `Connection to ${this.settings.routerAddress}:${this.settings.routerTcpPort} failed (timeout) - No response from router in ${this.settings.timeoutDelay} ms`))
-      })
-
-      //----- Connecting error events end -----
-
-
-      //Listening for connect event
-      socket.once('connect', async () => {
-        debug(`connect(): Socket connection established to ${this.settings.routerAddress}:${this.settings.routerTcpPort}`)
-
-        //No more timeout needed
-        socket.setTimeout(0);
-
-        this._internals.socket = socket
-
-        //Try to register an ADS port
-        try {
-          let res = await _registerAdsPort.call(this)
-
-          this.connection.connected = true
-          this.connection.localAmsNetId = res.amsTcp.data.localAmsNetId
-          this.connection.localAdsPort = res.amsTcp.data.localAdsPort
-          this.connection.isLocal = this.settings.targetAmsNetId === '127.0.0.1.1.1' || this.settings.targetAmsNetId === this.connection.localAmsNetId
-
-          debug(`connect(): ADS port registered from router. We are ${this.connection.localAmsNetId}:${this.connection.localAdsPort}`)
-        } catch (err) {
-
-          if (socket) {
-            socket.destroy()
-            //Remove all events from socket
-            socket.removeAllListeners()
-          }
-          this.connection.connected = false
-
-          return reject(new ClientException(this, 'connect()', `Registering ADS port from router failed`, err))
-        }
-
-        //Remove the socket events that were used only during connect()
-        socket.removeAllListeners('error')
-        socket.removeAllListeners('close')
-        socket.removeAllListeners('end')
-
-        //When socket errors from now on, we will close the connection
-        this._internals.socketErrorHandler = _onSocketError.bind(this)
-        socket.on('error', this._internals.socketErrorHandler)
-
-        try {
-          //Try to read system manager state - If it's OK, connection is successful to the target
-          await this.readSystemManagerState()
-          _systemManagerStatePoller.call(this)
-
-        } catch (err) {
-          try {
-            await this.disconnect()
-          } catch (err) {
-            debug(`connect(): Reading target system manager failed -> Connection closed`)
-          }
-          this.connection.connected = false
-
-          return reject(new ClientException(this, 'connect()', `Connection failed: ${err.message}`, err))
-        }
-
-
-        try {
-          await _reInitializeInternals.call(this)
-
-        } catch (err) {
-          if (this.settings.allowHalfOpen !== true) {
-            try {
-              await this.disconnect()
-            } catch (err) {
-              debug(`connect(): Connecting to target PLC runtime failed -> Connection closed`)
-            }
-            this.connection.connected = false
-
-            return reject(new ClientException(this, 'connect()', `Target and system manager found but couldn't connect to the PLC runtime (see setting allowHalfOpen): ${err.message}`, err))
-          }
-
-          //Todo: Redesign this
-          if (this.metaData.systemManagerState.adsState !== ADS.ADS_STATE.Run)
-            _console.call(this, `WARNING: Target is connected but not in RUN mode (mode: ${this.metaData.systemManagerState.adsStateStr}) - connecting to runtime (ADS port ${this.settings.targetAdsPort}) failed`)
-          else
-            _console.call(this, `WARNING: Target is connected but connecting to runtime (ADS port ${this.settings.targetAdsPort}) failed - Check the port number and that the target system state (${this.metaData.systemManagerState.adsStateStr}) is valid.`)
-        }
-
-        //Listening connection lost events
-        this._internals.socketConnectionLostHandler = _onConnectionLost.bind(this, true)
-        socket.on('close', this._internals.socketConnectionLostHandler)
-
-        //We are connected to the target
-        this.emit('connect', this.connection)
-
-        resolve(this.connection)
-      })
-
-      //Listening data event
-      socket.on('data', data => {
-        _socketReceive.call(this, data)
-      })
-
-      //Timeout only during connecting, other timeouts are handled elsewhere
-      socket.setTimeout(this.settings.timeoutDelay);
-
-      //Finally, connect
-      try {
-        socket.connect({
-          port: this.settings.routerTcpPort,
-          host: this.settings.routerAddress,
-          localPort: (this.settings.localTcpPort ? this.settings.localTcpPort : null),
-          localAddress: (this.settings.localAddress ? this.settings.localAddress : null),
-        })
-
-      } catch (err) {
-        this.connection.connected = false
-
-        reject(new ClientException(this, 'connect()', `Opening socket connection to ${this.settings.routerAddress}:${this.settings.routerTcpPort} failed`, err))
-      }
-    })
+    return _connect.call(this)
   }
 
 
@@ -511,96 +313,7 @@ class Client extends EventEmitter {
    * - If rejected, connection is still closed but something went wrong during disconnecting and error info is returned
    */
   disconnect(forceDisconnect = false) {
-    return new Promise(async (resolve, reject) => {
-      debug(`disconnect(): Starting to close connection (force: ${forceDisconnect})`)
-
-      try {
-        if (this._internals.socketConnectionLostHandler) {
-          this._internals.socket.off('close', this._internals.socketConnectionLostHandler)
-        }
-
-      } catch (err) {
-        //We probably have no socket anymore. Just quit.
-        forceDisconnect = true
-      }
-
-      //Clear system manager state poller
-      clearTimeout(this._internals.systemManagerStatePoller)
-      clearTimeout(this._internals.portRegisterTimeoutTimer)
-
-      //If forced, then just destroy the socket
-      if (forceDisconnect) {
-
-        if (this._internals.socket) {
-          this._internals.socket.removeAllListeners()
-          this._internals.socket.destroy()
-        }
-        this.connection.connected = false
-        this.connection.localAdsPort = null
-        this._internals.socket = null
-
-        this.emit('disconnect')
-
-        return resolve()
-      }
-
-
-      let error = null
-
-      try {
-        await this.unsubscribeAll()
-      } catch (err) {
-        error = new ClientException(this, 'disconnect()', err)
-      }
-
-      try {
-        await _unsubscribeAllInternals.call(this)
-      } catch (err) {
-        error = new ClientException(this, 'disconnect()', err)
-      }
-
-      try {
-        await _unregisterAdsPort.call(this)
-
-        //Done
-        this.connection.connected = false
-        this.connection.localAdsPort = null
-
-        //Socket should be null but check it anyways
-        if (this._internals.socket != null) {
-          this._internals.socket.removeAllListeners()
-          this._internals.socket.destroy() //Just incase
-          this._internals.socket = null
-        }
-
-        debug(`disconnect(): Connection closed successfully`)
-
-      } catch (err) {
-        //Force socket close
-        if (this._internals.socket) {
-          this._internals.socket.removeAllListeners()
-          this._internals.socket.destroy()
-        }
-
-        this.connection.connected = false
-        this.connection.localAdsPort = null
-        this._internals.socket = null
-
-        error = new ClientException(this, 'disconnect()', err)
-
-        debug(`disconnect(): Connection closing failed, connection forced to close`)
-      }
-
-      if (error !== null) {
-        error.message = `Disconnected but something failed: ${error.message}`
-        this.emit('disconnect')
-
-        return reject(error)
-      }
-
-      this.emit('disconnect')
-      resolve()
-    })
+    return _disconnect.call(this, forceDisconnect)
   }
 
 
@@ -611,42 +324,18 @@ class Client extends EventEmitter {
 
 
   /**
-   * Disconnects and reconnects again. At the moment does NOT reinitialize subscriptions, everything is lost
+   * Disconnects and reconnects again. Subscribes again to all active subscriptions.
+   * To prevent subscribing, call unsubscribeAll() before reconnecting.
    * 
    * @param {boolean} [forceDisconnect] - If true, the connection is dropped immediately (default = false)  
    * 
    * @returns {Promise} Returns a promise (async function)
-   * - If resolved, connection to PLC runtime is successful
-   * - If rejected, connection to PLC runtime failed
+   * - If resolved, reconnecting was successful
+   * - If rejected, reconnecting failed and error info is returned
    */
   reconnect(forceDisconnect = false) {
-    return new Promise(async (resolve, reject) => {
-
-      if (this._internals.socket != null) {
-        try {
-          debug(`reconnect(): Trying to disconnect`)
-
-          await this.disconnect(forceDisconnect)
-
-        } catch (err) {
-          debug(`reconnect(): Disconnecting failed: %o`, err)
-        }
-      }
-
-      debug(`reconnect(): Trying to connect`)
-
-      return this.connect()
-        .then(res => {
-          debug(`reconnect(): Connected!`)
-          this.emit('reconnect')
-
-          resolve(res)
-        })
-        .catch(err => {
-          debug(`reconnect(): Connecting failed`)
-          reject(err)
-        })
-    })
+    debug(`reconnect(): Reconnecting...`)
+    return _reconnect.call(this, forceDisconnect)
   }
 
 
@@ -3566,6 +3255,408 @@ class ClientException extends Error {
 
 
 
+
+
+
+/**
+ * Connects to the target system using pre-defined Client::settings (at constructor or manually given)
+ *
+   * @param {boolean} [isReconnecting] - If true, the _connect() call is made during reconnection (-> affects disconnect() calls if connecting fails)
+ * 
+ * @returns {Promise<object>} Returns a promise (async function)
+   * - If resolved, client is connected successfully and connection info is returned (object)
+   * - If rejected, something went wrong and error info is returned (object)
+ * 
+ * @memberof _LibraryInternals
+ */
+function _connect(isReconnecting = false) {
+  return new Promise(async (resolve, reject) => {
+
+    if (this._internals.socket !== null) {
+      debug(`_connect(): Socket already assigned`)
+      return reject(new ClientException(this, '_connect()', 'Connection is already opened. Close the connection first using disconnect()'))
+    }
+
+    debug(`_connect(): Starting to connect ${this.settings.routerAddress}:${this.settings.routerTcpPort}`)
+
+    //Creating a socket and setting it up
+    let socket = new net.Socket()
+    socket.setNoDelay(true) //Sends data without delay
+
+
+
+    //----- Connecting error events -----
+
+    //Listening error event during connection
+    socket.once('error', err => {
+      debug('_connect(): Socket connect failed: %O', err)
+
+      //Remove all events from socket
+      socket.removeAllListeners()
+      socket = null
+
+      //Reset connection flag
+      this.connection.connected = false
+
+      reject(new ClientException(this, '_connect()', `Connection to ${this.settings.routerAddress}:${this.settings.routerTcpPort} failed (socket error ${err.errno})`, err))
+    })
+
+
+
+    //Listening close event during connection
+    socket.once('close', hadError => {
+      debug(`_connect(): Socket closed by remote, connection failed`)
+
+      //Remove all events from socket
+      socket.removeAllListeners()
+      socket = null
+
+      //Reset connection flag
+      this.connection.connected = false
+
+      reject(new ClientException(this, '_connect()', `Connection to ${this.settings.routerAddress}:${this.settings.routerTcpPort} failed - socket closed by remote (hadError = ${hadError})`))
+    })
+
+
+    //Listening end event during connection
+    socket.once('end', () => {
+      debug(`_connect(): Socket connection ended by remote, connection failed.`)
+
+      //Remove all events from socket
+      socket.removeAllListeners()
+      socket = null
+
+      //Reset connection flag
+      this.connection.connected = false
+
+      if (this.settings.localAdsPort != null)
+        reject(new ClientException(this, '_connect()', `Connection to ${this.settings.routerAddress}:${this.settings.routerTcpPort} failed - socket ended by remote (is the given local ADS port ${this.settings.localAdsPort} already in use?)`))
+      else
+        reject(new ClientException(this, '_connect()', `Connection to ${this.settings.routerAddress}:${this.settings.routerTcpPort} failed - socket ended by remote`))
+    })
+
+    //Listening timeout event during connection
+    socket.once('timeout', () => {
+      debug(`_connect(): Socket timeout`)
+
+      //No more timeout needed
+      socket.setTimeout(0);
+      socket.destroy()
+
+      //Remove all events from socket
+      socket.removeAllListeners()
+      socket = null
+
+      //Reset connection flag
+      this.connection.connected = false
+
+      reject(new ClientException(this, '_connect()', `Connection to ${this.settings.routerAddress}:${this.settings.routerTcpPort} failed (timeout) - No response from router in ${this.settings.timeoutDelay} ms`))
+    })
+
+    //----- Connecting error events end -----
+
+
+    //Listening for connect event
+    socket.once('connect', async () => {
+      debug(`_connect(): Socket connection established to ${this.settings.routerAddress}:${this.settings.routerTcpPort}`)
+
+      //No more timeout needed
+      socket.setTimeout(0);
+
+      this._internals.socket = socket
+
+      //Try to register an ADS port
+      try {
+        let res = await _registerAdsPort.call(this)
+
+        this.connection.connected = true
+        this.connection.localAmsNetId = res.amsTcp.data.localAmsNetId
+        this.connection.localAdsPort = res.amsTcp.data.localAdsPort
+        this.connection.isLocal = this.settings.targetAmsNetId === '127.0.0.1.1.1' || this.settings.targetAmsNetId === this.connection.localAmsNetId
+
+        debug(`_connect(): ADS port registered from router. We are ${this.connection.localAmsNetId}:${this.connection.localAdsPort}`)
+      } catch (err) {
+
+        if (socket) {
+          socket.destroy()
+          //Remove all events from socket
+          socket.removeAllListeners()
+        }
+        this.connection.connected = false
+
+        return reject(new ClientException(this, '_connect()', `Registering ADS port from router failed`, err))
+      }
+
+      //Remove the socket events that were used only during _connect()
+      socket.removeAllListeners('error')
+      socket.removeAllListeners('close')
+      socket.removeAllListeners('end')
+
+      //When socket errors from now on, we will close the connection
+      this._internals.socketErrorHandler = _onSocketError.bind(this)
+      socket.on('error', this._internals.socketErrorHandler)
+
+      try {
+        //Try to read system manager state - If it's OK, connection is successful to the target
+        await this.readSystemManagerState()
+        _systemManagerStatePoller.call(this)
+
+      } catch (err) {
+        try {
+          await _disconnect.call(this, false, isReconnecting)
+        } catch (err) {
+          debug(`_connect(): Reading target system manager failed -> Connection closed`)
+        }
+        this.connection.connected = false
+
+        return reject(new ClientException(this, '_connect()', `Connection failed: ${err.message}`, err))
+      }
+
+
+      try {
+        await _reInitializeInternals.call(this)
+
+      } catch (err) {
+        if (this.settings.allowHalfOpen !== true) {
+          try {
+            await _disconnect.call(this, false, true)
+          } catch (err) {
+            debug(`_connect(): Connecting to target PLC runtime failed -> Connection closed`)
+          }
+          this.connection.connected = false
+
+          return reject(new ClientException(this, '_connect()', `Target and system manager found but couldn't connect to the PLC runtime (see setting allowHalfOpen): ${err.message}`, err))
+        }
+
+        //Todo: Redesign this
+        if (this.metaData.systemManagerState.adsState !== ADS.ADS_STATE.Run)
+          _console.call(this, `WARNING: Target is connected but not in RUN mode (mode: ${this.metaData.systemManagerState.adsStateStr}) - connecting to runtime (ADS port ${this.settings.targetAdsPort}) failed`)
+        else
+          _console.call(this, `WARNING: Target is connected but connecting to runtime (ADS port ${this.settings.targetAdsPort}) failed - Check the port number and that the target system state (${this.metaData.systemManagerState.adsStateStr}) is valid.`)
+      }
+
+      //Listening connection lost events
+      this._internals.socketConnectionLostHandler = _onConnectionLost.bind(this, true)
+      socket.on('close', this._internals.socketConnectionLostHandler)
+
+      //We are connected to the target
+      this.emit('connect', this.connection)
+
+      resolve(this.connection)
+    })
+
+    //Listening data event
+    socket.on('data', data => {
+      _socketReceive.call(this, data)
+    })
+
+    //Timeout only during connecting, other timeouts are handled elsewhere
+    socket.setTimeout(this.settings.timeoutDelay);
+
+    //Finally, connect
+    try {
+      socket.connect({
+        port: this.settings.routerTcpPort,
+        host: this.settings.routerAddress,
+        localPort: (this.settings.localTcpPort ? this.settings.localTcpPort : null),
+        localAddress: (this.settings.localAddress ? this.settings.localAddress : null),
+      })
+
+    } catch (err) {
+      this.connection.connected = false
+
+      reject(new ClientException(this, '_connect()', `Opening socket connection to ${this.settings.routerAddress}:${this.settings.routerTcpPort} failed`, err))
+    }
+  })
+}
+
+
+/**
+ * Unsubscribes all notifications, unregisters ADS port from router (if it was registered)
+ * and disconnects target system and ADS router
+ *
+ * @param {boolean} [forceDisconnect] - If true, the connection is dropped immediately (default = false)
+ * @param {boolean} [isReconnecting] - If true, _disconnect() call is made during reconnecting
+ *
+ * @returns {Promise<object>} Returns a promise (async function)
+ * - If resolved, disconnect was successful 
+ * - If rejected, connection is still closed but something went wrong during disconnecting and error info is returned
+ *
+ * @memberof _LibraryInternals
+ */
+function _disconnect(forceDisconnect = false, isReconnecting = false) {
+  return new Promise(async (resolve, reject) => {
+
+    debug(`_disconnect(): Starting to close connection (force: ${forceDisconnect})`)
+
+    try {
+      if (this._internals.socketConnectionLostHandler) {
+        this._internals.socket.off('close', this._internals.socketConnectionLostHandler)
+      }
+
+    } catch (err) {
+      //We probably have no socket anymore. Just quit.
+      forceDisconnect = true
+    }
+
+    //Clear reconnection timer only when not reconnecting
+    if (!isReconnecting) {
+      _clearTimer(this._internals.reconnectionTimer)
+    }
+
+    //Clear other timers
+    _clearTimer(this._internals.systemManagerStatePoller)
+    clearTimeout(this._internals.portRegisterTimeoutTimer)
+
+    //If forced, then just destroy the socket
+    if (forceDisconnect) {
+
+      if (this._internals.socket) {
+        this._internals.socket.removeAllListeners()
+        this._internals.socket.destroy()
+      }
+      this.connection.connected = false
+      this.connection.localAdsPort = null
+      this._internals.socket = null
+
+      this.emit('disconnect')
+
+      return resolve()
+    }
+
+
+    let error = null
+
+    try {
+      await this.unsubscribeAll()
+    } catch (err) {
+      error = new ClientException(this, 'disconnect()', err)
+    }
+
+    try {
+      await _unsubscribeAllInternals.call(this)
+    } catch (err) {
+      error = new ClientException(this, 'disconnect()', err)
+    }
+
+    try {
+      await _unregisterAdsPort.call(this)
+
+      //Done
+      this.connection.connected = false
+      this.connection.localAdsPort = null
+
+      //Socket should be null but check it anyways
+      if (this._internals.socket != null) {
+        this._internals.socket.removeAllListeners()
+        this._internals.socket.destroy() //Just incase
+        this._internals.socket = null
+      }
+
+      debug(`_disconnect(): Connection closed successfully`)
+
+    } catch (err) {
+      //Force socket close
+      if (this._internals.socket) {
+        this._internals.socket.removeAllListeners()
+        this._internals.socket.destroy()
+      }
+
+      this.connection.connected = false
+      this.connection.localAdsPort = null
+      this._internals.socket = null
+
+      error = new ClientException(this, 'disconnect()', err)
+
+      debug(`_disconnect(): Connection closing failed, connection forced to close`)
+    }
+
+    if (error !== null) {
+      error.message = `Disconnected but something failed: ${error.message}`
+      this.emit('disconnect')
+
+      return reject(error)
+    }
+
+    this.emit('disconnect')
+    resolve()
+  })
+}
+
+
+
+/**
+ * Disconnects and reconnects again. Subscribes again to all active subscriptions.
+ * To prevent subscribing, call unsubscribeAll() before reconnecting.
+ *
+ * @param {boolean} [forceDisconnect] - If true, the connection is dropped immediately (default = false)
+ * @param {boolean} [isReconnecting] - If true, _reconnect() call is made during reconnecting
+ *
+ * @returns {Promise<object>} Returns a promise (async function)
+ * - If resolved, reconnecting was successful
+ * - If rejected, reconnecting failed and error info is returned
+ *
+ * @memberof _LibraryInternals
+ */
+function _reconnect(forceDisconnect = false, isReconnecting = false) {
+  return new Promise(async (resolve, reject) => {
+
+    //Clear all cached symbols and data types (might be incorrect)
+    this.metaData.symbols = {}
+    this.metaData.dataTypes = {}
+
+    //Save active subscriptions to memory and delete olds
+    if (this._internals.oldSubscriptions == null) {
+      this._internals.oldSubscriptions = {}
+      Object.assign(this._internals.oldSubscriptions, this._internals.activeSubscriptions)
+
+      debug(`_reconnect(): Total of ${Object.keys(this._internals.activeSubscriptions).length} subcriptions saved for reinitializing`)
+    }
+
+    this._internals.activeSubscriptions = {}
+
+    if (this._internals.socket != null) {
+      try {
+        debug(`_reconnect(): Trying to disconnect`)
+
+        await _disconnect.call(this, forceDisconnect, isReconnecting)
+
+      } catch (err) {
+        //debug(`_reconnect(): Disconnecting failed: %o`, err)
+      }
+    }
+
+    debug(`_reconnect(): Trying to connect`)
+
+    return _connect.call(this, true)
+      .then(res => {
+        debug(`_reconnect(): Connected!`)
+
+        //Reconnected, try to subscribe again 
+        _reInitializeSubscriptions.call(this, this._internals.oldSubscriptions)
+          .then(() => {
+            _console.call(this, `PLC runtime reconnected successfully and all subscriptions were restored!`)
+
+            debug(`_reconnect(): Connection and subscriptions reinitialized. Connection is back.`)
+          })
+          .catch(err => {
+            _console.call(this, `PLC runtime reconnected successfully but not all subscriptions were restored. Error info: ${err}`)
+
+            debug(`_reconnect(): Connection and some subscriptions reinitialized. Connection is back.`)
+          })
+        
+        this.emit('reconnect')
+
+        resolve(res)
+      })
+      .catch(err => {
+        debug(`_reconnect(): Connecting failed`)
+        reject(err)
+      })
+  })
+}
+
+
 /**
  * Registers a new ADS port from used AMS router
  * 
@@ -3677,8 +3768,8 @@ function _unregisterAdsPort() {
   return new Promise(async (resolve, reject) => {
     debugD(`_unregisterAdsPort(): Unregister ads port ${this.connection.localAdsPort} from ${this.settings.routerAddress}:${this.settings.routerTcpPort}`)
 
-    //If we have manually given ADS port, we only need to close the connection manually
-    if (this.settings.localAdsPort) {
+    //If we have manually given AmsNetId and ADS port, we only need to close the connection manually
+    if (this.settings.localAmsNetId && this.settings.localAdsPort) {
       debug(`_unregisterAdsPort(): Local AmsNetId and ADS port manually given so no need to unregister`)
 
 
@@ -3829,8 +3920,7 @@ async function _onSocketError(err) {
  */
 async function _onConnectionLost(socketFailure = false) {
   //Clear timers
-  clearTimeout(this._internals.systemManagerStatePoller)
-  clearTimeout(this._internals.reconnectionTimer)
+  _clearTimer(this._internals.systemManagerStatePoller)
 
   debug(`_onConnectionLost(): Connection was lost. Socket failure: ${socketFailure}`)
 
@@ -3851,53 +3941,70 @@ async function _onConnectionLost(socketFailure = false) {
 
   _console.call(this, 'WARNING: Connection was lost. Trying to reconnect...')
 
+  const tryToReconnect = async (firstTime, timerId) => {
 
-  //Clear all cached symbols and data types (might be incorrect)
-  this.metaData.symbols = {}
-  this.metaData.dataTypes = {}
+    //If the timer has changed, quit here
+    if (this._internals.reconnectionTimer.id !== timerId) {
+      return
+    }
 
-  //Save active subscriptions to memory and delete olds
-  if (this._internals.oldSubscriptions == null) {
-    this._internals.oldSubscriptions = {}
-    Object.assign(this._internals.oldSubscriptions, this._internals.activeSubscriptions)
+    //Try to reconnect
+    _reconnect.call(this, socketFailure, true)
+      .then(res => {
+        
+        //Success -> remove timer
+        _clearTimer(this._internals.reconnectionTimer)
 
-    debugD(`_onConnectionLost(): Total of ${Object.keys(this._internals.activeSubscriptions).length} subcriptions saved for reinitializing`)
+      })
+      .catch(err => {
+        //Reconnecting failed
+        if (firstTime)
+          _console.call(this, `WARNING: Reconnecting failed. Keeping trying in the background every ${this.settings.reconnectInterval} ms...`)
+        
+        //If this is still a valid timer, start over again
+        if (this._internals.reconnectionTimer.id === timerId) {
+          //Creating a new timer with the same id
+          this._internals.reconnectionTimer.timer = setTimeout(
+            () => tryToReconnect(false, timerId),
+            this.settings.reconnectInterval
+          )
+        } else {
+          debugD(`_onConnectionLost(): Timer is no more valid, quiting here`)
+        }
+      })
   }
 
-  this._internals.activeSubscriptions = {}
+  //Clearing old timer if there is one + increasing timer id
+  _clearTimer(this._internals.reconnectionTimer)
 
+  //Starting poller timer
+  this._internals.reconnectionTimer.timer = setTimeout(
+    () => tryToReconnect(true, this._internals.reconnectionTimer.id),
+    this.settings.reconnectInterval
+  )
+}
 
-  const tryToReconnect = async (firstTime) => {
-    clearTimeout(this._internals.reconnectionTimer)
 
-    this.reconnect(socketFailure)
-      .then(res => {
 
-        _reInitializeSubscriptions.call(this, this._internals.oldSubscriptions)
-          .then(() => {
-            _console.call(this, `PLC runtime reconnected successfully and all subscriptions were restored!`)
 
-            debug(`_onConnectionLost(): Connection and subscriptions reinitialized. Connection is back.`)
-          })
-          .catch(err => {
-            _console.call(this, `PLC runtime reconnected successfully but not all subscriptions were restored. Error info: ${err}`)
 
-            debug(`_onConnectionLost(): Connection and some subscriptions reinitialized. Connection is back.`)
-          })
-      })
-      .catch(err => {
-        if (firstTime)
-          _console.call(this, `WARNING: Reconnecting failed. Keeping trying in the background every ${this.settings.reconnectInterval} ms...`)
-
-        //Clear timer again just incase
-        clearTimeout(this._internals.reconnectionTimer)
-        this._internals.reconnectionTimer = setTimeout(() => tryToReconnect(false), this.settings.reconnectInterval)
-      })
-  }
+/**
+ * Clears given object timer if it's available
+ * and increases the id
+ * 
+ * @param {object} timerObject Timer object {id, timer}
+ * 
+ * @memberof _LibraryInternals
+ */
+function _clearTimer(timerObject) {
+  //Clearing timer
+  clearTimeout(timerObject.timer)
+  timerObject.timer = null
 
-  clearTimeout(this._internals.reconnectionTimer)
-  this._internals.reconnectionTimer = setTimeout(() => tryToReconnect(true), this.settings.reconnectInterval)
+  //Increasing timer id
+  timerObject.id = timerObject.id < Number.MAX_SAFE_INTEGER ? timerObject.id + 1 : 0;
 }
+  
 
 
 
@@ -4167,10 +4274,15 @@ async function _onSymbolVersionChanged(data) {
  * @memberof _LibraryInternals
  */
 function _systemManagerStatePoller() {
-  clearTimeout(this._internals.systemManagerStatePoller)
 
-  const poller = async () => {
-    let startAgain = true, oldState = this.metaData.systemManagerState
+  const poller = async (timerId) => {
+    let startAgain = true
+    let oldState = this.metaData.systemManagerState
+
+    //If the timer has changed, quit here
+    if (this._internals.systemManagerStatePoller.id !== timerId){
+      return
+    }
 
     try {
       await this.readSystemManagerState()
@@ -4191,6 +4303,7 @@ function _systemManagerStatePoller() {
           _onConnectionLost.call(this)
         }
       }
+
     } catch (err) {
       debug(`_systemManagerStatePoller(): Reading system manager state failed: %o`, err)
 
@@ -4207,11 +4320,26 @@ function _systemManagerStatePoller() {
       }
     }
 
-    if (startAgain)
-      this._internals.systemManagerStatePoller = setTimeout(poller, this.settings.checkStateInterval)
+    //Try again if required AND this is still the valid timer
+    if (startAgain && this._internals.systemManagerStatePoller.id === timerId) {
+      //Creating a new timer with the same id
+      this._internals.systemManagerStatePoller.timer = setTimeout(
+        () => poller(timerId),
+        this.settings.checkStateInterval
+      )
+    }
   }
 
-  this._internals.systemManagerStatePoller = setTimeout(poller, this.settings.checkStateInterval)
+
+  //Clearing old timer if there is one + increasing timer id
+  _clearTimer(this._internals.systemManagerStatePoller)
+
+  //Starting poller timer
+  this._internals.systemManagerStatePoller.timer = setTimeout(
+    () => poller(this._internals.systemManagerStatePoller.id),
+    this.settings.checkStateInterval
+  )
+    
 }
 
 
@@ -4286,7 +4414,7 @@ async function _onRouterStateChanged(data) {
   //If we have a local connection, connection needs to be reinitialized
   if (this.connection.isLocal === true) {
     //We should stop polling system manager, it will be reinitialized later
-    clearTimeout(this._internals.systemManagerStatePoller)
+    _clearTimer(this._internals.systemManagerStatePoller)
 
     debug(`_onRouterStateChanged(): Local loopback connection active, monitoring router state`)