271 lines
5.6 KiB
Go
271 lines
5.6 KiB
Go
package input
|
|
|
|
import (
|
|
"encoding/binary"
|
|
"errors"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/sirupsen/logrus"
|
|
"go.maze.io/harmon/hardware"
|
|
"periph.io/x/conn/v3/gpio"
|
|
)
|
|
|
|
const (
|
|
devfsPath = "/dev"
|
|
procfsPath = "/proc"
|
|
procInputDevices = procfsPath + "/bus/input/devices"
|
|
)
|
|
|
|
type devInputEncoder struct {
|
|
path string
|
|
click gpio.PinIn
|
|
}
|
|
|
|
func newDevInputEncoder(click string) (enc Encoder, err error) {
|
|
e := new(devInputEncoder)
|
|
if e.click, err = hardware.LookupPin(click); err != nil {
|
|
return
|
|
}
|
|
|
|
var ps []*linuxPheripheral
|
|
if ps, err = linuxPheripherals(); err != nil {
|
|
return
|
|
}
|
|
|
|
for _, p := range ps {
|
|
if strings.HasPrefix(p.name, "rotary@") {
|
|
e.path = p.path
|
|
return e, nil
|
|
}
|
|
}
|
|
return nil, errors.New("no rotary encoders found in " + procInputDevices)
|
|
}
|
|
|
|
type linuxPheripheral struct {
|
|
name string
|
|
bus string
|
|
vendor string
|
|
product string
|
|
version string
|
|
phys string
|
|
path string
|
|
}
|
|
|
|
/*
|
|
I: Bus=0019 Vendor=0001 Product=0001 Version=0100
|
|
N: Name="button@10"
|
|
P: Phys=gpio-keys/input0
|
|
S: Sysfs=/devices/platform/button@10/input/input0
|
|
U: Uniq=
|
|
H: Handlers=kbd event0
|
|
B: PROP=0
|
|
B: EV=3
|
|
B: KEY=20000 0 0 0
|
|
|
|
I: Bus=0019 Vendor=0000 Product=0000 Version=0000
|
|
N: Name="rotary@14"
|
|
P: Phys=
|
|
S: Sysfs=/devices/platform/rotary@14/input/input1
|
|
U: Uniq=
|
|
H: Handlers=event1
|
|
B: PROP=0
|
|
B: EV=5
|
|
B: REL=1
|
|
*/
|
|
func linuxPheripherals() (ps []*linuxPheripheral, err error) {
|
|
log := logrus.WithField("input", "linux")
|
|
log.Trace("detecting peripherals")
|
|
|
|
b, err := os.ReadFile(procInputDevices)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
for _, segment := range strings.Split(string(b), "\n\n") {
|
|
lines := strings.Split(segment, "\n")
|
|
perip := new(linuxPheripheral)
|
|
for _, line := range lines {
|
|
if line == "" {
|
|
continue
|
|
}
|
|
log.WithField("line", line).Trace("parsing line")
|
|
switch {
|
|
case strings.HasPrefix(line, "I: "):
|
|
for _, kv := range strings.Split(strings.TrimPrefix(line, "I: "), " ") {
|
|
kv := strings.SplitN(kv, "=", 2)
|
|
switch kv[0] {
|
|
case "Bus":
|
|
case "Vendor":
|
|
perip.vendor = kv[1]
|
|
case "Product":
|
|
perip.product = kv[1]
|
|
case "Version":
|
|
perip.version = kv[1]
|
|
}
|
|
}
|
|
case strings.HasPrefix(line, "N: Name="):
|
|
perip.name = strings.TrimFunc(strings.TrimPrefix(line, "N: Name="), func(r rune) bool { return r == '"' || r == '@' })
|
|
case strings.HasPrefix(line, "P: Phys="):
|
|
perip.phys = strings.TrimPrefix(line, "P: Phys=")
|
|
//case strings.HasPrefix(line, "S: Sysfs="):
|
|
// perip.sysfs = filepath.Join(sysfsPath, strings.TrimPrefix(line, "S: Sysfs="), "device")
|
|
case strings.HasPrefix(line, "H: Handlers="):
|
|
for _, handler := range strings.Split(strings.TrimPrefix(line, "H: Handlers="), " ") {
|
|
if strings.HasPrefix(handler, "event") {
|
|
perip.path = filepath.Join(devfsPath, "input", handler)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if perip.path != "" {
|
|
log.WithFields(logrus.Fields{
|
|
"name": perip.name,
|
|
"bus": perip.bus,
|
|
"vendor": perip.vendor,
|
|
"product": perip.product,
|
|
"version": perip.version,
|
|
"phys": perip.phys,
|
|
"path": perip.path,
|
|
}).Trace("found peripheral")
|
|
ps = append(ps, perip)
|
|
}
|
|
}
|
|
|
|
return ps, nil
|
|
}
|
|
|
|
type linuxInputEvent struct {
|
|
Secs uint32
|
|
USecs uint32
|
|
Type uint16
|
|
Code uint16
|
|
Value int32
|
|
}
|
|
|
|
func (e linuxInputEvent) Time() time.Time {
|
|
return time.Unix(int64(e.Secs), int64(e.USecs))
|
|
}
|
|
|
|
func readLinuxInputEvents(name string, cb func(linuxInputEvent) error) error {
|
|
f, err := os.Open(name)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var raw linuxInputEvent
|
|
for {
|
|
if err := binary.Read(f, binary.LittleEndian, &raw); err != nil {
|
|
_ = f.Close()
|
|
return err
|
|
}
|
|
if err := cb(raw); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
|
|
type linuxButton struct {
|
|
p *linuxPheripheral
|
|
}
|
|
|
|
func newLinuxButton(p *linuxPheripheral) *linuxButton {
|
|
return &linuxButton{p: p}
|
|
}
|
|
|
|
func (s *linuxButton) Name() string {
|
|
return s.p.name
|
|
}
|
|
|
|
func (s *linuxButton) Events() (<-chan Event, error) {
|
|
log := logrus.
|
|
WithField("input", "button").
|
|
WithField("path", s.p.path)
|
|
log.Debug("opening linux button source")
|
|
|
|
events := make(chan Event)
|
|
go s.readEvents(events)
|
|
return events, nil
|
|
}
|
|
|
|
func (s *linuxButton) readEvents(events chan<- Event) {
|
|
defer close(events)
|
|
|
|
log := logrus.
|
|
WithField("input", "button").
|
|
WithField("path", s.p.path)
|
|
|
|
err := readLinuxInputEvents(s.p.path, func(ev linuxInputEvent) error {
|
|
log.WithField("data", ev).Debug("button event")
|
|
|
|
if ev.Code == 0 {
|
|
return nil // not sure what this is
|
|
}
|
|
|
|
var pressed bool
|
|
if ev.Value == 1 {
|
|
pressed = true
|
|
}
|
|
|
|
select {
|
|
case events <- NewButtonEvent(s, pressed):
|
|
default:
|
|
log.Warn("dropping event")
|
|
}
|
|
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
log.WithError(err).Error("failed to read events")
|
|
}
|
|
}
|
|
|
|
type linuxRotary struct {
|
|
p *linuxPheripheral
|
|
}
|
|
|
|
func newLinuxRotary(p *linuxPheripheral) *linuxRotary {
|
|
return &linuxRotary{p: p}
|
|
}
|
|
|
|
func (s *linuxRotary) Name() string {
|
|
return s.p.name
|
|
}
|
|
|
|
func (s *linuxRotary) Events() (<-chan Event, error) {
|
|
log := logrus.
|
|
WithField("input", "rotary").
|
|
WithField("path", s.p.path)
|
|
log.Debug("opening linux rotary source")
|
|
|
|
events := make(chan Event)
|
|
go s.readEvents(events)
|
|
return events, nil
|
|
}
|
|
|
|
func (s *linuxRotary) readEvents(events chan<- Event) {
|
|
defer close(events)
|
|
|
|
log := logrus.
|
|
WithField("input", "rotary").
|
|
WithField("path", s.p.path)
|
|
|
|
err := readLinuxInputEvents(s.p.path, func(ev linuxInputEvent) error {
|
|
log.WithField("data", ev).Debug("rotary event")
|
|
|
|
select {
|
|
case events <- NewRotaryEvent(s, int(ev.Value), ev.Value == 0):
|
|
default:
|
|
log.Warn("dropping event")
|
|
}
|
|
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
log.WithError(err).Error("failed to read events")
|
|
}
|
|
}
|