Checkpoint

This commit is contained in:
maze authored and maze committed 2026-10-29 17:29:41 +01:00
1 parent 0295eb1ad2
commit b8a493b93d
138 files changed
+1898 -57607

No files matched your search

+360
View File
@@ -0,0 +1,360 @@
// Package ssd1306 implements SSD1306 (monochrome) OLED displays.
package ssd1306
import (
"bytes"
"fmt"
"image"
"image/color"
"image/draw"
"periph.io/x/conn/v3/gpio"
"go.maze.io/harmon/config"
"go.maze.io/harmon/hardware"
"go.maze.io/harmon/hardware/display"
"go.maze.io/harmon/internal/pixel"
)
const (
defaultWidth = 128
defaultHeight = 64
)
func init() {
display.Register("ssd1306", newDriver)
}
type Display struct {
conn display.Conn
rect image.Rectangle
rotate display.Rotation
bl gpio.PinOut
buffer []byte
next *pixel.VerticalLSB
startPage, endPage int
startCol, endCol int
scrolled bool
halted bool
}
func (Display) Type() string { return "ssd1306" }
func newDriver(config config.DisplayConfig) (hardware.Display, error) {
var (
opts *display.Options
conn display.Conn
err error
)
if opts, err = display.ParseOptions(config, defaultWidth, defaultHeight); err != nil {
return nil, err
}
if opts.Rotate == display.Rotate180 {
// Let the hardware handle this rotation.
opts.Flip = true
opts.Mirror = true
}
switch config.Mode {
case "", "i2c":
conn, err = display.OpenI2C(config.Bus, config.Address)
case "spi":
conn, err = display.OpenSPI(config.Port, config.Reset, config.DC)
default:
return nil, display.InvalidMode(config.Mode)
}
if err != nil {
return nil, err
}
return newDisplay(conn, opts)
}
func newDisplay(conn display.Conn, opts *display.Options) (*Display, error) {
if opts.W < 8 || opts.W > 128 || opts.W&7 != 0 {
return nil, fmt.Errorf("invalid width %d", opts.W)
}
if opts.H < 8 || opts.H > 64 || opts.H&7 != 0 {
return nil, fmt.Errorf("invalid height %d", opts.H)
}
nbPages := opts.H / 8
pageSize := opts.W
d := &Display{
conn: conn,
bl: opts.Backlight,
rect: image.Rect(0, 0, opts.W, opts.H),
rotate: opts.Rotate,
buffer: make([]byte, nbPages*pageSize),
startPage: 0,
endPage: nbPages,
startCol: 0,
endCol: opts.W,
scrolled: true, // Signal that the screen must be redrawn on first draw().
}
if err := d.sendCommand(getInitCmd(opts)); err != nil {
return nil, err
}
return d, nil
}
func (d *Display) sendData(data []byte) error {
if d.halted {
// Transparently enable the display.
if err := d.sendCommand(nil); err != nil {
return err
}
}
return d.conn.Tx(data, false)
}
func (d *Display) sendCommand(data []byte) error {
if d.halted {
// Transparently enable the display.
data = append([]byte{0xAF}, data...)
d.halted = false
}
return d.conn.Tx(data, true)
}
func (d *Display) calculateSubset(next []byte) (int, int, int, int, bool) {
w := d.rect.Dx()
h := d.rect.Dy()
startPage := 0
endPage := h / 8
startCol := 0
endCol := w
if d.scrolled {
// Painting disable scrolling but if scrolling was enabled, this requires a
// full screen redraw.
d.scrolled = false
} else {
// Calculate the smallest square that need to be sent.
pageSize := w
// Top.
for ; startPage < endPage; startPage++ {
x := pageSize * startPage
y := pageSize * (startPage + 1)
if !bytes.Equal(d.buffer[x:y], next[x:y]) {
break
}
}
// Bottom.
for ; endPage > startPage; endPage-- {
x := pageSize * (endPage - 1)
y := pageSize * endPage
if !bytes.Equal(d.buffer[x:y], next[x:y]) {
break
}
}
if startPage == endPage {
// Early exit, the image is exactly the same.
return 0, 0, 0, 0, true
}
// Left.
for ; startCol < endCol; startCol++ {
for i := startPage; i < endPage; i++ {
x := i*pageSize + startCol
if d.buffer[x] != next[x] {
goto breakLeft
}
}
}
breakLeft:
// Right.
for ; endCol > startCol; endCol-- {
for i := startPage; i < endPage; i++ {
x := i*pageSize + endCol - 1
if d.buffer[x] != next[x] {
goto breakRight
}
}
}
breakRight:
}
return startPage, endPage, startCol, endCol, false
}
// drawInternal sends image data to the controller.
func (d *Display) drawInternal(next []byte) error {
startPage, endPage, startCol, endCol, skip := d.calculateSubset(next)
if skip {
return nil
}
copy(d.buffer, next)
if d.startPage != startPage || d.endPage != endPage || d.startCol != startCol || d.endCol != endCol {
d.startPage = startPage
d.endPage = endPage
d.startCol = startCol
d.endCol = endCol
}
pageSize := d.rect.Dx()
for page := d.startPage; page < d.endPage; page++ {
err := d.sendCommand([]byte{
pageAddr | byte(page),
setLowColumn | (byte(d.startCol) & 0x0F),
setHighColumn | (byte(d.startCol) >> 4),
})
if err != nil {
return err
}
pageStart := page * pageSize
err = d.sendData(d.buffer[pageStart+d.startCol : pageStart+d.endCol])
if err != nil {
return err
}
}
return nil
}
// Halt turns off the display.
//
// Sending any other command afterward reenables the display.
func (d *Display) Halt() error {
d.halted = false
err := d.sendCommand([]byte{0xAE})
if err == nil {
d.halted = true
}
return err
}
// Size of the display.
func (d *Display) Size() image.Point {
if d.rotate == display.Rotate90 || d.rotate == display.Rotate270 {
return image.Pt(d.rect.Max.Y, d.rect.Max.X)
}
return d.rect.Max
}
// Draw implements display.Drawer.
//
// It draws synchronously, once this function returns, the display is updated.
// It means that on slow bus (I²C), it may be preferable to defer Draw() calls
// to a background goroutine.
func (d *Display) Draw(r image.Rectangle, src image.Image, sp image.Point) error {
var next []byte
if img, ok := src.(*pixel.VerticalLSB); ok && r.Eq(d.rect) && img.Rect.Eq(d.rect) && sp.X == 0 && sp.Y == 0 {
// Exact size, full frame, image1bit encoding: fast path!
next = img.Pix
} else {
// Double buffering.
if d.next == nil {
d.next = pixel.NewVerticalLSB(d.rect)
}
next = d.next.Pix
draw.Src.Draw(d.next, r, src, sp)
}
return d.drawInternal(next)
}
func getInitCmd(opts *display.Options) []byte {
// Set COM output scan direction; C0 means normal; C8 means reversed
comScan := byte(0xC8)
// See page 40.
columnAddr := byte(0xA1)
if opts.Rotate == display.Rotate180 {
// Change order both horizontally and vertically.
comScan = 0xC0
columnAddr = byte(0xA0)
}
if opts.Flip {
comScan = byte(0xC0)
}
if opts.Mirror {
columnAddr = byte(0xA0)
}
// See page 40.
hwLayout := byte(0x02)
if !opts.Sequential {
hwLayout |= 0x10
}
if opts.SwapTopBottom {
hwLayout |= 0x20
}
// Set the max frequency. The problem with I²C is that it creates visible
// tear down. On SPI at high speed this is not visible. Page 23 pictures how
// to avoid tear down. For now default to max frequency.
freq := byte(0xF0)
// Initialize the device by fully resetting all values.
// Page 64 has the full recommended flow.
// Page 28 lists all the commands.
return []byte{
0xAE, // Display off
0xD3, 0x00, // Set display offset; 0
0x40, // Start display start line; 0
columnAddr, // Set segment remap; RESET is column 127.
comScan, //
0xDA, hwLayout, // Set COM pins hardware configuration; see page 40
0x81, 0xFF, // Set max contrast
0xA4, // Set display to use GDDRAM content
0xA6, // Set normal display (0xA7 for inverted 0=lit, 1=dark)
0xD5, freq, // Set osc frequency and divide ratio; power on reset value is 0x80.
0x8D, 0x14, // Enable charge pump regulator; page 62
0xD9, 0xF1, // Set pre-charge period; from adafruit driver
0xDB, 0x40, // Set Vcomh deselect level; page 32
0x2E, // Deactivate scroll
0xA8, byte(opts.H - 1), // Set multiplex ratio (number of lines to display)
0x20, 0x00, // Set memory addressing mode to horizontal
0x21, 0, uint8(opts.W - 1), // Set column address (Width)
0x22, 0, uint8(opts.H/8 - 1), // Set page address (Pages)
0xAF, // Display on
}
}
func (d *Display) Invert(on bool) error {
if on {
return d.sendCommand([]byte{0xA7})
}
return d.sendCommand([]byte{0xA6})
}
/* hardware.Display interface methods */
func (d *Display) Fill(c color.Color) error {
//return d.Draw(d.rect, &image.Uniform{c}, image.Point{})
return d.sendCommand([]byte{0xa7}) // invert :D
}
func (d *Display) Refresh() error {
if d.next == nil {
return nil
}
return d.drawInternal(d.next.Pix)
}
/* draw.Image interface methods */
func (d *Display) At(x, y int) color.Color {
if d.next == nil {
return pixel.Off
}
return d.next.At(x, y)
}
func (d *Display) Bounds() image.Rectangle {
return d.rect
}
func (d *Display) ColorModel() color.Model {
return pixel.MonochromeModel
}
func (d *Display) Set(x, y int, c color.Color) {
if d.next == nil {
d.next = pixel.NewVerticalLSB(d.rect)
}
d.next.Set(x, y, c)
}