release: prepare for release v0.16.0

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

.gitignore

@@ -1 +1,2 @@
 build
+.vscode/

CHANGELOG.md

@@ -1,3 +1,46 @@
+0.16.0
+---
+- **new devices**
+    - aht20: add device
+    - ina260: add new i2c device
+    - keypad: add 4x4 keypad driver (#226)
+    - max7219: add driver support
+    - mcp2515: add support for mcp2515 CAN device
+    - p1am: support the P1AM-100 hardware watchdog
+    - pcf8563: add support for pcf8563 real time clock
+    - servo: add driver using PWM
+    - tm1637: add support for tm1637 7-segment LED
+    - tone: add package for producing tones using the PWM interface
+- **enhancements**
+    - pwm: update drivers with PWM to use new interface
+    - wifinina: Make TLS work over WiFiNINA Verified on Arduino Nano33 IoT and nina fw v1.4.5
+    - ssd1306: Enable reset screen for SSD1306 via I2C
+    - st7789: add scrolling functions to match st7735
+- **bugfixes**
+    - wifinina:
+        - fix getMACAddress and getTime
+        - fix println + cleanup
+        - remove debug flag and remove unnecessary padding call
+        - fix padding and implement missing functions
+    - flash: fix EraseBlocks method which is erasing sectors instead
+- **core**
+    - all: use interfaces for UART objects
+    - all: do not take the pointer of an I2C object
+    - adc: update drivers with ADC to use new config struct
+- **testing**
+    - tester:
+        - add a mock for command-oriented i2c devices
+        - add 16-bit register mock device
+
+- **docs**
+    - ssd1306: example of ssd1306 with 128x64 display over I2C
+    - wifinina:
+        - add information about Adafruit boards with ESP32 wifi coprocessors, and modify examples to remove code that was both not being used, and also prevented many Adafruit boards from being able to be targeted by the examples
+        - update docs to simplify the nina-fw update process
+        - example that connects to AP and prints ip addresses, time and mac
+    - p1am: documentation and example program
+    - add missing new drivers added since last release
+
 0.15.0
 ---
 - **new devices**

Makefile

@@ -89,16 +89,22 @@ smoke-test:
 	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=itsybitsy-m0 ./examples/mcp3008/main.go
 	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=itsybitsy-m0 ./examples/mcp2515/main.go
+	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=microbit ./examples/microbitmatrix/main.go
 	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=itsybitsy-m0 ./examples/mma8653/main.go
 	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=itsybitsy-m0 ./examples/mpu6050/main.go
 	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=p1am-100 ./examples/p1am/main.go
+	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=microbit ./examples/pcd8544/setbuffer/main.go
 	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=microbit ./examples/pcd8544/setpixel/main.go
 	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=arduino ./examples/servo
+	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=pybadge ./examples/shifter/main.go
 	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=microbit ./examples/sht3x/main.go
@@ -115,6 +121,10 @@ smoke-test:
 	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=circuitplay-express ./examples/thermistor/main.go
 	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=circuitplay-bluefruit ./examples/tone
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=arduino-nano33 ./examples/tm1637/main.go
+	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=pyportal ./examples/touch/resistive/fourwire/main.go
 	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=pyportal ./examples/touch/resistive/pyportal_touchpaint/main.go
@@ -165,13 +175,30 @@ endif
 	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=circuitplay-express ./examples/lis2mdl/main.go
 	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=arduino-nano33 ./examples/max72xx/main.go
+	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=feather-m0 ./examples/dht/main.go
 	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=arduino ./examples/keypad4x4/main.go
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=xiao ./examples/pcf8563/alarm/
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=xiao ./examples/pcf8563/clkout/
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=xiao ./examples/pcf8563/time/
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=xiao ./examples/pcf8563/timer/
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=feather-m0 ./examples/ina260/main.go
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=nucleo-l432kc ./examples/aht20/main.go
+	@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
+		hd44780 buzzer ssd1306 espat l9110x st7735 bmi160 l293x dht keypad4x4 max72xx p1am tone tm1637 \
+		pcf8563 mcp2515 servo
 TESTS = $(filter-out $(addsuffix /%,$(NOTESTS)),$(DRIVERS))
 
 unit-test:

README.md

@@ -52,12 +52,13 @@ func main() {
 
 ## Currently supported devices
 
-The following 56 devices are supported.
+The following 65 devices are supported.
 
 | Device Name | Interface Type |
 |----------|-------------|
 | [ADT7410 I2C Temperature Sensor](https://www.analog.com/media/en/technical-documentation/data-sheets/ADT7410.pdf) | I2C |
 | [ADXL345 accelerometer](http://www.analog.com/media/en/technical-documentation/data-sheets/ADXL345.pdf) | I2C |
+| [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 |
 | [AT24CX 2-wire serial EEPROM](https://www.openimpulse.com/blog/wp-content/uploads/wpsc/downloadables/24C32-Datasheet.pdf) | I2C |
@@ -80,20 +81,27 @@ The following 56 devices are supported.
 | [HD44780 LCD controller](https://www.sparkfun.com/datasheets/LCD/HD44780.pdf) | GPIO/I2C |
 | [HUB75 RGB led matrix](https://cdn-learn.adafruit.com/downloads/pdf/32x16-32x32-rgb-led-matrix.pdf) | SPI |
 | [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 |
 | [L293x motor driver](https://www.ti.com/lit/ds/symlink/l293d.pdf) | GPIO/PWM |
 | [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 |
 | [LSM6DS3 accelerometer](https://www.st.com/resource/en/datasheet/lsm6ds3.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 |
 | [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 |
+| [P1AM-100 Base Controller](https://facts-engineering.github.io/modules/P1AM-100/P1AM-100.html) | SPI |
 | [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 |
 | [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 |
@@ -105,6 +113,7 @@ The following 56 devices are supported.
 | [ST7789 TFT color display](https://cdn-shop.adafruit.com/product-files/3787/3787_tft_QT154H2201__________20190228182902.pdf) | SPI |
 | [Stepper motor "Easystepper" controller](https://en.wikipedia.org/wiki/Stepper_motor) | GPIO |
 | [Thermistor](https://www.farnell.com/datasheets/33552.pdf) | ADC |
+| [TM1637 7-segment LED display](https://www.mcielectronics.cl/website_MCI/static/documents/Datasheet_TM1637.pdf) | I2C |
 | [TMP102 I2C Temperature Sensor](https://download.mikroe.com/documents/datasheets/tmp102-data-sheet.pdf) | I2C |
 | [VEML6070 UV light sensor](https://www.vishay.com/docs/84277/veml6070.pdf) | I2C |
 | [VL53L1X time-of-flight distance sensor](https://www.st.com/resource/en/datasheet/vl53l1x.pdf) | I2C |

aht20/aht20.go

@@ -0,0 +1,108 @@
+package aht20
+
+import (
+	"time"
+
+	"tinygo.org/x/drivers"
+)
+
+// Device wraps an I2C connection to an AHT20 device.
+type Device struct {
+	bus      drivers.I2C
+	Address  uint16
+	humidity uint32
+	temp     uint32
+}
+
+// New creates a new AHT20 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: Address,
+	}
+}
+
+// Configure the device
+func (d *Device) Configure() {
+	// Check initialization state
+	status := d.Status()
+	if status&0x08 == 1 {
+		// Device is initialized
+		return
+	}
+
+	// Force initialization
+	d.bus.Tx(d.Address, []byte{CMD_INITIALIZE, 0x08, 0x00}, nil)
+	time.Sleep(10 * time.Millisecond)
+}
+
+// Reset the device
+func (d *Device) Reset() {
+	d.bus.Tx(d.Address, []byte{CMD_SOFTRESET}, nil)
+}
+
+// Status of the device
+func (d *Device) Status() byte {
+	data := []byte{0}
+
+	d.bus.Tx(d.Address, []byte{CMD_STATUS}, data)
+
+	return data[0]
+}
+
+// Read the temperature and humidity
+//
+// The actual temperature and humidity are stored
+// and can be accessed using `Temp` and `Humidity`.
+func (d *Device) Read() error {
+	d.bus.Tx(d.Address, []byte{CMD_TRIGGER, 0x33, 0x00}, nil)
+
+	data := []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
+	for retry := 0; retry < 3; retry++ {
+		time.Sleep(80 * time.Millisecond)
+		err := d.bus.Tx(d.Address, nil, data)
+		if err != nil {
+			return err
+		}
+
+		// If measurement complete, store values
+		if data[0]&0x04 != 0 && data[0]&0x80 == 0 {
+			d.humidity = uint32(data[1])<<12 | uint32(data[2])<<4 | uint32(data[3])>>4
+			d.temp = (uint32(data[3])&0xF)<<16 | uint32(data[4])<<8 | uint32(data[5])
+			return nil
+		}
+	}
+
+	return ErrTimeout
+}
+
+func (d *Device) RawHumidity() uint32 {
+	return d.humidity
+}
+
+func (d *Device) RawTemp() uint32 {
+	return d.temp
+}
+
+func (d *Device) RelHumidity() float32 {
+	return (float32(d.humidity) * 100) / 0x100000
+}
+
+func (d *Device) DeciRelHumidity() int32 {
+	return (int32(d.humidity) * 1000) / 0x100000
+}
+
+// Temperature in degrees celsius
+func (d *Device) Celsius() float32 {
+	return (float32(d.temp*200.0) / 0x100000) - 50
+}
+
+// Temperature in mutiples of one tenth of a degree celsius
+//
+// Using this method avoids floating point calculations.
+func (d *Device) DeciCelsius() int32 {
+	return ((int32(d.temp) * 2000) / 0x100000) - 500
+}

aht20/aht20_test.go

@@ -0,0 +1,74 @@
+package aht20
+
+import (
+	"testing"
+
+	qt "github.com/frankban/quicktest"
+	"tinygo.org/x/drivers/tester"
+)
+
+func TestDefaultI2CAddress(t *testing.T) {
+	c := qt.New(t)
+	bus := tester.NewI2CBus(c)
+	dev := New(bus)
+	c.Assert(uint8(dev.Address), qt.Equals, uint8(Address))
+}
+
+func TestInitialization(t *testing.T) {
+	c := qt.New(t)
+	bus := tester.NewI2CBus(c)
+	fdev := tester.NewI2CDeviceCmd(c, Address)
+	fdev.Commands = defaultCommands()
+	bus.AddDevice(fdev)
+
+	// Set status to uninitialized to force initialization
+	fdev.Commands[CMD_STATUS].Response[0] = 0x0C
+
+	dev := New(bus)
+	dev.Configure()
+
+	// Check initialization command invoked
+	c.Assert(fdev.Commands[CMD_INITIALIZE].Invocations > 0, qt.Equals, true)
+}
+
+func TestRead(t *testing.T) {
+	c := qt.New(t)
+	bus := tester.NewI2CBus(c)
+	fdev := tester.NewI2CDeviceCmd(c, Address)
+	fdev.Commands = defaultCommands()
+	bus.AddDevice(fdev)
+
+	dev := New(bus)
+	dev.Read()
+
+	// Should be 25deg (250 decidegrees)
+	c.Assert(dev.DeciCelsius(), qt.Equals, int32(250))
+
+	// Should be 36.3% (363 decipercent)
+	c.Assert(dev.DeciRelHumidity(), qt.Equals, int32(363))
+}
+
+func defaultCommands() map[uint8]*tester.Cmd {
+	return map[uint8]*tester.Cmd{
+		CMD_INITIALIZE: {
+			Command:  []byte{0xBE},
+			Mask:     []byte{0xFF},
+			Response: []byte{},
+		},
+		CMD_TRIGGER: {
+			Command:  []byte{0xAC, 0x33, 0x00},
+			Mask:     []byte{0xFF, 0xFF, 0xFF},
+			Response: []byte{0x1C, 0x5D, 0x10, 0x66, 0x01, 0xD2, 0x93},
+		},
+		CMD_SOFTRESET: {
+			Command:  []byte{0xBA},
+			Mask:     []byte{0xFF},
+			Response: []byte{},
+		},
+		CMD_STATUS: {
+			Command:  []byte{0x71},
+			Mask:     []byte{0xFF},
+			Response: []byte{0x1C},
+		},
+	}
+}

aht20/registers.go

@@ -0,0 +1,20 @@
+package aht20
+
+import "errors"
+
+const (
+	Address = 0x38
+
+	CMD_INITIALIZE = 0xBE
+	CMD_STATUS     = 0x71
+	CMD_TRIGGER    = 0xAC
+	CMD_SOFTRESET  = 0xBA
+
+	STATUS_BUSY       = 0x80
+	STATUS_CALIBRATED = 0x08
+)
+
+var (
+	ErrBusy    = errors.New("device busy")
+	ErrTimeout = errors.New("timeout")
+)

espat/espat.go

@@ -20,17 +20,17 @@ package espat // import "tinygo.org/x/drivers/espat"
 
 import (
 	"errors"
-	"machine"
 	"strconv"
 	"strings"
 	"time"
 
+	"tinygo.org/x/drivers"
 	"tinygo.org/x/drivers/net"
 )
 
 // Device wraps UART connection to the ESP8266/ESP32.
 type Device struct {
-	bus machine.UART
+	bus drivers.UART
 
 	// command responses that come back from the ESP8266/ESP32
 	response []byte
@@ -43,7 +43,7 @@ type Device struct {
 var ActiveDevice *Device
 
 // New returns a new espat driver. Pass in a fully configured UART bus.
-func New(b machine.UART) *Device {
+func New(b drivers.UART) *Device {
 	return &Device{bus: b, response: make([]byte, 512), socketdata: make([]byte, 0, 1024)}
 }
 

examples/adt7410/main.go

@@ -9,7 +9,7 @@ import (
 )
 
 var (
-	i2c    = &machine.I2C0
+	i2c    = machine.I2C0
 	sensor = adt7410.New(i2c)
 )
 

examples/aht20/main.go

@@ -0,0 +1,55 @@
+package main
+
+import (
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/aht20"
+)
+
+func main() {
+	machine.I2C0.Configure(machine.I2CConfig{})
+
+	dev := aht20.New(machine.I2C0)
+	dev.Configure()
+
+	dev.Reset()
+	for {
+		time.Sleep(500 * time.Millisecond)
+
+		err := dev.Read()
+		if err != nil {
+			println("Error", err)
+			continue
+		}
+
+		println("temp    ", fmtD(dev.DeciCelsius(), 3, 1), "C")
+		println("humidity", fmtD(dev.DeciRelHumidity(), 3, 1), "%")
+	}
+}
+
+func fmtD(val int32, i int, f int) string {
+	result := make([]byte, i+f+1)
+	neg := false
+
+	if val < 0 {
+		val = -val
+		neg = true
+	}
+
+	for p := len(result) - 1; p >= 0; p-- {
+		result[p] = byte(int32('0') + (val % 10))
+		val = val / 10
+
+		if p == i+1 && p > 0 {
+			p--
+			result[p] = '.'
+		}
+	}
+
+	if neg {
+		result[0] = '-'
+	}
+
+	return string(result)
+}

examples/apa102/itsybitsy-m0/main.go

@@ -15,7 +15,7 @@ import (
 var (
 	apa apa102.Device
 
-	led   = machine.PWM{machine.LED}
+	pwm   = machine.TCC0
 	leds  = make([]color.RGBA, 1)
 	wheel = &Wheel{Brightness: 0x10}
 )
@@ -27,12 +27,19 @@ func init() {
 	apa = apa102.NewSoftwareSPI(machine.PA00, machine.PA01, 1)
 
 	// Configure the regular on-board LED for PWM fading
-	machine.InitPWM()
-	led.Configure()
-
+	err := pwm.Configure(machine.PWMConfig{})
+	if err != nil {
+		println("failed to configure PWM")
+		return
+	}
 }
 
 func main() {
+	channelLED, err := pwm.Channel(machine.LED)
+	if err != nil {
+		println("failed to configure LED PWM channel")
+		return
+	}
 
 	// We'll fade the on-board LED in a goroutine to show/ensure that the APA102
 	// works fine with the scheduler enabled.  Comment this out to test this code
@@ -43,11 +50,11 @@ func main() {
 				brightening = !brightening
 				continue
 			}
-			var brightness uint16 = uint16(i) << 8
+			var brightness uint32 = uint32(i)
 			if !brightening {
-				brightness = 0xFFFF - brightness
+				brightness = 256 - brightness
 			}
-			led.Set(brightness)
+			pwm.Set(channelLED, pwm.Top()*brightness/256)
 			time.Sleep(5 * time.Millisecond)
 		}
 	}()

examples/gps/i2c/main.go

@@ -10,7 +10,7 @@ import (
 func main() {
 	println("GPS I2C Example")
 	machine.I2C0.Configure(machine.I2CConfig{})
-	ublox := gps.NewI2C(&machine.I2C0)
+	ublox := gps.NewI2C(machine.I2C0)
 	parser := gps.NewParser()
 	var fix gps.Fix
 	for {

examples/ina260/main.go

@@ -0,0 +1,63 @@
+package main
+
+import (
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/ina260"
+)
+
+func main() {
+	machine.I2C0.Configure(machine.I2CConfig{})
+
+	dev := ina260.New(machine.I2C0)
+	dev.Configure(ina260.Config{
+		AverageMode:     ina260.AVGMODE_16,
+		VoltConvTime:    ina260.CONVTIME_140USEC,
+		CurrentConvTime: ina260.CONVTIME_140USEC,
+		Mode:            ina260.MODE_CONTINUOUS | ina260.MODE_VOLTAGE | ina260.MODE_CURRENT,
+	})
+
+	if dev.Connected() {
+		println("INA260 detected")
+	} else {
+		println("INA260 NOT detected")
+		return
+	}
+
+	for {
+		microvolts := dev.Voltage()
+		microamps := dev.Current()
+		microwatts := dev.Power()
+
+		println(fmtD(microvolts, 4, 3), "mV,", fmtD(microamps, 4, 3), "mA,", fmtD(microwatts, 4, 3), "mW")
+
+		time.Sleep(10 * time.Millisecond)
+	}
+}
+
+func fmtD(val int32, i int, f int) string {
+	result := make([]byte, i+f+1)
+	neg := false
+
+	if val < 0 {
+		val = -val
+		neg = true
+	}
+
+	for p := len(result) - 1; p >= 0; p-- {
+		result[p] = byte(int32('0') + (val % 10))
+		val = val / 10
+
+		if p == i+1 && p > 0 {
+			p--
+			result[p] = '.'
+		}
+	}
+
+	if neg {
+		result[0] = '-'
+	}
+
+	return string(result)
+}

examples/keypad4x4/main.go

@@ -0,0 +1,38 @@
+package main
+
+import (
+	"machine"
+
+	"tinygo.org/x/drivers/keypad4x4"
+)
+
+func main() {
+	mapping := map[uint8]string{
+		1:  "1",
+		2:  "2",
+		3:  "3",
+		4:  "A",
+		5:  "4",
+		6:  "5",
+		7:  "6",
+		8:  "B",
+		9:  "7",
+		10: "8",
+		11: "9",
+		12: "C",
+		13: "*",
+		14: "0",
+		15: "#",
+		16: "D",
+	}
+
+	keypadDevice := keypad4x4.NewDevice(machine.D2, machine.D3, machine.D4, machine.D5, machine.D6, machine.D7, machine.D8, machine.D9)
+	keypadDevice.Configure()
+
+	for {
+		key := keypadDevice.GetKey()
+		if key != keypad4x4.NoKeyPressed {
+			println("Button: ", mapping[key])
+		}
+	}
+}

examples/l293x/speed/main.go

@@ -8,19 +8,31 @@ import (
 )
 
 const (
-	maxSpeed = 30000
+	maxSpeed = 100
 )
 
 func main() {
-	machine.InitPWM()
+	err := machine.TCC0.Configure(machine.PWMConfig{
+		Period: 16384e3, // 16.384ms
+	})
+	if err != nil {
+		println(err.Error())
+		return
+	}
 
-	wheel := l293x.NewWithSpeed(machine.D10, machine.D11, machine.PWM{machine.D12})
+	spc, err := machine.TCC0.Channel(machine.D12)
+	if err != nil {
+		println(err.Error())
+		return
+	}
+
+	wheel := l293x.NewWithSpeed(machine.D10, machine.D11, spc, machine.TCC0)
 	wheel.Configure()
 
 	for i := 0; i <= 10; i++ {
 		println("Forward")
-		var i uint16
-		for i = 0; i < maxSpeed; i += 1000 {
+		var i uint32
+		for i = 0; i < maxSpeed; i += 10 {
 			wheel.Forward(i)
 			time.Sleep(time.Millisecond * 100)
 		}
@@ -30,7 +42,7 @@ func main() {
 		time.Sleep(time.Millisecond * 1000)
 
 		println("Backward")
-		for i = 0; i < maxSpeed; i += 1000 {
+		for i = 0; i < maxSpeed; i += 10 {
 			wheel.Backward(i)
 			time.Sleep(time.Millisecond * 100)
 		}

examples/l9110x/speed/main.go

@@ -8,19 +8,38 @@ import (
 )
 
 const (
-	maxSpeed = 30000
+	maxSpeed = 100
 )
 
 func main() {
-	machine.InitPWM()
+	machine.D11.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	machine.D12.Configure(machine.PinConfig{Mode: machine.PinOutput})
 
-	wheel := l9110x.NewWithSpeed(machine.PWM{machine.D11}, machine.PWM{machine.D12})
+	err := machine.TCC0.Configure(machine.PWMConfig{})
+	if err != nil {
+		println(err.Error())
+		return
+	}
+
+	ca, err := machine.TCC0.Channel(machine.D11)
+	if err != nil {
+		println(err.Error())
+		return
+	}
+
+	cb, err := machine.TCC0.Channel(machine.D12)
+	if err != nil {
+		println(err.Error())
+		return
+	}
+
+	wheel := l9110x.NewWithSpeed(ca, cb, machine.TCC0)
 	wheel.Configure()
 
 	for i := 0; i <= 10; i++ {
 		println("Forward")
-		var i uint16
-		for i = 0; i < maxSpeed; i += 1000 {
+		var i uint32
+		for i = 0; i < maxSpeed; i += 10 {
 			wheel.Forward(i)
 			time.Sleep(time.Millisecond * 100)
 		}
@@ -30,7 +49,7 @@ func main() {
 		time.Sleep(time.Millisecond * 1000)
 
 		println("Backward")
-		for i = 0; i < maxSpeed; i += 1000 {
+		for i = 0; i < maxSpeed; i += 10 {
 			wheel.Backward(i)
 			time.Sleep(time.Millisecond * 100)
 		}

examples/max72xx/main.go

@@ -0,0 +1,135 @@
+package main
+
+import (
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/max72xx"
+)
+
+// example for a 4 digit 7 segment display
+func main() {
+	// Pins for Arduino Nano 33 IOT
+	err := machine.SPI0.Configure(machine.SPIConfig{
+		SDO:       machine.D11, // default SDO pin
+		SCK:       machine.D13, // default sck pin
+		LSBFirst:  false,
+		Frequency: 10000000,
+	})
+
+	if err != nil {
+		println(err.Error())
+	}
+
+	driver := max72xx.NewDevice(machine.SPI0, machine.D6)
+	driver.Configure()
+
+	digitNumber := 4
+
+	driver.StopDisplayTest()
+	driver.SetDecodeMode(4)
+	driver.SetScanLimit(4)
+	driver.StopShutdownMode()
+
+	for i := 1; i < int(digitNumber); i++ {
+		driver.WriteCommand(byte(i), byte(Blank))
+	}
+
+	for {
+		for _, character := range characters {
+			println("writing", "characterValue:", character.String())
+			driver.WriteCommand(byte(4), byte(character))
+			driver.WriteCommand(byte(3), byte(character))
+			driver.WriteCommand(byte(2), byte(character))
+			driver.WriteCommand(byte(1), byte(character))
+			time.Sleep(500 * time.Millisecond)
+
+		}
+		time.Sleep(time.Second)
+	}
+
+}
+
+var characters = []Character{
+	Zero,
+	One,
+	Two,
+	Three,
+	Four,
+	Five,
+	Six,
+	Seven,
+	Eight,
+	Nine,
+	Dash,
+	E,
+	H,
+	L,
+	P,
+	Blank,
+	Dot,
+}
+
+// Each bit translates to a pin, which is driven high or low
+type Character byte
+
+func (char Character) String() string {
+	switch char {
+	case Zero:
+		return "0"
+	case One:
+		return "1"
+	case Two:
+		return "2"
+	case Three:
+		return "3"
+	case Four:
+		return "4"
+	case Five:
+		return "5"
+	case Six:
+		return "6"
+	case Seven:
+		return "7"
+	case Eight:
+		return "8"
+	case Nine:
+		return "9"
+	case Dash:
+		return "-"
+	case E:
+		return "E"
+	case H:
+		return "H"
+	case L:
+		return "L"
+	case P:
+		return "P"
+	case Blank:
+		return ""
+	case Dot:
+		return "."
+	}
+
+	return ""
+}
+
+const (
+	Zero  Character = 0 //126
+	One   Character = 1 //48
+	Two   Character = 2 // 109
+	Three Character = 3 // 121
+	Four  Character = 4
+	Five  Character = 5
+	Six   Character = 6
+	Seven Character = 7
+	Eight Character = 8
+	Nine  Character = 9
+	Dash  Character = 10
+	E     Character = 11
+	H     Character = 12
+	L     Character = 13
+	P     Character = 14
+	Blank Character = 15
+	Dot   Character = 128
+)

examples/mcp2515/main.go

@@ -0,0 +1,55 @@
+package main
+
+import (
+	"fmt"
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/mcp2515"
+)
+
+var (
+	spi   = machine.SPI0
+	csPin = machine.D5
+)
+
+func main() {
+	spi.Configure(machine.SPIConfig{
+		Frequency: 115200,
+		SCK:       machine.SPI0_SCK_PIN,
+		SDO:       machine.SPI0_SDO_PIN,
+		SDI:       machine.SPI0_SDI_PIN,
+		Mode:      0})
+	can := mcp2515.New(spi, csPin)
+	can.Configure()
+	err := can.Begin(mcp2515.CAN500kBps, mcp2515.Clock8MHz)
+	if err != nil {
+		failMessage(err.Error())
+	}
+
+	for {
+		err := can.Tx(0x111, 8, []byte{0x00, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA})
+		if err != nil {
+			failMessage(err.Error())
+		}
+		if can.Received() {
+			msg, err := can.Rx()
+			if err != nil {
+				failMessage(err.Error())
+			}
+			fmt.Printf("CAN-ID: %03X dlc: %d data: ", msg.ID, msg.Dlc)
+			for _, b := range msg.Data {
+				fmt.Printf("%02X ", b)
+			}
+			fmt.Print("\r\n")
+		}
+		time.Sleep(time.Millisecond * 500)
+	}
+}
+
+func failMessage(msg string) {
+	for {
+		println(msg)
+		time.Sleep(1 * time.Second)
+	}
+}

examples/p1am/main.go

@@ -0,0 +1,74 @@
+package main
+
+import (
+	"fmt"
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/p1am"
+)
+
+func main() {
+	for {
+		if err := loop(); err != nil {
+			fmt.Printf("loop failed, retrying: %v\n", err)
+			time.Sleep(500 * time.Millisecond)
+		}
+	}
+}
+func loop() error {
+	led := machine.LED
+	led.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	sw := machine.SWITCH
+	sw.Configure(machine.PinConfig{Mode: machine.PinInput})
+
+	if err := p1am.Controller.Initialize(); err != nil {
+		return fmt.Errorf("initializing controller: %w", err)
+	}
+
+	version, err := p1am.Controller.Version()
+	if err != nil {
+		return fmt.Errorf("fetching base controller version: %w", err)
+	}
+	fmt.Printf("Base controller version: %d.%d.%d\n", version[0], version[1], version[2])
+
+	for i := 1; i <= p1am.Controller.Slots; i++ {
+		slot := p1am.Controller.Slot(i)
+		fmt.Printf("Slot %d: ID 0x%08x, Props %+v\n", i, slot.ID, slot.Props)
+	}
+
+	slot1 := p1am.Controller.Slot(1)
+	var lastInput uint32
+	state := sw.Get()
+	for {
+		if active, err := p1am.Controller.Active(); err != nil || !active {
+			return fmt.Errorf("controller active %v: %v", active, err)
+		}
+		if state != sw.Get() {
+			state = sw.Get()
+			fmt.Printf("New switch state: %v\n", state)
+			if slot1.Props.DO > 0 {
+				if err := slot1.Channel(1).WriteDiscrete(state); err != nil {
+					return err
+				}
+			}
+		}
+		if slot1.Props.DI > 0 {
+			sstate, err := slot1.ReadDiscrete()
+			if err != nil {
+				return fmt.Errorf("reading slot: %w", err)
+			}
+			if sstate != lastInput {
+				lastInput = sstate
+				fmt.Printf("new DI state: %#b\n", sstate)
+			}
+		}
+		if state {
+			led.High()
+		} else {
+			led.Low()
+		}
+		time.Sleep(time.Millisecond * 10)
+	}
+	return nil
+}

examples/pcf8563/alarm/main.go

@@ -0,0 +1,45 @@
+package main
+
+import (
+	"fmt"
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/pcf8563"
+)
+
+var (
+	i2c = machine.I2C0
+	rtc = pcf8563.New(i2c)
+)
+
+func main() {
+	i2c.Configure(machine.I2CConfig{Frequency: machine.TWI_FREQ_400KHZ})
+	rtc.Reset()
+
+	time.Sleep(3 * time.Second)
+	rtc.SetTime(time.Date(2006, 1, 2, 15, 4, 50, 0, time.UTC))
+
+	rtc.SetAlarm(time.Date(2006, 1, 2, 15, 5, 0, 0, time.UTC))
+	rtc.EnableAlarmInterrupt()
+
+	prev := -1
+
+	for {
+		for {
+			t, _ := rtc.ReadTime()
+			if prev != t.Second() {
+				fmt.Printf("%s\r\n", t.String())
+				prev = t.Second()
+
+				if rtc.AlarmTriggered() {
+					fmt.Printf("alarm triggered\r\n")
+					rtc.ClearAlarm()
+				}
+
+				break
+			}
+			time.Sleep(time.Millisecond * 100)
+		}
+	}
+}

examples/pcf8563/clkout/main.go

@@ -0,0 +1,31 @@
+package main
+
+import (
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/pcf8563"
+)
+
+var (
+	i2c = machine.I2C0
+	rtc = pcf8563.New(i2c)
+)
+
+func main() {
+	i2c.Configure(machine.I2CConfig{Frequency: machine.TWI_FREQ_400KHZ})
+	rtc.Reset()
+
+	for {
+		rtc.SetOscillatorFrequency(pcf8563.RTC_COT_1HZ)
+		time.Sleep(3 * time.Second)
+		rtc.SetOscillatorFrequency(pcf8563.RTC_COT_32HZ)
+		time.Sleep(3 * time.Second)
+		rtc.SetOscillatorFrequency(pcf8563.RTC_COT_1KHZ)
+		time.Sleep(3 * time.Second)
+		rtc.SetOscillatorFrequency(pcf8563.RTC_COT_32KHZ)
+		time.Sleep(3 * time.Second)
+		rtc.SetOscillatorFrequency(pcf8563.RTC_COT_DISABLE)
+		time.Sleep(3 * time.Second)
+	}
+}

examples/pcf8563/time/main.go

@@ -0,0 +1,36 @@
+package main
+
+import (
+	"fmt"
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/pcf8563"
+)
+
+var (
+	i2c = machine.I2C0
+	rtc = pcf8563.New(i2c)
+)
+
+func main() {
+	i2c.Configure(machine.I2CConfig{Frequency: machine.TWI_FREQ_400KHZ})
+	rtc.Reset()
+
+	rtc.SetTime(time.Date(2006, 1, 2, 15, 4, 5, 0, time.UTC))
+
+	prev := -1
+
+	for {
+		for {
+			t, _ := rtc.ReadTime()
+			if prev != t.Second() {
+				fmt.Printf("%s\r\n", t.String())
+				prev = t.Second()
+				break
+			}
+			time.Sleep(time.Millisecond * 100)
+		}
+	}
+
+}

examples/pcf8563/timer/main.go

@@ -0,0 +1,46 @@
+package main
+
+import (
+	"fmt"
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/pcf8563"
+)
+
+var (
+	i2c = machine.I2C0
+	rtc = pcf8563.New(i2c)
+)
+
+func main() {
+	i2c.Configure(machine.I2CConfig{Frequency: machine.TWI_FREQ_400KHZ})
+	rtc.Reset()
+
+	time.Sleep(3 * time.Second)
+	rtc.SetTime(time.Date(2006, 1, 2, 15, 4, 5, 0, time.UTC))
+
+	rtc.SetTimer(15 * time.Second)
+	rtc.EnableTimerInterrupt()
+
+	prev := -1
+
+	for {
+		for {
+			t, _ := rtc.ReadTime()
+			if prev != t.Second() {
+				fmt.Printf("%s\r\n", t.String())
+				prev = t.Second()
+
+				if rtc.TimerTriggered() {
+					fmt.Printf("timer triggered\r\n")
+					rtc.ClearTimer()
+					rtc.SetTimer(10 * time.Second)
+				}
+
+				break
+			}
+			time.Sleep(time.Millisecond * 100)
+		}
+	}
+}

examples/servo/servo.go

@@ -0,0 +1,43 @@
+package main
+
+import (
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/servo"
+)
+
+// Configuration for the Arduino Uno.
+// Please change the PWM and pin if you want to try this example on a different
+// board.
+var (
+	pwm = machine.Timer1
+	pin = machine.D9
+)
+
+func main() {
+	s, err := servo.New(pwm, pin)
+	if err != nil {
+		for {
+			println("could not configure servo")
+			time.Sleep(time.Second)
+		}
+		return
+	}
+
+	println("setting to 0°")
+	s.SetMicroseconds(1000)
+	time.Sleep(3 * time.Second)
+
+	println("setting to 45°")
+	s.SetMicroseconds(1500)
+	time.Sleep(3 * time.Second)
+
+	println("setting to 90°")
+	s.SetMicroseconds(2000)
+	time.Sleep(3 * time.Second)
+
+	for {
+		time.Sleep(time.Second)
+	}
+}

examples/ssd1306/i2c_128x64/main.go

@@ -0,0 +1,60 @@
+// This example shows how to use 128x64 display over I2C
+// Tested on Seeeduino XIAO Expansion Board https://wiki.seeedstudio.com/Seeeduino-XIAO-Expansion-Board/
+//
+// According to manual, I2C address of the display is 0x78, but that's 8-bit address.
+// TinyGo operates on 7-bit addresses and respective 7-bit address would be 0x3C, which we use below.
+//
+// To learn more about different types of I2C addresses, please see following page
+// https://www.totalphase.com/support/articles/200349176-7-bit-8-bit-and-10-bit-I2C-Slave-Addressing
+
+package main
+
+import (
+	"machine"
+
+	"image/color"
+	"time"
+
+	"tinygo.org/x/drivers/ssd1306"
+)
+
+func main() {
+	machine.I2C0.Configure(machine.I2CConfig{
+		Frequency: machine.TWI_FREQ_400KHZ,
+	})
+
+	display := ssd1306.NewI2C(machine.I2C0)
+	display.Configure(ssd1306.Config{
+		Address: 0x3C,
+		Width:   128,
+		Height:  64,
+	})
+
+	display.ClearDisplay()
+
+	x := int16(0)
+	y := int16(0)
+	deltaX := int16(1)
+	deltaY := int16(1)
+	for {
+		pixel := display.GetPixel(x, y)
+		c := color.RGBA{255, 255, 255, 255}
+		if pixel {
+			c = color.RGBA{0, 0, 0, 255}
+		}
+		display.SetPixel(x, y, c)
+		display.Display()
+
+		x += deltaX
+		y += deltaY
+
+		if x == 0 || x == 127 {
+			deltaX = -deltaX
+		}
+
+		if y == 0 || y == 63 {
+			deltaY = -deltaY
+		}
+		time.Sleep(1 * time.Millisecond)
+	}
+}

examples/tm1637/main.go

@@ -0,0 +1,40 @@
+package main
+
+import (
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/tm1637"
+)
+
+func main() {
+
+	tm := tm1637.New(machine.D2, machine.D3, 7) // clk, dio, brightness
+	tm.Configure()
+
+	tm.ClearDisplay()
+
+	tm.DisplayText([]byte("Tiny"))
+	time.Sleep(time.Millisecond * 1000)
+
+	tm.ClearDisplay()
+
+	tm.DisplayChr(byte('G'), 1)
+	tm.DisplayDigit(0, 2) // looks like O
+	time.Sleep(time.Millisecond * 1000)
+
+	tm.DisplayClock(12, 59, true)
+
+	for i := uint8(0); i < 8; i++ {
+		tm.Brightness(i)
+		time.Sleep(time.Millisecond * 200)
+	}
+
+	i := int16(0)
+	for {
+		tm.DisplayNumber(i)
+		i++
+		time.Sleep(time.Millisecond * 50)
+	}
+
+}

examples/tone/tone.go

@@ -0,0 +1,33 @@
+package main
+
+import (
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/tone"
+)
+
+var (
+	// Configuration for the Adafruit Circuit Playground Bluefruit.
+	pwm = machine.PWM0
+	pin = machine.D12
+)
+
+func main() {
+	speaker, err := tone.New(pwm, pin)
+	if err != nil {
+		println("failed to configure PWM")
+		return
+	}
+
+	// Two tone siren.
+	for {
+		println("nee")
+		speaker.SetNote(tone.B5)
+		time.Sleep(time.Second / 2)
+
+		println("naw")
+		speaker.SetNote(tone.A5)
+		time.Sleep(time.Second / 2)
+	}
+}

examples/wifinina/connect/main.go

@@ -0,0 +1,130 @@
+// This example connects to Access Point and prints some info
+package main
+
+import (
+	"encoding/binary"
+	"fmt"
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/wifinina"
+)
+
+// access point info
+const ssid = ""
+const pass = ""
+
+// 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
+)
+
+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()
+
+	waitSerial()
+
+	connectToAP()
+
+	for {
+		println("---------------------------------")
+		printIPs()
+		printTime()
+		printMacAddress()
+		time.Sleep(10 * time.Second)
+	}
+
+}
+
+func printIPs() {
+	ip, subnet, gateway, err := adaptor.GetIP()
+	if err != nil {
+		println("IP: Unknown (error: ", err.Error(), ")")
+		return
+	}
+	println("IP: ", ip.String())
+	println("Subnet: ", subnet.String())
+	println("Gateway IP: ", gateway.String())
+}
+
+func printTime() {
+	print("Time: ")
+	t, err := adaptor.GetTime()
+	if err != nil {
+		println("Unknown (error: ", err.Error(), ")")
+	}
+	println(time.Unix(int64(t), 0).String())
+}
+
+func printMacAddress() {
+	print("MAC Address: ")
+	b := make([]byte, 8)
+	mac, err := adaptor.GetMACAddress()
+	if err != nil {
+		println("Unknown (", err.Error(), ")")
+	}
+	binary.LittleEndian.PutUint64(b, uint64(mac))
+	macAddress := ""
+	for i := 5; i >= 0; i-- {
+		macAddress += fmt.Sprintf("%0X", b[i])
+		if i != 0 {
+			macAddress += ":"
+		}
+	}
+	println(macAddress)
+}
+
+// Wait for user to open serial console
+func waitSerial() {
+	for !machine.UART0.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.")
+}
+
+func message(msg string) {
+	println(msg, "\r")
+}

examples/wifinina/mqttclient/main.go

@@ -35,10 +35,7 @@ const server = "tcp://test.mosquitto.org:1883"
 var (
 
 	// these are the default pins for the Arduino Nano33 IoT.
-	uart = machine.UART2
-	tx   = machine.NINA_TX
-	rx   = machine.NINA_RX
-	spi  = machine.NINA_SPI
+	spi = machine.NINA_SPI
 
 	// this is the ESP chip that has the WIFININA firmware flashed on it
 	adaptor *wifinina.Device
@@ -48,7 +45,6 @@ var (
 func main() {
 	time.Sleep(3000 * time.Millisecond)
 
-	uart.Configure(machine.UARTConfig{TX: tx, RX: rx})
 	rand.Seed(time.Now().UnixNano())
 
 	// Configure SPI for 8Mhz, Mode 0, MSB First
@@ -94,7 +90,7 @@ func main() {
 				println(err.Error())
 			}
 		}
-		time.Sleep(1 * time.Millisecond)
+		time.Sleep(100 * time.Millisecond)
 	}
 
 	// Right now this code is never reached. Need a way to trigger it...

examples/wifinina/mqttsub/main.go

@@ -32,12 +32,8 @@ const server = "tcp://test.mosquitto.org:1883"
 
 // 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.
-	uart = machine.UART2
-	tx   = machine.NINA_TX
-	rx   = machine.NINA_RX
-	spi  = machine.NINA_SPI
+	spi = machine.NINA_SPI
 
 	// this is the ESP chip that has the WIFININA firmware flashed on it
 	adaptor *wifinina.Device
@@ -55,7 +51,6 @@ func subHandler(client mqtt.Client, msg mqtt.Message) {
 func main() {
 	time.Sleep(3000 * time.Millisecond)
 
-	uart.Configure(machine.UARTConfig{TX: tx, RX: rx})
 	rand.Seed(time.Now().UnixNano())
 
 	// Configure SPI for 8Mhz, Mode 0, MSB First

examples/wifinina/ntpclient/main.go

@@ -23,33 +23,41 @@ const ntpHost = "129.6.15.29"
 
 const NTP_PACKET_SIZE = 48
 
+// 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
 	b       = make([]byte, NTP_PACKET_SIZE)
 )
 
-func main() {
-
-	// Init esp32
+func setup() {
 	// Configure SPI for 8Mhz, Mode 0, MSB First
-	machine.NINA_SPI.Configure(machine.SPIConfig{
+	spi.Configure(machine.SPIConfig{
 		Frequency: 8 * 1e6,
 		SDO:       machine.NINA_SDO,
 		SDI:       machine.NINA_SDI,
 		SCK:       machine.NINA_SCK,
 	})
 
-	// these are the default pins for the Arduino Nano33 IoT.
-	adaptor = wifinina.New(machine.NINA_SPI,
+	adaptor = wifinina.New(spi,
 		machine.NINA_CS,
 		machine.NINA_ACK,
 		machine.NINA_GPIO0,
 		machine.NINA_RESETN)
-
 	adaptor.Configure()
+}
+
+func main() {
+
+	setup()
+
+	waitSerial()
 
-	// connect to access point
 	connectToAP()
 
 	// now make UDP connection
@@ -80,10 +88,13 @@ func main() {
 		}
 	}
 
-	// Right now this code is never reached. Need a way to trigger it...
-	println("Disconnecting UDP...")
-	conn.Close()
-	println("Done.")
+}
+
+// Wait for user to open serial console
+func waitSerial() {
+	for !machine.UART0.DTR() {
+		time.Sleep(100 * time.Millisecond)
+	}
 }
 
 func getCurrentTime(conn *net.UDPSerialConn) (time.Time, error) {
@@ -140,6 +151,12 @@ func clearBuffer() {
 
 // 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)

examples/wifinina/tcpclient/main.go

@@ -29,10 +29,7 @@ const serverIP = ""
 var (
 
 	// these are the default pins for the Arduino Nano33 IoT.
-	uart = machine.UART2
-	tx   = machine.NINA_TX
-	rx   = machine.NINA_RX
-	spi  = machine.NINA_SPI
+	spi = machine.NINA_SPI
 
 	// this is the ESP chip that has the WIFININA firmware flashed on it
 	adaptor *wifinina.Device
@@ -42,8 +39,6 @@ var buf = &bytes.Buffer{}
 
 func main() {
 
-	uart.Configure(machine.UARTConfig{TX: tx, RX: rx})
-
 	// Configure SPI for 8Mhz, Mode 0, MSB First
 	spi.Configure(machine.SPIConfig{
 		Frequency: 8 * 1e6,

examples/wifinina/tlsclient/main.go

@@ -0,0 +1,151 @@
+// This example opens a TCP connection using a device with WiFiNINA firmware
+// and sends a HTTPS request to retrieve a webpage
+//
+// You shall see "strict-transport-security" header in the response,
+// this confirms communication is indeed over HTTPS
+// https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Strict-Transport-Security
+//
+package main
+
+import (
+	"fmt"
+	"machine"
+	"strings"
+	"time"
+
+	"tinygo.org/x/drivers/net"
+	"tinygo.org/x/drivers/net/tls"
+	"tinygo.org/x/drivers/wifinina"
+)
+
+// access point info
+const ssid = ""
+const pass = ""
+
+// IP address of the server aka "hub". Replace with your own info.
+const server = "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 [256]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()
+
+	waitSerial()
+
+	connectToAP()
+
+	for {
+		readConnection()
+		if time.Now().Sub(lastRequestTime).Milliseconds() >= 10000 {
+			makeHTTPSRequest()
+		}
+	}
+
+}
+
+// Wait for user to open serial console
+func waitSerial() {
+	for !machine.UART0.DTR() {
+		time.Sleep(100 * time.Millisecond)
+	}
+}
+
+func readConnection() {
+	if conn != nil {
+		for n, err := conn.Read(buf[:]); n > 0; n, err = conn.Read(buf[:]) {
+			if err != nil {
+				println("Read error: " + err.Error())
+			} else {
+				print(string(buf[0:n]))
+			}
+		}
+	}
+}
+
+func makeHTTPSRequest() {
+
+	var err error
+	if conn != nil {
+		conn.Close()
+	}
+
+	message("\r\n---------------\r\nDialing TCP connection")
+	conn, err = tls.Dial("tcp", server, nil)
+	for ; err != nil; conn, err = tls.Dial("tcp", server, nil) {
+		message("Connection failed: " + err.Error())
+		time.Sleep(5 * time.Second)
+	}
+	println("Connected!\r")
+
+	print("Sending HTTPS request...")
+	fmt.Fprintln(conn, "GET / HTTP/1.1")
+	fmt.Fprintln(conn, "Host:", strings.Split(server, ":")[0])
+	fmt.Fprintln(conn, "User-Agent: TinyGo")
+	fmt.Fprintln(conn, "Connection: close")
+	fmt.Fprintln(conn)
+	println("Sent!\r\n\r")
+
+	lastRequestTime = time.Now()
+}
+
+// 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/webclient/main.go

@@ -27,10 +27,7 @@ const server = "tinygo.org"
 var (
 
 	// these are the default pins for the Arduino Nano33 IoT.
-	uart = machine.UART2
-	tx   = machine.NINA_TX
-	rx   = machine.NINA_RX
-	spi  = machine.NINA_SPI
+	spi = machine.NINA_SPI
 
 	// this is the ESP chip that has the WIFININA firmware flashed on it
 	adaptor *wifinina.Device
@@ -41,10 +38,7 @@ var buf [256]byte
 var lastRequestTime time.Time
 var conn net.Conn
 
-func main() {
-
-	uart.Configure(machine.UARTConfig{TX: tx, RX: rx})
-
+func setup() {
 	// Configure SPI for 8Mhz, Mode 0, MSB First
 	spi.Configure(machine.SPIConfig{
 		Frequency: 8 * 1e6,
@@ -59,16 +53,33 @@ func main() {
 		machine.NINA_GPIO0,
 		machine.NINA_RESETN)
 	adaptor.Configure()
+}
+
+func main() {
+
+	setup()
+
+	waitSerial()
 
 	connectToAP()
 
 	for {
-		loop()
+		readConnection()
+		if time.Now().Sub(lastRequestTime).Milliseconds() >= 10000 {
+			makeHTTPRequest()
+		}
 	}
-	println("Done.")
+
 }
 
-func loop() {
+// Wait for user to open serial console
+func waitSerial() {
+	for !machine.UART0.DTR() {
+		time.Sleep(100 * time.Millisecond)
+	}
+}
+
+func readConnection() {
 	if conn != nil {
 		for n, err := conn.Read(buf[:]); n > 0; n, err = conn.Read(buf[:]) {
 			if err != nil {
@@ -78,9 +89,6 @@ func loop() {
 			}
 		}
 	}
-	if time.Now().Sub(lastRequestTime).Milliseconds() >= 10000 {
-		makeHTTPRequest()
-	}
 }
 
 func makeHTTPRequest() {
@@ -98,7 +106,7 @@ func makeHTTPRequest() {
 	message("\r\n---------------\r\nDialing TCP connection")
 	conn, err = net.DialTCP("tcp", laddr, raddr)
 	for ; err != nil; conn, err = net.DialTCP("tcp", laddr, raddr) {
-		message("connection failed: " + err.Error())
+		message("Connection failed: " + err.Error())
 		time.Sleep(5 * time.Second)
 	}
 	println("Connected!\r")
@@ -106,7 +114,7 @@ func makeHTTPRequest() {
 	print("Sending HTTP request...")
 	fmt.Fprintln(conn, "GET / HTTP/1.1")
 	fmt.Fprintln(conn, "Host:", server)
-	fmt.Fprintln(conn, "User-Agent: TinyGo/0.10.0")
+	fmt.Fprintln(conn, "User-Agent: TinyGo")
 	fmt.Fprintln(conn, "Connection: close")
 	fmt.Fprintln(conn)
 	println("Sent!\r\n\r")
@@ -114,19 +122,14 @@ func makeHTTPRequest() {
 	lastRequestTime = time.Now()
 }
 
-func readLine(conn *net.TCPSerialConn) string {
-	println("Attempting to read...\r")
-	b := buf[:]
-	for expiry := time.Now().Unix() + 10; time.Now().Unix() > expiry; {
-		if n, err := conn.Read(b); n > 0 && err == nil {
-			return string(b[0:n])
-		}
-	}
-	return ""
-}
-
 // 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)

flash/flash.go

@@ -290,9 +290,8 @@ func (dev *Device) EraseBlockSize() int64 {
 // supports this. The start and len parameters are in block numbers, use
 // EraseBlockSize to map addresses to blocks.
 func (dev *Device) EraseBlocks(start, len int64) error {
-	// TODO: maybe combine sector erase operations into block erase operations
 	for i := start; i < start+len; i++ {
-		if err := dev.EraseSector(uint32(i)); err != nil {
+		if err := dev.EraseBlock(uint32(i)); err != nil {
 			return err
 		}
 	}

gps/gps.go

@@ -4,7 +4,6 @@ package gps // import "tinygo.org/x/drivers/gps"
 import (
 	"encoding/hex"
 	"errors"
-	"machine"
 	"strings"
 	"time"
 
@@ -21,13 +20,13 @@ type Device struct {
 	buffer   []byte
 	bufIdx   int
 	sentence strings.Builder
-	uart     *machine.UART
+	uart     drivers.UART
 	bus      drivers.I2C
 	address  uint16
 }
 
 // NewUART creates a new UART GPS connection. The UART must already be configured.
-func NewUART(uart *machine.UART) Device {
+func NewUART(uart drivers.UART) Device {
 	return Device{
 		uart:     uart,
 		buffer:   make([]byte, bufferSize),

ina260/ina260.go

@@ -0,0 +1,112 @@
+package ina260
+
+import "tinygo.org/x/drivers"
+
+// Device wraps an I2C connection to an INA260 device.
+type Device struct {
+	bus     drivers.I2C
+	Address uint16
+}
+
+// Config holds the configuration of the INA260 device.
+type Config struct {
+	// One of AVGMODE_XXX
+	AverageMode byte
+
+	// One of CONVTIME_XXXXUSEC
+	VoltConvTime byte
+
+	// One of CONVTIME_XXXXUSEC
+	CurrentConvTime byte
+
+	// Multiple of MODE_XXXX
+	Mode byte
+}
+
+// New creates a new INA260 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: Address,
+	}
+}
+
+// Configure sets up the device.
+//
+// This only needs to be called to override built-in defaults. By default,
+// the device starts with:
+//
+// * AverageMode = AVGMODE_1
+// * VoltConvTime = CONVTIME_1100USEC
+// * CurrentConvTime = CONVTIME_1100USEC
+// * Mode = MODE_CONTINUOUS | MODE_VOLTAGE | MODE_CURRENT
+//
+func (d *Device) Configure(cfg Config) {
+	var val uint16
+
+	val = uint16(cfg.AverageMode&0x7) << 9
+	val |= uint16(cfg.VoltConvTime&0x7) << 6
+	val |= uint16(cfg.CurrentConvTime&0x7) << 3
+	val |= uint16(cfg.Mode & 0x7)
+
+	d.WriteRegister(REG_CONFIG, val)
+}
+
+// Resets the device, setting all registers to default values
+func (d *Device) Reset() {
+	d.WriteRegister(REG_CONFIG, 0x8000)
+}
+
+// Connected returns whether an INA260 has been found.
+func (d *Device) Connected() bool {
+	return d.ReadRegister(REG_MANF_ID) == MANF_ID &&
+		(d.ReadRegister(REG_DIE_ID)&DEVICE_ID_MASK) == DEVICE_ID
+}
+
+// Gets the measured current in µA (max resolution 1.25mA)
+func (d *Device) Current() int32 {
+	val := d.ReadRegister(REG_CURRENT)
+
+	if val&0x8000 == 0 {
+		return int32(val) * 1250
+	}
+
+	// Two's complement, convert to signed int
+	return -(int32(^val) + 1) * 1250
+}
+
+// Gets the measured voltage in µV (max resolution 1.25mV)
+func (d *Device) Voltage() int32 {
+	val := d.ReadRegister(REG_BUSVOLTAGE)
+
+	if val&0x8000 == 0 {
+		return int32(val) * 1250
+	}
+
+	// Two's complement, convert to signed int
+	return -(int32(^val) + 1) * 1250
+}
+
+// Gets the measured power in µW (max resolution 10mW)
+func (d *Device) Power() int32 {
+	return int32(d.ReadRegister(REG_POWER)) * 10000
+}
+
+// Read a register
+func (d *Device) ReadRegister(reg uint8) uint16 {
+	data := []byte{0, 0}
+	d.bus.ReadRegister(uint8(d.Address), reg, data)
+	return (uint16(data[0]) << 8) | uint16(data[1])
+}
+
+// Write to a register
+func (d *Device) WriteRegister(reg uint8, v uint16) {
+	data := []byte{0, 0}
+	data[0] = byte(v >> 8)
+	data[1] = byte(v & 0xff)
+
+	d.bus.WriteRegister(uint8(d.Address), reg, data)
+}

ina260/ina260_test.go

@@ -0,0 +1,80 @@
+package ina260
+
+import (
+	"testing"
+
+	qt "github.com/frankban/quicktest"
+	"tinygo.org/x/drivers/tester"
+)
+
+func TestDefaultI2CAddress(t *testing.T) {
+	c := qt.New(t)
+	bus := tester.NewI2CBus(c)
+	dev := New(bus)
+	c.Assert(dev.Address, qt.Equals, uint16(Address))
+}
+
+func TestConnected(t *testing.T) {
+	c := qt.New(t)
+	bus := tester.NewI2CBus(c)
+	fake := tester.NewI2CDevice16(c, Address)
+	fake.Registers = defaultRegisters()
+	bus.AddDevice(fake)
+
+	dev := New(bus)
+	c.Assert(dev.Connected(), qt.Equals, true)
+}
+
+func TestVoltage(t *testing.T) {
+	c := qt.New(t)
+	bus := tester.NewI2CBus(c)
+	fake := tester.NewI2CDevice16(c, Address)
+	fake.Registers = defaultRegisters()
+	fake.Registers[REG_BUSVOLTAGE] = 0x2570
+	bus.AddDevice(fake)
+
+	dev := New(bus)
+	// Datasheet: 2570h = 11.98V = 11980mV = 11980000uV
+	c.Assert(dev.Voltage(), qt.Equals, int32(11980000))
+}
+
+func TestCurrent(t *testing.T) {
+	c := qt.New(t)
+	bus := tester.NewI2CBus(c)
+	fake := tester.NewI2CDevice16(c, Address)
+	fake.Registers = defaultRegisters()
+	fake.Registers[REG_CURRENT] = 0x2710
+	bus.AddDevice(fake)
+
+	dev := New(bus)
+	// Datasheet: 2710h = 12.5A = 12500mA = 12500000uA
+	c.Assert(dev.Current(), qt.Equals, int32(12500000))
+}
+
+func TestPower(t *testing.T) {
+	c := qt.New(t)
+	bus := tester.NewI2CBus(c)
+	fake := tester.NewI2CDevice16(c, Address)
+	fake.Registers = defaultRegisters()
+	fake.Registers[REG_POWER] = 0x3A7F
+	bus.AddDevice(fake)
+
+	dev := New(bus)
+	// 3A7Fh = 149.75W = 149750mW = 149750000uW
+	c.Assert(dev.Power(), qt.Equals, int32(149750000))
+}
+
+// defaultRegisters returns the default values for all of the device's registers.
+// set TI INA260 datasheet for power-on defaults
+func defaultRegisters() map[uint8]uint16 {
+	return map[uint8]uint16{
+		REG_CONFIG:     0x6127,
+		REG_CURRENT:    0x0000,
+		REG_BUSVOLTAGE: 0x0000,
+		REG_POWER:      0x0000,
+		REG_MASKENABLE: 0x0000,
+		REG_ALERTLIMIT: 0x0000,
+		REG_MANF_ID:    0x5449,
+		REG_DIE_ID:     0x2270,
+	}
+}

ina260/registers.go

@@ -0,0 +1,50 @@
+package ina260
+
+// The default I2C address for this device.
+//
+// The actual address is configurable by connecting address pins.
+const Address = 0x40
+
+// Registers
+const (
+	REG_CONFIG     = 0x00
+	REG_CURRENT    = 0x01
+	REG_BUSVOLTAGE = 0x02
+	REG_POWER      = 0x03
+	REG_MASKENABLE = 0x06
+	REG_ALERTLIMIT = 0x07
+	REG_MANF_ID    = 0xFE
+	REG_DIE_ID     = 0xFF
+)
+
+// Well-Known Values
+const (
+	MANF_ID        = 0x5449 // TI
+	DEVICE_ID      = 0x2270 // 227h
+	DEVICE_ID_MASK = 0xFFF0
+
+	AVGMODE_1    = 0
+	AVGMODE_4    = 1
+	AVGMODE_16   = 2
+	AVGMODE_64   = 3
+	AVGMODE_128  = 4
+	AVGMODE_256  = 5
+	AVGMODE_512  = 6
+	AVGMODE_1024 = 7
+
+	CONVTIME_140USEC  = 0
+	CONVTIME_204USEC  = 1
+	CONVTIME_332USEC  = 2
+	CONVTIME_588USEC  = 3
+	CONVTIME_1100USEC = 4 // 1.1 ms
+	CONVTIME_2116USEC = 5 // 2.1 ms
+	CONVTIME_4156USEC = 6 // 4.2 ms
+	CONVTIME_8244USEC = 7 // 8.2 ms
+
+	MODE_CONTINUOUS = 0x4
+	MODE_TRIGGERED  = 0x0
+	MODE_VOLTAGE    = 0x2
+	MODE_NO_VOLTAGE = 0x0
+	MODE_CURRENT    = 0x1
+	MODE_NO_CURRENT = 0x0
+)

keypad4x4/keypad4x4.go

@@ -0,0 +1,107 @@
+package keypad4x4
+
+import (
+	"machine"
+)
+
+// NoKeyPressed is used, when no key was pressed
+const NoKeyPressed = 255
+
+// Device is used as 4x4 keypad driver
+type Device interface {
+	Configure()
+	GetKey() uint8
+	GetIndices() (int, int)
+}
+
+// device is a driver for 4x4 keypads
+type device struct {
+	inputEnabled bool
+	lastColumn   int
+	lastRow      int
+	columns      [4]machine.Pin
+	rows         [4]machine.Pin
+	mapping      [4][4]uint8
+}
+
+// takes r4 -r1 pins and c4 - c1 pins
+func NewDevice(r4, r3, r2, r1, c4, c3, c2, c1 machine.Pin) Device {
+	result := &device{}
+	result.columns = [4]machine.Pin{c4, c3, c2, c1}
+	result.rows = [4]machine.Pin{r4, r3, r2, r1}
+
+	return result
+}
+
+// Configure sets the column pins as input and the row pins as output
+func (keypad *device) Configure() {
+	inputConfig := machine.PinConfig{Mode: machine.PinInputPullup}
+	for i := range keypad.columns {
+		keypad.columns[i].Configure(inputConfig)
+	}
+
+	outputConfig := machine.PinConfig{Mode: machine.PinOutput}
+	for i := range keypad.rows {
+		keypad.rows[i].Configure(outputConfig)
+		keypad.rows[i].High()
+	}
+
+	keypad.mapping = [4][4]uint8{
+		{0, 1, 2, 3},
+		{4, 5, 6, 7},
+		{8, 9, 10, 11},
+		{12, 13, 14, 15},
+	}
+
+	keypad.inputEnabled = true
+	keypad.lastColumn = -1
+	keypad.lastRow = -1
+}
+
+// GetKey returns the code for the given key.
+// The codes start with 0 at the upper left end of the keypad and end with 15 at the lower right end of the keypad
+// Example:
+// 0	1	2	3
+// 4	5	6	7
+// 8	9	10	11
+// 12	13	14	15
+// returns 255 for no keyPressed
+func (keypad *device) GetKey() uint8 {
+	row, column := keypad.GetIndices()
+	if row == -1 && column == -1 {
+		return NoKeyPressed
+	}
+
+	return keypad.mapping[row][column]
+}
+
+// GetIndices returns the position of the pressed key
+func (keypad *device) GetIndices() (int, int) {
+	for rowIndex, rowPin := range keypad.rows {
+		rowPin.Low()
+
+		for columnIndex := range keypad.columns {
+			columnPin := keypad.columns[columnIndex]
+
+			if !columnPin.Get() && keypad.inputEnabled {
+				keypad.inputEnabled = false
+
+				keypad.lastColumn = columnIndex
+				keypad.lastRow = rowIndex
+
+				return keypad.lastRow, keypad.lastColumn
+			}
+
+			if columnPin.Get() &&
+				columnIndex == keypad.lastColumn &&
+				rowIndex == keypad.lastRow &&
+				!keypad.inputEnabled {
+				keypad.inputEnabled = true
+			}
+		}
+
+		rowPin.High()
+	}
+
+	return -1, -1
+}

l293x/l293x.go

@@ -56,49 +56,71 @@ func (d *Device) Stop() {
 	d.en.Low()
 }
 
+// PWM is the interface necessary for controlling the motor driver.
+type PWM interface {
+	Configure(config machine.PWMConfig) error
+	Channel(pin machine.Pin) (channel uint8, err error)
+	Top() uint32
+	Set(channel uint8, value uint32)
+	SetPeriod(period uint64) error
+}
+
 // PWMDevice is a motor with speed control.
 // a1 and a2 are the directional GPIO pins.
 // en is the PWM pin that controls the motor speed.
 type PWMDevice struct {
 	a1, a2 machine.Pin
-	en     machine.PWM
+	spc    uint8
+	pwm    PWM
 }
 
-// NewWithSpeed returns a new PWMMotor driver that uses a PWM pin to control speed.
-func NewWithSpeed(direction1, direction2 machine.Pin, speedPin machine.PWM) PWMDevice {
+// NewWithSpeed returns a new PWMMotor driver that uses an already configured PWM channel
+// to control speed.
+func NewWithSpeed(direction1, direction2 machine.Pin, spc uint8, pwm PWM) PWMDevice {
 	return PWMDevice{
-		a1: direction1,
-		a2: direction2,
-		en: speedPin,
+		a1:  direction1,
+		a2:  direction2,
+		spc: spc,
+		pwm: pwm,
 	}
 }
 
-// Configure configures the PWMDevice.
-func (d *PWMDevice) Configure() {
+// Configure configures the PWMDevice. Note that the PWM interface and
+// channel must already be configured, this function will not do it for you.
+func (d *PWMDevice) Configure() error {
 	d.a1.Configure(machine.PinConfig{Mode: machine.PinOutput})
 	d.a2.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	d.en.Configure()
 
 	d.Stop()
+
+	return nil
 }
 
-// Forward turns motor on in forward direction at specific speed.
-func (d *PWMDevice) Forward(speed uint16) {
+// Forward turns motor on in forward direction at specific speed as a percentage.
+func (d *PWMDevice) Forward(speed uint32) {
+	if speed > 100 {
+		speed = 100
+	}
+
 	d.a1.High()
 	d.a2.Low()
-	d.en.Set(speed)
+	d.pwm.Set(d.spc, d.pwm.Top()*speed/100)
 }
 
-// Backward turns motor on in backward direction at specific speed.
-func (d *PWMDevice) Backward(speed uint16) {
+// Backward turns motor on in backward direction at specific speed as a percentage.
+func (d *PWMDevice) Backward(speed uint32) {
+	if speed > 100 {
+		speed = 100
+	}
+
 	d.a1.Low()
 	d.a2.High()
-	d.en.Set(speed)
+	d.pwm.Set(d.spc, d.pwm.Top()*speed/100)
 }
 
 // Stop turns motor off.
 func (d *PWMDevice) Stop() {
 	d.a1.Low()
 	d.a2.Low()
-	d.en.Set(0)
+	d.pwm.Set(d.spc, 0)
 }

l9110x/l9110x.go

@@ -49,42 +49,52 @@ func (d *Device) Stop() {
 	d.ib.Low()
 }
 
+// PWM is the interface necessary for controlling the motor driver.
+type PWM interface {
+	Configure(config machine.PWMConfig) error
+	Channel(pin machine.Pin) (channel uint8, err error)
+	Top() uint32
+	Set(channel uint8, value uint32)
+	SetPeriod(period uint64) error
+}
+
 // PWMDevice is a motor with speed control.
 // ia and ib are the directional/speed PWM pins.
 type PWMDevice struct {
-	ia, ib machine.PWM
+	pwm    PWM
+	ca, cb uint8
 }
 
 // NewWithSpeed returns a new PWMMotor driver that uses 2 PWM pins to control both direction and speed.
-func NewWithSpeed(direction1, direction2 machine.PWM) PWMDevice {
+func NewWithSpeed(ca, cb uint8, pwm PWM) PWMDevice {
 	return PWMDevice{
-		ia: direction1,
-		ib: direction2,
+		pwm: pwm,
+		ca:  ca,
+		cb:  cb,
 	}
 }
 
-// Configure configures the PWMDevice.
-func (d *PWMDevice) Configure() {
-	d.ia.Configure()
-	d.ib.Configure()
-
+// Configure configures the PWMDevice. Note that the pins, PWM interface,
+// and channels must all already be configured.
+func (d *PWMDevice) Configure() (err error) {
 	d.Stop()
+	return
 }
 
-// Forward turns motor on in forward direction at specific speed.
-func (d *PWMDevice) Forward(speed uint16) {
-	d.ia.Set(speed)
-	d.ib.Set(0)
+// Forward turns motor on in forward direction at specific speed as a percentage.
+func (d *PWMDevice) Forward(speed uint32) {
+	d.pwm.Set(d.ca, d.pwm.Top()*speed/100)
+	d.pwm.Set(d.cb, 0)
 }
 
-// Backward turns motor on in backward direction at specific speed.
-func (d *PWMDevice) Backward(speed uint16) {
-	d.ia.Set(0)
-	d.ib.Set(speed)
+// Backward turns motor on in backward direction at specific speed as a percentage.
+func (d *PWMDevice) Backward(speed uint32) {
+	d.pwm.Set(d.ca, 0)
+	d.pwm.Set(d.cb, d.pwm.Top()*speed/100)
 }
 
 // Stop turns motor off.
 func (d *PWMDevice) Stop() {
-	d.ia.Set(0)
-	d.ib.Set(0)
+	d.pwm.Set(d.ca, 0)
+	d.pwm.Set(d.cb, 0)
 }

max72xx/max72xx.go

@@ -0,0 +1,85 @@
+// Driver works for max7219 and 7221
+// Datasheet: https://datasheets.maximintegrated.com/en/ds/MAX7219-MAX7221.pdf
+package max72xx
+
+import (
+	"machine"
+)
+
+type Device struct {
+	bus machine.SPI
+	cs  machine.Pin
+}
+
+// NewDriver creates a new max7219 connection. The SPI wire must already be configured
+// The SPI frequency must not be higher than 10MHz.
+// parameter cs: the datasheet also refers to this pin as "load" pin.
+func NewDevice(bus machine.SPI, cs machine.Pin) *Device {
+	return &Device{
+		bus: bus,
+		cs:  cs,
+	}
+}
+
+// Configure setups the pins.
+func (driver *Device) Configure() {
+	outPutConfig := machine.PinConfig{Mode: machine.PinOutput}
+
+	driver.cs.Configure(outPutConfig)
+}
+
+// SetScanLimit sets the scan limit. Maximum is 8.
+// Example: a 4 digit 7SegmentDisplay has a scan limit of 4
+func (driver *Device) SetScanLimit(digitNumber uint8) {
+	driver.WriteCommand(byte(REG_SCANLIMIT), byte(digitNumber-1))
+}
+
+// SetDecodeMode sets the decode mode for 7 segment displays.
+// digitNumber = 1 -> 1 digit gets decoded
+// digitNumber = 2 or 3, or 4 -> 4 digit are being decoded
+// digitNumber = 8 -> 8 digits are being decoded
+// digitNumber 0 || digitNumber > 8 -> no decoding is being used
+func (driver *Device) SetDecodeMode(digitNumber uint8) {
+	switch digitNumber {
+	case 1: // only decode first digit
+		driver.WriteCommand(REG_DECODE_MODE, 0x01)
+	case 2, 3, 4: //  decode digits 3-0
+		driver.WriteCommand(REG_DECODE_MODE, 0x0F)
+	case 8: // decode 8 digits
+		driver.WriteCommand(REG_DECODE_MODE, 0xFF)
+	default:
+		driver.WriteCommand(REG_DECODE_MODE, 0x00)
+	}
+}
+
+// StartShutdownMode sets the IC into a low power shutdown mode.
+func (driver *Device) StartShutdownMode() {
+	driver.WriteCommand(REG_SHUTDOWN, 0x00)
+}
+
+// StartShutdownMode sets the IC into normal operation mode.
+func (driver *Device) StopShutdownMode() {
+	driver.WriteCommand(REG_SHUTDOWN, 0x01)
+}
+
+// StartDisplayTest starts a display test.
+func (driver *Device) StartDisplayTest() {
+	driver.WriteCommand(REG_DISPLAY_TEST, 0x01)
+}
+
+// StopDisplayTest stops the display test and gets into normal operation mode.
+func (driver *Device) StopDisplayTest() {
+	driver.WriteCommand(REG_DISPLAY_TEST, 0x00)
+}
+
+func (driver *Device) writeByte(data byte) {
+	driver.bus.Transfer(data)
+}
+
+// WriteCommand write data to a given register.
+func (driver *Device) WriteCommand(register, data byte) {
+	driver.cs.Low()
+	driver.writeByte(register)
+	driver.writeByte(data)
+	driver.cs.High()
+}

max72xx/registers.go

@@ -0,0 +1,18 @@
+package max72xx
+
+const (
+	REG_NOOP         byte = 0x00
+	REG_DIGIT0       byte = 0x01
+	REG_DIGIT1       byte = 0x02
+	REG_DIGIT2       byte = 0x03
+	REG_DIGIT3       byte = 0x04
+	REG_DIGIT4       byte = 0x05
+	REG_DIGIT5       byte = 0x06
+	REG_DIGIT6       byte = 0x07
+	REG_DIGIT7       byte = 0x08
+	REG_DECODE_MODE  byte = 0x09 // turn of for led matrix, turn on for digits
+	REG_INTENSITY    byte = 0x0A
+	REG_SCANLIMIT    byte = 0x0B
+	REG_SHUTDOWN     byte = 0x0C // turn on for no shutdown mode
+	REG_DISPLAY_TEST byte = 0x0F // turn off for no display test
+)

mcp23017/device_test.go

@@ -211,7 +211,7 @@ func TestInitWithError(t *testing.T) {
 	c.Assert(dev, qt.IsNil)
 }
 
-func newDevice(bus *tester.I2CBus, addr uint8) *tester.I2CDevice {
+func newDevice(bus *tester.I2CBus, addr uint8) *tester.I2CDevice8 {
 	fdev := bus.NewDevice(addr)
 	// IODIRA and IODIRB are all ones by default.
 	fdev.Registers[rIODIR] = 0xff

mcp2515/mcp2515.go

@@ -0,0 +1,786 @@
+// Package mcp2515 implements a driver for the MCP2515 CAN Controller.
+//
+// Datasheet: http://ww1.microchip.com/downloads/en/DeviceDoc/MCP2515-Stand-Alone-CAN-Controller-with-SPI-20001801J.pdf
+//
+// Reference: https://github.com/coryjfowler/MCP_CAN_lib
+package mcp2515 // import "tinygo.org/x/drivers/mcp2515"
+
+import (
+	"errors"
+	"fmt"
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers"
+)
+
+// Device wraps MCP2515 SPI CAN Module.
+type Device struct {
+	spi     SPI
+	cs      machine.Pin
+	msg     *CANMsg
+	mcpMode byte
+}
+
+// CANMsg stores CAN message fields.
+type CANMsg struct {
+	ID   uint32
+	Dlc  uint8
+	Data []byte
+	Ext  bool
+	Rtr  bool
+}
+
+const (
+	bufferSize int = 64
+)
+
+// New returns a new MCP2515 driver. Pass in a fully configured SPI bus.
+func New(b drivers.SPI, csPin machine.Pin) *Device {
+	d := &Device{
+		spi: SPI{
+			bus: b,
+			tx:  make([]byte, 0, bufferSize),
+			rx:  make([]byte, 0, bufferSize),
+		},
+		cs:  csPin,
+		msg: &CANMsg{},
+	}
+
+	return d
+}
+
+// Configure sets up the device for communication.
+func (d *Device) Configure() {
+	d.cs.Configure(machine.PinConfig{Mode: machine.PinOutput})
+}
+
+const beginTimeoutValue int = 10
+
+// Begin starts the CAN controller.
+func (d *Device) Begin(speed byte, clock byte) error {
+	timeOutCount := 0
+	for {
+		err := d.init(speed, clock)
+		if err == nil {
+			break
+		}
+		timeOutCount++
+		if timeOutCount >= beginTimeoutValue {
+			return err
+		}
+	}
+	return nil
+}
+
+// Received returns true if CAN message is received.
+func (d *Device) Received() bool {
+	res, err := d.readStatus()
+	if err != nil {
+		panic(err)
+	}
+	// if RX STATUS INSTRUCTION  result is not 0x00 (= No RX message)
+	// TODO: reconsider this logic
+	return (res & mcpStatRxifMask) != 0x00
+}
+
+// Rx returns received CAN message.
+func (d *Device) Rx() (*CANMsg, error) {
+	err := d.readMsg()
+	return d.msg, err
+}
+
+// Tx transmits CAN Message.
+func (d *Device) Tx(canid uint32, dlc uint8, data []byte) error {
+	// TODO: add ext, rtrBit, waitSent
+	timeoutCount := 0
+
+	var bufNum, res uint8
+	var err error
+	res = mcpAlltxbusy
+	for res == mcpAlltxbusy && (timeoutCount < timeoutvalue) {
+		if timeoutCount > 0 {
+			time.Sleep(time.Microsecond * 10)
+		}
+		bufNum, res, err = d.getNextFreeTxBuf()
+		if err != nil {
+			return err
+		}
+		timeoutCount++
+	}
+	if timeoutCount == timeoutvalue {
+		return fmt.Errorf("Tx: Tx timeout")
+	}
+	err = d.writeCANMsg(bufNum, canid, 0, 0, dlc, data)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (d *Device) init(speed, clock byte) error {
+	err := d.Reset()
+	if err != nil {
+		return err
+	}
+
+	if err := d.setCANCTRLMode(modeConfig); err != nil {
+		return fmt.Errorf("setCANCTRLMode %s: ", err)
+	}
+	time.Sleep(time.Millisecond * 10)
+
+	// set baudrate
+	if err := d.configRate(speed, clock); err != nil {
+		return fmt.Errorf("configRate %s: ", err)
+	}
+	time.Sleep(time.Millisecond * 10)
+
+	if err := d.initCANBuffers(); err != nil {
+		return fmt.Errorf("initCANBuffers: %s ", err)
+	}
+	if err := d.setRegister(mcpCANINTE, mcpRX0IF|mcpRX1IF); err != nil {
+		return fmt.Errorf("setRegister: %s ", err)
+	}
+	if err := d.modifyRegister(mcpRXB0CTRL, mcpRxbRxMask|mcpRxbBuktMask, mcpRxbRxStdExt|mcpRxbBuktMask); err != nil {
+		return fmt.Errorf("modifyRegister: %s ", err)
+	}
+	if err := d.modifyRegister(mcpRXB1CTRL, mcpRxbRxMask, mcpRxbRxStdExt); err != nil {
+		return fmt.Errorf("modifyRegister: %s ", err)
+	}
+
+	if err := d.setMode(modeNormal); err != nil {
+		return fmt.Errorf("setMode %s: ", err)
+	}
+	time.Sleep(time.Millisecond * 10)
+
+	return nil
+}
+
+// Reset resets mcp2515.
+func (d *Device) Reset() error {
+	d.cs.Low()
+	_, err := d.spi.readWrite(mcpReset)
+	d.cs.High()
+	// time.Sleep(time.Microsecond * 4)
+	if err != nil {
+		return err
+	}
+
+	time.Sleep(time.Millisecond * 10)
+
+	return nil
+}
+
+func (d *Device) setCANCTRLMode(newMode byte) error {
+	// If the chip is asleep and we want to change mode then a manual wake needs to be done
+	// This is done by setting the wake up interrupt flag
+	// This undocumented trick was found at https://github.com/mkleemann/can/blob/master/can_sleep_mcp2515.c
+	m, err := d.getMode()
+	if err != nil {
+		return err
+	}
+	if m == modeSleep && newMode != modeSleep {
+		r, err := d.readRegister(mcpCANINTE)
+		if err != nil {
+			return err
+		}
+		wakeIntEnabled := (r & mcpWAKIF) == 0x00
+		if !wakeIntEnabled {
+			d.modifyRegister(mcpCANINTE, mcpWAKIF, mcpWAKIF)
+		}
+		// Set wake flag (this does the actual waking up)
+		d.modifyRegister(mcpCANINTF, mcpWAKIF, mcpWAKIF)
+
+		// Wait for the chip to exit SLEEP and enter LISTENONLY mode.
+
+		// If the chip is not connected to a CAN bus (or the bus has no other powered nodes) it will sometimes trigger the wake interrupt as soon
+		// as it's put to sleep, but it will stay in SLEEP mode instead of automatically switching to LISTENONLY mode.
+		// In this situation the mode needs to be manually set to LISTENONLY.
+
+		if err := d.requestNewMode(modeListenOnly); err != nil {
+			return err
+		}
+
+		// Turn wake interrupt back off if it was originally off
+		if !wakeIntEnabled {
+			d.modifyRegister(mcpCANINTE, mcpWAKIF, 0)
+		}
+	}
+
+	// Clear wake flag
+	d.modifyRegister(mcpCANINTF, mcpWAKIF, 0)
+
+	return d.requestNewMode(newMode)
+}
+
+func (d *Device) setMode(opMode byte) error {
+	if opMode != modeSleep {
+		d.mcpMode = opMode
+	}
+
+	err := d.setCANCTRLMode(opMode)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (d *Device) getMode() (byte, error) {
+	r, err := d.readRegister(mcpCANSTAT)
+	if err != nil {
+		return 0, err
+	}
+	return r & modeMask, nil
+}
+
+func (d *Device) configRate(speed, clock byte) error {
+	// TODO: add another baudrate
+	var cfg1, cfg2, cfg3 byte
+	set := true
+	switch clock {
+	case Clock16MHz:
+		switch speed {
+		case CAN500kBps:
+			cfg1 = mcp16mHz500kBpsCfg1
+			cfg2 = mcp16mHz500kBpsCfg2
+			cfg3 = mcp16mHz500kBpsCfg3
+		case CAN1000kBps:
+			cfg1 = mcp16mHz1000kBpsCfg1
+			cfg2 = mcp16mHz1000kBpsCfg2
+			cfg3 = mcp16mHz1000kBpsCfg3
+		default:
+			set = false
+		}
+	case Clock8MHz:
+		switch speed {
+		case CAN500kBps:
+			cfg1 = mcp8mHz500kBpsCfg1
+			cfg2 = mcp8mHz500kBpsCfg2
+			cfg3 = mcp8mHz500kBpsCfg3
+		case CAN1000kBps:
+			cfg1 = mcp8mHz1000kBpsCfg1
+			cfg2 = mcp8mHz1000kBpsCfg2
+			cfg3 = mcp8mHz1000kBpsCfg3
+		default:
+			set = false
+		}
+	default:
+		set = false
+	}
+	if !set {
+		return errors.New("invalid parameter")
+	}
+	if err := d.setRegister(mcpCNF1, cfg1); err != nil {
+		return err
+	}
+	if err := d.setRegister(mcpCNF2, cfg2); err != nil {
+		return err
+	}
+	if err := d.setRegister(mcpCNF3, cfg3); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (d *Device) initCANBuffers() error {
+	a1 := byte(mcpTXB0CTRL)
+	a2 := byte(mcpTXB1CTRL)
+	a3 := byte(mcpTXB2CTRL)
+	for i := 0; i < 14; i++ {
+		if err := d.setRegister(a1, 0); err != nil {
+			return err
+		}
+		if err := d.setRegister(a2, 0); err != nil {
+			return err
+		}
+		if err := d.setRegister(a3, 0); err != nil {
+			return err
+		}
+		a1++
+		a2++
+		a3++
+	}
+
+	if err := d.setRegister(mcpRXB0CTRL, 0); err != nil {
+		return err
+	}
+	if err := d.setRegister(mcpRXB1CTRL, 0); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (d *Device) readMsg() error {
+	status, err := d.readRxTxStatus()
+	if err != nil {
+		return err
+	}
+	if (status & mcpRX0IF) == 0x01 {
+		err := d.readRxBuffer(mcpReadRx0)
+		if err != nil {
+			return err
+		}
+	} else if (status & mcpRX1IF) == 0x02 {
+		err := d.readRxBuffer(mcpReadRx1)
+		if err != nil {
+			return err
+		}
+	} else {
+		return fmt.Errorf("readMsg: nothing is received")
+	}
+
+	return nil
+}
+
+func (d *Device) readRxBuffer(loadAddr uint8) error {
+	msg := d.msg
+	d.cs.Low()
+	defer d.cs.High()
+	_, err := d.spi.readWrite(loadAddr)
+	if err != nil {
+		return err
+	}
+	err = d.spi.read(4)
+	if err != nil {
+		return err
+	}
+	buf := d.spi.rx
+	msg.ID = uint32((uint32(buf[0]) << 3) + (uint32(buf[1]) >> 5))
+	msg.Ext = false
+	if (buf[1] & mcpTxbExideM) == mcpTxbExideM {
+		// extended id
+		msg.ID = uint32(uint32(msg.ID<<2) + uint32(buf[1]&0x03))
+		msg.ID = uint32(uint32(msg.ID<<8) + uint32(buf[2]))
+		msg.ID = uint32(uint32(msg.ID<<8) + uint32(buf[3]))
+		msg.Ext = true
+	}
+	err = d.spi.read(1)
+	if err != nil {
+		return err
+	}
+	msgSize := d.spi.rx[0]
+	msg.Dlc = uint8(msgSize & mcpDlcMask)
+	msg.Rtr = false
+	if (msgSize & mcpRtrMask) == 0x40 {
+		msg.Rtr = true
+	}
+	readLen := uint8(canMaxCharInMessage)
+	if msg.Dlc < canMaxCharInMessage {
+		readLen = msg.Dlc
+	}
+	err = d.spi.read(int(readLen))
+	if err != nil {
+		return err
+	}
+	msg.Data = d.spi.rx
+
+	return err
+}
+
+func (d *Device) getNextFreeTxBuf() (uint8, uint8, error) {
+	status, err := d.readStatus()
+	if err != nil {
+		return 0, mcpAlltxbusy, err
+	}
+	status &= mcpStatTxPendingMask
+
+	bufNum := uint8(0x00)
+
+	if status == mcpStatTxPendingMask {
+		return 0, mcpAlltxbusy, nil
+	}
+
+	for i := 0; i < int(mcpNTxbuffers-nReservedTx(0)); i++ {
+		if (status & txStatusPendingFlag(uint8(i))) == 0 {
+			bufNum = txCtrlReg(uint8(i)) + 1
+			d.modifyRegister(mcpCANINTF, txIfFlag(uint8(i)), 0)
+			return bufNum, mcp2515Ok, nil
+		}
+	}
+
+	return 0, mcpAlltxbusy, nil
+}
+
+func (d *Device) writeCANMsg(bufNum uint8, canid uint32, ext, rtrBit, dlc uint8, data []byte) error {
+	d.cs.Low()
+	defer d.cs.High()
+	_, err := d.spi.readWrite(txSidhToLoad(bufNum))
+	if err != nil {
+		return err
+	}
+	err = d.spi.clearBuffer(tx)
+	if err != nil {
+		return err
+	}
+	err = d.spi.setTxBufData(canid, ext, rtrBit, dlc, data)
+	if err != nil {
+		return err
+	}
+	err = d.spi.write()
+	if err != nil {
+		return err
+	}
+	// Since cs.Low and cs.High are executed in d.startTransmission,
+	// it is necessary to set cs.High once to separate the instruction of mcp2515.
+	d.cs.High()
+
+	err = d.startTransmission(bufNum)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (s *SPI) setTxBufData(canid uint32, ext, rtrBit, dlc uint8, data []byte) error {
+	canid = canid & 0x0FFFF
+	if ext == 1 {
+		// TODO: add Extended ID
+		err := s.setTxData(0)
+		if err != nil {
+			return err
+		}
+		err = s.setTxData(0)
+		if err != nil {
+			return err
+		}
+		err = s.setTxData(0)
+		if err != nil {
+			return err
+		}
+		err = s.setTxData(0)
+		if err != nil {
+			return err
+		}
+	} else {
+		err := s.setTxData(byte(canid >> 3))
+		if err != nil {
+			return err
+		}
+		err = s.setTxData(byte((canid & 0x07) << 5))
+		if err != nil {
+			return err
+		}
+		err = s.setTxData(0)
+		if err != nil {
+			return err
+		}
+		err = s.setTxData(0)
+		if err != nil {
+			return err
+		}
+	}
+	if rtrBit == 1 {
+		dlc |= mcpRtrMask
+	} else {
+		dlc |= (0)
+	}
+	err := s.setTxData(dlc)
+	if err != nil {
+		return err
+	}
+	for _, d := range data {
+		err := s.setTxData(d)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (d *Device) startTransmission(bufNum uint8) error {
+	d.cs.Low()
+	_, err := d.spi.readWrite(txSidhToRTS(bufNum))
+	d.cs.High()
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func nReservedTx(number uint8) uint8 {
+	if number < mcpNTxbuffers {
+		return number
+	}
+	return mcpNTxbuffers - 1
+}
+
+func txStatusPendingFlag(i uint8) uint8 {
+	ret := uint8(0)
+	switch i {
+	case 0:
+		ret = mcpStatTx0Pending
+	case 1:
+		ret = mcpStatTx1Pending
+	case 2:
+		ret = mcpStatTx2Pending
+	}
+	return ret
+}
+
+func txCtrlReg(status uint8) uint8 {
+	ret := uint8(0)
+	switch status {
+	case 0:
+		ret = mcpTXB0CTRL
+	case 1:
+		ret = mcpTXB1CTRL
+	case 2:
+		ret = mcpTXB2CTRL
+	}
+	return ret
+}
+
+func txIfFlag(i uint8) uint8 {
+	ret := uint8(0)
+	switch i {
+	case 0:
+		ret = mcpTX0IF
+	case 1:
+		ret = mcpTX1IF
+	case 2:
+		ret = mcpTX2IF
+	}
+	return ret
+}
+
+func txSidhToSidh(i uint8) uint8 {
+	ret := uint8(0)
+	switch i {
+	case mcpTX0IF:
+		ret = mcpTXB0SIDH
+	case mcpTX1IF:
+		ret = mcpTXB1SIDH
+	case mcpTX2IF:
+		ret = mcpTXB2SIDH
+	}
+	return ret
+}
+
+func txSidhToRTS(i uint8) uint8 {
+	ret := uint8(0)
+	switch i {
+	case mcpTXB0SIDH:
+		ret = mcpRtsTx0
+	case mcpTXB1SIDH:
+		ret = mcpRtsTx1
+	case mcpTXB2SIDH:
+		ret = mcpRtsTx2
+	}
+	return ret
+}
+
+func txSidhToLoad(i uint8) uint8 {
+	ret := uint8(0)
+	switch i {
+	case mcpTXB0SIDH:
+		ret = mcpLoadTx0
+	case mcpTXB1SIDH:
+		ret = mcpLoadTx1
+	case mcpTXB2SIDH:
+		ret = mcpLoadTx2
+	}
+	return ret
+}
+
+func (d *Device) setRegister(addr, value byte) error {
+	d.cs.Low()
+	defer d.cs.High()
+	_, err := d.spi.readWrite(mcpWrite)
+	if err != nil {
+		return err
+	}
+	_, err = d.spi.readWrite(addr)
+	if err != nil {
+		return err
+	}
+	_, err = d.spi.readWrite(value)
+	if err != nil {
+		return err
+	}
+	// time.Sleep(time.Microsecond * 4)
+
+	return nil
+}
+
+func (d *Device) readRegister(addr byte) (byte, error) {
+	d.cs.Low()
+	defer d.cs.High()
+	_, err := d.spi.readWrite(mcpRead)
+	if err != nil {
+		return 0, err
+	}
+	_, err = d.spi.readWrite(addr)
+	if err != nil {
+		return 0, err
+	}
+	err = d.spi.read(1)
+	if err != nil {
+		return 0, err
+	}
+	// time.Sleep(time.Microsecond * 4)
+	return d.spi.rx[0], nil
+}
+
+func (d *Device) modifyRegister(addr, mask, data byte) error {
+	d.cs.Low()
+	defer d.cs.High()
+	_, err := d.spi.readWrite(mcpBitMod)
+	if err != nil {
+		return err
+	}
+	_, err = d.spi.readWrite(addr)
+	if err != nil {
+		return err
+	}
+	_, err = d.spi.readWrite(mask)
+	if err != nil {
+		return err
+	}
+	_, err = d.spi.readWrite(data)
+	if err != nil {
+		return err
+	}
+	// time.Sleep(time.Microsecond * 4)
+
+	return nil
+}
+
+func (d *Device) requestNewMode(newMode byte) error {
+	s := time.Now()
+	for {
+		err := d.modifyRegister(mcpCANCTRL, modeMask, newMode)
+		if err != nil {
+			return err
+		}
+		r, err := d.readRegister(mcpCANSTAT)
+		if err != nil {
+			return err
+		}
+		if r&modeMask == newMode {
+			return nil
+		} else if e := time.Now(); e.Sub(s) > 200*time.Millisecond {
+			return errors.New("requestNewMode max time expired")
+		}
+	}
+}
+
+func (d *Device) readStatus() (byte, error) {
+	d.cs.Low()
+	defer d.cs.High()
+	_, err := d.spi.readWrite(mcpReadStatus)
+	if err != nil {
+		return 0, err
+	}
+	err = d.spi.read(1)
+	if err != nil {
+		return 0, err
+	}
+
+	return d.spi.rx[0], nil
+}
+
+func (d *Device) readRxTxStatus() (byte, error) {
+	status, err := d.readStatus()
+	if err != nil {
+		return 0, err
+	}
+	ret := status & (mcpStatTxifMask | mcpStatRxifMask)
+	if (status & mcpStatTx0if) == 0x08 {
+		ret |= mcpTX0IF
+	}
+	if (status & mcpStatTx1if) == 0x20 {
+		ret |= mcpTX1IF
+	}
+	if (status & mcpStatTx2if) == 0x80 {
+		ret |= mcpTX2IF
+	}
+	ret |= ret & mcpStatRxifMask
+
+	return ret, nil
+}
+
+type SPI struct {
+	bus drivers.SPI
+	tx  []byte
+	rx  []byte
+}
+
+const (
+	tx = iota
+	rx
+)
+
+func (s *SPI) readWrite(w byte) (byte, error) {
+	return s.bus.Transfer(w)
+}
+
+func (s *SPI) read(readLength int) error {
+	err := s.clearBuffer(rx)
+	if err != nil {
+		return err
+	}
+	err = s.setBufferLength(readLength, rx)
+	if err != nil {
+		return err
+	}
+	return s.bus.Tx(nil, s.rx)
+}
+
+func (s *SPI) write() error {
+	return s.bus.Tx(s.tx, nil)
+}
+
+func (s *SPI) clearBuffer(dir int) error { return s.setBufferLength(0, dir) }
+
+func (s *SPI) setBufferLength(length int, dir int) error {
+	if dir == tx {
+		if length > cap(s.tx) {
+			return fmt.Errorf("length is longer than capacity")
+		}
+		s.tx = s.tx[:length]
+	} else if dir == rx {
+		if length > cap(s.rx) {
+			return fmt.Errorf("length is longer than capacity")
+		}
+		s.rx = s.rx[:length]
+	} else {
+		return fmt.Errorf("invalid direction")
+	}
+	return nil
+}
+
+func (s *SPI) setTxData(data byte) error {
+	if len(s.tx) >= bufferSize {
+		return fmt.Errorf("cannot expand buffer (to avoid memory allocation)")
+	}
+	s.tx = append(s.tx, data)
+
+	return nil
+}
+
+func (d *Device) dumpMode() error {
+	m, err := d.getMode()
+	if err != nil {
+		return err
+	}
+	fmt.Printf("Mode: %02X\r\n", m)
+
+	return nil
+}
+
+func (d *Device) dumpRegister(addr byte) error {
+	r, err := d.readRegister(addr)
+	if err != nil {
+		return err
+	}
+	fmt.Printf("Register: %02X = %02X\r\n", addr, r)
+
+	return nil
+}

mcp2515/registers.go

@@ -0,0 +1,421 @@
+// Package mcp2515 implements a driver for the MCP2515 CAN Controller.
+//
+// Datasheet: http://ww1.microchip.com/downloads/en/DeviceDoc/MCP2515-Stand-Alone-CAN-Controller-with-SPI-20001801J.pdf
+//
+package mcp2515 // import "tinygo.org/x/drivers/mcp2515"
+
+const DebugEn = 0
+
+const (
+	// begin mt
+
+	timeoutvalue = 50
+	mcpSidh      = 0
+	mcpSidl      = 1
+	mcpEid8      = 2
+	mcpEid0      = 3
+
+	mcpTxbExideM = 0x08 // in txbnsidl
+	mcpDlcMask   = 0x0f //= 4 lsbits
+	mcpRtrMask   = 0x40 // =(1<=<6) bit= 6
+
+	mcpRxbRxAny    = 0x60
+	mcpRxbRxExt    = 0x40
+	mcpRxbRxStd    = 0x20
+	mcpRxbRxStdExt = 0x00
+	mcpRxbRxMask   = 0x60
+	mcpRxbBuktMask = 1 << 2
+
+	// bits in the txbnctrl registers.
+
+	mcpTxbTxbufeM = 0x80
+	mcpTxbAbtfM   = 0x40
+	mcpTxbMloaM   = 0x20
+	mcpTxbTxerrM  = 0x10
+	mcpTxbTxreqM  = 0x08
+	mcpTxbTxieM   = 0x04
+	mcpTxbTxp10M  = 0x03
+
+	mcpTxbRtrM = 0x40 // in txbndlc
+	mcpRxbIdeM = 0x08 // in rxbnsidl
+	mcpRxbRtrM = 0x40 // in rxbndlc
+
+	mcpStatTxPendingMask = 0x54
+	mcpStatTx0Pending    = 0x04
+	mcpStatTx1Pending    = 0x10
+	mcpStatTx2Pending    = 0x40
+	mcpStatTxifMask      = 0xa8
+	mcpStatTx0if         = 0x08
+	mcpStatTx1if         = 0x20
+	mcpStatTx2if         = 0x80
+	mcpStatRxifMask      = 0x03
+	mcpStatRx0if         = 1 << 0
+	mcpStatRx1if         = 1 << 1
+
+	mcpEflgRx1ovr    = 1 << 7
+	mcpEflgRx0ovr    = 1 << 6
+	mcpEflgTxbo      = 1 << 5
+	mcpEflgTxep      = 1 << 4
+	mcpEflgRxep      = 1 << 3
+	mcpEflgTxwar     = 1 << 2
+	mcpEflgRxwar     = 1 << 1
+	mcpEflgEwarn     = 1 << 0
+	mcpEflgErrormask = 0xf8 //= 5 ms-bits
+
+	// define mcp2515 register addresses
+
+	mcpRXF0SIDH  = 0x00
+	mcpRXF0SIDL  = 0x01
+	mcpRXF0EID8  = 0x02
+	mcpRXF0EID0  = 0x03
+	mcpRXF1SIDH  = 0x04
+	mcpRXF1SIDL  = 0x05
+	mcpRXF1EID8  = 0x06
+	mcpRXF1EID0  = 0x07
+	mcpRXF2SIDH  = 0x08
+	mcpRXF2SIDL  = 0x09
+	mcpRXF2EID8  = 0x0a
+	mcpRXF2EID0  = 0x0b
+	mcpBFPCTRL   = 0x0c
+	mcpTXRTSCTRl = 0x0d
+	mcpCANSTAT   = 0x0e
+	mcpCANCTRL   = 0x0f
+	mcpRXF3SIDH  = 0x10
+	mcpRXF3SIDL  = 0x11
+	mcpRXF3EID8  = 0x12
+	mcpRXF3EID0  = 0x13
+	mcpRXF4SIDH  = 0x14
+	mcpRXF4SIDL  = 0x15
+	mcpRXF4EID8  = 0x16
+	mcpRXF4EID0  = 0x17
+	mcpRXF5SIDH  = 0x18
+	mcpRXF5SIDL  = 0x19
+	mcpRXF5EID8  = 0x1a
+	mcpRXF5EID0  = 0x1b
+	mcpTEC       = 0x1c
+	mcpREC       = 0x1d
+	mcpRXM0SIDH  = 0x20
+	mcpRXM0SIDL  = 0x21
+	mcpRXM0EID8  = 0x22
+	mcpRXM0EID0  = 0x23
+	mcpRXM1SIDH  = 0x24
+	mcpRXM1SIDL  = 0x25
+	mcpRXM1EID8  = 0x26
+	mcpRXM1EID0  = 0x27
+	mcpCNF3      = 0x28
+	mcpCNF2      = 0x29
+	mcpCNF1      = 0x2a
+	mcpCANINTE   = 0x2b
+	mcpCANINTF   = 0x2c
+	mcpEFLG      = 0x2d
+	mcpTXB0CTRL  = 0x30
+	mcpTXB0SIDH  = 0x31
+	mcpTXB1CTRL  = 0x40
+	mcpTXB1SIDH  = 0x41
+	mcpTXB2CTRL  = 0x50
+	mcpTXB2SIDH  = 0x51
+	mcpRXB0CTRL  = 0x60
+	mcpRXB0SIDH  = 0x61
+	mcpRXB1CTRL  = 0x70
+	mcpRXB1SIDH  = 0x71
+
+	mcpTxInt   = 0x1c // enable all transmit interrup ts
+	mcpTx01Int = 0x0c // enable txb0 and txb1 interru pts
+	mcpRxInt   = 0x03 // enable receive interrupts
+	mcpNoInt   = 0x00 // disable all interrupts
+
+	mcpTx01Mask = 0x14
+	mcpTxMask   = 0x54
+
+	// define spi instruction set
+	mcpWrite   = 0x02
+	mcpRead    = 0x03
+	mcpBitMod  = 0x05
+	mcpLoadTx0 = 0x40
+	mcpLoadTx1 = 0x42
+	mcpLoadTx2 = 0x44
+
+	mcpRtsTx0     = 0x81
+	mcpRtsTx1     = 0x82
+	mcpRtsTx2     = 0x84
+	mcpRtsAll     = 0x87
+	mcpReadRx0    = 0x90
+	mcpReadRx1    = 0x94
+	mcpReadStatus = 0xa0
+	mcpRxStatus   = 0xb0
+	mcpReset      = 0xc0
+
+	// canctrl register values
+
+	modeNormal     = 0x00
+	modeSleep      = 0x20
+	modeLoopBack   = 0x40
+	modeListenOnly = 0x60
+	modeConfig     = 0x80
+	modePowerUp    = 0xe0
+	modeMask       = 0xe0
+	abortTx        = 0x10
+	modeOneShot    = 0x08
+	clkoutEnable   = 0x04
+	clkoutDisable  = 0x00
+	clkoutPs1      = 0x00
+	clkoutPs2      = 0x01
+	clkoutPs4      = 0x02
+	clkoutPs8      = 0x03
+
+	// cnf1 register values
+
+	sjw1 = 0x00
+	sjw2 = 0x40
+	sjw3 = 0x80
+	sjw4 = 0xc0
+
+	//  cnf2 register values
+
+	btlmode  = 0x80
+	sample1x = 0x00
+	sample3x = 0x40
+
+	// cnf3 register values
+
+	sofEnable     = 0x80
+	sofDisable    = 0x00
+	wakfilEnable  = 0x40
+	wakfilDisable = 0x00
+
+	// canintf register bits
+
+	mcpRX0IF = 0x01
+	mcpRX1IF = 0x02
+	mcpTX0IF = 0x04
+	mcpTX1IF = 0x08
+	mcpTX2IF = 0x10
+	mcpERRIF = 0x20
+	mcpWAKIF = 0x40
+	mcpMERRF = 0x80
+
+	// bfpctrl register bits
+
+	b1bfs = 0x20
+	b0bfs = 0x10
+	b1bfe = 0x08
+	b0bfe = 0x04
+	b1bfm = 0x02
+	b0bfm = 0x01
+
+	// txrtctrl register bits
+
+	b2rts  = 0x20
+	b1rts  = 0x10
+	b0rts  = 0x08
+	b2rtsm = 0x04
+	b1rtsm = 0x02
+	b0rtsm = 0x01
+
+	// clock
+
+	Clock16MHz = 1
+	Clock8MHz  = 2
+
+	// speed= 16m
+
+	mcp16mHz1000kBpsCfg1 = 0x00
+	mcp16mHz1000kBpsCfg2 = 0xd0
+	mcp16mHz1000kBpsCfg3 = 0x82
+
+	mcp16mHz500kBpsCfg1 = 0x00
+	mcp16mHz500kBpsCfg2 = 0xf0
+	mcp16mHz500kBpsCfg3 = 0x86
+
+	mcp16mHz250kBpsCfg1 = 0x41
+	mcp16mHz250kBpsCfg2 = 0xf1
+	mcp16mHz250kBpsCfg3 = 0x85
+
+	mcp16mHz200kBpsCfg1 = 0x01
+	mcp16mHz200kBpsCfg2 = 0xfa
+	mcp16mHz200kBpsCfg3 = 0x87
+
+	mcp16mHz125kBpsCfg1 = 0x03
+	mcp16mHz125kBpsCfg2 = 0xf0
+	mcp16mHz125kBpsCfg3 = 0x86
+
+	mcp16mHz100kBpsCfg1 = 0x03
+	mcp16mHz100kBpsCfg2 = 0xfa
+	mcp16mHz100kBpsCfg3 = 0x87
+
+	mcp16mHz95kBpsCfg1 = 0x03
+	mcp16mHz95kBpsCfg2 = 0xad
+	mcp16mHz95kBpsCfg3 = 0x07
+
+	mcp16mHz83k3BpsCfg1 = 0x03
+	mcp16mHz83k3BpsCfg2 = 0xbe
+	mcp16mHz83k3BpsCfg3 = 0x07
+
+	mcp16mHz80kBpsCfg1 = 0x03
+	mcp16mHz80kBpsCfg2 = 0xff
+	mcp16mHz80kBpsCfg3 = 0x87
+
+	mcp16mHz50kBpsCfg1 = 0x07
+	mcp16mHz50kBpsCfg2 = 0xfa
+	mcp16mHz50kBpsCfg3 = 0x87
+
+	mcp16mHz40kBpsCfg1 = 0x07
+	mcp16mHz40kBpsCfg2 = 0xff
+	mcp16mHz40kBpsCfg3 = 0x87
+
+	mcp16mHz33kBpsCfg1 = 0x09
+	mcp16mHz33kBpsCfg2 = 0xbe
+	mcp16mHz33kBpsCfg3 = 0x07
+
+	mcp16mHz31k25BpsCfg1 = 0x0f
+	mcp16mHz31k25BpsCfg2 = 0xf1
+	mcp16mHz31k25BpsCfg3 = 0x85
+
+	mcp16mHz25kBpsCfg1 = 0x0f
+	mcp16mHz25kBpsCfg2 = 0xba
+	mcp16mHz25kBpsCfg3 = 0x07
+
+	mcp16mHz20kBpsCfg1 = 0x0f
+	mcp16mHz20kBpsCfg2 = 0xff
+	mcp16mHz20kBpsCfg3 = 0x87
+
+	mcp16mHz10kBpsCfg1 = 0x1f
+	mcp16mHz10kBpsCfg2 = 0xff
+	mcp16mHz10kBpsCfg3 = 0x87
+
+	mcp16mHz5kBpsCfg1 = 0x3f
+	mcp16mHz5kBpsCfg2 = 0xff
+	mcp16mHz5kBpsCfg3 = 0x87
+
+	mcp16mHz666kBpsCfg1 = 0x00
+	mcp16mHz666kBpsCfg2 = 0xa0
+	mcp16mHz666kBpsCfg3 = 0x04
+
+	// speed= 8m
+
+	mcp8mHz1000kBpsCfg1 = 0x00
+	mcp8mHz1000kBpsCfg2 = 0x80
+	mcp8mHz1000kBpsCfg3 = 0x00
+
+	mcp8mHz500kBpsCfg1 = 0x00
+	mcp8mHz500kBpsCfg2 = 0x90
+	mcp8mHz500kBpsCfg3 = 0x02
+
+	mcp8mHz250kBpsCfg1 = 0x00
+	mcp8mHz250kBpsCfg2 = 0xb1
+	mcp8mHz250kBpsCfg3 = 0x05
+
+	mcp8mHz200kBpsCfg1 = 0x00
+	mcp8mHz200kBpsCfg2 = 0xb4
+	mcp8mHz200kBpsCfg3 = 0x06
+
+	mcp8mHz125kBpsCfg1 = 0x01
+	mcp8mHz125kBpsCfg2 = 0xb1
+	mcp8mHz125kBpsCfg3 = 0x05
+
+	mcp8mHz100kBpsCfg1 = 0x01
+	mcp8mHz100kBpsCfg2 = 0xb4
+	mcp8mHz100kBpsCfg3 = 0x06
+
+	mcp8mHz80kBpsCfg1 = 0x01
+	mcp8mHz80kBpsCfg2 = 0xbf
+	mcp8mHz80kBpsCfg3 = 0x07
+
+	mcp8mHz50kBpsCfg1 = 0x03
+	mcp8mHz50kBpsCfg2 = 0xb4
+	mcp8mHz50kBpsCfg3 = 0x06
+
+	mcp8mHz40kBpsCfg1 = 0x03
+	mcp8mHz40kBpsCfg2 = 0xbf
+	mcp8mHz40kBpsCfg3 = 0x07
+
+	mcp8mHz31k25BpsCfg1 = 0x07
+	mcp8mHz31k25BpsCfg2 = 0xa4
+	mcp8mHz31k25BpsCfg3 = 0x04
+
+	mcp8mHz20kBpsCfg1 = 0x07
+	mcp8mHz20kBpsCfg2 = 0xbf
+	mcp8mHz20kBpsCfg3 = 0x07
+
+	mcp8mHz10kBpsCfg1 = 0x0f
+	mcp8mHz10kBpsCfg2 = 0xbf
+	mcp8mHz10kBpsCfg3 = 0x07
+
+	mcp8mHz5kBpsCfg1 = 0x1f
+	mcp8mHz5kBpsCfg2 = 0xbf
+	mcp8mHz5kBpsCfg3 = 0x07
+
+	mcp16mHz47kBpsCfg1 = 0x06
+	mcp16mHz47kBpsCfg2 = 0xbe
+	mcp16mHz47kBpsCfg3 = 0x07
+
+	mcpdebug      = 0
+	mcpdebugTxbuf = 0
+	mcpNTxbuffers = 3
+
+	mcpRxbuf0 = 0x61
+	mcpRxbuf1 = 0x71
+
+	mcp2515Ok    = 0
+	mcp2515Fail  = 1
+	mcpAlltxbusy = 2
+
+	candebug = 1
+
+	canuseloop = 0
+
+	cansendtimeout = 200 // milliseconds
+
+	mcpPinHiz = 0
+	mcpPinInt = 1
+	mcpPinOut = 2
+	mcpPinIn  = 3
+
+	mcpRx0bf  = 0
+	mcpRx1bf  = 1
+	mcpTx0rts = 2
+	mcpTx1rts = 3
+	mcpTx2rts = 4
+
+	// initial value of gcanautoprocess
+
+	canautoprocess     = 1
+	canautoon          = 1
+	canautooff         = 0
+	canStdid           = 0
+	canExtid           = 1
+	candefaultident    = 0x55cc
+	candefaultidentext = 1
+
+	CAN5kBps    = 1
+	CAN10kBps   = 2
+	CAN20kBps   = 3
+	CAN25kBps   = 4
+	CAN31k25Bps = 5
+	CAN33kBps   = 6
+	CAN40kBps   = 7
+	CAN50kBps   = 8
+	CAN80kBps   = 9
+	CAN83k3Bps  = 10
+	CAN95kBps   = 11
+	CAN100kBps  = 12
+	CAN125kBps  = 13
+	CAN200kBps  = 14
+	CAN250kBps  = 15
+	CAN500kBps  = 16
+	CAN666kBps  = 17
+	CAN1000kBps = 18
+	CAN47kBps   = 19
+
+	canOk             = 0
+	canFailinit       = 1
+	canFailtx         = 2
+	canMsgavail       = 3
+	canNomsg          = 4
+	canCtrlerror      = 5
+	canGettxbftimeout = 6
+	canSendmsgtimeout = 7
+	canFail           = 0xff
+
+	canMaxCharInMessage = 8
+)

net/tls/tls.go

@@ -4,6 +4,7 @@ package tls
 
 import (
 	"strconv"
+	"strings"
 
 	"tinygo.org/x/drivers/net"
 )
@@ -17,14 +18,17 @@ func Dial(network, address string, config *Config) (*net.TCPSerialConn, error) {
 		return nil, err
 	}
 
-	addr := raddr.IP.String()
+	hostname := strings.Split(address, ":")[0]
 	sendport := strconv.Itoa(raddr.Port)
+	if sendport == "0" {
+		sendport = "443"
+	}
 
 	// disconnect any old socket
 	net.ActiveDevice.DisconnectSocket()
 
 	// connect new socket
-	err = net.ActiveDevice.ConnectSSLSocket(addr, sendport)
+	err = net.ActiveDevice.ConnectSSLSocket(hostname, sendport)
 	if err != nil {
 		return nil, err
 	}

p1am/defines.go

@@ -0,0 +1,157 @@
+package p1am
+
+//go:generate go run ./internal/cmd/gen_defines
+
+type ModuleProps struct {
+	ModuleID                                 uint32
+	DI, DO, AI, AO, Status, Config, DataSize byte
+	Name                                     string
+}
+
+var modules = []ModuleProps{
+	//{0x000000ID,di,do,ai,ao,st,cf,ds}
+	{0x00000000, 0, 0, 0, 0, 0, 0, 0, "Empty"}, //Empty first entry for defaultgs
+
+	{0x04A00081, 1, 0, 0, 0, 0, 0, 1, "P1-08ND3"}, //P1-08ND3
+
+	{0x04A00085, 1, 0, 0, 0, 0, 0, 1, "P1-08NA"}, //P1-08NA
+
+	{0x04A00087, 1, 0, 0, 0, 0, 0, 1, "P1-08SIM"}, //P1-08SIM
+
+	{0x04A00088, 1, 0, 0, 0, 0, 0, 1, "P1-08NE3"}, //P1-08NE3
+
+	{0x05200082, 2, 0, 0, 0, 0, 0, 1, "P1-16ND3"}, //P1-16ND3
+
+	{0x05200089, 2, 0, 0, 0, 0, 0, 1, "P1-16NE3"}, //P1-16NE3
+
+	{0x1403F481, 0, 0, 0, 32, 4, 4, 0xA0, "P1-04PWM"}, //P1-04PWM
+
+	{0x1404008D, 0, 1, 0, 0, 0, 0, 1, "P1-08TA"}, //P1-08TA
+
+	{0x1404008F, 0, 1, 0, 0, 0, 0, 1, "P1-08TRS"}, //P1-08TRS
+
+	{0x14040091, 0, 2, 0, 0, 0, 0, 1, "P1-16TR"}, //P1-16TR
+
+	{0x14050081, 0, 1, 0, 0, 0, 0, 1, "P1-08TD1"}, //P1-08TD1
+
+	{0x14050082, 0, 1, 0, 0, 0, 0, 1, "P1-08TD2"}, //P1-08TD2
+
+	{0x14080085, 0, 2, 0, 0, 0, 0, 1, "P1-15TD1"}, //P1-15TD1
+
+	{0x14080086, 0, 2, 0, 0, 0, 0, 1, "P1-15TD2"}, //P1-15TD2
+
+	{0x24A50081, 1, 1, 0, 0, 0, 0, 1, "P1-16CDR"}, //P1-16CDR
+
+	{0x24A50082, 1, 1, 0, 0, 0, 0, 1, "P1-15CDD1"}, //P1-15CDD1
+
+	{0x24A50083, 1, 1, 0, 0, 0, 0, 1, "P1-15CDD2"}, //P1-15CDD2
+
+	{0x34605581, 0, 0, 16, 0, 12, 18, 16, "P1-04AD"}, //P1-04AD
+
+	{0x34605588, 0, 0, 16, 0, 12, 8, 16, "P1-04RTD"}, //P1-04RTD
+
+	{0x3460558F, 0, 0, 16, 0, 12, 2, 12, "P1-04ADL-1"}, //P1-04ADL-1
+
+	{0x34605590, 0, 0, 16, 0, 12, 2, 12, "P1-04ADL-2"}, //P1-04ADL-2
+
+	{0x34608C81, 0, 0, 16, 0, 12, 20, 32, "P1-04THM"}, //P1-04THM
+
+	{0x34608C8E, 0, 0, 16, 0, 12, 8, 32, "P1-04NTC"}, //P1-04NTC
+
+	{0x34A0558A, 0, 0, 32, 0, 12, 2, 12, "P1-08ADL-1"}, //P1-08ADL-1
+
+	{0x34A0558B, 0, 0, 32, 0, 12, 2, 12, "P1-08ADL-2"}, //P1-08ADL-2
+
+	{0x34A5A481, 2, 0, 36, 36, 4, 12, 0xC0, "P1-02HSC"}, //P1-02HSC
+
+	{0x44035583, 0, 0, 0, 16, 4, 0, 12, "P1-04DAL-1"}, //P1-04DAL-1
+
+	{0x44035584, 0, 0, 0, 16, 4, 0, 12, "P1-04DAL-2"}, //P1-04DAL-2
+
+	{0x44055588, 0, 0, 0, 32, 4, 0, 12, "P1-08DAL-1"}, //P1-08DAL-1
+
+	{0x44055589, 0, 0, 0, 32, 4, 0, 12, "P1-08DAL-2"}, //P1-08DAL-2
+
+	{0x5461A783, 0, 0, 16, 8, 12, 2, 12, "P1-4ADL2DAL-1"}, //P1-4ADL2DAL-1
+
+	{0x5461A784, 0, 0, 16, 8, 12, 2, 12, "P1-4ADL2DAL-2"}, //P1-4ADL2DAL-2
+
+	{0xFFFFFFFF, 0, 0, 0, 0, 0, 0, 0, "BAD SLOT"}, //empty in case no modules are defined.
+
+	{0x00000000, 0, 0, 0, 0, 0, 0, 0, "BAD SLOT"}, //empty in case no modules are defined.
+}
+
+var defaultConfig = map[uint32][]byte{
+	0x34605590:// P1_04ADL_2_DEFAULT_CONFIG
+	{0x40, 0x03},
+	0x34608C8E: // P1_04NTC_DEFAULT_CONFIG
+	{0x40, 0x03, 0x60, 0x05,
+		0x20, 0x00, 0x80, 0x02},
+	0x34608C81: // P1_04THM_DEFAULT_CONFIG
+	{0x40, 0x03, 0x60, 0x05,
+		0x21, 0x00, 0x22, 0x00,
+		0x23, 0x00, 0x24, 0x00,
+		0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00},
+	0x34605588: // P1_04RTD_DEFAULT_CONFIG
+	{0x40, 0x03, 0x60, 0x05,
+		0x20, 0x01, 0x80, 0x00},
+	0x34605581: // P1_04AD_DEFAULT_CONFIG
+	{0x40, 0x03, 0x00, 0x00,
+		0x20, 0x03, 0x00, 0x00,
+		0x21, 0x03, 0x00, 0x00,
+		0x22, 0x03, 0x00, 0x00,
+		0x23, 0x03},
+	0x3460558F:// P1_04ADL_1_DEFAULT_CONFIG
+	{0x40, 0x03},
+	0x34A0558A:// P1_08ADL_1_DEFAULT_CONFIG
+	{0x40, 0x07},
+	0x34A0558B:// P1_08ADL_2_DEFAULT_CONFIG
+	{0x40, 0x07},
+	0x5461A783:// P1_04ADL2DAL_1_DEFAULT_CONFIG
+	{0x40, 0x03},
+	0x5461A784:// P1_04ADL2DAL_2_DEFAULT_CONFIG
+	{0x40, 0x03},
+	0x1403F481:// P1_04PWM_DEFAULT_CONFIG
+	{0x02, 0x02, 0x02, 0x02},
+	0x34A5A481: // P1_02HSC_DEFAULT_CONFIG
+	{0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x01,
+		0x00, 0x00, 0x00, 0x01},
+}
+
+const NUMBER_OF_MODULES = 15 //Current max 15 Modules
+const SWITCH_BUILTIN = 31
+const baseEnable = 33
+const MOD_HDR = 0x02
+const VERSION_HDR = 0x03
+const ACTIVE_HDR = 0x04
+const DROPOUT_HDR = 0x05
+const CFG_HDR = 0x10
+const READ_CFG_HDR = 0x11
+const PETWD_HDR = 0x30
+const STARTWD_HDR = 0x31
+const STOPWD_HDR = 0x32
+const CONFIGWD_HDR = 0x33
+const READ_STATUS_HDR = 0x40
+const READ_DISCRETE_HDR = 0x50
+const READ_ANALOG_HDR = 0x51
+const READ_BLOCK_HDR = 0x52
+const WRITE_DISCRETE_HDR = 0x60
+const WRITE_ANALOG_HDR = 0x61
+const WRITE_BLOCK_HDR = 0x62
+const FW_UPDATE_HDR = 0xAA
+const DUMMY = 0xFF
+const EMPTY_SLOT_ID = 0xFFFFFFFE
+const MAX_TIMEOUT = 0xFFFFFFFF
+const DISCRETE_IN_BLOCK = 0
+const ANALOG_IN_BLOCK = 1
+const DISCRETE_OUT_BLOCK = 2
+const ANALOG_OUT_BLOCK = 3
+const STATUS_IN_BLOCK = 4
+const MISSING24V_STATUS = 3
+const BURNOUT_STATUS = 5
+const UNDER_RANGE_STATUS = 7
+const OVER_RANGE_STATUS = 11
+const TOGGLE = 0x01
+const HOLD = 0x00

p1am/internal/cmd/gen_defines/main.go

@@ -0,0 +1,133 @@
+package main
+
+import (
+	"bytes"
+	"go/format"
+	"io/ioutil"
+	"log"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"text/template"
+)
+
+var tmpl = template.Must(template.New("main").Parse(`package p1am
+
+//go:generate go run ./internal/cmd/gen_defines
+
+type ModuleProps struct {
+	ModuleID                                 uint32
+	DI, DO, AI, AO, Status, Config, DataSize byte
+	Name                                     string
+}
+
+var modules = []ModuleProps{
+{{.MDB -}}
+}
+
+var defaultConfig = map[uint32][]byte{
+	{{range .Configs -}}
+	0x{{.ID}}: // {{.Name}}
+	{{index $.DefaultConfigs .Name}},
+	{{end}}
+}
+
+{{range .Defines}}
+const {{.Name}} = {{.Value}}{{.Comment -}}
+{{end}}
+`))
+
+func findLibrary() string {
+	home, err := os.UserHomeDir()
+	if err != nil {
+		log.Fatal(err)
+	}
+	for _, dir := range []string{
+		"Documents/Arduino",
+		"Arduino",
+	} {
+		dir = filepath.Join(home, dir, "libraries/P1AM/src")
+		if _, err := os.Stat(dir); err == nil {
+			return dir
+		}
+	}
+	return ""
+}
+
+func definitions(path string, delim string) []string {
+	data, err := ioutil.ReadFile(path)
+	if err != nil {
+		log.Fatal(err)
+	}
+	return strings.Split(string(data), delim)
+}
+
+var (
+	mdbRE    = regexp.MustCompile(`(?s)mdb\[\] = \{\s*(.+)\}`)
+	configRE = regexp.MustCompile(`(?s)const char (.*?)\[\] = (.+)`)
+	caseRE   = regexp.MustCompile(`(?s)case 0x([^:]+):\s+return \(char\*\)(.+)`)
+	defineRE = regexp.MustCompile(`(?ms)^\s*#define (\S+)\s+(\d+|0x[0-9a-fA-F]+)(\s+.*?)?\s*$`)
+)
+
+func main() {
+	base := findLibrary()
+	if base == "" {
+		log.Fatal("can't find Arduino library")
+	}
+	var data = struct {
+		MDB            string
+		DefaultConfigs map[string]string
+		Configs        []struct {
+			ID   string
+			Name string
+		}
+		Defines []struct {
+			Name    string
+			Value   string
+			Comment string
+		}
+	}{
+		DefaultConfigs: make(map[string]string),
+	}
+	for _, line := range definitions(filepath.Join(base, "Module_List.h"), ";") {
+		if matches := mdbRE.FindStringSubmatch(line); matches != nil {
+			data.MDB = regexp.MustCompile(`}\s*//`).ReplaceAllString(matches[1], `}, //`)
+		}
+		if matches := configRE.FindStringSubmatch(line); matches != nil {
+			data.DefaultConfigs[matches[1]] = matches[2]
+		}
+	}
+
+	for _, line := range definitions(filepath.Join(base, "P1AM.cpp"), ";") {
+		if matches := caseRE.FindStringSubmatch(line); matches != nil {
+			data.Configs = append(data.Configs, struct{ ID, Name string }{
+				ID:   matches[1],
+				Name: matches[2],
+			})
+		}
+	}
+
+	for _, line := range definitions(filepath.Join(base, "defines.h"), "\n") {
+		if matches := defineRE.FindStringSubmatch(line); matches != nil {
+			data.Defines = append(data.Defines, struct{ Name, Value, Comment string }{
+				Name:    matches[1],
+				Value:   matches[2],
+				Comment: matches[3],
+			})
+		}
+	}
+
+	var buf bytes.Buffer
+	if err := tmpl.Execute(&buf, &data); err != nil {
+		log.Fatal(err)
+	}
+	formatted, err := format.Source(buf.Bytes())
+	if err != nil {
+		log.Printf("failed to compile %s", buf.Bytes())
+		log.Fatal(err)
+	}
+	if err := ioutil.WriteFile("defines.go", formatted, 0666); err != nil {
+		log.Fatal(err)
+	}
+}

p1am/p1am.go

@@ -0,0 +1,429 @@
+// Driver for the P1AM-100 base controller.
+//
+// This is an embedded device on the P1AM-100 board.
+// Based on v1.0.1 of the Arduino library: https://github.com/facts-engineering/P1AM/tree/1.0.1
+
+package p1am
+
+import (
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"machine"
+	"time"
+)
+
+type P1AM struct {
+	bus                                        machine.SPI
+	slaveSelectPin, slaveAckPin, baseEnablePin machine.Pin
+
+	// SkipAutoConfig will skip loading a default configuration into each module.
+	SkipAutoConfig bool
+
+	Slots int
+	// Access slots via Slot()
+	slots []Slot
+}
+
+var Controller = P1AM{
+	bus:            machine.SPI0,
+	slaveSelectPin: machine.BASE_SLAVE_SELECT_PIN,
+	slaveAckPin:    machine.BASE_SLAVE_ACK_PIN,
+	baseEnablePin:  machine.BASE_ENABLE_PIN,
+}
+
+type baseSlotConstants struct {
+	DI, DO, AI, AO, Status, Config, DataSize byte
+}
+
+func (p *P1AM) Initialize() error {
+	p.slaveSelectPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	p.slaveAckPin.Configure(machine.PinConfig{Mode: machine.PinInput})
+	p.baseEnablePin.Configure(machine.PinConfig{Mode: machine.PinOutput})
+
+	if err := p.bus.Configure(machine.SPIConfig{
+		Frequency: 1000000,
+		Mode:      2,
+		LSBFirst:  false,
+	}); err != nil {
+		return err
+	}
+
+	p.SetEnabled(true)
+	time.Sleep(100 * time.Millisecond)
+
+	if err := p.waitAck(5 * time.Second); err != nil {
+		return errors.New("no base controller activity; check external supply connection")
+	}
+
+	for i := 0; i < 5; i++ {
+		if err := p.handleHDR(MOD_HDR); err == nil {
+			time.Sleep(5 * time.Millisecond)
+			slots, err := p.spiSendRecvByte(0xFF)
+			if err == nil && slots > 0 && slots <= 15 {
+				p.Slots = int(slots)
+				break
+			}
+		}
+		if i > 2 {
+			// Try restarting the base controller
+			p.SetEnabled(false)
+			time.Sleep(10 * time.Millisecond)
+			p.SetEnabled(true)
+			time.Sleep(10 * time.Millisecond)
+		}
+	}
+	if p.Slots <= 0 || p.Slots > 15 {
+		return errors.New("zero modules in the base")
+	}
+
+	moduleIDs := make([]uint32, p.Slots)
+
+	p.waitAck(200 * time.Millisecond)
+	if err := binary.Read(p, binary.LittleEndian, &moduleIDs); err != nil {
+		return err
+	}
+
+	baseConstants := make([]baseSlotConstants, p.Slots)
+	p.slots = make([]Slot, p.Slots)
+
+	for i := 1; i <= p.Slots; i++ {
+		slot := p.Slot(i)
+		slot.p = p
+		slot.slot = byte(i)
+		slot.ID = moduleIDs[i-1]
+		// What if 0xFFFFFFFF isn't at position -2?
+		slot.Props = &modules[len(modules)-2]
+		for j := 0; j < len(modules); j++ {
+			if modules[j].ModuleID == slot.ID {
+				slot.Props = &modules[j]
+			}
+			bc := &baseConstants[i-1]
+			bc.DI = slot.Props.DI
+			bc.DO = slot.Props.DO
+			bc.AI = slot.Props.AI
+			bc.AO = slot.Props.AO
+			bc.Status = slot.Props.Status
+			bc.Config = slot.Props.Config
+			bc.DataSize = slot.Props.DataSize
+		}
+	}
+
+	p.waitAck(200 * time.Millisecond)
+	if err := binary.Write(p, binary.LittleEndian, &baseConstants); err != nil {
+		return err
+	}
+
+	if !p.SkipAutoConfig {
+		for i := 1; i <= p.Slots; i++ {
+			s := p.Slot(i)
+			if s.Props.Config > 0 {
+				cfg := defaultConfig[s.ID]
+				if cfg != nil {
+					s.Configure(cfg)
+				}
+			}
+		}
+	}
+
+	return nil
+}
+
+func (p *P1AM) Version() ([3]byte, error) {
+	if err := p.handleHDR(VERSION_HDR); err != nil {
+		return [3]byte{}, err
+	}
+	var buf [4]byte
+	if err := p.spiSendRecvBuf(nil, buf[:]); err != nil {
+		return [3]byte{}, err
+	}
+	return [3]byte{
+		byte(buf[1] >> 4),
+		byte(buf[1] & 0xF),
+		byte(buf[0]),
+	}, p.dataSync()
+}
+
+func (p *P1AM) Active() (bool, error) {
+	if _, err := p.spiSendRecvByte(ACTIVE_HDR); err != nil {
+		return false, err
+	}
+	if err := p.waitAck(200 * time.Millisecond); err != nil {
+		return false, err
+	}
+	buf, err := p.spiSendRecvByte(DUMMY)
+	defer p.dataSync()
+	return buf != 0, err
+}
+
+const wdToggleTime = 100 * time.Millisecond
+
+func (p *P1AM) ConfigureWatchdog(interval time.Duration, reset bool) error {
+	ms := interval / time.Millisecond
+	toggleMs := wdToggleTime / time.Millisecond
+	resetB := byte(0)
+	if reset {
+		resetB = 1
+	}
+	buf := [6]byte{
+		CONFIGWD_HDR,
+		byte(ms),
+		byte(ms >> 8),
+		byte(toggleMs),
+		byte(toggleMs >> 8),
+		resetB,
+	}
+	if err := p.spiSendRecvBuf(buf[:], nil); err != nil {
+		return err
+	}
+	return p.dataSync()
+}
+
+func (p *P1AM) sendWatchdog(hdr byte) error {
+	if _, err := p.spiSendRecvByte(hdr); err != nil {
+		return err
+	}
+	if err := p.waitAck(200 * time.Millisecond); err != nil {
+		return err
+	}
+	if _, err := p.spiSendRecvByte(DUMMY); err != nil {
+		return err
+	}
+	return p.dataSync()
+}
+
+func (p *P1AM) StartWatchdog() error {
+	return p.sendWatchdog(STARTWD_HDR)
+}
+
+func (p *P1AM) StopWatchdog() error {
+	return p.sendWatchdog(STOPWD_HDR)
+}
+
+func (p *P1AM) PetWatchdog() error {
+	return p.sendWatchdog(PETWD_HDR)
+}
+
+func (p *P1AM) Slot(i int) *Slot {
+	if i < 1 || i > p.Slots {
+		return nil
+	}
+	return &p.slots[i-1]
+}
+
+type Slot struct {
+	p    *P1AM
+	slot byte
+	ID   uint32
+	// TODO: Embed this?
+	Props *ModuleProps
+}
+
+func (s *Slot) Configure(data []byte) error {
+	if s == nil {
+		return errors.New("invalid slot")
+	}
+	if len(data) != int(s.Props.Config) {
+		return fmt.Errorf("expected %d config bytes, got %d", s.Props.Config, len(data))
+	}
+
+	if len(data) == 0 {
+		return errors.New("no config bytes")
+	}
+
+	out := make([]byte, len(data)+2)
+	out[0] = CFG_HDR
+	out[1] = s.slot
+	copy(out[2:], data)
+
+	if err := s.p.spiSendRecvBuf(out, nil); err != nil {
+		return err
+	}
+	time.Sleep(100 * time.Millisecond)
+	s.p.dataSync()
+	s.p.dataSync()
+	return nil
+}
+
+func (s *Slot) ReadDiscrete() (uint32, error) {
+	if s == nil {
+		return 0, errors.New("invalid slot")
+	}
+	bytes := s.Props.DI
+	out := [2]byte{
+		READ_DISCRETE_HDR,
+		s.slot,
+	}
+	if err := s.p.spiSendRecvBuf(out[:], nil); err != nil {
+		return 0, err
+	}
+	if err := s.p.waitAck(200 * time.Millisecond); err != nil {
+		return 0, err
+	}
+	var data [4]byte
+	if err := s.p.spiSendRecvBuf(nil, data[:bytes]); err != nil {
+		return 0, err
+	}
+	err := s.p.dataSync()
+	return binary.LittleEndian.Uint32(data[:]), err
+}
+
+func (s *Slot) WriteDiscrete(value uint32) error {
+	return s.writeDiscrete(0, value)
+}
+
+func (s *Slot) writeDiscrete(channel byte, value uint32) error {
+	if s == nil {
+		return errors.New("invalid slot")
+	}
+	bytes := s.Props.DO
+	buf := [7]byte{
+		WRITE_DISCRETE_HDR,
+		s.slot,
+		channel,
+	}
+	binary.LittleEndian.PutUint32(buf[3:], value)
+	out := buf[:3+bytes]
+	if channel != 0 {
+		out = buf[:4]
+		out[3] &= 1
+	}
+	if err := s.p.spiSendRecvBuf(out, nil); err != nil {
+		return err
+	}
+	return s.p.dataSync()
+}
+
+type Channel struct {
+	s       *Slot
+	channel int
+}
+
+func (s *Slot) Channel(channel int) Channel {
+	return Channel{
+		s:       s,
+		channel: channel,
+	}
+}
+
+func (c Channel) ReadDiscrete() (bool, error) {
+	if c.channel < 1 || c.channel > int(c.s.Props.DI)*8 {
+		return false, errors.New("invalid channel")
+	}
+	data, err := c.s.ReadDiscrete()
+	return (data>>(c.channel-1))&1 == 1, err
+}
+
+func (c Channel) WriteDiscrete(value bool) error {
+	if c.channel < 1 || c.channel > int(c.s.Props.DO)*8 {
+		return errors.New("invalid channel")
+	}
+	data := uint32(0)
+	if value {
+		data = 1
+	}
+	return c.s.writeDiscrete(byte(c.channel), data)
+}
+
+const ackTimeout = 200 * time.Millisecond
+
+func awaitPin(pin machine.Pin, state bool, timeout time.Duration) bool {
+	start := time.Now()
+	for pin.Get() != state {
+		time.Sleep(100 * time.Microsecond)
+		if time.Since(start) > timeout {
+			return false
+		}
+	}
+	return true
+	// TODO: Use channels when https://github.com/tinygo-org/tinygo/pull/1402 is merged.
+	// edge := machine.PinRising
+	// if state {
+	// 	edge = machine.PinFalling
+	// }
+	// ch := make(chan struct{}, 1)
+	// defer close(ch)
+	// pin.SetInterrupt(edge, func(machine.Pin) {
+	// 	ch <- struct{}{}
+	// })
+	// defer pin.SetInterrupt(0, nil)
+	// select {
+	// case <-ch:
+	// 	return true
+	// case <-time.After(timeout):
+	// 	return false
+	// }
+}
+
+var dataSyncErr = errors.New("base sync timeout")
+
+func (p *P1AM) dataSync() error {
+	if !awaitPin(p.slaveAckPin, true, ackTimeout) {
+		return dataSyncErr
+	}
+	time.Sleep(time.Microsecond)
+	if !awaitPin(p.slaveAckPin, false, ackTimeout) {
+		return dataSyncErr
+	}
+	time.Sleep(time.Microsecond)
+	if !awaitPin(p.slaveAckPin, true, ackTimeout) {
+		return dataSyncErr
+	}
+	time.Sleep(time.Microsecond)
+	return nil
+}
+
+func (p *P1AM) handleHDR(HDR byte) error {
+	for !p.slaveAckPin.Get() {
+	}
+	if _, err := p.spiSendRecvByte(HDR); err != nil {
+		return err
+	}
+	return p.spiTimeout(MAX_TIMEOUT*time.Millisecond, HDR, 2*time.Second)
+}
+
+func (p *P1AM) Read(data []byte) (int, error) {
+	return len(data), p.spiSendRecvBuf(nil, data)
+}
+
+func (p *P1AM) Write(data []byte) (int, error) {
+	return len(data), p.spiSendRecvBuf(data, nil)
+}
+
+func (p *P1AM) spiSendRecvBuf(w, r []byte) error {
+	p.slaveSelectPin.Low()
+	defer p.slaveSelectPin.High()
+	return p.bus.Tx(w, r)
+}
+
+func (p *P1AM) spiSendRecvByte(data byte) (byte, error) {
+	p.slaveSelectPin.Low()
+	defer p.slaveSelectPin.High()
+	return p.bus.Transfer(data)
+}
+
+func (p *P1AM) waitAck(timeout time.Duration) error {
+	return p.spiTimeout(timeout, 0, 0)
+}
+
+var timeoutErr = errors.New("timeout")
+
+func (p *P1AM) spiTimeout(timeout time.Duration, resendMsg byte, retryPeriod time.Duration) error {
+	end := time.Now().Add(timeout)
+	retry := time.Now().Add(retryPeriod)
+	for time.Now().Before(end) {
+		if p.slaveAckPin.Get() {
+			time.Sleep(50 * time.Microsecond)
+			return nil
+		}
+		if retryPeriod > 0 && time.Now().After(retry) {
+			p.spiSendRecvByte(resendMsg)
+			retry = retry.Add(retryPeriod)
+		}
+	}
+	return timeoutErr
+}
+
+func (p *P1AM) SetEnabled(enabled bool) {
+	p.baseEnablePin.Set(enabled)
+}

pcf8563/pcf8563.go

@@ -0,0 +1,252 @@
+// Package pcf8563 implements a driver for the PCF8563 CMOS Real-Time Clock (RTC)
+//
+// Datasheet: https://www.nxp.com/docs/en/data-sheet/PCF8563.pdf
+//
+
+package pcf8563
+
+import (
+	"time"
+
+	"tinygo.org/x/drivers"
+)
+
+// Device wraps an I2C connection to a PCF8563 device.
+type Device struct {
+	bus     drivers.I2C
+	Address uint16
+}
+
+// New creates a new PCF8563 connection. I2C bus must be already configured.
+func New(i2c drivers.I2C) Device {
+	return Device{
+		bus:     i2c,
+		Address: PCF8563_ADDR,
+	}
+}
+
+// Reset resets the `control and status registers`. When this method is
+// called, it writes `0x00` to the `control and status registers`. This will
+// cause `Alarm` and `Timer` to become Inactive. Please refer to the datasheet
+// for details.
+func (d *Device) Reset() (err error) {
+	return d.bus.Tx(d.Address, []byte{0x00, 0x00, 0x00}, nil)
+}
+
+// SetTime sets the time and date
+func (d *Device) SetTime(t time.Time) error {
+	var buf [9]byte
+	buf[0] = 0x02
+	buf[1] = decToBcd(t.Second())
+	buf[2] = decToBcd(t.Minute())
+	buf[3] = decToBcd(t.Hour())
+	buf[4] = decToBcd(t.Day())
+	buf[5] = decToBcd(int(t.Weekday() + 1))
+	buf[6] = decToBcd(int(t.Month()))
+	buf[7] = decToBcd(t.Year() - 2000)
+	err := d.bus.Tx(d.Address, buf[:], nil)
+	return err
+}
+
+// ReadTime returns the date and time
+func (d *Device) ReadTime() (time.Time, error) {
+	var buf [9]byte
+	err := d.bus.Tx(d.Address, []byte{0x00}, buf[:])
+	if err != nil {
+		return time.Time{}, err
+	}
+
+	seconds := bcdToDec(buf[2] & 0x7F)
+	minute := bcdToDec(buf[3] % 0x7F)
+	hour := bcdToDec(buf[4] & 0x3F)
+	day := bcdToDec(buf[5] & 0x3F)
+	month := time.Month(bcdToDec(buf[7] & 0x0F))
+	year := int(bcdToDec(buf[8])) + 2000
+
+	t := time.Date(year, month, day, hour, minute, seconds, 0, time.UTC)
+	return t, nil
+}
+
+// SetAlarm sets the alarm
+func (d *Device) SetAlarm(t time.Time) error {
+	var buf [5]byte
+	buf[0] = 0x09
+	buf[1] = RTC_ALARM_ENABLE | decToBcd(t.Minute())
+	buf[2] = RTC_ALARM_ENABLE | decToBcd(t.Hour())
+	buf[3] = RTC_ALARM_ENABLE | decToBcd(t.Day())
+	buf[4] = RTC_ALARM_DISABLE
+	err := d.bus.Tx(d.Address, buf[:], nil)
+	if err != nil {
+		return err
+	}
+
+	// enable alarm
+	buf[0] = 0x01
+	err = d.bus.Tx(d.Address, buf[:1], buf[1:])
+	if err != nil {
+		return err
+	}
+
+	buf[1] |= RTC_CTRL_AF
+	err = d.bus.Tx(d.Address, buf[:2], nil)
+	return err
+}
+
+// ClearAlarm disables alarm.
+func (d *Device) ClearAlarm() error {
+	var buf [2]byte
+	buf[0] = 0x01
+	err := d.bus.Tx(d.Address, buf[:1], buf[1:])
+	if err != nil {
+		return err
+	}
+
+	buf[1] &= ^uint8(RTC_CTRL_AF)
+	err = d.bus.Tx(d.Address, buf[:], nil)
+	return err
+}
+
+// EnableAlarmInterrupt enables alarm interrupt. When triggered, INT pin (3)
+// goes low.
+func (d *Device) EnableAlarmInterrupt() error {
+	var buf [2]byte
+	buf[0] = 0x01
+	err := d.bus.Tx(d.Address, buf[:1], buf[1:])
+	if err != nil {
+		return err
+	}
+
+	buf[1] |= RTC_CTRL_AIE
+	err = d.bus.Tx(d.Address, buf[:], nil)
+	return err
+}
+
+// DisableAlarmInterrupt disable alarm interrupt.
+func (d *Device) DisableAlarmInterrupt() error {
+	var buf [2]byte
+	buf[0] = 0x01
+	err := d.bus.Tx(d.Address, buf[:1], buf[1:])
+	if err != nil {
+		return err
+	}
+
+	buf[1] &= ^uint8(RTC_CTRL_AIE)
+	err = d.bus.Tx(d.Address, buf[:], nil)
+	return err
+}
+
+// AlarmTriggered returns whether or not an Alarm has been triggered.
+func (d *Device) AlarmTriggered() bool {
+	var buf [1]byte
+	buf[0] = 0x01
+	err := d.bus.Tx(d.Address, buf[:], buf[:])
+	if err != nil {
+		return false
+	}
+	return (buf[0] & RTC_CTRL_AF) != 0
+}
+
+// SetTimer sets timer. The available durations are 1 to 127 seconds.  If any
+// other value is specified, it will be truncated.
+func (d *Device) SetTimer(dur time.Duration) error {
+	var buf [3]byte
+
+	sec := dur / time.Second
+	if sec > 127 {
+		sec = 127
+	}
+
+	// Treat as sec timer.
+	buf[0] = 0x0E
+	buf[1] = RTC_TIMER_1S
+	buf[2] = byte(sec)
+	err := d.bus.Tx(d.Address, buf[:], nil)
+	if err != nil {
+		return err
+	}
+
+	// enable alarm
+	buf[0] = 0x01
+	err = d.bus.Tx(d.Address, buf[:1], buf[1:])
+	if err != nil {
+		return err
+	}
+
+	buf[1] |= RTC_CTRL_TF
+	err = d.bus.Tx(d.Address, buf[:2], nil)
+	return err
+}
+
+// ClearTimer disables timer.
+func (d *Device) ClearTimer() error {
+	var buf [2]byte
+	buf[0] = 0x01
+	err := d.bus.Tx(d.Address, buf[:1], buf[1:])
+	if err != nil {
+		return err
+	}
+
+	buf[1] &= ^uint8(RTC_CTRL_TF)
+	err = d.bus.Tx(d.Address, buf[:], nil)
+	return err
+}
+
+// EnableTimerInterrupt enables timer interrupt. When triggered, INT pin (3)
+// goes low.
+func (d *Device) EnableTimerInterrupt() error {
+	var buf [2]byte
+	buf[0] = 0x01
+	err := d.bus.Tx(d.Address, buf[:1], buf[1:])
+	if err != nil {
+		return err
+	}
+
+	buf[1] |= RTC_CTRL_TIE
+	err = d.bus.Tx(d.Address, buf[:], nil)
+	return err
+}
+
+// DisableTimerInterrupt disable timer interrupt.
+func (d *Device) DisableTimerInterrupt() error {
+	var buf [2]byte
+	buf[0] = 0x01
+	err := d.bus.Tx(d.Address, buf[:1], buf[1:])
+	if err != nil {
+		return err
+	}
+
+	buf[1] &= ^uint8(RTC_CTRL_TIE)
+	err = d.bus.Tx(d.Address, buf[:], nil)
+	return err
+}
+
+// TimerTriggered returns whether or not an Alarm has been triggered.
+func (d *Device) TimerTriggered() bool {
+	var buf [1]byte
+	buf[0] = 0x01
+	err := d.bus.Tx(d.Address, buf[:], buf[:])
+	if err != nil {
+		return false
+	}
+	return (buf[0] & RTC_CTRL_TF) != 0
+}
+
+// SetOscillatorFrequency sets output oscillator frequency
+// Available modes: RTC_COT_DISABLE, RTC_COT_32KHZ, RTC_COT_1KHZ,
+// RTC_COT_32Hz, RTC_COT_1HZ.
+func (d *Device) SetOscillatorFrequency(sqw uint8) error {
+	var buf [2]byte
+	buf[0] = 0x0D
+	buf[1] = sqw
+	return d.bus.Tx(d.Address, buf[:], nil)
+}
+
+// decToBcd converts int to BCD
+func decToBcd(dec int) uint8 {
+	return uint8(dec + 6*(dec/10))
+}
+
+// bcdToDec converts BCD to int
+func bcdToDec(bcd uint8) int {
+	return int(bcd - 6*(bcd>>4))
+}

pcf8563/registers.go

@@ -0,0 +1,31 @@
+package pcf8563
+
+// Registers
+const (
+	PCF8563_ADDR = 0x51 // R:A3 W:A2
+
+	I2C_SPEED_STANDARD = 100000
+	I2C_SPEED_DOUBLE   = 200000
+
+	RTC_CTRL_STOP = 0x20
+	RTC_CTRL_TITP = 0x10
+	RTC_CTRL_AF   = 0x08
+	RTC_CTRL_TF   = 0x04
+	RTC_CTRL_AIE  = 0x02
+	RTC_CTRL_TIE  = 0x01
+
+	RTC_COT_DISABLE = 0x00
+	RTC_COT_32KHZ   = 0x80
+	RTC_COT_1KHZ    = 0x81
+	RTC_COT_32HZ    = 0x82
+	RTC_COT_1HZ     = 0x83
+
+	RTC_TIMER_DISABLE = 0x00
+	RTC_TIMER_4KHZ    = 0x80
+	RTC_TIMER_64HZ    = 0x81
+	RTC_TIMER_1S      = 0x82
+	RTC_TIMER_60S     = 0x83
+
+	RTC_ALARM_DISABLE = 0x80
+	RTC_ALARM_ENABLE  = 0x00
+)

servo/servo.go

@@ -0,0 +1,82 @@
+package servo
+
+import "machine"
+
+// PWM is the interface necessary for controlling typical servo motors.
+type PWM interface {
+	Configure(config machine.PWMConfig) error
+	Channel(pin machine.Pin) (channel uint8, err error)
+	Top() uint32
+	Set(channel uint8, value uint32)
+}
+
+// Array is an array of servos controlled by a single PWM peripheral. On most
+// chips, one PWM peripheral can control multiple servos (usually two or four).
+type Array struct {
+	pwm PWM
+}
+
+// Servo is a single servo (connected to one PWM output) that's part of a servo
+// array.
+type Servo struct {
+	pwm     PWM
+	channel uint8
+}
+
+const pwmPeriod = 20e6 // 20ms
+
+// NewArray returns a new servo array based on the given PWM, for if you want to
+// control multiple servos from a single PWM peripheral. Using a single PWM for
+// multiple servos saves PWM peripherals for other uses and might use less power
+// depending on the chip.
+//
+// If you only want to control a single servo, you could use the New shorthand
+// instead.
+func NewArray(pwm PWM) (Array, error) {
+	err := pwm.Configure(machine.PWMConfig{
+		Period: pwmPeriod,
+	})
+	if err != nil {
+		return Array{}, err
+	}
+	return Array{pwm}, nil
+}
+
+// Add adds a new servo to the servo array. Please check the chip documentation
+// which pins can be controlled by the given PWM: depending on the chip this
+// might be rigid (only a single pin) or very flexible (you can pick any pin).
+func (array Array) Add(pin machine.Pin) (Servo, error) {
+	channel, err := array.pwm.Channel(pin)
+	if err != nil {
+		return Servo{}, err
+	}
+	return Servo{
+		pwm:     array.pwm,
+		channel: channel,
+	}, nil
+}
+
+// New is a shorthand for NewArray and array.Add. This is useful if you only
+// want to control just a single servo.
+func New(pwm PWM, pin machine.Pin) (Servo, error) {
+	array, err := NewArray(pwm)
+	if err != nil {
+		return Servo{}, err
+	}
+	return array.Add(pin)
+}
+
+// SetMicroseconds sets the output signal to be high for the given number of
+// microseconds. For many servos the range is normally between 1000µs and 2000µs
+// for 90° of rotation (with 1500µs being the 'neutral' middle position).
+//
+// In many cases they can actually go a bit further, with a wider range of
+// supported pulse ranges. For example, they might allow pulse widths from 500µs
+// to 2500µs, but be warned that going outside of the 1000µs-2000µs range might
+// break the servo as it might destroy the gears if it doesn't support this
+// range. Therefore, to be sure check the datasheet before you try values
+// outside of the 1000µs-2000µs range.
+func (s Servo) SetMicroseconds(microseconds int16) {
+	value := uint64(s.pwm.Top()) * uint64(microseconds) / (pwmPeriod / 1000)
+	s.pwm.Set(s.channel, uint32(value))
+}

ssd1306/ssd1306.go

@@ -13,7 +13,7 @@ import (
 	"tinygo.org/x/drivers"
 )
 
-// Device wraps an SPI connection.
+// Device wraps I2C or SPI connection.
 type Device struct {
 	bus        Buser
 	buffer     []byte
@@ -21,6 +21,7 @@ type Device struct {
 	height     int16
 	bufferSize int16
 	vccState   VccMode
+	canReset   bool
 }
 
 // Config is the configuration for the display
@@ -98,6 +99,7 @@ func (d *Device) Configure(cfg Config) {
 	}
 	d.bufferSize = d.width * d.height / 8
 	d.buffer = make([]byte, d.bufferSize)
+	d.canReset = cfg.Address != 0 || d.width != 128 || d.height != 64 // I2C or not 128x64
 
 	d.bus.configure()
 
@@ -178,9 +180,11 @@ func (d *Device) ClearDisplay() {
 
 // Display sends the whole buffer to the screen
 func (d *Device) Display() error {
+	// Reset the screen to 0x0
+	// This works fine with I2C
 	// In the 128x64 (SPI) screen resetting to 0x0 after 128 times corrupt the buffer
-	// Since we're printing the whole buffer, avoid resetting it
-	if d.width != 128 || d.height != 64 {
+	// Since we're printing the whole buffer, avoid resetting it in this case
+	if d.canReset {
 		d.Command(COLUMNADDR)
 		d.Command(0)
 		d.Command(uint8(d.width - 1))

tester/device.go

@@ -1,61 +1,18 @@
 package tester
 
 // MaxRegisters is the maximum number of registers supported for a Device.
-const MaxRegisters = 200
+const MaxRegisters = 255
 
-// I2CDevice represents a mock I2C device on a mock I2C bus.
-type I2CDevice struct {
-	c Failer
-	// addr is the i2c device address.
-	addr uint8
-	// Registers holds the device registers. It can be inspected
-	// or changed as desired for testing.
-	Registers [MaxRegisters]uint8
-	// If Err is non-nil, it will be returned as the error from the
-	// I2C methods.
-	Err error
-}
+type I2CDevice interface {
+	// ReadRegister implements I2C.ReadRegister.
+	ReadRegister(r uint8, buf []byte) error
 
-// NewI2CDevice returns a new mock I2C device.
-func NewI2CDevice(c Failer, addr uint8) *I2CDevice {
-	return &I2CDevice{
-		c:    c,
-		addr: addr,
-	}
-}
+	// WriteRegister implements I2C.WriteRegister.
+	WriteRegister(r uint8, buf []byte) error
 
-// Addr returns the Device address.
-func (d *I2CDevice) Addr() uint8 {
-	return d.addr
-}
+	// Tx implements I2C.Tx
+	Tx(w, r []byte) error
 
-// ReadRegister implements I2C.ReadRegister.
-func (d *I2CDevice) ReadRegister(r uint8, buf []byte) error {
-	if d.Err != nil {
-		return d.Err
-	}
-	d.assertRegisterRange(r, buf)
-	copy(buf, d.Registers[r:])
-	return nil
-}
-
-// WriteRegister implements I2C.WriteRegister.
-func (d *I2CDevice) WriteRegister(r uint8, buf []byte) error {
-	if d.Err != nil {
-		return d.Err
-	}
-	d.assertRegisterRange(r, buf)
-	copy(d.Registers[r:], buf)
-	return nil
-}
-
-// assertRegisterRange asserts that reading or writing the given
-// register and subsequent registers is in range of the available registers.
-func (d *I2CDevice) assertRegisterRange(r uint8, buf []byte) {
-	if int(r) >= len(d.Registers) {
-		d.c.Fatalf("register read/write [%#x, %#x] start out of range", r, int(r)+len(buf))
-	}
-	if int(r)+len(buf) > len(d.Registers) {
-		d.c.Fatalf("register read/write [%#x, %#x] end out of range", r, int(r)+len(buf))
-	}
+	// Addr returns the Device address.
+	Addr() uint8
 }

tester/device16.go

@@ -0,0 +1,80 @@
+package tester
+
+// I2CDevice represents a mock I2C device on a mock I2C bus with 16-bit registers.
+type I2CDevice16 struct {
+	c Failer
+	// addr is the i2c device address.
+	addr uint8
+	// Registers holds the device registers. It can be inspected
+	// or changed as desired for testing.
+	Registers map[uint8]uint16
+	// If Err is non-nil, it will be returned as the error from the
+	// I2C methods.
+	Err error
+}
+
+// NewI2CDevice returns a new mock I2C device.
+//
+// To use this mock, populate the Registers map with known / expected
+// registers.  Attempts by the code under test to write to a register
+// that has not been populated into the map will be treated as an
+// error.
+func NewI2CDevice16(c Failer, addr uint8) *I2CDevice16 {
+	return &I2CDevice16{
+		c:         c,
+		addr:      addr,
+		Registers: map[uint8]uint16{},
+	}
+}
+
+// Addr returns the Device address.
+func (d *I2CDevice16) Addr() uint8 {
+	return d.addr
+}
+
+// ReadRegister implements I2C.ReadRegister.
+func (d *I2CDevice16) ReadRegister(r uint8, buf []byte) error {
+	if d.Err != nil {
+		return d.Err
+	}
+
+	if len(buf) > 2 {
+		d.c.Fatalf("register read [%#x, %#x] oversized buffer", r, len(buf))
+	}
+
+	val, ok := d.Registers[r]
+	if !ok {
+		d.c.Fatalf("register read [%#x] unknown register", r)
+	}
+
+	buf[0] = byte(val >> 8)
+	buf[1] = byte(val & 0xff)
+
+	return nil
+}
+
+// WriteRegister implements I2C.WriteRegister.
+func (d *I2CDevice16) WriteRegister(r uint8, buf []byte) error {
+	if d.Err != nil {
+		return d.Err
+	}
+
+	if len(buf) != 2 {
+		d.c.Fatalf("register write [%#x, %#x] mis-sized write", r, len(buf))
+	}
+
+	_, ok := d.Registers[r]
+	if !ok {
+		d.c.Fatalf("register write [%#x] unknown register", r)
+	}
+
+	d.Registers[r] = uint16(buf[0])<<8 | uint16(buf[1])
+
+	return nil
+}
+
+// Tx implements I2C.Tx.
+func (bus *I2CDevice16) Tx(w, r []byte) error {
+	// TODO: implement this
+	return nil
+}

tester/device16_test.go

@@ -0,0 +1,42 @@
+package tester
+
+import (
+	"testing"
+
+	qt "github.com/frankban/quicktest"
+)
+
+func TestCreate16(t *testing.T) {
+	c := qt.New(t)
+	bus := NewI2CBus(c)
+	d := NewI2CDevice16(c, 8)
+	bus.AddDevice(d)
+}
+
+func TestRead16(t *testing.T) {
+	c := qt.New(t)
+	bus := NewI2CBus(c)
+	d := NewI2CDevice16(c, 8)
+	bus.AddDevice(d)
+
+	// Setup a random register
+	d.Registers[3] = 0x1234
+
+	buf := []byte{0, 0}
+	err := bus.ReadRegister(8, 3, buf)
+	c.Assert(err, qt.IsNil)
+	c.Assert(buf[0], qt.Equals, byte(0x12))
+	c.Assert(buf[1], qt.Equals, byte(0x34))
+}
+
+func TestWrite16(t *testing.T) {
+	c := qt.New(t)
+	bus := NewI2CBus(c)
+	d := NewI2CDevice16(c, 8)
+	bus.AddDevice(d)
+
+	d.Registers[9] = 0x0
+	err := bus.WriteRegister(8, 9, []byte{0xbe, 0xad})
+	c.Assert(err, qt.IsNil)
+	c.Assert(d.Registers[9], qt.Equals, uint16(0xbead))
+}

tester/device8.go

@@ -0,0 +1,71 @@
+package tester
+
+// I2CDevice represents a mock I2C device on a mock I2C bus with 8-bit registers.
+type I2CDevice8 struct {
+	c Failer
+	// addr is the i2c device address.
+	addr uint8
+	// Registers holds the device registers. It can be inspected
+	// or changed as desired for testing.
+	Registers [MaxRegisters]uint8
+	// If Err is non-nil, it will be returned as the error from the
+	// I2C methods.
+	Err error
+}
+
+// NewI2CDevice returns a new mock I2C device.
+//
+// For compatibility, this creates an instance of NewI2CDevice8
+func NewI2CDevice(c Failer, addr uint8) *I2CDevice8 {
+	return NewI2CDevice8(c, addr)
+}
+
+// NewI2CDevice8 returns a new mock I2C device.
+func NewI2CDevice8(c Failer, addr uint8) *I2CDevice8 {
+	return &I2CDevice8{
+		c:    c,
+		addr: addr,
+	}
+}
+
+// Addr returns the Device address.
+func (d *I2CDevice8) Addr() uint8 {
+	return d.addr
+}
+
+// ReadRegister implements I2C.ReadRegister.
+func (d *I2CDevice8) ReadRegister(r uint8, buf []byte) error {
+	if d.Err != nil {
+		return d.Err
+	}
+	d.assertRegisterRange(r, buf)
+	copy(buf, d.Registers[r:])
+	return nil
+}
+
+// WriteRegister implements I2C.WriteRegister.
+func (d *I2CDevice8) WriteRegister(r uint8, buf []byte) error {
+	if d.Err != nil {
+		return d.Err
+	}
+	d.assertRegisterRange(r, buf)
+	copy(d.Registers[r:], buf)
+	return nil
+}
+
+// Tx implements I2C.Tx.
+func (bus *I2CDevice8) Tx(w, r []byte) error {
+	// TODO: implement this
+	return nil
+}
+
+// assertRegisterRange asserts that reading or writing the given
+// register and subsequent registers is in range of the available registers.
+func (d *I2CDevice8) assertRegisterRange(r uint8, buf []byte) {
+	if int(r) >= len(d.Registers) {
+		d.c.Fatalf("register read/write [%#x, %#x] start out of range", r, int(r)+len(buf))
+	}
+	if int(r)+len(buf) > len(d.Registers) {
+		d.c.Fatalf("register read/write [%#x, %#x] end out of range", r, int(r)+len(buf))
+	}
+}

tester/device8_test.go

@@ -0,0 +1,43 @@
+package tester
+
+import (
+	"testing"
+
+	qt "github.com/frankban/quicktest"
+)
+
+func TestCreate8(t *testing.T) {
+	c := qt.New(t)
+	bus := NewI2CBus(c)
+	d := NewI2CDevice8(c, 8)
+	bus.AddDevice(d)
+}
+
+func TestRead8(t *testing.T) {
+	c := qt.New(t)
+	bus := NewI2CBus(c)
+	d := NewI2CDevice8(c, 8)
+	bus.AddDevice(d)
+
+	// Setup a random register
+	d.Registers[3] = 0x12
+	d.Registers[4] = 0x34
+
+	buf := []byte{0, 0}
+	err := bus.ReadRegister(8, 3, buf)
+	c.Assert(err, qt.IsNil)
+	c.Assert(buf[0], qt.Equals, byte(0x12))
+	c.Assert(buf[1], qt.Equals, byte(0x34))
+}
+
+func TestWrite8(t *testing.T) {
+	c := qt.New(t)
+	bus := NewI2CBus(c)
+	d := NewI2CDevice8(c, 8)
+	bus.AddDevice(d)
+
+	err := bus.WriteRegister(8, 9, []byte{0xbe, 0xad})
+	c.Assert(err, qt.IsNil)
+	c.Assert(d.Registers[9], qt.Equals, uint8(0xbe))
+	c.Assert(d.Registers[10], qt.Equals, uint8(0xad))
+}

tester/devicecmd.go

@@ -0,0 +1,126 @@
+package tester
+
+// Cmd represents a command sent via I2C to a device.
+//
+// A command matches when (Command & Mask) == (Data & Mask).  If
+// a command is recognized, Response bytes is returned.
+type Cmd struct {
+	Command     []byte
+	Mask        []byte
+	Response    []byte
+	Invocations int
+}
+
+// I2CDeviceCmd represents a mock I2C device that does not
+// have 'registers', but has a command/response model.
+//
+// Commands and canned responses are pre-loaded into the
+// Commands member.  For each command the mock receives it
+// will lookup the command and return the corresponding
+// canned response.
+type I2CDeviceCmd struct {
+	c Failer
+
+	// addr is the i2c device address.
+	addr uint8
+
+	// Commands are the commands the device recognizes and responds to.
+	Commands map[uint8]*Cmd
+
+	// Command response that is pending (used with a command is split over)
+	// two transactions
+	pendingResponse []byte
+
+	// If Err is non-nil, it will be returned as the error from the
+	// I2C methods.
+	Err error
+}
+
+// NewI2CDeviceCmd returns a new mock I2C device.
+func NewI2CDeviceCmd(c Failer, addr uint8) *I2CDeviceCmd {
+	return &I2CDeviceCmd{
+		c:    c,
+		addr: addr,
+	}
+}
+
+// Addr returns the Device address.
+func (d *I2CDeviceCmd) Addr() uint8 {
+	return d.addr
+}
+
+// ReadRegister implements I2C.ReadRegister.
+func (d *I2CDeviceCmd) ReadRegister(r uint8, buf []byte) error {
+	if d.Err != nil {
+		return d.Err
+	}
+
+	return nil
+}
+
+// WriteRegister implements I2C.WriteRegister.
+func (d *I2CDeviceCmd) WriteRegister(r uint8, buf []byte) error {
+	if d.Err != nil {
+		return d.Err
+	}
+
+	return nil
+}
+
+// Tx implements I2C.Tx.
+func (d *I2CDeviceCmd) Tx(w, r []byte) error {
+	if d.Err != nil {
+		return d.Err
+	}
+
+	if len(w) == 0 && len(d.pendingResponse) != 0 {
+		return d.respond(r)
+	}
+
+	cmd := d.FindCommand(w)
+	if cmd == nil {
+		d.c.Fatalf("command [%#x] not identified", w)
+		return nil
+	}
+
+	cmd.Invocations++
+	d.pendingResponse = cmd.Response
+	return d.respond(r)
+}
+
+func (d *I2CDeviceCmd) FindCommand(command []byte) *Cmd {
+	for _, c := range d.Commands {
+		if len(c.Command) > len(command) {
+			continue
+		}
+
+		match := true
+		for i := 0; i < len(c.Command); i++ {
+			mask := c.Mask[i]
+			if (c.Command[i] & mask) != (command[i] & mask) {
+				match = false
+				break
+			}
+		}
+
+		if match {
+			return c
+		}
+	}
+
+	return nil
+}
+
+func (d *I2CDeviceCmd) respond(r []byte) error {
+	if len(r) > len(d.pendingResponse) {
+		d.c.Fatalf("read too large (expected: <= %#x, got: %#x)",
+			len(d.pendingResponse), len(r))
+	}
+
+	if len(r) > 0 {
+		copy(r, d.pendingResponse[:len(r)])
+		d.pendingResponse = nil
+	}
+
+	return nil
+}

tester/i2c.go

@@ -5,7 +5,7 @@ import "fmt"
 // I2CBus implements the I2C interface in memory for testing.
 type I2CBus struct {
 	c       Failer
-	devices []*I2CDevice
+	devices []I2CDevice
 }
 
 // NewI2CBus returns an I2CBus mock I2C instance that uses c to flag errors
@@ -19,9 +19,9 @@ func NewI2CBus(c Failer) *I2CBus {
 
 // AddDevice adds a new mock device to the mock I2C bus.
 // It panics if a device with the same address is added more than once.
-func (bus *I2CBus) AddDevice(d *I2CDevice) {
+func (bus *I2CBus) AddDevice(d I2CDevice) {
 	for _, dev := range bus.devices {
-		if dev.Addr() == d.addr {
+		if dev.Addr() == d.Addr() {
 			panic(fmt.Errorf("device already added at address %#x", d))
 		}
 	}
@@ -30,8 +30,8 @@ func (bus *I2CBus) AddDevice(d *I2CDevice) {
 
 // NewDevice creates a new device with the given address
 // and adds it to the mock I2C bus.
-func (bus *I2CBus) NewDevice(addr uint8) *I2CDevice {
-	dev := NewI2CDevice(bus.c, addr)
+func (bus *I2CBus) NewDevice(addr uint8) *I2CDevice8 {
+	dev := NewI2CDevice8(bus.c, addr)
 	bus.AddDevice(dev)
 	return dev
 }
@@ -48,12 +48,11 @@ func (bus *I2CBus) WriteRegister(addr uint8, r uint8, buf []byte) error {
 
 // Tx implements I2C.Tx.
 func (bus *I2CBus) Tx(addr uint16, w, r []byte) error {
-	// TODO: implement this
-	return nil
+	return bus.FindDevice(uint8(addr)).Tx(w, r)
 }
 
 // FindDevice returns the device with the given address.
-func (bus *I2CBus) FindDevice(addr uint8) *I2CDevice {
+func (bus *I2CBus) FindDevice(addr uint8) I2CDevice {
 	for _, dev := range bus.devices {
 		if dev.Addr() == addr {
 			return dev

tm1637/registers.go

@@ -0,0 +1,16 @@
+package tm1637
+
+const (
+	TM1637_CMD1   = 0x40
+	TM1637_CMD2   = 0xC0
+	TM1637_CMD3   = 0x80
+	TM1637_DSP_ON = 0x08
+	TM1637_DELAY  = uint8(10)
+)
+
+// 7-segment characters encoding for 0-9, A-Z, a-z, blank, dash, star
+var segments []byte = []byte{
+	0x3F, 0x06, 0x5B, 0x4F, 0x66, 0x6D, 0x7D, 0x07, 0x7F, 0x6F,
+	0x77, 0x7C, 0x39, 0x5E, 0x79, 0x71, 0x3D, 0x76, 0x06, 0x1E,
+	0x76, 0x38, 0x55, 0x54, 0x3F, 0x73, 0x67, 0x50, 0x6D, 0x78,
+	0x3E, 0x1C, 0x2A, 0x76, 0x6E, 0x5B, 0x00, 0x40, 0x63}

tm1637/tm1637.go

@@ -0,0 +1,215 @@
+// Package tm1637 provides a driver for the TM1637 4-digit 7-segment LED display.
+//
+// Datasheet: https://www.mcielectronics.cl/website_MCI/static/documents/Datasheet_TM1637.pdf
+//
+package tm1637
+
+import (
+	"machine"
+	"time"
+)
+
+// Device wraps the pins of the TM1637.
+type Device struct {
+	clk        machine.Pin
+	dio        machine.Pin
+	brightness uint8
+}
+
+// New creates a new TM1637 device.
+func New(clk machine.Pin, dio machine.Pin, brightness uint8) Device {
+	return Device{clk: clk, dio: dio, brightness: brightness}
+}
+
+// Configure sets up the pins.
+func (d *Device) Configure() {
+	pinMode(d.clk, false)
+	pinMode(d.dio, false)
+	d.clk.Low() // required for future pull-down
+	d.dio.Low() // required for future pull-down
+}
+
+// Brightness sets the brightness of the display (0-7).
+func (d *Device) Brightness(brightness uint8) {
+	if brightness > 7 {
+		brightness = 7
+	}
+	d.brightness = brightness
+	d.writeCmd()
+	d.writeDsp()
+}
+
+// ClearDisplay clears the display.
+func (d *Device) ClearDisplay() {
+	d.writeData([]byte{0, 0, 0, 0}, 0)
+}
+
+// DisplayText shows a text on the display.
+//
+// Only the first 4 letters in the array text would be shown.
+func (d *Device) DisplayText(text []byte) {
+	var sequences []byte
+	for i, t := range text {
+		if i > 3 {
+			break
+		}
+		sequences = append(sequences, encodeChr(t))
+	}
+	d.writeData(sequences, 0)
+}
+
+// DisplayChr shows a single character (A-Z, a-z)
+// on the display at position 0-3.
+func (d *Device) DisplayChr(chr byte, pos uint8) {
+	if pos > 3 {
+		pos = 3
+	}
+	d.writeData([]byte{encodeChr(chr)}, pos)
+}
+
+// DisplayNumber shows a number on the display.
+//
+// Only 4 rightmost digits of the number would be shown.
+//
+// For negative numbers, only -999 to -1 would be
+// shown with a negaive sign.
+func (d *Device) DisplayNumber(num int16) {
+	var sequences []byte
+	var start int16
+	if num < 0 {
+		sequences = append(sequences, segments[37])
+		num *= -1
+		start = 100
+		num %= 1000
+	} else {
+		start = 1000
+		num %= 10000
+	}
+	for i := start; i >= 1; i /= 10 {
+		if num >= i {
+			n := (num / int16(i)) % 10
+			sequences = append(sequences, segments[n])
+		} else {
+			if i == 1 && num == 0 {
+				sequences = append(sequences, segments[0])
+			} else {
+				sequences = append(sequences, 0)
+			}
+		}
+	}
+	d.writeData(sequences, 0)
+}
+
+// DisplayDigit shows a single-digit number (0-9)
+// at position 0-3.
+func (d *Device) DisplayDigit(digit uint8, pos uint8) {
+	digit %= 10
+	d.writeData([]byte{segments[digit]}, pos)
+}
+
+// DisplayClock allows you to display hour and minute numbers
+// together with the colon on/off.
+func (d *Device) DisplayClock(num1 uint8, num2 uint8, colon bool) {
+	var sequences []byte
+	num := []uint8{num1 % 100, num2 % 100}
+	for k := 0; k < 2; k++ {
+		for i := 10; i >= 1; i /= 10 {
+			n := (num[k] / uint8(i)) % 10
+			sequences = append(sequences, segments[n])
+		}
+	}
+	if colon {
+		sequences[1] |= 1 << 7
+	}
+	d.writeData(sequences, 0)
+}
+
+func encodeChr(c byte) byte {
+	r := rune(c)
+	switch {
+	case r == 32:
+		return segments[36] // space
+	case r == 42:
+		return segments[38] // star/degrees
+	case r == 45:
+		return segments[37] // dash
+	case r >= 65 && r <= 90:
+		return segments[r-55] // uppercase A-Z
+	case r >= 97 && r <= 122:
+		return segments[r-87] // lowercase a-z
+	case r >= 48 && r <= 57:
+		return segments[r-48] // 0-9
+	default:
+		return byte(0)
+	}
+}
+
+func delaytm() {
+	time.Sleep(time.Microsecond * time.Duration(TM1637_DELAY))
+}
+
+func pinMode(pin machine.Pin, mode bool) {
+	// TM1637 has internal pull-up resistors for both CLK and DIO pins.
+	// Set them to input mode will pull them high,
+	// and set them to output mode will pull them down
+	// (since we did so in the beginning.)
+	// The High()/Low() method don't work on some boards.
+	if mode {
+		pin.Configure(machine.PinConfig{Mode: machine.PinInput})
+	} else {
+		pin.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	}
+}
+
+func (d *Device) start() {
+	pinMode(d.dio, false)
+	delaytm()
+	pinMode(d.clk, false)
+}
+
+func (d *Device) stop() {
+	pinMode(d.dio, false)
+	delaytm()
+	pinMode(d.clk, true)
+	delaytm()
+	pinMode(d.dio, true)
+}
+
+func (d *Device) writeByte(data uint8) {
+	for i := 0; i < 8; i++ {
+		pinMode(d.dio, data&(1<<i) > 0) // send bits from LSB to MSB
+		delaytm()
+		pinMode(d.clk, true)
+		delaytm()
+		pinMode(d.clk, false)
+		delaytm()
+	}
+	pinMode(d.clk, false)
+	delaytm()
+	pinMode(d.clk, true)
+	delaytm()
+	pinMode(d.clk, false)
+}
+
+func (d *Device) writeCmd() {
+	d.start()
+	d.writeByte(TM1637_CMD1)
+	d.stop()
+}
+
+func (d *Device) writeDsp() {
+	d.start()
+	d.writeByte(TM1637_CMD3 | TM1637_DSP_ON | d.brightness)
+	d.stop()
+}
+
+func (d *Device) writeData(segments []byte, position uint8) {
+	d.writeCmd()
+	d.start()
+	d.writeByte(TM1637_CMD2 | position)
+	for _, seg := range segments {
+		d.writeByte(seg)
+	}
+	d.stop()
+	d.writeDsp()
+}

tone/notes.go

@@ -0,0 +1,147 @@
+package tone
+
+// Note represents a MIDI note number. For example, Note(69) is A4 or 440Hz.
+type Note uint8
+
+// Define all the notes in a format similar to the Tone library in the Arduino
+// IDE.
+const (
+	A0 Note = iota + 21 // 27.5Hz
+	AS0
+	B0
+	C1
+	CS1
+	D1
+	DS1
+	E1
+	F1
+	FS1
+	G1
+	GS1
+	A1 // 55Hz
+	AS1
+	B1
+	C2
+	CS2
+	D2
+	DS2
+	E2
+	F2
+	FS2
+	G2
+	GS2
+	A2 // 110Hz
+	AS2
+	B2
+	C3
+	CS3
+	D3
+	DS3
+	E3
+	F3
+	FS3
+	G3
+	GS3
+	A3 // 220Hz
+	AS3
+	B3
+	C4
+	CS4
+	D4
+	DS4
+	E4
+	F4
+	FS4
+	G4
+	GS4
+	A4 // 440Hz
+	AS4
+	B4
+	C5
+	CS5
+	D5
+	DS5
+	E5
+	F5
+	FS5
+	G5
+	GS5
+	A5 // 880Hz
+	AS5
+	B5
+	C6
+	CS6
+	D6
+	DS6
+	E6
+	F6
+	FS6
+	G6
+	GS6
+	A6 // 1760Hz
+	AS6
+	B6
+	C7
+	CS7
+	D7
+	DS7
+	E7
+	F7
+	FS7
+	G7
+	GS7
+	A7 // 3520Hz
+	AS7
+	B7
+	C8
+	CS8
+	D8
+	DS8
+	E8
+	F8
+	FS8
+	G8
+	GS8
+	A8 // 7040Hz
+	AS8
+	B8
+)
+
+// Period returns the period in nanoseconds of a single wave.
+func (n Note) Period() uint64 {
+	if n == 0 {
+		// Assume that a zero note means no sound.
+		return 0
+	}
+
+	octave := (n - 9) / 12
+	note := (n - 9) - octave*12
+
+	// Start with a base period (in nanoseconds) of 6.875Hz (quarter the
+	// frequency of A0) and shift it right with the octave to get the base
+	// period of this note.
+	//     145454545 = 1e9 / 6.875
+	basePeriod := uint32(145454545) >> octave
+
+	// Make the pitch higher based on the note within the octave.
+	period := uint64(basePeriod) * uint64(tones[note]) / 32768
+
+	return period
+}
+
+// Constants to calculate the pitch within an octave. Python oneliner:
+// [round(1e9/(440*(2**(n/12))) / (1e9/440) * 0x8000) for n in range(12)]
+var tones = [12]uint16{
+	32768,
+	30929,
+	29193,
+	27554,
+	26008,
+	24548,
+	23170,
+	21870,
+	20643,
+	19484,
+	18390,
+	17358,
+}

tone/tone.go

@@ -0,0 +1,73 @@
+package tone
+
+import (
+	"machine"
+)
+
+// PWM is the interface necessary for controlling a speaker.
+type PWM interface {
+	Configure(config machine.PWMConfig) error
+	Channel(pin machine.Pin) (channel uint8, err error)
+	Top() uint32
+	Set(channel uint8, value uint32)
+	SetPeriod(period uint64) error
+}
+
+// Speaker is a configured audio output channel based on a PWM.
+type Speaker struct {
+	pwm PWM
+	ch  uint8
+}
+
+// New returns a new Speaker instance readily configured for the given PWM and
+// pin combination. The lowest frequency possible is 27.5Hz, or A0. The audio
+// output uses a PWM so the audio will form a square wave, a sound that
+// generally sounds rather harsh.
+func New(pwm PWM, pin machine.Pin) (Speaker, error) {
+	err := pwm.Configure(machine.PWMConfig{
+		Period: uint64(1e9) / 55 / 2,
+	})
+	if err != nil {
+		return Speaker{}, err
+	}
+	ch, err := pwm.Channel(pin)
+	if err != nil {
+		return Speaker{}, err
+	}
+	return Speaker{pwm, ch}, nil
+}
+
+// Stop disables the speaker, setting the output to low continuously.
+func (s Speaker) Stop() {
+	s.pwm.Set(s.ch, 0)
+}
+
+// SetPeriod sets the period for the signal in nanoseconds. Use the following
+// formula to convert frequency to period:
+//
+//     period = 1e9 / frequency
+//
+// You can also use s.SetNote() instead for MIDI note numbers.
+func (s Speaker) SetPeriod(period uint64) {
+	// Disable output.
+	s.Stop()
+
+	if period == 0 {
+		// Assume a period of 0 is intended as "no output".
+		return
+	}
+
+	// Reconfigure period.
+	s.pwm.SetPeriod(period)
+
+	// Make this a square wave by setting the channel position to half the
+	// period.
+	s.pwm.Set(s.ch, s.pwm.Top()/2)
+}
+
+// SetNote starts playing the given note. For example, s.SetNote(C4) will
+// produce a 440Hz square wave tone.
+func (s Speaker) SetNote(note Note) {
+	period := note.Period()
+	s.SetPeriod(period)
+}

uart.go

@@ -0,0 +1,12 @@
+package drivers
+
+import "io"
+
+// UART represents a UART connection. It is implemented by the machine.UART
+// type.
+type UART interface {
+	io.Reader
+	io.Writer
+
+	Buffered() int
+}

version.go

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

wifinina/README.md

@@ -8,24 +8,13 @@ The way this driver works is by using the SPI interface of your microcontroller
 
 For information on how to use this driver, please take a look at the examples located in the [examples/wifinina](../examples/wifinina) directory.
 
-## WiFiNINA Firmware Installation
+## nina-fw Firmware
 
-**PLEASE NOTE: New Arduino Nano33 IoT boards already have the WiFiNINA firmware pre-installed, so you should not need to install the firmware yourself.**
+**PLEASE NOTE: New Adafruit Boards with WiFi and Arduino Nano33 IoT boards most likely already have a recent version of the nina-fw firmware pre-installed. You should not need to install the firmware yourself.**
 
-In order to use this driver, you must have the WiFiNINA firmware installed on the ESP32 chip. If it is already installed, you can just use it. You do not need to build and flash the firmware again.
+In order to use this driver, you must have the nina-fw firmware installed on the ESP32 chip. If it is already installed, you can just use it. You do not need to flash the firmware again. The following instructions are only for those who want or need to update the firmware on your board.
 
-### Building the WifiNINA firmware
-
-We have provided a Dockerfile that can build the needed firmware.
-
-```shell
-docker build -t wifinina ./wifinina/
-docker run -v "$(pwd)/build:/src/build" wifinina
-```
-
-This will put the firmware files into the `build` directory. Now you can flash them to the ESP32 chip.
-
-### Installing esptool to flash WifiNINA firmware
+### Installing esptool to flash nina-fw firmware
 
 In order to flash the firmware, you need to use Python to install the `esptool` package.
 
@@ -35,24 +24,33 @@ pip install esptool
 
 Once you have installed `esptool` you can follow the correct procedure for flashing your board.
 
-### Installing on Arduino Nano33 IoT
+### Updating nina-fw on the Arduino Nano33 IoT
 
-The Arduino Nano33 IoT board has the WiFiNINA firmware flashed onto the onboard NINA-W102 chip out of the box.
+In the `updater` directory we have a precompiled binary of the "passthrough" code you will need to flash first, in order to update the ESP32 co-processor on your board.
 
-Flashing the firmware is only necessary on the Arduino Nano33 IoT in order to upgrade or if other firmware was installed previously.
-
-If you do want to install the firmware on the Arduino Nano33 IoT board's built-in NINA-W102 chip, you will need to first build the firmware as described above.
-
-To flash this firmware on the Arduino Nano33 IoT you will need to follow the following procedure using the Arduino IDE software:
-
-- Install _Arduino SAMD Boards_ from the Boards Manager.
-- Install _WiFiNINA_ from the Library Manager.
-- Using the normal Arduino software, load the `SerialNINAPassthrough` sketch on to the board (in File -> Examples -> WiFiNINA-> Tools).
-
-Now you can flash the WifiNINA firmware using the `esptool` script:
+This is what needs to be done. There is also a bash script that performs the same steps also located in the `updater` directory.
 
 ```shell
-python esptool.py --chip esp32 --port /dev/ttyACM0 --baud 115200 --before no_reset --after hard_reset write_flash -z --flash_mode dio --flash_freq 40m --flash_size detect 0x1000 build/bootloader.bin 0xf000 build/phy_init_data.bin 0x30000 build/nina-fw.bin 0x8000 build/partitions.bin
+mkdir -p ../build
+
+# reset board into bootloader mode using 1200 baud
+stty -F /dev/ttyACM0 ispeed 1200 ospeed 1200
+
+# flash the passthru binary to the SAMD21 using bossac
+# code from https://github.com/arduino-libraries/WiFiNINA/blob/master/examples/Tools/SerialNINAPassthrough/SerialNINAPassthrough.ino
+bossac -d -i -e -w -v -R --port=/dev/ttyACM0 --offset=0x2000 ./SerialNINAPassthrough.ino.nano_33_iot.bin
+
+# download the nina-fw binary
+wget -P ../build/ https://github.com/arduino/nina-fw/releases/download/1.4.5/NINA_W102-v1.4.5.bin 
+
+# flash the nina-fw binary to the ESP32 using esptool
+esptool --port /dev/ttyACM0 --before default_reset --baud 115200 write_flash 0 ../build/NINA_W102-v1.4.5.bin
 ```
 
-You only need to do this one time, and then the correct WiFiNINA firmware will be on the NINA chip, and you can just flash the Arduino Nano33 IoT board using TinyGo. We should be able to remove some of these steps in a future release of this software.
+You only need to do this one time, and then the correct nina-fw firmware will be on the NINA ESP32 chip, and you can just flash the Arduino Nano33 IoT board using TinyGo.
+
+## Updating Adafruit ESP32 WiFi Boards
+
+Adafruit provides very good instructions for updating their boards that provide a ESP32 WiFi-BLE co-processor. For more information, please see:
+
+https://learn.adafruit.com/upgrading-esp32-firmware

wifinina/tcp.go

@@ -50,19 +50,24 @@ func (drv *Driver) connectSocket(addr, portStr string, mode uint8) error {
 	drv.proto, drv.ip, drv.port = mode, 0, 0
 
 	// convert port to uint16
-	p64, err := strconv.ParseUint(portStr, 10, 16)
-	if err != nil {
-		return fmt.Errorf("could not convert port to uint16: %s", err.Error())
-	}
-	port := uint16(p64)
-
-	// look up the hostname if necessary; if an IP address was specified, the
-	// same will be returned.  Otherwise, an IPv4 for the hostname is returned.
-	ipAddr, err := drv.dev.GetHostByName(addr)
+	port, err := convertPort(portStr)
 	if err != nil {
 		return err
 	}
-	ip := ipAddr.AsUint32()
+
+	hostname := addr
+	ip := uint32(0)
+
+	if mode != ProtoModeTLS {
+		// look up the hostname if necessary; if an IP address was specified, the
+		// same will be returned.  Otherwise, an IPv4 for the hostname is returned.
+		ipAddr, err := drv.dev.GetHostByName(addr)
+		if err != nil {
+			return err
+		}
+		hostname = ""
+		ip = ipAddr.AsUint32()
+	}
 
 	// check to see if socket is already set; if so, stop it
 	if drv.sock != NoSocketAvail {
@@ -77,7 +82,7 @@ func (drv *Driver) connectSocket(addr, portStr string, mode uint8) error {
 	}
 
 	// attempt to start the client
-	if err := drv.dev.StartClient(ip, port, drv.sock, mode); err != nil {
+	if err := drv.dev.StartClient(hostname, ip, port, drv.sock, mode); err != nil {
 		return err
 	}
 
@@ -169,7 +174,7 @@ func (drv *Driver) Write(b []byte) (n int, err error) {
 		return 0, ErrNoData
 	}
 	if drv.proto == ProtoModeUDP {
-		if err := drv.dev.StartClient(drv.ip, drv.port, drv.sock, drv.proto); err != nil {
+		if err := drv.dev.StartClient("", drv.ip, drv.port, drv.sock, drv.proto); err != nil {
 			return 0, fmt.Errorf("error in startClient: %w", err)
 		}
 		if _, err := drv.dev.InsertDataBuf(b, drv.sock); err != nil {

wifinina/updater/update_ninafw.sh

@@ -0,0 +1,15 @@
+#!/bin/bash
+
+mkdir -p ../build
+
+# flash the passthru binary to the SAMD21 using bossac
+# code from https://github.com/arduino-libraries/WiFiNINA/blob/master/examples/Tools/SerialNINAPassthrough/SerialNINAPassthrough.ino
+stty -F /dev/ttyACM0 ispeed 1200 ospeed 1200
+bossac -d -i -e -w -v -R --port=/dev/ttyACM0 --offset=0x2000 ./SerialNINAPassthrough.ino.nano_33_iot.bin
+
+# download the nina-fw binary
+wget -P ../build/ https://github.com/arduino/nina-fw/releases/download/1.4.5/NINA_W102-v1.4.5.bin 
+
+# flash the nina-fw binary to the ESP32 using esptool
+esptool --port /dev/ttyACM0 --before default_reset --baud 115200 write_flash 0 ../build/NINA_W102-v1.4.5.bin
+

wifinina/wifinina.go

@@ -303,22 +303,32 @@ func (d *Device) Configure() {
 
 // ----------- client methods (should this be a separate struct?) ------------
 
-func (d *Device) StartClient(addr uint32, port uint16, sock uint8, mode uint8) error {
+func (d *Device) StartClient(hostname string, addr uint32, port uint16, sock uint8, mode uint8) error {
 	if _debug {
-		println("[StartClient] called StartClient()\r")
-		fmt.Printf("[StartClient] addr: % 02X, port: %d, sock: %d\r\n", addr, port, sock)
+		fmt.Printf("[StartClient] hostname: %s addr: % 02X, port: %d, sock: %d\r\n", hostname, addr, port, sock)
 	}
 	if err := d.waitForChipSelect(); err != nil {
 		d.spiChipDeselect()
 		return err
 	}
-	l := d.sendCmd(CmdStartClientTCP, 4)
-	l += d.sendParam32(addr, false)
-	l += d.sendParam16(port, false)
-	l += d.sendParam8(sock, false)
-	l += d.sendParam8(mode, true)
-	d.addPadding(l)
+
+	if len(hostname) > 0 {
+		d.sendCmd(CmdStartClientTCP, 5)
+		d.sendParamStr(hostname, false)
+	} else {
+		d.sendCmd(CmdStartClientTCP, 4)
+	}
+	d.sendParam32(addr, false)
+	d.sendParam16(port, false)
+	d.sendParam8(sock, false)
+	d.sendParam8(mode, true)
+
+	if len(hostname) > 0 {
+		d.padTo4(17 + len(hostname))
+	}
+
 	d.spiChipDeselect()
+
 	_, err := d.waitRspCmd1(CmdStartClientTCP)
 	return err
 }
@@ -547,8 +557,9 @@ func (d *Device) GetReasonCode() (uint8, error) {
 	return d.getUint8(d.req0(CmdGetReasonCode))
 }
 
-func (d *Device) GetTime() (string, error) {
-	return d.getString(d.req0(CmdGetTime))
+// GetTime is the time as a Unix timestamp
+func (d *Device) GetTime() (uint32, error) {
+	return d.getUint32(d.req0(CmdGetTime))
 }
 
 func (d *Device) GetTemperature() (float32, error) {
@@ -579,7 +590,24 @@ func (d *Device) SetPassphrase(ssid string, passphrase string) error {
 }
 
 func (d *Device) SetKey(ssid string, index uint8, key string) error {
-	return ErrNotImplemented
+	defer d.spiChipDeselect()
+	if err := d.waitForChipSelect(); err != nil {
+		return err
+	}
+
+	d.sendCmd(CmdSetKey, 3)
+	d.sendParamStr(ssid, false)
+	d.sendParam8(index, false)
+	d.sendParamStr(key, true)
+
+	d.padTo4(8 + len(ssid) + len(key))
+
+	_, err := d.waitRspCmd1(CmdSetKey)
+	if err != nil {
+		return err
+	}
+
+	return nil
 }
 
 func (d *Device) SetNetworkForAP(ssid string) error {
@@ -597,11 +625,41 @@ func (d *Device) SetIP(which uint8, ip uint32, gw uint32, subnet uint32) error {
 }
 
 func (d *Device) SetDNS(which uint8, dns1 uint32, dns2 uint32) error {
-	return ErrNotImplemented
+	defer d.spiChipDeselect()
+	if err := d.waitForChipSelect(); err != nil {
+		return err
+	}
+
+	d.sendCmd(CmdSetDNSConfig, 3)
+	d.sendParam8(which, false)
+	d.sendParam32(dns1, false)
+	d.sendParam32(dns2, true)
+
+	_, err := d.waitRspCmd1(CmdSetDNSConfig)
+	if err != nil {
+		return err
+	}
+
+	return nil
 }
 
 func (d *Device) SetHostname(hostname string) error {
-	return ErrNotImplemented
+	defer d.spiChipDeselect()
+	if err := d.waitForChipSelect(); err != nil {
+		return err
+	}
+
+	d.sendCmd(CmdSetHostname, 3)
+	d.sendParamStr(hostname, true)
+
+	d.padTo4(5 + len(hostname))
+
+	_, err := d.waitRspCmd1(CmdSetHostname)
+	if err != nil {
+		return err
+	}
+
+	return nil
 }
 
 func (d *Device) SetPowerMode(mode uint8) error {
@@ -677,7 +735,7 @@ func (d *Device) getMACAddress(l uint8, err error) (MACAddress, error) {
 	if l != 6 {
 		return 0, ErrUnexpectedLength
 	}
-	return MACAddress(binary.LittleEndian.Uint64(d.buf[0:8]) >> 16), err
+	return MACAddress(binary.LittleEndian.Uint64(d.buf[0:8]) & 0xFFFFFFFFFFFF), err
 }
 
 // req0 sends a command to the device with no request parameters
@@ -768,8 +826,8 @@ func (d *Device) sendCmdStr(cmd uint8, p1 string) (err error) {
 		return err
 	}
 	l := d.sendCmd(cmd, 1)
-	l += d.sendParamStr(p1, false)
-	d.addPadding(l)
+	l += d.sendParamStr(p1, true)
+	d.padTo4(5 + len(p1))
 	return nil
 }
 
@@ -778,10 +836,10 @@ func (d *Device) sendCmdStr2(cmd uint8, p1 string, p2 string) (err error) {
 	if err := d.waitForChipSelect(); err != nil {
 		return err
 	}
-	l := d.sendCmd(cmd, 2)
-	l += d.sendParamStr(p1, false)
-	l += d.sendParamStr(p2, true)
-	d.addPadding(l)
+	d.sendCmd(cmd, 2)
+	d.sendParamStr(p1, false)
+	d.sendParamStr(p2, true)
+	d.padTo4(6 + len(p1) + len(p2))
 	return nil
 }
 
@@ -1092,3 +1150,14 @@ func (d *Device) addPadding(l int) {
 		d.SPI.Transfer(dummyData)
 	}
 }
+
+func (d *Device) padTo4(l int) {
+	if _debug {
+		println("padTo4", l, "\r")
+	}
+
+	for l%4 != 0 {
+		d.SPI.Transfer(dummyData)
+		l++
+	}
+}