bufferflow_grbl.go

package main

import (
	"encoding/json"
	"log"
	"regexp"
	"strconv"
	"strings"
	"sync"
	"time"
	"unicode/utf8"
)

type BufferflowGrbl struct {
	Name      string
	Port      string
	Paused    bool
	BufferMax int
	q         *Queue

	// use thread locking for b.Paused
	lock *sync.Mutex

	sem            chan int
	LatestData     string
	LastStatus     string
	version        string
	quit           chan int
	parent_serport *serport

	reNewLine *regexp.Regexp
	ok        *regexp.Regexp
	err       *regexp.Regexp
	initline  *regexp.Regexp
	qry       *regexp.Regexp
	rpt       *regexp.Regexp
}

type DataCmdError struct {
	DataCmdComplete
	ErrorCode	string
}

func (b *BufferflowGrbl) Init() {
	b.lock = &sync.Mutex{}
	b.SetPaused(false, 1)

	log.Println("Initting GRBL buffer flow")
	// b.BufferMax = 127 //max buffer size 127 bytes available
	b.BufferMax = 125 // changed to be safe with extra chars

	b.q = NewQueue()

	//create channels
	b.sem = make(chan int)

	//define regex
	b.reNewLine, _ = regexp.Compile("\\r{0,1}\\n{1,2}") //\\r{0,1}
	b.ok, _ = regexp.Compile("^ok")
	b.err, _ = regexp.Compile("^error")
	b.initline, _ = regexp.Compile("^Grbl")
	b.qry, _ = regexp.Compile("\\?")
	b.rpt, _ = regexp.Compile("^<")

	//initialize query loop
	b.rptQueryLoop(b.parent_serport)
}

func (b *BufferflowGrbl) RewriteSerialData(cmd string, id string) string {
	return ""
}

func (b *BufferflowGrbl) BlockUntilReady(cmd string, id string) (bool, bool, string) {
	log.Printf("BlockUntilReady() start\n")

	b.q.Push(cmd, id)

	log.Printf("New line length: %v, buffer size increased to:%v\n", len(cmd), b.q.LenOfCmds())
	log.Println(b.q)

	if b.q.LenOfCmds() >= b.BufferMax {
		b.SetPaused(true, 0)
		log.Printf("Buffer Full - Will send this command when space is available")
	}

	if b.GetPaused() {
		log.Println("It appears we are being asked to pause, so we will wait on b.sem")
		// We are being asked to pause our sending of commands

		// clear all b.sem signals so when we block below, we truly block
		b.ClearOutSemaphore()

		log.Println("Blocking on b.sem until told from OnIncomingData to go")
		unblockType, ok := <-b.sem // will block until told from OnIncomingData to go

		log.Printf("Done blocking cuz got b.sem semaphore release. ok:%v, unblockType:%v\n", ok, unblockType)

		// we get an unblockType of 1 for normal unblocks
		// we get an unblockType of 2 when we're being asked to wipe the buffer, i.e. from a % cmd
		if unblockType == 2 {
			log.Println("This was an unblock of type 2, which means we're being asked to wipe internal buffer. so return false.")
			// returning false asks the calling method to wipe the serial send once
			// this function returns
			return false, false, ""
		}

		log.Printf("BlockUntilReady(cmd:%q, id:%v) end\n", cmd, id)
	}
	return true, true, ""
}

func (b *BufferflowGrbl) OnIncomingData(data string) {
	log.Printf("OnIncomingData() start. data:%q\n", data)

	b.LatestData += data

	//it was found ok was only received with status responses until the grbl buffer is full.
	//b.LatestData = regexp.MustCompile(">\\r\\nok").ReplaceAllString(b.LatestData, ">") //remove oks from status responses

	arrLines := b.reNewLine.Split(b.LatestData, -1)
	log.Printf("arrLines:%v\n", arrLines)

	if len(arrLines) > 1 {
		// that means we found a newline and have 2 or greater array values
		// so we need to analyze our arrLines[] lines but keep last line
		// for next trip into OnIncomingData
		log.Printf("We have data lines to analyze. numLines:%v\n", len(arrLines))

	} else {
		// we don't have a newline yet, so just exit and move on
		// we don't have to reset b.LatestData because we ended up
		// without any newlines so maybe we will next time into this method
		log.Printf("Did not find newline yet, so nothing to analyze\n")
		return
	}

	// if we made it here we have lines to analyze
	// so analyze all of them except the last line
	for index, element := range arrLines[:len(arrLines)-1] {
		log.Printf("Working on element:%v, index:%v", element, index)

		//check for 'ok' or 'error' response indicating a gcode line has been processed
		if b.ok.MatchString(element) || b.err.MatchString(element) {
			if b.q.Len() > 0 {
				doneCmd, id := b.q.Poll()

				if b.ok.MatchString(element) {
					// Send cmd:"Complete" back
					m := DataCmdComplete{"Complete", id, b.Port, b.q.LenOfCmds(), doneCmd}
					bm, err := json.Marshal(m)
					if err == nil {
						h.broadcastSys <- bm
					}
				} else if b.err.MatchString(element) {
					// Send cmd:"Error" back
					log.Printf("Error Response Received:%v, id:%v", doneCmd, id)
					arrErrors := strings.SplitN(element, ":", 2)
					errCode := ""
					if len(arrErrors) == 2 {
						errCode = arrErrors[1]
					}
					m := DataCmdError{DataCmdComplete{"Error", id, b.Port, b.q.LenOfCmds(), doneCmd}, errCode}
					bm, err := json.Marshal(m)
					if err == nil {
						h.broadcastSys <- bm
					}
				}

				log.Printf("Buffer decreased to itemCnt:%v, lenOfBuf:%v\n", b.q.Len(), b.q.LenOfCmds())
			} else {
				log.Printf("We should NEVER get here cuz we should have a command in the queue to dequeue when we get the r:{} response. If you see this debug stmt this is BAD!!!!")
			}

			if b.q.LenOfCmds() < b.BufferMax {

				log.Printf("Grbl just completed a line of gcode\n")

				// if we are paused, tell us to unpause cuz we have clean buffer room now
				if b.GetPaused() {
					b.SetPaused(false, 1)
				}
			}

			//check for the grbl init line indicating the arduino is ready to accept commands
			//could also pull version from this string, if we find a need for that later
		} else if b.initline.MatchString(element) {
			//grbl init line received, clear anything from current buffer and unpause
			b.LocalBufferWipe(b.parent_serport)

			//unpause buffer but wipe the command in the queue as grbl has restarted.
			if b.GetPaused() {
				b.SetPaused(false, 2)
			}

			b.version = element //save element in version

			//Check for report output, compare to last report output, if different return to client to update status; otherwise ignore status.
		} else if b.rpt.MatchString(element) {
			if element == b.LastStatus {
				log.Println("Grbl status has not changed, not reporting to client")
				continue //skip this element as the cnc position has not changed, and move on to the next element.
			}

			b.LastStatus = element //if we make it here something has changed with the status string and laststatus needs updating
		}

		// handle communication back to client
		m := DataPerLine{b.Port, element + "\n"}
		bm, err := json.Marshal(m)
		if err == nil {
			h.broadcastSys <- bm
		}

	} // for loop

	// now wipe the LatestData to only have the last line that we did not analyze
	// because we didn't know/think that was a full command yet
	b.LatestData = arrLines[len(arrLines)-1]

	//time.Sleep(3000 * time.Millisecond)
	log.Printf("OnIncomingData() end.\n")
}

// Clean out b.sem so it can truly block
func (b *BufferflowGrbl) ClearOutSemaphore() {
	ctr := 0

	keepLooping := true
	for keepLooping {
		select {
		case d, ok := <-b.sem:
			log.Printf("Consuming b.sem queue to clear it before we block. ok:%v, d:%v\n", ok, string(d))
			ctr++
			if ok == false {
				keepLooping = false
			}
		default:
			keepLooping = false
			log.Println("Hit default in select clause")
		}
	}
	log.Printf("Done consuming b.sem queue so we're good to block on it now. ctr:%v\n", ctr)
	// ok, all b.sem signals are now consumed into la-la land
}

func (b *BufferflowGrbl) BreakApartCommands(cmd string) []string {

	// add newline after !~%
	log.Printf("Command Before Break-Apart: %q\n", cmd)

	cmds := strings.Split(cmd, "\n")
	finalCmds := []string{}
	for _, item := range cmds {
		//remove comments and whitespace from item
		item = regexp.MustCompile("\\(.*?\\)").ReplaceAllString(item, "")
		item = regexp.MustCompile(";.*").ReplaceAllString(item, "")
		item = strings.Replace(item, " ", "", -1)

		if len(item) > utf8.RuneCountInString(item) {	// If item contains UTF-8 chars other than ASCII. Extended ASCII must be extracted from UTF8 code point
			r := []rune(item)			// Note : Extended ASCII are used for some realtime commands
			a := make([]byte, len(r))
			for idx, element := range r {
				a[idx] = byte(element)
        		}
			item = string(a)
		}
		
		if item == "*init*" { //return init string to update grbl widget when already connected to grbl
			m := DataPerLine{b.Port, b.version + "\n"}
			bm, err := json.Marshal(m)
			if err == nil {
				h.broadcastSys <- bm
			}
		} else if item == "*status*" { //return status when client first connects to existing open port
			m := DataPerLine{b.Port, b.LastStatus + "\n"}
			bm, err := json.Marshal(m)
			if err == nil {
				h.broadcastSys <- bm
			}
		} else if b.SeeIfSpecificCommandsShouldSkipBuffer(item) {	// realtime commands don't need '\n'
			log.Printf("Query added without newline: %q\n", item)
			finalCmds = append(finalCmds, item) //append query request without newline character
		} else if item == "%" {
			log.Printf("Wiping Grbl BufferFlow")
			b.LocalBufferWipe(b.parent_serport)
			//dont add this command to the list of finalCmds
		} else if item != "" {
			log.Printf("Re-adding newline to item:%q\n", item)
			s := item + "\n"
			finalCmds = append(finalCmds, s)
			log.Printf("New cmd item:%q\n", s)
		}

	}
	log.Printf("Final array of cmds after BreakApartCommands(). finalCmds:%v\n", finalCmds)

	return finalCmds
	//return []string{cmd} //do not process string
}

func (b *BufferflowGrbl) Pause() {
	b.SetPaused(true, 0)
	//b.BypassMode = false // turn off bypassmode in case it's on
	log.Println("Paused buffer on next BlockUntilReady() call")
}

func (b *BufferflowGrbl) Unpause() {
	//unpause buffer by setting paused to false and passing a 1 to b.sem
	b.SetPaused(false, 1)
	log.Println("Unpaused buffer inside BlockUntilReady() call")
}

func (b *BufferflowGrbl) SeeIfSpecificCommandsShouldSkipBuffer(cmd string) bool {
	if len(cmd) != 1 {		// Skip buffer commands (=realtime commands) are always single byte
		return false
	}
	c := cmd[0]				// Extract ASCII code
	return c == '!' || c == '~' || c == '?' || c == 0x18 || c >= 0x80 
	// remove comments
	//cmd = regexp.MustCompile("\\(.*?\\)").ReplaceAllString(cmd, "")
	//cmd = regexp.MustCompile(";.*").ReplaceAllString(cmd, "")
	// adding some new regexp to match real-time commands for grbl 1 version 
	//if match, _ := regexp.MatchString("[!~\\?]|(\u0018)|[\u0080-\u00FF]", cmd); match {
	//	log.Printf("Found cmd that should skip buffer. cmd:%q\n", cmd)
	//	return true
	//}
	//return false
}

func (b *BufferflowGrbl) SeeIfSpecificCommandsShouldPauseBuffer(cmd string) bool {
	// remove comments
	//cmd = regexp.MustCompile("\\(.*?\\)").ReplaceAllString(cmd, "")
	//cmd = regexp.MustCompile(";.*").ReplaceAllString(cmd, "")
	//if match, _ := regexp.MatchString("[!]", cmd); match {
	//	log.Printf("Found cmd that should pause buffer. cmd:%v\n", cmd)
	//	return true
	//}
	return false	// No command should stop the transmission
}

func (b *BufferflowGrbl) SeeIfSpecificCommandsShouldUnpauseBuffer(cmd string) bool {

	//cmd = regexp.MustCompile("\\(.*?\\)").ReplaceAllString(cmd, "")
	//cmd = regexp.MustCompile(";.*").ReplaceAllString(cmd, "")
	//if match, _ := regexp.MatchString("[~]", cmd); match {
	//	log.Printf("Found cmd that should unpause buffer. cmd:%v\n", cmd)
	//	return true
	//}
	return false	// No command should stop the transmission
}

func (b *BufferflowGrbl) SeeIfSpecificCommandsShouldWipeBuffer(cmd string) bool {

	//cmd = regexp.MustCompile("\\(.*?\\)").ReplaceAllString(cmd, "")
	//cmd = regexp.MustCompile(";.*").ReplaceAllString(cmd, "")
	if match, _ := regexp.MatchString("(\u0018)", cmd); match {
		log.Printf("Found cmd that should wipe out and reset buffer. cmd:%v\n", cmd)

		//b.q.Delete() //delete tracking queue, all buffered commands will be wiped.

		//log.Println("Buffer variables cleared for new input.")
		return true
	}
	return false
}

func (b *BufferflowGrbl) SeeIfSpecificCommandsReturnNoResponse(cmd string) bool {
	/*
		// remove comments
		cmd = b.reComment.ReplaceAllString(cmd, "")
		cmd = b.reComment2.ReplaceAllString(cmd, "")
		if match := b.reNoResponse.MatchString(cmd); match {
			log.Printf("Found cmd that does not get a response from TinyG. cmd:%v\n", cmd)
			return true
		}
	*/
	return false
}

func (b *BufferflowGrbl) ReleaseLock() {
	log.Println("Lock being released in GRBL buffer")

	b.q.Delete()

	log.Println("ReleaseLock(), so we will send signal of 2 to b.sem to unpause the BlockUntilReady() thread")

	//release lock, send signal 2 to b.sem
	b.SetPaused(false, 2)
}

func (b *BufferflowGrbl) IsBufferGloballySendingBackIncomingData() bool {
	//telling json server that we are handling client responses
	return true
}

//Use this function to open a connection, write directly to serial port and close connection.
//This is used for sending query requests outside of the normal buffered operations that will pause to wait for room in the grbl buffer
//'?' is asynchronous to the normal buffer load and does not need to be paused when buffer full
func (b *BufferflowGrbl) rptQueryLoop(p *serport) {
	b.parent_serport = p //make note of this port for use in clearing the buffer later, on error.
	ticker := time.NewTicker(250 * time.Millisecond)
	b.quit = make(chan int)
	go func() {
		for {
			select {
			case <-ticker.C:

				n2, err := p.portIo.Write([]byte("?"))

				log.Print("Just wrote ", n2, " bytes to serial: ?")

				if err != nil {
					errstr := "Error writing to " + p.portConf.Name + " " + err.Error() + " Closing port."
					log.Print(errstr)
					h.broadcastSys <- []byte(errstr)
					ticker.Stop() //stop query loop if we can't write to the port
					break
				}
			case <-b.quit:
				ticker.Stop()
				return
			}
		}
	}()
}

func (b *BufferflowGrbl) Close() {
	//stop the status query loop when the serial port is closed off.
	log.Println("Stopping the status query loop")
	b.quit <- 1
}

//	Gets the paused state of this buffer
//	go-routine safe.
func (b *BufferflowGrbl) GetPaused() bool {
	b.lock.Lock()
	defer b.lock.Unlock()
	return b.Paused
}

//	Sets the paused state of this buffer
//	go-routine safe.
func (b *BufferflowGrbl) SetPaused(isPaused bool, semRelease int) {
	b.lock.Lock()
	defer b.lock.Unlock()
	b.Paused = isPaused

	//if we are unpausing the buffer, we need to send a signal to release the channel
	if isPaused == false {
		go func() {
			// sending a 2 asks BlockUntilReady() to cancel the send
			b.sem <- semRelease
			defer func() {
				log.Printf("Unpause Semaphore just got consumed by the BlockUntilReady()\n")
			}()
		}()
	}
}

//local version of buffer wipe loop needed to handle pseudo clear buffer (%) without passing that value on to
func (b *BufferflowGrbl) LocalBufferWipe(p *serport) {
	log.Printf("Pseudo command received to wipe grbl buffer but *not* send on to grbl controller.")

	// consume all stuff queued
	func() {
		ctr := 0

		keepLooping := true
		for keepLooping {
			select {
			case d, ok := <-p.sendBuffered:
				log.Printf("Consuming sendBuffered queue. ok:%v, d:%v, id:%v\n", ok, string(d.data), string(d.id))
				ctr++

				p.itemsInBuffer--
				if ok == false {
					keepLooping = false
				}
			default:
				keepLooping = false
				log.Println("Hit default in select clause")
			}
		}
		log.Printf("Done consuming sendBuffered cmds. ctr:%v\n", ctr)
	}()

	b.ReleaseLock()

	// let user know we wiped queue
	log.Printf("itemsInBuffer:%v\n", p.itemsInBuffer)
	h.broadcastSys <- []byte("{\"Cmd\":\"WipedQueue\",\"QCnt\":" + strconv.Itoa(p.itemsInBuffer) + ",\"Port\":\"" + p.portConf.Name + "\"}")
}

func (b *BufferflowGrbl) GetManualPaused() bool {
	return false
}

func (b *BufferflowGrbl) SetManualPaused(isPaused bool) {
}