mirror of
https://github.com/tinygo-org/drivers.git
synced 2026-07-26 10:38:41 +00:00
deadprogram
568 lines
11 KiB
Go
568 lines
11 KiB
Go
// Package gc9a01 implements a driver for the gc9a01 LCD round display
|
|
//
|
|
// Datasheet: https://www.waveshare.com/w/upload/5/5e/GC9A01A.pdf
|
|
package gc9a01 // import "tinygo.org/x/drivers/gc9a01"
|
|
|
|
import (
|
|
"image/color"
|
|
"machine"
|
|
"time"
|
|
|
|
"errors"
|
|
|
|
"tinygo.org/x/drivers"
|
|
)
|
|
|
|
// Rotation controls the rotation used by the display.
|
|
type Orientation uint8
|
|
|
|
// FrameRate controls the frame rate used by the display.
|
|
type FrameRate uint8
|
|
|
|
// Device wraps an SPI connection.
|
|
type Device struct {
|
|
bus drivers.SPI
|
|
dcPin machine.Pin
|
|
resetPin machine.Pin
|
|
csPin machine.Pin
|
|
blPin machine.Pin
|
|
width int16
|
|
height int16
|
|
columnOffsetCfg int16
|
|
rowOffsetCfg int16
|
|
columnOffset int16
|
|
rowOffset int16
|
|
frameRate FrameRate
|
|
isBGR bool
|
|
vSyncLines int16
|
|
orientation Orientation
|
|
batchLength int16
|
|
batchData []uint8
|
|
}
|
|
|
|
// Config is the configuration for the display
|
|
type Config struct {
|
|
Orientation Orientation
|
|
RowOffset int16
|
|
ColumnOffset int16
|
|
FrameRate FrameRate
|
|
VSyncLines int16
|
|
Width int16
|
|
Height int16
|
|
}
|
|
|
|
// New creates a new ST7789 connection. The SPI wire must already be configured.
|
|
func New(bus drivers.SPI, resetPin, dcPin, csPin, blPin machine.Pin) Device {
|
|
resetPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
|
|
dcPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
|
|
csPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
|
|
blPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
|
|
return Device{
|
|
bus: bus,
|
|
resetPin: resetPin,
|
|
dcPin: dcPin,
|
|
csPin: csPin,
|
|
blPin: blPin,
|
|
}
|
|
}
|
|
|
|
// Reset the Device
|
|
func (d *Device) Reset() {
|
|
d.resetPin.High()
|
|
time.Sleep(100 * time.Millisecond)
|
|
d.resetPin.Low()
|
|
time.Sleep(100 * time.Millisecond)
|
|
d.resetPin.High()
|
|
time.Sleep(100 * time.Millisecond)
|
|
|
|
}
|
|
|
|
// Sets Device configuration for screen orientation using the initialzation values
|
|
func (d *Device) SetDeviceOrientation() {
|
|
|
|
var MemoryAccessReg uint8
|
|
|
|
//Get GRAM and LCD width and height
|
|
if d.orientation == HORIZONTAL {
|
|
MemoryAccessReg = 0xc8
|
|
} else {
|
|
MemoryAccessReg = 0x68
|
|
}
|
|
|
|
// Set the read / write scan direction of the frame memory
|
|
d.Command(MADCTR)
|
|
//0x08 set RGB
|
|
d.Command(MemoryAccessReg)
|
|
}
|
|
|
|
// setWindow prepares the screen to be modified at a given rectangle
|
|
func (d *Device) setWindow(x, y, w, h int16) {
|
|
if d.orientation == HORIZONTAL {
|
|
x += d.columnOffset
|
|
y += d.rowOffset
|
|
} else {
|
|
x += d.rowOffset
|
|
y += d.columnOffset
|
|
}
|
|
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)
|
|
}
|
|
|
|
// FillScreen fills the screen with a given color
|
|
func (d *Device) FillScreen(c color.RGBA) {
|
|
d.FillRectangle(0, 0, d.height, d.width, c)
|
|
}
|
|
|
|
// 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, j := d.Size()
|
|
var i int32
|
|
if x < 0 || y < 0 || width <= 0 || height <= 0 ||
|
|
x >= k || (x+width) > k || y >= j || (y+height) > j {
|
|
return errors.New("rectangle coordinates outside display area")
|
|
}
|
|
d.setWindow(x, y, width, height)
|
|
c565 := RGBATo565(c)
|
|
c1 := uint8(c565 >> 8)
|
|
c2 := uint8(c565)
|
|
|
|
for i = 0; i < int32(d.batchLength); i++ {
|
|
d.batchData[i*2] = c1
|
|
d.batchData[i*2+1] = c2
|
|
}
|
|
i = int32(width) * int32(height)
|
|
batchLength := int32(d.batchLength)
|
|
for i > 0 {
|
|
if i >= batchLength {
|
|
d.Tx(d.batchData, false)
|
|
} else {
|
|
d.Tx(d.batchData[:i*2], false)
|
|
}
|
|
i -= batchLength
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Display sends the whole buffer to the screen
|
|
func (d *Device) Display() error {
|
|
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 {
|
|
h, w := d.Size()
|
|
if x < 0 || y < 0 || width <= 0 || height <= 0 ||
|
|
x >= h || (x+width) > h || y >= w || (y+height) > w {
|
|
return errors.New("rectangle coordinates outside display area")
|
|
}
|
|
k := int32(width) * int32(height)
|
|
l := int32(len(buffer))
|
|
if k != l {
|
|
return errors.New("buffer length does not match with rectangle size")
|
|
}
|
|
|
|
d.setWindow(x, y, width, height)
|
|
|
|
offset := int32(0)
|
|
batchLength := int32(d.batchLength)
|
|
for k > 0 {
|
|
for i := int32(0); i < batchLength; i++ {
|
|
if offset+i < l {
|
|
c565 := RGBATo565(buffer[offset+i])
|
|
c1 := uint8(c565 >> 8)
|
|
c2 := uint8(c565)
|
|
d.batchData[i*2] = c1
|
|
d.batchData[i*2+1] = c2
|
|
}
|
|
}
|
|
if k >= batchLength {
|
|
d.Tx(d.batchData, false)
|
|
} else {
|
|
d.Tx(d.batchData[:k*2], false)
|
|
}
|
|
k -= batchLength
|
|
offset += 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)
|
|
}
|
|
|
|
// SetPixel sets a pixel in the screen
|
|
func (d *Device) SetPixel(x, y int16, c color.RGBA) {
|
|
w, h := d.Size()
|
|
if x < 0 || y < 0 || x >= w || y >= h {
|
|
return
|
|
}
|
|
d.FillRectangle(x, y, 1, 1, c)
|
|
}
|
|
|
|
// Command sends a command to the display.
|
|
func (d *Device) Command(command uint8) {
|
|
d.Tx([]byte{command}, true)
|
|
}
|
|
|
|
// Data sends 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) {
|
|
d.dcPin.Set(!isCommand)
|
|
d.bus.Tx(data, nil)
|
|
}
|
|
|
|
// Rx reads data from the display
|
|
func (d *Device) Rx(command uint8, data []byte) {
|
|
d.dcPin.Low()
|
|
d.csPin.Low()
|
|
d.bus.Transfer(command)
|
|
d.dcPin.High()
|
|
for i := range data {
|
|
data[i], _ = d.bus.Transfer(0xFF)
|
|
}
|
|
d.csPin.High()
|
|
}
|
|
|
|
// Size returns the current size of the display.
|
|
func (d *Device) Size() (w, h int16) {
|
|
return d.height, d.width
|
|
}
|
|
|
|
// EnableBacklight enables or disables the backlight
|
|
func (d *Device) EnableBacklight(enable bool) {
|
|
if enable {
|
|
d.blPin.High()
|
|
} else {
|
|
d.blPin.Low()
|
|
}
|
|
}
|
|
|
|
// InvertColors 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
|
|
}
|
|
|
|
// SetScrollArea sets an area to scroll with fixed top and bottom parts of the display.
|
|
func (d *Device) SetScrollArea(topFixedArea, bottomFixedArea int16) {
|
|
d.Command(VSCRDEF)
|
|
d.Tx([]uint8{
|
|
uint8(topFixedArea >> 8), uint8(topFixedArea),
|
|
uint8(d.height - topFixedArea - bottomFixedArea>>8), uint8(d.height - topFixedArea - bottomFixedArea),
|
|
uint8(bottomFixedArea >> 8), uint8(bottomFixedArea)},
|
|
false)
|
|
}
|
|
|
|
// SetScroll sets the vertical scroll address of the display.
|
|
func (d *Device) SetScroll(line int16) {
|
|
d.Command(VSCRSADD)
|
|
d.Tx([]uint8{uint8(line >> 8), uint8(line)}, false)
|
|
}
|
|
|
|
// StopScroll returns the display to its normal state.
|
|
func (d *Device) StopScroll() {
|
|
d.Command(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))
|
|
}
|
|
|
|
// 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
|
|
}
|
|
|
|
d.orientation = cfg.Orientation
|
|
d.rowOffsetCfg = cfg.RowOffset
|
|
d.columnOffsetCfg = cfg.ColumnOffset
|
|
d.batchLength = d.width
|
|
|
|
if cfg.VSyncLines >= 2 && cfg.VSyncLines <= 254 {
|
|
d.vSyncLines = cfg.VSyncLines
|
|
} else {
|
|
d.vSyncLines = 16
|
|
}
|
|
d.batchLength += d.batchLength & 1
|
|
d.batchData = make([]uint8, d.batchLength*2)
|
|
|
|
// Reset the device
|
|
d.Reset()
|
|
|
|
// Set Device Attributes
|
|
d.SetDeviceOrientation()
|
|
|
|
// Common initialization
|
|
d.Command(0xEF)
|
|
d.Command(0xEB)
|
|
d.Data(0x14)
|
|
|
|
d.Command(INTEN1)
|
|
d.Command(0xEF)
|
|
|
|
d.Command(0xEB)
|
|
d.Data(0x14)
|
|
|
|
d.Command(0x84)
|
|
d.Data(0x40)
|
|
|
|
d.Command(0x85)
|
|
d.Data(0xFF)
|
|
|
|
d.Command(0x86)
|
|
d.Data(0xFF)
|
|
|
|
d.Command(0x87)
|
|
d.Data(0xFF)
|
|
|
|
d.Command(0x88)
|
|
d.Data(0x0A)
|
|
|
|
d.Command(0x89)
|
|
d.Data(0x21)
|
|
|
|
d.Command(0x8A)
|
|
d.Data(0x00)
|
|
|
|
d.Command(0x8B)
|
|
d.Data(0x80)
|
|
|
|
d.Command(0x8C)
|
|
d.Data(0x01)
|
|
|
|
d.Command(0x8D)
|
|
d.Data(0x01)
|
|
|
|
d.Command(0x8E)
|
|
d.Data(0xFF)
|
|
|
|
d.Command(0x8F)
|
|
d.Data(0xFF)
|
|
|
|
d.Command(DISFNCTL)
|
|
d.Data(0x00)
|
|
d.Data(0x20)
|
|
|
|
d.Command(MADCTR)
|
|
d.Data(0x08) //Set as vertical screen
|
|
|
|
d.Command(COLMOD)
|
|
d.Data(0x05)
|
|
|
|
d.Command(0x90)
|
|
d.Data(0x08)
|
|
d.Data(0x08)
|
|
d.Data(0x08)
|
|
d.Data(0x08)
|
|
|
|
d.Command(0xBD)
|
|
d.Data(0x06)
|
|
|
|
d.Command(0xBC)
|
|
d.Data(0x00)
|
|
|
|
d.Command(0xFF)
|
|
d.Data(0x60)
|
|
d.Data(0x01)
|
|
d.Data(0x04)
|
|
|
|
d.Command(PWCTR3)
|
|
d.Data(0x13)
|
|
d.Command(PWCTR4)
|
|
d.Data(0x13)
|
|
|
|
d.Command(0xC9)
|
|
d.Data(0x22)
|
|
|
|
d.Command(0xBE)
|
|
d.Data(0x11)
|
|
|
|
d.Command(0xE1)
|
|
d.Data(0x10)
|
|
d.Data(0x0E)
|
|
|
|
d.Command(0xDF)
|
|
d.Data(0x21)
|
|
d.Data(0x0c)
|
|
d.Data(0x02)
|
|
|
|
d.Command(GMSET1)
|
|
d.Data(0x45)
|
|
d.Data(0x09)
|
|
d.Data(0x08)
|
|
d.Data(0x08)
|
|
d.Data(0x26)
|
|
d.Data(0x2A)
|
|
|
|
d.Command(GMSET2)
|
|
d.Data(0x43)
|
|
d.Data(0x70)
|
|
d.Data(0x72)
|
|
d.Data(0x36)
|
|
d.Data(0x37)
|
|
d.Data(0x6F)
|
|
|
|
d.Command(GMSET3)
|
|
d.Data(0x45)
|
|
d.Data(0x09)
|
|
d.Data(0x08)
|
|
d.Data(0x08)
|
|
d.Data(0x26)
|
|
d.Data(0x2A)
|
|
|
|
d.Command(GMSET4)
|
|
d.Data(0x43)
|
|
d.Data(0x70)
|
|
d.Data(0x72)
|
|
d.Data(0x36)
|
|
d.Data(0x37)
|
|
d.Data(0x6F)
|
|
|
|
d.Command(0xED)
|
|
d.Data(0x1B)
|
|
d.Data(0x0B)
|
|
|
|
d.Command(0xAE)
|
|
d.Data(0x77)
|
|
|
|
d.Command(0xCD)
|
|
d.Data(0x63)
|
|
|
|
d.Command(0x70)
|
|
d.Data(0x07)
|
|
d.Data(0x07)
|
|
d.Data(0x04)
|
|
d.Data(0x0E)
|
|
d.Data(0x0F)
|
|
d.Data(0x09)
|
|
d.Data(0x07)
|
|
d.Data(0x08)
|
|
d.Data(0x03)
|
|
|
|
d.Command(FRMCTL)
|
|
d.Data(0x34)
|
|
|
|
d.Command(0x62)
|
|
d.Data(0x18)
|
|
d.Data(0x0D)
|
|
d.Data(0x71)
|
|
d.Data(0xED)
|
|
d.Data(0x70)
|
|
d.Data(0x70)
|
|
d.Data(0x18)
|
|
d.Data(0x0F)
|
|
d.Data(0x71)
|
|
d.Data(0xEF)
|
|
d.Data(0x70)
|
|
d.Data(0x70)
|
|
|
|
d.Command(0x63)
|
|
d.Data(0x18)
|
|
d.Data(0x11)
|
|
d.Data(0x71)
|
|
d.Data(0xF1)
|
|
d.Data(0x70)
|
|
d.Data(0x70)
|
|
d.Data(0x18)
|
|
d.Data(0x13)
|
|
d.Data(0x71)
|
|
d.Data(0xF3)
|
|
d.Data(0x70)
|
|
d.Data(0x70)
|
|
|
|
d.Command(0x64)
|
|
d.Data(0x28)
|
|
d.Data(0x29)
|
|
d.Data(0xF1)
|
|
d.Data(0x01)
|
|
d.Data(0xF1)
|
|
d.Data(0x00)
|
|
d.Data(0x07)
|
|
|
|
d.Command(0x66)
|
|
d.Data(0x3C)
|
|
d.Data(0x00)
|
|
d.Data(0xCD)
|
|
d.Data(0x67)
|
|
d.Data(0x45)
|
|
d.Data(0x45)
|
|
d.Data(0x10)
|
|
d.Data(0x00)
|
|
d.Data(0x00)
|
|
d.Data(0x00)
|
|
|
|
d.Command(0x67)
|
|
d.Data(0x00)
|
|
d.Data(0x3C)
|
|
d.Data(0x00)
|
|
d.Data(0x00)
|
|
d.Data(0x00)
|
|
d.Data(0x01)
|
|
d.Data(0x54)
|
|
d.Data(0x10)
|
|
d.Data(0x32)
|
|
d.Data(0x98)
|
|
|
|
d.Command(0x74)
|
|
d.Data(0x10)
|
|
d.Data(0x85)
|
|
d.Data(0x80)
|
|
d.Data(0x00)
|
|
d.Data(0x00)
|
|
d.Data(0x4E)
|
|
d.Data(0x00)
|
|
|
|
d.Command(0x98)
|
|
d.Data(0x3e)
|
|
d.Data(0x07)
|
|
|
|
d.Command(TEON)
|
|
d.Command(0x21)
|
|
|
|
d.Command(SLPOUT)
|
|
time.Sleep(120 * time.Millisecond)
|
|
d.Command(DISPON)
|
|
time.Sleep(20 * time.Millisecond)
|
|
|
|
d.blPin.High()
|
|
}
|