From f160282fe2bcc8b5cf06c66cac1a3c88a744804a Mon Sep 17 00:00:00 2001 From: Andrey Egorov Date: Sun, 21 Jul 2024 16:05:09 +0300 Subject: [PATCH] Potencially working. --- Makefile | 2 +- api/modem/at.go | 53 ------- api/modem/at/at.go | 154 ++++++++++++++++++++ api/modem/gpio.go | 68 ++++----- api/modem/modem.go | 353 ++++++++++++++++++++++++++++++--------------- go.mod | 3 +- go.sum | 8 +- main.go | 6 + readme.md | 2 + 9 files changed, 440 insertions(+), 209 deletions(-) delete mode 100644 api/modem/at.go create mode 100644 api/modem/at/at.go create mode 100644 readme.md diff --git a/Makefile b/Makefile index f5942ac..1e0228d 100644 --- a/Makefile +++ b/Makefile @@ -5,7 +5,7 @@ build: # @./out/annalist.exe linux: - @$Env:GOOS="linux" $Env:GOARCH="arm" $Env:GOARM=5 + @$Env:GOOS="linux"; $Env:GOARCH="arm"; $Env:GOARM=5 # .profile # cgo_enabled 0 \ No newline at end of file diff --git a/api/modem/at.go b/api/modem/at.go deleted file mode 100644 index d7d0e86..0000000 --- a/api/modem/at.go +++ /dev/null @@ -1,53 +0,0 @@ -package modem - -import ( - "fmt" - "log" - "strings" - - "go.bug.st/serial" -) - -func (m *modem) makeAtReq(msg string) (string, error) { - log.Println("Write...") - if _, err := m.serialPort.Write([]byte(msg)); err != nil { - return "", fmt.Errorf("serial port write: %w", err) - } - log.Println("Read...") - readLen, err := m.serialPort.Read(m.inputBuf) - if err != nil { - return "", fmt.Errorf("port read: %w", err) - } - return strings.Split(string(m.inputBuf[:readLen]), "\n")[1], nil -} - -func (m *modem) makeAtEchoReqAndCheck(msg, checkMsg string) (bool, error) { - ans, err := m.makeAtReq(msg) - log.Println(msg, checkMsg) - if err != nil { - return false, err - } - return (len(ans) >= len(checkMsg) && ans[:len(checkMsg)] == checkMsg), nil -} - -func (m *modem) connect(port string) error { - log.Println("Connecting to", port, "...") - s, err := serial.Open(port, &serial.Mode{BaudRate: m.baudrate}) - if err != nil { - return fmt.Errorf("open port: %w", err) - } - // s.Close() There is no open f - // s.Open() - m.serialPort = s - return nil -} - -func (m *modem) disconnect() error { - defer func() { - m.serialPort = nil - }() - if err := m.serialPort.Close(); err != nil { - return fmt.Errorf("close port: %w", err) - } - return nil -} diff --git a/api/modem/at/at.go b/api/modem/at/at.go new file mode 100644 index 0000000..99caab2 --- /dev/null +++ b/api/modem/at/at.go @@ -0,0 +1,154 @@ +package at + +import ( + "fmt" + "log" + "strings" + "time" + + "go.bug.st/serial" +) + +// Some constants +const ( + ReadTimeout = time.Second + InputBufSize = 128 +) + +// Command types +type CmdType byte + +// Command types base on request/answer semantic: +const ( + CmdTest CmdType = iota + // AT\r\n + // OK + CmdCheck + // AT+\r\n + // OK + CmdGet + // AT+\r\n + // +: + CmdQuestion + // AT+?\r\n + // +: +) + +type atPort struct { + baudrate int + portName string + port serial.Port + inputBuf []byte +} + +type Port interface { + Connect() error + Disconnect() error + Request(cmdType CmdType, cmd string) (string, error) + GetName() string + IsConnected() bool + GetSerialPort() serial.Port // For extra need +} + +func New(portName string, baudrate int) Port { + return &atPort{ + portName: portName, + baudrate: baudrate, + inputBuf: make([]byte, InputBufSize), + } +} + +func (p *atPort) Connect() error { + log.Println("Connecting to", p.portName, "...") + s, err := serial.Open(p.portName, &serial.Mode{BaudRate: p.baudrate}) + if err != nil { + return fmt.Errorf("open port: %w", err) + } + // s.Close() There is no open f + // s.Open() + p.port = s + p.port.SetReadTimeout(ReadTimeout) + p.port.ResetInputBuffer() + p.port.ResetOutputBuffer() + return nil +} + +func (p *atPort) Disconnect() error { + defer func() { + p.port = nil + }() + if err := p.port.Close(); err != nil { + return fmt.Errorf("close port: %w", err) + } + return nil +} + +// Low level write/read function +func (p *atPort) makeReq(msg string) (string, error) { + // Write + p.port.ResetInputBuffer() + log.Println("Write...") // DEBUG + if written, err := p.port.Write([]byte(msg)); err != nil { + return "", fmt.Errorf("serial port write: %w", err) + } else { + log.Println("Written:", written) // DEBUG + } + // Read + log.Println("Read...") // DEBUG + readLen, err := p.port.Read(p.inputBuf) + if err != nil { + return "", fmt.Errorf("port read: %w", err) + } + + log.Println("Read: ", readLen, string(p.inputBuf[:readLen])) // DEBUG + return string(p.inputBuf[:readLen]), nil +} + +func (p *atPort) Request(cmdType CmdType, cmd string) (string, error) { + msg := "AT" + // Make command + // By default it just will be AT check cmd + switch cmdType { + case CmdGet, CmdCheck: + msg += cmd + case CmdQuestion: + msg += cmd + "?" + } + msg += "\r\n" + rawResp, err := p.makeReq(msg) + log.Println("Got") + if err != nil { + return "", fmt.Errorf("make at request: %w", err) + } + if len(rawResp) == 0 { + return "", fmt.Errorf("read nothing") + } + resp := strings.Split(rawResp, "\n") + switch cmdType { + case CmdTest, CmdCheck: + // Check and test cmds do not suppose anything but OK + if len(resp[1]) >= 2 && resp[1][:2] == "OK" { + return "", nil + } + return "", fmt.Errorf("connection lost") + case CmdGet, CmdQuestion: + checkL := len(cmd) + 1 + if len(resp[1]) >= checkL && resp[1][:checkL] != "+"+cmd { + return "", fmt.Errorf("connetion lost") + } + return strings.Split(resp[1], ":")[1], nil + } + return "", fmt.Errorf("undefined command type") +} + +func (p *atPort) GetName() string { + return p.portName +} + +func (p *atPort) IsConnected() bool { + return p.port != nil +} + +func (p *atPort) GetSerialPort() serial.Port { + return p.port +} diff --git a/api/modem/gpio.go b/api/modem/gpio.go index e486a42..fec7597 100644 --- a/api/modem/gpio.go +++ b/api/modem/gpio.go @@ -1,44 +1,44 @@ package modem import ( - "fmt" + "log" "time" - gpio "github.com/warthog618/go-gpiocdev" + gpio "github.com/stianeikeland/go-rpio/v4" ) -func (m *modem) PowerOn() error { - c, err := gpio.NewChip(m.deviceName) - if err != nil { - return fmt.Errorf("gpio new chip: %w", err) - } - l, err := c.RequestLine(m.powerKey, gpio.AsOutput(0)) - if err != nil { - return fmt.Errorf("gpio request line: %w", err) - } - m.gpioLine = l - time.Sleep(100 * time.Millisecond) - if err := m.gpioLine.SetValue(1); err != nil { - return fmt.Errorf("gpio set value: %w", err) - } - time.Sleep(3 * time.Second) - if err := m.gpioLine.SetValue(0); err != nil { - return fmt.Errorf("gpio set value: %w", err) - } - time.Sleep(30 * time.Second) - return nil +type gpioPin struct { + Pin gpio.Pin } -func (m *modem) PowerOff() error { - time.Sleep(100 * time.Millisecond) - if err := m.gpioLine.SetValue(1); err != nil { - return fmt.Errorf("gpio set value: %w", err) - } - time.Sleep(3 * time.Second) - if err := m.gpioLine.SetValue(0); err != nil { - return fmt.Errorf("gpio set value: %w", err) - } - time.Sleep(30 * time.Second) - m.gpioLine = nil - return nil +func (p gpioPin) Init() error { + return gpio.Open() +} + +func (p gpioPin) sendOnOffSignal() { + p.Pin.Output() + log.Println("Power on 0/3 + 100ms") + p.Pin.Low() + p.Pin.Toggle() + time.Sleep(100 * time.Millisecond) + + log.Println("Power on 1/3 + 3s") + p.Pin.High() + p.Pin.Toggle() + time.Sleep(3 * time.Second) + + log.Println("Power on 2/3 + 30s") + p.Pin.Low() + p.Pin.Toggle() + time.Sleep(30 * time.Second) + + log.Println("Power on 3/3") +} + +func (p gpioPin) PowerOn() { + p.sendOnOffSignal() +} + +func (p *gpioPin) PowerOff() { + p.sendOnOffSignal() } diff --git a/api/modem/modem.go b/api/modem/modem.go index 4fadc43..9139603 100644 --- a/api/modem/modem.go +++ b/api/modem/modem.go @@ -1,194 +1,199 @@ package modem import ( + "annalist/api/modem/at" + "encoding/json" "errors" "fmt" "log" "math" "os" "os/exec" + "slices" + "strconv" "strings" "time" - - gpio "github.com/warthog618/go-gpiocdev" - "go.bug.st/serial" ) +type GpsInfo struct { + Latitude float64 `json:"Latitude"` + Longitude float64 `json:"Longitude"` + LatitudeIndicator string `json:"Latitude_indicator"` // North/South + LongitudeIndicator string `json:"Longitude_indicator"` // West/East + Speed float64 `json:"Speed"` + Course float64 `json:"-"` + Altitude float64 `json:"-"` + Date string `json:"-"` + Time string `json:"-"` +} + type modem struct { // Serial stuff - port string + baudrate int + deviceName string - baudrate int - inputBuf []byte - serialPort serial.Port + port at.Port isAvailable bool // Gpio stuff - powerKey int - gpioLine *gpio.Line + onOffPin gpioPin // Other values - speed float64 - latitude_ns float64 - latitude float64 - longitude_we float64 - longitude float64 - + gpsInfo GpsInfo lastUpdateTime time.Time } type Modem interface { Init() error SearchPort(isSoft bool) error - PowerOn() error - PowerOff() error Connect() error - Ping() (bool, error) + Ping() error SwitchToGpsMode() error CalculateSpeed(newLatitude, newlongitude float64) Update() error - GetInfo() string + GetInfo() (string, error) TestGPS() error } func New() Modem { return &modem{ baudrate: 115200, - powerKey: 6, + onOffPin: gpioPin{Pin: 6}, lastUpdateTime: time.Now(), - inputBuf: make([]byte, 128), } } func (m *modem) Init() error { + // Turn module on + if err := m.onOffPin.Init(); err != nil { + return fmt.Errorf("gpio pin init: %w", err) + } + m.onOffPin.PowerOn() + + // Soft search if err := m.SearchPort(true); err != nil { return fmt.Errorf("soft port search: %w", err) } - if m.port == "" { + + return nil + + // Common search + if m.port == nil { if err := m.SearchPort(false); err != nil { return fmt.Errorf("not soft port search: %w", err) } } - if m.port == "" { + if m.port == nil { return errors.New("no port is detected") } + + // Connect if err := m.Connect(); err != nil { return fmt.Errorf("connect: %w", err) } + // Tests if err := m.TestGPS(); err != nil { return fmt.Errorf("testGPS: %w", err) } return nil } -func (m *modem) SearchPort(isSoft bool) error { - ports := []string{} - - // Get ports - if isSoft { - ports = []string{"ttyUSB1", "ttyUSB2", "ttyUSB3"} - } else { - /**/ - log.Print("Search for ports...") - out, err := exec.Command("/bin/ls", "/dev").Output() - if err != nil { - return fmt.Errorf("execute ls command: %w", err) - } - allPorts := strings.Split(string(out), "\n") - for _, p := range allPorts { - if len(p) > 2 && p[:3] == "tty" { - ports = append(ports, p) - } - } - // slices.Reverse(ports) // TODO why +func (m *modem) checkPort(portName string) error { + // Check device for existance + if _, err := os.Stat(portName); err != nil { + return fmt.Errorf("device does not exist") } + + // Check serial connection + // Connect + port := at.New(portName, m.baudrate) + if err := port.Connect(); err != nil { + return fmt.Errorf("connect: %w", err) + } + defer port.Disconnect() // Do not bother about errors... + + // Ping + log.Println("Ping...") + + if err := m.Ping(); err != nil { + return fmt.Errorf("ping error: %w", err) + } + + // Check model + model, err := port.Request(at.CmdGet, "CGMM") + if err != nil { + return fmt.Errorf("get model: %w", err) + } + if model != "SIMCOM_SIM7600E-H" { + return fmt.Errorf("invalid modem model: %s", model) + } + return nil +} + +func (m *modem) SearchPort(isSoft bool) error { + // Get ports + ports := []string{"ttyUSB1", "ttyUSB2", "ttyUSB3"} + if !isSoft { + ps, err := GetTtyDevices() + if err != nil { + fmt.Errorf("get serial devices: %w", err) + } + ports = ps + } + // Check ports - log.Println("Found ports: ", ports) - log.Println("Check...") - defer func() { - if m.serialPort != nil { - m.disconnect() // TODO maybe handle - } - }() +SearchLoop: for _, p := range ports { - if m.serialPort != nil { - if err := m.disconnect(); err != nil { - return fmt.Errorf("disconnect: %w", err) - } - } - log.Println("Checking port: ", p) - if _, err := os.Stat("/dev/" + p); err != nil { - continue - } - if err := m.connect("/dev/" + p); err != nil { - log.Println("Error:", fmt.Errorf("connect: %w", err).Error()) - continue - } + log.Printf("Checking port %s ...\n", p) - // Ping - log.Println("Ping...") - if ok, err := m.Ping(); err != nil || !ok { - if err != nil { - return fmt.Errorf("ping error: %w", err) - } - return errors.New("modem does not ping") - } - - // Check model - { - ok, err := m.makeAtEchoReqAndCheck("AT+CGMM\r\n", "SIMCOM_SIM7600E-H") - if err != nil { - return fmt.Errorf("make serial request: %w", err) - } - if !ok { - continue - } + if err := m.checkPort("/dev/" + p); err != nil { + log.Printf("Check failed: %s\n", err.Error()) + continue SearchLoop } log.Print("Found modem on port: ", p) - m.port = "/dev/" + p + m.port = at.New("/dev/"+p, m.baudrate) m.isAvailable = true return nil } - // return errors.New("no a compatible modem port found") return nil } func (m *modem) Connect() error { - return m.connect(m.port) + if m.port == nil { + return fmt.Errorf("port is not defined") + } + return m.port.Connect() } -func (m *modem) Ping() (bool, error) { - return m.makeAtEchoReqAndCheck("AT\r\n", "OK") +func (m *modem) Ping() error { + _, err := m.port.Request(at.CmdTest, "") + return err } func (m *modem) SwitchToGpsMode() error { - if err := m.serialPort.ResetInputBuffer(); err != nil { + log.Println("Enabling GPS mode...") + // Reset intput + if err := m.port.GetSerialPort().ResetInputBuffer(); err != nil { return fmt.Errorf("reset input buffer: %w", err) } - ans, err := m.makeAtReq("AT+CGPS?\r\n") + + // Check gps mode status + ans, err := m.port.Request(at.CmdQuestion, "CGPS") if err != nil { - return fmt.Errorf("make serial request: %w", err) + return fmt.Errorf("make at ask: %w", err) } - resp := strings.Split(ans, ":") - if !(len(resp) > 1 && resp[0] == "+CGPS") { - return errors.New("lost connection while checking gps status") - } - switch resp[1][1] { - case '1': + if ans == "1" { log.Println("GPS already enabled") return nil - case '0': - ok, err := m.makeAtEchoReqAndCheck("AT+CGPS=1", "OK") - if err != nil { - return fmt.Errorf("try to switch to gps mode echo reqest: %w", err) - } - if !ok { - return errors.New("lost connection while trying to switch to gps mode") - } - default: - return errors.New("unexpected response of gps status") } + + // Modem is not in GPS mode + _, err = m.port.Request(at.CmdCheck, "CGPS=1") + if err != nil { + return fmt.Errorf("try to switch to gps: %w", err) + } + log.Println("GPS mode enabled") return nil } @@ -199,13 +204,13 @@ func deg2rad(deg float64) float64 { func (m *modem) CalculateSpeed(newLatitude, newLongitude float64) { log.Println("Calculate speed") earthRad := 6371.0 // TODO ? - dLat := deg2rad(math.Abs(newLatitude - m.latitude)) - dLon := deg2rad(math.Abs(newLongitude - m.longitude)) + dLat := deg2rad(math.Abs(newLatitude - m.gpsInfo.Latitude)) + dLon := deg2rad(math.Abs(newLongitude - m.gpsInfo.Longitude)) a := math.Sin(dLat/2)*math.Sin(dLat/2) + - math.Cos(deg2rad(newLatitude))*math.Cos(deg2rad(m.latitude))*math.Sin(dLon/2)*math.Sin(dLon/2) + math.Cos(deg2rad(newLatitude))*math.Cos(deg2rad(m.gpsInfo.Latitude))*math.Sin(dLon/2)*math.Sin(dLon/2) c := 2 * math.Atan2(math.Sqrt(a), math.Sqrt(1-a)) - m.speed = earthRad * c / (math.Abs(float64(time.Since(m.lastUpdateTime)))) + m.gpsInfo.Speed = earthRad * c / (math.Abs(float64(time.Since(m.lastUpdateTime)))) } func (m *modem) Update() error { @@ -214,23 +219,143 @@ func (m *modem) Update() error { log.Println("No connection to module") return nil } - m.serialPort.ResetInputBuffer() - // MAKE + ans, err := m.port.Request(at.CmdQuestion, "CGPSINFO") + if err != nil { + return fmt.Errorf("check GPS info mode: %w", err) + } + ok := ans == "1" + if !ok { + _, err := m.port.Request(at.CmdCheck, "CGPSINFO") + if err != nil { + return fmt.Errorf("switch to GPS info mode: %w", err) + } + log.Println("switched to GPS mode") + } else { + log.Println("mode in right GPS mode") + } + + // Update + + log.Println("Receiving GPS data...") + resp, err := m.port.Request(at.CmdGet, "GPSINFO") + if err != nil { + return fmt.Errorf("receive GPS data: %w", err) + } + + log.Println("Decoding data...") + coordinates := strings.Split(resp, ",") + + m.gpsInfo.Latitude, err = strconv.ParseFloat(coordinates[0], 64) + if err != nil { + return fmt.Errorf("parse latitude: %w", err) + } + m.gpsInfo.Longitude, err = strconv.ParseFloat(coordinates[2], 64) + if err != nil { + return fmt.Errorf("parse longitude: %w", err) + } + m.gpsInfo.LatitudeIndicator = coordinates[1] + m.gpsInfo.LatitudeIndicator = coordinates[3] + m.gpsInfo.Date = coordinates[4] + m.gpsInfo.Time = coordinates[5] + m.gpsInfo.Altitude, err = strconv.ParseFloat(coordinates[6], 64) + if err != nil { + return fmt.Errorf("parse altitude: %w", err) + } + m.gpsInfo.Speed, err = strconv.ParseFloat(coordinates[7], 64) + if err != nil { + return fmt.Errorf("parse speed: %w", err) + } + m.gpsInfo.Course, err = strconv.ParseFloat(coordinates[8], 64) + if err != nil { + return fmt.Errorf("parse course: %w", err) + } + log.Println("Decoded successfully") + return nil } -func (m *modem) GetInfo() string { - return "" +type ModemInfo struct { + Port string `json:"Port"` + GpsInfo +} + +type Info struct { + Modem ModemInfo `json:"Modem"` +} + +func (m *modem) GetInfo() (string, error) { + info := Info{ + Modem: ModemInfo{ + Port: m.port.GetName(), + GpsInfo: m.gpsInfo, + }, + } + buf, err := json.Marshal(info) + if err != nil { + fmt.Errorf("marshal info: %w", err) + } + return string(buf), nil // why you clamp +} + +// Difference: I do not set \n at the end of string +func (m *modem) GetShortInfo() string { + return fmt.Sprintf("%f,%s,%f,%s", m.gpsInfo.Latitude, m.gpsInfo.LatitudeIndicator, m.gpsInfo.Longitude, m.gpsInfo.LongitudeIndicator) +} + +func (m *modem) SaveGPS(path string) error { + f, err := os.OpenFile(path, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0600) + if err != nil { + return fmt.Errorf("open file: %w", err) + } + + defer f.Close() + + if _, err = f.WriteString(m.GetShortInfo()); err != nil { + return fmt.Errorf("write file: %W", err) + } + return nil } func (m *modem) TestGPS() error { + log.Println("Testing GPS") + + if err := m.SwitchToGpsMode(); err != nil { + return fmt.Errorf("switch to GPS: %w", err) + } + + if err := m.Update(); err != nil { + return fmt.Errorf("update: %w", err) + } + + log.Println("Current coords:", m.GetShortInfo()) return nil } +func GetTtyDevices() ([]string, error) { + devices := []string{} + + // Get ports + /**/ + log.Print("Search for ports...") + out, err := exec.Command("/bin/ls", "/dev").Output() + if err != nil { + return nil, fmt.Errorf("execute ls command: %w", err) + } + allPorts := strings.Split(string(out), "\n") + for _, p := range allPorts { + if len(p) > 3 && p[:3] == "tty" { + devices = append(devices, p) + } + } + slices.Reverse(devices) // ASK why + + return devices, nil +} + /* TODOs: maybe to store read/write buf in obj QUESTIONS: - do many threads? + JSON why you clamp */ /* diff --git a/go.mod b/go.mod index 721f1aa..da33ec1 100644 --- a/go.mod +++ b/go.mod @@ -3,11 +3,12 @@ module annalist go 1.22.5 require ( - github.com/warthog618/go-gpiocdev v0.9.0 + github.com/stianeikeland/go-rpio/v4 v4.6.0 go.bug.st/serial v1.6.2 ) require ( github.com/creack/goselect v0.1.2 // indirect + github.com/stretchr/testify v1.9.0 // indirect golang.org/x/sys v0.18.0 // indirect ) diff --git a/go.sum b/go.sum index c3a9fb6..3d8776f 100644 --- a/go.sum +++ b/go.sum @@ -2,16 +2,12 @@ github.com/creack/goselect v0.1.2 h1:2DNy14+JPjRBgPzAd1thbQp4BSIihxcBf0IXhQXDRa0 github.com/creack/goselect v0.1.2/go.mod h1:a/NhLweNvqIYMuxcMOuWY516Cimucms3DglDzQP3hKY= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= -github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/stianeikeland/go-rpio/v4 v4.6.0 h1:eAJgtw3jTtvn/CqwbC82ntcS+dtzUTgo5qlZKe677EY= +github.com/stianeikeland/go-rpio/v4 v4.6.0/go.mod h1:A3GvHxC1Om5zaId+HqB3HKqx4K/AqeckxB7qRjxMK7o= github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= -github.com/warthog618/go-gpiocdev v0.9.0 h1:AZWUq1WObgKCO9cJCACFpwWQw6yu8vJbIE6fRZ+6cbY= -github.com/warthog618/go-gpiocdev v0.9.0/go.mod h1:GV4NZC82fWJERqk7Gu0+KfLSDIBEDNm6aPGiHlmT5fY= -github.com/warthog618/go-gpiosim v0.1.0 h1:2rTMTcKUVZxpUuvRKsagnKAbKpd3Bwffp87xywEDVGI= -github.com/warthog618/go-gpiosim v0.1.0/go.mod h1:Ngx/LYI5toxHr4E+Vm6vTgCnt0of0tktsSuMUEJ2wCI= go.bug.st/serial v1.6.2 h1:kn9LRX3sdm+WxWKufMlIRndwGfPWsH1/9lCWXQCasq8= go.bug.st/serial v1.6.2/go.mod h1:UABfsluHAiaNI+La2iESysd9Vetq7VRdpxvjx7CmmOE= golang.org/x/sys v0.18.0 h1:DBdB3niSjOA/O0blCZBqDefyWNYveAYMNF1Wum0DYQ4= diff --git a/main.go b/main.go index 24b74dc..61f6e53 100644 --- a/main.go +++ b/main.go @@ -16,4 +16,10 @@ func main() { func mainE() error { m := modem.New() return m.Init() + // ports, err := serial.GetPortsList() + // if err != nil { + // return err + // } + // log.Println(ports) + // return nil } diff --git a/readme.md b/readme.md new file mode 100644 index 0000000..c128a3e --- /dev/null +++ b/readme.md @@ -0,0 +1,2 @@ +ISSUES: + - create input buffer every at port creation \ No newline at end of file