Updates for v0.12.0 release

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

CHANGELOG.md

@@ -1,3 +1,154 @@
+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**
+    - shiftregister: Support for various shift register chips (#135)
+- **enhancements**
+    - shifter: simplify API surface for PyBadge (#137)
+    - shifter: new API for shifter driver
+    - mqtt: use buffered channels for incoming messages to handle bursts
+    - ili9341: Adding scroll functionality (#121)
+- **bugfixes**
+    - wifinina: fix typo on StartScanNetworks
+    - ili9341: various bugfixes for display
+- **examples**
+    - semihosting: add example
+- **docs**
+    - readme: Use degree sign instead of ordinal
+    - all: fix celsius symbol in all code comments
+
+0.10.0
+---
+- **new devices**
+    - adt7410: Support for ADT7410 temperature sensor (#109)
+    - ili9341: ILI9341 TFT driver (#115)
+    - l293x: added support for h-bridge motor controller
+    - l9110x: add support for L9110x h-bridge motor driver
+    - resistive: Adding driver for four-wire resistive touchscreen (#118)
+- **enhancements**
+    - st7735: added scroll functionality to st7735
+    - st7735: remove default offsets
+    - st7789: remove default offsets
+    - ws2812: Added nrf52840 tag to ws2812
+    - ws2812: work-arounds to allow Digispark to control WS2812 LEDs
+- **docs**
+    - readme: update README to include list of all 44 drivers
+    - wifinina: update docs and add Dockerfile to build firmware
+    - wifinina: update docs and info on how to install WiFiNINA driver
+
+0.9.0
+---
+- **new devices**
+    - net: shared implementation of net package for serial wifi devices
+    - shifter: add support for bit Parallel In Serial Out (PISO) shifter
+    - stepper: add support for dual stepper motor
+    - wifinina: add implementation for WiFiNINA firmware
+- **enhancements**
+    - st7735: improvements in st7735 driver
+    - st7789: improvements in st7789 driver
+    - ws2812: add support for 120Mhz Cortex-M4
+    - ws2812: added Feather M0 and Trinket M0 to build tags for WS2812
+    - ws2812: add support for simulation
+- **bugfixes**
+    - ws2812: fix "invalid symbol redefinition" error
+- **examples**
+    - Add examples for wifinina drivers
+
+0.8.0
+---
+- **new devices**
+    - mcp3008: add implementation for MCP3008 ADC with SPI interface
+    - semihosting: initial implementation of ARM semihosting
+- **enhancements**
+    - espat: refactor response processing for greater speed and efficiency
+    - espat: implement mqtt subscribe functionality via blocking select/channels (experiemental)
+- **bugfixes**
+    - st7789: fix index out of bounds error
+- **examples**
+    - Add espat driver example for mqtt subscribe
+
+0.7.0
+---
+- **new devices**
+    - veml6070: add Vishay UV light sensor
+- **enhancements**
+    - lis3dh: example uses I2C1 so requires config to specify pins since they are not default
+    - ssd1331: make SPI TX faster
+    - st7735: make SPI Tx faster
+- **docs**
+    - complete missing GoDocs for main and sub-packages
+- **core**
+    - add Version string for support purposes
+- **examples**
+    - Change all espat driver examples to use Arduino Nano33 IoT by default
+
+0.6.0
+---
+- **new devices**
+    - Support software SPI for APA102 (Itsy Bitsy M0 on-board "Dotstar" LED as example)
+
+0.5.0
+---
+- **new devices**
+    - LSM6DS3 accelerometer
+- **bugfixes**
+    - ws2812: fix timings for the nrf51
+- **enhancements**
+    - ws2812: Add build tag for Arduino Nano33 IoT
+
+0.4.0
+---
+- **new devices**
+    - SSD1331 TFT color display
+    - ST7735 TFT color display
+    - ST7789 TFT color display
+- **docs**
+    - espat
+        - complete list of dependencies for flashing NINA-W102 as used in Arduino Nano33 IoT board.
+
+0.3.0
+---
+- **new devices**
+    - Buzzer for piezo or small speaker
+    - PDM MEMS microphone support using I2S interface
+- **enhancements**
+    - epd2in13: added rotation
+    - espat
+        - add built-in support for MQTT publish using the Paho library packets, alongside some modifications needed for the AT protocol.
+        - add DialTLS and Dial methods, update MQTT example to allow both MQTT and MQTTS connections
+        - add example that uses MQTT publish to open server
+        - add README with information on how to flash ESP32 or ESP8266 with AT command set firmware.
+        - add ResolveUDPAddr and ResolveTCPAddr implementations using AT command for DNS lookup
+        - change Response() method to use a passed-in timeout value instead of fixed pauses.
+        - implement TCPConn using AT command set
+        - improve error handling for key TCP functions
+        - refactor net and tls interface compatible code into separate sub-packages
+        - update MQTT example for greater stability
+        - use only AT commands that work on both ESP8266 and ESP32
+        - add documentation on how to use Arduino Nano33 IoT built-in WiFi NINA-W102 chip.
+- **bugfixes**
+    - core: Error strings should not be capitalized (unless beginning with proper nouns or acronyms) or end with punctuation, since they are usually printed following other context.
+    - docs: add note to current/future contributors to please start by opening a GH issue to avoid duplication of efforts
+    - examples: typo in package name of examples
+    - mpu6050: properly scale the outputs of the accel/gyro
+
+0.2.0
+---
+- **new devices**
+    - AT24C32/64 2-wire serial EEPROM
+    - BME280 humidity/pressure sensor
+- **bugfixes**
+    - ws2812: better support for nrf52832
+
 0.1.0
 ---
 - **first release**

CONTRIBUTING.md

@@ -16,6 +16,8 @@ Please open a Github issue with your problem, and we will be happy to assist.
 
 We probably have not implemented it yet. Your contribution adding the hardware support to TinyGo would be greatly appreciated.
 
+Please first open a Github issue. We want to help, and also make sure that there is no duplications of efforts. Sometimes what you need is already being worked on by someone else.
+
 ## 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.

LICENSE

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

Makefile

@@ -9,37 +9,127 @@ fmt-check:
 
 smoke-test:
 	@mkdir -p build
-	tinygo build -size short -o ./build/test.elf -target=itsybitsy-m0 ./examples/adxl345/main.go
-	tinygo build -size short -o ./build/test.elf -target=itsybitsy-m0 ./examples/apa102/main.go
-	tinygo build -size short -o ./build/test.elf -target=itsybitsy-m0 ./examples/bh1750/main.go
-	tinygo build -size short -o ./build/test.elf -target=itsybitsy-m0 ./examples/blinkm/main.go
-	tinygo build -size short -o ./build/test.elf -target=itsybitsy-m0 ./examples/bmp180/main.go
-	tinygo build -size short -o ./build/test.elf -target=bluepill ./examples/ds1307/sram/main.go
-	tinygo build -size short -o ./build/test.elf -target=bluepill ./examples/ds1307/time/main.go
-	tinygo build -size short -o ./build/test.elf -target=itsybitsy-m0 ./examples/ds3231/main.go
-	tinygo build -size short -o ./build/test.elf -target=microbit ./examples/easystepper/main.go
-	tinygo build -size short -o ./build/test.elf -target=itsybitsy-m0 ./examples/espat/espconsole/main.go
-	tinygo build -size short -o ./build/test.elf -target=itsybitsy-m0 ./examples/espat/esphub/main.go
-	tinygo build -size short -o ./build/test.elf -target=itsybitsy-m0 ./examples/espat/espstation/main.go
-	tinygo build -size short -o ./build/test.elf -target=feather-m0 ./examples/gps/i2c/main.go
-	tinygo build -size short -o ./build/test.elf -target=feather-m0 ./examples/gps/uart/main.go
-	tinygo build -size short -o ./build/test.elf -target=microbit ./examples/hd44780/customchar/main.go
-	tinygo build -size short -o ./build/test.elf -target=microbit ./examples/hd44780/text/main.go
-	tinygo build -size short -o ./build/test.elf -target=microbit ./examples/hub75/main.go
-	tinygo build -size short -o ./build/test.elf -target=circuitplay-express ./examples/lis3dh/main.go
-	tinygo build -size short -o ./build/test.elf -target=itsybitsy-m0 ./examples/mag3110/main.go
-	tinygo build -size short -o ./build/test.elf -target=microbit ./examples/microbitmatrix/main.go
-	tinygo build -size short -o ./build/test.elf -target=itsybitsy-m0 ./examples/mma8653/main.go
-	tinygo build -size short -o ./build/test.elf -target=itsybitsy-m0 ./examples/mpu6050/main.go
-	tinygo build -size short -o ./build/test.elf -target=microbit ./examples/pcd8544/setbuffer/main.go
-	tinygo build -size short -o ./build/test.elf -target=microbit ./examples/pcd8544/setpixel/main.go
-	tinygo build -size short -o ./build/test.elf -target=microbit ./examples/sht3x/main.go
-	tinygo build -size short -o ./build/test.elf -target=microbit ./examples/ssd1306/i2c_128x32/main.go
-	tinygo build -size short -o ./build/test.elf -target=microbit ./examples/ssd1306/spi_128x64/main.go
-	tinygo build -size short -o ./build/test.elf -target=circuitplay-express ./examples/thermistor/main.go
-	tinygo build -size short -o ./build/test.elf -target=itsybitsy-m0 ./examples/vl53l1x/main.go
-	tinygo build -size short -o ./build/test.elf -target=microbit ./examples/waveshare-epd/epd2in13/main.go
-	tinygo build -size short -o ./build/test.elf -target=microbit ./examples/waveshare-epd/epd2in13x/main.go
-	tinygo build -size short -o ./build/test.elf -target=circuitplay-express ./examples/ws2812/main.go
+	tinygo build -size short -o ./build/test.hex -target=itsybitsy-m0 ./examples/adt7410/main.go
+	@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
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=microbit ./examples/at24cx/main.go
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=itsybitsy-m0 ./examples/bh1750/main.go
+	@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/bmp180/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
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=itsybitsy-m0 ./examples/ds3231/main.go
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=microbit ./examples/easystepper/main.go
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=arduino-nano33 ./examples/espat/espconsole/main.go
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=arduino-nano33 ./examples/espat/esphub/main.go
+	@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=microbit ./examples/hub75/main.go
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=pyportal ./examples/ili9341/basic/main.go
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=pyportal ./examples/ili9341/scroll/main.go
+	@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=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
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=itsybitsy-m0 ./examples/mcp3008/main.go
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=microbit ./examples/microbitmatrix/main.go
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=itsybitsy-m0 ./examples/mma8653/main.go
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=itsybitsy-m0 ./examples/mpu6050/main.go
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=microbit ./examples/pcd8544/setbuffer/main.go
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=microbit ./examples/pcd8544/setpixel/main.go
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=pybadge ./examples/shifter/main.go
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=microbit ./examples/sht3x/main.go
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=microbit ./examples/ssd1306/i2c_128x32/main.go
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=microbit ./examples/ssd1306/spi_128x64/main.go
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=microbit ./examples/ssd1331/main.go
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=microbit ./examples/st7735/main.go
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=microbit ./examples/st7789/main.go
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=circuitplay-express ./examples/thermistor/main.go
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=pyportal ./examples/touch/resistive/fourwire/main.go
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=pyportal ./examples/touch/resistive/pyportal_touchpaint/main.go
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=itsybitsy-m0 ./examples/vl53l1x/main.go
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=microbit ./examples/waveshare-epd/epd2in13/main.go
+	@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/tcpclient/main.go
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=arduino-nano33 ./examples/wifinina/webclient/main.go
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=circuitplay-express ./examples/ws2812
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=digispark ./examples/ws2812
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=trinket-m0 ./examples/bme280/main.go
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=circuitplay-express ./examples/microphone/main.go
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=circuitplay-express ./examples/buzzer/main.go
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=trinket-m0 ./examples/veml6070/main.go
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=arduino-nano33 ./examples/l293x/simple/main.go
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=arduino-nano33 ./examples/l293x/speed/main.go
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=arduino-nano33 ./examples/l9110x/simple/main.go
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=arduino-nano33 ./examples/l9110x/speed/main.go
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=nucleo-f103rb ./examples/shiftregister/main.go
+	@md5sum ./build/test.hex
 
 test: clean fmt-check smoke-test

README.md

@@ -1,6 +1,6 @@
 # TinyGo Drivers
 
-[![GoDoc](https://godoc.org/github.com/tinygo-org/drivers?status.svg)](https://godoc.org/github.com/tinygo-org/drivers) [![CircleCI](https://circleci.com/gh/tinygo-org/drivers/tree/dev.svg?style=svg)](https://circleci.com/gh/tinygo-org/drivers/tree/dev)
+[![GoDoc](https://godoc.org/tinygo.org/x/drivers?status.svg)](https://godoc.org/tinygo.org/x/drivers) [![CircleCI](https://circleci.com/gh/tinygo-org/drivers/tree/dev.svg?style=svg)](https://circleci.com/gh/tinygo-org/drivers/tree/dev)
 
 
 This package provides a collection of hardware drivers for devices that can be used together with [TinyGo](https://tinygo.org).
@@ -40,7 +40,7 @@ func main() {
 
     for {
         temp, _ := sensor.ReadTemperature()
-        println("Temperature:", float32(temp)/1000, "ºC")
+        println("Temperature:", float32(temp)/1000, "°C")
 
         pressure, _ := sensor.ReadPressure()
         println("Pressure", float32(pressure)/100000, "hPa")
@@ -52,31 +52,57 @@ func main() {
 
 ## Currently supported devices
 
+The following 48 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 |
 | [BMP180 barometer](https://cdn-shop.adafruit.com/datasheets/BST-BMP180-DS000-09.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 |
+| [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 |
 | [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 |
+| [L9110x motor driver](https://www.elecrow.com/download/datasheet-l9110.pdf) | GPIO/PWM |
 | [LIS3DH accelerometer](https://www.st.com/resource/en/datasheet/lis3dh.pdf) | I2C |
+| [LSM6DS3 accelerometer](https://www.st.com/resource/en/datasheet/lsm6ds3.pdf) | I2C |
 | [MAG3110 magnetometer](https://www.nxp.com/docs/en/data-sheet/MAG3110.pdf) | I2C |
-| [BBC micro:bit LED matrix](https://github.com/bbcmicrobit/hardware/blob/master/SCH_BBC-Microbit_V1.3B.pdf) | GPIO |
+| [MCP3008 analog to digital converter (ADC)](http://ww1.microchip.com/downloads/en/DeviceDoc/21295d.pdf) | SPI |
+| [Microphone - PDM](https://cdn-learn.adafruit.com/assets/assets/000/049/977/original/MP34DT01-M.pdf) | I2S/PDM |
 | [MMA8653 accelerometer](https://www.nxp.com/docs/en/data-sheet/MMA8653FC.pdf) | I2C |
 | [MPU6050 accelerometer/gyroscope](https://store.invensense.com/datasheets/invensense/MPU-6050_DataSheet_V3%204.pdf) | I2C |
 | [PCD8544 display](http://eia.udg.edu/~forest/PCD8544_1.pdf) | SPI |
+| [Resistive Touchscreen (4-wire)](http://ww1.microchip.com/downloads/en/Appnotes/doc8091.pdf) | GPIO |
+| [Semihosting](https://wiki.segger.com/Semihosting) | Debug |
+| [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 |
+| [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

@@ -0,0 +1,90 @@
+package adt7410
+
+import (
+	"machine"
+	"time"
+)
+
+type Error uint8
+
+const (
+	ErrInvalidID Error = 0x1
+)
+
+func (e Error) Error() string {
+	switch e {
+	case ErrInvalidID:
+		return "Invalid chip ID"
+	default:
+		return "Unknown error"
+	}
+}
+
+type Device struct {
+	bus  *machine.I2C
+	buf  []byte
+	addr uint8
+}
+
+// New returns ADT7410 device for the provided I2C bus and address. The ADT7410
+// has a default address of 0x48 (1001000).  The last 2 bits of the address
+// can be set using by connecting to the A1 and A0 pins to VDD or GND (for a
+// total of up to 4 devices on a I2C bus).  Also note that 10k pullups are
+// recommended for the SDA and SCL lines.
+func New(i2c *machine.I2C, addressBits uint8) *Device {
+	return &Device{
+		bus:  i2c,
+		buf:  make([]byte, 2),
+		addr: Address | (addressBits & 0x3),
+	}
+}
+
+func (dev *Device) Configure() (err error) {
+
+	// verify the chip ID
+	// TODO: According to datasheet, the check below should work; however
+	//       this does not seem to be working right, but is not exactly
+	//       necessary, so can revisit later to see if there is a bug
+	//id := dev.ReadByte(RegID) & 0xF8
+	//if id != 0xC8 {
+	//	err = ErrInvalidID
+	//}
+
+	// reset the chip
+	dev.writeByte(RegReset, 0xFF)
+	time.Sleep(10 * time.Millisecond)
+	return
+
+}
+
+// ReadTemperature returns the temperature in celsius milli degrees (°C/1000)
+func (d *Device) ReadTemperature() (temperature int32, err error) {
+	return (int32(d.readUint16(RegTempValueMSB)) * 1000) / 128, nil
+}
+
+// ReadTempC returns the value in the temperature value register, in Celcius
+func (d *Device) ReadTempC() float32 {
+	t := d.readUint16(RegTempValueMSB)
+	return float32(int(t)) / 128.0
+}
+
+// ReadTempF returns the value in the temperature value register, in Fahrenheit
+func (d *Device) ReadTempF() float32 {
+	return d.ReadTempC()*1.8 + 32.0
+}
+
+func (d *Device) writeByte(reg uint8, data byte) {
+	d.buf[0] = reg
+	d.buf[1] = data
+	d.bus.Tx(uint16(d.addr), d.buf, nil)
+}
+
+func (d *Device) readByte(reg uint8) byte {
+	d.bus.ReadRegister(d.addr, reg, d.buf)
+	return d.buf[0]
+}
+
+func (d *Device) readUint16(reg uint8) uint16 {
+	d.bus.ReadRegister(d.addr, reg, d.buf)
+	return uint16(d.buf[0])<<8 | uint16(d.buf[1])
+}

adt7410/registers.go

@@ -0,0 +1,24 @@
+package adt7410
+
+const (
+	// Default I2C address
+	Address = 0x48
+
+	// Temperature Value MSB Register
+	RegTempValueMSB = 0x0
+
+	// Temperature Value LSB Register
+	RegTempValueLSB = 0x1
+
+	// Status Register
+	RegStatus = 0x2
+
+	// Config Register
+	RegConfig = 0x3
+
+	// ID Register
+	RegID = 0x0B
+
+	// Software Reset Register
+	RegReset = 0x2F
+)

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

@@ -21,15 +21,28 @@ const (
 
 // Device wraps APA102 SPI LEDs.
 type Device struct {
-	bus   machine.SPI
+	bus   SPI
 	Order int
 }
 
+// The SPI interface specifies the minimum functionality that a bus
+// implementation needs to provide for use by the APA102 driver.  Hardware
+// SPI from the TinyGo "machine" package implements this already.
+type SPI interface {
+	Tx(w, r []byte) error
+}
+
 // New returns a new APA102 driver. Pass in a fully configured SPI bus.
-func New(b machine.SPI) Device {
+func New(b SPI) Device {
 	return Device{bus: b, Order: BGR}
 }
 
+// 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})
+}
+
 // WriteColors writes the given RGBA color slice out using the APA102 protocol.
 // The A value (Alpha channel) is used for brightness, set to 0xff (255) for maximum.
 func (d Device) WriteColors(cs []color.RGBA) (n int, err error) {

apa102/softspi.go

@@ -0,0 +1,68 @@
+package apa102
+
+import "machine"
+
+// bbSPI is a dumb bit-bang implementation of SPI protocol that is hardcoded
+// to mode 0 and ignores trying to receive data. Just enough for the APA102.
+// Note: making this unexported for now because it is probable not suitable
+// most purposes other than the APA102 package. It might be desirable to make
+// this more generic and include it in the TinyGo "machine" package instead.
+type bbSPI struct {
+	SCK   machine.Pin
+	MOSI  machine.Pin
+	Delay uint32
+}
+
+// Configure sets up the SCK and MOSI 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.SCK.Low()
+	s.MOSI.Low()
+	if s.Delay == 0 {
+		s.Delay = 1
+	}
+}
+
+// Tx matches signature of machine.SPI.Tx() and is used to send multiple bytes.
+// The r slice is ignored and no error will ever be returned.
+func (s *bbSPI) Tx(w []byte, r []byte) error {
+	s.Configure()
+	for _, b := range w {
+		s.Transfer(b)
+	}
+	return nil
+}
+
+// delay represents a quarter of the clock cycle
+func (s *bbSPI) delay() {
+	for i := uint32(0); i < s.Delay; {
+		i++
+	}
+}
+
+// Transfer is used to send a single byte.
+func (s *bbSPI) Transfer(b byte) {
+	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)
+		if b&(1<<(7-i)) == 0 {
+			s.MOSI.Low()
+		} else {
+			s.MOSI.High()
+		}
+		s.delay()
+
+		// half clock cycle low
+		s.SCK.Low()
+		s.delay()
+
+		// for actual SPI would try to read the MISO value here
+		s.delay()
+
+	}
+}

at24cx/at24cx.go

@@ -0,0 +1,171 @@
+// Package at24cx provides a driver for the AT24C32/64/128/256/512 2-wire serial EEPROM
+//
+// Datasheet:
+// https://www.openimpulse.com/blog/wp-content/uploads/wpsc/downloadables/24C32-Datasheet.pdf
+package at24cx // import "tinygo.org/x/drivers/at24cx"
+
+import (
+	"errors"
+	"machine"
+	"time"
+)
+
+// Device wraps an I2C connection to a DS3231 device.
+type Device struct {
+	bus               machine.I2C
+	Address           uint16
+	pageSize          uint16
+	currentRAMAddress uint16
+	startRAMAddress   uint16
+	endRAMAddress     uint16
+}
+
+type Config struct {
+	PageSize        uint16
+	StartRAMAddress uint16
+	EndRAMAddress   uint16
+}
+
+// New creates a new AT24C32/64 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: Address,
+	}
+}
+
+// Configure sets up the device for communication
+func (d *Device) Configure(cfg Config) {
+	if cfg.PageSize == 0 {
+		d.pageSize = 32
+	} else {
+		d.pageSize = cfg.PageSize
+	}
+	if cfg.EndRAMAddress == 0 {
+		d.endRAMAddress = 4096
+	} else {
+		d.endRAMAddress = cfg.EndRAMAddress
+	}
+	d.startRAMAddress = cfg.StartRAMAddress
+}
+
+// WriteByte writes a byte at the specified address
+func (d *Device) WriteByte(eepromAddress uint16, value uint8) error {
+	address := []uint8{
+		uint8((eepromAddress >> 8) & 0xFF),
+		uint8(eepromAddress & 0xFF),
+		value,
+	}
+	return d.bus.Tx(d.Address, address, nil)
+}
+
+// ReadByte reads the byte at the specified address
+func (d *Device) ReadByte(eepromAddress uint16) (uint8, error) {
+	address := []uint8{
+		uint8(eepromAddress >> 8),
+		uint8(eepromAddress & 0xFF),
+	}
+	data := make([]uint8, 1)
+	err := d.bus.Tx(d.Address, address, data)
+	return data[0], err
+}
+
+// WriteAt writes a byte array at the specified address
+func (d *Device) WriteAt(data []byte, offset int64) (n int, err error) {
+	return d.writeAt(data, uint16(offset))
+}
+
+// writeAt writes a byte array at the specified address
+func (d *Device) writeAt(data []byte, offset uint16) (n int, err error) {
+	values := make([]uint8, 32)
+	dataLeft := uint16(len(data))
+	d.currentRAMAddress = offset
+	offset = 0
+	var offsetPage uint16
+	var chunkLength uint16
+	for dataLeft > 0 {
+		offsetPage = d.currentRAMAddress % d.pageSize
+		if dataLeft < 30 { // The 32K/64K EEPROM is capable of 32-byte page writes and we're using 2 for the address
+			chunkLength = dataLeft
+		} else {
+			chunkLength = 30
+		}
+		if (d.pageSize - offsetPage) < chunkLength {
+			chunkLength = d.pageSize - offsetPage
+		}
+		for i := uint16(0); i < chunkLength; i++ {
+			values[2+i] = data[offset+i]
+		}
+		values[0] = uint8(d.currentRAMAddress >> 8)
+		values[1] = uint8(d.currentRAMAddress & 0xFF)
+		err := d.bus.Tx(d.Address, values[:chunkLength+2], nil)
+		if err != nil {
+			return 0, err
+		}
+		dataLeft -= chunkLength
+		offset += chunkLength
+		if d.endRAMAddress-chunkLength < d.currentRAMAddress {
+			d.currentRAMAddress = d.startRAMAddress + (d.currentRAMAddress+uint16(len(data)))%d.endRAMAddress
+		} else {
+			d.currentRAMAddress += chunkLength
+		}
+		time.Sleep(2 * time.Millisecond) // writing again too soon will block the device
+	}
+	return len(data), nil
+}
+
+// ReadAt reads the bytes at the specified address
+func (d *Device) ReadAt(data []byte, offset int64) (n int, err error) {
+	return d.readAt(data, uint16(offset))
+}
+
+// readAt reads the bytes at the specified address
+func (d *Device) readAt(data []byte, offset uint16) (n int, err error) {
+	address := []uint8{
+		uint8((offset >> 8) & 0xFF),
+		uint8(offset & 0xFF),
+	}
+	err = d.bus.Tx(d.Address, address, data)
+
+	if d.endRAMAddress-uint16(len(data)) < offset {
+		d.currentRAMAddress = d.startRAMAddress + (offset+uint16(len(data)))%d.endRAMAddress
+	} else {
+		d.currentRAMAddress = offset + uint16(len(data))
+	}
+	return len(data), err
+}
+
+// Seek sets the offset for the next Read or Write on SRAM to offset, interpreted
+// according to whence: 0 means relative to the origin of the SRAM, 1 means
+// relative to the current offset, and 2 means relative to the end.
+// returns new offset and error, if any
+func (d *Device) Seek(offset int64, whence int) (int64, error) {
+	w := uint16(0)
+	switch whence {
+	case 0:
+		w = d.startRAMAddress
+	case 1:
+		w = d.currentRAMAddress
+	case 2:
+		w = d.endRAMAddress
+	default:
+		return 0, errors.New("invalid whence")
+	}
+	d.currentRAMAddress = w + uint16(offset)
+	return int64(d.currentRAMAddress), nil
+}
+
+// Write writes len(data) bytes to SRAM
+// returns number of bytes written and error, if any
+func (d *Device) Write(data []byte) (n int, err error) {
+	return d.writeAt(data, d.currentRAMAddress)
+}
+
+// Read reads len(data) from SRAM
+// returns number of bytes written and error, if any
+func (d *Device) Read(data []uint8) (n int, err error) {
+	return d.readAt(data, d.currentRAMAddress)
+}

at24cx/registers.go

@@ -0,0 +1,4 @@
+package at24cx
+
+// The I2C address which this device listens to.
+const Address = 0x57

bme280/bme280.go

@@ -0,0 +1,257 @@
+// Package bme280 provides a driver for the BME280 digital combined
+// humidity and pressure sensor by Bosch.
+//
+// Datasheet:
+// https://cdn-shop.adafruit.com/datasheets/BST-BME280_DS001-10.pdf
+//
+package bme280
+
+import (
+	"machine"
+	"math"
+)
+
+// calibrationCoefficients reads at startup and stores the calibration coefficients
+type calibrationCoefficients struct {
+	t1 uint16
+	t2 int16
+	t3 int16
+	p1 uint16
+	p2 int16
+	p3 int16
+	p4 int16
+	p5 int16
+	p6 int16
+	p7 int16
+	p8 int16
+	p9 int16
+	h1 uint8
+	h2 int16
+	h3 uint8
+	h4 int16
+	h5 int16
+	h6 int8
+}
+
+// Device wraps an I2C connection to a BME280 device.
+type Device struct {
+	bus                     machine.I2C
+	Address                 uint16
+	calibrationCoefficients calibrationCoefficients
+}
+
+// New creates a new BME280 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: Address,
+	}
+}
+
+// Configure sets up the device for communication and
+// read the calibration coefficientes.
+func (d *Device) Configure() {
+
+	var data [24]byte
+	err := d.bus.ReadRegister(uint8(d.Address), REG_CALIBRATION, data[:])
+	if err != nil {
+		return
+	}
+
+	var h1 [1]byte
+	err = d.bus.ReadRegister(uint8(d.Address), REG_CALIBRATION_H1, h1[:])
+	if err != nil {
+		return
+	}
+
+	var h2lsb [7]byte
+	err = d.bus.ReadRegister(uint8(d.Address), REG_CALIBRATION_H2LSB, h2lsb[:])
+	if err != nil {
+		return
+	}
+
+	d.calibrationCoefficients.t1 = readUintLE(data[0], data[1])
+	d.calibrationCoefficients.t2 = readIntLE(data[2], data[3])
+	d.calibrationCoefficients.t3 = readIntLE(data[4], data[5])
+	d.calibrationCoefficients.p1 = readUintLE(data[6], data[7])
+	d.calibrationCoefficients.p2 = readIntLE(data[8], data[9])
+	d.calibrationCoefficients.p3 = readIntLE(data[10], data[11])
+	d.calibrationCoefficients.p4 = readIntLE(data[12], data[13])
+	d.calibrationCoefficients.p5 = readIntLE(data[14], data[15])
+	d.calibrationCoefficients.p6 = readIntLE(data[16], data[17])
+	d.calibrationCoefficients.p7 = readIntLE(data[18], data[19])
+	d.calibrationCoefficients.p8 = readIntLE(data[20], data[21])
+	d.calibrationCoefficients.p9 = readIntLE(data[22], data[23])
+
+	d.calibrationCoefficients.h1 = h1[0]
+	d.calibrationCoefficients.h2 = readIntLE(h2lsb[0], h2lsb[1])
+	d.calibrationCoefficients.h3 = h2lsb[2]
+	d.calibrationCoefficients.h6 = int8(h2lsb[6])
+	d.calibrationCoefficients.h4 = 0 + (int16(h2lsb[3]) << 4) | (int16(h2lsb[4] & 0x0F))
+	d.calibrationCoefficients.h5 = 0 + (int16(h2lsb[5]) << 4) | (int16(h2lsb[4]) >> 4)
+
+	d.bus.WriteRegister(uint8(d.Address), CTRL_HUMIDITY_ADDR, []byte{0x3f})
+	d.bus.WriteRegister(uint8(d.Address), CTRL_MEAS_ADDR, []byte{0xB7})
+	d.bus.WriteRegister(uint8(d.Address), CTRL_CONFIG, []byte{0x00})
+
+}
+
+// Connected returns whether a BME280 has been found.
+// It does a "who am I" request and checks the response.
+func (d *Device) Connected() bool {
+	data := []byte{0}
+	d.bus.ReadRegister(uint8(d.Address), WHO_AM_I, data)
+	return data[0] == CHIP_ID
+}
+
+// Reset the device
+func (d *Device) Reset() {
+	d.bus.WriteRegister(uint8(d.Address), CMD_RESET, []byte{0xB6})
+}
+
+// ReadTemperature returns the temperature in celsius milli degrees (°C/1000)
+func (d *Device) ReadTemperature() (int32, error) {
+	data, err := d.readData()
+	if err != nil {
+		return 0, err
+	}
+
+	temp, _ := d.calculateTemp(data)
+	return temp, nil
+}
+
+// ReadPressure returns the pressure in milli pascals mPa
+func (d *Device) ReadPressure() (int32, error) {
+	data, err := d.readData()
+	if err != nil {
+		return 0, err
+	}
+	_, tFine := d.calculateTemp(data)
+	pressure := d.calculatePressure(data, tFine)
+	return pressure, nil
+}
+
+// ReadHumidity returns the relative humidity in hundredths of a percent
+func (d *Device) ReadHumidity() (int32, error) {
+	data, err := d.readData()
+	if err != nil {
+		return 0, err
+	}
+	_, tFine := d.calculateTemp(data)
+	humidity := d.calculateHumidity(data, tFine)
+	return humidity, nil
+}
+
+// ReadAltitude returns the current altitude in meters based on the
+// current barometric pressure and estimated pressure at sea level.
+// Calculation is based on code from Adafruit BME280 library
+// 	https://github.com/adafruit/Adafruit_BME280_Library
+func (d *Device) ReadAltitude() (alt int32, err error) {
+	mPa, _ := d.ReadPressure()
+	atmP := float32(mPa) / 100000
+	alt = int32(44330.0 * (1.0 - math.Pow(float64(atmP/SEALEVEL_PRESSURE), 0.1903)))
+	return
+}
+
+// convert2Bytes converts two bytes to int32
+func convert2Bytes(msb byte, lsb byte) int32 {
+	return int32(readUint(msb, lsb))
+}
+
+// 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))
+}
+
+// readData does a burst read from 0xF7 to 0xF0 according to the datasheet
+// resulting in an slice with 8 bytes 0-2 = pressure / 3-5 = temperature / 6-7 = humidity
+func (d *Device) readData() (data [8]byte, err error) {
+	err = d.bus.ReadRegister(uint8(d.Address), REG_PRESSURE, data[:])
+	if err != nil {
+		println(err)
+		return
+	}
+	return
+}
+
+// calculateTemp uses the data slice and applies calibrations values on it to convert the value to milli degrees
+// it also calculates the variable tFine which is used by the pressure and humidity calculation
+func (d *Device) calculateTemp(data [8]byte) (int32, int32) {
+
+	rawTemp := convert3Bytes(data[3], data[4], data[5])
+
+	var1 := (((rawTemp >> 3) - (int32(d.calibrationCoefficients.t1) << 1)) * int32(d.calibrationCoefficients.t2)) >> 11
+	var2 := (((((rawTemp >> 4) - int32(d.calibrationCoefficients.t1)) * ((rawTemp >> 4) - int32(d.calibrationCoefficients.t1))) >> 12) * int32(d.calibrationCoefficients.t3)) >> 14
+
+	tFine := var1 + var2
+	T := (tFine*5 + 128) >> 8
+	return (10 * T), tFine
+}
+
+// calculatePressure uses the data slice and applies calibrations values on it to convert the value to milli pascals mPa
+func (d *Device) calculatePressure(data [8]byte, tFine int32) int32 {
+
+	rawPressure := convert3Bytes(data[0], data[1], data[2])
+
+	var1 := int64(tFine) - 128000
+	var2 := var1 * var1 * int64(d.calibrationCoefficients.p6)
+	var2 = var2 + ((var1 * int64(d.calibrationCoefficients.p5)) << 17)
+	var2 = var2 + (int64(d.calibrationCoefficients.p4) << 35)
+	var1 = ((var1 * var1 * int64(d.calibrationCoefficients.p3)) >> 8) + ((var1 * int64(d.calibrationCoefficients.p2)) << 12)
+	var1 = ((int64(1) << 47) + var1) * int64(d.calibrationCoefficients.p1) >> 33
+
+	if var1 == 0 {
+		return 0 // avoid exception caused by division by zero
+	}
+	p := int64(1048576 - rawPressure)
+	p = (((p << 31) - var2) * 3125) / var1
+	var1 = (int64(d.calibrationCoefficients.p9) * (p >> 13) * (p >> 13)) >> 25
+	var2 = (int64(d.calibrationCoefficients.p8) * p) >> 19
+
+	p = ((p + var1 + var2) >> 8) + (int64(d.calibrationCoefficients.p7) << 4)
+	p = (p / 256)
+	return int32(1000 * p)
+}
+
+// calculateHumidity uses the data slice and applies calibrations values on it to convert the value to relative humidity in hundredths of a percent
+func (d *Device) calculateHumidity(data [8]byte, tFine int32) int32 {
+
+	rawHumidity := convert2Bytes(data[6], data[7])
+
+	h := float32(tFine) - 76800
+
+	if h == 0 {
+		println("invalid value")
+	}
+
+	var1 := float32(rawHumidity) - (float32(d.calibrationCoefficients.h4)*64.0 +
+		(float32(d.calibrationCoefficients.h5) / 16384.0 * h))
+
+	var2 := float32(d.calibrationCoefficients.h2) / 65536.0 *
+		(1.0 + float32(d.calibrationCoefficients.h6)/67108864.0*h*
+			(1.0+float32(d.calibrationCoefficients.h3)/67108864.0*h))
+
+	h = var1 * var2
+	h = h * (1 - float32(d.calibrationCoefficients.h1)*h/524288)
+	return int32(100 * h)
+
+}

bme280/registers.go

@@ -0,0 +1,25 @@
+package bme280
+
+// Constants/addresses used for I2C.
+
+// The I2C address which this device listens to.
+const Address = 0x76
+
+// Registers. Names, addresses and comments copied from the datasheet.
+const (
+	CTRL_MEAS_ADDR        = 0xF4
+	CTRL_HUMIDITY_ADDR    = 0xF2
+	CTRL_CONFIG           = 0xF5
+	REG_PRESSURE          = 0xF7
+	REG_CALIBRATION       = 0x88
+	REG_CALIBRATION_H1    = 0xA1
+	REG_CALIBRATION_H2LSB = 0xE1
+	CMD_RESET             = 0xE0
+
+	WHO_AM_I = 0xD0
+	CHIP_ID  = 0x60
+)
+
+const (
+	SEALEVEL_PRESSURE float32 = 1013.25 // in hPa
+)

bmp180/bmp180.go

@@ -80,7 +80,7 @@ func (d *Device) Configure() {
 	d.calibrationCoefficients.md = readInt(data[20], data[21])
 }
 
-// ReadTemperature returns the temperature in celsius milli degrees (ºC/1000).
+// ReadTemperature returns the temperature in celsius milli degrees (°C/1000).
 func (d *Device) ReadTemperature() (temperature int32, err error) {
 	rawTemp, err := d.rawTemp()
 	if err != nil {

buzzer/buzzer.go

@@ -0,0 +1,71 @@
+// Package buzzer provides a very simplistic driver for a connected buzzer or low-fidelity speaker.
+//
+package buzzer // import "tinygo.org/x/drivers/buzzer"
+
+import (
+	"machine"
+
+	"time"
+)
+
+// Device wraps a GPIO connection to a buzzer.
+type Device struct {
+	pin  machine.Pin
+	High bool
+	BPM  float64
+}
+
+// New returns a new buzzer driver given which pin to use
+func New(pin machine.Pin) Device {
+	return Device{
+		pin:  pin,
+		High: false,
+		BPM:  96.0,
+	}
+}
+
+// On sets the buzzer to a high state.
+func (l *Device) On() (err error) {
+	l.pin.Set(true)
+	l.High = true
+	return
+}
+
+// Off sets the buzzer to a low state.
+func (l *Device) Off() (err error) {
+	l.pin.Set(false)
+	l.High = false
+	return
+}
+
+// Toggle sets the buzzer to the opposite of it's current state
+func (l *Device) Toggle() (err error) {
+	if l.High {
+		err = l.Off()
+	} else {
+		err = l.On()
+	}
+	return
+}
+
+// Tone plays a tone of the requested frequency and duration.
+func (l *Device) Tone(hz, duration float64) (err error) {
+	// calculation based off https://www.arduino.cc/en/Tutorial/Melody
+	tone := (1.0 / (2.0 * hz)) * 1000000.0
+
+	tempo := ((60 / l.BPM) * (duration * 1000))
+
+	for i := 0.0; i < tempo*1000; i += tone * 2.0 {
+		if err = l.On(); err != nil {
+			return
+		}
+		time.Sleep(time.Duration(tone) * time.Microsecond)
+
+		if err = l.Off(); err != nil {
+			return
+		}
+		time.Sleep(time.Duration(tone) * time.Microsecond)
+	}
+
+	return
+}

buzzer/notes.go

@@ -0,0 +1,121 @@
+package buzzer
+
+const (
+	Whole   = 4
+	Half    = 2
+	Quarter = 1
+	Eighth  = 0.500
+)
+
+// The values seem like they are little off, so feel free to make corrections, as needed.
+const (
+	Rest = 0
+	C0   = 16.35
+	Db0  = 17.32
+	D0   = 18.35
+	Eb0  = 19.45
+	E0   = 20.60
+	F0   = 21.83
+	Gb0  = 23.12
+	G0   = 24.50
+	Ab0  = 25.96
+	A0   = 27.50
+	Bb0  = 29.14
+	B0   = 30.87
+	C1   = 32.70
+	Db1  = 34.65
+	D1   = 36.71
+	Eb1  = 38.89
+	E1   = 41.20
+	F1   = 43.65
+	Gb1  = 46.25
+	G1   = 49.00
+	Ab1  = 51.91
+	A1   = 55.00
+	Bb1  = 58.27
+	B1   = 61.74
+	C2   = 65.41
+	Db2  = 69.30
+	D2   = 73.42
+	Eb2  = 77.78
+	E2   = 82.41
+	F2   = 87.31
+	Gb2  = 92.50
+	G2   = 98.00
+	Ab2  = 103.83
+	A2   = 110.00
+	Bb2  = 116.54
+	B2   = 123.47
+	C3   = 130.81
+	Db3  = 138.59
+	D3   = 146.83
+	Eb3  = 155.56
+	E3   = 164.81
+	F3   = 174.61
+	Gb3  = 185.00
+	G3   = 196.00
+	Ab3  = 207.65
+	A3   = 220.00
+	Bb3  = 233.08
+	B3   = 246.94
+	C4   = 261.63
+	Db4  = 277.18
+	D4   = 293.66
+	Eb4  = 311.13
+	E4   = 329.63
+	F4   = 349.23
+	Gb4  = 369.99
+	G4   = 392.00
+	Ab4  = 415.30
+	A4   = 440.00
+	Bb4  = 466.16
+	B4   = 493.88
+	C5   = 523.25
+	Db5  = 554.37
+	D5   = 587.33
+	Eb5  = 622.25
+	E5   = 659.25
+	F5   = 698.46
+	Gb5  = 739.99
+	G5   = 783.99
+	Ab5  = 830.61
+	A5   = 880.00
+	Bb5  = 932.33
+	B5   = 987.77
+	C6   = 1046.50
+	Db6  = 1108.73
+	D6   = 1174.66
+	Eb6  = 1244.51
+	E6   = 1318.51
+	F6   = 1396.91
+	Gb6  = 1479.98
+	G6   = 1567.98
+	Ab6  = 1661.22
+	A6   = 1760.00
+	Bb6  = 1864.66
+	B6   = 1975.53
+	C7   = 2093.00
+	Db7  = 2217.46
+	D7   = 2349.32
+	Eb7  = 2489.02
+	E7   = 2637.02
+	F7   = 2793.83
+	Gb7  = 2959.96
+	G7   = 3135.96
+	Ab7  = 3322.44
+	A7   = 3520.00
+	Bb7  = 3729.31
+	B7   = 3951.07
+	C8   = 4186.01
+	Db8  = 4434.92
+	D8   = 4698.63
+	Eb8  = 4978.03
+	E8   = 5274.04
+	F8   = 5587.65
+	Gb8  = 5919.91
+	G8   = 6271.93
+	Ab8  = 6644.88
+	A8   = 7040.00
+	Bb8  = 7458.62
+	B8   = 7902.13
+)

drivers.go

@@ -1,5 +1,5 @@
-// Package drivers provides a collection of hardware drivers for devices that
-// can be used together with TinyGo (https://tinygo.org).
+// Package drivers provides a collection of hardware drivers for TinyGo (https://tinygo.org)
+// for devices such as sensors and displays.
 //
 // Here is an example in TinyGo that uses the BMP180 digital barometer:
 //
@@ -9,7 +9,7 @@
 //		"time"
 //		"machine"
 //
-// 		"github.com/tinygo-org/drivers/bmp180"
+// 		"tinygo.org/x/drivers/bmp180"
 // 	)
 //
 // 	func main() {
@@ -26,7 +26,7 @@
 //
 //		for {
 //			temp, _ := sensor.ReadTemperature()
-//			println("Temperature:", float32(temp)/1000, "ºC")
+//			println("Temperature:", float32(temp)/1000, "°C")
 //
 //			pressure, _ := sensor.ReadPressure()
 //			println("Pressure", float32(pressure)/100000, "hPa")

ds1307/ds1307.go

@@ -74,7 +74,7 @@ func (d *Device) Seek(offset int64, whence int) (int64, error) {
 	case 2:
 		whence = SRAMEndAddress
 	default:
-		return 0, errors.New("Invalid starting point")
+		return 0, errors.New("invalid starting point")
 	}
 	d.AddressSRAM = uint8(whence) + uint8(offset)
 	if d.AddressSRAM > SRAMEndAddress {
@@ -87,7 +87,7 @@ func (d *Device) Seek(offset int64, whence int) (int64, error) {
 // returns number of bytes written and error, if any
 func (d *Device) Write(data []byte) (n int, err error) {
 	if int(d.AddressSRAM)+len(data)-1 > SRAMEndAddress {
-		return 0, errors.New("Writing outside of SRAM")
+		return 0, errors.New("writing outside of SRAM")
 	}
 	buffer := make([]byte, len(data)+1)
 	buffer[0] = d.AddressSRAM

easystepper/easystepper.go

@@ -1,4 +1,4 @@
-// Simple driver to rotate a 4-wire stepper motor
+// Package easystepper provides a simple driver to rotate a 4-wire stepper motor.
 package easystepper // import "tinygo.org/x/drivers/easystepper"
 
 import (
@@ -10,47 +10,115 @@ import (
 type Device struct {
 	pins       [4]machine.Pin
 	stepDelay  int32
-	stepNumber int32
+	stepNumber uint8
 }
 
-// New returns a new easystepper driver given 4 pins numbers (not pin object),
-// number of steps and rpm
+// DualDevice holds information for controlling 2 motors
+type DualDevice struct {
+	devices [2]Device
+}
+
+// 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 {
-	pin1.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	pin2.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	pin3.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	pin4.Configure(machine.PinConfig{Mode: machine.PinOutput})
 	return Device{
 		pins:      [4]machine.Pin{pin1, pin2, pin3, pin4},
 		stepDelay: 60000000 / (steps * rpm),
 	}
 }
 
+// Configure configures the pins of the Device
+func (d *Device) Configure() {
+	for _, pin := range d.pins {
+		pin.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	}
+}
+
+// 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{
+		pins:      [4]machine.Pin{pin1, pin2, pin3, pin4},
+		stepDelay: 60000000 / (steps * rpm),
+	}
+	dual.devices[1] = Device{
+		pins:      [4]machine.Pin{pin5, pin6, pin7, pin8},
+		stepDelay: 60000000 / (steps * rpm),
+	}
+	return dual
+}
+
+// Configure configures the pins of the DualDevice
+func (d *DualDevice) Configure() {
+	d.devices[0].Configure()
+	d.devices[1].Configure()
+}
+
 // Move rotates the motor the number of given steps
 // (negative steps will rotate it the opposite direction)
 func (d *Device) Move(steps int32) {
 	direction := steps > 0
 	if steps < 0 {
-		steps = -steps - d.stepNumber
-	} else {
-		steps += d.stepNumber
+		steps = -steps
 	}
-	var stepN int8
+	steps += int32(d.stepNumber)
 	var s int32
-	for s = d.stepNumber; s < steps; s++ {
+	d.stepMotor(d.stepNumber)
+	for s = int32(d.stepNumber); s < steps; s++ {
 		time.Sleep(time.Duration(d.stepDelay) * time.Microsecond)
-		if direction {
-			stepN = int8(s % 4)
-		} else {
-			stepN = int8((s + 2*(s%2)) % 4)
-		}
-		d.stepMotor(stepN)
+		d.moveDirectionSteps(direction, s)
 	}
-	d.stepNumber = int32(stepN)
+}
+
+// Off turns off all motor pins
+func (d *Device) Off() {
+	for _, pin := range d.pins {
+		pin.Low()
+	}
+}
+
+// Move rotates the motors the number of given steps
+// (negative steps will rotate it the opposite direction)
+func (d *DualDevice) Move(stepsA, stepsB int32) {
+	min := uint8(1)
+	max := uint8(0)
+	var directions [2]bool
+	var minStep int32
+
+	directions[0] = stepsA > 0
+	directions[1] = stepsB > 0
+	if stepsA < 0 {
+		stepsA = -stepsA
+	}
+	if stepsB < 0 {
+		stepsB = -stepsB
+	}
+	if stepsB > stepsA {
+		stepsA, stepsB = stepsB, stepsA
+		max, min = min, max
+	}
+	d.devices[0].stepMotor(d.devices[0].stepNumber)
+	d.devices[1].stepMotor(d.devices[1].stepNumber)
+	stepsA += int32(d.devices[max].stepNumber)
+	minStep = int32(d.devices[min].stepNumber)
+	for s := int32(d.devices[max].stepNumber); s < stepsA; s++ {
+		time.Sleep(time.Duration(d.devices[0].stepDelay) * time.Microsecond)
+		d.devices[max].moveDirectionSteps(directions[max], s)
+
+		if ((s * stepsB) / stepsA) > minStep {
+			minStep++
+			d.devices[min].moveDirectionSteps(directions[min], minStep)
+		}
+	}
+}
+
+// Off turns off all motor pins
+func (d *DualDevice) Off() {
+	d.devices[0].Off()
+	d.devices[1].Off()
 }
 
 // stepMotor changes the pins' state to the correct step
-func (d *Device) stepMotor(step int8) {
+func (d *Device) stepMotor(step uint8) {
 	switch step {
 	case 0:
 		d.pins[0].High()
@@ -77,4 +145,16 @@ func (d *Device) stepMotor(step int8) {
 		d.pins[3].High()
 		break
 	}
+	d.stepNumber = step
+}
+
+// moveDirectionSteps uses the direction to calculate the correct step and change the motor to it.
+// Direction true: 0, 1, 2, 3, 0, 1, 2, ...
+// Direction false: 0, 3, 2, 1, 0, 3, 2, ...
+func (d *Device) moveDirectionSteps(direction bool, step int32) {
+	if direction {
+		d.stepMotor(uint8(step % 4))
+	} else {
+		d.stepMotor(uint8((step + 2*(step%2)) % 4))
+	}
 }

espat/README.md

@@ -0,0 +1,84 @@
+# ESP-AT Driver
+
+This package provides a driver to use a separate connected WiFi processor either the ESP8266 or the ESP32 from Espressif. 
+
+The way this driver works is by using the UART interface to communicate with the WiFi chip using the Espressif AT command set.
+
+## ESP-AT Firmware Installation
+
+In order to use this driver, you must have the ESP-AT firmware installed on the ESP8266/ESP32 chip.
+
+### Installing on Arduino Nano33 IoT
+
+In order to install the needed firmware on the Arduino Nano33 IoT board's built-in NINA W102 chip, you will need to use the `arduino-nano33-iot` branch of this fork of the firmware:
+
+https://github.com/hybridgroup/esp32-at
+
+To flash this firmware on the Arduino Nano33 IoT you will need to follow the following procedure:
+
+- Install _Arduino SAMD Boards_ from the Boards Manager.
+- Install _WiFiNANO_ from the Library Manager.
+- Using the normal Arduino software, load the `SerialNINAPassthrough` sketch on to the board (in File -> Examples -> WiFiNINA-> Tools).
+- Flash the NINA 102 firmware using the `make flash` command in the https://github.com/hybridgroup/esp32-at repo.
+
+You only need to do this one time, and then the correct ESP-AT firmware will be on the NINA chip, and you can just flash the Arduino Nano33 IoT board using TinyGo. We should be able to remove some of these step in a future release of this software.
+
+### Installing on ESP32
+
+The official repository for the ESP-AT for the ESP32 processor is located here:
+
+https://github.com/espressif/esp32-at
+
+Your best option is to follow the instructions in the official repo.
+
+### Installing on ESP8266
+
+The official repository for the AT command set firmware for the ESP8266 processor is located here:
+
+https://github.com/espressif/ESP8266_NONOS_SDK
+
+First clone the repo:
+
+```shell
+git clone https://github.com/espressif/ESP8266_NONOS_SDK.git
+```
+
+You will also need to install the Espressif `esptool` to flash this firmware on your ESP8266:
+
+https://github.com/espressif/esptool
+
+Once you have obtained the binary code, and installed `esptool`, you can flash the ESP8266.
+
+Here is an example shell script that flashes a Wemos D1 Mini board:
+
+
+```python
+#!/bin/sh
+SPToolDir="$HOME/.local/lib/python2.7/site-packages"
+FirmwareDir="$HOME/Development/ESP8266_NONOS_SDK"
+cd "$SPToolDir"
+port=/dev/ttyUSB0
+if [ ! -c $port ]; then
+   port=/dev/ttyUSB0
+fi
+if [ ! -c $port ]; then
+   echo "No device appears to be plugged in.  Stopping."
+fi
+printf "Writing AT firmware to the Wemos D1 Mini in 3..."
+sleep 1; printf "2..."
+sleep 1; printf "1..."
+sleep 1; echo "done."
+echo "Erasing the flash first"
+esptool.py --port $port erase_flash
+esptool.py --port /dev/ttyUSB0 --baud 115200 \
+   write_flash -fm dio -ff 20m -fs detect \
+   0x0000 "$FirmwareDir/bin/boot_v1.7.bin" \
+   0x01000 "$FirmwareDir/bin/at/512+512/user1.1024.new.2.bin" \
+   0x3fc000 "$FirmwareDir/bin/esp_init_data_default_v05.bin"  \
+   0x7e000 "$FirmwareDir/bin/blank.bin" \
+   0x3fe000 "$FirmwareDir/bin/blank.bin"
+
+echo "Check the boot by typing: miniterm $port 74800"
+echo " and then resetting.  Use Ctrl-] to quit miniterm."
+
+```

espat/commands.go

@@ -42,12 +42,14 @@ const (
 	Disconnect = "+CWQAP"
 
 	// Set softAP configuration. This also activates the ESP8266/ESP32 to act as an access point.
-	// The settings will not be saved in flash memory, so they will be forgotten on next reset.
-	SoftAPConfigCurrent = "+CWSAP_CUR"
+	// On the ESP8266 the settings will not be saved in flash memory, so they will be forgotten on next reset.
+	// On the ESP32 the settings WILL be saved in flash memory, so they will be used on next reset.
+	SoftAPConfigCurrent = "+CWSAP"
 
-	// Set softAP configuration as saved in flash. This also activates the ESP8266/ESP32 to act as an
-	// access point. The settings will be saved in flash memory, so they will be used on next reset.
-	SoftAPConfigFlash = "+CWSAP_DEF"
+	// Set softAP configuration. This also activates the ESP8266/ESP32 to act as an access point.
+	// On the ESP8266 the settings will not be saved in flash memory, so they will be forgotten on next reset.
+	// On the ESP32 the settings WILL be saved in flash memory, so they will be used on next reset.
+	SoftAPConfigFlash = "+CWSAP"
 
 	// List station IP's connected to softAP
 	ListConnectedIP = "+CWLIF"
@@ -65,12 +67,14 @@ const (
 	SetStationIP = "+CIPSTA"
 
 	// Set IP address of ESP8266/ESP32 when acting as access point.
-	// The IP address will not be saved in flash memory, so it will be forgotten on next reset.
-	SetSoftAPIPCurrent = "+CIPAP_CUR"
+	// On the ESP8266 the IP address will not be saved in flash memory, so it will be forgotten on next reset.
+	// On the ESP32 the IP address WILL be saved in flash memory, so it will be used on next reset.
+	SetSoftAPIPCurrent = "+CIPAP"
 
 	// Set IP address of ESP8266/ESP32 when acting as access point.
-	// The IP address will be saved in flash memory, so they will be used on next reset.
-	SetSoftAPIPFlash = "+CIPAP_DEF"
+	// On the ESP8266 the IP address will not be saved in flash memory, so it will be forgotten on next reset.
+	// On the ESP32 the IP address WILL be saved in flash memory, so it will be used on next reset.
+	SetSoftAPIPFlash = "+CIPAP"
 )
 
 // TCP/IP commands
@@ -81,6 +85,9 @@ const (
 	// Establish TCP connection or register UDP port
 	TCPConnect = "+CIPSTART"
 
+	// DNS Lookup
+	TCPDNSLookup = "+CIPDOMAIN"
+
 	// Send Data
 	TCPSend = "+CIPSEND"
 

espat/espat.go

@@ -19,10 +19,13 @@
 package espat // import "tinygo.org/x/drivers/espat"
 
 import (
+	"errors"
 	"machine"
 	"strconv"
 	"strings"
 	"time"
+
+	"tinygo.org/x/drivers/net"
 )
 
 // Device wraps UART connection to the ESP8266/ESP32.
@@ -36,6 +39,9 @@ type Device struct {
 	socketdata []byte
 }
 
+// ActiveDevice is the currently configured Device in use. There can only be one.
+var ActiveDevice *Device
+
 // New returns a new espat driver. Pass in a fully configured UART bus.
 func New(b machine.UART) *Device {
 	return &Device{bus: b, response: make([]byte, 512), socketdata: make([]byte, 0, 1024)}
@@ -43,6 +49,8 @@ func New(b machine.UART) *Device {
 
 // Configure sets up the device for communication.
 func (d Device) Configure() {
+	ActiveDevice = &d
+	net.ActiveDevice = ActiveDevice
 }
 
 // Connected checks if there is communication with the ESP8266/ESP32.
@@ -50,11 +58,11 @@ func (d *Device) Connected() bool {
 	d.Execute(Test)
 
 	// handle response here, should include "OK"
-	r := d.Response()
-	if strings.Contains(string(r), "OK") {
-		return true
+	_, err := d.Response(100)
+	if err != nil {
+		return false
 	}
-	return false
+	return true
 }
 
 // Write raw bytes to the UART.
@@ -68,7 +76,7 @@ func (d *Device) Read(b []byte) (n int, err error) {
 }
 
 // how long in milliseconds to pause after sending AT commands
-const pause = 100
+const pause = 300
 
 // Execute sends an AT command to the ESP8266/ESP32.
 func (d Device) Execute(cmd string) error {
@@ -93,7 +101,11 @@ func (d Device) Set(cmd, params string) error {
 // Version returns the ESP8266/ESP32 firmware version info.
 func (d Device) Version() []byte {
 	d.Execute(Version)
-	return d.Response()
+	r, err := d.Response(100)
+	if err != nil {
+		return []byte("unknown")
+	}
+	return r
 }
 
 // Echo sets the ESP8266/ESP32 echo setting.
@@ -104,7 +116,7 @@ func (d Device) Echo(set bool) {
 		d.Execute(EchoConfigOff)
 	}
 	// TODO: check for success
-	d.Response()
+	d.Response(100)
 }
 
 // Reset restarts the ESP8266/ESP32 firmware. Due to how the baud rate changes,
@@ -112,13 +124,13 @@ func (d Device) Echo(set bool) {
 // what you are doing when you call this.
 func (d Device) Reset() {
 	d.Execute(Restart)
-	d.Response()
+	d.Response(100)
 }
 
 // ReadSocket returns the data that has already been read in from the responses.
 func (d *Device) ReadSocket(b []byte) (n int, err error) {
 	// make sure no data in buffer
-	d.Response()
+	d.Response(300)
 
 	count := len(b)
 	if len(b) >= len(d.socketdata) {
@@ -137,116 +149,74 @@ func (d *Device) ReadSocket(b []byte) (n int, err error) {
 }
 
 // Response gets the next response bytes from the ESP8266/ESP32.
-func (d *Device) Response() []byte {
-	var i, retries int
+// The call will retry for up to timeout milliseconds before returning nothing.
+func (d *Device) Response(timeout int) ([]byte, error) {
+	// read data
+	var size int
+	var start, end int
+	pause := 100 // pause to wait for 100 ms
+	retries := timeout / pause
 
-	header := make([]byte, 2)
 	for {
-		for d.bus.Buffered() > 0 {
-			// get the first 2 bytes
-			header[0], _ = d.bus.ReadByte()
-			header[1], _ = d.bus.ReadByte()
+		size = d.bus.Buffered()
 
-			if d.isLeadingCRLF(header) {
-				// skip it
-				header[0], _ = d.bus.ReadByte()
-				header[1], _ = d.bus.ReadByte()
+		if size > 0 {
+			end += size
+			d.bus.Read(d.response[start:end])
+
+			// if "+IPD" then read socket data
+			if strings.Contains(string(d.response[:end]), "+IPD") {
+				// handle socket data
+				return nil, d.parseIPD(end)
 			}
 
-			if d.isIPD(header) {
-				// is socket data packet
-				d.parseIPD()
-			} else {
-				// no, so put into response
-				d.response[i] = header[0]
-				i++
-				d.response[i] = header[1]
-				i++
+			// if "OK" then the command worked
+			if strings.Contains(string(d.response[:end]), "OK") {
+				return d.response[start:end], nil
 			}
 
-			// read the rest of normal command response
-			for d.bus.Buffered() > 0 {
-				data, err := d.bus.ReadByte()
-				if err != nil {
-					return nil
-				}
-				d.response[i] = data
-				i++
+			// if "Error" then the command failed
+			if strings.Contains(string(d.response[:end]), "ERROR") {
+				return d.response[start:end], errors.New("response error:" + string(d.response[start:end]))
 			}
-		}
-		retries++
-		if retries > 2 {
-			break
+
+			// if anything else, then keep reading data in?
+			start = end
 		}
 
-		// pause to make sure is no more data to be read
-		time.Sleep(10 * time.Millisecond)
+		// wait longer?
+		retries--
+		if retries == 0 {
+			return nil, errors.New("response timeout error:" + string(d.response[start:end]))
+		}
+
+		time.Sleep(time.Duration(pause) * time.Millisecond)
 	}
-	return d.response[:i]
 }
 
-func (d *Device) isLeadingCRLF(b []byte) bool {
-	if len(b) < 2 {
-		return false
-	}
-	if b[0] == 13 && b[1] == 10 {
-		return true
-	}
-	return false
-}
+func (d *Device) parseIPD(end int) error {
+	// find the "+IPD," to get length
+	s := strings.Index(string(d.response[:end]), "+IPD,")
 
-func (d *Device) isIPD(b []byte) bool {
-	if len(b) < 2 {
-		return false
-	}
-	if b[0] == '+' && b[1] == 'I' {
-		return true
-	}
-	return false
-}
+	// find the ":"
+	e := strings.Index(string(d.response[:end]), ":")
 
-func (d *Device) parseIPD() bool {
-	data, _ := d.bus.ReadByte()
-	if data != 'P' {
-		// error
-		return false
-	}
-	data, _ = d.bus.ReadByte()
-	if data != 'D' {
-		// error
-		return false
-	}
-	data, _ = d.bus.ReadByte()
-	if data != ',' {
-		// error
-		return false
-	}
+	// find the data length
+	val := string(d.response[s+5 : e])
 
-	// get the expected data length
-	// skip remaining header up to the ":"
-	buf := []byte{}
-	data, _ = d.bus.ReadByte()
-	for data != ':' {
-		// put into the buffer with int value here
-		buf = append(buf, data)
-
-		// read next value
-		data, _ = d.bus.ReadByte()
-	}
-
-	val := string(buf)
-	count, err := strconv.Atoi(val)
+	// TODO: verify count
+	_, err := strconv.Atoi(val)
 	if err != nil {
 		// not expected data here. what to do?
-		return false
+		return err
 	}
 
 	// load up the socket data
-	// only read the expected amount of data
-	for m := 0; m < count; m++ {
-		data, _ = d.bus.ReadByte()
-		d.socketdata = append(d.socketdata, data)
-	}
-
-	return true
+	d.socketdata = append(d.socketdata, d.response[e+1:end]...)
+	return nil
+}
+
+// IsSocketDataAvailable returns of there is socket data available
+func (d *Device) IsSocketDataAvailable() bool {
+	return len(d.socketdata) > 0 || d.bus.Buffered() > 0
 }

espat/net.go

@@ -1,143 +0,0 @@
-package espat
-
-import (
-	"strconv"
-	"time"
-)
-
-// DialUDP makes a UDP network connection. raadr is the port that the messages will
-// be sent to, and laddr is the port that will be listened to in order to
-// receive incoming messages.
-func (d Device) DialUDP(network string, laddr, raddr *UDPAddr) (*SerialConn, error) {
-	addr := raddr.IP.String()
-	sendport := strconv.Itoa(raddr.Port)
-	listenport := strconv.Itoa(laddr.Port)
-
-	// disconnect any old socket
-	d.DisconnectSocket()
-
-	// connect new socket
-	d.ConnectUDPSocket(addr, sendport, listenport)
-
-	return &SerialConn{Adaptor: &d, laddr: laddr, raddr: raddr}, nil
-}
-
-// ListenUDP listens for UDP connections on the port listed in laddr.
-func (d Device) ListenUDP(network string, laddr *UDPAddr) (*SerialConn, error) {
-	addr := "0"
-	sendport := "0"
-	listenport := strconv.Itoa(laddr.Port)
-
-	// disconnect any old socket
-	d.DisconnectSocket()
-
-	// connect new socket
-	d.ConnectUDPSocket(addr, sendport, listenport)
-
-	return &SerialConn{Adaptor: &d, laddr: laddr}, nil
-}
-
-// SerialConn is a loosely net.Conn compatible intended to support
-// TCP/UDP over serial.
-type SerialConn struct {
-	Adaptor *Device
-	laddr   *UDPAddr
-	raddr   *UDPAddr
-}
-
-// Read reads data from the connection.
-// TODO: implement the full method functionality:
-// Read can be made to time out and return an Error with Timeout() == true
-// after a fixed time limit; see SetDeadline and SetReadDeadline.
-func (c *SerialConn) Read(b []byte) (n int, err error) {
-	// read only the data that has been received via "+IPD" socket
-	return c.Adaptor.ReadSocket(b)
-}
-
-// Write writes data to the connection.
-// TODO: implement the full method functionality for timeouts.
-// Write can be made to time out and return an Error with Timeout() == true
-// after a fixed time limit; see SetDeadline and SetWriteDeadline.
-func (c *SerialConn) Write(b []byte) (n int, err error) {
-	// specify that is a data transfer to the
-	// currently open socket, not commands to the ESP8266/ESP32.
-	c.Adaptor.StartSocketSend(len(b))
-	return c.Adaptor.Write(b)
-}
-
-// Close closes the connection.
-// Currently only supports a single Read or Write operations without blocking.
-func (c *SerialConn) Close() error {
-	c.Adaptor.DisconnectSocket()
-	return nil
-}
-
-// LocalAddr returns the local network address.
-func (c *SerialConn) LocalAddr() UDPAddr {
-	return *c.laddr
-}
-
-// RemoteAddr returns the remote network address.
-func (c *SerialConn) RemoteAddr() UDPAddr {
-	return *c.laddr
-}
-
-// SetDeadline sets the read and write deadlines associated
-// with the connection. It is equivalent to calling both
-// SetReadDeadline and SetWriteDeadline.
-//
-// A deadline is an absolute time after which I/O operations
-// fail with a timeout (see type Error) instead of
-// blocking. The deadline applies to all future and pending
-// I/O, not just the immediately following call to Read or
-// Write. After a deadline has been exceeded, the connection
-// can be refreshed by setting a deadline in the future.
-//
-// An idle timeout can be implemented by repeatedly extending
-// the deadline after successful Read or Write calls.
-//
-// A zero value for t means I/O operations will not time out.
-func (c *SerialConn) SetDeadline(t time.Time) error {
-	return nil
-}
-
-// SetReadDeadline sets the deadline for future Read calls
-// and any currently-blocked Read call.
-// A zero value for t means Read will not time out.
-func (c *SerialConn) SetReadDeadline(t time.Time) error {
-	return nil
-}
-
-// SetWriteDeadline sets the deadline for future Write calls
-// and any currently-blocked Write call.
-// Even if write times out, it may return n > 0, indicating that
-// some of the data was successfully written.
-// A zero value for t means Write will not time out.
-func (c *SerialConn) SetWriteDeadline(t time.Time) error {
-	return nil
-}
-
-// The following definitions are here to support a Golang standard package
-// net-compatible interface for IP until TinyGo can compile the net package.
-
-// IP is an IP address. Unlike the standard implementation, it is only
-// a buffer of bytes that contains the string form of the IP address, not the
-// full byte format used by the Go standard .
-type IP []byte
-
-// UDPAddr here to serve as compatible type. until TinyGo can compile the net package.
-type UDPAddr struct {
-	IP   IP
-	Port int
-	Zone string // IPv6 scoped addressing zone; added in Go 1.1
-}
-
-// ParseIP parses s as an IP address, returning the result.
-func ParseIP(s string) IP {
-	return IP([]byte(s))
-}
-
-// String returns the string form of the IP address ip.
-func (ip IP) String() string {
-	return string(ip)
-}

espat/tcp.go

@@ -1,8 +1,9 @@
 package espat
 
 import (
+	"errors"
 	"strconv"
-	"time"
+	"strings"
 )
 
 const (
@@ -13,14 +14,37 @@ const (
 	TCPTransferModeUnvarnished = 1
 )
 
+// GetDNS returns the IP address for a domain name.
+func (d *Device) GetDNS(domain string) (string, error) {
+	d.Set(TCPDNSLookup, "\""+domain+"\"")
+	resp, err := d.Response(1000)
+	if err != nil {
+		return "", err
+	}
+	if !strings.Contains(string(resp), ":") {
+		return "", errors.New("GetDNS error:" + string(resp))
+	}
+	r := strings.Split(string(resp), ":")
+	if len(r) != 2 {
+		return "", errors.New("Invalid domain lookup result")
+	}
+	res := strings.Split(r[1], "\r\n")
+	return res[0], nil
+}
+
 // ConnectTCPSocket creates a new TCP socket connection for the ESP8266/ESP32.
 // Currently only supports single connection mode.
 func (d *Device) ConnectTCPSocket(addr, port string) error {
 	protocol := "TCP"
-	val := "\"" + protocol + "\",\"" + addr + "\"," + port
-	d.Set(TCPConnect, val)
-	time.Sleep(100 * time.Millisecond)
-	d.Response()
+	val := "\"" + protocol + "\",\"" + addr + "\"," + port + ",120"
+	err := d.Set(TCPConnect, val)
+	if err != nil {
+		return err
+	}
+	_, e := d.Response(3000)
+	if e != nil {
+		return e
+	}
 	return nil
 }
 
@@ -28,17 +52,41 @@ func (d *Device) ConnectTCPSocket(addr, port string) error {
 func (d *Device) ConnectUDPSocket(addr, sendport, listenport string) error {
 	protocol := "UDP"
 	val := "\"" + protocol + "\",\"" + addr + "\"," + sendport + "," + listenport + ",2"
+	err := d.Set(TCPConnect, val)
+	if err != nil {
+		return err
+	}
+	_, e := d.Response(3000)
+	if e != nil {
+		return e
+	}
+	return nil
+}
+
+// ConnectSSLSocket creates a new SSL socket connection for the ESP8266/ESP32.
+// Currently only supports single connection mode.
+func (d *Device) ConnectSSLSocket(addr, port string) error {
+	protocol := "SSL"
+	val := "\"" + protocol + "\",\"" + addr + "\"," + port + ",120"
 	d.Set(TCPConnect, val)
-	time.Sleep(pause * time.Millisecond)
-	d.Response()
+	// this operation takes longer, so wait up to 6 seconds to complete.
+	_, err := d.Response(6000)
+	if err != nil {
+		return err
+	}
 	return nil
 }
 
 // DisconnectSocket disconnects the ESP8266/ESP32 from the current TCP/UDP connection.
 func (d *Device) DisconnectSocket() error {
-	d.Execute(TCPClose)
-	time.Sleep(pause * time.Millisecond)
-	d.Response()
+	err := d.Execute(TCPClose)
+	if err != nil {
+		return err
+	}
+	_, e := d.Response(pause)
+	if e != nil {
+		return e
+	}
 	return nil
 }
 
@@ -47,15 +95,14 @@ func (d *Device) DisconnectSocket() error {
 func (d *Device) SetMux(mode int) error {
 	val := strconv.Itoa(mode)
 	d.Set(TCPMultiple, val)
-	time.Sleep(pause * time.Millisecond)
-	d.Response()
-	return nil
+	_, err := d.Response(pause)
+	return err
 }
 
 // GetMux returns the ESP8266/ESP32 current client TCP/UDP configuration for concurrent connections.
 func (d *Device) GetMux() ([]byte, error) {
 	d.Query(TCPMultiple)
-	return d.Response(), nil
+	return d.Response(pause)
 }
 
 // SetTCPTransferMode sets the ESP8266/ESP32 current client TCP/UDP transfer mode.
@@ -63,15 +110,14 @@ func (d *Device) GetMux() ([]byte, error) {
 func (d *Device) SetTCPTransferMode(mode int) error {
 	val := strconv.Itoa(mode)
 	d.Set(TransmissionMode, val)
-	time.Sleep(pause * time.Millisecond)
-	d.Response()
-	return nil
+	_, err := d.Response(pause)
+	return err
 }
 
 // GetTCPTransferMode returns the ESP8266/ESP32 current client TCP/UDP transfer mode.
-func (d *Device) GetTCPTransferMode() []byte {
+func (d *Device) GetTCPTransferMode() ([]byte, error) {
 	d.Query(TransmissionMode)
-	return d.Response()
+	return d.Response(pause)
 }
 
 // StartSocketSend gets the ESP8266/ESP32 ready to receive TCP/UDP socket data.
@@ -79,10 +125,16 @@ func (d *Device) StartSocketSend(size int) error {
 	val := strconv.Itoa(size)
 	d.Set(TCPSend, val)
 
-	// TODO: wait until ">" is received, which indicates
+	// when ">" is received, it indicates
 	// ready to receive data
-	d.Response()
-	return nil
+	r, err := d.Response(2000)
+	if err != nil {
+		return err
+	}
+	if strings.Contains(string(r), ">") {
+		return nil
+	}
+	return errors.New("StartSocketSend error:" + string(r))
 }
 
 // EndSocketSend tell the ESP8266/ESP32 the TCP/UDP socket data sending is complete,
@@ -90,8 +142,6 @@ func (d *Device) StartSocketSend(size int) error {
 func (d *Device) EndSocketSend() error {
 	d.Write([]byte("+++"))
 
-	// TODO: wait until ">" is received, which indicates
-	// ready to receive data
-	d.Response()
-	return nil
+	_, err := d.Response(pause)
+	return err
 }

espat/wifi.go

@@ -2,7 +2,6 @@ package espat
 
 import (
 	"strconv"
-	"time"
 )
 
 const (
@@ -17,26 +16,25 @@ const (
 )
 
 // GetWifiMode returns the ESP8266/ESP32 wifi mode.
-func (d *Device) GetWifiMode() []byte {
+func (d *Device) GetWifiMode() ([]byte, error) {
 	d.Query(WifiMode)
-	return d.Response()
+	return d.Response(100)
 }
 
 // SetWifiMode sets the ESP8266/ESP32 wifi mode.
 func (d *Device) SetWifiMode(mode int) error {
 	val := strconv.Itoa(mode)
 	d.Set(WifiMode, val)
-	time.Sleep(pause * time.Millisecond)
-	d.Response()
-	return nil
+	_, err := d.Response(pause)
+	return err
 }
 
 // Wifi Client
 
 // GetConnectedAP returns the ESP8266/ESP32 is currently connected to as a client.
-func (d *Device) GetConnectedAP() []byte {
+func (d *Device) GetConnectedAP() ([]byte, error) {
 	d.Query(ConnectAP)
-	return d.Response()
+	return d.Response(100)
 }
 
 // ConnectToAP connects the ESP8266/ESP32 to an access point.
@@ -44,41 +42,43 @@ func (d *Device) GetConnectedAP() []byte {
 func (d *Device) ConnectToAP(ssid, pwd string, ws int) error {
 	val := "\"" + ssid + "\",\"" + pwd + "\""
 	d.Set(ConnectAP, val)
-	// TODO: a better way to wait for connect and check for up to ws seconds.
-	time.Sleep(time.Duration(ws) * time.Second)
-	d.Response()
+
+	_, err := d.Response(ws * 1000)
+	if err != nil {
+		return err
+	}
 	return nil
 }
 
 // DisconnectFromAP disconnects the ESP8266/ESP32 from the current access point.
 func (d *Device) DisconnectFromAP() error {
 	d.Execute(Disconnect)
-	time.Sleep(1000 * time.Millisecond)
-	d.Response()
-	return nil
+	_, err := d.Response(1000)
+	return err
 }
 
 // GetClientIP returns the ESP8266/ESP32 current client IP addess when connected to an Access Point.
-func (d *Device) GetClientIP() string {
+func (d *Device) GetClientIP() (string, error) {
 	d.Query(SetStationIP)
-	return string(d.Response())
+	r, err := d.Response(1000)
+	return string(r), err
 }
 
 // SetClientIP sets the ESP8266/ESP32 current client IP addess when connected to an Access Point.
-func (d *Device) SetClientIP(ipaddr string) []byte {
+func (d *Device) SetClientIP(ipaddr string) error {
 	val := "\"" + ipaddr + "\""
 	d.Set(ConnectAP, val)
-	time.Sleep(500 * time.Millisecond)
-	d.Response()
-	return nil
+	_, err := d.Response(500)
+	return err
 }
 
 // Access Point
 
 // GetAPConfig returns the ESP8266/ESP32 current configuration when acting as an Access Point.
-func (d *Device) GetAPConfig() string {
+func (d *Device) GetAPConfig() (string, error) {
 	d.Query(SoftAPConfigCurrent)
-	return string(d.Response())
+	r, err := d.Response(100)
+	return string(r), err
 }
 
 // SetAPConfig sets the ESP8266/ESP32 current configuration when acting as an Access Point.
@@ -89,37 +89,38 @@ func (d *Device) SetAPConfig(ssid, pwd string, ch, security int) error {
 	ecnval := strconv.Itoa(security)
 	val := "\"" + ssid + "\",\"" + pwd + "\"," + chval + "," + ecnval
 	d.Set(SoftAPConfigCurrent, val)
-	time.Sleep(1000 * time.Millisecond)
-	d.Response()
-	return nil
+	_, err := d.Response(1000)
+	return err
 }
 
 // GetAPClients returns the ESP8266/ESP32 current clients when acting as an Access Point.
-func (d *Device) GetAPClients() string {
+func (d *Device) GetAPClients() (string, error) {
 	d.Query(ListConnectedIP)
-	return string(d.Response())
+	r, err := d.Response(100)
+	return string(r), err
 }
 
 // GetAPIP returns the ESP8266/ESP32 current IP addess when configured as an Access Point.
-func (d *Device) GetAPIP() string {
+func (d *Device) GetAPIP() (string, error) {
 	d.Query(SetSoftAPIPCurrent)
-	return string(d.Response())
+	r, err := d.Response(100)
+	return string(r), err
 }
 
 // SetAPIP sets the ESP8266/ESP32 current IP addess when configured as an Access Point.
 func (d *Device) SetAPIP(ipaddr string) error {
 	val := "\"" + ipaddr + "\""
 	d.Set(SetSoftAPIPCurrent, val)
-	time.Sleep(500 * time.Millisecond)
-	d.Response()
-	return nil
+	_, err := d.Response(500)
+	return err
 }
 
 // GetAPConfigFlash returns the ESP8266/ESP32 current configuration acting as an Access Point
 // from flash storage. These settings are those used after a reset.
-func (d *Device) GetAPConfigFlash() string {
+func (d *Device) GetAPConfigFlash() (string, error) {
 	d.Query(SoftAPConfigFlash)
-	return string(d.Response())
+	r, err := d.Response(100)
+	return string(r), err
 }
 
 // SetAPConfigFlash sets the ESP8266/ESP32 current configuration acting as an Access Point,
@@ -131,16 +132,16 @@ func (d *Device) SetAPConfigFlash(ssid, pwd string, ch, security int) error {
 	ecnval := strconv.Itoa(security)
 	val := "\"" + ssid + "\",\"" + pwd + "\"," + chval + "," + ecnval
 	d.Set(SoftAPConfigFlash, val)
-	time.Sleep(1000 * time.Millisecond)
-	d.Response()
-	return nil
+	_, err := d.Response(1000)
+	return err
 }
 
 // GetAPIPFlash returns the ESP8266/ESP32 IP address as saved to flash storage.
 // This is the IP address that will be used after a reset.
-func (d *Device) GetAPIPFlash() string {
+func (d *Device) GetAPIPFlash() (string, error) {
 	d.Query(SetSoftAPIPFlash)
-	return string(d.Response())
+	r, err := d.Response(100)
+	return string(r), err
 }
 
 // SetAPIPFlash sets the ESP8266/ESP32 current IP addess when configured as an Access Point.
@@ -148,7 +149,6 @@ func (d *Device) GetAPIPFlash() string {
 func (d *Device) SetAPIPFlash(ipaddr string) error {
 	val := "\"" + ipaddr + "\""
 	d.Set(SetSoftAPIPFlash, val)
-	time.Sleep(500 * time.Millisecond)
-	d.Response()
-	return nil
+	_, err := d.Response(500)
+	return err
 }

examples/adt7410/main.go

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

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,
+		MOSI:      machine.SPI1_MOSI_PIN,
+		MISO:      machine.SPI1_MISO_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/apa102/itsybitsy-m0/main.go

@@ -0,0 +1,84 @@
+// This example demostrates how to control the "Dotstar" (APA102) LED included
+// on the Adafruit Itsy Bitsy M0 board.  It implements a "rainbow effect" based
+// on the following example:
+// https://github.com/adafruit/Adafruit_Learning_System_Guides/blob/master/CircuitPython_Essentials/CircuitPython_Internal_RGB_LED_rainbow.py
+package main
+
+import (
+	"image/color"
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/apa102"
+)
+
+var (
+	apa apa102.Device
+
+	led   = machine.PWM{machine.LED}
+	leds  = make([]color.RGBA, 1)
+	wheel = &Wheel{Brightness: 0x10}
+)
+
+func init() {
+
+	// APA102 on Itsy Bitsy is connected to pins that require a software-based
+	// SPI implementation.
+	apa = apa102.NewSoftwareSPI(machine.PA00, machine.PA01, 1)
+
+	// Configure the regular on-board LED for PWM fading
+	machine.InitPWM()
+	led.Configure()
+
+}
+
+func main() {
+
+	// We'll fade the on-board LED in a goroutine to show/ensure that the APA102
+	// works fine with the scheduler enabled.  Comment this out to test this code
+	// with the scheduler disabled.
+	go func() {
+		for i, brightening := uint8(0), false; ; i++ {
+			if i == 0 {
+				brightening = !brightening
+				continue
+			}
+			var brightness uint16 = uint16(i) << 8
+			if !brightening {
+				brightness = 0xFFFF - brightness
+			}
+			led.Set(brightness)
+			time.Sleep(5 * time.Millisecond)
+		}
+	}()
+
+	// Use the "wheel" function from Adafruit's example to cycle the APA102
+	for {
+		leds[0] = wheel.Next()
+		apa.WriteColors(leds)
+		time.Sleep(25 * time.Millisecond)
+	}
+
+}
+
+// Wheel is a port of Adafruit's Circuit Python example referenced above.
+type Wheel struct {
+	Brightness uint8
+	pos        uint8
+}
+
+// Next increments the internal state of the color and returns the new RGBA
+func (w *Wheel) Next() (c color.RGBA) {
+	pos := w.pos
+	if w.pos < 85 {
+		c = color.RGBA{R: 0xFF - pos*3, G: pos * 3, B: 0x0, A: w.Brightness}
+	} else if w.pos < 170 {
+		pos -= 85
+		c = color.RGBA{R: 0x0, G: 0xFF - pos*3, B: pos * 3, A: w.Brightness}
+	} else {
+		pos -= 170
+		c = color.RGBA{R: pos * 3, G: 0x0, B: 0xFF - pos*3, A: w.Brightness}
+	}
+	w.pos++
+	return
+}

examples/at24cx/main.go

@@ -0,0 +1,122 @@
+package main
+
+import (
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/at24cx"
+)
+
+func main() {
+	machine.I2C0.Configure(machine.I2CConfig{})
+
+	eeprom := at24cx.New(machine.I2C0)
+	eeprom.Configure(at24cx.Config{})
+
+	values := make([]uint8, 100)
+	for i := uint16(0); i < 100; i++ {
+		values[i] = uint8(65 + i%26)
+	}
+	_, err := eeprom.WriteAt(values, 0)
+	if err != nil {
+		println("There was an error in WriteAt:", err)
+		return
+	}
+
+	for i := uint16(0); i < 26; i++ {
+		err = eeprom.WriteByte(100+i, uint8(90-i))
+		if err != nil {
+			println("There was an error in WriteByte:", i, err)
+			return
+		}
+		time.Sleep(2 * time.Millisecond)
+	}
+
+	println("\n\r\n\rRead 26 bytes one by one from address 0")
+	println("Expected: ABCDEFGHIJKLMNOPQRSTUVWXYZ")
+	print("Real: ")
+	for i := uint16(0); i < 26; i++ {
+		char, err := eeprom.ReadByte(i)
+		print(string(char))
+		if err != nil {
+			println("There was an error in ReadByte:", i, err)
+			return
+		}
+	}
+	println("")
+
+	println("\n\r\n\rRead 100 bytes from address 26")
+	println("Expected: ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVZYXWVUTSRQPONMLKJIHGFEDCBA")
+	print("Real: ")
+	data := make([]byte, 100)
+	_, err = eeprom.ReadAt(data, 26)
+	if err != nil {
+		println("There was an error in ReadAt:", err)
+		return
+	}
+	for i := 0; i < 100; i++ {
+		print(string(data[i]))
+	}
+	println("")
+
+	// Move to the beginning of memory
+	eeprom.Seek(0, 0)
+	_, err = eeprom.Write([]uint8{88, 88, 88})
+	if err != nil {
+		println("There was an error in Write:", err)
+		return
+	}
+
+	println("\n\r\n\rRead 3 bytes")
+	println("Expected: DEF")
+	print("Real: ")
+	data = make([]byte, 3)
+	_, err = eeprom.Read(data)
+	if err != nil {
+		println("There was an error in Read:", err)
+		return
+	}
+	for _, char := range data {
+		print(string(char))
+	}
+	println("")
+
+	println("\n\r\n\rRead another 3 bytes (from the beginning this time)")
+	eeprom.Seek(-6, 1)
+	println("Expected: XXX")
+	print("Real: ")
+	data = make([]byte, 3)
+	_, err = eeprom.Read(data)
+	if err != nil {
+		println("There was an error in Read:", err)
+		return
+	}
+	for _, char := range data {
+		print(string(char))
+	}
+	println("")
+
+	// Move to the end of memory
+	eeprom.Seek(-4, 2)
+	_, err = eeprom.Write([]uint8{89, 90, 89, 90})
+	if err != nil {
+		println("There was an error in Write:", err)
+		return
+	}
+
+	println("\n\r\n\rRead the last 4 bytes of the memory and the 3 of the beginning")
+	eeprom.Seek(-4, 1)
+	println("Expected: YZYZXXX")
+	print("Real: ")
+	data = make([]byte, 7)
+	_, err = eeprom.Read(data)
+	if err != nil {
+		println("There was an error in Read:", err)
+		return
+	}
+	for _, char := range data {
+		print(string(char))
+	}
+	println("")
+
+}

examples/bme280/main.go

@@ -0,0 +1,35 @@
+package main
+
+import (
+	"machine"
+	"strconv"
+	"time"
+
+	"tinygo.org/x/drivers/bme280"
+)
+
+func main() {
+
+	machine.I2C0.Configure(machine.I2CConfig{})
+	sensor := bme280.New(machine.I2C0)
+	sensor.Configure()
+
+	connected := sensor.Connected()
+	if !connected {
+		println("BME280 not detected")
+	}
+	println("BME280 detected")
+
+	for {
+		temp, _ := sensor.ReadTemperature()
+		println("Temperature:", strconv.FormatFloat(float64(temp)/1000, 'f', 2, 64), "°C")
+		press, _ := sensor.ReadPressure()
+		println("Pressure:", strconv.FormatFloat(float64(press)/100000, 'f', 2, 64), "hPa")
+		hum, _ := sensor.ReadHumidity()
+		println("Humidity:", strconv.FormatFloat(float64(hum)/100, 'f', 2, 64), "%")
+		alt, _ := sensor.ReadAltitude()
+		println("Altitude:", alt, "m")
+
+		time.Sleep(2 * time.Second)
+	}
+}

examples/bmp180/main.go

@@ -22,7 +22,7 @@ func main() {
 
 	for {
 		temp, _ := sensor.ReadTemperature()
-		println("Temperature:", float32(temp)/1000, "ºC")
+		println("Temperature:", float32(temp)/1000, "°C")
 
 		pressure, _ := sensor.ReadPressure()
 		println("Pressure", float32(pressure)/100000, "hPa")

examples/buzzer/main.go

@@ -0,0 +1,40 @@
+package main
+
+import (
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/buzzer"
+)
+
+type note struct {
+	tone     float64
+	duration float64
+}
+
+func main() {
+	speaker := machine.PA30
+	speaker.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	speaker.Set(true)
+
+	bzrPin := machine.A0
+	bzrPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
+
+	bzr := buzzer.New(bzrPin)
+
+	song := []note{
+		{buzzer.C3, buzzer.Quarter},
+		{buzzer.D3, buzzer.Quarter},
+		{buzzer.E3, buzzer.Quarter},
+		{buzzer.F3, buzzer.Quarter},
+		{buzzer.G3, buzzer.Quarter},
+		{buzzer.A3, buzzer.Quarter},
+		{buzzer.B3, buzzer.Quarter},
+		{buzzer.C3, buzzer.Quarter},
+	}
+
+	for _, val := range song {
+		bzr.Tone(val.tone, val.duration)
+		time.Sleep(10 * time.Millisecond)
+	}
+}

examples/ds3231/main.go

@@ -38,7 +38,7 @@ func main() {
 			fmt.Printf("Date: %d/%s/%02d %02d:%02d:%02d \r\n", dt.Year(), dt.Month(), dt.Day(), dt.Hour(), dt.Minute(), dt.Second())
 		}
 		temp, _ := rtc.ReadTemperature()
-		fmt.Printf("Temperature: %.2f ºC \r\n", float32(temp)/1000)
+		fmt.Printf("Temperature: %.2f °C \r\n", float32(temp)/1000)
 
 		time.Sleep(time.Second * 1)
 	}

examples/easystepper/main.go

@@ -9,6 +9,7 @@ import (
 
 func main() {
 	motor := easystepper.New(machine.P13, machine.P15, machine.P14, machine.P16, 200, 75)
+	motor.Configure()
 
 	for {
 		println("CLOCKWISE")

examples/espat/espconsole/main.go

@@ -23,11 +23,12 @@ const actAsAP = false
 const ssid = "YOURSSID"
 const pass = "YOURPASS"
 
+// 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 (
 	uart = machine.UART1
-	tx   = machine.D10
-	rx   = machine.D11
+	tx   = machine.PA22
+	rx   = machine.PA23
 
 	console = machine.UART0
 
@@ -42,28 +43,20 @@ func main() {
 	adaptor.Configure()
 
 	// first check if connected
-	if adaptor.Connected() {
+	if connectToESP() {
+		println("Connected to wifi adaptor.")
 		adaptor.Echo(false)
-		console.Write([]byte("\r\n"))
-		console.Write([]byte("ESP-AT console enabled.\r\n"))
-		console.Write([]byte("Firmware version:\r\n"))
-		console.Write(adaptor.Version())
-		console.Write([]byte("\r\n"))
 
-		if actAsAP {
-			provideAP()
-		} else {
-			connectToAP()
-		}
-
-		console.Write([]byte("Type an AT command then press enter:\r\n"))
-		prompt()
+		connectToAP()
 	} else {
-		console.Write([]byte("\r\n"))
-		console.Write([]byte("Unable to connect to wifi adaptor.\r\n"))
+		println("")
+		failMessage("Unable to connect to wifi adaptor.")
 		return
 	}
 
+	println("Type an AT command then press enter:")
+	prompt()
+
 	input := make([]byte, 64)
 	i := 0
 	for {
@@ -80,11 +73,9 @@ func main() {
 				input[i+1] = byte('\n')
 				adaptor.Write(input[:i+2])
 
-				// give the ESP8266 a chance to respond.
-				time.Sleep(10 * time.Millisecond)
-
 				// display response
-				console.Write(adaptor.Response())
+				r, _ := adaptor.Response(500)
+				console.Write(r)
 
 				// prompt
 				prompt()
@@ -103,27 +94,50 @@ func main() {
 }
 
 func prompt() {
-	console.Write([]byte("ESPAT>"))
+	print("ESPAT>")
+}
+
+// connect to ESP8266/ESP32
+func connectToESP() bool {
+	for i := 0; i < 5; i++ {
+		println("Connecting to wifi adaptor...")
+		if adaptor.Connected() {
+			return true
+		}
+		time.Sleep(1 * time.Second)
+	}
+	return false
 }
 
 // connect to access point
 func connectToAP() {
-	console.Write([]byte("Connecting to wifi network...\r\n"))
+	println("Connecting to wifi network '" + ssid + "'")
+
 	adaptor.SetWifiMode(espat.WifiModeClient)
 	adaptor.ConnectToAP(ssid, pass, 10)
-	console.Write([]byte("Connected.\r\n"))
-	console.Write([]byte(adaptor.GetClientIP()))
-	console.Write([]byte("\r\n"))
+
+	println("Connected.")
+	ip, err := adaptor.GetClientIP()
+	if err != nil {
+		failMessage(err.Error())
+	}
+
+	println(ip)
 }
 
 // provide access point
 func provideAP() {
-	console.Write([]byte("Starting wifi network as access point '"))
-	console.Write([]byte(ssid))
-	console.Write([]byte("'...\r\n"))
+	println("Starting wifi network as access point '" + ssid + "'...")
 	adaptor.SetWifiMode(espat.WifiModeAP)
 	adaptor.SetAPConfig(ssid, pass, 7, espat.WifiAPSecurityWPA2_PSK)
-	console.Write([]byte("Ready.\r\n"))
-	console.Write([]byte(adaptor.GetAPIP()))
-	console.Write([]byte("\r\n"))
+	println("Ready.")
+	ip, _ := adaptor.GetAPIP()
+	println(ip)
+}
+
+func failMessage(msg string) {
+	for {
+		println(msg)
+		time.Sleep(1 * time.Second)
+	}
 }

examples/espat/esphub/main.go

@@ -11,6 +11,7 @@ import (
 	"time"
 
 	"tinygo.org/x/drivers/espat"
+	"tinygo.org/x/drivers/net"
 )
 
 // change actAsAP to true to act as an access point instead of connecting to one.
@@ -20,13 +21,12 @@ const actAsAP = false
 const ssid = "YOURSSID"
 const pass = "YOURPASS"
 
+// 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 (
 	uart = machine.UART1
-	tx   = machine.D10
-	rx   = machine.D11
-
-	console = machine.UART0
+	tx   = machine.PA22
+	rx   = machine.PA23
 
 	adaptor *espat.Device
 )
@@ -43,34 +43,29 @@ func main() {
 	readyled.High()
 
 	// first check if connected
-	if adaptor.Connected() {
-		console.Write([]byte("Connected to wifi adaptor.\r\n"))
+	if connectToESP() {
+		println("Connected to wifi adaptor.")
 		adaptor.Echo(false)
 
-		if actAsAP {
-			provideAP()
-		} else {
-			connectToAP()
-		}
+		connectToAP()
 	} else {
-		console.Write([]byte("\r\n"))
-		console.Write([]byte("Unable to connect to wifi adaptor.\r\n"))
+		println("")
+		failMessage("Unable to connect to wifi adaptor.")
 		return
 	}
 
 	// now make UDP connection
-	laddr := &espat.UDPAddr{Port: 2222}
-	console.Write([]byte("Loading UDP listener...\r\n"))
-	conn, _ := adaptor.ListenUDP("UDP", laddr)
+	laddr := &net.UDPAddr{Port: 2222}
+	println("Loading UDP listener...")
+	conn, _ := net.ListenUDP("UDP", laddr)
 
-	console.Write([]byte("Waiting for data...\r\n"))
+	println("Waiting for data...")
 	data := make([]byte, 50)
 	blink := true
 	for {
 		n, _ := conn.Read(data)
 		if n > 0 {
-			console.Write(data[:n])
-			console.Write([]byte("\r\n"))
+			println(string(data[:n]))
 			conn.Write([]byte("hello back\r\n"))
 		}
 		blink = !blink
@@ -83,29 +78,52 @@ func main() {
 	}
 
 	// Right now this code is never reached. Need a way to trigger it...
-	console.Write([]byte("Disconnecting UDP...\r\n"))
+	println("Disconnecting UDP...")
 	conn.Close()
-	console.Write([]byte("Done.\r\n"))
+	println("Done.")
+}
+
+// connect to ESP8266/ESP32
+func connectToESP() bool {
+	for i := 0; i < 5; i++ {
+		println("Connecting to wifi adaptor...")
+		if adaptor.Connected() {
+			return true
+		}
+		time.Sleep(1 * time.Second)
+	}
+	return false
 }
 
 // connect to access point
 func connectToAP() {
-	console.Write([]byte("Connecting to wifi network...\r\n"))
+	println("Connecting to wifi network '" + ssid + "'")
+
 	adaptor.SetWifiMode(espat.WifiModeClient)
 	adaptor.ConnectToAP(ssid, pass, 10)
-	console.Write([]byte("Connected.\r\n"))
-	console.Write([]byte(adaptor.GetClientIP()))
-	console.Write([]byte("\r\n"))
+
+	println("Connected.")
+	ip, err := adaptor.GetClientIP()
+	if err != nil {
+		failMessage(err.Error())
+	}
+
+	println(ip)
 }
 
 // provide access point
 func provideAP() {
-	console.Write([]byte("Starting wifi network as access point '"))
-	console.Write([]byte(ssid))
-	console.Write([]byte("'...\r\n"))
+	println("Starting wifi network as access point '" + ssid + "'...")
 	adaptor.SetWifiMode(espat.WifiModeAP)
 	adaptor.SetAPConfig(ssid, pass, 7, espat.WifiAPSecurityWPA2_PSK)
-	console.Write([]byte("Ready.\r\n"))
-	console.Write([]byte(adaptor.GetAPIP()))
-	console.Write([]byte("\r\n"))
+	println("Ready.")
+	ip, _ := adaptor.GetAPIP()
+	println(ip)
+}
+
+func failMessage(msg string) {
+	for {
+		println(msg)
+		time.Sleep(1 * time.Second)
+	}
 }

examples/espat/espstation/main.go

@@ -11,6 +11,7 @@ import (
 	"time"
 
 	"tinygo.org/x/drivers/espat"
+	"tinygo.org/x/drivers/net"
 )
 
 // access point info
@@ -20,13 +21,12 @@ const pass = "YOURPASS"
 // IP address of the listener aka "hub". Replace with your own info.
 const hubIP = "0.0.0.0"
 
+// 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 (
 	uart = machine.UART1
-	tx   = machine.D10
-	rx   = machine.D11
-
-	console = machine.UART0
+	tx   = machine.PA22
+	rx   = machine.PA23
 
 	adaptor *espat.Device
 )
@@ -39,45 +39,70 @@ func main() {
 	adaptor.Configure()
 
 	// first check if connected
-	if adaptor.Connected() {
-		console.Write([]byte("Connected to wifi adaptor.\r\n"))
+	if connectToESP() {
+		println("Connected to wifi adaptor.")
 		adaptor.Echo(false)
 
 		connectToAP()
 	} else {
-		console.Write([]byte("\r\n"))
-		console.Write([]byte("Unable to connect to wifi adaptor.\r\n"))
+		println("")
+		failMessage("Unable to connect to wifi adaptor.")
 		return
 	}
 
 	// now make UDP connection
-	ip := espat.ParseIP(hubIP)
-	raddr := &espat.UDPAddr{IP: ip, Port: 2222}
-	laddr := &espat.UDPAddr{Port: 2222}
+	ip := net.ParseIP(hubIP)
+	raddr := &net.UDPAddr{IP: ip, Port: 2222}
+	laddr := &net.UDPAddr{Port: 2222}
 
-	console.Write([]byte("Dialing UDP connection...\r\n"))
-	conn, _ := adaptor.DialUDP("udp", laddr, raddr)
+	println("Dialing UDP connection...")
+	conn, _ := net.DialUDP("udp", laddr, raddr)
 
 	for {
 		// send data
-		console.Write([]byte("Sending data...\r\n"))
+		println("Sending data...")
 		conn.Write([]byte("hello\r\n"))
 
 		time.Sleep(1000 * time.Millisecond)
 	}
 
 	// Right now this code is never reached. Need a way to trigger it...
-	console.Write([]byte("Disconnecting UDP...\r\n"))
+	println("Disconnecting UDP...")
 	conn.Close()
-	console.Write([]byte("Done.\r\n"))
+	println("Done.")
+}
+
+// connect to ESP8266/ESP32
+func connectToESP() bool {
+	for i := 0; i < 5; i++ {
+		println("Connecting to wifi adaptor...")
+		if adaptor.Connected() {
+			return true
+		}
+		time.Sleep(1 * time.Second)
+	}
+	return false
 }
 
 // connect to access point
 func connectToAP() {
-	console.Write([]byte("Connecting to wifi network...\r\n"))
+	println("Connecting to wifi network '" + ssid + "'")
+
 	adaptor.SetWifiMode(espat.WifiModeClient)
 	adaptor.ConnectToAP(ssid, pass, 10)
-	console.Write([]byte("Connected.\r\n"))
-	console.Write([]byte(adaptor.GetClientIP()))
-	console.Write([]byte("\r\n"))
+
+	println("Connected.")
+	ip, err := adaptor.GetClientIP()
+	if err != nil {
+		failMessage(err.Error())
+	}
+
+	println(ip)
+}
+
+func failMessage(msg string) {
+	for {
+		println(msg)
+		time.Sleep(1 * time.Second)
+	}
 }

examples/espat/mqttclient/main.go

@@ -0,0 +1,142 @@
+// This is a sensor station that uses a ESP8266 or ESP32 running on the device UART1.
+// It creates an MQTT connection that publishes a message every second
+// to an MQTT broker.
+//
+// In other words:
+// Your computer <--> UART0 <--> MCU <--> UART1 <--> ESP8266 <--> Internet <--> MQTT broker.
+//
+// You must install the Paho MQTT package to build this program:
+//
+// 		go get -u github.com/eclipse/paho.mqtt.golang
+//
+package main
+
+import (
+	"machine"
+	"math/rand"
+	"time"
+
+	"tinygo.org/x/drivers/espat"
+	"tinygo.org/x/drivers/net/mqtt"
+)
+
+// access point info
+const ssid = "YOURSSID"
+const pass = "YOURPASS"
+
+// IP address of the MQTT broker to use. Replace with your own info.
+const server = "tcp://test.mosquitto.org:1883"
+
+//const server = "ssl://test.mosquitto.org:8883"
+
+// 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 (
+	uart = machine.UART2
+	tx   = machine.PA22
+	rx   = machine.PA23
+
+	console = machine.UART0
+
+	adaptor *espat.Device
+	topic   = "tinygo"
+)
+
+func main() {
+	time.Sleep(3000 * time.Millisecond)
+
+	uart.Configure(machine.UARTConfig{TX: tx, RX: rx})
+	rand.Seed(time.Now().UnixNano())
+
+	// Init esp8266/esp32
+	adaptor = espat.New(uart)
+	adaptor.Configure()
+
+	// first check if connected
+	if connectToESP() {
+		println("Connected to wifi adaptor.")
+		adaptor.Echo(false)
+
+		connectToAP()
+	} else {
+		println("")
+		failMessage("Unable to connect to wifi adaptor.")
+		return
+	}
+
+	opts := mqtt.NewClientOptions()
+	opts.AddBroker(server).SetClientID("tinygo-client-" + randomString(10))
+
+	println("Connecting to MQTT broker at", server)
+	cl := mqtt.NewClient(opts)
+	if token := cl.Connect(); token.Wait() && token.Error() != nil {
+		failMessage(token.Error().Error())
+	}
+
+	for {
+		println("Publishing MQTT message...")
+		data := []byte("{\"e\":[{ \"n\":\"hello\", \"v\":101 }]}")
+		token := cl.Publish(topic, 0, false, data)
+		token.Wait()
+		if token.Error() != nil {
+			println(token.Error().Error())
+		}
+
+		time.Sleep(1000 * time.Millisecond)
+	}
+
+	// Right now this code is never reached. Need a way to trigger it...
+	println("Disconnecting MQTT...")
+	cl.Disconnect(100)
+
+	println("Done.")
+}
+
+// connect to ESP8266/ESP32
+func connectToESP() bool {
+	for i := 0; i < 5; i++ {
+		println("Connecting to wifi adaptor...")
+		if adaptor.Connected() {
+			return true
+		}
+		time.Sleep(1 * time.Second)
+	}
+	return false
+}
+
+// connect to access point
+func connectToAP() {
+	println("Connecting to wifi network '" + ssid + "'")
+
+	adaptor.SetWifiMode(espat.WifiModeClient)
+	adaptor.ConnectToAP(ssid, pass, 10)
+
+	println("Connected.")
+	ip, err := adaptor.GetClientIP()
+	if err != nil {
+		failMessage(err.Error())
+	}
+
+	println(ip)
+}
+
+// Returns an int >= min, < max
+func randomInt(min, max int) int {
+	return min + rand.Intn(max-min)
+}
+
+// Generate a random string of A-Z chars with len = l
+func randomString(len int) string {
+	bytes := make([]byte, len)
+	for i := 0; i < len; i++ {
+		bytes[i] = byte(randomInt(65, 90))
+	}
+	return string(bytes)
+}
+
+func failMessage(msg string) {
+	for {
+		println(msg)
+		time.Sleep(1 * time.Second)
+	}
+}

examples/espat/mqttsub/main.go

@@ -0,0 +1,163 @@
+// This is a sensor station that uses a ESP8266 or ESP32 running on the device UART1.
+// It creates an MQTT connection that publishes a message every second
+// to an MQTT broker.
+//
+// In other words:
+// Your computer <--> UART0 <--> MCU <--> UART1 <--> ESP8266 <--> Internet <--> MQTT broker.
+//
+// You must also install the Paho MQTT package to build this program:
+//
+// 		go get -u github.com/eclipse/paho.mqtt.golang
+//
+package main
+
+import (
+	"fmt"
+	"machine"
+	"math/rand"
+	"time"
+
+	"tinygo.org/x/drivers/espat"
+	"tinygo.org/x/drivers/net/mqtt"
+)
+
+// access point info
+const ssid = "YOURSSID"
+const pass = "YOURPASS"
+
+// IP address of the MQTT broker to use. Replace with your own info.
+//const server = "tcp://test.mosquitto.org:1883"
+
+const server = "ssl://test.mosquitto.org:8883"
+
+// change these to connect to a different UART or pins for the ESP8266/ESP32
+var (
+	// these are defaults for the Arduino Nano33 IoT.
+	uart = machine.UART1
+	tx   = machine.PA22
+	rx   = machine.PA23
+
+	console = machine.UART0
+
+	adaptor *espat.Device
+	cl      mqtt.Client
+	topicTx = "tinygo/tx"
+	topicRx = "tinygo/rx"
+)
+
+func subHandler(client mqtt.Client, msg mqtt.Message) {
+	fmt.Printf("[%s]  ", msg.Topic())
+	fmt.Printf("%s\r\n", msg.Payload())
+}
+
+func main() {
+	time.Sleep(3000 * time.Millisecond)
+
+	uart.Configure(machine.UARTConfig{TX: tx, RX: rx})
+	rand.Seed(time.Now().UnixNano())
+
+	// Init esp8266/esp32
+	adaptor = espat.New(uart)
+	adaptor.Configure()
+
+	// first check if connected
+	if connectToESP() {
+		println("Connected to wifi adaptor.")
+		adaptor.Echo(false)
+
+		connectToAP()
+	} else {
+		println("")
+		failMessage("Unable to connect to wifi adaptor.")
+		return
+	}
+
+	opts := mqtt.NewClientOptions()
+	opts.AddBroker(server).SetClientID("tinygo-client-" + randomString(10))
+
+	println("Connecting to MQTT broker at", server)
+	cl = mqtt.NewClient(opts)
+	if token := cl.Connect(); token.Wait() && token.Error() != nil {
+		failMessage(token.Error().Error())
+	}
+
+	// subscribe
+	token := cl.Subscribe(topicRx, 0, subHandler)
+	token.Wait()
+	if token.Error() != nil {
+		failMessage(token.Error().Error())
+	}
+
+	go publishing()
+
+	select {}
+
+	// Right now this code is never reached. Need a way to trigger it...
+	println("Disconnecting MQTT...")
+	cl.Disconnect(100)
+
+	println("Done.")
+}
+
+func publishing() {
+	for {
+		println("Publishing MQTT message...")
+		data := []byte("{\"e\":[{ \"n\":\"hello\", \"v\":101 }]}")
+		token := cl.Publish(topicTx, 0, false, data)
+		token.Wait()
+		if token.Error() != nil {
+			println(token.Error().Error())
+		}
+
+		time.Sleep(1000 * time.Millisecond)
+	}
+}
+
+// connect to ESP8266/ESP32
+func connectToESP() bool {
+	for i := 0; i < 5; i++ {
+		println("Connecting to wifi adaptor...")
+		if adaptor.Connected() {
+			return true
+		}
+		time.Sleep(1 * time.Second)
+	}
+	return false
+}
+
+// connect to access point
+func connectToAP() {
+	println("Connecting to wifi network '" + ssid + "'")
+
+	adaptor.SetWifiMode(espat.WifiModeClient)
+	adaptor.ConnectToAP(ssid, pass, 10)
+
+	println("Connected.")
+	ip, err := adaptor.GetClientIP()
+	if err != nil {
+		failMessage(err.Error())
+	}
+
+	println(ip)
+}
+
+// Returns an int >= min, < max
+func randomInt(min, max int) int {
+	return min + rand.Intn(max-min)
+}
+
+// Generate a random string of A-Z chars with len = l
+func randomString(len int) string {
+	bytes := make([]byte, len)
+	for i := 0; i < len; i++ {
+		bytes[i] = byte(randomInt(65, 90))
+	}
+	return string(bytes)
+}
+
+func failMessage(msg string) {
+	for {
+		println(msg)
+		time.Sleep(1 * time.Second)
+	}
+}

examples/espat/tcpclient/main.go

@@ -0,0 +1,111 @@
+// This is a sensor station that uses a ESP8266 or ESP32 running on the device UART1.
+// 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 <--> UART1 <--> ESP8266
+//
+package main
+
+import (
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/espat"
+	"tinygo.org/x/drivers/net"
+)
+
+// access point info
+const ssid = "YOURSSID"
+const pass = "YOURPASS"
+
+// IP address of the server aka "hub". Replace with your own info.
+const serverIP = "0.0.0.0"
+
+// 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 (
+	uart = machine.UART1
+	tx   = machine.PA22
+	rx   = machine.PA23
+
+	adaptor *espat.Device
+)
+
+func main() {
+	uart.Configure(machine.UARTConfig{TX: tx, RX: rx})
+
+	// Init esp8266/esp32
+	adaptor = espat.New(uart)
+	adaptor.Configure()
+
+	// first check if connected
+	if connectToESP() {
+		println("Connected to wifi adaptor.")
+		adaptor.Echo(false)
+
+		connectToAP()
+	} else {
+		println("")
+		failMessage("Unable to connect to wifi adaptor.")
+		return
+	}
+
+	// now make TCP connection
+	ip := net.ParseIP(serverIP)
+	raddr := &net.TCPAddr{IP: ip, Port: 8080}
+	laddr := &net.TCPAddr{Port: 8080}
+
+	println("Dialing TCP connection...")
+	conn, err := net.DialTCP("tcp", laddr, raddr)
+	if err != nil {
+		failMessage(err.Error())
+	}
+
+	for {
+		// send data
+		println("Sending data...")
+		conn.Write([]byte("hello\r\n"))
+
+		time.Sleep(1000 * time.Millisecond)
+	}
+
+	// Right now this code is never reached. Need a way to trigger it...
+	println("Disconnecting TCP...")
+	conn.Close()
+	println("Done.")
+}
+
+// connect to ESP8266/ESP32
+func connectToESP() bool {
+	for i := 0; i < 5; i++ {
+		println("Connecting to wifi adaptor...")
+		if adaptor.Connected() {
+			return true
+		}
+		time.Sleep(1 * time.Second)
+	}
+	return false
+}
+
+// connect to access point
+func connectToAP() {
+	println("Connecting to wifi network '" + ssid + "'")
+
+	adaptor.SetWifiMode(espat.WifiModeClient)
+	adaptor.ConnectToAP(ssid, pass, 10)
+
+	println("Connected.")
+	ip, err := adaptor.GetClientIP()
+	if err != nil {
+		failMessage(err.Error())
+	}
+
+	println(ip)
+}
+
+func failMessage(msg string) {
+	for {
+		println(msg)
+		time.Sleep(1 * 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"
+
+	"tinygo.org/x/drivers/examples/flash/console"
+	"tinygo.org/x/drivers/flash"
+)
+
+func main() {
+	console_example.RunFor(
+		flash.NewSPI(
+			&machine.SPI1,
+			machine.SPI1_MOSI_PIN,
+			machine.SPI1_MISO_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/ili9341/basic/main.go

@@ -0,0 +1,47 @@
+package main
+
+import (
+	"image/color"
+	"machine"
+	"time"
+
+	"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,
+	)
+
+	black = color.RGBA{0, 0, 0, 255}
+	white = color.RGBA{255, 255, 255, 255}
+	red   = color.RGBA{255, 0, 0, 255}
+	blue  = color.RGBA{0, 0, 255, 255}
+	green = color.RGBA{0, 255, 0, 255}
+)
+
+func main() {
+
+	machine.TFT_BACKLIGHT.Configure(machine.PinConfig{machine.PinOutput})
+
+	display.Configure(ili9341.Config{})
+	width, height := display.Size()
+
+	display.FillScreen(black)
+	machine.TFT_BACKLIGHT.High()
+
+	display.FillRectangle(0, 0, width/2, height/2, white)
+	display.FillRectangle(width/2, 0, width/2, height/2, red)
+	display.FillRectangle(0, height/2, width/2, height/2, green)
+	display.FillRectangle(width/2, height/2, width/2, height/2, blue)
+	display.FillRectangle(width/4, height/4, width/2, height/2, black)
+	for {
+		time.Sleep(time.Hour)
+	}
+
+}

examples/ili9341/pyportal_boing/main.go

@@ -0,0 +1,234 @@
+// Port of Adafruit's "pyportal_boing" demo found here:
+// https://github.com/adafruit/Adafruit_ILI9341/blob/master/examples/pyportal_boing
+package main
+
+import (
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/examples/ili9341/pyportal_boing/graphics"
+	"tinygo.org/x/drivers/ili9341"
+)
+
+const (
+	BGCOLOR    = 0xAD75
+	GRIDCOLOR  = 0xA815
+	BGSHADOW   = 0x5285
+	GRIDSHADOW = 0x600C
+	RED        = 0xF800
+	WHITE      = 0xFFFF
+
+	YBOTTOM = 123  // Ball Y coord at bottom
+	YBOUNCE = -3.5 // Upward velocity on ball bounce
+
+	_debug = false
+)
+
+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
+	frame     int64
+
+	// Ball coordinates are stored floating-point because screen refresh
+	// is so quick, whole-pixel movements are just too fast!
+	ballx     float32
+	bally     float32
+	ballvx    float32
+	ballvy    float32
+	ballframe float32
+	balloldx  float32
+	balloldy  float32
+
+	// Color table for ball rotation effect
+	palette [16]uint16
+)
+
+func main() {
+
+	// configure backlight
+	machine.TFT_BACKLIGHT.Configure(machine.PinConfig{machine.PinOutput})
+
+	// configure display
+	display.Configure(ili9341.Config{})
+	print("width, height == ")
+	width, height := display.Size()
+	println(width, height)
+
+	machine.TFT_BACKLIGHT.High()
+
+	display.SetRotation(ili9341.Rotation270)
+	DrawBackground()
+
+	startTime = time.Now().UnixNano()
+	frame = 0
+
+	ballx = 20.0
+	bally = YBOTTOM // Current ball position
+	ballvx = 0.8
+	ballvy = YBOUNCE // Ball velocity
+	ballframe = 3    // Ball animation frame #
+	balloldx = ballx
+	balloldy = bally // Prior ball position
+
+	for {
+
+		balloldx = ballx // Save prior position
+		balloldy = bally
+		ballx += ballvx // Update position
+		bally += ballvy
+		ballvy += 0.06 // Update Y velocity
+		if (ballx <= 15) || (ballx >= graphics.SCREENWIDTH-graphics.BALLWIDTH) {
+			ballvx *= -1 // Left/right bounce
+		}
+		if bally >= YBOTTOM { // Hit ground?
+			bally = YBOTTOM  // Clip and
+			ballvy = YBOUNCE // bounce up
+		}
+
+		// Determine screen area to update.  This is the bounds of the ball's
+		// prior and current positions, so the old ball is fully erased and new
+		// ball is fully drawn.
+		var minx, miny, maxx, maxy, width, height int16
+
+		// Determine bounds of prior and new positions
+		minx = int16(ballx)
+		if int16(balloldx) < minx {
+			minx = int16(balloldx)
+		}
+		miny = int16(bally)
+		if int16(balloldy) < miny {
+			miny = int16(balloldy)
+		}
+		maxx = int16(ballx + graphics.BALLWIDTH - 1)
+		if int16(balloldx+graphics.BALLWIDTH-1) > maxx {
+			maxx = int16(balloldx + graphics.BALLWIDTH - 1)
+		}
+		maxy = int16(bally + graphics.BALLHEIGHT - 1)
+		if int16(balloldy+graphics.BALLHEIGHT-1) > maxy {
+			maxy = int16(balloldy + graphics.BALLHEIGHT - 1)
+		}
+
+		width = maxx - minx + 1
+		height = maxy - miny + 1
+
+		// Ball animation frame # is incremented opposite the ball's X velocity
+		ballframe -= ballvx * 0.5
+		if ballframe < 0 {
+			ballframe += 14 // Constrain from 0 to 13
+		} else if ballframe >= 14 {
+			ballframe -= 14
+		}
+
+		// Set 7 palette entries to white, 7 to red, based on frame number.
+		// This makes the ball spin
+		for i := 0; i < 14; i++ {
+			if (int(ballframe)+i)%14 < 7 {
+				palette[i+2] = WHITE
+			} else {
+				palette[i+2] = RED
+			} // Palette entries 0 and 1 aren't used (clear and shadow, respectively)
+		}
+
+		// Only the changed rectangle is drawn into the 'renderbuf' array...
+		var c uint16              //, *destPtr;
+		bx := minx - int16(ballx) // X relative to ball bitmap (can be negative)
+		by := miny - int16(bally) // Y relative to ball bitmap (can be negative)
+		bgx := minx               // X relative to background bitmap (>= 0)
+		bgy := miny               // Y relative to background bitmap (>= 0)
+		var bx1, bgx1 int16       // Loop counters and working vars
+		var p uint8               // 'packed' value of 2 ball pixels
+		var bufIdx int8 = 0
+
+		//tft.setAddrWindow(minx, miny, width, height)
+
+		for y := 0; y < int(height); y++ { // For each row...
+			//destPtr = &renderbuf[bufIdx][0];
+			bx1 = bx   // Need to keep the original bx and bgx values,
+			bgx1 = bgx // so copies of them are made here (and changed in loop below)
+			for x := 0; x < int(width); x++ {
+				var bgidx = int(bgy)*(graphics.SCREENWIDTH/8) + int(bgx1/8)
+				if (bx1 >= 0) && (bx1 < graphics.BALLWIDTH) && // Is current pixel row/column
+					(by >= 0) && (by < graphics.BALLHEIGHT) { // inside the ball bitmap area?
+					// Yes, do ball compositing math...
+					p = graphics.Ball[int(by*(graphics.BALLWIDTH/2))+int(bx1/2)] // Get packed value (2 pixels)
+					if (bx1 & 1) != 0 {
+						c = uint16(p & 0xF)
+					} else {
+						c = uint16(p >> 4)
+					} // Unpack high or low nybble
+					if c == 0 { // Outside ball - just draw grid
+						if graphics.Background[bgidx]&(0x80>>(bgx1&7)) != 0 {
+							c = GRIDCOLOR
+						} else {
+							c = BGCOLOR
+						}
+					} else if c > 1 { // In ball area...
+						c = palette[c]
+					} else { // In shadow area...
+						if graphics.Background[bgidx]&(0x80>>(bgx1&7)) != 0 {
+							c = GRIDSHADOW
+						} else {
+							c = BGSHADOW
+						}
+					}
+				} else { // Outside ball bitmap, just draw background bitmap...
+					if graphics.Background[bgidx]&(0x80>>(bgx1&7)) != 0 {
+						c = GRIDCOLOR
+					} else {
+						c = BGCOLOR
+					}
+				}
+				frameBuffer[y*int(width)+x] = c
+				bx1++ // Increment bitmap position counters (X axis)
+				bgx1++
+			}
+			//tft.dmaWait(); // Wait for prior line to complete
+			//tft.writePixels(&renderbuf[bufIdx][0], width, false); // Non-blocking write
+			bufIdx = 1 - bufIdx
+			by++ // Increment bitmap position counters (Y axis)
+			bgy++
+		}
+
+		display.DrawRGBBitmap(minx, miny, frameBuffer[:width*height], width, height)
+
+		// Show approximate frame rate
+		frame++
+		if frame&255 == 0 { // Every 256 frames...
+			elapsed := (time.Now().UnixNano() - startTime) / int64(time.Second)
+			if elapsed > 0 {
+				println(frame/elapsed, " fps")
+			}
+		}
+	}
+}
+
+func DrawBackground() {
+	w, h := display.Size()
+	byteWidth := (w + 7) / 8 // Bitmap scanline pad = whole byte
+	var b uint8
+	for j := int16(0); j < h; j++ {
+		for k := int16(0); k < w; k++ {
+			if k&7 > 0 {
+				b <<= 1
+			} else {
+				b = graphics.Background[j*byteWidth+k/8]
+			}
+			if b&0x80 == 0 {
+				frameBuffer[k] = BGCOLOR
+			} else {
+				frameBuffer[k] = GRIDCOLOR
+			}
+		}
+		display.DrawRGBBitmap(0, j, frameBuffer[0:w], w, 1)
+	}
+}

examples/ili9341/scroll/main.go

@@ -0,0 +1,49 @@
+package main
+
+import (
+	"image/color"
+	"machine"
+	"time"
+
+	"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,
+	)
+
+	red   = color.RGBA{255, 0, 0, 255}
+	blue  = color.RGBA{0, 0, 255, 255}
+	green = color.RGBA{0, 255, 0, 255}
+	black = color.RGBA{0, 0, 0, 255}
+	white = color.RGBA{255, 255, 255, 255}
+)
+
+func main() {
+
+	machine.TFT_BACKLIGHT.Configure(machine.PinConfig{machine.PinOutput})
+
+	display.Configure(ili9341.Config{})
+	width, height := display.Size()
+
+	display.FillScreen(black)
+	machine.TFT_BACKLIGHT.High()
+
+	display.FillRectangle(0, 0, width/2, height/2, white)
+	display.FillRectangle(width/2, 0, width/2, height/2, red)
+	display.FillRectangle(0, height/2, width/2, height/2, green)
+	display.FillRectangle(width/2, height/2, width/2, height/2, blue)
+	display.FillRectangle(width/4, height/4, width/2, height/2, black)
+
+	for scroll := int16(0); ; scroll = (scroll + 1) % 320 {
+		time.Sleep(7500 * time.Microsecond)
+		display.SetScroll(scroll)
+	}
+
+}

examples/l293x/simple/main.go

@@ -0,0 +1,34 @@
+package main
+
+import (
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/l293x"
+)
+
+func main() {
+	wheel := l293x.New(machine.D10, machine.D11, machine.D12)
+	wheel.Configure()
+
+	for i := 0; i <= 10; i++ {
+		println("Forward")
+		wheel.Forward()
+		time.Sleep(time.Millisecond * 1000)
+
+		println("Stop")
+		wheel.Stop()
+		time.Sleep(time.Millisecond * 1000)
+
+		println("Backward")
+		wheel.Backward()
+		time.Sleep(time.Millisecond * 1000)
+
+		println("Stop")
+		wheel.Stop()
+		time.Sleep(time.Millisecond * 1000)
+	}
+
+	println("Stop")
+	wheel.Stop()
+}

examples/l293x/speed/main.go

@@ -0,0 +1,45 @@
+package main
+
+import (
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/l293x"
+)
+
+const (
+	maxSpeed = 30000
+)
+
+func main() {
+	machine.InitPWM()
+
+	wheel := l293x.NewWithSpeed(machine.D10, machine.D11, machine.PWM{machine.D12})
+	wheel.Configure()
+
+	for i := 0; i <= 10; i++ {
+		println("Forward")
+		var i uint16
+		for i = 0; i < maxSpeed; i += 1000 {
+			wheel.Forward(i)
+			time.Sleep(time.Millisecond * 100)
+		}
+
+		println("Stop")
+		wheel.Stop()
+		time.Sleep(time.Millisecond * 1000)
+
+		println("Backward")
+		for i = 0; i < maxSpeed; i += 1000 {
+			wheel.Backward(i)
+			time.Sleep(time.Millisecond * 100)
+		}
+
+		println("Stop")
+		wheel.Stop()
+		time.Sleep(time.Millisecond * 1000)
+	}
+
+	println("Stop")
+	wheel.Stop()
+}

examples/l9110x/simple/main.go

@@ -0,0 +1,34 @@
+package main
+
+import (
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/l9110x"
+)
+
+func main() {
+	wheel := l9110x.New(machine.D10, machine.D11)
+	wheel.Configure()
+
+	for i := 0; i <= 10; i++ {
+		println("Forward")
+		wheel.Forward()
+		time.Sleep(time.Millisecond * 1000)
+
+		println("Stop")
+		wheel.Stop()
+		time.Sleep(time.Millisecond * 1000)
+
+		println("Backward")
+		wheel.Backward()
+		time.Sleep(time.Millisecond * 1000)
+
+		println("Stop")
+		wheel.Stop()
+		time.Sleep(time.Millisecond * 1000)
+	}
+
+	println("Stop")
+	wheel.Stop()
+}

examples/l9110x/speed/main.go

@@ -0,0 +1,45 @@
+package main
+
+import (
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/l9110x"
+)
+
+const (
+	maxSpeed = 30000
+)
+
+func main() {
+	machine.InitPWM()
+
+	wheel := l9110x.NewWithSpeed(machine.PWM{machine.D11}, machine.PWM{machine.D12})
+	wheel.Configure()
+
+	for i := 0; i <= 10; i++ {
+		println("Forward")
+		var i uint16
+		for i = 0; i < maxSpeed; i += 1000 {
+			wheel.Forward(i)
+			time.Sleep(time.Millisecond * 100)
+		}
+
+		println("Stop")
+		wheel.Stop()
+		time.Sleep(time.Millisecond * 1000)
+
+		println("Backward")
+		for i = 0; i < maxSpeed; i += 1000 {
+			wheel.Backward(i)
+			time.Sleep(time.Millisecond * 100)
+		}
+
+		println("Stop")
+		wheel.Stop()
+		time.Sleep(time.Millisecond * 1000)
+	}
+
+	println("Stop")
+	wheel.Stop()
+}

examples/lis3dh/main.go

@@ -11,7 +11,7 @@ import (
 var i2c = machine.I2C1
 
 func main() {
-	i2c.Configure(machine.I2CConfig{})
+	i2c.Configure(machine.I2CConfig{SCL: machine.SCL1_PIN, SDA: machine.SDA1_PIN})
 
 	accel := lis3dh.New(i2c)
 	accel.Address = lis3dh.Address1 // address on the Circuit Playground Express

examples/lsm6ds3/main.go

@@ -0,0 +1,30 @@
+// Connects to an LSM6DS3 I2C a 6 axis Inertial Measurement Unit (IMU)
+package main
+
+import (
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/lsm6ds3"
+)
+
+func main() {
+	machine.I2C0.Configure(machine.I2CConfig{})
+
+	accel := lsm6ds3.New(machine.I2C0)
+	accel.Configure(lsm6ds3.Configuration{})
+	if !accel.Connected() {
+		println("LSM6DS3 not connected")
+		return
+	}
+
+	for {
+		x, y, z := accel.ReadAcceleration()
+		println("Acceleration:", float32(x)/1000000, float32(y)/1000000, float32(z)/1000000)
+		x, y, z = accel.ReadRotation()
+		println("Gyroscope:", float32(x)/1000000, float32(y)/1000000, float32(z)/1000000)
+		x, _ = accel.ReadTemperature()
+		println("Degrees C", float32(x)/1000, "\n\n")
+		time.Sleep(time.Millisecond * 1000)
+	}
+}

examples/mag3110/main.go

@@ -19,7 +19,7 @@ func main() {
 		println("Magnetic readings:", x, y, z)
 
 		c, _ := mag.ReadTemperature()
-		println("Temperature:", float32(c)/1000, "ºC")
+		println("Temperature:", float32(c)/1000, "°C")
 
 		time.Sleep(time.Millisecond * 100)
 	}

examples/mcp3008/main.go

@@ -0,0 +1,32 @@
+// Connects to a MCP3008 ADC via SPI.
+package main
+
+import (
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/mcp3008"
+)
+
+var (
+	spi   = machine.SPI0
+	csPin = machine.D12
+)
+
+func main() {
+	spi.Configure(machine.SPIConfig{
+		Frequency: 4000000,
+		Mode:      3})
+
+	adc := mcp3008.New(spi, csPin)
+	adc.Configure()
+
+	// get "CH0" aka "machine.ADC" interface to channel 0 from ADC.
+	p := adc.CH0
+
+	for {
+		val := p.Get()
+		println(val)
+		time.Sleep(50 * time.Millisecond)
+	}
+}

examples/microphone/main.go

@@ -0,0 +1,37 @@
+// Example using the i2s hardware interface on the Adafruit Circuit Playground Express
+// to read data from the onboard MEMS microphone.
+//
+// Uses ideas from the https://github.com/adafruit/Adafruit_CircuitPlayground repo.
+//
+package main
+
+import (
+	"machine"
+
+	"tinygo.org/x/drivers/microphone"
+)
+
+const (
+	defaultSampleRate        = 22000
+	quantizeSteps            = 64
+	msForSPLSample           = 50
+	defaultSampleCountForSPL = (defaultSampleRate / 1000) * msForSPLSample
+)
+
+func main() {
+	machine.I2S0.Configure(machine.I2SConfig{
+		Mode:           machine.I2SModePDM,
+		AudioFrequency: defaultSampleRate * quantizeSteps / 16,
+		ClockSource:    machine.I2SClockSourceExternal,
+		Stereo:         true,
+	})
+
+	mic := microphone.New(machine.I2S0)
+	mic.SampleCountForSPL = defaultSampleCountForSPL
+	mic.Configure()
+
+	for {
+		spl, maxval := mic.GetSoundPressure()
+		println("C", spl, "max", maxval)
+	}
+}

examples/semihosting/semihosting.go

@@ -0,0 +1,23 @@
+package main
+
+// A small example that demonstrates how SemiHosting can be used.
+// You could use it with a board that supports GDB, such as the BBC micro:bit:
+// 1. Compile and debug it:
+//      tinygo gdb -target=microbit -ocd-output tinygo.org/x/drivers/examples/semihosting
+// 2. Enable semihosting in the GDB shell:
+//      monitor arm semihosting enable
+// 3. Start the program:
+//      continue
+
+import (
+	"time"
+
+	"tinygo.org/x/drivers/semihosting"
+)
+
+func main() {
+	for {
+		semihosting.Stdout.Write([]byte("hello world!\n"))
+		time.Sleep(time.Second)
+	}
+}

examples/shifter/main.go

@@ -0,0 +1,44 @@
+// This example is designed to implement the button shifter for a PyBadge.
+package main
+
+import (
+	"time"
+
+	"tinygo.org/x/drivers/shifter"
+)
+
+func main() {
+	buttons := shifter.NewButtons()
+	buttons.Configure()
+
+	for {
+		// Update the pins state, to later be returned by .Get()
+		buttons.ReadInput()
+
+		if buttons.Pins[shifter.BUTTON_LEFT].Get() {
+			println("Button LEFT pressed")
+		}
+		if buttons.Pins[shifter.BUTTON_UP].Get() {
+			println("Button UP pressed")
+		}
+		if buttons.Pins[shifter.BUTTON_DOWN].Get() {
+			println("Button DOWN pressed")
+		}
+		if buttons.Pins[shifter.BUTTON_RIGHT].Get() {
+			println("Button RIGHT pressed")
+		}
+		if buttons.Pins[shifter.BUTTON_SELECT].Get() {
+			println("Button SELECT pressed")
+		}
+		if buttons.Pins[shifter.BUTTON_START].Get() {
+			println("Button START pressed")
+		}
+		if buttons.Pins[shifter.BUTTON_A].Get() {
+			println("Button A pressed")
+		}
+		if buttons.Pins[shifter.BUTTON_B].Get() {
+			println("Button B pressed")
+		}
+		time.Sleep(100 * time.Millisecond)
+	}
+}

examples/shiftregister/main.go

@@ -0,0 +1,124 @@
+package main
+
+import (
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/shiftregister"
+)
+
+func main() {
+	d := shiftregister.New(
+		shiftregister.EIGHT_BITS,
+		machine.PA6, // D12 Pin latch connected to ST_CP of 74HC595 (12)
+		machine.PA7, // D11 Pin clock connected to SH_CP of 74HC595 (11)
+		machine.PB6, // D10 Pin data connected to DS of 74HC595 (14)
+	)
+	d.Configure()
+
+	for {
+
+		// Examples using masks. This method writes all pins state at once.
+
+		// All pins High
+		d.WriteMask(0xFF)
+		delay()
+
+		// All pins Low
+		d.WriteMask(0x00)
+		delay()
+
+		// Some fun with masks
+		for _, pattern := range patterns {
+			d.WriteMask(pattern)
+			shortDelay()
+		}
+		delay()
+		d.WriteMask(0x00)
+
+		// Examples using individually addressable pin API. This method is slower than using mask
+		// because all register's pins state are send for is p.Set() call.
+
+		// Set register's pin #4
+		d.GetShiftPin(4).High()
+		delay()
+		d.GetShiftPin(4).Low()
+		delay()
+
+		// Get an individual pin and use it
+		pin := d.GetShiftPin(7)
+		pin.High()
+		delay()
+		pin.Low()
+		delay()
+
+		// Prepare an array of pin attached to the register
+		pins := [8]*shiftregister.ShiftPin{}
+		for p := 0; p < 8; p++ {
+			pins[p] = d.GetShiftPin(p)
+		}
+
+		for p := 7; p >= 0; p-- {
+			pins[p].Low()
+			shortDelay()
+			pins[p].High()
+		}
+
+		for p := 7; p >= 0; p-- {
+			pins[p].High()
+			time.Sleep(100 * time.Millisecond)
+			pins[p].Low()
+		}
+		delay()
+	}
+}
+
+func delay() {
+	time.Sleep(500 * time.Millisecond)
+}
+func shortDelay() {
+	time.Sleep(100 * time.Millisecond)
+}
+
+var patterns = []uint32{
+	0b00000001,
+	0b00000010,
+	0b00000100,
+	0b00001000,
+	0b00010000,
+	0b00100000,
+	0b01000000,
+	0b10000000,
+	0b10000001,
+	0b10000010,
+	0b10000100,
+	0b10001000,
+	0b10010000,
+	0b10100000,
+	0b11000000,
+	0b11000001,
+	0b11000010,
+	0b11000100,
+	0b11001000,
+	0b11010000,
+	0b11100000,
+	0b11100001,
+	0b11100010,
+	0b11100100,
+	0b11101000,
+	0b11110000,
+	0b11110001,
+	0b11110010,
+	0b11110100,
+	0b11111000,
+	0b11111001,
+	0b11111010,
+	0b11111100,
+	0b11111101,
+	0b11111110,
+	0b11111111,
+	0b00000000,
+	0b11111111,
+	0b00000000,
+	0b11111111,
+}

examples/sht3x/main.go

@@ -16,7 +16,7 @@ func main() {
 		temp, humidity, _ := sensor.ReadTemperatureHumidity()
 		t := fmt.Sprintf("%.2f", float32(temp)/1000)
 		h := fmt.Sprintf("%.2f", float32(humidity)/100)
-		println("Temperature:", t, "ºC")
+		println("Temperature:", t, "°C")
 		println("Humidity", h, "%")
 		time.Sleep(2 * time.Second)
 	}

examples/ssd1306/i2c_128x32/main.go

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

examples/ssd1306/spi_128x64/main.go

@@ -1,4 +1,4 @@
-package i2c_128x64
+package main
 
 import (
 	"image/color"

examples/ssd1331/main.go

@@ -0,0 +1,33 @@
+package ssd1331
+
+import (
+	"machine"
+
+	"image/color"
+
+	"tinygo.org/x/drivers/ssd1331"
+)
+
+func main() {
+	machine.SPI0.Configure(machine.SPIConfig{
+		Frequency: 8000000,
+	})
+	display := ssd1331.New(machine.SPI0, machine.P6, machine.P7, machine.P8)
+	display.Configure(ssd1331.Config{})
+	display.SetContrast(0x30, 0x20, 0x30)
+	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}
+	black := color.RGBA{0, 0, 0, 255}
+
+	display.FillScreen(black)
+
+	display.FillRectangle(0, 0, width/2, height/2, white)
+	display.FillRectangle(width/2, 0, width/2, height/2, red)
+	display.FillRectangle(0, height/2, width/2, height/2, green)
+	display.FillRectangle(width/2, height/2, width/2, height/2, blue)
+	display.FillRectangle(width/4, height/4, width/2, height/2, black)
+}

examples/st7735/main.go

@@ -0,0 +1,33 @@
+package main
+
+import (
+	"machine"
+
+	"image/color"
+
+	"tinygo.org/x/drivers/st7735"
+)
+
+func main() {
+	machine.SPI0.Configure(machine.SPIConfig{
+		Frequency: 8000000,
+	})
+	display := st7735.New(machine.SPI0, machine.P6, machine.P7, machine.P8, machine.P9)
+	display.Configure(st7735.Config{})
+
+	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}
+	black := color.RGBA{0, 0, 0, 255}
+
+	display.FillScreen(black)
+
+	display.FillRectangle(0, 0, width/2, height/2, white)
+	display.FillRectangle(width/2, 0, width/2, height/2, red)
+	display.FillRectangle(0, height/2, width/2, height/2, green)
+	display.FillRectangle(width/2, height/2, width/2, height/2, blue)
+	display.FillRectangle(width/4, height/4, width/2, height/2, black)
+}

examples/st7789/main.go

@@ -0,0 +1,34 @@
+package main
+
+import (
+	"machine"
+
+	"image/color"
+
+	"tinygo.org/x/drivers/st7789"
+)
+
+func main() {
+	machine.SPI0.Configure(machine.SPIConfig{
+		Frequency: 8000000,
+		Mode:      3,
+	})
+	display := st7789.New(machine.SPI0, machine.P6, machine.P7, machine.P8)
+	display.Configure(st7789.Config{Rotation: st7789.NO_ROTATION})
+
+	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}
+	black := color.RGBA{0, 0, 0, 255}
+
+	display.FillScreen(black)
+
+	display.FillRectangle(0, 0, width/2, height/2, white)
+	display.FillRectangle(width/2, 0, width/2, height/2, red)
+	display.FillRectangle(0, height/2, width/2, height/2, green)
+	display.FillRectangle(width/2, height/2, width/2, height/2, blue)
+	display.FillRectangle(width/4, height/4, width/2, height/2, black)
+}

examples/thermistor/main.go

@@ -19,7 +19,7 @@ func main() {
 
 	for {
 		temp, _ := sensor.ReadTemperature()
-		println("Temperature:", temp/1000, "ºC")
+		println("Temperature:", temp/1000, "°C")
 
 		time.Sleep(2 * time.Second)
 	}

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/touch/resistive/fourwire/main.go

@@ -0,0 +1,80 @@
+// demo of 4-wire touchscreen as described in app note:
+// http://ww1.microchip.com/downloads/en/Appnotes/doc8091.pdf
+package main
+
+import (
+	"machine"
+	"math"
+
+	"tinygo.org/x/drivers/touch"
+	"tinygo.org/x/drivers/touch/resistive"
+)
+
+var (
+	resistiveTouch = new(resistive.FourWire)
+)
+
+const (
+	Xmin = 750
+	Xmax = 325
+	Ymin = 840
+	Ymax = 240
+)
+
+func main() {
+
+	// configure touchscreen
+	machine.InitADC()
+	resistiveTouch.Configure(&resistive.FourWireConfig{
+		YP: machine.TOUCH_YD, // y+
+		YM: machine.TOUCH_YU, // y-
+		XP: machine.TOUCH_XR, // x+
+		XM: machine.TOUCH_XL, // x-
+	})
+
+	last := touch.Point{}
+
+	// loop and poll for touches, including performing debouncing
+	debounce := 0
+	for {
+
+		point := resistiveTouch.ReadTouchPoint()
+		touch := touch.Point{}
+		if point.Z>>6 > 100 {
+			touch.X = mapval(point.X>>6, Xmin, Xmax, 0, 240)
+			touch.Y = mapval(point.Y>>6, Ymin, Ymax, 0, 320)
+			touch.Z = point.Z >> 6 / 100
+		} else {
+			touch.X = 0
+			touch.Y = 0
+			touch.Z = 0
+		}
+
+		if last.Z != touch.Z {
+			debounce = 0
+			last = touch
+		} else if math.Abs(float64(touch.X-last.X)) > 4 ||
+			math.Abs(float64(touch.Y-last.Y)) > 4 {
+			debounce = 0
+			last = touch
+		} else if debounce > 1 {
+			debounce = 0
+			HandleTouch(last)
+		} else if touch.Z > 0 {
+			debounce++
+		} else {
+			last = touch
+			debounce = 0
+		}
+
+	}
+}
+
+// based on Arduino's "map" function
+func mapval(x int, inMin int, inMax int, outMin int, outMax int) int {
+	return (x-inMin)*(outMax-outMin)/(inMax-inMin) + outMin
+}
+
+func HandleTouch(touch touch.Point) {
+	println("touch point:", touch.X, touch.Y, touch.Z)
+}

examples/touch/resistive/pyportal_touchpaint/main.go

@@ -0,0 +1,185 @@
+package main
+
+import (
+	"image/color"
+	"machine"
+	"math"
+
+	"tinygo.org/x/drivers/ili9341"
+	"tinygo.org/x/drivers/touch"
+	"tinygo.org/x/drivers/touch/resistive"
+)
+
+var (
+	resistiveTouch = &resistive.FourWire{}
+
+	display = ili9341.NewParallel(
+		machine.LCD_DATA0,
+		machine.TFT_WR,
+		machine.TFT_DC,
+		machine.TFT_CS,
+		machine.TFT_RESET,
+		machine.TFT_RD,
+	)
+
+	white   = color.RGBA{255, 255, 255, 255}
+	black   = color.RGBA{0, 0, 0, 255}
+	red     = color.RGBA{255, 0, 0, 255}
+	green   = color.RGBA{0, 255, 0, 255}
+	blue    = color.RGBA{0, 0, 255, 255}
+	magenta = color.RGBA{255, 0, 255, 255}
+	yellow  = color.RGBA{255, 255, 0, 255}
+	cyan    = color.RGBA{0, 255, 255, 255}
+
+	oldColor     color.RGBA
+	currentColor color.RGBA
+)
+
+const (
+	penRadius = 3
+	boxSize   = 30
+
+	Xmin = 750
+	Xmax = 325
+	Ymin = 840
+	Ymax = 240
+)
+
+func main() {
+
+	// configure backlight
+	machine.TFT_BACKLIGHT.Configure(machine.PinConfig{machine.PinOutput})
+
+	// configure touchscreen
+	machine.InitADC()
+	resistiveTouch.Configure(&resistive.FourWireConfig{
+		YP: machine.TOUCH_YD,
+		YM: machine.TOUCH_YU,
+		XP: machine.TOUCH_XR,
+		XM: machine.TOUCH_XL,
+	})
+
+	// configure display
+	display.Configure(ili9341.Config{})
+
+	// fill the background and activate the backlight
+	width, height := display.Size()
+	display.FillRectangle(0, 0, width, height, black)
+	machine.TFT_BACKLIGHT.High()
+
+	// make color selection boxes
+	display.FillRectangle(0, 0, boxSize, boxSize, red)
+	display.FillRectangle(boxSize, 0, boxSize, boxSize, yellow)
+	display.FillRectangle(boxSize*2, 0, boxSize, boxSize, green)
+	display.FillRectangle(boxSize*3, 0, boxSize, boxSize, cyan)
+	display.FillRectangle(boxSize*4, 0, boxSize, boxSize, blue)
+	display.FillRectangle(boxSize*5, 0, boxSize, boxSize, magenta)
+	display.FillRectangle(boxSize*6, 0, boxSize, boxSize, black)
+	display.FillRectangle(boxSize*7, 0, boxSize, boxSize, white)
+
+	// set the initial color to red and draw a box to highlight it
+	oldColor = red
+	currentColor = red
+	display.DrawRectangle(0, 0, boxSize, boxSize, white)
+
+	last := touch.Point{}
+
+	// loop and poll for touches, including performing debouncing
+	debounce := 0
+	for {
+
+		point := resistiveTouch.ReadTouchPoint()
+		touch := touch.Point{}
+		if point.Z>>6 > 100 {
+			rawX := mapval(point.X>>6, Xmin, Xmax, 0, 240)
+			rawY := mapval(point.Y>>6, Ymin, Ymax, 0, 320)
+			touch.X = rawX
+			touch.Y = rawY
+			touch.Z = 1
+		} else {
+			touch.X = 0
+			touch.Y = 0
+			touch.Z = 0
+		}
+
+		if last.Z != touch.Z {
+			debounce = 0
+			last = touch
+		} else if math.Abs(float64(touch.X-last.X)) > 4 ||
+			math.Abs(float64(touch.Y-last.Y)) > 4 {
+			debounce = 0
+			last = touch
+		} else if debounce > 1 {
+			debounce = 0
+			HandleTouch(last)
+		} else if touch.Z > 0 {
+			debounce++
+		} else {
+			last = touch
+			debounce = 0
+		}
+
+	}
+}
+
+// based on Arduino's "map" function
+func mapval(x int, inMin int, inMax int, outMin int, outMax int) int {
+	return (x-inMin)*(outMax-outMin)/(inMax-inMin) + outMin
+}
+
+func HandleTouch(touch touch.Point) {
+
+	if int16(touch.Y) < boxSize {
+		oldColor = currentColor
+		x := int16(touch.X)
+		switch {
+		case x < boxSize:
+			currentColor = red
+		case x < boxSize*2:
+			currentColor = yellow
+		case x < boxSize*3:
+			currentColor = green
+		case x < boxSize*4:
+			currentColor = cyan
+		case x < boxSize*5:
+			currentColor = blue
+		case x < boxSize*6:
+			currentColor = magenta
+		case x < boxSize*7:
+			currentColor = black
+		case x < boxSize*8:
+			currentColor = white
+		}
+
+		if oldColor == currentColor {
+			return
+		}
+
+		display.DrawRectangle((x/boxSize)*boxSize, 0, boxSize, boxSize, white)
+		switch oldColor {
+		case red:
+			x = 0
+		case yellow:
+			x = boxSize
+		case green:
+			x = boxSize * 2
+		case cyan:
+			x = boxSize * 3
+		case blue:
+			x = boxSize * 4
+		case magenta:
+			x = boxSize * 5
+		case black:
+			x = boxSize * 6
+		case white:
+			x = boxSize * 7
+		}
+		display.FillRectangle(int16(x), 0, boxSize, boxSize, oldColor)
+
+	}
+
+	if (int16(touch.Y) - penRadius) > boxSize {
+		display.FillRectangle(
+			int16(touch.X), int16(touch.Y), penRadius*2, penRadius*2, currentColor)
+	}
+}

examples/veml6070/main.go

@@ -0,0 +1,41 @@
+package main
+
+import (
+	"time"
+
+	"machine"
+
+	"tinygo.org/x/drivers/veml6070"
+)
+
+func main() {
+	machine.I2C0.Configure(machine.I2CConfig{})
+	sensor := veml6070.New(machine.I2C0)
+
+	if !sensor.Configure() {
+		println("VEML6070 could not be configured")
+		return
+	}
+
+	println("VEML6070 configured")
+
+	for {
+		intensity, _ := sensor.ReadUVALightIntensity()
+		println("UVA light intensity:", float32(intensity)/1000.0, "W/(m*m)")
+
+		switch sensor.GetEstimatedRiskLevel(intensity) {
+		case veml6070.UVI_RISK_LOW:
+			println("UV risk level: low")
+		case veml6070.UVI_RISK_MODERATE:
+			println("UV risk level: moderate")
+		case veml6070.UVI_RISK_HIGH:
+			println("UV risk level: high")
+		case veml6070.UVI_RISK_VERY_HIGH:
+			println("UV risk level: very high")
+		case veml6070.UVI_RISK_EXTREME:
+			println("UV risk level: extreme")
+		}
+
+		time.Sleep(2 * time.Second)
+	}
+}

examples/wifinina/mqttclient/main.go

@@ -0,0 +1,149 @@
+// This is a sensor station that uses a ESP8266 or ESP32 running on the device UART1.
+// It creates an MQTT connection that publishes a message every second
+// to an MQTT broker.
+//
+// In other words:
+// Your computer <--> UART0 <--> MCU <--> UART1 <--> ESP8266 <--> Internet <--> MQTT broker.
+//
+// You must install the Paho MQTT package to build this program:
+//
+// 		go get -u github.com/eclipse/paho.mqtt.golang
+//
+package main
+
+import (
+	"fmt"
+	"machine"
+	"math/rand"
+	"time"
+
+	"tinygo.org/x/drivers/net/mqtt"
+	"tinygo.org/x/drivers/wifinina"
+)
+
+// access point info
+const ssid = ""
+const pass = ""
+
+// IP address of the MQTT broker to use. Replace with your own info.
+const server = "tcp://test.mosquitto.org:1883"
+
+//const server = "ssl://test.mosquitto.org:8883"
+
+// these are the default pins for the Arduino Nano33 IoT.
+// change these to connect to a different UART or pins for the ESP8266/ESP32
+var (
+
+	// these are the default pins for the Arduino Nano33 IoT.
+	uart = machine.UART2
+	tx   = machine.NINA_TX
+	rx   = machine.NINA_RX
+	spi  = machine.NINA_SPI
+
+	// this is the ESP chip that has the WIFININA firmware flashed on it
+	adaptor = &wifinina.Device{
+		SPI:   spi,
+		CS:    machine.NINA_CS,
+		ACK:   machine.NINA_ACK,
+		GPIO0: machine.NINA_GPIO0,
+		RESET: machine.NINA_RESETN,
+	}
+
+	console = machine.UART0
+	topic   = "tinygo"
+)
+
+func main() {
+	time.Sleep(3000 * time.Millisecond)
+
+	uart.Configure(machine.UARTConfig{TX: tx, RX: rx})
+	rand.Seed(time.Now().UnixNano())
+
+	// Configure SPI for 8Mhz, Mode 0, MSB First
+	spi.Configure(machine.SPIConfig{
+		Frequency: 8 * 1e6,
+		MOSI:      machine.NINA_MOSI,
+		MISO:      machine.NINA_MISO,
+		SCK:       machine.NINA_SCK,
+	})
+
+	// Init esp8266/esp32
+	adaptor.Configure()
+
+	connectToAP()
+
+	opts := mqtt.NewClientOptions()
+	opts.AddBroker(server).SetClientID("tinygo-client-" + randomString(10))
+
+	println("Connectng to MQTT...")
+	cl := mqtt.NewClient(opts)
+	if token := cl.Connect(); token.Wait() && token.Error() != nil {
+		failMessage(token.Error().Error())
+	}
+
+	for i := 0; ; i++ {
+		println("Publishing MQTT message...")
+		data := []byte(fmt.Sprintf(`{"e":[{"n":"hello %d","v":101}]}`, i))
+		token := cl.Publish(topic, 0, false, data)
+		token.Wait()
+		if err := token.Error(); err != nil {
+			switch t := err.(type) {
+			case wifinina.Error:
+				println(t.Error(), "attempting to reconnect")
+				if token := cl.Connect(); token.Wait() && token.Error() != nil {
+					failMessage(token.Error().Error())
+				}
+			default:
+				println(err.Error())
+			}
+		}
+		time.Sleep(1 * time.Millisecond)
+	}
+
+	// Right now this code is never reached. Need a way to trigger it...
+	println("Disconnecting MQTT...")
+	cl.Disconnect(100)
+
+	println("Done.")
+}
+
+// connect to access point
+func connectToAP() {
+	time.Sleep(2 * time.Second)
+	println("Connecting to " + ssid)
+	adaptor.SetPassphrase(ssid, pass)
+	for st, _ := adaptor.GetConnectionStatus(); st != wifinina.StatusConnected; {
+		println("Connection status: " + st.String())
+		time.Sleep(1 * time.Second)
+		st, _ = adaptor.GetConnectionStatus()
+	}
+	println("Connected.")
+	time.Sleep(2 * time.Second)
+	ip, _, _, err := adaptor.GetIP()
+	for ; err != nil; ip, _, _, err = adaptor.GetIP() {
+		println(err.Error())
+		time.Sleep(1 * time.Second)
+	}
+	println(ip.String())
+}
+
+// Returns an int >= min, < max
+func randomInt(min, max int) int {
+	return min + rand.Intn(max-min)
+}
+
+// Generate a random string of A-Z chars with len = l
+func randomString(len int) string {
+	bytes := make([]byte, len)
+	for i := 0; i < len; i++ {
+		bytes[i] = byte(randomInt(65, 90))
+	}
+	return string(bytes)
+}
+
+func failMessage(msg string) {
+	for {
+		println(msg)
+		time.Sleep(1 * time.Second)
+	}
+}

examples/wifinina/mqttsub/main.go

@@ -0,0 +1,162 @@
+// This is a sensor station that uses a ESP8266 or ESP32 running on the device UART1.
+// It creates an MQTT connection that publishes a message every second
+// to an MQTT broker.
+//
+// In other words:
+// Your computer <--> UART0 <--> MCU <--> UART1 <--> ESP8266 <--> Internet <--> MQTT broker.
+//
+// You must also install the Paho MQTT package to build this program:
+//
+// 		go get -u github.com/eclipse/paho.mqtt.golang
+//
+package main
+
+import (
+	"fmt"
+	"machine"
+	"math/rand"
+	"time"
+
+	"tinygo.org/x/drivers/net/mqtt"
+	"tinygo.org/x/drivers/wifinina"
+)
+
+// access point info
+const ssid = ""
+const pass = ""
+
+// IP address of the MQTT broker to use. Replace with your own info.
+const server = "tcp://test.mosquitto.org:1883"
+
+//const server = "ssl://test.mosquitto.org:8883"
+
+// change these to connect to a different UART or pins for the ESP8266/ESP32
+var (
+
+	// these are the default pins for the Arduino Nano33 IoT.
+	uart = machine.UART2
+	tx   = machine.NINA_TX
+	rx   = machine.NINA_RX
+	spi  = machine.NINA_SPI
+
+	// this is the ESP chip that has the WIFININA firmware flashed on it
+	adaptor = &wifinina.Device{
+		SPI:   spi,
+		CS:    machine.NINA_CS,
+		ACK:   machine.NINA_ACK,
+		GPIO0: machine.NINA_GPIO0,
+		RESET: machine.NINA_RESETN,
+	}
+
+	console = machine.UART0
+
+	cl      mqtt.Client
+	topicTx = "tinygo/tx"
+	topicRx = "tinygo/rx"
+)
+
+func subHandler(client mqtt.Client, msg mqtt.Message) {
+	fmt.Printf("[%s]  ", msg.Topic())
+	fmt.Printf("%s\r\n", msg.Payload())
+}
+
+func main() {
+	time.Sleep(3000 * time.Millisecond)
+
+	uart.Configure(machine.UARTConfig{TX: tx, RX: rx})
+	rand.Seed(time.Now().UnixNano())
+
+	// Configure SPI for 8Mhz, Mode 0, MSB First
+	spi.Configure(machine.SPIConfig{
+		Frequency: 8 * 1e6,
+		MOSI:      machine.NINA_MOSI,
+		MISO:      machine.NINA_MISO,
+		SCK:       machine.NINA_SCK,
+	})
+
+	// Init esp8266/esp32
+	adaptor.Configure()
+
+	connectToAP()
+
+	opts := mqtt.NewClientOptions()
+	opts.AddBroker(server).SetClientID("tinygo-client-" + randomString(10))
+
+	println("Connecting to MQTT broker at", server)
+	cl = mqtt.NewClient(opts)
+	if token := cl.Connect(); token.Wait() && token.Error() != nil {
+		failMessage(token.Error().Error())
+	}
+
+	// subscribe
+	token := cl.Subscribe(topicRx, 0, subHandler)
+	token.Wait()
+	if token.Error() != nil {
+		failMessage(token.Error().Error())
+	}
+
+	go publishing()
+
+	select {}
+
+	// Right now this code is never reached. Need a way to trigger it...
+	println("Disconnecting MQTT...")
+	cl.Disconnect(100)
+
+	println("Done.")
+}
+
+func publishing() {
+	for i := 0; ; i++ {
+		println("Publishing MQTT message...")
+		data := []byte(fmt.Sprintf(`{"e":[{"n":"hello %d","v":101}]}`, i))
+		token := cl.Publish(topicRx, 0, false, data)
+		token.Wait()
+		if token.Error() != nil {
+			println(token.Error().Error())
+		}
+
+		time.Sleep(100 * time.Millisecond)
+	}
+}
+
+// connect to access point
+func connectToAP() {
+	time.Sleep(2 * time.Second)
+	println("Connecting to " + ssid)
+	adaptor.SetPassphrase(ssid, pass)
+	for st, _ := adaptor.GetConnectionStatus(); st != wifinina.StatusConnected; {
+		println("Connection status: " + st.String())
+		time.Sleep(1 * time.Second)
+		st, _ = adaptor.GetConnectionStatus()
+	}
+	println("Connected.")
+	time.Sleep(2 * time.Second)
+	ip, _, _, err := adaptor.GetIP()
+	for ; err != nil; ip, _, _, err = adaptor.GetIP() {
+		println(err.Error())
+		time.Sleep(1 * time.Second)
+	}
+	println(ip.String())
+}
+
+// Returns an int >= min, < max
+func randomInt(min, max int) int {
+	return min + rand.Intn(max-min)
+}
+
+// Generate a random string of A-Z chars with len = l
+func randomString(len int) string {
+	bytes := make([]byte, len)
+	for i := 0; i < len; i++ {
+		bytes[i] = byte(randomInt(65, 90))
+	}
+	return string(bytes)
+}
+
+func failMessage(msg string) {
+	for {
+		println(msg)
+		time.Sleep(1 * time.Second)
+	}
+}

examples/wifinina/tcpclient/main.go

@@ -0,0 +1,143 @@
+// This example opens a TCP connection using a device with WiFiNINA firmware
+// and sends some data, for the purpose of testing speed and connectivity.
+//
+// You can open a server to accept connections from this program using:
+//
+// nc -w 5 -lk 8080
+//
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"machine"
+	"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 serverIP = ""
+
+// these are the default pins for the Arduino Nano33 IoT.
+// change these to connect to a different UART or pins for the ESP8266/ESP32
+var (
+
+	// these are the default pins for the Arduino Nano33 IoT.
+	uart = machine.UART2
+	tx   = machine.NINA_TX
+	rx   = machine.NINA_RX
+	spi  = machine.NINA_SPI
+
+	// this is the ESP chip that has the WIFININA firmware flashed on it
+	adaptor = &wifinina.Device{
+		SPI:   spi,
+		CS:    machine.NINA_CS,
+		ACK:   machine.NINA_ACK,
+		GPIO0: machine.NINA_GPIO0,
+		RESET: machine.NINA_RESETN,
+	}
+
+	console = machine.UART0
+)
+
+var buf = &bytes.Buffer{}
+
+func main() {
+
+	uart.Configure(machine.UARTConfig{TX: tx, RX: rx})
+
+	// Configure SPI for 8Mhz, Mode 0, MSB First
+	spi.Configure(machine.SPIConfig{
+		Frequency: 8 * 1e6,
+		MOSI:      machine.NINA_MOSI,
+		MISO:      machine.NINA_MISO,
+		SCK:       machine.NINA_SCK,
+	})
+
+	adaptor.Configure()
+
+	connectToAP()
+
+	for {
+		sendBatch()
+		time.Sleep(500 * time.Millisecond)
+	}
+	println("Done.")
+}
+
+func sendBatch() {
+
+	// make TCP connection
+	ip := net.ParseIP(serverIP)
+	raddr := &net.TCPAddr{IP: ip, Port: 8080}
+	laddr := &net.TCPAddr{Port: 8080}
+
+	message("---------------\r\nDialing TCP connection")
+	conn, err := net.DialTCP("tcp", laddr, raddr)
+	for ; err != nil; conn, err = net.DialTCP("tcp", laddr, raddr) {
+		message(err.Error())
+		time.Sleep(5 * time.Second)
+	}
+
+	n := 0
+	w := 0
+	start := time.Now()
+
+	// send data
+	message("Sending data")
+
+	for i := 0; i < 1000; i++ {
+		buf.Reset()
+		fmt.Fprint(buf,
+			"\r---------------------------- i == ", i, " ----------------------------"+
+				"\r---------------------------- i == ", i, " ----------------------------")
+		if w, err = conn.Write(buf.Bytes()); err != nil {
+			println("error:", err.Error(), "\r")
+			continue
+		}
+		n += w
+	}
+
+	buf.Reset()
+	ms := time.Now().Sub(start).Milliseconds()
+	fmt.Fprint(buf, "\nWrote ", n, " bytes in ", ms, " ms\r\n")
+	message(buf.String())
+
+	if _, err := conn.Write(buf.Bytes()); err != nil {
+		println("error:", err.Error(), "\r")
+	}
+
+	// Right now this code is never reached. Need a way to trigger it...
+	println("Disconnecting TCP...")
+	conn.Close()
+}
+
+// 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

@@ -0,0 +1,153 @@
+// This example opens a TCP connection using a device with WiFiNINA firmware
+// and sends a HTTP request to retrieve a webpage, based on the following
+// Arduino example:
+//
+// https://github.com/arduino-libraries/WiFiNINA/blob/master/examples/WiFiWebClientRepeating/
+//
+package main
+
+import (
+	"fmt"
+	"machine"
+	"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 server = "tinygo.org"
+
+// these are the default pins for the Arduino Nano33 IoT.
+// change these to connect to a different UART or pins for the ESP8266/ESP32
+var (
+
+	// these are the default pins for the Arduino Nano33 IoT.
+	uart = machine.UART2
+	tx   = machine.NINA_TX
+	rx   = machine.NINA_RX
+	spi  = machine.NINA_SPI
+
+	// this is the ESP chip that has the WIFININA firmware flashed on it
+	adaptor = &wifinina.Device{
+		SPI:   spi,
+		CS:    machine.NINA_CS,
+		ACK:   machine.NINA_ACK,
+		GPIO0: machine.NINA_GPIO0,
+		RESET: machine.NINA_RESETN,
+	}
+
+	console = machine.UART0
+)
+
+var buf [256]byte
+
+var lastRequestTime time.Time
+var conn net.Conn
+
+func main() {
+
+	uart.Configure(machine.UARTConfig{TX: tx, RX: rx})
+
+	// Configure SPI for 8Mhz, Mode 0, MSB First
+	spi.Configure(machine.SPIConfig{
+		Frequency: 8 * 1e6,
+		MOSI:      machine.NINA_MOSI,
+		MISO:      machine.NINA_MISO,
+		SCK:       machine.NINA_SCK,
+	})
+
+	adaptor.Configure()
+
+	connectToAP()
+
+	for {
+		loop()
+	}
+	println("Done.")
+}
+
+func loop() {
+	if conn != nil {
+		for n, err := conn.Read(buf[:]); n > 0; n, err = conn.Read(buf[:]) {
+			if err != nil {
+				println("Read error: " + err.Error())
+			} else {
+				print(string(buf[0:n]))
+			}
+		}
+	}
+	if time.Now().Sub(lastRequestTime).Milliseconds() >= 10000 {
+		makeHTTPRequest()
+	}
+}
+
+func makeHTTPRequest() {
+
+	var err error
+	if conn != nil {
+		conn.Close()
+	}
+
+	// make TCP connection
+	ip := net.ParseIP(server)
+	raddr := &net.TCPAddr{IP: ip, Port: 80}
+	laddr := &net.TCPAddr{Port: 8080}
+
+	message("\r\n---------------\r\nDialing TCP connection")
+	conn, err = net.DialTCP("tcp", laddr, raddr)
+	for ; err != nil; conn, err = net.DialTCP("tcp", laddr, raddr) {
+		message("connection failed: " + err.Error())
+		time.Sleep(5 * time.Second)
+	}
+	println("Connected!\r")
+
+	print("Sending HTTP request...")
+	fmt.Fprintln(conn, "GET / HTTP/1.1")
+	fmt.Fprintln(conn, "Host:", server)
+	fmt.Fprintln(conn, "User-Agent: TinyGo/0.10.0")
+	fmt.Fprintln(conn, "Connection: close")
+	fmt.Fprintln(conn)
+	println("Sent!\r\n\r")
+
+	lastRequestTime = time.Now()
+}
+
+func readLine(conn *net.TCPSerialConn) string {
+	println("Attempting to read...\r")
+	b := buf[:]
+	for expiry := time.Now().Unix() + 10; time.Now().Unix() > expiry; {
+		if n, err := conn.Read(b); n > 0 && err == nil {
+			return string(b[0:n])
+		}
+	}
+	return ""
+}
+
+// connect to access point
+func connectToAP() {
+	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/ws2812/digispark.go

@@ -0,0 +1,10 @@
+// +build digispark
+
+package main
+
+import "machine"
+
+// This is the pin assignment for the Digispark only.
+// Replace neo in the code below to match the pin
+// that you are using if different.
+var neo machine.Pin = 0

examples/ws2812/main.go

@@ -1,8 +1,7 @@
-// Connects to an WS2812 RGB LED strip with 10 LEDS, such as
-// on an Adafruit Circuit Playground Express board.
+// Connects to an WS2812 RGB LED strip with 10 LEDS.
 //
-// Replace machine.NEOPIXELS in the code below to match the pin
-// that you are using, if you have a different board.
+// See either the others.go or digispark.go files in this directory
+// for the neopixels pin assignments.
 package main
 
 import (
@@ -13,12 +12,15 @@ import (
 	"tinygo.org/x/drivers/ws2812"
 )
 
+var leds [10]color.RGBA
+
 func main() {
-	neo := machine.NEOPIXELS
+	led := machine.LED
+	led.Configure(machine.PinConfig{Mode: machine.PinOutput})
+
 	neo.Configure(machine.PinConfig{Mode: machine.PinOutput})
 
 	ws := ws2812.New(neo)
-	leds := make([]color.RGBA, 10)
 	rg := false
 
 	for {
@@ -33,7 +35,8 @@ func main() {
 			}
 		}
 
-		ws.WriteColors(leds)
+		ws.WriteColors(leds[:])
+		led.Set(rg)
 		time.Sleep(100 * time.Millisecond)
 	}
 }

examples/ws2812/others.go

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

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, mosi, miso, sck, cs machine.Pin) *Device {
+	return &Device{
+		trans: &spiTransport{
+			spi:  spi,
+			mosi: mosi,
+			miso: miso,
+			sck:  sck,
+			ss:   cs,
+		},
+	}
+}
+
+type spiTransport struct {
+	spi  *machine.SPI
+	mosi machine.Pin
+	miso 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,
+		MISO:      tr.miso,
+		MOSI:      tr.mosi,
+		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
+}

gps/ublox.go

@@ -49,5 +49,5 @@ func sendCommand(gpsDevice GPSDevice, command []byte) (err error) {
 			}
 		}
 	}
-	return errors.New("No ACK to GPS command")
+	return errors.New("no ACK to GPS command")
 }

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
+}

hd44780/gpio.go

@@ -87,7 +87,7 @@ func (g *GPIO) write4BitMode(data byte) {
 // Ram address can be changed by writing address in command mode
 func (g *GPIO) Read(data []byte) (n int, err error) {
 	if len(data) == 0 {
-		return 0, errors.New("Length greater than 0 is required")
+		return 0, errors.New("length greater than 0 is required")
 	}
 	g.rw.High()
 	g.reconfigureGPIOMode(machine.PinInput)

hd44780/hd44780.go

@@ -1,4 +1,4 @@
-// Package lis3dh provides a driver for the HD44780 LCD controller.
+// Package hd44780 provides a driver for the HD44780 LCD controller.
 //
 // Datasheet: https://www.sparkfun.com/datasheets/LCD/HD44780.pdf
 //
@@ -66,7 +66,7 @@ func (d *Device) Configure(cfg Config) error {
 	d.width = uint8(cfg.Width)
 	d.height = uint8(cfg.Height)
 	if d.width == 0 || d.height == 0 {
-		return errors.New("Width and height must be set")
+		return errors.New("width and height must be set")
 	}
 	memoryMap := uint8(ONE_LINE)
 	if d.height > 1 {

ili9341/README.md

@@ -0,0 +1,19 @@
+TinyGo driver for TFT displays using ILI9341 driver chips.
+
+These displays support 8-bit parallel, 16-bit parallel, or SPI interfaces.
+
+Examples of such displays include:
+
+ * [Adafruit PyPortal
+ ](https://www.adafruit.com/product/4116)
+ * [Adafruit 2.8" Touch Shield V2 (SPI)](http://www.adafruit.com/products/1651)
+ * [Adafruit 2.4" TFT LCD with Touchscreen Breakout w/MicroSD Socket](https://www.adafruit.com/product/2478)
+ * [2.8" TFT LCD with Touchscreen Breakout Board w/MicroSD Socket](https://www.adafruit.com/product/1770)
+ * [2.2" 18-bit color TFT LCD display with microSD card breakout](https://www.adafruit.com/product/1770)
+ * [TFT FeatherWing - 2.4" 320x240 Touchscreen For All Feathers](https://www.adafruit.com/product/3315)
+
+Currently this driver only supports an 8-bit parallel interface using ATSAMD51
+(this is the default configuration on PyPortal).  It should be relatively
+straightforward to implement a more generic SPI-based interface as well.
+Please see `parallel_atsamd51.go` for an example of what needs to be
+implemented if you are interested in contributing.

ili9341/ili9341.go

@@ -0,0 +1,310 @@
+package ili9341
+
+import (
+	"errors"
+	"image/color"
+	"machine"
+	"time"
+)
+
+type Config struct {
+	Width    int16
+	Height   int16
+	Rotation Rotation
+}
+
+type Device struct {
+	width    int16
+	height   int16
+	rotation Rotation
+	driver   driver
+
+	dc  machine.Pin
+	cs  machine.Pin
+	rst machine.Pin
+	rd  machine.Pin
+}
+
+func (d *Device) Configure(config Config) {
+
+	if config.Width == 0 {
+		config.Width = TFTWIDTH
+	}
+	if config.Height == 0 {
+		config.Height = TFTHEIGHT
+	}
+	d.width = config.Width
+	d.height = config.Height
+	d.rotation = config.Rotation
+
+	output := machine.PinConfig{machine.PinOutput}
+
+	// configure chip select if there is one
+	if d.cs != machine.NoPin {
+		d.cs.Configure(output)
+		d.cs.High() // deselect
+	}
+
+	d.dc.Configure(output)
+	d.dc.High() // data mode
+
+	// driver-specific configuration
+	d.driver.configure(&config)
+
+	if d.rd != machine.NoPin {
+		d.rd.Configure(output)
+		d.rd.High()
+	}
+
+	// reset the display
+	if d.rst != machine.NoPin {
+		// configure hardware reset if there is one
+		d.rst.Configure(output)
+		d.rst.High()
+		delay(100)
+		d.rst.Low()
+		delay(100)
+		d.rst.High()
+		delay(200)
+	} else {
+		// if no hardware reset, send software reset
+		d.sendCommand(SWRESET, nil)
+		delay(150)
+	}
+
+	initCmd := []byte{
+		0xEF, 3, 0x03, 0x80, 0x02,
+		0xCF, 3, 0x00, 0xC1, 0x30,
+		0xED, 4, 0x64, 0x03, 0x12, 0x81,
+		0xE8, 3, 0x85, 0x00, 0x78,
+		0xCB, 5, 0x39, 0x2C, 0x00, 0x34, 0x02,
+		0xF7, 1, 0x20,
+		0xEA, 2, 0x00, 0x00,
+		PWCTR1, 1, 0x23, // Power control VRH[5:0]
+		PWCTR2, 1, 0x10, // Power control SAP[2:0];BT[3:0]
+		VMCTR1, 2, 0x3e, 0x28, // VCM control
+		VMCTR2, 1, 0x86, // VCM control2
+		MADCTL, 1, 0x48, // Memory Access Control
+		VSCRSADD, 1, 0x00, // Vertical scroll zero
+		PIXFMT, 1, 0x55,
+		FRMCTR1, 2, 0x00, 0x18,
+		DFUNCTR, 3, 0x08, 0x82, 0x27, // Display Function Control
+		0xF2, 1, 0x00, // 3Gamma Function Disable
+		GAMMASET, 1, 0x01, // Gamma curve selected
+		GMCTRP1, 15, 0x0F, 0x31, 0x2B, 0x0C, 0x0E, 0x08, // Set Gamma
+		0x4E, 0xF1, 0x37, 0x07, 0x10, 0x03, 0x0E, 0x09, 0x00,
+		GMCTRN1, 15, 0x00, 0x0E, 0x14, 0x03, 0x11, 0x07, // Set Gamma
+		0x31, 0xC1, 0x48, 0x08, 0x0F, 0x0C, 0x31, 0x36, 0x0F,
+		SLPOUT, 0x80, // Exit Sleep
+		DISPON, 0x80, // Display on
+		0x00, // End of list
+	}
+	for i, c := 0, len(initCmd); i < c; {
+		cmd := initCmd[i]
+		if cmd == 0x00 {
+			break
+		}
+		x := initCmd[i+1]
+		numArgs := int(x & 0x7F)
+		d.sendCommand(cmd, initCmd[i+2:i+2+numArgs])
+		if x&0x80 > 0 {
+			delay(150)
+		}
+		i += numArgs + 2
+	}
+
+	d.SetRotation(d.rotation)
+}
+
+// Size returns the current size of the display.
+func (d *Device) Size() (x, y int16) {
+	if d.rotation == 1 || d.rotation == 3 {
+		return d.height, d.width
+	}
+	return d.width, d.height
+}
+
+// SetPixel modifies the internal buffer.
+func (d *Device) SetPixel(x, y int16, c color.RGBA) {
+	d.setWindow(x, y, 1, 1)
+	c565 := RGBATo565(c)
+	d.startWrite()
+	d.driver.write16(c565)
+	d.endWrite()
+}
+
+// Display sends the buffer (if any) to the screen.
+func (d *Device) Display() error {
+	return nil
+}
+
+func (d *Device) DrawRGBBitmap(x, y int16, data []uint16, w, h int16) error {
+	k, i := d.Size()
+	if x < 0 || y < 0 || w <= 0 || h <= 0 ||
+		x >= k || (x+w) > k || y >= i || (y+h) > i {
+		return errors.New("rectangle coordinates outside display area")
+	}
+	d.setWindow(x, y, w, h)
+	d.startWrite()
+	d.driver.write16sl(data)
+	d.endWrite()
+	return nil
+}
+
+// FillRectangle fills a rectangle at a given coordinates with a color
+func (d *Device) FillRectangle(x, y, width, height int16, c color.RGBA) error {
+	k, i := d.Size()
+	if x < 0 || y < 0 || width <= 0 || height <= 0 ||
+		x >= k || (x+width) > k || y >= i || (y+height) > i {
+		return errors.New("rectangle coordinates outside display area")
+	}
+	d.setWindow(x, y, width, height)
+	c565 := RGBATo565(c)
+	d.startWrite()
+	d.driver.write16n(c565, int(width)*int(height))
+	d.endWrite()
+	return nil
+}
+
+// DrawRectangle fills a rectangle at a given coordinates with a color
+func (d *Device) DrawRectangle(x, y, w, h int16, c color.RGBA) error {
+	if err := d.DrawFastHLine(x, x+w-1, y, c); err != nil {
+		return err
+	}
+	if err := d.DrawFastHLine(x, x+w-1, y+h-1, c); err != nil {
+		return err
+	}
+	if err := d.DrawFastVLine(x, y, y+h-1, c); err != nil {
+		return err
+	}
+	if err := d.DrawFastVLine(x+w-1, y, y+h-1, c); err != nil {
+		return err
+	}
+	return nil
+}
+
+// DrawFastVLine draws a vertical line faster than using SetPixel
+func (d *Device) DrawFastVLine(x, y0, y1 int16, c color.RGBA) error {
+	if y0 > y1 {
+		y0, y1 = y1, y0
+	}
+	return 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) error {
+	if x0 > x1 {
+		x0, x1 = x1, x0
+	}
+	return d.FillRectangle(x0, y, x1-x0+1, 1, c)
+}
+
+// FillScreen fills the screen with a given color
+func (d *Device) FillScreen(c color.RGBA) {
+	if d.rotation == Rotation0 || d.rotation == Rotation180 {
+		d.FillRectangle(0, 0, d.width, d.height, c)
+	} else {
+		d.FillRectangle(0, 0, d.height, d.width, c)
+	}
+}
+
+func (d *Device) GetRotation() Rotation {
+	return d.rotation
+}
+
+// SetRotation changes the rotation of the device (clock-wise)
+func (d *Device) SetRotation(rotation Rotation) {
+	madctl := uint8(0)
+	switch rotation % 4 {
+	case 0:
+		madctl = MADCTL_MX | MADCTL_BGR
+	case 1:
+		madctl = MADCTL_MV | MADCTL_BGR
+	case 2:
+		madctl = MADCTL_MY | MADCTL_BGR
+	case 3:
+		madctl = MADCTL_MX | MADCTL_MY | MADCTL_MV | MADCTL_BGR
+	}
+	d.sendCommand(MADCTL, []uint8{madctl})
+	d.rotation = rotation
+}
+
+// SetScrollWindow sets an area to scroll with fixed top and bottom parts of the display
+func (d *Device) SetScrollArea(topFixedArea, bottomFixedArea int16) {
+	d.sendCommand(VSCRDEF, []uint8{
+		uint8(topFixedArea >> 8), uint8(topFixedArea),
+		uint8(d.height - topFixedArea - bottomFixedArea>>8),
+		uint8(d.height - topFixedArea - bottomFixedArea),
+		uint8(bottomFixedArea >> 8), uint8(bottomFixedArea),
+	})
+}
+
+// SetScroll sets the vertical scroll address of the display.
+func (d *Device) SetScroll(line int16) {
+	d.sendCommand(VSCRSADD, []uint8{uint8(line >> 8), uint8(line)})
+}
+
+// SpotScroll returns the display to its normal state
+func (d *Device) StopScroll() {
+	d.sendCommand(NORON, nil)
+}
+
+// setWindow prepares the screen to be modified at a given rectangle
+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)
+}
+
+//go:inline
+func (d *Device) startWrite() {
+	if d.cs != machine.NoPin {
+		d.cs.Low()
+	}
+}
+
+//go:inline
+func (d *Device) endWrite() {
+	if d.cs != machine.NoPin {
+		d.cs.High()
+	}
+}
+
+func (d *Device) sendCommand(cmd byte, data []byte) {
+	d.startWrite()
+	d.dc.Low()
+	d.driver.write8(cmd)
+	d.dc.High()
+	for _, b := range data {
+		d.driver.write8(b)
+	}
+	d.endWrite()
+}
+
+type driver interface {
+	configure(config *Config)
+	write8(b byte)
+	write16(data uint16)
+	write16n(data uint16, n int)
+	write16sl(data []uint16)
+}
+
+func delay(m int) {
+	t := time.Now().UnixNano() + int64(time.Duration(m*1000)*time.Microsecond)
+	for time.Now().UnixNano() < t {
+	}
+}
+
+// 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))
+}

ili9341/parallel_atsamd51.go

@@ -0,0 +1,87 @@
+// +build atsamd51
+
+package ili9341
+
+import (
+	"machine"
+	"runtime/volatile"
+)
+
+type parallelDriver struct {
+	d0 machine.Pin
+	wr machine.Pin
+
+	setPort *uint32
+	setMask uint32
+
+	clrPort *uint32
+	clrMask uint32
+
+	wrPortSet *uint32
+	wrMaskSet uint32
+
+	wrPortClr *uint32
+	wrMaskClr uint32
+}
+
+func NewParallel(d0, wr, dc, cs, rst, rd machine.Pin) *Device {
+	return &Device{
+		dc:  dc,
+		cs:  cs,
+		rd:  rd,
+		rst: rst,
+		driver: &parallelDriver{
+			d0: d0,
+			wr: wr,
+		},
+	}
+}
+
+func (pd *parallelDriver) configure(config *Config) {
+	output := machine.PinConfig{machine.PinOutput}
+	for pin := pd.d0; pin < pd.d0+8; pin++ {
+		pin.Configure(output)
+		pin.Low()
+	}
+	pd.wr.Configure(output)
+	pd.wr.High()
+
+	pd.setPort, _ = pd.d0.PortMaskSet()
+	pd.setMask = uint32(pd.d0) & 0x1f
+
+	pd.clrPort, _ = (pd.d0).PortMaskClear()
+	pd.clrMask = 0xFF << uint32(pd.d0)
+
+	pd.wrPortSet, pd.wrMaskSet = pd.wr.PortMaskSet()
+	pd.wrPortClr, pd.wrMaskClr = pd.wr.PortMaskClear()
+}
+
+//go:inline
+func (pd *parallelDriver) write8(b byte) {
+	volatile.StoreUint32(pd.clrPort, pd.clrMask)
+	volatile.StoreUint32(pd.setPort, uint32(b)<<pd.setMask)
+	volatile.StoreUint32(pd.wrPortClr, pd.wrMaskClr)
+	volatile.StoreUint32(pd.wrPortSet, pd.wrMaskSet)
+}
+
+//go:inline
+func (pd *parallelDriver) write16(data uint16) {
+	pd.write8(byte(data >> 8))
+	pd.write8(byte(data))
+}
+
+//go:inline
+func (pd *parallelDriver) write16n(data uint16, n int) {
+	for i := 0; i < n; i++ {
+		pd.write8(byte(data >> 8))
+		pd.write8(byte(data))
+	}
+}
+
+//go:inline
+func (pd *parallelDriver) write16sl(data []uint16) {
+	for i, c := 0, len(data); i < c; i++ {
+		pd.write8(byte(data[i] >> 8))
+		pd.write8(byte(data[i]))
+	}
+}

ili9341/registers.go

@@ -0,0 +1,84 @@
+package ili9341
+
+type Rotation uint8
+
+const (
+
+	// register constants based on source:
+	// https://github.com/adafruit/Adafruit_ILI9341/blob/master/Adafruit_ILI9341.h
+
+	TFTWIDTH  = 240 ///< ILI9341 max TFT width
+	TFTHEIGHT = 320 ///< ILI9341 max TFT height
+
+	NOP     = 0x00 ///< No-op register
+	SWRESET = 0x01 ///< Software reset register
+	RDDID   = 0x04 ///< Read display identification information
+	RDDST   = 0x09 ///< Read Display Status
+
+	SLPIN  = 0x10 ///< Enter Sleep Mode
+	SLPOUT = 0x11 ///< Sleep Out
+	PTLON  = 0x12 ///< Partial Mode ON
+	NORON  = 0x13 ///< Normal Display Mode ON
+
+	RDMODE     = 0x0A ///< Read Display Power Mode
+	RDMADCTL   = 0x0B ///< Read Display MADCTL
+	RDPIXFMT   = 0x0C ///< Read Display Pixel Format
+	RDIMGFMT   = 0x0D ///< Read Display Image Format
+	RDSELFDIAG = 0x0F ///< Read Display Self-Diagnostic Result
+
+	INVOFF   = 0x20 ///< Display Inversion OFF
+	INVON    = 0x21 ///< Display Inversion ON
+	GAMMASET = 0x26 ///< Gamma Set
+	DISPOFF  = 0x28 ///< Display OFF
+	DISPON   = 0x29 ///< Display ON
+
+	CASET = 0x2A ///< Column Address Set
+	PASET = 0x2B ///< Page Address Set
+	RAMWR = 0x2C ///< Memory Write
+	RAMRD = 0x2E ///< Memory Read
+
+	PTLAR    = 0x30 ///< Partial Area
+	VSCRDEF  = 0x33 ///< Vertical Scrolling Definition
+	MADCTL   = 0x36 ///< Memory Access Control
+	VSCRSADD = 0x37 ///< Vertical Scrolling Start Address
+	PIXFMT   = 0x3A ///< COLMOD: Pixel Format Set
+
+	FRMCTR1 = 0xB1 ///< Frame Rate Control (In Normal Mode/Full Colors)
+	FRMCTR2 = 0xB2 ///< Frame Rate Control (In Idle Mode/8 colors)
+	FRMCTR3 = 0xB3 ///< Frame Rate control (In Partial Mode/Full Colors)
+	INVCTR  = 0xB4 ///< Display Inversion Control
+	DFUNCTR = 0xB6 ///< Display Function Control
+
+	PWCTR1 = 0xC0 ///< Power Control 1
+	PWCTR2 = 0xC1 ///< Power Control 2
+	PWCTR3 = 0xC2 ///< Power Control 3
+	PWCTR4 = 0xC3 ///< Power Control 4
+	PWCTR5 = 0xC4 ///< Power Control 5
+	VMCTR1 = 0xC5 ///< VCOM Control 1
+	VMCTR2 = 0xC7 ///< VCOM Control 2
+
+	RDID1 = 0xDA ///< Read ID 1
+	RDID2 = 0xDB ///< Read ID 2
+	RDID3 = 0xDC ///< Read ID 3
+	RDID4 = 0xDD ///< Read ID 4
+
+	GMCTRP1 = 0xE0 ///< Positive Gamma Correction
+	GMCTRN1 = 0xE1 ///< Negative Gamma Correction
+	//PWCTR6     0xFC
+
+	MADCTL_MY  = 0x80 ///< Bottom to top
+	MADCTL_MX  = 0x40 ///< Right to left
+	MADCTL_MV  = 0x20 ///< Reverse Mode
+	MADCTL_ML  = 0x10 ///< LCD refresh Bottom to top
+	MADCTL_RGB = 0x00 ///< Red-Green-Blue pixel order
+	MADCTL_BGR = 0x08 ///< Blue-Green-Red pixel order
+	MADCTL_MH  = 0x04 ///< LCD refresh right to left
+
+)
+
+const (
+	Rotation0   Rotation = 0
+	Rotation90  Rotation = 1 // 90 degrees clock-wise rotation
+	Rotation180 Rotation = 2
+	Rotation270 Rotation = 3
+)

l293x/l293x.go

@@ -0,0 +1,104 @@
+// Package l293x provides a driver to the L293/L293D H-bridge chip
+// typically used to control DC motors.
+//
+// Datasheet: https://www.ti.com/lit/ds/symlink/l293d.pdf
+//
+package l293x // import "tinygo.org/x/drivers/l293x"
+
+import (
+	"machine"
+)
+
+// Device is a motor without speed control.
+// a1 and a2 are the directional pins.
+// en is the pin turns the motor on/off.
+type Device struct {
+	a1, a2 machine.Pin
+	en     machine.Pin
+}
+
+// New returns a new Motor driver for GPIO-only operation.
+func New(direction1, direction2, enablePin machine.Pin) Device {
+	return Device{
+		a1: direction1,
+		a2: direction2,
+		en: enablePin,
+	}
+}
+
+// Configure configures the Device.
+func (d *Device) Configure() {
+	d.a1.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	d.a2.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	d.en.Configure(machine.PinConfig{Mode: machine.PinOutput})
+
+	d.Stop()
+}
+
+// Forward turns motor on in forward direction.
+func (d *Device) Forward() {
+	d.a1.High()
+	d.a2.Low()
+	d.en.High()
+}
+
+// Backward turns motor on in backward direction.
+func (d *Device) Backward() {
+	d.a1.Low()
+	d.a2.High()
+	d.en.High()
+}
+
+// Stop turns motor off.
+func (d *Device) Stop() {
+	d.a1.Low()
+	d.a2.Low()
+	d.en.Low()
+}
+
+// PWMDevice is a motor with speed control.
+// a1 and a2 are the directional GPIO pins.
+// en is the PWM pin that controls the motor speed.
+type PWMDevice struct {
+	a1, a2 machine.Pin
+	en     machine.PWM
+}
+
+// NewWithSpeed returns a new PWMMotor driver that uses a PWM pin to control speed.
+func NewWithSpeed(direction1, direction2 machine.Pin, speedPin machine.PWM) PWMDevice {
+	return PWMDevice{
+		a1: direction1,
+		a2: direction2,
+		en: speedPin,
+	}
+}
+
+// Configure configures the PWMDevice.
+func (d *PWMDevice) Configure() {
+	d.a1.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	d.a2.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	d.en.Configure()
+
+	d.Stop()
+}
+
+// Forward turns motor on in forward direction at specific speed.
+func (d *PWMDevice) Forward(speed uint16) {
+	d.a1.High()
+	d.a2.Low()
+	d.en.Set(speed)
+}
+
+// Backward turns motor on in backward direction at specific speed.
+func (d *PWMDevice) Backward(speed uint16) {
+	d.a1.Low()
+	d.a2.High()
+	d.en.Set(speed)
+}
+
+// Stop turns motor off.
+func (d *PWMDevice) Stop() {
+	d.a1.Low()
+	d.a2.Low()
+	d.en.Set(0)
+}

l9110x/l9110x.go

@@ -0,0 +1,90 @@
+// Package l9110x provides a driver to the L9110/L9110S H-bridge chip
+// typically used to control DC motors.
+//
+// Datasheet: https://www.elecrow.com/download/datasheet-l9110.pdf
+//
+package l9110x // import "tinygo.org/x/drivers/l9110x"
+
+import (
+	"machine"
+)
+
+// Device is a motor without speed control.
+// ia and ib are the directional pins.
+type Device struct {
+	ia, ib machine.Pin
+}
+
+// New returns a new Motor driver for GPIO-only operation.
+func New(direction1, direction2 machine.Pin) Device {
+	return Device{
+		ia: direction1,
+		ib: direction2,
+	}
+}
+
+// Configure configures the Device.
+func (d *Device) Configure() {
+	d.ia.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	d.ib.Configure(machine.PinConfig{Mode: machine.PinOutput})
+
+	d.Stop()
+}
+
+// Forward turns motor on in forward direction.
+func (d *Device) Forward() {
+	d.ia.High()
+	d.ib.Low()
+}
+
+// Backward turns motor on in backward direction.
+func (d *Device) Backward() {
+	d.ia.Low()
+	d.ib.High()
+}
+
+// Stop turns motor off.
+func (d *Device) Stop() {
+	d.ia.Low()
+	d.ib.Low()
+}
+
+// PWMDevice is a motor with speed control.
+// ia and ib are the directional/speed PWM pins.
+type PWMDevice struct {
+	ia, ib machine.PWM
+}
+
+// NewWithSpeed returns a new PWMMotor driver that uses 2 PWM pins to control both direction and speed.
+func NewWithSpeed(direction1, direction2 machine.PWM) PWMDevice {
+	return PWMDevice{
+		ia: direction1,
+		ib: direction2,
+	}
+}
+
+// Configure configures the PWMDevice.
+func (d *PWMDevice) Configure() {
+	d.ia.Configure()
+	d.ib.Configure()
+
+	d.Stop()
+}
+
+// Forward turns motor on in forward direction at specific speed.
+func (d *PWMDevice) Forward(speed uint16) {
+	d.ia.Set(speed)
+	d.ib.Set(0)
+}
+
+// Backward turns motor on in backward direction at specific speed.
+func (d *PWMDevice) Backward(speed uint16) {
+	d.ia.Set(0)
+	d.ib.Set(speed)
+}
+
+// Stop turns motor off.
+func (d *PWMDevice) Stop() {
+	d.ia.Set(0)
+	d.ib.Set(0)
+}

lsm6ds3/lsm6ds3.go

@@ -0,0 +1,183 @@
+// Package lsm6ds3 implements a driver for the LSM6DS3 a 6 axis Inertial
+// Measurement Unit (IMU)
+//
+// Datasheet: https://www.st.com/resource/en/datasheet/lsm6ds3.pdf
+//
+package lsm6ds3 // import "tinygo.org/x/drivers/lsm6ds3"
+
+import (
+	"machine"
+)
+
+type AccelRange uint8
+type AccelSampleRate uint8
+type AccelBandwidth uint8
+
+type GyroRange uint8
+type GyroSampleRate uint8
+
+// Device wraps an I2C connection to a LSM6DS3 device.
+type Device struct {
+	bus             machine.I2C
+	Address         uint16
+	accelRange      AccelRange
+	accelSampleRate AccelSampleRate
+	accelBandWidth  AccelBandwidth
+	gyroRange       GyroRange
+	gyroSampleRate  GyroSampleRate
+	dataBufferSix   []uint8
+	dataBufferTwo   []uint8
+}
+
+// Configuration for LSM6DS3 device.
+type Configuration struct {
+	AccelRange       AccelRange
+	AccelSampleRate  AccelSampleRate
+	AccelBandWidth   AccelBandwidth
+	GyroRange        GyroRange
+	GyroSampleRate   GyroSampleRate
+	IsPedometer      bool
+	ResetStepCounter bool
+}
+
+// New creates a new LSM6DS3 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: Address}
+}
+
+// Configure sets up the device for communication.
+func (d *Device) Configure(cfg Configuration) {
+	if cfg.AccelRange != 0 {
+		d.accelRange = cfg.AccelRange
+	} else {
+		d.accelRange = ACCEL_2G
+	}
+
+	if cfg.AccelSampleRate != 0 {
+		d.accelSampleRate = cfg.AccelSampleRate
+	} else {
+		d.accelSampleRate = ACCEL_SR_104
+	}
+
+	if cfg.AccelBandWidth != 0 {
+		d.accelBandWidth = cfg.AccelBandWidth
+	} else {
+		d.accelBandWidth = ACCEL_BW_100
+	}
+
+	if cfg.GyroRange != 0 {
+		d.gyroRange = cfg.GyroRange
+	} else {
+		d.gyroRange = GYRO_2000DPS
+	}
+
+	if cfg.GyroSampleRate != 0 {
+		d.gyroSampleRate = cfg.GyroSampleRate
+	} else {
+		d.gyroSampleRate = GYRO_SR_104
+	}
+
+	d.dataBufferSix = make([]uint8, 6)
+	d.dataBufferTwo = make([]uint8, 2)
+
+	if cfg.IsPedometer { // CONFIGURE AS PEDOMETER
+		// Configure accelerometer: 2G + 26Hz
+		d.bus.WriteRegister(uint8(d.Address), CTRL1_XL, []byte{uint8(ACCEL_2G) | uint8(ACCEL_SR_26)})
+
+		// Configure Zen_G, Yen_G, Xen_G, reset steps
+		if cfg.ResetStepCounter {
+			d.bus.WriteRegister(uint8(d.Address), CTRL10_C, []byte{0x3E})
+		} else {
+			d.bus.WriteRegister(uint8(d.Address), CTRL10_C, []byte{0x3C})
+		}
+
+		// Enable pedometer
+		d.bus.WriteRegister(uint8(d.Address), TAP_CFG, []byte{0x40})
+	} else { // NORMAL USE
+		// Configure accelerometer
+		data := make([]uint8, 1)
+		data[0] = uint8(d.accelRange) | uint8(d.accelSampleRate) | uint8(d.accelBandWidth)
+		d.bus.WriteRegister(uint8(d.Address), CTRL1_XL, data)
+
+		// Set ODR bit
+		d.bus.ReadRegister(uint8(d.Address), CTRL4_C, data)
+		data[0] = data[0] &^ BW_SCAL_ODR_ENABLED
+		data[0] |= BW_SCAL_ODR_ENABLED
+		d.bus.WriteRegister(uint8(d.Address), CTRL4_C, data)
+
+		// Configure gyroscope
+		data[0] = uint8(d.gyroRange) | uint8(d.gyroSampleRate)
+		d.bus.WriteRegister(uint8(d.Address), CTRL2_G, data)
+	}
+}
+
+// Connected returns whether a LSM6DS3 has been found.
+// It does a "who am I" request and checks the response.
+func (d *Device) Connected() bool {
+	data := []byte{0}
+	d.bus.ReadRegister(uint8(d.Address), WHO_AM_I, data)
+	return data[0] == 0x69
+}
+
+// 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) {
+	d.bus.ReadRegister(uint8(d.Address), OUTX_L_XL, d.dataBufferSix)
+	// k comes from "Table 3. Mechanical characteristics" 3 of the datasheet * 1000
+	k := int32(61) // 2G
+	if d.accelRange == ACCEL_4G {
+		k = 122
+	} else if d.accelRange == ACCEL_8G {
+		k = 244
+	} else if d.accelRange == ACCEL_16G {
+		k = 488
+	}
+	x = int32(int16((uint16(d.dataBufferSix[1])<<8)|uint16(d.dataBufferSix[0]))) * k
+	y = int32(int16((uint16(d.dataBufferSix[3])<<8)|uint16(d.dataBufferSix[2]))) * k
+	z = int32(int16((uint16(d.dataBufferSix[5])<<8)|uint16(d.dataBufferSix[4]))) * k
+	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 *Device) ReadRotation() (x int32, y int32, z int32) {
+	d.bus.ReadRegister(uint8(d.Address), OUTX_L_G, d.dataBufferSix)
+	// k comes from "Table 3. Mechanical characteristics" 3 of the datasheet * 1000
+	k := int32(4375) // 125DPS
+	if d.gyroRange == GYRO_250DPS {
+		k = 8750
+	} else if d.gyroRange == GYRO_500DPS {
+		k = 17500
+	} else if d.gyroRange == GYRO_1000DPS {
+		k = 35000
+	} else if d.gyroRange == GYRO_2000DPS {
+		k = 70000
+	}
+	x = int32(int16((uint16(d.dataBufferSix[1])<<8)|uint16(d.dataBufferSix[0]))) * k
+	y = int32(int16((uint16(d.dataBufferSix[3])<<8)|uint16(d.dataBufferSix[2]))) * k
+	z = int32(int16((uint16(d.dataBufferSix[5])<<8)|uint16(d.dataBufferSix[4]))) * k
+	return
+}
+
+// ReadTemperature returns the temperature in celsius milli degrees (°C/1000)
+func (d *Device) ReadTemperature() (int32, error) {
+	d.bus.ReadRegister(uint8(d.Address), OUT_TEMP_L, d.dataBufferTwo)
+
+	// From "Table 5. Temperature sensor characteristics"
+	// temp = value/16 + 25
+	t := 25000 + (int32(int16((int16(d.dataBufferTwo[1])<<8)|int16(d.dataBufferTwo[0])))*125)/2
+	return t, nil
+}
+
+// ReadSteps returns the steps of the pedometer
+func (d *Device) ReadSteps() int32 {
+	d.bus.ReadRegister(uint8(d.Address), STEP_COUNTER_L, d.dataBufferTwo)
+	return int32(int16((uint16(d.dataBufferTwo[1]) << 8) | uint16(d.dataBufferTwo[0])))
+}

lsm6ds3/registers.go

@@ -0,0 +1,83 @@
+package lsm6ds3
+
+// Constants/addresses used for I2C.
+
+// The I2C address which this device listens to.
+const Address = 0x6A
+
+const (
+	WHO_AM_I             = 0x0F
+	STATUS               = 0x1E
+	CTRL1_XL             = 0x10
+	CTRL2_G              = 0x11
+	CTRL3_C              = 0x12
+	CTRL4_C              = 0x13
+	CTRL5_C              = 0x14
+	CTRL6_C              = 0x15
+	CTRL7_G              = 0x16
+	CTRL8_XL             = 0x17
+	CTRL9_XL             = 0x18
+	CTRL10_C             = 0x19
+	OUTX_L_G             = 0x22
+	OUTX_H_G             = 0x23
+	OUTY_L_G             = 0x24
+	OUTY_H_G             = 0x25
+	OUTZ_L_G             = 0x26
+	OUTZ_H_G             = 0x27
+	OUTX_L_XL            = 0x28
+	OUTX_H_XL            = 0x29
+	OUTY_L_XL            = 0x2A
+	OUTY_H_XL            = 0x2B
+	OUTZ_L_XL            = 0x2C
+	OUTZ_H_XL            = 0x2D
+	OUT_TEMP_L           = 0x20
+	OUT_TEMP_H           = 0x21
+	BW_SCAL_ODR_DISABLED = 0x00
+	BW_SCAL_ODR_ENABLED  = 0x80
+	STEP_TIMESTAMP_L     = 0x49
+	STEP_TIMESTAMP_H     = 0x4A
+	STEP_COUNTER_L       = 0x4B
+	STEP_COUNTER_H       = 0x4C
+	STEP_COUNT_DELTA     = 0x15
+	TAP_CFG              = 0x58
+	INT1_CTRL            = 0x0D
+
+	ACCEL_2G  AccelRange = 0x00
+	ACCEL_4G  AccelRange = 0x08
+	ACCEL_8G  AccelRange = 0x0C
+	ACCEL_16G AccelRange = 0x04
+
+	ACCEL_SR_OFF   AccelSampleRate = 0x00
+	ACCEL_SR_13    AccelSampleRate = 0x10
+	ACCEL_SR_26    AccelSampleRate = 0x20
+	ACCEL_SR_52    AccelSampleRate = 0x30
+	ACCEL_SR_104   AccelSampleRate = 0x40
+	ACCEL_SR_208   AccelSampleRate = 0x50
+	ACCEL_SR_416   AccelSampleRate = 0x60
+	ACCEL_SR_833   AccelSampleRate = 0x70
+	ACCEL_SR_1666  AccelSampleRate = 0x80
+	ACCEL_SR_3332  AccelSampleRate = 0x90
+	ACCEL_SR_6664  AccelSampleRate = 0xA0
+	ACCEL_SR_13330 AccelSampleRate = 0xB0
+
+	ACCEL_BW_50  AccelBandwidth = 0x03
+	ACCEL_BW_100 AccelBandwidth = 0x02
+	ACCEL_BW_200 AccelBandwidth = 0x01
+	ACCEL_BW_400 AccelBandwidth = 0x00
+
+	//GYRO_125DPS  GyroRange = 0x01
+	GYRO_250DPS  GyroRange = 0x00
+	GYRO_500DPS  GyroRange = 0x04
+	GYRO_1000DPS GyroRange = 0x08
+	GYRO_2000DPS GyroRange = 0x0C
+
+	GYRO_SR_OFF  GyroSampleRate = 0x00
+	GYRO_SR_13   GyroSampleRate = 0x10
+	GYRO_SR_26   GyroSampleRate = 0x20
+	GYRO_SR_52   GyroSampleRate = 0x30
+	GYRO_SR_104  GyroSampleRate = 0x40
+	GYRO_SR_208  GyroSampleRate = 0x50
+	GYRO_SR_416  GyroSampleRate = 0x60
+	GYRO_SR_833  GyroSampleRate = 0x70
+	GYRO_SR_1666 GyroSampleRate = 0x80
+)

mag3110/mag3110.go

@@ -50,7 +50,7 @@ func (d Device) ReadMagnetic() (x int16, y int16, z int16) {
 }
 
 // ReadTemperature reads and returns the current die temperature in
-// celsius milli degrees (ºC/1000).
+// celsius milli degrees (°C/1000).
 func (d Device) ReadTemperature() (int32, error) {
 	data := make([]byte, 1)
 	d.bus.ReadRegister(uint8(d.Address), DIE_TEMP, data)

mcp3008/mcp3008.go

@@ -0,0 +1,92 @@
+// Package mcp3008 implements a driver for the MCP3008 Analog to Digital Converter.
+//
+// Datasheet: http://ww1.microchip.com/downloads/en/DeviceDoc/21295d.pdf
+//
+package mcp3008 // import "tinygo.org/x/drivers/mcp3008"
+
+import (
+	"errors"
+	"machine"
+)
+
+// Device wraps MCP3008 SPI ADC.
+type Device struct {
+	bus machine.SPI
+	cs  machine.Pin
+	tx  []byte
+	rx  []byte
+	CH0 ADCPin
+	CH1 ADCPin
+	CH2 ADCPin
+	CH3 ADCPin
+	CH4 ADCPin
+	CH5 ADCPin
+	CH6 ADCPin
+	CH7 ADCPin
+}
+
+// ADCPin is the implementation of the ADConverter interface.
+type ADCPin struct {
+	machine.Pin
+	d *Device
+}
+
+// New returns a new MCP3008 driver. Pass in a fully configured SPI bus.
+func New(b machine.SPI, csPin machine.Pin) *Device {
+	d := &Device{bus: b,
+		cs: csPin,
+		tx: make([]byte, 3),
+		rx: make([]byte, 3),
+	}
+
+	// setup all channels
+	d.CH0 = d.GetADC(0)
+	d.CH1 = d.GetADC(1)
+	d.CH2 = d.GetADC(2)
+	d.CH3 = d.GetADC(3)
+	d.CH4 = d.GetADC(4)
+	d.CH5 = d.GetADC(5)
+	d.CH6 = d.GetADC(6)
+	d.CH7 = d.GetADC(7)
+
+	return d
+}
+
+// Configure sets up the device for communication
+func (d *Device) Configure() {
+	d.cs.Configure(machine.PinConfig{Mode: machine.PinOutput})
+}
+
+// Read analog data from channel
+func (d *Device) Read(ch int) (uint16, error) {
+	if ch < 0 || ch > 7 {
+		return 0, errors.New("invalid channel for MCP3008 Read")
+	}
+
+	return d.GetADC(ch).Get(), nil
+}
+
+// GetADC returns an ADC for a specific channel.
+func (d *Device) GetADC(ch int) ADCPin {
+	return ADCPin{machine.Pin(ch), d}
+}
+
+// Get the current reading for a specific ADCPin.
+func (p ADCPin) Get() uint16 {
+	p.d.tx[0] = 0x01
+	p.d.tx[1] = byte(8+p.Pin) << 4
+	p.d.tx[2] = 0x00
+
+	p.d.cs.Low()
+	p.d.bus.Tx(p.d.tx, p.d.rx)
+
+	// scale result to 16bit value like other ADCs
+	result := uint16((p.d.rx[1]&0x3))<<8 + uint16(p.d.rx[2])<<6
+	p.d.cs.High()
+
+	return result
+}
+
+// Configure here just for interface compatibility.
+func (p ADCPin) Configure() {
+}

microphone/microphone.go

@@ -0,0 +1,173 @@
+// Package microphone implements a driver for a PDM microphone.
+// For example, the Adafruit PDM MEMS breakout board (https://www.adafruit.com/product/3492)
+//
+// Datasheet: https://cdn-learn.adafruit.com/assets/assets/000/049/977/original/MP34DT01-M.pdf
+//
+package microphone // import "tinygo.org/x/drivers/microphone"
+
+import (
+	"machine"
+	"math"
+)
+
+const (
+	defaultSampleRate        = 22000
+	quantizeSteps            = 64
+	msForSPLSample           = 50
+	defaultSampleCountForSPL = (defaultSampleRate / 1000) * msForSPLSample
+	defaultGain              = 9.0
+	defaultRefLevel          = 0.00002
+)
+
+// Device wraps an I2S connection to a PDM microphone device.
+type Device struct {
+	bus machine.I2S
+
+	// data buffer used for SPL sound pressure level samples
+	data []int32
+
+	// buf buffer used for sinc filter
+	buf []uint32
+
+	// SampleCountForSPL is number of samples aka size of data buffer to be used
+	// for sound pressure level measurement.
+	// Once Configure() is called, changing this value has no effect.
+	SampleCountForSPL int
+
+	// Gain setting used to calculate sound pressure level
+	Gain float64
+
+	// ReferenceLevel setting used to calculate sound pressure level.
+	ReferenceLevel float64
+}
+
+// New creates a new microphone connection. The I2S bus must already be
+// configured.
+//
+// This function only creates the Device object, it does not touch the device.
+func New(bus machine.I2S) Device {
+	return Device{
+		bus:               bus,
+		SampleCountForSPL: defaultSampleCountForSPL,
+		Gain:              defaultGain,
+		ReferenceLevel:    defaultRefLevel,
+	}
+}
+
+// Configure the microphone.
+func (d *Device) Configure() {
+	d.data = make([]int32, d.SampleCountForSPL)
+	d.buf = make([]uint32, (quantizeSteps / 16))
+}
+
+// Read the raw microphone data.
+func (d *Device) Read(r []int32) (int, error) {
+	count := len(r)
+
+	// get the next group of samples
+	machine.I2S0.Read(d.buf)
+
+	if len(r) > len(d.buf) {
+		count = len(d.buf)
+	}
+	for i := 0; i < count; i++ {
+		r[i] = int32(d.buf[i])
+	}
+
+	return count, nil
+}
+
+// ReadWithFilter reads the microphone and filters the buffer using the sinc filter.
+func (d *Device) ReadWithFilter(r []int32) (int, error) {
+	// read/filter the samples
+	var sum uint16
+	for i := 0; i < len(r); i++ {
+
+		// get the next group of samples
+		machine.I2S0.Read(d.buf)
+
+		// filter
+		sum = applySincFilter(d.buf)
+
+		// adjust to 10 bit value
+		s := int32(sum >> 6)
+
+		// make it close to 0-offset signed
+		s -= 512
+
+		r[i] = s
+	}
+
+	return len(r), nil
+}
+
+// GetSoundPressure returns the sound pressure in milli-decibels.
+func (d *Device) GetSoundPressure() (int32, int32) {
+	// read/filter the samples
+	d.ReadWithFilter(d.data)
+
+	// remove offset
+	var avg int32
+	for i := 0; i < len(d.data); i++ {
+		avg += d.data[i]
+	}
+	avg /= int32(len(d.data))
+
+	for i := 0; i < len(d.data); i++ {
+		d.data[i] -= avg
+	}
+
+	// get max value
+	var maxval int32
+	for i := 0; i < len(d.data); i++ {
+		v := d.data[i]
+		if v < 0 {
+			v = -v
+		}
+		if maxval < v {
+			maxval = v
+		}
+	}
+
+	// calculate SPL
+	spl := float64(maxval) / 1023.0 * d.Gain
+	spl = 20 * math.Log10(spl/d.ReferenceLevel)
+
+	return int32(spl * 1000), maxval
+}
+
+// sinc filter for 44 khz with 64 samples
+// each value matches the corresponding bit in the 8-bit value
+// for that sample.
+//
+// For more information: https://en.wikipedia.org/wiki/Sinc_filter
+//
+var sincfilter = [quantizeSteps]uint16{
+	0, 2, 9, 21, 39, 63, 94, 132,
+	179, 236, 302, 379, 467, 565, 674, 792,
+	920, 1055, 1196, 1341, 1487, 1633, 1776, 1913,
+	2042, 2159, 2263, 2352, 2422, 2474, 2506, 2516,
+	2506, 2474, 2422, 2352, 2263, 2159, 2042, 1913,
+	1776, 1633, 1487, 1341, 1196, 1055, 920, 792,
+	674, 565, 467, 379, 302, 236, 179, 132,
+	94, 63, 39, 21, 9, 2, 0, 0,
+}
+
+// applySincFilter uses the sinc filter to process a single set of sample values.
+func applySincFilter(samples []uint32) (result uint16) {
+	var sample uint16
+	pos := 0
+	for j := 0; j < len(samples); j++ {
+		// takes only the low order 16-bits
+		sample = uint16(samples[j] & 0xffff)
+		for i := 0; i < 16; i++ {
+			if (sample & 0x1) > 0 {
+				result += sincfilter[pos]
+				pos++
+			}
+			sample >>= 1
+		}
+	}
+
+	return
+}