goMesh/streamer.go at main · ra014620/goMesh · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
package gomesh

import (
	"io"
	"net"
	"time"

	"github.com/jacobsa/go-serial/serial"
)

type streamer struct {
	serialPort io.ReadWriteCloser
	netPort    net.Conn
	isTCP      bool
}

func (s *streamer) Init(addr string) error {

	ip := net.ParseIP(addr)

	if ip != nil {
		tcpAddr := net.TCPAddr{IP: ip, Port: 4403}
		conn, err := net.DialTCP("tcp", nil, &tcpAddr)
		if err != nil {
			return err
		}
		s.netPort = conn
		s.isTCP = true

	} else {
		//Configure the serial port
		options := serial.OpenOptions{
			PortName:              addr,
			BaudRate:              115200,
			DataBits:              8,
			StopBits:              1,
			MinimumReadSize:       0,
			InterCharacterTimeout: 100,
			ParityMode:            serial.PARITY_NONE,
		}

		// Open the port.
		port, err := serial.Open(options)
		if err != nil {
			return err
		}

		s.serialPort = port
		s.isTCP = false

		return nil
	}

	return nil
}

func (s *streamer) Write(p []byte) error {

	if s.isTCP {
		s.netPort.SetReadDeadline(time.Now().Add(1 * time.Second))
		_, err := s.netPort.Write(p)
		if err != nil {
			return err
		}
	} else {
		_, err := s.serialPort.Write(p)
		if err != nil {
			return err
		}

		time.Sleep(100 * time.Millisecond)
	}

	return nil
}

func (s *streamer) Read(p []byte) error {

	if s.isTCP {
		s.netPort.SetReadDeadline(time.Now().Add(2 * time.Second))
		_, err := s.netPort.Read(p)
		if err != nil {
			return err
		}
	} else {
		_, err := s.serialPort.Read(p)
		if err != nil {
			return err
		}
	}

	return nil

}

func (s *streamer) Close() {
	if s.isTCP {
		s.netPort.Close()
	} else {
		s.serialPort.Close()
	}
}