Prepare for drivers release 0.15.0

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

.circleci/config.yml

@@ -12,6 +12,9 @@ jobs:
       - run:
           name: "Enforce Go Formatted Code"
           command: make fmt-check
+      - run:
+          name: "Run unit tests"
+          command: make unit-test
       - run:
           name: "Run build and smoke tests"
           command: make smoke-test

CHANGELOG.md

@@ -1,3 +1,57 @@
+0.15.0
+---
+- **new devices**
+    - dht: add DHTXX thermometer
+    - mcp23017: new driver for MCP23017 (I2C port expander)
+    - bmp388: Add bmp388 support (#219)
+- **enhancements**
+    - hd44780: add a mode to work with boards where the RW pin is grounded
+    - st7789: add scrolling functions to match st7735
+    - microbitmatrix: matrix now working on microbit v2
+    - ds1307: Better interface "ReadTime" instead of "Time"
+    - ws2812: make AVR support more robust
+- **bugfixes**
+    - all: fix main package in examples
+- **core**
+    - adc: update all drivers with ADC to use new config struct
+    - spi: remove machine.SPI and replace with drivers.SPI interface for almost all SPI drivers
+- **testing**
+    - test: run unit tests against i2c drivers and any spi drivers without direct gpio
+- **docs**
+    - st7789: correct errors on various godoc comments
+
+0.14.0
+---
+- **new devices**
+    - lis2mdl: add LIS2MDL magnetometer (#187)
+    - waveshare: add Waveshare 4.2in B/W e-paper driver (#183)
+- **enhancements**
+    - adt7410: add connection test and for that matter connection method
+    - gps
+        - add speed and heading to fix, as parsed from RMC NMEA sentence
+        - improvements and bugfixes (#186)
+    - ili9341
+        - add support for setting framerate, vsync pause, and reading scanline data.
+        - renamed NewSpi() to NewSPI() in accordance with Go naming conventions
+    - ws2812
+        - add support for ESP8266
+        - add support for ESP32
+- **bugfixes**
+    - ili9341
+        - rix setWindow bug, add CS pin for Clue compatibility. (#180)
+        - bugfix for RAMWR bug
+    - lis2mdl: turn on read mode on every read, to ensure that magnetometer data is updated
+- **core**
+    - i2c
+        - switch all i2c drivers definitions to use i2c bus interface type instead of machine package concrete type
+        - correct interface definition for I2C Tx function
+- **testing**
+    - fix smoke-test unless avr-gcc installed
+    - add very basic mock structs for testing i2c devices, based on work done by @rogpeppe
+    - improve API surface and implement one more test function in lis2mdl driver
+- **docs**
+    - replace README badge for godocs with pkgdocs
+
 0.13.0
 ---
 - **new devices**

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2018-2020 The TinyGo Authors. All rights reserved.
+Copyright (c) 2018-2021 The TinyGo Authors. All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are

Makefile

@@ -31,6 +31,8 @@ smoke-test:
 	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=itsybitsy-m0 ./examples/bmp280/main.go
 	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=trinket-m0 ./examples/bmp388/main.go
+	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=bluepill ./examples/ds1307/sram/main.go
 	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=bluepill ./examples/ds1307/time/main.go
@@ -81,6 +83,10 @@ smoke-test:
 	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=itsybitsy-m0 ./examples/mag3110/main.go
 	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=itsybitsy-m0 ./examples/mcp23017/main.go
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=itsybitsy-m0 ./examples/mcp23017-multiple/main.go
+	@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=microbit ./examples/microbitmatrix/main.go
@@ -119,6 +125,8 @@ smoke-test:
 	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=microbit ./examples/waveshare-epd/epd2in13x/main.go
 	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=microbit ./examples/waveshare-epd/epd4in2/main.go
+	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=arduino-nano33 ./examples/wifinina/ntpclient/main.go
 	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=arduino-nano33 ./examples/wifinina/udpstation/main.go
@@ -129,8 +137,12 @@ smoke-test:
 	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=circuitplay-express ./examples/ws2812
 	@md5sum ./build/test.hex
+ifneq ($(AVR), 0)
+	tinygo build -size short -o ./build/test.hex -target=arduino   ./examples/ws2812
+	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=digispark ./examples/ws2812
 	@md5sum ./build/test.hex
+endif
 	tinygo build -size short -o ./build/test.hex -target=trinket-m0 ./examples/bme280/main.go
 	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=circuitplay-express ./examples/microphone/main.go
@@ -151,5 +163,18 @@ smoke-test:
 	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=hifive1b ./examples/ssd1351/main.go
 	@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=feather-m0 ./examples/dht/main.go
+	@md5sum ./build/test.hex
 
-test: clean fmt-check smoke-test
+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
+TESTS = $(filter-out $(addsuffix /%,$(NOTESTS)),$(DRIVERS))
+
+unit-test:
+	@go test -v $(addprefix ./,$(TESTS)) 
+
+test: clean fmt-check unit-test smoke-test

README.md

@@ -1,9 +1,9 @@
 # TinyGo Drivers
 
-[![GoDoc](https://godoc.org/tinygo.org/x/drivers?status.svg)](https://godoc.org/tinygo.org/x/drivers) [![CircleCI](https://circleci.com/gh/tinygo-org/drivers/tree/dev.svg?style=svg)](https://circleci.com/gh/tinygo-org/drivers/tree/dev)
+[![PkgGoDev](https://pkg.go.dev/badge/tinygo.org/x/drivers)](https://pkg.go.dev/tinygo.org/x/drivers) [![CircleCI](https://circleci.com/gh/tinygo-org/drivers/tree/dev.svg?style=svg)](https://circleci.com/gh/tinygo-org/drivers/tree/dev)
 
 
-This package provides a collection of hardware drivers for devices that can be used together with [TinyGo](https://tinygo.org).
+This package provides a collection of hardware drivers for devices such as sensors and displays that can be used together with [TinyGo](https://tinygo.org).
 
 ## Installing
 
@@ -52,7 +52,7 @@ func main() {
 
 ## Currently supported devices
 
-The following 51 devices are supported.
+The following 56 devices are supported.
 
 | Device Name | Interface Type |
 |----------|-------------|
@@ -68,7 +68,9 @@ The following 51 devices are supported.
 | [BMI160 accelerometer/gyroscope](https://www.bosch-sensortec.com/media/boschsensortec/downloads/datasheets/bst-bmi160-ds000.pdf) | SPI |
 | [BMP180 barometer](https://cdn-shop.adafruit.com/datasheets/BST-BMP180-DS000-09.pdf) | I2C |
 | [BMP280 temperature/barometer](https://www.bosch-sensortec.com/media/boschsensortec/downloads/datasheets/bst-bmp280-ds001.pdf) | I2C |
+| [BMP388 pressure sensor](https://www.bosch-sensortec.com/media/boschsensortec/downloads/datasheets/bst-bmp388-ds001.pdf) | I2C |
 | [Buzzer](https://en.wikipedia.org/wiki/Buzzer#Piezoelectric) | GPIO |
+| [DHTXX thermometer and humidity sensor](https://cdn-shop.adafruit.com/datasheets/Digital+humidity+and+temperature+sensor+AM2302.pdf) | GPIO |
 | [DS1307 real time clock](https://datasheets.maximintegrated.com/en/ds/DS1307.pdf) | I2C |
 | [DS3231 real time clock](https://datasheets.maximintegrated.com/en/ds/DS3231.pdf) | I2C |
 | [ESP32 as WiFi Coprocessor with Arduino nina-fw](https://github.com/arduino/nina-fw) | SPI |
@@ -80,9 +82,11 @@ The following 51 devices are supported.
 | [ILI9341 TFT color display](https://cdn-shop.adafruit.com/datasheets/ILI9341.pdf) | SPI |
 | [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 |
+| [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 |
 | [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 |
@@ -106,6 +110,7 @@ The following 51 devices are supported.
 | [VL53L1X time-of-flight distance sensor](https://www.st.com/resource/en/datasheet/vl53l1x.pdf) | I2C |
 | [Waveshare 2.13" (B & C) e-paper display](https://www.waveshare.com/w/upload/d/d3/2.13inch-e-paper-b-Specification.pdf) | SPI |
 | [Waveshare 2.13" e-paper display](https://www.waveshare.com/w/upload/e/e6/2.13inch_e-Paper_Datasheet.pdf) | SPI |
+| [Waveshare 4.2" e-paper B/W display](https://www.waveshare.com/w/upload/6/6a/4.2inch-e-paper-specification.pdf) | SPI |
 | [WS2812 RGB LED](https://cdn-shop.adafruit.com/datasheets/WS2812.pdf) | GPIO |
 
 ## Contributing

adt7410/adt7410.go

@@ -1,8 +1,13 @@
+// Package adt7410 provides a driver for the adt7410 I2C Temperature Sensor.
+//
+// Datasheet: https://www.analog.com/media/en/technical-documentation/data-sheets/ADT7410.pdf
+//
 package adt7410 // import "tinygo.org/x/drivers/adt7410"
 
 import (
-	"machine"
 	"time"
+
+	"tinygo.org/x/drivers"
 )
 
 type Error uint8
@@ -21,40 +26,37 @@ func (e Error) Error() string {
 }
 
 type Device struct {
-	bus  *machine.I2C
-	buf  []byte
-	addr uint8
+	bus     drivers.I2C
+	buf     []byte
+	Address uint8
 }
 
-// New returns ADT7410 device for the provided I2C bus and address. The ADT7410
-// has a default address of 0x48 (1001000).  The last 2 bits of the address
+// New returns ADT7410 device for the provided I2C bus using default address.
+// of 0x48 (1001000).  To use multiple ADT7410 devices, the last 2 bits of the address
 // can be set using by connecting to the A1 and A0 pins to VDD or GND (for a
 // total of up to 4 devices on a I2C bus).  Also note that 10k pullups are
 // recommended for the SDA and SCL lines.
-func New(i2c *machine.I2C, addressBits uint8) *Device {
+func New(i2c drivers.I2C) *Device {
 	return &Device{
-		bus:  i2c,
-		buf:  make([]byte, 2),
-		addr: Address | (addressBits & 0x3),
+		bus:     i2c,
+		buf:     make([]byte, 2),
+		Address: Address,
 	}
 }
 
-func (dev *Device) Configure() (err error) {
-
-	// verify the chip ID
-	// TODO: According to datasheet, the check below should work; however
-	//       this does not seem to be working right, but is not exactly
-	//       necessary, so can revisit later to see if there is a bug
-	//id := dev.ReadByte(RegID) & 0xF8
-	//if id != 0xC8 {
-	//	err = ErrInvalidID
-	//}
-
+// Configure the ADT7410 device.
+func (d *Device) Configure() (err error) {
 	// reset the chip
-	dev.writeByte(RegReset, 0xFF)
+	d.writeByte(RegReset, 0xFF)
 	time.Sleep(10 * time.Millisecond)
 	return
+}
 
+// Connected returns whether sensor has been found.
+func (d *Device) Connected() bool {
+	data := []byte{0}
+	d.bus.ReadRegister(uint8(d.Address), RegID, data)
+	return data[0]&0xF8 == 0xC8
 }
 
 // ReadTemperature returns the temperature in celsius milli degrees (°C/1000)
@@ -62,13 +64,13 @@ func (d *Device) ReadTemperature() (temperature int32, err error) {
 	return (int32(d.readUint16(RegTempValueMSB)) * 1000) / 128, nil
 }
 
-// ReadTempC returns the value in the temperature value register, in Celcius
+// ReadTempC returns the value in the temperature value register, in Celsius.
 func (d *Device) ReadTempC() float32 {
 	t := d.readUint16(RegTempValueMSB)
 	return float32(int(t)) / 128.0
 }
 
-// ReadTempF returns the value in the temperature value register, in Fahrenheit
+// ReadTempF returns the value in the temperature value register, in Fahrenheit.
 func (d *Device) ReadTempF() float32 {
 	return d.ReadTempC()*1.8 + 32.0
 }
@@ -76,15 +78,15 @@ func (d *Device) ReadTempF() float32 {
 func (d *Device) writeByte(reg uint8, data byte) {
 	d.buf[0] = reg
 	d.buf[1] = data
-	d.bus.Tx(uint16(d.addr), d.buf, nil)
+	d.bus.Tx(uint16(d.Address), d.buf, nil)
 }
 
 func (d *Device) readByte(reg uint8) byte {
-	d.bus.ReadRegister(d.addr, reg, d.buf)
+	d.bus.ReadRegister(d.Address, reg, d.buf)
 	return d.buf[0]
 }
 
 func (d *Device) readUint16(reg uint8) uint16 {
-	d.bus.ReadRegister(d.addr, reg, d.buf)
+	d.bus.ReadRegister(d.Address, reg, d.buf)
 	return uint16(d.buf[0])<<8 | uint16(d.buf[1])
 }

adt7410/adt7410_test.go

@@ -0,0 +1,49 @@
+package adt7410
+
+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, uint8(Address))
+}
+
+func TestWhoAmI(t *testing.T) {
+	c := qt.New(t)
+	bus := tester.NewI2CBus(c)
+	fake := tester.NewI2CDevice(c, Address)
+	copy(fake.Registers[:], defaultRegisters())
+	bus.AddDevice(fake)
+
+	dev := New(bus)
+	c.Assert(dev.Connected(), qt.Equals, true)
+
+	fake.Registers[RegID] = 0x99
+	c.Assert(dev.Connected(), qt.Equals, false)
+}
+
+// defaultRegisters returns the default values for all of the device's registers.
+// see table 22 on page 27 of the datasheet.
+func defaultRegisters() []uint8 {
+	return []uint8{
+		RegTempValueMSB: 0,
+		RegTempValueLSB: 0,
+		RegStatus:       0,
+		RegConfig:       0,
+		RegTHIGHMsbReg:  0x20,
+		RegTHIGHLsbReg:  0,
+		RegTLOWMsbReg:   0x05,
+		RegTLOWLsbReg:   0,
+		RegTCRITMsbReg:  0x49,
+		RegTCRITLsbReg:  0x80,
+		RegTHYSTReg:     0x05,
+		RegID:           0xC8,
+		RegReset:        0,
+	}
+}

adt7410/registers.go

@@ -1,8 +1,33 @@
 package adt7410
 
+// 0x00 Temperature value most significant byte 0x00
+// 0x01 Temperature value least significant byte 0x00
+// 0x02 Status 0x00
+// 0x03 Configuration 0x00
+// 0x04 THIGH setpoint most significant byte 0x20 (64°C)
+// 0x05 THIGH setpoint least significant byte 0x00 (64°C)
+// 0x06 TLOW setpoint most significant byte 0x05 (10°C)
+// 0x07 TLOW setpoint least significant byte 0x00 (10°C)
+// 0x08 TCRIT setpoint most significant byte 0x49 (147°C)
+// 0x09 TCRIT setpoint least significant byte 0x80 (147°C)
+// 0x0A THYST setpoint 0x05 (5°C)
+// 0x0B ID 0xCX
+// 0x0C Reserved 0xXX
+// 0x0D Reserved 0xXX
+// 0x2E Reserved 0xXX
+// 0x2F Software reset 0xXX
+
 const (
-	// Default I2C address
+	// Address is default I2C address.
 	Address = 0x48
+	// Address1 is for first device, aka the default.
+	Address1 = Address
+	// Address2 is for second device.
+	Address2 = 0x49
+	// Address3 is for third device.
+	Address3 = 0x4A
+	// Address4 is for fourth device.
+	Address4 = 0x4B
 
 	// Temperature Value MSB Register
 	RegTempValueMSB = 0x0
@@ -16,7 +41,28 @@ const (
 	// Config Register
 	RegConfig = 0x3
 
-	// ID Register
+	// THIGH setpoint most significant byte 0x20 (64°C)
+	RegTHIGHMsbReg = 0x4
+
+	// THIGH setpoint least significant byte 0x00 (64°C)
+	RegTHIGHLsbReg = 0x5
+
+	// TLOW setpoint most significant byte 0x05 (10°C)
+	RegTLOWMsbReg = 0x6
+
+	// TLOW setpoint least significant byte 0x00 (10°C)
+	RegTLOWLsbReg = 0x7
+
+	// TCRIT setpoint most significant byte 0x49 (147°C)
+	RegTCRITMsbReg = 0x8
+
+	// TCRIT setpoint least significant byte 0x80 (147°C)
+	RegTCRITLsbReg = 0x9
+
+	// THYST setpoint 0x05 (5°C)
+	RegTHYSTReg = 0xA
+
+	// ID Register (0xCx)
 	RegID = 0x0B
 
 	// Software Reset Register

adxl345/adxl345.go

@@ -6,9 +6,7 @@
 //
 package adxl345 // import "tinygo.org/x/drivers/adxl345"
 
-import (
-	"machine"
-)
+import "tinygo.org/x/drivers"
 
 type Range uint8
 type Rate uint8
@@ -40,7 +38,7 @@ type bwRate struct {
 
 // Device wraps an I2C connection to a ADXL345 device.
 type Device struct {
-	bus        machine.I2C
+	bus        drivers.I2C
 	Address    uint16
 	powerCtl   powerCtl
 	dataFormat dataFormat
@@ -52,7 +50,7 @@ type Device struct {
 //
 // This function only creates the Device object, it does not init the device.
 // To do that you must call the Configure() method on the Device before using it.
-func New(bus machine.I2C) Device {
+func New(bus drivers.I2C) Device {
 	return Device{
 		bus: bus,
 		powerCtl: powerCtl{

amg88xx/amg88xx.go

@@ -5,13 +5,14 @@
 package amg88xx // import "tinygo.org/x/drivers/amg88xx"
 
 import (
-	"machine"
 	"time"
+
+	"tinygo.org/x/drivers"
 )
 
 // Device wraps an I2C connection to a AMG88xx device.
 type Device struct {
-	bus             machine.I2C
+	bus             drivers.I2C
 	Address         uint16
 	data            []uint8
 	interruptMode   InterruptMode
@@ -27,7 +28,7 @@ type Config struct {
 // configured.
 //
 // This function only creates the Device object, it does not touch the device.
-func New(bus machine.I2C) Device {
+func New(bus drivers.I2C) Device {
 	return Device{
 		bus:     bus,
 		Address: AddressHigh,

apa102/apa102.go

@@ -6,6 +6,8 @@ package apa102 // import "tinygo.org/x/drivers/apa102"
 import (
 	"image/color"
 	"machine"
+
+	"tinygo.org/x/drivers"
 )
 
 const (
@@ -23,20 +25,12 @@ var startFrame = []byte{0x00, 0x00, 0x00, 0x00}
 
 // Device wraps APA102 SPI LEDs.
 type Device struct {
-	bus   SPI
+	bus   drivers.SPI
 	Order int
 }
 
-// The SPI interface specifies the minimum functionality that a bus
-// implementation needs to provide for use by the APA102 driver.  Hardware
-// SPI from the TinyGo "machine" package implements this already.
-type SPI interface {
-	Tx(w, r []byte) error
-	Transfer(b byte) (byte, error)
-}
-
 // New returns a new APA102 driver. Pass in a fully configured SPI bus.
-func New(b SPI) Device {
+func New(b drivers.SPI) Device {
 	return Device{bus: b, Order: BGR}
 }
 

at24cx/at24cx.go

@@ -6,13 +6,14 @@ package at24cx // import "tinygo.org/x/drivers/at24cx"
 
 import (
 	"errors"
-	"machine"
 	"time"
+
+	"tinygo.org/x/drivers"
 )
 
 // Device wraps an I2C connection to a DS3231 device.
 type Device struct {
-	bus               machine.I2C
+	bus               drivers.I2C
 	Address           uint16
 	pageSize          uint16
 	currentRAMAddress uint16
@@ -30,7 +31,7 @@ type Config struct {
 // configured.
 //
 // This function only creates the Device object, it does not touch the device.
-func New(bus machine.I2C) Device {
+func New(bus drivers.I2C) Device {
 	return Device{
 		bus:     bus,
 		Address: Address,

bh1750/bh1750.go

@@ -8,7 +8,7 @@ package bh1750 // import "tinygo.org/x/drivers/bh1750"
 import (
 	"time"
 
-	"machine"
+	"tinygo.org/x/drivers"
 )
 
 // SamplingMode is the sampling's resolution of the measurement
@@ -16,7 +16,7 @@ type SamplingMode byte
 
 // Device wraps an I2C connection to a bh1750 device.
 type Device struct {
-	bus     machine.I2C
+	bus     drivers.I2C
 	Address uint16
 	mode    SamplingMode
 }
@@ -25,7 +25,7 @@ type Device struct {
 // configured.
 //
 // This function only creates the Device object, it does not touch the device.
-func New(bus machine.I2C) Device {
+func New(bus drivers.I2C) Device {
 	return Device{
 		bus:     bus,
 		Address: Address,

blinkm/blinkm.go

@@ -1,15 +1,14 @@
 // Package blinkm implements a driver for the BlinkM I2C RGB LED.
 //
 // Datasheet: http://thingm.com/fileadmin/thingm/downloads/BlinkM_datasheet.pdf
+//
 package blinkm // import "tinygo.org/x/drivers/blinkm"
 
-import (
-	"machine"
-)
+import "tinygo.org/x/drivers"
 
 // Device wraps an I2C connection to a BlinkM device.
 type Device struct {
-	bus     machine.I2C
+	bus     drivers.I2C
 	Address uint16
 }
 
@@ -17,7 +16,7 @@ type Device struct {
 // configured.
 //
 // This function only creates the Device object, it does not touch the device.
-func New(bus machine.I2C) Device {
+func New(bus drivers.I2C) Device {
 	return Device{bus, Address}
 }
 

bme280/bme280.go

@@ -7,8 +7,9 @@
 package bme280
 
 import (
-	"machine"
 	"math"
+
+	"tinygo.org/x/drivers"
 )
 
 // calibrationCoefficients reads at startup and stores the calibration coefficients
@@ -35,7 +36,7 @@ type calibrationCoefficients struct {
 
 // Device wraps an I2C connection to a BME280 device.
 type Device struct {
-	bus                     machine.I2C
+	bus                     drivers.I2C
 	Address                 uint16
 	calibrationCoefficients calibrationCoefficients
 }
@@ -44,7 +45,7 @@ type Device struct {
 // configured.
 //
 // This function only creates the Device object, it does not touch the device.
-func New(bus machine.I2C) Device {
+func New(bus drivers.I2C) Device {
 	return Device{
 		bus:     bus,
 		Address: Address,

bmi160/bmi160.go

@@ -1,8 +1,11 @@
 package bmi160
 
-import "machine"
+import (
+	"machine"
+	"time"
 
-import "time"
+	"tinygo.org/x/drivers"
+)
 
 // DeviceSPI is the SPI interface to a BMI160 accelerometer/gyroscope. There is
 // also an I2C interface, but it is not yet supported.
@@ -11,13 +14,13 @@ type DeviceSPI struct {
 	CSB machine.Pin
 
 	// SPI bus (requires chip select to be usable).
-	Bus machine.SPI
+	Bus drivers.SPI
 }
 
 // NewSPI returns a new device driver. The pin and SPI interface are not
 // touched, provide a fully configured SPI object and call Configure to start
 // using this device.
-func NewSPI(csb machine.Pin, spi machine.SPI) *DeviceSPI {
+func NewSPI(csb machine.Pin, spi drivers.SPI) *DeviceSPI {
 	return &DeviceSPI{
 		CSB: csb, // chip select
 		Bus: spi,

bmp180/bmp180.go

@@ -9,7 +9,7 @@ package bmp180 // import "tinygo.org/x/drivers/bmp180"
 import (
 	"time"
 
-	"machine"
+	"tinygo.org/x/drivers"
 )
 
 // OversamplingMode is the oversampling ratio of the pressure measurement.
@@ -32,7 +32,7 @@ type calibrationCoefficients struct {
 
 // Device wraps an I2C connection to a BMP180 device.
 type Device struct {
-	bus                     machine.I2C
+	bus                     drivers.I2C
 	Address                 uint16
 	mode                    OversamplingMode
 	calibrationCoefficients calibrationCoefficients
@@ -43,7 +43,7 @@ type Device struct {
 //
 // This function only creates the Device object, it does not initialize the device.
 // You must call Configure() first in order to use the device itself.
-func New(bus machine.I2C) Device {
+func New(bus drivers.I2C) Device {
 	return Device{
 		bus:     bus,
 		Address: Address,

bmp280/bmp280.go

@@ -1,8 +1,9 @@
 package bmp280
 
 import (
-	"machine"
 	"time"
+
+	"tinygo.org/x/drivers"
 )
 
 // OversamplingMode is the oversampling ratio of the temperature or pressure measurement.
@@ -19,7 +20,7 @@ type Filter uint
 
 // Device wraps an I2C connection to a BMP280 device.
 type Device struct {
-	bus         machine.I2C
+	bus         drivers.I2C
 	Address     uint16
 	cali        calibrationCoefficients
 	Temperature Oversampling
@@ -52,7 +53,7 @@ type calibrationCoefficients struct {
 //
 // This function only creates the Device object, it does not initialize the device.
 // You must call Configure() first in order to use the device itself.
-func New(bus machine.I2C) Device {
+func New(bus drivers.I2C) Device {
 	return Device{
 		bus:     bus,
 		Address: Address,

bmp388/bmp388.go

@@ -0,0 +1,249 @@
+package bmp388
+
+import (
+	"errors"
+
+	"tinygo.org/x/drivers"
+)
+
+var (
+	errConfigWrite  = errors.New("bmp388: failed to configure sensor, check connection")
+	errConfig       = errors.New("bmp388: there is a problem with the configuration, try reducing ODR")
+	errCaliRead     = errors.New("bmp388: failed to read calibration coefficient register")
+	errSoftReset    = errors.New("bmp388: failed to perform a soft reset")
+	errNotConnected = errors.New("bmp388: not connected")
+)
+
+type Oversampling byte
+type Mode byte
+type OutputDataRate byte
+type FilterCoefficient byte
+
+// Config contains settings for filtering, sampling, and modes of operation
+type Config struct {
+	Pressure    Oversampling
+	Temperature Oversampling
+	Mode        Mode
+	ODR         OutputDataRate
+	IIR         FilterCoefficient
+}
+
+// Device wraps the I2C connection and configuration values for the BMP388
+type Device struct {
+	bus     drivers.I2C
+	Address uint8
+	cali    calibrationCoefficients
+	Config  Config
+}
+
+type calibrationCoefficients struct {
+	// Temperature compensation
+	t1 uint16
+	t2 uint16
+	t3 int8
+
+	// Pressure compensation
+	p1  int16
+	p2  int16
+	p3  int8
+	p4  int8
+	p5  uint16
+	p6  uint16
+	p7  int8
+	p8  int8
+	p9  int16
+	p10 int8
+	p11 int8
+}
+
+// New returns a bmp388 struct with the default I2C address. Configure must also be called after instanting
+func New(bus drivers.I2C) Device {
+	return Device{
+		bus:     bus,
+		Address: Address,
+	}
+}
+
+// Configure can enable settings on the BMP388 and reads the calibration coefficients
+func (d *Device) Configure(config Config) (err error) {
+	d.Config = config
+
+	if d.Config == (Config{}) {
+		d.Config.Mode = Normal
+	}
+
+	// Turning on the pressure and temperature sensors and setting the measurement mode
+	err = d.writeRegister(RegPwrCtrl, PwrPress|PwrTemp|byte(d.Config.Mode))
+
+	// Configure the oversampling, output data rate, and iir filter coefficient settings
+	err = d.writeRegister(RegOSR, byte(d.Config.Pressure|d.Config.Temperature<<3))
+	err = d.writeRegister(RegODR, byte(d.Config.ODR))
+	err = d.writeRegister(RegIIR, byte(d.Config.IIR<<1))
+
+	if err != nil {
+		return errConfigWrite
+	}
+
+	// Check if there is a problem with the given configuration
+	if d.configurationError() {
+		return errConfig
+	}
+
+	// Reading the builtin calibration coefficients and parsing them per the datasheet. The compensation formula given
+	// in the datasheet is implemented in floating point
+	buffer, err := d.readRegister(RegCali, 21)
+	if err != nil {
+		return errCaliRead
+	}
+
+	d.cali.t1 = uint16(buffer[1])<<8 | uint16(buffer[0])
+	d.cali.t2 = uint16(buffer[3])<<8 | uint16(buffer[2])
+	d.cali.t3 = int8(buffer[4])
+
+	d.cali.p1 = int16(buffer[6])<<8 | int16(buffer[5])
+	d.cali.p2 = int16(buffer[8])<<8 | int16(buffer[7])
+	d.cali.p3 = int8(buffer[9])
+	d.cali.p4 = int8(buffer[10])
+	d.cali.p5 = uint16(buffer[12])<<8 | uint16(buffer[11])
+	d.cali.p6 = uint16(buffer[14])<<8 | uint16(buffer[13])
+	d.cali.p7 = int8(buffer[15])
+	d.cali.p8 = int8(buffer[16])
+	d.cali.p9 = int16(buffer[18])<<8 | int16(buffer[17])
+	d.cali.p10 = int8(buffer[19])
+	d.cali.p11 = int8(buffer[20])
+
+	return nil
+}
+
+// Read the temperature registers and compute a compensation value for the temperature and pressure compensation
+// calculations. This is not the temperature itself.
+func (d *Device) tlinCompensate() (int64, error) {
+	rawTemp, err := d.readSensorData(RegTemp)
+	if err != nil {
+		return 0, err
+	}
+
+	// pulled from C driver: https://github.com/BoschSensortec/BMP3-Sensor-API/blob/master/bmp3.c
+	partialData1 := rawTemp - (256 * int64(d.cali.t1))
+	partialData2 := int64(d.cali.t2) * partialData1
+	partialData3 := (partialData1 * partialData1)
+	partialData4 := partialData3 * int64(d.cali.t3)
+	partialData5 := (partialData2 * 262144) + partialData4
+	return partialData5 / 4294967296, nil
+
+}
+
+// ReadTemperature returns the temperature in centicelsius, i.e 2426 / 100 = 24.26 C
+func (d *Device) ReadTemperature() (int32, error) {
+
+	tlin, err := d.tlinCompensate()
+	if err != nil {
+		return 0, err
+	}
+
+	temp := (tlin * 25) / 16384
+	return int32(temp), nil
+}
+
+// ReadPressure returns the pressure in centipascals, i.e 10132520 / 100 = 101325.20 Pa
+func (d *Device) ReadPressure() (int32, error) {
+
+	tlin, err := d.tlinCompensate()
+	if err != nil {
+		return 0, err
+	}
+	rawPress, err := d.readSensorData(RegPress)
+	if err != nil {
+		return 0, err
+	}
+
+	// code pulled from bmp388 C driver: https://github.com/BoschSensortec/BMP3-Sensor-API/blob/master/bmp3.c
+	partialData1 := tlin * tlin
+	partialData2 := partialData1 / 64
+	partialData3 := (partialData2 * tlin) / 256
+	partialData4 := (int64(d.cali.p8) * partialData3) / 32
+	partialData5 := (int64(d.cali.p7) * partialData1) * 16
+	partialData6 := (int64(d.cali.p6) * tlin) * 4194304
+	offset := (int64(d.cali.p5) * 140737488355328) + partialData4 + partialData5 + partialData6
+	partialData2 = (int64(d.cali.p4) * partialData3) / 32
+	partialData4 = (int64(d.cali.p3) * partialData1) * 4
+	partialData5 = (int64(d.cali.p2) - 16384) * tlin * 2097152
+	sensitivity := ((int64(d.cali.p1) - 16384) * 70368744177664) + partialData2 + partialData4 + partialData5
+	partialData1 = (sensitivity / 16777216) * rawPress
+	partialData2 = int64(d.cali.p10) * tlin
+	partialData3 = partialData2 + (65536 * int64(d.cali.p9))
+	partialData4 = (partialData3 * rawPress) / 8192
+
+	// dividing by 10 followed by multiplying by 10
+	// To avoid overflow caused by (pressure * partial_data4)
+	partialData5 = (rawPress * (partialData4 / 10)) / 512
+	partialData5 = partialData5 * 10
+	partialData6 = (int64)(uint64(rawPress) * uint64(rawPress))
+	partialData2 = (int64(d.cali.p11) * partialData6) / 65536
+	partialData3 = (partialData2 * rawPress) / 128
+	partialData4 = (offset / 4) + partialData1 + partialData5 + partialData3
+	compPress := ((uint64(partialData4) * 25) / uint64(1099511627776))
+	return int32(compPress), nil
+}
+
+// SoftReset commands the BMP388 to reset of all user configuration settings
+func (d *Device) SoftReset() error {
+	err := d.writeRegister(RegCmd, SoftReset)
+	if err != nil {
+		return errSoftReset
+	}
+	return nil
+}
+
+// Connected tries to reach the bmp388 and check its chip id register. Returns true if it was able to successfully
+// communicate over i2c and returns the correct value
+func (d *Device) Connected() bool {
+	data, err := d.readRegister(RegChipId, 1)
+	return err == nil && data[0] == ChipId // returns true if i2c comm was good and response equals 0x50
+}
+
+// SetMode changes the run mode of the sensor, NORMAL is the one to use for most cases. Use FORCED if you plan to take
+// measurements infrequently and want to conserve power. SLEEP will of course put the sensor to sleep
+func (d *Device) SetMode(mode Mode) error {
+	d.Config.Mode = mode
+	return d.writeRegister(RegPwrCtrl, PwrPress|PwrTemp|byte(d.Config.Mode))
+}
+
+func (d *Device) readSensorData(register byte) (data int64, err error) {
+
+	if !d.Connected() {
+		return 0, errNotConnected
+	}
+
+	// put the sensor back into forced mode to get a reading, the sensor goes back to sleep after taking one read in
+	// forced mode
+	if d.Config.Mode != Normal {
+		err = d.SetMode(Forced)
+		if err != nil {
+			return
+		}
+	}
+
+	bytes, err := d.readRegister(register, 3)
+	if err != nil {
+		return
+	}
+	data = int64(bytes[2])<<16 | int64(bytes[1])<<8 | int64(bytes[0])
+	return
+}
+
+// configurationError checks the register error for the configuration error bit. The bit is cleared on read by the bmp.
+func (d *Device) configurationError() bool {
+	data, err := d.readRegister(RegErr, 1)
+	return err == nil && (data[0]&0x04) != 0
+}
+
+func (d *Device) readRegister(register byte, len int) (data []byte, err error) {
+	data = make([]byte, len)
+	err = d.bus.ReadRegister(d.Address, register, data)
+	return
+}
+
+func (d *Device) writeRegister(register byte, data byte) error {
+	return d.bus.WriteRegister(d.Address, register, []byte{data})
+}

bmp388/registers.go

@@ -0,0 +1,84 @@
+// Package bmp388 provides a driver for Bosch's BMP388 digital temperature & pressure sensor.
+// The datasheet can be found here: https://www.bosch-sensortec.com/media/boschsensortec/downloads/datasheets/bst-bmp388-ds001.pdf
+package bmp388
+
+const Address byte = 0x77 // default I2C address
+
+const (
+	RegChipId  byte = 0x00 // useful for checking the connection
+	RegCali    byte = 0x31 // pressure & temperature compensation calibration coefficients
+	RegPress   byte = 0x04 // start of pressure data registers
+	RegTemp    byte = 0x07 // start of temperature data registers
+	RegPwrCtrl byte = 0x1B // measurement mode & pressure/temperature sensor power register
+	RegOSR     byte = 0x1C // oversampling settings register
+	RegODR     byte = 0x1D //
+	RegCmd     byte = 0x7E // miscellaneous command register
+	RegStat    byte = 0x03 // sensor status register
+	RegErr     byte = 0x02 // error status register
+	RegIIR     byte = 0x1F
+)
+
+const (
+	ChipId    byte = 0x50 // correct response if reading from chip id register
+	PwrPress  byte = 0x01 // power on pressure sensor
+	PwrTemp   byte = 0x02 // power on temperature sensor
+	SoftReset byte = 0xB6 // command to reset all user configuration
+	DRDYPress byte = 0x20 // for checking if pressure data is ready
+	DRDYTemp  byte = 0x40 // for checking if pressure data is ready
+)
+
+// The difference between forced and normal mode is the bmp388 goes to sleep after taking a measurement in forced mode.
+// Set it to forced if you intend to take measurements sporadically and want to save power. The driver will handle
+// waking the sensor up when the sensor is in forced mode.
+const (
+	Normal Mode = 0x30
+	Forced Mode = 0x16
+	Sleep  Mode = 0x00
+)
+
+// Increasing sampling rate increases precision but also the wait time for measurements. The datasheet has a table of
+// suggested values for oversampling, output data rates, and iir filter coefficients by use case.
+const (
+	Sampling1X Oversampling = iota
+	Sampling2X
+	Sampling4X
+	Sampling8X
+	Sampling16X
+	Sampling32X
+)
+
+// Output data rates in Hz. If increasing the sampling rates you need to decrease the output data rates, else the bmp388
+// will freeze and Configure() will return a configuration error message. In that case keep decreasing the data rate
+// until the bmp is happy
+const (
+	Odr200 OutputDataRate = iota
+	Odr100
+	Odr50
+	Odr25
+	Odr12p5
+	Odr6p25
+	Odr3p1
+	Odr1p5
+	Odr0p78
+	Odr0p39
+	Odr0p2
+	Odr0p1
+	Odr0p05
+	Odr0p02
+	Odr0p01
+	Odr0p006
+	Odr0p003
+	Odr0p0015
+)
+
+// IIR filter coefficients, higher values means steadier measurements but slower reaction times
+const (
+	Coeff0 FilterCoefficient = iota
+	Coeff1
+	Coeff3
+	Coeff7
+	Coeff15
+	Coeff31
+	Coeff63
+	Coeff127
+)

dht/constants.go

@@ -0,0 +1,116 @@
+// Package dht provides a driver for DHTXX family temperature and humidity sensors.
+//
+// [1] Datasheet DHT11: https://www.mouser.com/datasheet/2/758/DHT11-Technical-Data-Sheet-Translated-Version-1143054.pdf
+// [2] Datasheet DHT22: https://cdn-shop.adafruit.com/datasheets/Digital+humidity+and+temperature+sensor+AM2302.pdf
+// Adafruit C++ driver: https://github.com/adafruit/DHT-sensor-library
+
+package dht // import "tinygo.org/x/drivers/dht"
+
+import (
+	"encoding/binary"
+	"machine"
+	"time"
+)
+
+// enum type for device type
+type DeviceType uint8
+
+// DeviceType specific parsing of information received from the sensor
+func (d DeviceType) extractData(buf []byte) (temp int16, hum uint16) {
+	if d == DHT11 {
+		temp = int16(buf[2])
+		if buf[3]&0x80 > 0 {
+			temp = -1 - temp
+		}
+		temp *= 10
+		temp += int16(buf[3] & 0x0f)
+		hum = 10*uint16(buf[0]) + uint16(buf[1])
+	} else {
+		hum = binary.LittleEndian.Uint16(buf[0:2])
+		temp = int16(buf[3])<<8 + int16(buf[2]&0x7f)
+		if buf[2]&0x80 > 0 {
+			temp = -temp
+		}
+	}
+	return
+}
+
+// Celsius and Fahrenheit temperature scales
+type TemperatureScale uint8
+
+func (t TemperatureScale) convertToFloat(temp int16) float32 {
+	if t == C {
+		return float32(temp) / 10
+	} else {
+		// Fahrenheit
+		return float32(temp)*(9.0/50.) + 32.
+	}
+}
+
+// All functions return ErrorCode instance as error. This class can be used for more efficient error processing
+type ErrorCode uint8
+
+const (
+	startTimeout = time.Millisecond * 200
+	startingLow  = time.Millisecond * 20
+
+	DHT11 DeviceType = iota
+	DHT22
+
+	C TemperatureScale = iota
+	F
+
+	ChecksumError ErrorCode = iota
+	NoSignalError
+	NoDataError
+	UpdateError
+	UninitializedDataError
+)
+
+// error interface implementation for ErrorCode
+func (e ErrorCode) Error() string {
+	switch e {
+	case ChecksumError:
+		// DHT returns ChecksumError if all the data from the sensor was received, but the checksum does not match.
+		return "checksum mismatch"
+	case NoSignalError:
+		// DHT returns NoSignalError if there was no reply from the sensor. Check sensor connection or the correct pin
+		// sis chosen,
+		return "no signal"
+	case NoDataError:
+		// DHT returns NoDataError if the connection was successfully initialized, but not all 40 bits from
+		// the sensor is received
+		return "no data"
+	case UpdateError:
+		// DHT returns UpdateError if ReadMeasurements function is called before time specified in UpdatePolicy or
+		// less than 2 seconds after past measurement
+		return "cannot update now"
+	case UninitializedDataError:
+		// DHT returns UninitializedDataError if user attempts to access data before first measurement
+		return "no measurements done"
+	}
+	// should never be reached
+	return "unknown error"
+}
+
+// Update policy of the DHT device. UpdateTime cannot be shorter than 2 seconds. According to dht specification sensor
+// will return undefined data if update requested less than 2 seconds before last usage
+type UpdatePolicy struct {
+	UpdateTime          time.Duration
+	UpdateAutomatically bool
+}
+
+var (
+	// timeout counter equal to number of ticks per 1 millisecond
+	timeout counter
+)
+
+func init() {
+	timeout = cyclesPerMillisecond()
+}
+
+func cyclesPerMillisecond() counter {
+	freq := machine.CPUFrequency()
+	freq /= 1000
+	return counter(freq)
+}

dht/highfreq.go

@@ -0,0 +1,6 @@
+// +build mimxrt1062  stm32f405  atsamd51  stm32f103xx  k210  stm32f407
+
+package dht // import "tinygo.org/x/drivers/dht"
+
+// This file provides a definition of the counter for boards with frequency higher than 2^8 ticks per millisecond (>64MHz)
+type counter uint32

dht/lowfreq.go

@@ -0,0 +1,6 @@
+// +build arduino atmega1284p nrf52840 digispark nrf52 arduino_nano nrf51 atsamd21 fe310 arduino_nano33 circuitplay_express arduino_mega2560
+
+package dht // import "tinygo.org/x/drivers/dht"
+
+// This file provides a definition of the counter for boards with frequency lower than 2^8 ticks per millisecond (<64MHz)
+type counter uint16

dht/thermometer.go

@@ -0,0 +1,218 @@
+// Package dht provides a driver for DHTXX family temperature and humidity sensors.
+//
+// [1] Datasheet DHT11: https://www.mouser.com/datasheet/2/758/DHT11-Technical-Data-Sheet-Translated-Version-1143054.pdf
+// [2] Datasheet DHT22: https://cdn-shop.adafruit.com/datasheets/Digital+humidity+and+temperature+sensor+AM2302.pdf
+// Adafruit C++ driver: https://github.com/adafruit/DHT-sensor-library
+
+package dht // import "tinygo.org/x/drivers/dht"
+
+import (
+	"machine"
+	"time"
+)
+
+// DummyDevice provides a basic interface for DHT devices.
+type DummyDevice interface {
+	ReadMeasurements() error
+	Measurements() (temperature int16, humidity uint16, err error)
+	Temperature() (int16, error)
+	TemperatureFloat(scale TemperatureScale) (float32, error)
+	Humidity() (uint16, error)
+	HumidityFloat() (float32, error)
+}
+
+// Basic implementation of the DummyDevice
+// This implementation takes measurements from sensor only with ReadMeasurements function
+// and does not provide a protection from too frequent calls for measurements.
+// Since taking measurements from the sensor is time consuming procedure and blocks interrupts,
+// user can avoid any hidden calls to the sensor.
+type device struct {
+	pin machine.Pin
+
+	measurements DeviceType
+	initialized  bool
+
+	temperature int16
+	humidity    uint16
+}
+
+// ReadMeasurements reads data from the sensor.
+// According to documentation pin should be always, but the t *device restores pin to the state before call.
+func (t *device) ReadMeasurements() error {
+	// initial waiting
+	state := powerUp(t.pin)
+	defer t.pin.Set(state)
+	err := t.read()
+	if err == nil {
+		t.initialized = true
+	}
+	return err
+}
+
+// Getter for temperature. Temperature method returns temperature as it is sent by device.
+// The temperature is measured temperature in Celsius multiplied by 10.
+// If no successful measurements for this device was performed, returns UninitializedDataError.
+func (t *device) Temperature() (int16, error) {
+	if !t.initialized {
+		return 0, UninitializedDataError
+	}
+	return t.temperature, nil
+}
+
+// Getter for temperature. TemperatureFloat returns temperature in a given scale.
+// If no successful measurements for this device was performed, returns UninitializedDataError.
+func (t *device) TemperatureFloat(scale TemperatureScale) (float32, error) {
+	if !t.initialized {
+		return 0, UninitializedDataError
+	}
+	return scale.convertToFloat(t.temperature), nil
+}
+
+// Getter for humidity. Humidity returns humidity as it is sent by device.
+// The humidity is measured in percentages multiplied by 10.
+// If no successful measurements for this device was performed, returns UninitializedDataError.
+func (t *device) Humidity() (uint16, error) {
+	if !t.initialized {
+		return 0, UninitializedDataError
+	}
+	return t.humidity, nil
+}
+
+// Getter for humidity. HumidityFloat returns humidity in percentages.
+// If no successful measurements for this device was performed, returns UninitializedDataError.
+func (t *device) HumidityFloat() (float32, error) {
+	if !t.initialized {
+		return 0, UninitializedDataError
+	}
+	return float32(t.humidity) / 10., nil
+}
+
+// Perform initialization of the communication protocol.
+// Device lowers the voltage on pin for startingLow=20ms and starts listening for response
+// Section 5.2 in [1]
+func initiateCommunication(p machine.Pin) {
+	// Send low signal to the device
+	p.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	p.Low()
+	time.Sleep(startingLow)
+	// Set pin to high and wait for reply
+	p.High()
+	p.Configure(machine.PinConfig{Mode: machine.PinInput})
+}
+
+// Measurements returns both measurements: temperature and humidity as they sent by the device.
+// If no successful measurements for this device was performed, returns UninitializedDataError.
+func (t *device) Measurements() (temperature int16, humidity uint16, err error) {
+	if !t.initialized {
+		return 0, 0, UninitializedDataError
+	}
+	temperature = t.temperature
+	humidity = t.humidity
+	err = nil
+	return
+}
+
+// Main routine that performs communication with the sensor
+func (t *device) read() error {
+	// initialize loop variables
+
+	// buffer for the data sent by the sensor. Sensor sends 40 bits = 5 bytes
+	bufferData := [5]byte{}
+	buf := bufferData[:]
+
+	// We perform measurements of the signal from the sensor by counting low and high cycles.
+	// The bit is determined by the relative length of the high signal to low signal.
+	// For 1, high signal will be longer than low, for 0---low is longer.
+	// See section 5.3 [1]
+	signalsData := [80]counter{}
+	signals := signalsData[:]
+
+	// Start communication protocol with sensor
+	initiateCommunication(t.pin)
+	// Wait for sensor's response and abort if sensor does not reply
+	err := waitForDataTransmission(t.pin)
+	if err != nil {
+		return err
+	}
+	// count low and high cycles for sensor's reply
+	receiveSignals(t.pin, signals)
+
+	// process received signals and store the result in the buffer. Abort if data transmission was interrupted and not
+	// all 40 bits were received
+	err = t.extractData(signals[:], buf)
+	if err != nil {
+		return err
+	}
+	// Compute checksum and compare it to the one in data. Abort if checksum is incorrect
+	if !isValid(buf[:]) {
+		return ChecksumError
+	}
+
+	// Extract temperature and humidity data from buffer
+	t.temperature, t.humidity = t.measurements.extractData(buf)
+	return nil
+}
+
+// receiveSignals counts number of low and high cycles. The execution is time critical, so the function disables
+// interrupts
+func receiveSignals(pin machine.Pin, result []counter) {
+	i := uint8(0)
+	machine.UART1.Interrupt.Disable()
+	defer machine.UART1.Interrupt.Enable()
+	for ; i < 40; i++ {
+		result[i*2] = expectChange(pin, false)
+		result[i*2+1] = expectChange(pin, true)
+	}
+}
+
+// extractData process signal counters and transforms them into bits.
+// if any of the bits were not received (timed-out), returns NoDataError
+func (t *device) extractData(signals []counter, buf []uint8) error {
+	for i := uint8(0); i < 40; i++ {
+		lowCycle := signals[i*2]
+		highCycle := signals[i*2+1]
+		if lowCycle == timeout || highCycle == timeout {
+			return NoDataError
+		}
+		byteN := i >> 3
+		buf[byteN] <<= 1
+		if highCycle > lowCycle {
+			buf[byteN] |= 1
+		}
+	}
+	return nil
+}
+
+// waitForDataTransmission waits for reply from the sensor.
+// If no reply received, returns NoSignalError.
+// For more details, see section 5.2 in [1]
+func waitForDataTransmission(p machine.Pin) error {
+	// wait for thermometer to pull down
+	if expectChange(p, true) == timeout {
+		return NoSignalError
+	}
+	//wait for thermometer to pull up
+	if expectChange(p, false) == timeout {
+		return NoSignalError
+	}
+	// wait for thermometer to pull down and start sending the data
+	if expectChange(p, true) == timeout {
+		return NoSignalError
+	}
+	return nil
+}
+
+// Constructor function for a DummyDevice implementation.
+// This device provides full control to the user.
+// It does not do any hidden measurements calls and does not check
+// for 2 seconds delay between measurements.
+func NewDummyDevice(pin machine.Pin, deviceType DeviceType) DummyDevice {
+	pin.High()
+	return &device{
+		pin:          pin,
+		measurements: deviceType,
+		initialized:  false,
+		temperature:  0,
+		humidity:     0,
+	}
+}

dht/timesafethermometer.go

@@ -0,0 +1,154 @@
+// Package dht provides a driver for DHTXX family temperature and humidity sensors.
+//
+// [1] Datasheet DHT11: https://www.mouser.com/datasheet/2/758/DHT11-Technical-Data-Sheet-Translated-Version-1143054.pdf
+// [2] Datasheet DHT22: https://cdn-shop.adafruit.com/datasheets/Digital+humidity+and+temperature+sensor+AM2302.pdf
+// Adafruit C++ driver: https://github.com/adafruit/DHT-sensor-library
+
+package dht // import "tinygo.org/x/drivers/dht"
+
+import (
+	"machine"
+	"time"
+)
+
+// Device interface provides main functionality of the DHTXX sensors.
+type Device interface {
+	DummyDevice
+	Configure(policy UpdatePolicy)
+}
+
+// managedDevice struct provides time control and optional automatic data retrieval from the sensor.
+// It delegates all the functionality to device
+type managedDevice struct {
+	t          device
+	lastUpdate time.Time
+	policy     UpdatePolicy
+}
+
+// Measurements returns both measurements: temperature and humidity as they sent by the device.
+// Depending on the UpdatePolicy of the device may update cached measurements.
+func (m *managedDevice) Measurements() (temperature int16, humidity uint16, err error) {
+	err = m.checkForUpdateOnDataRequest()
+	if err != nil {
+		return 0, 0, err
+	}
+	return m.t.Measurements()
+}
+
+// Getter for temperature. Temperature method returns temperature as it is sent by device.
+// The temperature is measured temperature in Celsius multiplied by 10.
+// Depending on the UpdatePolicy of the device may update cached measurements.
+func (m *managedDevice) Temperature() (temp int16, err error) {
+	err = m.checkForUpdateOnDataRequest()
+	if err != nil {
+		return 0, err
+	}
+	temp, err = m.t.Temperature()
+	return
+}
+
+func (m *managedDevice) checkForUpdateOnDataRequest() (err error) {
+	// update if necessary
+	if m.policy.UpdateAutomatically {
+		err = m.ReadMeasurements()
+	}
+	// ignore error if the data was updated recently
+	// interface comparison does not work in tinygo. Therefore need to cast to explicit type
+	if code, ok := err.(ErrorCode); ok && code == UpdateError {
+		err = nil
+	}
+	// add error if the data is not initialized
+	if !m.t.initialized {
+		err = UninitializedDataError
+	}
+	return err
+}
+
+// Getter for temperature. TemperatureFloat returns temperature in a given scale.
+// Depending on the UpdatePolicy of the device may update cached measurements.
+func (m *managedDevice) TemperatureFloat(scale TemperatureScale) (float32, error) {
+	err := m.checkForUpdateOnDataRequest()
+	if err != nil {
+		return 0, err
+	}
+	return m.t.TemperatureFloat(scale)
+}
+
+// Getter for humidity. Humidity returns humidity as it is sent by device.
+// The humidity is measured in percentages multiplied by 10.
+// Depending on the UpdatePolicy of the device may update cached measurements.
+func (m *managedDevice) Humidity() (hum uint16, err error) {
+	err = m.checkForUpdateOnDataRequest()
+	if err != nil {
+		return 0, err
+	}
+	return m.t.Humidity()
+}
+
+// Getter for humidity. HumidityFloat returns humidity in percentages.
+// Depending on the UpdatePolicy of the device may update cached measurements.
+func (m *managedDevice) HumidityFloat() (float32, error) {
+	err := m.checkForUpdateOnDataRequest()
+	if err != nil {
+		return 0, err
+	}
+	return m.t.HumidityFloat()
+}
+
+// ReadMeasurements reads data from the sensor.
+// The function will return UpdateError if it is called more frequently than specified in UpdatePolicy
+func (m *managedDevice) ReadMeasurements() (err error) {
+	timestamp := time.Now()
+	if !m.t.initialized || timestamp.Sub(m.lastUpdate) > m.policy.UpdateTime {
+		err = m.t.ReadMeasurements()
+	} else {
+		err = UpdateError
+	}
+	if err == nil {
+		m.lastUpdate = timestamp
+	}
+	return
+}
+
+// Configure configures UpdatePolicy for Device.
+// Configure checks for policy.UpdateTime and prevent from updating more frequently than specified in [1][2]
+// to prevent undefined behaviour of the sensor.
+func (m *managedDevice) Configure(policy UpdatePolicy) {
+	if policy.UpdateAutomatically && policy.UpdateTime < time.Second*2 {
+		policy.UpdateTime = time.Second * 2
+	}
+	m.policy = policy
+}
+
+// Constructor of the Device implementation.
+// This implementation updates data every 2 seconds during data access.
+func New(pin machine.Pin, deviceType DeviceType) Device {
+	pin.High()
+	return &managedDevice{
+		t: device{
+			pin:          pin,
+			measurements: deviceType,
+			initialized:  false,
+		},
+		lastUpdate: time.Time{},
+		policy: UpdatePolicy{
+			UpdateTime:          time.Second * 2,
+			UpdateAutomatically: true,
+		},
+	}
+}
+
+// Constructor of the Device implementation with given UpdatePolicy
+func NewWithPolicy(pin machine.Pin, deviceType DeviceType, updatePolicy UpdatePolicy) Device {
+	pin.High()
+	result := &managedDevice{
+		t: device{
+			pin:          pin,
+			measurements: deviceType,
+			initialized:  false,
+		},
+		lastUpdate: time.Time{},
+	}
+	result.Configure(updatePolicy)
+	return result
+}

dht/util.go

@@ -0,0 +1,34 @@
+package dht // import "tinygo.org/x/drivers/dht"
+
+import (
+	"machine"
+	"time"
+)
+
+// Check if the pin is disabled
+func powerUp(p machine.Pin) bool {
+	state := p.Get()
+	if !state {
+		p.High()
+		time.Sleep(startTimeout)
+	}
+	return state
+}
+
+func expectChange(p machine.Pin, oldState bool) counter {
+	cnt := counter(0)
+	for ; p.Get() == oldState && cnt != timeout; cnt++ {
+	}
+	return cnt
+}
+
+func checksum(buf []uint8) uint8 {
+	return buf[4]
+}
+func computeChecksum(buf []uint8) uint8 {
+	return buf[0] + buf[1] + buf[2] + buf[3]
+}
+
+func isValid(buf []uint8) bool {
+	return checksum(buf) == computeChecksum(buf)
+}

ds1307/ds1307.go

@@ -9,18 +9,18 @@ import (
 	"errors"
 	"time"
 
-	"machine"
+	"tinygo.org/x/drivers"
 )
 
 // Device wraps an I2C connection to a DS1307 device.
 type Device struct {
-	bus         machine.I2C
+	bus         drivers.I2C
 	Address     uint8
 	AddressSRAM uint8
 }
 
 // New creates a new DS1307 connection. I2C bus must be already configured.
-func New(bus machine.I2C) Device {
+func New(bus drivers.I2C) Device {
 	return Device{bus: bus,
 		Address:     uint8(I2CAddress),
 		AddressSRAM: SRAMBeginAddres,
@@ -42,8 +42,8 @@ func (d *Device) SetTime(t time.Time) error {
 	return err
 }
 
-// Time returns the time and date
-func (d *Device) Time() (time.Time, error) {
+// ReadTime returns the date and time
+func (d *Device) ReadTime() (time.Time, error) {
 	data := make([]byte, 8)
 	err := d.bus.ReadRegister(d.Address, uint8(TimeDate), data)
 	if err != nil {

ds3231/ds3231.go

@@ -5,15 +5,16 @@
 package ds3231 // import "tinygo.org/x/drivers/ds3231"
 
 import (
-	"machine"
 	"time"
+
+	"tinygo.org/x/drivers"
 )
 
 type Mode uint8
 
 // Device wraps an I2C connection to a DS3231 device.
 type Device struct {
-	bus     machine.I2C
+	bus     drivers.I2C
 	Address uint16
 }
 
@@ -21,7 +22,7 @@ type Device struct {
 // configured.
 //
 // This function only creates the Device object, it does not touch the device.
-func New(bus machine.I2C) Device {
+func New(bus drivers.I2C) Device {
 	return Device{
 		bus:     bus,
 		Address: Address,

examples/adt7410/main.go

@@ -10,7 +10,7 @@ import (
 
 var (
 	i2c    = &machine.I2C0
-	sensor = adt7410.New(i2c, 0)
+	sensor = adt7410.New(i2c)
 )
 
 func main() {

examples/bmp388/main.go

@@ -0,0 +1,53 @@
+package main
+
+import (
+	"machine"
+	"strconv"
+	"time"
+
+	"tinygo.org/x/drivers/bmp388"
+)
+
+func main() {
+
+	machine.I2C0.Configure(machine.I2CConfig{})
+
+	sensor := bmp388.New(machine.I2C0)
+	if !sensor.Connected() {
+		println("Uh oh, BMP388 not detected")
+		return
+	}
+
+	// The accuracy of the sensor can be increased, at the cost of a slower output rate. Table 9 in Section 3.5 of the
+	// datasheet has recommended settings for common use cases. If increasing the sampling rate, the output data rate
+	// (ODR) will likely have to be decreased. Configure() will return an error if there's a problem with the
+	// configuration settings - keep decreasing the ODR and cycling the power to the sensor until it is happy.
+	err := sensor.Configure(bmp388.Config{
+		Pressure:    bmp388.Sampling8X,
+		Temperature: bmp388.Sampling2X,
+		ODR:         bmp388.Odr25,
+		IIR:         bmp388.Coeff0,
+		Mode:        bmp388.Normal,
+	})
+
+	// This is also fine
+	// err := sensor.Configure(bmp388.BMP388Config{})
+
+	if err != nil {
+		println(err)
+	}
+
+	for {
+		temp, err := sensor.ReadTemperature() // returns the temperature in centicelsius
+		press, err := sensor.ReadPressure()   // returns the pressure in centipascals
+
+		if err != nil {
+			println(err)
+		} else {
+			println("Temperature: " + strconv.FormatInt(int64(temp), 10) + " cC")
+			println("Pressure:    " + strconv.FormatInt(int64(press), 10) + " cPa\n")
+		}
+
+		time.Sleep(time.Second)
+	}
+}

examples/dht/main.go

@@ -0,0 +1,23 @@
+package main
+
+import (
+	"fmt"
+	"machine"
+	"time"
+	"tinygo.org/x/drivers/dht"
+)
+
+func main() {
+	pin := machine.D6
+	dhtSensor := dht.New(pin, dht.DHT11)
+	for {
+		temp, hum, err := dhtSensor.Measurements()
+		if err != nil {
+			fmt.Printf("Temperature: %02d.%d°C, Humidity: %02d.%d%%\n", temp/10, temp%10, hum/10, hum%10)
+		} else {
+			fmt.Printf("Could not take measurements from the sensor: %s\n", err.Error())
+		}
+		// Measurements cannot be updated only 2 seconds. More frequent calls will return the same value
+		time.Sleep(time.Second * 2)
+	}
+}

examples/ds1307/time/main.go

@@ -13,7 +13,7 @@ func main() {
 	rtc.SetTime(time.Date(2019, 5, 15, 20, 34, 12, 0, time.UTC))
 
 	for {
-		t, err := rtc.Time()
+		t, err := rtc.ReadTime()
 		if err != nil {
 			println("Error reading date:", err)
 			break

examples/gps/i2c/main.go

@@ -1,8 +1,8 @@
 package main
 
 import (
-	"fmt"
 	"machine"
+	"time"
 
 	"tinygo.org/x/drivers/gps"
 )
@@ -11,19 +11,40 @@ func main() {
 	println("GPS I2C Example")
 	machine.I2C0.Configure(machine.I2CConfig{})
 	ublox := gps.NewI2C(&machine.I2C0)
-	parser := gps.Parser(ublox)
+	parser := gps.NewParser()
 	var fix gps.Fix
 	for {
-		fix = parser.NextFix()
+		s, err := ublox.NextSentence()
+		if err != nil {
+			println(err)
+			continue
+		}
+
+		fix, err = parser.Parse(s)
+		if err != nil {
+			println(err)
+			continue
+		}
 		if fix.Valid {
 			print(fix.Time.Format("15:04:05"))
-			print(", lat=", fmt.Sprintf("%f", fix.Latitude))
-			print(", long=", fmt.Sprintf("%f", fix.Longitude))
-			print(", altitude:=", fix.Altitude)
+			print(", lat=")
+			print(fix.Latitude)
+			print(", long=")
+			print(fix.Longitude)
+			print(", altitude=", fix.Altitude)
 			print(", satellites=", fix.Satellites)
+			if fix.Speed != 0 {
+				print(", speed=")
+				print(fix.Speed)
+			}
+			if fix.Heading != 0 {
+				print(", heading=")
+				print(fix.Heading)
+			}
 			println()
 		} else {
 			println("No fix")
 		}
+		time.Sleep(200 * time.Millisecond)
 	}
 }

examples/gps/uart/main.go

@@ -1,8 +1,8 @@
 package main
 
 import (
-	"fmt"
 	"machine"
+	"time"
 
 	"tinygo.org/x/drivers/gps"
 )
@@ -11,19 +11,40 @@ func main() {
 	println("GPS UART Example")
 	machine.UART1.Configure(machine.UARTConfig{BaudRate: 9600})
 	ublox := gps.NewUART(&machine.UART1)
-	parser := gps.Parser(ublox)
+	parser := gps.NewParser()
 	var fix gps.Fix
 	for {
-		fix = parser.NextFix()
+		s, err := ublox.NextSentence()
+		if err != nil {
+			println(err)
+			continue
+		}
+
+		fix, err = parser.Parse(s)
+		if err != nil {
+			println(err)
+			continue
+		}
 		if fix.Valid {
 			print(fix.Time.Format("15:04:05"))
-			print(", lat=", fmt.Sprintf("%f", fix.Latitude))
-			print(", long=", fmt.Sprintf("%f", fix.Longitude))
-			print(", altitude:=", fix.Altitude)
+			print(", lat=")
+			print(fix.Latitude)
+			print(", long=")
+			print(fix.Longitude)
+			print(", altitude=", fix.Altitude)
 			print(", satellites=", fix.Satellites)
+			if fix.Speed != 0 {
+				print(", speed=")
+				print(fix.Speed)
+			}
+			if fix.Heading != 0 {
+				print(", heading=")
+				print(fix.Heading)
+			}
 			println()
 		} else {
 			println("No fix")
 		}
+		time.Sleep(200 * time.Millisecond)
 	}
 }

examples/hcsr04/main.go

@@ -1,4 +1,4 @@
-package hcsr04
+package main
 
 import (
 	"machine"

examples/ili9341/basic/atsamd21.go

@@ -9,7 +9,7 @@ import (
 )
 
 var (
-	display = ili9341.NewSpi(
+	display = ili9341.NewSPI(
 		machine.SPI0,
 		machine.D0,
 		machine.D1,

examples/ili9341/basic/wioterminal.go

@@ -9,7 +9,7 @@ import (
 )
 
 var (
-	display = ili9341.NewSpi(
+	display = ili9341.NewSPI(
 		machine.SPI3,
 		machine.LCD_DC,
 		machine.LCD_SS_PIN,

examples/ili9341/pyportal_boing/wioterminal.go

@@ -9,7 +9,7 @@ import (
 )
 
 var (
-	display = ili9341.NewSpi(
+	display = ili9341.NewSPI(
 		machine.SPI3,
 		machine.LCD_DC,
 		machine.LCD_SS_PIN,

examples/ili9341/scroll/atsamd21.go

@@ -9,7 +9,7 @@ import (
 )
 
 var (
-	display = ili9341.NewSpi(
+	display = ili9341.NewSPI(
 		machine.SPI0,
 		machine.D0,
 		machine.D1,

examples/ili9341/scroll/wioterminal.go

@@ -9,7 +9,7 @@ import (
 )
 
 var (
-	display = ili9341.NewSpi(
+	display = ili9341.NewSPI(
 		machine.SPI3,
 		machine.LCD_DC,
 		machine.LCD_SS_PIN,

examples/lis2mdl/main.go

@@ -0,0 +1,29 @@
+package main
+
+import (
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/lis2mdl"
+)
+
+func main() {
+	machine.I2C0.Configure(machine.I2CConfig{})
+	compass := lis2mdl.New(machine.I2C0)
+
+	if !compass.Connected() {
+		for {
+			println("LIS2MDL not connected!")
+			time.Sleep(1 * time.Second)
+		}
+	}
+
+	compass.Configure(lis2mdl.Configuration{}) //default settings
+
+	for {
+		heading := compass.ReadCompass()
+		println("Heading:", heading)
+
+		time.Sleep(time.Millisecond * 100)
+	}
+}

examples/mcp23017-multiple/main.go

@@ -0,0 +1,45 @@
+// This example demonstrates putting several mcp23017 devices together into
+// a single virtual I/O array.
+package main
+
+import (
+	"machine"
+
+	"tinygo.org/x/drivers/mcp23017"
+)
+
+func main() {
+	err := machine.I2C0.Configure(machine.I2CConfig{
+		Frequency: machine.TWI_FREQ_400KHZ,
+	})
+	if err != nil {
+		panic(err)
+	}
+	// Assume the devices are at addresses 0x20, 0x21
+	dev, err := mcp23017.NewI2CDevices(machine.I2C0, 0x20, 0x21)
+	if err != nil {
+		panic(err)
+	}
+	// Configure pin 0 for input and all the others for output.
+	if err := dev.SetModes([]mcp23017.PinMode{
+		mcp23017.Input | mcp23017.Pullup,
+		mcp23017.Output,
+	}); err != nil {
+		panic(err)
+	}
+	input := dev.Pin(0)
+	// Make a mask that represents all the output pins.
+	// Note that this leverages the driver behaviour which replicates the highest bit in
+	// the last slice element (1 in this case) to all other pins
+	outputMask := mcp23017.PinSlice{^mcp23017.Pins(1 << 0)} // All except pin 0
+	inputVal, err := input.Get()
+	if err != nil {
+		panic(err)
+	}
+	println("input value: ", inputVal)
+	// Set the values of all the output pins.
+	err = dev.SetPins(mcp23017.PinSlice{0b1011011_01101110, 0b11111101_11100110}, outputMask)
+	if err != nil {
+		panic(err)
+	}
+}

examples/mcp23017/main.go

@@ -0,0 +1,39 @@
+package main
+
+import (
+	"machine"
+
+	"tinygo.org/x/drivers/mcp23017"
+)
+
+func main() {
+	err := machine.I2C0.Configure(machine.I2CConfig{
+		Frequency: machine.TWI_FREQ_400KHZ,
+	})
+	if err != nil {
+		panic(err)
+	}
+	dev, err := mcp23017.NewI2C(machine.I2C0, 0x20)
+	if err != nil {
+		panic(err)
+	}
+	// Configure pin 0 for input and all the others for output.
+	if err := dev.SetModes([]mcp23017.PinMode{
+		mcp23017.Input | mcp23017.Pullup,
+		mcp23017.Output,
+	}); err != nil {
+		panic(err)
+	}
+	input := dev.Pin(0)
+	outputMask := ^mcp23017.Pins(1 << 0) // All except pin 0
+	inputVal, err := input.Get()
+	if err != nil {
+		panic(err)
+	}
+	println("input value: ", inputVal)
+	// Set the values of all the output pins.
+	err = dev.SetPins(0b1011011_01101110, outputMask)
+	if err != nil {
+		panic(err)
+	}
+}

examples/ssd1331/main.go

@@ -1,4 +1,4 @@
-package ssd1331
+package main
 
 import (
 	"machine"

examples/ssd1351/main.go

@@ -1,4 +1,4 @@
-package ssd1351
+package main
 
 import (
 	"machine"

examples/st7789/main.go

@@ -9,12 +9,37 @@ import (
 )
 
 func main() {
+
+	// Example configuration for Adafruit Clue
+	// machine.SPI1.Configure(machine.SPIConfig{
+	//	Frequency: 8000000,
+	//	SCK:       machine.TFT_SCK,
+	//	SDO:       machine.TFT_SDO,
+	//	SDI:       machine.TFT_SDO,
+	//	Mode:      0,
+	// })
+	// display := st7789.New(machine.SPI1,
+	//	machine.TFT_RESET,
+	//	machine.TFT_DC,
+	//	machine.TFT_CS,
+	//	machine.TFT_LITE)
+
 	machine.SPI0.Configure(machine.SPIConfig{
 		Frequency: 8000000,
-		Mode:      3,
+		Mode:      0,
+	})
+	display := st7789.New(machine.SPI0,
+		machine.P6, // TFT_RESET
+		machine.P7, // TFT_DC
+		machine.P8, // TFT_CS
+		machine.P9) // TFT_LITE
+
+	display.Configure(st7789.Config{
+		Rotation:   st7789.NO_ROTATION,
+		RowOffset:  80,
+		FrameRate:  st7789.FRAMERATE_111,
+		VSyncLines: st7789.MAX_VSYNC_SCANLINES,
 	})
-	display := st7789.New(machine.SPI0, machine.P6, machine.P7, machine.P8)
-	display.Configure(st7789.Config{Rotation: st7789.NO_ROTATION})
 
 	width, height := display.Size()
 

examples/waveshare-epd/epd4in2/main.go

@@ -0,0 +1,56 @@
+package main
+
+import (
+	"machine"
+
+	"image/color"
+
+	"time"
+
+	"tinygo.org/x/drivers/waveshare-epd/epd4in2"
+)
+
+var display epd4in2.Device
+
+func main() {
+	machine.SPI0.Configure(machine.SPIConfig{
+		Frequency: 8000000,
+		Mode:      0,
+	})
+
+	display = epd4in2.New(machine.SPI0, machine.P6, machine.P7, machine.P8, machine.P9)
+	display.Configure(epd4in2.Config{})
+
+	black := color.RGBA{1, 1, 1, 255}
+
+	display.ClearBuffer()
+	println("Clear the display")
+	display.ClearDisplay()
+	display.WaitUntilIdle()
+	println("Waiting for 2 seconds")
+	time.Sleep(2 * time.Second)
+
+	// Show a checkered board
+	for i := int16(0); i < 16; i++ {
+		for j := int16(0); j < 25; j++ {
+			if (i+j)%2 == 0 {
+				showRect(i*8, j*10, 8, 10, black)
+			}
+		}
+	}
+	println("Show checkered board")
+	display.Display()
+	display.WaitUntilIdle()
+	println("Waiting for 2 seconds")
+	time.Sleep(2 * time.Second)
+
+	println("You could remove power now")
+}
+
+func showRect(x int16, y int16, w int16, h int16, c color.RGBA) {
+	for i := x; i < x+w; i++ {
+		for j := y; j < y+h; j++ {
+			display.SetPixel(i, j, c)
+		}
+	}
+}

examples/wifinina/mqttclient/main.go

@@ -41,15 +41,7 @@ var (
 	spi  = machine.NINA_SPI
 
 	// this is the ESP chip that has the WIFININA firmware flashed on it
-	adaptor = &wifinina.Device{
-		SPI:   spi,
-		CS:    machine.NINA_CS,
-		ACK:   machine.NINA_ACK,
-		GPIO0: machine.NINA_GPIO0,
-		RESET: machine.NINA_RESETN,
-	}
-
-	console = machine.UART0
+	adaptor *wifinina.Device
 	topic   = "tinygo"
 )
 
@@ -68,6 +60,11 @@ func main() {
 	})
 
 	// Init esp8266/esp32
+	adaptor = wifinina.New(spi,
+		machine.NINA_CS,
+		machine.NINA_ACK,
+		machine.NINA_GPIO0,
+		machine.NINA_RESETN)
 	adaptor.Configure()
 
 	connectToAP()

examples/wifinina/mqttsub/main.go

@@ -40,15 +40,7 @@ var (
 	spi  = machine.NINA_SPI
 
 	// this is the ESP chip that has the WIFININA firmware flashed on it
-	adaptor = &wifinina.Device{
-		SPI:   spi,
-		CS:    machine.NINA_CS,
-		ACK:   machine.NINA_ACK,
-		GPIO0: machine.NINA_GPIO0,
-		RESET: machine.NINA_RESETN,
-	}
-
-	console = machine.UART0
+	adaptor *wifinina.Device
 
 	cl      mqtt.Client
 	topicTx = "tinygo/tx"
@@ -75,6 +67,11 @@ func main() {
 	})
 
 	// Init esp8266/esp32
+	adaptor = wifinina.New(spi,
+		machine.NINA_CS,
+		machine.NINA_ACK,
+		machine.NINA_GPIO0,
+		machine.NINA_RESETN)
 	adaptor.Configure()
 
 	connectToAP()

examples/wifinina/ntpclient/main.go

@@ -24,20 +24,9 @@ const ntpHost = "129.6.15.29"
 const NTP_PACKET_SIZE = 48
 
 var (
-
 	// this is the ESP chip that has the WIFININA firmware flashed on it
-	// these are the default pins for the Arduino Nano33 IoT.
-	adaptor = wifinina.Device{
-		SPI:   machine.NINA_SPI,
-		CS:    machine.NINA_CS,
-		ACK:   machine.NINA_ACK,
-		GPIO0: machine.NINA_GPIO0,
-		RESET: machine.NINA_RESETN,
-	}
-
-	b = make([]byte, NTP_PACKET_SIZE)
-
-	console = machine.UART0
+	adaptor *wifinina.Device
+	b       = make([]byte, NTP_PACKET_SIZE)
 )
 
 func main() {
@@ -50,6 +39,14 @@ func main() {
 		SDI:       machine.NINA_SDI,
 		SCK:       machine.NINA_SCK,
 	})
+
+	// these are the default pins for the Arduino Nano33 IoT.
+	adaptor = wifinina.New(machine.NINA_SPI,
+		machine.NINA_CS,
+		machine.NINA_ACK,
+		machine.NINA_GPIO0,
+		machine.NINA_RESETN)
+
 	adaptor.Configure()
 
 	// connect to access point

examples/wifinina/tcpclient/main.go

@@ -35,15 +35,7 @@ var (
 	spi  = machine.NINA_SPI
 
 	// this is the ESP chip that has the WIFININA firmware flashed on it
-	adaptor = &wifinina.Device{
-		SPI:   spi,
-		CS:    machine.NINA_CS,
-		ACK:   machine.NINA_ACK,
-		GPIO0: machine.NINA_GPIO0,
-		RESET: machine.NINA_RESETN,
-	}
-
-	console = machine.UART0
+	adaptor *wifinina.Device
 )
 
 var buf = &bytes.Buffer{}
@@ -60,6 +52,11 @@ func main() {
 		SCK:       machine.NINA_SCK,
 	})
 
+	adaptor = wifinina.New(spi,
+		machine.NINA_CS,
+		machine.NINA_ACK,
+		machine.NINA_GPIO0,
+		machine.NINA_RESETN)
 	adaptor.Configure()
 
 	connectToAP()

examples/wifinina/udpstation/main.go

@@ -22,19 +22,9 @@ const pass = ""
 // IP address of the server aka "hub". Replace with your own info.
 const hubIP = ""
 
-// 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 (
-
 	// this is the ESP chip that has the WIFININA firmware flashed on it
-	// these are the default pins for the Arduino Nano33 IoT.
-	adaptor = &wifinina.Device{
-		SPI:   machine.NINA_SPI,
-		CS:    machine.NINA_CS,
-		ACK:   machine.NINA_ACK,
-		GPIO0: machine.NINA_GPIO0,
-		RESET: machine.NINA_RESETN,
-	}
+	adaptor *wifinina.Device
 )
 
 func main() {
@@ -47,6 +37,14 @@ func main() {
 		SDI:       machine.NINA_SDI,
 		SCK:       machine.NINA_SCK,
 	})
+
+	// these are the default pins for the Arduino Nano33 IoT.
+	// change these to connect to a different UART or pins for the ESP8266/ESP32
+	adaptor = wifinina.New(machine.NINA_SPI,
+		machine.NINA_CS,
+		machine.NINA_ACK,
+		machine.NINA_GPIO0,
+		machine.NINA_RESETN)
 	adaptor.Configure()
 
 	// connect to access point

examples/wifinina/webclient/main.go

@@ -33,15 +33,7 @@ var (
 	spi  = machine.NINA_SPI
 
 	// this is the ESP chip that has the WIFININA firmware flashed on it
-	adaptor = &wifinina.Device{
-		SPI:   spi,
-		CS:    machine.NINA_CS,
-		ACK:   machine.NINA_ACK,
-		GPIO0: machine.NINA_GPIO0,
-		RESET: machine.NINA_RESETN,
-	}
-
-	console = machine.UART0
+	adaptor *wifinina.Device
 )
 
 var buf [256]byte
@@ -61,6 +53,11 @@ func main() {
 		SCK:       machine.NINA_SCK,
 	})
 
+	adaptor = wifinina.New(spi,
+		machine.NINA_CS,
+		machine.NINA_ACK,
+		machine.NINA_GPIO0,
+		machine.NINA_RESETN)
 	adaptor.Configure()
 
 	connectToAP()

examples/ws2812/arduino.go

@@ -0,0 +1,9 @@
+// +build arduino
+
+package main
+
+import "machine"
+
+// Replace neo in the code below to match the pin
+// that you are using if different.
+var neo = machine.D2

examples/ws2812/others.go

@@ -1,4 +1,4 @@
-// +build !digispark
+// +build !digispark,!arduino
 
 package main
 

flash/flash.go

@@ -133,6 +133,8 @@ func (dev *Device) Configure(config *DeviceConfig) (err error) {
 	time.Sleep(30 * time.Microsecond)
 
 	// Speed up to max device frequency
+	// I propose a check here for max frequency, but not put that functionality directly into the driver.
+	// Either that or we have to change the signature of the SPI interface in the machine package itself.
 	if dev.attrs.MaxClockSpeedMHz > 0 {
 		err := dev.trans.setClockSpeed(uint32(dev.attrs.MaxClockSpeedMHz) * 1e6)
 		if err != nil {

flash/transport_spi.go

@@ -1,6 +1,8 @@
 package flash
 
-import "machine"
+import (
+	"machine"
+)
 
 type transport interface {
 	configure(config *DeviceConfig)

go.mod

@@ -1,5 +1,8 @@
 module tinygo.org/x/drivers
 
-go 1.14
+go 1.15
 
-require github.com/eclipse/paho.mqtt.golang v1.2.0
+require (
+	github.com/eclipse/paho.mqtt.golang v1.2.0
+	github.com/frankban/quicktest v1.10.2
+)

go.sum

@@ -1,2 +1,13 @@
 github.com/eclipse/paho.mqtt.golang v1.2.0 h1:1F8mhG9+aO5/xpdtFkW4SxOJB67ukuDC3t2y2qayIX0=
 github.com/eclipse/paho.mqtt.golang v1.2.0/go.mod h1:H9keYFcgq3Qr5OUJm/JZI/i6U7joQ8SYLhZwfeOo6Ts=
+github.com/frankban/quicktest v1.10.2 h1:19ARM85nVi4xH7xPXuc5eM/udya5ieh7b/Sv+d844Tk=
+github.com/frankban/quicktest v1.10.2/go.mod h1:K+q6oSqb0W0Ininfk863uOk1lMy69l/P6txr3mVT54s=
+github.com/google/go-cmp v0.5.2 h1:X2ev0eStA3AbceY54o37/0PQ/UWqKEiiO2dKL5OPaFM=
+github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/kr/pretty v0.2.1 h1:Fmg33tUaq4/8ym9TJN1x7sLJnHVwhP33CNkpYV/7rwI=
+github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

gps/gps.go

@@ -3,24 +3,32 @@ package gps // import "tinygo.org/x/drivers/gps"
 
 import (
 	"encoding/hex"
+	"errors"
 	"machine"
 	"strings"
 	"time"
+
+	"tinygo.org/x/drivers"
+)
+
+var (
+	errInvalidNMEASentenceLength = errors.New("invalid NMEA sentence length")
+	errInvalidNMEAChecksum       = errors.New("invalid NMEA sentence checksum")
 )
 
 // Device wraps a connection to a GPS device.
-type GPSDevice struct {
+type Device struct {
 	buffer   []byte
 	bufIdx   int
 	sentence strings.Builder
 	uart     *machine.UART
-	bus      *machine.I2C
+	bus      drivers.I2C
 	address  uint16
 }
 
 // NewUART creates a new UART GPS connection. The UART must already be configured.
-func NewUART(uart *machine.UART) GPSDevice {
-	return GPSDevice{
+func NewUART(uart *machine.UART) Device {
+	return Device{
 		uart:     uart,
 		buffer:   make([]byte, bufferSize),
 		bufIdx:   bufferSize,
@@ -29,8 +37,8 @@ func NewUART(uart *machine.UART) GPSDevice {
 }
 
 // NewI2C creates a new I2C GPS connection.
-func NewI2C(bus *machine.I2C) GPSDevice {
-	return GPSDevice{
+func NewI2C(bus drivers.I2C) Device {
+	return Device{
 		bus:      bus,
 		address:  I2C_ADDRESS,
 		buffer:   make([]byte, bufferSize),
@@ -39,17 +47,17 @@ func NewI2C(bus *machine.I2C) GPSDevice {
 	}
 }
 
-// ReadNextSentence returns the next valid NMEA sentence from the GPS device.
-func (gps *GPSDevice) NextSentence() (sentence string) {
+// NextSentence returns the next valid NMEA sentence from the GPS device.
+func (gps *Device) NextSentence() (sentence string, err error) {
 	sentence = gps.readNextSentence()
-	for !validSentence(sentence) {
-		sentence = gps.readNextSentence()
+	if err = validSentence(sentence); err != nil {
+		return "", err
 	}
-	return sentence
+	return sentence, nil
 }
 
 // readNextSentence returns the next sentence from the GPS device.
-func (gps *GPSDevice) readNextSentence() (sentence string) {
+func (gps *Device) readNextSentence() (sentence string) {
 	gps.sentence.Reset()
 	var b byte = ' '
 
@@ -69,7 +77,7 @@ func (gps *GPSDevice) readNextSentence() (sentence string) {
 	return sentence
 }
 
-func (gps *GPSDevice) readNextByte() (b byte) {
+func (gps *Device) readNextByte() (b byte) {
 	gps.bufIdx += 1
 	if gps.bufIdx >= bufferSize {
 		gps.fillBuffer()
@@ -77,7 +85,7 @@ func (gps *GPSDevice) readNextByte() (b byte) {
 	return gps.buffer[gps.bufIdx]
 }
 
-func (gps *GPSDevice) fillBuffer() {
+func (gps *Device) fillBuffer() {
 	if gps.uart != nil {
 		gps.uartFillBuffer()
 	} else {
@@ -85,7 +93,7 @@ func (gps *GPSDevice) fillBuffer() {
 	}
 }
 
-func (gps *GPSDevice) uartFillBuffer() {
+func (gps *Device) uartFillBuffer() {
 	for gps.uart.Buffered() < bufferSize {
 		time.Sleep(100 * time.Millisecond)
 	}
@@ -93,7 +101,7 @@ func (gps *GPSDevice) uartFillBuffer() {
 	gps.bufIdx = 0
 }
 
-func (gps *GPSDevice) i2cFillBuffer() {
+func (gps *Device) i2cFillBuffer() {
 	for gps.available() < bufferSize {
 		time.Sleep(100 * time.Millisecond)
 	}
@@ -102,7 +110,7 @@ func (gps *GPSDevice) i2cFillBuffer() {
 }
 
 // Available returns how many bytes of GPS data are currently available.
-func (gps *GPSDevice) available() (available int) {
+func (gps *Device) available() (available int) {
 	var lengthBytes [2]byte
 	gps.bus.Tx(gps.address, []byte{BYTES_AVAIL_REG}, lengthBytes[0:2])
 	available = int(lengthBytes[0])*256 + int(lengthBytes[1])
@@ -110,7 +118,7 @@ func (gps *GPSDevice) available() (available int) {
 }
 
 // WriteBytes sends data/commands to the GPS device
-func (gps *GPSDevice) WriteBytes(bytes []byte) {
+func (gps *Device) WriteBytes(bytes []byte) {
 	if gps.uart != nil {
 		gps.uart.Write(bytes)
 	} else {
@@ -119,14 +127,18 @@ func (gps *GPSDevice) WriteBytes(bytes []byte) {
 }
 
 // validSentence checks if a sentence has been received uncorrupted
-func validSentence(sentence string) bool {
+func validSentence(sentence string) error {
 	if len(sentence) < 4 || sentence[0] != '$' || sentence[len(sentence)-3] != '*' {
-		return false
+		return errInvalidNMEASentenceLength
 	}
 	var cs byte = 0
 	for i := 1; i < len(sentence)-3; i++ {
 		cs ^= sentence[i]
 	}
 	checksum := hex.EncodeToString([]byte{cs})
-	return (checksum[0] == sentence[len(sentence)-2]) && (checksum[1] == sentence[len(sentence)-1])
+	if (checksum[0] != sentence[len(sentence)-2]) || (checksum[1] != sentence[len(sentence)-1]) {
+		return errInvalidNMEAChecksum
+	}
+
+	return nil
 }

gps/gpsparser.go

@@ -1,92 +1,131 @@
 package gps
 
 import (
+	"errors"
 	"strconv"
 	"strings"
 	"time"
 )
 
-type GPSParser struct {
-	gpsDevice GPSDevice
+var (
+	errEmptyNMEASentence   = errors.New("cannot parse empty NMEA sentence")
+	errUnknownNMEASentence = errors.New("unsupported NMEA sentence type")
+	errInvalidGGASentence  = errors.New("invalid GGA NMEA sentence")
+	errInvalidRMCSentence  = errors.New("invalid RMC NMEA sentence")
+)
+
+// Parser for GPS NMEA sentences.
+type Parser struct {
 }
 
-// fix is a GPS location fix
+// Fix is a GPS location fix
 type Fix struct {
-	Valid      bool
-	Time       time.Time
-	Latitude   float32
-	Longitude  float32
-	Altitude   int32
+	// Valid if the fix was valid.
+	Valid bool
+
+	// Time that the fix was taken, in UTC time.
+	Time time.Time
+
+	// Latitude is the decimal latitude. Negative numbers indicate S.
+	Latitude float32
+
+	// Longitude is the decimal longitude. Negative numbers indicate E.
+	Longitude float32
+
+	// Altitude is only returned for GGA sentences.
+	Altitude int32
+
+	// Satellites is the number of visible satellites, but is only returned for GGA sentences.
 	Satellites int16
+
+	// Speed based on reported movement. Only returned for RMC sentences.
+	Speed float32
+
+	// Heading based on reported movement. Only returned for RMC sentences.
+	Heading float32
 }
 
-func Parser(gpsDevice GPSDevice) GPSParser {
-	return GPSParser{
-		gpsDevice: gpsDevice,
+// NewParser returns a GPS NMEA Parser.
+func NewParser() Parser {
+	return Parser{}
+}
+
+// Parse parses a NMEA sentence looking for fix info.
+func (parser *Parser) Parse(sentence string) (fix Fix, err error) {
+	if sentence == "" {
+		err = errEmptyNMEASentence
+		return
 	}
-}
-
-// NextFix returns the next GPS location Fix from the GPS device
-func (parser *GPSParser) NextFix() (fix Fix) {
-	var ggaSentence = nextGGA(parser.gpsDevice)
-	var ggaFields = strings.Split(ggaSentence, ",")
-	fix.Altitude = findAltitude(ggaFields)
-	fix.Satellites = findSatellites(ggaFields)
-	fix.Longitude = findLongitude(ggaFields)
-	fix.Latitude = findLatitude(ggaFields)
-	fix.Time = findTime(ggaFields)
-	fix.Valid = (fix.Altitude != -99999) && (fix.Satellites > 0)
-	return fix
-}
-
-// nextGGA returns the next GGA type sentence from the GPS device
-// $--GGA,,,,,,,,,,,,,,*hh
-func nextGGA(gpsDevice GPSDevice) (sentence string) {
-	for {
-		sentence = gpsDevice.NextSentence()
-		if sentence[3:6] == "GGA" {
-			return sentence
+	typ := sentence[3:6]
+	switch typ {
+	case "GGA":
+		fields := strings.Split(sentence, ",")
+		if len(fields) != 15 {
+			err = errInvalidGGASentence
+			return
 		}
+
+		fix.Altitude = findAltitude(fields[9])
+		fix.Satellites = findSatellites(fields[7])
+		fix.Longitude = findLongitude(fields[4], fields[5])
+		fix.Latitude = findLatitude(fields[2], fields[3])
+		fix.Time = findTime(fields[1])
+		fix.Valid = (fix.Altitude != -99999) && (fix.Satellites > 0)
+	case "RMC":
+		fields := strings.Split(sentence, ",")
+		if len(fields) != 13 {
+			err = errInvalidRMCSentence
+			return
+		}
+
+		fix.Longitude = findLongitude(fields[5], fields[6])
+		fix.Latitude = findLatitude(fields[3], fields[4])
+		fix.Time = findTime(fields[1])
+		fix.Speed = findSpeed(fields[7])
+		fix.Heading = findHeading(fields[8])
+		fix.Valid = (len(fields[2]) > 0 && fields[2][0:1] == "A")
+	default:
+		err = errUnknownNMEASentence
 	}
+	return
 }
 
-// findTime returns the time from a GGA sentence:
+// findTime returns the time from an NMEA sentence:
 // $--GGA,hhmmss.ss,,,,,,,,,,,,,*xx
-func findTime(ggaFields []string) time.Time {
-	if len(ggaFields) < 1 || len(ggaFields[1]) < 6 {
+func findTime(val string) time.Time {
+	if len(val) < 6 {
 		return time.Time{}
 	}
-	ts := strings.Builder{}
-	ts.WriteString(ggaFields[1][0:2])
-	ts.WriteString(":")
-	ts.WriteString(ggaFields[1][2:4])
-	ts.WriteString(":")
-	ts.WriteString(ggaFields[1][4:6])
-	var t, _ = time.Parse("15:04:05", ts.String())
+
+	h, _ := strconv.ParseInt(val[0:2], 10, 8)
+	m, _ := strconv.ParseInt(val[2:4], 10, 8)
+	s, _ := strconv.ParseInt(val[4:6], 10, 8)
+	ms, _ := strconv.ParseInt(val[7:10], 10, 16)
+	t := time.Date(0, 0, 0, int(h), int(m), int(s), int(ms), time.UTC)
 
 	return t
 }
 
-// findAltitude returns the altitude from a GGA sentence:
+// findAltitude returns the altitude from an NMEA sentence:
 // $--GGA,,,,,,,,,25.8,,,,,*63
-func findAltitude(ggaFields []string) int32 {
-	if len(ggaFields) > 8 && len(ggaFields[9]) > 0 {
-		var v, _ = strconv.ParseFloat(ggaFields[9], 32)
+func findAltitude(val string) int32 {
+	if len(val) > 0 {
+		var v, _ = strconv.ParseFloat(val, 32)
 		return int32(v)
 	}
 	return -99999
 }
 
-// findLatitude returns the Latitude from a GGA sentence:
+// findLatitude returns the Latitude from an NMEA sentence:
 // $--GGA,,ddmm.mmmmm,x,,,,,,,,,,,*hh
-func findLatitude(ggaFields []string) float32 {
-	if len(ggaFields) > 2 && len(ggaFields[2]) > 8 {
-		var dd = ggaFields[2][0:2]
-		var mm = ggaFields[2][2:]
+func findLatitude(val, hemi string) float32 {
+	if len(val) > 8 {
+		var dd = val[0:2]
+		var mm = val[2:]
 		var d, _ = strconv.ParseFloat(dd, 32)
 		var m, _ = strconv.ParseFloat(mm, 32)
 		var v = float32(d + (m / 60))
-		if ggaFields[3] == "S" {
+		if hemi == "S" {
 			v *= -1
 		}
 		return v
@@ -94,16 +133,16 @@ func findLatitude(ggaFields []string) float32 {
 	return 0.0
 }
 
-// findLatitude returns the longitude from a GGA sentence:
+// findLatitude returns the longitude from an NMEA sentence:
 // $--GGA,,,,dddmm.mmmmm,x,,,,,,,,,*hh
-func findLongitude(ggaFields []string) float32 {
-	if len(ggaFields) > 4 && len(ggaFields[4]) > 8 {
-		var ddd = ggaFields[4][0:3]
-		var mm = ggaFields[4][3:]
+func findLongitude(val, hemi string) float32 {
+	if len(val) > 8 {
+		var ddd = val[0:3]
+		var mm = val[3:]
 		var d, _ = strconv.ParseFloat(ddd, 32)
 		var m, _ = strconv.ParseFloat(mm, 32)
 		var v = float32(d + (m / 60))
-		if ggaFields[5] == "W" {
+		if hemi == "W" {
 			v *= -1
 		}
 		return v
@@ -111,14 +150,32 @@ func findLongitude(ggaFields []string) float32 {
 	return 0.0
 }
 
-// findSatellites returns the satellites from a GGA sentence:
+// findSatellites returns the satellites from an NMEA sentence:
 // $--GGA,,,,,,,nn,,,,,,,*hh
-func findSatellites(ggaFields []string) (n int16) {
-	if len(ggaFields) > 6 && len(ggaFields[7]) > 0 {
-		var nn = ggaFields[7]
+func findSatellites(val string) (n int16) {
+	if len(val) > 0 {
+		var nn = val
 		var v, _ = strconv.ParseInt(nn, 10, 32)
 		n = int16(v)
 		return n
 	}
 	return 0
 }
+
+// findSpeed returns the speed from an RMC NMEA sentence.
+func findSpeed(val string) float32 {
+	if len(val) > 0 {
+		var v, _ = strconv.ParseFloat(val, 32)
+		return float32(v)
+	}
+	return 0
+}
+
+// findHeading returns the speed from an RMC NMEA sentence.
+func findHeading(val string) float32 {
+	if len(val) > 0 {
+		var v, _ = strconv.ParseFloat(val, 32)
+		return float32(v)
+	}
+	return 0
+}

gps/registers.go

@@ -13,5 +13,5 @@ const (
 )
 
 const (
-	bufferSize = 32
+	bufferSize = 100
 )

gps/ublox.go

@@ -24,25 +24,25 @@ var cfg_gnss_cmd = [...]byte{
 	0x01, 0x01, 0x06, 0x08, 0x0E, 0x00, 0x00, 0x00,
 	0x01, 0x01, 0xFC, 0x11}
 
-func FlightMode(gpsDevice GPSDevice) (err error) {
-	err = sendCommand(gpsDevice, flight_mode_cmd[:])
+func FlightMode(d Device) (err error) {
+	err = sendCommand(d, flight_mode_cmd[:])
 	return err
 }
 
-func SetCfgGNSS(gpsDevice GPSDevice) (err error) {
-	err = sendCommand(gpsDevice, cfg_gnss_cmd[:])
+func SetCfgGNSS(d Device) (err error) {
+	err = sendCommand(d, cfg_gnss_cmd[:])
 	return err
 }
 
-func sendCommand(gpsDevice GPSDevice, command []byte) (err error) {
-	gpsDevice.WriteBytes(command)
+func sendCommand(d Device, command []byte) (err error) {
+	d.WriteBytes(command)
 	start := time.Now()
 	for time.Now().Sub(start) < 1000 {
-		if gpsDevice.readNextByte() == '\n' {
-			if gpsDevice.readNextByte() == 0xB5 {
-				gpsDevice.readNextByte()
-				if gpsDevice.readNextByte() == 0x05 {
-					if gpsDevice.readNextByte() == 0x01 {
+		if d.readNextByte() == '\n' {
+			if d.readNextByte() == 0xB5 {
+				d.readNextByte()
+				if d.readNextByte() == 0x05 {
+					if d.readNextByte() == 0x01 {
 						return
 					}
 				}

hd44780/gpio.go

@@ -57,9 +57,16 @@ func (g *GPIO) SetCommandMode(set bool) {
 	}
 }
 
+// WriteOnly is true if you passed rw in as machine.NoPin
+func (g *GPIO) WriteOnly() bool {
+	return g.rw == machine.NoPin
+}
+
 // Write writes len(data) bytes from data to display driver
 func (g *GPIO) Write(data []byte) (n int, err error) {
-	g.rw.Low()
+	if !g.WriteOnly() {
+		g.rw.Low()
+	}
 	for _, d := range data {
 		g.write(d)
 		n++
@@ -89,6 +96,9 @@ func (g *GPIO) Read(data []byte) (n int, err error) {
 	if len(data) == 0 {
 		return 0, errors.New("length greater than 0 is required")
 	}
+	if g.WriteOnly() {
+		return 0, errors.New("Read not supported if RW not wired")
+	}
 	g.rw.High()
 	g.reconfigureGPIOMode(machine.PinInput)
 	for i := 0; i < len(data); i++ {

hd44780/hd44780.go

@@ -11,9 +11,23 @@ import (
 	"time"
 )
 
+const (
+	// These are the default execution times for the Clear and
+	// Home commands and everything else.
+	//
+	// These are used if RW is passed as machine.NoPin and ignored
+	// otherwise.
+	//
+	// They are set conservatively here and can be tweaked in the
+	// Config structure.
+	DefaultClearHomeTime = 80 * time.Millisecond
+	DefaultInstrExecTime = 80 * time.Microsecond
+)
+
 type Buser interface {
 	io.ReadWriter
 	SetCommandMode(set bool)
+	WriteOnly() bool
 }
 
 type Device struct {
@@ -28,6 +42,9 @@ type Device struct {
 
 	cursor     cursor
 	busyStatus []byte
+
+	clearHomeTime time.Duration // time clear/home instructions might take
+	instrExecTime time.Duration // time all other instructions might take
 }
 
 type cursor struct {
@@ -35,14 +52,18 @@ type cursor struct {
 }
 
 type Config struct {
-	Width       int16
-	Height      int16
-	CursorBlink bool
-	CursorOnOff bool
-	Font        uint8
+	Width         int16
+	Height        int16
+	CursorBlink   bool
+	CursorOnOff   bool
+	Font          uint8
+	ClearHomeTime time.Duration // time clear/home instructions might take - use 0 for the default
+	InstrExecTime time.Duration // time all other instructions might take - use 0 for the default
 }
 
 // NewGPIO4Bit returns 4bit data length HD44780 driver. Datapins are LCD DB pins starting from DB4 to DB7
+//
+// If your device has RW set permanently to ground then pass in rw as machine.NoPin
 func NewGPIO4Bit(dataPins []machine.Pin, e, rs, rw machine.Pin) (Device, error) {
 	const fourBitMode = 4
 	if len(dataPins) != fourBitMode {
@@ -52,6 +73,8 @@ func NewGPIO4Bit(dataPins []machine.Pin, e, rs, rw machine.Pin) (Device, error)
 }
 
 // NewGPIO8Bit returns 8bit data length HD44780 driver. Datapins are LCD DB pins starting from DB0 to DB7
+//
+// If your device has RW set permanently to ground then pass in rw as machine.NoPin
 func NewGPIO8Bit(dataPins []machine.Pin, e, rs, rw machine.Pin) (Device, error) {
 	const eightBitMode = 8
 	if len(dataPins) != eightBitMode {
@@ -68,6 +91,8 @@ func (d *Device) Configure(cfg Config) error {
 	if d.width == 0 || d.height == 0 {
 		return errors.New("width and height must be set")
 	}
+	d.clearHomeTime = cfg.ClearHomeTime
+	d.instrExecTime = cfg.InstrExecTime
 	memoryMap := uint8(ONE_LINE)
 	if d.height > 1 {
 		memoryMap = TWO_LINE
@@ -186,7 +211,7 @@ func (d *Device) SendCommand(command byte) {
 	d.bus.SetCommandMode(true)
 	d.bus.Write([]byte{command})
 
-	for d.Busy() {
+	for d.busy(command == DISPLAY_CLEAR || command == CURSOR_HOME) {
 	}
 }
 
@@ -195,7 +220,7 @@ func (d *Device) sendData(data byte) {
 	d.bus.SetCommandMode(false)
 	d.bus.Write([]byte{data})
 
-	for d.Busy() {
+	for d.busy(false) {
 	}
 }
 
@@ -207,13 +232,39 @@ func (d *Device) CreateCharacter(cgramAddr uint8, data []byte) {
 	}
 }
 
-// Busy returns true when hd447890 is busy
-func (d *Device) Busy() bool {
+// busy returns true when hd447890 is busy
+// or after the timeout specified
+func (d *Device) busy(longDelay bool) bool {
+	if d.bus.WriteOnly() {
+		// Can't read busy flag if write only, so sleep a bit then return
+		if longDelay {
+			// Note that we sleep like this so the default
+			// time.Sleep is time.Sleep(constant) as
+			// time.Sleep(variable) doesn't seem to work on AVR yet
+			if d.clearHomeTime != 0 {
+				time.Sleep(d.clearHomeTime)
+			} else {
+				time.Sleep(DefaultClearHomeTime)
+			}
+		} else {
+			if d.instrExecTime != 0 {
+				time.Sleep(d.instrExecTime)
+			} else {
+				time.Sleep(DefaultInstrExecTime)
+			}
+		}
+		return false
+	}
 	d.bus.SetCommandMode(true)
 	d.bus.Read(d.busyStatus)
 	return (d.busyStatus[0] & BUSY) > 0
 }
 
+// Busy returns true when hd447890 is busy
+func (d *Device) Busy() bool {
+	return d.busy(false)
+}
+
 // Size returns the current size of the display.
 func (d *Device) Size() (w, h int16) {
 	return int16(d.width), int16(d.height)

hd44780i2c/hd44780i2c.go

@@ -7,13 +7,14 @@ package hd44780i2c
 
 import (
 	"errors"
-	"machine"
 	"time"
+
+	"tinygo.org/x/drivers"
 )
 
 // Device wraps an I2C connection to a HD44780 I2C LCD with related data.
 type Device struct {
-	bus             machine.I2C
+	bus             drivers.I2C
 	addr            uint8
 	width           uint8
 	height          uint8
@@ -41,7 +42,7 @@ type Config struct {
 // configured.
 //
 // This function only creates the Device object, it does not touch the device.
-func New(bus machine.I2C, addr uint8) Device {
+func New(bus drivers.I2C, addr uint8) Device {
 	if addr == 0 {
 		addr = 0x27
 	}

hub75/hub75.go

@@ -9,6 +9,8 @@ import (
 	"image/color"
 	"machine"
 	"time"
+
+	"tinygo.org/x/drivers"
 )
 
 type Config struct {
@@ -21,7 +23,7 @@ type Config struct {
 }
 
 type Device struct {
-	bus               machine.SPI
+	bus               drivers.SPI
 	a                 machine.Pin
 	b                 machine.Pin
 	c                 machine.Pin
@@ -52,7 +54,7 @@ type Device struct {
 }
 
 // New returns a new HUB75 driver. Pass in a fully configured SPI bus.
-func New(b machine.SPI, latPin, oePin, aPin, bPin, cPin, dPin machine.Pin) Device {
+func New(b drivers.SPI, latPin, oePin, aPin, bPin, cPin, dPin machine.Pin) Device {
 	aPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
 	bPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
 	cPin.Configure(machine.PinConfig{Mode: machine.PinOutput})

i2c.go

@@ -0,0 +1,9 @@
+package drivers
+
+// I2C represents an I2C bus. It is notably implemented by the
+// machine.I2C type.
+type I2C interface {
+	ReadRegister(addr uint8, r uint8, buf []byte) error
+	WriteRegister(addr uint8, r uint8, buf []byte) error
+	Tx(addr uint16, w, r []byte) error
+}

ili9341/ili9341.go

@@ -20,7 +20,7 @@ type Device struct {
 	driver   driver
 
 	x0, x1 int16 // cached address window; prevents useless/expensive
-	y0, y1 int16 // syscalls to PASET, CASET, and RAMWR
+	y0, y1 int16 // syscalls to PASET and CASET
 
 	dc  machine.Pin
 	cs  machine.Pin
@@ -28,6 +28,7 @@ type Device struct {
 	rd  machine.Pin
 }
 
+// Configure prepares display for use
 func (d *Device) Configure(config Config) {
 
 	if config.Width == 0 {
@@ -145,6 +146,7 @@ func (d *Device) Display() error {
 	return nil
 }
 
+// DrawRGBBitmap copies an RGB bitmap to the internal buffer at given coordinates
 func (d *Device) DrawRGBBitmap(x, y int16, data []uint16, w, h int16) error {
 	k, i := d.Size()
 	if x < 0 || y < 0 || w <= 0 || h <= 0 ||
@@ -158,7 +160,7 @@ func (d *Device) DrawRGBBitmap(x, y int16, data []uint16, w, h int16) error {
 	return nil
 }
 
-// FillRectangle fills a rectangle at a given coordinates with a color
+// FillRectangle fills a rectangle at given coordinates with a color
 func (d *Device) FillRectangle(x, y, width, height int16, c color.RGBA) error {
 	k, i := d.Size()
 	if x < 0 || y < 0 || width <= 0 || height <= 0 ||
@@ -173,7 +175,7 @@ func (d *Device) FillRectangle(x, y, width, height int16, c color.RGBA) error {
 	return nil
 }
 
-// DrawRectangle fills a rectangle at a given coordinates with a color
+// DrawRectangle draws a rectangle at given coordinates with a color
 func (d *Device) DrawRectangle(x, y, w, h int16, c color.RGBA) error {
 	if err := d.DrawFastHLine(x, x+w-1, y, c); err != nil {
 		return err
@@ -215,6 +217,7 @@ func (d *Device) FillScreen(c color.RGBA) {
 	}
 }
 
+// GetRotation returns the current rotation of the device
 func (d *Device) GetRotation() Rotation {
 	return d.rotation
 }
@@ -236,7 +239,8 @@ func (d *Device) SetRotation(rotation Rotation) {
 	d.rotation = rotation
 }
 
-// SetScrollWindow sets an area to scroll with fixed top and bottom parts of the display
+// SetScrollArea sets an area to scroll with fixed top/bottom or left/right parts of the display
+// Rotation affects scroll direction
 func (d *Device) SetScrollArea(topFixedArea, bottomFixedArea int16) {
 	d.sendCommand(VSCRDEF, []uint8{
 		uint8(topFixedArea >> 8), uint8(topFixedArea),
@@ -251,7 +255,7 @@ func (d *Device) SetScroll(line int16) {
 	d.sendCommand(VSCRSADD, []uint8{uint8(line >> 8), uint8(line)})
 }
 
-// SpotScroll returns the display to its normal state
+// StopScroll returns the display to its normal state
 func (d *Device) StopScroll() {
 	d.sendCommand(NORON, nil)
 }
@@ -260,10 +264,8 @@ func (d *Device) StopScroll() {
 func (d *Device) setWindow(x, y, w, h int16) {
 	//x += d.columnOffset
 	//y += d.rowOffset
-	wr := false
 	x1 := x + w - 1
 	if x != d.x0 || x1 != d.x1 {
-		wr = true
 		d.sendCommand(CASET, []uint8{
 			uint8(x >> 8), uint8(x), uint8(x1 >> 8), uint8(x1),
 		})
@@ -271,15 +273,12 @@ func (d *Device) setWindow(x, y, w, h int16) {
 	}
 	y1 := y + h - 1
 	if y != d.y0 || y1 != d.y1 {
-		wr = true
 		d.sendCommand(PASET, []uint8{
 			uint8(y >> 8), uint8(y), uint8(y1 >> 8), uint8(y1),
 		})
 		d.y0, d.y1 = y, y1
 	}
-	if wr {
-		d.sendCommand(RAMWR, nil)
-	}
+	d.sendCommand(RAMWR, nil)
 }
 
 //go:inline

ili9341/spi_atsamd21.go

@@ -11,7 +11,7 @@ type spiDriver struct {
 	bus machine.SPI
 }
 
-func NewSpi(bus machine.SPI, dc, cs, rst machine.Pin) *Device {
+func NewSPI(bus machine.SPI, dc, cs, rst machine.Pin) *Device {
 	return &Device{
 		dc:  dc,
 		cs:  cs,

ili9341/spi_atsamd51.go

@@ -11,7 +11,7 @@ type spiDriver struct {
 	bus machine.SPI
 }
 
-func NewSpi(bus machine.SPI, dc, cs, rst machine.Pin) *Device {
+func NewSPI(bus machine.SPI, dc, cs, rst machine.Pin) *Device {
 	return &Device{
 		dc:  dc,
 		cs:  cs,

lis2mdl/lis2mdl.go

@@ -0,0 +1,126 @@
+// Package lis2mdl implements a driver for the LIS2MDL,
+// a magnetic sensor which is included on BBC micro:bit v1.5.
+//
+// Datasheet: https://www.st.com/resource/en/datasheet/lis2mdl.pdf
+//
+package lis2mdl // import "tinygo.org/x/drivers/lis2mdl"
+
+import (
+	"math"
+	"time"
+
+	"tinygo.org/x/drivers"
+)
+
+// Device wraps an I2C connection to a LIS2MDL device.
+type Device struct {
+	bus        drivers.I2C
+	Address    uint8
+	PowerMode  uint8
+	SystemMode uint8
+	DataRate   uint8
+}
+
+// Configuration for LIS2MDL device.
+type Configuration struct {
+	PowerMode  uint8
+	SystemMode uint8
+	DataRate   uint8
+}
+
+// New creates a new LIS2MDL 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}
+}
+
+// Connected returns whether LIS2MDL sensor has been found.
+func (d *Device) Connected() bool {
+	data := []byte{0}
+	d.bus.ReadRegister(uint8(d.Address), WHO_AM_I, data)
+	return data[0] == 0x40
+}
+
+// Configure sets up the LIS2MDL device for communication.
+func (d *Device) Configure(cfg Configuration) {
+	if cfg.PowerMode != 0 {
+		d.PowerMode = cfg.PowerMode
+	} else {
+		d.PowerMode = POWER_NORMAL
+	}
+
+	if cfg.DataRate != 0 {
+		d.DataRate = cfg.DataRate
+	} else {
+		d.DataRate = DATARATE_100HZ
+	}
+
+	if cfg.SystemMode != 0 {
+		d.SystemMode = cfg.SystemMode
+	} else {
+		d.SystemMode = SYSTEM_CONTINUOUS
+	}
+
+	cmd := []byte{0}
+
+	// reset
+	cmd[0] = byte(1 << 5)
+	d.bus.WriteRegister(uint8(d.Address), CFG_REG_A, cmd)
+	time.Sleep(100 * time.Millisecond)
+
+	// reboot
+	cmd[0] = byte(1 << 6)
+	d.bus.WriteRegister(uint8(d.Address), CFG_REG_A, cmd)
+	time.Sleep(100 * time.Millisecond)
+
+	// bdu
+	cmd[0] = byte(1 << 4)
+	d.bus.WriteRegister(uint8(d.Address), CFG_REG_C, cmd)
+
+	// Temperature compensation is on for magnetic sensor (0x80)
+	cmd[0] = byte(0x80)
+	d.bus.WriteRegister(uint8(d.Address), CFG_REG_A, cmd)
+
+	// speed
+	cmd[0] = byte(0x80 | d.DataRate)
+	d.bus.WriteRegister(uint8(d.Address), CFG_REG_A, cmd)
+}
+
+// ReadMagneticField reads the current magnetic field from the device and returns
+// it in mG (milligauss). 1 mG = 0.1 µT (microtesla).
+func (d *Device) ReadMagneticField() (x int32, y int32, z int32) {
+	// turn back on read mode, even though it is supposed to be continuous?
+	cmd := []byte{0}
+	cmd[0] = byte(0x80 | d.PowerMode<<4 | d.DataRate<<2 | d.SystemMode)
+	d.bus.WriteRegister(uint8(d.Address), CFG_REG_A, cmd)
+	time.Sleep(10 * time.Millisecond)
+
+	data := make([]byte, 6)
+	d.bus.ReadRegister(uint8(d.Address), OUTX_L_REG, data)
+
+	x = int32(int16((uint16(data[0]) << 8) | uint16(data[1])))
+	y = int32(int16((uint16(data[2]) << 8) | uint16(data[3])))
+	z = int32(int16((uint16(data[4]) << 8) | uint16(data[5])))
+
+	return
+}
+
+// ReadCompass reads the current compass heading from the device and returns
+// it in degrees. When the z axis is pointing straight to Earth and
+// the y axis is pointing to North, the heading would be zero.
+//
+// However, the heading may be off due to electronic compasses would be effected
+// by strong magnetic fields and require constant calibration.
+func (d *Device) ReadCompass() (h int32) {
+	x, y, _ := d.ReadMagneticField()
+	xf, yf := float64(x)*0.15, float64(y)*0.15
+
+	rh := (math.Atan2(yf, xf) * 180) / math.Pi
+	if rh < 0 {
+		rh = 360 + rh
+	}
+
+	return int32(rh)
+}

lis2mdl/lis2mdl_test.go

@@ -0,0 +1,59 @@
+package lis2mdl
+
+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, uint8(ADDRESS))
+}
+
+func TestWhoAmI(t *testing.T) {
+	c := qt.New(t)
+	bus := tester.NewI2CBus(c)
+	fake := tester.NewI2CDevice(c, ADDRESS)
+	copy(fake.Registers[:], defaultRegisters())
+	bus.AddDevice(fake)
+
+	dev := New(bus)
+	c.Assert(dev.Connected(), qt.Equals, true)
+
+	fake.Registers[WHO_AM_I] = 0x99
+	c.Assert(dev.Connected(), qt.Equals, false)
+}
+
+// defaultRegisters returns the default values for all of the device's registers.
+// see table 22 on page 27 of the datasheet.
+func defaultRegisters() []uint8 {
+	return []uint8{
+		OFFSET_X_REG_L: 0,
+		OFFSET_X_REG_H: 0,
+		OFFSET_Y_REG_L: 0,
+		OFFSET_Y_REG_H: 0,
+		OFFSET_Z_REG_L: 0,
+		OFFSET_Z_REG_H: 0,
+		WHO_AM_I:       0x40,
+		CFG_REG_A:      0x03,
+		CFG_REG_B:      0,
+		CFG_REG_C:      0,
+		INT_CRTL_REG:   0xE0,
+		INT_SOURCE_REG: 0,
+		INT_THS_L_REG:  0,
+		INT_THS_H_REG:  0,
+		STATUS_REG:     0,
+		OUTX_L_REG:     0,
+		OUTX_H_REG:     0,
+		OUTY_L_REG:     0,
+		OUTY_H_REG:     0,
+		OUTZ_L_REG:     0,
+		OUTZ_H_REG:     0,
+		TEMP_OUT_L_REG: 0,
+		TEMP_OUT_H_REG: 0,
+	}
+}

lis2mdl/registers.go

@@ -0,0 +1,45 @@
+package lis2mdl
+
+const (
+	// Constants/addresses used for I2C.
+	ADDRESS = 0x1E
+
+	// magnetic sensor registers.
+	OFFSET_X_REG_L = 0x45
+	OFFSET_X_REG_H = 0x46
+	OFFSET_Y_REG_L = 0x47
+	OFFSET_Y_REG_H = 0x48
+	OFFSET_Z_REG_L = 0x49
+	OFFSET_Z_REG_H = 0x4A
+	WHO_AM_I       = 0x4F
+	CFG_REG_A      = 0x60
+	CFG_REG_B      = 0x61
+	CFG_REG_C      = 0x62
+	INT_CRTL_REG   = 0x63
+	INT_SOURCE_REG = 0x64
+	INT_THS_L_REG  = 0x65
+	INT_THS_H_REG  = 0x66
+	STATUS_REG     = 0x67
+	OUTX_L_REG     = 0x68
+	OUTX_H_REG     = 0x69
+	OUTY_L_REG     = 0x6A
+	OUTY_H_REG     = 0x6B
+	OUTZ_L_REG     = 0x6C
+	OUTZ_H_REG     = 0x6D
+	TEMP_OUT_L_REG = 0x6E
+	TEMP_OUT_H_REG = 0x6F
+
+	// magnetic sensor power mode.
+	POWER_NORMAL = 0x00 // default
+	POWER_LOW    = 0x01
+
+	// magnetic sensor operate mode.
+	SYSTEM_CONTINUOUS = 0x00 // default
+	SYSTEM_SINGLE     = 0x01
+
+	// magnetic sensor data rate
+	DATARATE_10HZ  = 0x00 // default
+	DATARATE_20HZ  = 0x01
+	DATARATE_50HZ  = 0x02
+	DATARATE_100HZ = 0x03
+)

lis3dh/lis3dh.go

@@ -4,13 +4,11 @@
 //
 package lis3dh // import "tinygo.org/x/drivers/lis3dh"
 
-import (
-	"machine"
-)
+import "tinygo.org/x/drivers"
 
 // Device wraps an I2C connection to a LIS3DH device.
 type Device struct {
-	bus     machine.I2C
+	bus     drivers.I2C
 	Address uint16
 	r       Range
 }
@@ -18,7 +16,7 @@ type Device struct {
 // New creates a new LIS3DH connection. The I2C bus must already be configured.
 //
 // This function only creates the Device object, it does not touch the device.
-func New(bus machine.I2C) Device {
+func New(bus drivers.I2C) Device {
 	return Device{bus: bus, Address: Address0}
 }
 

lsm303agr/lsm303agr.go

@@ -6,13 +6,14 @@
 package lsm303agr // import "tinygo.org/x/drivers/lsm303agr"
 
 import (
-	"machine"
 	"math"
+
+	"tinygo.org/x/drivers"
 )
 
 // Device wraps an I2C connection to a LSM303AGR device.
 type Device struct {
-	bus            machine.I2C
+	bus            drivers.I2C
 	AccelAddress   uint8
 	MagAddress     uint8
 	AccelPowerMode uint8
@@ -37,7 +38,7 @@ type Configuration struct {
 // configured.
 //
 // This function only creates the Device object, it does not touch the device.
-func New(bus machine.I2C) Device {
+func New(bus drivers.I2C) Device {
 	return Device{bus: bus, AccelAddress: ACCEL_ADDRESS, MagAddress: MAG_ADDRESS}
 }
 

lsm6ds3/lsm6ds3.go

@@ -5,9 +5,7 @@
 //
 package lsm6ds3 // import "tinygo.org/x/drivers/lsm6ds3"
 
-import (
-	"machine"
-)
+import "tinygo.org/x/drivers"
 
 type AccelRange uint8
 type AccelSampleRate uint8
@@ -18,7 +16,7 @@ type GyroSampleRate uint8
 
 // Device wraps an I2C connection to a LSM6DS3 device.
 type Device struct {
-	bus             machine.I2C
+	bus             drivers.I2C
 	Address         uint16
 	accelRange      AccelRange
 	accelSampleRate AccelSampleRate
@@ -44,7 +42,7 @@ type Configuration struct {
 // configured.
 //
 // This function only creates the Device object, it does not touch the device.
-func New(bus machine.I2C) Device {
+func New(bus drivers.I2C) Device {
 	return Device{bus: bus, Address: Address}
 }
 

mag3110/mag3110.go

@@ -5,13 +5,11 @@
 //
 package mag3110 // import "tinygo.org/x/drivers/mag3110"
 
-import (
-	"machine"
-)
+import "tinygo.org/x/drivers"
 
 // Device wraps an I2C connection to a MAG3110 device.
 type Device struct {
-	bus     machine.I2C
+	bus     drivers.I2C
 	Address uint16
 }
 
@@ -19,7 +17,7 @@ type Device struct {
 // configured.
 //
 // This function only creates the Device object, it does not touch the device.
-func New(bus machine.I2C) Device {
+func New(bus drivers.I2C) Device {
 	return Device{bus, Address}
 }
 

mcp23017/device.go

@@ -0,0 +1,381 @@
+// Package mcp23017 implements a driver for the MCP23017
+// I2C port expander chip. See https://www.microchip.com/wwwproducts/en/MCP23017
+// for details of the interface.
+//
+// It also provides a way of joining several such devices into one logical
+// device (see the Devices type).
+package mcp23017
+
+import (
+	"errors"
+)
+
+const (
+	// hwAddressFixed holds the bits of the hardware address
+	// that are fixed by the chip. Bits 0-3 (those in hwAddressMask)
+	// are user-defined by the A0-A2 pins on the chip.
+	hwAddress = uint8(0b010_0000)
+	// hwAddressMask holds the bits that are significant in hwAddress.
+	hwAddressMask = uint8(0b111_1000)
+)
+
+type register uint8
+
+const (
+	// The following registers all refer to port A (except
+	// rIOCON with is port-agnostic).
+	// ORing them with portB makes them refer to port B.
+	rIODIR        = register(0x00) // I/O direction. 0=output; 1=input.
+	rIOPOL        = register(0x02) // Invert input values. 0=normal; 1=inverted.
+	rGPINTEN      = register(0x04)
+	rDEFVAL       = register(0x06)
+	rINTCON       = register(0x08)
+	rIOCON        = register(0x0A)
+	rGPPU         = register(0x0C) // Pull up; 0=no pull-up; 1=pull-up.
+	rINTF         = register(0x0E)
+	rINTCAP       = register(0x10)
+	rGPIO         = register(0x12) // GPIO pin values.
+	rOLAT         = register(0x14)
+	registerCount = 0x16
+
+	portB = register(0x1)
+)
+
+// PinCount is the number of GPIO pins available on the chip.
+const PinCount = 16
+
+// PinMode represents a possible I/O mode for a pin.
+// The zero value represents the default value
+// after the chip is reset (input).
+type PinMode uint8
+
+const (
+	// Input configures a pin as an input.
+	Input = PinMode(0)
+	// Output configures a pin as an output.
+	Output = PinMode(1)
+
+	// Direction is the bit mask of the pin mode representing
+	// the I/O direction.
+	Direction = PinMode(1)
+
+	// Pullup can be bitwise-or'd with Input
+	// to cause the pull-up resistor on the pin to
+	// be enabled.
+	Pullup = PinMode(2)
+
+	// Invert can be bitwise-or'd with Input to
+	// cause the pin value to reflect the inverted
+	// value on the pin.
+	Invert = PinMode(4)
+)
+
+// ErrInvalidHWAddress is returned when the hardware address
+// of the device is not valid (only some bits can be set by the
+// address pins).
+var ErrInvalidHWAddress = errors.New("invalid hardware address")
+
+// I2C represents an I2C bus. It is notably implemented by the
+// machine.I2C type.
+type I2C interface {
+	ReadRegister(addr uint8, r uint8, buf []byte) error
+	WriteRegister(addr uint8, r uint8, buf []byte) error
+}
+
+// New returns a new MCP23017 device at the given I2C address
+// on the given bus.
+// It returns ErrInvalidHWAddress if the address isn't possible for the device.
+//
+// By default all pins are configured as inputs.
+func NewI2C(bus I2C, address uint8) (*Device, error) {
+	if address&hwAddressMask != hwAddress {
+		return nil, ErrInvalidHWAddress
+	}
+	d := &Device{
+		bus:  bus,
+		addr: address,
+	}
+	pins, err := d.GetPins()
+	if err != nil {
+		return nil, errors.New("cannot initialize mcp23017 device at " + hex(address) + ": " + err.Error())
+	}
+	d.pins = pins
+	return d, nil
+}
+
+func hex(x uint8) string {
+	digits := "0123456789abcdef"
+	return "0x" + digits[x>>4:x>>4+1] + digits[x&0xf:x&0xf+1]
+}
+
+// Device represents an MCP23017 device.
+type Device struct {
+	// TODO would it be good to have a mutex here so that independent goroutines
+	// could change pins without needing to do the locking themselves?
+
+	// bus holds the reference the I2C bus that the device lives on.
+	// It's an interface so that we can write tests for it.
+	bus  I2C
+	addr uint8
+	// pins caches the most recent pin values that have been set.
+	// This enables us to change individual pin values without
+	// doing a read followed by a write.
+	pins Pins
+}
+
+// GetPins reads all 16 pins from ports A and B.
+func (d *Device) GetPins() (Pins, error) {
+	return d.readRegisterAB(rGPIO)
+}
+
+// SetPins sets all the pins for which mask is high
+// to their respective values in pins.
+//
+// That is, it does the equivalent of:
+//
+// 	for i := 0; i < PinCount; i++ {
+//		if mask.Get(i) {
+//			d.Pin(i).Set(pins.Get(i))
+//		}
+//	}
+func (d *Device) SetPins(pins, mask Pins) error {
+	if mask == 0 {
+		return nil
+	}
+	newPins := (d.pins &^ mask) | (pins & mask)
+	if newPins == d.pins {
+		return nil
+	}
+	err := d.writeRegisterAB(rGPIO, newPins)
+	if err != nil {
+		return err
+	}
+	d.pins = newPins
+	return nil
+}
+
+// TogglePins inverts the values on all pins for
+// which mask is high.
+func (d *Device) TogglePins(mask Pins) error {
+	if mask == 0 {
+		return nil
+	}
+	return d.SetPins(^d.pins, mask)
+}
+
+// Pin returns a Pin representing the given pin number (from 0 to 15).
+// Pin numbers from 0 to 7 represent port A pins 0 to 7.
+// Pin numbers from 8 to 15 represent port B pins 0 to 7.
+func (d *Device) Pin(pin int) Pin {
+	if pin < 0 || pin >= PinCount {
+		panic("pin out of range")
+	}
+	var mask Pins
+	mask.High(pin)
+	return Pin{
+		dev:  d,
+		mask: mask,
+		pin:  uint8(pin),
+	}
+}
+
+// SetAllModes sets the mode of all the pins in a single operation.
+// If len(modes) is less than PinCount, all remaining pins
+// will be set fo modes[len(modes)-1], or PinMode(0) if
+// modes is empty.
+//
+// If len(modes) is greater than PinCount, the excess entries
+// will be ignored.
+func (d *Device) SetModes(modes []PinMode) error {
+	defaultMode := PinMode(0)
+	if len(modes) > 0 {
+		defaultMode = modes[len(modes)-1]
+	}
+	var dir, pullup, invert Pins
+	for i := 0; i < PinCount; i++ {
+		mode := defaultMode
+		if i < len(modes) {
+			mode = modes[i]
+		}
+		if mode&Direction == Input {
+			dir.High(i)
+		}
+		if mode&Pullup != 0 {
+			pullup.High(i)
+		}
+		if mode&Invert != 0 {
+			invert.High(i)
+		}
+	}
+	if err := d.writeRegisterAB(rIODIR, dir); err != nil {
+		return err
+	}
+	if err := d.writeRegisterAB(rGPPU, pullup); err != nil {
+		return err
+	}
+	if err := d.writeRegisterAB(rIOPOL, invert); err != nil {
+		return err
+	}
+	return nil
+}
+
+// GetModes reads the modes of all the pins into modes.
+// It's OK if len(modes) is not PinCount - excess entries
+// will be left unset.
+func (d *Device) GetModes(modes []PinMode) error {
+	dir, err := d.readRegisterAB(rIODIR)
+	if err != nil {
+		return err
+	}
+	pullup, err := d.readRegisterAB(rGPPU)
+	if err != nil {
+		return err
+	}
+	invert, err := d.readRegisterAB(rIOPOL)
+	if err != nil {
+		return err
+	}
+	if len(modes) > PinCount {
+		modes = modes[:PinCount]
+	}
+	for i := range modes {
+		mode := Output
+		if dir.Get(i) {
+			mode = Input
+		}
+		if pullup.Get(i) {
+			mode |= Pullup
+		}
+		if invert.Get(i) {
+			mode |= Invert
+		}
+		modes[i] = mode
+	}
+	return nil
+}
+
+func (d *Device) writeRegisterAB(r register, val Pins) error {
+	// We rely on the auto-incrementing sequential write
+	// and the fact that registers alternate between A and B
+	// to write both ports in a single operation.
+	buf := [2]byte{uint8(val), uint8(val >> 8)}
+	return d.bus.WriteRegister(d.addr, uint8(r&^portB), buf[:])
+}
+
+func (d *Device) readRegisterAB(r register) (Pins, error) {
+	// We rely on the auto-incrementing sequential write
+	// and the fact that registers alternate between A and B
+	// to read both ports in a single operation.
+	var buf [2]byte
+	if err := d.bus.ReadRegister(d.addr, uint8(r), buf[:]); err != nil {
+		return Pins(0), err
+	}
+	return Pins(buf[0]) | (Pins(buf[1]) << 8), nil
+}
+
+// Pin represents a single GPIO pin on the device.
+type Pin struct {
+	// mask holds the mask of the pin.
+	mask Pins
+	// pin holds the actual pin number.
+	pin uint8
+	dev *Device
+}
+
+// Set sets the pin to the given value.
+func (p Pin) Set(value bool) error {
+	// TODO currently this always writes both registers when
+	// technically it only needs to write one. We could potentially
+	// optimize that.
+	if value {
+		return p.dev.SetPins(^Pins(0), p.mask)
+	} else {
+		return p.dev.SetPins(0, p.mask)
+	}
+}
+
+// High is short for p.Set(true).
+func (p Pin) High() error {
+	return p.Set(true)
+}
+
+// High is short for p.Set(false).
+func (p Pin) Low() error {
+	return p.Set(false)
+}
+
+// Toggle inverts the value output on the pin.
+func (p Pin) Toggle() error {
+	return p.dev.TogglePins(p.mask)
+}
+
+// Get returns the current value of the given pin.
+func (p Pin) Get() (bool, error) {
+	// TODO this reads 2 registers when we could read just one.
+	pins, err := p.dev.GetPins()
+	if err != nil {
+		return false, err
+	}
+	return pins&p.mask != 0, nil
+}
+
+// SetMode configures the pin to the given mode.
+func (p Pin) SetMode(mode PinMode) error {
+	// We could use a more efficient single-register
+	// read/write pattern but setting pin modes isn't an
+	// operation that's likely to need to be efficient, so
+	// use less code and use Get/SetModes directly.
+	modes := make([]PinMode, PinCount)
+	if err := p.dev.GetModes(modes); err != nil {
+		return err
+	}
+	modes[p.pin] = mode
+	return p.dev.SetModes(modes)
+}
+
+// GetMode returns the mode of the pin.
+func (p Pin) GetMode() (PinMode, error) {
+	modes := make([]PinMode, PinCount)
+	if err := p.dev.GetModes(modes); err != nil {
+		return 0, err
+	}
+	return modes[p.pin], nil
+}
+
+// Pins represents a bitmask of pin values.
+// Port A values are in bits 0-8 (numbered from least significant bit)
+// Port B values are in bits 9-15.
+type Pins uint16
+
+// Set sets the value for the given pin.
+func (p *Pins) Set(pin int, value bool) {
+	if value {
+		p.High(pin)
+	} else {
+		p.Low(pin)
+	}
+}
+
+// Get returns the value for the given pin.
+func (p Pins) Get(pin int) bool {
+	return (p & pinMask(pin)) != 0
+}
+
+// High is short for p.Set(pin, true).
+func (p *Pins) High(pin int) {
+	*p |= pinMask(pin)
+}
+
+// Low is short for p.Set(pin, false).
+func (p *Pins) Low(pin int) {
+	*p &^= pinMask(pin)
+}
+
+// Toggle inverts the value of the given pin.
+func (p *Pins) Toggle(pin int) {
+	*p ^= pinMask(pin)
+}
+
+func pinMask(pin int) Pins {
+	return 1 << pin
+}

mcp23017/device_test.go

@@ -0,0 +1,220 @@
+package mcp23017
+
+import (
+	"fmt"
+	"testing"
+
+	qt "github.com/frankban/quicktest"
+
+	"tinygo.org/x/drivers/tester"
+)
+
+func TestGetPins(t *testing.T) {
+	c := qt.New(t)
+	bus := tester.NewI2CBus(c)
+	fdev := newDevice(bus, 0x20)
+	fdev.Registers[rGPIO] = 0b10101100
+	fdev.Registers[rGPIO|portB] = 0b01010011
+	dev, err := NewI2C(bus, 0x20)
+	c.Assert(err, qt.IsNil)
+	pins, err := dev.GetPins()
+	c.Assert(err, qt.IsNil)
+	c.Assert(pins, qt.Equals, Pins(0b01010011_10101100))
+}
+
+func TestSetPins(t *testing.T) {
+	c := qt.New(t)
+	bus := tester.NewI2CBus(c)
+	fdev := newDevice(bus, 0x20)
+	fdev.Registers[rGPIO] = 0b00001111
+	fdev.Registers[rGPIO|portB] = 0b11110000
+	dev, err := NewI2C(bus, 0x20)
+	c.Assert(err, qt.IsNil)
+	pins, err := dev.GetPins()
+	c.Assert(err, qt.IsNil)
+	c.Assert(pins, qt.Equals, Pins(0b11110000_00001111))
+
+	err = dev.SetPins(0b01100000_00110000, 0b10101010_01010101)
+	c.Assert(err, qt.IsNil)
+	pins, err = dev.GetPins()
+	c.Assert(err, qt.IsNil)
+	c.Assert(pins, qt.Equals, Pins(0b01110000_0001_1010))
+
+	// The logic uses the cached value of the pins rather than
+	// reading it from the registers each time.
+	fdev.Registers[rGPIO] = 0
+	fdev.Registers[rGPIO|portB] = 0
+
+	err = dev.SetPins(0b01000000_00110000, 0b01100000_00000000)
+	c.Assert(err, qt.IsNil)
+	pins, err = dev.GetPins()
+	c.Assert(err, qt.IsNil)
+	c.Assert(pins, qt.Equals, Pins(0b01010000_00011010))
+}
+
+func TestTogglePins(t *testing.T) {
+	c := qt.New(t)
+	bus := tester.NewI2CBus(c)
+	fdev := newDevice(bus, 0x20)
+	fdev.Registers[rGPIO] = 0b00001111
+	fdev.Registers[rGPIO|portB] = 0b11110000
+	dev, err := NewI2C(bus, 0x20)
+	c.Assert(err, qt.IsNil)
+	pins, err := dev.GetPins()
+	c.Assert(err, qt.IsNil)
+	c.Assert(pins, qt.Equals, Pins(0b11110000_00001111))
+
+	err = dev.TogglePins(0b10101010_01010101)
+	c.Assert(err, qt.IsNil)
+	pins, err = dev.GetPins()
+	c.Assert(err, qt.IsNil)
+	c.Assert(pins, qt.Equals, Pins(0b01011010_01011010))
+}
+
+func TestSetGetModes(t *testing.T) {
+	c := qt.New(t)
+	bus := tester.NewI2CBus(c)
+	fdev := newDevice(bus, 0x20)
+	dev, err := NewI2C(bus, 0x20)
+	c.Assert(err, qt.IsNil)
+	// Calling SetModes with less items in than there are
+	// pins should use the last item for all the unspecified ones.
+	err = dev.SetModes([]PinMode{Input | Invert, Output})
+	c.Assert(err, qt.IsNil)
+	c.Assert(fdev.Registers[rIODIR], qt.Equals, uint8(0b00000001))
+	c.Assert(fdev.Registers[rIOPOL], qt.Equals, uint8(0b00000001))
+	c.Assert(fdev.Registers[rGPPU], qt.Equals, uint8(0))
+
+	modes := make([]PinMode, 17)
+	err = dev.GetModes(modes)
+	c.Assert(err, qt.IsNil)
+	c.Assert(modes[0], qt.Equals, Input|Invert)
+	for i, m := range modes[1:16] {
+		c.Assert(m, qt.Equals, Output, qt.Commentf("index %d", i))
+	}
+	c.Assert(modes[16], qt.Equals, PinMode(0))
+
+	// Using an empty slice should reset all the modes to the initial state.
+	err = dev.SetModes(nil)
+	c.Assert(err, qt.IsNil)
+	c.Assert(fdev.Registers[rIODIR], qt.Equals, uint8(0b11111111))
+	c.Assert(fdev.Registers[rIOPOL], qt.Equals, uint8(0))
+	c.Assert(fdev.Registers[rGPPU], qt.Equals, uint8(0))
+}
+
+func TestPinSetGet(t *testing.T) {
+	c := qt.New(t)
+	bus := tester.NewI2CBus(c)
+	fdev := newDevice(bus, 0x20)
+	dev, err := NewI2C(bus, 0x20)
+	c.Assert(err, qt.IsNil)
+	pin := dev.Pin(1)
+	v, err := pin.Get()
+	c.Assert(err, qt.Equals, nil)
+	c.Assert(v, qt.Equals, false)
+	err = pin.Set(true)
+	c.Assert(err, qt.Equals, nil)
+	c.Assert(fdev.Registers[rGPIO], qt.Equals, uint8(0b10))
+	v, err = pin.Get()
+	c.Assert(err, qt.Equals, nil)
+	c.Assert(v, qt.Equals, true)
+	err = pin.Set(false)
+	c.Assert(err, qt.Equals, nil)
+	c.Assert(fdev.Registers[rGPIO], qt.Equals, uint8(0))
+	err = pin.High()
+	c.Assert(err, qt.Equals, nil)
+	c.Assert(fdev.Registers[rGPIO], qt.Equals, uint8(0b10))
+	err = pin.Low()
+	c.Assert(err, qt.Equals, nil)
+	c.Assert(fdev.Registers[rGPIO], qt.Equals, uint8(0))
+}
+
+func TestPinToggle(t *testing.T) {
+	c := qt.New(t)
+	bus := tester.NewI2CBus(c)
+	fdev := newDevice(bus, 0x20)
+	dev, err := NewI2C(bus, 0x20)
+	c.Assert(err, qt.IsNil)
+	pin := dev.Pin(1)
+	v, err := pin.Get()
+	c.Assert(err, qt.Equals, nil)
+	c.Assert(v, qt.Equals, false)
+	err = pin.Toggle()
+	c.Assert(err, qt.Equals, nil)
+	c.Assert(fdev.Registers[rGPIO], qt.Equals, uint8(0b10))
+	err = pin.Toggle()
+	c.Assert(err, qt.Equals, nil)
+	c.Assert(fdev.Registers[rGPIO], qt.Equals, uint8(0))
+}
+
+func TestPinMode(t *testing.T) {
+	c := qt.New(t)
+	bus := tester.NewI2CBus(c)
+	fdev := newDevice(bus, 0x20)
+	dev, err := NewI2C(bus, 0x20)
+	c.Assert(err, qt.IsNil)
+	pin := dev.Pin(1)
+	mode, err := pin.GetMode()
+	c.Assert(err, qt.IsNil)
+	c.Assert(mode, qt.Equals, PinMode(0))
+	c.Assert(mode&Direction, qt.Equals, Input)
+
+	err = pin.SetMode(Input | Pullup | Invert)
+	c.Assert(err, qt.IsNil)
+	c.Assert(fdev.Registers[rIODIR], qt.Equals, uint8(0b11111111))
+	c.Assert(fdev.Registers[rIOPOL], qt.Equals, uint8(0b10))
+	c.Assert(fdev.Registers[rGPPU], qt.Equals, uint8(0b10))
+
+	mode, err = pin.GetMode()
+	c.Assert(err, qt.IsNil)
+	c.Assert(mode, qt.Equals, Input|Pullup|Invert)
+
+	// Set another pin to output.
+	err = dev.Pin(2).SetMode(Output)
+	c.Assert(err, qt.IsNil)
+	c.Assert(fdev.Registers[rIODIR], qt.Equals, uint8(0b11111011))
+	c.Assert(fdev.Registers[rIOPOL], qt.Equals, uint8(0b10))
+	c.Assert(fdev.Registers[rGPPU], qt.Equals, uint8(0b10))
+
+	// Check that changing a pin in port B works too.
+	err = dev.Pin(8).SetMode(Output)
+	c.Assert(err, qt.IsNil)
+	c.Assert(fdev.Registers[rIODIR], qt.Equals, uint8(0b11111011))
+	c.Assert(fdev.Registers[rIODIR|portB], qt.Equals, uint8(0b11111110))
+	c.Assert(fdev.Registers[rIOPOL], qt.Equals, uint8(0b10))
+	c.Assert(fdev.Registers[rIOPOL|portB], qt.Equals, uint8(0))
+	c.Assert(fdev.Registers[rGPPU], qt.Equals, uint8(0b10))
+	c.Assert(fdev.Registers[rGPPU|portB], qt.Equals, uint8(0))
+}
+
+func TestPins(t *testing.T) {
+	c := qt.New(t)
+	var p Pins
+	p.Set(1, true)
+	c.Assert(p, qt.Equals, Pins(0b10))
+	c.Assert(p.Get(1), qt.Equals, true)
+	c.Assert(p.Get(0), qt.Equals, false)
+	c.Assert(p.Get(16), qt.Equals, false)
+	p.High(2)
+	c.Assert(p, qt.Equals, Pins(0b110))
+	p.Low(1)
+	c.Assert(p, qt.Equals, Pins(0b100))
+}
+
+func TestInitWithError(t *testing.T) {
+	c := qt.New(t)
+	bus := tester.NewI2CBus(c)
+	fdev := newDevice(bus, 0x20)
+	fdev.Err = fmt.Errorf("some error")
+	dev, err := NewI2C(bus, 0x20)
+	c.Assert(err, qt.ErrorMatches, `cannot initialize mcp23017 device at 0x20: some error`)
+	c.Assert(dev, qt.IsNil)
+}
+
+func newDevice(bus *tester.I2CBus, addr uint8) *tester.I2CDevice {
+	fdev := bus.NewDevice(addr)
+	// IODIRA and IODIRB are all ones by default.
+	fdev.Registers[rIODIR] = 0xff
+	fdev.Registers[rIODIR|portB] = 0xff
+	return fdev
+}

mcp23017/multidevice.go

@@ -0,0 +1,211 @@
+package mcp23017
+
+// All is a convenience value that represents all pins high (or all mask bits one).
+var All = PinSlice{0xffff}
+
+// Devices holds a slice of devices that can be treated as one
+// contiguous set of devices. Earlier entries in the slice have
+// lower-numbered pins, so index 0 holds pins 0-7, index 1 holds
+// pins 8-15, etc.
+type Devices []*Device
+
+// NewI2CDevices returns a Devices slice holding the Device values
+// for all the given addresses on the given bus.
+// When more than one bus is in use, create the slice yourself.
+func NewI2CDevices(bus I2C, addrs ...uint8) (Devices, error) {
+	devs := make(Devices, len(addrs))
+	for i, addr := range addrs {
+		dev, err := NewI2C(bus, addr)
+		if err != nil {
+			// TODO return a more informative error.
+			return nil, err
+		}
+		devs[i] = dev
+	}
+	return devs, nil
+}
+
+// SetModes sets the pin modes of all the pins on all the devices in devs.
+// If there are less entries in modes than there are pins, the
+// last entry is replicated to all of them (or PinMode(0) if modes
+// is empty).
+func (devs Devices) SetModes(modes []PinMode) error {
+	var defaultModes []PinMode
+	if len(modes) > 0 {
+		defaultModes = modes[len(modes)-1:]
+	}
+	for i, dev := range devs {
+		pinStart := i * PinCount
+		var devModes []PinMode
+		if pinStart < len(modes) {
+			devModes = modes[pinStart:]
+		} else {
+			devModes = defaultModes
+		}
+		if err := dev.SetModes(devModes); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// GetModes gets the pin modes from the devices.
+// It's OK if modes isn't the same length as all the pins:
+// extra entries will be left unchanged.
+func (devs Devices) GetModes(modes []PinMode) error {
+	for i, dev := range devs {
+		pinStart := i * PinCount
+		if pinStart >= len(modes) {
+			break
+		}
+		if err := dev.GetModes(modes[pinStart:]); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// Pin returns the pin for the given number.
+func (devs Devices) Pin(pin int) Pin {
+	if pin < 0 || pin >= len(devs)*PinCount {
+		panic("pin out of range")
+	}
+	return devs[pin/PinCount].Pin(pin % PinCount)
+}
+
+// GetPins returns pin values for all the pins.
+func (devs Devices) GetPins(pins PinSlice) error {
+	for i, dev := range devs {
+		if i >= len(pins) {
+			break
+		}
+		devPins, err := dev.GetPins()
+		if err != nil {
+			return err
+		}
+		pins[i] = devPins
+	}
+	return nil
+}
+
+// SetPins sets all the pins for which mask is high
+// to their respective values in pins.
+//
+// That is, it does the equivalent of:
+//
+// 	for i := 0; i < PinCount*len(devs); i++ {
+//		if mask.Get(i) {
+//			d.Pin(i).Set(pins.Get(i))
+//		}
+//	}
+func (devs Devices) SetPins(pins, mask PinSlice) error {
+	defaultPins := pins.extra()
+	defaultMask := mask.extra()
+	for i, dev := range devs {
+		devPins := defaultPins
+		if i < len(pins) {
+			devPins = pins[i]
+		}
+		devMask := defaultMask
+		if i < len(mask) {
+			devMask = mask[i]
+		}
+		if err := dev.SetPins(devPins, devMask); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// TogglePins inverts the values on all pins for
+// which mask is high.
+func (devs Devices) TogglePins(mask PinSlice) error {
+	defaultMask := mask.extra()
+	for i, dev := range devs {
+		devMask := defaultMask
+		if i < len(mask) {
+			devMask = mask[i]
+		}
+		if err := dev.TogglePins(devMask); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// PinSlice represents an arbitrary nunber of pins, each element corresponding
+// to the pins for one device. The value of the highest numbered pin in the
+// slice is extended to all other pins beyond the end of the slice.
+type PinSlice []Pins
+
+// Get returns the value for the given pin. If the length of pins is too short
+// for the pin number, the value of the highest available pin is returned.
+// That is, the highest numbered pin in the last element of pins
+// is effectively replicated to all other elements.
+//
+// This means that PinSlice{} means "all pins high" and
+// PinSlice{0xffff} means "all pins low".
+func (pins PinSlice) Get(i int) bool {
+	if len(pins) == 0 || i < 0 {
+		return false
+	}
+	if i >= len(pins)*PinCount {
+		return pins[len(pins)-1].Get(PinCount - 1)
+	}
+	return pins[i/PinCount].Get(i % PinCount)
+}
+
+// Set sets the value for the given pin.
+func (pins PinSlice) Set(i int, value bool) {
+	pins[i/PinCount].Set(i%PinCount, value)
+}
+
+// High is short for p.Set(pin, true).
+func (pins PinSlice) High(pin int) {
+	pins[pin/PinCount].High(pin % PinCount)
+}
+
+// High is short for p.Set(pin, false).
+func (pins PinSlice) Low(pin int) {
+	pins[pin/PinCount].Low(pin % PinCount)
+}
+
+// Toggle inverts the value of the given pin.
+func (pins PinSlice) Toggle(pin int) {
+	pins[pin/PinCount].Toggle(pin % PinCount)
+}
+
+// Ensure checks that pins has enough space to store
+// at least length pins. If it does, it returns pins unchanged.
+// Otherwise, it returns pins with elements appended as needed,
+// populating additonal elements by replicating the
+// highest pin (mirroring the behavior of PinSlice.Get).
+func (pins PinSlice) Ensure(length int) PinSlice {
+	if length == 0 {
+		return pins
+	}
+	n := length/PinCount + 1
+	if len(pins) >= n {
+		return pins
+	}
+	// TODO we could potentially make use of additional
+	// extra capacity in pins when available instead
+	// of allocating a new slice always.
+	newPins := make(PinSlice, n)
+	copy(newPins, pins)
+	if extend := pins.extra(); extend != 0 {
+		for i := len(pins); i < n; i++ {
+			newPins[i] = extend
+		}
+	}
+	return newPins
+}
+
+// extra returns the value of implied extra elements beyond
+// the end of pins.
+func (pins PinSlice) extra() Pins {
+	if len(pins) == 0 || !pins[len(pins)-1].Get(PinCount-1) {
+		return 0
+	}
+	return ^Pins(0)
+}

mcp23017/multidevice_test.go

@@ -0,0 +1,190 @@
+package mcp23017
+
+import (
+	"testing"
+
+	qt "github.com/frankban/quicktest"
+
+	"tinygo.org/x/drivers/tester"
+)
+
+func TestDevicesGetPins(t *testing.T) {
+	c := qt.New(t)
+	bus := tester.NewI2CBus(c)
+	fdev0 := newDevice(bus, 0x20)
+	fdev1 := newDevice(bus, 0x21)
+	fdev0.Registers[rGPIO] = 0b10101100
+	fdev0.Registers[rGPIO|portB] = 0b01010011
+	fdev1.Registers[rGPIO] = 0b10101101
+	fdev1.Registers[rGPIO|portB] = 0b01010010
+	devs, err := NewI2CDevices(bus, 0x20, 0x21)
+	c.Assert(err, qt.IsNil)
+	pins := make(PinSlice, 2)
+	err = devs.GetPins(pins)
+	c.Assert(err, qt.IsNil)
+	c.Assert(pins, qt.DeepEquals, PinSlice{0b01010011_10101100, 0b01010010_10101101})
+
+	// It's OK to pass less elements than there are devices.
+	pins = make(PinSlice, 1)
+	err = devs.GetPins(pins)
+	c.Assert(err, qt.IsNil)
+	c.Assert(pins, qt.DeepEquals, PinSlice{0b01010011_10101100})
+}
+
+func TestDevicesSetPinsAllOff(t *testing.T) {
+	c := qt.New(t)
+	bus := tester.NewI2CBus(c)
+	fdev0 := newDevice(bus, 0x20)
+	fdev1 := newDevice(bus, 0x21)
+	fdev0.Registers[rGPIO] = 0b10101100
+	fdev0.Registers[rGPIO|portB] = 0b01010011
+	fdev1.Registers[rGPIO] = 0b10101101
+	fdev1.Registers[rGPIO|portB] = 0b01010010
+	devs, err := NewI2CDevices(bus, 0x20, 0x21)
+	c.Assert(err, qt.IsNil)
+
+	err = devs.SetPins(nil, PinSlice{0xffff})
+	c.Assert(err, qt.IsNil)
+	pins := make(PinSlice, 2)
+	err = devs.GetPins(pins)
+	c.Assert(err, qt.IsNil)
+	c.Assert(pins, qt.DeepEquals, PinSlice{0, 0})
+}
+
+func TestDevicesSetPinsAllOn(t *testing.T) {
+	c := qt.New(t)
+	bus := tester.NewI2CBus(c)
+	fdev0 := newDevice(bus, 0x20)
+	fdev1 := newDevice(bus, 0x21)
+	fdev0.Registers[rGPIO] = 0b10101100
+	fdev0.Registers[rGPIO|portB] = 0b01010011
+	fdev1.Registers[rGPIO] = 0b10101101
+	fdev1.Registers[rGPIO|portB] = 0b01010010
+	devs, err := NewI2CDevices(bus, 0x20, 0x21)
+	c.Assert(err, qt.IsNil)
+
+	err = devs.SetPins(PinSlice{0xffff}, PinSlice{0xffff})
+	c.Assert(err, qt.IsNil)
+	pins := make(PinSlice, 2)
+	err = devs.GetPins(pins)
+	c.Assert(err, qt.IsNil)
+	c.Assert(pins, qt.DeepEquals, PinSlice{0xffff, 0xffff})
+}
+
+func TestDevicesSetPinsMask(t *testing.T) {
+	c := qt.New(t)
+	bus := tester.NewI2CBus(c)
+	fdev0 := newDevice(bus, 0x20)
+	fdev1 := newDevice(bus, 0x21)
+	fdev0.Registers[rGPIO] = 0b10101100
+	fdev0.Registers[rGPIO|portB] = 0b01010011
+	fdev1.Registers[rGPIO] = 0b10101101
+	fdev1.Registers[rGPIO|portB] = 0b01010010
+	devs, err := NewI2CDevices(bus, 0x20, 0x21)
+	c.Assert(err, qt.IsNil)
+
+	// Sanity check the original value of the pins.
+	pins := make(PinSlice, 2)
+	err = devs.GetPins(pins)
+	c.Assert(err, qt.IsNil)
+	c.Assert(pins, qt.DeepEquals, PinSlice{0b01010011_10101100, 0b01010010_10101101})
+
+	pins = make(PinSlice, 2)
+	pins.High(0)
+	pins.High(1)
+	mask := make(PinSlice, 2)
+	mask.High(0)
+	mask.High(16)
+
+	err = devs.SetPins(pins, mask)
+	c.Assert(err, qt.IsNil)
+	pins = make(PinSlice, 2)
+	err = devs.GetPins(pins)
+	c.Assert(err, qt.IsNil)
+	c.Assert(pins, qt.DeepEquals, PinSlice{0b01010011_10101101, 0b01010010_10101100})
+}
+
+func TestDevicesTogglePins(t *testing.T) {
+	c := qt.New(t)
+	bus := tester.NewI2CBus(c)
+	newDevice(bus, 0x20)
+	newDevice(bus, 0x21)
+	devs, err := NewI2CDevices(bus, 0x20, 0x21)
+	c.Assert(err, qt.IsNil)
+
+	mask := make(PinSlice, 2)
+	mask.High(0)
+	mask.High(16)
+
+	err = devs.TogglePins(mask)
+	c.Assert(err, qt.IsNil)
+	pins := make(PinSlice, 2)
+	err = devs.GetPins(pins)
+	c.Assert(err, qt.IsNil)
+	c.Assert(pins, qt.DeepEquals, PinSlice{0b00000000_00000001, 0b00000000_00000001})
+}
+
+func TestDevicesSetGetModes(t *testing.T) {
+	c := qt.New(t)
+	bus := tester.NewI2CBus(c)
+	fdev0 := newDevice(bus, 0x20)
+	fdev1 := newDevice(bus, 0x21)
+	devs, err := NewI2CDevices(bus, 0x20, 0x21)
+	c.Assert(err, qt.IsNil)
+	// Sanity check that IODIR registers start off all ones.
+	c.Assert(fdev0.Registers[rIODIR], qt.Equals, uint8(0xff))
+
+	// The last entry is replicated to fill them all.
+	err = devs.SetModes([]PinMode{Input | Pullup, Output})
+	c.Assert(err, qt.IsNil)
+	c.Assert(fdev0.Registers[rIODIR], qt.Equals, uint8(1))
+	c.Assert(fdev0.Registers[rIODIR|portB], qt.Equals, uint8(0))
+	c.Assert(fdev1.Registers[rIODIR], qt.Equals, uint8(0))
+	c.Assert(fdev1.Registers[rIODIR|portB], qt.Equals, uint8(0))
+
+	modes := make([]PinMode, 2)
+	err = devs.GetModes(modes)
+	c.Assert(err, qt.Equals, nil)
+	c.Assert(modes, qt.DeepEquals, []PinMode{Input | Pullup, Output})
+
+	// It's OK to pass a smaller slice to GetModes.
+	modes = make([]PinMode, 1)
+	err = devs.GetModes(modes)
+	c.Assert(err, qt.Equals, nil)
+	c.Assert(modes, qt.DeepEquals, []PinMode{Input | Pullup})
+}
+
+func TestDevicesPin(t *testing.T) {
+	c := qt.New(t)
+	bus := tester.NewI2CBus(c)
+	newDevice(bus, 0x20)
+	fdev1 := newDevice(bus, 0x21)
+	devs, err := NewI2CDevices(bus, 0x20, 0x21)
+	c.Assert(err, qt.IsNil)
+	pin := devs.Pin(16)
+	v, err := pin.Get()
+	c.Assert(err, qt.Equals, nil)
+	c.Assert(v, qt.Equals, false)
+	err = pin.High()
+	c.Assert(err, qt.Equals, nil)
+	c.Assert(fdev1.Registers[rGPIO], qt.Equals, uint8(1))
+}
+
+func TestPinSlice(t *testing.T) {
+	c := qt.New(t)
+	pins := PinSlice(nil).Ensure(20)
+	pins.Set(16, true)
+	c.Assert(pins, qt.DeepEquals, PinSlice{0, 1})
+	pins.Set(31, true)
+	c.Assert(pins, qt.DeepEquals, PinSlice{0, 0b10000000_00000001})
+	c.Assert(pins.Get(0), qt.Equals, false)
+	c.Assert(pins.Get(16), qt.Equals, true)
+	pins = pins.Ensure(40)
+	c.Assert(pins, qt.DeepEquals, PinSlice{0, 0b10000000_00000001, 0xffff})
+	pins.Low(16)
+	c.Assert(pins.Get(16), qt.Equals, false)
+	pins.High(16)
+	c.Assert(pins.Get(16), qt.Equals, true)
+	pins.Toggle(16)
+	c.Assert(pins.Get(16), qt.Equals, false)
+}

mcp3008/mcp3008.go

@@ -7,11 +7,13 @@ package mcp3008 // import "tinygo.org/x/drivers/mcp3008"
 import (
 	"errors"
 	"machine"
+
+	"tinygo.org/x/drivers"
 )
 
 // Device wraps MCP3008 SPI ADC.
 type Device struct {
-	bus machine.SPI
+	bus drivers.SPI
 	cs  machine.Pin
 	tx  []byte
 	rx  []byte
@@ -32,7 +34,7 @@ type ADCPin struct {
 }
 
 // New returns a new MCP3008 driver. Pass in a fully configured SPI bus.
-func New(b machine.SPI, csPin machine.Pin) *Device {
+func New(b drivers.SPI, csPin machine.Pin) *Device {
 	d := &Device{bus: b,
 		cs: csPin,
 		tx: make([]byte, 3),

microbitmatrix/microbitmatrix-v1.go

@@ -0,0 +1,112 @@
+// +build microbit
+
+// Package microbitmatrix implements a driver for the BBC micro:bit's LED matrix.
+//
+// Schematic: https://github.com/bbcmicrobit/hardware/blob/master/SCH_BBC-Microbit_V1.3B.pdf
+//
+package microbitmatrix // import "tinygo.org/x/drivers/microbitmatrix"
+
+import (
+	"machine"
+	"time"
+)
+
+var matrixRotations = [4][5][5][2]uint8{
+	{ // 0
+		{{0, 0}, {1, 3}, {0, 1}, {1, 4}, {0, 2}},
+		{{2, 3}, {2, 4}, {2, 5}, {2, 6}, {2, 7}},
+		{{1, 1}, {0, 8}, {1, 2}, {2, 8}, {1, 0}},
+		{{0, 7}, {0, 6}, {0, 5}, {0, 4}, {0, 3}},
+		{{2, 2}, {1, 6}, {2, 0}, {1, 5}, {2, 1}},
+	},
+	{ // 90 CCW
+		{{0, 2}, {2, 7}, {1, 0}, {0, 3}, {2, 1}},
+		{{1, 4}, {2, 6}, {2, 8}, {0, 4}, {1, 5}},
+		{{0, 1}, {2, 5}, {1, 2}, {0, 5}, {2, 0}},
+		{{1, 3}, {2, 4}, {0, 8}, {0, 6}, {1, 6}},
+		{{0, 0}, {2, 3}, {1, 1}, {0, 7}, {2, 2}},
+	},
+	{ // 180
+		{{2, 1}, {1, 5}, {2, 0}, {1, 6}, {2, 2}},
+		{{0, 3}, {0, 4}, {0, 5}, {0, 6}, {0, 7}},
+		{{1, 0}, {2, 8}, {1, 2}, {0, 8}, {1, 1}},
+		{{2, 7}, {2, 6}, {2, 5}, {2, 4}, {2, 3}},
+		{{0, 2}, {1, 4}, {0, 1}, {1, 3}, {0, 0}},
+	},
+	{ // 270
+		{{2, 2}, {0, 7}, {1, 1}, {2, 3}, {0, 0}},
+		{{1, 6}, {0, 6}, {0, 8}, {2, 4}, {1, 3}},
+		{{2, 0}, {0, 5}, {1, 2}, {2, 5}, {0, 1}},
+		{{1, 5}, {0, 4}, {2, 8}, {2, 6}, {1, 4}},
+		{{2, 1}, {0, 3}, {1, 0}, {2, 7}, {0, 2}},
+	},
+}
+
+type Device struct {
+	pin      [12]machine.Pin
+	buffer   [3][9]bool
+	rotation uint8
+}
+
+// Configure sets up the device.
+func (d *Device) Configure(cfg Config) {
+	d.SetRotation(cfg.Rotation)
+
+	for i := machine.LED_COL_1; i <= machine.LED_ROW_3; i++ {
+		d.pin[i-machine.LED_COL_1] = i
+		d.pin[i-machine.LED_COL_1].Configure(machine.PinConfig{Mode: machine.PinOutput})
+	}
+	d.ClearDisplay()
+	d.DisableAll()
+}
+
+// Display sends the buffer (if any) to the screen.
+func (d *Device) Display() error {
+	for row := 0; row < 3; row++ {
+		d.DisableAll()
+		d.pin[9+row].High()
+
+		for col := 0; col < 9; col++ {
+			if d.buffer[row][col] {
+				d.pin[col].Low()
+			}
+
+		}
+		time.Sleep(time.Millisecond * 2)
+	}
+	return nil
+}
+
+// ClearDisplay erases the internal buffer
+func (d *Device) ClearDisplay() {
+	for row := 0; row < 3; row++ {
+		for col := 0; col < 9; col++ {
+			d.buffer[row][col] = false
+		}
+	}
+}
+
+// DisableAll disables all the LEDs without modifying the buffer
+func (d *Device) DisableAll() {
+	for i := machine.LED_COL_1; i <= machine.LED_COL_9; i++ {
+		d.pin[i-machine.LED_COL_1].High()
+	}
+	for i := machine.LED_ROW_1; i <= machine.LED_ROW_3; i++ {
+		d.pin[i-machine.LED_COL_1].Low()
+	}
+}
+
+// EnableAll enables all the LEDs without modifying the buffer
+func (d *Device) EnableAll() {
+	for i := machine.LED_COL_1; i <= machine.LED_COL_9; i++ {
+		d.pin[i-machine.LED_COL_1].Low()
+	}
+	for i := machine.LED_ROW_1; i <= machine.LED_ROW_3; i++ {
+		d.pin[i-machine.LED_COL_1].High()
+	}
+}
+
+// Size returns the current size of the display.
+func (d *Device) Size() (w, h int16) {
+	return 5, 5
+}

microbitmatrix/microbitmatrix-v2.go

@@ -0,0 +1,122 @@
+// +build microbit_v2
+
+// Package microbitmatrix implements a driver for the BBC micro:bit version 2 LED matrix.
+//
+// Schematic:
+//
+package microbitmatrix // import "tinygo.org/x/drivers/microbitmatrix"
+
+import (
+	"machine"
+	"time"
+)
+
+var matrixRotations = [4][5][5][2]uint8{
+	{ // 0
+		{{0, 0}, {1, 0}, {2, 0}, {3, 0}, {4, 0}},
+		{{0, 1}, {1, 1}, {2, 1}, {3, 1}, {4, 1}},
+		{{0, 2}, {1, 2}, {2, 2}, {3, 2}, {4, 2}},
+		{{0, 3}, {1, 3}, {2, 3}, {3, 3}, {4, 3}},
+		{{0, 4}, {1, 4}, {2, 4}, {3, 4}, {4, 4}},
+	},
+	{ // 90 CCW
+		{{4, 0}, {4, 1}, {4, 2}, {4, 3}, {4, 4}},
+		{{3, 0}, {3, 1}, {3, 2}, {3, 3}, {3, 4}},
+		{{2, 0}, {2, 1}, {2, 2}, {2, 3}, {2, 4}},
+		{{1, 0}, {1, 1}, {1, 2}, {1, 3}, {1, 4}},
+		{{0, 0}, {0, 1}, {0, 2}, {0, 3}, {0, 4}},
+	},
+	{ // 180
+		{{4, 4}, {3, 4}, {2, 4}, {1, 4}, {0, 4}},
+		{{4, 3}, {3, 3}, {2, 3}, {1, 3}, {0, 3}},
+		{{4, 2}, {3, 2}, {2, 2}, {1, 2}, {0, 2}},
+		{{4, 1}, {3, 1}, {2, 1}, {1, 1}, {0, 1}},
+		{{4, 0}, {3, 0}, {2, 0}, {1, 0}, {0, 0}},
+	},
+	{ // 270
+		{{0, 4}, {0, 3}, {0, 2}, {0, 1}, {0, 0}},
+		{{1, 4}, {1, 3}, {1, 2}, {1, 1}, {1, 0}},
+		{{2, 4}, {2, 3}, {2, 2}, {2, 1}, {2, 0}},
+		{{3, 4}, {3, 3}, {3, 2}, {3, 1}, {3, 0}},
+		{{4, 4}, {4, 3}, {4, 2}, {4, 1}, {4, 0}},
+	},
+}
+
+type Device struct {
+	pin      [10]machine.Pin
+	buffer   [5][5]bool
+	rotation uint8
+}
+
+// Configure sets up the device.
+func (d *Device) Configure(cfg Config) {
+	d.SetRotation(cfg.Rotation)
+
+	d.pin[0] = machine.LED_COL_1
+	d.pin[1] = machine.LED_COL_2
+	d.pin[2] = machine.LED_COL_3
+	d.pin[3] = machine.LED_COL_4
+	d.pin[4] = machine.LED_COL_5
+
+	d.pin[5] = machine.LED_ROW_1
+	d.pin[6] = machine.LED_ROW_2
+	d.pin[7] = machine.LED_ROW_3
+	d.pin[8] = machine.LED_ROW_4
+	d.pin[9] = machine.LED_ROW_5
+
+	for i := 0; i < 10; i++ {
+		d.pin[i].Configure(machine.PinConfig{Mode: machine.PinOutput})
+	}
+
+	d.ClearDisplay()
+	d.DisableAll()
+}
+
+// Display sends the buffer (if any) to the screen.
+func (d *Device) Display() error {
+	for x := 0; x < 5; x++ {
+		d.DisableAll()
+		d.pin[x].Low()
+
+		for y := 0; y < 5; y++ {
+			if d.buffer[x][y] {
+				d.pin[5+y].High()
+			} else {
+				d.pin[5+y].Low()
+			}
+
+		}
+		time.Sleep(time.Millisecond * 4)
+	}
+	return nil
+}
+
+// ClearDisplay erases the internal buffer
+func (d *Device) ClearDisplay() {
+	for row := 0; row < 5; row++ {
+		for col := 0; col < 5; col++ {
+			d.buffer[row][col] = false
+		}
+	}
+}
+
+// DisableAll disables all the LEDs without modifying the buffer
+func (d *Device) DisableAll() {
+	for i := 0; i < 5; i++ {
+		d.pin[i].High()
+		d.pin[5+i].Low()
+	}
+}
+
+// EnableAll enables all the LEDs without modifying the buffer
+func (d *Device) EnableAll() {
+	for i := 0; i < 5; i++ {
+		d.pin[i].Low()
+		d.pin[5+i].High()
+	}
+}
+
+// Size returns the current size of the display.
+func (d *Device) Size() (w, h int16) {
+	return 5, 5
+}

microbitmatrix/microbitmatrix.go

@@ -6,68 +6,17 @@ package microbitmatrix // import "tinygo.org/x/drivers/microbitmatrix"
 
 import (
 	"image/color"
-	"machine"
-	"time"
 )
 
-var matrixRotations = [4][5][5][2]uint8{
-	{ // 0
-		{{0, 0}, {1, 3}, {0, 1}, {1, 4}, {0, 2}},
-		{{2, 3}, {2, 4}, {2, 5}, {2, 6}, {2, 7}},
-		{{1, 1}, {0, 8}, {1, 2}, {2, 8}, {1, 0}},
-		{{0, 7}, {0, 6}, {0, 5}, {0, 4}, {0, 3}},
-		{{2, 2}, {1, 6}, {2, 0}, {1, 5}, {2, 1}},
-	},
-	{ // 90 CCW
-		{{0, 2}, {2, 7}, {1, 0}, {0, 3}, {2, 1}},
-		{{1, 4}, {2, 6}, {2, 8}, {0, 4}, {1, 5}},
-		{{0, 1}, {2, 5}, {1, 2}, {0, 5}, {2, 0}},
-		{{1, 3}, {2, 4}, {0, 8}, {0, 6}, {1, 6}},
-		{{0, 0}, {2, 3}, {1, 1}, {0, 7}, {2, 2}},
-	},
-	{ // 180
-		{{2, 1}, {1, 5}, {2, 0}, {1, 6}, {2, 2}},
-		{{0, 3}, {0, 4}, {0, 5}, {0, 6}, {0, 7}},
-		{{1, 0}, {2, 8}, {1, 2}, {0, 8}, {1, 1}},
-		{{2, 7}, {2, 6}, {2, 5}, {2, 4}, {2, 3}},
-		{{0, 2}, {1, 4}, {0, 1}, {1, 3}, {0, 0}},
-	},
-	{ // 270
-		{{2, 2}, {0, 7}, {1, 1}, {2, 3}, {0, 0}},
-		{{1, 6}, {0, 6}, {0, 8}, {2, 4}, {1, 3}},
-		{{2, 0}, {0, 5}, {1, 2}, {2, 5}, {0, 1}},
-		{{1, 5}, {0, 4}, {2, 8}, {2, 6}, {1, 4}},
-		{{2, 1}, {0, 3}, {1, 0}, {2, 7}, {0, 2}},
-	},
-}
-
 type Config struct {
 	Rotation uint8
 }
 
-type Device struct {
-	pin      [12]machine.Pin
-	buffer   [3][9]bool
-	rotation uint8
-}
-
 // New returns a new microbitmatrix driver.
 func New() Device {
 	return Device{}
 }
 
-// Configure sets up the device.
-func (d *Device) Configure(cfg Config) {
-	d.SetRotation(cfg.Rotation)
-
-	for i := machine.LED_COL_1; i <= machine.LED_ROW_3; i++ {
-		d.pin[i-machine.LED_COL_1] = i
-		d.pin[i-machine.LED_COL_1].Configure(machine.PinConfig{Mode: machine.PinOutput})
-	}
-	d.ClearDisplay()
-	d.DisableAll()
-}
-
 // SetRotation changes the rotation of the LED matrix
 func (d *Device) SetRotation(rotation uint8) {
 	d.rotation = rotation % 4
@@ -92,54 +41,3 @@ func (d *Device) GetPixel(x int16, y int16) bool {
 	}
 	return d.buffer[matrixRotations[d.rotation][x][y][0]][matrixRotations[d.rotation][x][y][1]]
 }
-
-// Display sends the buffer (if any) to the screen.
-func (d *Device) Display() error {
-	for row := 0; row < 3; row++ {
-		d.DisableAll()
-		d.pin[9+row].High()
-
-		for col := 0; col < 9; col++ {
-			if d.buffer[row][col] {
-				d.pin[col].Low()
-			}
-
-		}
-		time.Sleep(time.Millisecond * 2)
-	}
-	return nil
-}
-
-// ClearDisplay erases the internal buffer
-func (d *Device) ClearDisplay() {
-	for row := 0; row < 3; row++ {
-		for col := 0; col < 9; col++ {
-			d.buffer[row][col] = false
-		}
-	}
-}
-
-// DisableAll disables all the LEDs without modifying the buffer
-func (d *Device) DisableAll() {
-	for i := machine.LED_COL_1; i <= machine.LED_COL_9; i++ {
-		d.pin[i-machine.LED_COL_1].High()
-	}
-	for i := machine.LED_ROW_1; i <= machine.LED_ROW_3; i++ {
-		d.pin[i-machine.LED_COL_1].Low()
-	}
-}
-
-// EnableAll enables all the LEDs without modifying the buffer
-func (d *Device) EnableAll() {
-	for i := machine.LED_COL_1; i <= machine.LED_COL_9; i++ {
-		d.pin[i-machine.LED_COL_1].Low()
-	}
-	for i := machine.LED_ROW_1; i <= machine.LED_ROW_3; i++ {
-		d.pin[i-machine.LED_COL_1].High()
-	}
-}
-
-// Size returns the current size of the display.
-func (d *Device) Size() (w, h int16) {
-	return 5, 5
-}

mma8653/mma8653.go

@@ -6,13 +6,11 @@
 //
 package mma8653 // import "tinygo.org/x/drivers/mma8653"
 
-import (
-	"machine"
-)
+import "tinygo.org/x/drivers"
 
 // Device wraps an I2C connection to a MMA8653 device.
 type Device struct {
-	bus         machine.I2C
+	bus         drivers.I2C
 	Address     uint16
 	sensitivity Sensitivity
 }
@@ -21,7 +19,7 @@ type Device struct {
 // configured.
 //
 // This function only creates the Device object, it does not touch the device.
-func New(bus machine.I2C) Device {
+func New(bus drivers.I2C) Device {
 	return Device{bus, Address, Sensitivity2G}
 }
 

mpu6050/mpu6050.go

@@ -7,13 +7,11 @@
 //
 package mpu6050 // import "tinygo.org/x/drivers/mpu6050"
 
-import (
-	"machine"
-)
+import "tinygo.org/x/drivers"
 
 // Device wraps an I2C connection to a MPU6050 device.
 type Device struct {
-	bus     machine.I2C
+	bus     drivers.I2C
 	Address uint16
 }
 
@@ -21,7 +19,7 @@ type Device struct {
 // configured.
 //
 // This function only creates the Device object, it does not touch the device.
-func New(bus machine.I2C) Device {
+func New(bus drivers.I2C) Device {
 	return Device{bus, Address}
 }
 

pcd8544/pcd8544.go

@@ -9,11 +9,13 @@ import (
 	"image/color"
 	"machine"
 	"time"
+
+	"tinygo.org/x/drivers"
 )
 
 // Device wraps an SPI connection.
 type Device struct {
-	bus        machine.SPI
+	bus        drivers.SPI
 	dcPin      machine.Pin
 	rstPin     machine.Pin
 	scePin     machine.Pin
@@ -29,7 +31,7 @@ type Config struct {
 }
 
 // New creates a new PCD8544 connection. The SPI bus must already be configured.
-func New(bus machine.SPI, dcPin, rstPin, scePin machine.Pin) *Device {
+func New(bus drivers.SPI, dcPin, rstPin, scePin machine.Pin) *Device {
 	return &Device{
 		bus:    bus,
 		dcPin:  dcPin,

sht3x/sht3x.go

@@ -7,13 +7,14 @@
 package sht3x // import "tinygo.org/x/drivers/sht3x"
 
 import (
-	"machine"
 	"time"
+
+	"tinygo.org/x/drivers"
 )
 
 // Device wraps an I2C connection to a SHT31 device.
 type Device struct {
-	bus     machine.I2C
+	bus     drivers.I2C
 	Address uint16
 }
 
@@ -22,7 +23,7 @@ type Device struct {
 //
 // This function only creates the Device object, it does not initialize the device.
 // You must call Configure() first in order to use the device itself.
-func New(bus machine.I2C) Device {
+func New(bus drivers.I2C) Device {
 	return Device{
 		bus:     bus,
 		Address: AddressA,

spi.go

@@ -0,0 +1,13 @@
+package drivers
+
+// SPI represents a SPI bus. It is implemented by the machine.SPI type.
+type SPI interface {
+	// Tx transmits the given buffer w and receives at the same time the buffer r.
+	// The two buffers must be the same length. The only exception is when w or r are nil,
+	// in which case Tx only transmits (without receiving) or only receives (while sending 0 bytes).
+	Tx(w, r []byte) error
+
+	// Transfer writes a single byte out on the SPI bus and receives a byte at the same time.
+	// If you want to transfer multiple bytes, it is more efficient to use Tx instead.
+	Transfer(b byte) (byte, error)
+}

ssd1306/ssd1306.go

@@ -9,6 +9,8 @@ import (
 	"image/color"
 	"machine"
 	"time"
+
+	"tinygo.org/x/drivers"
 )
 
 // Device wraps an SPI connection.
@@ -30,12 +32,12 @@ type Config struct {
 }
 
 type I2CBus struct {
-	wire    machine.I2C
+	wire    drivers.I2C
 	Address uint16
 }
 
 type SPIBus struct {
-	wire     machine.SPI
+	wire     drivers.SPI
 	dcPin    machine.Pin
 	resetPin machine.Pin
 	csPin    machine.Pin
@@ -50,7 +52,7 @@ type Buser interface {
 type VccMode uint8
 
 // NewI2C creates a new SSD1306 connection. The I2C wire must already be configured.
-func NewI2C(bus machine.I2C) Device {
+func NewI2C(bus drivers.I2C) Device {
 	return Device{
 		bus: &I2CBus{
 			wire:    bus,
@@ -60,7 +62,7 @@ func NewI2C(bus machine.I2C) Device {
 }
 
 // NewSPI creates a new SSD1306 connection. The SPI wire must already be configured.
-func NewSPI(bus machine.SPI, dcPin, resetPin, csPin machine.Pin) Device {
+func NewSPI(bus drivers.SPI, dcPin, resetPin, csPin machine.Pin) Device {
 	dcPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
 	resetPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
 	csPin.Configure(machine.PinConfig{Mode: machine.PinOutput})

ssd1331/ssd1331.go

@@ -10,6 +10,8 @@ import (
 
 	"errors"
 	"time"
+
+	"tinygo.org/x/drivers"
 )
 
 type Model uint8
@@ -17,7 +19,7 @@ type Rotation uint8
 
 // Device wraps an SPI connection.
 type Device struct {
-	bus         machine.SPI
+	bus         drivers.SPI
 	dcPin       machine.Pin
 	resetPin    machine.Pin
 	csPin       machine.Pin
@@ -35,7 +37,7 @@ type Config struct {
 }
 
 // New creates a new SSD1331 connection. The SPI wire must already be configured.
-func New(bus machine.SPI, resetPin, dcPin, csPin machine.Pin) Device {
+func New(bus drivers.SPI, resetPin, dcPin, csPin machine.Pin) Device {
 	dcPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
 	resetPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
 	csPin.Configure(machine.PinConfig{Mode: machine.PinOutput})

ssd1351/ssd1351.go

@@ -9,6 +9,8 @@ import (
 	"image/color"
 	"machine"
 	"time"
+
+	"tinygo.org/x/drivers"
 )
 
 var (
@@ -18,7 +20,7 @@ var (
 
 // Device wraps an SPI connection.
 type Device struct {
-	bus          machine.SPI
+	bus          drivers.SPI
 	dcPin        machine.Pin
 	resetPin     machine.Pin
 	csPin        machine.Pin
@@ -40,7 +42,7 @@ type Config struct {
 }
 
 // New creates a new SSD1351 connection. The SPI wire must already be configured.
-func New(bus machine.SPI, resetPin, dcPin, csPin, enPin, rwPin machine.Pin) Device {
+func New(bus drivers.SPI, resetPin, dcPin, csPin, enPin, rwPin machine.Pin) Device {
 	return Device{
 		bus:      bus,
 		dcPin:    dcPin,

st7735/st7735.go

@@ -10,6 +10,8 @@ import (
 	"time"
 
 	"errors"
+
+	"tinygo.org/x/drivers"
 )
 
 type Model uint8
@@ -17,7 +19,7 @@ type Rotation uint8
 
 // Device wraps an SPI connection.
 type Device struct {
-	bus          machine.SPI
+	bus          drivers.SPI
 	dcPin        machine.Pin
 	resetPin     machine.Pin
 	csPin        machine.Pin
@@ -44,7 +46,7 @@ type Config struct {
 }
 
 // New creates a new ST7735 connection. The SPI wire must already be configured.
-func New(bus machine.SPI, resetPin, dcPin, csPin, blPin machine.Pin) Device {
+func New(bus drivers.SPI, resetPin, dcPin, csPin, blPin machine.Pin) Device {
 	dcPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
 	resetPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
 	csPin.Configure(machine.PinConfig{Mode: machine.PinOutput})

st7789/registers.go

@@ -33,7 +33,9 @@ const (
 	RDID3      = 0xDC
 	RDID4      = 0xDD
 	FRMCTR1    = 0xB1
+	RGBCTRL    = 0xB1
 	FRMCTR2    = 0xB2
+	PORCTRL    = 0xB2
 	FRMCTR3    = 0xB3
 	INVCTR     = 0xB4
 	DISSET5    = 0xB6
@@ -43,12 +45,51 @@ const (
 	PWCTR4     = 0xC3
 	PWCTR5     = 0xC4
 	VMCTR1     = 0xC5
+	FRCTRL2    = 0xC6
 	PWCTR6     = 0xFC
 	GMCTRP1    = 0xE0
 	GMCTRN1    = 0xE1
+	GSCAN      = 0x45
+	VSCRDEF    = 0x33
+	VSCRSADD   = 0x37
 
 	NO_ROTATION  Rotation = 0
 	ROTATION_90  Rotation = 1 // 90 degrees clock-wise rotation
 	ROTATION_180 Rotation = 2
 	ROTATION_270 Rotation = 3
+
+	// Allowable frame rate codes for FRCTRL2 (Identifier is in Hz)
+	FRAMERATE_111 FrameRate = 0x01
+	FRAMERATE_105 FrameRate = 0x02
+	FRAMERATE_99  FrameRate = 0x03
+	FRAMERATE_94  FrameRate = 0x04
+	FRAMERATE_90  FrameRate = 0x05
+	FRAMERATE_86  FrameRate = 0x06
+	FRAMERATE_82  FrameRate = 0x07
+	FRAMERATE_78  FrameRate = 0x08
+	FRAMERATE_75  FrameRate = 0x09
+	FRAMERATE_72  FrameRate = 0x0A
+	FRAMERATE_69  FrameRate = 0x0B
+	FRAMERATE_67  FrameRate = 0x0C
+	FRAMERATE_64  FrameRate = 0x0D
+	FRAMERATE_62  FrameRate = 0x0E
+	FRAMERATE_60  FrameRate = 0x0F // 60 is default
+	FRAMERATE_58  FrameRate = 0x10
+	FRAMERATE_57  FrameRate = 0x11
+	FRAMERATE_55  FrameRate = 0x12
+	FRAMERATE_53  FrameRate = 0x13
+	FRAMERATE_52  FrameRate = 0x14
+	FRAMERATE_50  FrameRate = 0x15
+	FRAMERATE_49  FrameRate = 0x16
+	FRAMERATE_48  FrameRate = 0x17
+	FRAMERATE_46  FrameRate = 0x18
+	FRAMERATE_45  FrameRate = 0x19
+	FRAMERATE_44  FrameRate = 0x1A
+	FRAMERATE_43  FrameRate = 0x1B
+	FRAMERATE_42  FrameRate = 0x1C
+	FRAMERATE_41  FrameRate = 0x1D
+	FRAMERATE_40  FrameRate = 0x1E
+	FRAMERATE_39  FrameRate = 0x1F
+
+	MAX_VSYNC_SCANLINES = 254
 )

st7789/st7789.go

@@ -1,24 +1,33 @@
 // Package st7789 implements a driver for the ST7789 TFT displays, it comes in various screen sizes.
 //
-// Datasheet: https://cdn-shop.adafruit.com/product-files/3787/3787_tft_QT154H2201__________20190228182902.pdf
+// Datasheets: https://cdn-shop.adafruit.com/product-files/3787/3787_tft_QT154H2201__________20190228182902.pdf
+//             http://www.newhavendisplay.com/appnotes/datasheets/LCDs/ST7789V.pdf
 //
 package st7789 // import "tinygo.org/x/drivers/st7789"
 
 import (
 	"image/color"
 	"machine"
+	"math"
 	"time"
 
 	"errors"
+
+	"tinygo.org/x/drivers"
 )
 
+// Rotation controls the rotation used by the display.
 type Rotation uint8
 
+// FrameRate controls the frame rate used by the display.
+type FrameRate uint8
+
 // Device wraps an SPI connection.
 type Device struct {
-	bus             machine.SPI
+	bus             drivers.SPI
 	dcPin           machine.Pin
 	resetPin        machine.Pin
+	csPin           machine.Pin
 	blPin           machine.Pin
 	width           int16
 	height          int16
@@ -27,8 +36,10 @@ type Device struct {
 	columnOffset    int16
 	rowOffset       int16
 	rotation        Rotation
+	frameRate       FrameRate
 	batchLength     int32
 	isBGR           bool
+	vSyncLines      int16
 }
 
 // Config is the configuration for the display
@@ -38,17 +49,21 @@ type Config struct {
 	Rotation     Rotation
 	RowOffset    int16
 	ColumnOffset int16
+	FrameRate    FrameRate
+	VSyncLines   int16
 }
 
 // New creates a new ST7789 connection. The SPI wire must already be configured.
-func New(bus machine.SPI, resetPin, dcPin, blPin machine.Pin) Device {
+func New(bus drivers.SPI, resetPin, dcPin, csPin, blPin machine.Pin) Device {
 	dcPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
 	resetPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	csPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
 	blPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
 	return Device{
 		bus:      bus,
 		dcPin:    dcPin,
 		resetPin: resetPin,
+		csPin:    csPin,
 		blPin:    blPin,
 	}
 }
@@ -65,42 +80,149 @@ func (d *Device) Configure(cfg Config) {
 	} else {
 		d.height = 240
 	}
+
 	d.rotation = cfg.Rotation
 	d.rowOffsetCfg = cfg.RowOffset
 	d.columnOffsetCfg = cfg.ColumnOffset
 
+	if cfg.FrameRate != 0 {
+		d.frameRate = cfg.FrameRate
+	} else {
+		d.frameRate = FRAMERATE_60
+	}
+
+	if cfg.VSyncLines >= 2 && cfg.VSyncLines <= 254 {
+		d.vSyncLines = cfg.VSyncLines
+	} else {
+		d.vSyncLines = 16
+	}
+
 	d.batchLength = int32(d.width)
 	if d.height > d.width {
 		d.batchLength = int32(d.height)
 	}
 	d.batchLength += d.batchLength & 1
 
-	// reset the device
+	// Reset the device
 	d.resetPin.High()
-	time.Sleep(5 * time.Millisecond)
+	time.Sleep(50 * time.Millisecond)
 	d.resetPin.Low()
-	time.Sleep(20 * time.Millisecond)
+	time.Sleep(50 * time.Millisecond)
 	d.resetPin.High()
-	time.Sleep(150 * time.Millisecond)
+	time.Sleep(50 * time.Millisecond)
 
 	// Common initialization
-	d.Command(SWRESET)
-	time.Sleep(150 * time.Millisecond)
-	d.Command(SLPOUT)
-	time.Sleep(500 * time.Millisecond)
-	d.Command(COLMOD)
-	d.Data(0x55)
-	time.Sleep(10 * time.Millisecond)
+	d.Command(SWRESET)                 // Soft reset
+	time.Sleep(150 * time.Millisecond) //
 
-	d.SetRotation(d.rotation)
-	d.InvertColors(true)
+	d.Command(SLPOUT)                  // Exit sleep mode
+	time.Sleep(500 * time.Millisecond) //
 
-	d.Command(NORON)
-	time.Sleep(10 * time.Millisecond)
-	d.Command(DISPON)
-	time.Sleep(500 * time.Millisecond)
+	// Memory initialization
+	d.Command(COLMOD)                 // Set color mode
+	d.Data(0x55)                      //   16-bit color
+	time.Sleep(10 * time.Millisecond) //
 
-	d.blPin.High()
+	d.SetRotation(d.rotation) // Memory orientation
+
+	d.setWindow(0, 0, d.width, d.height)   // Full draw window
+	d.FillScreen(color.RGBA{0, 0, 0, 255}) // Clear screen
+
+	// Framerate
+	d.Command(FRCTRL2)         // Frame rate for normal mode
+	d.Data(uint8(d.frameRate)) // Default is 60Hz
+
+	// Frame vertical sync and "porch"
+	//
+	// Front and back porch controls vertical scanline sync time before and after
+	// a frame, where memory can be safely written without tearing.
+	//
+	fp := uint8(d.vSyncLines / 2)         // Split the desired pause half and half
+	bp := uint8(d.vSyncLines - int16(fp)) // between front and back porch.
+
+	d.Command(PORCTRL)
+	d.Data(bp)   // Back porch 5bit     (0x7F max 0x08 default)
+	d.Data(fp)   // Front porch 5bit    (0x7F max 0x08 default)
+	d.Data(0x00) // Seprarate porch     (TODO: what is this?)
+	d.Data(0x22) // Idle mode porch     (4bit-back 4bit-front 0x22 default)
+	d.Data(0x22) // Partial mode porch  (4bit-back 4bit-front 0x22 default)
+
+	// Ready to display
+	d.Command(INVON)                  // Inversion ON
+	time.Sleep(10 * time.Millisecond) //
+
+	d.Command(NORON)                  // Normal mode ON
+	time.Sleep(10 * time.Millisecond) //
+
+	d.Command(DISPON)                 // Screen ON
+	time.Sleep(10 * time.Millisecond) //
+
+	d.blPin.High() // Backlight ON
+}
+
+// Sync waits for the display to hit the next VSYNC pause
+func (d *Device) Sync() {
+	d.SyncToScanLine(0)
+}
+
+// SyncToScanLine waits for the display to hit a specific scanline
+//
+// A scanline value of 0 will forward to the beginning of the next VSYNC,
+// even if the display is currently in a VSYNC pause.
+//
+// Syncline values appear to increment once for every two vertical
+// lines on the display.
+//
+// NOTE: Use GetHighestScanLine and GetLowestScanLine to obtain the highest
+// and lowest useful values. Values are affected by front and back porch
+// vsync settings (derived from VSyncLines configuration option).
+//
+func (d *Device) SyncToScanLine(scanline uint16) {
+	scan := d.GetScanLine()
+
+	// Sometimes GetScanLine returns erroneous 0 on first call after draw, so double check
+	if scan == 0 {
+		scan = d.GetScanLine()
+	}
+
+	if scanline == 0 {
+		// we dont know where we are in an ongoing vsync so go around
+		for scan < 1 {
+			time.Sleep(1 * time.Millisecond)
+			scan = d.GetScanLine()
+		}
+		for scan > 0 {
+			scan = d.GetScanLine()
+		}
+	} else {
+		// go around unless we're very close to the target
+		for scan > scanline+4 {
+			time.Sleep(1 * time.Millisecond)
+			scan = d.GetScanLine()
+		}
+		for scan < scanline {
+			scan = d.GetScanLine()
+		}
+	}
+}
+
+// GetScanLine reads the current scanline value from the display
+func (d *Device) GetScanLine() uint16 {
+	data := []uint8{0x00, 0x00}
+	d.Rx(GSCAN, data)
+	return uint16(data[0])<<8 + uint16(data[1])
+}
+
+// GetHighestScanLine calculates the last scanline id in the frame before VSYNC pause
+func (d *Device) GetHighestScanLine() uint16 {
+	// Last scanline id appears to be backporch/2 + 320/2
+	return uint16(math.Ceil(float64(d.vSyncLines)/2)/2) + 160
+}
+
+// GetLowestScanLine calculate the first scanline id to appear after VSYNC pause
+func (d *Device) GetLowestScanLine() uint16 {
+	// First scanline id appears to be backporch/2 + 1
+	return uint16(math.Ceil(float64(d.vSyncLines)/2)/2) + 1
 }
 
 // Display does nothing, there's no buffer as it might be too big for some boards
@@ -123,7 +245,7 @@ func (d *Device) setWindow(x, y, w, h int16) {
 	x += d.columnOffset
 	y += d.rowOffset
 	d.Tx([]uint8{CASET}, true)
-	d.Tx([]uint8{uint8(x << 8), uint8(x), uint8((x + w - 1) >> 8), uint8(x + w - 1)}, false)
+	d.Tx([]uint8{uint8(x >> 8), uint8(x), uint8((x + w - 1) >> 8), uint8(x + w - 1)}, false)
 	d.Tx([]uint8{RASET}, true)
 	d.Tx([]uint8{uint8(y >> 8), uint8(y), uint8((y + h - 1) >> 8), uint8(y + h - 1)}, false)
 	d.Command(RAMWR)
@@ -158,7 +280,7 @@ func (d *Device) FillRectangle(x, y, width, height int16, c color.RGBA) error {
 	return nil
 }
 
-// FillRectangle fills a rectangle at a given coordinates with a buffer
+// FillRectangleWithBuffer fills buffer with a rectangle at a given coordinates.
 func (d *Device) FillRectangleWithBuffer(x, y, width, height int16, buffer []color.RGBA) error {
 	i, j := d.Size()
 	if x < 0 || y < 0 || width <= 0 || height <= 0 ||
@@ -248,15 +370,14 @@ func (d *Device) SetRotation(rotation Rotation) {
 	}
 	d.Command(MADCTL)
 	d.Data(madctl)
-
 }
 
-// Command sends a command to the display
+// Command sends a command to the display.
 func (d *Device) Command(command uint8) {
 	d.Tx([]byte{command}, true)
 }
 
-// Command sends a data to the display
+// Data sends data to the display.
 func (d *Device) Data(data uint8) {
 	d.Tx([]byte{data}, false)
 }
@@ -265,11 +386,24 @@ func (d *Device) Data(data uint8) {
 func (d *Device) Tx(data []byte, isCommand bool) {
 	if isCommand {
 		d.dcPin.Low()
-		d.bus.Tx(data, nil)
 	} else {
 		d.dcPin.High()
-		d.bus.Tx(data, nil)
 	}
+	d.csPin.Low()
+	d.bus.Tx(data, nil)
+	d.csPin.High()
+}
+
+// Rx reads data from the display
+func (d *Device) Rx(command uint8, data []byte) {
+	d.dcPin.Low()
+	d.csPin.Low()
+	d.bus.Transfer(command)
+	d.dcPin.High()
+	for i := range data {
+		data[i], _ = d.bus.Transfer(0xFF)
+	}
+	d.csPin.High()
 }
 
 // Size returns the current size of the display.
@@ -289,7 +423,7 @@ func (d *Device) EnableBacklight(enable bool) {
 	}
 }
 
-// InverColors inverts the colors of the screen
+// InvertColors inverts the colors of the screen
 func (d *Device) InvertColors(invert bool) {
 	if invert {
 		d.Command(INVON)
@@ -303,6 +437,27 @@ func (d *Device) IsBGR(bgr bool) {
 	d.isBGR = bgr
 }
 
+// SetScrollArea sets an area to scroll with fixed top and bottom parts of the display.
+func (d *Device) SetScrollArea(topFixedArea, bottomFixedArea int16) {
+	d.Command(VSCRDEF)
+	d.Tx([]uint8{
+		uint8(topFixedArea >> 8), uint8(topFixedArea),
+		uint8(d.height - topFixedArea - bottomFixedArea>>8), uint8(d.height - topFixedArea - bottomFixedArea),
+		uint8(bottomFixedArea >> 8), uint8(bottomFixedArea)},
+		false)
+}
+
+// SetScroll sets the vertical scroll address of the display.
+func (d *Device) SetScroll(line int16) {
+	d.Command(VSCRSADD)
+	d.Tx([]uint8{uint8(line >> 8), uint8(line)}, false)
+}
+
+// StopScroll returns the display to its normal state.
+func (d *Device) StopScroll() {
+	d.Command(NORON)
+}
+
 // RGBATo565 converts a color.RGBA to uint16 used in the display
 func RGBATo565(c color.RGBA) uint16 {
 	r, g, b, _ := c.RGBA()

tester/device.go

@@ -0,0 +1,61 @@
+package tester
+
+// MaxRegisters is the maximum number of registers supported for a Device.
+const MaxRegisters = 200
+
+// 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
+}
+
+// NewI2CDevice returns a new mock I2C device.
+func NewI2CDevice(c Failer, addr uint8) *I2CDevice {
+	return &I2CDevice{
+		c:    c,
+		addr: addr,
+	}
+}
+
+// Addr returns the Device address.
+func (d *I2CDevice) Addr() uint8 {
+	return d.addr
+}
+
+// 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))
+	}
+}

tester/i2c.go

@@ -0,0 +1,64 @@
+package tester
+
+import "fmt"
+
+// I2CBus implements the I2C interface in memory for testing.
+type I2CBus struct {
+	c       Failer
+	devices []*I2CDevice
+}
+
+// NewI2CBus returns an I2CBus mock I2C instance that uses c to flag errors
+// if they happen. After creating a I2C instance, add devices
+// to it with addDevice before using NewI2CBus interface.
+func NewI2CBus(c Failer) *I2CBus {
+	return &I2CBus{
+		c: c,
+	}
+}
+
+// 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) {
+	for _, dev := range bus.devices {
+		if dev.Addr() == d.addr {
+			panic(fmt.Errorf("device already added at address %#x", d))
+		}
+	}
+	bus.devices = append(bus.devices, d)
+}
+
+// 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)
+	bus.AddDevice(dev)
+	return dev
+}
+
+// ReadRegister implements I2C.ReadRegister.
+func (bus *I2CBus) ReadRegister(addr uint8, r uint8, buf []byte) error {
+	return bus.FindDevice(addr).ReadRegister(r, buf)
+}
+
+// WriteRegister implements I2C.WriteRegister.
+func (bus *I2CBus) WriteRegister(addr uint8, r uint8, buf []byte) error {
+	return bus.FindDevice(addr).WriteRegister(r, buf)
+}
+
+// Tx implements I2C.Tx.
+func (bus *I2CBus) Tx(addr uint16, w, r []byte) error {
+	// TODO: implement this
+	return nil
+}
+
+// FindDevice returns the device with the given address.
+func (bus *I2CBus) FindDevice(addr uint8) *I2CDevice {
+	for _, dev := range bus.devices {
+		if dev.Addr() == addr {
+			return dev
+		}
+	}
+	bus.c.Fatalf("invalid device addr %#x passed to i2c bus", addr)
+	panic("unreachable")
+}

tester/tester.go

@@ -0,0 +1,13 @@
+// Package tester contains mock structs to make it easier to test I2C devices.
+//
+// TODO: info on how to use this.
+//
+package tester // import "tinygo.org/x/drivers/tester"
+
+// Failer is used by the I2CDevice type to abort when it's used in
+// unexpected ways, such as reading an out-of-range register.
+type Failer interface {
+	// Fatalf prints the Printf-formatted message and exits the current
+	// goroutine.
+	Fatalf(f string, a ...interface{})
+}