feat: remove bufferAlgorithm param from the open command

.github/workflows/release.yml

@@ -286,6 +286,11 @@ jobs:
             -k "${{ env.KEYCHAIN_PASSWORD }}" \
             "${{ env.KEYCHAIN }}"
 
+      - name: Install Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: ${{ env.GO_VERSION }}
+
       - name: Install gon for code signing
         uses: actions/checkout@v4
         with:

bufferflow_timed.go

@@ -33,8 +33,8 @@ type BufferflowTimed struct {
 	bufferedOutput string
 }
 
-// NewBufferflowTimed will create a new timed bufferflow
-func NewBufferflowTimed(port string, output chan<- []byte) *BufferflowTimed {
+// NewBufferFlowTimed will create a new timed bufferflow
+func NewBufferFlowTimed(port string, output chan<- []byte) *BufferflowTimed {
 	return &BufferflowTimed{
 		port:           port,
 		output:         output,
@@ -48,7 +48,7 @@ func NewBufferflowTimed(port string, output chan<- []byte) *BufferflowTimed {
 
 // Init will initialize the bufferflow
 func (b *BufferflowTimed) Init() {
-	log.Println("Initting timed buffer flow (output once every 16ms)")
+	log.Println("Start consuming from serial port (output once every 16ms)")
 	go b.consumeInput()
 }
 

hub.go

@@ -58,7 +58,7 @@ var h = hub{
 const commands = `{
   "Commands": [
     "list",
-    "open <portName> <baud> [bufferAlgorithm: ({default}, timed, timedraw)]",
+    "open <portName> <baud>",
     "(send, sendnobuf, sendraw) <portName> <cmd>",
     "close <portName>",
     "restart",
@@ -146,15 +146,13 @@ func checkCmd(m []byte) {
 			go spErr("Problem converting baud rate " + args[2])
 			return
 		}
-		// pass in buffer type now as string. if user does not
-		// ask for a buffer type pass in empty string
-		bufferAlgorithm := "default" // use the default buffer if none is specified
+
+		// Ignore extra "buffer type" param for backward compatibility
 		if len(args) > 3 {
-			// cool. we got a buffer type request
-			buftype := strings.Replace(args[3], "\n", "", -1)
-			bufferAlgorithm = buftype
+			log.Warn(fmt.Sprintf("Unexpected arguments for the open command. Ignored arguments: '%s'.", args[3:]))
 		}
-		go spHandlerOpen(args[1], baud, bufferAlgorithm)
+
+		go spHandlerOpen(args[1], baud)
 
 	} else if strings.HasPrefix(sl, "close") {
 

serial.go

@@ -67,7 +67,7 @@ var sh = serialhub{
 func (sh *serialhub) Register(port *serport) {
 	sh.mu.Lock()
 	//log.Print("Registering a port: ", p.portConf.Name)
-	h.broadcastSys <- []byte("{\"Cmd\":\"Open\",\"Desc\":\"Got register/open on port.\",\"Port\":\"" + port.portConf.Name + "\",\"Baud\":" + strconv.Itoa(port.portConf.Baud) + ",\"BufferType\":\"" + port.BufferType + "\"}")
+	h.broadcastSys <- []byte("{\"Cmd\":\"Open\",\"Desc\":\"Got register/open on port.\",\"Port\":\"" + port.portConf.Name + "\",\"Baud\":" + strconv.Itoa(port.portConf.Baud) + "}")
 	sh.ports[port] = true
 	sh.mu.Unlock()
 }

serialport.go

@@ -22,7 +22,6 @@ import (
 	"strconv"
 	"sync/atomic"
 	"time"
-	"unicode/utf8"
 
 	log "github.com/sirupsen/logrus"
 	serial "go.bug.st/serial"
@@ -57,10 +56,7 @@ type serport struct {
 	// channel containing raw base64 encoded binary data (outbound messages)
 	sendRaw chan string
 
-	// Do we have an extra channel/thread to watch our buffer?
-	BufferType string
-	//bufferwatcher *BufferflowDummypause
-	bufferwatcher Bufferflow
+	bufferFlow *BufferflowTimed
 }
 
 // SpPortMessage is the serial port message
@@ -75,15 +71,13 @@ type SpPortMessageRaw struct {
 	D []byte // the data, i.e. G0 X0 Y0
 }
 
-func (p *serport) reader(buftype string) {
+func (p *serport) reader() {
 
 	timeCheckOpen := time.Now()
-	var bufferedCh bytes.Buffer
 
 	serialBuffer := make([]byte, 1024)
 	for {
 		n, err := p.portIo.Read(serialBuffer)
-		bufferPart := serialBuffer[:n]
 
 		//if we detect that port is closing, break out of this for{} loop.
 		if p.isClosing.Load() {
@@ -96,39 +90,8 @@ func (p *serport) reader(buftype string) {
 		// read can return legitimate bytes as well as an error
 		// so process the n bytes red, if n > 0
 		if n > 0 && err == nil {
-
-			log.Print("Read " + strconv.Itoa(n) + " bytes ch: " + string(bufferPart[:n]))
-
-			data := ""
-			switch buftype {
-			case "timedraw", "timed":
-				data = string(bufferPart[:n])
-				// give the data to our bufferflow so it can do it's work
-				// to read/translate the data to see if it wants to block
-				// writes to the serialport. each bufferflow type will decide
-				// this on its own based on its logic
-				p.bufferwatcher.OnIncomingData(data)
-			case "default": // the bufferbuftype is actually called default 🤷‍♂️
-				// save the left out bytes for the next iteration due to UTF-8 encoding
-				bufferPart = append(bufferedCh.Bytes(), bufferPart[:n]...)
-				n += len(bufferedCh.Bytes())
-				bufferedCh.Reset()
-				for i, w := 0, 0; i < n; i += w {
-					runeValue, width := utf8.DecodeRune(bufferPart[i:n]) // try to decode the first i bytes in the buffer (UTF8 runes do not have a fixed length)
-					if runeValue == utf8.RuneError {
-						bufferedCh.Write(bufferPart[i:n])
-						break
-					}
-					if i == n {
-						bufferedCh.Reset()
-					}
-					data += string(runeValue)
-					w = width
-				}
-				p.bufferwatcher.OnIncomingData(data)
-			default:
-				log.Panicf("unknown buffer type %s", buftype)
-			}
+			log.Print("Read " + strconv.Itoa(n) + " bytes ch: " + string(serialBuffer[:n]))
+			p.bufferFlow.OnIncomingData(string(serialBuffer[:n]))
 		}
 
 		// double check that we got characters in the buffer
@@ -273,7 +236,7 @@ func (p *serport) writerRaw() {
 	h.broadcastSys <- []byte(msgstr)
 }
 
-func spHandlerOpen(portname string, baud int, buftype string) {
+func spHandlerOpen(portname string, baud int) {
 
 	log.Print("Inside spHandler")
 
@@ -312,23 +275,10 @@ func spHandlerOpen(portname string, baud int, buftype string) {
 		portConf:     conf,
 		portIo:       sp,
 		portName:     portname,
-		BufferType:   buftype}
-
-	var bw Bufferflow
-
-	switch buftype {
-	case "timed":
-		bw = NewBufferflowTimed(portname, h.broadcastSys)
-	case "timedraw":
-		bw = NewBufferflowTimedRaw(portname, h.broadcastSys)
-	case "default":
-		bw = NewBufferflowDefault(portname, h.broadcastSys)
-	default:
-		log.Panicf("unknown buffer type: %s", buftype)
 	}
 
-	bw.Init()
-	p.bufferwatcher = bw
+	p.bufferFlow = NewBufferFlowTimed(portname, h.broadcastSys)
+	p.bufferFlow.Init()
 
 	sh.Register(p)
 	defer sh.Unregister(p)
@@ -343,15 +293,15 @@ func spHandlerOpen(portname string, baud int, buftype string) {
 	// this is thread to send to serial port but with base64 decoding
 	go p.writerRaw()
 
-	p.reader(buftype)
+	p.reader()
 
 	serialPorts.List()
 }
 
 func (p *serport) Close() {
 	p.isClosing.Store(true)
 
-	p.bufferwatcher.Close()
+	p.bufferFlow.Close()
 	p.portIo.Close()
 	serialPorts.MarkPortAsClosed(p.portName)
 	serialPorts.List()