add sendraw command to send base64 encoded bytes, add tests (for send raw and for open/close port)

Author: umbynos

go.sum

@@ -391,6 +391,7 @@ golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3
 golang.org/x/tools v0.0.0-20190328211700-ab21143f2384/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
 golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
 golang.org/x/tools v0.0.0-20190729092621-ff9f1409240a/go.mod h1:jcCCGcm9btYwXyDqrUWc6MKQKKGJCWEQ3AfLSRIbEuI=
+golang.org/x/tools v0.0.0-20191216052735-49a3e744a425 h1:VvQyQJN0tSuecqgcIxMWnnfG5kSmgy9KZR9sW3W5QeA=
 golang.org/x/tools v0.0.0-20191216052735-49a3e744a425/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=

hub.go

@@ -44,8 +44,7 @@ const commands = `{
   "Commands": [
     "list",
     "open <portName> <baud> [bufferAlgorithm: ({default}, timed, timedraw)]",
-    "send <portName> <cmd>",
-    "sendnobuf <portName> <cmd>",
+    "(send, sendnobuf, sendraw) <portName> <cmd>",
     "close <portName>",
     "restart",
     "exit",
@@ -160,7 +159,7 @@ func checkCmd(m []byte) {
 		}()
 
 	} else if strings.HasPrefix(sl, "send") {
-		// will catch send and sendnobuf
+		// will catch send and sendnobuf and sendraw
 		go spWrite(s)
 	} else if strings.HasPrefix(sl, "list") {
 		go spList(false)

serial.go

@@ -14,7 +14,7 @@ import (
 type writeRequest struct {
 	p      *serport
 	d      string
-	buffer bool
+	buffer string
 }
 
 type serialhub struct {
@@ -89,13 +89,15 @@ func (sh *serialhub) run() {
 }
 
 func write(wr writeRequest) {
-	if wr.buffer {
-		//log.Println("Send was normal send, so sending to wr.p.sendBuffered")
+	switch wr.buffer {
+	case "send":
 		wr.p.sendBuffered <- wr.d
-	} else {
-		//log.Println("Send was sendnobuf, so sending to wr.p.sendNoBuf")
-		wr.p.sendNoBuf <- wr.d
+	case "sendnobuf":
+		wr.p.sendNoBuf <- []byte(wr.d)
+	case "sendraw":
+		wr.p.sendRaw <- wr.d
 	}
+	// no default since we alredy verified in spWrite()
 }
 
 // spList broadcasts a Json representation of the ports found
@@ -274,13 +276,13 @@ func spWrite(arg string) {
 	var wr writeRequest
 	wr.p = myport
 
-	// see if args[0] is send or sendnobuf
-	if args[0] != "sendnobuf" {
-		// we were just given a "send" so buffer it
-		wr.buffer = true
-	} else {
-		//log.Println("sendnobuf specified so wr.buffer is false")
-		wr.buffer = false
+	// see if args[0] is send or sendnobuf or sendraw
+	switch args[0] {
+	case "send", "sendnobuf", "sendraw":
+		wr.buffer = args[0]
+	default:
+		spErr("Unsupported send command:" + args[0] + ". Please specify a valid one")
+		return
 	}
 
 	// include newline or not in the write? that is the question.

serialport.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"bytes"
+	"encoding/base64"
 	"io"
 	"strconv"
 	"time"
@@ -38,6 +39,9 @@ type serport struct {
 	// unbuffered channel of outbound messages that bypass internal serial port buffer
 	sendNoBuf chan []byte
 
+	// 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
@@ -222,6 +226,46 @@ func (p *serport) writerNoBuf() {
 	spList(false)
 }
 
+// this method runs as its own thread because it's instantiated
+// as a "go" method. so if it blocks inside, it is ok
+func (p *serport) writerRaw() {
+	// this method can panic if user closes serial port and something is
+	// in BlockUntilReady() and then a send occurs on p.sendNoBuf
+
+	defer func() {
+		if e := recover(); e != nil {
+			log.Println("Got panic: ", e)
+		}
+	}()
+
+	// this for loop blocks on p.sendRaw until that channel
+	// sees something come in
+	for data := range p.sendRaw {
+
+		// Decode stuff
+		sDec, err := base64.StdEncoding.DecodeString(data)
+		if err != nil {
+			log.Println("Decoding error:", err)
+		}
+		log.Println(string(sDec))
+
+		// we want to block here if we are being asked to pause.
+		goodToGo, _ := p.bufferwatcher.BlockUntilReady(string(data), "")
+
+		if goodToGo == false {
+			log.Println("We got back from BlockUntilReady() but apparently we must cancel this cmd")
+			// since we won't get a buffer decrement in p.sendNoBuf, we must do it here
+			p.itemsInBuffer--
+		} else {
+			// send to the non-buffered serial port writer
+			p.sendNoBuf <- sDec
+		}
+	}
+	msgstr := "writerRaw just got closed. make sure you make a new one. port:" + p.portConf.Name
+	log.Println(msgstr)
+	h.broadcastSys <- []byte(msgstr)
+}
+
 func spHandlerOpen(portname string, baud int, buftype string) {
 
 	log.Print("Inside spHandler")
@@ -254,7 +298,7 @@ func spHandlerOpen(portname string, baud int, buftype string) {
 	log.Print("Opened port successfully")
 	//p := &serport{send: make(chan []byte, 256), portConf: conf, portIo: sp}
 	// we can go up to 256,000 lines of gcode in the buffer
-	p := &serport{sendBuffered: make(chan string, 256000), sendNoBuf: make(chan []byte), portConf: conf, portIo: sp, BufferType: buftype}
+	p := &serport{sendBuffered: make(chan string, 256000), sendNoBuf: make(chan []byte), sendRaw: make(chan string), portConf: conf, portIo: sp, BufferType: buftype}
 
 	var bw Bufferflow
 
@@ -282,6 +326,9 @@ func spHandlerOpen(portname string, baud int, buftype string) {
 	go p.writerBuffered()
 	// this is thread to send to serial port regardless of block
 	go p.writerNoBuf()
+	// this is thread to send to serial port but with base64 decoding
+	go p.writerRaw()
+
 	p.reader(buftype)
 
 	spListDual(false)

test/conftest.py

@@ -51,3 +51,21 @@ def socketio(base_url, agent):
     sio.connect(base_url)
     yield sio
     sio.disconnect()
+
+@pytest.fixture(scope="session")
+def serial_port():
+    return "/dev/ttyACM0" # maybe this could be enhanced by calling arduino-cli
+
+@pytest.fixture(scope="session")
+def baudrate():
+    return "9600"
+
+# open_port cannot be coced as a fixture because of the buffertype parameter
+
+# at the end of the test closes the serial port
+@pytest.fixture(scope="function")
+def close_port(socketio, serial_port):
+    yield socketio
+    socketio.emit('command', 'close ' + serial_port)
+    time.sleep(.5)
+

test/test_ws.py

@@ -20,39 +20,84 @@ def test_list(socketio):
     assert any("Ports" in i for i in message)
     assert any("Network" in i for i in message)
 
-# NOTE run the following tests on linux with a board connected to the PC and with the sketch found in test/testdata/SerialEcho.ino on it
+# NOTE run the following tests with a board connected to the PC
 @pytest.mark.skipif(
     running_on_ci(),
     reason="VMs have no serial ports",
 )
-def test_open_serial_default(socketio):
-    general_test_serial(socketio, "default")
+def test_open_serial_default(socketio, serial_port, baudrate):
+    general_open_serial(socketio, serial_port, baudrate, "default")
 
 
 @pytest.mark.skipif(
     running_on_ci(),
     reason="VMs have no serial ports",
 )
-def test_open_serial_timed(socketio):
-    general_test_serial(socketio, "timed")
+def test_open_serial_timed(socketio, serial_port, baudrate):
+    general_open_serial(socketio, serial_port, baudrate, "timed")
 
 
 @pytest.mark.skipif(
     running_on_ci(),
     reason="VMs have no serial ports",
 )
-def test_open_serial_timedraw(socketio):
-    general_test_serial(socketio, "timedraw")
+def test_open_serial_timedraw(socketio, serial_port, baudrate):
+    general_open_serial(socketio, serial_port, baudrate, "timedraw")
 
 
-def general_test_serial(socketio, buffertype):
-    port = "/dev/ttyACM0"
+# NOTE run the following tests with a board connected to the PC and with the sketch found in test/testdata/SerialEcho.ino on it be sure to change serial_address in conftest.py
+@pytest.mark.skipif(
+    running_on_ci(),
+    reason="VMs have no serial ports",
+)
+def test_send_serial_default(socketio, close_port, serial_port, baudrate):
+    general_send_serial(socketio, close_port, serial_port, baudrate, "default")
+
+
+@pytest.mark.skipif(
+    running_on_ci(),
+    reason="VMs have no serial ports",
+)
+def test_send_serial_timed(socketio, close_port, serial_port, baudrate):
+    general_send_serial(socketio, close_port, serial_port, baudrate, "timed")
+
+
+@pytest.mark.skipif(
+    running_on_ci(),
+    reason="VMs have no serial ports",
+)
+def test_send_serial_timedraw(socketio, close_port, serial_port, baudrate):
+    general_send_serial(socketio, close_port, serial_port, baudrate, "timedraw")
+
+
+def general_open_serial(socketio, serial_port, baudrate, buffertype):
+    global message
+    message = []
+    # in message var we will find the "response"
+    socketio.on('message', message_handler)
+    socketio.emit('command', 'open ' + serial_port + ' ' + baudrate + ' ' + buffertype)
+    # give time to the message var to be filled
+    time.sleep(.5)
+    print(message)
+    # the serial connection should be open now
+    assert any("\"IsOpen\": true" in i for i in message)
+
+    # close the serial port
+    socketio.emit('command', 'close ' + serial_port)
+    time.sleep(.2)
+    print (message)
+    #check if port has been closed
+    assert any("\"IsOpen\": false," in i for i in message)
+
+
+
+def general_send_serial(socketio, close_port, serial_port, baudrate, buffertype):
     global message
     message = []
     #in message var we will find the "response"
     socketio.on('message', message_handler)
     #open a new serial connection with the specified buffertype, if buffertype is empty it will use the default one
-    socketio.emit('command', 'open ' + port + ' 9600 ' + buffertype)
+    socketio.emit('command', 'open ' + serial_port + ' ' + baudrate + ' ' + buffertype)
     # give time to the message var to be filled
     time.sleep(.5)
     print(message)
@@ -61,11 +106,11 @@ def general_test_serial(socketio, buffertype):
 
     #test with string
     # send the string "ciao" using the serial connection
-    socketio.emit('command', 'send ' + port + ' /"ciao/"')
+    socketio.emit('command', 'send ' + serial_port + ' /"ciao/"')
     time.sleep(1)
     print(message)
     # check if the send command has been registered
-    assert any("send " + port + " /\"ciao/\"" in i for i in message)
+    assert any("send " + serial_port + " /\"ciao/\"" in i for i in message)
     #check if message has been sent back by the connected board
     if buffertype == "timedraw":
         output =  decode_output(extract_serial_data(message))
@@ -76,23 +121,45 @@ def general_test_serial(socketio, buffertype):
     #test with emoji
     message = [] # reinitialize the message buffer to have a clean situation
     # send a lot of emoji: they can be messed up
-    socketio.emit('command', 'send ' + port + ' /"🧀🧀🧀🧀🧀🧀🧀🧀🧀🧀/"')
-    time.sleep(.2)
+    socketio.emit('command', 'send ' + serial_port + ' /"🧀🧀🧀🧀🧀🧀🧀🧀🧀🧀/"')
+    time.sleep(.5)
     print(message)
     # check if the send command has been registered
-    assert any("send " + port + " /\"🧀🧀🧀🧀🧀🧀🧀🧀🧀🧀/\"" in i for i in message)
+    assert any("send " + serial_port + " /\"🧀🧀🧀🧀🧀🧀🧀🧀🧀🧀/\"" in i for i in message)
     if buffertype == "timedraw":
         output =  decode_output(extract_serial_data(message))
     elif buffertype in ("default", "timed"):
         output = extract_serial_data(message)
     assert "/\"🧀🧀🧀🧀🧀🧀🧀🧀🧀🧀/\"" in output
+    # the serial connection is closed by close_port() fixture: even if in case of test failure
 
-    #finally close the serial port
-    socketio.emit('command', 'close ' + port)
-    time.sleep(.2)
-    print (message)
-    #check if port has been closed
-    assert any("\"IsOpen\": false," in i for i in message)
+
+def test_sendraw_serial(socketio, close_port, serial_port, baudrate):
+    global message
+    message = []
+    #in message var we will find the "response"
+    socketio.on('message', message_handler)
+    #open a new serial connection with the specified buffertype, if buffertype is empty it will use the default one
+    socketio.emit('command', 'open ' + serial_port + ' ' + baudrate + ' timedraw')
+    # give time to the message var to be filled
+    time.sleep(.5)
+    print(message)
+    # the serial connection should be open now
+    assert any("\"IsOpen\": true" in i for i in message)
+
+    #test with bytes
+    integers = [1, 2, 3, 4, 5]
+    bytes_array=bytearray(integers)
+    encoded_integers = base64.b64encode(bytes_array).decode('ascii')
+    socketio.emit('command', 'sendraw ' + serial_port + ' ' + encoded_integers)
+    time.sleep(1)
+    print(message)
+    # check if the send command has been registered
+    assert any(("sendraw " + serial_port + ' ' + encoded_integers) in i for i in message)
+    #check if message has been sent back by the connected board
+    output =  extract_serial_data(message) # TODO use decode_output()
+    print (output)
+    assert encoded_integers in output
 
 
 # callback  called by socketio when a message is received