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

+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
}