Return to minimal logger interface

.gitignore

@@ -1 +1,3 @@
 .idea/**
+
+dist/

.goreleaser.yaml

@@ -0,0 +1,40 @@
+builds:
+  - main: ./cmd/modbus-cli
+    env:
+      - CGO_ENABLED=0
+    goos:
+      - linux
+      - windows
+      - darwin
+    goarch:
+    - amd64
+    - arm64
+    - arm
+    goarm:
+      - 7
+    # Ignore ARM32 build for both macOS and Windows
+    ignore:
+      - goos: darwin
+        goarch: arm
+      - goos: windows
+        goarch: arm
+archives:
+  - id: modbus-cli
+    name_template: >-
+      modbus-cli_
+      {{- if eq .Os "darwin" }}mac
+      {{- else }}{{ .Os }}{{ end }}_{{ .Arch }}
+    format_overrides:
+    - goos: windows
+      format: zip
+checksum:
+  name_template: 'checksums.txt'
+snapshot:
+  name_template: "{{ incpatch .Version }}-next"
+changelog:
+  sort: asc
+  filters:
+    exclude:
+      - '^docs:'
+      - '^test:'
+

Makefile

@@ -1,6 +1,6 @@
 GO_FILES := $(shell find . -type f -name "*.go")
 GO_BUILD := CGO_ENABLED=0 go build -ldflags "-w -s"
-GO_TOOLS := registry.gridx.de/gridx/base-images:modbus-dev-1.15.latest
+GO_TOOLS := public.ecr.aws/gridx/base-images:modbus-dev-1.21.latest
 DOCKER_RUN := docker run --init --rm -v $$PWD:/go/src/github.com/grid-x/modbus -w /go/src/github.com/grid-x/modbus
 GO_RUN := ${DOCKER_RUN} ${GO_TOOLS} bash -c
 
@@ -13,6 +13,7 @@ test:
 	diagslave -m tcp -p 5020 & diagslave -m enc -p 5021 & go test -run TCP -v $(shell glide nv)
 	socat -d -d pty,raw,echo=0 pty,raw,echo=0 & diagslave -m rtu /dev/pts/1 & go test -run RTU -v $(shell glide nv)
 	socat -d -d pty,raw,echo=0 pty,raw,echo=0 & diagslave -m ascii /dev/pts/3 & go test -run ASCII -v $(shell glide nv)
+	go test -v -count=1 github.com/grid-x/modbus/cmd/modbus-cli 
 
 .PHONY: lint
 lint:
@@ -22,6 +23,9 @@ lint:
 build:
 	go build
 
+release:
+	goreleaser release --skip-publish --skip-validate --clean
+
 ci_test:
 	${GO_RUN} "make test"
 
@@ -30,3 +34,6 @@ ci_lint:
 
 ci_build:
 	${GO_RUN} "make build"
+
+ci_release:
+	${GO_RUN} "goreleaser release --skip-publish --skip-validate --rm-dist"

README.md

@@ -1,31 +1,29 @@
-go modbus
-=========
+# go modbus
 Fault-tolerant, fail-fast implementation of Modbus protocol in Go.
 
-Supported functions
--------------------
+# Supported functions
+
 Bit access:
-*   Read Discrete Inputs
-*   Read Coils
-*   Write Single Coil
-*   Write Multiple Coils
+- Read Discrete Inputs
+- Read Coils
+- Write Single Coil
+- Write Multiple Coils
 
 16-bit access:
-*   Read Input Registers
-*   Read Holding Registers
-*   Write Single Register
-*   Write Multiple Registers
-*   Read/Write Multiple Registers
-*   Mask Write Register
-*   Read FIFO Queue
-
-Supported formats
------------------
-*   TCP
-*   Serial (RTU, ASCII)
-
-Usage
------
+- Read Input Registers
+- Read Holding Registers
+- Write Single Register
+- Write Multiple Registers
+- Read/Write Multiple Registers
+- Mask Write Register
+- Read FIFO Queue
+
+# Supported formats
+- TCP
+- Serial (RTU, ASCII)
+- UDP
+
+# Usage
 Basic usage:
 ```go
 // Modbus TCP
@@ -73,6 +71,73 @@ client := modbus.NewClient(handler)
 results, err := client.ReadDiscreteInputs(15, 2)
 ```
 
-References
-----------
--   [Modbus Specifications and Implementation Guides](http://www.modbus.org/specs.php)
+# Modbus-CLI
+
+We offer a CLI tool to read/write registers.
+
+## Usage
+
+For simplicity, the following examples are all using Modbus TCP.
+For Modbus RTU, replace the address field and use the `rtu-` arguments in order to use different baudrates, databits, etc.
+```sh
+./modbus-cli -address=rtu:///dev/ttyUSB0 -rtu-baudrate=57600 -rtu-stopbits=2 -rtu-parity=N -rtu-databits=8 ...
+```
+
+For Modbus UDP, replace the address field with a UDP address.
+```sh
+./modbus-cli --address=udp://127.0.0.1:502 ...
+```
+
+### Reading Registers
+
+Read 1 register and get raw result
+```sh
+./modbus-cli -address=tcp://127.0.0.1:502 -quantity=1 -type-parse=raw -register=42
+```
+
+Read 1 register and decode result as uint16
+```sh
+./modbus-cli -address=tcp://127.0.0.1:502 -quantity=1 -type-parse=uint16 -register=42
+```
+
+Read 1 register and get all possible decoded results
+```sh
+./modbus-cli -address=tcp://127.0.0.1:502 -quantity=1 -type-parse=all -register=42
+```
+
+Read 2 registers and decode result as uint32
+```sh
+./modbus-cli -address=tcp://127.0.0.1:502 -quantity=2 -type-parse=uint32 -register=42
+```
+
+Read 2 registers and get all possible decoded results
+```sh
+./modbus-cli -address=tcp://127.0.0.1:502 -quantity=2 -type-parse=all -register=42
+```
+
+Reading multiple registers is only possible in the raw format
+```sh
+./modbus-cli -address=tcp://127.0.0.1:502 -quantity=16 -type-parse=raw -register=42
+```
+
+### Writing Registers
+
+Write 1 register 
+```sh
+./modbus-cli -address=tcp://127.0.0.1:502 -fn-code=0x06 -type-exec=uint16 -register=42 -write-value=7
+```
+
+Write 2 registers
+```sh
+./modbus-cli -address=tcp://127.0.0.1:502 -fn-code=0x10 -type-exec=uint32 -register=42 -write-value=7
+```
+
+## Release
+
+To release the Modbus-CLI tool, run either `make release` if you have installed `goreleaser` or `make ci_release`.
+The generated files can be found in the directory in the `dist` directory.
+
+Take the `.tar.gz` and `.zip` files and create a new GitHub release.
+
+# References
+- [Modbus Specifications and Implementation Guides](http://www.modbus.org/specs.php)

ascii_over_tcp_client.go

@@ -35,16 +35,16 @@ type asciiTCPTransporter struct {
 }
 
 func (mb *asciiTCPTransporter) Send(aduRequest []byte) (aduResponse []byte, err error) {
-	mb.tcpTransporter.mu.Lock()
-	defer mb.tcpTransporter.mu.Unlock()
+	mb.mu.Lock()
+	defer mb.mu.Unlock()
 
 	// Make sure port is connected
-	if err = mb.tcpTransporter.connect(); err != nil {
+	if err = mb.connect(); err != nil {
 		return
 	}
 	// Start the timer to close when idle
-	mb.tcpTransporter.lastActivity = time.Now()
-	mb.tcpTransporter.startCloseTimer()
+	mb.lastActivity = time.Now()
+	mb.startCloseTimer()
 	// Set write and read timeout
 	var timeout time.Time
 	if mb.Timeout > 0 {
@@ -55,14 +55,13 @@ func (mb *asciiTCPTransporter) Send(aduRequest []byte) (aduResponse []byte, err
 	}
 
 	// Send the request
-	mb.tcpTransporter.logf("modbus: send %q\n", aduRequest)
+	mb.logf("modbus: send %q\n", aduRequest)
 	if _, err = mb.conn.Write(aduRequest); err != nil {
 		return
 	}
 	// Get the response
-	var n int
+	var n, length int
 	var data [asciiMaxSize]byte
-	length := 0
 	for {
 		if n, err = mb.conn.Read(data[length:]); err != nil {
 			return
@@ -79,6 +78,6 @@ func (mb *asciiTCPTransporter) Send(aduRequest []byte) (aduResponse []byte, err
 		}
 	}
 	aduResponse = data[:length]
-	mb.tcpTransporter.logf("modbus: recv %q\n", aduResponse)
+	mb.logf("modbus: recv %q\n", aduResponse)
 	return
 }

asciiclient.go

@@ -34,7 +34,6 @@ func NewASCIIClientHandler(address string) *ASCIIClientHandler {
 	handler.Address = address
 	handler.Timeout = serialTimeout
 	handler.IdleTimeout = serialIdleTimeout
-	handler.serialPort.Logger = handler // expose the logger
 	return handler
 }
 
@@ -54,13 +53,14 @@ func (mb *asciiPackager) SetSlave(slaveID byte) {
 	mb.SlaveID = slaveID
 }
 
-// Encode encodes PDU in a ASCII frame:
-//  Start           : 1 char
-//  Address         : 2 chars
-//  Function        : 2 chars
-//  Data            : 0 up to 2x252 chars
-//  LRC             : 2 chars
-//  End             : 2 chars
+// Encode encodes PDU in an ASCII frame:
+//
+//	Start           : 1 char
+//	Address         : 2 chars
+//	Function        : 2 chars
+//	Data            : 0 up to 2x252 chars
+//	LRC             : 2 chars
+//	End             : 2 chars
 func (mb *asciiPackager) Encode(pdu *ProtocolDataUnit) (adu []byte, err error) {
 	var buf bytes.Buffer
 
@@ -166,36 +166,28 @@ func (mb *asciiPackager) Decode(adu []byte) (pdu *ProtocolDataUnit, err error) {
 // asciiSerialTransporter implements Transporter interface.
 type asciiSerialTransporter struct {
 	serialPort
-	Logger logger
-}
-
-func (mb *asciiSerialTransporter) Printf(format string, v ...interface{}) {
-	if mb.Logger != nil {
-		mb.Logger.Printf(format, v...)
-	}
 }
 
 func (mb *asciiSerialTransporter) Send(aduRequest []byte) (aduResponse []byte, err error) {
-	mb.serialPort.mu.Lock()
-	defer mb.serialPort.mu.Unlock()
+	mb.mu.Lock()
+	defer mb.mu.Unlock()
 
 	// Make sure port is connected
-	if err = mb.serialPort.connect(); err != nil {
+	if err = mb.connect(); err != nil {
 		return
 	}
 	// Start the timer to close when idle
-	mb.serialPort.lastActivity = time.Now()
-	mb.serialPort.startCloseTimer()
+	mb.lastActivity = time.Now()
+	mb.startCloseTimer()
 
 	// Send the request
-	mb.serialPort.logf("modbus: send % x\n", aduRequest)
+	mb.logf("modbus: send % x\n", aduRequest)
 	if _, err = mb.port.Write(aduRequest); err != nil {
 		return
 	}
 	// Get the response
-	var n int
+	var n, length int
 	var data [asciiMaxSize]byte
-	length := 0
 	for {
 		if n, err = mb.port.Read(data[length:]); err != nil {
 			return
@@ -212,7 +204,7 @@ func (mb *asciiSerialTransporter) Send(aduRequest []byte) (aduResponse []byte, e
 		}
 	}
 	aduResponse = data[:length]
-	mb.serialPort.logf("modbus: recv % x\n", aduResponse)
+	mb.logf("modbus: recv % x\n", aduResponse)
 	return
 }
 
@@ -231,7 +223,7 @@ func writeHex(buf *bytes.Buffer, value []byte) (err error) {
 	return
 }
 
-// readHex decodes hexa string to byte, e.g. "8C" => 0x8C.
+// readHex decodes hex string to byte, e.g. "8C" => 0x8C.
 func readHex(data []byte) (value byte, err error) {
 	var dst [1]byte
 	if _, err = hex.Decode(dst[:], data[0:2]); err != nil {

asciiclient_test.go

@@ -37,7 +37,7 @@ func TestASCIIDecoding(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	if 3 != pdu.FunctionCode {
+	if pdu.FunctionCode != 3 {
 		t.Fatalf("Function code: expected %v, actual %v", 15, pdu.FunctionCode)
 	}
 	expected := []byte{0x13, 0x89, 0, 0x0A}