Prepare for release v0.13.0

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

.circleci/config.yml

@@ -6,7 +6,6 @@ jobs:
   build:
     docker:
       - image: tinygo/tinygo-dev
-    working_directory: /usr/local/go/src/tinygo.org/x/drivers
     steps:
       - checkout
       - run: tinygo version

CHANGELOG.md

@@ -1,3 +1,44 @@
+0.13.0
+---
+- **new devices**
+    - bmi160: add initial support
+    - bmp280: added support for the Bosch BMP280 temperature and pressure sensor. (#158)
+    - lsm303agr: add lsm303agr (#162)
+    - ssd1351: add SSD1351 OLED display driver (#146)
+- **enhancements**
+    - hd44780: add Hd44780i2c driver (#173)
+    - ili9341
+        - add ILI9341 TFT driver (SPI) for ATSAMD2x (#174)
+        - cache address window to prevent sending unnecessary commands (#171)
+        - ILI9341 TFT driver (SPI) (#153)
+        - improve performance of ILI9341 on ATSAMD5X
+    - ST77xx: fix DrawFastHLine for ST77xx, SSD1331 and SSD1351 DrawFastHLine uses FillRectangle(x,y,width,height,c), so height must be 1 to draw a horizontal line
+    - tmp102: add Connected func to check for device
+    - wifinina: added UDP support
+    - ws2812: update ws2812_avr_16m.go
+- **bugfixes**
+    - apa102: avoid creating garbage
+    - bmp180: fix temperature type conversion
+- **core**
+    - all
+        - added custom import path (#161)
+        - changeover to eliminate all direct use of master/slave terminology
+    - build: try vendor in working directory to match expected module path
+    - ci: support Go modules
+    - modules: update go version and dependency
+- **docs**
+    - docs: reorder to correct alpha and adjust count of supported drivers
+
+0.12.0
+---
+- **new devices**
+    - hcsr04: Added HC-SR04 ultrasonic distance sensor. (#143)
+    - spi/qspi: Low-level IO driver for serial flash memory via SPI and QSPI (#124)
+    - tmp102: TMP102 low-power digital temperature sensor (#141)
+    - amg88xx: AMG88xx thermal camera module
+- **bugfixes**
+    - mqtt: reduce use of goroutines in router to not start a new goroutine for each invocation of each callback
+
 0.11.0
 ---
 - **new devices**

CONTRIBUTING.md

@@ -20,7 +20,7 @@ Please first open a Github issue. We want to help, and also make sure that there
 
 ## How to use our Github repository
 
-The `master` branch of this repo will always have the latest released version of the TinyGo drivers. All of the active development work for the next release will take place in the `dev` branch. The TinyGo drivers will use semantic versioning and will create a tag/release for each release.
+The `release` branch of this repo will always have the latest released version of the TinyGo drivers. All of the active development work for the next release will take place in the `dev` branch. The TinyGo drivers will use semantic versioning and will create a tag/release for each release.
 
 Here is how to contribute back some code or documentation:
 

Makefile

@@ -13,6 +13,8 @@ smoke-test:
 	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=itsybitsy-m0 ./examples/adxl345/main.go
 	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=pybadge ./examples/amg88xx
+	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=itsybitsy-m0 ./examples/apa102/main.go
 	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=itsybitsy-m0 ./examples/apa102/itsybitsy-m0/main.go
@@ -23,8 +25,12 @@ smoke-test:
 	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=itsybitsy-m0 ./examples/blinkm/main.go
 	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=itsybitsy-m0 ./examples/bmi160/main.go
+	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=itsybitsy-m0 ./examples/bmp180/main.go
 	@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=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
@@ -39,22 +45,38 @@ smoke-test:
 	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=arduino-nano33 ./examples/espat/espstation/main.go
 	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=itsybitsy-m0 ./examples/flash/console/spi
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=pyportal ./examples/flash/console/qspi
+	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=feather-m0 ./examples/gps/i2c/main.go
 	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=feather-m0 ./examples/gps/uart/main.go
 	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=itsybitsy-m0 ./examples/hcsr04/main.go
+	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=microbit ./examples/hd44780/customchar/main.go
 	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=microbit ./examples/hd44780/text/main.go
 	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=arduino-nano33 ./examples/hd44780i2c/main.go
+	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=microbit ./examples/hub75/main.go
 	@md5sum ./build/test.hex
-	tinygo build -size short -o ./build/test.hex -target=pyportal ./examples/ili9341/basic/main.go
+	tinygo build -size short -o ./build/test.hex -target=pyportal ./examples/ili9341/basic
 	@md5sum ./build/test.hex
-	tinygo build -size short -o ./build/test.hex -target=pyportal ./examples/ili9341/scroll/main.go
+	tinygo build -size short -o ./build/test.hex -target=xiao ./examples/ili9341/basic
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=pyportal ./examples/ili9341/pyportal_boing
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=pyportal ./examples/ili9341/scroll
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=xiao ./examples/ili9341/scroll
 	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=circuitplay-express ./examples/lis3dh/main.go
 	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=microbit ./examples/lsm303agr/main.go
+	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=arduino-nano33 ./examples/lsm6ds3/main.go
 	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=itsybitsy-m0 ./examples/mag3110/main.go
@@ -97,6 +119,10 @@ 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=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
+	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=arduino-nano33 ./examples/wifinina/tcpclient/main.go
 	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=arduino-nano33 ./examples/wifinina/webclient/main.go
@@ -123,5 +149,7 @@ smoke-test:
 	@md5sum ./build/test.hex
 	tinygo build -size short -o ./build/test.hex -target=nucleo-f103rb ./examples/shiftregister/main.go
 	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=hifive1b ./examples/ssd1351/main.go
+	@md5sum ./build/test.hex
 
 test: clean fmt-check smoke-test

README.md

@@ -52,26 +52,30 @@ func main() {
 
 ## Currently supported devices
 
-The following 45 devices are supported.
+The following 51 devices are supported.
 
 | Device Name | Interface Type |
 |----------|-------------|
 | [ADT7410 I2C Temperature Sensor](https://www.analog.com/media/en/technical-documentation/data-sheets/ADT7410.pdf) | I2C |
 | [ADXL345 accelerometer](http://www.analog.com/media/en/technical-documentation/data-sheets/ADXL345.pdf) | I2C |
+| [AMG88xx 8x8 Thermal camera sensor](https://cdn-learn.adafruit.com/assets/assets/000/043/261/original/Grid-EYE_SPECIFICATIONS%28Reference%29.pdf) | I2C |
 | [APA102 RGB LED](https://cdn-shop.adafruit.com/product-files/2343/APA102C.pdf) | SPI |
 | [AT24CX 2-wire serial EEPROM](https://www.openimpulse.com/blog/wp-content/uploads/wpsc/downloadables/24C32-Datasheet.pdf) | I2C |
+| [BBC micro:bit LED matrix](https://github.com/bbcmicrobit/hardware/blob/master/SCH_BBC-Microbit_V1.3B.pdf) | GPIO |
 | [BH1750 ambient light sensor](https://www.mouser.com/ds/2/348/bh1750fvi-e-186247.pdf) | I2C |
 | [BlinkM RGB LED](http://thingm.com/fileadmin/thingm/downloads/BlinkM_datasheet.pdf) | I2C |
 | [BME280 humidity/pressure sensor](https://cdn-shop.adafruit.com/datasheets/BST-BME280_DS001-10.pdf) | I2C |
+| [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 |
 | [Buzzer](https://en.wikipedia.org/wiki/Buzzer#Piezoelectric) | 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 |
-| ["Easystepper" stepper motor controller](https://en.wikipedia.org/wiki/Stepper_motor) | GPIO |
 | [ESP32 as WiFi Coprocessor with Arduino nina-fw](https://github.com/arduino/nina-fw) | SPI |
 | [ESP8266/ESP32 AT Command set for WiFi/TCP/UDP](https://github.com/espressif/esp32-at) | UART |
 | [GPS module](https://www.u-blox.com/en/product/neo-6-series) | I2C/UART |
-| [HD44780 LCD controller](https://www.sparkfun.com/datasheets/LCD/HD44780.pdf) | GPIO |
+| [HC-SR04 Ultrasonic distance sensor](https://cdn.sparkfun.com/datasheets/Sensors/Proximity/HCSR04.pdf) | GPIO |
+| [HD44780 LCD controller](https://www.sparkfun.com/datasheets/LCD/HD44780.pdf) | GPIO/I2C |
 | [HUB75 RGB led matrix](https://cdn-learn.adafruit.com/downloads/pdf/32x16-32x32-rgb-led-matrix.pdf) | SPI |
 | [ILI9341 TFT color display](https://cdn-shop.adafruit.com/datasheets/ILI9341.pdf) | SPI |
 | [L293x motor driver](https://www.ti.com/lit/ds/symlink/l293d.pdf) | GPIO/PWM |
@@ -80,7 +84,6 @@ The following 45 devices are supported.
 | [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 |
 | [MCP3008 analog to digital converter (ADC)](http://ww1.microchip.com/downloads/en/DeviceDoc/21295d.pdf) | SPI |
-| [BBC micro:bit LED matrix](https://github.com/bbcmicrobit/hardware/blob/master/SCH_BBC-Microbit_V1.3B.pdf) | GPIO |
 | [Microphone - PDM](https://cdn-learn.adafruit.com/assets/assets/000/049/977/original/MP34DT01-M.pdf) | I2S/PDM |
 | [MMA8653 accelerometer](https://www.nxp.com/docs/en/data-sheet/MMA8653FC.pdf) | I2C |
 | [MPU6050 accelerometer/gyroscope](https://store.invensense.com/datasheets/invensense/MPU-6050_DataSheet_V3%204.pdf) | I2C |
@@ -90,15 +93,19 @@ The following 45 devices are supported.
 | [Shift register (PISO)](https://en.wikipedia.org/wiki/Shift_register#Parallel-in_serial-out_\(PISO\)) | GPIO |
 | [Shift registers (SIPO)](https://en.wikipedia.org/wiki/Shift_register#Serial-in_parallel-out_(SIPO)) | GPIO |
 | [SHT3x Digital Humidity Sensor](https://www.sensirion.com/fileadmin/user_upload/customers/sensirion/Dokumente/0_Datasheets/Humidity/Sensirion_Humidity_Sensors_SHT3x_Datasheet_digital.pdf) | I2C |
+| [SPI NOR Flash Memory](https://en.wikipedia.org/wiki/Flash_memory#NOR_flash) | SPI/QSPI |
 | [SSD1306 OLED display](https://cdn-shop.adafruit.com/datasheets/SSD1306.pdf) | I2C / SPI |
 | [SSD1331 TFT color display](https://www.crystalfontz.com/controllers/SolomonSystech/SSD1331/381/) | SPI |
+| [SSD1351 OLED display](https://download.mikroe.com/documents/datasheets/ssd1351-revision-1.3.pdf) | SPI |
 | [ST7735 TFT color display](https://www.crystalfontz.com/controllers/Sitronix/ST7735R/319/) | SPI |
 | [ST7789 TFT color display](https://cdn-shop.adafruit.com/product-files/3787/3787_tft_QT154H2201__________20190228182902.pdf) | SPI |
+| [Stepper motor "Easystepper" controller](https://en.wikipedia.org/wiki/Stepper_motor) | GPIO |
 | [Thermistor](https://www.farnell.com/datasheets/33552.pdf) | ADC |
+| [TMP102 I2C Temperature Sensor](https://download.mikroe.com/documents/datasheets/tmp102-data-sheet.pdf) | I2C |
 | [VEML6070 UV light sensor](https://www.vishay.com/docs/84277/veml6070.pdf) | I2C |
 | [VL53L1X time-of-flight distance sensor](https://www.st.com/resource/en/datasheet/vl53l1x.pdf) | I2C |
-| [Waveshare 2.13" e-paper display](https://www.waveshare.com/w/upload/e/e6/2.13inch_e-Paper_Datasheet.pdf) | SPI |
 | [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 |
 | [WS2812 RGB LED](https://cdn-shop.adafruit.com/datasheets/WS2812.pdf) | GPIO |
 
 ## Contributing

adt7410/adt7410.go

@@ -1,4 +1,4 @@
-package adt7410
+package adt7410 // import "tinygo.org/x/drivers/adt7410"
 
 import (
 	"machine"

amg88xx/amg88xx.go

@@ -0,0 +1,158 @@
+// Package amg88xx provides a driver for the AMG88XX Thermal Camera
+//
+// Datasheet:
+// https://cdn-learn.adafruit.com/assets/assets/000/043/261/original/Grid-EYE_SPECIFICATIONS%28Reference%29.pdf
+package amg88xx // import "tinygo.org/x/drivers/amg88xx"
+
+import (
+	"machine"
+	"time"
+)
+
+// Device wraps an I2C connection to a AMG88xx device.
+type Device struct {
+	bus             machine.I2C
+	Address         uint16
+	data            []uint8
+	interruptMode   InterruptMode
+	interruptEnable uint8
+}
+
+type InterruptMode uint8
+
+type Config struct {
+}
+
+// New creates a new AMG88xx 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 {
+	return Device{
+		bus:     bus,
+		Address: AddressHigh,
+	}
+}
+
+// Configure sets up the device for communication
+func (d *Device) Configure(cfg Config) {
+	d.data = make([]uint8, 128)
+
+	d.SetPCTL(NORMAL_MODE)
+	d.SetReset(INITIAL_RESET)
+	d.SetFrameRate(FPS_10)
+
+	time.Sleep(100 * time.Millisecond)
+}
+
+// ReadPixels returns the 64 values (8x8 grid) of the sensor converted to  millicelsius
+func (d *Device) ReadPixels(buffer *[64]int16) {
+	d.bus.ReadRegister(uint8(d.Address), PIXEL_OFFSET, d.data)
+	for i := 0; i < 64; i++ {
+		buffer[i] = int16((uint16(d.data[2*i+1]) << 8) | uint16(d.data[2*i]))
+		if (buffer[i] & (1 << 11)) > 0 { // temperature negative
+			buffer[i] &= ^(1 << 11)
+			buffer[i] = -buffer[i]
+		}
+		buffer[i] *= PIXEL_TEMP_CONVERSION
+	}
+}
+
+// SetPCTL sets the PCTL
+func (d *Device) SetPCTL(pctl uint8) {
+	d.bus.WriteRegister(uint8(d.Address), PCTL, []byte{pctl})
+}
+
+// SetReset sets the reset value
+func (d *Device) SetReset(rst uint8) {
+	d.bus.WriteRegister(uint8(d.Address), RST, []byte{rst})
+}
+
+// SetFrameRate configures the frame rate
+func (d *Device) SetFrameRate(framerate uint8) {
+	d.bus.WriteRegister(uint8(d.Address), FPSC, []byte{framerate & 0x01})
+}
+
+// SetMovingAverageMode sets the moving average mode
+func (d *Device) SetMovingAverageMode(mode bool) {
+	var value uint8
+	if mode {
+		value = 1
+	}
+	d.bus.WriteRegister(uint8(d.Address), AVE, []byte{value << 5})
+}
+
+// SetInterruptLevels sets the interrupt levels
+func (d *Device) SetInterruptLevels(high int16, low int16) {
+	d.SetInterruptLevelsHysteresis(high, low, (high*95)/100)
+}
+
+// SetInterruptLevelsHysteresis sets the interrupt levels with hysteresis
+func (d *Device) SetInterruptLevelsHysteresis(high int16, low int16, hysteresis int16) {
+	high = high / PIXEL_TEMP_CONVERSION
+	if high < -4095 {
+		high = -4095
+	}
+	if high > 4095 {
+		high = 4095
+	}
+	d.bus.WriteRegister(uint8(d.Address), INTHL, []byte{uint8(high & 0xFF)})
+	d.bus.WriteRegister(uint8(d.Address), INTHL, []byte{uint8((high & 0xFF) >> 4)})
+
+	low = low / PIXEL_TEMP_CONVERSION
+	if low < -4095 {
+		low = -4095
+	}
+	if low > 4095 {
+		low = 4095
+	}
+	d.bus.WriteRegister(uint8(d.Address), INTHL, []byte{uint8(low & 0xFF)})
+	d.bus.WriteRegister(uint8(d.Address), INTHL, []byte{uint8((low & 0xFF) >> 4)})
+
+	hysteresis = hysteresis / PIXEL_TEMP_CONVERSION
+	if hysteresis < -4095 {
+		hysteresis = -4095
+	}
+	if hysteresis > 4095 {
+		hysteresis = 4095
+	}
+	d.bus.WriteRegister(uint8(d.Address), INTHL, []byte{uint8(hysteresis & 0xFF)})
+	d.bus.WriteRegister(uint8(d.Address), INTHL, []byte{uint8((hysteresis & 0xFF) >> 4)})
+}
+
+// EnableInterrupt enables the interrupt pin on the device
+func (d *Device) EnableInterrupt() {
+	d.interruptEnable = 1
+	d.bus.WriteRegister(uint8(d.Address), INTC, []byte{((uint8(d.interruptMode) << 1) | d.interruptEnable) & 0x03})
+}
+
+// DisableInterrupt disables the interrupt pin on the device
+func (d *Device) DisableInterrupt() {
+	d.interruptEnable = 0
+	d.bus.WriteRegister(uint8(d.Address), INTC, []byte{((uint8(d.interruptMode) << 1) | d.interruptEnable) & 0x03})
+}
+
+// SetInterruptMode sets the interrupt mode
+func (d *Device) SetInterruptMode(mode InterruptMode) {
+	d.interruptMode = mode
+	d.bus.WriteRegister(uint8(d.Address), INTC, []byte{((uint8(d.interruptMode) << 1) | d.interruptEnable) & 0x03})
+}
+
+// GetInterrupt reads the state of the triggered interrupts
+func (d *Device) GetInterrupt() []uint8 {
+	data := make([]uint8, 8)
+	d.bus.ReadRegister(uint8(d.Address), INT_OFFSET, data)
+	return data
+}
+
+// ClearInterrupt clears any triggered interrupts
+func (d *Device) ClearInterrupt() {
+	d.SetReset(FLAG_RESET)
+}
+
+// ReadThermistor reads the onboard thermistor
+func (d *Device) ReadThermistor() int16 {
+	data := make([]uint8, 2)
+	d.bus.ReadRegister(uint8(d.Address), TTHL, data)
+	return (int16((uint16(data[1])<<8)|uint16(data[0])) * THERMISTOR_CONVERSION) / 10
+}

amg88xx/registers.go

@@ -0,0 +1,46 @@
+package amg88xx
+
+// The I2C address which this device listens to.
+const AddressHigh = 0x69
+const AddressLow = 0x68
+
+const (
+	PCTL         = 0x00
+	RST          = 0x01
+	FPSC         = 0x02
+	INTC         = 0x03
+	STAT         = 0x04
+	SCLR         = 0x05
+	AVE          = 0x07
+	INTHL        = 0x08
+	INTHH        = 0x09
+	INTLL        = 0x0A
+	INTLH        = 0x0B
+	IHYSL        = 0x0C
+	IHYSH        = 0x0D
+	TTHL         = 0x0E
+	TTHH         = 0x0F
+	INT_OFFSET   = 0x010
+	PIXEL_OFFSET = 0x80
+
+	// power modes
+	NORMAL_MODE = 0x00
+	SLEEP_MODE  = 0x01
+	STAND_BY_60 = 0x20
+	STAND_BY_10 = 0x21
+
+	// resets
+	FLAG_RESET    = 0x30
+	INITIAL_RESET = 0x3F
+
+	// frame rates
+	FPS_10 = 0x00
+	FPS_1  = 0x01
+
+	// interrupt modes
+	DIFFERENCE     InterruptMode = 0x00
+	ABSOLUTE_VALUE InterruptMode = 0x01
+
+	PIXEL_TEMP_CONVERSION = 250
+	THERMISTOR_CONVERSION = 625
+)

apa102/apa102.go

@@ -19,6 +19,8 @@ const (
 	GRB
 )
 
+var startFrame = []byte{0x00, 0x00, 0x00, 0x00}
+
 // Device wraps APA102 SPI LEDs.
 type Device struct {
 	bus   SPI
@@ -30,6 +32,7 @@ type Device struct {
 // 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.
@@ -39,8 +42,8 @@ func New(b SPI) Device {
 
 // NewSoftwareSPI returns a new APA102 driver that will use a software based
 // implementation of the SPI protocol.
-func NewSoftwareSPI(sckPin, mosiPin machine.Pin, delay uint32) Device {
-	return New(&bbSPI{SCK: sckPin, MOSI: mosiPin, Delay: delay})
+func NewSoftwareSPI(sckPin, sdoPin machine.Pin, delay uint32) Device {
+	return New(&bbSPI{SCK: sckPin, SDO: sdoPin, Delay: delay})
 }
 
 // WriteColors writes the given RGBA color slice out using the APA102 protocol.
@@ -51,22 +54,22 @@ func (d Device) WriteColors(cs []color.RGBA) (n int, err error) {
 	// write data
 	for _, c := range cs {
 		// brightness is scaled to 5 bit value
-		d.bus.Tx([]byte{0xe0 | (c.A >> 3)}, nil)
+		d.bus.Transfer(0xe0 | (c.A >> 3))
 
 		// set the colors
 		switch d.Order {
 		case BRG:
-			d.bus.Tx([]byte{c.B}, nil)
-			d.bus.Tx([]byte{c.R}, nil)
-			d.bus.Tx([]byte{c.G}, nil)
+			d.bus.Transfer(c.B)
+			d.bus.Transfer(c.R)
+			d.bus.Transfer(c.G)
 		case GRB:
-			d.bus.Tx([]byte{c.G}, nil)
-			d.bus.Tx([]byte{c.R}, nil)
-			d.bus.Tx([]byte{c.B}, nil)
+			d.bus.Transfer(c.G)
+			d.bus.Transfer(c.R)
+			d.bus.Transfer(c.B)
 		case BGR:
-			d.bus.Tx([]byte{c.B}, nil)
-			d.bus.Tx([]byte{c.G}, nil)
-			d.bus.Tx([]byte{c.R}, nil)
+			d.bus.Transfer(c.B)
+			d.bus.Transfer(c.G)
+			d.bus.Transfer(c.R)
 		}
 	}
 
@@ -86,7 +89,7 @@ func (d Device) Write(buf []byte) (n int, err error) {
 
 // startFrame sends the start bytes for a strand of LEDs.
 func (d Device) startFrame() {
-	d.bus.Tx([]byte{0x00, 0x00, 0x00, 0x00}, nil)
+	d.bus.Tx(startFrame, nil)
 }
 
 // endFrame sends the end frame marker with one extra bit per LED so
@@ -94,6 +97,6 @@ func (d Device) startFrame() {
 // See https://cpldcpu.wordpress.com/2014/11/30/understanding-the-apa102-superled/
 func (d Device) endFrame(count int) {
 	for i := 0; i < count/16; i++ {
-		d.bus.Tx([]byte{0xff}, nil)
+		d.bus.Transfer(0xff)
 	}
 }

apa102/softspi.go

@@ -9,16 +9,16 @@ import "machine"
 // this more generic and include it in the TinyGo "machine" package instead.
 type bbSPI struct {
 	SCK   machine.Pin
-	MOSI  machine.Pin
+	SDO   machine.Pin
 	Delay uint32
 }
 
-// Configure sets up the SCK and MOSI pins as outputs and sets them low
+// Configure sets up the SCK and SDO pins as outputs and sets them low
 func (s *bbSPI) Configure() {
 	s.SCK.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	s.MOSI.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	s.SDO.Configure(machine.PinConfig{Mode: machine.PinOutput})
 	s.SCK.Low()
-	s.MOSI.Low()
+	s.SDO.Low()
 	if s.Delay == 0 {
 		s.Delay = 1
 	}
@@ -41,19 +41,20 @@ func (s *bbSPI) delay() {
 	}
 }
 
-// Transfer is used to send a single byte.
-func (s *bbSPI) Transfer(b byte) {
+// Transfer matches signature of machine.SPI.Transfer() and is used to send a
+// single byte. The received data is ignored and no error will ever be returned.
+func (s *bbSPI) Transfer(b byte) (byte, error) {
 	for i := uint8(0); i < 8; i++ {
 
 		// half clock cycle high to start
 		s.SCK.High()
 		s.delay()
 
-		// write the value to MOSI (MSB first)
+		// write the value to SDO (MSB first)
 		if b&(1<<(7-i)) == 0 {
-			s.MOSI.Low()
+			s.SDO.Low()
 		} else {
-			s.MOSI.High()
+			s.SDO.High()
 		}
 		s.delay()
 
@@ -61,8 +62,9 @@ func (s *bbSPI) Transfer(b byte) {
 		s.SCK.Low()
 		s.delay()
 
-		// for actual SPI would try to read the MISO value here
+		// for actual SPI would try to read the SDI value here
 		s.delay()
-
 	}
+
+	return 0, nil
 }

bmi160/bmi160.go

@@ -0,0 +1,201 @@
+package bmi160
+
+import "machine"
+
+import "time"
+
+// DeviceSPI is the SPI interface to a BMI160 accelerometer/gyroscope. There is
+// also an I2C interface, but it is not yet supported.
+type DeviceSPI struct {
+	// Chip select pin
+	CSB machine.Pin
+
+	// SPI bus (requires chip select to be usable).
+	Bus machine.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 {
+	return &DeviceSPI{
+		CSB: csb, // chip select
+		Bus: spi,
+	}
+}
+
+// Configure configures the BMI160 for use. It configures the CSB pin and
+// configures the BMI160, but it does not configure the SPI interface (it is
+// assumed to be up and running).
+func (d *DeviceSPI) Configure() error {
+	d.CSB.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	d.CSB.High()
+
+	// The datasheet recommends doing a register read from address 0x7F to get
+	// SPI communication going:
+	// > If CSB sees a rising edge after power-up, the BMI160 interface switches
+	// > to SPI until a reset or the next power-up occurs. Therefore, a CSB
+	// > rising edge is needed before starting the SPI communication. Hence, it
+	// > is recommended to perform a SPI single read access to the ADDRESS 0x7F
+	// > before the actual communication in order to use the SPI interface.
+	d.readRegister(0x7F)
+
+	// Power up the accelerometer. 0b0001_00nn is the command format, with 0b01
+	// indicating normal mode.
+	d.runCommand(0b0001_0001)
+
+	// Power up the gyroscope. 0b0001_01nn is the command format, with 0b01
+	// indicating normal mode.
+	d.runCommand(0b0001_0101)
+
+	// Wait until the device is fully initialized. Even after the command has
+	// finished, the gyroscope may not be fully powered on. Therefore, wait
+	// until we get an expected value.
+	// This takes 30ms or so.
+	for {
+		// Wait for the acc_pmu_status and gyr_pmu_status to both be 0b01.
+		if d.readRegister(reg_PMU_STATUS) == 0b0001_0100 {
+			break
+		}
+	}
+
+	return nil
+}
+
+// Connected check whether the device appears to be properly connected. It reads
+// the CHIPID, which must be 0xD1 for the BMI160.
+func (d *DeviceSPI) Connected() bool {
+	return d.readRegister(reg_CHIPID) == 0xD1
+}
+
+// Reset restores the device to the state after power up. This can be useful to
+// easily disable the accelerometer and gyroscope to reduce current consumption.
+func (d *DeviceSPI) Reset() error {
+	d.runCommand(0xB6) // softreset
+	return nil
+}
+
+// ReadTemperature returns the temperature in celsius milli degrees (°C/1000).
+func (d *DeviceSPI) ReadTemperature() (temperature int32, err error) {
+	data := []byte{0x80 | reg_TEMPERATURE_0, 0, 0}
+	d.CSB.Low()
+	err = d.Bus.Tx(data, data)
+	d.CSB.High()
+	if err != nil {
+		return
+	}
+	rawTemperature := int16(uint16(data[1]) | uint16(data[2])<<8)
+	// 0x0000 is 23°C
+	// 0x7fff is ~87°C
+	// We use 0x8000 instead of 0x7fff to make the formula easier. The result
+	// should be near identical and shouldn't affect the result too much (the
+	// temperature sensor has an offset of around 2°C so isn't very reliable).
+	// So the formula is as follows:
+	// 1. Scale from 0x0000..0x8000 to 0..(87-23).
+	//    rawTemperature * (87-23) / 0x8000
+	// 2. Convert to centidegrees.
+	//    rawTemperature * 1000 * (87-23) / 0x8000
+	// 3. Add 23°C offset.
+	//    rawTemperature * 1000 * (87-23) / 0x8000 + 23000
+	// 4. Simplify.
+	//    rawTemperature * 1000 * 64 / 0x8000 + 23000
+	//    rawTemperature * 64000 / 0x8000 + 23000
+	//    rawTemperature * 125 / 64 + 23000
+	temperature = int32(rawTemperature)*125/64 + 23000
+	return
+}
+
+// ReadAcceleration reads the current acceleration from the device and returns
+// it in µg (micro-gravity). When one of the axes is pointing straight to Earth
+// and the sensor is not moving the returned value will be around 1000000 or
+// -1000000.
+func (d *DeviceSPI) ReadAcceleration() (x int32, y int32, z int32, err error) {
+	data := []byte{0x80 | reg_ACC_XL, 0, 0, 0, 0, 0, 0}
+	d.CSB.Low()
+	err = d.Bus.Tx(data, data)
+	d.CSB.High()
+	if err != nil {
+		return
+	}
+	// Now do two things:
+	// 1. merge the two values to a 16-bit number (and cast to a 32-bit integer)
+	// 2. scale the value to bring it in the -1000000..1000000 range.
+	//    This is done with a trick. What we do here is essentially multiply by
+	//    1000000 and divide by 16384 to get the original scale, but to avoid
+	//    overflow we do it at 1/64 of the value:
+	//      1000000 / 64 = 15625
+	//      16384   / 64 = 256
+	x = int32(int16(uint16(data[1])|uint16(data[2])<<8)) * 15625 / 256
+	y = int32(int16(uint16(data[3])|uint16(data[4])<<8)) * 15625 / 256
+	z = int32(int16(uint16(data[5])|uint16(data[6])<<8)) * 15625 / 256
+	return
+}
+
+// ReadRotation reads the current rotation from the device and returns it in
+// µ°/s (micro-degrees/sec). This means that if you were to do a complete
+// rotation along one axis and while doing so integrate all values over time,
+// you would get a value close to 360000000.
+func (d *DeviceSPI) ReadRotation() (x int32, y int32, z int32, err error) {
+	data := []byte{0x80 | reg_GYR_XL, 0, 0, 0, 0, 0, 0}
+	d.CSB.Low()
+	err = d.Bus.Tx(data, data)
+	d.CSB.High()
+	if err != nil {
+		return
+	}
+	// First the value is converted from a pair of bytes to a signed 16-bit
+	// value and then to a signed 32-bit value to avoid integer overflow.
+	// Then the value is scaled to µ°/s (micro-degrees per second).
+	// The default is 2000°/s full scale range for -32768..32767.
+	// The formula works as follows (taking X as an example):
+	// 1. Scale from 32768 to 2000. This means that it is in °/s units.
+	//    rawX * 2000 / 32768
+	// 2. Scale to µ°/s by multiplying by 1e6.
+	//    rawX * 1e6 * 2000 / 32768
+	// 3. Simplify.
+	//    rawX * 2e9 / 32768
+	//    rawX * 1953125 / 32
+	rawX := int32(int16(uint16(data[1]) | uint16(data[2])<<8))
+	rawY := int32(int16(uint16(data[3]) | uint16(data[4])<<8))
+	rawZ := int32(int16(uint16(data[5]) | uint16(data[6])<<8))
+	x = int32(int64(rawX) * 1953125 / 32)
+	y = int32(int64(rawY) * 1953125 / 32)
+	z = int32(int64(rawZ) * 1953125 / 32)
+	return
+}
+
+// runCommand runs a BMI160 command through the CMD register. It waits for the
+// command to complete before returning.
+func (d *DeviceSPI) runCommand(command uint8) {
+	d.writeRegister(reg_CMD, command)
+	for {
+		response := d.readRegister(reg_CMD)
+		if response == 0 {
+			return // command was completed
+		}
+	}
+}
+
+// readRegister reads from a single BMI160 register. It should only be used for
+// single register reads, not for reading multiple registers at once.
+func (d *DeviceSPI) readRegister(address uint8) uint8 {
+	// I don't know why but it appears necessary to sleep for a bit here.
+	time.Sleep(time.Millisecond)
+
+	data := []byte{0x80 | address, 0}
+	d.CSB.Low()
+	d.Bus.Tx(data, data)
+	d.CSB.High()
+	return data[1]
+}
+
+// writeRegister writes a single byte BMI160 register. It should only be used
+// for writing to a single register.
+func (d *DeviceSPI) writeRegister(address, data uint8) {
+	// I don't know why but it appears necessary to sleep for a bit here.
+	time.Sleep(time.Millisecond)
+
+	d.CSB.Low()
+	d.Bus.Tx([]byte{address, data}, []byte{0, 0})
+	d.CSB.High()
+}

bmi160/registers.go

@@ -0,0 +1,44 @@
+package bmi160
+
+const (
+	reg_CHIPID        = 0x00
+	reg_ERR_REG       = 0x02
+	reg_PMU_STATUS    = 0x03
+	reg_MAG_XL        = 0x04
+	reg_MAG_XH        = 0x05
+	reg_MAG_YL        = 0x06
+	reg_MAG_YH        = 0x07
+	reg_MAG_ZL        = 0x08
+	reg_MAG_ZH        = 0x09
+	reg_RHALL_L       = 0x0A
+	reg_RHALL_H       = 0x0B
+	reg_GYR_XL        = 0x0C
+	reg_GYR_XH        = 0x0D
+	reg_GYR_YL        = 0x0E
+	reg_GYR_YH        = 0x0F
+	reg_GYR_ZL        = 0x10
+	reg_GYR_ZH        = 0x11
+	reg_ACC_XL        = 0x12
+	reg_ACC_XH        = 0x13
+	reg_ACC_YL        = 0x14
+	reg_ACC_YH        = 0x15
+	reg_ACC_ZL        = 0x16
+	reg_ACC_ZH        = 0x17
+	reg_SENSORTIME_0  = 0x18
+	reg_SENSORTIME_1  = 0x19
+	reg_SENSORTIME_2  = 0x1A
+	reg_STATUS        = 0x1B
+	reg_INT_STATUS_0  = 0x1C
+	reg_INT_STATUS_1  = 0x1D
+	reg_INT_STATUS_2  = 0x1E
+	reg_INT_STATUS_3  = 0x1F
+	reg_TEMPERATURE_0 = 0x20
+	reg_TEMPERATURE_1 = 0x21
+	reg_FIFO_LENGTH_0 = 0x22
+	reg_FIFO_LENGTH_1 = 0x23
+	reg_FIFO_DATA     = 0x24
+
+	// ...
+
+	reg_CMD = 0x7E
+)

bmp180/bmp180.go

@@ -125,7 +125,7 @@ func (d *Device) ReadPressure() (pressure int32, err error) {
 }
 
 // rawTemp returns the sensor's raw values of the temperature
-func (d *Device) rawTemp() (int16, error) {
+func (d *Device) rawTemp() (int32, error) {
 	d.bus.WriteRegister(uint8(d.Address), REG_CTRL, []byte{CMD_TEMP})
 	time.Sleep(5 * time.Millisecond)
 	data := make([]byte, 2)
@@ -133,12 +133,12 @@ func (d *Device) rawTemp() (int16, error) {
 	if err != nil {
 		return 0, err
 	}
-	return readInt(data[0], data[1]), nil
+	return int32(uint16(data[0])<<8 | uint16(data[1])), nil
 }
 
 // calculateB5 calculates intermediate value B5 as per page 15 of datasheet
-func (d *Device) calculateB5(rawTemp int16) int32 {
-	x1 := (int32(rawTemp) - int32(d.calibrationCoefficients.ac6)) * int32(d.calibrationCoefficients.ac5) >> 15
+func (d *Device) calculateB5(rawTemp int32) int32 {
+	x1 := (rawTemp - int32(d.calibrationCoefficients.ac6)) * int32(d.calibrationCoefficients.ac5) >> 15
 	x2 := int32(d.calibrationCoefficients.mc) << 11 / (x1 + int32(d.calibrationCoefficients.md))
 	return x1 + x2
 }

bmp280/bmp280.go

@@ -0,0 +1,243 @@
+package bmp280
+
+import (
+	"machine"
+	"time"
+)
+
+// OversamplingMode is the oversampling ratio of the temperature or pressure measurement.
+type Oversampling uint
+
+// Mode is the Power Mode.
+type Mode uint
+
+// Standby is the inactive period between the reads when the sensor is in normal power mode.
+type Standby uint
+
+// Filter unwanted changes in measurement caused by external (environmental) or internal changes (IC).
+type Filter uint
+
+// Device wraps an I2C connection to a BMP280 device.
+type Device struct {
+	bus         machine.I2C
+	Address     uint16
+	cali        calibrationCoefficients
+	Temperature Oversampling
+	Pressure    Oversampling
+	Mode        Mode
+	Standby     Standby
+	Filter      Filter
+}
+
+type calibrationCoefficients struct {
+	// Temperature compensation
+	t1 uint16
+	t2 int16
+	t3 int16
+
+	// Pressure compensation
+	p1 uint16
+	p2 int16
+	p3 int16
+	p4 int16
+	p5 int16
+	p6 int16
+	p7 int16
+	p8 int16
+	p9 int16
+}
+
+// New creates a new BMP280 connection. The I2C bus must already be
+// configured.
+//
+// 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 {
+	return Device{
+		bus:     bus,
+		Address: Address,
+	}
+}
+
+// Connected returns whether a BMP280 has been found.
+// It does a "who am I" request and checks the response.
+func (d *Device) Connected() bool {
+	data := make([]byte, 1)
+	d.bus.ReadRegister(uint8(d.Address), REG_ID, data)
+	return data[0] == CHIP_ID
+}
+
+// Reset preforms complete power-on-reset procedure.
+// It is required to call Configure afterwards.
+func (d *Device) Reset() {
+	d.bus.WriteRegister(uint8(d.Address), REG_RESET, []byte{CMD_RESET})
+}
+
+// Configure sets up the device for communication and
+// read the calibration coefficients.
+func (d *Device) Configure(standby Standby, filter Filter, temp Oversampling, pres Oversampling, mode Mode) {
+	d.Standby = standby
+	d.Filter = filter
+	d.Temperature = temp
+	d.Pressure = pres
+	d.Mode = mode
+
+	//  Write the configuration (standby, filter, spi 3 wire)
+	config := uint(d.Standby<<5) | uint(d.Filter<<2) | 0x00
+	d.bus.WriteRegister(uint8(d.Address), REG_CONFIG, []byte{byte(config)})
+
+	// Write the control (temperature oversampling, pressure oversampling,
+	config = uint(d.Temperature<<5) | uint(d.Pressure<<2) | uint(d.Mode)
+	d.bus.WriteRegister(uint8(d.Address), REG_CTRL_MEAS, []byte{byte(config)})
+
+	// Read Calibration data
+	data := make([]byte, 24)
+	err := d.bus.ReadRegister(uint8(d.Address), REG_CALI, data)
+	if err != nil {
+		return
+	}
+
+	// Datasheet: 3.11.2 Trimming parameter readout
+	d.cali.t1 = readUintLE(data[0], data[1])
+	d.cali.t2 = readIntLE(data[2], data[3])
+	d.cali.t3 = readIntLE(data[4], data[5])
+
+	d.cali.p1 = readUintLE(data[6], data[7])
+	d.cali.p2 = readIntLE(data[8], data[9])
+	d.cali.p3 = readIntLE(data[10], data[11])
+	d.cali.p4 = readIntLE(data[12], data[13])
+	d.cali.p5 = readIntLE(data[14], data[15])
+	d.cali.p6 = readIntLE(data[16], data[17])
+	d.cali.p7 = readIntLE(data[18], data[19])
+	d.cali.p8 = readIntLE(data[20], data[21])
+	d.cali.p9 = readIntLE(data[22], data[23])
+}
+
+// PrintCali prints the Calibration information.
+func (d *Device) PrintCali() {
+	println("T1:", d.cali.t1)
+	println("T2:", d.cali.t2)
+	println("T3:", d.cali.t3)
+
+	println("P1:", d.cali.p1)
+	println("P2:", d.cali.p2)
+	println("P3:", d.cali.p3)
+	println("P4:", d.cali.p4)
+	println("P5:", d.cali.p5)
+	println("P6:", d.cali.p6)
+	println("P7:", d.cali.p7)
+	println("P8:", d.cali.p8)
+	println("P9:", d.cali.p9, "\n")
+}
+
+// ReadTemperature returns the temperature in celsius milli degrees (°C/1000).
+func (d *Device) ReadTemperature() (temperature int32, err error) {
+	data, err := d.readData(REG_TEMP, 3)
+	if err != nil {
+		return
+	}
+
+	rawTemp := convert3Bytes(data[0], data[1], data[2])
+
+	// Datasheet: 8.2 Compensation formula in 32 bit fixed point
+	// Temperature compensation
+	var1 := ((rawTemp >> 3) - int32(d.cali.t1<<1)) * int32(d.cali.t2) >> 11
+	var2 := (((rawTemp >> 4) - int32(d.cali.t1)) * ((rawTemp >> 4) - int32(d.cali.t1)) >> 12) *
+		int32(d.cali.t3) >> 14
+
+	tFine := var1 + var2
+
+	// Convert from degrees to milli degrees by multiplying by 10.
+	// Will output 30250 milli degrees celsius for 30.25 degrees celsius
+	temperature = 10 * ((tFine*5 + 128) >> 8)
+	return
+}
+
+// ReadPressure returns the pressure in milli pascals (mPa).
+func (d *Device) ReadPressure() (pressure int32, err error) {
+	// First 3 bytes are Pressure, last 3 bytes are Temperature
+	data, err := d.readData(REG_PRES, 6)
+	if err != nil {
+		return
+	}
+
+	rawTemp := convert3Bytes(data[3], data[4], data[5])
+
+	// Datasheet: 8.2 Compensation formula in 32 bit fixed point
+	// Calculate tFine (temperature), used for the Pressure compensation
+	var1 := ((rawTemp >> 3) - int32(d.cali.t1<<1)) * int32(d.cali.t2) >> 11
+	var2 := (((rawTemp >> 4) - int32(d.cali.t1)) * ((rawTemp >> 4) - int32(d.cali.t1)) >> 12) *
+		int32(d.cali.t3) >> 14
+
+	tFine := var1 + var2
+
+	rawPres := convert3Bytes(data[0], data[1], data[2])
+
+	// Datasheet: 8.2 Compensation formula in 32 bit fixed point
+	// Pressure compensation
+	var1 = (tFine >> 1) - 64000
+	var2 = (((var1 >> 2) * (var1 >> 2)) >> 11) * int32(d.cali.p6)
+	var2 = var2 + ((var1 * int32(d.cali.p5)) << 1)
+	var2 = (var2 >> 2) + (int32(d.cali.p4) << 16)
+	var1 = (((int32(d.cali.p3) * (((var1 >> 2) * (var1 >> 2)) >> 13)) >> 3) +
+		((int32(d.cali.p2) * var1) >> 1)) >> 18
+	var1 = ((32768 + var1) * int32(d.cali.p1)) >> 15
+
+	if var1 == 0 {
+		return 0, nil
+	}
+
+	p := uint32(((1048576 - rawPres) - (var2 >> 12)) * 3125)
+	if p < 0x80000000 {
+		p = (p << 1) / uint32(var1)
+	} else {
+		p = (p / uint32(var1)) * 2
+	}
+
+	var1 = (int32(d.cali.p9) * int32(((p>>3)*(p>>3))>>13)) >> 12
+	var2 = (int32(p>>2) * int32(d.cali.p8)) >> 13
+
+	return 1000 * (int32(p) + ((var1 + var2 + int32(d.cali.p7)) >> 4)), nil
+}
+
+// readData reads n number of bytes of the specified register
+func (d *Device) readData(register int, n int) ([]byte, error) {
+	// If not in normal mode, set the mode to FORCED mode, to prevent incorrect measurements
+	// After the measurement in FORCED mode, the sensor will return to SLEEP mode
+	if d.Mode != MODE_NORMAL {
+		config := uint(d.Temperature<<5) | uint(d.Pressure<<2) | uint(MODE_FORCED)
+		d.bus.WriteRegister(uint8(d.Address), REG_CTRL_MEAS, []byte{byte(config)})
+	}
+
+	// Check STATUS register, wait if data is not available yet
+	status := make([]byte, 1)
+	for d.bus.ReadRegister(uint8(d.Address), uint8(REG_STATUS), status[0:]); status[0] != 4 && status[0] != 0; d.bus.ReadRegister(uint8(d.Address), uint8(REG_STATUS), status[0:]) {
+		time.Sleep(time.Millisecond)
+	}
+
+	// Read the requested register
+	data := make([]byte, n)
+	err := d.bus.ReadRegister(uint8(d.Address), uint8(register), data[:])
+	return data, err
+}
+
+// convert3Bytes converts three bytes to int32
+func convert3Bytes(msb byte, b1 byte, lsb byte) int32 {
+	return int32(((((uint32(msb) << 8) | uint32(b1)) << 8) | uint32(lsb)) >> 4)
+}
+
+// readUint converts two bytes to uint16
+func readUint(msb byte, lsb byte) uint16 {
+	return (uint16(msb) << 8) | uint16(lsb)
+}
+
+// readUintLE converts two little endian bytes to uint16
+func readUintLE(msb byte, lsb byte) uint16 {
+	temp := readUint(msb, lsb)
+	return (temp >> 8) | (temp << 8)
+}
+
+// readIntLE converts two little endian bytes to int16
+func readIntLE(msb byte, lsb byte) int16 {
+	return int16(readUintLE(msb, lsb))
+}

bmp280/registers.go

@@ -0,0 +1,56 @@
+// Package bmp280 provides a driver for the BMP280 digital temperature & pressure sensor by Bosch.
+//
+// Datasheet: https://www.bosch-sensortec.com/media/boschsensortec/downloads/datasheets/bst-bmp280-ds001.pdf
+package bmp280
+
+// The I2C address which this device listens to.
+const Address = 0x77
+
+// Registers
+const (
+	REG_ID        = 0xD0 // WHO_AM_I
+	REG_RESET     = 0xE0
+	REG_STATUS    = 0xF3
+	REG_CTRL_MEAS = 0xF4
+	REG_CONFIG    = 0xF5
+	REG_TEMP      = 0xFA
+	REG_PRES      = 0xF7
+	REG_CALI      = 0x88
+
+	CHIP_ID   = 0x58
+	CMD_RESET = 0xB6
+)
+
+const (
+	SAMPLING_SKIPPED Oversampling = iota
+	SAMPLING_1X
+	SAMPLING_2X
+	SAMPLING_4X
+	SAMPLING_8X
+	SAMPLING_16X
+)
+
+const (
+	MODE_SLEEP  Mode = 0x00
+	MODE_FORCED Mode = 0x01
+	MODE_NORMAL Mode = 0x03
+)
+
+const (
+	STANDBY_1MS Standby = iota
+	STANDBY_63MS
+	STANDBY_125MS
+	STANDBY_250MS
+	STANDBY_500MS
+	STANDBY_1000MS
+	STANDBY_2000MS
+	STANDBY_4000MS
+)
+
+const (
+	FILTER_OFF Filter = iota
+	FILTER_2X
+	FILTER_4X
+	FILTER_8X
+	FILTER_16X
+)

easystepper/easystepper.go

@@ -18,8 +18,7 @@ type DualDevice struct {
 	devices [2]Device
 }
 
-// New returns a new easystepper driver given 4 pins numbers (not pin object),
-// number of steps and rpm
+// New returns a new easystepper driver given 4 pins, number of steps and rpm
 func New(pin1, pin2, pin3, pin4 machine.Pin, steps int32, rpm int32) Device {
 	return Device{
 		pins:      [4]machine.Pin{pin1, pin2, pin3, pin4},
@@ -34,8 +33,7 @@ func (d *Device) Configure() {
 	}
 }
 
-// NewDual returns a new dual easystepper driver given 8 pins numbers (not pin object),
-// number of steps and rpm
+// NewDual returns a new dual easystepper driver given 8 pins, number of steps and rpm
 func NewDual(pin1, pin2, pin3, pin4, pin5, pin6, pin7, pin8 machine.Pin, steps int32, rpm int32) DualDevice {
 	var dual DualDevice
 	dual.devices[0] = Device{

examples/amg88xx/main.go

@@ -0,0 +1,56 @@
+package main
+
+import (
+	"image/color"
+	"machine"
+
+	"tinygo.org/x/drivers/st7735"
+
+	"tinygo.org/x/drivers/amg88xx"
+)
+
+func main() {
+
+	machine.SPI1.Configure(machine.SPIConfig{
+		SCK:       machine.SPI1_SCK_PIN,
+		SDO:       machine.SPI1_SDO_PIN,
+		SDI:       machine.SPI1_SDI_PIN,
+		Frequency: 8000000,
+	})
+	machine.I2C0.Configure(machine.I2CConfig{SCL: machine.SCL_PIN, SDA: machine.SDA_PIN})
+
+	display := st7735.New(machine.SPI1, machine.TFT_RST, machine.TFT_DC, machine.TFT_CS, machine.TFT_LITE)
+	display.Configure(st7735.Config{
+		Rotation: st7735.ROTATION_90,
+	})
+	display.FillScreen(color.RGBA{0, 0, 0, 255})
+
+	camera := amg88xx.New(machine.I2C0)
+	camera.Configure(amg88xx.Config{})
+
+	var data [64]int16
+	var value int16
+	for {
+		// get the values of the sensor in millicelsius
+		camera.ReadPixels(&data)
+
+		for j := int16(0); j < 8; j++ {
+			for i := int16(0); i < 8; i++ {
+				value = data[63-(i+j*8)]
+				// treat anything below 18°C as 18°C
+				if value < 18000 {
+					value = 0
+				} else {
+					value = (value - 18000) / 36
+					// our color array only have 433 values, avoid getting a value that doesn't exist
+					if value > 432 {
+						value = 432
+					}
+				}
+				// show the image on the PyBadge's display
+				display.FillRectangle(16+i*16, j*16, 16, 16, colors[value])
+			}
+		}
+	}
+
+}

examples/bmi160/main.go

@@ -0,0 +1,46 @@
+package main
+
+import (
+	"fmt"
+	"machine"
+	"time"
+	"tinygo.org/x/drivers/bmi160"
+)
+
+func main() {
+	time.Sleep(5 * time.Second)
+
+	machine.SPI0.Configure(machine.SPIConfig{})
+	sensor := bmi160.NewSPI(machine.A5, machine.SPI0)
+	sensor.Configure()
+
+	if !sensor.Connected() {
+		println("BMI160 not connected")
+		return
+	}
+
+	for {
+		time.Sleep(time.Second)
+
+		t, err := sensor.ReadTemperature()
+		if err != nil {
+			println("Error reading temperature", err)
+			continue
+		}
+		fmt.Printf("Temperature: %.2f °C\n", float32(t)/1000)
+
+		accelX, accelY, accelZ, err := sensor.ReadAcceleration()
+		if err != nil {
+			println("Error reading acceleration", err)
+			continue
+		}
+		fmt.Printf("Acceleration: %.2fg %.2fg %.2fg\n", float32(accelX)/1e6, float32(accelY)/1e6, float32(accelZ)/1e6)
+
+		gyroX, gyroY, gyroZ, err := sensor.ReadRotation()
+		if err != nil {
+			println("Error reading rotation", err)
+			continue
+		}
+		fmt.Printf("Rotation: %.2f°/s %.2f°/s %.2f°/s\n", float32(gyroX)/1e6, float32(gyroY)/1e6, float32(gyroZ)/1e6)
+	}
+}

examples/bmp280/main.go

@@ -0,0 +1,44 @@
+package main
+
+import (
+	"fmt"
+	"machine"
+	"time"
+	"tinygo.org/x/drivers/bmp280"
+)
+
+func main() {
+	time.Sleep(5 * time.Second)
+
+	machine.I2C0.Configure(machine.I2CConfig{})
+	sensor := bmp280.New(machine.I2C0)
+	sensor.Configure(bmp280.STANDBY_125MS, bmp280.FILTER_4X, bmp280.SAMPLING_16X, bmp280.SAMPLING_16X, bmp280.MODE_FORCED)
+
+	connected := sensor.Connected()
+	if !connected {
+		println("\nBMP280 Sensor not detected\n")
+		return
+	}
+	println("\nBMP280 Sensor detected\n")
+
+	println("Calibration:")
+	sensor.PrintCali()
+
+	for {
+		t, err := sensor.ReadTemperature()
+		if err != nil {
+			println("Error reading temperature")
+		}
+		// Temperature in degrees Celsius
+		fmt.Printf("Temperature: %.2f °C\n", float32(t)/1000)
+
+		p, err := sensor.ReadPressure()
+		if err != nil {
+			println("Error reading pressure")
+		}
+		// Pressure in hectoPascal
+		fmt.Printf("Pressure: %.2f hPa\n", float32(p)/100000)
+
+		time.Sleep(5 * time.Second)
+	}
+}

examples/flash/console/console_example.go

@@ -0,0 +1,259 @@
+package console_example
+
+import (
+	"fmt"
+	"io"
+	"machine"
+	"os"
+	"strconv"
+	"strings"
+
+	"tinygo.org/x/drivers/flash"
+)
+
+const consoleBufLen = 64
+const storageBufLen = 512
+
+var (
+	debug = false
+
+	input [consoleBufLen]byte
+	store [storageBufLen]byte
+
+	console = machine.UART0
+
+	dev *flash.Device
+
+	commands map[string]cmdfunc = map[string]cmdfunc{
+		"":      cmdfunc(noop),
+		"erase": cmdfunc(erase),
+		"lsblk": cmdfunc(lsblk),
+		"write": cmdfunc(write),
+		"xxd":   cmdfunc(xxd),
+	}
+)
+
+type cmdfunc func(argv []string)
+
+const (
+	StateInput = iota
+	StateEscape
+	StateEscBrc
+	StateCSI
+)
+
+func RunFor(device *flash.Device) {
+
+	dev = device
+	dev.Configure(&flash.DeviceConfig{
+		Identifier: flash.DefaultDeviceIdentifier,
+	})
+
+	prompt()
+
+	var state = StateInput
+
+	for i := 0; ; {
+		if console.Buffered() > 0 {
+			data, _ := console.ReadByte()
+			if debug {
+				fmt.Printf("\rdata: %x\r\n\r", data)
+				prompt()
+				console.Write(input[:i])
+			}
+			switch state {
+			case StateInput:
+				switch data {
+				case 0x8:
+					fallthrough
+				case 0x7f: // this is probably wrong... works on my machine tho :)
+					// backspace
+					if i > 0 {
+						i -= 1
+						console.Write([]byte{0x8, 0x20, 0x8})
+					}
+				case 13:
+					// return key
+					console.Write([]byte("\r\n"))
+					runCommand(string(input[:i]))
+					prompt()
+
+					i = 0
+					continue
+				case 27:
+					// escape
+					state = StateEscape
+				default:
+					// anything else, just echo the character if it is printable
+					if strconv.IsPrint(rune(data)) {
+						if i < (consoleBufLen - 1) {
+							console.WriteByte(data)
+							input[i] = data
+							i++
+						}
+					}
+				}
+			case StateEscape:
+				switch data {
+				case 0x5b:
+					state = StateEscBrc
+				default:
+					state = StateInput
+				}
+			default:
+				// TODO: handle escape sequences
+				state = StateInput
+			}
+		}
+	}
+}
+
+func runCommand(line string) {
+	argv := strings.SplitN(strings.TrimSpace(line), " ", -1)
+	cmd := argv[0]
+	cmdfn, ok := commands[cmd]
+	if !ok {
+		println("unknown command: " + line)
+		return
+	}
+	cmdfn(argv)
+}
+
+func noop(argv []string) {}
+
+func lsblk(argv []string) {
+	attrs := dev.Attrs()
+	status1, _ := dev.ReadStatus()
+	status2, _ := dev.ReadStatus2()
+	serialNumber1, _ := dev.ReadSerialNumber()
+	fmt.Printf(
+		"\n-------------------------------------\r\n"+
+			" Device Information:  \r\n"+
+			"-------------------------------------\r\n"+
+			" JEDEC ID: %v\r\n"+
+			" Serial:   %v\r\n"+
+			" Status 1: %02x\r\n"+
+			" Status 2: %02x\r\n"+
+			" \r\n"+
+			" Max clock speed (MHz): %d\r\n"+
+			" Has Sector Protection: %t\r\n"+
+			" Supports Fast Reads:   %t\r\n"+
+			" Supports QSPI Reads:   %t\r\n"+
+			" Supports QSPI Write:   %t\r\n"+
+			" Write Status Split:    %t\r\n"+
+			" Single Status Byte:    %t\r\n"+
+			"-------------------------------------\r\n\r\n",
+		attrs.JedecID,
+		serialNumber1,
+		status1,
+		status2,
+		attrs.MaxClockSpeedMHz,
+		attrs.HasSectorProtection,
+		attrs.SupportsFastRead,
+		attrs.SupportsQSPI,
+		attrs.SupportsQSPIWrites,
+		attrs.WriteStatusSplit,
+		attrs.SingleStatusByte,
+	)
+}
+
+func erase(argv []string) {
+	if len(argv) < 3 {
+		println("usage: erase <chip|block|sector> <bytes>")
+		return
+	}
+	var err error
+	var addr uint64 = 0x0
+	if addr, err = strconv.ParseUint(argv[2], 16, 32); err != nil {
+		println("Invalid address: " + err.Error() + "\r\n")
+		return
+	}
+	if argv[1] == "block" {
+		if err = dev.EraseBlock(uint32(addr)); err != nil {
+			println("Block erase error: " + err.Error() + "\r\n")
+		}
+	} else if argv[1] == "sector" {
+		if err = dev.EraseSector(uint32(addr)); err != nil {
+			println("Sector erase error: " + err.Error() + "\r\n")
+		}
+	} else if argv[1] == "chip" {
+		if err = dev.EraseAll(); err != nil {
+			println("Chip erase error: " + err.Error() + "\r\n")
+		}
+	} else {
+		println("usage: erase <chip|block|sector> <bytes>")
+	}
+}
+
+func write(argv []string) {
+	if len(argv) < 3 {
+		println("usage: write <hex offset> <bytes>")
+	}
+	var err error
+	var addr uint64 = 0x0
+	if addr, err = strconv.ParseUint(argv[1], 16, 32); err != nil {
+		println("Invalid address: " + err.Error() + "\r\n")
+		return
+	}
+	buf := []byte(argv[2])
+	if _, err = dev.WriteAt(buf, int64(addr)); err != nil {
+		println("Write error: " + err.Error() + "\r\n")
+	}
+}
+
+func xxd(argv []string) {
+	var err error
+	var addr uint64 = 0x0
+	var size int = 64
+	switch len(argv) {
+	case 3:
+		if size, err = strconv.Atoi(argv[2]); err != nil {
+			println("Invalid size argument: " + err.Error() + "\r\n")
+			return
+		}
+		if size > storageBufLen || size < 1 {
+			fmt.Printf("Size of hexdump must be greater than 0 and less than %d\r\n", storageBufLen)
+			return
+		}
+		fallthrough
+	case 2:
+		if addr, err = strconv.ParseUint(argv[1], 16, 32); err != nil {
+			println("Invalid address: " + err.Error() + "\r\n")
+			return
+		}
+		fallthrough
+	case 1:
+		// no args supplied, so nothing to do here, just use the defaults
+	default:
+		println("usage: xxd <hex address, ex: 0xA0> <size of hexdump in bytes>\r\n")
+		return
+	}
+	buf := store[0:size]
+	dev.ReadAt(buf, int64(addr))
+	xxdfprint(os.Stdout, uint32(addr), buf)
+}
+
+func xxdfprint(w io.Writer, offset uint32, b []byte) {
+	var l int
+	var buf16 = make([]byte, 16)
+	for i, c := 0, len(b); i < c; i += 16 {
+		l = i + 16
+		if l >= c {
+			l = c
+		}
+		fmt.Fprintf(w, "%08x: % x    ", offset+uint32(i), b[i:l])
+		for j, n := 0, l-i; j < 16; j++ {
+			if j >= n || !strconv.IsPrint(rune(b[i+j])) {
+				buf16[j] = '.'
+			} else {
+				buf16[j] = b[i+j]
+			}
+		}
+		console.Write(buf16)
+		println()
+	}
+}
+
+func prompt() {
+	print("==> ")
+}

examples/flash/console/qspi/main.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+	"machine"
+
+	"tinygo.org/x/drivers/examples/flash/console"
+	"tinygo.org/x/drivers/flash"
+)
+
+func main() {
+	console_example.RunFor(
+		flash.NewQSPI(
+			machine.QSPI_CS,
+			machine.QSPI_SCK,
+			machine.QSPI_DATA0,
+			machine.QSPI_DATA1,
+			machine.QSPI_DATA2,
+			machine.QSPI_DATA3,
+		),
+	)
+}

examples/flash/console/spi/main.go

@@ -0,0 +1,20 @@
+package main
+
+import (
+	"machine"
+
+	console_example "tinygo.org/x/drivers/examples/flash/console"
+	"tinygo.org/x/drivers/flash"
+)
+
+func main() {
+	console_example.RunFor(
+		flash.NewSPI(
+			&machine.SPI1,
+			machine.SPI1_SDO_PIN,
+			machine.SPI1_SDI_PIN,
+			machine.SPI1_SCK_PIN,
+			machine.SPI1_CS_PIN,
+		),
+	)
+}

examples/hcsr04/main.go

@@ -0,0 +1,20 @@
+package hcsr04
+
+import (
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/hcsr04"
+)
+
+func main() {
+	sensor := hcsr04.New(machine.D10, machine.D9)
+	sensor.Configure()
+
+	println("Ultrasonic starts")
+	for {
+		println("Distance:", sensor.ReadDistance(), "mm")
+
+		time.Sleep(100 * time.Millisecond)
+	}
+}

examples/hd44780i2c/main.go

@@ -0,0 +1,60 @@
+package main
+
+import (
+	"machine"
+	"strconv"
+	"time"
+
+	"tinygo.org/x/drivers/hd44780i2c"
+)
+
+func main() {
+
+	// Note: most HD44780 LCD modules requires 5V power, however some variations
+	// use 3.3V (and may be damaged by 5V).
+
+	machine.I2C0.Configure(machine.I2CConfig{
+		Frequency: machine.TWI_FREQ_400KHZ,
+	})
+
+	lcd := hd44780i2c.New(machine.I2C0, 0x27) // some modules have address 0x3F
+
+	lcd.Configure(hd44780i2c.Config{
+		Width:       16, // required
+		Height:      2,  // required
+		CursorOn:    true,
+		CursorBlink: true,
+	})
+
+	lcd.Print([]byte(" TinyGo\n  LCD Test "))
+
+	// CGRAM address 0x0-0x7 can be used to store 8 custom characters
+	lcd.CreateCharacter(0x0, []byte{0x00, 0x11, 0x0E, 0x1F, 0x15, 0x1F, 0x1F, 0x1F})
+	lcd.Print([]byte{0x0})
+
+	// You can use https://maxpromer.github.io/LCD-Character-Creator/
+	// to crete your own characters.
+
+	time.Sleep(time.Millisecond * 7000)
+
+	for i := 0; i < 5; i++ {
+		lcd.BacklightOn(false)
+		time.Sleep(time.Millisecond * 250)
+		lcd.BacklightOn(true)
+		time.Sleep(time.Millisecond * 250)
+	}
+
+	lcd.CursorOn(false)
+	lcd.CursorBlink(false)
+
+	i := 0
+	for {
+
+		lcd.ClearDisplay()
+		lcd.SetCursor(2, 1)
+		lcd.Print([]byte(strconv.FormatInt(int64(i), 10)))
+		i++
+		time.Sleep(time.Millisecond * 100)
+
+	}
+}

examples/ili9341/basic/atsamd21.go

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

examples/ili9341/basic/main.go

@@ -9,15 +9,6 @@ import (
 )
 
 var (
-	display = ili9341.NewParallel(
-		machine.LCD_DATA0,
-		machine.TFT_WR,
-		machine.TFT_DC,
-		machine.TFT_CS,
-		machine.TFT_RESET,
-		machine.TFT_RD,
-	)
-
 	black = color.RGBA{0, 0, 0, 255}
 	white = color.RGBA{255, 255, 255, 255}
 	red   = color.RGBA{255, 0, 0, 255}
@@ -27,13 +18,13 @@ var (
 
 func main() {
 
-	machine.TFT_BACKLIGHT.Configure(machine.PinConfig{machine.PinOutput})
+	backlight.Configure(machine.PinConfig{machine.PinOutput})
 
 	display.Configure(ili9341.Config{})
 	width, height := display.Size()
 
 	display.FillScreen(black)
-	machine.TFT_BACKLIGHT.High()
+	backlight.High()
 
 	display.FillRectangle(0, 0, width/2, height/2, white)
 	display.FillRectangle(width/2, 0, width/2, height/2, red)

examples/ili9341/basic/pyportal.go

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

examples/ili9341/basic/wioterminal.go

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

examples/ili9341/pyportal_boing/main.go

@@ -25,15 +25,6 @@ const (
 )
 
 var (
-	display = ili9341.NewParallel(
-		machine.LCD_DATA0,
-		machine.TFT_WR,
-		machine.TFT_DC,
-		machine.TFT_CS,
-		machine.TFT_RESET,
-		machine.TFT_RD,
-	)
-
 	frameBuffer = [(graphics.BALLHEIGHT + 8) * (graphics.BALLWIDTH + 8)]uint16{}
 
 	startTime int64
@@ -56,7 +47,7 @@ var (
 func main() {
 
 	// configure backlight
-	machine.TFT_BACKLIGHT.Configure(machine.PinConfig{machine.PinOutput})
+	backlight.Configure(machine.PinConfig{machine.PinOutput})
 
 	// configure display
 	display.Configure(ili9341.Config{})
@@ -64,7 +55,7 @@ func main() {
 	width, height := display.Size()
 	println(width, height)
 
-	machine.TFT_BACKLIGHT.High()
+	backlight.High()
 
 	display.SetRotation(ili9341.Rotation270)
 	DrawBackground()

examples/ili9341/pyportal_boing/pyportal.go

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

examples/ili9341/pyportal_boing/wioterminal.go

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

examples/ili9341/scroll/atsamd21.go

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

examples/ili9341/scroll/main.go

@@ -9,15 +9,6 @@ import (
 )
 
 var (
-	display = ili9341.NewParallel(
-		machine.LCD_DATA0,
-		machine.TFT_WR,
-		machine.TFT_DC,
-		machine.TFT_CS,
-		machine.TFT_RESET,
-		machine.TFT_RD,
-	)
-
 	red   = color.RGBA{255, 0, 0, 255}
 	blue  = color.RGBA{0, 0, 255, 255}
 	green = color.RGBA{0, 255, 0, 255}
@@ -27,13 +18,13 @@ var (
 
 func main() {
 
-	machine.TFT_BACKLIGHT.Configure(machine.PinConfig{machine.PinOutput})
+	backlight.Configure(machine.PinConfig{machine.PinOutput})
 
 	display.Configure(ili9341.Config{})
 	width, height := display.Size()
 
 	display.FillScreen(black)
-	machine.TFT_BACKLIGHT.High()
+	backlight.High()
 
 	display.FillRectangle(0, 0, width/2, height/2, white)
 	display.FillRectangle(width/2, 0, width/2, height/2, red)

examples/ili9341/scroll/pyportal.go

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

examples/ili9341/scroll/wioterminal.go

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

examples/lsm303agr/main.go

@@ -0,0 +1,39 @@
+package main
+
+import (
+	"machine"
+	"time"
+	"tinygo.org/x/drivers/lsm303agr"
+)
+
+func main() {
+
+	machine.I2C0.Configure(machine.I2CConfig{})
+	accel_mag := lsm303agr.New(machine.I2C0)
+
+	if !accel_mag.Connected() {
+		println("LSM303AGR/MAG not connected!")
+		return
+	}
+
+	accel_mag.Configure(lsm303agr.Configuration{}) //default settings
+
+	for {
+
+		accel_x, accel_y, accel_z := accel_mag.ReadAcceleration()
+		pitch, roll := accel_mag.ReadPitchRoll()
+		mag_x, mag_y, mag_z := accel_mag.ReadMagneticField()
+		heading := accel_mag.ReadCompass()
+		temp, _ := accel_mag.ReadTemperature()
+
+		println("ACCEL_X:", accel_x, " ACCEL_Y:", accel_y, " ACCEL_Z:", accel_z)
+		println("MAG_X:", mag_x, " MAG_Y:", mag_y, " MAG_Z:", mag_z)
+		println("Pitch:", pitch, " Roll:", roll)
+		println("Heading:", heading)
+		println("Temperature:", temp/1000)
+		println("\n")
+
+		time.Sleep(time.Millisecond * 100)
+	}
+
+}

examples/ssd1351/main.go

@@ -0,0 +1,36 @@
+package ssd1351
+
+import (
+	"machine"
+
+	"image/color"
+
+	"tinygo.org/x/drivers/ssd1351"
+)
+
+func main() {
+	machine.SPI1.Configure(machine.SPIConfig{
+		Frequency: 2000000,
+	})
+	display := ssd1351.New(machine.SPI1, machine.D18, machine.D17, machine.D16, machine.D4, machine.D19)
+
+	display.Configure(ssd1351.Config{
+		Width:        96,
+		Height:       96,
+		ColumnOffset: 16,
+	})
+
+	width, height := display.Size()
+
+	white := color.RGBA{255, 255, 255, 255}
+	red := color.RGBA{255, 0, 0, 255}
+	blue := color.RGBA{0, 0, 255, 255}
+	green := color.RGBA{0, 255, 0, 255}
+
+	display.FillRectangle(0, 0, width, height/4, white)
+	display.FillRectangle(0, height/4, width, height/4, red)
+	display.FillRectangle(0, height/2, width, height/4, green)
+	display.FillRectangle(0, 3*height/4, width, height/4, blue)
+
+	display.Display()
+}

examples/tmp102/main.go

@@ -0,0 +1,28 @@
+package main
+
+import (
+	"fmt"
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/tmp102"
+)
+
+func main() {
+	machine.I2C0.Configure(machine.I2CConfig{
+		Frequency: machine.TWI_FREQ_400KHZ,
+	})
+
+	thermo := tmp102.New(machine.I2C0)
+	thermo.Configure(tmp102.Config{})
+
+	for {
+
+		temp, _ := thermo.ReadTemperature()
+
+		print(fmt.Sprintf("%.2f°C\r\n", float32(temp)/1000.0))
+
+		time.Sleep(time.Millisecond * 1000)
+	}
+
+}

examples/wifinina/mqttclient/main.go

@@ -62,8 +62,8 @@ func main() {
 	// Configure SPI for 8Mhz, Mode 0, MSB First
 	spi.Configure(machine.SPIConfig{
 		Frequency: 8 * 1e6,
-		MOSI:      machine.NINA_MOSI,
-		MISO:      machine.NINA_MISO,
+		SDO:       machine.NINA_SDO,
+		SDI:       machine.NINA_SDI,
 		SCK:       machine.NINA_SCK,
 	})
 

examples/wifinina/mqttsub/main.go

@@ -69,8 +69,8 @@ func main() {
 	// Configure SPI for 8Mhz, Mode 0, MSB First
 	spi.Configure(machine.SPIConfig{
 		Frequency: 8 * 1e6,
-		MOSI:      machine.NINA_MOSI,
-		MISO:      machine.NINA_MISO,
+		SDO:       machine.NINA_SDO,
+		SDI:       machine.NINA_SDI,
 		SCK:       machine.NINA_SCK,
 	})
 

examples/wifinina/ntpclient/main.go

@@ -0,0 +1,166 @@
+// This is an example of using the wifinina driver to implement a NTP client.
+// It creates a UDP connection to request the current time and parse the
+// response from a NTP server.
+package main
+
+import (
+	"errors"
+	"fmt"
+	"machine"
+	"runtime"
+	"time"
+
+	"tinygo.org/x/drivers/net"
+	"tinygo.org/x/drivers/wifinina"
+)
+
+// access point info
+const ssid = ""
+const pass = ""
+
+// IP address of the server aka "hub". Replace with your own info.
+const 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
+)
+
+func main() {
+
+	// Init esp32
+	// Configure SPI for 8Mhz, Mode 0, MSB First
+	machine.NINA_SPI.Configure(machine.SPIConfig{
+		Frequency: 8 * 1e6,
+		SDO:       machine.NINA_SDO,
+		SDI:       machine.NINA_SDI,
+		SCK:       machine.NINA_SCK,
+	})
+	adaptor.Configure()
+
+	// connect to access point
+	connectToAP()
+
+	// now make UDP connection
+	ip := net.ParseIP(ntpHost)
+	raddr := &net.UDPAddr{IP: ip, Port: 123}
+	laddr := &net.UDPAddr{Port: 2390}
+	conn, err := net.DialUDP("udp", laddr, raddr)
+	if err != nil {
+		for {
+			time.Sleep(time.Second)
+			println(err)
+		}
+	}
+
+	for {
+		// send data
+		println("Requesting NTP time...")
+		t, err := getCurrentTime(conn)
+		if err != nil {
+			message("Error getting current time: %v", err)
+		} else {
+			message("NTP time: %v", t)
+		}
+		runtime.AdjustTimeOffset(-1 * int64(time.Since(t)))
+		for i := 0; i < 10; i++ {
+			message("Current time: %v", time.Now())
+			time.Sleep(1 * time.Second)
+		}
+	}
+
+	// Right now this code is never reached. Need a way to trigger it...
+	println("Disconnecting UDP...")
+	conn.Close()
+	println("Done.")
+}
+
+func getCurrentTime(conn *net.UDPSerialConn) (time.Time, error) {
+	if err := sendNTPpacket(conn); err != nil {
+		return time.Time{}, err
+	}
+	clearBuffer()
+	for now := time.Now(); time.Since(now) < time.Second; {
+		time.Sleep(5 * time.Millisecond)
+		if n, err := conn.Read(b); err != nil {
+			return time.Time{}, fmt.Errorf("error reading UDP packet: %w", err)
+		} else if n == 0 {
+			continue // no packet received yet
+		} else if n != NTP_PACKET_SIZE {
+			if n != NTP_PACKET_SIZE {
+				return time.Time{}, fmt.Errorf("expected NTP packet size of %d: %d", NTP_PACKET_SIZE, n)
+			}
+		}
+		return parseNTPpacket(), nil
+	}
+	return time.Time{}, errors.New("no packet received after 1 second")
+}
+
+func sendNTPpacket(conn *net.UDPSerialConn) error {
+	clearBuffer()
+	b[0] = 0b11100011 // LI, Version, Mode
+	b[1] = 0          // Stratum, or type of clock
+	b[2] = 6          // Polling Interval
+	b[3] = 0xEC       // Peer Clock Precision
+	// 8 bytes of zero for Root Delay & Root Dispersion
+	b[12] = 49
+	b[13] = 0x4E
+	b[14] = 49
+	b[15] = 52
+	if _, err := conn.Write(b); err != nil {
+		return err
+	}
+	return nil
+}
+
+func parseNTPpacket() time.Time {
+	// the timestamp starts at byte 40 of the received packet and is four bytes,
+	// this is NTP time (seconds since Jan 1 1900):
+	t := uint32(b[40])<<24 | uint32(b[41])<<16 | uint32(b[42])<<8 | uint32(b[43])
+	const seventyYears = 2208988800
+	return time.Unix(int64(t-seventyYears), 0)
+}
+
+func clearBuffer() {
+	for i := range b {
+		b[i] = 0
+	}
+}
+
+// connect to access point
+func connectToAP() {
+	time.Sleep(2 * time.Second)
+	message("Connecting to " + ssid)
+	adaptor.SetPassphrase(ssid, pass)
+	for st, _ := adaptor.GetConnectionStatus(); st != wifinina.StatusConnected; {
+		message("Connection status: " + st.String())
+		time.Sleep(1 * time.Second)
+		st, _ = adaptor.GetConnectionStatus()
+	}
+	message("Connected.")
+	time.Sleep(2 * time.Second)
+	ip, _, _, err := adaptor.GetIP()
+	for ; err != nil; ip, _, _, err = adaptor.GetIP() {
+		message(err.Error())
+		time.Sleep(1 * time.Second)
+	}
+	message(ip.String())
+}
+
+func message(format string, args ...interface{}) {
+	println(fmt.Sprintf(format, args...), "\r")
+}

examples/wifinina/tcpclient/main.go

@@ -55,8 +55,8 @@ func main() {
 	// Configure SPI for 8Mhz, Mode 0, MSB First
 	spi.Configure(machine.SPIConfig{
 		Frequency: 8 * 1e6,
-		MOSI:      machine.NINA_MOSI,
-		MISO:      machine.NINA_MISO,
+		SDO:       machine.NINA_SDO,
+		SDI:       machine.NINA_SDI,
 		SCK:       machine.NINA_SCK,
 	})
 

examples/wifinina/udpstation/main.go

@@ -0,0 +1,100 @@
+// This is a sensor station that uses a ESP32 running nina-fw over SPI.
+// It creates a UDP connection you can use to get info to/from your computer via the microcontroller.
+//
+// In other words:
+// Your computer <--> UART0 <--> MCU <--> SPI <--> ESP32
+//
+package main
+
+import (
+	"machine"
+	"strconv"
+	"time"
+
+	"tinygo.org/x/drivers/net"
+	"tinygo.org/x/drivers/wifinina"
+)
+
+// access point info
+const ssid = ""
+const pass = ""
+
+// IP address of the server aka "hub". Replace with your own info.
+const 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,
+	}
+)
+
+func main() {
+
+	// Init esp8266/esp32
+	// Configure SPI for 8Mhz, Mode 0, MSB First
+	machine.NINA_SPI.Configure(machine.SPIConfig{
+		Frequency: 8 * 1e6,
+		SDO:       machine.NINA_SDO,
+		SDI:       machine.NINA_SDI,
+		SCK:       machine.NINA_SCK,
+	})
+	adaptor.Configure()
+
+	// connect to access point
+	connectToAP()
+
+	// now make UDP connection
+	ip := net.ParseIP(hubIP)
+	raddr := &net.UDPAddr{IP: ip, Port: 2222}
+	laddr := &net.UDPAddr{Port: 2222}
+
+	println("Dialing UDP connection...")
+	conn, _ := net.DialUDP("udp", laddr, raddr)
+
+	for {
+		// send data
+		println("Sending data...")
+		for i := 0; i < 25; i++ {
+			conn.Write([]byte("hello " + strconv.Itoa(i) + "\r\n"))
+		}
+		time.Sleep(1000 * time.Millisecond)
+	}
+
+	// Right now this code is never reached. Need a way to trigger it...
+	println("Disconnecting UDP...")
+	conn.Close()
+	println("Done.")
+}
+
+// connect to access point
+func connectToAP() {
+	time.Sleep(2 * time.Second)
+	message("Connecting to " + ssid)
+	adaptor.SetPassphrase(ssid, pass)
+	for st, _ := adaptor.GetConnectionStatus(); st != wifinina.StatusConnected; {
+		message("Connection status: " + st.String())
+		time.Sleep(1 * time.Second)
+		st, _ = adaptor.GetConnectionStatus()
+	}
+	message("Connected.")
+	time.Sleep(2 * time.Second)
+	ip, _, _, err := adaptor.GetIP()
+	for ; err != nil; ip, _, _, err = adaptor.GetIP() {
+		message(err.Error())
+		time.Sleep(1 * time.Second)
+	}
+	message(ip.String())
+}
+
+func message(msg string) {
+	println(msg, "\r")
+}

examples/wifinina/webclient/main.go

@@ -56,8 +56,8 @@ func main() {
 	// Configure SPI for 8Mhz, Mode 0, MSB First
 	spi.Configure(machine.SPIConfig{
 		Frequency: 8 * 1e6,
-		MOSI:      machine.NINA_MOSI,
-		MISO:      machine.NINA_MISO,
+		SDO:       machine.NINA_SDO,
+		SDI:       machine.NINA_SDI,
 		SCK:       machine.NINA_SCK,
 	})
 

flash/devices.go

@@ -0,0 +1,448 @@
+package flash
+
+import "time"
+
+// A DeviceIdentifier can be passed to the Configure() method of a flash Device
+// in order provide a means of discovery of device-specific attributes based on
+// the JEDEC ID read from the device.
+type DeviceIdentifier interface {
+	// Identify returns an Attrs struct based on the provided JEDEC ID
+	Identify(id JedecID) Attrs
+}
+
+// DeviceIdentifierFunc is a functional Identifier implementation
+type DeviceIdentifierFunc func(id JedecID) Attrs
+
+// Identify implements the Identifier interface
+func (fn DeviceIdentifierFunc) Identify(id JedecID) Attrs {
+	return fn(id)
+}
+
+// DefaultDeviceIndentifier is a DeviceIdentifier that is capable of recognizing
+// JEDEC IDs for all of the known memory devices in this package. If you are
+// have no way to be sure about the type of memory device that might be on a
+// board you are targeting, this can be a good starting point to use.  The
+// downside of using this function is that it will prevent the compiler from
+// being able to mark any of the functions for the various devices as unused,
+// resulting in larger code size.  If code size is a concern, and if you know
+// ahead of time you are only dealing with a limited set of memory devices, it
+// might be worthwhile to use your own implementation of a DeviceIdentifier
+// that only references those devices, so that more methods are marked unused.
+var DefaultDeviceIdentifier = DeviceIdentifierFunc(func(id JedecID) Attrs {
+	switch id.Uint32() {
+	case 0x010617:
+		return S25FL064L()
+	case 0x014015:
+		return S25FL216K()
+	case 0x1F4501:
+		return AT25DF081A()
+	case 0xC22015:
+		return MX25L1606()
+	case 0xC22016:
+		return MX25L3233F()
+	case 0xC22817:
+		return MX25R6435F()
+	case 0xC84015:
+		return GD25Q16C()
+	case 0xC84017:
+		return GD25Q64C()
+	case 0xEF4015:
+		return W25Q16JVIQ()
+	case 0xEF4016:
+		return W25Q32FV()
+	case 0xEF4017:
+		return W25Q64JVIQ()
+	case 0xEF4018:
+		return W25Q128JVSQ()
+	case 0xEF6014:
+		return W25Q80DL()
+	case 0xEF6015:
+		return W25Q16FW()
+	case 0xEF6016:
+		return W25Q32BV()
+	case 0xEF7015:
+		return W25Q16JVIM()
+	case 0xEF7016:
+		return W25Q32JVIM()
+	case 0xEF7017:
+		return W25Q64JVIM()
+	case 0xEF7018:
+		return W25Q128JVPM()
+	default:
+		return Attrs{JedecID: id}
+	}
+})
+
+// Settings for the Cypress (was Spansion) S25FL064L 8MiB SPI flash.
+// Datasheet: http://www.cypress.com/file/316661/download
+func S25FL064L() Attrs {
+	return Attrs{
+		TotalSize:           1 << 23, // 8 MiB
+		StartUp:             300 * time.Microsecond,
+		JedecID:             JedecID{0x01, 0x60, 0x17},
+		MaxClockSpeedMHz:    108,
+		QuadEnableBitMask:   0x02,
+		HasSectorProtection: false,
+		SupportsFastRead:    true,
+		SupportsQSPI:        true,
+		SupportsQSPIWrites:  true,
+		WriteStatusSplit:    false,
+		SingleStatusByte:    false,
+	}
+}
+
+// Settings for the Cypress (was Spansion) S25FL116K 2MiB SPI flash.
+// Datasheet: http://www.cypress.com/file/196886/download
+func S25FL116K() Attrs {
+	return Attrs{
+		TotalSize:           1 << 21, // 2 MiB
+		StartUp:             10000 * time.Microsecond,
+		JedecID:             JedecID{0x01, 0x40, 0x15},
+		MaxClockSpeedMHz:    108,
+		QuadEnableBitMask:   0x02,
+		HasSectorProtection: false,
+		SupportsFastRead:    true,
+		SupportsQSPI:        true,
+		SupportsQSPIWrites:  false,
+		WriteStatusSplit:    false,
+		SingleStatusByte:    false,
+	}
+}
+
+// Settings for the Cypress (was Spansion) S25FL216K 2MiB SPI flash.
+// Datasheet: http://www.cypress.com/file/197346/download
+func S25FL216K() Attrs {
+	return Attrs{
+		TotalSize:           1 << 21, // 2 MiB
+		StartUp:             10000 * time.Microsecond,
+		JedecID:             JedecID{0x01, 0x40, 0x15},
+		MaxClockSpeedMHz:    65,
+		QuadEnableBitMask:   0x02,
+		HasSectorProtection: false,
+		SupportsFastRead:    true,
+		SupportsQSPI:        true,
+		SupportsQSPIWrites:  false,
+		WriteStatusSplit:    false,
+		SingleStatusByte:    false,
+	}
+}
+
+// Settings for the Adesto Tech AT25DF081A 1MiB SPI flash. Its on the SAMD21
+// Xplained board.
+// Datasheet: https://www.adestotech.com/wp-content/uploads/doc8715.pdf
+func AT25DF081A() Attrs {
+	return Attrs{
+		TotalSize:           1 << 20, // 1 MiB
+		StartUp:             10000 * time.Microsecond,
+		JedecID:             JedecID{0x1F, 0x45, 0x01},
+		MaxClockSpeedMHz:    85,
+		QuadEnableBitMask:   0x00,
+		HasSectorProtection: true,
+		SupportsFastRead:    true,
+		SupportsQSPI:        false,
+		SupportsQSPIWrites:  false,
+		WriteStatusSplit:    false,
+		SingleStatusByte:    false,
+	}
+}
+
+// Settings for the Macronix MX25L1606 2MiB SPI flash.
+// Datasheet:
+func MX25L1606() Attrs {
+	return Attrs{
+		TotalSize:           1 << 21, // 2 MiB,
+		StartUp:             5000 * time.Microsecond,
+		JedecID:             JedecID{0xC2, 0x20, 0x15},
+		MaxClockSpeedMHz:    8,
+		QuadEnableBitMask:   0x40,
+		HasSectorProtection: false,
+		SupportsFastRead:    true,
+		SupportsQSPI:        true,
+		SupportsQSPIWrites:  true,
+		WriteStatusSplit:    false,
+		SingleStatusByte:    true,
+	}
+}
+
+// Settings for the Macronix MX25L3233F 4MiB SPI flash.
+// Datasheet:
+// http://www.macronix.com/Lists/Datasheet/Attachments/7426/MX25L3233F,%203V,%2032Mb,%20v1.6.pdf
+func MX25L3233F() Attrs {
+	return Attrs{
+		TotalSize:           1 << 22, // 4 MiB
+		StartUp:             5000 * time.Microsecond,
+		JedecID:             JedecID{0xC2, 0x20, 0x16},
+		MaxClockSpeedMHz:    133,
+		QuadEnableBitMask:   0x40,
+		HasSectorProtection: false,
+		SupportsFastRead:    true,
+		SupportsQSPI:        true,
+		SupportsQSPIWrites:  true,
+		WriteStatusSplit:    false,
+		SingleStatusByte:    false,
+	}
+}
+
+// Settings for the Macronix MX25R6435F 8MiB SPI flash.
+// Datasheet:
+// http://www.macronix.com/Lists/Datasheet/Attachments/7428/MX25R6435F,%20Wide%20Range,%2064Mb,%20v1.4.pdf
+// By default its in lower power mode which can only do 8mhz. In high power mode
+// it can do 80mhz.
+func MX25R6435F() Attrs {
+	return Attrs{
+		TotalSize:           1 << 23, // 8 MiB
+		StartUp:             5000 * time.Microsecond,
+		JedecID:             JedecID{0xC2, 0x28, 0x17},
+		MaxClockSpeedMHz:    8,
+		QuadEnableBitMask:   0x40,
+		HasSectorProtection: false,
+		SupportsFastRead:    true,
+		SupportsQSPI:        true,
+		SupportsQSPIWrites:  true,
+		WriteStatusSplit:    false,
+		SingleStatusByte:    true,
+	}
+}
+
+// Settings for the Gigadevice GD25Q16C 2MiB SPI flash.
+// Datasheet: http://www.gigadevice.com/datasheet/gd25q16c/
+func GD25Q16C() Attrs {
+	return Attrs{
+		TotalSize:          1 << 21, // 2 MiB
+		StartUp:            5000 * time.Microsecond,
+		JedecID:            JedecID{0xC8, 0x40, 0x15},
+		MaxClockSpeedMHz:   104,
+		QuadEnableBitMask:  0x02,
+		SupportsFastRead:   true,
+		SupportsQSPI:       true,
+		SupportsQSPIWrites: true,
+		WriteStatusSplit:   false,
+		SingleStatusByte:   false,
+	}
+}
+
+// Settings for the Gigadevice GD25Q64C 8MiB SPI flash.
+// Datasheet: http://www.elm-tech.com/en/products/spi-flash-memory/gd25q64/gd25q64.pdf
+func GD25Q64C() Attrs {
+	return Attrs{
+		TotalSize:           1 << 23, // 8 MiB
+		StartUp:             5000 * time.Microsecond,
+		JedecID:             JedecID{0xC8, 0x40, 0x17},
+		MaxClockSpeedMHz:    104,
+		QuadEnableBitMask:   0x02,
+		HasSectorProtection: false,
+		SupportsFastRead:    true,
+		SupportsQSPI:        true,
+		SupportsQSPIWrites:  true,
+		WriteStatusSplit:    true,
+		SingleStatusByte:    false,
+	}
+}
+
+// Settings for the Winbond W25Q16JV-IQ 2MiB SPI flash. Note that JV-IM has a
+// different .memory_type (0x70) Datasheet:
+// https://www.winbond.com/resource-files/w25q16jv%20spi%20revf%2005092017.pdf
+func W25Q16JVIQ() Attrs {
+	return Attrs{
+		TotalSize:           1 << 21, // 2 MiB
+		StartUp:             5000 * time.Microsecond,
+		JedecID:             JedecID{0xEF, 0x40, 0x15},
+		MaxClockSpeedMHz:    133,
+		QuadEnableBitMask:   0x02,
+		HasSectorProtection: false,
+		SupportsFastRead:    true,
+		SupportsQSPI:        true,
+		SupportsQSPIWrites:  true,
+		WriteStatusSplit:    false,
+		SingleStatusByte:    false,
+	}
+}
+
+// Settings for the Winbond W25Q16FW 2MiB SPI flash.
+// Datasheet:
+// https://www.winbond.com/resource-files/w25q16fw%20revj%2005182017%20sfdp.pdf
+func W25Q16FW() Attrs {
+	return Attrs{
+		TotalSize:           1 << 21, // 2 MiB
+		StartUp:             5000 * time.Microsecond,
+		JedecID:             JedecID{0xEF, 0x60, 0x15},
+		MaxClockSpeedMHz:    133,
+		QuadEnableBitMask:   0x02,
+		HasSectorProtection: false,
+		SupportsFastRead:    true,
+		SupportsQSPI:        true,
+		SupportsQSPIWrites:  true,
+		WriteStatusSplit:    false,
+		SingleStatusByte:    false,
+	}
+}
+
+// Settings for the Winbond W25Q16JV-IM 2MiB SPI flash. Note that JV-IQ has a
+// different .memory_type (0x40) Datasheet:
+// https://www.winbond.com/resource-files/w25q16jv%20spi%20revf%2005092017.pdf
+func W25Q16JVIM() Attrs {
+	return Attrs{
+		TotalSize:           1 << 21, // 2 MiB
+		StartUp:             5000 * time.Microsecond,
+		JedecID:             JedecID{0xEF, 0x70, 0x15},
+		MaxClockSpeedMHz:    133,
+		QuadEnableBitMask:   0x02,
+		HasSectorProtection: false,
+		SupportsFastRead:    true,
+		SupportsQSPI:        true,
+		SupportsQSPIWrites:  true,
+		WriteStatusSplit:    false,
+		SingleStatusByte:    false,
+	}
+}
+
+// Settings for the Winbond W25Q32BV 4MiB SPI flash.
+// Datasheet:
+// https://www.winbond.com/resource-files/w25q32bv_revi_100413_wo_automotive.pdf
+func W25Q32BV() Attrs {
+	return Attrs{
+		TotalSize:           1 << 22, // 4 MiB
+		StartUp:             10000 * time.Microsecond,
+		JedecID:             JedecID{0xEF, 0x60, 0x16},
+		MaxClockSpeedMHz:    104,
+		QuadEnableBitMask:   0x02,
+		HasSectorProtection: false,
+		SupportsFastRead:    true,
+		SupportsQSPI:        true,
+		SupportsQSPIWrites:  false,
+		WriteStatusSplit:    false,
+		SingleStatusByte:    false,
+	}
+}
+
+// Settings for the Winbond W25Q32JV-IM 4MiB SPI flash.
+// Datasheet:
+// https://www.winbond.com/resource-files/w25q32jv%20revg%2003272018%20plus.pdf
+func W25Q32JVIM() Attrs {
+	return Attrs{
+		TotalSize:           1 << 22, // 4 MiB
+		StartUp:             5000 * time.Microsecond,
+		JedecID:             JedecID{0xEF, 0x70, 0x16},
+		MaxClockSpeedMHz:    133,
+		QuadEnableBitMask:   0x02,
+		HasSectorProtection: false,
+		SupportsFastRead:    true,
+		SupportsQSPI:        true,
+		SupportsQSPIWrites:  true,
+		WriteStatusSplit:    false,
+		SingleStatusByte:    false,
+	}
+}
+
+// Settings for the Winbond W25Q64JV-IM 8MiB SPI flash. Note that JV-IQ has a
+// different .memory_type (0x40) Datasheet:
+// http://www.winbond.com/resource-files/w25q64jv%20revj%2003272018%20plus.pdf
+func W25Q64JVIM() Attrs {
+	return Attrs{
+		TotalSize:           1 << 23, // 8 MiB
+		StartUp:             5000 * time.Microsecond,
+		JedecID:             JedecID{0xEF, 0x70, 0x17},
+		MaxClockSpeedMHz:    133,
+		QuadEnableBitMask:   0x02,
+		HasSectorProtection: false,
+		SupportsFastRead:    true,
+		SupportsQSPI:        true,
+		SupportsQSPIWrites:  true,
+		WriteStatusSplit:    false,
+		SingleStatusByte:    false,
+	}
+}
+
+// Settings for the Winbond W25Q64JV-IQ 8MiB SPI flash. Note that JV-IM has a
+// different .memory_type (0x70) Datasheet:
+// http://www.winbond.com/resource-files/w25q64jv%20revj%2003272018%20plus.pdf
+func W25Q64JVIQ() Attrs {
+	return Attrs{
+		TotalSize:           1 << 23, // 8 MiB
+		StartUp:             5000 * time.Microsecond,
+		JedecID:             JedecID{0xEF, 0x40, 0x17},
+		MaxClockSpeedMHz:    133,
+		QuadEnableBitMask:   0x02,
+		HasSectorProtection: false,
+		SupportsFastRead:    true,
+		SupportsQSPI:        true,
+		SupportsQSPIWrites:  true,
+		WriteStatusSplit:    false,
+		SingleStatusByte:    false,
+	}
+}
+
+// Settings for the Winbond W25Q80DL 1MiB SPI flash.
+// Datasheet:
+// https://www.winbond.com/resource-files/w25q80dv%20dl_revh_10022015.pdf
+func W25Q80DL() Attrs {
+	return Attrs{
+		TotalSize:           1 << 20, // 1 MiB
+		StartUp:             5000 * time.Microsecond,
+		JedecID:             JedecID{0xEF, 0x60, 0x14},
+		MaxClockSpeedMHz:    104,
+		QuadEnableBitMask:   0x02,
+		HasSectorProtection: false,
+		SupportsFastRead:    true,
+		SupportsQSPI:        true,
+		SupportsQSPIWrites:  false,
+		WriteStatusSplit:    false,
+		SingleStatusByte:    false,
+	}
+}
+
+// Settings for the Winbond W25Q128JV-SQ 16MiB SPI flash. Note that JV-IM has a
+// different .memory_type (0x70) Datasheet:
+// https://www.winbond.com/resource-files/w25q128jv%20revf%2003272018%20plus.pdf
+func W25Q128JVSQ() Attrs {
+	return Attrs{
+		TotalSize:           1 << 24, // 16 MiB
+		StartUp:             5000 * time.Microsecond,
+		JedecID:             JedecID{0xEF, 0x40, 0x18},
+		MaxClockSpeedMHz:    133,
+		QuadEnableBitMask:   0x02,
+		HasSectorProtection: false,
+		SupportsFastRead:    true,
+		SupportsQSPI:        true,
+		SupportsQSPIWrites:  true,
+		WriteStatusSplit:    false,
+		SingleStatusByte:    false,
+	}
+}
+
+// Settings for the Winbond W25Q128JV-PM 16MiB SPI flash. Note that JV-IM has a
+// different .memory_type (0x70) Datasheet:
+// https://www.winbond.com/resource-files/w25q128jv%20revf%2003272018%20plus.pdf
+func W25Q128JVPM() Attrs {
+	return Attrs{
+		TotalSize:           1 << 24, // 16 MiB
+		StartUp:             5000 * time.Microsecond,
+		JedecID:             JedecID{0xEF, 0x70, 0x18},
+		MaxClockSpeedMHz:    133,
+		QuadEnableBitMask:   0x02,
+		HasSectorProtection: false,
+		SupportsFastRead:    true,
+		SupportsQSPI:        true,
+		SupportsQSPIWrites:  true,
+		WriteStatusSplit:    false,
+		SingleStatusByte:    false,
+	}
+}
+
+// Settings for the Winbond W25Q32FV 4MiB SPI flash.
+// Datasheet:http://www.winbond.com/resource-files/w25q32fv%20revj%2006032016.pdf?__locale=en
+func W25Q32FV() Attrs {
+	return Attrs{
+		TotalSize:           1 << 22, // 4 MiB
+		StartUp:             5000 * time.Microsecond,
+		JedecID:             JedecID{0xEF, 0x40, 0x16},
+		MaxClockSpeedMHz:    104,
+		QuadEnableBitMask:   0x00,
+		HasSectorProtection: false,
+		SupportsFastRead:    true,
+		SupportsQSPI:        false,
+		SupportsQSPIWrites:  false,
+		WriteStatusSplit:    false,
+		SingleStatusByte:    false,
+	}
+}

flash/flash.go

@@ -0,0 +1,405 @@
+package flash
+
+import (
+	"time"
+)
+
+const (
+	// BlockSize is the number of bytes in a block for most/all NOR flash memory
+	BlockSize = 64 * 1024
+
+	// SectorSize is the number of bytes in a sector for most/all NOR flash memory
+	SectorSize = 4 * 1024
+
+	// PageSize is the number of bytes in a page for most/all NOR flash memory
+	PageSize = 256
+)
+
+// Device represents a NOR flash memory device accessible using SPI
+type Device struct {
+	trans transport
+	attrs Attrs
+}
+
+// DeviceConfig contains the parameters that can be set when configuring a
+// flash memory device.
+type DeviceConfig struct {
+	Identifier DeviceIdentifier
+}
+
+// JedecID encapsules the ID values that unique identify a flash memory device.
+type JedecID struct {
+	ManufID  uint8
+	MemType  uint8
+	Capacity uint8
+}
+
+// Uint32 returns the JEDEC ID packed into a uint32
+func (id JedecID) Uint32() uint32 {
+	return uint32(id.ManufID)<<16 | uint32(id.MemType)<<8 | uint32(id.Capacity)
+}
+
+// SerialNumber represents a serial number read from a flash memory device
+type SerialNumber uint64
+
+// Attrs represent the differences in hardware characteristics and capabilities
+// of various SPI flash memory devices.
+type Attrs struct {
+
+	// TotalSize is the number of bytes that the flash device can store
+	TotalSize uint32
+
+	// StartUp is the duration of time between when the device is reset and when
+	// it is ready to operation
+	StartUp time.Duration
+
+	// Three response bytes to 0x9f JEDEC ID command.
+	JedecID
+
+	// Max clock speed for all operations and the fastest read mode.
+	MaxClockSpeedMHz uint8
+
+	// Bitmask for Quad Enable bit if present. 0x00 otherwise. This is for the
+	// highest byte in the status register.
+	QuadEnableBitMask uint8
+
+	HasSectorProtection bool
+
+	// Supports the 0x0b fast read command with 8 dummy cycles.
+	SupportsFastRead bool
+
+	// Supports the fast read, quad output command 0x6b with 8 dummy cycles.
+	SupportsQSPI bool
+
+	// Supports the quad input page program command 0x32. This is known as 1-1-4
+	// because it only uses all four lines for data.
+	SupportsQSPIWrites bool
+
+	// Requires a separate command 0x31 to write to the second byte of the status
+	// register. Otherwise two byte are written via 0x01.
+	WriteStatusSplit bool
+
+	// True when the status register is a single byte. This implies the Quad
+	// Enable bit is in the first byte and the Read Status Register 2 command
+	// (0x35) is unsupported.
+	SingleStatusByte bool
+}
+
+// Configure sets up the device and the underlying transport mechanism.  The
+// DeviceConfig argument allows the caller to specify an instance of the
+// DeviceIdentifier interface that, if provided, will be used to retrieve the
+// attributes of the device based on the JEDEC ID.
+func (dev *Device) Configure(config *DeviceConfig) (err error) {
+
+	dev.trans.configure(config)
+
+	var id JedecID
+	if id, err = dev.ReadJEDEC(); err != nil {
+		return err
+	}
+
+	// try to ascertain the vendor-specific attributes of the chip using the
+	// provided Identifier
+	if config.Identifier != nil {
+		dev.attrs = config.Identifier.Identify(id)
+	} else {
+		dev.attrs = Attrs{JedecID: id}
+	}
+
+	// We don't know what state the flash is in so wait for any remaining
+	// writes and then reset.
+
+	// The write in progress bit should be low.
+	for s, err := dev.ReadStatus(); (s & 0x01) > 0; s, err = dev.ReadStatus() {
+		if err != nil {
+			return err
+		}
+	}
+	// The suspended write/erase bit should be low.
+	for s, err := dev.ReadStatus2(); (s & 0x80) > 0; s, err = dev.ReadStatus2() {
+		if err != nil {
+			return err
+		}
+	}
+	// perform device reset
+	if err := dev.trans.runCommand(cmdEnableReset); err != nil {
+		return err
+	}
+	if err := dev.trans.runCommand(cmdReset); err != nil {
+		return err
+	}
+
+	// Wait for the reset - 30us by default
+	time.Sleep(30 * time.Microsecond)
+
+	// Speed up to max device frequency
+	if dev.attrs.MaxClockSpeedMHz > 0 {
+		err := dev.trans.setClockSpeed(uint32(dev.attrs.MaxClockSpeedMHz) * 1e6)
+		if err != nil {
+			return err
+		}
+	}
+
+	// Enable Quad Mode if available
+	if dev.trans.supportQuadMode() && dev.attrs.QuadEnableBitMask > 0 {
+		// Verify that QSPI mode is enabled.
+		var status byte
+		if dev.attrs.SingleStatusByte {
+			status, err = dev.ReadStatus()
+		} else {
+			status, err = dev.ReadStatus2()
+		}
+		if err != nil {
+			return err
+		}
+		// Check and set the quad enable bit.
+		if status&dev.attrs.QuadEnableBitMask == 0 {
+			if err := dev.WriteEnable(); err != nil {
+				return err
+			}
+			fullStatus := []byte{0x00, dev.attrs.QuadEnableBitMask}
+			if dev.attrs.WriteStatusSplit {
+				err = dev.trans.writeCommand(cmdWriteStatus2, fullStatus[1:])
+			} else if dev.attrs.SingleStatusByte {
+				err = dev.trans.writeCommand(cmdWriteStatus, fullStatus[1:])
+			} else {
+				err = dev.trans.writeCommand(cmdWriteStatus, fullStatus)
+			}
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	// disable sector protection if the chip has it
+	if dev.attrs.HasSectorProtection {
+		if err := dev.WriteEnable(); err != nil {
+			return err
+		}
+		if err := dev.trans.writeCommand(cmdWriteStatus, []byte{0x00}); err != nil {
+			return err
+		}
+	}
+
+	// write disable
+	if err := dev.trans.runCommand(cmdWriteDisable); err != nil {
+		return err
+	}
+	return dev.WaitUntilReady()
+}
+
+// Attrs returns the attributes of the device determined from the most recent
+// call to Configure(). If no call to Configure() has been made, this will be
+// the zero value of the Attrs struct.
+func (dev *Device) Attrs() Attrs {
+	return dev.attrs
+}
+
+// ReadJEDEC reads the JEDEC ID from the device; this ID can then be used to
+// ascertain the attributes of the chip from a list of known devices.
+func (dev *Device) ReadJEDEC() (JedecID, error) {
+	jedecID := make([]byte, 3)
+	if err := dev.trans.readCommand(cmdReadJedecID, jedecID); err != nil {
+		return JedecID{}, err
+	}
+	return JedecID{jedecID[0], jedecID[1], jedecID[2]}, nil
+}
+
+// ReadSerialNumber reads the serial numbers from the connected device.
+// TODO: maybe check if byte order / endianess is correct, probably is not
+func (dev *Device) ReadSerialNumber() (SerialNumber, error) {
+	sn := make([]byte, 12)
+	if err := dev.trans.readCommand(0x4B, sn); err != nil {
+		return 0, err
+	}
+	return SerialNumber(uint64(sn[11]) | uint64(sn[10])<<0x8 |
+		uint64(sn[9])<<0x10 | uint64(sn[8])<<0x18 | uint64(sn[7])<<0x20 |
+		uint64(sn[6])<<0x28 | uint64(sn[5])<<0x30 | uint64(sn[4])<<0x38), nil
+}
+
+// Size returns the size of this memory, in bytes.
+func (dev *Device) Size() int64 {
+	if dev.attrs.TotalSize < 1 {
+		// in case a DeviceIdentifier function wasn't used, use the capacity
+		// specified in the JEDEC ID instead
+		return int64(dev.attrs.Capacity)
+	}
+	return int64(dev.attrs.TotalSize)
+}
+
+// ReadAt satisfies the io.ReaderAt interface, and fills the provided buffer
+// with memory read from the device starting at the provided address.
+func (dev *Device) ReadAt(buf []byte, addr int64) (int, error) {
+	if err := dev.WaitUntilReady(); err != nil {
+		return 0, err
+	}
+	if err := dev.trans.readMemory(uint32(addr), buf); err != nil {
+		return 0, err
+	}
+	return len(buf), nil
+}
+
+// WriteAt satisfies the io.WriterAt interface and writes data to the device,
+// one page at a time, starting at the provided address. This method assumes
+// that the destination is already erased.
+func (dev *Device) WriteAt(buf []byte, addr int64) (n int, err error) {
+	remain := uint32(len(buf))
+	idx := uint32(0)
+	loc := uint32(addr)
+	for remain > 0 {
+		if err = dev.WaitUntilReady(); err != nil {
+			return
+		}
+		if err = dev.WriteEnable(); err != nil {
+			return
+		}
+		leftOnPage := PageSize - (loc & (PageSize - 1))
+		toWrite := remain
+		if leftOnPage < remain {
+			toWrite = leftOnPage
+		}
+		if err = dev.trans.writeMemory(loc, buf[idx:idx+toWrite]); err != nil {
+			return
+		}
+		idx += toWrite
+		loc += toWrite
+		remain -= toWrite
+	}
+	return len(buf) - int(remain), nil
+}
+
+// WriteBlockSize returns the block size in which data can be written to
+// memory. It can be used by a client to optimize writes, non-aligned writes
+// should always work correctly.
+// For SPI NOR flash this is the page size, usually/always 256.
+func (dev *Device) WriteBlockSize() int64 {
+	return PageSize
+}
+
+// EraseBlockSize returns the smallest erasable area on this particular chip
+// in bytes. This is used for the block size in EraseBlocks.
+// For SPI NOR flash this is the sector size, usually/always 4096.
+func (dev *Device) EraseBlockSize() int64 {
+	return SectorSize
+}
+
+// EraseBlocks erases the given number of blocks. An implementation may
+// transparently coalesce ranges of blocks into larger bundles if the chip
+// supports this. The start and len parameters are in block numbers, use
+// EraseBlockSize to map addresses to blocks.
+func (dev *Device) EraseBlocks(start, len int64) error {
+	// TODO: maybe combine sector erase operations into block erase operations
+	for i := start; i < start+len; i++ {
+		if err := dev.EraseSector(uint32(i)); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (dev *Device) WriteEnable() error {
+	return dev.trans.runCommand(cmdWriteEnable)
+}
+
+// EraseBlock erases a block of memory at the specified index
+func (dev *Device) EraseBlock(blockNumber uint32) error {
+	if err := dev.WaitUntilReady(); err != nil {
+		return err
+	}
+	if err := dev.WriteEnable(); err != nil {
+		return err
+	}
+	return dev.trans.eraseCommand(cmdEraseBlock, blockNumber*BlockSize)
+}
+
+// EraseSector erases a sector of memory at the given index
+func (dev *Device) EraseSector(sectorNumber uint32) error {
+	if err := dev.WaitUntilReady(); err != nil {
+		return err
+	}
+	if err := dev.WriteEnable(); err != nil {
+		return err
+	}
+	return dev.trans.eraseCommand(cmdEraseSector, sectorNumber*SectorSize)
+}
+
+// EraseChip erases the entire flash memory chip
+func (dev *Device) EraseAll() error {
+	if err := dev.WaitUntilReady(); err != nil {
+		return err
+	}
+	if err := dev.WriteEnable(); err != nil {
+		return err
+	}
+	return dev.trans.runCommand(cmdEraseChip)
+}
+
+// ReadStatus reads the value from status register 1 of the device
+func (dev *Device) ReadStatus() (status byte, err error) {
+	buf := make([]byte, 1)
+	err = dev.trans.readCommand(cmdReadStatus, buf)
+	return buf[0], err
+}
+
+// ReadStatus2 reads the value from status register 2 of the device
+func (dev *Device) ReadStatus2() (status byte, err error) {
+	buf := make([]byte, 1)
+	err = dev.trans.readCommand(cmdReadStatus2, buf)
+	return buf[0], err
+}
+
+// WaitUntilReady queries the status register until the device is ready for the
+// next operation.
+func (dev *Device) WaitUntilReady() error {
+	expire := time.Now().UnixNano() + int64(1*time.Second)
+	for s, err := dev.ReadStatus(); (s & 0x03) > 0; s, err = dev.ReadStatus() {
+		if err != nil {
+			return err
+		}
+		if time.Now().UnixNano() > expire {
+			return ErrWaitExpired
+		}
+	}
+	return nil
+}
+
+const (
+	cmdRead            = 0x03 // read memory using single-bit transfer
+	cmdQuadRead        = 0x6B // read with 1 line address, 4 line data
+	cmdReadJedecID     = 0x9F // read the JEDEC ID from the device
+	cmdPageProgram     = 0x02 // write a page of memory using single-bit transfer
+	cmdQuadPageProgram = 0x32 // write with 1 line address, 4 line data
+	cmdReadStatus      = 0x05 // read status register 1
+	cmdReadStatus2     = 0x35 // read status register 2
+	cmdWriteStatus     = 0x01 // write status register 1
+	cmdWriteStatus2    = 0x31 // write status register 2
+	cmdEnableReset     = 0x66 // enable reset
+	cmdReset           = 0x99 // perform reset
+	cmdWriteEnable     = 0x06 // write-enable memory
+	cmdWriteDisable    = 0x04 // write-protect memory
+	cmdEraseSector     = 0x20 // erase a sector of memory
+	cmdEraseBlock      = 0xD8 // erase a block of memory
+	cmdEraseChip       = 0xC7 // erase the entire chip
+)
+
+type Error uint8
+
+const (
+	_                          = iota
+	ErrInvalidClockSpeed Error = iota
+	ErrInvalidAddrRange
+	ErrWaitExpired
+)
+
+func (err Error) Error() string {
+	switch err {
+	case ErrInvalidClockSpeed:
+		return "flash: invalid clock speed"
+	case ErrInvalidAddrRange:
+		return "flash: invalid address range"
+	case ErrWaitExpired:
+		return "flash: wait until ready expired"
+	default:
+		return "flash: unspecified error"
+	}
+}

flash/transport_qspi_samd.go

@@ -0,0 +1,247 @@
+// +build atsamd51
+
+package flash
+
+import (
+	"device/sam"
+	"machine"
+	"runtime/volatile"
+	"unsafe"
+)
+
+// NewQSPI returns a pointer to a flash device that uses the QSPI peripheral to
+// communicate with a serial memory chip.
+func NewQSPI(cs, sck, d0, d1, d2, d3 machine.Pin) *Device {
+	return &Device{
+		trans: &qspiTransport{
+			cs:  cs,
+			sck: sck,
+			d0:  d0,
+			d1:  d1,
+			d2:  d2,
+			d3:  d3,
+		},
+	}
+}
+
+// QSPI address space on SAMD51 is 0x04000000 to 0x05000000
+const (
+	// Low address of the QSPI address space on SAMD51
+	qspi_AHB_LO = 0x04000000
+
+	// High address of the QSPI address space on SAMD51
+	qspi_AHB_HI = 0x05000000
+
+	// Instruction frame for running sending a command to the device
+	iframeRunCommand = 0x0 |
+		sam.QSPI_INSTRFRAME_WIDTH_SINGLE_BIT_SPI |
+		sam.QSPI_INSTRFRAME_ADDRLEN_24BITS |
+		sam.QSPI_INSTRFRAME_INSTREN |
+		(sam.QSPI_INSTRFRAME_TFRTYPE_READ << sam.QSPI_INSTRFRAME_TFRTYPE_Pos)
+
+	// Instruction frame for running a command that returns data
+	iframeReadCommand = 0x0 |
+		sam.QSPI_INSTRFRAME_WIDTH_SINGLE_BIT_SPI |
+		sam.QSPI_INSTRFRAME_ADDRLEN_24BITS |
+		sam.QSPI_INSTRFRAME_INSTREN |
+		sam.QSPI_INSTRFRAME_DATAEN |
+		(sam.QSPI_INSTRFRAME_TFRTYPE_READ << sam.QSPI_INSTRFRAME_TFRTYPE_Pos)
+
+	// Instruction frame to set up the device to read from memory
+	iframeReadMemory = 0x0 |
+		sam.QSPI_INSTRFRAME_WIDTH_QUAD_OUTPUT |
+		sam.QSPI_INSTRFRAME_ADDRLEN_24BITS |
+		sam.QSPI_INSTRFRAME_INSTREN |
+		sam.QSPI_INSTRFRAME_DATAEN |
+		sam.QSPI_INSTRFRAME_ADDREN |
+		(8 << sam.QSPI_INSTRFRAME_DUMMYLEN_Pos) |
+		(sam.QSPI_INSTRFRAME_TFRTYPE_READMEMORY << sam.QSPI_INSTRFRAME_TFRTYPE_Pos)
+
+	// Instruction frame for running a command that requires parameter data
+	iframeWriteCommand = 0x0 |
+		sam.QSPI_INSTRFRAME_WIDTH_SINGLE_BIT_SPI |
+		sam.QSPI_INSTRFRAME_ADDRLEN_24BITS |
+		sam.QSPI_INSTRFRAME_INSTREN |
+		(sam.QSPI_INSTRFRAME_TFRTYPE_WRITE << sam.QSPI_INSTRFRAME_TFRTYPE_Pos)
+
+	// Instruction frame to set up the device for writing to memory
+	iframeWriteMemory = 0x0 |
+		sam.QSPI_INSTRFRAME_WIDTH_QUAD_OUTPUT |
+		sam.QSPI_INSTRFRAME_ADDRLEN_24BITS |
+		sam.QSPI_INSTRFRAME_INSTREN |
+		sam.QSPI_INSTRFRAME_ADDREN |
+		sam.QSPI_INSTRFRAME_DATAEN |
+		(sam.QSPI_INSTRFRAME_TFRTYPE_WRITEMEMORY << sam.QSPI_INSTRFRAME_TFRTYPE_Pos)
+
+	// Instruction frame for running an erase command that requires and address
+	iframeEraseCommand = 0x0 |
+		sam.QSPI_INSTRFRAME_WIDTH_SINGLE_BIT_SPI |
+		sam.QSPI_INSTRFRAME_ADDRLEN_24BITS |
+		sam.QSPI_INSTRFRAME_INSTREN |
+		sam.QSPI_INSTRFRAME_ADDREN |
+		(sam.QSPI_INSTRFRAME_TFRTYPE_WRITE << sam.QSPI_INSTRFRAME_TFRTYPE_Pos)
+)
+
+type qspiTransport struct {
+	cs  machine.Pin
+	sck machine.Pin
+	d0  machine.Pin
+	d1  machine.Pin
+	d2  machine.Pin
+	d3  machine.Pin
+}
+
+func (q qspiTransport) configure(config *DeviceConfig) {
+
+	// enable main clocks
+	sam.MCLK.APBCMASK.SetBits(sam.MCLK_APBCMASK_QSPI_)
+	sam.MCLK.AHBMASK.SetBits(sam.MCLK_AHBMASK_QSPI_)
+	sam.MCLK.AHBMASK.ClearBits(sam.MCLK_AHBMASK_QSPI_2X_)
+
+	sam.QSPI.CTRLA.SetBits(sam.QSPI_CTRLA_SWRST)
+
+	// enable all pins to be PinCom
+	q.d0.Configure(machine.PinConfig{Mode: machine.PinCom})
+	q.d1.Configure(machine.PinConfig{Mode: machine.PinCom})
+	q.d2.Configure(machine.PinConfig{Mode: machine.PinCom})
+	q.d3.Configure(machine.PinConfig{Mode: machine.PinCom})
+	q.cs.Configure(machine.PinConfig{Mode: machine.PinCom})
+	q.sck.Configure(machine.PinConfig{Mode: machine.PinCom})
+
+	// start out with 4Mhz
+	// can ignore the error, 4Mhz is always a valid speed
+	_ = q.setClockSpeed(4e6)
+
+	// configure the CTRLB register
+	sam.QSPI.CTRLB.Set(sam.QSPI_CTRLB_MODE_MEMORY |
+		(sam.QSPI_CTRLB_DATALEN_8BITS << sam.QSPI_CTRLB_DATALEN_Pos) |
+		(sam.QSPI_CTRLB_CSMODE_LASTXFER << sam.QSPI_CTRLB_CSMODE_Pos))
+
+	// enable the peripheral
+	sam.QSPI.CTRLA.SetBits(sam.QSPI_CTRLA_ENABLE)
+}
+
+func (q qspiTransport) supportQuadMode() bool {
+	return true
+}
+
+func (q qspiTransport) setClockSpeed(hz uint32) error {
+	// The clock speed for the QSPI peripheral is controlled by a divider, so
+	// we can't set the requested speed exactly. Instead we will increment the
+	// divider until the speed is less than or equal to the speed requested.
+	for div, freq := uint32(1), machine.CPUFrequency(); div < 256; div++ {
+		if freq/div <= hz {
+			sam.QSPI.BAUD.Set(div << sam.QSPI_BAUD_BAUD_Pos)
+			return nil
+		}
+	}
+	return ErrInvalidClockSpeed
+}
+
+func (q qspiTransport) runCommand(cmd byte) (err error) {
+	q.runInstruction(cmd, iframeRunCommand)
+	q.endTransfer()
+	return
+}
+
+func (q qspiTransport) readCommand(cmd byte, buf []byte) (err error) {
+	q.disableAndClearCache()
+	q.runInstruction(cmd, iframeReadCommand)
+	q.readInto(buf, 0)
+	q.endTransfer()
+	q.enableCache()
+	return
+}
+
+func (q qspiTransport) readMemory(addr uint32, buf []byte) (err error) {
+	if (addr + uint32(len(buf))) > (qspi_AHB_HI - qspi_AHB_LO) {
+		return ErrInvalidAddrRange
+	}
+	q.disableAndClearCache()
+	q.runInstruction(cmdQuadRead, iframeReadMemory)
+	q.readInto(buf, addr)
+	q.endTransfer()
+	q.enableCache()
+	return
+}
+
+func (q qspiTransport) writeCommand(cmd byte, data []byte) (err error) {
+	var dataen uint32
+	if len(data) > 0 {
+		dataen = sam.QSPI_INSTRFRAME_DATAEN
+	}
+	q.disableAndClearCache()
+	q.runInstruction(cmd, iframeWriteCommand|dataen)
+	q.writeFrom(data, 0)
+	q.endTransfer()
+	q.enableCache()
+	return
+}
+
+func (q qspiTransport) writeMemory(addr uint32, data []byte) (err error) {
+	if (addr + uint32(len(data))) > (qspi_AHB_HI - qspi_AHB_LO) {
+		return ErrInvalidAddrRange
+	}
+	q.disableAndClearCache()
+	q.runInstruction(cmdQuadPageProgram, iframeWriteMemory)
+	q.writeFrom(data, addr)
+	q.endTransfer()
+	q.enableCache()
+	return
+}
+
+func (q qspiTransport) eraseCommand(cmd byte, addr uint32) (err error) {
+	q.disableAndClearCache()
+	sam.QSPI.INSTRADDR.Set(addr)
+	q.runInstruction(cmd, iframeEraseCommand)
+	q.endTransfer()
+	q.enableCache()
+	return
+}
+
+func (q qspiTransport) runInstruction(cmd byte, iframe uint32) {
+	sam.QSPI.INSTRCTRL.Set(uint32(cmd))
+	sam.QSPI.INSTRFRAME.Set(iframe)
+	sam.QSPI.INSTRFRAME.Get() // dummy read for synchronization, as per datasheet
+}
+
+func (q qspiTransport) enableCache() {
+	sam.CMCC.CTRL.SetBits(sam.CMCC_CTRL_CEN)
+}
+
+func (q qspiTransport) disableAndClearCache() {
+	sam.CMCC.CTRL.ClearBits(sam.CMCC_CTRL_CEN)
+	for sam.CMCC.SR.HasBits(sam.CMCC_SR_CSTS) {
+	}
+	sam.CMCC.MAINT0.SetBits(sam.CMCC_MAINT0_INVALL)
+}
+
+func (q qspiTransport) endTransfer() {
+	sam.QSPI.CTRLA.Set(sam.QSPI_CTRLA_ENABLE | sam.QSPI_CTRLA_LASTXFER)
+	for !sam.QSPI.INTFLAG.HasBits(sam.QSPI_INTFLAG_INSTREND) {
+	}
+	sam.QSPI.INTFLAG.Set(sam.QSPI_INTFLAG_INSTREND)
+}
+
+func (q qspiTransport) readInto(buf []byte, addr uint32) {
+	var ptr = qspi_AHB_LO + uintptr(addr)
+	for i := range buf {
+		buf[i] = volatile.LoadUint8((*uint8)(unsafe.Pointer(ptr)))
+		ptr++
+	}
+	/* // NB(bcg): for some reason this reads data that results from commands in
+	   // a different byte order than the loop above, but works fine for reading
+	   // from memory. Oddly, the above loop seems to work fine in both cases.
+		ln := len(buf)
+		sl := (*[1 << 28]byte)(unsafe.Pointer(uintptr(qspi_AHB_LO + addr)))[:ln:ln]
+		copy(buf, sl)
+	*/
+}
+
+func (q qspiTransport) writeFrom(buf []byte, addr uint32) {
+	var ptr = qspi_AHB_LO + uintptr(addr)
+	for i := range buf {
+		volatile.StoreUint8((*uint8)(unsafe.Pointer(ptr)), buf[i])
+		ptr++
+	}
+}

flash/transport_spi.go

@@ -0,0 +1,154 @@
+package flash
+
+import "machine"
+
+type transport interface {
+	configure(config *DeviceConfig)
+	supportQuadMode() bool
+	setClockSpeed(hz uint32) (err error)
+	runCommand(cmd byte) (err error)
+	readCommand(cmd byte, rsp []byte) (err error)
+	writeCommand(cmd byte, data []byte) (err error)
+	eraseCommand(cmd byte, address uint32) (err error)
+	readMemory(addr uint32, rsp []byte) (err error)
+	writeMemory(addr uint32, data []byte) (err error)
+}
+
+// NewSPI returns a pointer to a flash device that uses a SPI peripheral to
+// communicate with a serial memory chip.
+func NewSPI(spi *machine.SPI, sdo, sdi, sck, cs machine.Pin) *Device {
+	return &Device{
+		trans: &spiTransport{
+			spi: spi,
+			sdo: sdo,
+			sdi: sdi,
+			sck: sck,
+			ss:  cs,
+		},
+	}
+}
+
+type spiTransport struct {
+	spi *machine.SPI
+	sdo machine.Pin
+	sdi machine.Pin
+	sck machine.Pin
+	ss  machine.Pin
+}
+
+func (tr *spiTransport) configure(config *DeviceConfig) {
+	// Configure spi bus
+	tr.setClockSpeed(5000000)
+
+	// Configure chip select pin
+	tr.ss.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	tr.ss.High()
+}
+
+func (tr *spiTransport) setClockSpeed(hz uint32) error {
+	// TODO: un-hardcode this max speed; it is probably a sensible
+	//       default maximum for atsamd and nrf at least
+	if hz > 24*1e6 {
+		hz = 24 * 1e6
+	}
+	tr.spi.Configure(machine.SPIConfig{
+		Frequency: hz,
+		SDI:       tr.sdi,
+		SDO:       tr.sdo,
+		SCK:       tr.sck,
+		LSBFirst:  false,
+		Mode:      0,
+	})
+	return nil
+}
+
+func (tr *spiTransport) supportQuadMode() bool {
+	return false
+}
+
+func (tr *spiTransport) runCommand(cmd byte) (err error) {
+	tr.ss.Low()
+	_, err = tr.spi.Transfer(byte(cmd))
+	tr.ss.High()
+	return
+}
+
+func (tr *spiTransport) readCommand(cmd byte, rsp []byte) (err error) {
+	tr.ss.Low()
+	if _, err := tr.spi.Transfer(byte(cmd)); err == nil {
+		err = tr.readInto(rsp)
+	}
+	tr.ss.High()
+	return
+}
+
+func (tr *spiTransport) readCommandByte(cmd byte) (rsp byte, err error) {
+	tr.ss.Low()
+	if _, err := tr.spi.Transfer(byte(cmd)); err == nil {
+		rsp, err = tr.spi.Transfer(0xFF)
+	}
+	tr.ss.High()
+	return
+}
+
+func (tr *spiTransport) writeCommand(cmd byte, data []byte) (err error) {
+	tr.ss.Low()
+	if _, err := tr.spi.Transfer(byte(cmd)); err == nil {
+		err = tr.writeFrom(data)
+	}
+	tr.ss.High()
+	return
+}
+
+func (tr *spiTransport) eraseCommand(cmd byte, address uint32) (err error) {
+	tr.ss.Low()
+	err = tr.sendAddress(cmd, address)
+	tr.ss.High()
+	return
+}
+
+func (tr *spiTransport) readMemory(addr uint32, rsp []byte) (err error) {
+	tr.ss.Low()
+	if err = tr.sendAddress(cmdRead, addr); err == nil {
+		err = tr.readInto(rsp)
+	}
+	tr.ss.High()
+	return
+}
+
+func (tr *spiTransport) writeMemory(addr uint32, data []byte) (err error) {
+	tr.ss.Low()
+	if err = tr.sendAddress(cmdPageProgram, addr); err == nil {
+		err = tr.writeFrom(data)
+	}
+	tr.ss.High()
+	return
+}
+
+func (tr *spiTransport) sendAddress(cmd byte, addr uint32) error {
+	_, err := tr.spi.Transfer(byte(cmd))
+	if err == nil {
+		_, err = tr.spi.Transfer(byte((addr >> 16) & 0xFF))
+	}
+	if err == nil {
+		_, err = tr.spi.Transfer(byte((addr >> 8) & 0xFF))
+	}
+	if err == nil {
+		_, err = tr.spi.Transfer(byte(addr & 0xFF))
+	}
+	return err
+}
+
+func (tr *spiTransport) readInto(rsp []byte) (err error) {
+	for i, c := 0, len(rsp); i < c && err == nil; i++ {
+		rsp[i], err = tr.spi.Transfer(0xFF)
+	}
+	return
+}
+
+func (tr *spiTransport) writeFrom(data []byte) (err error) {
+	for i, c := 0, len(data); i < c && err == nil; i++ {
+		_, err = tr.spi.Transfer(data[i])
+	}
+	return
+}

go.mod

@@ -0,0 +1,5 @@
+module tinygo.org/x/drivers
+
+go 1.14
+
+require github.com/eclipse/paho.mqtt.golang v1.2.0

go.sum

@@ -0,0 +1,2 @@
+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=

hcsr04/hcsr04.go

@@ -0,0 +1,81 @@
+// Package hcsr04 provides a driver for the HC-SR04 ultrasonic distance sensor
+//
+// Datasheet:
+// https://cdn.sparkfun.com/datasheets/Sensors/Proximity/HCSR04.pdf
+package hcsr04
+
+import (
+	"machine"
+	"time"
+)
+
+const TIMEOUT = 23324 // max sensing distance (4m)
+
+// Device holds the pins
+type Device struct {
+	trigger machine.Pin
+	echo    machine.Pin
+}
+
+// New returns a new ultrasonic driver given 2 pins
+func New(trigger, echo machine.Pin) Device {
+	return Device{
+		trigger: trigger,
+		echo:    echo,
+	}
+}
+
+// Configure configures the pins of the Device
+func (d *Device) Configure() {
+	d.trigger.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	d.echo.Configure(machine.PinConfig{Mode: machine.PinInput})
+}
+
+// ReadDistance returns the distance of the object in mm
+func (d *Device) ReadDistance() int32 {
+	pulse := d.ReadPulse()
+
+	// sound speed is 343000 mm/s
+	// pulse is roundtrip measured in microseconds
+	// distance = velocity * time
+	// 2 * distance = 343000 * (pulse/1000000)
+	return (pulse * 1715) / 10000 //mm
+}
+
+// ReadPulse returns the time of the pulse (roundtrip) in microseconds
+func (d *Device) ReadPulse() int32 {
+	t := time.Now()
+	d.trigger.Low()
+	time.Sleep(2 * time.Microsecond)
+	d.trigger.High()
+	time.Sleep(10 * time.Microsecond)
+	d.trigger.Low()
+	i := uint8(0)
+	for {
+		if d.echo.Get() {
+			t = time.Now()
+			break
+		}
+		i++
+		if i > 10 {
+			if time.Since(t).Microseconds() > TIMEOUT {
+				return 0
+			}
+			i = 0
+		}
+	}
+	i = 0
+	for {
+		if !d.echo.Get() {
+			return int32(time.Since(t).Microseconds())
+		}
+		i++
+		if i > 10 {
+			if time.Since(t).Microseconds() > TIMEOUT {
+				return 0
+			}
+			i = 0
+		}
+	}
+	return 0
+}

hd44780i2c/hd44780i2c.go

@@ -0,0 +1,242 @@
+// Package hd44780i2c implements a driver for the Hitachi HD44780 LCD display module
+// with an I2C adapter.
+//
+// Datasheet: https://www.sparkfun.com/datasheets/LCD/HD44780.pdf
+//
+package hd44780i2c
+
+import (
+	"errors"
+	"machine"
+	"time"
+)
+
+// Device wraps an I2C connection to a HD44780 I2C LCD with related data.
+type Device struct {
+	bus             machine.I2C
+	addr            uint8
+	width           uint8
+	height          uint8
+	cursor          cursor
+	backlight       uint8
+	displayfunction uint8
+	displaycontrol  uint8
+	displaymode     uint8
+}
+
+type cursor struct {
+	x, y uint8
+}
+
+// Config for HD44780 I2C LCD.
+type Config struct {
+	Width       uint8
+	Height      uint8
+	Font        uint8
+	CursorOn    bool
+	CursorBlink bool
+}
+
+// New creates a new HD44780 I2C LCD 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, addr uint8) Device {
+	if addr == 0 {
+		addr = 0x27
+	}
+	return Device{
+		bus:  bus,
+		addr: addr,
+	}
+}
+
+// Configure sets up the display. Display itself and backlight is default on.
+func (d *Device) Configure(cfg Config) error {
+
+	if cfg.Width == 0 || cfg.Height == 0 {
+		return errors.New("width and height must be set")
+	}
+	d.width = uint8(cfg.Width)
+	d.height = uint8(cfg.Height)
+
+	delayms(50)
+
+	d.backlight = BACKLIGHT_ON
+	d.expanderWrite(0)
+	delayms(1000)
+
+	d.write4bits(0x03 << 4)
+	delayus(4500)
+	d.write4bits(0x03 << 4)
+	delayus(4500)
+	d.write4bits(0x03 << 4)
+	delayus(150)
+	d.write4bits(0x02 << 4)
+
+	d.displayfunction = DATA_LENGTH_4BIT | ONE_LINE | FONT_5X8
+	if d.height > 1 {
+		d.displayfunction |= TWO_LINE
+	}
+	if cfg.Font != 0 && d.height == 1 {
+		d.displayfunction |= FONT_5X10
+	}
+	d.sendCommand(FUNCTION_MODE | d.displayfunction)
+
+	d.displaycontrol = DISPLAY_ON | CURSOR_OFF | CURSOR_BLINK_OFF
+	if cfg.CursorOn {
+		d.displaycontrol |= CURSOR_ON
+	}
+	if cfg.CursorBlink {
+		d.displaycontrol |= CURSOR_BLINK_ON
+	}
+	d.sendCommand(DISPLAY_ON_OFF | d.displaycontrol)
+	d.ClearDisplay()
+
+	d.displaymode = CURSOR_INCREASE | DISPLAY_NO_SHIFT
+	d.sendCommand(ENTRY_MODE | d.displaymode)
+	d.Home()
+
+	return nil
+}
+
+// ClearDisplay clears all texts on the display.
+func (d *Device) ClearDisplay() {
+	d.sendCommand(DISPLAY_CLEAR)
+	d.cursor.x = 0
+	d.cursor.y = 0
+	delayus(2000)
+}
+
+// Home sets the cursor back to position (0, 0).
+func (d *Device) Home() {
+	d.sendCommand(CURSOR_HOME)
+	d.cursor.x = 0
+	d.cursor.y = 0
+	delayus(2000)
+}
+
+// SetCursor sets the cursor to a specific position (x, y).
+//
+// if y (row) is set larger than actual rows, it would be set to 0.
+func (d *Device) SetCursor(x, y uint8) {
+	rowOffset := []uint8{0x0, 0x40, 0x14, 0x54}
+	if y > (d.height - 1) {
+		y = 0
+	}
+	d.cursor.x = x
+	d.cursor.y = y
+	d.sendCommand(DDRAM_SET | (x + (rowOffset[y])))
+}
+
+// Print prints text on the display (started from current cursor position).
+//
+// It would automatically break to new line when the text is too long.
+// You can also use \n as line breakers.
+func (d *Device) Print(data []byte) {
+	for _, chr := range data {
+		if chr == '\n' {
+			d.newLine()
+		} else {
+			d.cursor.x++
+			if d.cursor.x >= d.width {
+				d.newLine()
+			}
+			d.sendData(uint8(rune(chr)))
+		}
+	}
+}
+
+// CreateCharacter crates custom characters (using data parameter)
+// and stores it under CGRAM address (using cgramAddr, 0x0-0x7).
+func (d *Device) CreateCharacter(cgramAddr uint8, data []byte) {
+	cgramAddr &= 0x7
+	d.sendCommand(CGRAM_SET | cgramAddr<<3)
+	for _, dd := range data {
+		d.sendData(dd)
+	}
+	d.SetCursor(d.cursor.x, d.cursor.y)
+}
+
+// DisplayOn turns on/off the display.
+func (d *Device) DisplayOn(option bool) {
+	if option {
+		d.displaycontrol |= DISPLAY_ON
+	} else {
+		d.displaycontrol &= ^uint8(DISPLAY_ON)
+	}
+	d.sendCommand(DISPLAY_ON_OFF | d.displaycontrol)
+}
+
+// CursorOn display/hides the cursor.
+func (d *Device) CursorOn(option bool) {
+	if option {
+		d.displaycontrol |= CURSOR_ON
+	} else {
+		d.displaycontrol &= ^uint8(CURSOR_ON)
+	}
+	d.sendCommand(DISPLAY_ON_OFF | d.displaycontrol)
+}
+
+// CursorBlink turns on/off the blinking cursor mode.
+func (d *Device) CursorBlink(option bool) {
+	if option {
+		d.displaycontrol |= CURSOR_BLINK_ON
+	} else {
+		d.displaycontrol &= ^uint8(CURSOR_BLINK_ON)
+	}
+	d.sendCommand(DISPLAY_ON_OFF | d.displaycontrol)
+}
+
+// BacklightOn turns on/off the display backlight.
+func (d *Device) BacklightOn(option bool) {
+	if option {
+		d.backlight = BACKLIGHT_ON
+	} else {
+		d.backlight = BACKLIGHT_OFF
+	}
+	d.expanderWrite(0)
+}
+
+func (d *Device) newLine() {
+	d.cursor.x = 0
+	d.cursor.y++
+	d.SetCursor(d.cursor.x, d.cursor.y)
+}
+
+func delayms(t uint16) {
+	time.Sleep(time.Millisecond * time.Duration(t))
+}
+
+func delayus(t uint16) {
+	time.Sleep(time.Microsecond * time.Duration(t))
+}
+
+func (d *Device) expanderWrite(value uint8) {
+	d.bus.Tx(uint16(d.addr), []uint8{value | d.backlight}, nil)
+}
+
+func (d *Device) pulseEnable(value uint8) {
+	d.expanderWrite(value | En)
+	delayus(1)
+	d.expanderWrite(value & ^uint8(En))
+	delayus(50)
+}
+
+func (d *Device) write4bits(value uint8) {
+	d.expanderWrite(value)
+	d.pulseEnable(value)
+}
+
+func (d *Device) write(value uint8, mode uint8) {
+	d.write4bits(uint8(value&0xf0) | mode)
+	d.write4bits(uint8((value<<4)&0xf0) | mode)
+}
+
+func (d *Device) sendCommand(value uint8) {
+	d.write(value, 0)
+}
+
+func (d *Device) sendData(value uint8) {
+	d.write(value, Rs)
+}

hd44780i2c/registers.go

@@ -0,0 +1,44 @@
+package hd44780i2c
+
+const (
+
+	// commands
+	DISPLAY_CLEAR        = 0x01
+	CURSOR_HOME          = 0x02
+	ENTRY_MODE           = 0x04
+	DISPLAY_ON_OFF       = 0x08
+	CURSOR_DISPLAY_SHIFT = 0x10
+	FUNCTION_MODE        = 0x20
+	CGRAM_SET            = 0x40
+	DDRAM_SET            = 0x80
+
+	// flags for display entry mode
+	// CURSOR_DECREASE  = 0x00
+	CURSOR_INCREASE = 0x02
+	// DISPLAY_SHIFT    = 0x01
+	DISPLAY_NO_SHIFT = 0x00
+
+	// flags for display on/off control
+	DISPLAY_ON       = 0x04
+	DISPLAY_OFF      = 0x00
+	CURSOR_ON        = 0x02
+	CURSOR_OFF       = 0x00
+	CURSOR_BLINK_ON  = 0x01
+	CURSOR_BLINK_OFF = 0x00
+
+	// flags for function set
+	// DATA_LENGTH_8BIT = 0x10
+	DATA_LENGTH_4BIT = 0x00
+	TWO_LINE         = 0x08
+	ONE_LINE         = 0x00
+	FONT_5X10        = 0x04
+	FONT_5X8         = 0x00
+
+	// flags for backlight control
+	BACKLIGHT_ON  = 0x08
+	BACKLIGHT_OFF = 0x00
+
+	En = 0x04 // Enable bit
+	// Rw = 0x02 // Read/Write bit
+	Rs = 0x01 // Register select bit
+)

ili9341/ili9341.go

@@ -19,6 +19,9 @@ type Device struct {
 	rotation Rotation
 	driver   driver
 
+	x0, x1 int16 // cached address window; prevents useless/expensive
+	y0, y1 int16 // syscalls to PASET, CASET, and RAMWR
+
 	dc  machine.Pin
 	cs  machine.Pin
 	rst machine.Pin
@@ -37,6 +40,10 @@ func (d *Device) Configure(config Config) {
 	d.height = config.Height
 	d.rotation = config.Rotation
 
+	// try to pick an initial cache miss for one of the points
+	d.x0, d.x1 = -(d.width + 1), d.x0
+	d.y0, d.y1 = -(d.height + 1), d.y0
+
 	output := machine.PinConfig{machine.PinOutput}
 
 	// configure chip select if there is one
@@ -253,13 +260,26 @@ func (d *Device) StopScroll() {
 func (d *Device) setWindow(x, y, w, h int16) {
 	//x += d.columnOffset
 	//y += d.rowOffset
-	d.sendCommand(CASET, []uint8{
-		uint8(x >> 8), uint8(x), uint8((x + w - 1) >> 8), uint8(x + w - 1),
-	})
-	d.sendCommand(PASET, []uint8{
-		uint8(y >> 8), uint8(y), uint8((y + h - 1) >> 8), uint8(y + h - 1),
-	})
-	d.sendCommand(RAMWR, nil)
+	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),
+		})
+		d.x0, d.x1 = x, x1
+	}
+	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)
+	}
 }
 
 //go:inline
@@ -281,15 +301,15 @@ func (d *Device) sendCommand(cmd byte, data []byte) {
 	d.dc.Low()
 	d.driver.write8(cmd)
 	d.dc.High()
-	for _, b := range data {
-		d.driver.write8(b)
-	}
+	d.driver.write8sl(data)
 	d.endWrite()
 }
 
 type driver interface {
 	configure(config *Config)
 	write8(b byte)
+	write8n(b byte, n int)
+	write8sl(b []byte)
 	write16(data uint16)
 	write16n(data uint16, n int)
 	write16sl(data []uint16)

ili9341/parallel_atsamd51.go

@@ -5,14 +5,14 @@ package ili9341
 import (
 	"machine"
 	"runtime/volatile"
+	"unsafe"
 )
 
 type parallelDriver struct {
 	d0 machine.Pin
 	wr machine.Pin
 
-	setPort *uint32
-	setMask uint32
+	setPort *uint8
 
 	clrPort *uint32
 	clrMask uint32
@@ -46,8 +46,12 @@ func (pd *parallelDriver) configure(config *Config) {
 	pd.wr.Configure(output)
 	pd.wr.High()
 
-	pd.setPort, _ = pd.d0.PortMaskSet()
-	pd.setMask = uint32(pd.d0) & 0x1f
+	// Calculates the address of the OUT register from the OUTSET register and obtains an address that allows 8-bit access.
+	//   OUT    : offset = 0x10
+	//   OUTSET : offset = 0x18
+	setPort, _ := pd.d0.PortMaskSet()
+	setMask := uint32(pd.d0) & 0x1f
+	pd.setPort = (*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(setPort)) - uintptr(8) + uintptr(setMask/8)))
 
 	pd.clrPort, _ = (pd.d0).PortMaskClear()
 	pd.clrMask = 0xFF << uint32(pd.d0)
@@ -58,12 +62,30 @@ func (pd *parallelDriver) configure(config *Config) {
 
 //go:inline
 func (pd *parallelDriver) write8(b byte) {
-	volatile.StoreUint32(pd.clrPort, pd.clrMask)
-	volatile.StoreUint32(pd.setPort, uint32(b)<<pd.setMask)
+	volatile.StoreUint8(pd.setPort, uint8(b))
+	pd.wrx()
+}
+
+//go:inline
+func (pd *parallelDriver) wrx() {
 	volatile.StoreUint32(pd.wrPortClr, pd.wrMaskClr)
 	volatile.StoreUint32(pd.wrPortSet, pd.wrMaskSet)
 }
 
+//go:inline
+func (pd *parallelDriver) write8n(b byte, n int) {
+	for i := 0; i < n; i++ {
+		pd.write8(b)
+	}
+}
+
+//go:inline
+func (pd *parallelDriver) write8sl(b []byte) {
+	for i := 0; i < len(b); i++ {
+		pd.write8(b[i])
+	}
+}
+
 //go:inline
 func (pd *parallelDriver) write16(data uint16) {
 	pd.write8(byte(data >> 8))

ili9341/spi_atsamd21.go

@@ -0,0 +1,116 @@
+// +build atsamd21
+
+package ili9341
+
+import (
+	"device/sam"
+	"machine"
+)
+
+type spiDriver struct {
+	bus machine.SPI
+}
+
+func NewSpi(bus machine.SPI, dc, cs, rst machine.Pin) *Device {
+	return &Device{
+		dc:  dc,
+		cs:  cs,
+		rst: rst,
+		rd:  machine.NoPin,
+		driver: &spiDriver{
+			bus: bus,
+		},
+	}
+}
+
+func (pd *spiDriver) configure(config *Config) {
+}
+
+func (pd *spiDriver) write8(b byte) {
+	pd.bus.Bus.CTRLB.ClearBits(sam.SERCOM_SPI_CTRLB_RXEN)
+
+	for !pd.bus.Bus.INTFLAG.HasBits(sam.SERCOM_SPI_INTFLAG_DRE) {
+	}
+	pd.bus.Bus.DATA.Set(uint32(b))
+
+	pd.bus.Bus.CTRLB.SetBits(sam.SERCOM_SPI_CTRLB_RXEN)
+	for pd.bus.Bus.SYNCBUSY.HasBits(sam.SERCOM_SPI_SYNCBUSY_CTRLB) {
+	}
+}
+
+func (pd *spiDriver) write8n(b byte, n int) {
+	pd.bus.Bus.CTRLB.ClearBits(sam.SERCOM_SPI_CTRLB_RXEN)
+
+	for i, c := 0, n; i < c; i++ {
+		for !pd.bus.Bus.INTFLAG.HasBits(sam.SERCOM_SPI_INTFLAG_DRE) {
+		}
+		pd.bus.Bus.DATA.Set(uint32(b))
+	}
+
+	pd.bus.Bus.CTRLB.SetBits(sam.SERCOM_SPI_CTRLB_RXEN)
+	for pd.bus.Bus.SYNCBUSY.HasBits(sam.SERCOM_SPI_SYNCBUSY_CTRLB) {
+	}
+}
+
+func (pd *spiDriver) write8sl(b []byte) {
+	pd.bus.Bus.CTRLB.ClearBits(sam.SERCOM_SPI_CTRLB_RXEN)
+
+	for i, c := 0, len(b); i < c; i++ {
+		for !pd.bus.Bus.INTFLAG.HasBits(sam.SERCOM_SPI_INTFLAG_DRE) {
+		}
+		pd.bus.Bus.DATA.Set(uint32(b[i]))
+	}
+
+	pd.bus.Bus.CTRLB.SetBits(sam.SERCOM_SPI_CTRLB_RXEN)
+	for pd.bus.Bus.SYNCBUSY.HasBits(sam.SERCOM_SPI_SYNCBUSY_CTRLB) {
+	}
+}
+
+func (pd *spiDriver) write16(data uint16) {
+	pd.bus.Bus.CTRLB.ClearBits(sam.SERCOM_SPI_CTRLB_RXEN)
+
+	for !pd.bus.Bus.INTFLAG.HasBits(sam.SERCOM_SPI_INTFLAG_DRE) {
+	}
+	pd.bus.Bus.DATA.Set(uint32(uint8(data >> 8)))
+	for !pd.bus.Bus.INTFLAG.HasBits(sam.SERCOM_SPI_INTFLAG_DRE) {
+	}
+	pd.bus.Bus.DATA.Set(uint32(uint8(data)))
+
+	pd.bus.Bus.CTRLB.SetBits(sam.SERCOM_SPI_CTRLB_RXEN)
+	for pd.bus.Bus.SYNCBUSY.HasBits(sam.SERCOM_SPI_SYNCBUSY_CTRLB) {
+	}
+}
+
+func (pd *spiDriver) write16n(data uint16, n int) {
+	pd.bus.Bus.CTRLB.ClearBits(sam.SERCOM_SPI_CTRLB_RXEN)
+
+	for i := 0; i < n; i++ {
+		for !pd.bus.Bus.INTFLAG.HasBits(sam.SERCOM_SPI_INTFLAG_DRE) {
+		}
+		pd.bus.Bus.DATA.Set(uint32(uint8(data >> 8)))
+		for !pd.bus.Bus.INTFLAG.HasBits(sam.SERCOM_SPI_INTFLAG_DRE) {
+		}
+		pd.bus.Bus.DATA.Set(uint32(uint8(data)))
+	}
+
+	pd.bus.Bus.CTRLB.SetBits(sam.SERCOM_SPI_CTRLB_RXEN)
+	for pd.bus.Bus.SYNCBUSY.HasBits(sam.SERCOM_SPI_SYNCBUSY_CTRLB) {
+	}
+}
+
+func (pd *spiDriver) write16sl(data []uint16) {
+	pd.bus.Bus.CTRLB.ClearBits(sam.SERCOM_SPI_CTRLB_RXEN)
+
+	for i, c := 0, len(data); i < c; i++ {
+		for !pd.bus.Bus.INTFLAG.HasBits(sam.SERCOM_SPI_INTFLAG_DRE) {
+		}
+		pd.bus.Bus.DATA.Set(uint32(uint8(data[i] >> 8)))
+		for !pd.bus.Bus.INTFLAG.HasBits(sam.SERCOM_SPI_INTFLAG_DRE) {
+		}
+		pd.bus.Bus.DATA.Set(uint32(uint8(data[i])))
+	}
+
+	pd.bus.Bus.CTRLB.SetBits(sam.SERCOM_SPI_CTRLB_RXEN)
+	for pd.bus.Bus.SYNCBUSY.HasBits(sam.SERCOM_SPI_SYNCBUSY_CTRLB) {
+	}
+}

ili9341/spi_atsamd51.go

@@ -0,0 +1,116 @@
+// +build atsamd51
+
+package ili9341
+
+import (
+	"device/sam"
+	"machine"
+)
+
+type spiDriver struct {
+	bus machine.SPI
+}
+
+func NewSpi(bus machine.SPI, dc, cs, rst machine.Pin) *Device {
+	return &Device{
+		dc:  dc,
+		cs:  cs,
+		rst: rst,
+		rd:  machine.NoPin,
+		driver: &spiDriver{
+			bus: bus,
+		},
+	}
+}
+
+func (pd *spiDriver) configure(config *Config) {
+}
+
+func (pd *spiDriver) write8(b byte) {
+	pd.bus.Bus.CTRLB.ClearBits(sam.SERCOM_SPIM_CTRLB_RXEN)
+
+	for !pd.bus.Bus.INTFLAG.HasBits(sam.SERCOM_SPIM_INTFLAG_DRE) {
+	}
+	pd.bus.Bus.DATA.Set(uint32(b))
+
+	pd.bus.Bus.CTRLB.SetBits(sam.SERCOM_SPIM_CTRLB_RXEN)
+	for pd.bus.Bus.SYNCBUSY.HasBits(sam.SERCOM_SPIM_SYNCBUSY_CTRLB) {
+	}
+}
+
+func (pd *spiDriver) write8n(b byte, n int) {
+	pd.bus.Bus.CTRLB.ClearBits(sam.SERCOM_SPIM_CTRLB_RXEN)
+
+	for i, c := 0, n; i < c; i++ {
+		for !pd.bus.Bus.INTFLAG.HasBits(sam.SERCOM_SPIM_INTFLAG_DRE) {
+		}
+		pd.bus.Bus.DATA.Set(uint32(b))
+	}
+
+	pd.bus.Bus.CTRLB.SetBits(sam.SERCOM_SPIM_CTRLB_RXEN)
+	for pd.bus.Bus.SYNCBUSY.HasBits(sam.SERCOM_SPIM_SYNCBUSY_CTRLB) {
+	}
+}
+
+func (pd *spiDriver) write8sl(b []byte) {
+	pd.bus.Bus.CTRLB.ClearBits(sam.SERCOM_SPIM_CTRLB_RXEN)
+
+	for i, c := 0, len(b); i < c; i++ {
+		for !pd.bus.Bus.INTFLAG.HasBits(sam.SERCOM_SPIM_INTFLAG_DRE) {
+		}
+		pd.bus.Bus.DATA.Set(uint32(b[i]))
+	}
+
+	pd.bus.Bus.CTRLB.SetBits(sam.SERCOM_SPIM_CTRLB_RXEN)
+	for pd.bus.Bus.SYNCBUSY.HasBits(sam.SERCOM_SPIM_SYNCBUSY_CTRLB) {
+	}
+}
+
+func (pd *spiDriver) write16(data uint16) {
+	pd.bus.Bus.CTRLB.ClearBits(sam.SERCOM_SPIM_CTRLB_RXEN)
+
+	for !pd.bus.Bus.INTFLAG.HasBits(sam.SERCOM_SPIM_INTFLAG_DRE) {
+	}
+	pd.bus.Bus.DATA.Set(uint32(uint8(data >> 8)))
+	for !pd.bus.Bus.INTFLAG.HasBits(sam.SERCOM_SPIM_INTFLAG_DRE) {
+	}
+	pd.bus.Bus.DATA.Set(uint32(uint8(data)))
+
+	pd.bus.Bus.CTRLB.SetBits(sam.SERCOM_SPIM_CTRLB_RXEN)
+	for pd.bus.Bus.SYNCBUSY.HasBits(sam.SERCOM_SPIM_SYNCBUSY_CTRLB) {
+	}
+}
+
+func (pd *spiDriver) write16n(data uint16, n int) {
+	pd.bus.Bus.CTRLB.ClearBits(sam.SERCOM_SPIM_CTRLB_RXEN)
+
+	for i := 0; i < n; i++ {
+		for !pd.bus.Bus.INTFLAG.HasBits(sam.SERCOM_SPIM_INTFLAG_DRE) {
+		}
+		pd.bus.Bus.DATA.Set(uint32(uint8(data >> 8)))
+		for !pd.bus.Bus.INTFLAG.HasBits(sam.SERCOM_SPIM_INTFLAG_DRE) {
+		}
+		pd.bus.Bus.DATA.Set(uint32(uint8(data)))
+	}
+
+	pd.bus.Bus.CTRLB.SetBits(sam.SERCOM_SPIM_CTRLB_RXEN)
+	for pd.bus.Bus.SYNCBUSY.HasBits(sam.SERCOM_SPIM_SYNCBUSY_CTRLB) {
+	}
+}
+
+func (pd *spiDriver) write16sl(data []uint16) {
+	pd.bus.Bus.CTRLB.ClearBits(sam.SERCOM_SPIM_CTRLB_RXEN)
+
+	for i, c := 0, len(data); i < c; i++ {
+		for !pd.bus.Bus.INTFLAG.HasBits(sam.SERCOM_SPIM_INTFLAG_DRE) {
+		}
+		pd.bus.Bus.DATA.Set(uint32(uint8(data[i] >> 8)))
+		for !pd.bus.Bus.INTFLAG.HasBits(sam.SERCOM_SPIM_INTFLAG_DRE) {
+		}
+		pd.bus.Bus.DATA.Set(uint32(uint8(data[i])))
+	}
+
+	pd.bus.Bus.CTRLB.SetBits(sam.SERCOM_SPIM_CTRLB_RXEN)
+	for pd.bus.Bus.SYNCBUSY.HasBits(sam.SERCOM_SPIM_SYNCBUSY_CTRLB) {
+	}
+}

lsm303agr/lsm303agr.go

@@ -0,0 +1,203 @@
+// Package lsm303agr implements a driver for the LSM303AGR,
+// a 3 axis accelerometer/magnetic sensor which is included on BBC micro:bits v1.5.
+//
+// Datasheet: https://www.st.com/resource/en/datasheet/lsm303agr.pdf
+//
+package lsm303agr // import "tinygo.org/x/drivers/lsm303agr"
+
+import (
+	"machine"
+	"math"
+)
+
+// Device wraps an I2C connection to a LSM303AGR device.
+type Device struct {
+	bus            machine.I2C
+	AccelAddress   uint8
+	MagAddress     uint8
+	AccelPowerMode uint8
+	AccelRange     uint8
+	AccelDataRate  uint8
+	MagPowerMode   uint8
+	MagSystemMode  uint8
+	MagDataRate    uint8
+}
+
+// Configuration for LSM303AGR device.
+type Configuration struct {
+	AccelPowerMode uint8
+	AccelRange     uint8
+	AccelDataRate  uint8
+	MagPowerMode   uint8
+	MagSystemMode  uint8
+	MagDataRate    uint8
+}
+
+// New creates a new LSM303AGR 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 {
+	return Device{bus: bus, AccelAddress: ACCEL_ADDRESS, MagAddress: MAG_ADDRESS}
+}
+
+// Connected returns whether both sensor on LSM303AGR has been found.
+// It does two "who am I" requests and checks the responses.
+func (d *Device) Connected() bool {
+	data1, data2 := []byte{0}, []byte{0}
+	d.bus.ReadRegister(uint8(d.AccelAddress), ACCEL_WHO_AM_I, data1)
+	d.bus.ReadRegister(uint8(d.MagAddress), MAG_WHO_AM_I, data2)
+	return data1[0] == 0x33 && data2[0] == 0x40
+}
+
+// Configure sets up the LSM303AGR device for communication.
+func (d *Device) Configure(cfg Configuration) {
+
+	if cfg.AccelDataRate != 0 {
+		d.AccelDataRate = cfg.AccelDataRate
+	} else {
+		d.AccelDataRate = ACCEL_DATARATE_100HZ
+	}
+
+	if cfg.AccelPowerMode != 0 {
+		d.AccelPowerMode = cfg.AccelPowerMode
+	} else {
+		d.AccelPowerMode = ACCEL_POWER_NORMAL
+	}
+
+	if cfg.AccelRange != 0 {
+		d.AccelRange = cfg.AccelRange
+	} else {
+		d.AccelRange = ACCEL_RANGE_2G
+	}
+
+	if cfg.MagPowerMode != 0 {
+		d.MagPowerMode = cfg.MagPowerMode
+	} else {
+		d.MagPowerMode = MAG_POWER_NORMAL
+	}
+
+	if cfg.MagDataRate != 0 {
+		d.MagDataRate = cfg.MagDataRate
+	} else {
+		d.MagDataRate = MAG_DATARATE_10HZ
+	}
+
+	if cfg.MagSystemMode != 0 {
+		d.MagSystemMode = cfg.MagSystemMode
+	} else {
+		d.MagSystemMode = MAG_SYSTEM_CONTINUOUS
+	}
+
+	cmd := []byte{0}
+
+	cmd[0] = byte(d.AccelDataRate<<4 | d.AccelPowerMode | 0x07)
+	d.bus.WriteRegister(uint8(d.AccelAddress), ACCEL_CTRL_REG1_A, cmd)
+
+	cmd[0] = byte(0x80 | d.AccelRange<<4)
+	d.bus.WriteRegister(uint8(d.AccelAddress), ACCEL_CTRL_REG4_A, cmd)
+
+	cmd[0] = byte(0xC0)
+	d.bus.WriteRegister(uint8(d.AccelAddress), TEMP_CFG_REG_A, cmd)
+
+	// Temperature compensation is on for magnetic sensor
+	cmd[0] = byte(0x80 | d.MagPowerMode<<4 | d.MagDataRate<<2 | d.MagSystemMode)
+	d.bus.WriteRegister(uint8(d.MagAddress), MAG_MR_REG_M, cmd)
+
+}
+
+// ReadAcceleration reads the current acceleration from the device and returns
+// it in µg (micro-gravity). When one of the axes is pointing straight to Earth
+// and the sensor is not moving the returned value will be around 1000000 or
+// -1000000.
+func (d *Device) ReadAcceleration() (x int32, y int32, z int32) {
+
+	data1, data2, data3, data4, data5, data6 := []byte{0}, []byte{0}, []byte{0}, []byte{0}, []byte{0}, []byte{0}
+	d.bus.ReadRegister(uint8(d.AccelAddress), ACCEL_OUT_X_H_A, data1)
+	d.bus.ReadRegister(uint8(d.AccelAddress), ACCEL_OUT_X_L_A, data2)
+	d.bus.ReadRegister(uint8(d.AccelAddress), ACCEL_OUT_Y_H_A, data3)
+	d.bus.ReadRegister(uint8(d.AccelAddress), ACCEL_OUT_Y_L_A, data4)
+	d.bus.ReadRegister(uint8(d.AccelAddress), ACCEL_OUT_Z_H_A, data5)
+	d.bus.ReadRegister(uint8(d.AccelAddress), ACCEL_OUT_Z_L_A, data6)
+
+	rangeFactor := int16(0)
+	switch d.AccelRange {
+	case ACCEL_RANGE_2G:
+		rangeFactor = 1
+	case ACCEL_RANGE_4G:
+		rangeFactor = 2
+	case ACCEL_RANGE_8G:
+		rangeFactor = 4
+	case ACCEL_RANGE_16G:
+		rangeFactor = 12 // the readings in 16G are a bit lower
+	}
+
+	x = int32(int32(int16((uint16(data1[0])<<8|uint16(data2[0])))>>4*rangeFactor) * 1000000 / 1024)
+	y = int32(int32(int16((uint16(data3[0])<<8|uint16(data4[0])))>>4*rangeFactor) * 1000000 / 1024)
+	z = int32(int32(int16((uint16(data5[0])<<8|uint16(data6[0])))>>4*rangeFactor) * 1000000 / 1024)
+	return
+}
+
+// ReadPitchRoll reads the current pitch and roll angles from the device and
+// returns it in micro-degrees. When the z axis is pointing straight to Earth
+// the returned values of pitch and roll would be zero.
+func (d *Device) ReadPitchRoll() (pitch int32, roll int32) {
+
+	x, y, z := d.ReadAcceleration()
+	xf, yf, zf := float64(x), float64(y), float64(z)
+	pitch = int32((math.Round(math.Atan2(yf, math.Sqrt(math.Pow(xf, 2)+math.Pow(zf, 2)))*(180/math.Pi)*100) / 100) * 1000000)
+	roll = int32((math.Round(math.Atan2(xf, math.Sqrt(math.Pow(yf, 2)+math.Pow(zf, 2)))*(180/math.Pi)*100) / 100) * 1000000)
+	return
+
+}
+
+// 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) {
+
+	if d.MagSystemMode == MAG_SYSTEM_SINGLE {
+		cmd := []byte{0}
+		cmd[0] = byte(0x80 | d.MagPowerMode<<4 | d.MagDataRate<<2 | d.MagSystemMode)
+		d.bus.WriteRegister(uint8(d.MagAddress), MAG_MR_REG_M, cmd)
+	}
+
+	data1, data2, data3, data4, data5, data6 := []byte{0}, []byte{0}, []byte{0}, []byte{0}, []byte{0}, []byte{0}
+	d.bus.ReadRegister(uint8(d.MagAddress), MAG_OUT_X_H_M, data1)
+	d.bus.ReadRegister(uint8(d.MagAddress), MAG_OUT_X_L_M, data2)
+	d.bus.ReadRegister(uint8(d.MagAddress), MAG_OUT_Y_H_M, data3)
+	d.bus.ReadRegister(uint8(d.MagAddress), MAG_OUT_Y_L_M, data4)
+	d.bus.ReadRegister(uint8(d.MagAddress), MAG_OUT_Z_H_M, data5)
+	d.bus.ReadRegister(uint8(d.MagAddress), MAG_OUT_Z_L_M, data6)
+
+	x = int32(int16((uint16(data1[0])<<8 | uint16(data2[0]))))
+	y = int32(int16((uint16(data3[0])<<8 | uint16(data4[0]))))
+	z = int32(int16((uint16(data5[0])<<8 | uint16(data6[0]))))
+	return
+}
+
+// ReadCompass reads the current compass heading from the device and returns
+// it in micro-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), float64(y)
+	h = int32(float32((180/math.Pi)*math.Atan2(yf, xf)) * 1000000)
+	return
+}
+
+// ReadTemperature returns the temperature in Celsius milli degrees (°C/1000)
+func (d *Device) ReadTemperature() (c int32, e error) {
+
+	data1, data2 := []byte{0}, []byte{0}
+	d.bus.ReadRegister(uint8(d.AccelAddress), OUT_TEMP_H_A, data1)
+	d.bus.ReadRegister(uint8(d.AccelAddress), OUT_TEMP_L_A, data2)
+
+	t := int16((uint16(data1[0])<<8 | uint16(data2[0]))) >> 4 // temperature offsef from 25 °C
+	c = int32((float32(25) + float32(t)/8) * 1000)
+	e = nil
+	return
+}

lsm303agr/registers.go

@@ -0,0 +1,68 @@
+package lsm303agr
+
+const (
+
+	// Constants/addresses used for I2C.
+	ACCEL_ADDRESS = 0x19
+	MAG_ADDRESS   = 0x1E
+
+	// accelerometer registers.
+	ACCEL_WHO_AM_I    = 0x0F
+	ACCEL_CTRL_REG1_A = 0x20
+	ACCEL_CTRL_REG4_A = 0x23
+	ACCEL_OUT_X_L_A   = 0x28
+	ACCEL_OUT_X_H_A   = 0x29
+	ACCEL_OUT_Y_L_A   = 0x2A
+	ACCEL_OUT_Y_H_A   = 0x2B
+	ACCEL_OUT_Z_L_A   = 0x2C
+	ACCEL_OUT_Z_H_A   = 0x2D
+
+	// magnetic sensor registers.
+	MAG_WHO_AM_I  = 0x4F
+	MAG_MR_REG_M  = 0x60
+	MAG_OUT_X_L_M = 0x68
+	MAG_OUT_X_H_M = 0x69
+	MAG_OUT_Y_L_M = 0x6A
+	MAG_OUT_Y_H_M = 0x6B
+	MAG_OUT_Z_L_M = 0x6C
+	MAG_OUT_Z_H_M = 0x6D
+
+	// temperature sensor registers.
+	TEMP_CFG_REG_A = 0x1F
+	OUT_TEMP_L_A   = 0x0C
+	OUT_TEMP_H_A   = 0x0D
+
+	// accelerometer power mode.
+	ACCEL_POWER_NORMAL = 0x00 // default
+	ACCEL_POWER_LOW    = 0x08
+
+	// accelerometer range.
+	ACCEL_RANGE_2G  = 0x00 // default
+	ACCEL_RANGE_4G  = 0x01
+	ACCEL_RANGE_8G  = 0x02
+	ACCEL_RANGE_16G = 0x03
+
+	// accelerometer data rate.
+	ACCEL_DATARATE_1HZ    = 0x01
+	ACCEL_DATARATE_10HZ   = 0x02
+	ACCEL_DATARATE_25HZ   = 0x03
+	ACCEL_DATARATE_50HZ   = 0x04
+	ACCEL_DATARATE_100HZ  = 0x05 // default
+	ACCEL_DATARATE_200HZ  = 0x06
+	ACCEL_DATARATE_400HZ  = 0x07
+	ACCEL_DATARATE_1344HZ = 0x09 // 5376Hz in low-power mode
+
+	// magnetic sensor power mode.
+	MAG_POWER_NORMAL = 0x00 // default
+	MAG_POWER_LOW    = 0x01
+
+	// magnetic sensor operate mode.
+	MAG_SYSTEM_CONTINUOUS = 0x00 // default
+	MAG_SYSTEM_SINGLE     = 0x01
+
+	// magnetic sensor data rate
+	MAG_DATARATE_10HZ  = 0x00 // default
+	MAG_DATARATE_20HZ  = 0x01
+	MAG_DATARATE_50HZ  = 0x02
+	MAG_DATARATE_100HZ = 0x03
+)

mpu6050/registers.go

@@ -91,11 +91,11 @@ const (
 	EXT_SENS_DATA_22 = 0x5F
 	EXT_SENS_DATA_23 = 0x60
 
-	// I2C slave data out
-	I2C_SLV0_DO      = 0x63
-	I2C_SLV1_DO      = 0x64
-	I2C_SLV2_DO      = 0x65
-	I2C_SLV3_DO      = 0x66
+	// I2C peripheral data out
+	I2C_PER0_DO      = 0x63
+	I2C_PER1_DO      = 0x64
+	I2C_PER2_DO      = 0x65
+	I2C_PER3_DO      = 0x66
 	I2C_MST_DELAY_CT = 0x67
 
 	SIGNAL_PATH_RES = 0x68 // Signal path reset

net/mqtt/router.go

@@ -150,10 +150,8 @@ func (r *router) matchAndDispatch(messages <-chan *packets.PublishPacket, order
 							handlers = append(handlers, e.Value.(*route).callback)
 						} else {
 							hd := e.Value.(*route).callback
-							go func() {
-								hd(client, m)
-								//TODO: m.Ack()
-							}()
+							hd(client, m)
+							//TODO: m.Ack()
 						}
 						sent = true
 					}
@@ -162,10 +160,8 @@ func (r *router) matchAndDispatch(messages <-chan *packets.PublishPacket, order
 					if order {
 						handlers = append(handlers, r.defaultHandler)
 					} else {
-						go func() {
-							r.defaultHandler(client, m)
-							//TODO: m.Ack()
-						}()
+						r.defaultHandler(client, m)
+						//TODO: m.Ack()
 					}
 				}
 				for _, handler := range handlers {

ssd1331/ssd1331.go

@@ -220,7 +220,7 @@ func (d *Device) DrawFastHLine(x0, x1, y int16, c color.RGBA) {
 	if x0 > x1 {
 		x0, x1 = x1, x0
 	}
-	d.FillRectangle(x0, y, x1-x0+1, y, c)
+	d.FillRectangle(x0, y, x1-x0+1, 1, c)
 }
 
 // FillScreen fills the screen with a given color

ssd1351/commands.go

@@ -0,0 +1,38 @@
+package ssd1351
+
+// Commands
+const (
+	SET_COLUMN_ADDRESS          = 0x15
+	SET_ROW_ADDRESS             = 0x75
+	WRITE_RAM                   = 0x5C
+	READ_RAM                    = 0x5D
+	SET_REMAP_COLORDEPTH        = 0xA0
+	SET_DISPLAY_START_LINE      = 0xA1
+	SET_DISPLAY_OFFSET          = 0xA2
+	SET_DISPLAY_MODE_ALLOFF     = 0xA4
+	SET_DISPLAY_MODE_ALLON      = 0xA5
+	SET_DISPLAY_MODE_RESET      = 0xA6
+	SET_DISPLAY_MODE_INVERT     = 0xA7
+	FUNCTION_SELECTION          = 0xAB
+	SLEEP_MODE_DISPLAY_OFF      = 0xAE
+	SLEEP_MODE_DISPLAY_ON       = 0xAF
+	SET_PHASE_PERIOD            = 0xB1
+	ENHANCED_DRIVING_SCHEME     = 0xB2
+	SET_FRONT_CLOCK_DIV         = 0xB3
+	SET_SEGMENT_LOW_VOLTAGE     = 0xB4
+	SET_GPIO                    = 0xB5
+	SET_SECOND_PRECHARGE_PERIOD = 0xB6
+	GRAY_SCALE_LOOKUP           = 0xB8
+	LINEAR_LUT                  = 0xB9
+	SET_PRECHARGE_VOLTAGE       = 0xBB
+	SET_VCOMH_VOLTAGE           = 0xBE
+	SET_CONTRAST                = 0xC1
+	MASTER_CONTRAST             = 0xC7
+	SET_MUX_RATIO               = 0xCA
+	NOP0                        = 0xD1
+	NOP1                        = 0xE3
+	SET_COMMAND_LOCK            = 0xFD
+	HORIZONTAL_SCROLL           = 0x96
+	STOP_MOVING                 = 0x9E
+	START_MOVING                = 0x9F
+)

ssd1351/ssd1351.go

@@ -0,0 +1,297 @@
+// Package ssd1351 implements a driver for the SSD1351 OLED color displays.
+//
+// Datasheet: https://download.mikroe.com/documents/datasheets/ssd1351-revision-1.3.pdf
+//
+package ssd1351 // import "tinygo.org/x/drivers/ssd1351"
+
+import (
+	"errors"
+	"image/color"
+	"machine"
+	"time"
+)
+
+var (
+	errDrawingOutOfBounds = errors.New("rectangle coordinates outside display area")
+	errBufferSizeMismatch = errors.New("buffer length does not match with rectangle size")
+)
+
+// Device wraps an SPI connection.
+type Device struct {
+	bus          machine.SPI
+	dcPin        machine.Pin
+	resetPin     machine.Pin
+	csPin        machine.Pin
+	enPin        machine.Pin
+	rwPin        machine.Pin
+	width        int16
+	height       int16
+	rowOffset    int16
+	columnOffset int16
+	bufferLength int16
+}
+
+// Config is the configuration for the display
+type Config struct {
+	Width        int16
+	Height       int16
+	RowOffset    int16
+	ColumnOffset int16
+}
+
+// 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 {
+	return Device{
+		bus:      bus,
+		dcPin:    dcPin,
+		resetPin: resetPin,
+		csPin:    csPin,
+		enPin:    enPin,
+		rwPin:    rwPin,
+	}
+}
+
+// Configure initializes the display with default configuration
+func (d *Device) Configure(cfg Config) {
+	if cfg.Width == 0 {
+		cfg.Width = 128
+	}
+
+	if cfg.Height == 0 {
+		cfg.Height = 128
+	}
+
+	d.width = cfg.Width
+	d.height = cfg.Height
+	d.rowOffset = cfg.RowOffset
+	d.columnOffset = cfg.ColumnOffset
+
+	d.bufferLength = d.width
+	if d.height > d.width {
+		d.bufferLength = d.height
+	}
+
+	// configure GPIO pins
+	d.dcPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	d.resetPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	d.csPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	d.enPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	d.rwPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
+
+	// reset the device
+	d.resetPin.High()
+	time.Sleep(100 * time.Millisecond)
+	d.resetPin.Low()
+	time.Sleep(100 * time.Millisecond)
+	d.resetPin.High()
+	time.Sleep(200 * time.Millisecond)
+
+	d.rwPin.Low()
+	d.dcPin.Low()
+	d.enPin.High()
+
+	// Initialization
+	d.Command(SET_COMMAND_LOCK)
+	d.Data(0x12)
+	d.Command(SET_COMMAND_LOCK)
+	d.Data(0xB1)
+	d.Command(SLEEP_MODE_DISPLAY_OFF)
+	d.Command(SET_FRONT_CLOCK_DIV)
+	d.Data(0xF1)
+	d.Command(SET_MUX_RATIO)
+	d.Data(0x7F)
+	d.Command(SET_REMAP_COLORDEPTH)
+	d.Data(0x72)
+	d.Command(SET_COLUMN_ADDRESS)
+	d.Data(0x00)
+	d.Data(0x7F)
+	d.Command(SET_ROW_ADDRESS)
+	d.Data(0x00)
+	d.Data(0x7F)
+	d.Command(SET_DISPLAY_START_LINE)
+	d.Data(0x00)
+	d.Command(SET_DISPLAY_OFFSET)
+	d.Data(0x00)
+	d.Command(SET_GPIO)
+	d.Data(0x00)
+	d.Command(FUNCTION_SELECTION)
+	d.Data(0x01)
+	d.Command(SET_PHASE_PERIOD)
+	d.Data(0x32)
+	d.Command(SET_SEGMENT_LOW_VOLTAGE)
+	d.Data(0xA0)
+	d.Data(0xB5)
+	d.Data(0x55)
+	d.Command(SET_PRECHARGE_VOLTAGE)
+	d.Data(0x17)
+	d.Command(SET_VCOMH_VOLTAGE)
+	d.Data(0x05)
+	d.Command(SET_CONTRAST)
+	d.Data(0xC8)
+	d.Data(0x80)
+	d.Data(0xC8)
+	d.Command(MASTER_CONTRAST)
+	d.Data(0x0F)
+	d.Command(SET_SECOND_PRECHARGE_PERIOD)
+	d.Data(0x01)
+	d.Command(SET_DISPLAY_MODE_RESET)
+	d.Command(SLEEP_MODE_DISPLAY_ON)
+
+}
+
+// Display does nothing, there's no buffer as it might be too big for some boards
+func (d *Device) Display() error {
+	return nil
+}
+
+// SetPixel sets a pixel in the buffer
+func (d *Device) SetPixel(x int16, y int16, c color.RGBA) {
+	if x < 0 || y < 0 || x >= d.width || y >= d.height {
+		return
+	}
+	d.FillRectangle(x, y, 1, 1, c)
+}
+
+// setWindow prepares the screen memory to be modified at given coordinates
+func (d *Device) setWindow(x, y, w, h int16) {
+	x += d.columnOffset
+	y += d.rowOffset
+	d.Command(SET_COLUMN_ADDRESS)
+	d.Tx([]byte{uint8(x), uint8(x + w - 1)}, false)
+	d.Command(SET_ROW_ADDRESS)
+	d.Tx([]byte{uint8(y), uint8(y + h - 1)}, false)
+	d.Command(WRITE_RAM)
+}
+
+// FillRectangle fills a rectangle at given coordinates with a color
+func (d *Device) FillRectangle(x, y, width, height int16, c color.RGBA) error {
+	if x < 0 || y < 0 || width <= 0 || height <= 0 ||
+		x >= d.width || (x+width) > d.width || y >= d.height || (y+height) > d.height {
+		return errDrawingOutOfBounds
+	}
+	d.setWindow(x, y, width, height)
+	c565 := RGBATo565(c)
+	c1 := uint8(c565 >> 8)
+	c2 := uint8(c565)
+
+	dim := int16(width * height)
+	if d.bufferLength < dim {
+		dim = d.bufferLength
+	}
+	data := make([]uint8, dim*2)
+
+	for i := int16(0); i < dim; i++ {
+		data[i*2] = c1
+		data[i*2+1] = c2
+	}
+	dim = int16(width * height)
+	for dim > 0 {
+		if dim >= d.bufferLength {
+			d.Tx(data, false)
+		} else {
+			d.Tx(data[:dim*2], false)
+		}
+		dim -= d.bufferLength
+	}
+	return nil
+}
+
+// FillRectangleWithBuffer fills a rectangle at given coordinates with a buffer
+func (d *Device) FillRectangleWithBuffer(x, y, width, height int16, buffer []color.RGBA) error {
+	if x < 0 || y < 0 || width <= 0 || height <= 0 ||
+		x >= d.width || (x+width) > d.width || y >= d.height || (y+height) > d.height {
+		return errDrawingOutOfBounds
+	}
+	dim := int16(width * height)
+	l := int16(len(buffer))
+	if dim != l {
+		return errBufferSizeMismatch
+	}
+
+	d.setWindow(x, y, width, height)
+
+	bl := dim
+	if d.bufferLength < dim {
+		bl = d.bufferLength
+	}
+	data := make([]uint8, bl*2)
+
+	offset := int16(0)
+	for dim > 0 {
+		for i := int16(0); i < bl; i++ {
+			if offset+i < l {
+				c565 := RGBATo565(buffer[offset+i])
+				c1 := uint8(c565 >> 8)
+				c2 := uint8(c565)
+				data[i*2] = c1
+				data[i*2+1] = c2
+			}
+		}
+		if dim >= d.bufferLength {
+			d.Tx(data, false)
+		} else {
+			d.Tx(data[:dim*2], false)
+		}
+		dim -= d.bufferLength
+		offset += d.bufferLength
+	}
+	return nil
+}
+
+// DrawFastVLine draws a vertical line faster than using SetPixel
+func (d *Device) DrawFastVLine(x, y0, y1 int16, c color.RGBA) {
+	if y0 > y1 {
+		y0, y1 = y1, y0
+	}
+	d.FillRectangle(x, y0, 1, y1-y0+1, c)
+}
+
+// DrawFastHLine draws a horizontal line faster than using SetPixel
+func (d *Device) DrawFastHLine(x0, x1, y int16, c color.RGBA) {
+	if x0 > x1 {
+		x0, x1 = x1, x0
+	}
+	d.FillRectangle(x0, y, x1-x0+1, 1, c)
+}
+
+// FillScreen fills the screen with a given color
+func (d *Device) FillScreen(c color.RGBA) {
+	d.FillRectangle(0, 0, d.width, d.height, c)
+}
+
+// SetContrast sets the three contrast values (A, B & C)
+func (d *Device) SetContrast(contrastA, contrastB, contrastC uint8) {
+	d.Command(SET_CONTRAST)
+	d.Tx([]byte{contrastA, contrastB, contrastC}, false)
+}
+
+// Command sends a command byte to the display
+func (d *Device) Command(command uint8) {
+	d.Tx([]byte{command}, true)
+}
+
+// Data sends a data byte to the display
+func (d *Device) Data(data uint8) {
+	d.Tx([]byte{data}, false)
+}
+
+// Tx sends data to the display
+func (d *Device) Tx(data []byte, isCommand bool) {
+	d.dcPin.Set(!isCommand)
+	d.csPin.Low()
+	d.bus.Tx(data, nil)
+	d.csPin.High()
+}
+
+// Size returns the current size of the display
+func (d *Device) Size() (w, h int16) {
+	return d.width, d.height
+}
+
+// RGBATo565 converts a color.RGBA to uint16 used in the display
+func RGBATo565(c color.RGBA) uint16 {
+	r, g, b, _ := c.RGBA()
+	return uint16((r & 0xF800) +
+		((g & 0xFC00) >> 5) +
+		((b & 0xF800) >> 11))
+}

st7735/st7735.go

@@ -323,7 +323,7 @@ func (d *Device) DrawFastHLine(x0, x1, y int16, c color.RGBA) {
 	if x0 > x1 {
 		x0, x1 = x1, x0
 	}
-	d.FillRectangle(x0, y, x1-x0+1, y, c)
+	d.FillRectangle(x0, y, x1-x0+1, 1, c)
 }
 
 // FillScreen fills the screen with a given color

st7789/st7789.go

@@ -207,7 +207,7 @@ func (d *Device) DrawFastHLine(x0, x1, y int16, c color.RGBA) {
 	if x0 > x1 {
 		x0, x1 = x1, x0
 	}
-	d.FillRectangle(x0, y, x1-x0+1, y, c)
+	d.FillRectangle(x0, y, x1-x0+1, 1, c)
 }
 
 // FillScreen fills the screen with a given color

tmp102/registers.go

@@ -0,0 +1,18 @@
+package tmp102
+
+const (
+	// Default I2C address
+	Address = 0x48
+
+	// Temperature register address
+	RegTemperature = 0x00
+
+	// Configuration register address
+	RegConfiguration = 0x01
+
+	// Low limit register address
+	RegLimitLow = 0x02
+
+	// High limit register address
+	RegLimitHigh = 0x03
+)

tmp102/tmp102.go

@@ -0,0 +1,70 @@
+// Package tmp102 implements a driver for the TMP102 digital temperature sensor.
+//
+// Datasheet: https://download.mikroe.com/documents/datasheets/tmp102-data-sheet.pdf
+
+package tmp102 // import "tinygo.org/x/drivers/tmp102"
+
+import (
+	"machine"
+)
+
+// Device holds the already configured I2C bus and the address of the sensor.
+type Device struct {
+	bus     machine.I2C
+	address uint8
+}
+
+// Config is the configuration for the TMP102.
+type Config struct {
+	Address uint8
+}
+
+// New creates a new TMP102 connection. The I2C bus must already be configured.
+func New(bus machine.I2C) Device {
+	return Device{
+		bus: bus,
+	}
+}
+
+// Configure initializes the sensor with the given parameters.
+func (d *Device) Configure(cfg Config) {
+	if cfg.Address == 0 {
+		cfg.Address = Address
+	}
+
+	d.address = cfg.Address
+}
+
+// Connected checks if the config register can be read and that the configuration is correct.
+func (d *Device) Connected() bool {
+	configData := make([]byte, 2)
+	err := d.bus.ReadRegister(d.address, RegConfiguration, configData)
+	// Check the reset configuration values.
+	if err != nil || configData[0] != 0x60 || configData[1] != 0xA0 {
+		return false
+	}
+	return true
+
+}
+
+// Reads the temperature from the sensor and returns it in celsius milli degrees (°C/1000).
+func (d *Device) ReadTemperature() (temperature int32, err error) {
+
+	tmpData := make([]byte, 2)
+
+	err = d.bus.ReadRegister(d.address, RegTemperature, tmpData)
+
+	if err != nil {
+		return
+	}
+
+	temperatureSum := int32((int16(tmpData[0])<<8 | int16(tmpData[1])) >> 4)
+
+	if (temperatureSum & int32(1<<11)) == int32(1<<11) {
+		temperatureSum |= int32(0xf800)
+	}
+
+	temperature = temperatureSum * 625
+
+	return temperature / 10, nil
+}

version.go

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

wifinina/tcp.go

@@ -20,6 +20,10 @@ type Driver struct {
 	dev     *Device
 	sock    uint8
 	readBuf readBuffer
+
+	proto uint8
+	ip    uint32
+	port  uint16
 }
 
 type readBuffer struct {
@@ -43,6 +47,8 @@ func (drv *Driver) ConnectSSLSocket(addr, portStr string) error {
 
 func (drv *Driver) connectSocket(addr, portStr string, mode uint8) error {
 
+	drv.proto, drv.ip, drv.port = mode, 0, 0
+
 	// convert port to uint16
 	p64, err := strconv.ParseUint(portStr, 10, 16)
 	if err != nil {
@@ -90,8 +96,56 @@ func (drv *Driver) connectSocket(addr, portStr string, mode uint8) error {
 	return ErrConnectionTimeout
 }
 
-func (drv *Driver) ConnectUDPSocket(addr, sport, lport string) error {
-	return ErrNotImplemented
+func convertPort(portStr string) (uint16, error) {
+	p64, err := strconv.ParseUint(portStr, 10, 16)
+	if err != nil {
+		return 0, fmt.Errorf("could not convert port to uint16: %w", err)
+	}
+	return uint16(p64), nil
+}
+
+func (drv *Driver) ConnectUDPSocket(addr, portStr, lportStr string) (err error) {
+
+	drv.proto, drv.ip, drv.port = ProtoModeUDP, 0, 0
+
+	// convert remote port to uint16
+	if drv.port, err = convertPort(portStr); err != nil {
+		return err
+	}
+
+	// convert local port to uint16
+	var lport uint16
+	if lport, err = convertPort(lportStr); err != nil {
+		return err
+	}
+
+	// look up the hostname if necessary; if an IP address was specified, the
+	// same will be returned.  Otherwise, an IPv4 for the hostname is returned.
+	ipAddr, err := drv.dev.GetHostByName(addr)
+	if err != nil {
+		return err
+	}
+	drv.ip = ipAddr.AsUint32()
+
+	// check to see if socket is already set; if so, stop it
+	// TODO: we can probably have more than one socket at once right?
+	if drv.sock != NoSocketAvail {
+		if err := drv.stop(); err != nil {
+			return err
+		}
+	}
+
+	// get a socket from the device
+	if drv.sock, err = drv.dev.GetSocket(); err != nil {
+		return err
+	}
+
+	// start listening for UDP packets on the local port
+	if err := drv.dev.StartServer(lport, drv.sock, drv.proto); err != nil {
+		return err
+	}
+
+	return nil
 }
 
 func (drv *Driver) DisconnectSocket() error {
@@ -114,16 +168,31 @@ func (drv *Driver) Write(b []byte) (n int, err error) {
 	if len(b) == 0 {
 		return 0, ErrNoData
 	}
-	written, err := drv.dev.SendData(b, drv.sock)
-	if err != nil {
-		return 0, err
-	}
-	if written == 0 {
-		return 0, ErrDataNotWritten
-	}
-	if sent, _ := drv.dev.CheckDataSent(drv.sock); !sent {
-		return 0, ErrCheckDataError
+	if drv.proto == ProtoModeUDP {
+		if err := drv.dev.StartClient(drv.ip, drv.port, drv.sock, drv.proto); err != nil {
+			return 0, fmt.Errorf("error in startClient: %w", err)
+		}
+		if _, err := drv.dev.InsertDataBuf(b, drv.sock); err != nil {
+			return 0, fmt.Errorf("error in insertDataBuf: %w", err)
+		}
+		if _, err := drv.dev.SendUDPData(drv.sock); err != nil {
+			return 0, fmt.Errorf("error in sendUDPData: %w", err)
+		}
+		return len(b), nil
+	} else {
+		written, err := drv.dev.SendData(b, drv.sock)
+		if err != nil {
+			return 0, err
+		}
+		if written == 0 {
+			return 0, ErrDataNotWritten
+		}
+		if sent, _ := drv.dev.CheckDataSent(drv.sock); !sent {
+			return 0, ErrCheckDataError
+		}
+		return len(b), nil
 	}
+
 	return len(b), nil
 }
 

wifinina/wifinina.go

@@ -134,23 +134,23 @@ const (
 	CmdSetDigitalWrite = 0x51
 	CmdSetAnalogWrite  = 0x52
 
-	ErrTimeoutSlaveReady  Error = 0x01
-	ErrTimeoutSlaveSelect Error = 0x02
-	ErrCheckStartCmd      Error = 0x03
-	ErrWaitRsp            Error = 0x04
-	ErrUnexpectedLength   Error = 0xE0
-	ErrNoParamsReturned   Error = 0xE1
-	ErrIncorrectSentinel  Error = 0xE2
-	ErrCmdErrorReceived   Error = 0xEF
-	ErrNotImplemented     Error = 0xF0
-	ErrUnknownHost        Error = 0xF1
-	ErrSocketAlreadySet   Error = 0xF2
-	ErrConnectionTimeout  Error = 0xF3
-	ErrNoData             Error = 0xF4
-	ErrDataNotWritten     Error = 0xF5
-	ErrCheckDataError     Error = 0xF6
-	ErrBufferTooSmall     Error = 0xF7
-	ErrNoSocketAvail      Error = 0xFF
+	ErrTimeoutChipReady  Error = 0x01
+	ErrTimeoutChipSelect Error = 0x02
+	ErrCheckStartCmd     Error = 0x03
+	ErrWaitRsp           Error = 0x04
+	ErrUnexpectedLength  Error = 0xE0
+	ErrNoParamsReturned  Error = 0xE1
+	ErrIncorrectSentinel Error = 0xE2
+	ErrCmdErrorReceived  Error = 0xEF
+	ErrNotImplemented    Error = 0xF0
+	ErrUnknownHost       Error = 0xF1
+	ErrSocketAlreadySet  Error = 0xF2
+	ErrConnectionTimeout Error = 0xF3
+	ErrNoData            Error = 0xF4
+	ErrDataNotWritten    Error = 0xF5
+	ErrCheckDataError    Error = 0xF6
+	ErrBufferTooSmall    Error = 0xF7
+	ErrNoSocketAvail     Error = 0xFF
 
 	NoSocketAvail uint8 = 0xFF
 )
@@ -296,8 +296,8 @@ func (d *Device) StartClient(addr uint32, port uint16, sock uint8, mode uint8) e
 		println("[StartClient] called StartClient()\r")
 		fmt.Printf("[StartClient] addr: % 02X, port: %d, sock: %d\r\n", addr, port, sock)
 	}
-	if err := d.waitForSlaveSelect(); err != nil {
-		d.spiSlaveDeselect()
+	if err := d.waitForChipSelect(); err != nil {
+		d.spiChipDeselect()
 		return err
 	}
 	l := d.sendCmd(CmdStartClientTCP, 4)
@@ -306,7 +306,7 @@ func (d *Device) StartClient(addr uint32, port uint16, sock uint8, mode uint8) e
 	l += d.sendParam8(sock, false)
 	l += d.sendParam8(mode, true)
 	d.addPadding(l)
-	d.spiSlaveDeselect()
+	d.spiChipDeselect()
 	_, err := d.waitRspCmd1(CmdStartClientTCP)
 	return err
 }
@@ -320,15 +320,15 @@ func (d *Device) GetClientState(sock uint8) (uint8, error) {
 }
 
 func (d *Device) SendData(buf []byte, sock uint8) (uint16, error) {
-	if err := d.waitForSlaveSelect(); err != nil {
-		d.spiSlaveDeselect()
+	if err := d.waitForChipSelect(); err != nil {
+		d.spiChipDeselect()
 		return 0, err
 	}
 	l := d.sendCmd(CmdSendDataTCP, 2)
 	l += d.sendParamBuf([]byte{sock}, false)
 	l += d.sendParamBuf(buf, true)
 	d.addPadding(l)
-	d.spiSlaveDeselect()
+	d.spiChipDeselect()
 	return d.getUint16(d.waitRspCmd1(CmdSendDataTCP))
 }
 
@@ -348,8 +348,8 @@ func (d *Device) CheckDataSent(sock uint8) (bool, error) {
 }
 
 func (d *Device) GetDataBuf(sock uint8, buf []byte) (int, error) {
-	if err := d.waitForSlaveSelect(); err != nil {
-		d.spiSlaveDeselect()
+	if err := d.waitForChipSelect(); err != nil {
+		d.spiChipDeselect()
 		return 0, err
 	}
 	p := uint16(len(buf))
@@ -357,13 +357,13 @@ func (d *Device) GetDataBuf(sock uint8, buf []byte) (int, error) {
 	l += d.sendParamBuf([]byte{sock}, false)
 	l += d.sendParamBuf([]byte{uint8(p & 0x00FF), uint8((p) >> 8)}, true)
 	d.addPadding(l)
-	d.spiSlaveDeselect()
-	if err := d.waitForSlaveSelect(); err != nil {
-		d.spiSlaveDeselect()
+	d.spiChipDeselect()
+	if err := d.waitForChipSelect(); err != nil {
+		d.spiChipDeselect()
 		return 0, err
 	}
 	n, err := d.waitRspBuf16(CmdGetDatabufTCP, buf)
-	d.spiSlaveDeselect()
+	d.spiChipDeselect()
 	return int(n), err
 }
 
@@ -375,6 +375,50 @@ func (d *Device) StopClient(sock uint8) error {
 	return err
 }
 
+func (d *Device) StartServer(port uint16, sock uint8, mode uint8) error {
+	if err := d.waitForChipSelect(); err != nil {
+		d.spiChipDeselect()
+		return err
+	}
+	l := d.sendCmd(CmdStartServerTCP, 3)
+	l += d.sendParam16(port, false)
+	l += d.sendParam8(sock, false)
+	l += d.sendParam8(mode, true)
+	d.addPadding(l)
+	d.spiChipDeselect()
+	_, err := d.waitRspCmd1(CmdStartClientTCP)
+	return err
+}
+
+// InsertDataBuf adds data to the buffer used for sending UDP data
+func (d *Device) InsertDataBuf(buf []byte, sock uint8) (bool, error) {
+	if err := d.waitForChipSelect(); err != nil {
+		d.spiChipDeselect()
+		return false, err
+	}
+	l := d.sendCmd(CmdInsertDataBuf, 2)
+	l += d.sendParamBuf([]byte{sock}, false)
+	l += d.sendParamBuf(buf, true)
+	d.addPadding(l)
+	d.spiChipDeselect()
+	n, err := d.getUint8(d.waitRspCmd1(CmdInsertDataBuf))
+	return n == 1, err
+}
+
+// SendUDPData sends the data previously added to the UDP buffer
+func (d *Device) SendUDPData(sock uint8) (bool, error) {
+	if err := d.waitForChipSelect(); err != nil {
+		d.spiChipDeselect()
+		return false, err
+	}
+	l := d.sendCmd(CmdSendDataUDP, 1)
+	l += d.sendParam8(sock, true)
+	d.addPadding(l)
+	d.spiChipDeselect()
+	n, err := d.getUint8(d.waitRspCmd1(CmdSendDataUDP))
+	return n == 1, err
+}
+
 // ---------- /client methods (should this be a separate struct?) ------------
 
 /*
@@ -666,8 +710,8 @@ func (d *Device) reqRspStr0(cmd uint8, sl []string) (l uint8, err error) {
 	if err := d.sendCmd0(cmd); err != nil {
 		return 0, err
 	}
-	defer d.spiSlaveDeselect()
-	if err = d.waitForSlaveSelect(); err != nil {
+	defer d.spiChipDeselect()
+	if err = d.waitForChipSelect(); err != nil {
 		return
 	}
 	return d.waitRspStr(cmd, sl)
@@ -678,16 +722,16 @@ func (d *Device) reqRspStr1(cmd uint8, data uint8, sl []string) (uint8, error) {
 	if err := d.sendCmdPadded1(cmd, data); err != nil {
 		return 0, err
 	}
-	defer d.spiSlaveDeselect()
-	if err := d.waitForSlaveSelect(); err != nil {
+	defer d.spiChipDeselect()
+	if err := d.waitForChipSelect(); err != nil {
 		return 0, err
 	}
 	return d.waitRspStr(cmd, sl)
 }
 
 func (d *Device) sendCmd0(cmd uint8) error {
-	defer d.spiSlaveDeselect()
-	if err := d.waitForSlaveSelect(); err != nil {
+	defer d.spiChipDeselect()
+	if err := d.waitForChipSelect(); err != nil {
 		return err
 	}
 	d.sendCmd(cmd, 0)
@@ -695,8 +739,8 @@ func (d *Device) sendCmd0(cmd uint8) error {
 }
 
 func (d *Device) sendCmdPadded1(cmd uint8, data uint8) error {
-	defer d.spiSlaveDeselect()
-	if err := d.waitForSlaveSelect(); err != nil {
+	defer d.spiChipDeselect()
+	if err := d.waitForChipSelect(); err != nil {
 		return err
 	}
 	d.sendCmd(cmd, 1)
@@ -707,8 +751,8 @@ func (d *Device) sendCmdPadded1(cmd uint8, data uint8) error {
 }
 
 func (d *Device) sendCmdStr(cmd uint8, p1 string) (err error) {
-	defer d.spiSlaveDeselect()
-	if err := d.waitForSlaveSelect(); err != nil {
+	defer d.spiChipDeselect()
+	if err := d.waitForChipSelect(); err != nil {
 		return err
 	}
 	l := d.sendCmd(cmd, 1)
@@ -718,8 +762,8 @@ func (d *Device) sendCmdStr(cmd uint8, p1 string) (err error) {
 }
 
 func (d *Device) sendCmdStr2(cmd uint8, p1 string, p2 string) (err error) {
-	defer d.spiSlaveDeselect()
-	if err := d.waitForSlaveSelect(); err != nil {
+	defer d.spiChipDeselect()
+	if err := d.waitForChipSelect(); err != nil {
 		return err
 	}
 	l := d.sendCmd(cmd, 2)
@@ -730,8 +774,8 @@ func (d *Device) sendCmdStr2(cmd uint8, p1 string, p2 string) (err error) {
 }
 
 func (d *Device) waitRspCmd1(cmd uint8) (l uint8, err error) {
-	defer d.spiSlaveDeselect()
-	if err = d.waitForSlaveSelect(); err != nil {
+	defer d.spiChipDeselect()
+	if err = d.waitForChipSelect(); err != nil {
 		return
 	}
 	return d.waitRspCmd(cmd, 1)
@@ -856,29 +900,29 @@ func (d *Device) checkStartCmd() (bool, error) {
 	return true, nil
 }
 
-func (d *Device) waitForSlaveSelect() (err error) {
-	err = d.waitForSlaveReady()
+func (d *Device) waitForChipSelect() (err error) {
+	err = d.waitForChipReady()
 	if err == nil {
-		err = d.spiSlaveSelect()
+		err = d.spiChipSelect()
 	}
 	return
 }
 
-func (d *Device) waitForSlaveReady() error {
+func (d *Device) waitForChipReady() error {
 	if _debug {
-		println("waitForSlaveReady()\r")
+		println("waitForChipReady()\r")
 	}
 	for t := newTimer(10 * time.Second); !(d.ACK.Get() == false); {
 		if t.Expired() {
-			return ErrTimeoutSlaveReady
+			return ErrTimeoutChipReady
 		}
 	}
 	return nil
 }
 
-func (d *Device) spiSlaveSelect() error {
+func (d *Device) spiChipSelect() error {
 	if _debug {
-		println("spiSlaveSelect()\r")
+		println("spiChipSelect()\r")
 	}
 	d.CS.Low()
 	for t := newTimer(5 * time.Millisecond); !t.Expired(); {
@@ -886,12 +930,12 @@ func (d *Device) spiSlaveSelect() error {
 			return nil
 		}
 	}
-	return ErrTimeoutSlaveSelect
+	return ErrTimeoutChipSelect
 }
 
-func (d *Device) spiSlaveDeselect() {
+func (d *Device) spiChipDeselect() {
 	if _debug {
-		println("spiSlaveDeselect\r")
+		println("spiChipDeselect\r")
 	}
 	d.CS.High()
 }

ws2812/ws2812_avr_16m.go

@@ -1,4 +1,4 @@
-// +build arduino
+// +build atmega328p
 
 package ws2812