Removed possibility to enable/disable logging. Just subscribe to appropriate channel

Author: dyrkin

README.md

@@ -11,11 +11,12 @@ I tested it with cc253**1**, but it might work with cc253**X**
 
 ## Example
 
-To use it you need to provide a reference to a serial port:
+To use it you need to provide a reference to an unp instance:
 
 ```go
 import (
 	"go.bug.st/serial.v1"
+	"github.com/davecgh/go-spew/spew"
 	"github.com/dyrkin/unp-go"
 	"github.com/dyrkin/znp-go"
 )
@@ -33,6 +34,7 @@ func main() {
 
 	u := unp.New(1, port)
 	z := znp.New(u)
+	z.Start()
 }
 ```
 
@@ -50,5 +52,35 @@ if err != nil {
 }
 ```
 
+To receive async commands and errors, use `AsyncInbound()` and `Errors()` channels:
+
+```go
+go func() {
+    for {
+        select {
+        case err := <-z.Errors():
+            fmt.Printf("Error received: %s\n", err)
+        case async := <-z.AsyncInbound():
+            fmt.Printf("Async received: %s\n", spew.Sdump(async))
+        }
+    }
+}()
+```
+
+To log all ingoing and outgoing unp frames, use `InFramesLog()` and `OutFramesLog()` channels:
+
+```go
+go func() {
+    for {
+        select {
+        case frame := <-z.OutFramesLog():
+            fmt.Printf("Frame sent: %s\n", spew.Sdump(frame))
+        case frame := <-z.InFramesLog():
+            fmt.Printf("Frame received: %s\n", spew.Sdump(frame))
+        }
+    }
+}()
+```
+
 See more [examples](example/example.go)
 

example/example.go

@@ -1,15 +1,14 @@
 package main
 
 import (
-	"encoding/json"
 	"fmt"
 	"log"
 	"time"
 
 	"github.com/davecgh/go-spew/spew"
-	unp "github.com/dyrkin/unp-go"
-	znp "github.com/dyrkin/znp-go"
-	serial "go.bug.st/serial.v1"
+	"github.com/dyrkin/unp-go"
+	"github.com/dyrkin/znp-go"
+	"go.bug.st/serial.v1"
 )
 
 func main() {
@@ -21,38 +20,32 @@ func main() {
 
 	port, err := serial.Open("/dev/tty.usbmodem14101", mode)
 	if err != nil {
-		log.Fatal(err)
+		log.Fatalf("Can't open port. Reason: %s", err)
 	}
 	port.SetRTS(true)
 
 	u := unp.New(1, port)
 	z := znp.New(u)
-	z.LogInFrames(true)
-	z.LogOutFrames(true)
 	z.Start()
 
-	printChan := make(chan string)
-
 	go func() {
 		for {
 			select {
-			case msg := <-printChan:
-				fmt.Print(msg)
+			case err := <-z.Errors():
+				fmt.Printf("Error received: %s\n", err)
+			case async := <-z.AsyncInbound():
+				fmt.Printf("Async received: %s\n", spew.Sdump(async))
 			}
 		}
 	}()
 
 	go func() {
 		for {
 			select {
-			case err := <-z.Errors():
-				printChan <- fmt.Sprintf("Error: %s\n", err)
-			case async := <-z.AsyncInbound():
-				printChan <- fmt.Sprintf("Async: %s\n", spew.Sdump(async))
-			case _ = <-z.OutFramesLog():
-				// printChan <- fmt.Sprintf("Frame sent: %s\n", spew.Sdump(frame))
-			case _ = <-z.InFramesLog():
-				// printChan <- fmt.Sprintf("Frame received: %s\n", spew.Sdump(frame))
+			case frame := <-z.OutFramesLog():
+				fmt.Printf("Frame sent: %s\n", spew.Sdump(frame))
+			case frame := <-z.InFramesLog():
+				fmt.Printf("Frame received: %s\n", spew.Sdump(frame))
 			}
 		}
 	}()
@@ -386,8 +379,3 @@ func main() {
 func PrintStruct(v interface{}) {
 	spew.Dump(v)
 }
-
-func RenderStruct(v interface{}) string {
-	jsonBytes, _ := json.Marshal(v)
-	return string(jsonBytes)
-}

processor.go

@@ -89,7 +89,10 @@ func startProcessors(znp *Znp) {
 				case unp.C_AREQ:
 					asyncResponseProcessor(frame)
 				default:
-					znp.errors <- fmt.Errorf("unsupported frame received type: %v ", frame)
+					select {
+					case znp.errors <- fmt.Errorf("unsupported frame received type: %v ", frame):
+					default:
+					}
 				}
 			}
 		}
@@ -103,9 +106,12 @@ func startIncomingFrameLoop(znp *Znp) {
 		for znp.started {
 			frame, err := znp.u.ReadFrame()
 			if err != nil {
-				znp.errors <- err
+				select {
+				case znp.errors <- err:
+				default:
+				}
 			} else {
-				logFrame(frame, znp.logInFrames, znp.inFramesLog)
+				logFrame(frame, znp.inFramesLog)
 				znp.inbound <- frame
 			}
 		}
@@ -117,7 +123,7 @@ func makeSyncRequestProcessor(znp *Znp, syncRsp chan *unp.Frame, syncErr chan er
 	return func(req *request.Sync) {
 		frame := req.Frame()
 		deadline := time.NewTimer(5 * time.Second)
-		logFrame(frame, znp.logOutFrames, znp.outFramesLog)
+		logFrame(frame, znp.outFramesLog)
 		err := znp.u.WriteFrame(frame)
 		if err != nil {
 			req.SyncErr() <- err
@@ -140,7 +146,7 @@ func makeSyncRequestProcessor(znp *Znp, syncRsp chan *unp.Frame, syncErr chan er
 
 func makeAsyncRequestProcessor(znp *Znp) func(req *request.Async) {
 	return func(req *request.Async) {
-		logFrame(req.Frame(), znp.logOutFrames, znp.outFramesLog)
+		logFrame(req.Frame(), znp.outFramesLog)
 		znp.u.WriteFrame(req.Frame())
 	}
 }
@@ -169,15 +175,25 @@ func makeAsyncResponseProcessor(znp *Znp) func(frame *unp.Frame) {
 		if value, ok := asyncCommandRegistry[key]; ok {
 			cp := reflection.Copy(value)
 			bin.Decode(frame.Payload, cp)
-			znp.asyncInbound <- cp
+			select {
+			case znp.asyncInbound <- cp:
+			default:
+			}
 		} else {
-			znp.errors <- fmt.Errorf("unknown async command received: %v", frame)
+			select {
+			case znp.errors <- fmt.Errorf("unknown async command received: %v", frame):
+			default:
+			}
 		}
 	}
 }
 
-func logFrame(frame *unp.Frame, log bool, logger chan *unp.Frame) {
-	if log {
-		logger <- frame
-	}
+func logFrame(frame *unp.Frame, logger chan *unp.Frame) {
+	go func() {
+		select {
+		case logger <- frame:
+		default:
+		}
+	}()
+
 }

znp.go

@@ -1,7 +1,7 @@
 package znp
 
 import (
-	unp "github.com/dyrkin/unp-go"
+	"github.com/dyrkin/unp-go"
 
 	"github.com/dyrkin/znp-go/request"
 )
@@ -14,8 +14,6 @@ type Znp struct {
 	errors       chan error
 	inFramesLog  chan *unp.Frame
 	outFramesLog chan *unp.Frame
-	logInFrames  bool
-	logOutFrames bool
 	started      bool
 }
 
@@ -25,17 +23,13 @@ func New(u *unp.Unp) *Znp {
 		outbound:     make(chan request.Outgoing),
 		inbound:      make(chan *unp.Frame),
 		asyncInbound: make(chan interface{}),
-		errors:       make(chan error),
+		errors:       make(chan error, 100),
 		inFramesLog:  make(chan *unp.Frame, 100),
 		outFramesLog: make(chan *unp.Frame, 100),
 	}
 	return znp
 }
 
-func (znp *Znp) LogInFrames(enabled bool) {
-	znp.logInFrames = enabled
-}
-
 func (znp *Znp) Errors() chan error {
 	return znp.errors
 }
@@ -52,10 +46,6 @@ func (znp *Znp) OutFramesLog() chan *unp.Frame {
 	return znp.outFramesLog
 }
 
-func (znp *Znp) LogOutFrames(enabled bool) {
-	znp.logOutFrames = enabled
-}
-
 func (znp *Znp) IsStarted() bool {
 	return znp.started
 }