version 1.86 ready for binaries

Author: johnlauer

README.md

@@ -328,6 +328,7 @@ sudo service serial-port-json-server start
 Revisions
 -------
 Changes in 1.86
+- Rewrote "tinyg" buffer to use better locking technique on in/out thread to remove chance that r:{}'s are lost and jobs get paused mysteriously. Now report {"Lbs":xx} which is a LocalBufferSize report that tells the UI how many characters are in the TinyG buffer from SPJS's perspective. This will help users see if in fact there is a mis-sync between what SPJS thinks is in the TinyG buffer and what actually is in that buffer. The {"Lbs":0} value will be reported back after every r:{} received from TinyG.
 - Added "Pause" value in sendjson command so you can ask SPJS to pause after sending a serial command. This was needed because on Atmel processors during an EEPROM write all data is dropped that is sent in on the serial lines. To use this value, send in a sendjson command similar to the following:
 `sendjson {"P":"COM7","Data":[{"D":"{\"ej\":1}\n","Id":"tinygInit-cmd182","Pause":50}]}`
 - Added "tinyg_tidmode" buffer which is the most advanced buffer ever added to SPJS. This buffer uses a primary key for each line sent to TinyG and TinyG sends back the primary key as it processes each line. This means that SPJS will be in 100% perfect sync with TinyG. This will solve the longstanding hard-to-find bug where users would occasionally get random pausing because SPJS thought TinyG's buffer was full, but it really wasn't.

bufferflow.go

@@ -5,7 +5,7 @@ import (
 //"time"
 )
 
-var availableBufferAlgorithms = []string{"default", "tinyg", "tinyg_v2", "tinyg_linemode", "tinyg_tidmode", "tinygg2", "grbl", "marlin"}
+var availableBufferAlgorithms = []string{"default", "tinyg", "tinyg_old", "tinyg_linemode", "tinyg_tidmode", "tinygg2", "grbl", "marlin"}
 
 //var availableBufferAlgorithms = []string{"default", "tinyg", "tinygg2", "dummypause", "grbl"}
 

bufferflow_tinyg_v2.go

@@ -4,7 +4,7 @@ import (
 	"encoding/json"
 	"log"
 	"regexp"
-	"strconv"
+	//"strconv"
 	"strings"
 	"sync"
 	//"time"
@@ -135,15 +135,13 @@ func (b *BufferflowTinygV2) Init() {
 
 	go func() {
 		time.Sleep(2500 * time.Millisecond)
-		spWriteJson("sendjson {\"P\":\"" + b.parent_serport.portConf.Name + "\",\"Data\":[{\"D\":\"" + "{\\\"rxm\\\":0}\\n\", \"Id\":\"internalInit0\", \"Pause\":50}]}")
+		//spWriteJson("sendjson {\"P\":\"" + b.parent_serport.portConf.Name + "\",\"Data\":[{\"D\":\"" + "{\\\"rxm\\\":0}\\n\", \"Id\":\"internalInit0\", \"Pause\":50}]}")
 
 	}()
 }
 
 func (b *BufferflowTinygV2) RewriteSerialData(cmd string, id string) string {
 
-	b.q.Push(cmd, id)
-
 	return ""
 }
 
@@ -170,17 +168,19 @@ func (b *BufferflowTinygV2) BlockUntilReady(cmd string, id string) (bool, bool,
 		// Normal Command - i.e. it returns response
 
 		newCmd = b.RewriteSerialData(cmd, id)
+		b.q.Push(cmd, id)
+		log.Printf("\tWe have cmd that returns response. cmd:%v\n", strings.Replace(cmd, "\n", "\\n", -1))
 
 	} else {
 
 		// this is sketchy. could we overrun the buffer by not counting !~%\n
 		// so to give extra room don't actually allow full serial buffer to
 		// be used in b.BufferMax
-		log.Printf("\tWe have cmd that returns no response, so not incrementing buffer size for cmd:%v\n", cmd)
+		log.Printf("\tWe have cmd that returns no response, so not incrementing buffer size for cmd:%v\n", strings.Replace(cmd, "\n", "\\n", -1))
 
 	}
 
-	log.Printf("\tLen of cmd: %v, new len of local queue:%v\n", len(cmd), b.q.LenOfCmds())
+	log.Printf("\tLen of cmd: %v, new len of local queue:%v, debugStr:%v\n", len(cmd), b.q.LenOfCmds(), b.q.DebugStr())
 
 	if b.q.LenOfCmds() >= b.BufferMax {
 		b.SetPaused(true, 0) // b.Paused = true
@@ -236,6 +236,9 @@ func (b *BufferflowTinygV2) BlockUntilReady(cmd string, id string) (bool, bool,
 }
 
 type LocalRemoteBuffers struct {
+	LocalBufSize int    `json:"Lbs"`
+	CmdCnt       int    `json:"-"`
+	Cmds         string `json:"-"`
 }
 
 type BufferStats struct {
@@ -293,16 +296,30 @@ func (b *BufferflowTinygV2) OnIncomingData(data string) {
 					h.broadcastSys <- bm
 				}
 
+				// For debug
+				mLocalQueue := LocalRemoteBuffers{}
+				mLocalQueue.LocalBufSize = b.q.LenOfCmds()
+				mLocalQueue.CmdCnt = b.q.Len()
+				//mLocalQueue.Cmds = b.q.DebugStr()
+				bmLocalQueue, errlq := json.Marshal(mLocalQueue)
+				if errlq != nil {
+					log.Printf("\tCould not marshal localBufSize debug stmt:%v", mLocalQueue)
+				} else {
+					log.Printf("\tHere is our localBufSize debug stmt:%v", string(bmLocalQueue))
+				}
+
 				// we need to send a buffer size update
 				mbs := BufferStats{}
 				mbs.P = b.Port
-				mbs.D = "{\"LocalBufSize\":" + strconv.Itoa(b.q.LenOfCmds()) + "}\n"
+				//mbs.D = "{\"LocalBufSize\":" + strconv.Itoa(b.q.LenOfCmds()) + ",\"Cmds\":\"" + b.q.DebugStr() + "\"}\n"
+				mbs.D = string(bmLocalQueue) + "\n"
 				bmbs, err2 := json.Marshal(mbs)
 				if err2 == nil {
 					h.broadcastSys <- bmbs
+					//log.Printf("\tFinal buf size update:%v", string(bmbs))
 				}
 
-				log.Printf("\tLocal buffer decreased to itemCnt:%v, lenOfBuf:%v\n", b.q.Len(), b.q.LenOfCmds())
+				//log.Printf("\tLocal buffer decreased to itemCnt:%v, lenOfBuf:%v\n", b.q.Len(), b.q.LenOfCmds())
 
 				if *bufFlowDebugType == "on" {
 					// let's report on how our buffer is doing

main.go

@@ -1,4 +1,4 @@
-// Version 1.85
+// Version 1.86
 // Supports Windows, Linux, Mac, and Raspberry Pi, Beagle Bone Black
 
 package main
@@ -22,8 +22,8 @@ import (
 )
 
 var (
-	version      = "1.85"
-	versionFloat = float32(1.85)
+	version      = "1.86"
+	versionFloat = float32(1.86)
 	addr         = flag.String("addr", ":8989", "http service address")
 	//assets       = flag.String("assets", defaultAssetPath(), "path to assets")
 	//verbose = flag.Bool("v", true, "show debug logging")

queue.go

@@ -28,7 +28,10 @@
 
 package main
 
-import "sync"
+import (
+	"strings"
+	"sync"
+)
 
 type queuenode struct {
 	data string
@@ -141,3 +144,21 @@ func (q *Queue) Delete() {
 	q.count = 0
 	q.lenOfCmds = 0
 }
+
+func (q *Queue) DebugStr() string {
+	q.lock.Lock()
+	defer q.lock.Unlock()
+
+	str := ""
+	if q.head != nil {
+		str += q.head.id + ":" + strings.Replace(q.head.data, "\n", "\\n", -1)
+
+		n := q.head.next
+		for n != nil {
+			str += ", " + n.id + ":" + strings.Replace(n.data, "\n", "\\n", -1)
+			n = n.next
+		}
+	}
+
+	return str
+}

serialport.go

@@ -227,7 +227,7 @@ func (p *serport) writerBuffered() {
 	// sees something come in
 	for data := range p.sendBuffered {
 
-		log.Printf("Got p.sendBuffered. data:%v, id:%v, pause:%v\n", string(data.data), string(data.id), data.pause)
+		log.Printf("Got p.sendBuffered. data:%v, id:%v, pause:%v\n", strings.Replace(string(data.data), "\n", "\\n", -1), string(data.id), data.pause)
 
 		// we want to block here if we are being asked
 		// to pause.
@@ -428,13 +428,13 @@ func spHandlerOpen(portname string, baud int, buftype string, isSecondary bool)
 	p := &serport{sendBuffered: make(chan Cmd, 500000), sendNoBuf: make(chan Cmd), portConf: conf, portIo: sp, BufferType: buftype, IsPrimary: isPrimary, IsSecondary: isSecondary}
 
 	// if user asked for a buffer watcher, i.e. tinyg/grbl then attach here
-	if buftype == "tinyg" {
+	if buftype == "tinyg_old" {
 
 		bw := &BufferflowTinyg{Name: "tinyg", parent_serport: p}
 		bw.Init()
 		bw.Port = portname
 		p.bufferwatcher = bw
-	} else if buftype == "tinyg_v2" {
+	} else if buftype == "tinyg" {
 
 		bw := &BufferflowTinygV2{Name: "tinyg_v2", parent_serport: p}
 		bw.Init()