rtl8720dn: add Rpc_tcpip_adapter_init_with_timeout()

CHANGELOG.md

@@ -1,37 +1,3 @@
-0.22.0
----
-- **new devices**
-    - epd: add waveshare 2.9in (v1)
-    - makeybutton: add driver for MakeyMakey-like button
-
-- **enhancements**
-    - **rtl8720dn**
-        - add UDP close function
-        - improve error handling
-    - **net/http**
-        - improve header parsing
-        - add last-will-and-testament to MQTT
-    - **net/mqtt**
-        - adds keepalive pinging, disconnect, and graceful goroutine cleanup
-        - support for cookies when https
-        - add support for retained messsages
-
-- **bugfixes**
-    - irremote: Fix irremote reporting incorrect NEC addresses and command codes (#422)
-    - net/http:  Fix http.Get() with port specification
-
-- **build**
-    - Makefile recursively finds unit-tests
-    - switching to GHA
-
-- **updates**
-    - update tinyfont to v0.3.0
-    - update tinyfs to v0.2.0
-
-- **examples**
-    - rtl8720dn: add ./examples/rtl8720dn/version
-
-
 0.21.0
 ---
 - **new devices**

README.md

@@ -52,7 +52,7 @@ func main() {
 
 ## Currently supported devices
 
-The following 82 devices are supported.
+The following 81 devices are supported.
 
 | Device Name                                                                                                                                                                                         | Interface Type |
 |-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------|
@@ -137,7 +137,6 @@ The following 82 devices are supported.
 | [VL53L1X time-of-flight distance sensor](https://www.st.com/resource/en/datasheet/vl53l1x.pdf)                                                                                                      | I2C |
 | [Waveshare 2.13" (B & C) e-paper display](https://www.waveshare.com/w/upload/d/d3/2.13inch-e-paper-b-Specification.pdf)                                                                             | SPI |
 | [Waveshare 2.13" e-paper display](https://www.waveshare.com/w/upload/e/e6/2.13inch_e-Paper_Datasheet.pdf)                                                                                           | SPI |
-| [Waveshare 2.9" e-paper display (V1)](https://www.waveshare.com/w/upload/e/e6/2.9inch_e-Paper_Datasheet.pdf)                                                                                           | SPI |
 | [Waveshare 4.2" e-paper B/W display](https://www.waveshare.com/w/upload/6/6a/4.2inch-e-paper-specification.pdf)                                                                                     | SPI |
 | [WS2812 RGB LED](https://cdn-shop.adafruit.com/datasheets/WS2812.pdf)                                                                                                                               | GPIO |
 | [XPT2046 touch controller](http://grobotronics.com/images/datasheets/xpt2046-datasheet.pdf)                                                                                                         | GPIO |

examples/rtl8720dn/wioterminal.go

@@ -47,7 +47,7 @@ func Setup() (*rtl8720dn.RTL8720DN, error) {
 	rtl := rtl8720dn.New(uart)
 	rtl.Debug(debug)
 
-	_, err := rtl.Rpc_tcpip_adapter_init()
+	_, err := rtl.Rpc_tcpip_adapter_init_with_timeout(10 * time.Second)
 	if err != nil {
 		return nil, err
 	}

examples/waveshare-epd/epd2in9/main.go

@@ -1,84 +0,0 @@
-package main
-
-import (
-	"machine"
-
-	"image/color"
-
-	"time"
-
-	"tinygo.org/x/drivers/waveshare-epd/epd2in9"
-)
-
-var display epd2in9.Device
-
-const (
-	width  = 128
-	height = 296
-)
-
-func main() {
-	machine.SPI0.Configure(machine.SPIConfig{
-		Frequency: 8000000,
-		Mode:      0,
-	})
-
-	display = epd2in9.New(machine.SPI0, machine.GPIO2, machine.GPIO3, machine.GPIO4, machine.GPIO5)
-	display.Configure(epd2in9.Config{
-		Width:        width,
-		LogicalWidth: width,
-		Height:       height,
-	})
-
-	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 < width/8; i++ {
-		for j := int16(0); j < height/8; j++ {
-			if (i+j)%2 == 0 {
-				showRect(i*8, j*8, 8, 8, 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)
-			}
-		}
-	}
-
-	display.Display()
-	display.WaitUntilIdle()
-
-	display.DeepSleep()
-
-	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)
-		}
-	}
-}

net/mqtt/mqtt.go

@@ -5,7 +5,6 @@ package mqtt
 import (
 	"errors"
 	"strings"
-	"sync"
 	"time"
 
 	"github.com/eclipse/paho.mqtt.golang/packets"
@@ -20,12 +19,6 @@ import (
 func NewClient(o *ClientOptions) Client {
 	c := &mqttclient{opts: o, adaptor: o.Adaptor}
 	c.msgRouter, c.stopRouter = newRouter()
-
-	c.inboundPacketChan = make(chan packets.ControlPacket, 10)
-	c.stopInbound = make(chan struct{})
-	c.incomingPubChan = make(chan *packets.PublishPacket, 10)
-	// this launches a goroutine, so only call once per client:
-	c.msgRouter.matchAndDispatch(c.incomingPubChan, c.opts.Order, c)
 	return c
 }
 
@@ -35,17 +28,11 @@ type mqttclient struct {
 	connected       bool
 	opts            *ClientOptions
 	mid             uint16
-	inboundPacketChan chan packets.ControlPacket
+	inbound         chan packets.ControlPacket
-	stopInbound       chan struct{}
+	stop            chan struct{}
 	msgRouter       *router
 	stopRouter      chan bool
 	incomingPubChan chan *packets.PublishPacket
-	// stats for keepalive
-	lastReceive time.Time
-	lastSend    time.Time
-	// keep track of routines and signal a shutdown
-	workers  sync.WaitGroup
-	shutdown bool
 }
 
 // AddRoute allows you to add a handler for messages on a specific topic
@@ -69,9 +56,6 @@ func (c *mqttclient) IsConnectionOpen() bool {
 
 // Connect will create a connection to the message broker.
 func (c *mqttclient) Connect() Token {
-	if c.IsConnected() {
-		return &mqtttoken{}
-	}
 	var err error
 
 	// make connection
@@ -93,6 +77,10 @@ func (c *mqttclient) Connect() Token {
 	}
 
 	c.mid = 1
+	c.inbound = make(chan packets.ControlPacket, 10)
+	c.stop = make(chan struct{})
+	c.incomingPubChan = make(chan *packets.PublishPacket, 10)
+	c.msgRouter.matchAndDispatch(c.incomingPubChan, c.opts.Order, c)
 
 	// send the MQTT connect message
 	connectPkt := packets.NewControlPacket(packets.Connect).(*packets.ConnectPacket)
@@ -110,7 +98,7 @@ func (c *mqttclient) Connect() Token {
 	connectPkt.ClientIdentifier = c.opts.ClientID
 	connectPkt.ProtocolVersion = byte(c.opts.ProtocolVersion)
 	connectPkt.ProtocolName = "MQTT"
-	connectPkt.Keepalive = uint16(c.opts.KeepAlive)
+	connectPkt.Keepalive = 60
 
 	connectPkt.WillFlag = c.opts.WillEnabled
 	connectPkt.WillTopic = c.opts.WillTopic
@@ -122,7 +110,6 @@ func (c *mqttclient) Connect() Token {
 	if err != nil {
 		return &mqtttoken{err: err}
 	}
-	c.lastSend = time.Now()
 
 	// TODO: handle timeout as ReadPacket blocks until it gets a packet.
 	// CONNECT response.
@@ -140,34 +127,18 @@ func (c *mqttclient) Connect() Token {
 		}
 	}
 
-	go processInbound(c)
 	go readMessages(c)
-	go keepAlive(c)
+	go processInbound(c)
 
 	return &mqtttoken{}
 }
 
 // Disconnect will end the connection with the server, but not before waiting
 // the specified number of milliseconds to wait for existing work to be
-// completed. Blocks until disconnected.
+// completed.
 func (c *mqttclient) Disconnect(quiesce uint) {
-	c.shutdownRoutines()
-	// block until all done
-	for c.connected {
-		time.Sleep(time.Millisecond * 10)
-	}
-	return
-}
-
-// shutdownRoutines will disconnect and shut down all processes. If you want to trigger a
-// disconnect internally, make sure you call this instead of Disconnect() to avoid deadlocks
-func (c *mqttclient) shutdownRoutines() {
-	if c.shutdown {
-		return
-	}
-	c.shutdown = true
 	c.conn.Close()
-	c.stopInbound <- struct{}{}
+	return
 }
 
 // Publish will publish a message with the specified QoS and content
@@ -182,7 +153,6 @@ func (c *mqttclient) Publish(topic string, qos byte, retained bool, payload inte
 	pub.Qos = qos
 	pub.TopicName = topic
 	pub.Retain = retained
-
 	switch payload.(type) {
 	case string:
 		pub.Payload = []byte(payload.(string))
@@ -198,8 +168,6 @@ func (c *mqttclient) Publish(topic string, qos byte, retained bool, payload inte
 	if err != nil {
 		return &mqtttoken{err: err}
 	}
-	// update this for every control message that is sent successfully, for keepalive
-	c.lastSend = time.Now()
 
 	return &mqtttoken{}
 }
@@ -227,7 +195,6 @@ func (c *mqttclient) Subscribe(topic string, qos byte, callback MessageHandler)
 	if err != nil {
 		return &mqtttoken{err: err}
 	}
-	c.lastSend = time.Now()
 
 	return &mqtttoken{}
 }
@@ -253,13 +220,12 @@ func (c *mqttclient) OptionsReader() ClientOptionsReader {
 }
 
 func processInbound(c *mqttclient) {
-PROCESS:
 	for {
 		select {
-		case msg := <-c.inboundPacketChan:
+		case msg := <-c.inbound:
 			switch m := msg.(type) {
 			case *packets.PingrespPacket:
-				// println("pong")
+				// TODO: handle this
 			case *packets.SubackPacket:
 				// TODO: handle this
 			case *packets.UnsubackPacket:
@@ -276,85 +242,33 @@ PROCESS:
 			case *packets.PubcompPacket:
 				// TODO: handle this
 			}
-		case <-c.stopInbound:
+		case <-c.stop:
-			break PROCESS
+			return
 		}
 	}
-
-	// as this routine could be the last to finish (if a lot of messages are queued in the
-	// channel), it is the last to turn out the lights
-
-	c.workers.Wait()
-	c.connected = false
-	c.shutdown = false
 }
 
 // readMessages reads incoming messages off the wire.
-// incoming messages are then send into inbound buffered channel.
+// incoming messages are then send into inbound channel.
 func readMessages(c *mqttclient) {
-	c.workers.Add(1)
-	defer c.workers.Done()
-
 	var err error
 	var cp packets.ControlPacket
 
-	for !c.shutdown {
+PROCESS:
+	for {
 		if cp, err = c.ReadPacket(); err != nil {
-			c.shutdownRoutines()
+			break PROCESS
-			return
 		}
 		if cp != nil {
-			c.inboundPacketChan <- cp
+			c.inbound <- cp
-			// notify keepalive logic that we recently received a packet
+			// TODO: Notify keepalive logic that we recently received a packet
-			c.lastReceive = time.Now()
 		}
 
 		time.Sleep(100 * time.Millisecond)
 	}
-}
 
-// keepAlive is a goroutine to handle sending ping requests according to the MQTT spec. If the keepalive time has
+	// TODO: handle if we received an error on read.
-// been reached with no messages being sent, we will send a ping request and check back to see if we've
+	// If disconnect is in progress, swallow error and return
-// had any activity by the timeout. If not, disconnect.
-func keepAlive(c *mqttclient) {
-	c.workers.Add(1)
-	defer c.workers.Done()
-
-	var err error
-	var ping *packets.PingreqPacket
-	var timeout, pingsent time.Time
-
-	for !c.shutdown {
-		// As long as we haven't reached the keepalive value...
-		if time.Since(c.lastSend) < time.Duration(c.opts.KeepAlive)*time.Second {
-			// ...sleep and check shutdown status again
-			time.Sleep(time.Millisecond * 100)
-			continue
-		}
-
-		// value has been reached, so send a ping request
-		ping = packets.NewControlPacket(packets.Pingreq).(*packets.PingreqPacket)
-		if err = ping.Write(c.conn); err != nil {
-			// if connection is lost, report disconnect
-			c.shutdownRoutines()
-			return
-		}
-		// println("ping")
-
-		c.lastSend = time.Now()
-		pingsent = time.Now()
-		timeout = pingsent.Add(c.opts.PingTimeout)
-
-		// as long as we are still connected and haven't received anything after the ping...
-		for !c.shutdown && c.lastReceive.Before(pingsent) {
-			// if the timeout has passed, disconnect
-			if time.Now().After(timeout) {
-				c.shutdownRoutines()
-				return
-			}
-			time.Sleep(time.Millisecond * 100)
-		}
-	}
 }
 
 func (c *mqttclient) ackFunc(packet *packets.PublishPacket) func() {

net/mqtt/paho.go

@@ -210,7 +210,7 @@ type ClientOptions struct {
 
 // NewClientOptions returns a new ClientOptions struct.
 func NewClientOptions() *ClientOptions {
-	return &ClientOptions{Adaptor: net.ActiveDevice, ProtocolVersion: 4, KeepAlive: 60, PingTimeout: time.Second * 10}
+	return &ClientOptions{Adaptor: net.ActiveDevice, ProtocolVersion: 4}
 }
 
 // AddBroker adds a broker URI to the list of brokers to be used. The format should be
@@ -257,23 +257,6 @@ func (o *ClientOptions) SetPassword(p string) *ClientOptions {
 	return o
 }
 
-// SetKeepAlive will set the amount of time (in seconds) that the client
-// should wait before sending a PING request to the broker. This will
-// allow the client to know that a connection has not been lost with the
-// server.
-func (o *ClientOptions) SetKeepAlive(k time.Duration) *ClientOptions {
-	o.KeepAlive = int64(k / time.Second)
-	return o
-}
-
-// SetPingTimeout will set the amount of time (in seconds) that the client
-// will wait after sending a PING request to the broker, before deciding
-// that the connection has been lost. Default is 10 seconds.
-func (o *ClientOptions) SetPingTimeout(k time.Duration) *ClientOptions {
-	o.PingTimeout = k
-	return o
-}
-
 // SetWill accepts a string will message to be set. When the client connects,
 // it will give this will message to the broker, which will then publish the
 // provided payload (the will) to any clients that are subscribed to the provided

rtl8720dn/netdriver.go

@@ -227,7 +227,7 @@ func (r *RTL8720DN) DisconnectSocket() error {
 		fmt.Printf("DisconnectSocket()\r\n")
 	}
 	switch r.connectionType {
-	case ConnectionTypeTCP, ConnectionTypeUDP:
+	case ConnectionTypeTCP:
 		_, err := r.Rpc_lwip_close(r.socket)
 		if err != nil {
 			return err

rtl8720dn/rtl8720dn.go

@@ -1,6 +1,10 @@
 package rtl8720dn
 
-import "io"
+import (
+	"fmt"
+	"io"
+	"time"
+)
 
 const maxUartRecvSize = 128
 
@@ -38,6 +42,33 @@ func New(r io.ReadWriter) *RTL8720DN {
 	return ret
 }
 
+func (r *RTL8720DN) Rpc_tcpip_adapter_init_with_timeout(d time.Duration) (int32, error) {
+	timeout := make(chan bool)
+	go func() {
+		time.Sleep(d)
+		timeout <- true
+	}()
+
+	var ret int32
+	var err error
+	done := make(chan bool)
+	go func() {
+		ret, err = r.Rpc_tcpip_adapter_init()
+		done <- true
+	}()
+
+	select {
+	case <-timeout:
+		return ret, fmt.Errorf("Rpc_tcpip_adapter_init: timeout")
+	case <-done:
+		if err != nil {
+			return ret, err
+		}
+	}
+
+	return ret, nil
+}
+
 func (r *RTL8720DN) SetSeq(s uint64) {
 	r.seq = s
 }

version.go

@@ -2,4 +2,4 @@ package drivers
 
 // Version returns a user-readable string showing the version of the drivers package for support purposes.
 // Update this value before release of new version of software.
-const Version = "0.22.0"
+const Version = "0.21.0"

waveshare-epd/epd2in9/epd2in9.go

@@ -1,291 +0,0 @@
-// Package epd2in9 implements a driver for Waveshare 2.9in black and white e-paper device.
-//
-// Note: this is for the V1 device (using IL3820), the V2 device uses a different chipset.
-//
-// Datasheets:
-//   https://www.waveshare.com/w/upload/e/e6/2.9inch_e-Paper_Datasheet.pdf
-//   https://www.smart-prototyping.com/image/data/9_Modules/EinkDisplay/GDE029A1/IL3820.pdf
-//
-// This implementation is essentially a copy of the 2in13 driver with the correct LUTs and
-// default size for the 2.9in device.
-//
-package epd2in9 // import "tinygo.org/x/drivers/waveshare-epd/epd2in9"
-
-import (
-	"image/color"
-	"machine"
-	"time"
-
-	"tinygo.org/x/drivers"
-)
-
-type Config struct {
-	Width        int16 // Width is the display resolution
-	Height       int16
-	LogicalWidth int16    // LogicalWidth must be a multiple of 8 and same size or bigger than Width
-	Rotation     Rotation // Rotation is clock-wise
-}
-
-type Device struct {
-	bus          drivers.SPI
-	cs           machine.Pin
-	dc           machine.Pin
-	rst          machine.Pin
-	busy         machine.Pin
-	logicalWidth int16
-	width        int16
-	height       int16
-	buffer       []uint8
-	bufferLength uint32
-	rotation     Rotation
-}
-
-type Rotation uint8
-
-// Look up table for full updates
-var lutFullUpdate = [30]uint8{
-	0x50, 0xAA, 0x55, 0xAA, 0x11, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0xFF, 0xFF, 0x1F, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-}
-
-// Look up table for partial updates, faster but there will be some ghosting
-var lutPartialUpdate = [30]uint8{
-	0x10, 0x18, 0x18, 0x08, 0x18, 0x18,
-	0x08, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x13, 0x14, 0x44, 0x12,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-}
-
-// New returns a new epd2in9 driver. Pass in a fully configured SPI bus.
-func New(bus drivers.SPI, csPin, dcPin, rstPin, busyPin machine.Pin) Device {
-	csPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	dcPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	rstPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	busyPin.Configure(machine.PinConfig{Mode: machine.PinInput})
-	return Device{
-		bus:  bus,
-		cs:   csPin,
-		dc:   dcPin,
-		rst:  rstPin,
-		busy: busyPin,
-	}
-}
-
-// Configure sets up the device.
-func (d *Device) Configure(cfg Config) {
-	if cfg.LogicalWidth != 0 {
-		d.logicalWidth = cfg.LogicalWidth
-	} else {
-		d.logicalWidth = 128
-	}
-	if cfg.Width != 0 {
-		d.width = cfg.Width
-	} else {
-		d.width = 128
-	}
-	if cfg.Height != 0 {
-		d.height = cfg.Height
-	} else {
-		d.height = 296
-	}
-	d.rotation = cfg.Rotation
-	d.bufferLength = (uint32(d.logicalWidth) * 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) {
-	x, y = d.xy(x, y)
-	if x < 0 || x >= d.logicalWidth || y < 0 || y >= d.height {
-		return
-	}
-	byteIndex := (int32(x) + int32(y)*int32(d.logicalWidth)) / 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.logicalWidth-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.logicalWidth/8; i++ {
-			d.SendData(d.buffer[i+j*(d.logicalWidth/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.logicalWidth-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) {
-	if d.rotation == ROTATION_90 || d.rotation == ROTATION_270 {
-		return d.height, d.logicalWidth
-	}
-	return d.logicalWidth, d.height
-}
-
-// SetRotation changes the rotation (clock-wise) of the device
-func (d *Device) SetRotation(rotation Rotation) {
-	d.rotation = rotation
-}
-
-// xy chages the coordinates according to the rotation
-func (d *Device) xy(x, y int16) (int16, int16) {
-	switch d.rotation {
-	case NO_ROTATION:
-		return x, y
-	case ROTATION_90:
-		return d.width - y - 1, x
-	case ROTATION_180:
-		return d.width - x - 1, d.height - y - 1
-	case ROTATION_270:
-		return y, d.height - x - 1
-	}
-	return x, y
-}

waveshare-epd/epd2in9/registers.go

@@ -1,31 +0,0 @@
-package epd2in9
-
-// 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
-
-	NO_ROTATION  Rotation = 0
-	ROTATION_90  Rotation = 1 // 90 degrees clock-wise rotation
-	ROTATION_180 Rotation = 2
-	ROTATION_270 Rotation = 3
-)