Checkpoint

This commit is contained in:
maze authored and maze committed 2026-10-29 17:29:41 +01:00
1 parent b8a493b93d
commit 85a9ec684c
54 files changed
+6855 -526

No files matched your search

+146
View File
@@ -0,0 +1,146 @@
package st7789
import "go.maze.io/harmon/hardware/display"
const (
ST7789_TFTWIDTH = 240
ST7789_TFTHEIGHT = 240
ST7789_NOP = 0x00
ST7789_SWRESET = 0x01
ST7789_RDDID = 0x04
ST7789_RDDST = 0x09
ST7789_RDDPM = 0x0A
ST7789_RDDMADCTL = 0x0B
ST7789_RDDCOLMOD = 0x0C
ST7789_RDDIM = 0x0D
ST7789_RDDSM = 0x0E
ST7789_RDDSDR = 0x0F
ST7789_SLPIN = 0x10
ST7789_SLPOUT = 0x11
ST7789_PTLON = 0x12
ST7789_NORON = 0x13
ST7789_INVOFF = 0x20
ST7789_INVON = 0x21
ST7789_GAMSET = 0x26
ST7789_DISPOFF = 0x28
ST7789_DISPON = 0x29
ST7789_CASET = 0x2A
ST7789_RASET = 0x2B
ST7789_RAMWR = 0x2C
ST7789_RAMRD = 0x2E
ST7789_PTLAR = 0x30
ST7789_VSCRDEF = 0x33
ST7789_TEOFF = 0x34
ST7789_TEON = 0x35
ST7789_MADCTL = 0x36
ST7789_VSCRSADD = 0x37
ST7789_IDMOFF = 0x38
ST7789_IDMON = 0x39
ST7789_COLMOD = 0x3A
ST7789_RAMWRC = 0x3C
ST7789_RAMRDC = 0x3E
ST7789_TESCAN = 0x44
ST7789_RDTESCAN = 0x45
ST7789_WRDISBV = 0x51
ST7789_RDDISBV = 0x52
ST7789_WRCTRLD = 0x53
ST7789_RDCTRLD = 0x54
ST7789_WRCACE = 0x55
ST7789_RDCABC = 0x56
ST7789_WRCABCMB = 0x5E
ST7789_RDCABCMB = 0x5F
ST7789_RDABCSDR = 0x68
ST7789_RDID1 = 0xDA
ST7789_RDID2 = 0xDB
ST7789_RDID3 = 0xDC
ST7789_RAMCTRL = 0xB0
ST7789_RGBCTRL = 0xB1
ST7789_PORCTRL = 0xB2
ST7789_FRCTRL1 = 0xB3
ST7789_GCTRL = 0xB7
ST7789_DGMEN = 0xBA
ST7789_VCOMS = 0xBB
ST7789_LCMCTRL = 0xC0
ST7789_IDSET = 0xC1
ST7789_VDVVRHEN = 0xC2
ST7789_VRHS = 0xC3
ST7789_VDVSET = 0xC4
ST7789_VCMOFSET = 0xC5
ST7789_FRCTR2 = 0xC6
ST7789_CABCCTRL = 0xC7
ST7789_REGSEL1 = 0xC8
ST7789_REGSEL2 = 0xCA
ST7789_PWMFRSEL = 0xCC
ST7789_PWCTRL1 = 0xD0
ST7789_VAPVANEN = 0xD2
ST7789_CMD2EN = 0xDF5A6902
ST7789_PVGAMCTRL = 0xE0
ST7789_NVGAMCTRL = 0xE1
ST7789_DGMLUTR = 0xE2
ST7789_DGMLUTB = 0xE3
ST7789_GATECTRL = 0xE4
ST7789_PWCTRL2 = 0xE8
ST7789_EQCTRL = 0xE9
ST7789_PROMCTRL = 0xEC
ST7789_PROMEN = 0xFA
ST7789_NVMSET = 0xFC
ST7789_PROMACT = 0xFE
)
const (
NO_ROTATION display.Rotation = 0
ROTATION_90 display.Rotation = 1 // 90 degrees clock-wise rotation
ROTATION_180 display.Rotation = 2
ROTATION_270 display.Rotation = 3
)
const (
FRAMERATE_111 FrameRate = 0x01
FRAMERATE_105 FrameRate = 0x02
FRAMERATE_99 FrameRate = 0x03
FRAMERATE_94 FrameRate = 0x04
FRAMERATE_90 FrameRate = 0x05
FRAMERATE_86 FrameRate = 0x06
FRAMERATE_82 FrameRate = 0x07
FRAMERATE_78 FrameRate = 0x08
FRAMERATE_75 FrameRate = 0x09
FRAMERATE_72 FrameRate = 0x0A
FRAMERATE_69 FrameRate = 0x0B
FRAMERATE_67 FrameRate = 0x0C
FRAMERATE_64 FrameRate = 0x0D
FRAMERATE_62 FrameRate = 0x0E
FRAMERATE_60 FrameRate = 0x0F // 60 is default
FRAMERATE_58 FrameRate = 0x10
FRAMERATE_57 FrameRate = 0x11
FRAMERATE_55 FrameRate = 0x12
FRAMERATE_53 FrameRate = 0x13
FRAMERATE_52 FrameRate = 0x14
FRAMERATE_50 FrameRate = 0x15
FRAMERATE_49 FrameRate = 0x16
FRAMERATE_48 FrameRate = 0x17
FRAMERATE_46 FrameRate = 0x18
FRAMERATE_45 FrameRate = 0x19
FRAMERATE_44 FrameRate = 0x1A
FRAMERATE_43 FrameRate = 0x1B
FRAMERATE_42 FrameRate = 0x1C
FRAMERATE_41 FrameRate = 0x1D
FRAMERATE_40 FrameRate = 0x1E
FRAMERATE_39 FrameRate = 0x1F
)
const (
MAX_VSYNC_SCANLINES = 254
)
+611
View File
@@ -0,0 +1,611 @@
// Package st7789 implements a driver for the ST7789 TFT displays, it comes in various screen sizes.
//
// Datasheets: https://cdn-shop.adafruit.com/product-files/3787/3787_tft_QT154H2201__________20190228182902.pdf
//
// http://www.newhavendisplay.com/appnotes/datasheets/LCDs/ST7789V.pdf
package st7789
import (
"errors"
"fmt"
"image"
"image/color"
"math"
"time"
"github.com/sirupsen/logrus"
"periph.io/x/conn/v3/gpio"
"periph.io/x/conn/v3/physic"
"periph.io/x/conn/v3/spi"
"periph.io/x/conn/v3/spi/spireg"
"go.maze.io/harmon/config"
"go.maze.io/harmon/hardware"
"go.maze.io/harmon/hardware/display"
)
func init() {
display.Register("st7789", newDriver)
}
var (
errOutOfBounds = errors.New("rectangle coordinates outside display area")
)
// FrameRate controls the frame rate used by the display.
type FrameRate uint8
type Device struct {
conn spi.Conn
reset gpio.PinOut
dcPin gpio.PinOut
resetPin gpio.PinOut
blPin gpio.PinOut
width int16
height int16
columnOffsetCfg int16
rowOffsetCfg int16
columnOffset int16
rowOffset int16
rotation display.Rotation
frameRate FrameRate
batchLength int32
isBGR bool
vSyncLines int16
}
// Config is the configuration for the display
type Config struct {
Width int16
Height int16
Rotation display.Rotation
RowOffset int16
ColumnOffset int16
FrameRate FrameRate
VSyncLines int16
}
func newDriver(config config.DisplayConfig) (hardware.Display, error) {
var (
opts *display.Options
port spi.PortCloser
conn spi.Conn
reset, dc, bl gpio.PinOut
err error
)
if opts, err = display.ParseOptions(config, 240, 240); err != nil {
return nil, err
}
log := logrus.WithFields(logrus.Fields{
"type": "st7789",
"size": fmt.Sprintf("%dx%d", opts.W, opts.H),
"rotate": opts.Rotate,
})
log.Debug("new driver")
if reset, err = hardware.LookupPin(config.Reset); err != nil {
return nil, err
}
if dc, err = hardware.LookupPin(config.DC); err != nil {
return nil, err
}
if bl, err = hardware.LookupPin(config.BL); err != nil {
return nil, err
}
const speed = 40000000 * physic.Hertz
log.WithFields(logrus.Fields{
"port": config.Port,
"pin_reset": reset,
"pin_dc": dc,
"pin_bl": bl,
"speed": speed,
"bits": 8,
"mode": spi.Mode0,
}).Debug("opening SPI port")
if port, err = spireg.Open(config.Port); err != nil {
return nil, err
}
if conn, err = port.Connect(speed, spi.Mode0, 8); err != nil {
_ = port.Close()
return nil, err
}
return newDisplay(conn, reset, dc, bl, opts)
}
func newDisplay(conn spi.Conn, reset, dc, bl gpio.PinOut, opts *display.Options) (d *Device, err error) {
d = &Device{
conn: conn,
resetPin: reset,
dcPin: dc,
blPin: bl,
}
d.Configure(Config{
Width: int16(opts.W),
Height: int16(opts.H),
Rotation: opts.Rotate,
FrameRate: FRAMERATE_60,
})
return d, nil
}
// Configure initializes the display with default configuration
func (d *Device) Configure(cfg Config) {
if cfg.Width != 0 {
d.width = cfg.Width
} else {
d.width = 240
}
if cfg.Height != 0 {
d.height = cfg.Height
} else {
d.height = 240
}
logrus.WithFields(logrus.Fields{
"driver": "st7789",
"width": d.width,
"height": d.height,
}).Warn("yello!")
d.rotation = cfg.Rotation
d.rowOffsetCfg = cfg.RowOffset
d.columnOffsetCfg = cfg.ColumnOffset
if cfg.FrameRate != 0 {
d.frameRate = cfg.FrameRate
} else {
d.frameRate = FRAMERATE_60
}
if cfg.VSyncLines >= 2 && cfg.VSyncLines <= 254 {
d.vSyncLines = cfg.VSyncLines
} else {
d.vSyncLines = 16
}
d.batchLength = int32(d.width)
if d.height > d.width {
d.batchLength = int32(d.height)
}
d.batchLength += d.batchLength & 1
// Reset the device
d.resetPin.Out(gpio.High)
time.Sleep(500 * time.Millisecond)
d.resetPin.Out(gpio.Low)
time.Sleep(500 * time.Millisecond)
d.resetPin.Out(gpio.High)
time.Sleep(500 * time.Millisecond)
// Common initialization
d.sendCommand(0x11)
time.Sleep(150 * time.Millisecond)
d.sendCommand(0x36, 0x00)
d.sendCommand(0x3A, 0x05)
d.sendCommand(0xB2, 0x0C, 0x0C)
d.sendCommand(0xB7, 0x35)
d.sendCommand(0xBB, 0x1A)
d.sendCommand(0xC0, 0x2C)
d.sendCommand(0xC2, 0x01)
d.sendCommand(0xC3, 0x0B)
d.sendCommand(0xC4, 0x20)
d.sendCommand(0xC6, 0x0F)
d.sendCommand(0xD0, 0xA4, 0xA1)
d.sendCommand(0x21)
d.sendCommand(ST7789_MADCTL, 0x78)
d.sendCommand(0xE0, 0x00, 0x19, 0x1E, 0x0A, 0x09, 0x15, 0x3D, 0x44, 0x51, 0x12, 0x03, 0x00, 0x3F, 0x3F)
d.sendCommand(0xE1, 0x00,
0x18,
0x1E,
0x0A,
0x09,
0x25,
0x3F,
0x43,
0x52,
0x33,
0x03,
0x00,
0x3F,
0x3F)
d.sendCommand(0x29)
time.Sleep(100 * time.Millisecond)
d.blPin.Out(gpio.High) // Backlight ON
}
// Sync waits for the display to hit the next VSYNC pause
func (d *Device) Sync() {
d.SyncToScanLine(0)
}
// SyncToScanLine waits for the display to hit a specific scanline
//
// A scanline value of 0 will forward to the beginning of the next VSYNC,
// even if the display is currently in a VSYNC pause.
//
// Syncline values appear to increment once for every two vertical
// lines on the display.
//
// NOTE: Use GetHighestScanLine and GetLowestScanLine to obtain the highest
// and lowest useful values. Values are affected by front and back porch
// vsync settings (derived from VSyncLines configuration option).
func (d *Device) SyncToScanLine(scanline uint16) {
scan := d.GetScanLine()
// Sometimes GetScanLine returns erroneous 0 on first call after draw, so double check
if scan == 0 {
scan = d.GetScanLine()
}
if scanline == 0 {
// we dont know where we are in an ongoing vsync so go around
for scan < 1 {
time.Sleep(1 * time.Millisecond)
scan = d.GetScanLine()
}
for scan > 0 {
scan = d.GetScanLine()
}
} else {
// go around unless we're very close to the target
for scan > scanline+4 {
time.Sleep(1 * time.Millisecond)
scan = d.GetScanLine()
}
for scan < scanline {
scan = d.GetScanLine()
}
}
}
func (d *Device) Backlight(on bool) error {
return d.blPin.Out(gpio.Level(on))
}
// GetScanLine reads the current scanline value from the display
func (d *Device) GetScanLine() uint16 {
data := []uint8{0x00, 0x00}
//d.Rx(GSCAN, data)
return uint16(data[0])<<8 + uint16(data[1])
}
// GetHighestScanLine calculates the last scanline id in the frame before VSYNC pause
func (d *Device) GetHighestScanLine() uint16 {
// Last scanline id appears to be backporch/2 + 320/2
return uint16(math.Ceil(float64(d.vSyncLines)/2)/2) + 160
}
// GetLowestScanLine calculate the first scanline id to appear after VSYNC pause
func (d *Device) GetLowestScanLine() uint16 {
// First scanline id appears to be backporch/2 + 1
return uint16(math.Ceil(float64(d.vSyncLines)/2)/2) + 1
}
// Display does nothing, there's no buffer as it might be too big for some boards
func (d *Device) Display() error {
return nil
}
// SetPixel sets a pixel in the screen
func (d *Device) SetPixel(x int16, y int16, c color.RGBA) {
if x < 0 || y < 0 ||
(((d.rotation == NO_ROTATION || d.rotation == ROTATION_180) && (x >= d.width || y >= d.height)) ||
((d.rotation == ROTATION_90 || d.rotation == ROTATION_270) && (x >= d.height || y >= d.width))) {
return
}
d.FillRectangle(x, y, 1, 1, c)
}
// setWindow prepares the screen to be modified at a given rectangle
func (d *Device) setWindow(x, y, w, h int16) {
x0 := x + d.columnOffset
y0 := y + d.rowOffset
x1 := x + w - 1
y1 := y + h - 1
d.sendCommand(ST7789_CASET, byte(x0>>8), byte(x0), byte(x1>>8), byte(x1))
d.sendCommand(ST7789_RASET, byte(y0>>8), byte(y0), byte(y1>>8), byte(y1))
d.sendCommand(ST7789_RAMWR)
}
// FillRectangle fills a rectangle at a given coordinates with a color
func (d *Device) FillRectangle(x, y, width, height int16, c color.RGBA) error {
k, i := d.size()
if x < 0 || y < 0 || width <= 0 || height <= 0 ||
x >= k || (x+width) > k || y >= i || (y+height) > i {
return errors.New("rectangle coordinates outside display area")
}
d.setWindow(x, y, width, height)
c565 := RGBATo565(c)
c1 := uint8(c565 >> 8)
c2 := uint8(c565)
data := make([]uint8, d.batchLength*2)
for i := int32(0); i < d.batchLength; i++ {
data[i*2] = c1
data[i*2+1] = c2
}
j := int32(width) * int32(height)
for j > 0 {
if j >= d.batchLength {
d.sendData(data)
} else {
d.sendData(data[:j*2])
}
j -= d.batchLength
}
return nil
}
// FillRectangleWithBuffer fills buffer with a rectangle at a given coordinates.
func (d *Device) FillRectangleWithBuffer(x, y, width, height int16, buffer []color.RGBA) error {
i, j := d.size()
if x < 0 || y < 0 || width <= 0 || height <= 0 ||
x >= i || (x+width) > i || y >= j || (y+height) > j {
return errors.New("rectangle coordinates outside display area")
}
if int32(width)*int32(height) != int32(len(buffer)) {
return errors.New("buffer length does not match with rectangle size")
}
d.setWindow(x, y, width, height)
k := int32(width) * int32(height)
data := make([]uint8, d.batchLength*2)
offset := int32(0)
for k > 0 {
for i := int32(0); i < d.batchLength; i++ {
if offset+i < int32(len(buffer)) {
c565 := RGBATo565(buffer[offset+i])
c1 := uint8(c565 >> 8)
c2 := uint8(c565)
data[i*2] = c1
data[i*2+1] = c2
}
}
if k >= d.batchLength {
d.sendData(data)
} else {
d.sendData(data[:k*2])
}
k -= d.batchLength
offset += d.batchLength
}
return nil
}
// DrawFastVLine draws a vertical line faster than using SetPixel
func (d *Device) DrawFastVLine(x, y0, y1 int16, c color.RGBA) {
if y0 > y1 {
y0, y1 = y1, y0
}
d.FillRectangle(x, y0, 1, y1-y0+1, c)
}
// DrawFastHLine draws a horizontal line faster than using SetPixel
func (d *Device) DrawFastHLine(x0, x1, y int16, c color.RGBA) {
if x0 > x1 {
x0, x1 = x1, x0
}
d.FillRectangle(x0, y, x1-x0+1, 1, c)
}
// FillScreen fills the screen with a given color
func (d *Device) FillScreen(c color.RGBA) {
if d.rotation == NO_ROTATION || d.rotation == ROTATION_180 {
d.FillRectangle(0, 0, d.width, d.height, c)
} else {
d.FillRectangle(0, 0, d.height, d.width, c)
}
}
// SetRotation changes the rotation of the device (clock-wise)
func (d *Device) SetRotation(rotation display.Rotation) {
/*
madctl := uint8(0)
switch rotation % 4 {
case 0:
madctl = MADCTL_MX | MADCTL_MY
d.rowOffset = d.rowOffsetCfg
d.columnOffset = d.columnOffsetCfg
break
case 1:
madctl = MADCTL_MY | MADCTL_MV
d.rowOffset = d.columnOffsetCfg
d.columnOffset = d.rowOffsetCfg
break
case 2:
d.rowOffset = 0
d.columnOffset = 0
break
case 3:
madctl = MADCTL_MX | MADCTL_MV
d.rowOffset = 0
d.columnOffset = 0
break
}
if d.isBGR {
madctl |= MADCTL_BGR
}
d.sendCommand(ST7789_MADCTL, madctl)
*/
}
// Rx reads data from the display
func (d *Device) Rx(command uint8, data []byte) {
d.dcPin.Out(gpio.Low)
sendCommand(d.conn, command)
d.dcPin.Out(gpio.High)
for i := range data {
data[i], _ = sendCommand(d.conn, 0xFF)
}
}
func sendCommand(bus spi.Conn, command byte) (byte, error) {
answer := []byte{0}
err := bus.Tx(
[]byte{command},
[]byte(""),
)
if err != nil {
return 0, err
}
return answer[0], nil
}
// Size returns the current size of the display.
func (d *Device) size() (w, h int16) {
if d.rotation == NO_ROTATION || d.rotation == ROTATION_180 {
return d.width, d.height
}
return d.height, d.width
}
// EnableBacklight enables or disables the backlight
func (d *Device) EnableBacklight(enable bool) {
if enable {
d.blPin.Out(gpio.High)
} else {
d.blPin.Out(gpio.Low)
}
}
// InvertColors inverts the colors of the screen
func (d *Device) InvertColors(invert bool) {
if invert {
d.sendCommand(ST7789_INVON)
} else {
d.sendCommand(ST7789_INVOFF)
}
}
// IsBGR changes the color mode (RGB/BGR)
func (d *Device) IsBGR(bgr bool) {
d.isBGR = bgr
}
// SetScrollArea sets an area to scroll with fixed top and bottom parts of the display.
func (d *Device) SetScrollArea(topFixedArea, bottomFixedArea int16) {
d.sendCommand(ST7789_VSCRDEF,
uint8(topFixedArea>>8), uint8(topFixedArea),
uint8(d.height-topFixedArea-bottomFixedArea>>8), uint8(d.height-topFixedArea-bottomFixedArea),
uint8(bottomFixedArea>>8), uint8(bottomFixedArea))
}
// SetScroll sets the vertical scroll address of the display.
func (d *Device) SetScroll(line int16) {
d.sendCommand(ST7789_VSCRSADD, uint8(line>>8), uint8(line))
}
// StopScroll returns the display to its normal state.
func (d *Device) StopScroll() {
d.sendCommand(ST7789_NORON)
}
// RGBATo565 converts a color.RGBA to uint16 used in the display
func RGBATo565(c color.RGBA) uint16 {
r, g, b, _ := c.RGBA()
return uint16((r & 0xF800) +
((g & 0xFC00) >> 5) +
((b & 0xF800) >> 11))
}
func (d *Device) At(x, y int) color.Color {
return color.Black
}
func (d *Device) Bounds() image.Rectangle {
if d.rotation == display.Rotate90 || d.rotation == display.Rotate270 {
return image.Rect(0, 0, int(d.height), int(d.width))
}
return image.Rect(0, 0, int(d.width), int(d.height))
}
func (d *Device) Clear() {
d.FillRectangle(0, 0, d.width, d.height, color.RGBA{A: 0xff})
}
func (Device) ColorModel() color.Model {
return color.RGBAModel
}
func (d *Device) Fill(c color.Color) error {
rgba := color.RGBAModel.Convert(c).(color.RGBA)
d.FillRectangle(0, 0, d.width, d.height, rgba)
return nil
}
func (d *Device) sendData(data []byte) (err error) {
if err = d.dcPin.Out(gpio.High); err != nil {
return
}
return d.conn.Tx(data, nil)
}
func (d *Device) sendCommand(cmd byte, args ...byte) (err error) {
if err = d.dcPin.Out(gpio.Low); err != nil {
return
}
if err = d.conn.Tx([]byte{cmd}, nil); err != nil {
return
}
if len(args) > 0 {
return d.sendData(args)
}
return
}
func (d *Device) Set(x, y int, c color.Color) {
var (
rc = RGBATo565(color.RGBAModel.Convert(c).(color.RGBA))
xo = x + int(d.columnOffset)
yo = y + int(d.rowOffset)
)
d.sendCommand(0x2A, byte(xo>>8), byte(xo), byte(xo>>8), byte(xo)) // column addr
d.sendCommand(0x2B, byte(yo>>8), byte(yo), byte(yo>>8), byte(yo)) // row addr
d.sendCommand(0x2C, byte(rc>>8), byte(rc)) // pixel
}
func (d *Device) Size() image.Point {
if d.rotation == display.Rotate90 || d.rotation == display.Rotate270 {
return image.Pt(int(d.height), int(d.width))
}
return image.Pt(int(d.width), int(d.height))
}
func (Device) Type() string {
return "st7789"
}
func (d *Device) Draw(r image.Rectangle, src image.Image, sp image.Point) error {
//draw.Draw(d, r, src, sp, draw.Src)
logrus.Warnf("make slice %d (%dx%d)", d.height*d.width, d.height, d.width)
var (
buffer = make([]color.RGBA, int(d.height)*int(d.width))
bounds = src.Bounds()
)
for y := 0; y < bounds.Max.Y && y < int(d.height); y++ {
for x := 0; x < bounds.Max.X && x < int(d.width); x++ {
r, g, b, a := src.At(x, y).RGBA()
buffer[y*int(d.width)+x] = color.RGBA{R: uint8(r / 0x100), G: uint8(g / 0x100), B: uint8(b / 0x100), A: uint8(a / 0x100)}
}
}
return d.FillRectangleWithBuffer(0, 0, d.width, d.height, buffer)
}
func (Device) Halt() error {
return nil
}
func (Device) Refresh() error {
return nil
}