change ping pong handler and fix blocking channel

.github/workflows/build.yml

@@ -36,9 +36,9 @@ jobs:
         run: |
           mkdir -p build
           if [ "${{ matrix.goos }}" == "windows" ]; then
-            GOOS=${{ matrix.goos }} GOARCH=${{ matrix.goarch }} go build -o build/tecamino-driver-artNet-${{ matrix.goos }}-${{ matrix.goarch }}.exe main.go
+            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 -o build/tecamino-driver-artNet-${{ matrix.goos }}-${{ matrix.goarch }} main.go
+            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

.gitignore

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

driver/artNet.go

@@ -4,6 +4,7 @@ import (
 	"artNet/cfg"
 	"artNet/models"
 	ws "artNet/websocket"
+	"encoding/json"
 	"fmt"
 	"path"
 
@@ -81,7 +82,7 @@ func (d *ArtNetDriver) SetValue(bus string, address uint, value uint8) error {
 		return fmt.Errorf("no dmx data on bus '%s' found", bus)
 	}
 	d.Buses[bus].Data.SetValue(address, value)
-	return d.Buses[bus].SendData()
+	return nil
 }
 
 // connect to websocket server and listen to subscriptions
@@ -101,7 +102,26 @@ func (d *ArtNetDriver) Connect(ip, id string, port uint) error {
 	}
 
 	client.OnMessage = func(data []byte) {
-		fmt.Println(100, string(data))
+		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()
@@ -112,10 +132,18 @@ func (d *ArtNetDriver) Connect(ip, id string, port uint) error {
 		d.Log.Error("websocket send data", err)
 	}
 
-	for {
+	for err := range errChan {
-		select {
+		return err
-		case err := <-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/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

@@ -17,4 +17,5 @@ func (d *ArtNetDriver) Subscribe(subs ...json_dataModels.Subscription) {
 			d.SetValue(drv.Bus, drv.Address, uint8(sub.Value.(float64)))
 		}
 	}
+	d.SendData()
 }

main.go

@@ -75,6 +75,7 @@ func main() {
 		if err := artNetDriver.Connect(*serverIp, DriverName, *serverPort); err != nil {
 			artNetDriver.Log.Error("main", err)
 		}
+
 		artNetDriver.Log.Info("main", "next reconnecting attempt in 10 seconds")
 		time.Sleep(10 * time.Second)
 	}

models/bus.go

@@ -29,6 +29,7 @@ type Bus struct {
 	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)
@@ -102,13 +103,15 @@ func (b *Bus) Poll(interval time.Duration) error {
 }
 
 // start bus
-func (b *Bus) Start(log *logging.Logger) {
+func (b *Bus) Start(log *logging.Logger) error {
 	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 stopped", b.Name, b.Ip))
+		log.Info("bus.Start", fmt.Sprintf("device:%s ip:%s watchdog starting", b.Name, b.Ip))
 		for {
 			select {
 			case <-ctx.Done():
@@ -125,6 +128,8 @@ func (b *Bus) Start(log *logging.Logger) {
 					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
 				}
@@ -132,26 +137,7 @@ func (b *Bus) Start(log *logging.Logger) {
 			}
 		}
 	}()
-}
 
-// stop bus
-func (b *Bus) Stop() {
-	if b.Watchdog != nil {
-		b.Watchdog()
-	}
-}
-
-// status bus
-func (b *Bus) Status() bool {
-	return b.Watchdog != nil
-}
-
-// send dmx data
-func (b *Bus) SendData() error {
-	if !b.Reachable {
-		return nil
-	}
-	// Send packet over UDP
 	conn, err := net.DialUDP("udp", nil, &net.UDPAddr{
 		IP:   net.ParseIP(b.Ip),
 		Port: *b.Port,
@@ -160,11 +146,37 @@ func (b *Bus) SendData() error {
 	if err != nil {
 		return err
 	}
-	defer conn.Close()
 
-	_, err = conn.Write(NewArtNetPackage(b.Data))
+	go func() {
+		defer conn.Close()
+		//close send channel
+		defer close(b.Send)
 
-	return err
+		for send := range b.Send {
+			_, 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 {

websocket/client.go

@@ -16,9 +16,6 @@ const (
 
 	// Time allowed to read the next pong message from the peer.
 	pongWait = 10 * time.Second
-
-	// Send pings to peer with this period. Must be less than pongWait.
-	pingPeriod = (pongWait * 9) / 10
 )
 
 type Client struct {
@@ -32,7 +29,6 @@ type Client struct {
 	OnError    func(err error)
 	OnPing     func()
 	OnPong     func()
-	sendPong   chan string
 	send       chan []byte
 	unregister chan []byte
 }
@@ -45,9 +41,8 @@ func NewClient(ip, id string, port uint) (*Client, error) {
 		ip:         ip,
 		port:       port,
 		Connected:  true,
-		sendPong:   make(chan string),
+		send:       make(chan []byte, 256),
-		send:       make(chan []byte),
+		unregister: make(chan []byte, 256),
-		unregister: make(chan []byte),
 	}
 
 	dialer := websocket.DefaultDialer
@@ -60,18 +55,21 @@ func NewClient(ip, id string, port uint) (*Client, error) {
 	}
 	c.conn = conn
 
-	// Setup control handlers
+	//Setup control handlers
 	conn.SetPingHandler(func(appData string) error {
 		if c.OnPing != nil {
 			c.OnPing()
 		}
-		conn.SetWriteDeadline(time.Now().Add(writeWait))
+		conn.SetReadDeadline(time.Now().Add(pongWait))
-		conn.SetReadDeadline(time.Now().Add(writeWait))
+		conn.SetWriteDeadline(time.Now().Add(pongWait))
-		c.sendPong <- appData
+		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(string) error {
+	conn.SetPongHandler(func(appData string) error {
 		conn.SetReadDeadline(time.Now().Add(pongWait))
 		if c.OnPong != nil {
 			c.OnPong()
@@ -79,17 +77,6 @@ func NewClient(ip, id string, port uint) (*Client, error) {
 		return nil
 	})
 
-	conn.SetCloseHandler(func(code int, text string) error {
-		if c.OnClose != nil {
-			c.OnClose(code, text)
-		}
-		return nil
-	})
-
-	if c.OnOpen != nil {
-		c.OnOpen()
-	}
-
 	// Start reading messages from client
 	go c.Read()
 	go c.Write()
@@ -101,13 +88,16 @@ func (c *Client) Read() {
 		c.OnOpen()
 	}
 
-	c.conn.SetReadDeadline(time.Now().Add(writeWait))
+	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 (id:%s:%d): %w", c.ip, c.port, err))
+			c.handleError(fmt.Errorf("read error (ip:%s): %w", c.ip, err))
 			return
 		}
+
 		switch msgType {
 		case websocket.CloseMessage:
 			c.Close(websocket.CloseNormalClosure, "Client closed")
@@ -116,32 +106,29 @@ func (c *Client) Read() {
 			if c.OnMessage != nil {
 				c.OnMessage(msg)
 			} else {
-				log.Printf("Received message but no handler set (id:%s:%d): %s", c.ip, c.port, string(msg))
+				log.Printf("Received message but no handler set (ip:%s): %s", c.ip, string(msg))
 			}
 		default:
-			log.Printf("Unhandled message type %d (id:%s:%d)", msgType, c.ip, c.port)
+			log.Printf("Unhandled message type %d (ip:%s)", msgType, c.ip)
 		}
 	}
 }
 
 func (c *Client) Write() {
-	ticker := time.NewTicker(pingPeriod)
+	defer c.conn.Close()
-	defer func() {
-		ticker.Stop()
-		c.conn.Close()
-	}()
-	for {
 
+	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{}); err != nil {
+				if err := c.conn.WriteMessage(websocket.CloseMessage, []byte("ping")); err != nil {
 					c.handleError(err)
 					return
 				}
-				c.handleError(fmt.Errorf("server %s:%d closed channel", c.ip, c.port))
+				c.handleError(fmt.Errorf("server %s closed channel", c.ip))
 				return
 			} else {
 				if err := c.conn.WriteMessage(websocket.TextMessage, message); err != nil {
@@ -149,26 +136,10 @@ func (c *Client) Write() {
 					return
 				}
 			}
-		case <-ticker.C:
-			c.conn.SetWriteDeadline(time.Now().Add(writeWait))
-			if err := c.conn.WriteMessage(websocket.PingMessage, nil); err != nil {
-				c.handleError(err)
-				return
-			}
-
-			if c.OnPing != nil {
-				c.OnPing()
-			}
-
-		case message, ok := <-c.sendPong:
-			if ok {
-				c.conn.WriteMessage(websocket.PongMessage, []byte(message))
-			}
 		case message := <-c.unregister:
 			c.conn.WriteMessage(websocket.CloseMessage, message)
 			c.Connected = false
 			close(c.send)
-			close(c.sendPong)
 			close(c.unregister)
 			return
 		}
@@ -217,7 +188,7 @@ func (c *Client) handleError(err error) {
 		if c.OnError != nil {
 			c.OnError(err)
 		} else {
-			fmt.Println("error: ", err)
+			log.Println("error:", err)
 		}
 	}
 }