aboutsummaryrefslogtreecommitdiff
path: root/vendor/github.com/tarm
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/github.com/tarm')
-rw-r--r--vendor/github.com/tarm/serial/.travis.yml14
-rw-r--r--vendor/github.com/tarm/serial/LICENSE27
-rw-r--r--vendor/github.com/tarm/serial/README.md82
-rw-r--r--vendor/github.com/tarm/serial/serial.go167
-rw-r--r--vendor/github.com/tarm/serial/serial_linux.go164
-rw-r--r--vendor/github.com/tarm/serial/serial_posix.go197
-rw-r--r--vendor/github.com/tarm/serial/serial_windows.go327
7 files changed, 0 insertions, 978 deletions
diff --git a/vendor/github.com/tarm/serial/.travis.yml b/vendor/github.com/tarm/serial/.travis.yml
deleted file mode 100644
index 28d22ca..0000000
--- a/vendor/github.com/tarm/serial/.travis.yml
+++ /dev/null
@@ -1,14 +0,0 @@
-sudo: false
-language: go
-go:
- - "1.9"
- - "1.10"
- - "1.11"
- - tip
-env:
- - GOOS=linux CGO=1
- - GOOS=linux CGO=0
- - GOOS=linux GOARCH=arm
- - GOOS=linux GOARCH=mips
- - GOOS=linux GOARCH=mipsle
- - GOOS=windows GOARCH=386
diff --git a/vendor/github.com/tarm/serial/LICENSE b/vendor/github.com/tarm/serial/LICENSE
deleted file mode 100644
index 6a66aea..0000000
--- a/vendor/github.com/tarm/serial/LICENSE
+++ /dev/null
@@ -1,27 +0,0 @@
-Copyright (c) 2009 The Go Authors. All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
- * Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
- * Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the following disclaimer
-in the documentation and/or other materials provided with the
-distribution.
- * Neither the name of Google Inc. nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/github.com/tarm/serial/README.md b/vendor/github.com/tarm/serial/README.md
deleted file mode 100644
index d2fa899..0000000
--- a/vendor/github.com/tarm/serial/README.md
+++ /dev/null
@@ -1,82 +0,0 @@
-[![GoDoc](https://godoc.org/github.com/tarm/serial?status.svg)](http://godoc.org/github.com/tarm/serial)
-[![Build Status](https://travis-ci.org/tarm/serial.svg?branch=master)](https://travis-ci.org/tarm/serial)
-
-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.
-
-You can cross compile with
- GOOS=windows GOARCH=386 go install github.com/tarm/serial
-
-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() simulantiously on the same connection (from
-different goroutines).
-
-Usage
------
-```go
-package main
-
-import (
- "log"
-
- "github.com/tarm/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])
-}
-```
-
-NonBlocking Mode
-----------------
-By default the returned Port reads in blocking mode. Which means
-`Read()` will block until at least one byte is returned. If that's not
-what you want, specify a positive ReadTimeout and the Read() will
-timeout returning 0 bytes if no bytes are read. Please note that this
-is the total timeout the read operation will wait and not the interval
-timeout between two bytes.
-
-```go
- c := &serial.Config{Name: "COM45", Baud: 115200, ReadTimeout: time.Second * 5}
-
- // In this mode, you will want to suppress error for read
- // as 0 bytes return EOF error on Linux / POSIX
- n, _ = s.Read(buf)
-```
-
-Possible Future Work
---------------------
-- better tests (loopback etc)
diff --git a/vendor/github.com/tarm/serial/serial.go b/vendor/github.com/tarm/serial/serial.go
deleted file mode 100644
index f61ea28..0000000
--- a/vendor/github.com/tarm/serial/serial.go
+++ /dev/null
@@ -1,167 +0,0 @@
-/*
-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])
- }
-*/
-package serial
-
-import (
- "errors"
- "time"
-)
-
-const DefaultSize = 8 // Default value for Config.Size
-
-type StopBits byte
-type Parity byte
-
-const (
- Stop1 StopBits = 1
- Stop1Half StopBits = 15
- Stop2 StopBits = 2
-)
-
-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
-)
-
-// 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 Config struct {
- Name string
- Baud int
- ReadTimeout time.Duration // Total timeout
-
- // Size is the number of data bits. If 0, DefaultSize is used.
- Size byte
-
- // Parity is the bit to use and defaults to ParityNone (no parity bit).
- Parity Parity
-
- // Number of stop bits to use. Default is 1 (1 stop bit).
- StopBits StopBits
-
- // RTSFlowControl bool
- // DTRFlowControl bool
- // XONFlowControl bool
-
- // CRLFTranslate bool
-}
-
-// ErrBadSize is returned if Size is not supported.
-var ErrBadSize error = errors.New("unsupported serial data size")
-
-// ErrBadStopBits is returned if the specified StopBits setting not supported.
-var ErrBadStopBits error = errors.New("unsupported stop bit setting")
-
-// ErrBadParity is returned if the parity is not supported.
-var ErrBadParity error = errors.New("unsupported parity setting")
-
-// OpenPort opens a serial port with the specified configuration
-func OpenPort(c *Config) (*Port, error) {
- size, par, stop := c.Size, c.Parity, c.StopBits
- if size == 0 {
- size = DefaultSize
- }
- if par == 0 {
- par = ParityNone
- }
- if stop == 0 {
- stop = Stop1
- }
- return openPort(c.Name, c.Baud, size, par, stop, c.ReadTimeout)
-}
-
-// Converts the timeout values for Linux / POSIX systems
-func posixTimeoutValues(readTimeout time.Duration) (vmin uint8, vtime uint8) {
- const MAXUINT8 = 1<<8 - 1 // 255
- // set blocking / non-blocking read
- var minBytesToRead uint8 = 1
- var readTimeoutInDeci int64
- if readTimeout > 0 {
- // EOF on zero read
- minBytesToRead = 0
- // convert timeout to deciseconds as expected by VTIME
- readTimeoutInDeci = (readTimeout.Nanoseconds() / 1e6 / 100)
- // capping the timeout
- if readTimeoutInDeci < 1 {
- // min possible timeout 1 Deciseconds (0.1s)
- readTimeoutInDeci = 1
- } else if readTimeoutInDeci > MAXUINT8 {
- // max possible timeout is 255 deciseconds (25.5s)
- readTimeoutInDeci = MAXUINT8
- }
- }
- return minBytesToRead, uint8(readTimeoutInDeci)
-}
-
-// func SendBreak()
-
-// func RegisterBreakHandler(func())
diff --git a/vendor/github.com/tarm/serial/serial_linux.go b/vendor/github.com/tarm/serial/serial_linux.go
deleted file mode 100644
index 65420f3..0000000
--- a/vendor/github.com/tarm/serial/serial_linux.go
+++ /dev/null
@@ -1,164 +0,0 @@
-// +build linux
-
-package serial
-
-import (
- "fmt"
- "os"
- "time"
- "unsafe"
-
- "golang.org/x/sys/unix"
-)
-
-func openPort(name string, baud int, databits byte, parity Parity, stopbits StopBits, readTimeout time.Duration) (p *Port, err error) {
- var bauds = map[int]uint32{
- 50: unix.B50,
- 75: unix.B75,
- 110: unix.B110,
- 134: unix.B134,
- 150: unix.B150,
- 200: unix.B200,
- 300: unix.B300,
- 600: unix.B600,
- 1200: unix.B1200,
- 1800: unix.B1800,
- 2400: unix.B2400,
- 4800: unix.B4800,
- 9600: unix.B9600,
- 19200: unix.B19200,
- 38400: unix.B38400,
- 57600: unix.B57600,
- 115200: unix.B115200,
- 230400: unix.B230400,
- 460800: unix.B460800,
- 500000: unix.B500000,
- 576000: unix.B576000,
- 921600: unix.B921600,
- 1000000: unix.B1000000,
- 1152000: unix.B1152000,
- 1500000: unix.B1500000,
- 2000000: unix.B2000000,
- 2500000: unix.B2500000,
- 3000000: unix.B3000000,
- 3500000: unix.B3500000,
- 4000000: unix.B4000000,
- }
-
- rate, ok := bauds[baud]
-
- if !ok {
- return nil, fmt.Errorf("Unrecognized baud rate")
- }
-
- f, err := os.OpenFile(name, unix.O_RDWR|unix.O_NOCTTY|unix.O_NONBLOCK, 0666)
- if err != nil {
- return nil, err
- }
-
- defer func() {
- if err != nil && f != nil {
- f.Close()
- }
- }()
-
- // Base settings
- cflagToUse := unix.CREAD | unix.CLOCAL | rate
- switch databits {
- case 5:
- cflagToUse |= unix.CS5
- case 6:
- cflagToUse |= unix.CS6
- case 7:
- cflagToUse |= unix.CS7
- case 8:
- cflagToUse |= unix.CS8
- default:
- return nil, ErrBadSize
- }
- // Stop bits settings
- switch stopbits {
- case Stop1:
- // default is 1 stop bit
- case Stop2:
- cflagToUse |= unix.CSTOPB
- default:
- // Don't know how to set 1.5
- return nil, ErrBadStopBits
- }
- // Parity settings
- switch parity {
- case ParityNone:
- // default is no parity
- case ParityOdd:
- cflagToUse |= unix.PARENB
- cflagToUse |= unix.PARODD
- case ParityEven:
- cflagToUse |= unix.PARENB
- default:
- return nil, ErrBadParity
- }
- fd := f.Fd()
- vmin, vtime := posixTimeoutValues(readTimeout)
- t := unix.Termios{
- Iflag: unix.IGNPAR,
- Cflag: cflagToUse,
- Ispeed: rate,
- Ospeed: rate,
- }
- t.Cc[unix.VMIN] = vmin
- t.Cc[unix.VTIME] = vtime
-
- if _, _, errno := unix.Syscall6(
- unix.SYS_IOCTL,
- uintptr(fd),
- uintptr(unix.TCSETS),
- uintptr(unsafe.Pointer(&t)),
- 0,
- 0,
- 0,
- ); errno != 0 {
- return nil, errno
- }
-
- if err = unix.SetNonblock(int(fd), false); err != nil {
- return
- }
-
- return &Port{f: f}, nil
-}
-
-type Port struct {
- // We intentionly do not use an "embedded" struct so that we
- // don't export File
- f *os.File
-}
-
-func (p *Port) Read(b []byte) (n int, err error) {
- return p.f.Read(b)
-}
-
-func (p *Port) Write(b []byte) (n int, err error) {
- return p.f.Write(b)
-}
-
-// Discards data written to the port but not transmitted,
-// or data received but not read
-func (p *Port) Flush() error {
- const TCFLSH = 0x540B
- _, _, errno := unix.Syscall(
- unix.SYS_IOCTL,
- uintptr(p.f.Fd()),
- uintptr(TCFLSH),
- uintptr(unix.TCIOFLUSH),
- )
-
- if errno == 0 {
- return nil
- }
- return errno
-}
-
-func (p *Port) Close() (err error) {
- return p.f.Close()
-}
diff --git a/vendor/github.com/tarm/serial/serial_posix.go b/vendor/github.com/tarm/serial/serial_posix.go
deleted file mode 100644
index d733f0f..0000000
--- a/vendor/github.com/tarm/serial/serial_posix.go
+++ /dev/null
@@ -1,197 +0,0 @@
-// +build !windows,!linux,cgo
-
-package serial
-
-// #include <termios.h>
-// #include <unistd.h>
-import "C"
-
-// TODO: Maybe change to using syscall package + ioctl instead of cgo
-
-import (
- "errors"
- "fmt"
- "os"
- "syscall"
- "time"
- //"unsafe"
-)
-
-func openPort(name string, baud int, databits byte, parity Parity, stopbits StopBits, readTimeout time.Duration) (p *Port, err error) {
- f, err := os.OpenFile(name, syscall.O_RDWR|syscall.O_NOCTTY|syscall.O_NONBLOCK, 0666)
- if err != nil {
- return
- }
-
- fd := C.int(f.Fd())
- if C.isatty(fd) != 1 {
- f.Close()
- return nil, errors.New("File is not a tty")
- }
-
- var st C.struct_termios
- _, err = C.tcgetattr(fd, &st)
- if err != nil {
- f.Close()
- return nil, err
- }
- var speed C.speed_t
- switch baud {
- case 115200:
- speed = C.B115200
- case 57600:
- speed = C.B57600
- case 38400:
- speed = C.B38400
- case 19200:
- speed = C.B19200
- case 9600:
- speed = C.B9600
- case 4800:
- speed = C.B4800
- case 2400:
- speed = C.B2400
- case 1200:
- speed = C.B1200
- case 600:
- speed = C.B600
- case 300:
- speed = C.B300
- case 200:
- speed = C.B200
- case 150:
- speed = C.B150
- case 134:
- speed = C.B134
- case 110:
- speed = C.B110
- case 75:
- speed = C.B75
- case 50:
- speed = C.B50
- default:
- f.Close()
- return nil, fmt.Errorf("Unknown baud rate %v", baud)
- }
-
- _, err = C.cfsetispeed(&st, speed)
- if err != nil {
- f.Close()
- return nil, err
- }
- _, err = C.cfsetospeed(&st, speed)
- if err != nil {
- f.Close()
- return nil, err
- }
-
- // Turn off break interrupts, CR->NL, Parity checks, strip, and IXON
- st.c_iflag &= ^C.tcflag_t(C.BRKINT | C.ICRNL | C.INPCK | C.ISTRIP | C.IXOFF | C.IXON | C.PARMRK)
-
- // Select local mode, turn off parity, set to 8 bits
- st.c_cflag &= ^C.tcflag_t(C.CSIZE | C.PARENB)
- st.c_cflag |= (C.CLOCAL | C.CREAD)
- // databits
- switch databits {
- case 5:
- st.c_cflag |= C.CS5
- case 6:
- st.c_cflag |= C.CS6
- case 7:
- st.c_cflag |= C.CS7
- case 8:
- st.c_cflag |= C.CS8
- default:
- return nil, ErrBadSize
- }
- // Parity settings
- switch parity {
- case ParityNone:
- // default is no parity
- case ParityOdd:
- st.c_cflag |= C.PARENB
- st.c_cflag |= C.PARODD
- case ParityEven:
- st.c_cflag |= C.PARENB
- st.c_cflag &= ^C.tcflag_t(C.PARODD)
- default:
- return nil, ErrBadParity
- }
- // Stop bits settings
- switch stopbits {
- case Stop1:
- // as is, default is 1 bit
- case Stop2:
- st.c_cflag |= C.CSTOPB
- default:
- return nil, ErrBadStopBits
- }
- // Select raw mode
- st.c_lflag &= ^C.tcflag_t(C.ICANON | C.ECHO | C.ECHOE | C.ISIG)
- st.c_oflag &= ^C.tcflag_t(C.OPOST)
-
- // set blocking / non-blocking read
- /*
- * http://man7.org/linux/man-pages/man3/termios.3.html
- * - Supports blocking read and read with timeout operations
- */
- vmin, vtime := posixTimeoutValues(readTimeout)
- st.c_cc[C.VMIN] = C.cc_t(vmin)
- st.c_cc[C.VTIME] = C.cc_t(vtime)
-
- _, err = C.tcsetattr(fd, C.TCSANOW, &st)
- if err != nil {
- f.Close()
- return nil, err
- }
-
- //fmt.Println("Tweaking", name)
- r1, _, e := syscall.Syscall(syscall.SYS_FCNTL,
- uintptr(f.Fd()),
- uintptr(syscall.F_SETFL),
- uintptr(0))
- if e != 0 || r1 != 0 {
- s := fmt.Sprint("Clearing NONBLOCK syscall error:", e, r1)
- f.Close()
- return nil, errors.New(s)
- }
-
- /*
- r1, _, e = syscall.Syscall(syscall.SYS_IOCTL,
- uintptr(f.Fd()),
- uintptr(0x80045402), // IOSSIOSPEED
- uintptr(unsafe.Pointer(&baud)));
- if e != 0 || r1 != 0 {
- s := fmt.Sprint("Baudrate syscall error:", e, r1)
- f.Close()
- return nil, os.NewError(s)
- }
- */
-
- return &Port{f: f}, nil
-}
-
-type Port struct {
- // We intentionly do not use an "embedded" struct so that we
- // don't export File
- f *os.File
-}
-
-func (p *Port) Read(b []byte) (n int, err error) {
- return p.f.Read(b)
-}
-
-func (p *Port) Write(b []byte) (n int, err error) {
- return p.f.Write(b)
-}
-
-// Discards data written to the port but not transmitted,
-// or data received but not read
-func (p *Port) Flush() error {
- _, err := C.tcflush(C.int(p.f.Fd()), C.TCIOFLUSH)
- return err
-}
-
-func (p *Port) Close() (err error) {
- return p.f.Close()
-}
diff --git a/vendor/github.com/tarm/serial/serial_windows.go b/vendor/github.com/tarm/serial/serial_windows.go
deleted file mode 100644
index 2a9c004..0000000
--- a/vendor/github.com/tarm/serial/serial_windows.go
+++ /dev/null
@@ -1,327 +0,0 @@
-// +build windows
-
-package serial
-
-import (
- "fmt"
- "os"
- "sync"
- "syscall"
- "time"
- "unsafe"
-)
-
-type Port struct {
- f *os.File
- fd syscall.Handle
- rl sync.Mutex
- wl sync.Mutex
- ro *syscall.Overlapped
- wo *syscall.Overlapped
-}
-
-type structDCB struct {
- DCBlength, BaudRate uint32
- flags [4]byte
- wReserved, XonLim, XoffLim uint16
- ByteSize, Parity, StopBits byte
- XonChar, XoffChar, ErrorChar, EofChar, EvtChar byte
- wReserved1 uint16
-}
-
-type structTimeouts struct {
- ReadIntervalTimeout uint32
- ReadTotalTimeoutMultiplier uint32
- ReadTotalTimeoutConstant uint32
- WriteTotalTimeoutMultiplier uint32
- WriteTotalTimeoutConstant uint32
-}
-
-func openPort(name string, baud int, databits byte, parity Parity, stopbits StopBits, readTimeout time.Duration) (p *Port, err error) {
- if len(name) > 0 && name[0] != '\\' {
- name = "\\\\.\\" + name
- }
-
- h, err := syscall.CreateFile(syscall.StringToUTF16Ptr(name),
- syscall.GENERIC_READ|syscall.GENERIC_WRITE,
- 0,
- nil,
- syscall.OPEN_EXISTING,
- syscall.FILE_ATTRIBUTE_NORMAL|syscall.FILE_FLAG_OVERLAPPED,
- 0)
- if err != nil {
- return nil, err
- }
- f := os.NewFile(uintptr(h), name)
- defer func() {
- if err != nil {
- f.Close()
- }
- }()
-
- if err = setCommState(h, baud, databits, parity, stopbits); err != nil {
- return nil, err
- }
- if err = setupComm(h, 64, 64); err != nil {
- return nil, err
- }
- if err = setCommTimeouts(h, readTimeout); err != nil {
- return nil, err
- }
- if err = setCommMask(h); err != nil {
- return nil, err
- }
-
- ro, err := newOverlapped()
- if err != nil {
- return nil, err
- }
- wo, err := newOverlapped()
- if err != nil {
- return nil, err
- }
- port := new(Port)
- port.f = f
- port.fd = h
- port.ro = ro
- port.wo = wo
-
- return port, nil
-}
-
-func (p *Port) Close() error {
- return p.f.Close()
-}
-
-func (p *Port) Write(buf []byte) (int, error) {
- p.wl.Lock()
- defer p.wl.Unlock()
-
- if err := resetEvent(p.wo.HEvent); err != nil {
- return 0, err
- }
- var n uint32
- err := syscall.WriteFile(p.fd, buf, &n, p.wo)
- if err != nil && err != syscall.ERROR_IO_PENDING {
- return int(n), err
- }
- return getOverlappedResult(p.fd, p.wo)
-}
-
-func (p *Port) Read(buf []byte) (int, error) {
- if p == nil || p.f == nil {
- return 0, fmt.Errorf("Invalid port on read")
- }
-
- p.rl.Lock()
- defer p.rl.Unlock()
-
- if err := resetEvent(p.ro.HEvent); err != nil {
- return 0, err
- }
- var done uint32
- err := syscall.ReadFile(p.fd, buf, &done, p.ro)
- if err != nil && err != syscall.ERROR_IO_PENDING {
- return int(done), err
- }
- return getOverlappedResult(p.fd, p.ro)
-}
-
-// Discards data written to the port but not transmitted,
-// or data received but not read
-func (p *Port) Flush() error {
- return purgeComm(p.fd)
-}
-
-var (
- nSetCommState,
- nSetCommTimeouts,
- nSetCommMask,
- nSetupComm,
- nGetOverlappedResult,
- nCreateEvent,
- nResetEvent,
- nPurgeComm,
- nFlushFileBuffers uintptr
-)
-
-func init() {
- k32, err := syscall.LoadLibrary("kernel32.dll")
- if err != nil {
- panic("LoadLibrary " + err.Error())
- }
- defer syscall.FreeLibrary(k32)
-
- nSetCommState = getProcAddr(k32, "SetCommState")
- nSetCommTimeouts = getProcAddr(k32, "SetCommTimeouts")
- nSetCommMask = getProcAddr(k32, "SetCommMask")
- nSetupComm = getProcAddr(k32, "SetupComm")
- nGetOverlappedResult = getProcAddr(k32, "GetOverlappedResult")
- nCreateEvent = getProcAddr(k32, "CreateEventW")
- nResetEvent = getProcAddr(k32, "ResetEvent")
- nPurgeComm = getProcAddr(k32, "PurgeComm")
- nFlushFileBuffers = getProcAddr(k32, "FlushFileBuffers")
-}
-
-func getProcAddr(lib syscall.Handle, name string) uintptr {
- addr, err := syscall.GetProcAddress(lib, name)
- if err != nil {
- panic(name + " " + err.Error())
- }
- return addr
-}
-
-func setCommState(h syscall.Handle, baud int, databits byte, parity Parity, stopbits StopBits) error {
- var params structDCB
- params.DCBlength = uint32(unsafe.Sizeof(params))
-
- params.flags[0] = 0x01 // fBinary
- params.flags[0] |= 0x10 // Assert DSR
-
- params.BaudRate = uint32(baud)
-
- params.ByteSize = databits
-
- switch parity {
- case ParityNone:
- params.Parity = 0
- case ParityOdd:
- params.Parity = 1
- case ParityEven:
- params.Parity = 2
- case ParityMark:
- params.Parity = 3
- case ParitySpace:
- params.Parity = 4
- default:
- return ErrBadParity
- }
-
- switch stopbits {
- case Stop1:
- params.StopBits = 0
- case Stop1Half:
- params.StopBits = 1
- case Stop2:
- params.StopBits = 2
- default:
- return ErrBadStopBits
- }
-
- r, _, err := syscall.Syscall(nSetCommState, 2, uintptr(h), uintptr(unsafe.Pointer(&params)), 0)
- if r == 0 {
- return err
- }
- return nil
-}
-
-func setCommTimeouts(h syscall.Handle, readTimeout time.Duration) error {
- var timeouts structTimeouts
- const MAXDWORD = 1<<32 - 1
-
- // blocking read by default
- var timeoutMs int64 = MAXDWORD - 1
-
- if readTimeout > 0 {
- // non-blocking read
- timeoutMs = readTimeout.Nanoseconds() / 1e6
- if timeoutMs < 1 {
- timeoutMs = 1
- } else if timeoutMs > MAXDWORD-1 {
- timeoutMs = MAXDWORD - 1
- }
- }
-
- /* From http://msdn.microsoft.com/en-us/library/aa363190(v=VS.85).aspx
-
- For blocking I/O see below:
-
- Remarks:
-
- If an application sets ReadIntervalTimeout and
- ReadTotalTimeoutMultiplier to MAXDWORD and sets
- ReadTotalTimeoutConstant to a value greater than zero and
- less than MAXDWORD, one of the following occurs when the
- ReadFile function is called:
-
- If there are any bytes in the input buffer, ReadFile returns
- immediately with the bytes in the buffer.
-
- If there are no bytes in the input buffer, ReadFile waits
- until a byte arrives and then returns immediately.
-
- If no bytes arrive within the time specified by
- ReadTotalTimeoutConstant, ReadFile times out.
- */
-
- timeouts.ReadIntervalTimeout = MAXDWORD
- timeouts.ReadTotalTimeoutMultiplier = MAXDWORD
- timeouts.ReadTotalTimeoutConstant = uint32(timeoutMs)
-
- r, _, err := syscall.Syscall(nSetCommTimeouts, 2, uintptr(h), uintptr(unsafe.Pointer(&timeouts)), 0)
- if r == 0 {
- return err
- }
- return nil
-}
-
-func setupComm(h syscall.Handle, in, out int) error {
- r, _, err := syscall.Syscall(nSetupComm, 3, uintptr(h), uintptr(in), uintptr(out))
- if r == 0 {
- return err
- }
- return nil
-}
-
-func setCommMask(h syscall.Handle) error {
- const EV_RXCHAR = 0x0001
- r, _, err := syscall.Syscall(nSetCommMask, 2, uintptr(h), EV_RXCHAR, 0)
- if r == 0 {
- return err
- }
- return nil
-}
-
-func resetEvent(h syscall.Handle) error {
- r, _, err := syscall.Syscall(nResetEvent, 1, uintptr(h), 0, 0)
- if r == 0 {
- return err
- }
- return nil
-}
-
-func purgeComm(h syscall.Handle) error {
- const PURGE_TXABORT = 0x0001
- const PURGE_RXABORT = 0x0002
- const PURGE_TXCLEAR = 0x0004
- const PURGE_RXCLEAR = 0x0008
- r, _, err := syscall.Syscall(nPurgeComm, 2, uintptr(h),
- PURGE_TXABORT|PURGE_RXABORT|PURGE_TXCLEAR|PURGE_RXCLEAR, 0)
- if r == 0 {
- return err
- }
- return nil
-}
-
-func newOverlapped() (*syscall.Overlapped, error) {
- var overlapped syscall.Overlapped
- r, _, err := syscall.Syscall6(nCreateEvent, 4, 0, 1, 0, 0, 0, 0)
- if r == 0 {
- return nil, err
- }
- overlapped.HEvent = syscall.Handle(r)
- return &overlapped, nil
-}
-
-func getOverlappedResult(h syscall.Handle, overlapped *syscall.Overlapped) (int, error) {
- var n int
- r, _, err := syscall.Syscall6(nGetOverlappedResult, 4,
- uintptr(h),
- uintptr(unsafe.Pointer(overlapped)),
- uintptr(unsafe.Pointer(&n)), 1, 0, 0)
- if r == 0 {
- return n, err
- }
-
- return n, nil
-}