@things-factory/integration-modbus 8.0.0 → 9.0.0-beta.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/integration-modbus",
-  "version": "8.0.0",
+  "version": "9.0.0-beta.3",
   "main": "dist-server/index.js",
   "browser": "client/index.js",
   "things-factory": true,
@@ -23,11 +23,11 @@
     "clean": "npm run clean:server"
   },
   "dependencies": {
-    "@things-factory/integration-base": "^8.0.0",
+    "@things-factory/integration-base": "^9.0.0-beta.3",
     "jsmodbus": "^4.0.2",
     "p-queue": "^6.4.0",
     "promise-socket": "^7.0.0",
     "serialport": "^9.0.2"
   },
-  "gitHead": "07ef27d272dd9a067a9648ac7013748510556a18"
+  "gitHead": "1d7e0dd4c88f3c3f3bd311c00e4b1d1542d53634"
 }

package/server/engine/connector/index.ts

@@ -1,2 +0,0 @@
-import './modbus-tcp-server'
-import './modbus-tcp'

package/server/engine/connector/modbus-tcp-server.ts

@@ -1,50 +0,0 @@
-import { ConnectionManager, Connector, Connection } from '@things-factory/integration-base'
-import net from 'net'
-import * as modbus from 'jsmodbus'
-
-export class ModbusTCPServer implements Connector {
-  async ready(connectionConfigs) {
-    await Promise.all(connectionConfigs.map(this.connect))
-
-    ConnectionManager.logger.info('modbus-tcp-servers are ready')
-  }
-
-  async connect(config) {
-    var [host = '0.0.0.0', port = 502] = config.endpoint.split(':')
-
-    const netServer = new net.Server()
-
-    const server = new modbus.server.TCP(netServer)
-
-    netServer.on('error', console.error)
-    netServer.listen(port, host)
-
-    /* default client connection */
-    const clientSocket = new net.Socket()
-    const client = new modbus.client.TCP(clientSocket)
-    clientSocket.on('error', console.error)
-    clientSocket.connect({ host: 'localhost', port })
-
-    client['__server__'] = server
-
-    ConnectionManager.addConnectionInstance(config, client)
-
-    ConnectionManager.logger.info(`modbus-tcp-server connection(${config.name}:${config.endpoint}) is connected`)
-  }
-
-  async disconnect(connection: Connection) {
-    var client = ConnectionManager.removeConnectionInstance(connection)
-    var server = client['__server__']
-
-    client.socket.end()
-    server && server._server.close()
-
-    ConnectionManager.logger.info(`modbus-tcp-server connection(${connection.name}) is disconnected`)
-  }
-
-  get parameterSpec() {
-    return []
-  }
-}
-
-ConnectionManager.registerConnector('modbus-tcp-server', new ModbusTCPServer())

package/server/engine/connector/modbus-tcp.ts

@@ -1,173 +0,0 @@
-import * as modbus from 'jsmodbus'
-import { Socket } from 'net'
-import PQueue from 'p-queue'
-import PromiseSocket from 'promise-socket'
-
-import { Connection, ConnectionManager, Connector } from '@things-factory/integration-base'
-import { sleep } from '@things-factory/utils'
-
-const debug = require('debug')('things-factory:modbus-tcp-connector')
-
-export class ModbusTCPConnector implements Connector {
-  async ready(connectionConfigs) {
-    await Promise.all(connectionConfigs.map(this.connect.bind(this)))
-
-    ConnectionManager.logger.info('modbus-tcp connections are ready')
-  }
-
-  checkConnectionInstance(domain, connectionName): boolean {
-    try {
-      const connection = ConnectionManager.getConnectionInstanceByName(domain, connectionName)
-
-      return !!(connection?.client?.connectionState !== 'online')
-    } catch (e) {
-      return false
-    }
-  }
-
-  async connect(connection) {
-    var [host, port = 502] = connection.endpoint.split(':')
-    var {
-      params: { keepalive = true }
-    } = connection
-
-    try {
-      /*
-        try to keep connecting if keepalive is true
-      */
-      var clientIdx = 1
-      var connected: boolean = false
-      var looped: boolean = true
-      while (true) {
-        var clientSocket = new Socket()
-        clientSocket = new Socket()
-        var promiseSocket = new PromiseSocket(clientSocket)
-
-        var client = new modbus.client.TCP(clientSocket, clientIdx++, 10000)
-
-        clientSocket.on('error', async ex => {
-          debug(ex)
-          ConnectionManager.logger.error(`modbus tcp connection error: ${ex}`)
-        })
-
-        clientSocket.on('close', async () => {
-          debug(`modbus tcp connection closed`)
-          if (keepalive && !looped) {
-            await this.disconnect(connection)
-            await this.connect(connection)
-          }
-        })
-
-        debug(`connecting to ${connection.endpoint}...`)
-
-        looped = true
-        await promiseSocket
-          .connect(port, host)
-          .then(() => {
-            connected = true
-          })
-          .catch(ex => {
-            promiseSocket && promiseSocket.destroy()
-          })
-
-        // if the current connections have the connection with the same name, the current try should be stopped.
-        if (!keepalive || connected) {
-          looped = false
-          break
-        }
-
-        await sleep(1000)
-      }
-
-      var queue = new PQueue({ concurrency: 1 })
-      ConnectionManager.addConnectionInstance(connection, {
-        readModBus: async function (objectType, address, quantity, { logger }) {
-          return await queue.add(async () => {
-            var response
-
-            switch (objectType) {
-              case 'descrete input':
-                response = await client.readDiscreteInputs(address, quantity)
-                break
-              case 'input register':
-                response = await client.readInputRegisters(address, quantity)
-                break
-              case 'holding register':
-                response = await client.readHoldingRegisters(address, quantity)
-                break
-              default:
-                response = await client.readCoils(address, quantity)
-            }
-
-            var data = response && response.response._body.valuesAsArray.slice(0, quantity)
-            logger.info(`${JSON.stringify(data)}`)
-            return {
-              data
-            }
-          })
-        },
-        writeSingleModBus: async function (objectType, address, value, { logger }) {
-          return await queue.add(async () => {
-            var response
-
-            switch (objectType) {
-              case 'holding register':
-                await client.writeSingleRegister(address, parseInt(value))
-                response = await client.readHoldingRegisters(address, 1)
-                break
-              default:
-                await client.writeSingleCoil(address, !!Number(value))
-                response = await client.readCoils(address, 1)
-            }
-
-            var data = response && response.response._body.valuesAsArray[0]
-            logger.info(data)
-            return {
-              data
-            }
-          })
-        },
-        close: function () {
-          queue.clear()
-          keepalive = false
-          promiseSocket.destroy()
-        }
-      })
-
-      ConnectionManager.logger.info(`modbus-tcp connection(${connection.name}:${connection.endpoint}) is connected`)
-    } catch (ex) {
-      ConnectionManager.logger.info(`modbus-tcp connection(${connection.name}:${connection.endpoint}) failed to connect`)
-      throw ex
-    }
-  }
-
-  async disconnect(connection: Connection) {
-    var { close } = ConnectionManager.removeConnectionInstance(connection)
-    close()
-
-    ConnectionManager.logger.info(`modbus-tcp connection(${connection.name}) is disconnected`)
-  }
-
-  get parameterSpec() {
-    return [
-      {
-        type: 'checkbox',
-        name: 'keepalive',
-        label: 'keepalive',
-        property: {
-          value: 'checked'
-        }
-      }
-    ]
-  }
-
-  get taskPrefixes() {
-    return ['modbus']
-  }
-
-  get help() {
-    return 'integration/connector/modbus-tcp'
-  }
-}
-
-ConnectionManager.registerConnector('modbus-tcp', new ModbusTCPConnector())

package/server/engine/index.ts

@@ -1,2 +0,0 @@
-import './connector'
-import './task'

package/server/engine/task/index.ts

@@ -1,2 +0,0 @@
-import './modbus-read'
-import './modbus-write-single'

package/server/engine/task/modbus-read.ts

@@ -1,58 +0,0 @@
-import { access } from '@things-factory/utils'
-import { ConnectionManager, TaskRegistry } from '@things-factory/integration-base'
-
-const debug = require('debug')('things-factory:modbus-read')
-
-async function modbusRead(step, { logger, domain, data }) {
-  var {
-    connection,
-    params: { objectType = 'coil', address, quantity = 1, accessorAddress }
-  } = step
-
-  var connectionInstance = ConnectionManager.getConnectionInstanceByName(domain, connection)
-  if (!connectionInstance) {
-    debug(`no connection : ${connection}`)
-    throw new Error(`no connection : ${connection}`)
-  }
-
-  address = accessorAddress ? access(accessorAddress, data) : address
-  if (isNaN(address)) {
-    debug(`invalid number address : ${address}`)
-    throw new Error(`invalid number address : ${address}`)
-  }
-
-  var { readModBus } = connectionInstance
-  var content = await readModBus(objectType, address, quantity, { logger })
-  debug(`result : ${JSON.stringify(content)}`)
-  return content
-}
-
-modbusRead.parameterSpec = [
-  {
-    type: 'select',
-    name: 'objectType',
-    label: 'object-type',
-    property: {
-      options: ['', 'coil', 'descrete input', 'input register', 'holding register']
-    }
-  },
-  {
-    type: 'number',
-    name: 'address',
-    label: 'address'
-  },
-  {
-    type: 'number',
-    name: 'quantity',
-    label: 'quantity'
-  },
-  {
-    type: 'scenario-step-input',
-    name: 'accessorAddress',
-    label: 'accessor-address'
-  }
-]
-
-modbusRead.help = 'integration/task/modbus-read'
-
-TaskRegistry.registerTaskHandler('modbus-read', modbusRead)

package/server/engine/task/modbus-write-single.ts

@@ -1,68 +0,0 @@
-import { access } from '@things-factory/utils'
-import { ConnectionManager, TaskRegistry } from '@things-factory/integration-base'
-
-const debug = require('debug')('things-factory:modbus-write-single')
-
-async function modbusWriteSingle(step, { logger, domain, data }) {
-  var {
-    connection,
-    params: { objectType = 'coil', accessorAddress, address, accessor, value }
-  } = step
-
-  var connectionInstance = ConnectionManager.getConnectionInstanceByName(domain, connection)
-  if (!connectionInstance) {
-    debug(`no connection : ${connection}`)
-    throw new Error(`no connection : ${connection}`)
-  }
-
-  address = accessorAddress ? access(accessorAddress, data) : address
-  if (isNaN(address)) {
-    debug(`invalid number address : ${address}`)
-    throw new Error(`invalid number address : ${address}`)
-  }
-
-  // determine accessor or value as a input value value
-  value = accessor ? access(accessor, data) : value
-  if (isNaN(value)) {
-    throw new Error(`invalid number value : ${value}`)
-  }
-
-  var { writeSingleModBus } = connectionInstance
-  var content = await writeSingleModBus(objectType, address, value, { logger })
-  return content
-}
-
-modbusWriteSingle.parameterSpec = [
-  {
-    type: 'select',
-    name: 'objectType',
-    label: 'object-type',
-    property: {
-      options: ['', 'coil', 'holding register']
-    }
-  },
-  {
-    type: 'number',
-    name: 'address',
-    label: 'address'
-  },
-  {
-    type: 'number',
-    name: 'value',
-    label: 'value'
-  },
-  {
-    type: 'scenario-step-input',
-    name: 'accessor',
-    label: 'accessor-value'
-  },
-  {
-    type: 'scenario-step-input',
-    name: 'accessorAddress',
-    label: 'accessor-address'
-  }
-]
-
-modbusWriteSingle.help = 'integration/task/modbus-write-single'
-
-TaskRegistry.registerTaskHandler('modbus-write-single', modbusWriteSingle)

package/server/index.ts

@@ -1 +0,0 @@
-import './engine'