main.go

Documentation: edge-infra.dev/cmd/sds/devices/serial-loopback-tester

     1  package main
     2  
     3  import (
     4  	"errors"
     5  	"flag"
     6  	"io"
     7  	"os"
     8  
     9  	"github.com/jacobsa/go-serial/serial"
    10  	"github.com/peterbourgon/ff/v3"
    11  
    12  	"edge-infra.dev/pkg/lib/fog"
    13  )
    14  
    15  var (
    16  	baudRate        uint = 19200
    17  	dataBits        uint = 8
    18  	stopBits        uint = 1
    19  	minimumReadSize uint = 4
    20  	// errMissingDevicePath is thrown when argument for serial device path is missing or empty
    21  	errMissingDevicePath = errors.New("missing serial device path")
    22  	// errMissingData is thrown when data argument is missing or has an empty value
    23  	errMissingData = errors.New("missing data argument")
    24  	// testData is data sent to serial device
    25  	testData = "this data is sent to the serial device and read back"
    26  )
    27  
    28  func main() {
    29  	fs := flag.NewFlagSet("serial-tester", flag.ExitOnError)
    30  	flags := FromFlagSet(fs)
    31  
    32  	log := fog.New()
    33  	if err := ff.Parse(fs, os.Args[1:], ff.WithEnvVarNoPrefix(), ff.WithIgnoreUndefined(true)); err != nil {
    34  		log.Error(err, "error parsing flags or envvars")
    35  		os.Exit(1)
    36  	}
    37  
    38  	if flags.DevPath == nil || *flags.DevPath == "" {
    39  		log.Error(errMissingDevicePath, "missing argument --devpath")
    40  	}
    41  
    42  	// set serial port options
    43  	options := serial.OpenOptions{
    44  		PortName:        *flags.DevPath,
    45  		BaudRate:        baudRate,
    46  		DataBits:        dataBits,
    47  		StopBits:        stopBits,
    48  		MinimumReadSize: minimumReadSize,
    49  	}
    50  
    51  	// open the port and close it later
    52  	port, err := serial.Open(options)
    53  	if err != nil {
    54  		log.Error(err, "error opening serial port")
    55  		os.Exit(1)
    56  	}
    57  	defer port.Close()
    58  
    59  	if flags.Data == nil || *flags.Data == "" {
    60  		log.Error(errMissingData, "missing argument --data")
    61  	}
    62  
    63  	log.Info("writing data to serial device", "dataSent", testData)
    64  
    65  	// write data to the serial device
    66  	_, err = port.Write([]byte(testData))
    67  	if err != nil {
    68  		log.Error(err, "error writing to serial device")
    69  		os.Exit(1)
    70  	}
    71  
    72  	// read data from the serial device
    73  	for {
    74  		buf := make([]byte, len(testData))
    75  		n, err := port.Read(buf)
    76  		if err != nil {
    77  			if err != io.EOF {
    78  				log.Error(err, "error reading from serial device")
    79  			}
    80  		} else {
    81  			buf = buf[:n]
    82  			log.Info("successful write/read to serial device", "dataSent", testData, "dataRead", string(buf), "device", *flags.DevPath)
    83  		}
    84  	}
    85  }
    86  
    87  // Set of flags passed into serial device test
    88  type Flags struct {
    89  	DevPath *string
    90  	Data    *string
    91  }
    92  
    93  // FlagsFromFlagSet returns the possible flags for the serial device test.
    94  func FromFlagSet(fs *flag.FlagSet) Flags {
    95  	return Flags{
    96  		DevPath: fs.String(
    97  			"devpath",
    98  			"",
    99  			"path of serial device i.e. /dev/ttyUSB1",
   100  		),
   101  	}
   102  }
   103
View as plain text