KRBL/sim-modem
11
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 1 Wiki Activity

Potencially working.

Browse Source
This commit is contained in:
Andrey Egorov 2024-07-21 16:05:09 +03:00
parent c8f30c0caf
commit f160282fe2
9 changed files with 440 additions and 209 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile
View File

@ -5,7 +5,7 @@ build:
# @./out/annalist.exe # @./out/annalist.exe
linux: linux:
@$Env:GOOS="linux" $Env:GOARCH="arm" $Env:GOARM=5 @$Env:GOOS="linux"; $Env:GOARCH="arm"; $Env:GOARM=5
# .profile # .profile
# cgo_enabled 0 # cgo_enabled 0

53
api/modem/at.go
View File

@ -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
}

154
api/modem/at/at.go Normal file
View File

@ -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+<CMD>\r\n
// OK
CmdGet
// AT+<CMD>\r\n
// +<CMD>: <ANS>
CmdQuestion
// AT+<CMD>?\r\n
// +<CMD>: <ANS>
)
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
}

68
api/modem/gpio.go
View File

@ -1,44 +1,44 @@
package modem package modem
import ( import (
"fmt" "log"
"time" "time"
gpio "github.com/warthog618/go-gpiocdev" gpio "github.com/stianeikeland/go-rpio/v4"
) )
func (m *modem) PowerOn() error { type gpioPin struct {
c, err := gpio.NewChip(m.deviceName) Pin gpio.Pin
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
} }
func (m *modem) PowerOff() error { func (p gpioPin) Init() error {
time.Sleep(100 * time.Millisecond) return gpio.Open()
if err := m.gpioLine.SetValue(1); err != nil { }
return fmt.Errorf("gpio set value: %w", err)
} func (p gpioPin) sendOnOffSignal() {
time.Sleep(3 * time.Second) p.Pin.Output()
if err := m.gpioLine.SetValue(0); err != nil { log.Println("Power on 0/3 + 100ms")
return fmt.Errorf("gpio set value: %w", err) p.Pin.Low()
} p.Pin.Toggle()
time.Sleep(30 * time.Second) time.Sleep(100 * time.Millisecond)
m.gpioLine = nil
return nil 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()
} }

353
api/modem/modem.go
View File

@ -1,194 +1,199 @@
package modem package modem
import ( import (
"annalist/api/modem/at"
"encoding/json"
"errors" "errors"
"fmt" "fmt"
"log" "log"
"math" "math"
"os" "os"
"os/exec" "os/exec"
"slices"
"strconv"
"strings" "strings"
"time" "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 { type modem struct {
// Serial stuff // Serial stuff
port string baudrate int
deviceName string deviceName string
baudrate int port at.Port
inputBuf []byte
serialPort serial.Port
isAvailable bool isAvailable bool
// Gpio stuff // Gpio stuff
powerKey int onOffPin gpioPin
gpioLine *gpio.Line
// Other values // Other values
speed float64 gpsInfo GpsInfo
latitude_ns float64
latitude float64
longitude_we float64
longitude float64
lastUpdateTime time.Time lastUpdateTime time.Time
} }
type Modem interface { type Modem interface {
Init() error Init() error
SearchPort(isSoft bool) error SearchPort(isSoft bool) error
PowerOn() error
PowerOff() error
Connect() error Connect() error
Ping() (bool, error) Ping() error
SwitchToGpsMode() error SwitchToGpsMode() error
CalculateSpeed(newLatitude, newlongitude float64) CalculateSpeed(newLatitude, newlongitude float64)
Update() error Update() error
GetInfo() string GetInfo() (string, error)
TestGPS() error TestGPS() error
} }
func New() Modem { func New() Modem {
return &modem{ return &modem{
baudrate: 115200, baudrate: 115200,
powerKey: 6, onOffPin: gpioPin{Pin: 6},
lastUpdateTime: time.Now(), lastUpdateTime: time.Now(),
inputBuf: make([]byte, 128),
} }
} }
func (m *modem) Init() error { 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 { if err := m.SearchPort(true); err != nil {
return fmt.Errorf("soft port search: %w", err) 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 { if err := m.SearchPort(false); err != nil {
return fmt.Errorf("not soft port search: %w", err) return fmt.Errorf("not soft port search: %w", err)
} }
} }
if m.port == "" { if m.port == nil {
return errors.New("no port is detected") return errors.New("no port is detected")
} }
// Connect
if err := m.Connect(); err != nil { if err := m.Connect(); err != nil {
return fmt.Errorf("connect: %w", err) return fmt.Errorf("connect: %w", err)
} }
// Tests
if err := m.TestGPS(); err != nil { if err := m.TestGPS(); err != nil {
return fmt.Errorf("testGPS: %w", err) return fmt.Errorf("testGPS: %w", err)
} }
return nil return nil
} }
func (m *modem) SearchPort(isSoft bool) error { func (m *modem) checkPort(portName string) error {
ports := []string{} // Check device for existance
if _, err := os.Stat(portName); err != nil {
// Get ports return fmt.Errorf("device does not exist")
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
} }
// 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 // Check ports
log.Println("Found ports: ", ports) SearchLoop:
log.Println("Check...")
defer func() {
if m.serialPort != nil {
m.disconnect() // TODO maybe handle
}
}()
for _, p := range ports { for _, p := range ports {
if m.serialPort != nil { log.Printf("Checking port %s ...\n", p)
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
}
// Ping if err := m.checkPort("/dev/" + p); err != nil {
log.Println("Ping...") log.Printf("Check failed: %s\n", err.Error())
if ok, err := m.Ping(); err != nil || !ok { continue SearchLoop
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
}
} }
log.Print("Found modem on port: ", p) log.Print("Found modem on port: ", p)
m.port = "/dev/" + p m.port = at.New("/dev/"+p, m.baudrate)
m.isAvailable = true m.isAvailable = true
return nil return nil
} }
// return errors.New("no a compatible modem port found")
return nil return nil
} }
func (m *modem) Connect() error { 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) { func (m *modem) Ping() error {
return m.makeAtEchoReqAndCheck("AT\r\n", "OK") _, err := m.port.Request(at.CmdTest, "")
return err
} }
func (m *modem) SwitchToGpsMode() error { 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) 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 { if err != nil {
return fmt.Errorf("make serial request: %w", err) return fmt.Errorf("make at ask: %w", err)
} }
resp := strings.Split(ans, ":") if ans == "1" {
if !(len(resp) > 1 && resp[0] == "+CGPS") {
return errors.New("lost connection while checking gps status")
}
switch resp[1][1] {
case '1':
log.Println("GPS already enabled") log.Println("GPS already enabled")
return nil 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 return nil
} }
@ -199,13 +204,13 @@ func deg2rad(deg float64) float64 {
func (m *modem) CalculateSpeed(newLatitude, newLongitude float64) { func (m *modem) CalculateSpeed(newLatitude, newLongitude float64) {
log.Println("Calculate speed") log.Println("Calculate speed")
earthRad := 6371.0 // TODO ? earthRad := 6371.0 // TODO ?
dLat := deg2rad(math.Abs(newLatitude - m.latitude)) dLat := deg2rad(math.Abs(newLatitude - m.gpsInfo.Latitude))
dLon := deg2rad(math.Abs(newLongitude - m.longitude)) dLon := deg2rad(math.Abs(newLongitude - m.gpsInfo.Longitude))
a := math.Sin(dLat/2)*math.Sin(dLat/2) + 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)) 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 { func (m *modem) Update() error {
@ -214,23 +219,143 @@ func (m *modem) Update() error {
log.Println("No connection to module") log.Println("No connection to module")
return nil return nil
} }
m.serialPort.ResetInputBuffer() ans, err := m.port.Request(at.CmdQuestion, "CGPSINFO")
// MAKE 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 { type ModemInfo struct {
return "" 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 { 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 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: TODOs:
maybe to store read/write buf in obj maybe to store read/write buf in obj
QUESTIONS: QUESTIONS:
do many threads? JSON why you clamp
*/ */
/* /*

3
go.mod
View File

@ -3,11 +3,12 @@ module annalist
go 1.22.5 go 1.22.5
require ( 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 go.bug.st/serial v1.6.2
) )
require ( require (
github.com/creack/goselect v0.1.2 // indirect github.com/creack/goselect v0.1.2 // indirect
github.com/stretchr/testify v1.9.0 // indirect
golang.org/x/sys v0.18.0 // indirect golang.org/x/sys v0.18.0 // indirect
) )

8
go.sum
View File

@ -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/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 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= 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 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= 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 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= 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 h1:kn9LRX3sdm+WxWKufMlIRndwGfPWsH1/9lCWXQCasq8=
go.bug.st/serial v1.6.2/go.mod h1:UABfsluHAiaNI+La2iESysd9Vetq7VRdpxvjx7CmmOE= go.bug.st/serial v1.6.2/go.mod h1:UABfsluHAiaNI+La2iESysd9Vetq7VRdpxvjx7CmmOE=
golang.org/x/sys v0.18.0 h1:DBdB3niSjOA/O0blCZBqDefyWNYveAYMNF1Wum0DYQ4= golang.org/x/sys v0.18.0 h1:DBdB3niSjOA/O0blCZBqDefyWNYveAYMNF1Wum0DYQ4=

6
main.go
View File

@ -16,4 +16,10 @@ func main() {
func mainE() error { func mainE() error {
m := modem.New() m := modem.New()
return m.Init() return m.Init()
// ports, err := serial.GetPortsList()
// if err != nil {
// return err
// }
// log.Println(ports)
// return nil
} }

2
readme.md Normal file
View File

@ -0,0 +1,2 @@
ISSUES:
- create input buffer every at port creation