ws2812: add SPI based implementation

This is useful because it allows using the WS2812 driver on platforms
without bitbanged WS2812 support and it may be the only option if
disabling interrupts is impossible or impractical.

.circleci/config.yml

@@ -6,13 +6,15 @@ jobs:
   build:
     docker:
       - image: tinygo/tinygo-dev
-    working_directory: /usr/local/go/src/tinygo.org/x/drivers
     steps:
       - checkout
       - run: tinygo version
       - run:
           name: "Enforce Go Formatted Code"
           command: make fmt-check
+      - run:
+          name: "Run unit tests"
+          command: make unit-test
       - run:
           name: "Run build and smoke tests"
           command: make smoke-test

CHANGELOG.md

@@ -1,3 +1,217 @@
+0.14.0
+---
+- **new devices**
+    - lis2mdl: add LIS2MDL magnetometer (#187)
+    - waveshare: add Waveshare 4.2in B/W e-paper driver (#183)
+- **enhancements**
+    - adt7410: add connection test and for that matter connection method
+    - gps
+        - add speed and heading to fix, as parsed from RMC NMEA sentence
+        - improvements and bugfixes (#186)
+    - ili9341
+        - add support for setting framerate, vsync pause, and reading scanline data.
+        - renamed NewSpi() to NewSPI() in accordance with Go naming conventions
+    - ws2812
+        - add support for ESP8266
+        - add support for ESP32
+- **bugfixes**
+    - ili9341
+        - rix setWindow bug, add CS pin for Clue compatibility. (#180)
+        - bugfix for RAMWR bug
+    - lis2mdl: turn on read mode on every read, to ensure that magnetometer data is updated
+- **core**
+    - i2c
+        - switch all i2c drivers definitions to use i2c bus interface type instead of machine package concrete type
+        - correct interface definition for I2C Tx function
+- **testing**
+    - fix smoke-test unless avr-gcc installed
+    - add very basic mock structs for testing i2c devices, based on work done by @rogpeppe
+    - improve API surface and implement one more test function in lis2mdl driver
+- **docs**
+    - replace README badge for godocs with pkgdocs
+
+0.13.0
+---
+- **new devices**
+    - bmi160: add initial support
+    - bmp280: added support for the Bosch BMP280 temperature and pressure sensor. (#158)
+    - lsm303agr: add lsm303agr (#162)
+    - ssd1351: add SSD1351 OLED display driver (#146)
+- **enhancements**
+    - hd44780: add Hd44780i2c driver (#173)
+    - ili9341
+        - add ILI9341 TFT driver (SPI) for ATSAMD2x (#174)
+        - cache address window to prevent sending unnecessary commands (#171)
+        - ILI9341 TFT driver (SPI) (#153)
+        - improve performance of ILI9341 on ATSAMD5X
+    - ST77xx: fix DrawFastHLine for ST77xx, SSD1331 and SSD1351 DrawFastHLine uses FillRectangle(x,y,width,height,c), so height must be 1 to draw a horizontal line
+    - tmp102: add Connected func to check for device
+    - wifinina: added UDP support
+    - ws2812: update ws2812_avr_16m.go
+- **bugfixes**
+    - apa102: avoid creating garbage
+    - bmp180: fix temperature type conversion
+- **core**
+    - all
+        - added custom import path (#161)
+        - changeover to eliminate all direct use of master/slave terminology
+    - build: try vendor in working directory to match expected module path
+    - ci: support Go modules
+    - modules: update go version and dependency
+- **docs**
+    - docs: reorder to correct alpha and adjust count of supported drivers
+
+0.12.0
+---
+- **new devices**
+    - hcsr04: Added HC-SR04 ultrasonic distance sensor. (#143)
+    - spi/qspi: Low-level IO driver for serial flash memory via SPI and QSPI (#124)
+    - tmp102: TMP102 low-power digital temperature sensor (#141)
+    - amg88xx: AMG88xx thermal camera module
+- **bugfixes**
+    - mqtt: reduce use of goroutines in router to not start a new goroutine for each invocation of each callback
+
+0.11.0
+---
+- **new devices**
+    - 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,9 +16,11 @@ 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.
+The `release` branch of this repo will always have the latest released version of the TinyGo drivers. All of the active development work for the next release will take place in the `dev` branch. The TinyGo drivers will use semantic versioning and will create a tag/release for each release.
 
 Here is how to contribute back some code or documentation:
 

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,164 @@ 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/bmi160/main.go
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=itsybitsy-m0 ./examples/bmp180/main.go
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=itsybitsy-m0 ./examples/bmp280/main.go
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=bluepill ./examples/ds1307/sram/main.go
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=bluepill ./examples/ds1307/time/main.go
+	@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=arduino-nano33 ./examples/hd44780i2c/main.go
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=microbit ./examples/hub75/main.go
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=pyportal ./examples/ili9341/basic
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=xiao ./examples/ili9341/basic
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=pyportal ./examples/ili9341/pyportal_boing
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=pyportal ./examples/ili9341/scroll
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=xiao ./examples/ili9341/scroll
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=circuitplay-express ./examples/lis3dh/main.go
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=microbit ./examples/lsm303agr/main.go
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=arduino-nano33 ./examples/lsm6ds3/main.go
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=itsybitsy-m0 ./examples/mag3110/main.go
+	@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=microbit ./examples/waveshare-epd/epd4in2/main.go
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=arduino-nano33 ./examples/wifinina/ntpclient/main.go
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=arduino-nano33 ./examples/wifinina/udpstation/main.go
+	@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
+ifneq ($(AVR), 0)
+	tinygo build -size short -o ./build/test.hex -target=arduino   ./examples/ws2812
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=digispark ./examples/ws2812
+	@md5sum ./build/test.hex
+endif
+	tinygo build -size short -o ./build/test.hex -target=trinket-m0 ./examples/bme280/main.go
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=circuitplay-express ./examples/microphone/main.go
+	@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
+	tinygo build -size short -o ./build/test.hex -target=hifive1b ./examples/ssd1351/main.go
+	@md5sum ./build/test.hex
+	tinygo build -size short -o ./build/test.hex -target=circuitplay-express ./examples/lis2mdl/main.go
+	@md5sum ./build/test.hex
 
-test: clean fmt-check smoke-test
+DRIVERS = $(wildcard */)
+NOTESTS = build examples flash semihosting pcd8544 shiftregister st7789 microphone mcp3008 gps microbitmatrix \
+		hcsr04 ssd1331 ws2812 thermistor apa102 easystepper ssd1351 ili9341 wifinina shifter hub75 \
+		hd44780 buzzer ssd1306 espat l9110x st7735 bmi160 l293x
+TESTS = $(filter-out $(addsuffix /%,$(NOTESTS)),$(DRIVERS))
+
+unit-test:
+	@go test -v $(addprefix ./,$(TESTS)) 
+
+test: clean fmt-check unit-test 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)
+[![PkgGoDev](https://pkg.go.dev/badge/tinygo.org/x/drivers)](https://pkg.go.dev/tinygo.org/x/drivers) [![CircleCI](https://circleci.com/gh/tinygo-org/drivers/tree/dev.svg?style=svg)](https://circleci.com/gh/tinygo-org/drivers/tree/dev)
 
 
 This package provides a collection of hardware drivers for devices that can be used together with [TinyGo](https://tinygo.org).
@@ -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,62 @@ func main() {
 
 ## Currently supported devices
 
+The following 53 devices are supported.
+
 | Device Name | Interface Type |
 |----------|-------------|
+| [ADT7410 I2C Temperature Sensor](https://www.analog.com/media/en/technical-documentation/data-sheets/ADT7410.pdf) | I2C |
 | [ADXL345 accelerometer](http://www.analog.com/media/en/technical-documentation/data-sheets/ADXL345.pdf) | I2C |
+| [AMG88xx 8x8 Thermal camera sensor](https://cdn-learn.adafruit.com/assets/assets/000/043/261/original/Grid-EYE_SPECIFICATIONS%28Reference%29.pdf) | I2C |
 | [APA102 RGB LED](https://cdn-shop.adafruit.com/product-files/2343/APA102C.pdf) | SPI |
+| [AT24CX 2-wire serial EEPROM](https://www.openimpulse.com/blog/wp-content/uploads/wpsc/downloadables/24C32-Datasheet.pdf) | I2C |
+| [BBC micro:bit LED matrix](https://github.com/bbcmicrobit/hardware/blob/master/SCH_BBC-Microbit_V1.3B.pdf) | GPIO |
 | [BH1750 ambient light sensor](https://www.mouser.com/ds/2/348/bh1750fvi-e-186247.pdf) | I2C |
 | [BlinkM RGB LED](http://thingm.com/fileadmin/thingm/downloads/BlinkM_datasheet.pdf) | I2C |
+| [BME280 humidity/pressure sensor](https://cdn-shop.adafruit.com/datasheets/BST-BME280_DS001-10.pdf) | I2C |
+| [BMI160 accelerometer/gyroscope](https://www.bosch-sensortec.com/media/boschsensortec/downloads/datasheets/bst-bmi160-ds000.pdf) | SPI |
 | [BMP180 barometer](https://cdn-shop.adafruit.com/datasheets/BST-BMP180-DS000-09.pdf) | I2C |
+| [BMP280 temperature/barometer](https://www.bosch-sensortec.com/media/boschsensortec/downloads/datasheets/bst-bmp280-ds001.pdf) | I2C |
+| [Buzzer](https://en.wikipedia.org/wiki/Buzzer#Piezoelectric) | GPIO |
 | [DS1307 real time clock](https://datasheets.maximintegrated.com/en/ds/DS1307.pdf) | I2C |
 | [DS3231 real time clock](https://datasheets.maximintegrated.com/en/ds/DS3231.pdf) | I2C |
-| ["Easystepper" stepper motor controller](https://en.wikipedia.org/wiki/Stepper_motor) | GPIO |
+| [ESP32 as WiFi Coprocessor with Arduino nina-fw](https://github.com/arduino/nina-fw) | SPI |
 | [ESP8266/ESP32 AT Command set for WiFi/TCP/UDP](https://github.com/espressif/esp32-at) | UART |
 | [GPS module](https://www.u-blox.com/en/product/neo-6-series) | I2C/UART |
+| [HC-SR04 Ultrasonic distance sensor](https://cdn.sparkfun.com/datasheets/Sensors/Proximity/HCSR04.pdf) | GPIO |
+| [HD44780 LCD controller](https://www.sparkfun.com/datasheets/LCD/HD44780.pdf) | GPIO/I2C |
 | [HUB75 RGB led matrix](https://cdn-learn.adafruit.com/downloads/pdf/32x16-32x32-rgb-led-matrix.pdf) | SPI |
+| [ILI9341 TFT color display](https://cdn-shop.adafruit.com/datasheets/ILI9341.pdf) | SPI |
+| [L293x motor driver](https://www.ti.com/lit/ds/symlink/l293d.pdf) | GPIO/PWM |
+| [L9110x motor driver](https://www.elecrow.com/download/datasheet-l9110.pdf) | GPIO/PWM |
+| [LIS2MDL magnetometer](https://www.st.com/resource/en/datasheet/lis2mdl.pdf) | I2C |
 | [LIS3DH accelerometer](https://www.st.com/resource/en/datasheet/lis3dh.pdf) | I2C |
+| [LSM6DS3 accelerometer](https://www.st.com/resource/en/datasheet/lsm6ds3.pdf) | I2C |
 | [MAG3110 magnetometer](https://www.nxp.com/docs/en/data-sheet/MAG3110.pdf) | I2C |
-| [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 |
+| [SSD1351 OLED display](https://download.mikroe.com/documents/datasheets/ssd1351-revision-1.3.pdf) | SPI |
+| [ST7735 TFT color display](https://www.crystalfontz.com/controllers/Sitronix/ST7735R/319/) | SPI |
+| [ST7789 TFT color display](https://cdn-shop.adafruit.com/product-files/3787/3787_tft_QT154H2201__________20190228182902.pdf) | SPI |
+| [Stepper motor "Easystepper" controller](https://en.wikipedia.org/wiki/Stepper_motor) | GPIO |
 | [Thermistor](https://www.farnell.com/datasheets/33552.pdf) | ADC |
+| [TMP102 I2C Temperature Sensor](https://download.mikroe.com/documents/datasheets/tmp102-data-sheet.pdf) | I2C |
+| [VEML6070 UV light sensor](https://www.vishay.com/docs/84277/veml6070.pdf) | I2C |
 | [VL53L1X time-of-flight distance sensor](https://www.st.com/resource/en/datasheet/vl53l1x.pdf) | I2C |
-| [Waveshare 2.13" e-paper display](https://www.waveshare.com/w/upload/e/e6/2.13inch_e-Paper_Datasheet.pdf) | SPI |
 | [Waveshare 2.13" (B & C) e-paper display](https://www.waveshare.com/w/upload/d/d3/2.13inch-e-paper-b-Specification.pdf) | SPI |
+| [Waveshare 2.13" e-paper display](https://www.waveshare.com/w/upload/e/e6/2.13inch_e-Paper_Datasheet.pdf) | SPI |
+| [Waveshare 4.2" e-paper B/W display](https://www.waveshare.com/w/upload/6/6a/4.2inch-e-paper-specification.pdf) | SPI |
 | [WS2812 RGB LED](https://cdn-shop.adafruit.com/datasheets/WS2812.pdf) | GPIO |
 
 ## Contributing

adt7410/adt7410.go

@@ -0,0 +1,92 @@
+// Package adt7410 provides a driver for the adt7410 I2C Temperature Sensor.
+//
+// Datasheet: https://www.analog.com/media/en/technical-documentation/data-sheets/ADT7410.pdf
+//
+package adt7410 // import "tinygo.org/x/drivers/adt7410"
+
+import (
+	"time"
+
+	"tinygo.org/x/drivers"
+)
+
+type Error uint8
+
+const (
+	ErrInvalidID Error = 0x1
+)
+
+func (e Error) Error() string {
+	switch e {
+	case ErrInvalidID:
+		return "Invalid chip ID"
+	default:
+		return "Unknown error"
+	}
+}
+
+type Device struct {
+	bus     drivers.I2C
+	buf     []byte
+	Address uint8
+}
+
+// New returns ADT7410 device for the provided I2C bus using default address.
+// of 0x48 (1001000).  To use multiple ADT7410 devices, the last 2 bits of the address
+// can be set using by connecting to the A1 and A0 pins to VDD or GND (for a
+// total of up to 4 devices on a I2C bus).  Also note that 10k pullups are
+// recommended for the SDA and SCL lines.
+func New(i2c drivers.I2C) *Device {
+	return &Device{
+		bus:     i2c,
+		buf:     make([]byte, 2),
+		Address: Address,
+	}
+}
+
+// Configure the ADT7410 device.
+func (d *Device) Configure() (err error) {
+	// reset the chip
+	d.writeByte(RegReset, 0xFF)
+	time.Sleep(10 * time.Millisecond)
+	return
+}
+
+// Connected returns whether sensor has been found.
+func (d *Device) Connected() bool {
+	data := []byte{0}
+	d.bus.ReadRegister(uint8(d.Address), RegID, data)
+	return data[0]&0xF8 == 0xC8
+}
+
+// ReadTemperature returns the temperature in celsius milli degrees (°C/1000)
+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 Celsius.
+func (d *Device) ReadTempC() float32 {
+	t := d.readUint16(RegTempValueMSB)
+	return float32(int(t)) / 128.0
+}
+
+// ReadTempF returns the value in the temperature value register, in Fahrenheit.
+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.Address), d.buf, nil)
+}
+
+func (d *Device) readByte(reg uint8) byte {
+	d.bus.ReadRegister(d.Address, reg, d.buf)
+	return d.buf[0]
+}
+
+func (d *Device) readUint16(reg uint8) uint16 {
+	d.bus.ReadRegister(d.Address, reg, d.buf)
+	return uint16(d.buf[0])<<8 | uint16(d.buf[1])
+}

adt7410/adt7410_test.go

@@ -0,0 +1,49 @@
+package adt7410
+
+import (
+	"testing"
+
+	qt "github.com/frankban/quicktest"
+	"tinygo.org/x/drivers/tester"
+)
+
+func TestDefaultI2CAddress(t *testing.T) {
+	c := qt.New(t)
+	bus := tester.NewI2CBus(c)
+	dev := New(bus)
+	c.Assert(dev.Address, qt.Equals, uint8(Address))
+}
+
+func TestWhoAmI(t *testing.T) {
+	c := qt.New(t)
+	bus := tester.NewI2CBus(c)
+	fake := tester.NewI2CDevice(c, Address)
+	fake.SetupRegisters(defaultRegisters())
+	bus.AddDevice(fake)
+
+	dev := New(bus)
+	c.Assert(dev.Connected(), qt.Equals, true)
+
+	fake.SetupRegister(RegID, 0x99)
+	c.Assert(dev.Connected(), qt.Equals, false)
+}
+
+// defaultRegisters returns the default values for all of the device's registers.
+// see table 22 on page 27 of the datasheet.
+func defaultRegisters() []uint8 {
+	return []uint8{
+		RegTempValueMSB: 0,
+		RegTempValueLSB: 0,
+		RegStatus:       0,
+		RegConfig:       0,
+		RegTHIGHMsbReg:  0x20,
+		RegTHIGHLsbReg:  0,
+		RegTLOWMsbReg:   0x05,
+		RegTLOWLsbReg:   0,
+		RegTCRITMsbReg:  0x49,
+		RegTCRITLsbReg:  0x80,
+		RegTHYSTReg:     0x05,
+		RegID:           0xC8,
+		RegReset:        0,
+	}
+}

adt7410/registers.go

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

adxl345/adxl345.go

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

amg88xx/amg88xx.go

@@ -0,0 +1,159 @@
+// 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 (
+	"time"
+
+	"tinygo.org/x/drivers"
+)
+
+// Device wraps an I2C connection to a AMG88xx device.
+type Device struct {
+	bus             drivers.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 drivers.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

@@ -6,6 +6,8 @@ package apa102 // import "tinygo.org/x/drivers/apa102"
 import (
 	"image/color"
 	"machine"
+
+	"tinygo.org/x/drivers"
 )
 
 const (
@@ -19,17 +21,25 @@ const (
 	GRB
 )
 
+var startFrame = []byte{0x00, 0x00, 0x00, 0x00}
+
 // Device wraps APA102 SPI LEDs.
 type Device struct {
-	bus   machine.SPI
+	bus   drivers.SPI
 	Order int
 }
 
 // New returns a new APA102 driver. Pass in a fully configured SPI bus.
-func New(b machine.SPI) Device {
+func New(b drivers.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, sdoPin machine.Pin, delay uint32) Device {
+	return New(&bbSPI{SCK: sckPin, SDO: sdoPin, Delay: delay})
+}
+
 // WriteColors writes the given RGBA color slice out using the APA102 protocol.
 // 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) {
@@ -38,22 +48,22 @@ func (d Device) WriteColors(cs []color.RGBA) (n int, err error) {
 	// write data
 	for _, c := range cs {
 		// brightness is scaled to 5 bit value
-		d.bus.Tx([]byte{0xe0 | (c.A >> 3)}, nil)
+		d.bus.Transfer(0xe0 | (c.A >> 3))
 
 		// set the colors
 		switch d.Order {
 		case BRG:
-			d.bus.Tx([]byte{c.B}, nil)
-			d.bus.Tx([]byte{c.R}, nil)
-			d.bus.Tx([]byte{c.G}, nil)
+			d.bus.Transfer(c.B)
+			d.bus.Transfer(c.R)
+			d.bus.Transfer(c.G)
 		case GRB:
-			d.bus.Tx([]byte{c.G}, nil)
-			d.bus.Tx([]byte{c.R}, nil)
-			d.bus.Tx([]byte{c.B}, nil)
+			d.bus.Transfer(c.G)
+			d.bus.Transfer(c.R)
+			d.bus.Transfer(c.B)
 		case BGR:
-			d.bus.Tx([]byte{c.B}, nil)
-			d.bus.Tx([]byte{c.G}, nil)
-			d.bus.Tx([]byte{c.R}, nil)
+			d.bus.Transfer(c.B)
+			d.bus.Transfer(c.G)
+			d.bus.Transfer(c.R)
 		}
 	}
 
@@ -73,7 +83,7 @@ func (d Device) Write(buf []byte) (n int, err error) {
 
 // startFrame sends the start bytes for a strand of LEDs.
 func (d Device) startFrame() {
-	d.bus.Tx([]byte{0x00, 0x00, 0x00, 0x00}, nil)
+	d.bus.Tx(startFrame, nil)
 }
 
 // endFrame sends the end frame marker with one extra bit per LED so
@@ -81,6 +91,6 @@ func (d Device) startFrame() {
 // See https://cpldcpu.wordpress.com/2014/11/30/understanding-the-apa102-superled/
 func (d Device) endFrame(count int) {
 	for i := 0; i < count/16; i++ {
-		d.bus.Tx([]byte{0xff}, nil)
+		d.bus.Transfer(0xff)
 	}
 }

apa102/softspi.go

@@ -0,0 +1,70 @@
+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
+	SDO   machine.Pin
+	Delay uint32
+}
+
+// Configure sets up the SCK and SDO pins as outputs and sets them low
+func (s *bbSPI) Configure() {
+	s.SCK.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	s.SDO.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	s.SCK.Low()
+	s.SDO.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 matches signature of machine.SPI.Transfer() and is used to send a
+// single byte. The received data is ignored and no error will ever be returned.
+func (s *bbSPI) Transfer(b byte) (byte, error) {
+	for i := uint8(0); i < 8; i++ {
+
+		// half clock cycle high to start
+		s.SCK.High()
+		s.delay()
+
+		// write the value to SDO (MSB first)
+		if b&(1<<(7-i)) == 0 {
+			s.SDO.Low()
+		} else {
+			s.SDO.High()
+		}
+		s.delay()
+
+		// half clock cycle low
+		s.SCK.Low()
+		s.delay()
+
+		// for actual SPI would try to read the SDI value here
+		s.delay()
+	}
+
+	return 0, nil
+}

at24cx/at24cx.go

@@ -0,0 +1,172 @@
+// 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"
+	"time"
+
+	"tinygo.org/x/drivers"
+)
+
+// Device wraps an I2C connection to a DS3231 device.
+type Device struct {
+	bus               drivers.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 drivers.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

bh1750/bh1750.go

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

blinkm/blinkm.go

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

bme280/bme280.go

@@ -0,0 +1,258 @@
+// 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 (
+	"math"
+
+	"tinygo.org/x/drivers"
+)
+
+// 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                     drivers.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 drivers.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
+)

bmi160/bmi160.go

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

bmi160/registers.go

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

bmp180/bmp180.go

@@ -9,7 +9,7 @@ package bmp180 // import "tinygo.org/x/drivers/bmp180"
 import (
 	"time"
 
-	"machine"
+	"tinygo.org/x/drivers"
 )
 
 // OversamplingMode is the oversampling ratio of the pressure measurement.
@@ -32,7 +32,7 @@ type calibrationCoefficients struct {
 
 // Device wraps an I2C connection to a BMP180 device.
 type Device struct {
-	bus                     machine.I2C
+	bus                     drivers.I2C
 	Address                 uint16
 	mode                    OversamplingMode
 	calibrationCoefficients calibrationCoefficients
@@ -43,7 +43,7 @@ type Device struct {
 //
 // This function only creates the Device object, it does not initialize the device.
 // You must call Configure() first in order to use the device itself.
-func New(bus machine.I2C) Device {
+func New(bus drivers.I2C) Device {
 	return Device{
 		bus:     bus,
 		Address: Address,
@@ -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 {
@@ -125,7 +125,7 @@ func (d *Device) ReadPressure() (pressure int32, err error) {
 }
 
 // rawTemp returns the sensor's raw values of the temperature
-func (d *Device) rawTemp() (int16, error) {
+func (d *Device) rawTemp() (int32, error) {
 	d.bus.WriteRegister(uint8(d.Address), REG_CTRL, []byte{CMD_TEMP})
 	time.Sleep(5 * time.Millisecond)
 	data := make([]byte, 2)
@@ -133,12 +133,12 @@ func (d *Device) rawTemp() (int16, error) {
 	if err != nil {
 		return 0, err
 	}
-	return readInt(data[0], data[1]), nil
+	return int32(uint16(data[0])<<8 | uint16(data[1])), nil
 }
 
 // calculateB5 calculates intermediate value B5 as per page 15 of datasheet
-func (d *Device) calculateB5(rawTemp int16) int32 {
-	x1 := (int32(rawTemp) - int32(d.calibrationCoefficients.ac6)) * int32(d.calibrationCoefficients.ac5) >> 15
+func (d *Device) calculateB5(rawTemp int32) int32 {
+	x1 := (rawTemp - int32(d.calibrationCoefficients.ac6)) * int32(d.calibrationCoefficients.ac5) >> 15
 	x2 := int32(d.calibrationCoefficients.mc) << 11 / (x1 + int32(d.calibrationCoefficients.md))
 	return x1 + x2
 }

bmp280/bmp280.go

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

bmp280/registers.go

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

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

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

ds3231/ds3231.go

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

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

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

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

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

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

examples/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/ds1307/time/main.go

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

examples/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"
+
+	console_example "tinygo.org/x/drivers/examples/flash/console"
+	"tinygo.org/x/drivers/flash"
+)
+
+func main() {
+	console_example.RunFor(
+		flash.NewSPI(
+			&machine.SPI1,
+			machine.SPI1_SDO_PIN,
+			machine.SPI1_SDI_PIN,
+			machine.SPI1_SCK_PIN,
+			machine.SPI1_CS_PIN,
+		),
+	)
+}

examples/gps/i2c/main.go

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

examples/gps/uart/main.go

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

examples/hcsr04/main.go

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

examples/hd44780i2c/main.go

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

examples/ili9341/basic/atsamd21.go

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

examples/ili9341/basic/main.go

@@ -0,0 +1,38 @@
+package main
+
+import (
+	"image/color"
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/ili9341"
+)
+
+var (
+	black = color.RGBA{0, 0, 0, 255}
+	white = color.RGBA{255, 255, 255, 255}
+	red   = color.RGBA{255, 0, 0, 255}
+	blue  = color.RGBA{0, 0, 255, 255}
+	green = color.RGBA{0, 255, 0, 255}
+)
+
+func main() {
+
+	backlight.Configure(machine.PinConfig{machine.PinOutput})
+
+	display.Configure(ili9341.Config{})
+	width, height := display.Size()
+
+	display.FillScreen(black)
+	backlight.High()
+
+	display.FillRectangle(0, 0, width/2, height/2, white)
+	display.FillRectangle(width/2, 0, width/2, height/2, red)
+	display.FillRectangle(0, height/2, width/2, height/2, green)
+	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/basic/pyportal.go

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

examples/ili9341/basic/wioterminal.go

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

examples/ili9341/pyportal_boing/main.go

@@ -0,0 +1,225 @@
+// 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 (
+	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
+	backlight.Configure(machine.PinConfig{machine.PinOutput})
+
+	// configure display
+	display.Configure(ili9341.Config{})
+	print("width, height == ")
+	width, height := display.Size()
+	println(width, height)
+
+	backlight.High()
+
+	display.SetRotation(ili9341.Rotation270)
+	DrawBackground()
+
+	startTime = time.Now().UnixNano()
+	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/pyportal_boing/pyportal.go

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

examples/ili9341/pyportal_boing/wioterminal.go

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

examples/ili9341/scroll/atsamd21.go

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

examples/ili9341/scroll/main.go

@@ -0,0 +1,40 @@
+package main
+
+import (
+	"image/color"
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/ili9341"
+)
+
+var (
+	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() {
+
+	backlight.Configure(machine.PinConfig{machine.PinOutput})
+
+	display.Configure(ili9341.Config{})
+	width, height := display.Size()
+
+	display.FillScreen(black)
+	backlight.High()
+
+	display.FillRectangle(0, 0, width/2, height/2, white)
+	display.FillRectangle(width/2, 0, width/2, height/2, red)
+	display.FillRectangle(0, height/2, width/2, height/2, green)
+	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/ili9341/scroll/pyportal.go

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

examples/ili9341/scroll/wioterminal.go

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

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

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

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

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

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

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

examples/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,59 @@
+package main
+
+import (
+	"machine"
+
+	"image/color"
+
+	"tinygo.org/x/drivers/st7789"
+)
+
+func main() {
+
+	// Example configuration for Adafruit Clue
+	// machine.SPI1.Configure(machine.SPIConfig{
+	//	Frequency: 8000000,
+	//	SCK:       machine.TFT_SCK,
+	//	SDO:       machine.TFT_SDO,
+	//	SDI:       machine.TFT_SDO,
+	//	Mode:      0,
+	// })
+	// display := st7789.New(machine.SPI1,
+	//	machine.TFT_RESET,
+	//	machine.TFT_DC,
+	//	machine.TFT_CS,
+	//	machine.TFT_LITE)
+
+	machine.SPI0.Configure(machine.SPIConfig{
+		Frequency: 8000000,
+		Mode:      0,
+	})
+	display := st7789.New(machine.SPI0,
+		machine.P6, // TFT_RESET
+		machine.P7, // TFT_DC
+		machine.P8, // TFT_CS
+		machine.P9) // TFT_LITE
+
+	display.Configure(st7789.Config{
+		Rotation:   st7789.NO_ROTATION,
+		RowOffset:  80,
+		FrameRate:  st7789.FRAMERATE_111,
+		VSyncLines: st7789.MAX_VSYNC_SCANLINES,
+	})
+
+	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)
+	}
+}