diff --git a/Makefile b/Makefile index cdf13f2..11c8998 100644 --- a/Makefile +++ b/Makefile @@ -36,6 +36,7 @@ smoke-test: tinygo build -size short -o ./build/test.elf -target=microbit ./examples/ssd1306/spi_128x64/main.go tinygo build -size short -o ./build/test.elf -target=circuitplay-express ./examples/thermistor/main.go tinygo build -size short -o ./build/test.elf -target=itsybitsy-m0 ./examples/vl53l1x/main.go + tinygo build -size short -o ./build/test.elf -target=microbit ./examples/waveshare-epd/epd2in13/main.go tinygo build -size short -o ./build/test.elf -target=microbit ./examples/waveshare-epd/epd2in13x/main.go tinygo build -size short -o ./build/test.elf -target=circuitplay-express ./examples/ws2812/main.go diff --git a/README.md b/README.md index 9c1f0a2..13180d2 100644 --- a/README.md +++ b/README.md @@ -74,6 +74,7 @@ func main() { | [SSD1306 OLED display](https://cdn-shop.adafruit.com/datasheets/SSD1306.pdf) | I2C / SPI | | [Thermistor](https://www.farnell.com/datasheets/33552.pdf) | ADC | | [VL53L1X time-of-flight distance sensor](https://www.st.com/resource/en/datasheet/vl53l1x.pdf) | I2C | +| [Waveshare 2.13" e-paper display](https://www.waveshare.com/w/upload/e/e6/2.13inch_e-Paper_Datasheet.pdf) | SPI | | [Waveshare 2.13" (B & C) e-paper display](https://www.waveshare.com/w/upload/d/d3/2.13inch-e-paper-b-Specification.pdf) | SPI | | [WS2812 RGB LED](https://cdn-shop.adafruit.com/datasheets/WS2812.pdf) | GPIO | diff --git a/examples/waveshare-epd/epd2in13/main.go b/examples/waveshare-epd/epd2in13/main.go new file mode 100644 index 0000000..0c97c5d --- /dev/null +++ b/examples/waveshare-epd/epd2in13/main.go @@ -0,0 +1,77 @@ +package main + +import ( + "machine" + + "image/color" + + "time" + + "github.com/tinygo-org/drivers/waveshare-epd/epd2in13" +) + +var display epd2in13.Device + +func main() { + machine.SPI0.Configure(machine.SPIConfig{ + Frequency: 8000000, + Mode: 0, + }) + + display = epd2in13.New(machine.SPI0, machine.P6, machine.P7, machine.P8, machine.P9) + display.Configure(epd2in13.Config{}) + + black := color.RGBA{1, 1, 1, 255} + white := color.RGBA{0, 0, 0, 255} + + display.ClearBuffer() + println("Clear the display") + display.ClearDisplay() + display.WaitUntilIdle() + println("Waiting for 2 seconds") + time.Sleep(2 * time.Second) + + // Show a checkered board + for i := int16(0); i < 16; i++ { + for j := int16(0); j < 25; j++ { + if (i+j)%2 == 0 { + showRect(i*8, j*10, 8, 10, black) + } + } + } + println("Show checkered board") + display.Display() + display.WaitUntilIdle() + println("Waiting for 2 seconds") + time.Sleep(2 * time.Second) + + println("Set partial lut") + display.SetLUT(false) // partial updates (faster, but with some ghosting) + println("Show smaller striped area") + for i := int16(40); i < 88; i++ { + for j := int16(83); j < 166; j++ { + if (i+j)%4 == 0 || (i+j)%4 == 1 { + display.SetPixel(i, j, black) + } else { + display.SetPixel(i, j, white) + } + } + } + + // There are two memory areas in the display, once the display is refreshed, memory areas are auto-toggled. + // DisplayRect needs to be called twice + display.DisplayRect(40,83,48,83) + display.WaitUntilIdle() + display.DisplayRect(40,83,48,83) + display.WaitUntilIdle() + + println("You could remove power now") +} + +func showRect(x int16, y int16, w int16, h int16, c color.RGBA) { + for i := x; i < x+w; i++ { + for j := y; j < y+h; j++ { + display.SetPixel(i, j, c) + } + } +} diff --git a/waveshare-epd/epd2in13/epd2in13.go b/waveshare-epd/epd2in13/epd2in13.go new file mode 100644 index 0000000..44c6047 --- /dev/null +++ b/waveshare-epd/epd2in13/epd2in13.go @@ -0,0 +1,281 @@ +// Package epd2in13 implements a driver for Waveshare 2.13in black and white e-paper device. +// +// Datasheet: https://www.waveshare.com/w/upload/e/e6/2.13inch_e-Paper_Datasheet.pdf +package epd2in13 + +import ( + "errors" + "image/color" + "machine" + "time" +) + +type Config struct { + Width int16 + Height int16 +} + +type Device struct { + bus machine.SPI + cs machine.GPIO + dc machine.GPIO + rst machine.GPIO + busy machine.GPIO + width int16 + height int16 + buffer []uint8 + bufferLength uint32 +} + +// Look up table for full updates +var lutFullUpdate = [30]uint8{ + 0x22, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x11, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, + 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, +} + +// Look up table for partial updates, faster but there will be some ghosting +var lutPartialUpdate = [30]uint8{ + 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x0F, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +} + +// New returns a new epd2in13x driver. Pass in a fully configured SPI bus. +func New(bus machine.SPI, csPin uint8, dcPin uint8, rstPin uint8, busyPin uint8) Device { + pinCs := machine.GPIO{csPin} + pinCs.Configure(machine.GPIOConfig{Mode: machine.GPIO_OUTPUT}) + pinDc := machine.GPIO{dcPin} + pinDc.Configure(machine.GPIOConfig{Mode: machine.GPIO_OUTPUT}) + pinRst := machine.GPIO{rstPin} + pinRst.Configure(machine.GPIOConfig{Mode: machine.GPIO_OUTPUT}) + pinBusy := machine.GPIO{busyPin} + pinBusy.Configure(machine.GPIOConfig{Mode: machine.GPIO_INPUT}) + return Device{ + bus: bus, + cs: pinCs, + dc: pinDc, + rst: pinRst, + busy: pinBusy, + } +} + +// Configure sets up the device. +func (d *Device) Configure(cfg Config) { + if cfg.Width != 0 { + d.width = cfg.Width + } else { + d.width = 128 + } + if cfg.Height != 0 { + d.height = cfg.Height + } else { + d.height = 250 + } + d.bufferLength = (uint32(d.width) * uint32(d.height)) / 8 + d.buffer = make([]uint8, d.bufferLength) + for i := uint32(0); i < d.bufferLength; i++ { + d.buffer[i] = 0xFF + } + + d.cs.Low() + d.dc.Low() + d.rst.Low() + + d.Reset() + + d.SendCommand(DRIVER_OUTPUT_CONTROL) + d.SendData(uint8((d.height - 1) & 0xFF)) + d.SendData(uint8(((d.height - 1) >> 8) & 0xFF)) + d.SendData(0x00) // GD = 0; SM = 0; TB = 0; + d.SendCommand(BOOSTER_SOFT_START_CONTROL) + d.SendData(0xD7) + d.SendData(0xD6) + d.SendData(0x9D) + d.SendCommand(WRITE_VCOM_REGISTER) + d.SendData(0xA8) // VCOM 7C + d.SendCommand(SET_DUMMY_LINE_PERIOD) + d.SendData(0x1A) // 4 dummy lines per gate + d.SendCommand(SET_GATE_TIME) + d.SendData(0x08) // 2us per line + d.SendCommand(DATA_ENTRY_MODE_SETTING) + d.SendData(0x03) // X increment; Y increment + + d.SetLUT(true) +} + +// Reset resets the device +func (d *Device) Reset() { + d.rst.Low() + time.Sleep(200 * time.Millisecond) + d.rst.High() + time.Sleep(200 * time.Millisecond) +} + +// DeepSleep puts the display into deepsleep +func (d *Device) DeepSleep() { + d.SendCommand(DEEP_SLEEP_MODE) + d.WaitUntilIdle() +} + +// SendCommand sends a command to the display +func (d *Device) SendCommand(command uint8) { + d.sendDataCommand(true, command) +} + +// SendData sends a data byte to the display +func (d *Device) SendData(data uint8) { + d.sendDataCommand(false, data) +} + +// sendDataCommand sends image data or a command to the screen +func (d *Device) sendDataCommand(isCommand bool, data uint8) { + if isCommand { + d.dc.Low() + } else { + d.dc.High() + } + d.cs.Low() + d.bus.Transfer(data) + d.cs.High() +} + +// SetLUT sets the look up tables for full or partial updates +func (d *Device) SetLUT(fullUpdate bool) { + d.SendCommand(WRITE_LUT_REGISTER) + if fullUpdate { + for i := 0; i < 30; i++ { + d.SendData(lutFullUpdate[i]) + } + } else { + for i := 0; i < 30; i++ { + d.SendData(lutPartialUpdate[i]) + } + } +} + +// SetPixel modifies the internal buffer in a single pixel. +// The display have 2 colors: black and white +// We use RGBA(0,0,0, 255) as white (transparent) +// Anything else as black +func (d *Device) SetPixel(x int16, y int16, c color.RGBA) { + if x < 0 || x >= d.width || y < 0 || y >= d.height { + return + } + byteIndex := (x + y*d.width) / 8 + if c.R == 0 && c.G == 0 && c.B == 0 { // TRANSPARENT / WHITE + d.buffer[byteIndex] |= 0x80 >> uint8(x%8) + } else { // WHITE / EMPTY + d.buffer[byteIndex] &^= 0x80 >> uint8(x%8) + } +} + +// Display sends the buffer to the screen. +func (d *Device) Display() error { + d.setMemoryArea(0, 0, d.width-1, d.height-1) + for j := int16(0); j < d.height; j++ { + d.setMemoryPointer(0, j) + d.SendCommand(WRITE_RAM) + for i := int16(0); i < d.width/8; i++ { + d.SendData(d.buffer[i+j*(d.width/8)]) + } + } + + d.SendCommand(DISPLAY_UPDATE_CONTROL_2) + d.SendData(0xC4) + d.SendCommand(MASTER_ACTIVATION) + d.SendCommand(TERMINATE_FRAME_READ_WRITE) + return nil +} + +// DisplayRect sends only an area of the buffer to the screen. +func (d *Device) DisplayRect(x int16, y int16, width int16, height int16) error { + if x < 0 || y < 0 || x >= d.width || y >= d.height || width < 0 || height < 0 { + return errors.New("wrong rectangle") + } + x &= 0xF8 + width &= 0xF8 + width = x + width // reuse variables + if width >= d.width { + width = d.width + } + height = y + height + if height > d.height { + height = d.height + } + d.setMemoryArea(x, y, width, height) + x = x / 8 + width = width / 8 + for ; y < height; y++ { + d.setMemoryPointer(8*x, y) + d.SendCommand(WRITE_RAM) + for i := int16(x); i < width; i++ { + d.SendData(d.buffer[i+y*d.width/8]) + } + } + + d.SendCommand(DISPLAY_UPDATE_CONTROL_2) + d.SendData(0xC4) + d.SendCommand(MASTER_ACTIVATION) + d.SendCommand(TERMINATE_FRAME_READ_WRITE) + return nil +} + +// ClearDisplay erases the device SRAM +func (d *Device) ClearDisplay() { + d.setMemoryArea(0, 0, d.width-1, d.height-1) + d.setMemoryPointer(0, 0) + d.SendCommand(WRITE_RAM) + for i := uint32(0); i < d.bufferLength; i++ { + d.SendData(0xFF) + } + d.Display() +} + +// setMemoryArea sets the area of the display that will be updated +func (d *Device) setMemoryArea(x0 int16, y0 int16, x1 int16, y1 int16) { + d.SendCommand(SET_RAM_X_ADDRESS_START_END_POSITION) + d.SendData(uint8((x0 >> 3) & 0xFF)) + d.SendData(uint8((x1 >> 3) & 0xFF)) + d.SendCommand(SET_RAM_Y_ADDRESS_START_END_POSITION) + d.SendData(uint8(y0 & 0xFF)) + d.SendData(uint8((y0 >> 8) & 0xFF)) + d.SendData(uint8(y1 & 0xFF)) + d.SendData(uint8((y1 >> 8) & 0xFF)) +} + +// setMemoryPointer moves the internal pointer to the speficied coordinates +func (d *Device) setMemoryPointer(x int16, y int16) { + d.SendCommand(SET_RAM_X_ADDRESS_COUNTER) + d.SendData(uint8((x >> 3) & 0xFF)) + d.SendCommand(SET_RAM_Y_ADDRESS_COUNTER) + d.SendData(uint8(y & 0xFF)) + d.SendData(uint8((y >> 8) & 0xFF)) + d.WaitUntilIdle() +} + +// WaitUntilIdle waits until the display is ready +func (d *Device) WaitUntilIdle() { + for d.busy.Get() { + time.Sleep(100 * time.Millisecond) + } +} + +// IsBusy returns the busy status of the display +func (d *Device) IsBusy() bool { + return d.busy.Get() +} + +// ClearBuffer sets the buffer to 0xFF (white) +func (d *Device) ClearBuffer() { + for i := uint32(0); i < d.bufferLength; i++ { + d.buffer[i] = 0xFF + } +} + +// Size returns the current size of the display. +func (d *Device) Size() (w, h int16) { + return d.width, d.height +} diff --git a/waveshare-epd/epd2in13/registers.go b/waveshare-epd/epd2in13/registers.go new file mode 100644 index 0000000..a34e209 --- /dev/null +++ b/waveshare-epd/epd2in13/registers.go @@ -0,0 +1,26 @@ +package epd2in13 + +// Registers +const ( + DRIVER_OUTPUT_CONTROL = 0x01 + BOOSTER_SOFT_START_CONTROL = 0x0C + GATE_SCAN_START_POSITION = 0x0F + DEEP_SLEEP_MODE = 0x10 + DATA_ENTRY_MODE_SETTING = 0x11 + SW_RESET = 0x12 + TEMPERATURE_SENSOR_CONTROL = 0x1A + MASTER_ACTIVATION = 0x20 + DISPLAY_UPDATE_CONTROL_1 = 0x21 + DISPLAY_UPDATE_CONTROL_2 = 0x22 + WRITE_RAM = 0x24 + WRITE_VCOM_REGISTER = 0x2C + WRITE_LUT_REGISTER = 0x32 + SET_DUMMY_LINE_PERIOD = 0x3A + SET_GATE_TIME = 0x3B + BORDER_WAVEFORM_CONTROL = 0x3C + SET_RAM_X_ADDRESS_START_END_POSITION = 0x44 + SET_RAM_Y_ADDRESS_START_END_POSITION = 0x45 + SET_RAM_X_ADDRESS_COUNTER = 0x4E + SET_RAM_Y_ADDRESS_COUNTER = 0x4F + TERMINATE_FRAME_READ_WRITE = 0xFF +)