Files
beatglow/display/oled/bus.go
T
2026-10-29 17:28:51 +01:00

196 lines
3.9 KiB
Go

// Package oled contains common routines for driving OLEDs.
package oled
import (
"fmt"
"strings"
"time"
"git.maze.io/go/harmon/config"
"git.maze.io/go/harmon/display"
"periph.io/x/conn/v3/gpio"
"periph.io/x/conn/v3/i2c"
"periph.io/x/conn/v3/i2c/i2creg"
"periph.io/x/conn/v3/physic"
"periph.io/x/conn/v3/spi"
"periph.io/x/conn/v3/spi/spireg"
)
type Bus interface {
// Halt the bus.
Halt() error
// Tx transfers bytes.
Tx(data []byte, isCommand bool) error
String() string
}
func NewBus(config *config.Display) (Bus, error) {
if config.Bus == "" || strings.HasPrefix(config.Bus, "i2c") {
return newI2C(config)
}
return newSPI(config)
}
type I2C struct {
bus i2c.BusCloser
conn *i2c.Dev
}
func newI2C(config *config.Display) (Bus, error) {
addr, err := display.ParseI2CAddress(config.Address)
if err != nil {
return nil, fmt.Errorf("invalid I2C address %q: %w", config.Address, err)
}
bus, err := i2creg.Open(config.Bus)
if err != nil {
return nil, fmt.Errorf("error opening I2C bus %q: %w", config.Bus, err)
}
return &I2C{
bus: bus,
conn: &i2c.Dev{Bus: bus, Addr: addr},
}, nil
}
func (bus *I2C) Halt() error {
return bus.bus.Close()
}
func (bus *I2C) Tx(data []byte, isCommand bool) error {
if isCommand {
return bus.conn.Tx(append([]byte{0x00}, data...), nil)
}
return bus.conn.Tx(append([]byte{0x40}, data...), nil)
}
func (bus *I2C) String() string {
return "I²C"
}
type SPI struct {
Reset gpio.PinOut
DC gpio.PinOut
CS gpio.PinOut
port spi.PortCloser
conn spi.Conn
}
func newSPI(config *config.Display) (Bus, error) {
var (
freq physic.Frequency = 800 * physic.KiloHertz
reset, dc, cs gpio.PinOut
err error
)
if config.Freq != "" {
if err = freq.Set(config.Freq); err != nil {
return nil, err
}
}
if reset, err = display.LookupPinOut(config.Reset); err != nil {
return nil, fmt.Errorf("invalid reset pin %q: %w", config.Reset, err)
}
if dc, err = display.LookupPinOut(config.DC); err != nil {
return nil, fmt.Errorf("invalid dc pin %q: %w", config.DC, err)
}
if cs, err = display.LookupPinOut(config.CS); err != nil {
return nil, fmt.Errorf("invalid cs pin %q: %w", config.CS, err)
}
port, err := spireg.Open(config.Port)
if err != nil {
return nil, fmt.Errorf("opening SPI port %q failed: %w", config.Port, err)
}
conn, err := port.Connect(freq, spi.Mode0, 8)
if err != nil {
return nil, fmt.Errorf("connecting on SPI port %q failed: %w", config.Port, err)
}
bus := &SPI{
Reset: reset,
DC: dc,
CS: cs,
port: port,
conn: conn,
}
if err = bus.reset(); err != nil {
return nil, err
}
return bus, nil
}
func (bus *SPI) Halt() error {
return bus.port.Close()
}
func (bus *SPI) reset() (err error) {
if err = bus.CS.Out(gpio.Low); err != nil {
return
}
if err = bus.DC.Out(gpio.Low); err != nil {
return
}
if err = bus.Reset.Out(gpio.Low); err != nil {
return
}
if err = bus.Reset.Out(gpio.High); err != nil {
return
}
time.Sleep(1 * time.Millisecond)
if err = bus.Reset.Out(gpio.Low); err != nil {
return
}
time.Sleep(10 * time.Millisecond)
if err = bus.Reset.Out(gpio.High); err != nil {
return
}
return
}
func (bus *SPI) Tx(data []byte, isCommand bool) (err error) {
if isCommand {
if err = bus.CS.Out(gpio.High); err != nil {
return
}
time.Sleep(1 * time.Millisecond)
if err = bus.DC.Out(gpio.Low); err != nil {
return
}
if err = bus.CS.Out(gpio.Low); err != nil {
return
}
if err = bus.conn.Tx(data, nil); err != nil {
return
}
if err = bus.CS.Out(gpio.High); err != nil {
return
}
} else {
if err = bus.CS.Out(gpio.High); err != nil {
return
}
time.Sleep(1 * time.Millisecond)
if err = bus.DC.Out(gpio.High); err != nil {
return
}
if err = bus.CS.Out(gpio.Low); err != nil {
return
}
if err = bus.conn.Tx(data, nil); err != nil {
return
}
if err = bus.CS.Out(gpio.High); err != nil {
return
}
}
return
}
func (bus *SPI) String() string {
return "SPI"
}