196 lines
3.9 KiB
Go
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"
|
|
}
|