Add serial binary communication

bufferflow.go

@@ -5,7 +5,7 @@ import (
 //"time"
 )
 
-var availableBufferAlgorithms = []string{"default", "timed", "timedraw"}
+var availableBufferAlgorithms = []string{"default", "timed", "timedraw", "timedbinary"}
 
 type BufferMsg struct {
 	Cmd                string
@@ -19,6 +19,7 @@ type Bufferflow interface {
 	Init()
 	BlockUntilReady(cmd string, id string) (bool, bool) // implement this method
 	//JustQueue(cmd string, id string) bool                     // implement this method
+	OnIncomingDataBinary(data []byte)
 	OnIncomingData(data string)                               // implement this method
 	ClearOutSemaphore()                                       // implement this method
 	BreakApartCommands(cmd string) []string                   // implement this method

bufferflow_default.go

@@ -20,6 +20,10 @@ func (b *BufferflowDefault) BlockUntilReady(cmd string, id string) (bool, bool)
 	return true, false
 }
 
+// not implemented, we are gonna use OnIncomingData
+func (b *BufferflowDefault) OnIncomingDataBinary(data []byte) {
+}
+
 func (b *BufferflowDefault) OnIncomingData(data string) {
 	//log.Printf("OnIncomingData() start. data:%v\n", data)
 }

bufferflow_timed.go

@@ -18,7 +18,7 @@ type BufferflowTimed struct {
 
 var (
 	bufferedOutput string
-	sPort string
+	sPort          string
 )
 
 func (b *BufferflowTimed) Init() {
@@ -61,6 +61,10 @@ func (b *BufferflowTimed) BlockUntilReady(cmd string, id string) (bool, bool) {
 	return true, false
 }
 
+// not implemented, we are gonna use OnIncomingData
+func (b *BufferflowTimed) OnIncomingDataBinary(data []byte) {
+}
+
 func (b *BufferflowTimed) OnIncomingData(data string) {
 	b.Input <- data
 }

bufferflow_timedbinary.go

@@ -0,0 +1,114 @@
+package main
+
+import (
+	"encoding/json"
+	"time"
+
+	log "github.com/sirupsen/logrus"
+)
+
+type BufferflowTimedBinary struct {
+	Name   string
+	Port   string
+	Output chan []byte
+	Input  chan []byte
+	done   chan bool
+	ticker *time.Ticker
+}
+
+var (
+	bufferedOutputBinary []byte
+	sPortBinary          string
+)
+
+func (b *BufferflowTimedBinary) Init() {
+	log.Println("Initting timed buffer binary flow (output once every 16ms)")
+	bufferedOutputBinary = nil
+	sPortBinary = ""
+
+	go func() {
+		b.ticker = time.NewTicker(16 * time.Millisecond)
+		b.done = make(chan bool)
+	Loop:
+		for {
+			select {
+			case data := <-b.Input:
+				bufferedOutputBinary = append(bufferedOutputBinary, data...)
+				sPortBinary = b.Port
+			case <-b.ticker.C:
+				if bufferedOutputBinary != nil {
+					m := SpPortMessageRaw{sPortBinary, bufferedOutputBinary}
+					buf, _ := json.Marshal(m)
+					b.Output <- buf
+					bufferedOutputBinary = nil
+					sPortBinary = ""
+				}
+			case <-b.done:
+				break Loop
+			}
+		}
+
+		close(b.Input)
+	}()
+}
+
+func (b *BufferflowTimedBinary) BlockUntilReady(cmd string, id string) (bool, bool) {
+	//log.Printf("BlockUntilReady() start\n")
+	return true, false
+}
+
+func (b *BufferflowTimedBinary) OnIncomingDataBinary(data []byte) {
+	b.Input <- data
+}
+
+// not implemented, we are gonna use OnIncomingDataBinary
+func (b *BufferflowTimedBinary) OnIncomingData(data string) {
+}
+
+// Clean out b.sem so it can truly block
+func (b *BufferflowTimedBinary) ClearOutSemaphore() {
+}
+
+func (b *BufferflowTimedBinary) BreakApartCommands(cmd string) []string {
+	return []string{cmd}
+}
+
+func (b *BufferflowTimedBinary) Pause() {
+	return
+}
+
+func (b *BufferflowTimedBinary) Unpause() {
+	return
+}
+
+func (b *BufferflowTimedBinary) SeeIfSpecificCommandsShouldSkipBuffer(cmd string) bool {
+	return false
+}
+
+func (b *BufferflowTimedBinary) SeeIfSpecificCommandsShouldPauseBuffer(cmd string) bool {
+	return false
+}
+
+func (b *BufferflowTimedBinary) SeeIfSpecificCommandsShouldUnpauseBuffer(cmd string) bool {
+	return false
+}
+
+func (b *BufferflowTimedBinary) SeeIfSpecificCommandsShouldWipeBuffer(cmd string) bool {
+	return false
+}
+
+func (b *BufferflowTimedBinary) SeeIfSpecificCommandsReturnNoResponse(cmd string) bool {
+	return false
+}
+
+func (b *BufferflowTimedBinary) ReleaseLock() {
+}
+
+func (b *BufferflowTimedBinary) IsBufferGloballySendingBackIncomingData() bool {
+	return true
+}
+
+func (b *BufferflowTimedBinary) Close() {
+	b.ticker.Stop()
+	close(b.Input)
+}

bufferflow_timedraw.go

@@ -12,43 +12,57 @@ type BufferflowTimedRaw struct {
 	Port   string
 	Output chan []byte
 	Input  chan string
+	done   chan bool
 	ticker *time.Ticker
 }
 
 var (
 	bufferedOutputRaw []byte
+	sPortRaw          string
 )
 
 func (b *BufferflowTimedRaw) Init() {
-	log.Println("Initting timed buffer flow (output once every 16ms)")
-
-	go func() {
-		for data := range b.Input {
-			bufferedOutputRaw = append(bufferedOutputRaw, []byte(data)...)
-		}
-	}()
+	log.Println("Initting timed buffer raw flow (output once every 16ms)")
+	bufferedOutputRaw = nil
+	sPortRaw = ""
 
 	go func() {
 		b.ticker = time.NewTicker(16 * time.Millisecond)
-		for _ = range b.ticker.C {
-			if len(bufferedOutputRaw) != 0 {
-				m := SpPortMessageRaw{b.Port, bufferedOutputRaw}
-				buf, _ := json.Marshal(m)
-				// data is now encoded in base64 format
-				// need a decoder on the other side
-				b.Output <- []byte(buf)
-				bufferedOutputRaw = nil
+		b.done = make(chan bool)
+	Loop:
+		for {
+			select {
+			case data := <-b.Input:
+				bufferedOutputRaw = append(bufferedOutputRaw, []byte(data)...)
+				sPortRaw = b.Port
+			case <-b.ticker.C:
+				if bufferedOutputRaw != nil {
+					m := SpPortMessageRaw{sPortRaw, bufferedOutputRaw}
+					buf, _ := json.Marshal(m)
+					// data is now encoded in base64 format
+					// need a decoder on the other side
+					b.Output <- []byte(buf)
+					bufferedOutputRaw = nil
+					sPortRaw = ""
+				}
+			case <-b.done:
+				break Loop
 			}
 		}
-	}()
 
+		close(b.Input)
+	}()
 }
 
 func (b *BufferflowTimedRaw) BlockUntilReady(cmd string, id string) (bool, bool) {
 	//log.Printf("BlockUntilReady() start\n")
 	return true, false
 }
 
+// not implemented, we are gonna use OnIncomingData
+func (b *BufferflowTimedRaw) OnIncomingDataBinary(data []byte) {
+}
+
 func (b *BufferflowTimedRaw) OnIncomingData(data string) {
 	b.Input <- data
 }

hub.go

@@ -38,14 +38,30 @@ var h = hub{
 	connections:  make(map[*connection]bool),
 }
 
+const commands = "{\"Commands\": [" +
+	"\"list\", " +
+	"\"open < portName > < baud > [bufferAlgorithm: ({default}, timed, timedraw, timedbinary)]\", " +
+	"\"send < portName > < cmd >\", " +
+	"\"sendnobuf < portName > < cmd >\", " +
+	"\"close < portName >\", " +
+	"\"restart\", " +
+	"\"exit\", " +
+	"\"killupload\", " +
+	"\"downloadtool < tool > < toolVersion: {latest} > < pack: {arduino} > < behaviour: {keep} >\", " +
+	"\"log\", " +
+	"\"memorystats\", " +
+	"\"gc\", " +
+	"\"hostname\", " +
+	"\"version\"]} "
+
 func (h *hub) run() {
 	for {
 		select {
 		case c := <-h.register:
 			h.connections[c] = true
 			// send supported commands
 			c.send <- []byte("{\"Version\" : \"" + version + "\"} ")
-			c.send <- []byte("{\"Commands\" : [\"list\", \"open [portName] [baud] [bufferAlgorithm (optional)]\", \"send [portName] [cmd]\", \"sendnobuf [portName] [cmd]\", \"close [portName]\", \"bufferalgorithms\", \"baudrates\", \"restart\", \"exit\", \"program [portName] [board:name] [$path/to/filename/without/extension]\", \"programfromurl [portName] [board:name] [urlToHexFile]\"]} ")
+			c.send <- []byte(commands)
 			c.send <- []byte("{\"Hostname\" : \"" + *hostname + "\"} ")
 			c.send <- []byte("{\"OS\" : \"" + runtime.GOOS + "\"} ")
 		case c := <-h.unregister:
@@ -127,7 +143,7 @@ func checkCmd(m []byte) {
 		}
 		// pass in buffer type now as string. if user does not
 		// ask for a buffer type pass in empty string
-		bufferAlgorithm := ""
+		bufferAlgorithm := "default" // use the default buffer if none is specified
 		if len(args) > 3 {
 			// cool. we got a buffer type request
 			buftype := strings.Replace(args[3], "\n", "", -1)