rtl8720dn: add Rpc_tcpip_adapter_init_with_timeout()

Signed-off-by: deadprogram <ron@hybridgroup.com>

examples/makeybutton/main.go

@@ -15,8 +15,8 @@ var (
 
 func main() {
 	led.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	button.Configure(machine.PinConfig{Mode: machine.PinInputPullup})
 	key = makeybutton.NewButton(button)
+	key.Configure()
 
 	for {
 		switch key.Get() {
@@ -25,6 +25,6 @@ func main() {
 		case makeybutton.Released:
 			led.Low()
 		}
-		time.Sleep(30 * time.Millisecond)
+		time.Sleep(100 * time.Millisecond)
 	}
 }

examples/rtl8720dn/tlsclient/main.go

@@ -6,8 +6,9 @@ import (
 	"strings"
 	"time"
 
-	"tinygo.org/x/drivers/examples/rtl8720dn"
+	"tinygo.org/x/drivers/net"
 	"tinygo.org/x/drivers/net/http"
+	"tinygo.org/x/drivers/rtl8720dn"
 )
 
 // You can override the setting with the init() in another source code.
@@ -52,6 +53,12 @@ CAUw7C29C79Fv1C5qfPrmAESrciIxpg0X40KPMbp1ZWVbd4=
 -----END CERTIFICATE-----
 `
 
+var buf [0x1000]byte
+
+var lastRequestTime time.Time
+var conn net.Conn
+var adaptor *rtl8720dn.RTL8720DN
+
 func main() {
 	err := run()
 	for err != nil {
@@ -61,12 +68,26 @@ func main() {
 }
 
 func run() error {
-	rtl8720dn.Debug(debug)
-	rtl, err := rtl8720dn.SetupAndConnectToAccessPoint(ssid, password, 10*time.Second)
+	rtl, err := setupRTL8720DN()
 	if err != nil {
 		return err
 	}
 	rtl.SetRootCA(&test_root_ca)
+	net.UseDriver(rtl)
+	http.SetBuf(buf[:])
+
+	err = rtl.ConnectToAccessPoint(ssid, password, 10*time.Second)
+	if err != nil {
+		return err
+	}
+
+	ip, subnet, gateway, err := rtl.GetIP()
+	if err != nil {
+		return err
+	}
+	fmt.Printf("IP Address : %s\r\n", ip)
+	fmt.Printf("Mask       : %s\r\n", subnet)
+	fmt.Printf("Gateway    : %s\r\n", gateway)
 
 	// You can send and receive cookies in the following way
 	// 	import "tinygo.org/x/drivers/net/http/cookiejar"

examples/rtl8720dn/tlsclient/wioterminal.go

@@ -0,0 +1,72 @@
+//go:build wioterminal
+// +build wioterminal
+
+package main
+
+import (
+	"device/sam"
+	"machine"
+	"runtime/interrupt"
+	"time"
+
+	"tinygo.org/x/drivers/rtl8720dn"
+)
+
+var (
+	uart UARTx
+)
+
+func handleInterrupt(interrupt.Interrupt) {
+	// should reset IRQ
+	uart.Receive(byte((uart.Bus.DATA.Get() & 0xFF)))
+	uart.Bus.INTFLAG.SetBits(sam.SERCOM_USART_INT_INTFLAG_RXC)
+}
+
+func setupRTL8720DN() (*rtl8720dn.RTL8720DN, error) {
+	machine.RTL8720D_CHIP_PU.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	machine.RTL8720D_CHIP_PU.Low()
+	time.Sleep(100 * time.Millisecond)
+	machine.RTL8720D_CHIP_PU.High()
+	time.Sleep(1000 * time.Millisecond)
+	waitSerial()
+
+	uart = UARTx{
+		UART: &machine.UART{
+			Buffer: machine.NewRingBuffer(),
+			Bus:    sam.SERCOM0_USART_INT,
+			SERCOM: 0,
+		},
+	}
+
+	uart.Interrupt = interrupt.New(sam.IRQ_SERCOM0_2, handleInterrupt)
+	uart.Configure(machine.UARTConfig{TX: machine.PB24, RX: machine.PC24, BaudRate: 614400})
+
+	rtl := rtl8720dn.New(uart)
+	rtl.Debug(debug)
+
+	_, err := rtl.Rpc_tcpip_adapter_init()
+	if err != nil {
+		return nil, err
+	}
+
+	return rtl, nil
+}
+
+// Wait for user to open serial console
+func waitSerial() {
+	for !machine.Serial.DTR() {
+		time.Sleep(100 * time.Millisecond)
+	}
+}
+
+type UARTx struct {
+	*machine.UART
+}
+
+func (u UARTx) Read(p []byte) (n int, err error) {
+	if u.Buffered() == 0 {
+		time.Sleep(1 * time.Millisecond)
+		return 0, nil
+	}
+	return u.UART.Read(p)
+}

examples/rtl8720dn/webclient-tinyterm/main.go

@@ -7,7 +7,7 @@ import (
 	"strings"
 	"time"
 
-	"tinygo.org/x/drivers/examples/rtl8720dn"
+	"tinygo.org/x/drivers/net"
 	"tinygo.org/x/drivers/net/http"
 	"tinygo.org/x/tinyfont/proggy"
 	"tinygo.org/x/tinyterm"
@@ -30,7 +30,7 @@ var (
 )
 
 var (
-	terminal *tinyterm.Terminal
+	terminal = tinyterm.NewTerminal(display)
 
 	black = color.RGBA{0, 0, 0, 255}
 	white = color.RGBA{255, 255, 255, 255}
@@ -41,10 +41,12 @@ var (
 	font = &proggy.TinySZ8pt7b
 )
 
+var buf [0x400]byte
+
 func main() {
 	display.FillScreen(black)
+	backlight.High()
 
-	terminal = tinyterm.NewTerminal(display)
 	terminal.Configure(&tinyterm.Config{
 		Font:       font,
 		FontHeight: 10,
@@ -63,14 +65,29 @@ func run() error {
 	if debug {
 		fmt.Fprintf(terminal, "Running in debug mode.\r\n")
 		fmt.Fprintf(terminal, "A serial connection is required to continue execution.\r\n")
-		rtl8720dn.Debug(true)
 	}
-	_, err := rtl8720dn.SetupAndConnectToAccessPoint(ssid, password, 10*time.Second)
+	rtl, err := setupRTL8720DN()
+	if err != nil {
+		return err
+	}
+	net.UseDriver(rtl)
+	http.SetBuf(buf[:])
+
+	fmt.Fprintf(terminal, "ConnectToAP()\r\n")
+	err = rtl.ConnectToAccessPoint(ssid, password, 10*time.Second)
 	if err != nil {
 		return err
 	}
 	fmt.Fprintf(terminal, "connected\r\n\r\n")
 
+	ip, subnet, gateway, err := rtl.GetIP()
+	if err != nil {
+		return err
+	}
+	fmt.Fprintf(terminal, "IP Address : %s\r\n", ip)
+	fmt.Fprintf(terminal, "Mask       : %s\r\n", subnet)
+	fmt.Fprintf(terminal, "Gateway    : %s\r\n", gateway)
+
 	// You can send and receive cookies in the following way
 	// 	import "tinygo.org/x/drivers/net/http/cookiejar"
 	// 	jar, err := cookiejar.New(nil)

examples/rtl8720dn/webclient-tinyterm/wioterminal.go

@@ -4,15 +4,95 @@
 package main
 
 import (
-	"tinygo.org/x/drivers/examples/ili9341/initdisplay"
+	"device/sam"
+	"machine"
+	"runtime/interrupt"
+	"time"
+
 	"tinygo.org/x/drivers/ili9341"
+	"tinygo.org/x/drivers/rtl8720dn"
 )
 
 var (
-	display *ili9341.Device
+	uart UARTx
+)
+
+var (
+	display = ili9341.NewSPI(
+		machine.SPI3,
+		machine.LCD_DC,
+		machine.LCD_SS_PIN,
+		machine.LCD_RESET,
+	)
+
+	backlight = machine.LCD_BACKLIGHT
 )
 
 func init() {
-	display = initdisplay.InitDisplay()
-	display.SetRotation(ili9341.Rotation0)
+	machine.SPI3.Configure(machine.SPIConfig{
+		SCK:       machine.LCD_SCK_PIN,
+		SDO:       machine.LCD_SDO_PIN,
+		SDI:       machine.LCD_SDI_PIN,
+		Frequency: 40000000,
+	})
+	display.Configure(ili9341.Config{})
+
+	backlight.Configure(machine.PinConfig{machine.PinOutput})
+}
+
+func handleInterrupt(interrupt.Interrupt) {
+	// should reset IRQ
+	uart.Receive(byte((uart.Bus.DATA.Get() & 0xFF)))
+	uart.Bus.INTFLAG.SetBits(sam.SERCOM_USART_INT_INTFLAG_RXC)
+}
+
+func setupRTL8720DN() (*rtl8720dn.RTL8720DN, error) {
+	machine.RTL8720D_CHIP_PU.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	machine.RTL8720D_CHIP_PU.Low()
+	time.Sleep(100 * time.Millisecond)
+	machine.RTL8720D_CHIP_PU.High()
+	time.Sleep(1000 * time.Millisecond)
+	if debug {
+		waitSerial()
+	}
+
+	uart = UARTx{
+		UART: &machine.UART{
+			Buffer: machine.NewRingBuffer(),
+			Bus:    sam.SERCOM0_USART_INT,
+			SERCOM: 0,
+		},
+	}
+
+	uart.Interrupt = interrupt.New(sam.IRQ_SERCOM0_2, handleInterrupt)
+	uart.Configure(machine.UARTConfig{TX: machine.PB24, RX: machine.PC24, BaudRate: 614400})
+
+	rtl := rtl8720dn.New(uart)
+	rtl.Debug(debug)
+
+	_, err := rtl.Rpc_tcpip_adapter_init()
+	if err != nil {
+		return nil, err
+	}
+
+	return rtl, nil
+}
+
+// Wait for user to open serial console
+func waitSerial() {
+	for !machine.Serial.DTR() {
+		time.Sleep(100 * time.Millisecond)
+	}
+}
+
+type UARTx struct {
+	*machine.UART
+}
+
+func (u UARTx) Read(p []byte) (n int, err error) {
+	if u.Buffered() == 0 {
+		time.Sleep(1 * time.Millisecond)
+		return 0, nil
+	}
+	return u.UART.Read(p)
 }

examples/rtl8720dn/webclient/main.go

@@ -6,7 +6,7 @@ import (
 	"strings"
 	"time"
 
-	"tinygo.org/x/drivers/examples/rtl8720dn"
+	"tinygo.org/x/drivers/net"
 	"tinygo.org/x/drivers/net/http"
 )
 
@@ -25,6 +25,8 @@ var (
 	debug    = false
 )
 
+var buf [0x400]byte
+
 func main() {
 	err := run()
 	for err != nil {
@@ -34,10 +36,25 @@ func main() {
 }
 
 func run() error {
-	_, err := rtl8720dn.SetupAndConnectToAccessPoint(ssid, password, 10*time.Second)
+	rtl, err := setupRTL8720DN()
 	if err != nil {
 		return err
 	}
+	net.UseDriver(rtl)
+	http.SetBuf(buf[:])
+
+	err = rtl.ConnectToAccessPoint(ssid, password, 10*time.Second)
+	if err != nil {
+		return err
+	}
+
+	ip, subnet, gateway, err := rtl.GetIP()
+	if err != nil {
+		return err
+	}
+	fmt.Printf("IP Address : %s\r\n", ip)
+	fmt.Printf("Mask       : %s\r\n", subnet)
+	fmt.Printf("Gateway    : %s\r\n", gateway)
 
 	// You can send and receive cookies in the following way
 	// 	import "tinygo.org/x/drivers/net/http/cookiejar"

examples/rtl8720dn/webclient/wioterminal.go

@@ -0,0 +1,72 @@
+//go:build wioterminal
+// +build wioterminal
+
+package main
+
+import (
+	"device/sam"
+	"machine"
+	"runtime/interrupt"
+	"time"
+
+	"tinygo.org/x/drivers/rtl8720dn"
+)
+
+var (
+	uart UARTx
+)
+
+func handleInterrupt(interrupt.Interrupt) {
+	// should reset IRQ
+	uart.Receive(byte((uart.Bus.DATA.Get() & 0xFF)))
+	uart.Bus.INTFLAG.SetBits(sam.SERCOM_USART_INT_INTFLAG_RXC)
+}
+
+func setupRTL8720DN() (*rtl8720dn.RTL8720DN, error) {
+	machine.RTL8720D_CHIP_PU.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	machine.RTL8720D_CHIP_PU.Low()
+	time.Sleep(100 * time.Millisecond)
+	machine.RTL8720D_CHIP_PU.High()
+	time.Sleep(1000 * time.Millisecond)
+	waitSerial()
+
+	uart = UARTx{
+		UART: &machine.UART{
+			Buffer: machine.NewRingBuffer(),
+			Bus:    sam.SERCOM0_USART_INT,
+			SERCOM: 0,
+		},
+	}
+
+	uart.Interrupt = interrupt.New(sam.IRQ_SERCOM0_2, handleInterrupt)
+	uart.Configure(machine.UARTConfig{TX: machine.PB24, RX: machine.PC24, BaudRate: 614400})
+
+	rtl := rtl8720dn.New(uart)
+	rtl.Debug(debug)
+
+	_, err := rtl.Rpc_tcpip_adapter_init()
+	if err != nil {
+		return nil, err
+	}
+
+	return rtl, nil
+}
+
+// Wait for user to open serial console
+func waitSerial() {
+	for !machine.Serial.DTR() {
+		time.Sleep(100 * time.Millisecond)
+	}
+}
+
+type UARTx struct {
+	*machine.UART
+}
+
+func (u UARTx) Read(p []byte) (n int, err error) {
+	if u.Buffered() == 0 {
+		time.Sleep(1 * time.Millisecond)
+		return 0, nil
+	}
+	return u.UART.Read(p)
+}

examples/rtl8720dn/webserver/main.go

@@ -2,15 +2,11 @@ package main
 
 import (
 	"fmt"
-	"image/color"
 	"machine"
 	"strconv"
 	"time"
 
-	"tinygo.org/x/drivers/examples/rtl8720dn"
 	"tinygo.org/x/drivers/net/http"
-	"tinygo.org/x/tinyfont"
-	"tinygo.org/x/tinyfont/freemono"
 )
 
 // You can override the setting with the init() in another source code.
@@ -27,9 +23,11 @@ var (
 )
 
 var led = machine.LED
+var backlight = machine.LCD_BACKLIGHT
 
 func main() {
 	led.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	backlight.Configure(machine.PinConfig{Mode: machine.PinOutput})
 
 	err := run()
 	for err != nil {
@@ -39,9 +37,13 @@ func main() {
 }
 
 func run() error {
-	tinyfont.WriteLine(display, &freemono.Regular9pt7b, 5, 15, "setup...", color.RGBA{0x00, 0x00, 0x00, 0xFF})
+	rtl, err := setupRTL8720DN()
+	if err != nil {
+		return err
+	}
+	http.UseDriver(rtl)
 
-	rtl, err := rtl8720dn.SetupAndConnectToAccessPoint(ssid, password, 10*time.Second)
+	err = rtl.ConnectToAccessPoint(ssid, password, 10*time.Second)
 	if err != nil {
 		return err
 	}
@@ -53,8 +55,6 @@ func run() error {
 	fmt.Printf("IP Address : %s\r\n", ip)
 	fmt.Printf("Mask       : %s\r\n", subnet)
 	fmt.Printf("Gateway    : %s\r\n", gateway)
-	tinyfont.WriteLine(display, &freemono.Regular9pt7b, 5, 15, "setup...done", color.RGBA{0x00, 0x00, 0x00, 0xFF})
-	tinyfont.WriteLine(display, &freemono.Regular9pt7b, 5, 30, fmt.Sprintf("listen:\nhttp://%s/", ip), color.RGBA{0x00, 0x00, 0x00, 0xFF})
 
 	http.HandleFunc("/", root)
 	http.HandleFunc("/hello", hello)
@@ -154,12 +154,14 @@ func sixlines(w http.ResponseWriter, r *http.Request) {
 
 func LED_ON(w http.ResponseWriter, r *http.Request) {
 	led.High()
+	backlight.High()
 	w.Header().Set(`Content-Type`, `text/plain; charset=UTF-8`)
 	fmt.Fprintf(w, "led.High()")
 }
 
 func LED_OFF(w http.ResponseWriter, r *http.Request) {
 	led.Low()
+	backlight.Low()
 	w.Header().Set(`Content-Type`, `text/plain; charset=UTF-8`)
 	fmt.Fprintf(w, "led.Low()")
 }

examples/rtl8720dn/webserver/wioterminal.go

@@ -4,20 +4,71 @@
 package main
 
 import (
+	"device/sam"
 	"machine"
+	"runtime/interrupt"
+	"time"
 
-	"tinygo.org/x/drivers/examples/ili9341/initdisplay"
-	"tinygo.org/x/drivers/ili9341"
+	"tinygo.org/x/drivers/rtl8720dn"
 )
 
 var (
-	display *ili9341.Device
+	uart UARTx
 )
 
-func init() {
-	display = initdisplay.InitDisplay()
-	display.SetRotation(ili9341.Rotation270)
-
-	// override
-	led = machine.LCD_BACKLIGHT
+func handleInterrupt(interrupt.Interrupt) {
+	// should reset IRQ
+	uart.Receive(byte((uart.Bus.DATA.Get() & 0xFF)))
+	uart.Bus.INTFLAG.SetBits(sam.SERCOM_USART_INT_INTFLAG_RXC)
+}
+
+func setupRTL8720DN() (*rtl8720dn.RTL8720DN, error) {
+	machine.RTL8720D_CHIP_PU.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	machine.RTL8720D_CHIP_PU.Low()
+	time.Sleep(100 * time.Millisecond)
+	machine.RTL8720D_CHIP_PU.High()
+	time.Sleep(1000 * time.Millisecond)
+	if debug {
+		waitSerial()
+	}
+
+	uart = UARTx{
+		UART: &machine.UART{
+			Buffer: machine.NewRingBuffer(),
+			Bus:    sam.SERCOM0_USART_INT,
+			SERCOM: 0,
+		},
+	}
+
+	uart.Interrupt = interrupt.New(sam.IRQ_SERCOM0_2, handleInterrupt)
+	uart.Configure(machine.UARTConfig{TX: machine.PB24, RX: machine.PC24, BaudRate: 614400})
+
+	rtl := rtl8720dn.New(uart)
+	rtl.Debug(debug)
+
+	_, err := rtl.Rpc_tcpip_adapter_init()
+	if err != nil {
+		return nil, err
+	}
+
+	return rtl, nil
+}
+
+// Wait for user to open serial console
+func waitSerial() {
+	for !machine.Serial.DTR() {
+		time.Sleep(100 * time.Millisecond)
+	}
+}
+
+type UARTx struct {
+	*machine.UART
+}
+
+func (u UARTx) Read(p []byte) (n int, err error) {
+	if u.Buffered() == 0 {
+		time.Sleep(1 * time.Millisecond)
+		return 0, nil
+	}
+	return u.UART.Read(p)
 }

examples/rtl8720dn/wioterminal.go

@@ -9,15 +9,12 @@ import (
 	"runtime/interrupt"
 	"time"
 
-	"tinygo.org/x/drivers/net"
-	"tinygo.org/x/drivers/net/http"
 	"tinygo.org/x/drivers/rtl8720dn"
 )
 
 var (
 	uart  UARTx
 	debug bool
-	buf   [0x1000]byte
 )
 
 func handleInterrupt(interrupt.Interrupt) {
@@ -50,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
 	}
@@ -58,24 +55,6 @@ func Setup() (*rtl8720dn.RTL8720DN, error) {
 	return rtl, nil
 }
 
-func SetupAndConnectToAccessPoint(ssid, pass string, timeout time.Duration) (*rtl8720dn.RTL8720DN, error) {
-	rtl, err := Setup()
-	if err != nil {
-		return nil, err
-	}
-
-	err = rtl.ConnectToAccessPoint(ssid, pass, 10*time.Second)
-	if err != nil {
-		return rtl, err
-	}
-
-	net.UseDriver(rtl)
-	http.UseDriver(rtl)
-	http.SetBuf(buf[:])
-
-	return rtl, nil
-}
-
 // Wait for user to open serial console
 func waitSerial() {
 	for !machine.Serial.DTR() {

go.mod

@@ -6,7 +6,7 @@ require (
 	github.com/eclipse/paho.mqtt.golang v1.2.0
 	github.com/frankban/quicktest v1.10.2
 	golang.org/x/net v0.0.0-20210614182718-04defd469f4e
-	tinygo.org/x/tinyfont v0.2.1
+	tinygo.org/x/tinyfont v0.3.0
 	tinygo.org/x/tinyfs v0.2.0
 	tinygo.org/x/tinyterm v0.1.0
 )

go.sum

@@ -5,12 +5,15 @@ github.com/frankban/quicktest v1.10.2 h1:19ARM85nVi4xH7xPXuc5eM/udya5ieh7b/Sv+d8
 github.com/frankban/quicktest v1.10.2/go.mod h1:K+q6oSqb0W0Ininfk863uOk1lMy69l/P6txr3mVT54s=
 github.com/google/go-cmp v0.5.2 h1:X2ev0eStA3AbceY54o37/0PQ/UWqKEiiO2dKL5OPaFM=
 github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/hajimehoshi/go-jisx0208 v1.0.0/go.mod h1:yYxEStHL7lt9uL+AbdWgW9gBumwieDoZCiB1f/0X0as=
 github.com/kr/pretty v0.2.1 h1:Fmg33tUaq4/8ym9TJN1x7sLJnHVwhP33CNkpYV/7rwI=
 github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/sago35/go-bdf v0.0.0-20200313142241-6c17821c91c4/go.mod h1:rOebXGuMLsXhZAC6mF/TjxONsm45498ZyzVhel++6KM=
 github.com/valyala/fastjson v1.6.3/go.mod h1:CLCAqky6SMuOcxStkYQvblddUtoRxhYMGLrsQns1aXY=
+golang.org/x/image v0.0.0-20210628002857-a66eb6448b8d/go.mod h1:023OzeP/+EPmXeapQh35lcL3II3LrY8Ic+EFFKVhULM=
 golang.org/x/net v0.0.0-20210614182718-04defd469f4e h1:XpT3nA5TvE525Ne3hInMh6+GETgn27Zfm9dxsThnX2Q=
 golang.org/x/net v0.0.0-20210614182718-04defd469f4e/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -25,8 +28,9 @@ tinygo.org/x/drivers v0.14.0/go.mod h1:uT2svMq3EpBZpKkGO+NQHjxjGf1f42ra4OnMMwQL2
 tinygo.org/x/drivers v0.15.1/go.mod h1:uT2svMq3EpBZpKkGO+NQHjxjGf1f42ra4OnMMwQL2aI=
 tinygo.org/x/drivers v0.16.0/go.mod h1:uT2svMq3EpBZpKkGO+NQHjxjGf1f42ra4OnMMwQL2aI=
 tinygo.org/x/drivers v0.19.0/go.mod h1:uJD/l1qWzxzLx+vcxaW0eY464N5RAgFi1zTVzASFdqI=
-tinygo.org/x/tinyfont v0.2.1 h1:FAaemBzw8wsfhAtG6fWW+QjyWw/K8YqEeiWo4N1pv4o=
 tinygo.org/x/tinyfont v0.2.1/go.mod h1:eLqnYSrFRjt5STxWaMeOWJTzrKhXqpWw7nU3bPfKOAM=
+tinygo.org/x/tinyfont v0.3.0 h1:HIRLQoI3oc+2CMhPcfv+Ig88EcTImE/5npjqOnMD4lM=
+tinygo.org/x/tinyfont v0.3.0/go.mod h1:+TV5q0KpwSGRWnN+ITijsIhrWYJkoUCp9MYELjKpAXk=
 tinygo.org/x/tinyfs v0.1.0/go.mod h1:ysc8Y92iHfhTXeyEM9+c7zviUQ4fN9UCFgSOFfMWv20=
 tinygo.org/x/tinyfs v0.2.0 h1:M0lwZC/dEGFt16XYN5GTQsif/qCkAN2qUVNxELVD1xg=
 tinygo.org/x/tinyfs v0.2.0/go.mod h1:6ZHYdvB3sFYeMB3ypmXZCNEnFwceKc61ADYTYHpep1E=

makeybutton/buffer.go

@@ -1,6 +1,6 @@
 package makeybutton
 
-const bufferSize = 10
+const bufferSize = 6
 
 // Buffer is a buffer to keep track of the most recent readings for a button.
 type Buffer struct {

makeybutton/button.go

@@ -6,7 +6,10 @@
 //
 package makeybutton
 
-import "machine"
+import (
+	"machine"
+	"time"
+)
 
 // ButtonState represents the state of a MakeyButton.
 type ButtonState int
@@ -36,9 +39,6 @@ type Button struct {
 
 // NewButton creates a new Button.
 func NewButton(pin machine.Pin) *Button {
-	pin.Configure(machine.PinConfig{Mode: machine.PinInput})
-	pin.Set(false)
-
 	return &Button{
 		pin:              pin,
 		state:            NeverPressed,
@@ -47,6 +47,18 @@ func NewButton(pin machine.Pin) *Button {
 	}
 }
 
+// Configure configures the Makey Button pin to have the correct settings to detect touches.
+func (b *Button) Configure() error {
+	// Note that we have to first turn on the pullup, and then turn off the pullup,
+	// in order for the pin to be properly floating.
+	b.pin.Configure(machine.PinConfig{Mode: machine.PinInputPullup})
+	time.Sleep(10 * time.Millisecond)
+	b.pin.Configure(machine.PinConfig{Mode: machine.PinInput})
+	b.pin.Set(false)
+
+	return nil
+}
+
 // Get returns a ButtonEvent based on the most recent state of the button,
 // and if it has changed by being pressed or released.
 func (b *Button) Get() ButtonEvent {
@@ -61,7 +73,7 @@ func (b *Button) Get() ButtonEvent {
 	b.readings.Put(pressed)
 
 	switch {
-	case pressed && avg > 0:
+	case pressed && avg > -1*bufferSize+2:
 		if b.state == Press {
 			return NotChanged
 		}

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
 }