release: prepare for v0.18.0

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

CHANGELOG.md

@@ -1,3 +1,60 @@
+0.18.0
+---
+- **new devices**
+    - apds9960: add support for APDS-9960 Digital Proximity sensor
+    - axp192: add support for AXP192 single Cell Li-Battery and power system management IC
+    - hts221: add support for HTS221 capacitive digital sensor for relative humidity and temperature
+    - i2csoft: add support for software I2C
+    - image: add support for image/jpeg and image/png
+    - lps22hb: add support for LPS22HB MEMS nano pressure sensor
+    - lsm6dox: add support for lsm6dox accelerometer
+    - lsm9ds1: add support for lsm9ds1 accelerometer
+- **enhancements**
+    - ili9341: change to use drivers.SPI interface
+    - **ws2812**
+        - generate assembly instead of handwriting it
+        - improve timings to be compatible with the WS2811
+        - add support for 168MHz (e.g. Adafruit Feather STM32F405)
+        - add support for RISC-V
+    - wifinina: control nina pins, for example leds
+- **docs**
+    - rtl8720dn: examples for tcpclient, udpstation, mqtt, and webserver
+    - **wifinina** 
+        - nina-fw update docs
+        - examples/wifinina/http-get
+    - ili9341: refactor examples
+    - Fix broken link for SHT3x datasheet
+- **core**
+    - all: use build directives for both Go1.17 and earlier versions
+- **bugfixes**
+    - net: fix raddr of tcp conn
+    - mcp3008: fix bitshift bug
+
+0.17.1
+---
+- To correct an error in the release process. Same as 0.17.0.
+
+0.17.0
+---
+- **new devices**
+    - rtl8720dn: add support for rtl8720dn
+    - sdcard: add support for spi sdcard driver, along with fatfs
+- **enhancements**
+    - apa102: use 4-byte buffer to improve speed
+    - bmi160: avoid heap allocations
+    - ili9341: add standard SPI driver
+    - wifinina
+        - avoid fmt package
+        - Fix RSSI command for WiFiNINA + Print current SSID + Wait for correct time before printing it out + Cleanup
+    - ws2812
+        - rename the pin to ws2812
+        - add tag for nrf52833
+        - Disable interrupts before sending ws2812 data
+        - add support for qtpy and atsame5x
+- **core**
+    - modules: switch to use tinygo-org version of tinyfs package
+    - all: use machine.Serial as the default output
+
 0.16.0
 ---
 - **new devices**

Makefile

@@ -2,7 +2,7 @@
 clean:
 	@rm -rf build
 
-FMT_PATHS = ./*.go ./examples/**/*.go
+FMT_PATHS = ./
 
 fmt-check:
 	@unformatted=$$(gofmt -l $(FMT_PATHS)); [ -z "$$unformatted" ] && exit 0; echo "Unformatted:"; for fn in $$unformatted; do echo "  $$fn"; done; exit 1
@@ -17,6 +17,8 @@ smoke-test:
 	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=itsybitsy-m0 ./examples/apa102/main.go
 	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=nano-33-ble ./examples/apds9960/proximity/main.go
+	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=itsybitsy-m0 ./examples/apa102/itsybitsy-m0/main.go
 	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=microbit ./examples/at24cx/main.go
@@ -63,6 +65,8 @@ smoke-test:
 	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=arduino-nano33 ./examples/hd44780i2c/main.go
 	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=nano-33-ble ./examples/hts221/main.go
+	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=microbit ./examples/hub75/main.go
 	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=pyportal ./examples/ili9341/basic
@@ -75,8 +79,12 @@ smoke-test:
 	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=xiao ./examples/ili9341/scroll
 	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=pyportal ./examples/ili9341/slideshow
+	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=circuitplay-express ./examples/lis3dh/main.go
 	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=nano-33-ble ./examples/lps22hb/main.go
+	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=microbit ./examples/lsm303agr/main.go
 	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=arduino-nano33 ./examples/lsm6ds3/main.go
@@ -197,12 +205,22 @@ endif
 	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=feather-m4 ./examples/sdcard/tinyfs/
 	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=wioterminal ./examples/rtl8720dn/webclient/
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=wioterminal ./examples/rtl8720dn/webserver/
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=wioterminal ./examples/rtl8720dn/mqttsub/
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=feather-m4 ./examples/i2csoft/adt7410/
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.elf -target=wioterminal ./examples/axp192/m5stack-core2-blinky/
+	@md5sum ./build/test.hex
 
 DRIVERS = $(wildcard */)
 NOTESTS = build examples flash semihosting pcd8544 shiftregister st7789 microphone mcp3008 gps microbitmatrix \
 		hcsr04 ssd1331 ws2812 thermistor apa102 easystepper ssd1351 ili9341 wifinina shifter hub75 \
 		hd44780 buzzer ssd1306 espat l9110x st7735 bmi160 l293x dht keypad4x4 max72xx p1am tone tm1637 \
-		pcf8563 mcp2515 servo sdcard
+		pcf8563 mcp2515 servo sdcard rtl8720dn image cmd i2csoft hts221 lps22hb apds9960 axp192
 TESTS = $(filter-out $(addsuffix /%,$(NOTESTS)),$(DRIVERS))
 
 unit-test:

README.md

@@ -52,7 +52,7 @@ func main() {
 
 ## Currently supported devices
 
-The following 66 devices are supported.
+The following 74 devices are supported.
 
 | Device Name | Interface Type |
 |----------|-------------|
@@ -61,7 +61,9 @@ The following 66 devices are supported.
 | [AHT20 I2C Temperature and Humidity Sensor](http://www.aosong.com/userfiles/files/media/AHT20%20%E8%8B%B1%E6%96%87%E7%89%88%E8%AF%B4%E6%98%8E%E4%B9%A6%20A0%2020201222.pdf) | I2C |
 | [AMG88xx 8x8 Thermal camera sensor](https://cdn-learn.adafruit.com/assets/assets/000/043/261/original/Grid-EYE_SPECIFICATIONS%28Reference%29.pdf) | I2C |
 | [APA102 RGB LED](https://cdn-shop.adafruit.com/product-files/2343/APA102C.pdf) | SPI |
+| [APDS9960 Digital proximity, ambient light, RGB and gesture sensor](https://cdn.sparkfun.com/assets/learn_tutorials/3/2/1/Avago-APDS-9960-datasheet.pdf) | I2C |
 | [AT24CX 2-wire serial EEPROM](https://www.openimpulse.com/blog/wp-content/uploads/wpsc/downloadables/24C32-Datasheet.pdf) | I2C |
+| [AXP192 single Cell Li-Battery and Power System Management](https://github.com/m5stack/M5-Schematic/blob/master/Core/AXP192%20Datasheet_v1.1_en_draft_2211.pdf) | I2C |
 | [BBC micro:bit LED matrix](https://github.com/bbcmicrobit/hardware/blob/master/SCH_BBC-Microbit_V1.3B.pdf) | GPIO |
 | [BH1750 ambient light sensor](https://www.mouser.com/ds/2/348/bh1750fvi-e-186247.pdf) | I2C |
 | [BlinkM RGB LED](http://thingm.com/fileadmin/thingm/downloads/BlinkM_datasheet.pdf) | I2C |
@@ -79,7 +81,9 @@ The following 66 devices are supported.
 | [GPS module](https://www.u-blox.com/en/product/neo-6-series) | I2C/UART |
 | [HC-SR04 Ultrasonic distance sensor](https://cdn.sparkfun.com/datasheets/Sensors/Proximity/HCSR04.pdf) | GPIO |
 | [HD44780 LCD controller](https://www.sparkfun.com/datasheets/LCD/HD44780.pdf) | GPIO/I2C |
+| [HTS221 digital humidity and temperature sensor](https://www.st.com/resource/en/datasheet/hts221.pdf) | I2C |
 | [HUB75 RGB led matrix](https://cdn-learn.adafruit.com/downloads/pdf/32x16-32x32-rgb-led-matrix.pdf) | SPI |
+| [software I2C driver](https://www.ti.com/lit/an/slva704/slva704.pdf) | GPIO |
 | [ILI9341 TFT color display](https://cdn-shop.adafruit.com/datasheets/ILI9341.pdf) | SPI |
 | [INA260 Volt/Amp/Power meter](https://www.ti.com/lit/ds/symlink/ina260.pdf) | I2C |
 | [4x4 Membrane Keypad](https://cdn.sparkfun.com/assets/f/f/a/5/0/DS-16038.pdf) | GPIO |
@@ -87,12 +91,16 @@ The following 66 devices are supported.
 | [L9110x motor driver](https://www.elecrow.com/download/datasheet-l9110.pdf) | GPIO/PWM |
 | [LIS2MDL magnetometer](https://www.st.com/resource/en/datasheet/lis2mdl.pdf) | I2C |
 | [LIS3DH accelerometer](https://www.st.com/resource/en/datasheet/lis3dh.pdf) | I2C |
+| [LPS22HB MEMS nano pressure sensor](https://www.st.com/resource/en/datasheet/dm00140895.pdf) | I2C |
 | [LSM6DS3 accelerometer](https://www.st.com/resource/en/datasheet/lsm6ds3.pdf) | I2C |
+| [LSM6DSOX accelerometer](https://www.st.com/resource/en/datasheet/lsm6dsox.pdf) | I2C |
+| [LSM303AGR accelerometer](https://www.st.com/resource/en/datasheet/lsm303agr.pdf) | I2C |
+| [LSM9DS1 accelerometer](https://www.st.com/resource/en/datasheet/lsm9ds1.pdf) | I2C |
 | [MAG3110 magnetometer](https://www.nxp.com/docs/en/data-sheet/MAG3110.pdf) | I2C |
 | [MAX7219 & MAX7221 display driver](https://datasheets.maximintegrated.com/en/ds/MAX7219-MAX7221.pdf) | SPI |
-| [MCP23017 port expander](https://ww1.microchip.com/downloads/en/DeviceDoc/20001952C.pdf) | I2C |
-| [MCP3008 analog to digital converter (ADC)](http://ww1.microchip.com/downloads/en/DeviceDoc/21295d.pdf) | SPI |
 | [MCP2515 Stand-Alone CAN Controller with SPI Interface](https://ww1.microchip.com/downloads/en/DeviceDoc/MCP2515-Family-Data-Sheet-DS20001801K.pdf) | SPI |
+| [MCP3008 analog to digital converter (ADC)](http://ww1.microchip.com/downloads/en/DeviceDoc/21295d.pdf) | SPI |
+| [MCP23017 port expander](https://ww1.microchip.com/downloads/en/DeviceDoc/20001952C.pdf) | I2C |
 | [Microphone - PDM](https://cdn-learn.adafruit.com/assets/assets/000/049/977/original/MP34DT01-M.pdf) | I2S/PDM |
 | [MMA8653 accelerometer](https://www.nxp.com/docs/en/data-sheet/MMA8653FC.pdf) | I2C |
 | [MPU6050 accelerometer/gyroscope](https://store.invensense.com/datasheets/invensense/MPU-6050_DataSheet_V3%204.pdf) | I2C |
@@ -100,11 +108,12 @@ The following 66 devices are supported.
 | [PCD8544 display](http://eia.udg.edu/~forest/PCD8544_1.pdf) | SPI |
 | [PCF8563 real time clock](https://www.nxp.com/docs/en/data-sheet/PCF8563.pdf) | I2C |
 | [Resistive Touchscreen (4-wire)](http://ww1.microchip.com/downloads/en/Appnotes/doc8091.pdf) | GPIO |
+| [RTL8720DN 2.4G/5G Dual Bands Wireless and BLE5.0](https://www.seeedstudio.com/Realtek8720DN-2-4G-5G-Dual-Bands-Wireless-and-BLE5-0-Combo-Module-p-4442.html) | UART |
 | [Semihosting](https://wiki.segger.com/Semihosting) | Debug |
 | [Servo](https://learn.sparkfun.com/tutorials/hobby-servo-tutorial/all) | PWM |
 | [Shift register (PISO)](https://en.wikipedia.org/wiki/Shift_register#Parallel-in_serial-out_\(PISO\)) | GPIO |
 | [Shift registers (SIPO)](https://en.wikipedia.org/wiki/Shift_register#Serial-in_parallel-out_(SIPO)) | GPIO |
-| [SHT3x Digital Humidity Sensor](https://www.sensirion.com/fileadmin/user_upload/customers/sensirion/Dokumente/0_Datasheets/Humidity/Sensirion_Humidity_Sensors_SHT3x_Datasheet_digital.pdf) | I2C |
+| [SHT3x Digital Humidity Sensor](https://www.sensirion.com/fileadmin/user_upload/customers/sensirion/Dokumente/2_Humidity_Sensors/Datasheets/Sensirion_Humidity_Sensors_SHT3x_Datasheet_digital.pdf) | I2C |
 | [SPI NOR Flash Memory](https://en.wikipedia.org/wiki/Flash_memory#NOR_flash) | SPI/QSPI |
 | [SPI SDCARD/MMC](https://en.wikipedia.org/wiki/SD_card) | SPI |
 | [SSD1306 OLED display](https://cdn-shop.adafruit.com/datasheets/SSD1306.pdf) | I2C / SPI |

apds9960/apds9960.go

@@ -0,0 +1,461 @@
+// Package apds9960 implements a driver for APDS-9960,
+// a digital proximity, ambient light, RGB and gesture sensor.
+//
+// Datasheet: https://cdn.sparkfun.com/assets/learn_tutorials/3/2/1/Avago-APDS-9960-datasheet.pdf
+//
+package apds9960
+
+import (
+	"time"
+
+	"tinygo.org/x/drivers"
+)
+
+// Device wraps an I2C connection to a APDS-9960 device.
+type Device struct {
+	bus     drivers.I2C
+	Address uint8
+	mode    uint8
+	gesture gestureData
+}
+
+// Configuration for APDS-9960 device.
+type Configuration struct {
+	ProximityPulseLength uint8
+	ProximityPulseCount  uint8
+	GesturePulseLength   uint8
+	GesturePulseCount    uint8
+	ProximityGain        uint8
+	GestureGain          uint8
+	ColorGain            uint8
+	ADCIntegrationCycles uint16
+	LEDBoost             uint16
+	threshold            uint8
+	sensitivity          uint8
+}
+
+// for gesture-related data
+type gestureData struct {
+	detected    uint8
+	threshold   uint8
+	sensitivity uint8
+	gXDelta     int16
+	gYDelta     int16
+	gXPrevDelta int16
+	gYPrevDelta int16
+	received    bool
+}
+
+// for enabling various device function
+type enableConfig struct {
+	GEN  bool
+	PIEN bool
+	AIEN bool
+	WEN  bool
+	PEN  bool
+	AEN  bool
+	PON  bool
+}
+
+// Connected returns whether APDS-9960 has been found.
+// It does a "who am I" request and checks the response.
+func (d *Device) Connected() bool {
+	data := []byte{0}
+	d.bus.ReadRegister(d.Address, APDS9960_ID_REG, data)
+	return data[0] == 0xAB
+}
+
+// Configure sets up the APDS-9960 device.
+func (d *Device) Configure(cfg Configuration) {
+	d.DisableAll() // turn off everything
+
+	// "default" settings
+	if cfg.ProximityPulseLength == 0 {
+		cfg.ProximityPulseLength = 16
+	}
+	if cfg.ProximityPulseCount == 0 {
+		cfg.ProximityPulseCount = 64
+	}
+	if cfg.GesturePulseLength == 0 {
+		cfg.GesturePulseLength = 16
+	}
+	if cfg.GesturePulseCount == 0 {
+		cfg.GesturePulseCount = 64
+	}
+	if cfg.ProximityGain == 0 {
+		cfg.ProximityGain = 1
+	}
+	if cfg.GestureGain == 0 {
+		cfg.GestureGain = 1
+	}
+	if cfg.ColorGain == 0 {
+		cfg.ColorGain = 4
+	}
+	if cfg.ADCIntegrationCycles == 0 {
+		cfg.ADCIntegrationCycles = 4
+	}
+	if cfg.threshold == 0 {
+		d.gesture.threshold = 30
+	}
+	if cfg.sensitivity == 0 {
+		d.gesture.sensitivity = 20
+	}
+
+	d.SetProximityPulse(cfg.ProximityPulseLength, cfg.ProximityPulseCount)
+	d.SetGesturePulse(cfg.GesturePulseLength, cfg.GesturePulseCount)
+	d.SetGains(cfg.ProximityGain, cfg.GestureGain, cfg.ColorGain)
+	d.SetADCIntegrationCycles(cfg.ADCIntegrationCycles)
+
+	if cfg.LEDBoost > 0 {
+		d.LEDBoost(cfg.LEDBoost)
+	}
+}
+
+// GetMode returns current engine mode
+func (d *Device) GetMode() uint8 {
+	return d.mode
+}
+
+// DisableAll turns off the device and all functions
+func (d *Device) DisableAll() {
+	d.enable(enableConfig{})
+	d.bus.WriteRegister(d.Address, APDS9960_GCONF4_REG, []byte{0x00})
+	d.mode = MODE_NONE
+	d.gesture.detected = GESTURE_NONE
+}
+
+// SetProximityPulse sets proximity pulse length (4, 8, 16, 32) and count (1~64)
+// default: 16, 64
+func (d *Device) SetProximityPulse(length, count uint8) {
+	d.bus.WriteRegister(d.Address, APDS9960_PPULSE_REG, []byte{getPulseLength(length)<<6 | getPulseCount(count)})
+}
+
+// SetGesturePulse sets gesture pulse length (4, 8, 16, 32) and count (1~64)
+// default: 16, 64
+func (d *Device) SetGesturePulse(length, count uint8) {
+	d.bus.WriteRegister(d.Address, APDS9960_GPULSE_REG, []byte{getPulseLength(length)<<6 | getPulseCount(count)})
+}
+
+// SetADCIntegrationCycles sets ALS/color ADC internal integration cycles (1~256, 1 cycle = 2.78 ms)
+// default: 4 (~10 ms)
+func (d *Device) SetADCIntegrationCycles(cycles uint16) {
+	if cycles > 256 {
+		cycles = 256
+	}
+	d.bus.WriteRegister(d.Address, APDS9960_ATIME_REG, []byte{uint8(256 - cycles)})
+}
+
+// SetGains sets proximity/gesture gain (1, 2, 4, 8x) and ALS/color gain (1, 4, 16, 64x)
+// default: 1, 1, 4
+func (d *Device) SetGains(proximityGain, gestureGain, colorGain uint8) {
+	d.bus.WriteRegister(d.Address, APDS9960_CONTROL_REG, []byte{getProximityGain(proximityGain)<<2 | getALSGain(colorGain)})
+	d.bus.WriteRegister(d.Address, APDS9960_GCONF2_REG, []byte{getProximityGain(gestureGain) << 5})
+}
+
+// LEDBoost sets proximity and gesture LED current level (100, 150, 200, 300 (%))
+// default: 100
+func (d *Device) LEDBoost(percent uint16) {
+	var v uint8
+	switch percent {
+	case 100:
+		v = 0
+	case 150:
+		v = 1
+	case 200:
+		v = 2
+	case 300:
+		v = 3
+	}
+	d.bus.WriteRegister(d.Address, APDS9960_CONFIG2_REG, []byte{0x01 | v<<4})
+}
+
+// Setthreshold sets threshold (0~255) for detecting gestures
+// default: 30
+func (d *Device) Setthreshold(t uint8) {
+	d.gesture.threshold = t
+}
+
+// Setsensitivity sets sensivity (0~100) for detecting gestures
+// default: 20
+func (d *Device) Setsensitivity(s uint8) {
+	if s > 100 {
+		s = 100
+	}
+	d.gesture.sensitivity = 100 - s
+}
+
+// EnableProximity starts the proximity engine
+func (d *Device) EnableProximity() {
+	if d.mode != MODE_NONE {
+		d.DisableAll()
+	}
+	d.enable(enableConfig{PON: true, PEN: true, WEN: true})
+	d.mode = MODE_PROXIMITY
+}
+
+// ProximityAvailable reports if proximity data is available
+func (d *Device) ProximityAvailable() bool {
+	if d.mode == MODE_PROXIMITY && d.readStatus("PVALID") {
+		return true
+	}
+	return false
+}
+
+// ReadProximity reads proximity data (0~255)
+func (d *Device) ReadProximity() (proximity int32) {
+	if d.mode != MODE_PROXIMITY {
+		return 0
+	}
+	data := []byte{0}
+	d.bus.ReadRegister(d.Address, APDS9960_PDATA_REG, data)
+	return 255 - int32(data[0])
+}
+
+// EnableColor starts the color engine
+func (d *Device) EnableColor() {
+	if d.mode != MODE_NONE {
+		d.DisableAll()
+	}
+	d.enable(enableConfig{PON: true, AEN: true, WEN: true})
+	d.mode = MODE_COLOR
+}
+
+// ColorAvailable reports if color data is available
+func (d *Device) ColorAvailable() bool {
+	if d.mode == MODE_COLOR && d.readStatus("AVALID") {
+		return true
+	}
+	return false
+}
+
+// ReadColor reads color data (red, green, blue, clear color/brightness)
+func (d *Device) ReadColor() (r int32, g int32, b int32, clear int32) {
+	if d.mode != MODE_COLOR {
+		return
+	}
+	data := []byte{0, 0, 0, 0, 0, 0, 0, 0}
+	d.bus.ReadRegister(d.Address, APDS9960_CDATAL_REG, data[:1])
+	d.bus.ReadRegister(d.Address, APDS9960_CDATAH_REG, data[1:2])
+	d.bus.ReadRegister(d.Address, APDS9960_RDATAL_REG, data[2:3])
+	d.bus.ReadRegister(d.Address, APDS9960_RDATAH_REG, data[3:4])
+	d.bus.ReadRegister(d.Address, APDS9960_GDATAL_REG, data[4:5])
+	d.bus.ReadRegister(d.Address, APDS9960_GDATAH_REG, data[5:6])
+	d.bus.ReadRegister(d.Address, APDS9960_BDATAL_REG, data[6:7])
+	d.bus.ReadRegister(d.Address, APDS9960_BDATAH_REG, data[7:])
+	clear = int32(uint16(data[1])<<8 | uint16(data[0]))
+	r = int32(uint16(data[3])<<8 | uint16(data[2]))
+	g = int32(uint16(data[5])<<8 | uint16(data[4]))
+	b = int32(uint16(data[7])<<8 | uint16(data[6]))
+	return
+}
+
+// EnableGesture starts the gesture engine
+func (d *Device) EnableGesture() {
+	if d.mode != MODE_NONE {
+		d.DisableAll()
+	}
+	d.enable(enableConfig{PON: true, PEN: true, GEN: true, WEN: true})
+	d.mode = MODE_GESTURE
+	d.gesture.detected = GESTURE_NONE
+	d.gesture.gXDelta = 0
+	d.gesture.gYDelta = 0
+	d.gesture.gXPrevDelta = 0
+	d.gesture.gYPrevDelta = 0
+	d.gesture.received = false
+}
+
+// GestureAvailable reports if gesture data is available
+func (d *Device) GestureAvailable() bool {
+	if d.mode != MODE_GESTURE {
+		return false
+	}
+
+	data := []byte{0, 0, 0, 0}
+
+	// check GVALID
+	d.bus.ReadRegister(d.Address, APDS9960_GSTATUS_REG, data[:1])
+	if data[0]&0x01 == 0 {
+		return false
+	}
+
+	// get number of data sets available in FIFO
+	d.bus.ReadRegister(d.Address, APDS9960_GFLVL_REG, data[:1])
+	availableDataSets := data[0]
+	if availableDataSets == 0 {
+		return false
+	}
+
+	// read up, down, left and right proximity data from FIFO
+	var dataSets [32][4]uint8
+	for i := uint8(0); i < availableDataSets; i++ {
+		d.bus.ReadRegister(d.Address, APDS9960_GFIFO_U_REG, data[:1])
+		d.bus.ReadRegister(d.Address, APDS9960_GFIFO_D_REG, data[1:2])
+		d.bus.ReadRegister(d.Address, APDS9960_GFIFO_L_REG, data[2:3])
+		d.bus.ReadRegister(d.Address, APDS9960_GFIFO_R_REG, data[3:4])
+		for j := uint8(0); j < 4; j++ {
+			dataSets[i][j] = data[j]
+		}
+	}
+
+	// gesture detection process
+	d.gesture.detected = GESTURE_NONE
+	for i := uint8(0); i < availableDataSets; i++ {
+		U := dataSets[i][0]
+		D := dataSets[i][1]
+		L := dataSets[i][2]
+		R := dataSets[i][3]
+
+		// if all readings fall below threshold, it's possible that
+		// a movement's just been made
+		if U < d.gesture.threshold && D < d.gesture.threshold && L < d.gesture.threshold && R < d.gesture.threshold {
+			d.gesture.received = true
+			// if there were movement in the previous step (including the last data sets)
+			if d.gesture.gXPrevDelta != 0 && d.gesture.gYPrevDelta != 0 {
+				totalX := d.gesture.gXPrevDelta - d.gesture.gXDelta
+				totalY := d.gesture.gYPrevDelta - d.gesture.gYDelta
+				// if previous and current movement are in opposite directions (pass through one led then next)
+				// and the difference is big enough, the gesture is recorded
+				switch {
+				case totalX < -int16(d.gesture.sensitivity):
+					d.gesture.detected = GESTURE_LEFT
+				case totalX > int16(d.gesture.sensitivity):
+					d.gesture.detected = GESTURE_RIGHT
+				case totalY > int16(d.gesture.sensitivity):
+					d.gesture.detected = GESTURE_DOWN
+				case totalY < -int16(d.gesture.sensitivity):
+					d.gesture.detected = GESTURE_UP
+				}
+				d.gesture.gXDelta = 0
+				d.gesture.gYDelta = 0
+				d.gesture.gXPrevDelta = 0
+				d.gesture.gYPrevDelta = 0
+			}
+			continue
+		}
+
+		// recording current movement
+		d.gesture.gXDelta = int16(R) - int16(L)
+		d.gesture.gYDelta = int16(D) - int16(U)
+		if d.gesture.received {
+			d.gesture.received = false
+			d.gesture.gXPrevDelta = d.gesture.gXDelta
+			d.gesture.gYPrevDelta = d.gesture.gYDelta
+		}
+	}
+
+	return d.gesture.detected != GESTURE_NONE
+}
+
+// ReadGesture reads last gesture data
+func (d *Device) ReadGesture() (gesture int32) {
+	return int32(d.gesture.detected)
+}
+
+// private functions
+
+func (d *Device) enable(cfg enableConfig) {
+	var gen, pien, aien, wen, pen, aen, pon uint8
+
+	if cfg.GEN {
+		gen = 1
+	}
+	if cfg.PIEN {
+		pien = 1
+	}
+	if cfg.AIEN {
+		aien = 1
+	}
+	if cfg.WEN {
+		wen = 1
+	}
+	if cfg.PEN {
+		pen = 1
+	}
+	if cfg.AEN {
+		aen = 1
+	}
+	if cfg.PON {
+		pon = 1
+	}
+
+	data := []byte{gen<<6 | pien<<5 | aien<<4 | wen<<3 | pen<<2 | aen<<1 | pon}
+	d.bus.WriteRegister(d.Address, APDS9960_ENABLE_REG, data)
+
+	if cfg.PON {
+		time.Sleep(time.Millisecond * 10)
+	}
+}
+
+func (d *Device) readStatus(param string) bool {
+	data := []byte{0}
+	d.bus.ReadRegister(d.Address, APDS9960_STATUS_REG, data)
+
+	switch param {
+	case "CPSAT":
+		return data[0]>>7&0x01 == 1
+	case "PGSAT":
+		return data[0]>>6&0x01 == 1
+	case "PINT":
+		return data[0]>>5&0x01 == 1
+	case "AINT":
+		return data[0]>>4&0x01 == 1
+	case "PVALID":
+		return data[0]>>1&0x01 == 1
+	case "AVALID":
+		return data[0]&0x01 == 1
+	default:
+		return false
+	}
+}
+
+func getPulseLength(l uint8) uint8 {
+	switch l {
+	case 4:
+		return 0
+	case 8:
+		return 1
+	case 16:
+		return 2
+	case 32:
+		return 3
+	default:
+		return 0
+	}
+}
+
+func getPulseCount(c uint8) uint8 {
+	if c < 1 && c > 64 {
+		return 0
+	}
+	return c - 1
+}
+
+func getProximityGain(g uint8) uint8 {
+	switch g {
+	case 1:
+		return 0
+	case 2:
+		return 1
+	case 4:
+		return 2
+	case 8:
+		return 3
+	default:
+		return 0
+	}
+}
+
+func getALSGain(g uint8) uint8 {
+	switch g {
+	case 1:
+		return 0
+	case 4:
+		return 1
+	case 16:
+		return 2
+	case 64:
+		return 3
+	default:
+		return 0
+	}
+}

apds9960/apds9960_generic.go

@@ -0,0 +1,14 @@
+//go:build !nano_33_ble
+// +build !nano_33_ble
+
+package apds9960
+
+import "tinygo.org/x/drivers"
+
+// New creates a new APDS-9960 connection. The I2C bus must already be
+// configured.
+//
+// This function only creates the Device object, it does not touch the device.
+func New(bus drivers.I2C) Device {
+	return Device{bus: bus, Address: ADPS9960_ADDRESS, mode: MODE_NONE}
+}

apds9960/apds9960_nano_33_ble.go

@@ -0,0 +1,29 @@
+//go:build nano_33_ble
+// +build nano_33_ble
+
+package apds9960
+
+import (
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers"
+)
+
+// New creates a new APDS-9960 connection. The I2C bus must already be
+// configured.
+//
+// This function only creates the Device object, it does not touch the device.
+func New(bus drivers.I2C) Device {
+	// turn on internal power pin (machine.P0_22) and I2C1 pullups power pin (machine.P1_00)
+	// and wait a moment.
+	ENV := machine.P0_22
+	ENV.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	ENV.High()
+	R := machine.P1_00
+	R.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	R.High()
+	time.Sleep(time.Millisecond * 10)
+
+	return Device{bus: bus, Address: ADPS9960_ADDRESS, mode: MODE_NONE}
+}

apds9960/registers.go

@@ -0,0 +1,78 @@
+package apds9960
+
+const (
+
+	// I2C address
+	ADPS9960_ADDRESS = 0x39
+
+	// control/status registers
+	APDS9960_RAM_REG        = 0x00
+	APDS9960_ENABLE_REG     = 0x80
+	APDS9960_ATIME_REG      = 0x81
+	APDS9960_WTIME_REG      = 0x83
+	APDS9960_AILTIL_REG     = 0x84
+	APDS9960_AILTH_REG      = 0x85
+	APDS9960_AIHTL_REG      = 0x86
+	APDS9960_AIHTH_REG      = 0x87
+	APDS9960_PILT_REG       = 0x89
+	APDS9960_PIHT_REG       = 0x8B
+	APDS9960_PERS_REG       = 0x8C
+	APDS9960_CONFIG1_REG    = 0x8D
+	APDS9960_PPULSE_REG     = 0x8E
+	APDS9960_CONTROL_REG    = 0x8F
+	APDS9960_CONFIG2_REG    = 0x90
+	APDS9960_ID_REG         = 0x92
+	APDS9960_STATUS_REG     = 0x93
+	APDS9960_CDATAL_REG     = 0x94
+	APDS9960_CDATAH_REG     = 0x95
+	APDS9960_RDATAL_REG     = 0x96
+	APDS9960_RDATAH_REG     = 0x97
+	APDS9960_GDATAL_REG     = 0x98
+	APDS9960_GDATAH_REG     = 0x99
+	APDS9960_BDATAL_REG     = 0x9A
+	APDS9960_BDATAH_REG     = 0x9B
+	APDS9960_PDATA_REG      = 0x9C
+	APDS9960_POFFSET_UR_REG = 0x9D
+	APDS9960_POFFSET_DL_REG = 0x9E
+	APDS9960_CONFIG3_REG    = 0x9F
+	APDS9960_GPENTH_REG     = 0xA0
+	APDS9960_GEXTH_REG      = 0xA1
+	APDS9960_GCONF1_REG     = 0xA2
+	APDS9960_GCONF2_REG     = 0xA3
+	APDS9960_GOFFSET_U_REG  = 0xA4
+	APDS9960_GOFFSET_D_REG  = 0xA5
+	APDS9960_GOFFSET_L_REG  = 0xA7
+	APDS9960_GOFFSET_R_REG  = 0xA9
+	APDS9960_GPULSE_REG     = 0xA6
+	APDS9960_GCONF3_REG     = 0xAA
+	APDS9960_GCONF4_REG     = 0xAB
+	APDS9960_GFLVL_REG      = 0xAE
+	APDS9960_GSTATUS_REG    = 0xAF
+	APDS9960_IFORCE_REG     = 0xE4
+	APDS9960_PICLEAR_REG    = 0xE5
+	APDS9960_CICLEAR_REG    = 0xE6
+	APDS9960_AICLEAR_REG    = 0xE7
+	APDS9960_GFIFO_U_REG    = 0xFC
+	APDS9960_GFIFO_D_REG    = 0xFD
+	APDS9960_GFIFO_L_REG    = 0xFE
+	APDS9960_GFIFO_R_REG    = 0xFF
+)
+
+const (
+
+	// sensor modes
+	MODE_NONE = iota
+	MODE_PROXIMITY
+	MODE_COLOR
+	MODE_GESTURE
+)
+
+const (
+
+	// detected gestures
+	GESTURE_NONE = iota
+	GESTURE_UP
+	GESTURE_DOWN
+	GESTURE_LEFT
+	GESTURE_RIGHT
+)

axp192/axp192.go

@@ -0,0 +1,258 @@
+// Package axp192 provides a driver for the axp192 I2C Enhanced single Cell
+// Li-Battery and Power System Management IC.
+//
+// http://www.x-powers.com/en.php/Info/product_detail/article_id/29
+// Datasheet: https://github.com/m5stack/M5-Schematic/blob/master/Core/AXP192%20Datasheet_v1.1_en_draft_2211.pdf
+//
+package axp192 // import "tinygo.org/x/drivers/axp192"
+
+import (
+	"tinygo.org/x/drivers"
+)
+
+type Error uint8
+
+const (
+	ErrInvalidID Error = 0x1
+)
+
+func (e Error) Error() string {
+	switch e {
+	case ErrInvalidID:
+		return "Invalid chip ID"
+	default:
+		return "Unknown error"
+	}
+}
+
+type Device struct {
+	bus     drivers.I2C
+	buf     []byte
+	Address uint8
+}
+
+// New returns AXP192 device for the provided I2C bus using default address.
+func New(i2c drivers.I2C) *Device {
+	return &Device{
+		bus:     i2c,
+		buf:     make([]byte, 2),
+		Address: Address,
+	}
+}
+
+type Config struct {
+}
+
+// Configure the AXP192 device.
+func (d *Device) Configure(config Config) error {
+	return nil
+}
+
+// ReadPowerSupplyStatus reads power supply status.
+func (d *Device) ReadPowerSupplyStatus() uint8 {
+	return d.read8bit(RegPowerSupplyStatus)
+}
+
+// SetVbusIPSOutAccessManagement sets VBUS-IPSOUT access management.
+func (d *Device) SetVbusIPSOutAccessManagement(a uint8) {
+	d.write1Byte(RegVbusIPSOutAccessManagement, a)
+}
+
+// GetVbusIPSOutAccessManagement gets VBUS-IPSOUT access management.
+func (d *Device) GetVbusIPSOutAccessManagement() uint8 {
+	return d.read8bit(RegVbusIPSOutAccessManagement)
+}
+
+// SetGPIO1Control sets GPIO1 function.
+func (d *Device) SetGPIO1Control(a uint8) {
+	d.write1Byte(RegGPIO1Control, a)
+}
+
+// GetGPIO1Control gets GPIO1 function.
+func (d *Device) GetGPIO1Control() uint8 {
+	return d.read8bit(RegGPIO1Control)
+}
+
+// SetGPIO2Control sets GPIO2 function.
+func (d *Device) SetGPIO2Control(a uint8) {
+	d.write1Byte(RegGPIO2Control, a)
+}
+
+// GetGPIO2Control gets GPIO2 function.
+func (d *Device) GetGPIO2Control() uint8 {
+	return d.read8bit(RegGPIO2Control)
+}
+
+// SetGPIO20SignalStatus sets GPIO[2:0] signal status.
+func (d *Device) SetGPIO20SignalStatus(a uint8) {
+	d.write1Byte(RegGPIO20SignalStatus, a)
+}
+
+// GetGPIO20SignalStatus gets GPIO[2:0] signal status.
+func (d *Device) GetGPIO20SignalStatus() uint8 {
+	return d.read8bit(RegGPIO20SignalStatus)
+}
+
+// SetBackupBatteryChargingControl sets backup battery charge control.
+func (d *Device) SetBackupBatteryChargingControl(a uint8) {
+	d.write1Byte(RegBackupBatteryChargingControl, a)
+}
+
+// GetBackupBatteryChargingControl gets backup battery charge control.
+func (d *Device) GetBackupBatteryChargingControl() uint8 {
+	return d.read8bit(RegBackupBatteryChargingControl)
+}
+
+// SetDCDC1VoltageSet sets DC-DC1 output voltage.
+func (d *Device) SetDCDC1VoltageSet(a uint8) {
+	d.write1Byte(RegDCDC1VoltageSet, a)
+}
+
+// GetDCDC1VoltageSet gets DC-DC1 output voltage.
+func (d *Device) GetDCDC1VoltageSet() uint8 {
+	return d.read8bit(RegDCDC1VoltageSet)
+}
+
+// SetDCDC2VoltageSet sets DC-DC2 dynamic voltage parameter.
+func (d *Device) SetDCDC2VoltageSet(a uint8) {
+	d.write1Byte(RegDCDC2VoltageSet, a)
+}
+
+// GetDCDC2VoltageSet gets DC-DC2 dynamic voltage parameter.
+func (d *Device) GetDCDC2VoltageSet() uint8 {
+	return d.read8bit(RegDCDC2VoltageSet)
+}
+
+// SetDCDC3VoltageSet sets DC-DC3 output voltage.
+func (d *Device) SetDCDC3VoltageSet(a uint8) {
+	d.write1Byte(RegDCDC3VoltageSet, a)
+}
+
+// GetDCDC3VoltageSet gets DC-DC3 output voltage.
+func (d *Device) GetDCDC3VoltageSet() uint8 {
+	return d.read8bit(RegDCDC3VoltageSet)
+}
+
+// SetLDO23VoltageSet sets LDO2/3 output voltage.
+func (d *Device) SetLDO23VoltageSet(a uint8) {
+	d.write1Byte(RegLDO23VoltageSet, a)
+}
+
+// GetLDO23VoltageSet gets LDO2/3 output voltage.
+func (d *Device) GetLDO23VoltageSet() uint8 {
+	return d.read8bit(RegLDO23VoltageSet)
+}
+
+// SetDCDC13LDO23Switch sets DC-DC1/3 & LOD2/3 output control.
+func (d *Device) SetDCDC13LDO23Switch(a uint8) {
+	d.write1Byte(RegDCDC13LDO23Switch, a)
+}
+
+// GetDCDC13LDO23Switch gets DC-DC1/3 & LOD2/3 output control.
+func (d *Device) GetDCDC13LDO23Switch() uint8 {
+	return d.read8bit(RegDCDC13LDO23Switch)
+}
+
+// SetGPIO43FunctionControl sets GPIO[4:3] pin function.
+func (d *Device) SetGPIO43FunctionControl(a uint8) {
+	d.write1Byte(RegGPIO43FunctionControl, a)
+}
+
+// GetGPIO43FunctionControl gets GPIO[4:3] pin function.
+func (d *Device) GetGPIO43FunctionControl() uint8 {
+	return d.read8bit(RegGPIO43FunctionControl)
+}
+
+// SetPEKParameterSet sets PEK press key parameter.
+func (d *Device) SetPEKParameterSet(a uint8) {
+	d.write1Byte(RegPEKParameterSet, a)
+}
+
+// GetPEKParameterSet gets PEK press key parameter.
+func (d *Device) GetPEKParameterSet() uint8 {
+	return d.read8bit(RegPEKParameterSet)
+}
+
+// SetADCEnableSet sets ADC enable 1.
+func (d *Device) SetADCEnableSet(a uint8) {
+	d.write1Byte(RegADCEnableSet, a)
+}
+
+// GetADCEnableSet gets ADC enable 1.
+func (d *Device) GetADCEnableSet() uint8 {
+	return d.read8bit(RegADCEnableSet)
+}
+
+// SetGPIO43SignalStatus sets GPIO[4:3] signal status.
+func (d *Device) SetGPIO43SignalStatus(a uint8) {
+	d.write1Byte(RegGPIO43SignalStatus, a)
+}
+
+// GetGPIO43SignalStatus gets GPIO[4:3] signal status.
+func (d *Device) GetGPIO43SignalStatus() uint8 {
+	return d.read8bit(RegGPIO43SignalStatus)
+}
+
+// SetDCVoltage sets DC voltage.
+func (d *Device) SetDCVoltage(number uint8, voltage uint16) {
+	if voltage < 700 {
+		voltage = 0
+	} else {
+		voltage = (voltage - 700) / 25
+	}
+
+	switch number {
+	case 0:
+		v := d.GetDCDC1VoltageSet()
+		d.SetDCDC1VoltageSet((v & 0x80) | (uint8(voltage) & 0x7F))
+	case 1:
+		v := d.GetDCDC2VoltageSet()
+		d.SetDCDC2VoltageSet((v & 0x80) | (uint8(voltage) & 0x7F))
+	case 2:
+		v := d.GetDCDC3VoltageSet()
+		d.SetDCDC3VoltageSet((v & 0x80) | (uint8(voltage) & 0x7F))
+	}
+}
+
+// SetLDOVoltage sets LDO voltage.
+func (d *Device) SetLDOVoltage(number uint8, voltage uint16) {
+	if voltage > 3300 {
+		voltage = 15
+	} else {
+		voltage = (voltage / 100) - 18
+	}
+
+	switch number {
+	case 2:
+		v := d.GetLDO23VoltageSet()
+		d.SetLDO23VoltageSet((v & 0x0F) | (uint8(voltage) << 4))
+		break
+	case 3:
+		v := d.GetLDO23VoltageSet()
+		d.SetLDO23VoltageSet((v & 0xF0) | uint8(voltage))
+		break
+	}
+}
+
+// SetLDOEnable enable LDO.
+func (d *Device) SetLDOEnable(number uint8, state bool) {
+	mark := uint8(0x01)
+	mark <<= number
+	switch number {
+	case 2:
+		v := d.GetDCDC13LDO23Switch()
+		d.SetDCDC13LDO23Switch(v | mark)
+	case 3:
+		v := d.GetDCDC13LDO23Switch()
+		d.SetDCDC13LDO23Switch(v & (^mark))
+	}
+}
+
+func (d *Device) write1Byte(reg, data uint8) {
+	d.bus.WriteRegister(d.Address, reg, []byte{data})
+}
+
+func (d *Device) read8bit(reg uint8) uint8 {
+	d.bus.ReadRegister(d.Address, reg, d.buf[:1])
+	return d.buf[0]
+}

axp192/m5stack-core2-axp192/axp192.go

@@ -0,0 +1,158 @@
+package axp192
+
+import (
+	"time"
+
+	"tinygo.org/x/drivers"
+	axp192orig "tinygo.org/x/drivers/axp192"
+)
+
+// Device wraps an I2C connection to a AXP192 device.
+type Device struct {
+	*axp192orig.Device
+	LED    Pin
+	RST    Pin
+	SPK_EN Pin
+}
+
+// New creates a new AXP192 connection. The I2C bus must already be
+// configured.
+//
+// This function only creates the Device object, it does not touch the device.
+func New(i2c drivers.I2C) *Device {
+	d := axp192orig.New(i2c)
+
+	axp := &Device{
+		Device: d,
+	}
+	axp.LED = Pin{pin: 1, axp: axp}
+	axp.SPK_EN = Pin{pin: 2, axp: axp}
+	axp.RST = Pin{pin: 4, axp: axp}
+
+	axp.begin()
+
+	return axp
+}
+
+type Config struct {
+}
+
+// Configure sets up the device for communication
+func (d *Device) Configure(config Config) error {
+	return d.Device.Configure(axp192orig.Config{})
+}
+
+func (d *Device) begin() {
+	d.SetVbusIPSOutAccessManagement((d.GetVbusIPSOutAccessManagement() & 0x04) | 0x02)
+	d.SetGPIO1Control(d.GetGPIO1Control() & 0xF8)
+	d.SetGPIO2Control(d.GetGPIO2Control() & 0xF8)
+	d.SetBackupBatteryChargingControl((d.GetBackupBatteryChargingControl() & 0x1C) | 0xA2)
+	d.SetESPVoltage(3350)
+	d.SetLcdVoltage(3300)
+	d.SetLDOVoltage(2, 3300) //Periph power voltage preset (LCD_logic, SD card)
+	d.SetLDOVoltage(3, 2000) //Vibrator power voltage preset
+
+	d.SetLDOEnable(2, true)
+	d.SetDCDC3(true) // LCD Backlight
+	// GPIO4 : LCD Reset
+	d.SetGPIO43FunctionControl((d.GetGPIO43FunctionControl() & 0x72) | 0x84)
+	// Power On/Off Setting
+	d.SetPEKParameterSet(0x4C)
+	d.SetADCEnableSet(0xFF)
+
+	d.RST.Low()
+	time.Sleep(100 * time.Millisecond)
+	d.RST.High()
+	time.Sleep(100 * time.Millisecond)
+}
+
+// ToggleLED toggles LED connected to AXP192.
+func (d *Device) ToggleLED() {
+	v := d.GetGPIO20SignalStatus()
+	if (v & 0x02) > 0 {
+		d.SetGPIO20SignalStatus(v & 0xFD)
+	} else {
+		d.SetGPIO20SignalStatus(v | 0x02)
+	}
+}
+
+// SetESPVoltage sets voltage of ESP32.
+func (d *Device) SetESPVoltage(voltage uint16) {
+	if voltage >= 3000 && voltage <= 3400 {
+		d.SetDCVoltage(0, voltage)
+	}
+}
+
+// SetLcdVoltage sets voltage of LCD.
+func (d *Device) SetLcdVoltage(voltage uint16) {
+	if voltage >= 2500 && voltage <= 3300 {
+		d.SetDCVoltage(2, voltage)
+	}
+}
+
+// SetDCDC3 enables or disables DCDC3.
+func (d *Device) SetDCDC3(State bool) {
+	v := d.GetDCDC13LDO23Switch()
+	if State == true {
+		v = (1 << 1) | v
+	} else {
+		v = ^(uint8(1) << 1) & v
+	}
+	d.SetDCDC13LDO23Switch(v)
+}
+
+// Pin is a single pin on AXP192.
+type Pin struct {
+	pin uint8
+	axp *Device
+}
+
+// High sets this GPIO pin to high.
+func (p Pin) High() {
+	switch p.pin {
+	case 1: // LED
+		v := p.axp.GetGPIO20SignalStatus()
+		p.axp.SetGPIO20SignalStatus(v | 0x02)
+	case 2: // SPK_EN
+	case 4: // RST
+		v := p.axp.GetGPIO43SignalStatus()
+		v |= uint8(0x02)
+		p.axp.SetGPIO43SignalStatus(v)
+	}
+}
+
+// Low sets this GPIO pin to low.
+func (p Pin) Low() {
+	switch p.pin {
+	case 1: // LED
+		v := p.axp.GetGPIO20SignalStatus()
+		p.axp.SetGPIO20SignalStatus(v & 0xFD)
+	case 2: // SPK_EN
+	case 4: // RST
+		v := p.axp.GetGPIO43SignalStatus()
+		v &= ^uint8(0x02)
+		p.axp.SetGPIO43SignalStatus(v)
+	}
+}
+
+// Toggle switches an output pin from low to high or from high to low.
+func (p Pin) Toggle() {
+	switch p.pin {
+	case 1: // LED
+		v := p.axp.GetGPIO20SignalStatus()
+		if (v & 0x02) == 0 {
+			p.axp.SetGPIO20SignalStatus(v | 0x02)
+		} else {
+			p.axp.SetGPIO20SignalStatus(v & 0xFD)
+		}
+	case 2: // SPK_EN
+	case 4: // RST
+		v := p.axp.GetGPIO43SignalStatus()
+		if (v & 0x02) == 0 {
+			v |= uint8(0x02)
+		} else {
+			v &= ^uint8(0x02)
+		}
+		p.axp.SetGPIO43SignalStatus(v)
+	}
+}

axp192/registers.go

@@ -0,0 +1,127 @@
+package axp192
+
+// power supply control class
+// 0x00 Power supply status register
+// 0x01  Power supply mode/charging status register
+// 0x04  OTG VBUS status register
+// 0x06‐09  Data buffer register
+// 0x10  EXTEN & DC‐DC2 switch register
+// 0x12  DC‐DC1/3 & LDO2/3switch register
+// 0x23  DC‐DC2 voltage set register
+// 0x25  DC‐DC2 voltage slope set register
+// 0x26  DC‐DC1voltage set register
+// 0x27  DC‐DC3 voltage set register
+// 0x28  LDO2/3 voltage set register
+// 0x30  VBUS‐IPSOUT access set register
+// 0x31  VOFF power off voltage set register
+// 0x32  Power off、battery detect、CHGLED control register
+// 0x33  Charging control register1
+// 0x34  Charging control register2
+// 0x35  Backup battery charging control register
+// 0x36  PEK parameter set register
+// 0x37  DCDC switch frequency set register
+// 0x38  Battery charging under temperature warning set register
+// 0x39  Battery charging over temperature warning set register
+// 0x3A  APS under voltage Level1 set register
+// 0x3B  APS under voltage Level2 set register
+// 0x3C  Battery discharging under temperature warning set register
+// 0x3D  Battery discharging over temperature warning set register
+// 0x80  DCDC mode set register
+// 0x82  ADC enable set register 1
+// 0x83  ADC enable set register 2
+// 0x84  ADC sample frequency set, TS pin control register
+// 0x85  GPIO [3:0] input range set register
+// 0x8A  Timer control register
+// 0x8B  VBUS monitor set register
+// 0x8F  Over temperature power off control register
+
+// GPIO control class
+// 0x90  GPIO0 control register
+// 0x91  GPIO0 LDO mode output voltage set register
+// 0x92  GPIO1 control register
+// 0x93  GPIO2 control register
+// 0x94  GPIO[2:0] signal status register
+// 0x95  GPIO[4:3] function control register
+// 0x96  GPIO[4:3] signal status register
+// 0x97  GPIO[2:0] pull down control register
+// 0x98  PWM1 frequency set register
+// 0x99  PWM1 duty ratio set register 1
+// 0x9A  PWM1 duty ratio set register 2
+// 0x9B  PWM2 frequency set register
+// 0x9C  PWM2 duty ratio set register 1
+// 0x9D  PWM2 duty ratio set register 2
+// 0x9E  GPIO5 control register
+
+// IRQ control class
+// 0x40  IRQ enable control register 1
+// 0x41  IRQ enable control register 2
+// 0x42  IRQ enable control register 3
+// 0x43  IRQ enable control register 4
+// 0x44  IRQ status register 1
+// 0x45  IRQ status register 2
+// 0x46  IRQ status register 3
+// 0x47  IRQ status register 4
+
+// ADC data class
+// 0x56  ACIN voltage ADC data high 8 bit
+// 0x57  ACIN voltage ADC data low 4 bit
+// 0x58  ACIN current ADC data high 8 bit
+// 0x59  ACIN current ADC data low 4 bit
+// 0x5A  VBUS voltage ADC data high 8 bit
+// 0x5B  VBUS voltage ADC data low 4 bit
+// 0x5C  VBUS current ADC data high 8 bit
+// 0x5D  VBUS current ADC data low 4 bit
+// 0x5E  AXP192 internal temperature monitor ADC data High 8 bit
+// 0x5F  AXP192 internal temperature monitor ADC data low 4 bit
+// 0x62  TS input ADC data High 8 bit，monitor battery temperature by default
+// 0x63  TS input ADC data low 4 bit，monitor battery temperature by default
+// 0x64  GPIO0 voltage ADC data high 8 bit
+// 0x65  GPIO0 voltage ADC data low 4 bit
+// 0x66  GPIO1 voltage ADC data high 8 bit
+// 0x67  GPIO1 voltage ADC data low 4 bit
+// 0x68  GPIO2 voltage ADC data high 8 bit
+// 0x69  GPIO2 voltage ADC data low 4 bit
+// 0x6A  GPIO[3] voltage ADC data high 8 bit
+// 0x6B  GPIO[3] voltage ADC data low 4 bit
+// 0x70  Battery instantaneous power high 8 bit
+// 0x71  Battery instantaneous power middle 8 bit
+// 0x72  Battery instantaneous power low 8 bit
+// 0x78  Battery voltage high 8 bit
+// 0x79  Battery voltage low 4 bit
+// 0x7A  Battery charging current high 8 bit
+// 0x7B  Battery charging current low 5 bit
+// 0x7C  Battery discharging current high 8 bit
+// 0x7D  Battery discharging current low 5 bit
+// 0x7E  APS voltage high 8 bit
+// 0x7F  APS voltage low 4 bit
+// 0xB0  Battery charging coulomb counter data register 3
+// 0xB1  Battery charging coulomb counter data register 2
+// 0xB2  Battery charging coulomb counter data register 1
+// 0xB3  Battery charging coulomb counter data register 0
+// 0xB4  Battery discharging coulomb counter data register 3
+// 0xB5  Battery discharging coulomb counter data register 2
+// 0xB6  Battery discharging coulomb counter data register 1
+// 0xB7  Battery discharging coulomb counter data register 0
+// 0xB8  Coulomb counter control register
+
+const (
+	// Address is default I2C address.
+	Address = 0x34
+
+	RegPowerSupplyStatus            = 0x00
+	RegDCDC13LDO23Switch            = 0x12
+	RegVbusIPSOutAccessManagement   = 0x30
+	RegBackupBatteryChargingControl = 0x35
+	RegDCDC2VoltageSet              = 0x25
+	RegDCDC1VoltageSet              = 0x26
+	RegDCDC3VoltageSet              = 0x27
+	RegLDO23VoltageSet              = 0x28
+	RegPEKParameterSet              = 0x36
+	RegADCEnableSet                 = 0x82
+
+	RegGPIO1Control          = 0x92
+	RegGPIO2Control          = 0x93
+	RegGPIO20SignalStatus    = 0x94
+	RegGPIO43FunctionControl = 0x95
+	RegGPIO43SignalStatus    = 0x96
+)

cmd/convert2bin/convert2bin.go

@@ -0,0 +1,49 @@
+package main
+
+import (
+	"fmt"
+	"io/ioutil"
+	"log"
+	"os"
+	"strings"
+)
+
+// See ../../image/README.md for the usage.
+
+func main() {
+	err := run(os.Args)
+	if err != nil {
+		log.Fatal(err)
+	}
+}
+
+func run(args []string) error {
+	if len(args) < 2 {
+		return fmt.Errorf("usage: %s FILE")
+	}
+
+	b, err := ioutil.ReadFile(args[1])
+	if err != nil {
+		return err
+	}
+
+	fmt.Printf("const %s = \"\" +\n", strings.Replace(args[1], ".", "_", -1))
+
+	i := 0
+	max := 32
+	for i = 0; i < len(b); i++ {
+		bb := b[i]
+		if (i % max) == 0 {
+			fmt.Printf("	\"")
+		}
+		fmt.Printf("\\x%02X", bb)
+		if (i%max) == max-1 && i != len(b)-1 {
+			fmt.Printf("\" + \n")
+		}
+	}
+	if (i % max) < max-1 {
+		fmt.Printf("\"\n")
+	}
+
+	return nil
+}

dht/highfreq.go

@@ -1,4 +1,5 @@
-// +build mimxrt1062  stm32f405  atsamd51  stm32f103xx  k210  stm32f407
+//go:build mimxrt1062 || stm32f405 || atsamd51 || stm32f103xx || k210 || stm32f407
+// +build mimxrt1062 stm32f405 atsamd51 stm32f103xx k210 stm32f407
 
 package dht // import "tinygo.org/x/drivers/dht"
 

dht/lowfreq.go

@@ -1,4 +1,5 @@
-// +build arduino atmega1284p nrf52840 digispark nrf52 arduino_nano nrf51 atsamd21 fe310 arduino_nano33 circuitplay_express arduino_mega2560
+//go:build !mimxrt1062 && !stm32f405 && !atsamd51 && !stm32f103xx && !k210 && !stm32f407
+// +build !mimxrt1062,!stm32f405,!atsamd51,!stm32f103xx,!k210,!stm32f407
 
 package dht // import "tinygo.org/x/drivers/dht"
 

examples/apds9960/color/main.go

@@ -0,0 +1,38 @@
+package main
+
+import (
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/apds9960"
+)
+
+func main() {
+
+	machine.I2C1.Configure(machine.I2CConfig{
+		SCL:       machine.P0_15, // SCL1 on Nano 33 BLE Sense
+		SDA:       machine.P0_14, // SDA1 on Nano 33 BLE Sense
+		Frequency: machine.TWI_FREQ_400KHZ,
+	})
+
+	sensor := apds9960.New(machine.I2C1)
+
+	if !sensor.Connected() {
+		println("APDS-9960 not connected!")
+		return
+	}
+
+	sensor.Configure(apds9960.Configuration{}) // use default settings
+
+	sensor.EnableColor() // enable color engine
+
+	for {
+
+		if sensor.ColorAvailable() {
+			r, g, b, c := sensor.ReadColor()
+			println("Red =", r, "\tGreen =", g, "\tBlue =", b, "\tClear =", c)
+		}
+		time.Sleep(time.Millisecond * 100)
+	}
+
+}

examples/apds9960/gesture/main.go

@@ -0,0 +1,51 @@
+package main
+
+import (
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/apds9960"
+)
+
+func main() {
+
+	machine.I2C1.Configure(machine.I2CConfig{
+		SCL:       machine.P0_15, // SCL1 on Nano 33 BLE Sense
+		SDA:       machine.P0_14, // SDA1 on Nano 33 BLE Sense
+		Frequency: machine.TWI_FREQ_400KHZ,
+	})
+
+	sensor := apds9960.New(machine.I2C1)
+
+	if !sensor.Connected() {
+		println("APDS-9960 not connected!")
+		return
+	}
+
+	sensor.Configure(apds9960.Configuration{}) // use default settings
+
+	sensor.EnableGesture() // enable gesture engine
+
+	for {
+
+		// wave your hand (not too slow) about 10 cm above the sensor
+		if sensor.GestureAvailable() {
+
+			gesture := sensor.ReadGesture()
+			print("Detected gesture: ")
+			switch gesture {
+			case apds9960.GESTURE_UP:
+				println("Up")
+			case apds9960.GESTURE_DOWN:
+				println("Down")
+			case apds9960.GESTURE_LEFT:
+				println("Left")
+			case apds9960.GESTURE_RIGHT:
+				println("Right")
+			}
+		}
+		// note: the delay shouldn't be too long, otherwise new gesture data might be lost
+		time.Sleep(time.Millisecond * 250)
+	}
+
+}

examples/apds9960/proximity/main.go

@@ -0,0 +1,38 @@
+package main
+
+import (
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/apds9960"
+)
+
+func main() {
+
+	machine.I2C1.Configure(machine.I2CConfig{
+		SCL:       machine.P0_15, // SCL1 on Nano 33 BLE Sense
+		SDA:       machine.P0_14, // SDA1 on Nano 33 BLE Sense
+		Frequency: machine.TWI_FREQ_400KHZ,
+	})
+
+	sensor := apds9960.New(machine.I2C1)
+
+	if !sensor.Connected() {
+		println("APDS-9960 not connected!")
+		return
+	}
+
+	sensor.Configure(apds9960.Configuration{}) // use default settings
+
+	sensor.EnableProximity() // enable proximity engine
+
+	for {
+
+		if sensor.ProximityAvailable() {
+			p := sensor.ReadProximity()
+			println("Proximity:", p)
+		}
+		time.Sleep(time.Millisecond * 100)
+	}
+
+}

examples/axp192/m5stack-core2-blinky/main.go

@@ -0,0 +1,25 @@
+package main
+
+import (
+	"machine"
+	"time"
+
+	axp192 "tinygo.org/x/drivers/axp192/m5stack-core2-axp192"
+	"tinygo.org/x/drivers/i2csoft"
+)
+
+func main() {
+	i2c := i2csoft.New(machine.SCL0_PIN, machine.SDA0_PIN)
+	i2c.Configure(i2csoft.I2CConfig{Frequency: 100e3})
+
+	axp := axp192.New(i2c)
+	led := axp.LED
+
+	for {
+		led.Low()
+		time.Sleep(time.Millisecond * 500)
+
+		led.High()
+		time.Sleep(time.Millisecond * 500)
+	}
+}

examples/hts221/main.go

@@ -0,0 +1,36 @@
+package main
+
+import (
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/hts221"
+)
+
+func main() {
+
+	machine.I2C1.Configure(machine.I2CConfig{
+		SCL:       machine.P0_15, // SCL1 on Nano 33 BLE Sense
+		SDA:       machine.P0_14, // SDA1 on Nano 33 BLE Sense
+		Frequency: machine.TWI_FREQ_400KHZ,
+	})
+
+	sensor := hts221.New(machine.I2C1)
+
+	if !sensor.Connected() {
+		println("HTS221 not connected!")
+		return
+	}
+
+	sensor.Configure() // power on and calibrate
+
+	for {
+
+		h, _ := sensor.ReadHumidity()
+		t, _ := sensor.ReadTemperature()
+		println("h =", float32(h)/100.0, "% / t =", float32(t)/1000.0, "*C")
+		time.Sleep(time.Second)
+
+	}
+
+}

examples/i2csoft/adt7410/main.go

@@ -0,0 +1,27 @@
+package main
+
+import (
+	"fmt"
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/adt7410"
+	"tinygo.org/x/drivers/i2csoft"
+)
+
+func main() {
+	i2c := i2csoft.New(machine.SCL_PIN, machine.SDA_PIN)
+	i2c.Configure(i2csoft.I2CConfig{
+		Frequency: 400e3,
+	})
+
+	sensor := adt7410.New(i2c)
+	sensor.Configure()
+
+	for {
+		temp := sensor.ReadTempF()
+		fmt.Printf("temperature: %f\r\n", temp)
+		time.Sleep(time.Second)
+	}
+
+}

examples/ili9341/basic/atsamd21.go

@@ -1,29 +0,0 @@
-// +build atsamd21
-
-package main
-
-import (
-	"machine"
-
-	"tinygo.org/x/drivers/ili9341"
-)
-
-var (
-	display = ili9341.NewSPI(
-		machine.SPI0,
-		machine.D0,
-		machine.D1,
-		machine.D2,
-	)
-
-	backlight = machine.D3
-)
-
-func init() {
-	machine.SPI0.Configure(machine.SPIConfig{
-		SCK:       machine.SPI0_SCK_PIN,
-		SDO:       machine.SPI0_SDO_PIN,
-		SDI:       machine.SPI0_SDI_PIN,
-		Frequency: 24000000,
-	})
-}

examples/ili9341/basic/main.go

@@ -2,9 +2,9 @@ package main
 
 import (
 	"image/color"
-	"machine"
 	"time"
 
+	"tinygo.org/x/drivers/examples/ili9341/initdisplay"
 	"tinygo.org/x/drivers/ili9341"
 )
 
@@ -16,16 +16,15 @@ var (
 	green = color.RGBA{0, 255, 0, 255}
 )
 
+var (
+	display *ili9341.Device
+)
+
 func main() {
+	display = initdisplay.InitDisplay()
 
-	backlight.Configure(machine.PinConfig{machine.PinOutput})
-
-	display.Configure(ili9341.Config{})
 	width, height := display.Size()
 
-	display.FillScreen(black)
-	backlight.High()
-
 	display.FillRectangle(0, 0, width/2, height/2, white)
 	display.FillRectangle(width/2, 0, width/2, height/2, red)
 	display.FillRectangle(0, height/2, width/2, height/2, green)

examples/ili9341/basic/pyportal.go

@@ -1,22 +0,0 @@
-// +build pyportal
-
-package main
-
-import (
-	"machine"
-
-	"tinygo.org/x/drivers/ili9341"
-)
-
-var (
-	display = ili9341.NewParallel(
-		machine.LCD_DATA0,
-		machine.TFT_WR,
-		machine.TFT_DC,
-		machine.TFT_CS,
-		machine.TFT_RESET,
-		machine.TFT_RD,
-	)
-
-	backlight = machine.TFT_BACKLIGHT
-)

examples/ili9341/basic/wioterminal.go

@@ -1,29 +0,0 @@
-// +build wioterminal
-
-package main
-
-import (
-	"machine"
-
-	"tinygo.org/x/drivers/ili9341"
-)
-
-var (
-	display = ili9341.NewSPI(
-		machine.SPI3,
-		machine.LCD_DC,
-		machine.LCD_SS_PIN,
-		machine.LCD_RESET,
-	)
-
-	backlight = machine.LCD_BACKLIGHT
-)
-
-func init() {
-	machine.SPI3.Configure(machine.SPIConfig{
-		SCK:       machine.LCD_SCK_PIN,
-		SDO:       machine.LCD_SDO_PIN,
-		SDI:       machine.LCD_SDI_PIN,
-		Frequency: 40000000,
-	})
-}

examples/ili9341/initdisplay/atsamd21.go

@@ -0,0 +1,41 @@
+//go:build atsamd21
+// +build atsamd21
+
+package initdisplay
+
+import (
+	"machine"
+
+	"tinygo.org/x/drivers/ili9341"
+)
+
+var ()
+
+func InitDisplay() *ili9341.Device {
+	machine.SPI0.Configure(machine.SPIConfig{
+		SCK:       machine.SPI0_SCK_PIN,
+		SDO:       machine.SPI0_SDO_PIN,
+		SDI:       machine.SPI0_SDI_PIN,
+		Frequency: 24000000,
+	})
+
+	// configure backlight
+	backlight := machine.D3
+	backlight.Configure(machine.PinConfig{machine.PinOutput})
+
+	display := ili9341.NewSPI(
+		machine.SPI0,
+		machine.D0,
+		machine.D1,
+		machine.D2,
+	)
+
+	// configure display
+	display.Configure(ili9341.Config{})
+
+	backlight.High()
+
+	display.SetRotation(ili9341.Rotation270)
+
+	return display
+}

examples/ili9341/initdisplay/pyportal.go

@@ -0,0 +1,34 @@
+//go:build pyportal
+// +build pyportal
+
+package initdisplay
+
+import (
+	"machine"
+
+	"tinygo.org/x/drivers/ili9341"
+)
+
+func InitDisplay() *ili9341.Device {
+	display := ili9341.NewParallel(
+		machine.LCD_DATA0,
+		machine.TFT_WR,
+		machine.TFT_DC,
+		machine.TFT_CS,
+		machine.TFT_RESET,
+		machine.TFT_RD,
+	)
+
+	// configure backlight
+	backlight := machine.TFT_BACKLIGHT
+	backlight.Configure(machine.PinConfig{machine.PinOutput})
+
+	// configure display
+	display.Configure(ili9341.Config{})
+
+	backlight.High()
+
+	display.SetRotation(ili9341.Rotation270)
+
+	return display
+}

examples/ili9341/initdisplay/wioterminal.go

@@ -0,0 +1,39 @@
+//go:build wioterminal
+// +build wioterminal
+
+package initdisplay
+
+import (
+	"machine"
+
+	"tinygo.org/x/drivers/ili9341"
+)
+
+func InitDisplay() *ili9341.Device {
+	machine.SPI3.Configure(machine.SPIConfig{
+		SCK:       machine.LCD_SCK_PIN,
+		SDO:       machine.LCD_SDO_PIN,
+		SDI:       machine.LCD_SDI_PIN,
+		Frequency: 40000000,
+	})
+
+	// configure backlight
+	backlight := machine.LCD_BACKLIGHT
+	backlight.Configure(machine.PinConfig{machine.PinOutput})
+
+	display := ili9341.NewSPI(
+		machine.SPI3,
+		machine.LCD_DC,
+		machine.LCD_SS_PIN,
+		machine.LCD_RESET,
+	)
+
+	// configure display
+	display.Configure(ili9341.Config{})
+
+	backlight.High()
+
+	display.SetRotation(ili9341.Rotation270)
+
+	return display
+}

examples/ili9341/pyportal_boing/main.go

@@ -3,32 +3,13 @@
 package main
 
 import (
-	"machine"
 	"time"
 
+	"tinygo.org/x/drivers/examples/ili9341/initdisplay"
 	"tinygo.org/x/drivers/examples/ili9341/pyportal_boing/graphics"
 	"tinygo.org/x/drivers/ili9341"
 )
 
-const (
-	BALLWIDTH  = 136
-	BALLHEIGHT = 100
-)
-
-const (
-	SCREENHEIGHT = 240
-	SCREENWIDTH  = 320
-)
-
-const (
-	invBGCOLOR    = 0x75AD
-	invGRIDCOLOR  = 0x15A8
-	invBGSHADOW   = 0x8552
-	invGRIDSHADOW = 0x0C60
-	invRED        = 0x00F8
-	invWHITE      = 0xFFFF
-)
-
 const (
 	BGCOLOR    = 0xAD75
 	GRIDCOLOR  = 0xA815
@@ -44,12 +25,7 @@ const (
 )
 
 var (
-	dbg5 = machine.D5
-	dbg6 = machine.D6
-)
-
-var (
-	frameBuffer = [2][(BALLHEIGHT + 8) * (BALLWIDTH + 8)]uint16{}
+	frameBuffer = [(graphics.BALLHEIGHT + 8) * (graphics.BALLWIDTH + 8) * 2]uint8{}
 
 	startTime int64
 	frame     int64
@@ -68,20 +44,17 @@ var (
 	palette [16]uint16
 )
 
+var (
+	display *ili9341.Device
+)
+
 func main() {
+	display = initdisplay.InitDisplay()
 
-	// configure backlight
-	backlight.Configure(machine.PinConfig{machine.PinOutput})
-
-	// configure display
-	display.Configure(ili9341.Config{})
 	print("width, height == ")
 	width, height := display.Size()
 	println(width, height)
 
-	backlight.High()
-
-	display.SetRotation(ili9341.Rotation270)
 	DrawBackground()
 
 	startTime = time.Now().UnixNano()
@@ -95,18 +68,14 @@ func main() {
 	balloldx = ballx
 	balloldy = bally // Prior ball position
 
-	var bufIdx int8 = 0
-
 	for {
-		dbg5.High()
-		bufIdx = 1 - bufIdx
 
 		balloldx = ballx // Save prior position
 		balloldy = bally
 		ballx += ballvx // Update position
 		bally += ballvy
 		ballvy += 0.06 // Update Y velocity
-		if (ballx <= 15) || (ballx >= SCREENWIDTH-BALLWIDTH) {
+		if (ballx <= 15) || (ballx >= graphics.SCREENWIDTH-graphics.BALLWIDTH) {
 			ballvx *= -1 // Left/right bounce
 		}
 		if bally >= YBOTTOM { // Hit ground?
@@ -128,13 +97,13 @@ func main() {
 		if int16(balloldy) < miny {
 			miny = int16(balloldy)
 		}
-		maxx = int16(ballx + BALLWIDTH - 1)
-		if int16(balloldx+BALLWIDTH-1) > maxx {
-			maxx = int16(balloldx + BALLWIDTH - 1)
+		maxx = int16(ballx + graphics.BALLWIDTH - 1)
+		if int16(balloldx+graphics.BALLWIDTH-1) > maxx {
+			maxx = int16(balloldx + graphics.BALLWIDTH - 1)
 		}
-		maxy = int16(bally + BALLHEIGHT - 1)
-		if int16(balloldy+BALLHEIGHT-1) > maxy {
-			maxy = int16(balloldy + BALLHEIGHT - 1)
+		maxy = int16(bally + graphics.BALLHEIGHT - 1)
+		if int16(balloldy+graphics.BALLHEIGHT-1) > maxy {
+			maxy = int16(balloldy + graphics.BALLHEIGHT - 1)
 		}
 
 		width = maxx - minx + 1
@@ -148,13 +117,13 @@ func main() {
 			ballframe -= 14
 		}
 
-		//// Set 7 palette entries to white, 7 to red, based on frame number.
-		//// This makes the ball spin
+		// Set 7 palette entries to white, 7 to red, based on frame number.
+		// This makes the ball spin
 		for i := 0; i < 14; i++ {
 			if (int(ballframe)+i)%14 < 7 {
-				palette[i+2] = invWHITE
+				palette[i+2] = WHITE
 			} else {
-				palette[i+2] = invRED
+				palette[i+2] = RED
 			} // Palette entries 0 and 1 aren't used (clear and shadow, respectively)
 		}
 
@@ -164,100 +133,62 @@ func main() {
 		by := miny - int16(bally) // Y relative to ball bitmap (can be negative)
 		bgx := minx               // X relative to background bitmap (>= 0)
 		bgy := miny               // Y relative to background bitmap (>= 0)
-		//var bufIdx int8 = 0
+		var bx1, bgx1 int16       // Loop counters and working vars
+		var p uint8               // 'packed' value of 2 ball pixels
+		var bufIdx int8 = 0
 
 		//tft.setAddrWindow(minx, miny, width, height)
-		dbg5.Low()
-		dbg6.High()
-		//fmt.Printf("%d < %d < %d < %d\r\n", by, 0, BALLHEIGHT, height)
 
-		y := 0
-		if by < 0 {
-			max := -1 * int(by)
-			for y = 0; y < max; y++ { // For each row...
-				var bgidxBase = int(bgy)*(SCREENWIDTH) + int(bgx)
-				var yBase = y * int(width)
-				for x := 0; x < int(width); x++ {
-					frameBuffer[bufIdx][yBase+x] = graphics.Background[bgidxBase+x]
-				}
-				bgy++
-			}
-		}
-
-		y2 := y
-		max := 0
-		if bx < 0 {
-			max = -1 * int(bx)
-			bgy2 := bgy
-			for y = y2; y < y2+int(BALLHEIGHT); y++ { // For each row...
-				var bgidxBase = int(bgy2)*(SCREENWIDTH) + int(bgx)
-				var yBase = y * int(width)
-				//fmt.Printf("- %d %d %d %d %d %d\r\n", bgy, y, bgx, max, yBase, bgidxBase)
-				for x := 0; x < int(max); x++ {
-					//fmt.Printf("  %d %d\r\n", yBase+x, bgidxBase+x)
-					frameBuffer[bufIdx][yBase+x] = graphics.Background[bgidxBase+x]
-				}
-				bgy2++
-			}
-			//fmt.Printf("(%d, %d) - (%d, %d)\r\n", bx, 0, -1, BALLHEIGHT-1)
-		}
-
-		{
-			bgy2 := bgy
-			//fmt.Printf("(%d, %d) - (%d, %d)\r\n", 0, 0, BALLWIDTH-1, BALLHEIGHT-1)
-			for y = y2; y < y2+int(BALLHEIGHT); y++ { // For each row...
-				var bgidxBase = int(bgy2)*(SCREENWIDTH) + int(bgx)
-				var byBase = (y - y2) * BALLWIDTH
-				var yBase = y * int(width)
-				for x := max; x < int(BALLWIDTH)+max; x++ {
-					//fmt.Printf("%d %d %d %d\r\n", byBase, x, bgidxBase, yBase)
-					//time.Sleep(1 * time.Millisecond)
+		for y := 0; y < int(height); y++ { // For each row...
+			//destPtr = &renderbuf[bufIdx][0];
+			bx1 = bx   // Need to keep the original bx and bgx values,
+			bgx1 = bgx // so copies of them are made here (and changed in loop below)
+			for x := 0; x < int(width); x++ {
+				var bgidx = int(bgy)*(graphics.SCREENWIDTH/8) + int(bgx1/8)
+				if (bx1 >= 0) && (bx1 < graphics.BALLWIDTH) && // Is current pixel row/column
+					(by >= 0) && (by < graphics.BALLHEIGHT) { // inside the ball bitmap area?
 					// Yes, do ball compositing math...
-					c = uint16(graphics.Ball[int(byBase)+x-max]) // Get packed value (2 pixels)
-
+					p = graphics.Ball[int(by*(graphics.BALLWIDTH/2))+int(bx1/2)] // Get packed value (2 pixels)
+					if (bx1 & 1) != 0 {
+						c = uint16(p & 0xF)
+					} else {
+						c = uint16(p >> 4)
+					} // Unpack high or low nybble
 					if c == 0 { // Outside ball - just draw grid
-						c = graphics.Background[bgidxBase+x]
+						if graphics.Background[bgidx]&(0x80>>(bgx1&7)) != 0 {
+							c = GRIDCOLOR
+						} else {
+							c = BGCOLOR
+						}
 					} else if c > 1 { // In ball area...
 						c = palette[c]
 					} else { // In shadow area...
-						c = graphics.BackgroundShadow[bgidxBase+x]
+						if graphics.Background[bgidx]&(0x80>>(bgx1&7)) != 0 {
+							c = GRIDSHADOW
+						} else {
+							c = BGSHADOW
+						}
+					}
+				} else { // Outside ball bitmap, just draw background bitmap...
+					if graphics.Background[bgidx]&(0x80>>(bgx1&7)) != 0 {
+						c = GRIDCOLOR
+					} else {
+						c = BGCOLOR
 					}
-					frameBuffer[bufIdx][yBase+x] = c
 				}
-				bgy2++
+				frameBuffer[(y*int(width)+x)*2] = byte(c >> 8)
+				frameBuffer[(y*int(width)+x)*2+1] = byte(c)
+				bx1++ // Increment bitmap position counters (X axis)
+				bgx1++
 			}
+			//tft.dmaWait(); // Wait for prior line to complete
+			//tft.writePixels(&renderbuf[bufIdx][0], width, false); // Non-blocking write
+			bufIdx = 1 - bufIdx
+			by++ // Increment bitmap position counters (Y axis)
+			bgy++
 		}
 
-		{
-			bgy2 := bgy
-			for y = y2; y < y2+int(BALLHEIGHT); y++ { // For each row...
-				var bgidxBase = int(bgy2)*(SCREENWIDTH) + int(bgx)
-				var yBase = y * int(width)
-				//fmt.Printf("+ %d %d %d %d %d\r\n", bgy, y, bgx, yBase, bgidxBase)
-				for x := int(BALLWIDTH) + max; x < int(width); x++ {
-					frameBuffer[bufIdx][yBase+x] = graphics.Background[bgidxBase+x]
-				}
-				bgy2++
-			}
-		}
-
-		y = y2 + int(BALLHEIGHT)
-		bgy += BALLHEIGHT
-		{
-			for ; y < int(height); y++ { // For each row...
-				//destPtr = &renderbuf[bufIdx][0];
-				var bgidxBase = int(bgy)*(SCREENWIDTH) + int(bgx)
-				var yBase = y * int(width)
-				for x := 0; x < int(width); x++ {
-					frameBuffer[bufIdx][yBase+x] = graphics.Background[bgidxBase+x]
-				}
-				bgy++
-			}
-		}
-		dbg6.Low()
-
-		display.DrawRGBBitmap(minx, miny, frameBuffer[bufIdx][:width*height], width, height)
-		//time.Sleep(10 * time.Millisecond)
+		display.DrawRGBBitmap8(minx, miny, frameBuffer[:width*height*2], width, height)
 
 		// Show approximate frame rate
 		frame++
@@ -272,13 +203,23 @@ func main() {
 
 func DrawBackground() {
 	w, h := display.Size()
-	var bufIdx int8 = 0
-	for j := 0; j < int(h); j++ {
-		bufIdx = 1 - bufIdx
-		for k := 0; k < int(w); k++ {
-			frameBuffer[bufIdx][k] = graphics.Background[j*int(w)+k]
+	byteWidth := (w + 7) / 8 // Bitmap scanline pad = whole byte
+	var b uint8
+	for j := int16(0); j < h; j++ {
+		for k := int16(0); k < w; k++ {
+			if k&7 > 0 {
+				b <<= 1
+			} else {
+				b = graphics.Background[j*byteWidth+k/8]
+			}
+			if b&0x80 == 0 {
+				frameBuffer[2*k] = byte(BGCOLOR >> 8)
+				frameBuffer[2*k+1] = byte(BGCOLOR & 0xFF)
+			} else {
+				frameBuffer[2*k] = byte(GRIDCOLOR >> 8)
+				frameBuffer[2*k+1] = byte(GRIDCOLOR & 0xFF)
+			}
 		}
-		display.DrawRGBBitmap(0, int16(j), frameBuffer[bufIdx][0:w], w, 1)
-		time.Sleep(1 * time.Millisecond)
+		display.DrawRGBBitmap8(0, j, frameBuffer[0:w*2], w, 1)
 	}
 }

examples/ili9341/pyportal_boing/pyportal.go

@@ -1,22 +0,0 @@
-// +build pyportal
-
-package main
-
-import (
-	"machine"
-
-	"tinygo.org/x/drivers/ili9341"
-)
-
-var (
-	display = ili9341.NewParallel(
-		machine.LCD_DATA0,
-		machine.TFT_WR,
-		machine.TFT_DC,
-		machine.TFT_CS,
-		machine.TFT_RESET,
-		machine.TFT_RD,
-	)
-
-	backlight = machine.TFT_BACKLIGHT
-)

examples/ili9341/pyportal_boing/wioterminal.go

@@ -1,29 +0,0 @@
-// +build wioterminal
-
-package main
-
-import (
-	"machine"
-
-	"tinygo.org/x/drivers/ili9341"
-)
-
-var (
-	display = ili9341.NewSPI(
-		machine.SPI3,
-		machine.LCD_DC,
-		machine.LCD_SS_PIN,
-		machine.LCD_RESET,
-	)
-
-	backlight = machine.LCD_BACKLIGHT
-)
-
-func init() {
-	machine.SPI3.Configure(machine.SPIConfig{
-		SCK:       machine.LCD_SCK_PIN,
-		SDO:       machine.LCD_SDO_PIN,
-		SDI:       machine.LCD_SDI_PIN,
-		Frequency: 40000000,
-	})
-}

examples/ili9341/scroll/atsamd21.go

@@ -1,29 +0,0 @@
-// +build atsamd21
-
-package main
-
-import (
-	"machine"
-
-	"tinygo.org/x/drivers/ili9341"
-)
-
-var (
-	display = ili9341.NewSPI(
-		machine.SPI0,
-		machine.D0,
-		machine.D1,
-		machine.D2,
-	)
-
-	backlight = machine.D3
-)
-
-func init() {
-	machine.SPI0.Configure(machine.SPIConfig{
-		SCK:       machine.SPI0_SCK_PIN,
-		SDO:       machine.SPI0_SDO_PIN,
-		SDI:       machine.SPI0_SDI_PIN,
-		Frequency: 24000000,
-	})
-}

examples/ili9341/scroll/main.go

@@ -2,9 +2,9 @@ package main
 
 import (
 	"image/color"
-	"machine"
 	"time"
 
+	"tinygo.org/x/drivers/examples/ili9341/initdisplay"
 	"tinygo.org/x/drivers/ili9341"
 )
 
@@ -16,16 +16,15 @@ var (
 	white = color.RGBA{255, 255, 255, 255}
 )
 
+var (
+	display *ili9341.Device
+)
+
 func main() {
+	display := initdisplay.InitDisplay()
 
-	backlight.Configure(machine.PinConfig{machine.PinOutput})
-
-	display.Configure(ili9341.Config{})
 	width, height := display.Size()
 
-	display.FillScreen(black)
-	backlight.High()
-
 	display.FillRectangle(0, 0, width/2, height/2, white)
 	display.FillRectangle(width/2, 0, width/2, height/2, red)
 	display.FillRectangle(0, height/2, width/2, height/2, green)

examples/ili9341/scroll/pyportal.go

@@ -1,22 +0,0 @@
-// +build pyportal
-
-package main
-
-import (
-	"machine"
-
-	"tinygo.org/x/drivers/ili9341"
-)
-
-var (
-	display = ili9341.NewParallel(
-		machine.LCD_DATA0,
-		machine.TFT_WR,
-		machine.TFT_DC,
-		machine.TFT_CS,
-		machine.TFT_RESET,
-		machine.TFT_RD,
-	)
-
-	backlight = machine.TFT_BACKLIGHT
-)

examples/ili9341/scroll/wioterminal.go

@@ -1,29 +0,0 @@
-// +build wioterminal
-
-package main
-
-import (
-	"machine"
-
-	"tinygo.org/x/drivers/ili9341"
-)
-
-var (
-	display = ili9341.NewSPI(
-		machine.SPI3,
-		machine.LCD_DC,
-		machine.LCD_SS_PIN,
-		machine.LCD_RESET,
-	)
-
-	backlight = machine.LCD_BACKLIGHT
-)
-
-func init() {
-	machine.SPI3.Configure(machine.SPIConfig{
-		SCK:       machine.LCD_SCK_PIN,
-		SDO:       machine.LCD_SDO_PIN,
-		SDI:       machine.LCD_SDI_PIN,
-		Frequency: 40000000,
-	})
-}

examples/ili9341/slideshow/README.md

@@ -0,0 +1,18 @@
+# examples/ili9341/slideshow
+
+![](./slideshow.jpg)
+
+This example uses the image package for TinyGo to display png and jpeg images.  
+
+## How to create an image
+
+The following program will output an image binary like the one in [images.go](./images.go).  
+
+```
+go run ./examples/ili9341/slideshow/convert2bin ./path/to/png_or_jpg.png
+```
+
+## Notes
+
+Displaying a 320x240 png or jpeg often requires more than 50KB of memory.  
+The examples include samd21 settings, but if you run them as is, you will get a memory size error.  

examples/ili9341/slideshow/main.go

@@ -0,0 +1,95 @@
+package main
+
+import (
+	"fmt"
+	"image/color"
+	"strings"
+	"time"
+
+	"tinygo.org/x/drivers/examples/ili9341/initdisplay"
+	"tinygo.org/x/drivers/ili9341"
+	"tinygo.org/x/drivers/image/jpeg"
+	"tinygo.org/x/drivers/image/png"
+)
+
+var (
+	black = color.RGBA{0, 0, 0, 255}
+	white = color.RGBA{255, 255, 255, 255}
+	red   = color.RGBA{255, 0, 0, 255}
+	blue  = color.RGBA{0, 0, 255, 255}
+	green = color.RGBA{0, 255, 0, 255}
+)
+
+var (
+	display *ili9341.Device
+)
+
+func main() {
+	err := run()
+	for err != nil {
+		errorMessage(err)
+	}
+}
+
+func run() error {
+	display = initdisplay.InitDisplay()
+
+	width, height := display.Size()
+	if width < 320 || height < 240 {
+		display.SetRotation(ili9341.Rotation270)
+	}
+
+	display.FillScreen(black)
+
+	for {
+		err := drawJpeg(display)
+		if err != nil {
+			return err
+		}
+		time.Sleep(time.Second)
+
+		err = drawPng(display)
+		if err != nil {
+			return err
+		}
+		time.Sleep(time.Second)
+	}
+
+	return nil
+}
+
+// Define the buffer required for the callback. In most cases, this setting
+// should be sufficient.  For jpeg, the callback will always be called every
+// 3*8*8*4 pix. png will be called every line, i.e. every width pix.
+var buffer [3 * 8 * 8 * 4]uint16
+
+func drawPng(display *ili9341.Device) error {
+	p := strings.NewReader(pngImage)
+	png.SetCallback(buffer[:], func(data []uint16, x, y, w, h, width, height int16) {
+		err := display.DrawRGBBitmap(x, y, data[:w*h], w, h)
+		if err != nil {
+			errorMessage(fmt.Errorf("error drawPng: %s", err))
+		}
+	})
+
+	return png.Decode(p)
+}
+
+func drawJpeg(display *ili9341.Device) error {
+	p := strings.NewReader(jpegImage)
+	jpeg.SetCallback(buffer[:], func(data []uint16, x, y, w, h, width, height int16) {
+		err := display.DrawRGBBitmap(x, y, data[:w*h], w, h)
+		if err != nil {
+			errorMessage(fmt.Errorf("error drawJpeg: %s", err))
+		}
+	})
+
+	return jpeg.Decode(p)
+}
+
+func errorMessage(err error) {
+	for {
+		fmt.Printf("%s\r\n", err.Error())
+		time.Sleep(5 * time.Second)
+	}
+}

examples/lps22hb/main.go

@@ -0,0 +1,37 @@
+package main
+
+import (
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/lps22hb"
+)
+
+func main() {
+
+	machine.I2C1.Configure(machine.I2CConfig{
+		SCL:       machine.P0_15, // SCL1 on Nano 33 BLE Sense
+		SDA:       machine.P0_14, // SDA1 on Nano 33 BLE Sense
+		Frequency: machine.TWI_FREQ_400KHZ,
+	})
+
+	sensor := lps22hb.New(machine.I2C1)
+
+	if !sensor.Connected() {
+		println("LPS22HB not connected!")
+		return
+	}
+
+	sensor.Configure()
+
+	for {
+
+		p, _ := sensor.ReadPressure()
+		t, _ := sensor.ReadTemperature()
+		println("p =", float32(p)/1000.0, "hPa / t =", float32(t)/1000.0, "*C")
+		time.Sleep(time.Second)
+		// note: the device would power down itself after each query
+
+	}
+
+}

examples/lsm6dsox/main.go

@@ -0,0 +1,108 @@
+// Connects to an LSM6DSOX I2C a 6 axis Inertial Measurement Unit (IMU)
+package main
+
+import (
+	"fmt"
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/lsm6dsox"
+)
+
+const (
+	PLOTTER           = true
+	SHOW_ACCELERATION = false
+	SHOW_ROTATION     = true
+	SHOW_TEMPERATURE  = false
+
+	// calibration is naive, good enough for a demo: do not shake a second after flashing
+	GYRO_CALIBRATION = true
+)
+
+var cal = [...]float32{0, 0, 0}
+
+func main() {
+
+	machine.I2C0.Configure(machine.I2CConfig{})
+
+	device := lsm6dsox.New(machine.I2C0)
+	device.Configure(lsm6dsox.Configuration{
+		AccelRange:      lsm6dsox.ACCEL_2G,
+		AccelSampleRate: lsm6dsox.ACCEL_SR_104,
+		GyroRange:       lsm6dsox.GYRO_250DPS,
+		GyroSampleRate:  lsm6dsox.GYRO_SR_104,
+	})
+
+	for {
+
+		if !device.Connected() {
+			println("LSM6DSOX not connected")
+			time.Sleep(time.Second)
+			continue
+		}
+
+		// heuristic: after successful calibration the value can't be 0
+		if GYRO_CALIBRATION && cal[0] == 0 {
+			calibrateGyro(device)
+		}
+
+		ax, ay, az := device.ReadAcceleration()
+		gx, gy, gz := device.ReadRotation()
+		t, _ := device.ReadTemperature()
+
+		if PLOTTER {
+			printPlotter(ax, ay, az, gx, gy, gz, t)
+			time.Sleep(time.Millisecond * 100)
+		} else {
+			printMonitor(ax, ay, az, gx, gy, gz, t)
+			time.Sleep(time.Millisecond * 1000)
+		}
+
+	}
+
+}
+
+func calibrateGyro(device *lsm6dsox.Device) {
+	for i := 0; i < 100; i++ {
+		gx, gy, gz := device.ReadRotation()
+		cal[0] += float32(gx) / 1000000
+		cal[1] += float32(gy) / 1000000
+		cal[2] += float32(gz) / 1000000
+		time.Sleep(time.Millisecond * 10)
+	}
+	cal[0] /= 100
+	cal[1] /= 100
+	cal[2] /= 100
+}
+
+// Arduino IDE's Serial Plotter
+func printPlotter(ax, ay, az, gx, gy, gz, t int32) {
+	if SHOW_ACCELERATION {
+		fmt.Printf("AX:%f, AY:%f, AZ:%f,", axis(ax, 0), axis(ay, 0), axis(az, 0))
+	}
+	if SHOW_ROTATION {
+		fmt.Printf("GX:%f, GY:%f, GZ:%f,", axis(gx, cal[0]), axis(gy, cal[1]), axis(gz, cal[2]))
+	}
+	if SHOW_TEMPERATURE {
+		fmt.Printf("T:%f", float32(t)/1000)
+	}
+	println()
+}
+
+// Any Serial Monitor
+func printMonitor(ax, ay, az, gx, gy, gz, t int32) {
+	if SHOW_ACCELERATION {
+		fmt.Printf("Acceleration: %f, %f, %f\r\n", axis(ax, 0), axis(ay, 0), axis(az, 0))
+	}
+	if SHOW_ROTATION {
+		fmt.Printf("Rotation: %f, %f, %f\r\n", axis(gx, cal[0]), axis(gy, cal[1]), axis(gz, cal[2]))
+	}
+	if SHOW_TEMPERATURE {
+		fmt.Printf("Temperature C: %f\r\n", float32(t)/1000)
+	}
+	println()
+}
+
+func axis(raw int32, cal float32) float32 {
+	return float32(raw)/1000000 - cal
+}

examples/lsm9ds1/main.go

@@ -0,0 +1,103 @@
+// LSM9DS1, 9 axis Inertial Measurement Unit (IMU)
+package main
+
+import (
+	"fmt"
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/lsm9ds1"
+)
+
+const (
+	PLOTTER             = false
+	SHOW_ACCELERATION   = true
+	SHOW_ROTATION       = true
+	SHOW_MAGNETIC_FIELD = true
+	SHOW_TEMPERATURE    = true
+)
+
+func main() {
+
+	// I2C configure
+	machine.I2C0.Configure(machine.I2CConfig{})
+
+	// LSM9DS1 setup
+	device := lsm9ds1.New(machine.I2C0)
+	err := device.Configure(lsm9ds1.Configuration{
+		AccelRange:      lsm9ds1.ACCEL_2G,
+		AccelSampleRate: lsm9ds1.ACCEL_SR_119,
+		GyroRange:       lsm9ds1.GYRO_250DPS,
+		GyroSampleRate:  lsm9ds1.GYRO_SR_119,
+		MagRange:        lsm9ds1.MAG_4G,
+		MagSampleRate:   lsm9ds1.MAG_SR_40,
+	})
+	if err != nil {
+		for {
+			println("Failed to configure", err.Error())
+			time.Sleep(time.Second)
+		}
+	}
+
+	for {
+
+		if con, err := device.Connected(); !con || err != nil {
+			println("LSM9DS1 not connected")
+			time.Sleep(time.Second)
+			continue
+		}
+
+		ax, ay, az, _ := device.ReadAcceleration()
+		gx, gy, gz, _ := device.ReadRotation()
+		mx, my, mz, _ := device.ReadMagneticField()
+		t, _ := device.ReadTemperature()
+
+		if PLOTTER {
+			printPlotter(ax, ay, az, gx, gy, gz, mx, my, mz, t)
+			time.Sleep(time.Millisecond * 100)
+		} else {
+			printMonitor(ax, ay, az, gx, gy, gz, mx, my, mz, t)
+			time.Sleep(time.Millisecond * 1000)
+		}
+
+	}
+
+}
+
+// Arduino IDE's Serial Plotter
+func printPlotter(ax, ay, az, gx, gy, gz, mx, my, mz, t int32) {
+	if SHOW_ACCELERATION {
+		fmt.Printf("AX:%f, AY:%f, AZ:%f,", axis(ax), axis(ay), axis(az))
+	}
+	if SHOW_ROTATION {
+		fmt.Printf("GX:%f, GY:%f, GZ:%f,", axis(gx), axis(gy), axis(gz))
+	}
+	if SHOW_MAGNETIC_FIELD {
+		fmt.Printf("MX:%d, MY:%d, MZ:%d,", mx, my, mz)
+	}
+	if SHOW_TEMPERATURE {
+		fmt.Printf("T:%f", float32(t)/1000)
+	}
+	println()
+}
+
+// Any Serial Monitor
+func printMonitor(ax, ay, az, gx, gy, gz, mx, my, mz, t int32) {
+	if SHOW_ACCELERATION {
+		fmt.Printf("Acceleration (g): %f, %f, %f\r\n", axis(ax), axis(ay), axis(az))
+	}
+	if SHOW_ROTATION {
+		fmt.Printf("Rotation (dps): %f, %f, %f\r\n", axis(gx), axis(gy), axis(gz))
+	}
+	if SHOW_MAGNETIC_FIELD {
+		fmt.Printf("Magnetic field (nT): %d, %d, %d\r\n", mx, my, mz)
+	}
+	if SHOW_TEMPERATURE {
+		fmt.Printf("Temperature C: %f\r\n", float32(t)/1000)
+	}
+	println()
+}
+
+func axis(raw int32) float32 {
+	return float32(raw) / 1000000
+}

examples/rtl8720dn/mqttclient/main.go

@@ -0,0 +1,131 @@
+// This is a sensor station that uses a RTL8720DN running on the device UART2.
+// It creates an MQTT connection that publishes a message every second
+// to an MQTT broker.
+//
+// In other words:
+// Your computer <--> USB-CDC <--> MCU <--> UART2 <--> RTL8720DN <--> Internet <--> MQTT broker.
+//
+// You must install the Paho MQTT package to build this program:
+//
+// 		go get -u github.com/eclipse/paho.mqtt.golang
+//
+// You can check that mqttpub is running successfully with the following command.
+//
+// 		mosquitto_sub -h test.mosquitto.org -t tinygo
+//
+package main
+
+import (
+	"fmt"
+	"math/rand"
+	"time"
+
+	"tinygo.org/x/drivers/net"
+	"tinygo.org/x/drivers/net/mqtt"
+	"tinygo.org/x/drivers/rtl8720dn"
+)
+
+// You can override the setting with the init() in another source code.
+// func init() {
+//    ssid = "your-ssid"
+//    password = "your-password"
+//    debug = true
+//    server = "tinygo.org"
+// }
+
+var (
+	ssid     string
+	password string
+	server   string = "tcp://test.mosquitto.org:1883"
+	debug           = false
+)
+
+var buf [0x400]byte
+
+var lastRequestTime time.Time
+var conn net.Conn
+var adaptor *rtl8720dn.RTL8720DN
+
+func main() {
+	err := run()
+	for err != nil {
+		fmt.Printf("error: %s\r\n", err.Error())
+		time.Sleep(5 * time.Second)
+	}
+}
+
+var (
+	topic = "tinygo"
+)
+
+func run() error {
+	rtl, err := setupRTL8720DN()
+	if err != nil {
+		return err
+	}
+	net.UseDriver(rtl)
+
+	err = rtl.ConnectToAP(ssid, password)
+	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)
+
+	rand.Seed(time.Now().UnixNano())
+
+	opts := mqtt.NewClientOptions()
+	opts.AddBroker(server).SetClientID("tinygo-client-" + randomString(10))
+
+	println("Connectng to MQTT...")
+	cl := mqtt.NewClient(opts)
+	if token := cl.Connect(); token.Wait() && token.Error() != nil {
+		failMessage(token.Error().Error())
+	}
+
+	for i := 0; ; i++ {
+		println("Publishing MQTT message...")
+		data := []byte(fmt.Sprintf(`{"e":[{"n":"hello %d","v":101}]}`, i))
+		token := cl.Publish(topic, 0, false, data)
+		token.Wait()
+		if err := token.Error(); err != nil {
+			return err
+		}
+		time.Sleep(100 * time.Millisecond)
+	}
+
+	// Right now this code is never reached. Need a way to trigger it...
+	println("Disconnecting MQTT...")
+	cl.Disconnect(100)
+
+	println("Done.")
+
+	return nil
+}
+
+// Returns an int >= min, < max
+func randomInt(min, max int) int {
+	return min + rand.Intn(max-min)
+}
+
+// Generate a random string of A-Z chars with len = l
+func randomString(len int) string {
+	bytes := make([]byte, len)
+	for i := 0; i < len; i++ {
+		bytes[i] = byte(randomInt(65, 90))
+	}
+	return string(bytes)
+}
+
+func failMessage(msg string) {
+	for {
+		println(msg)
+		time.Sleep(1 * time.Second)
+	}
+}

examples/rtl8720dn/mqttclient/wioterminal.go

@@ -0,0 +1,74 @@
+//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)
+	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/mqttsub/main.go

@@ -0,0 +1,154 @@
+// This is a sensor station that uses a RTL8720DN running on the device UART2.
+// It creates an MQTT connection that publishes a message every second
+// to an MQTT broker.
+//
+// In other words:
+// Your computer <--> USB-CDC <--> MCU <--> UART2 <--> RTL8720DN <--> Internet <--> MQTT broker.
+//
+// You must also install the Paho MQTT package to build this program:
+//
+// 		go get -u github.com/eclipse/paho.mqtt.golang
+//
+// You can check that mqttpub/mqttsub is running successfully with the following command.
+//
+// 		mosquitto_sub -h test.mosquitto.org -t tinygo/tx
+// 		mosquitto_pub -h test.mosquitto.org -t tinygo/rx -m "hello world"
+//
+package main
+
+import (
+	"fmt"
+	"math/rand"
+	"time"
+
+	"tinygo.org/x/drivers/net"
+	"tinygo.org/x/drivers/net/mqtt"
+	"tinygo.org/x/drivers/rtl8720dn"
+)
+
+// You can override the setting with the init() in another source code.
+// func init() {
+//    ssid = "your-ssid"
+//    password = "your-password"
+//    debug = true
+//    server = "tinygo.org"
+// }
+
+var (
+	ssid     string
+	password string
+	server   string = "tcp://test.mosquitto.org:1883"
+	debug           = false
+)
+
+var buf [0x400]byte
+
+var lastRequestTime time.Time
+var conn net.Conn
+var adaptor *rtl8720dn.RTL8720DN
+
+func main() {
+	err := run()
+	for err != nil {
+		fmt.Printf("error: %s\r\n", err.Error())
+		time.Sleep(5 * time.Second)
+	}
+}
+
+// change these to connect to a different UART or pins for the ESP8266/ESP32
+var (
+	cl      mqtt.Client
+	topicTx = "tinygo/tx"
+	topicRx = "tinygo/rx"
+)
+
+func subHandler(client mqtt.Client, msg mqtt.Message) {
+	fmt.Printf("[%s]  ", msg.Topic())
+	fmt.Printf("%s\r\n", msg.Payload())
+}
+
+func run() error {
+	rtl, err := setupRTL8720DN()
+	if err != nil {
+		return err
+	}
+	net.UseDriver(rtl)
+
+	err = rtl.ConnectToAP(ssid, password)
+	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)
+
+	rand.Seed(time.Now().UnixNano())
+
+	opts := mqtt.NewClientOptions()
+	opts.AddBroker(server).SetClientID("tinygo-client-" + randomString(10))
+
+	println("Connecting to MQTT broker at", server)
+	cl = mqtt.NewClient(opts)
+	if token := cl.Connect(); token.Wait() && token.Error() != nil {
+		failMessage(token.Error().Error())
+	}
+
+	// subscribe
+	token := cl.Subscribe(topicRx, 0, subHandler)
+	token.Wait()
+	if token.Error() != nil {
+		failMessage(token.Error().Error())
+	}
+
+	go publishing()
+
+	select {}
+
+	// Right now this code is never reached. Need a way to trigger it...
+	println("Disconnecting MQTT...")
+	cl.Disconnect(100)
+
+	println("Done.")
+
+	return nil
+}
+
+func publishing() {
+	for i := 0; ; i++ {
+		println("Publishing MQTT message...")
+		data := []byte(fmt.Sprintf(`{"e":[{"n":"hello %d","v":101}]}`, i))
+		token := cl.Publish(topicTx, 0, false, data)
+		token.Wait()
+		if token.Error() != nil {
+			println(token.Error().Error())
+		}
+
+		time.Sleep(20 * 100 * time.Millisecond)
+	}
+}
+
+// Returns an int >= min, < max
+func randomInt(min, max int) int {
+	return min + rand.Intn(max-min)
+}
+
+// Generate a random string of A-Z chars with len = l
+func randomString(len int) string {
+	bytes := make([]byte, len)
+	for i := 0; i < len; i++ {
+		bytes[i] = byte(randomInt(65, 90))
+	}
+	return string(bytes)
+}
+
+func failMessage(msg string) {
+	for {
+		println(msg)
+		time.Sleep(1 * time.Second)
+	}
+}

examples/rtl8720dn/mqttsub/wioterminal.go

@@ -0,0 +1,74 @@
+//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)
+	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/ntpclient/main.go

@@ -0,0 +1,144 @@
+// This is an example of using the rtl8720dn driver to implement a NTP client.
+// It creates a UDP connection to request the current time and parse the
+// response from a NTP server.
+package main
+
+import (
+	"errors"
+	"fmt"
+	"runtime"
+	"time"
+
+	"tinygo.org/x/drivers/net"
+)
+
+// IP address of the server aka "hub". Replace with your own info.
+// You can override the setting with the init() in another source code.
+// func init() {
+//    ssid = "your-ssid"
+//    password = "your-password"
+//    ntpHost = "129.6.15.29"
+//    debug = true
+// }
+
+var (
+	ssid     string
+	password string
+	ntpHost  = "129.6.15.29"
+	debug    = false
+)
+
+const NTP_PACKET_SIZE = 48
+
+var b = make([]byte, NTP_PACKET_SIZE)
+
+func main() {
+	err := run()
+	for err != nil {
+		fmt.Printf("error: %s\r\n", err.Error())
+		time.Sleep(5 * time.Second)
+	}
+}
+
+func run() error {
+	rtl, err := setupRTL8720DN()
+	if err != nil {
+		return err
+	}
+	net.UseDriver(rtl)
+
+	err = rtl.ConnectToAP(ssid, password)
+	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)
+
+	// now make UDP connection
+	hip := net.ParseIP(ntpHost)
+	raddr := &net.UDPAddr{IP: hip, Port: 123}
+	laddr := &net.UDPAddr{Port: 2390}
+	conn, err := net.DialUDP("udp", laddr, raddr)
+	if err != nil {
+		return err
+	}
+
+	for {
+		// send data
+		println("Requesting NTP time...")
+		t, err := getCurrentTime(conn)
+		if err != nil {
+			message("Error getting current time: %v", err)
+		} else {
+			message("NTP time: %v", t)
+		}
+		runtime.AdjustTimeOffset(-1 * int64(time.Since(t)))
+		for i := 0; i < 10; i++ {
+			message("Current time: %v", time.Now())
+			time.Sleep(1 * time.Second)
+		}
+	}
+
+}
+
+func getCurrentTime(conn *net.UDPSerialConn) (time.Time, error) {
+	if err := sendNTPpacket(conn); err != nil {
+		return time.Time{}, err
+	}
+	clearBuffer()
+	for now := time.Now(); time.Since(now) < time.Second; {
+		time.Sleep(5 * time.Millisecond)
+		if n, err := conn.Read(b); err != nil {
+			return time.Time{}, fmt.Errorf("error reading UDP packet: %w", err)
+		} else if n == 0 {
+			continue // no packet received yet
+		} else if n != NTP_PACKET_SIZE {
+			if n != NTP_PACKET_SIZE {
+				return time.Time{}, fmt.Errorf("expected NTP packet size of %d: %d", NTP_PACKET_SIZE, n)
+			}
+		}
+		return parseNTPpacket(), nil
+	}
+	return time.Time{}, errors.New("no packet received after 1 second")
+}
+
+func sendNTPpacket(conn *net.UDPSerialConn) error {
+	clearBuffer()
+	b[0] = 0b11100011 // LI, Version, Mode
+	b[1] = 0          // Stratum, or type of clock
+	b[2] = 6          // Polling Interval
+	b[3] = 0xEC       // Peer Clock Precision
+	// 8 bytes of zero for Root Delay & Root Dispersion
+	b[12] = 49
+	b[13] = 0x4E
+	b[14] = 49
+	b[15] = 52
+	if _, err := conn.Write(b); err != nil {
+		return err
+	}
+	return nil
+}
+
+func parseNTPpacket() time.Time {
+	// the timestamp starts at byte 40 of the received packet and is four bytes,
+	// this is NTP time (seconds since Jan 1 1900):
+	t := uint32(b[40])<<24 | uint32(b[41])<<16 | uint32(b[42])<<8 | uint32(b[43])
+	const seventyYears = 2208988800
+	return time.Unix(int64(t-seventyYears), 0)
+}
+
+func clearBuffer() {
+	for i := range b {
+		b[i] = 0
+	}
+}
+
+func message(format string, args ...interface{}) {
+	println(fmt.Sprintf(format, args...), "\r")
+}

examples/rtl8720dn/ntpclient/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/tcpclient/main.go

@@ -0,0 +1,121 @@
+// This example opens a TCP connection using a device with RTL8720DN firmware
+// and sends some data, for the purpose of testing speed and connectivity.
+//
+// You can open a server to accept connections from this program using:
+//
+// nc -w 5 -lk 8080
+//
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"time"
+
+	"tinygo.org/x/drivers/net"
+)
+
+// You can override the setting with the init() in another source code.
+// func init() {
+//    ssid = "sghome-gw"
+//    password = "3af25537b4524"
+//    serverIP = "192.168.1.119"
+//    debug = true
+// }
+
+var (
+	ssid     string
+	password string
+	serverIP = ""
+	debug    = false
+)
+
+var buf = &bytes.Buffer{}
+
+func main() {
+	err := run()
+	for err != nil {
+		fmt.Printf("error: %s\r\n", err.Error())
+		time.Sleep(5 * time.Second)
+	}
+}
+
+func run() error {
+	rtl, err := setupRTL8720DN()
+	if err != nil {
+		return err
+	}
+	net.UseDriver(rtl)
+
+	err = rtl.ConnectToAP(ssid, password)
+	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)
+
+	for {
+		sendBatch()
+		time.Sleep(500 * time.Millisecond)
+	}
+	println("Done.")
+
+	return nil
+}
+
+func sendBatch() {
+
+	// make TCP connection
+	ip := net.ParseIP(serverIP)
+	raddr := &net.TCPAddr{IP: ip, Port: 8080}
+	laddr := &net.TCPAddr{Port: 8080}
+
+	message("---------------\r\nDialing TCP connection")
+	conn, err := net.DialTCP("tcp", laddr, raddr)
+	for ; err != nil; conn, err = net.DialTCP("tcp", laddr, raddr) {
+		message(err.Error())
+		time.Sleep(5 * time.Second)
+	}
+
+	n := 0
+	w := 0
+	start := time.Now()
+
+	// send data
+	message("Sending data")
+
+	for i := 0; i < 1000; i++ {
+		buf.Reset()
+		fmt.Fprint(buf,
+			"\r---------------------------- i == ", i, " ----------------------------"+
+				"\r---------------------------- i == ", i, " ----------------------------")
+		if w, err = conn.Write(buf.Bytes()); err != nil {
+			println("error:", err.Error(), "\r")
+			continue
+		}
+		n += w
+	}
+
+	buf.Reset()
+	ms := time.Now().Sub(start).Milliseconds()
+	fmt.Fprint(buf, "\nWrote ", n, " bytes in ", ms, " ms\r\n")
+	message(buf.String())
+
+	if _, err := conn.Write(buf.Bytes()); err != nil {
+		println("error:", err.Error(), "\r")
+	}
+
+	// Right now this code is never reached. Need a way to trigger it...
+	println("Disconnecting TCP...")
+	conn.Close()
+}
+
+func message(msg string) {
+	println(msg, "\r")
+}

examples/rtl8720dn/tcpclient/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/tlsclient/main.go

@@ -0,0 +1,137 @@
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"strings"
+	"time"
+
+	"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.
+// func init() {
+//    ssid = "your-ssid"
+//    password = "your-password"
+//    debug = true
+//    url = "https://www.example.com"
+//    test_root_ca = "..."
+// }
+
+var (
+	ssid     string
+	password string
+	url      string = "https://www.example.com"
+	debug           = false
+)
+
+// Set the test_root_ca created by the following command
+// $ openssl s_client -showcerts -verify 5 -connect www.example.com:443 < /dev/null
+var test_root_ca = `-----BEGIN CERTIFICATE-----
+MIIDrzCCApegAwIBAgIQCDvgVpBCRrGhdWrJWZHHSjANBgkqhkiG9w0BAQUFADBh
+MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3
+d3cuZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBD
+QTAeFw0wNjExMTAwMDAwMDBaFw0zMTExMTAwMDAwMDBaMGExCzAJBgNVBAYTAlVT
+MRUwEwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5j
+b20xIDAeBgNVBAMTF0RpZ2lDZXJ0IEdsb2JhbCBSb290IENBMIIBIjANBgkqhkiG
+9w0BAQEFAAOCAQ8AMIIBCgKCAQEA4jvhEXLeqKTTo1eqUKKPC3eQyaKl7hLOllsB
+CSDMAZOnTjC3U/dDxGkAV53ijSLdhwZAAIEJzs4bg7/fzTtxRuLWZscFs3YnFo97
+nh6Vfe63SKMI2tavegw5BmV/Sl0fvBf4q77uKNd0f3p4mVmFaG5cIzJLv07A6Fpt
+43C/dxC//AH2hdmoRBBYMql1GNXRor5H4idq9Joz+EkIYIvUX7Q6hL+hqkpMfT7P
+T19sdl6gSzeRntwi5m3OFBqOasv+zbMUZBfHWymeMr/y7vrTC0LUq7dBMtoM1O/4
+gdW7jVg/tRvoSSiicNoxBN33shbyTApOB6jtSj1etX+jkMOvJwIDAQABo2MwYTAO
+BgNVHQ8BAf8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA95QNVbR
+TLtm8KPiGxvDl7I90VUwHwYDVR0jBBgwFoAUA95QNVbRTLtm8KPiGxvDl7I90VUw
+DQYJKoZIhvcNAQEFBQADggEBAMucN6pIExIK+t1EnE9SsPTfrgT1eXkIoyQY/Esr
+hMAtudXH/vTBH1jLuG2cenTnmCmrEbXjcKChzUyImZOMkXDiqw8cvpOp/2PV5Adg
+06O/nVsJ8dWO41P0jmP6P6fbtGbfYmbW0W5BjfIttep3Sp+dWOIrWcBAI+0tKIJF
+PnlUkiaY4IBIqDfv8NZ5YBberOgOzW6sRBc4L0na4UU+Krk2U886UAb3LujEV0ls
+YSEY1QSteDwsOoBrp+uvFRTp2InBuThs4pFsiv9kuXclVzDAGySj4dzp30d8tbQk
+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 {
+		fmt.Printf("error: %s\r\n", err.Error())
+		time.Sleep(5 * time.Second)
+	}
+}
+
+func run() error {
+	rtl, err := setupRTL8720DN()
+	if err != nil {
+		return err
+	}
+	rtl.SetRootCA(&test_root_ca)
+	net.UseDriver(rtl)
+	http.SetBuf(buf[:])
+
+	err = rtl.ConnectToAP(ssid, password)
+	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"
+	// 	jar, err := cookiejar.New(nil)
+	// 	if err != nil {
+	// 		return err
+	// 	}
+	// 	client := &http.Client{Jar: jar}
+	// 	http.DefaultClient = client
+
+	cnt := 0
+	for {
+		// Various examples are as follows
+		//
+		// -- Get
+		// 	resp, err := http.Get(url)
+		//
+		// -- Post
+		// 	body := `cnt=12`
+		// 	resp, err = http.Post(url, "application/x-www-form-urlencoded", strings.NewReader(body))
+		//
+		// -- Post with JSON
+		// 	body := `{"msg": "hello"}`
+		// 	resp, err := http.Post(url, "application/json", strings.NewReader(body))
+
+		resp, err := http.Get(url)
+		if err != nil {
+			return err
+		}
+
+		fmt.Printf("%s %s\r\n", resp.Proto, resp.Status)
+		for k, v := range resp.Header {
+			fmt.Printf("%s: %s\r\n", k, strings.Join(v, " "))
+		}
+		fmt.Printf("\r\n")
+
+		scanner := bufio.NewScanner(resp.Body)
+		for scanner.Scan() {
+			fmt.Printf("%s\r\n", scanner.Text())
+		}
+		resp.Body.Close()
+
+		cnt++
+		fmt.Printf("-------- %d --------\r\n", cnt)
+		time.Sleep(10 * time.Second)
+	}
+}

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/udpstation/main.go

@@ -0,0 +1,89 @@
+package main
+
+import (
+	"fmt"
+	"strconv"
+	"time"
+
+	"tinygo.org/x/drivers/net"
+	"tinygo.org/x/drivers/net/http"
+)
+
+// IP address of the server aka "hub". Replace with your own info.
+// You can override the setting with the init() in another source code.
+// func init() {
+//    ssid = "your-ssid"
+//    password = "your-password"
+//    hubIP = "192.168.1.118"
+//    debug = true
+// }
+
+var (
+	ssid     string
+	password string
+	hubIP    = ""
+	debug    = false
+)
+
+var buf [0x400]byte
+
+func main() {
+	err := run()
+	for err != nil {
+		fmt.Printf("error: %s\r\n", err.Error())
+		time.Sleep(5 * time.Second)
+	}
+}
+
+func run() error {
+	rtl, err := setupRTL8720DN()
+	if err != nil {
+		return err
+	}
+	net.UseDriver(rtl)
+	http.SetBuf(buf[:])
+
+	err = rtl.ConnectToAP(ssid, password)
+	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)
+
+	// now make UDP connection
+	hip := net.ParseIP(hubIP)
+	raddr := &net.UDPAddr{IP: hip, Port: 2222}
+	laddr := &net.UDPAddr{Port: 2222}
+
+	println("Dialing UDP connection...")
+	conn, err := net.DialUDP("udp", laddr, raddr)
+	if err != nil {
+		return err
+	}
+
+	for {
+		// send data
+		println("Sending data...")
+		for i := 0; i < 25; i++ {
+			conn.Write([]byte("hello " + strconv.Itoa(i) + "\r\n"))
+		}
+		time.Sleep(1000 * time.Millisecond)
+	}
+
+	// Right now this code is never reached. Need a way to trigger it...
+	println("Disconnecting UDP...")
+	conn.Close()
+	println("Done.")
+
+	return nil
+}
+
+func message(msg string) {
+	println(msg, "\r")
+}

examples/rtl8720dn/udpstation/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

@@ -0,0 +1,136 @@
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"image/color"
+	"strings"
+	"time"
+
+	"tinygo.org/x/drivers/net"
+	"tinygo.org/x/drivers/net/http"
+	"tinygo.org/x/tinyfont/proggy"
+	"tinygo.org/x/tinyterm"
+)
+
+// You can override the setting with the init() in another source code.
+// If debug is enabled, a serial connection is required.
+// func init() {
+//    ssid = "your-ssid"
+//    password = "your-password"
+//    debug = false // true
+//    server = "tinygo.org"
+// }
+
+var (
+	ssid     string
+	password string
+	url      = "http://tinygo.org/"
+	debug    = false
+)
+
+var (
+	terminal = tinyterm.NewTerminal(display)
+
+	black = color.RGBA{0, 0, 0, 255}
+	white = color.RGBA{255, 255, 255, 255}
+	red   = color.RGBA{255, 0, 0, 255}
+	blue  = color.RGBA{0, 0, 255, 255}
+	green = color.RGBA{0, 255, 0, 255}
+
+	font = &proggy.TinySZ8pt7b
+)
+
+var buf [0x400]byte
+
+func main() {
+	display.FillScreen(black)
+	backlight.High()
+
+	terminal.Configure(&tinyterm.Config{
+		Font:       font,
+		FontHeight: 10,
+		FontOffset: 6,
+	})
+
+	err := run()
+	for err != nil {
+		fmt.Fprintf(terminal, "error: %s\r\n", err.Error())
+		time.Sleep(5 * time.Second)
+	}
+}
+
+func run() error {
+	fmt.Fprintf(terminal, "setupRTL8720DN()\r\n")
+	if debug {
+		fmt.Fprintf(terminal, "Running in debug mode.\r\n")
+		fmt.Fprintf(terminal, "A serial connection is required to continue execution.\r\n")
+	}
+	rtl, err := setupRTL8720DN()
+	if err != nil {
+		return err
+	}
+	net.UseDriver(rtl)
+	http.SetBuf(buf[:])
+
+	fmt.Fprintf(terminal, "ConnectToAP()\r\n")
+	err = rtl.ConnectToAP(ssid, password)
+	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)
+	// 	if err != nil {
+	// 		return err
+	// 	}
+	// 	client := &http.Client{Jar: jar}
+	// 	http.DefaultClient = client
+
+	cnt := 0
+	for {
+		// Various examples are as follows
+		//
+		// -- Get
+		// 	resp, err := http.Get(url)
+		//
+		// -- Post
+		// 	body := `cnt=12`
+		// 	resp, err = http.Post(url, "application/x-www-form-urlencoded", strings.NewReader(body))
+		//
+		// -- Post with JSON
+		// 	body := `{"msg": "hello"}`
+		// 	resp, err := http.Post(url, "application/json", strings.NewReader(body))
+
+		resp, err := http.Get(url)
+		if err != nil {
+			return err
+		}
+
+		fmt.Fprintf(terminal, "%s %s\r\n", resp.Proto, resp.Status)
+		for k, v := range resp.Header {
+			fmt.Fprintf(terminal, "%s: %s\r\n", k, strings.Join(v, " "))
+		}
+		fmt.Printf("\r\n")
+
+		scanner := bufio.NewScanner(resp.Body)
+		for scanner.Scan() {
+			fmt.Fprintf(terminal, "%s\r\n", scanner.Text())
+		}
+		resp.Body.Close()
+
+		cnt++
+		fmt.Fprintf(terminal, "-------- %d --------\r\n", cnt)
+		time.Sleep(10 * time.Second)
+	}
+}

examples/rtl8720dn/webclient-tinyterm/wioterminal.go

@@ -0,0 +1,98 @@
+//go:build wioterminal
+// +build wioterminal
+
+package main
+
+import (
+	"device/sam"
+	"machine"
+	"runtime/interrupt"
+	"time"
+
+	"tinygo.org/x/drivers/ili9341"
+	"tinygo.org/x/drivers/rtl8720dn"
+)
+
+var (
+	uart UARTx
+)
+
+var (
+	display = ili9341.NewSPI(
+		machine.SPI3,
+		machine.LCD_DC,
+		machine.LCD_SS_PIN,
+		machine.LCD_RESET,
+	)
+
+	backlight = machine.LCD_BACKLIGHT
+)
+
+func init() {
+	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

@@ -0,0 +1,104 @@
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"strings"
+	"time"
+
+	"tinygo.org/x/drivers/net"
+	"tinygo.org/x/drivers/net/http"
+)
+
+// You can override the setting with the init() in another source code.
+// func init() {
+//    ssid = "your-ssid"
+//    password = "your-password"
+//    url = "http://tinygo.org/"
+//    debug = true
+// }
+
+var (
+	ssid     string
+	password string
+	url      = "http://tinygo.org/"
+	debug    = false
+)
+
+var buf [0x400]byte
+
+func main() {
+	err := run()
+	for err != nil {
+		fmt.Printf("error: %s\r\n", err.Error())
+		time.Sleep(5 * time.Second)
+	}
+}
+
+func run() error {
+	rtl, err := setupRTL8720DN()
+	if err != nil {
+		return err
+	}
+	net.UseDriver(rtl)
+	http.SetBuf(buf[:])
+
+	err = rtl.ConnectToAP(ssid, password)
+	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"
+	// 	jar, err := cookiejar.New(nil)
+	// 	if err != nil {
+	// 		return err
+	// 	}
+	// 	client := &http.Client{Jar: jar}
+	// 	http.DefaultClient = client
+
+	cnt := 0
+	for {
+		// Various examples are as follows
+		//
+		// -- Get
+		// 	resp, err := http.Get(url)
+		//
+		// -- Post
+		// 	body := `cnt=12`
+		// 	resp, err = http.Post(url, "application/x-www-form-urlencoded", strings.NewReader(body))
+		//
+		// -- Post with JSON
+		// 	body := `{"msg": "hello"}`
+		// 	resp, err := http.Post(url, "application/json", strings.NewReader(body))
+
+		resp, err := http.Get(url)
+		if err != nil {
+			return err
+		}
+
+		fmt.Printf("%s %s\r\n", resp.Proto, resp.Status)
+		for k, v := range resp.Header {
+			fmt.Printf("%s: %s\r\n", k, strings.Join(v, " "))
+		}
+		fmt.Printf("\r\n")
+
+		scanner := bufio.NewScanner(resp.Body)
+		for scanner.Scan() {
+			fmt.Printf("%s\r\n", scanner.Text())
+		}
+		resp.Body.Close()
+
+		cnt++
+		fmt.Printf("-------- %d --------\r\n", cnt)
+		time.Sleep(10 * time.Second)
+	}
+}

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

@@ -0,0 +1,192 @@
+package main
+
+import (
+	"fmt"
+	"machine"
+	"strconv"
+	"time"
+
+	"tinygo.org/x/drivers/net/http"
+)
+
+// You can override the setting with the init() in another source code.
+// func init() {
+//    ssid = "your-ssid"
+//    password = "your-password"
+//    debug = true
+// }
+
+var (
+	ssid     string
+	password string
+	debug    = false
+)
+
+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 {
+		fmt.Printf("error: %s\r\n", err.Error())
+		time.Sleep(5 * time.Second)
+	}
+}
+
+func run() error {
+	rtl, err := setupRTL8720DN()
+	if err != nil {
+		return err
+	}
+	http.UseDriver(rtl)
+
+	err = rtl.ConnectToAP(ssid, password)
+	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)
+
+	http.HandleFunc("/", root)
+	http.HandleFunc("/hello", hello)
+	http.HandleFunc("/cnt", cnt)
+	http.HandleFunc("/6", sixlines)
+	http.HandleFunc("/off", LED_OFF)
+	http.HandleFunc("/on", LED_ON)
+	if err := http.ListenAndServe(":80", nil); err != nil {
+		message(err.Error())
+	}
+	return nil
+}
+
+func root(w http.ResponseWriter, r *http.Request) {
+	access := 1
+
+	cookie, err := r.Cookie("access")
+	if err != nil {
+		if err == http.ErrNoCookie {
+			cookie = &http.Cookie{
+				Name:  "access",
+				Value: "1",
+			}
+		} else {
+			http.Error(w, fmt.Sprintf("%s", err.Error()), http.StatusBadRequest)
+			return
+		}
+	} else {
+		v, err := strconv.ParseInt(cookie.Value, 10, 0)
+		if err != nil {
+			http.Error(w, fmt.Sprintf("invalid cookie.Value : %s", cookie.Value), http.StatusBadRequest)
+			return
+		}
+		cookie.Value = fmt.Sprintf("%d", v+1)
+		access = int(v) + 1
+	}
+	http.SetCookie(w, cookie)
+	w.WriteHeader(http.StatusOK)
+
+	fmt.Fprintf(w, `
+<html>
+<head>
+    <title>TinyGo HTTP Server</title>
+    <script language="javascript" type="text/javascript">
+        var counter = 0
+        function ledOn() { fetch("/on").then(response => response.text()).then(text => { led.innerHTML = "<p>on</p>"; }); }
+        function ledOff() { fetch("/off").then(response => response.text()).then(text => { led.innerHTML = "<p>off</p>"; }); }
+        function fetchCnt() { fetch("/cnt").then(response => response.json()).then(json => { counter = json.cnt; cnt.innerHTML = counter; }); }
+        function incrCnt() { counter = counter + 1; fetch("/cnt?cnt=" + counter, { method: 'POST' }).then(response => response.json()).then(json => { counter = json.cnt; cnt.innerHTML = counter; }); }
+        function setCnt() { fetch("/cnt", {
+            method: "POST",
+            body: "cnt=" + document.getElementsByName("cnt")[0].value,
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        }).then(response => response.json()).then(json => { counter = json.cnt; cnt.innerHTML = counter; }); return false; }
+        function onLoad() { fetchCnt(); }
+    </script>
+</head>
+<body onLoad="onLoad()">
+    <h5>TinyGo HTTP Server</h5>
+
+    <p>
+        access: %d
+    </p>
+
+    <a href="/hello">/hello</a><br>
+    <a href="/6">/6</a><br>
+
+    <p>
+        LED<br>
+        <a href="javascript:ledOn();">/on</a><br>
+        <a href="javascript:ledOff();">/off</a><br>
+    </p>
+
+
+    <p>
+        <a href="/cnt">/cnt</a><br>
+        cnt: <span id="cnt"></span><br>
+        <a href="javascript:incrCnt()">incrCnt()</a><br>
+        <form id="form1" style="display: inline" onSubmit="return setCnt()">
+        <input type="text" name="cnt">
+        <input type="button" value="set cnt", onClick="setCnt()">
+        </form>
+    </p>
+</body>
+</html>
+    `, access)
+}
+
+func sixlines(w http.ResponseWriter, r *http.Request) {
+	// https://fukuno.jig.jp/3267
+	fmt.Fprint(w, `<body onload='onkeydown=e=>K=parseInt(e.key[5]||6,28)/3-8;Z=X=[B=A=12];Y=_=>`+
+		`{for(C=[q=c=i=4];f=i--*K;c-=!Z[h+(K+6?p+K:C[i]=p*A-(p/9|0)*145)])p=B[i];for(c?0:K+6?h+=K:B=C;`+
+		`i=K=q--;f+=Z[A+p])X[p=h+B[q]]=1;h+=A;if(f|B)for(Z=X,X=[l=228],B=[[-7,-20,6,h=17,-9,3,3][t=++t%7]-4,0,1,t-6?-A:2];l--;)`+
+		`for(l%A?l-=l%A*!Z[l]:(P++,c=l+=A);--c>A;)Z[c]=Z[c-A];for(S="";i<240;S+=X[i]|(X[i]=Z[i]|=++i%A<2|i>228)?i%A?"■":"■<br>":"　");`+
+		`D.innerHTML=S+P;setTimeout(Y,i-P)};Y(h=K=t=P=0)'id=D>`)
+}
+
+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()")
+}
+
+func hello(w http.ResponseWriter, r *http.Request) {
+	w.Header().Set(`Content-Type`, `text/plain; charset=UTF-8`)
+	fmt.Fprintf(w, "hello")
+}
+
+var counter int
+
+func cnt(w http.ResponseWriter, r *http.Request) {
+	r.ParseForm()
+	if r.Method == "POST" {
+		c := r.Form.Get("cnt")
+		if c != "" {
+			i64, _ := strconv.ParseInt(c, 0, 0)
+			counter = int(i64)
+		}
+	}
+
+	w.Header().Set(`Content-Type`, `application/json`)
+	fmt.Fprintf(w, `{"cnt": %d}`, counter)
+}
+
+func message(msg string) {
+	println(msg, "\r")
+}

examples/rtl8720dn/webserver/wioterminal.go

@@ -0,0 +1,74 @@
+//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)
+	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/sdcard/console/feather-m4.go

@@ -1,3 +1,4 @@
+//go:build feather_m4 || feather_m4_can || feather_nrf52840
 // +build feather_m4 feather_m4_can feather_nrf52840
 
 package main

examples/sdcard/console/grandcentral-m4.go

@@ -1,4 +1,5 @@
-// +build grandcentral-m4
+//go:build grandcentral_m4
+// +build grandcentral_m4
 
 package main
 

examples/sdcard/console/m0.go

@@ -1,3 +1,4 @@
+//go:build atsamd21 && !p1am_100
 // +build atsamd21,!p1am_100
 
 package main

examples/sdcard/console/p1am-100.go

@@ -1,3 +1,4 @@
+//go:build p1am_100
 // +build p1am_100
 
 package main

examples/sdcard/console/pygamer.go

@@ -1,3 +1,4 @@
+//go:build pygamer
 // +build pygamer
 
 package main

examples/sdcard/console/pyportal.go

@@ -1,3 +1,4 @@
+//go:build pyportal
 // +build pyportal
 
 package main

examples/sdcard/console/wioterminal.go

@@ -1,3 +1,4 @@
+//go:build wioterminal
 // +build wioterminal
 
 package main

examples/sdcard/tinyfs/console/console.go

@@ -1,3 +1,4 @@
+//go:build tinygo
 // +build tinygo
 
 package console
@@ -11,7 +12,7 @@ import (
 	"strings"
 	"time"
 
-	"github.com/tinygo-org/tinyfs"
+	"tinygo.org/x/tinyfs"
 )
 
 const consoleBufLen = 64
@@ -35,6 +36,7 @@ var (
 	commands = map[string]cmdfunc{
 		"":        noop,
 		"dbg":     dbg,
+		"help":    help,
 		"lsblk":   lsblk,
 		"mount":   mount,
 		"umount":  umount,
@@ -160,6 +162,28 @@ func runCommand(line string) {
 
 func noop(argv []string) {}
 
+func help(argv []string) {
+	fmt.Printf("help\r\n")
+	fmt.Printf("  show help\r\n")
+	fmt.Printf("dbg\r\n")
+	fmt.Printf("  toggle debug mode\r\n")
+	fmt.Printf("xxd <hex address, ex: 0xA0> <size of hexdump in bytes>\r\n")
+	fmt.Printf("  hexdump the specified address\r\n")
+	fmt.Printf("ls <target file>\r\n")
+	fmt.Printf("  list information\r\n")
+	fmt.Printf("samples\r\n")
+	fmt.Printf("  write some files in the root directory\r\n")
+	fmt.Printf("mkdir <target dir>\r\n")
+	fmt.Printf("  create directory\r\n")
+	fmt.Printf("cat <target file>\r\n")
+	fmt.Printf("  print the contents of file\r\n")
+	fmt.Printf("create <target file>\r\n")
+	fmt.Printf("  create file\r\n")
+	fmt.Printf("write <target file>\r\n")
+	fmt.Printf("  write to file (press CTRL-D to exit)\r\n")
+	fmt.Printf("rm\r\n")
+}
+
 func dbg(argv []string) {
 	if debug {
 		debug = false
@@ -421,7 +445,7 @@ func cat(argv []string) {
 		println("Trying to cat to " + tgt)
 	}
 	if tgt == "" {
-		println("Usage: cat <target dir>")
+		println("Usage: cat <target file>")
 		return
 	}
 	if debug {

examples/sdcard/tinyfs/feather-m4.go

@@ -1,3 +1,4 @@
+//go:build feather_m4 || feather_m4_can || feather_nrf52840
 // +build feather_m4 feather_m4_can feather_nrf52840
 
 package main

examples/sdcard/tinyfs/grandcentral-m4.go

@@ -1,4 +1,5 @@
-// +build grandcentral-m4
+//go:build grandcentral_m4
+// +build grandcentral_m4
 
 package main
 

examples/sdcard/tinyfs/m0.go

@@ -1,3 +1,4 @@
+//go:build atsamd21 && !p1am_100
 // +build atsamd21,!p1am_100
 
 package main

examples/sdcard/tinyfs/main.go

@@ -5,9 +5,9 @@ import (
 	"machine"
 	"time"
 
-	"github.com/tinygo-org/tinyfs/fatfs"
 	"tinygo.org/x/drivers/examples/sdcard/tinyfs/console"
 	"tinygo.org/x/drivers/sdcard"
+	"tinygo.org/x/tinyfs/fatfs"
 )
 
 var (

examples/sdcard/tinyfs/p1am-100.go

@@ -1,3 +1,4 @@
+//go:build p1am_100
 // +build p1am_100
 
 package main

examples/sdcard/tinyfs/pygamer.go

@@ -1,3 +1,4 @@
+//go:build pygamer
 // +build pygamer
 
 package main

examples/sdcard/tinyfs/pyportal.go

@@ -1,3 +1,4 @@
+//go:build pyportal
 // +build pyportal
 
 package main

examples/sdcard/tinyfs/wioterminal.go

@@ -1,3 +1,4 @@
+//go:build wioterminal
 // +build wioterminal
 
 package main

examples/wifinina/http-get/main.go

@@ -0,0 +1,161 @@
+// This example opens a TCP connection using a device with WiFiNINA firmware
+// and sends a HTTP request to retrieve a webpage, based on the following
+// Arduino example:
+//
+// https://github.com/arduino-libraries/WiFiNINA/blob/master/examples/WiFiWebClientRepeating/
+//
+// This example will not work with samd21 or other systems with less than 32KB
+// of RAM.  Use the following if you want to run wifinina on samd21, etc.
+//
+// examples/wifinina/webclient
+// examples/wifinina/tlsclient
+//
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"machine"
+	"strings"
+	"time"
+
+	"tinygo.org/x/drivers/net"
+	"tinygo.org/x/drivers/net/http"
+	"tinygo.org/x/drivers/wifinina"
+)
+
+// access point info
+const ssid = ""
+const pass = ""
+
+// IP address of the server aka "hub". Replace with your own info.
+// Can specify a URL starting with http or https
+const url = "http://tinygo.org/"
+
+// these are the default pins for the Arduino Nano33 IoT.
+// change these to connect to a different UART or pins for the ESP8266/ESP32
+var (
+
+	// these are the default pins for the Arduino Nano33 IoT.
+	spi = machine.NINA_SPI
+
+	// this is the ESP chip that has the WIFININA firmware flashed on it
+	adaptor *wifinina.Device
+)
+
+var buf [0x400]byte
+
+var lastRequestTime time.Time
+var conn net.Conn
+
+func setup() {
+	// Configure SPI for 8Mhz, Mode 0, MSB First
+	spi.Configure(machine.SPIConfig{
+		Frequency: 8 * 1e6,
+		SDO:       machine.NINA_SDO,
+		SDI:       machine.NINA_SDI,
+		SCK:       machine.NINA_SCK,
+	})
+
+	adaptor = wifinina.New(spi,
+		machine.NINA_CS,
+		machine.NINA_ACK,
+		machine.NINA_GPIO0,
+		machine.NINA_RESETN)
+	adaptor.Configure()
+}
+
+func main() {
+
+	setup()
+	http.SetBuf(buf[:])
+
+	waitSerial()
+
+	connectToAP()
+
+	// You can send and receive cookies in the following way
+	// 	import "tinygo.org/x/drivers/net/http/cookiejar"
+	// 	jar, err := cookiejar.New(nil)
+	// 	if err != nil {
+	// 		return err
+	// 	}
+	// 	client := &http.Client{Jar: jar}
+	// 	http.DefaultClient = client
+
+	cnt := 0
+	for {
+		// Various examples are as follows
+		//
+		// -- Get
+		// 	resp, err := http.Get(url)
+		//
+		// -- Post
+		// 	body := `cnt=12`
+		// 	resp, err = http.Post(url, "application/x-www-form-urlencoded", strings.NewReader(body))
+		//
+		// -- Post with JSON
+		// 	body := `{"msg": "hello"}`
+		// 	resp, err := http.Post(url, "application/json", strings.NewReader(body))
+
+		resp, err := http.Get(url)
+		if err != nil {
+			fmt.Printf("%s\r\n", err.Error())
+			continue
+		}
+
+		fmt.Printf("%s %s\r\n", resp.Proto, resp.Status)
+		for k, v := range resp.Header {
+			fmt.Printf("%s: %s\r\n", k, strings.Join(v, " "))
+		}
+		fmt.Printf("\r\n")
+
+		scanner := bufio.NewScanner(resp.Body)
+		for scanner.Scan() {
+			fmt.Printf("%s\r\n", scanner.Text())
+		}
+		resp.Body.Close()
+
+		cnt++
+		fmt.Printf("-------- %d --------\r\n", cnt)
+		time.Sleep(10 * time.Second)
+	}
+
+}
+
+// Wait for user to open serial console
+func waitSerial() {
+	for !machine.Serial.DTR() {
+		time.Sleep(100 * time.Millisecond)
+	}
+}
+
+// connect to access point
+func connectToAP() {
+	if len(ssid) == 0 || len(pass) == 0 {
+		for {
+			println("Connection failed: Either ssid or password not set")
+			time.Sleep(10 * time.Second)
+		}
+	}
+	time.Sleep(2 * time.Second)
+	message("Connecting to " + ssid)
+	adaptor.SetPassphrase(ssid, pass)
+	for st, _ := adaptor.GetConnectionStatus(); st != wifinina.StatusConnected; {
+		message("Connection status: " + st.String())
+		time.Sleep(1 * time.Second)
+		st, _ = adaptor.GetConnectionStatus()
+	}
+	message("Connected.")
+	time.Sleep(2 * time.Second)
+	ip, _, _, err := adaptor.GetIP()
+	for ; err != nil; ip, _, _, err = adaptor.GetIP() {
+		message(err.Error())
+		time.Sleep(1 * time.Second)
+	}
+	message(ip.String())
+}
+
+func message(msg string) {
+	println(msg, "\r")
+}

examples/wifinina/pins/main.go

@@ -0,0 +1,91 @@
+//go:build nano_rp2040
+// +build nano_rp2040
+
+// This examples shows how to control RGB LED connected to
+// NINA-W102 chip on Arduino Nano RP2040 Connect board
+// Built-in LED code added for API comparison
+
+package main
+
+import (
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/wifinina"
+)
+
+const (
+	LED = machine.LED
+
+	// Arduino Nano RP2040 Connect board RGB LED pins
+	// See https://docs.arduino.cc/static/3525d638b5c76a2d19588d6b41cd02a0/ABX00053-full-pinout.pdf
+	LED_R wifinina.Pin = 27
+	LED_G wifinina.Pin = 25
+	LED_B wifinina.Pin = 26
+)
+
+var (
+
+	// these are the default pins for the Arduino Nano-RP2040 Connect
+	spi = machine.NINA_SPI
+
+	// this is the ESP chip that has the WIFININA firmware flashed on it
+	device *wifinina.Device
+)
+
+func setup() {
+
+	// Configure SPI for 8Mhz, Mode 0, MSB First
+	spi.Configure(machine.SPIConfig{
+		Frequency: 8 * 1e6,
+		SDO:       machine.NINA_SDO,
+		SDI:       machine.NINA_SDI,
+		SCK:       machine.NINA_SCK,
+	})
+
+	device = wifinina.New(spi,
+		machine.NINA_CS,
+		machine.NINA_ACK,
+		machine.NINA_GPIO0,
+		machine.NINA_RESETN)
+	device.Configure()
+
+	time.Sleep(time.Second)
+
+	LED.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	LED_R.Configure(wifinina.PinConfig{Mode: wifinina.PinOutput})
+	LED_G.Configure(wifinina.PinConfig{Mode: wifinina.PinOutput})
+	LED_B.Configure(wifinina.PinConfig{Mode: wifinina.PinOutput})
+}
+
+func main() {
+
+	setup()
+
+	LED.Low()    // OFF
+	LED_R.High() // OFF
+	LED_G.High() // OFF
+	LED_B.High() // OFF
+
+	go func() {
+		for {
+			LED.Low()
+			time.Sleep(time.Second)
+			LED.High()
+			time.Sleep(time.Second)
+		}
+	}()
+
+	for {
+		LED_R.Low() // ON
+		time.Sleep(time.Second)
+		LED_R.High() // OFF
+		LED_G.Low()  // ON
+		time.Sleep(time.Second)
+		LED_G.High() // OFF
+		LED_B.Low()  // ON
+		time.Sleep(time.Second)
+		LED_B.High() // OFF
+	}
+
+}

examples/ws2812/arduino.go

@@ -1,3 +1,4 @@
+//go:build arduino
 // +build arduino
 
 package main

examples/ws2812/digispark.go

@@ -1,3 +1,4 @@
+//go:build digispark
 // +build digispark
 
 package main

examples/ws2812/others.go

@@ -1,3 +1,4 @@
+//go:build !digispark && !arduino && !qtpy
 // +build !digispark,!arduino,!qtpy
 
 package main
@@ -6,5 +7,5 @@ import "machine"
 
 // Replace neo and led in the code below to match the pin
 // that you are using if different.
-var neo machine.Pin = machine.NEOPIXELS
+var neo machine.Pin = machine.WS2812
 var led = machine.LED

examples/ws2812/qtpy.go

@@ -1,3 +1,4 @@
+//go:build qtpy
 // +build qtpy
 
 package main

flash/transport_qspi_samd.go

@@ -1,3 +1,4 @@
+//go:build atsamd51
 // +build atsamd51
 
 package flash

go.mod

@@ -5,10 +5,8 @@ go 1.15
 require (
 	github.com/eclipse/paho.mqtt.golang v1.2.0
 	github.com/frankban/quicktest v1.10.2
-	github.com/sago35/tinygo-dma v0.0.0-20210610020721-297675ab9b23 // indirect
-	github.com/tinygo-org/tinyfs v0.0.0-20210514090915-924e60a7bcf8
-)
-
-replace (
-    github.com/sago35/tinygo-dma => ../../sago35/tinygo-dma
+	golang.org/x/net v0.0.0-20210614182718-04defd469f4e // indirect
+	tinygo.org/x/tinyfont v0.2.1
+	tinygo.org/x/tinyfs v0.1.0
+	tinygo.org/x/tinyterm v0.1.0
 )

go.sum

@@ -1,3 +1,4 @@
+github.com/bgould/http v0.0.0-20190627042742-d268792bdee7/go.mod h1:BTqvVegvwifopl4KTEDth6Zezs9eR+lCWhvGKvkxJHE=
 github.com/eclipse/paho.mqtt.golang v1.2.0 h1:1F8mhG9+aO5/xpdtFkW4SxOJB67ukuDC3t2y2qayIX0=
 github.com/eclipse/paho.mqtt.golang v1.2.0/go.mod h1:H9keYFcgq3Qr5OUJm/JZI/i6U7joQ8SYLhZwfeOo6Ts=
 github.com/frankban/quicktest v1.10.2 h1:19ARM85nVi4xH7xPXuc5eM/udya5ieh7b/Sv+d844Tk=
@@ -9,12 +10,23 @@ github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfn
 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/tinygo-dma v0.0.0-20210610020721-297675ab9b23 h1:ESMYhe6RQJ2RbBCH2OK1SNyYq3gKoBpI7g07aLjQgJI=
-github.com/sago35/tinygo-dma v0.0.0-20210610020721-297675ab9b23/go.mod h1:gXCCsg4cKOJ6NJl7teGN597XgN0hzQJz0Wekayj4k+M=
-github.com/tinygo-org/tinyfs v0.0.0-20210514004344-b02c062d12c9 h1:66or7MohOph3xr3gMGCXceLkd+MBoUbV/rPPjl8iQOU=
-github.com/tinygo-org/tinyfs v0.0.0-20210514004344-b02c062d12c9/go.mod h1:HGuyo42bGd1zWSuS1gwgyyjN36ZZMlEpwM0vSrglmXc=
-github.com/tinygo-org/tinyfs v0.0.0-20210514090915-924e60a7bcf8 h1:pYwuKe1XuNeJnGV1UjeZ0FhuZ5+lapIq1NUmGacbBwo=
-github.com/tinygo-org/tinyfs v0.0.0-20210514090915-924e60a7bcf8/go.mod h1:HGuyo42bGd1zWSuS1gwgyyjN36ZZMlEpwM0vSrglmXc=
+github.com/valyala/fastjson v1.6.3/go.mod h1:CLCAqky6SMuOcxStkYQvblddUtoRxhYMGLrsQns1aXY=
+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=
+golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/text v0.3.6 h1:aRYxNxv6iGQlyVaZmk6ZgYEDa+Jg18DxebPSrd6bg1M=
+golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+tinygo.org/x/drivers v0.14.0/go.mod h1:uT2svMq3EpBZpKkGO+NQHjxjGf1f42ra4OnMMwQL2aI=
+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/tinyfont v0.2.1 h1:FAaemBzw8wsfhAtG6fWW+QjyWw/K8YqEeiWo4N1pv4o=
+tinygo.org/x/tinyfont v0.2.1/go.mod h1:eLqnYSrFRjt5STxWaMeOWJTzrKhXqpWw7nU3bPfKOAM=
+tinygo.org/x/tinyfs v0.1.0 h1:yx1Tq9L60rpCm6HURo45x+Tnag+O9RGSbQfgeCb6XYU=
+tinygo.org/x/tinyfs v0.1.0/go.mod h1:ysc8Y92iHfhTXeyEM9+c7zviUQ4fN9UCFgSOFfMWv20=
+tinygo.org/x/tinyterm v0.1.0 h1:80i+j+KWoxCFa/Xfp6pWbh79x+8zUdMXC1vaKj2QhkY=
+tinygo.org/x/tinyterm v0.1.0/go.mod h1:/DDhNnGwNF2/tNgHywvyZuCGnbH3ov49Z/6e8LPLRR4=

hts221/hts221.go

@@ -0,0 +1,178 @@
+// Package hts221 implements a driver for HTS221,
+// a capacitive digital sensor for relative humidity and temperature.
+//
+// Datasheet: https://www.st.com/resource/en/datasheet/hts221.pdf
+//
+package hts221
+
+import (
+	"errors"
+
+	"tinygo.org/x/drivers"
+)
+
+// Device wraps an I2C connection to a HTS221 device.
+type Device struct {
+	bus              drivers.I2C
+	Address          uint8
+	humiditySlope    float32
+	humidityZero     float32
+	temperatureSlope float32
+	temperatureZero  float32
+}
+
+// Connected returns whether HTS221 has been found.
+// It does a "who am I" request and checks the response.
+func (d *Device) Connected() bool {
+	data := []byte{0}
+	d.bus.ReadRegister(d.Address, HTS221_WHO_AM_I_REG, data)
+	return data[0] == 0xBC
+}
+
+// Configure sets up the HTS221 device for communication.
+func (d *Device) Configure() {
+	// read calibration data
+	d.calibration()
+	// activate device and use block data update mode
+	d.Power(true)
+}
+
+// Power is for turn on/off the HTS221 device
+func (d *Device) Power(status bool) {
+	data := []byte{0}
+	if status {
+		data[0] = 0x84
+	}
+	d.bus.WriteRegister(d.Address, HTS221_CTRL1_REG, data)
+}
+
+// ReadHumidity returns the relative humidity in percent * 100.
+// Returns an error if the device is not turned on.
+func (d *Device) ReadHumidity() (humidity int32, err error) {
+	err = d.waitForOneShot(0x02)
+	if err != nil {
+		return
+	}
+
+	// read data and calibrate
+	data := []byte{0, 0}
+	d.bus.ReadRegister(d.Address, HTS221_HUMID_OUT_REG, data[:1])
+	d.bus.ReadRegister(d.Address, HTS221_HUMID_OUT_REG+1, data[1:])
+	hValue := readInt(data[1], data[0])
+	hValueCalib := float32(hValue)*d.humiditySlope + d.humidityZero
+
+	return int32(hValueCalib * 100), nil
+}
+
+// ReadTemperature returns the temperature in celsius milli degrees (°C/1000).
+// Returns an error if the device is not turned on.
+func (d *Device) ReadTemperature() (temperature int32, err error) {
+	err = d.waitForOneShot(0x01)
+	if err != nil {
+		return
+	}
+
+	// read data and calibrate
+	data := []byte{0, 0}
+	d.bus.ReadRegister(d.Address, HTS221_TEMP_OUT_REG, data[:1])
+	d.bus.ReadRegister(d.Address, HTS221_TEMP_OUT_REG+1, data[1:])
+	tValue := readInt(data[1], data[0])
+	tValueCalib := float32(tValue)*d.temperatureSlope + d.temperatureZero
+
+	return int32(tValueCalib * 1000), nil
+}
+
+// Resolution sets the HTS221's resolution mode.
+// The higher resolutions are more accurate but comsume more power (see datasheet).
+// The number of averaged samples will be (h + 2) ^ 2, (t + 1) ^ 2
+//
+func (d *Device) Resolution(h uint8, t uint8) {
+	if h > 7 {
+		h = 3 // default
+	}
+	if t > 7 {
+		t = 3 // default
+	}
+	d.bus.WriteRegister(d.Address, HTS221_AV_CONF_REG, []byte{h<<3 | t})
+}
+
+// private functions
+
+// read factory calibration data
+func (d *Device) calibration() {
+	h0rH, h1rH := []byte{0}, []byte{0}
+	t0degC, t1degC := []byte{0}, []byte{0}
+	t1t0msb := []byte{0}
+	h0t0Out, h1t0Out := []byte{0, 0}, []byte{0, 0}
+	t0Out, t1Out := []byte{0, 0}, []byte{0, 0}
+
+	d.bus.ReadRegister(d.Address, HTS221_H0_rH_x2_REG, h0rH)
+	d.bus.ReadRegister(d.Address, HTS221_H1_rH_x2_REG, h1rH)
+	d.bus.ReadRegister(d.Address, HTS221_T0_degC_x8_REG, t0degC)
+	d.bus.ReadRegister(d.Address, HTS221_T1_degC_x8_REG, t1degC)
+	d.bus.ReadRegister(d.Address, HTS221_T1_T0_MSB_REG, t1t0msb)
+	d.bus.ReadRegister(d.Address, HTS221_H0_T0_OUT_REG, h0t0Out[:1])
+	d.bus.ReadRegister(d.Address, HTS221_H0_T0_OUT_REG+1, h0t0Out[1:])
+	d.bus.ReadRegister(d.Address, HTS221_H1_T0_OUT_REG, h1t0Out[:1])
+	d.bus.ReadRegister(d.Address, HTS221_H1_T0_OUT_REG+1, h1t0Out[1:])
+	d.bus.ReadRegister(d.Address, HTS221_T0_OUT_REG, t0Out[:1])
+	d.bus.ReadRegister(d.Address, HTS221_T0_OUT_REG+1, t0Out[1:])
+	d.bus.ReadRegister(d.Address, HTS221_T1_OUT_REG, t1Out[:1])
+	d.bus.ReadRegister(d.Address, HTS221_T1_OUT_REG+1, t1Out[1:])
+
+	h0rH_v := float32(h0rH[0]) / 2.0
+	h1rH_v := float32(h1rH[0]) / 2.0
+	t0degC_v := float32(readUint(t1t0msb[0]&0x03, t0degC[0])) / 8.0
+	t1degC_v := float32(readUint(t1t0msb[0]&0x0C>>2, t1degC[0])) / 8.0
+	h0t0Out_v := float32(readInt(h0t0Out[1], h0t0Out[0]))
+	h1t0Out_v := float32(readInt(h1t0Out[1], h1t0Out[0]))
+	t0Out_v := float32(readInt(t0Out[1], t0Out[0]))
+	t1Out_v := float32(readInt(t1Out[1], t1Out[0]))
+
+	d.humiditySlope = (h1rH_v - h0rH_v) / (h1t0Out_v - h0t0Out_v)
+	d.humidityZero = h0rH_v - d.humiditySlope*h0t0Out_v
+	d.temperatureSlope = (t1degC_v - t0degC_v) / (t1Out_v - t0Out_v)
+	d.temperatureZero = t0degC_v - d.temperatureSlope*t0Out_v
+}
+
+// wait and trigger one shot in block update
+func (d *Device) waitForOneShot(filter uint8) error {
+	data := []byte{0}
+
+	// check if the device is on
+	d.bus.ReadRegister(d.Address, HTS221_CTRL1_REG, data)
+	if data[0]&0x80 == 0 {
+		return errors.New("device is off, unable to query")
+	}
+
+	// wait until one shot (one conversion) is ready to go
+	data[0] = 1
+	for {
+		d.bus.ReadRegister(d.Address, HTS221_CTRL2_REG, data)
+		if data[0]&0x01 == 0 {
+			break
+		}
+	}
+
+	// trigger one shot
+	d.bus.WriteRegister(d.Address, HTS221_CTRL2_REG, []byte{0x01})
+
+	// wait until conversion completed
+	data[0] = 0
+	for {
+		d.bus.ReadRegister(d.Address, HTS221_STATUS_REG, data)
+		if data[0]&filter == filter {
+			break
+		}
+	}
+
+	return nil
+}
+
+func readUint(msb byte, lsb byte) uint16 {
+	return uint16(msb)<<8 | uint16(lsb)
+}
+
+func readInt(msb byte, lsb byte) int16 {
+	return int16(uint16(msb)<<8 | uint16(lsb))
+}

hts221/hts221_generic.go

@@ -0,0 +1,14 @@
+//go:build !nano_33_ble
+// +build !nano_33_ble
+
+package hts221
+
+import "tinygo.org/x/drivers"
+
+// New creates a new HTS221 connection. The I2C bus must already be
+// configured.
+//
+// This function only creates the Device object, it does not touch the device.
+func New(bus drivers.I2C) Device {
+	return Device{bus: bus, Address: HTS221_ADDRESS}
+}

hts221/hts221_nano_33_ble.go

@@ -0,0 +1,29 @@
+//go:build nano_33_ble
+// +build nano_33_ble
+
+package hts221
+
+import (
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers"
+)
+
+// New creates a new HTS221 connection. The I2C bus must already be
+// configured.
+//
+// This function only creates the Device object, it does not touch the device.
+func New(bus drivers.I2C) Device {
+	// turn on internal power pin (machine.P0_22) and I2C1 pullups power pin (machine.P1_00)
+	// and wait a moment.
+	ENV := machine.P0_22
+	ENV.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	ENV.High()
+	R := machine.P1_00
+	R.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	R.High()
+	time.Sleep(time.Millisecond * 10)
+
+	return Device{bus: bus, Address: HTS221_ADDRESS}
+}

hts221/registers.go

@@ -0,0 +1,27 @@
+package hts221
+
+const (
+
+	// I2C address
+	HTS221_ADDRESS = 0x5F
+
+	// control/status registers
+	HTS221_WHO_AM_I_REG  = 0x0F
+	HTS221_AV_CONF_REG   = 0x10
+	HTS221_CTRL1_REG     = 0x20
+	HTS221_CTRL2_REG     = 0x21
+	HTS221_STATUS_REG    = 0x27
+	HTS221_HUMID_OUT_REG = 0x28
+	HTS221_TEMP_OUT_REG  = 0x2A
+
+	// calibration registers
+	HTS221_H0_rH_x2_REG   = 0x30
+	HTS221_H1_rH_x2_REG   = 0x31
+	HTS221_T0_degC_x8_REG = 0x32
+	HTS221_T1_degC_x8_REG = 0x33
+	HTS221_T1_T0_MSB_REG  = 0x35
+	HTS221_H0_T0_OUT_REG  = 0x36
+	HTS221_H1_T0_OUT_REG  = 0x3A
+	HTS221_T0_OUT_REG     = 0x3C
+	HTS221_T1_OUT_REG     = 0x3E
+)

i2csoft/i2csoft.go

@@ -0,0 +1,280 @@
+package i2csoft
+
+import (
+	"errors"
+	"machine"
+)
+
+// I2C is an I2C implementation by Software. Since it is implemented by
+// software, it can be used with microcontrollers that do not have I2C
+// function. This is not efficient but works around broken or missing drivers.
+type I2C struct {
+	scl      machine.Pin
+	sda      machine.Pin
+	nack     bool
+	baudrate uint32
+}
+
+// I2CConfig is used to store config info for I2C.
+type I2CConfig struct {
+	Frequency uint32
+	SCL       machine.Pin
+	SDA       machine.Pin
+}
+
+var (
+	errSI2CAckExpected = errors.New("I2C error: expected ACK not NACK")
+)
+
+// New returns the i2csoft driver. For the arguments, specify the pins to be
+// used as SCL and SDA. As I2C is implemented in software, any GPIO pin can be
+// specified.
+func New(sclPin, sdaPin machine.Pin) *I2C {
+	return &I2C{
+		scl:      sclPin,
+		sda:      sdaPin,
+		baudrate: 100e3,
+	}
+}
+
+// Configure is intended to setup the I2C interface.
+func (i2c *I2C) Configure(config I2CConfig) error {
+	// Default I2C bus speed is 100 kHz.
+	if config.Frequency != 0 {
+		i2c.SetBaudRate(config.Frequency)
+	}
+
+	// This exists for compatibility with machine.I2CConfig. SCL and SDA must
+	// be set at the same time. Because Pin(0) is sometimes set, it is not
+	// checked for 0.
+	if config.SCL != config.SDA {
+		i2c.scl = config.SCL
+		i2c.sda = config.SDA
+	}
+
+	// enable pins
+	i2c.sda.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	i2c.sda.High()
+	i2c.scl.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	i2c.scl.High()
+
+	return nil
+}
+
+// SetBaudRate sets the communication speed for the I2C.
+func (i2c *I2C) SetBaudRate(br uint32) {
+	// At this time, the value of i2c.baudrate is ignored because it is fixed
+	// at 100 kHz. SetBaudrate() is exist for compatibility with machine.I2C.
+	i2c.baudrate = br
+}
+
+// Tx does a single I2C transaction at the specified address.
+// It clocks out the given address, writes the bytes in w, reads back len(r)
+// bytes and stores them in r, and generates a stop condition on the bus.
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error {
+	i2c.nack = false
+	if len(w) != 0 {
+		// send start/address for write
+		i2c.sendAddress(addr, true)
+
+		// wait until transmission complete
+
+		// ACK received (0: ACK, 1: NACK)
+		if i2c.nack {
+			i2c.signalStop()
+			return errSI2CAckExpected
+		}
+
+		// write data
+		for _, b := range w {
+			i2c.writeByte(b)
+		}
+
+		i2c.signalStop()
+	}
+	if len(r) != 0 {
+		// send start/address for read
+		i2c.sendAddress(addr, false)
+
+		// wait transmission complete
+
+		// ACK received (0: ACK, 1: NACK)
+		if i2c.nack {
+			i2c.signalStop()
+			return errSI2CAckExpected
+		}
+
+		// read first byte
+		r[0] = i2c.readByte()
+		for i := 1; i < len(r); i++ {
+			// Send an ACK
+
+			i2c.signalRead()
+
+			// Read data and send the ACK
+			r[i] = i2c.readByte()
+		}
+
+		// Send NACK to end transmission
+		i2c.sendNack()
+
+		i2c.signalStop()
+	}
+
+	return nil
+}
+
+// writeByte writes a single byte to the I2C bus.
+func (i2c *I2C) writeByte(data byte) {
+	// Send data byte
+	i2c.scl.Low()
+	i2c.sda.High()
+	i2c.sda.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	i2c.wait()
+
+	for i := 0; i < 8; i++ {
+		i2c.scl.Low()
+		if ((data >> (7 - i)) & 1) == 1 {
+			i2c.sda.High()
+		} else {
+			i2c.sda.Low()
+		}
+		i2c.wait()
+		i2c.wait()
+		i2c.scl.High()
+		i2c.wait()
+		i2c.wait()
+	}
+
+	i2c.scl.Low()
+	i2c.wait()
+	i2c.wait()
+	i2c.sda.Configure(machine.PinConfig{Mode: machine.PinInput})
+	i2c.scl.High()
+	i2c.wait()
+
+	i2c.nack = i2c.sda.Get()
+
+	i2c.wait()
+
+	// wait until transmission successful
+}
+
+// sendAddress sends the address and start signal
+func (i2c *I2C) sendAddress(address uint16, write bool) {
+	data := (address << 1)
+	if !write {
+		data |= 1 // set read flag
+	}
+
+	i2c.scl.High()
+	i2c.sda.Low()
+	i2c.wait()
+	i2c.wait()
+	for i := 0; i < 8; i++ {
+		i2c.scl.Low()
+		if ((data >> (7 - i)) & 1) == 1 {
+			i2c.sda.High()
+		} else {
+			i2c.sda.Low()
+		}
+		i2c.wait()
+		i2c.wait()
+		i2c.scl.High()
+		i2c.wait()
+		i2c.wait()
+	}
+
+	i2c.scl.Low()
+	i2c.wait()
+	i2c.wait()
+	i2c.sda.Configure(machine.PinConfig{Mode: machine.PinInput})
+	i2c.scl.High()
+	i2c.wait()
+
+	i2c.nack = i2c.sda.Get()
+
+	i2c.wait()
+
+	// wait until bus ready
+}
+
+func (i2c *I2C) signalStop() {
+	i2c.scl.Low()
+	i2c.sda.Low()
+	i2c.sda.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	i2c.wait()
+	i2c.wait()
+	i2c.scl.High()
+	i2c.wait()
+	i2c.wait()
+	i2c.sda.High()
+	i2c.wait()
+	i2c.wait()
+}
+
+func (i2c *I2C) signalRead() {
+	i2c.wait()
+	i2c.wait()
+	i2c.scl.Low()
+	i2c.sda.Low()
+	i2c.sda.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	i2c.wait()
+	i2c.wait()
+	i2c.scl.High()
+	i2c.wait()
+	i2c.wait()
+}
+
+func (i2c *I2C) readByte() byte {
+	var data byte
+	for i := 0; i < 8; i++ {
+		i2c.scl.Low()
+		i2c.sda.Configure(machine.PinConfig{Mode: machine.PinInput})
+		i2c.wait()
+		i2c.wait()
+		i2c.scl.High()
+		if i2c.sda.Get() {
+			data |= 1 << (7 - i)
+		}
+		i2c.wait()
+		i2c.wait()
+	}
+	return data
+}
+
+func (i2c *I2C) sendNack() {
+	i2c.wait()
+	i2c.wait()
+	i2c.scl.Low()
+	i2c.sda.High()
+	i2c.sda.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	i2c.wait()
+	i2c.wait()
+	i2c.scl.High()
+	i2c.wait()
+	i2c.wait()
+}
+
+// WriteRegister transmits first the register and then the data to the
+// peripheral device.
+//
+// Many I2C-compatible devices are organized in terms of registers. This method
+// is a shortcut to easily write to such registers. Also, it only works for
+// devices with 7-bit addresses, which is the vast majority.
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error {
+	buf := make([]uint8, len(data)+1)
+	buf[0] = register
+	copy(buf[1:], data)
+	return i2c.Tx(uint16(address), buf, nil)
+}
+
+// ReadRegister transmits the register, restarts the connection as a read
+// operation, and reads the response.
+//
+// Many I2C-compatible devices are organized in terms of registers. This method
+// is a shortcut to easily read such registers. Also, it only works for devices
+// with 7-bit addresses, which is the vast majority.
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error {
+	return i2c.Tx(uint16(address), []byte{register}, data)
+}

i2csoft/i2csoft_atsamd51.go

@@ -0,0 +1,17 @@
+//go:build atsamd51 || atsame5x
+// +build atsamd51 atsame5x
+
+package i2csoft
+
+import (
+	"device"
+)
+
+// wait waits for half the time of the SCL operation interval. It is set to
+// about 100 kHz.
+func (i2c *I2C) wait() {
+	wait := 20
+	for i := 0; i < wait; i++ {
+		device.Asm(`nop`)
+	}
+}

i2csoft/i2csoft_esp32.go

@@ -0,0 +1,17 @@
+//go:build esp32
+// +build esp32
+
+package i2csoft
+
+import (
+	"device"
+)
+
+// wait waits for half the time of the SCL operation interval. It is set to
+// about 100 kHz.
+func (i2c *I2C) wait() {
+	wait := 60
+	for i := 0; i < wait; i++ {
+		device.Asm(`nop`)
+	}
+}

i2csoft/i2csoft_nrf52840.go

@@ -0,0 +1,17 @@
+//go:build nrf52840
+// +build nrf52840
+
+package i2csoft
+
+import (
+	"device"
+)
+
+// wait waits for half the time of the SCL operation interval. It is set to
+// about 100 kHz.
+func (i2c *I2C) wait() {
+	wait := 26
+	for i := 0; i < wait; i++ {
+		device.Asm(`nop`)
+	}
+}

i2csoft/i2csoft_other.go

@@ -0,0 +1,16 @@
+//go:build !esp32 && !atsamd51 && !atsame5x && !stm32f4 && !rp2040 && !nrf52840
+// +build !esp32,!atsamd51,!atsame5x,!stm32f4,!rp2040,!nrf52840
+
+package i2csoft
+
+import (
+	"device"
+)
+
+// wait waits for half the time of the SCL operation interval.
+func (i2c *I2C) wait() {
+	wait := 20
+	for i := 0; i < wait; i++ {
+		device.Asm(`nop`)
+	}
+}

i2csoft/i2csoft_rp2040.go

@@ -0,0 +1,17 @@
+//go:build rp2040
+// +build rp2040
+
+package i2csoft
+
+import (
+	"device"
+)
+
+// wait waits for half the time of the SCL operation interval. It is set to
+// about 100 kHz.
+func (i2c *I2C) wait() {
+	wait := 50
+	for i := 0; i < wait; i++ {
+		device.Asm(`nop`)
+	}
+}

i2csoft/i2csoft_stm32f4.go

@@ -0,0 +1,17 @@
+//go:build stm32f4
+// +build stm32f4
+
+package i2csoft
+
+import (
+	"device"
+)
+
+// wait waits for half the time of the SCL operation interval. It is set to
+// about 100 kHz.
+func (i2c *I2C) wait() {
+	wait := 77
+	for i := 0; i < wait; i++ {
+		device.Asm(`nop`)
+	}
+}

ili9341/ili9341.go

@@ -28,35 +28,6 @@ type Device struct {
 	rd  machine.Pin
 }
 
-var cmdBuf [4]byte
-var initCmd = []byte{
-	0xEF, 3, 0x03, 0x80, 0x02,
-	0xCF, 3, 0x00, 0xC1, 0x30,
-	0xED, 4, 0x64, 0x03, 0x12, 0x81,
-	0xE8, 3, 0x85, 0x00, 0x78,
-	0xCB, 5, 0x39, 0x2C, 0x00, 0x34, 0x02,
-	0xF7, 1, 0x20,
-	0xEA, 2, 0x00, 0x00,
-	PWCTR1, 1, 0x23, // Power control VRH[5:0]
-	PWCTR2, 1, 0x10, // Power control SAP[2:0];BT[3:0]
-	VMCTR1, 2, 0x3e, 0x28, // VCM control
-	VMCTR2, 1, 0x86, // VCM control2
-	MADCTL, 1, 0x48, // Memory Access Control
-	VSCRSADD, 1, 0x00, // Vertical scroll zero
-	PIXFMT, 1, 0x55,
-	FRMCTR1, 2, 0x00, 0x18,
-	DFUNCTR, 3, 0x08, 0x82, 0x27, // Display Function Control
-	0xF2, 1, 0x00, // 3Gamma Function Disable
-	GAMMASET, 1, 0x01, // Gamma curve selected
-	GMCTRP1, 15, 0x0F, 0x31, 0x2B, 0x0C, 0x0E, 0x08, // Set Gamma
-	0x4E, 0xF1, 0x37, 0x07, 0x10, 0x03, 0x0E, 0x09, 0x00,
-	GMCTRN1, 15, 0x00, 0x0E, 0x14, 0x03, 0x11, 0x07, // Set Gamma
-	0x31, 0xC1, 0x48, 0x08, 0x0F, 0x0C, 0x31, 0x36, 0x0F,
-	SLPOUT, 0x80, // Exit Sleep
-	DISPON, 0x80, // Display on
-	0x00, // End of list
-}
-
 // Configure prepares display for use
 func (d *Device) Configure(config Config) {
 
@@ -109,6 +80,33 @@ func (d *Device) Configure(config Config) {
 		delay(150)
 	}
 
+	initCmd := []byte{
+		0xEF, 3, 0x03, 0x80, 0x02,
+		0xCF, 3, 0x00, 0xC1, 0x30,
+		0xED, 4, 0x64, 0x03, 0x12, 0x81,
+		0xE8, 3, 0x85, 0x00, 0x78,
+		0xCB, 5, 0x39, 0x2C, 0x00, 0x34, 0x02,
+		0xF7, 1, 0x20,
+		0xEA, 2, 0x00, 0x00,
+		PWCTR1, 1, 0x23, // Power control VRH[5:0]
+		PWCTR2, 1, 0x10, // Power control SAP[2:0];BT[3:0]
+		VMCTR1, 2, 0x3e, 0x28, // VCM control
+		VMCTR2, 1, 0x86, // VCM control2
+		MADCTL, 1, 0x48, // Memory Access Control
+		VSCRSADD, 1, 0x00, // Vertical scroll zero
+		PIXFMT, 1, 0x55,
+		FRMCTR1, 2, 0x00, 0x18,
+		DFUNCTR, 3, 0x08, 0x82, 0x27, // Display Function Control
+		0xF2, 1, 0x00, // 3Gamma Function Disable
+		GAMMASET, 1, 0x01, // Gamma curve selected
+		GMCTRP1, 15, 0x0F, 0x31, 0x2B, 0x0C, 0x0E, 0x08, // Set Gamma
+		0x4E, 0xF1, 0x37, 0x07, 0x10, 0x03, 0x0E, 0x09, 0x00,
+		GMCTRN1, 15, 0x00, 0x0E, 0x14, 0x03, 0x11, 0x07, // Set Gamma
+		0x31, 0xC1, 0x48, 0x08, 0x0F, 0x0C, 0x31, 0x36, 0x0F,
+		SLPOUT, 0x80, // Exit Sleep
+		DISPON, 0x80, // Display on
+		0x00, // End of list
+	}
 	for i, c := 0, len(initCmd); i < c; {
 		cmd := initCmd[i]
 		if cmd == 0x00 {
@@ -148,14 +146,12 @@ func (d *Device) Display() error {
 	return nil
 }
 
-var err1 = errors.New("rectangle coordinates outside display area")
-
 // DrawRGBBitmap copies an RGB bitmap to the internal buffer at given coordinates
 func (d *Device) DrawRGBBitmap(x, y int16, data []uint16, w, h int16) error {
 	k, i := d.Size()
 	if x < 0 || y < 0 || w <= 0 || h <= 0 ||
 		x >= k || (x+w) > k || y >= i || (y+h) > i {
-		return err1
+		return errors.New("rectangle coordinates outside display area")
 	}
 	d.setWindow(x, y, w, h)
 	d.startWrite()
@@ -253,8 +249,7 @@ func (d *Device) SetRotation(rotation Rotation) {
 	case 3:
 		madctl = MADCTL_MX | MADCTL_MY | MADCTL_MV | MADCTL_BGR
 	}
-	cmdBuf[0] = madctl
-	d.sendCommand(MADCTL, cmdBuf[:1])
+	d.sendCommand(MADCTL, []uint8{madctl})
 	d.rotation = rotation
 }
 
@@ -285,14 +280,16 @@ func (d *Device) setWindow(x, y, w, h int16) {
 	//y += d.rowOffset
 	x1 := x + w - 1
 	if x != d.x0 || x1 != d.x1 {
-		cmdBuf[0], cmdBuf[1], cmdBuf[2], cmdBuf[3] = uint8(x>>8), uint8(x), uint8(x1>>8), uint8(x1)
-		d.sendCommand(CASET, cmdBuf[:4])
+		d.sendCommand(CASET, []uint8{
+			uint8(x >> 8), uint8(x), uint8(x1 >> 8), uint8(x1),
+		})
 		d.x0, d.x1 = x, x1
 	}
 	y1 := y + h - 1
 	if y != d.y0 || y1 != d.y1 {
-		cmdBuf[0], cmdBuf[1], cmdBuf[2], cmdBuf[3] = uint8(y>>8), uint8(y), uint8(y1>>8), uint8(y1)
-		d.sendCommand(PASET, cmdBuf[:4])
+		d.sendCommand(PASET, []uint8{
+			uint8(y >> 8), uint8(y), uint8(y1 >> 8), uint8(y1),
+		})
 		d.y0, d.y1 = y, y1
 	}
 	d.sendCommand(RAMWR, nil)

ili9341/parallel_atsamd51.go

@@ -1,3 +1,4 @@
+//go:build atsamd51
 // +build atsamd51
 
 package ili9341

ili9341/spi.go

@@ -1,50 +1,21 @@
+//go:build !atsamd51 && !atsamd21
 // +build !atsamd51,!atsamd21
 
 package ili9341
 
 import (
-	"device/sam"
 	"machine"
-	"unsafe"
 
-	dma "github.com/sago35/tinygo-dma"
+	"tinygo.org/x/drivers"
 )
 
-var (
-	dbg5 = machine.D5
-	dbg6 = machine.D6
-)
-
-func init() {
-	dbg5.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	dbg6.Configure(machine.PinConfig{Mode: machine.PinOutput})
-}
-
 var buf [64]byte
 
 type spiDriver struct {
-	bus machine.SPI
+	bus drivers.SPI
 }
 
-var (
-	dmatx *dma.DMA
-	desc  *dma.DMADescriptor
-)
-
-func NewSPI(bus machine.SPI, dc, cs, rst machine.Pin) *Device {
-	from := make([]byte, 256)
-	for i := range from {
-		from[i] = byte(i)
-	}
-
-	dmatx = dma.NewDMA(func(d *dma.DMA) {
-		d.Wait()
-		return
-	})
-	dmatx.SetTrigger(dma.DMAC_CHANNEL_CHCTRLA_TRIGSRC_SERCOM1_TX)
-	dmatx.SetTriggerAction(sam.DMAC_CHANNEL_CHCTRLA_TRIGACT_BURST)
-	desc = dmatx.GetDescriptor()
-
+func NewSPI(bus drivers.SPI, dc, cs, rst machine.Pin) *Device {
 	return &Device{
 		dc:  dc,
 		cs:  cs,
@@ -72,19 +43,6 @@ func (pd *spiDriver) write8n(b byte, n int) {
 }
 
 func (pd *spiDriver) write8sl(b []byte) {
-	if len(b) > 64 {
-		desc.UpdateDescriptor(dma.DescriptorConfig{
-			SRC:      unsafe.Pointer(&b[0]),
-			DST:      unsafe.Pointer(&pd.bus.Bus.DATA.Reg),
-			SRCINC:   dma.DMAC_SRAM_BTCTRL_SRCINC_ENABLE,
-			DSTINC:   dma.DMAC_SRAM_BTCTRL_DSTINC_DISABLE,
-			SIZE:     uint32(len(b)), // Total size of DMA transfer
-			BLOCKACT: 1,
-		})
-		dmatx.Start()
-		return
-	}
-
 	pd.bus.Tx(b, nil)
 }
 
@@ -108,18 +66,6 @@ func (pd *spiDriver) write16n(data uint16, n int) {
 }
 
 func (pd *spiDriver) write16sl(data []uint16) {
-	if len(data) > 64 {
-		desc.UpdateDescriptor(dma.DescriptorConfig{
-			SRC:      unsafe.Pointer(&data[0]),
-			DST:      unsafe.Pointer(&pd.bus.Bus.DATA.Reg),
-			SRCINC:   dma.DMAC_SRAM_BTCTRL_SRCINC_ENABLE,
-			DSTINC:   dma.DMAC_SRAM_BTCTRL_DSTINC_DISABLE,
-			SIZE:     uint32(len(data) * 2), // Total size of DMA transfer
-			BLOCKACT: 1,
-		})
-		dmatx.Start()
-		return
-	}
 	for i, c := 0, len(data); i < c; i++ {
 		buf[0] = uint8(data[i] >> 8)
 		buf[1] = uint8(data[i])

ili9341/spi_atsamd21.go

@@ -1,3 +1,4 @@
+//go:build atsamd21
 // +build atsamd21
 
 package ili9341

ili9341/spi_atsamd51.go

@@ -1,3 +1,4 @@
+//go:build atsamd51
 // +build atsamd51
 
 package ili9341