536 lines
13 KiB
Go
536 lines
13 KiB
Go
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"
|
|
|
|
"git.maze.io/go/harmon/config"
|
|
"git.maze.io/go/harmon/display"
|
|
"git.maze.io/go/harmon/internal/pixel"
|
|
)
|
|
|
|
func init() {
|
|
display.Register("st7789", newDevice)
|
|
}
|
|
|
|
type Device struct {
|
|
conn spi.Conn
|
|
reset, cs, dc, bl 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
|
|
}
|
|
|
|
type Opts struct {
|
|
Width int16
|
|
Height int16
|
|
Rotation display.Rotation
|
|
RowOffset int16
|
|
ColumnOffset int16
|
|
FrameRate FrameRate
|
|
VSyncLines int16
|
|
}
|
|
|
|
var DefaultOpts = Opts{
|
|
Width: 240,
|
|
Height: 320,
|
|
}
|
|
|
|
func newDevice(config *config.Display) (display.Display, error) {
|
|
log := logrus.WithFields(logrus.Fields{
|
|
"type": "st7789",
|
|
"name": config.Name,
|
|
})
|
|
|
|
log.WithField("port", config.Port).Trace("opening SPI port")
|
|
port, err := spireg.Open(config.Port)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var (
|
|
bits = 8
|
|
reset gpio.PinOut
|
|
dc gpio.PinOut
|
|
cs gpio.PinOut
|
|
bl gpio.PinOut
|
|
)
|
|
if config.DC == "" {
|
|
bits = 9
|
|
} else {
|
|
if dc, err = display.LookupPinOut(config.DC); err != nil {
|
|
return nil, fmt.Errorf("invalid dc pin: %w", err)
|
|
}
|
|
if err = dc.Out(gpio.Low); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
if reset, err = display.LookupPinOut(config.Reset); err != nil {
|
|
return nil, fmt.Errorf("invalid reset pin: %w", err)
|
|
}
|
|
if cs, err = display.LookupPinOut(config.CS); err != nil {
|
|
return nil, fmt.Errorf("invalid cs pin: %w", err)
|
|
}
|
|
if bl, err = display.LookupPinOut(config.BL); err != nil {
|
|
return nil, fmt.Errorf("invalid bl pin: %w", err)
|
|
}
|
|
|
|
log.WithFields(logrus.Fields{
|
|
"mode": spi.Mode0,
|
|
"bits": bits,
|
|
"reset": reset.Name(),
|
|
"dc": dc.Name(),
|
|
"cs": cs.Name(),
|
|
"bl": bl.Name(),
|
|
}).Debug("connecting on SPI port")
|
|
conn, err := port.Connect(300*physic.KiloHertz, spi.Mode0, bits)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
d := &Device{
|
|
conn: conn,
|
|
reset: reset,
|
|
cs: cs,
|
|
dc: dc,
|
|
bl: bl,
|
|
}
|
|
cfg := DefaultOpts
|
|
|
|
if cfg.Width != 0 {
|
|
d.width = cfg.Width
|
|
} else {
|
|
d.width = 240
|
|
}
|
|
if cfg.Height != 0 {
|
|
d.height = cfg.Height
|
|
} else {
|
|
d.height = 240
|
|
}
|
|
|
|
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
|
|
log.Trace("reset device")
|
|
if err = d.reset.Out(gpio.High); err != nil {
|
|
_ = port.Close()
|
|
return nil, err
|
|
}
|
|
time.Sleep(50 * time.Millisecond)
|
|
if err = d.reset.Out(gpio.Low); err != nil {
|
|
_ = port.Close()
|
|
return nil, err
|
|
}
|
|
time.Sleep(50 * time.Millisecond)
|
|
if err = d.reset.Out(gpio.High); err != nil {
|
|
_ = port.Close()
|
|
return nil, err
|
|
}
|
|
time.Sleep(50 * time.Millisecond)
|
|
|
|
// Common initialization
|
|
log.Trace("configure device")
|
|
d.Command(SWRESET) // Soft reset
|
|
time.Sleep(150 * time.Millisecond) //
|
|
|
|
d.Command(SLPOUT) // Exit sleep mode
|
|
time.Sleep(500 * time.Millisecond) //
|
|
|
|
// Memory initialization
|
|
d.Command(COLMOD) // Set color mode
|
|
d.Data(0x55) // 16-bit color
|
|
time.Sleep(10 * time.Millisecond) //
|
|
|
|
d.SetRotation(d.rotation) // Memory orientation
|
|
|
|
d.setWindow(0, 0, d.width, d.height) // Full draw window
|
|
d.FillScreen(color.RGBA{0, 0, 0, 255}) // Clear screen
|
|
|
|
// Framerate
|
|
d.Command(FRCTRL2) // Frame rate for normal mode
|
|
d.Data(uint8(d.frameRate)) // Default is 60Hz
|
|
|
|
// Frame vertical sync and "porch"
|
|
//
|
|
// Front and back porch controls vertical scanline sync time before and after
|
|
// a frame, where memory can be safely written without tearing.
|
|
//
|
|
fp := uint8(d.vSyncLines / 2) // Split the desired pause half and half
|
|
bp := uint8(d.vSyncLines - int16(fp)) // between front and back porch.
|
|
|
|
d.Command(PORCTRL)
|
|
d.Data(bp) // Back porch 5bit (0x7F max 0x08 default)
|
|
d.Data(fp) // Front porch 5bit (0x7F max 0x08 default)
|
|
d.Data(0x00) // Seprarate porch (TODO: what is this?)
|
|
d.Data(0x22) // Idle mode porch (4bit-back 4bit-front 0x22 default)
|
|
d.Data(0x22) // Partial mode porch (4bit-back 4bit-front 0x22 default)
|
|
|
|
// Ready to display
|
|
d.Command(INVON) // Inversion ON
|
|
time.Sleep(10 * time.Millisecond) //
|
|
|
|
d.Command(NORON) // Normal mode ON
|
|
time.Sleep(10 * time.Millisecond) //
|
|
|
|
d.Command(DISPON) // Screen ON
|
|
time.Sleep(10 * time.Millisecond) //
|
|
|
|
// Backlight ON
|
|
if err = d.bl.Out(gpio.High); err != nil {
|
|
_ = port.Close()
|
|
return nil, err
|
|
}
|
|
|
|
return d, nil
|
|
}
|
|
|
|
func (d *Device) String() string {
|
|
return "st7789"
|
|
}
|
|
|
|
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) ColorModel() color.Model {
|
|
return color.RGBAModel
|
|
}
|
|
|
|
func (d *Device) Halt() error {
|
|
return nil
|
|
}
|
|
|
|
func (d *Device) Refresh() error {
|
|
return nil
|
|
}
|
|
|
|
// 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()
|
|
}
|
|
}
|
|
}
|
|
|
|
// 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
|
|
}
|
|
|
|
// 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 == display.NoRotation || d.rotation == display.Rotate180) && (x >= d.width || y >= d.height)) ||
|
|
((d.rotation == display.Rotate90 || d.rotation == display.Rotate270) && (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) {
|
|
x += d.columnOffset
|
|
y += d.rowOffset
|
|
d.Tx([]uint8{CASET}, true)
|
|
d.Tx([]uint8{uint8(x >> 8), uint8(x), uint8((x + w - 1) >> 8), uint8(x + w - 1)}, false)
|
|
d.Tx([]uint8{RASET}, true)
|
|
d.Tx([]uint8{uint8(y >> 8), uint8(y), uint8((y + h - 1) >> 8), uint8(y + h - 1)}, false)
|
|
d.Command(RAMWR)
|
|
}
|
|
|
|
// FillRectangle fills a rectangle at a given coordinates with a color
|
|
func (d *Device) FillRectangle(x, y, width, height int16, c color.Color) error {
|
|
|
|
k, i := int16(d.Size().X), int16(d.Size().Y)
|
|
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 := pixel.Color565Model.Convert(c).(pixel.Color565)
|
|
//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.Tx(data, false)
|
|
} else {
|
|
d.Tx(data[:j*2], false)
|
|
}
|
|
j -= d.batchLength
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// FillRectangle fills a rectangle at a given coordinates with a buffer
|
|
func (d *Device) FillRectangleWithBuffer(x, y, width, height int16, buffer []color.RGBA) error {
|
|
i, j := int16(d.Size().X), int16(d.Size().Y)
|
|
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.Tx(data, false)
|
|
} else {
|
|
d.Tx(data[:k*2], false)
|
|
}
|
|
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.Color) {
|
|
if d.rotation == display.NoRotation || d.rotation == display.Rotate180 {
|
|
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 display.NoRotation:
|
|
madctl = MADCTL_MX | MADCTL_MY
|
|
d.rowOffset = d.rowOffsetCfg
|
|
d.columnOffset = d.columnOffsetCfg
|
|
break
|
|
case display.Rotate90:
|
|
madctl = MADCTL_MY | MADCTL_MV
|
|
d.rowOffset = d.columnOffsetCfg
|
|
d.columnOffset = d.rowOffsetCfg
|
|
break
|
|
case display.Rotate180:
|
|
d.rowOffset = 0
|
|
d.columnOffset = 0
|
|
break
|
|
case display.Rotate270:
|
|
madctl = MADCTL_MX | MADCTL_MV
|
|
d.rowOffset = 0
|
|
d.columnOffset = 0
|
|
break
|
|
}
|
|
if d.isBGR {
|
|
madctl |= MADCTL_BGR
|
|
}
|
|
d.Command(MADCTL)
|
|
d.Data(madctl)
|
|
}
|
|
|
|
// Command sends a command to the display
|
|
func (d *Device) Command(command uint8) {
|
|
d.Tx([]byte{command}, true)
|
|
}
|
|
|
|
// Command sends a data to the display
|
|
func (d *Device) Data(data uint8) {
|
|
d.Tx([]byte{data}, false)
|
|
}
|
|
|
|
// Tx sends data to the display
|
|
func (d *Device) Tx(data []byte, isCommand bool) {
|
|
if isCommand {
|
|
d.dc.Out(gpio.Low)
|
|
} else {
|
|
d.dc.Out(gpio.High)
|
|
}
|
|
d.cs.Out(gpio.Low)
|
|
d.conn.Tx(data, nil)
|
|
d.cs.Out(gpio.High)
|
|
}
|
|
|
|
// Rx reads data from the display
|
|
func (d *Device) Rx(command uint8, read_bytes []byte) {
|
|
d.dc.Out(gpio.Low)
|
|
d.cs.Out(gpio.Low)
|
|
d.conn.Tx([]byte{command}, nil)
|
|
d.dc.Out(gpio.High)
|
|
for i := range read_bytes {
|
|
d.conn.Tx([]byte{0xFF}, read_bytes[i:i+1])
|
|
}
|
|
d.cs.Out(gpio.High)
|
|
}
|
|
|
|
// Size returns the current size of the display.
|
|
func (d *Device) Size() image.Point {
|
|
if d.rotation == display.NoRotation || d.rotation == display.Rotate180 {
|
|
return image.Pt(int(d.width), int(d.height))
|
|
}
|
|
return image.Pt(int(d.height), int(d.width))
|
|
}
|
|
|
|
// EnableBacklight enables or disables the backlight
|
|
func (d *Device) EnableBacklight(enable bool) {
|
|
if enable {
|
|
d.bl.Out(gpio.High)
|
|
} else {
|
|
d.bl.Out(gpio.Low)
|
|
}
|
|
}
|
|
|
|
// InverColors inverts the colors of the screen
|
|
func (d *Device) InvertColors(invert bool) {
|
|
if invert {
|
|
d.Command(INVON)
|
|
} else {
|
|
d.Command(INVOFF)
|
|
}
|
|
}
|
|
|
|
// IsBGR changes the color mode (RGB/BGR)
|
|
func (d *Device) IsBGR(bgr bool) {
|
|
d.isBGR = bgr
|
|
}
|
|
|
|
func (d *Device) At(x, y int) color.Color {
|
|
return color.Black
|
|
}
|
|
|
|
func (d *Device) Set(x, y int, c color.Color) {
|
|
d.FillRectangle(int16(x), int16(y), int16(x)+1, int16(y)+1, color.RGBAModel.Convert(c).(color.RGBA))
|
|
}
|
|
|
|
// 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))
|
|
}
|