change ping pong handler and fix blocking channel

fix crash when no bus found in map

.github/workflows/build.yml

@@ -0,0 +1,48 @@
+name: Build Go Binaries
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        goos: [linux, windows]
+        goarch: [amd64, arm, arm64]
+        exclude:
+          - goos: windows
+            goarch: arm
+          - goos: windows
+            goarch: arm64
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Set up Go
+        uses: actions/setup-go@v4
+        with:
+          go-version: '1.24.0'
+
+      - name: Set up Git credentials for private modules
+        run: |
+          git config --global url."https://${{ secrets.GH_PAT }}@github.com/".insteadOf "https://github.com/"
+          echo "GOPRIVATE=github.com/tecamino/*" >> $GITHUB_ENV
+
+      - name: Build binary
+        run: |
+          mkdir -p build
+          if [ "${{ matrix.goos }}" == "windows" ]; then
+            GOOS=${{ matrix.goos }} GOARCH=${{ matrix.goarch }} go build -ldflags="-s -w" -trimpath -o build/tecamino-driver-artNet-${{ matrix.goos }}-${{ matrix.goarch }}.exe main.go
+          else
+            GOOS=${{ matrix.goos }} GOARCH=${{ matrix.goarch }} go build -ldflags="-s -w" -trimpath -o build/tecamino-driver-artNet-${{ matrix.goos }}-${{ matrix.goarch }} main.go
+          fi
+
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: binaries-${{ matrix.goos }}-${{ matrix.goarch }}
+          path: build/

.gitignore

@@ -0,0 +1,5 @@
+.DS_Store
+*.cfg
+*.log
+artNetDriver-arm64
+tecamino-driver-artNet-linux-arm64

README.md

@@ -1,2 +1,45 @@
-# ArtNet Driver
+# 🎛️ ArtNet Driver
-Tecamino artNet driver DMX-Communication
+
+**Tecamino ArtNet Driver** — A lightweight driver for DMX communication using the ArtNet protocol over TCP/IP.
+
+This tool allows you to send DMX values to an ArtNet-compatible device, enabling remote lighting control and stage automation.
+
+---
+
+## 🚀 Features
+
+- 🔌 Sends DMX data over the ArtNet protocol (UDP)
+- 📁 Configurable working and config directories
+- 🐞 Optional debug logging for development and troubleshooting
+- ⚙️ Easy to run with CLI flags
+
+---
+
+## 🧰 Command Line Arguments
+
+| Flag              | Default     | Description                          |
+|-------------------|-------------|--------------------------------------|
+| `--port`          | `8110`      | Port on which the server listens     |
+| `--cfg`           | `./cfg`     | Path to the configuration directory  |
+| `--workingDirectory` | `"."`    | Working directory for runtime files  |
+| `--debug`         | `false`     | Enable verbose debug logging         |
+
+---
+
+## 🏁 Getting Started
+
+### 🔧 Run the Driver
+
+```bash
+go run main.go --port=8110 --cfg=./cfg --workingDirectory=. --debug=true
+
+```
+### 🔧 Build the App
+
+To compile the Go code into a runnable binary:
+
+#### On Linux or macOS:
+
+```bash
+go build -o artnet-driver
+```

auth/auth.go

@@ -0,0 +1,23 @@
+package auth
+
+import (
+	"errors"
+
+	"github.com/gin-gonic/gin"
+)
+
+func GetIDFromAuth(c *gin.Context) (string, error) {
+	auth := c.GetHeader("Authorization")
+	if len(auth) > 7 && auth[:7] == "Bearer " {
+		return auth[7:], nil
+	}
+	return "", errors.New("authorization token missing")
+}
+
+func GetIDFromQuery(c *gin.Context) (string, error) {
+	auth, exists := c.GetQuery("id")
+	if !exists {
+		return "", errors.New("id missing")
+	}
+	return auth, nil
+}

cfg/cfg.go

@@ -0,0 +1,62 @@
+package cfg
+
+import (
+	"os"
+	"path"
+
+	"gopkg.in/yaml.v3"
+)
+
+type Cfg struct {
+	Name string
+	Dir  string
+}
+
+// Initializes new config handler
+// dir is config directory from working dir on
+// name is filename, file extention is automatically added '.cfg'
+// file is in yaml format
+// if file exists it will read its content in to the driver
+func NewCfgHandler(dir, name string) *Cfg {
+	return &Cfg{
+		Dir:  dir,
+		Name: name,
+	}
+}
+
+func (c *Cfg) SaveCfg(data any) error {
+	if _, err := os.Stat(c.Dir); err != nil {
+		if err := os.MkdirAll(c.Dir, 0666); err != nil {
+			return err
+		}
+	}
+	f, err := os.Create(path.Join(c.Dir, c.Name) + ".cfg")
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	encoder := yaml.NewEncoder(f)
+	encoder.SetIndent(2)
+
+	if err := encoder.Encode(data); err != nil {
+		return err
+	}
+	encoder.Close()
+
+	return nil
+}
+
+func (c *Cfg) LoadCfg(data any) error {
+	p := path.Join(c.Dir, c.Name) + ".cfg"
+	if _, err := os.Stat(p); err != nil {
+		return nil
+	}
+
+	b, err := os.ReadFile(p)
+	if err != nil {
+		return err
+	}
+
+	return yaml.Unmarshal(b, data)
+}

driver/artNet.go

@@ -1,29 +1,149 @@
 package driver
 
-import "artNet/models"
+import (
+	"artNet/cfg"
+	"artNet/models"
+	ws "artNet/websocket"
+	"encoding/json"
+	"fmt"
+	"path"
+
+	json_data "github.com/tecamino/tecamino-json_data"
+	"github.com/tecamino/tecamino-logger/logging"
+)
 
 type ArtNetDriver struct {
-	Bus []*models.Bus
+	Name          string                 `yaml:"driver" json:"driver"`
+	Buses         map[string]*models.Bus `yaml:"buses,omitempty" json:"buses,omitempty"`
+	cfgHandler    *cfg.Cfg               `yaml:"-" json:"-"`
+	Subscriptions models.Subscriptions   `yaml:"-" json:"-"`
+	Log           *logging.Logger        `yaml:"-" json:"-"`
 }
 
 // initialize new Art-Net driver
-func NewDriver() *ArtNetDriver {
+// cfgDir config directory
-	return &ArtNetDriver{}
+// name name of driver
+func NewDriver(cfgDir, name string, debug bool) (*ArtNetDriver, error) {
+	if cfgDir == "" {
+		cfgDir = "./cfg"
+	}
+
+	logger, err := logging.NewLogger(path.Join(cfgDir, name+".log"), &logging.Config{
+		MaxSize:     1,
+		MaxBackup:   3,
+		MaxAge:      28,
+		Debug:       debug,
+		TerminalOut: true,
+	})
+	if err != nil {
+		panic(err)
+	}
+
+	logger.Debug("artNet.NewDriver", "initialize "+name+" driver")
+	d := ArtNetDriver{
+		Name:       name,
+		Buses:      make(map[string]*models.Bus),
+		cfgHandler: cfg.NewCfgHandler(cfgDir, name),
+		Log:        logger,
+	}
+
+	if err := d.LoadCfg(); err != nil {
+		logger.Error("artNet.NewDriver.LoadCfg", "error load driver configuration: "+err.Error())
+		return nil, err
+	}
+	return &d, nil
 }
 
-// adds new Art-Net interface to driver port 0 = 6454 (default art-net)
+// loads driver config
-func (d *ArtNetDriver) NewInterface(ip string, port int) *models.Bus {
+func (d *ArtNetDriver) LoadCfg() error {
-	i := models.NewBus(ip, port)
+	d.Log.Debug("artNet.LoadCfg", "load driver configuration")
-	d.Bus = append(d.Bus, i)
+	if err := d.cfgHandler.LoadCfg(d); err != nil {
-	return i
+		return err
+	}
+
+	for name, b := range d.Buses {
+		d.NewBus(name, b.Ip, *b.Port)
+	}
+	return nil
 }
 
-// dmxData[46] = byte(255) // Channel 1: Red
+// adds new Art-Net bus/interface to driver port 0 = 6454 (default art-net)
-// dmxData[47] = byte(255) // Channel 2: Green
+func (d *ArtNetDriver) NewBus(name, ip string, port int) *models.Bus {
-// dmxData[48] = byte(255) // Channel 3: Blue
+	b := models.NewBus(name, ip, port)
-// dmxData[49] = byte(255) // Channel 4: White
+	d.Buses[name] = b
-// dmxData[50] = byte(255) // Channel 5: Amber
+	return b
-// dmxData[51] = byte(255) // Channel 6: UV Lila
+}
-// dmxData[52] = byte(255) // Channel 7: 0-9  10-255 strobo
+
-// dmxData[53] = byte(255) // Channel 8: 0-5 stop 6-127 static position 128-255 Motorgeschwindigkeit
+func (d *ArtNetDriver) SetValue(bus string, address uint, value uint8) error {
-// dmxData[54] = byte(255) // Channel 9: 0-50 coincitence 51 -100 two color 101-150 all color
+	if _, ok := d.Buses[bus]; !ok {
+		return fmt.Errorf("no bus '%s' found", bus)
+	}
+	if d.Buses[bus].Data == nil {
+		return fmt.Errorf("no dmx data on bus '%s' found", bus)
+	}
+	d.Buses[bus].Data.SetValue(address, value)
+	return nil
+}
+
+// connect to websocket server and listen to subscriptions
+// ip: ip address of server
+// id: id of driver
+// port: port of server
+func (d *ArtNetDriver) Connect(ip, id string, port uint) error {
+	errChan := make(chan error)
+	client, err := ws.NewClient(ip, id, port)
+	if err != nil {
+		return err
+	}
+
+	client.OnError = func(err error) {
+		d.Log.Error("websocket connection", err)
+		errChan <- err
+	}
+
+	client.OnMessage = func(data []byte) {
+		request := json_data.NewResponse()
+
+		err = json.Unmarshal(data, &request)
+
+		if err != nil {
+			return
+		}
+
+		if request.Subscribe != nil {
+			d.Subscribe(request.Subscribe...)
+		}
+
+		if request.Publish != nil {
+			d.Publish(request.Publish...)
+		}
+	}
+
+	if err != nil {
+		d.Log.Error("artNet.Connect", err)
+		return err
+	}
+
+	req := json_data.NewRequest()
+	req.AddDriverSubscription(".*", id, 0, true, false, false)
+
+	if err := client.SendRequest(req); err != nil {
+		errChan <- err
+		d.Log.Error("websocket send data", err)
+	}
+
+	for err := range errChan {
+		return err
+	}
+	return nil
+}
+
+// send data to all buses that the send flage is true
+func (d *ArtNetDriver) SendData() {
+	for _, bus := range d.Buses {
+		if !bus.Reachable {
+			continue
+		}
+		bus.Send <- bus.Data
+	}
+}

driver/bus.go

@@ -0,0 +1,196 @@
+package driver
+
+import (
+	"artNet/auth"
+	"artNet/models"
+	"fmt"
+	"net"
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+	json_data "github.com/tecamino/tecamino-json_data"
+	json_dataModels "github.com/tecamino/tecamino-json_data/models"
+)
+
+// sends a list of all buses in the driver
+func (d *ArtNetDriver) GetAllBuses(c *gin.Context) {
+	var data any
+	if len(d.Buses) == 0 {
+		data = "no buses avaiable"
+	} else {
+		data = *d
+	}
+
+	c.JSON(200, gin.H{
+		"buses": data,
+	})
+}
+
+func (d *ArtNetDriver) CreateBus(c *gin.Context) {
+	_, err := auth.GetIDFromQuery(c)
+	if err != nil {
+		r := json_data.NewResponse()
+		r.SetError()
+		r.SetMessage(err.Error())
+		c.JSON(http.StatusBadRequest, r)
+		return
+	}
+
+	busPayload := models.Bus{}
+	if err := busPayload.ParsePayload(c); err != nil {
+		return
+	}
+
+	if addr := net.ParseIP(busPayload.Ip); addr == nil {
+		r := json_data.NewResponse()
+		r.SetError()
+		r.SetMessage("wrong ip '" + busPayload.Ip + "'")
+		c.JSON(http.StatusBadRequest, r)
+		return
+	}
+
+	if _, ok := d.Buses[busPayload.Name]; ok {
+		r := json_data.NewResponse()
+		r.SetError()
+		r.SetMessage("bus " + busPayload.Name + " exists already")
+		c.JSON(http.StatusOK, r)
+		return
+	}
+
+	bus := d.NewBus(busPayload.Name, busPayload.Ip, busPayload.GetPort())
+
+	r := json_data.NewResponse()
+	r.SetMessage(fmt.Sprintf("bus '%s' successfully created with ip: %s and on port: %d", bus.Name, bus.Ip, bus.GetPort()))
+	c.JSON(http.StatusOK, r)
+	d.cfgHandler.SaveCfg(*d)
+}
+
+func (d *ArtNetDriver) RemoveBus(c *gin.Context) {
+	_, err := auth.GetIDFromQuery(c)
+	if err != nil {
+		r := json_data.NewResponse()
+		r.SetError()
+		r.SetMessage("id: " + err.Error())
+		c.JSON(http.StatusBadRequest, r)
+		return
+	}
+
+	busPayload := models.Bus{}
+	if err := busPayload.ParsePayload(c); err != nil {
+		return
+	}
+
+	if _, ok := d.Buses[busPayload.Name]; !ok {
+		r := json_dataModels.NewResponse()
+		r.SetMessage("bus " + busPayload.Name + " not found")
+		c.JSON(http.StatusBadRequest, r)
+		return
+	} else {
+		delete(d.Buses, busPayload.Name)
+	}
+	r := json_dataModels.NewResponse()
+	r.SetMessage(fmt.Sprintf("bus '%s' successfully removed", busPayload.Name))
+	c.JSON(http.StatusOK, r)
+	d.cfgHandler.SaveCfg(*d)
+}
+
+func (d *ArtNetDriver) Start(c *gin.Context) {
+	_, err := auth.GetIDFromQuery(c)
+	if err != nil {
+		r := json_data.NewResponse()
+		r.SetError()
+		r.SetMessage("id: " + err.Error())
+		c.JSON(http.StatusBadRequest, r)
+		return
+	}
+
+	busPayload := models.Bus{}
+	if err := busPayload.ParsePayload(c); err != nil {
+		return
+	}
+
+	d.Buses[busPayload.Name].Start(d.Log)
+
+	r := json_dataModels.NewResponse()
+	r.SetMessage(fmt.Sprintf("bus '%s' running", busPayload.Name))
+	c.JSON(http.StatusOK, r)
+}
+
+func (d *ArtNetDriver) Stop(c *gin.Context) {
+	_, err := auth.GetIDFromQuery(c)
+	if err != nil {
+		r := json_data.NewResponse()
+		r.SetError()
+		r.SetMessage("id: " + err.Error())
+		c.JSON(http.StatusBadRequest, r)
+		return
+	}
+
+	busPayload := models.Bus{}
+	if err := busPayload.ParsePayload(c); err != nil {
+		return
+	}
+
+	d.Buses[busPayload.Name].Stop()
+
+	r := json_dataModels.NewResponse()
+	r.SetMessage(fmt.Sprintf("bus '%s' stopped", busPayload.Name))
+	c.JSON(http.StatusOK, r)
+}
+
+func (d *ArtNetDriver) Resubscribe(c *gin.Context) {
+	_, err := auth.GetIDFromQuery(c)
+
+	if err != nil {
+		r := json_data.NewResponse()
+		r.SetError()
+		r.SetMessage("id: " + err.Error())
+		c.JSON(http.StatusBadRequest, r)
+		return
+	}
+
+	busPayload := models.Bus{}
+	if err := busPayload.ParsePayload(c); err != nil {
+		return
+	}
+
+	if _, ok := d.Buses[busPayload.Name]; !ok {
+		r := json_dataModels.NewResponse()
+		r.SetMessage("bus " + busPayload.Name + " not found")
+		c.JSON(http.StatusBadRequest, r)
+		return
+	}
+
+	if busPayload.Resubscribe == nil {
+		r := json_dataModels.NewResponse()
+		r.SetMessage("no resubscriptions in request")
+		c.JSON(http.StatusBadRequest, r)
+		return
+	}
+
+	d.Subscribe(*busPayload.Resubscribe...)
+}
+
+func (d *ArtNetDriver) Status(c *gin.Context) {
+	_, err := auth.GetIDFromQuery(c)
+	if err != nil {
+		r := json_data.NewResponse()
+		r.SetError()
+		r.SetMessage("id: " + err.Error())
+		c.JSON(http.StatusBadRequest, r)
+		return
+	}
+
+	busPayload := models.Bus{}
+	if err := busPayload.ParsePayload(c); err != nil {
+		return
+	}
+
+	r := json_dataModels.NewResponse()
+	state := "stopped"
+	if d.Buses[busPayload.Name].Status() {
+		state = "running"
+	}
+	r.SetMessage(fmt.Sprintf("bus '%s' %s", busPayload.Name, state))
+	c.JSON(http.StatusOK, r)
+}

driver/publish.go

@@ -0,0 +1,19 @@
+package driver
+
+import (
+	json_dataModels "github.com/tecamino/tecamino-json_data/models"
+)
+
+func (d *ArtNetDriver) Publish(pubs ...json_dataModels.Publish) error {
+	if d.Subscriptions == nil {
+		return nil
+	}
+
+	for _, pub := range pubs {
+		if drv, ok := (d.Subscriptions)[pub.Uuid]; ok {
+			d.SetValue(drv.Bus, drv.Address, uint8(pub.Value.(float64)))
+		}
+	}
+	d.SendData()
+	return nil
+}

driver/subscribe.go

@@ -0,0 +1,21 @@
+package driver
+
+import (
+	"artNet/models"
+
+	json_dataModels "github.com/tecamino/tecamino-json_data/models"
+)
+
+func (d *ArtNetDriver) Subscribe(subs ...json_dataModels.Subscription) {
+	if d.Subscriptions == nil {
+		d.Subscriptions = models.NewSubscriptions()
+	}
+
+	for _, sub := range subs {
+		if drv, ok := (*sub.Drivers)[sub.Driver]; ok {
+			d.Subscriptions.AddSubscription(sub.Uuid, drv)
+			d.SetValue(drv.Bus, drv.Address, uint8(sub.Value.(float64)))
+		}
+	}
+	d.SendData()
+}

go.mod

@@ -5,10 +5,13 @@ go 1.23.0
 toolchain go1.23.8
 
 require (
-	github.com/coder/websocket v1.8.13
 	github.com/gin-gonic/gin v1.10.0
+	github.com/google/uuid v1.6.0
+	github.com/gorilla/websocket v1.5.3
 	github.com/tatsushid/go-fastping v0.0.0-20160109021039-d7bb493dee3e
-	github.com/tecamino/tecamino-logger v0.1.1
+	github.com/tecamino/tecamino-json_data v0.0.16
+	github.com/tecamino/tecamino-logger v0.2.0
+	gopkg.in/yaml.v3 v3.0.1
 )
 
 require (
@@ -39,5 +42,5 @@ require (
 	golang.org/x/sys v0.20.0 // indirect
 	golang.org/x/text v0.15.0 // indirect
 	google.golang.org/protobuf v1.34.1 // indirect
-	gopkg.in/yaml.v3 v3.0.1 // indirect
+	gopkg.in/natefinch/lumberjack.v2 v2.2.1 // indirect
 )

go.sum

@@ -6,8 +6,6 @@ github.com/cloudwego/base64x v0.1.4 h1:jwCgWpFanWmN8xoIUHa2rtzmkd5J2plF/dnLS6Xd/
 github.com/cloudwego/base64x v0.1.4/go.mod h1:0zlkT4Wn5C6NdauXdJRhSKRlJvmclQ1hhJgA0rcu/8w=
 github.com/cloudwego/iasm v0.2.0 h1:1KNIy1I1H9hNNFEEH3DVnI4UujN+1zjpuk6gwHLTssg=
 github.com/cloudwego/iasm v0.2.0/go.mod h1:8rXZaNYT2n95jn+zTI1sDr+IgcD2GVs0nlbbQPiEFhY=
-github.com/coder/websocket v1.8.13 h1:f3QZdXy7uGVz+4uCJy2nTZyM0yTBj8yANEHhqlXZ9FE=
-github.com/coder/websocket v1.8.13/go.mod h1:LNVeNrXQZfe5qhS9ALED3uA+l5pPqvwXg3CKoDBB2gs=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
@@ -30,6 +28,10 @@ github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MG
 github.com/google/go-cmp v0.5.5 h1:Khx7svrCpmxxtHBq5j2mp/xVjsi8hQMfNLvJFAlrGgU=
 github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
+github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
 github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
 github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
@@ -63,8 +65,10 @@ github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsT
 github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 github.com/tatsushid/go-fastping v0.0.0-20160109021039-d7bb493dee3e h1:nt2877sKfojlHCTOBXbpWjBkuWKritFaGIfgQwbQUls=
 github.com/tatsushid/go-fastping v0.0.0-20160109021039-d7bb493dee3e/go.mod h1:B4+Kq1u5FlULTjFSM707Q6e/cOHFv0z/6QRoxubDIQ8=
-github.com/tecamino/tecamino-logger v0.1.1 h1:bK0SEQpbjui42OsnM6JCDThaGMBoqwVj/Op6ESqDwV4=
+github.com/tecamino/tecamino-json_data v0.0.16 h1:aZFxnhm4g6WMDPoqy4HosUk7vl0DB0iIcVs8bbT4MzU=
-github.com/tecamino/tecamino-logger v0.1.1/go.mod h1:sGysmiFGIdr4vLJRAI+fJgsa7EoRRuxvRrKW7GnGQkw=
+github.com/tecamino/tecamino-json_data v0.0.16/go.mod h1:LLlyD7Wwqplb2BP4PeO86EokEcTRidlW5MwgPd1T2JY=
+github.com/tecamino/tecamino-logger v0.2.0 h1:NPH/Gg9qRhmVoW8b39i1eXu/LEftHc74nyISpcRG+XU=
+github.com/tecamino/tecamino-logger v0.2.0/go.mod h1:0M1E9Uei/qw3e3WA1x3lBo1eP3H5oeYE7GjYrMahnj8=
 github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI=
 github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
 github.com/ugorji/go/codec v1.2.12 h1:9LC83zGrHhuUA9l16C9AHXAqEV/2wBQ4nkvumAE65EE=
@@ -94,6 +98,8 @@ google.golang.org/protobuf v1.34.1 h1:9ddQBjfCyZPOHPUiPxpYESBLc+T8P3E+Vo4IbKZgFW
 google.golang.org/protobuf v1.34.1/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/natefinch/lumberjack.v2 v2.2.1 h1:bBRl1b0OH9s/DuPhuXpNl+VtCaJXFZ5/uEFST95x9zc=
+gopkg.in/natefinch/lumberjack.v2 v2.2.1/go.mod h1:YD8tP3GAjkrDg1eZH7EGmyESg/lsYskCTPBJVb9jqSc=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

main.go

@@ -3,71 +3,81 @@ package main
 import (
 	"artNet/driver"
 	"artNet/server"
+	"flag"
 	"fmt"
-	"math"
+	"os"
 	"time"
+
+	"github.com/gin-gonic/gin"
 )
 
+const DriverName string = "ArtNetDriver"
+
 func main() {
+	// cli flags
+	cfgDir := flag.String("cfg", "./cfg", "config directory")
+	workingDir := flag.String("workingDirectory", ".", "current working directory")
+	serverIp := flag.String("serverIp", "127.0.0.1", "ip address of server")
+	serverPort := flag.Uint("serverPort", 8100, "port of server")
+	wsPort := flag.Uint("port", 8200, "websocket port")
+	debug := flag.Bool("debug", false, "debug logging")
+	start := flag.Bool("start", false, "starts all buses on startup")
+	flag.Parse()
 
-	bus := driver.NewDriver().NewInterface("2.0.0.1", 0)
+	//change working directory only if value is given
-	d, _ := bus.AddDevice(47, 9)
+	if *workingDir != "." && *workingDir != "" {
+		os.Chdir(*workingDir)
+	}
 
-	var i uint8
+	//initialize new ArtNet driver
+	artNetDriver, err := driver.NewDriver(*cfgDir, DriverName, *debug)
+	if err != nil {
+		artNetDriver.Log.Error("main", "error initialize new artnet driver "+err.Error())
+		panic(err)
+	}
 
+	//initialize new server
+	artNetDriver.Log.Debug("main", "initialize new server instance")
 	s := server.NewServer()
 
-	s.ServeHttp(8120)
+	//set routes
+	artNetDriver.Log.Debug("main", "setting routes")
+	s.Routes.GET("/buses/all", artNetDriver.GetAllBuses)
+	s.Routes.POST("/buses/create", artNetDriver.CreateBus)
+	s.Routes.POST("/buses/remove", artNetDriver.RemoveBus)
+	s.Routes.POST("/buses/start", artNetDriver.Start)
+	s.Routes.POST("/buses/status", artNetDriver.Status)
+	s.Routes.POST("/buses/stop", artNetDriver.Stop)
+	s.Routes.POST("/buses/resubscribe", artNetDriver.Resubscribe)
 
+	s.Routes.GET("/", func(c *gin.Context) {
+		c.String(200, "ArtNet Driver WebSocket Server is running!")
+	})
+
+	go func() {
+		if err := s.ServeHttp(*wsPort); err != nil {
+			artNetDriver.Log.Error("main", err)
+		}
+	}()
+
+	artNetDriver.Log.Info("main", fmt.Sprintf("connect to server  ws://%s:%d with id %s", *serverIp, *serverPort, DriverName))
+
+	if *start {
+		for busName, bus := range artNetDriver.Buses {
+			artNetDriver.Log.Info("main", fmt.Sprintf("starting bus %s", busName))
+			// start bus and listen to subscriptions
+			bus.Start(artNetDriver.Log)
+		}
+	}
+
+	// connect to server
 	for {
-		if i == math.MaxUint8 {
+		if err := artNetDriver.Connect(*serverIp, DriverName, *serverPort); err != nil {
-			i = 0
+			artNetDriver.Log.Error("main", err)
-		}
-		err := d.SetChannelValue(0, i)
-		if err != nil {
-			fmt.Println(err)
-		}
-		err = d.SetChannelValue(1, i)
-		if err != nil {
-			fmt.Println(err)
-		}
-		err = d.SetChannelValue(2, i)
-		if err != nil {
-			fmt.Println(err)
-		}
-		err = d.SetChannelValue(3, i)
-		if err != nil {
-			fmt.Println(err)
-		}
-		err = d.SetChannelValue(4, i)
-		if err != nil {
-			fmt.Println(err)
-		}
-		err = d.SetChannelValue(5, i)
-		if err != nil {
-			fmt.Println(err)
-		}
-		err = d.SetChannelValue(6, i)
-		if err != nil {
-			fmt.Println(err)
-		}
-		err = d.SetChannelValue(7, i)
-		if err != nil {
-			fmt.Println(err)
-		}
-		err = d.SetChannelValue(8, i)
-		if err != nil {
-			fmt.Println(err)
 		}
 
-		if err := bus.SendData(); err != nil {
+		artNetDriver.Log.Info("main", "next reconnecting attempt in 10 seconds")
-			fmt.Println(12, err)
+		time.Sleep(10 * time.Second)
-			panic(err)
-		}
-		time.Sleep(100 * time.Microsecond)
-		i += 1
-		i = 0
-
 	}
 
 }

models/bus.go

@@ -1,11 +1,18 @@
 package models
 
 import (
+	"context"
+	"errors"
 	"fmt"
 	"net"
+	"net/http"
 	"time"
 
+	"github.com/gin-gonic/gin"
 	"github.com/tatsushid/go-fastping"
+	json_data "github.com/tecamino/tecamino-json_data"
+	json_dataModels "github.com/tecamino/tecamino-json_data/models"
+	"github.com/tecamino/tecamino-logger/logging"
 )
 
 // Art-Net constants
@@ -15,43 +22,49 @@ const (
 
 // Art-Net Interface
 type Bus struct {
-	ip      string    `yaml:"ip"`
+	Name        string                          `yaml:"name" json:"name"`
-	port    int       `yaml:"port"`
+	Ip          string                          `yaml:"ip" json:"ip"`
-	Devices []*Device `yaml:"devices"`
+	Port        *int                            `yaml:"port" json:"port,omitempty"`
-	Data    *DMX
+	Data        *DMX                            `yaml:"-" json:"-"`
+	Resubscribe *[]json_dataModels.Subscription `yaml:"-" json:"resubscribe"`
+	Watchdog    context.CancelFunc              `yaml:"-" json:"-"`
+	Reachable   bool                            `yaml:"-" json:"-"`
+	Send        chan *DMX                       `yaml:"-" json:"-"`
 }
 
 // adds new Art-Net interface to driver port 0 = 6454 (default art-net)
-func NewBus(ip string, port int) *Bus {
+func NewBus(name, ip string, port int) *Bus {
 	if port == 0 {
 		port = artPort
 	}
 
 	i := Bus{
-		ip:   ip,
+		Name: name,
-		port: port,
+		Ip:   ip,
+		Port: &port,
 		Data: NewDMXUniverse(),
 	}
 	return &i
 }
 
-// adds new dmx device to interface
+// get bus port from pointer
-func (i *Bus) AddDevice(address uint, channels uint) (*Device, error) {
+func (b *Bus) GetPort() int {
-	d := NewDevice(address, channels, i.Data)
+	if b.Port == nil {
-	i.Devices = append(i.Devices, d)
+		return artPort
-	return d, nil
+	}
+	return *b.Port
 }
 
 // start polling dmx data in milliseconds 0 = aprox. 44Hertz
-func (i *Bus) Poll(interval time.Duration) error {
+func (b *Bus) Poll(interval time.Duration) error {
 	if interval == 0 {
 		interval = 23
 	}
 
 	// Send packet over UDP
 	conn, err := net.DialUDP("udp", nil, &net.UDPAddr{
-		IP:   net.ParseIP(i.ip),
+		IP:   net.ParseIP(b.Ip),
-		Port: i.port,
+		Port: *b.Port,
 	})
 
 	if err != nil {
@@ -63,7 +76,7 @@ func (i *Bus) Poll(interval time.Duration) error {
 	for {
 		go func() {
 			for {
-				if reached, _ := isUDPReachable(i.ip); !reached {
+				if reached, _ := isUDPReachable(b.Ip); !reached {
 					if errCount > 20 {
 						break
 					} else {
@@ -77,7 +90,7 @@ func (i *Bus) Poll(interval time.Duration) error {
 			}
 		}()
 
-		_, err = conn.Write(NewArtNetPackage(i.Data))
+		_, err = conn.Write(NewArtNetPackage(b.Data))
 		if err != nil {
 			return err
 		}
@@ -89,42 +102,103 @@ func (i *Bus) Poll(interval time.Duration) error {
 	}
 }
 
-// start polling dmx data in milliseconds 0 = aprox. 44Hertz
+// start bus
-func (i *Bus) SendData() error {
+func (b *Bus) Start(log *logging.Logger) error {
-	// Send packet over UDP
+	var ctx context.Context
+	ctx, b.Watchdog = context.WithCancel(context.Background())
+
+	b.Send = make(chan *DMX, 1024)
+
+	go func() {
+		var interval time.Duration = 10 * time.Second
+		log.Info("bus.Start", fmt.Sprintf("device:%s ip:%s watchdog starting", b.Name, b.Ip))
+		for {
+			select {
+			case <-ctx.Done():
+				log.Info("bus.Start", fmt.Sprintf("device:%s ip:%s watchdog stopped", b.Name, b.Ip))
+				b.Reachable = false
+				return
+			default:
+				b.Reachable = false
+				if reached, err := isUDPReachable(b.Ip); err != nil {
+					log.Error("bus.Start", err)
+					interval = 5 * time.Second
+				} else if !reached {
+					log.Error("bus.Start", fmt.Sprintf("device:%s ip:%s not reached", b.Name, b.Ip))
+					interval = 5 * time.Second
+				} else {
+					b.Reachable = true
+					// send data as a heartbeat for she ArtNet Protocol
+					b.Send <- b.Data
+					log.Info("bus.Start", fmt.Sprintf("device:%s ip:%s watchdog running", b.Name, b.Ip))
+					interval = 30 * time.Second
+				}
+				time.Sleep(interval)
+			}
+		}
+	}()
+
 	conn, err := net.DialUDP("udp", nil, &net.UDPAddr{
-		IP:   net.ParseIP(i.ip),
+		IP:   net.ParseIP(b.Ip),
-		Port: i.port,
+		Port: *b.Port,
 	})
 
 	if err != nil {
 		return err
 	}
-	defer conn.Close()
 
-	errChan := make(chan error)
 	go func() {
-		if reached, _ := isUDPReachable(i.ip); !reached {
+		defer conn.Close()
-			errChan <- fmt.Errorf("device not reachable")
+		//close send channel
-			return
+		defer close(b.Send)
-		}
-		errChan <- nil
-	}()
 
-	err = <-errChan
+		for send := range b.Send {
-	if err != nil {
+			_, err = conn.Write(NewArtNetPackage(send))
+			if err != nil {
+				log.Error("bus.Start", err)
+				return
+			}
+			time.Sleep(23 * time.Millisecond)
+		}
+	}()
+	return nil
+}
+
+// stop bus
+func (b *Bus) Stop() {
+	if b.Watchdog != nil {
+		//cancels context
+		b.Watchdog()
+		//close send channel
+		close(b.Send)
+	}
+}
+
+// status bus
+func (b *Bus) Status() bool {
+	return b.Watchdog != nil
+}
+
+func (b *Bus) ParsePayload(c *gin.Context) error {
+
+	if err := c.BindJSON(b); err != nil {
+		r := json_data.NewResponse()
+		r.SetError()
+		r.SetMessage("json: " + err.Error())
+		c.JSON(http.StatusBadRequest, r)
 		return err
 	}
 
-	_, err = conn.Write(NewArtNetPackage(i.Data))
+	if b.Name == "" {
-
+		r := json_data.NewResponse()
-	return err
+		r.SetError()
+		r.SetMessage("bus name missing")
+		c.JSON(http.StatusBadRequest, r)
+		return errors.New("bus name missing")
+	}
+	return nil
 }
 
-const (
-	protocolICMP = 1
-)
-
 func isUDPReachable(ip string) (recieved bool, err error) {
 	p := fastping.NewPinger()
 	ra, err := net.ResolveIPAddr("ip4:icmp", ip)
@@ -132,10 +206,11 @@ func isUDPReachable(ip string) (recieved bool, err error) {
 		return
 	}
 	p.AddIPAddr(ra)
+
 	p.OnRecv = func(addr *net.IPAddr, rtt time.Duration) {
 		recieved = true
-		return
 	}
+
 	p.OnIdle = func() {}
 
 	err = p.Run()

models/device.go

@@ -1,25 +0,0 @@
-package models
-
-import "fmt"
-
-type Device struct {
-	startAddress uint
-	length       uint
-	channels     *DMX
-}
-
-func NewDevice(startAddress uint, channels uint, dmx *DMX) *Device {
-	return &Device{
-		startAddress: startAddress,
-		length:       channels,
-		channels:     dmx,
-	}
-}
-
-func (d *Device) SetChannelValue(channel uint, value uint8) error {
-	if d.length == channel {
-		return fmt.Errorf("channel out of range %d", channel)
-	}
-	d.channels.SetValue(d.startAddress+channel, value)
-	return nil
-}

models/get.go

@@ -1,5 +0,0 @@
-package models
-
-type Get struct {
-	Bus uint `json:"bus"`
-}

models/jsonData.go

@@ -1,22 +0,0 @@
-package models
-
-type JsonData struct {
-	Set *[]Set `json:"set,omitempty"`
-}
-
-func NewRequest() *JsonData {
-	return &JsonData{}
-
-}
-
-func (r *JsonData) AddSet(bus, address uint, value uint8) {
-	if r.Set == nil {
-		r.Set = &[]Set{}
-	}
-
-	*r.Set = append(*r.Set, Set{
-		Bus:     bus,
-		Address: address,
-		Value:   value,
-	})
-}

models/set.go

@@ -1,7 +1,7 @@
 package models
 
 type Set struct {
-	Bus     uint  `json:"bus"`
+	Bus     string `json:"bus"`
-	Address uint  `json:"address"`
+	Address uint   `json:"address"`
-	Value   uint8 `json:"value"`
+	Value   uint8  `json:"value"`
 }

models/subscriptions.go

@@ -0,0 +1,24 @@
+package models
+
+import (
+	"github.com/google/uuid"
+	json_dataModels "github.com/tecamino/tecamino-json_data/models"
+)
+
+type Subscriptions map[uuid.UUID]Subscription
+
+type Subscription struct {
+	Bus     string
+	Address uint
+}
+
+func NewSubscriptions() Subscriptions {
+	return make(Subscriptions)
+}
+
+func (s *Subscriptions) AddSubscription(uid uuid.UUID, drv *json_dataModels.Driver) {
+	(*s)[uid] = Subscription{
+		Bus:     drv.Bus,
+		Address: drv.Address,
+	}
+}

server/allBuses.go

@@ -1,18 +0,0 @@
-package server
-
-import (
-	"github.com/gin-gonic/gin"
-)
-
-func (s *Server) AllBuses(c *gin.Context) {
-	var data any
-	if s.Driver.Bus == nil {
-		data = "no buses avaiable"
-	} else {
-		data = s.Driver.Bus
-	}
-
-	c.JSON(200, gin.H{
-		"buses": data,
-	})
-}

server/jsonRequest.go

@@ -1,25 +0,0 @@
-package server
-
-import (
-	"net/http"
-
-	"artNet/models"
-
-	"github.com/gin-gonic/gin"
-)
-
-func (s *Server) JsonRequest(c *gin.Context) {
-	var payload models.JsonData
-
-	if err := c.BindJSON(&payload); err != nil {
-
-		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
-		return
-	}
-
-	c.JSON(200, gin.H{
-		"name": payload,
-	})
-	return
-
-}

server/models/response.go

@@ -1,7 +0,0 @@
-package models
-
-type Response struct {
-	StatusCode int    `json:"statusCode"`
-	Message    string `json:"message,omitempty"`
-	Data       string `json:"dat,omitempty"`
-}

server/models/subscribers.go

@@ -1,26 +0,0 @@
-package models
-
-import "github.com/coder/websocket"
-
-type Subscribers map[*websocket.Conn]*bool
-
-func InitSubsrcibers() Subscribers {
-	return make(Subscribers)
-}
-
-func (s *Subscribers) Connect(conn *websocket.Conn) {
-	b := true
-	(*s)[conn] = &b
-}
-
-func (s *Subscribers) DeleteSubsrcibers(conn *websocket.Conn) {
-	delete(*s, conn)
-}
-
-func (s *Subscribers) GetPointer(conn *websocket.Conn) *bool {
-	return (*s)[conn]
-}
-
-func (s *Subscribers) Disconnect(conn *websocket.Conn) {
-	*(*s)[conn] = false
-}

server/routes.go

@@ -1,16 +0,0 @@
-package server
-
-import (
-	"github.com/gin-gonic/gin"
-)
-
-func (s *Server) AddRoutes() {
-
-	s.engine.GET("/ws", s.handleWebSocket)
-
-	s.engine.GET("/allBuses", s.AllBuses)
-
-	s.engine.GET("/", func(c *gin.Context) {
-		c.String(200, "WebSocket Broadcast Server is running!")
-	})
-}

server/server.go

@@ -1,48 +1,38 @@
 package server
 
 import (
-	"fmt"
-	"sync"
-
 	"artNet/cert"
-	"artNet/driver"
+	"fmt"
-	serverModels "artNet/server/models"
 
 	"github.com/gin-gonic/gin"
-	"github.com/tecamino/tecamino-logger/logging"
 )
 
 type Server struct {
-	engine *gin.Engine
+	Routes *gin.Engine
-	sync.RWMutex
-	Subscribers serverModels.Subscribers
-	Logger      *logging.Logger
-	Driver      *driver.ArtNetDriver
 }
 
+type Send struct {
+	Set []Set `json:"subscribe"`
+}
+
+type Set struct {
+	Path     string `json:"path"`
+	OnChange bool   `json:"onChange"`
+	Depth    int    `json:"depth"`
+	Driver   string `json:"driver"`
+}
+
+// Initialize new websocket server
 func NewServer() *Server {
-	s := Server{
+	return &Server{
-		engine:      gin.Default(),
+		Routes: gin.Default(),
-		Subscribers: serverModels.InitSubsrcibers(),
 	}
-	s.AddRoutes()
-
-	s.Driver = driver.NewDriver()
-
-	return &s
 }
 
 func (s *Server) ServeHttp(port uint) error {
-	if err := s.engine.Run(fmt.Sprintf(":%d", port)); err != nil {
+	return s.Routes.Run(fmt.Sprintf(":%d", port))
-		return fmt.Errorf("failed to run http server: %v", err)
-	}
-	return nil
 }
 
 func (s *Server) ServeHttps(port uint, cert cert.Cert) error {
-	cert.GenerateSelfSignedCert()
+	return s.Routes.RunTLS(fmt.Sprintf(":%d", port), cert.CertFile, cert.KeyFile)
-	if err := s.engine.RunTLS(fmt.Sprintf(":%d", port), cert.CertFile, cert.KeyFile); err != nil {
-		return fmt.Errorf("failed to run https server: %v", err)
-	}
-	return nil
 }

server/set.go

@@ -1,13 +0,0 @@
-package server
-
-import (
-	"artNet/models"
-	"fmt"
-)
-
-func (s *Server) Set(get models.Get) error {
-	if len(s.Driver.Bus) <= int(get.Bus) {
-		return fmt.Errorf("no bus number '%d' found", get.Bus)
-	}
-	return nil
-}

server/webSocket.go

@@ -1,65 +0,0 @@
-package server
-
-import (
-	"context"
-	"fmt"
-	"log"
-	"time"
-
-	"artNet/models"
-
-	"github.com/coder/websocket"
-	"github.com/coder/websocket/wsjson"
-	"github.com/gin-gonic/gin"
-)
-
-const (
-	OnCreate = "onCreate"
-	OnChange = "onChange"
-	OnDelete = "onDelete"
-)
-
-func (s *Server) handleWebSocket(c *gin.Context) {
-	conn, err := websocket.Accept(c.Writer, c.Request, &websocket.AcceptOptions{
-		OriginPatterns: []string{"*"},
-	})
-	if err != nil {
-		log.Println("Upgrade error:", err)
-		return
-	}
-
-	defer conn.Close(websocket.StatusInternalError, "Internal error")
-
-	ctx, cancel := context.WithTimeout(c.Request.Context(), 10*time.Minute)
-	defer cancel()
-
-	s.Subscribers.Connect(conn)
-
-	//Read loop
-	for {
-		var request models.JsonData
-		err := wsjson.Read(ctx, conn, &request)
-		if err != nil {
-			fmt.Println(s.Subscribers[conn])
-			log.Println("WebSocket read error:", err)
-			s.Subscribers.Disconnect(conn)
-			fmt.Println(s.Subscribers[conn])
-			break
-		}
-
-		// Set
-		// if request.Set != nil {
-		// 	for _, set := range *request.Set {
-		// 		err = s.Unsubscribe(unsub, conn)
-		// 		if err != nil {
-		// 			fmt.Println(err)
-		// 			break
-		// 		}
-		// 	}
-		// }
-
-		if err != nil {
-			break
-		}
-	}
-}

websocket/client.go

@@ -0,0 +1,194 @@
+package websocket
+
+import (
+	"encoding/json"
+	"fmt"
+	"log"
+	"time"
+
+	"github.com/gorilla/websocket"
+	json_dataModels "github.com/tecamino/tecamino-json_data/models"
+)
+
+const (
+	// Time allowed to write a message to the peer.
+	writeWait = 10 * time.Second
+
+	// Time allowed to read the next pong message from the peer.
+	pongWait = 10 * time.Second
+)
+
+type Client struct {
+	ip         string
+	port       uint
+	Connected  bool
+	conn       *websocket.Conn
+	OnOpen     func()
+	OnMessage  func(data []byte)
+	OnClose    func(code int, reason string)
+	OnError    func(err error)
+	OnPing     func()
+	OnPong     func()
+	send       chan []byte
+	unregister chan []byte
+}
+
+// Connect to websocket server
+// ip: ip address of server
+func NewClient(ip, id string, port uint) (*Client, error) {
+	url := fmt.Sprintf("ws://%s:%d/ws?id=%s", ip, port, id)
+	c := &Client{
+		ip:         ip,
+		port:       port,
+		Connected:  true,
+		send:       make(chan []byte, 256),
+		unregister: make(chan []byte, 256),
+	}
+
+	dialer := websocket.DefaultDialer
+	conn, resp, err := dialer.Dial(url, nil)
+	if err != nil {
+		if c.OnError != nil {
+			c.OnError(err)
+		}
+		return nil, fmt.Errorf("dial error %v (status %v)", err, resp)
+	}
+	c.conn = conn
+
+	//Setup control handlers
+	conn.SetPingHandler(func(appData string) error {
+		if c.OnPing != nil {
+			c.OnPing()
+		}
+		conn.SetReadDeadline(time.Now().Add(pongWait))
+		conn.SetWriteDeadline(time.Now().Add(pongWait))
+		if err := conn.WriteControl(websocket.PongMessage, []byte(appData), time.Now().Add(2*pongWait)); err != nil {
+			c.OnError(err)
+			return err
+		}
+		return nil
+	})
+
+	conn.SetPongHandler(func(appData string) error {
+		conn.SetReadDeadline(time.Now().Add(pongWait))
+		if c.OnPong != nil {
+			c.OnPong()
+		}
+		return nil
+	})
+
+	// Start reading messages from client
+	go c.Read()
+	go c.Write()
+	return c, nil
+}
+
+func (c *Client) Read() {
+	if c.OnOpen != nil {
+		c.OnOpen()
+	}
+
+	c.conn.SetReadDeadline(time.Now().Add(pongWait))
+	for c.Connected {
+		c.conn.SetReadDeadline(time.Now().Add(pongWait))
+		msgType, msg, err := c.conn.ReadMessage()
+
+		if err != nil {
+			c.handleError(fmt.Errorf("read error (ip:%s): %w", c.ip, err))
+			return
+		}
+
+		switch msgType {
+		case websocket.CloseMessage:
+			c.Close(websocket.CloseNormalClosure, "Client closed")
+			return
+		case websocket.TextMessage:
+			if c.OnMessage != nil {
+				c.OnMessage(msg)
+			} else {
+				log.Printf("Received message but no handler set (ip:%s): %s", c.ip, string(msg))
+			}
+		default:
+			log.Printf("Unhandled message type %d (ip:%s)", msgType, c.ip)
+		}
+	}
+}
+
+func (c *Client) Write() {
+	defer c.conn.Close()
+
+	c.conn.SetWriteDeadline(time.Now().Add(writeWait))
+	for {
+		select {
+		case message, ok := <-c.send:
+			c.conn.SetWriteDeadline(time.Now().Add(writeWait))
+			if !ok {
+				// The hub closed the channel.
+				if err := c.conn.WriteMessage(websocket.CloseMessage, []byte("ping")); err != nil {
+					c.handleError(err)
+					return
+				}
+				c.handleError(fmt.Errorf("server %s closed channel", c.ip))
+				return
+			} else {
+				if err := c.conn.WriteMessage(websocket.TextMessage, message); err != nil {
+					c.handleError(err)
+					return
+				}
+			}
+		case message := <-c.unregister:
+			c.conn.WriteMessage(websocket.CloseMessage, message)
+			c.Connected = false
+			close(c.send)
+			close(c.unregister)
+			return
+		}
+
+	}
+}
+
+func (c *Client) SendRequest(req *json_dataModels.Request) error {
+	if !c.Connected {
+		return nil
+	}
+
+	data, err := json.Marshal(*req)
+	if err != nil {
+		return err
+	}
+	c.send <- data
+	return nil
+}
+
+func (c *Client) ReadJsonData(data []byte) (json_dataModels.Response, error) {
+	var resp json_dataModels.Response
+	err := json.Unmarshal(data, &resp)
+	return resp, err
+}
+
+// Close connection to websocket server
+func (c *Client) Close(code int, reason string) error {
+	closeMsg := websocket.FormatCloseMessage(code, reason)
+	select {
+	case c.unregister <- closeMsg: // Attempt to send
+	default: // If the channel is full, this runs
+		return fmt.Errorf("attempt close client socket failed")
+	}
+	if c.OnClose != nil {
+		c.OnClose(code, reason)
+	}
+	return nil
+}
+
+func (c *Client) handleError(err error) {
+	if c.OnError != nil {
+		c.OnError(err)
+	}
+	if err := c.Close(websocket.CloseInternalServerErr, err.Error()); err != nil {
+		if c.OnError != nil {
+			c.OnError(err)
+		} else {
+			log.Println("error:", err)
+		}
+	}
+}