Always return 1 byte of data

[ma6254]

platform: windows 10

package main

import (
    "encoding/binary"
    "encoding/hex"
    "fmt"
    "log"
    "time"

    "go.bug.st/serial"
)

var testCOM = "COM23"
var step uint8

type ReadPkgCallback func([]byte)

func main() {
    var (
        err error
    )

    fmt.Printf("Hello, world.\n")

    mode := &serial.Mode{
        BaudRate: 115200,
        DataBits: 8,
        Parity:   serial.NoParity,
        StopBits: serial.OneStopBit,
    }

    port, err := serial.Open(testCOM, mode)
    if err != nil {
        log.Fatal(err)
    }
    err = port.SetReadTimeout(time.Millisecond * 1000)
    if err != nil {
        log.Fatal(err)
    }

    wch := make(chan int, 1)

    go func(ch chan int) {

        wtick := time.NewTicker(time.Millisecond * 10)
    w_loop:
        for {
            select {
            case <-ch:
                break w_loop
            case <-wtick.C:
                port.Write([]byte{0x7F})
            }
        }
    }(wch)

    r_fn := func(b []byte) {
        log.Printf("recv package: %#v\n", b)
    }

    go func(fn ReadPkgCallback) {
        for {

            var (
                rb       = make([]byte, 1)
                head_cnt = 0
            )

            for {
                _, err = port.Read(rb)
                // fmt.Printf("r: %02X\n", rb[0])

                if head_cnt == 0 {
                    if rb[0] == 0x46 {
                        head_cnt = 1
                    }
                } else {
                    if rb[0] == 0xb9 {
                        // wch <- 1
                        break
                    } else {
                        head_cnt = 0
                    }
                }
            }

            rb = make([]byte, 1)
            _, err := port.Read(rb)
            if err != nil {
                return
            }

            if rb[0] != 0x68 {
                continue
            }

            var len uint16
            binary.Read(port, binary.BigEndian, &len)

            fmt.Printf("len: %#v\n", len)

            rb = make([]byte, len-4)

            n, err := port.Read(rb)
            fmt.Printf("n: %d\n", n)
            fmt.Printf("%s\n", hex.Dump(rb))
            fn(rb)

            // _, err := port.Read(rb)
            // if err != nil {
            // }
        }
    }(r_fn)

    for {
    }
}

[cmaglie]

The reason is that Read waits until at least one byte is received:

// Stores data received from the serial port into the provided byte array
// buffer. The function returns the number of bytes read.
//
// The Read function blocks until (at least) one byte is received from    <-----
// the serial port or an error occurs.
Read(p []byte) (n int, err error)

As soon as the first byte is received the function will unblock and return that byte. If you want to read a fixed-size string you need to cycle and accumulate until you reach the desired size.