serial

package module
v0.2.7 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Sep 23, 2020 License: BSD-3-Clause Imports: 12 Imported by: 1

README

GoDoc Build Status

Serial

A Go package to allow you to read and write from the serial port as a stream of bytes.

Details

It aims to have the same API on all platforms, including windows. As an added bonus, the windows package does not use cgo, so you can cross compile for windows from another platform.

Windows support is turned off at this moment

Currently there is very little in the way of configurability. You can set the baud rate. Then you can Read(), Write(), or Close() the connection. By default Read() will block until at least one byte is returned. Write is the same.

Currently all ports are opened with 8 data bits, 1 stop bit, no parity, no hardware flow control, and no software flow control. This works fine for many real devices and many faux serial devices including usb-to-serial converters and Bluetooth serial ports.

You may Read() and Write() simultaneously on the same connection (from different goroutines).

Usage

package main

import (
        "log"

        "github.com/NotifAi/serial"
)

func main() {
        c := serial.Config{Name: "COM45", Baud: 115200}
        s, err := serial.OpenPort(c)
        if err != nil {
                log.Fatal(err)
        }
        
        n, err := s.Write([]byte("test"))
        if err != nil {
                log.Fatal(err)
        }
        
        buf := make([]byte, 128)
        n, err = s.Read(buf)
        if err != nil {
                log.Fatal(err)
        }
        log.Printf("%q", buf[:n])
}

Documentation

Overview

Goserial is a simple go package to allow you to read and write from the serial port as a stream of bytes.

It aims to have the same API on all platforms, including windows. As an added bonus, the windows package does not use cgo, so you can cross compile for windows from another platform. Unfortunately goinstall does not currently let you cross compile so you will have to do it manually:

GOOS=windows make clean install

Currently there is very little in the way of configurability. You can set the baud rate. Then you can Read(), Write(), or Close() the connection. Read() will block until at least one byte is returned. Write is the same. There is currently no exposed way to set the timeouts, though patches are welcome.

Currently all ports are opened with 8 data bits, 1 stop bit, no parity, no hardware flow control, and no software flow control. This works fine for many real devices and many faux serial devices including usb-to-serial converters and bluetooth serial ports.

You may Read() and Write() simulantiously on the same connection (from different goroutines).

Example usage:

package main

import (
      "github.com/tarm/serial"
      "log"
)

func main() {
      c := &serial.Config{Name: "COM5", Baud: 115200}
      s, err := serial.OpenPort(c)
      if err != nil {
              log.Fatal(err)
      }

      n, err := s.Write([]byte("test"))
      if err != nil {
              log.Fatal(err)
      }

      buf := make([]byte, 128)
      n, err = s.Read(buf)
      if err != nil {
              log.Fatal(err)
      }
      log.Print("%q", buf[:n])
}

Index

Constants

View Source
const DefaultSize = 8 // Default value for Config.Size
View Source
const (
	MaxTimeout = time.Duration(1<<63 - 1)
)

Variables

View Source
var ErrBadParity = errors.New("serial: unsupported parity setting")

ErrBadParity is returned if the parity is not supported.

View Source
var ErrBadSize = errors.New("serial: unsupported serial data size")

ErrBadSize is returned if Size is not supported.

View Source
var ErrBadStopBits = errors.New("serial: unsupported stop bit setting")

ErrBadStopBits is returned if the specified StopBits setting not supported.

View Source
var ErrInvalidArg = errors.New("serial: invalid argument")
View Source
var ErrNotSupported = errors.New("serial: not supported")

Functions

This section is empty.

Types

type Config

type Config struct {
	Name string `yaml:"name,omitempty"`
	Baud int    `yaml:"baud,omitempty"`
	// Size is the number of data bits. If 0, DefaultSize is used.
	Size DataSize `yaml:"dataBits"`
	// Parity is the bit to use and defaults to ParityNone (no parity bit).
	Parity Parity `yaml:"parity"`
	// StopBits number of stop bits to use. Default is 1 (1 stop bit).
	StopBits StopBits     `yaml:"stopBits"`
	DumpRx   func([]byte) `yaml:"-"`
	DumpTx   func([]byte) `yaml:"-"`
	// contains filtered or unexported fields
}

Config contains the information needed to open a serial port.

Currently few options are implemented, but more may be added in the future (patches welcome), so it is recommended that you create a new config addressing the fields by name rather than by order.

For example:

c0 := &serial.Config{Name: "COM45", Baud: 115200, ReadTimeout: time.Millisecond * 500}

or

c1 := new(serial.Config)
c1.Name = "/dev/tty.usbserial"
c1.Baud = 115200
c1.ReadTimeout = time.Millisecond * 500

type DataSize added in v0.2.6

type DataSize byte

func (*DataSize) UnmarshalYAML added in v0.2.6

func (d *DataSize) UnmarshalYAML(node *yaml.Node) error

type Parity

type Parity byte
const (
	ParityNone  Parity = 'N'
	ParityOdd   Parity = 'O'
	ParityEven  Parity = 'E'
	ParityMark  Parity = 'M' // parity bit is always 1
	ParitySpace Parity = 'S' // parity bit is always 0
)

func (*Parity) UnmarshalYAML added in v0.2.6

func (p *Parity) UnmarshalYAML(node *yaml.Node) error

type Port

type Port interface {
	io.ReadWriteCloser
	SetReadDeadline(time.Duration) error
	Flush() error
	Status() (uint, error)
	SetDTR(bool) error
	SetRTS(bool) error
	SetParity(Parity) error
}

func OpenPort

func OpenPort(c Config) (Port, error)

OpenPort opens a serial port with the specified configuration

type StopBits

type StopBits byte
const (
	Stop1     StopBits = 1
	Stop1Half StopBits = 15
	Stop2     StopBits = 2
)

func (*StopBits) UnmarshalYAML added in v0.2.6

func (s *StopBits) UnmarshalYAML(node *yaml.Node) error

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL