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