goserial

package module
v0.0.0-...-7b90efd Latest Latest
Warning

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

Go to latest
Published: Oct 12, 2012 License: BSD-3-Clause Imports: 6 Imported by: 17

README

GoSerial

A simple 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. 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).

Usage

package main

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

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.Print("%q", buf[:n])
}

Possible Future Work

  • better tests (loopback etc)

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 ports are opened with 8 data bits, 1 stop bit, no parity, no hardware flow control, and no software flow control by default. 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/goserial"
      "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 (
	ParityNone = ParityMode(iota)
	ParityEven
	ParityOdd
)
View Source
const (
	Byte8 = ByteSize(iota)
	Byte5
	Byte6
	Byte7
)
View Source
const (
	StopBits1 = StopBits(iota)
	StopBits2
)

Variables

View Source
var (
	ErrConfigStopBits = errors.New("goserial config: bad number of stop bits")
	ErrConfigByteSize = errors.New("goserial config: bad byte size")
	ErrConfigParity   = errors.New("goserial config: bad parity")
)

Functions

func OpenPort

func OpenPort(c *Config) (io.ReadWriteCloser, error)

OpenPort opens a serial port with the specified configuration

Types

type ByteSize

type ByteSize byte

type Config

type Config struct {
	Name string
	Baud int

	Size     ByteSize
	Parity   ParityMode
	StopBits StopBits

	CRLFTranslate bool // Ignored on Windows.

}

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}

or

c1 := new(serial.Config)
c1.Name = "/dev/tty.usbserial"
c1.Baud = 115200

type ParityMode

type ParityMode byte

type StopBits

type StopBits byte

Jump to

Keyboard shortcuts

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