mirror of
https://github.com/tinygo-org/drivers.git
synced 2026-08-02 22:17:49 +00:00
Compare commits
2 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 deadprogram
|
5130e9a120 | ||
|
deadprogram
|
ee70298bc4 |
@@ -0,0 +1,20 @@
|
||||
# Golang CircleCI 2.0 configuration file
|
||||
#
|
||||
# Check https://circleci.com/docs/2.0/language-go/ for more details
|
||||
version: 2
|
||||
jobs:
|
||||
build:
|
||||
docker:
|
||||
- image: tinygo/tinygo-dev
|
||||
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
|
||||
@@ -1,25 +0,0 @@
|
||||
name: Build
|
||||
|
||||
on:
|
||||
pull_request:
|
||||
push:
|
||||
branches:
|
||||
- dev
|
||||
- release
|
||||
workflow_dispatch:
|
||||
|
||||
jobs:
|
||||
build:
|
||||
runs-on: ubuntu-latest
|
||||
container: tinygo/tinygo-dev
|
||||
steps:
|
||||
- name: Checkout
|
||||
uses: actions/checkout@v2
|
||||
- name: TinyGo version check
|
||||
run: tinygo version
|
||||
- name: Enforce Go Formatted Code
|
||||
run: make fmt-check
|
||||
- name: Run unit tests
|
||||
run: make unit-test
|
||||
- name: Run build and smoke tests
|
||||
run: make smoke-test
|
||||
@@ -1,66 +1,3 @@
|
||||
0.21.0
|
||||
---
|
||||
- **new devices**
|
||||
- lsm6ds3tr: initial implementation
|
||||
- UC8151: used in Pimoroni's badger2040 e-paper (#416)
|
||||
- scd4x: implement driver for CO2 sensor
|
||||
|
||||
- **enhancements**
|
||||
- easystepper: Add support for '8-step mode'
|
||||
- vl53l1x: Add functions for setting the device address
|
||||
- sdcard: support thingplus-rp2040
|
||||
- wifinina: add mutex to prevent communication race problems
|
||||
- **ws2812**
|
||||
- support thingplus-rp2040 board
|
||||
- Added 125 MHz rp2040 timing
|
||||
- Added unsafe.Pointer for pointer conversion
|
||||
|
||||
- **bugfixes**
|
||||
- ssd1351: Fix mirrored text on OLED display
|
||||
|
||||
|
||||
0.20.0
|
||||
---
|
||||
- **new devices**
|
||||
- irremote: Add basic infra-red driver
|
||||
- IS31FL3731: add driver for IS31FL3731 matrix LED driver (#370)
|
||||
- l3gd20: add gyro driver
|
||||
- SSD1289: Driver for SSD1289 LCD
|
||||
|
||||
- **enhancements**
|
||||
- **ili9341**
|
||||
- add support for atsame5x
|
||||
- added Feather board support to InitDisplay()
|
||||
- avoid heap allocations
|
||||
- **lps22hb**
|
||||
- pin rename, sync with main repo
|
||||
- **lsmXXX**
|
||||
- unified, error handling, memory management
|
||||
- **max7xx**
|
||||
- Add a SetIntensity() function to max7xx driver and example
|
||||
- **vl53l1x**
|
||||
- Add functions for setting 'region of interest'
|
||||
- Fix switch-case semantics
|
||||
- **ws2812**
|
||||
- add support for m5stamp-c3
|
||||
- convert AVR assembly to C inline assembly
|
||||
- support high-MHz ARMv6M chips like the RP2040
|
||||
- write inline assembly using C instead of Go
|
||||
|
||||
- **bugfixes**
|
||||
- **dht**
|
||||
- fix error check in example
|
||||
- fix humidity and temperature extraction for DHT22 (#358)
|
||||
- **esp8266**
|
||||
- fix ConnectToAccessPoint timeout args
|
||||
- **image**
|
||||
- fix interface
|
||||
- **pca9685**
|
||||
- add buffered one shot write
|
||||
- fix on=0 bug
|
||||
- **wifinina**
|
||||
- correct sendParamStr to handle empty strings, such as when connecting to an unsecured access point
|
||||
|
||||
0.19.0
|
||||
---
|
||||
- **new devices**
|
||||
|
||||
@@ -107,8 +107,6 @@ smoke-test:
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=p1am-100 ./examples/p1am/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=pico ./examples/pca9685/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
|
||||
@@ -159,10 +157,6 @@ smoke-test:
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=circuitplay-express ./examples/ws2812
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.bin -target=m5stamp-c3 ./examples/ws2812
|
||||
@md5sum ./build/test.bin
|
||||
tinygo build -size short -o ./build/test.hex -target=feather-nrf52840 ./examples/is31fl3731/main.go
|
||||
@md5sum ./build/test.hex
|
||||
ifneq ($(AVR), 0)
|
||||
tinygo build -size short -o ./build/test.hex -target=arduino ./examples/ws2812
|
||||
@md5sum ./build/test.hex
|
||||
@@ -233,25 +227,16 @@ endif
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.uf2 -target=pico ./examples/ssd1289/main.go
|
||||
@md5sum ./build/test.uf2
|
||||
tinygo build -size short -o ./build/test.hex -target=pico ./examples/irremote/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=badger2040 ./examples/uc8151/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.uf2 -target=pico ./examples/scd4x/main.go
|
||||
@md5sum ./build/test.uf2
|
||||
tinygo build -size short -o ./build/test.uf2 -target=circuitplay-express ./examples/makeybutton/main.go
|
||||
@md5sum ./build/test.uf2
|
||||
|
||||
# rwildcard is a recursive version of $(wildcard)
|
||||
# https://blog.jgc.org/2011/07/gnu-make-recursive-wildcard-function.html
|
||||
rwildcard=$(foreach d,$(wildcard $1*),$(call rwildcard,$d/,$2) $(filter $(subst *,%,$2),$d))
|
||||
# Recursively find all *_test.go files from cwd & reduce to unique dir names
|
||||
HAS_TESTS = $(sort $(dir $(call rwildcard,,*_test.go)))
|
||||
# Exclude anything we explicitly don't want to test for whatever reason
|
||||
EXCLUDE_TESTS = image
|
||||
TESTS = $(filter-out $(addsuffix /%,$(EXCLUDE_TESTS)),$(HAS_TESTS))
|
||||
DRIVERS = $(wildcard */)
|
||||
NOTESTS = build examples flash semihosting pcd8544 shiftregister st7789 microphone mcp3008 gps microbitmatrix \
|
||||
hcsr04 ssd1331 ws2812 thermistor apa102 easystepper ssd1351 ili9341 wifinina shifter hub75 \
|
||||
hd44780 buzzer ssd1306 espat l9110x st7735 bmi160 l293x dht keypad4x4 max72xx p1am tone tm1637 \
|
||||
pcf8563 mcp2515 servo sdcard rtl8720dn image cmd i2csoft hts221 lps22hb apds9960 axp192 xpt2046 \
|
||||
ft6336 sx126x ssd1289
|
||||
TESTS = $(filter-out $(addsuffix /%,$(NOTESTS)),$(DRIVERS))
|
||||
|
||||
unit-test:
|
||||
@go test -v $(addprefix ./,$(TESTS))
|
||||
@go test -v $(addprefix ./,$(TESTS))
|
||||
|
||||
test: clean fmt-check unit-test smoke-test
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# TinyGo Drivers
|
||||
|
||||
[](https://pkg.go.dev/tinygo.org/x/drivers) [](https://github.com/tinygo-org/drivers/actions/workflows/build.yml)
|
||||
[](https://pkg.go.dev/tinygo.org/x/drivers) [](https://circleci.com/gh/tinygo-org/drivers/tree/dev)
|
||||
|
||||
|
||||
This package provides a collection of hardware drivers for devices such as sensors and displays that can be used together with [TinyGo](https://tinygo.org).
|
||||
@@ -52,96 +52,90 @@ func main() {
|
||||
|
||||
## Currently supported devices
|
||||
|
||||
The following 81 devices are supported.
|
||||
The following 78 devices are supported.
|
||||
|
||||
| Device Name | Interface Type |
|
||||
|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------|
|
||||
| [ADT7410 I2C Temperature Sensor](https://www.analog.com/media/en/technical-documentation/data-sheets/ADT7410.pdf) | I2C |
|
||||
| [ADXL345 accelerometer](http://www.analog.com/media/en/technical-documentation/data-sheets/ADXL345.pdf) | I2C |
|
||||
| [AHT20 I2C Temperature and Humidity Sensor](http://www.aosong.com/userfiles/files/media/AHT20%20%E8%8B%B1%E6%96%87%E7%89%88%E8%AF%B4%E6%98%8E%E4%B9%A6%20A0%2020201222.pdf) | I2C |
|
||||
| [AMG88xx 8x8 Thermal camera sensor](https://cdn-learn.adafruit.com/assets/assets/000/043/261/original/Grid-EYE_SPECIFICATIONS%28Reference%29.pdf) | I2C |
|
||||
| [APA102 RGB LED](https://cdn-shop.adafruit.com/product-files/2343/APA102C.pdf) | SPI |
|
||||
| [APDS9960 Digital proximity, ambient light, RGB and gesture sensor](https://cdn.sparkfun.com/assets/learn_tutorials/3/2/1/Avago-APDS-9960-datasheet.pdf) | I2C |
|
||||
| [AT24CX 2-wire serial EEPROM](https://www.openimpulse.com/blog/wp-content/uploads/wpsc/downloadables/24C32-Datasheet.pdf) | I2C |
|
||||
| [AXP192 single Cell Li-Battery and Power System Management](https://github.com/m5stack/M5-Schematic/blob/master/Core/AXP192%20Datasheet_v1.1_en_draft_2211.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 |
|
||||
| [BMP388 pressure sensor](https://www.bosch-sensortec.com/media/boschsensortec/downloads/datasheets/bst-bmp388-ds001.pdf) | I2C |
|
||||
| [Buzzer](https://en.wikipedia.org/wiki/Buzzer#Piezoelectric) | GPIO |
|
||||
| [DHTXX thermometer and humidity sensor](https://cdn-shop.adafruit.com/datasheets/Digital+humidity+and+temperature+sensor+AM2302.pdf) | GPIO |
|
||||
| [DS1307 real time clock](https://datasheets.maximintegrated.com/en/ds/DS1307.pdf) | I2C |
|
||||
| [DS3231 real time clock](https://datasheets.maximintegrated.com/en/ds/DS3231.pdf) | I2C |
|
||||
| [ESP32 as WiFi Coprocessor with Arduino nina-fw](https://github.com/arduino/nina-fw) | SPI |
|
||||
| [ESP8266/ESP32 AT Command set for WiFi/TCP/UDP](https://github.com/espressif/esp32-at) | UART |
|
||||
| [FT6336 touch controller](https://focuslcds.com/content/FT6236.pdf) | I2C |
|
||||
| [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 |
|
||||
| [HTS221 digital humidity and temperature sensor](https://www.st.com/resource/en/datasheet/hts221.pdf) | I2C |
|
||||
| [HUB75 RGB led matrix](https://cdn-learn.adafruit.com/downloads/pdf/32x16-32x32-rgb-led-matrix.pdf) | SPI |
|
||||
| [software I2C driver](https://www.ti.com/lit/an/slva704/slva704.pdf) | GPIO |
|
||||
| [ILI9341 TFT color display](https://cdn-shop.adafruit.com/datasheets/ILI9341.pdf) | SPI |
|
||||
| [INA260 Volt/Amp/Power meter](https://www.ti.com/lit/ds/symlink/ina260.pdf) | I2C |
|
||||
| [Infrared remote control](https://en.wikipedia.org/wiki/Consumer_IR) | GPIO |
|
||||
| [IS31FL3731 matrix LED driver](https://www.lumissil.com/assets/pdf/core/IS31FL3731_DS.pdf) | I2C |
|
||||
| [4x4 Membrane Keypad](https://cdn.sparkfun.com/assets/f/f/a/5/0/DS-16038.pdf) | GPIO |
|
||||
| [L293x motor driver](https://www.ti.com/lit/ds/symlink/l293d.pdf) | GPIO/PWM |
|
||||
| [L9110x motor driver](https://www.elecrow.com/download/datasheet-l9110.pdf) | GPIO/PWM |
|
||||
| [LIS2MDL magnetometer](https://www.st.com/resource/en/datasheet/lis2mdl.pdf) | I2C |
|
||||
| [LIS3DH accelerometer](https://www.st.com/resource/en/datasheet/lis3dh.pdf) | I2C |
|
||||
| [LPS22HB MEMS nano pressure sensor](https://www.st.com/resource/en/datasheet/dm00140895.pdf) | I2C |
|
||||
| [LSM6DS3 accelerometer](https://www.st.com/resource/en/datasheet/lsm6ds3.pdf) | I2C |
|
||||
| [LSM6DSOX accelerometer](https://www.st.com/resource/en/datasheet/lsm6dsox.pdf) | I2C |
|
||||
| [LSM6DS3TR accelerometer](https://www.st.com/resource/en/datasheet/lsm6ds3tr.pdf) | I2C |
|
||||
| [LSM303AGR accelerometer](https://www.st.com/resource/en/datasheet/lsm303agr.pdf) | I2C |
|
||||
| [LSM9DS1 accelerometer](https://www.st.com/resource/en/datasheet/lsm9ds1.pdf) | I2C |
|
||||
| [Makey Button](https://makeymakey.com/) | GPIO |
|
||||
| [MAG3110 magnetometer](https://www.nxp.com/docs/en/data-sheet/MAG3110.pdf) | I2C |
|
||||
| [MAX7219 & MAX7221 display driver](https://datasheets.maximintegrated.com/en/ds/MAX7219-MAX7221.pdf) | SPI |
|
||||
| [MCP2515 Stand-Alone CAN Controller with SPI Interface](https://ww1.microchip.com/downloads/en/DeviceDoc/MCP2515-Family-Data-Sheet-DS20001801K.pdf) | SPI |
|
||||
| [MCP3008 analog to digital converter (ADC)](http://ww1.microchip.com/downloads/en/DeviceDoc/21295d.pdf) | SPI |
|
||||
| [MCP23017 port expander](https://ww1.microchip.com/downloads/en/DeviceDoc/20001952C.pdf) | I2C |
|
||||
| [Microphone - PDM](https://cdn-learn.adafruit.com/assets/assets/000/049/977/original/MP34DT01-M.pdf) | I2S/PDM |
|
||||
| [MMA8653 accelerometer](https://www.nxp.com/docs/en/data-sheet/MMA8653FC.pdf) | I2C |
|
||||
| [MPU6050 accelerometer/gyroscope](https://store.invensense.com/datasheets/invensense/MPU-6050_DataSheet_V3%204.pdf) | I2C |
|
||||
| [P1AM-100 Base Controller](https://facts-engineering.github.io/modules/P1AM-100/P1AM-100.html) | SPI |
|
||||
| [PCD8544 display](http://eia.udg.edu/~forest/PCD8544_1.pdf) | SPI |
|
||||
| [PCF8563 real time clock](https://www.nxp.com/docs/en/data-sheet/PCF8563.pdf) | I2C |
|
||||
| [Resistive Touchscreen (4-wire)](http://ww1.microchip.com/downloads/en/Appnotes/doc8091.pdf) | GPIO |
|
||||
| [RTL8720DN 2.4G/5G Dual Bands Wireless and BLE5.0](https://www.seeedstudio.com/Realtek8720DN-2-4G-5G-Dual-Bands-Wireless-and-BLE5-0-Combo-Module-p-4442.html) | UART |
|
||||
| [SCD4x CO2 Sensor](https://sensirion.com/media/documents/C4B87CE6/627C2DCD/CD_DS_SCD40_SCD41_Datasheet_D1.pdf) | I2C |
|
||||
| [Semihosting](https://wiki.segger.com/Semihosting) | Debug |
|
||||
| [Servo](https://learn.sparkfun.com/tutorials/hobby-servo-tutorial/all) | PWM |
|
||||
| [Shift register (PISO)](https://en.wikipedia.org/wiki/Shift_register#Parallel-in_serial-out_\(PISO\)) | GPIO |
|
||||
| [Shift registers (SIPO)](https://en.wikipedia.org/wiki/Shift_register#Serial-in_parallel-out_(SIPO)) | GPIO |
|
||||
| Device Name | Interface Type |
|
||||
|----------|-------------|
|
||||
| [ADT7410 I2C Temperature Sensor](https://www.analog.com/media/en/technical-documentation/data-sheets/ADT7410.pdf) | I2C |
|
||||
| [ADXL345 accelerometer](http://www.analog.com/media/en/technical-documentation/data-sheets/ADXL345.pdf) | I2C |
|
||||
| [AHT20 I2C Temperature and Humidity Sensor](http://www.aosong.com/userfiles/files/media/AHT20%20%E8%8B%B1%E6%96%87%E7%89%88%E8%AF%B4%E6%98%8E%E4%B9%A6%20A0%2020201222.pdf) | I2C |
|
||||
| [AMG88xx 8x8 Thermal camera sensor](https://cdn-learn.adafruit.com/assets/assets/000/043/261/original/Grid-EYE_SPECIFICATIONS%28Reference%29.pdf) | I2C |
|
||||
| [APA102 RGB LED](https://cdn-shop.adafruit.com/product-files/2343/APA102C.pdf) | SPI |
|
||||
| [APDS9960 Digital proximity, ambient light, RGB and gesture sensor](https://cdn.sparkfun.com/assets/learn_tutorials/3/2/1/Avago-APDS-9960-datasheet.pdf) | I2C |
|
||||
| [AT24CX 2-wire serial EEPROM](https://www.openimpulse.com/blog/wp-content/uploads/wpsc/downloadables/24C32-Datasheet.pdf) | I2C |
|
||||
| [AXP192 single Cell Li-Battery and Power System Management](https://github.com/m5stack/M5-Schematic/blob/master/Core/AXP192%20Datasheet_v1.1_en_draft_2211.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 |
|
||||
| [BMP388 pressure sensor](https://www.bosch-sensortec.com/media/boschsensortec/downloads/datasheets/bst-bmp388-ds001.pdf) | I2C |
|
||||
| [Buzzer](https://en.wikipedia.org/wiki/Buzzer#Piezoelectric) | GPIO |
|
||||
| [DHTXX thermometer and humidity sensor](https://cdn-shop.adafruit.com/datasheets/Digital+humidity+and+temperature+sensor+AM2302.pdf) | GPIO |
|
||||
| [DS1307 real time clock](https://datasheets.maximintegrated.com/en/ds/DS1307.pdf) | I2C |
|
||||
| [DS3231 real time clock](https://datasheets.maximintegrated.com/en/ds/DS3231.pdf) | I2C |
|
||||
| [ESP32 as WiFi Coprocessor with Arduino nina-fw](https://github.com/arduino/nina-fw) | SPI |
|
||||
| [ESP8266/ESP32 AT Command set for WiFi/TCP/UDP](https://github.com/espressif/esp32-at) | UART |
|
||||
| [FT6336 touch controller](https://focuslcds.com/content/FT6236.pdf) | I2C |
|
||||
| [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 |
|
||||
| [HTS221 digital humidity and temperature sensor](https://www.st.com/resource/en/datasheet/hts221.pdf) | I2C |
|
||||
| [HUB75 RGB led matrix](https://cdn-learn.adafruit.com/downloads/pdf/32x16-32x32-rgb-led-matrix.pdf) | SPI |
|
||||
| [software I2C driver](https://www.ti.com/lit/an/slva704/slva704.pdf) | GPIO |
|
||||
| [ILI9341 TFT color display](https://cdn-shop.adafruit.com/datasheets/ILI9341.pdf) | SPI |
|
||||
| [INA260 Volt/Amp/Power meter](https://www.ti.com/lit/ds/symlink/ina260.pdf) | I2C |
|
||||
| [4x4 Membrane Keypad](https://cdn.sparkfun.com/assets/f/f/a/5/0/DS-16038.pdf) | GPIO |
|
||||
| [L293x motor driver](https://www.ti.com/lit/ds/symlink/l293d.pdf) | GPIO/PWM |
|
||||
| [L9110x motor driver](https://www.elecrow.com/download/datasheet-l9110.pdf) | GPIO/PWM |
|
||||
| [LIS2MDL magnetometer](https://www.st.com/resource/en/datasheet/lis2mdl.pdf) | I2C |
|
||||
| [LIS3DH accelerometer](https://www.st.com/resource/en/datasheet/lis3dh.pdf) | I2C |
|
||||
| [LPS22HB MEMS nano pressure sensor](https://www.st.com/resource/en/datasheet/dm00140895.pdf) | I2C |
|
||||
| [LSM6DS3 accelerometer](https://www.st.com/resource/en/datasheet/lsm6ds3.pdf) | I2C |
|
||||
| [LSM6DSOX accelerometer](https://www.st.com/resource/en/datasheet/lsm6dsox.pdf) | I2C |
|
||||
| [LSM303AGR accelerometer](https://www.st.com/resource/en/datasheet/lsm303agr.pdf) | I2C |
|
||||
| [LSM9DS1 accelerometer](https://www.st.com/resource/en/datasheet/lsm9ds1.pdf) | I2C |
|
||||
| [MAG3110 magnetometer](https://www.nxp.com/docs/en/data-sheet/MAG3110.pdf) | I2C |
|
||||
| [MAX7219 & MAX7221 display driver](https://datasheets.maximintegrated.com/en/ds/MAX7219-MAX7221.pdf) | SPI |
|
||||
| [MCP2515 Stand-Alone CAN Controller with SPI Interface](https://ww1.microchip.com/downloads/en/DeviceDoc/MCP2515-Family-Data-Sheet-DS20001801K.pdf) | SPI |
|
||||
| [MCP3008 analog to digital converter (ADC)](http://ww1.microchip.com/downloads/en/DeviceDoc/21295d.pdf) | SPI |
|
||||
| [MCP23017 port expander](https://ww1.microchip.com/downloads/en/DeviceDoc/20001952C.pdf) | I2C |
|
||||
| [Microphone - PDM](https://cdn-learn.adafruit.com/assets/assets/000/049/977/original/MP34DT01-M.pdf) | I2S/PDM |
|
||||
| [MMA8653 accelerometer](https://www.nxp.com/docs/en/data-sheet/MMA8653FC.pdf) | I2C |
|
||||
| [MPU6050 accelerometer/gyroscope](https://store.invensense.com/datasheets/invensense/MPU-6050_DataSheet_V3%204.pdf) | I2C |
|
||||
| [P1AM-100 Base Controller](https://facts-engineering.github.io/modules/P1AM-100/P1AM-100.html) | SPI |
|
||||
| [PCD8544 display](http://eia.udg.edu/~forest/PCD8544_1.pdf) | SPI |
|
||||
| [PCF8563 real time clock](https://www.nxp.com/docs/en/data-sheet/PCF8563.pdf) | I2C |
|
||||
| [Resistive Touchscreen (4-wire)](http://ww1.microchip.com/downloads/en/Appnotes/doc8091.pdf) | GPIO |
|
||||
| [RTL8720DN 2.4G/5G Dual Bands Wireless and BLE5.0](https://www.seeedstudio.com/Realtek8720DN-2-4G-5G-Dual-Bands-Wireless-and-BLE5-0-Combo-Module-p-4442.html) | UART |
|
||||
| [Semihosting](https://wiki.segger.com/Semihosting) | Debug |
|
||||
| [Servo](https://learn.sparkfun.com/tutorials/hobby-servo-tutorial/all) | PWM |
|
||||
| [Shift register (PISO)](https://en.wikipedia.org/wiki/Shift_register#Parallel-in_serial-out_\(PISO\)) | GPIO |
|
||||
| [Shift registers (SIPO)](https://en.wikipedia.org/wiki/Shift_register#Serial-in_parallel-out_(SIPO)) | GPIO |
|
||||
| [SHT3x Digital Humidity Sensor](https://www.sensirion.com/fileadmin/user_upload/customers/sensirion/Dokumente/2_Humidity_Sensors/Datasheets/Sensirion_Humidity_Sensors_SHT3x_Datasheet_digital.pdf) | I2C |
|
||||
| [SHTC3 Digital Humidity Sensor (RH/T)](https://www.sensirion.com/fileadmin/user_upload/customers/sensirion/Dokumente/2_Humidity_Sensors/Datasheets/Sensirion_Humidity_Sensors_SHTC3_Datasheet.pdf) | I2C |
|
||||
| [SPI NOR Flash Memory](https://en.wikipedia.org/wiki/Flash_memory#NOR_flash) | SPI/QSPI |
|
||||
| [SPI SDCARD/MMC](https://en.wikipedia.org/wiki/SD_card) | SPI |
|
||||
| [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 |
|
||||
| [TM1637 7-segment LED display](https://www.mcielectronics.cl/website_MCI/static/documents/Datasheet_TM1637.pdf) | I2C |
|
||||
| [TMP102 I2C Temperature Sensor](https://download.mikroe.com/documents/datasheets/tmp102-data-sheet.pdf) | I2C |
|
||||
| [UC8151 All-in-one driver IC for ESL](https://www.buydisplay.com/download/ic/UC8151C.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" (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 |
|
||||
| [XPT2046 touch controller](http://grobotronics.com/images/datasheets/xpt2046-datasheet.pdf) | GPIO |
|
||||
| [Semtech SX126x Lora](https://www.semtech.com/products/wireless-rf/lora-transceiv-ers/sx1261) | SPI |
|
||||
| [SSD1289 TFT color display](http://aitendo3.sakura.ne.jp/aitendo_data/product_img/lcd/tft2/M032C1289TP/3.2-SSD1289.pdf) | GPIO |
|
||||
| [SHTC3 Digital Humidity Sensor (RH/T)](https://www.sensirion.com/fileadmin/user_upload/customers/sensirion/Dokumente/2_Humidity_Sensors/Datasheets/Sensirion_Humidity_Sensors_SHTC3_Datasheet.pdf) | I2C |
|
||||
| [SPI NOR Flash Memory](https://en.wikipedia.org/wiki/Flash_memory#NOR_flash) | SPI/QSPI |
|
||||
| [SPI SDCARD/MMC](https://en.wikipedia.org/wiki/SD_card) | SPI |
|
||||
| [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 |
|
||||
| [TM1637 7-segment LED display](https://www.mcielectronics.cl/website_MCI/static/documents/Datasheet_TM1637.pdf) | I2C |
|
||||
| [TMP102 I2C Temperature Sensor](https://download.mikroe.com/documents/datasheets/tmp102-data-sheet.pdf) | I2C |
|
||||
| [VEML6070 UV light sensor](https://www.vishay.com/docs/84277/veml6070.pdf) | I2C |
|
||||
| [VL53L1X time-of-flight distance sensor](https://www.st.com/resource/en/datasheet/vl53l1x.pdf) | I2C |
|
||||
| [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 |
|
||||
| [XPT2046 touch controller](http://grobotronics.com/images/datasheets/xpt2046-datasheet.pdf) | GPIO |
|
||||
| [Semtech SX126x Lora](https://www.semtech.com/products/wireless-rf/lora-transceiv-ers/sx1261) | SPI |
|
||||
| [SSD1289 TFT color display](http://aitendo3.sakura.ne.jp/aitendo_data/product_img/lcd/tft2/M032C1289TP/3.2-SSD1289.pdf) | GPIO |
|
||||
|
||||
## Contributing
|
||||
|
||||
|
||||
+27
-3
@@ -1,6 +1,3 @@
|
||||
//go:build tinygo
|
||||
// +build tinygo
|
||||
|
||||
// Package dht provides a driver for DHTXX family temperature and humidity sensors.
|
||||
//
|
||||
// [1] Datasheet DHT11: https://www.mouser.com/datasheet/2/758/DHT11-Technical-Data-Sheet-Translated-Version-1143054.pdf
|
||||
@@ -10,10 +7,34 @@
|
||||
package dht // import "tinygo.org/x/drivers/dht"
|
||||
|
||||
import (
|
||||
"encoding/binary"
|
||||
"machine"
|
||||
"time"
|
||||
)
|
||||
|
||||
// enum type for device type
|
||||
type DeviceType uint8
|
||||
|
||||
// DeviceType specific parsing of information received from the sensor
|
||||
func (d DeviceType) extractData(buf []byte) (temp int16, hum uint16) {
|
||||
if d == DHT11 {
|
||||
temp = int16(buf[2])
|
||||
if buf[3]&0x80 > 0 {
|
||||
temp = -1 - temp
|
||||
}
|
||||
temp *= 10
|
||||
temp += int16(buf[3] & 0x0f)
|
||||
hum = 10*uint16(buf[0]) + uint16(buf[1])
|
||||
} else {
|
||||
hum = binary.LittleEndian.Uint16(buf[0:2])
|
||||
temp = int16(buf[3])<<8 + int16(buf[2]&0x7f)
|
||||
if buf[2]&0x80 > 0 {
|
||||
temp = -temp
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// Celsius and Fahrenheit temperature scales
|
||||
type TemperatureScale uint8
|
||||
|
||||
@@ -33,6 +54,9 @@ const (
|
||||
startTimeout = time.Millisecond * 200
|
||||
startingLow = time.Millisecond * 20
|
||||
|
||||
DHT11 DeviceType = iota
|
||||
DHT22
|
||||
|
||||
C TemperatureScale = iota
|
||||
F
|
||||
|
||||
|
||||
@@ -1,44 +0,0 @@
|
||||
package dht
|
||||
|
||||
import (
|
||||
"encoding/binary"
|
||||
)
|
||||
|
||||
// DeviceType is the enum type for device type
|
||||
type DeviceType uint8
|
||||
|
||||
const (
|
||||
DHT11 DeviceType = iota
|
||||
DHT22
|
||||
)
|
||||
|
||||
// extractData parses information received from the sensor.
|
||||
// The 2 first buffers are for the humidity and
|
||||
// the 2 following corresponds to the temperature.
|
||||
func (d DeviceType) extractData(buf []byte) (temp int16, hum uint16) {
|
||||
switch d {
|
||||
case DHT11:
|
||||
hum = 10*uint16(buf[0]) + uint16(buf[1])
|
||||
temp = int16(buf[2])
|
||||
if buf[3]&0x80 > 0 {
|
||||
temp = -1 - temp
|
||||
}
|
||||
temp *= 10
|
||||
temp += int16(buf[3] & 0x0f)
|
||||
case DHT22:
|
||||
hum = binary.BigEndian.Uint16(buf[0:2])
|
||||
temp = int16(buf[2]&0x7f)<<8 + int16(buf[3])
|
||||
// the first bit corresponds to the sign bit
|
||||
if buf[2]&0x80 > 0 {
|
||||
temp = -temp
|
||||
}
|
||||
default:
|
||||
// keeping this for retro-compatibility but not tested
|
||||
hum = binary.LittleEndian.Uint16(buf[0:2])
|
||||
temp = int16(buf[3])<<8 + int16(buf[2]&0x7f)
|
||||
if buf[2]&0x80 > 0 {
|
||||
temp = -temp
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
@@ -1,46 +0,0 @@
|
||||
package dht
|
||||
|
||||
import (
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestDeviceType_extractData(t *testing.T) {
|
||||
bitStr := "0000001010001100000000010101111111101110"
|
||||
buf := bitStringToBytes(bitStr)
|
||||
|
||||
tt := []struct {
|
||||
name string
|
||||
d DeviceType
|
||||
buf []byte
|
||||
wantTemp int16
|
||||
wantHum uint16
|
||||
}{
|
||||
{
|
||||
// temp = 35.1C hum = 65.2%
|
||||
name: "DHT22", d: DHT22, buf: buf, wantTemp: 351, wantHum: 652,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tc := range tt {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
gotTemp, gotHum := tc.d.extractData(tc.buf)
|
||||
if gotTemp != tc.wantTemp {
|
||||
t.Errorf("extractData() gotTemp = %v, want %v", gotTemp, tc.wantTemp)
|
||||
}
|
||||
if gotHum != tc.wantHum {
|
||||
t.Errorf("extractData() gotHum = %v, want %v", gotHum, tc.wantHum)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func bitStringToBytes(s string) []byte {
|
||||
b := make([]byte, (len(s)+(8-1))/8)
|
||||
for i, r := range s {
|
||||
if r < '0' || r > '1' {
|
||||
panic("not in range")
|
||||
}
|
||||
b[i>>3] |= byte(r-'0') << uint(7-i&7)
|
||||
}
|
||||
return b
|
||||
}
|
||||
@@ -1,6 +1,3 @@
|
||||
//go:build tinygo
|
||||
// +build tinygo
|
||||
|
||||
// Package dht provides a driver for DHTXX family temperature and humidity sensors.
|
||||
//
|
||||
// [1] Datasheet DHT11: https://www.mouser.com/datasheet/2/758/DHT11-Technical-Data-Sheet-Translated-Version-1143054.pdf
|
||||
|
||||
@@ -1,6 +1,3 @@
|
||||
//go:build tinygo
|
||||
// +build tinygo
|
||||
|
||||
// Package dht provides a driver for DHTXX family temperature and humidity sensors.
|
||||
//
|
||||
// [1] Datasheet DHT11: https://www.mouser.com/datasheet/2/758/DHT11-Technical-Data-Sheet-Translated-Version-1143054.pdf
|
||||
|
||||
@@ -1,6 +1,3 @@
|
||||
//go:build tinygo
|
||||
// +build tinygo
|
||||
|
||||
package dht // import "tinygo.org/x/drivers/dht"
|
||||
|
||||
import (
|
||||
|
||||
+22
-138
@@ -2,76 +2,28 @@
|
||||
package easystepper // import "tinygo.org/x/drivers/easystepper"
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"machine"
|
||||
"time"
|
||||
)
|
||||
|
||||
// StepMode determines the coil sequence used to perform a single step
|
||||
type StepMode uint8
|
||||
|
||||
// Valid values for StepMode
|
||||
const (
|
||||
// ModeFour uses a 'four step' coil sequence (12-23-34-41). This is the default (zero-value) mode
|
||||
ModeFour StepMode = iota
|
||||
// ModeEight uses an 'eight step' coil sequence (1-12-2-23-3-34-4-41)
|
||||
ModeEight
|
||||
)
|
||||
|
||||
// stepCount is a helper function to return the number of steps in a StepMode sequence
|
||||
func (sm StepMode) stepCount() uint {
|
||||
switch sm {
|
||||
default:
|
||||
fallthrough
|
||||
case ModeFour:
|
||||
return 4
|
||||
case ModeEight:
|
||||
return 8
|
||||
}
|
||||
}
|
||||
|
||||
// DeviceConfig contains the configuration data for a single easystepper driver
|
||||
type DeviceConfig struct {
|
||||
// Pin1 ... Pin4 determines the pins to configure and use for the device
|
||||
Pin1, Pin2, Pin3, Pin4 machine.Pin
|
||||
// StepCount is the number of steps required to perform a full revolution of the stepper motor
|
||||
StepCount uint
|
||||
// RPM determines the speed of the stepper motor in 'Revolutions per Minute'
|
||||
RPM uint
|
||||
// Mode determines the coil sequence used to perform a single step
|
||||
Mode StepMode
|
||||
}
|
||||
|
||||
// DualDeviceConfig contains the configuration data for a dual easystepper driver
|
||||
type DualDeviceConfig struct {
|
||||
DeviceConfig
|
||||
// Pin5 ... Pin8 determines the pins to configure and use for the second device
|
||||
Pin5, Pin6, Pin7, Pin8 machine.Pin
|
||||
}
|
||||
|
||||
// Device holds the pins and the delay between steps
|
||||
type Device struct {
|
||||
pins [4]machine.Pin
|
||||
stepDelay time.Duration
|
||||
stepDelay int32
|
||||
stepNumber uint8
|
||||
stepMode StepMode
|
||||
}
|
||||
|
||||
// DualDevice holds information for controlling 2 motors
|
||||
type DualDevice struct {
|
||||
devices [2]*Device
|
||||
devices [2]Device
|
||||
}
|
||||
|
||||
// New returns a new single easystepper driver given a DeviceConfig
|
||||
func New(config DeviceConfig) (*Device, error) {
|
||||
if config.StepCount == 0 || config.RPM == 0 {
|
||||
return nil, errors.New("config.StepCount and config.RPM must be > 0")
|
||||
// New returns a new easystepper driver given 4 pins, number of steps and rpm
|
||||
func New(pin1, pin2, pin3, pin4 machine.Pin, steps int32, rpm int32) Device {
|
||||
return Device{
|
||||
pins: [4]machine.Pin{pin1, pin2, pin3, pin4},
|
||||
stepDelay: 60000000 / (steps * rpm),
|
||||
}
|
||||
return &Device{
|
||||
pins: [4]machine.Pin{config.Pin1, config.Pin2, config.Pin3, config.Pin4},
|
||||
stepDelay: time.Second * 60 / time.Duration((config.StepCount * config.RPM)),
|
||||
stepMode: config.Mode,
|
||||
}, nil
|
||||
}
|
||||
|
||||
// Configure configures the pins of the Device
|
||||
@@ -82,23 +34,17 @@ func (d *Device) Configure() {
|
||||
}
|
||||
|
||||
// NewDual returns a new dual easystepper driver given 8 pins, number of steps and rpm
|
||||
func NewDual(config DualDeviceConfig) (*DualDevice, error) {
|
||||
// Create the first device
|
||||
dev1, err := New(config.DeviceConfig)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
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),
|
||||
}
|
||||
// Create the second device
|
||||
config.DeviceConfig.Pin1 = config.Pin5
|
||||
config.DeviceConfig.Pin2 = config.Pin6
|
||||
config.DeviceConfig.Pin3 = config.Pin7
|
||||
config.DeviceConfig.Pin4 = config.Pin8
|
||||
dev2, err := New(config.DeviceConfig)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
dual.devices[1] = Device{
|
||||
pins: [4]machine.Pin{pin5, pin6, pin7, pin8},
|
||||
stepDelay: 60000000 / (steps * rpm),
|
||||
}
|
||||
// Return composite dual device
|
||||
return &DualDevice{devices: [2]*Device{dev1, dev2}}, nil
|
||||
return dual
|
||||
}
|
||||
|
||||
// Configure configures the pins of the DualDevice
|
||||
@@ -118,7 +64,7 @@ func (d *Device) Move(steps int32) {
|
||||
var s int32
|
||||
d.stepMotor(d.stepNumber)
|
||||
for s = int32(d.stepNumber); s < steps; s++ {
|
||||
time.Sleep(d.stepDelay)
|
||||
time.Sleep(time.Duration(d.stepDelay) * time.Microsecond)
|
||||
d.moveDirectionSteps(direction, s)
|
||||
}
|
||||
}
|
||||
@@ -155,7 +101,7 @@ func (d *DualDevice) Move(stepsA, stepsB int32) {
|
||||
stepsA += int32(d.devices[max].stepNumber)
|
||||
minStep = int32(d.devices[min].stepNumber)
|
||||
for s := int32(d.devices[max].stepNumber); s < stepsA; s++ {
|
||||
time.Sleep(d.devices[0].stepDelay)
|
||||
time.Sleep(time.Duration(d.devices[0].stepDelay) * time.Microsecond)
|
||||
d.devices[max].moveDirectionSteps(directions[max], s)
|
||||
|
||||
if ((s * stepsB) / stepsA) > minStep {
|
||||
@@ -173,18 +119,6 @@ func (d *DualDevice) Off() {
|
||||
|
||||
// stepMotor changes the pins' state to the correct step
|
||||
func (d *Device) stepMotor(step uint8) {
|
||||
switch d.stepMode {
|
||||
default:
|
||||
fallthrough
|
||||
case ModeFour:
|
||||
d.stepMotor4(step)
|
||||
case ModeEight:
|
||||
d.stepMotor8(step)
|
||||
}
|
||||
}
|
||||
|
||||
// stepMotor4 changes the pins' state to the correct step in 4-step mode
|
||||
func (d *Device) stepMotor4(step uint8) {
|
||||
switch step {
|
||||
case 0:
|
||||
d.pins[0].High()
|
||||
@@ -214,63 +148,13 @@ func (d *Device) stepMotor4(step uint8) {
|
||||
d.stepNumber = step
|
||||
}
|
||||
|
||||
// stepMotor8 changes the pins' state to the correct step in 8-step mode
|
||||
func (d *Device) stepMotor8(step uint8) {
|
||||
switch step {
|
||||
case 0:
|
||||
d.pins[0].High()
|
||||
d.pins[2].Low()
|
||||
d.pins[1].Low()
|
||||
d.pins[3].Low()
|
||||
case 1:
|
||||
d.pins[0].High()
|
||||
d.pins[2].High()
|
||||
d.pins[1].Low()
|
||||
d.pins[3].Low()
|
||||
case 2:
|
||||
d.pins[0].Low()
|
||||
d.pins[2].High()
|
||||
d.pins[1].Low()
|
||||
d.pins[3].Low()
|
||||
case 3:
|
||||
d.pins[0].Low()
|
||||
d.pins[2].High()
|
||||
d.pins[1].High()
|
||||
d.pins[3].Low()
|
||||
case 4:
|
||||
d.pins[0].Low()
|
||||
d.pins[2].Low()
|
||||
d.pins[1].High()
|
||||
d.pins[3].Low()
|
||||
case 5:
|
||||
d.pins[0].Low()
|
||||
d.pins[2].Low()
|
||||
d.pins[1].High()
|
||||
d.pins[3].High()
|
||||
case 6:
|
||||
d.pins[0].Low()
|
||||
d.pins[2].Low()
|
||||
d.pins[1].Low()
|
||||
d.pins[3].High()
|
||||
case 7:
|
||||
d.pins[0].High()
|
||||
d.pins[2].Low()
|
||||
d.pins[1].Low()
|
||||
d.pins[3].High()
|
||||
}
|
||||
d.stepNumber = step
|
||||
}
|
||||
|
||||
// moveDirectionSteps uses the direction to calculate the correct step and change the motor to it.
|
||||
// Direction true: (4-step mode) 0, 1, 2, 3, 0, 1, 2, ...
|
||||
// Direction false: (4-step mode) 0, 3, 2, 1, 0, 3, 2, ...
|
||||
// Direction true: (8-step mode) 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, ...
|
||||
// Direction false: (8-step mode) 0, 7, 6, 5, 4, 3, 2, 1, 0, 7, 6, ...
|
||||
// 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) {
|
||||
modulus := int32(d.stepMode.stepCount())
|
||||
if direction {
|
||||
d.stepMotor(uint8(step % modulus))
|
||||
d.stepMotor(uint8(step % 4))
|
||||
} else {
|
||||
d.stepMotor(uint8(((-step % modulus) + modulus) % modulus))
|
||||
d.stepMotor(uint8((step + 2*(step%2)) % 4))
|
||||
}
|
||||
}
|
||||
|
||||
+1
-1
@@ -12,7 +12,7 @@ func (d *Device) ConnectToAccessPoint(ssid, pass string, timeout time.Duration)
|
||||
}
|
||||
|
||||
d.SetWifiMode(WifiModeClient)
|
||||
return d.ConnectToAP(ssid, pass, int(timeout.Seconds()))
|
||||
return d.ConnectToAP(ssid, pass, 10)
|
||||
}
|
||||
|
||||
func (d *Device) Disconnect() error {
|
||||
|
||||
@@ -12,7 +12,7 @@ func main() {
|
||||
dhtSensor := dht.New(pin, dht.DHT11)
|
||||
for {
|
||||
temp, hum, err := dhtSensor.Measurements()
|
||||
if err == nil {
|
||||
if err != nil {
|
||||
fmt.Printf("Temperature: %02d.%d°C, Humidity: %02d.%d%%\n", temp/10, temp%10, hum/10, hum%10)
|
||||
} else {
|
||||
fmt.Printf("Could not take measurements from the sensor: %s\n", err.Error())
|
||||
|
||||
@@ -8,11 +8,7 @@ import (
|
||||
)
|
||||
|
||||
func main() {
|
||||
config := easystepper.DeviceConfig{
|
||||
Pin1: machine.P13, Pin2: machine.P15, Pin3: machine.P14, Pin4: machine.P16,
|
||||
StepCount: 200, RPM: 75, Mode: easystepper.ModeFour,
|
||||
}
|
||||
motor, _ := easystepper.New(config)
|
||||
motor := easystepper.New(machine.P13, machine.P15, machine.P14, machine.P16, 200, 75)
|
||||
motor.Configure()
|
||||
|
||||
for {
|
||||
|
||||
@@ -1,42 +0,0 @@
|
||||
//go:build feather_m0 || feather_m4 || feather_m4_can || feather_nrf52840 || feather_nrf52840_sense || feather_stm32f405 || feather_rp2040
|
||||
// +build feather_m0 feather_m4 feather_m4_can feather_nrf52840 feather_nrf52840_sense feather_stm32f405 feather_rp2040
|
||||
|
||||
package initdisplay
|
||||
|
||||
import (
|
||||
"machine"
|
||||
|
||||
"tinygo.org/x/drivers/ili9341"
|
||||
)
|
||||
|
||||
func InitDisplay() *ili9341.Device {
|
||||
machine.D5.Configure(machine.PinConfig{Mode: machine.PinOutput})
|
||||
machine.D6.Configure(machine.PinConfig{Mode: machine.PinOutput})
|
||||
|
||||
machine.SPI0.Configure(machine.SPIConfig{
|
||||
SCK: machine.SPI0_SCK_PIN,
|
||||
SDO: machine.SPI0_SDO_PIN,
|
||||
SDI: machine.SPI0_SDI_PIN,
|
||||
Frequency: 40000000,
|
||||
})
|
||||
|
||||
// configure backlight
|
||||
backlight := machine.D9
|
||||
backlight.Configure(machine.PinConfig{machine.PinOutput})
|
||||
|
||||
display := ili9341.NewSPI(
|
||||
machine.SPI0,
|
||||
machine.D10, // LCD_DC,
|
||||
machine.D11, // LCD_SS_PIN,
|
||||
machine.D12, // LCD_RESET,
|
||||
)
|
||||
|
||||
// configure display
|
||||
display.Configure(ili9341.Config{})
|
||||
|
||||
backlight.High()
|
||||
|
||||
display.SetRotation(ili9341.Rotation270)
|
||||
|
||||
return display
|
||||
}
|
||||
@@ -72,8 +72,7 @@ func drawPng(display *ili9341.Device) error {
|
||||
}
|
||||
})
|
||||
|
||||
_, err := png.Decode(p)
|
||||
return err
|
||||
return png.Decode(p)
|
||||
}
|
||||
|
||||
func drawJpeg(display *ili9341.Device) error {
|
||||
@@ -85,8 +84,7 @@ func drawJpeg(display *ili9341.Device) error {
|
||||
}
|
||||
})
|
||||
|
||||
_, err := jpeg.Decode(p)
|
||||
return err
|
||||
return jpeg.Decode(p)
|
||||
}
|
||||
|
||||
func errorMessage(err error) {
|
||||
|
||||
@@ -1,58 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"machine"
|
||||
"time"
|
||||
|
||||
"tinygo.org/x/drivers/irremote"
|
||||
)
|
||||
|
||||
var irCmdButtons = map[uint16]string{
|
||||
0x45: "POWER",
|
||||
0x47: "FUNC/STOP",
|
||||
0x46: "VOL+",
|
||||
0x44: "FAST BACK",
|
||||
0x40: "PAUSE",
|
||||
0x43: "FAST FORWARD",
|
||||
0x07: "DOWN",
|
||||
0x15: "VOL-",
|
||||
0x09: "UP",
|
||||
0x19: "EQ",
|
||||
0x0D: "ST/REPT",
|
||||
0x16: "0",
|
||||
0x0C: "1",
|
||||
0x18: "2",
|
||||
0x5E: "3",
|
||||
0x08: "4",
|
||||
0x1C: "5",
|
||||
0x5A: "6",
|
||||
0x42: "7",
|
||||
0x52: "8",
|
||||
0x4A: "9",
|
||||
}
|
||||
|
||||
var (
|
||||
pinIRIn = machine.GP26
|
||||
ir irremote.ReceiverDevice
|
||||
)
|
||||
|
||||
func setupPins() {
|
||||
ir = irremote.NewReceiver(pinIRIn)
|
||||
ir.Configure()
|
||||
}
|
||||
|
||||
func irCallback(data irremote.Data) {
|
||||
msg := "Command: " + irCmdButtons[data.Command]
|
||||
if data.Flags&irremote.DataFlagIsRepeat != 0 {
|
||||
msg = msg + " (REPEAT)"
|
||||
}
|
||||
println(msg)
|
||||
}
|
||||
|
||||
func main() {
|
||||
setupPins()
|
||||
ir.SetCommandHandler(irCallback)
|
||||
for {
|
||||
time.Sleep(time.Millisecond * 10)
|
||||
}
|
||||
}
|
||||
@@ -1,51 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"time"
|
||||
|
||||
"machine"
|
||||
|
||||
"tinygo.org/x/drivers/is31fl3731"
|
||||
)
|
||||
|
||||
// I2CAddress -- address of led matrix
|
||||
var I2CAddress uint8 = is31fl3731.I2C_ADDRESS_74
|
||||
|
||||
func main() {
|
||||
bus := machine.I2C0
|
||||
err := bus.Configure(machine.I2CConfig{})
|
||||
if err != nil {
|
||||
println("could not configure I2C:", err)
|
||||
return
|
||||
}
|
||||
|
||||
// Create driver for Adafruit 15x7 CharliePlex LED Matrix FeatherWing
|
||||
// (CharlieWing): https://www.adafruit.com/product/3163
|
||||
ledMatrix := is31fl3731.NewAdafruitCharlieWing15x7(bus, I2CAddress)
|
||||
|
||||
err = ledMatrix.Configure()
|
||||
if err != nil {
|
||||
println("could not configure is31fl3731 driver:", err)
|
||||
return
|
||||
}
|
||||
|
||||
// Fill the whole matrix on the frame #0 (visible by default)
|
||||
ledMatrix.Fill(is31fl3731.FRAME_0, uint8(3))
|
||||
|
||||
// Draw couple pixels on the frame #1 (not visible yet)
|
||||
ledMatrix.DrawPixelXY(is31fl3731.FRAME_1, uint8(0), uint8(0), uint8(10))
|
||||
ledMatrix.DrawPixelXY(is31fl3731.FRAME_1, uint8(14), uint8(6), uint8(10))
|
||||
|
||||
// There are 8 frames available, it's a good idea to draw on an invisible
|
||||
// frame and then switch to that frame to reduce flickering. Switch between
|
||||
// frame #0 and #1 in a loop to show animation:
|
||||
for {
|
||||
println("show frame #0...")
|
||||
ledMatrix.SetActiveFrame(is31fl3731.FRAME_0)
|
||||
time.Sleep(time.Second * 3)
|
||||
|
||||
println("show frame #1...")
|
||||
ledMatrix.SetActiveFrame(is31fl3731.FRAME_1)
|
||||
time.Sleep(time.Second * 3)
|
||||
}
|
||||
}
|
||||
@@ -1,39 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"machine"
|
||||
"time"
|
||||
|
||||
"tinygo.org/x/drivers/l3gd20"
|
||||
)
|
||||
|
||||
func main() {
|
||||
const (
|
||||
// Default address on most breakout boards.
|
||||
pcaAddr = 0x40
|
||||
)
|
||||
|
||||
bus := machine.I2C0
|
||||
|
||||
err := bus.Configure(machine.I2CConfig{})
|
||||
if err != nil {
|
||||
panic(err.Error())
|
||||
}
|
||||
|
||||
gyro := l3gd20.NewI2C(bus, 105)
|
||||
err = gyro.Configure(l3gd20.Config{Range: l3gd20.Range_250})
|
||||
if err != nil {
|
||||
println(err.Error())
|
||||
}
|
||||
|
||||
var x, y, z int32
|
||||
for {
|
||||
err = gyro.Update()
|
||||
if err != nil {
|
||||
println(err.Error())
|
||||
}
|
||||
x, y, z = gyro.AngularVelocity()
|
||||
println(x, y, z)
|
||||
time.Sleep(500 * time.Millisecond)
|
||||
}
|
||||
}
|
||||
@@ -1,37 +0,0 @@
|
||||
// Connects to an LSM6DS3TR I2C a 6 axis Inertial Measurement Unit (IMU)
|
||||
package main
|
||||
|
||||
import (
|
||||
"machine"
|
||||
"time"
|
||||
|
||||
"tinygo.org/x/drivers/lsm6ds3tr"
|
||||
)
|
||||
|
||||
func main() {
|
||||
machine.I2C0.Configure(machine.I2CConfig{})
|
||||
|
||||
accel := lsm6ds3tr.New(machine.I2C0)
|
||||
err := accel.Configure(lsm6ds3tr.Configuration{})
|
||||
if err != nil {
|
||||
for {
|
||||
println("Failed to configure", err.Error())
|
||||
time.Sleep(time.Second)
|
||||
}
|
||||
}
|
||||
|
||||
for {
|
||||
if !accel.Connected() {
|
||||
println("LSM6DS3TR not connected")
|
||||
time.Sleep(time.Second)
|
||||
continue
|
||||
}
|
||||
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)
|
||||
}
|
||||
}
|
||||
@@ -1,30 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"machine"
|
||||
"time"
|
||||
|
||||
"tinygo.org/x/drivers/makeybutton"
|
||||
)
|
||||
|
||||
var (
|
||||
led machine.Pin = machine.LED
|
||||
button machine.Pin = machine.BUTTON
|
||||
key *makeybutton.Button
|
||||
)
|
||||
|
||||
func main() {
|
||||
led.Configure(machine.PinConfig{Mode: machine.PinOutput})
|
||||
key = makeybutton.NewButton(button)
|
||||
key.Configure()
|
||||
|
||||
for {
|
||||
switch key.Get() {
|
||||
case makeybutton.Pressed:
|
||||
led.High()
|
||||
case makeybutton.Released:
|
||||
led.Low()
|
||||
}
|
||||
time.Sleep(100 * time.Millisecond)
|
||||
}
|
||||
}
|
||||
@@ -29,7 +29,6 @@ func main() {
|
||||
driver.StopDisplayTest()
|
||||
driver.SetDecodeMode(4)
|
||||
driver.SetScanLimit(4)
|
||||
driver.SetIntensity(8)
|
||||
driver.StopShutdownMode()
|
||||
|
||||
for i := 1; i < int(digitNumber); i++ {
|
||||
|
||||
@@ -1,40 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"time"
|
||||
|
||||
"tinygo.org/x/drivers/examples/rtl8720dn"
|
||||
)
|
||||
|
||||
var (
|
||||
debug = false
|
||||
)
|
||||
|
||||
func main() {
|
||||
err := run()
|
||||
for err != nil {
|
||||
fmt.Printf("error: %s\r\n", err.Error())
|
||||
time.Sleep(5 * time.Second)
|
||||
}
|
||||
}
|
||||
|
||||
func run() error {
|
||||
//rtl8720dn.Debug(true)
|
||||
rtl, err := rtl8720dn.Setup()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
ver, err := rtl.Version()
|
||||
if err != nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
for {
|
||||
fmt.Printf("RTL8270DN Firmware Version: %s\r\n", ver)
|
||||
time.Sleep(10 * time.Second)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
@@ -1,79 +0,0 @@
|
||||
//go:build wioterminal
|
||||
// +build wioterminal
|
||||
|
||||
package rtl8720dn
|
||||
|
||||
import (
|
||||
"device/sam"
|
||||
"machine"
|
||||
"runtime/interrupt"
|
||||
"time"
|
||||
|
||||
"tinygo.org/x/drivers/rtl8720dn"
|
||||
)
|
||||
|
||||
var (
|
||||
uart UARTx
|
||||
debug bool
|
||||
)
|
||||
|
||||
func handleInterrupt(interrupt.Interrupt) {
|
||||
// should reset IRQ
|
||||
uart.Receive(byte((uart.Bus.DATA.Get() & 0xFF)))
|
||||
uart.Bus.INTFLAG.SetBits(sam.SERCOM_USART_INT_INTFLAG_RXC)
|
||||
}
|
||||
|
||||
func Setup() (*rtl8720dn.RTL8720DN, error) {
|
||||
machine.RTL8720D_CHIP_PU.Configure(machine.PinConfig{Mode: machine.PinOutput})
|
||||
machine.RTL8720D_CHIP_PU.Low()
|
||||
time.Sleep(100 * time.Millisecond)
|
||||
machine.RTL8720D_CHIP_PU.High()
|
||||
time.Sleep(1000 * time.Millisecond)
|
||||
if debug {
|
||||
waitSerial()
|
||||
}
|
||||
|
||||
uart = UARTx{
|
||||
UART: &machine.UART{
|
||||
Buffer: machine.NewRingBuffer(),
|
||||
Bus: sam.SERCOM0_USART_INT,
|
||||
SERCOM: 0,
|
||||
},
|
||||
}
|
||||
|
||||
uart.Interrupt = interrupt.New(sam.IRQ_SERCOM0_2, handleInterrupt)
|
||||
uart.Configure(machine.UARTConfig{TX: machine.PB24, RX: machine.PC24, BaudRate: 614400})
|
||||
|
||||
rtl := rtl8720dn.New(uart)
|
||||
rtl.Debug(debug)
|
||||
|
||||
_, err := rtl.Rpc_tcpip_adapter_init_with_timeout(10 * time.Second)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return rtl, nil
|
||||
}
|
||||
|
||||
// Wait for user to open serial console
|
||||
func waitSerial() {
|
||||
for !machine.Serial.DTR() {
|
||||
time.Sleep(100 * time.Millisecond)
|
||||
}
|
||||
}
|
||||
|
||||
type UARTx struct {
|
||||
*machine.UART
|
||||
}
|
||||
|
||||
func (u UARTx) Read(p []byte) (n int, err error) {
|
||||
if u.Buffered() == 0 {
|
||||
time.Sleep(1 * time.Millisecond)
|
||||
return 0, nil
|
||||
}
|
||||
return u.UART.Read(p)
|
||||
}
|
||||
|
||||
func Debug(b bool) {
|
||||
debug = b
|
||||
}
|
||||
@@ -1,39 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"machine"
|
||||
"time"
|
||||
|
||||
"tinygo.org/x/drivers/scd4x"
|
||||
)
|
||||
|
||||
var (
|
||||
i2c = machine.I2C0
|
||||
sensor = scd4x.New(i2c)
|
||||
)
|
||||
|
||||
func main() {
|
||||
time.Sleep(1500 * time.Millisecond)
|
||||
|
||||
i2c.Configure(machine.I2CConfig{})
|
||||
if err := sensor.Configure(); err != nil {
|
||||
println(err)
|
||||
}
|
||||
|
||||
time.Sleep(1500 * time.Millisecond)
|
||||
|
||||
if err := sensor.StartPeriodicMeasurement(); err != nil {
|
||||
println(err)
|
||||
}
|
||||
|
||||
time.Sleep(1500 * time.Millisecond)
|
||||
|
||||
for {
|
||||
co2, err := sensor.ReadCO2()
|
||||
if err != nil {
|
||||
println(err)
|
||||
}
|
||||
println("CO2", co2)
|
||||
time.Sleep(time.Second)
|
||||
}
|
||||
}
|
||||
@@ -8,7 +8,7 @@ import (
|
||||
)
|
||||
|
||||
func init() {
|
||||
spi = &machine.SPI0
|
||||
spi = machine.SPI0
|
||||
sckPin = machine.SPI0_SCK_PIN
|
||||
sdoPin = machine.SPI0_SDO_PIN
|
||||
sdiPin = machine.SPI0_SDI_PIN
|
||||
|
||||
@@ -8,7 +8,7 @@ import (
|
||||
)
|
||||
|
||||
func init() {
|
||||
spi = &machine.SPI1
|
||||
spi = machine.SPI1
|
||||
sckPin = machine.SDCARD_SCK_PIN
|
||||
sdoPin = machine.SDCARD_SDO_PIN
|
||||
sdiPin = machine.SDCARD_SDI_PIN
|
||||
|
||||
@@ -8,7 +8,7 @@ import (
|
||||
)
|
||||
|
||||
func init() {
|
||||
spi = &machine.SPI0
|
||||
spi = machine.SPI0
|
||||
sckPin = machine.SPI0_SCK_PIN
|
||||
sdoPin = machine.SPI0_SDO_PIN
|
||||
sdiPin = machine.SPI0_SDI_PIN
|
||||
|
||||
@@ -9,7 +9,7 @@ import (
|
||||
)
|
||||
|
||||
var (
|
||||
spi *machine.SPI
|
||||
spi machine.SPI
|
||||
sckPin machine.Pin
|
||||
sdoPin machine.Pin
|
||||
sdiPin machine.Pin
|
||||
@@ -18,6 +18,7 @@ var (
|
||||
)
|
||||
|
||||
func main() {
|
||||
waitSerial()
|
||||
fmt.Printf("sdcard console\r\n")
|
||||
|
||||
led := ledPin
|
||||
@@ -41,3 +42,10 @@ func main() {
|
||||
time.Sleep(200 * time.Millisecond)
|
||||
}
|
||||
}
|
||||
|
||||
// Wait for user to open serial console
|
||||
func waitSerial() {
|
||||
for !machine.Serial.DTR() {
|
||||
time.Sleep(100 * time.Millisecond)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -8,7 +8,7 @@ import (
|
||||
)
|
||||
|
||||
func init() {
|
||||
spi = &machine.SDCARD_SPI
|
||||
spi = machine.SDCARD_SPI
|
||||
sckPin = machine.SDCARD_SCK_PIN
|
||||
sdoPin = machine.SDCARD_SDO_PIN
|
||||
sdiPin = machine.SDCARD_SDI_PIN
|
||||
|
||||
@@ -8,7 +8,7 @@ import (
|
||||
)
|
||||
|
||||
func init() {
|
||||
spi = &machine.SPI0
|
||||
spi = machine.SPI0
|
||||
sckPin = machine.SPI0_SCK_PIN
|
||||
sdoPin = machine.SPI0_SDO_PIN
|
||||
sdiPin = machine.SPI0_SDI_PIN
|
||||
|
||||
@@ -8,7 +8,7 @@ import (
|
||||
)
|
||||
|
||||
func init() {
|
||||
spi = &machine.SPI0
|
||||
spi = machine.SPI0
|
||||
sckPin = machine.SPI0_SCK_PIN
|
||||
sdoPin = machine.SPI0_SDO_PIN
|
||||
sdiPin = machine.SPI0_SDI_PIN
|
||||
|
||||
@@ -1,18 +0,0 @@
|
||||
//go:build thingplus_rp2040
|
||||
// +build thingplus_rp2040
|
||||
|
||||
package main
|
||||
|
||||
import (
|
||||
"machine"
|
||||
)
|
||||
|
||||
func init() {
|
||||
spi = machine.SPI1
|
||||
sckPin = machine.SPI1_SCK_PIN
|
||||
sdoPin = machine.SPI1_SDO_PIN
|
||||
sdiPin = machine.SPI1_SDI_PIN
|
||||
csPin = machine.GPIO9
|
||||
|
||||
ledPin = machine.LED
|
||||
}
|
||||
@@ -8,7 +8,7 @@ import (
|
||||
)
|
||||
|
||||
func init() {
|
||||
spi = &machine.SPI2
|
||||
spi = machine.SPI2
|
||||
sckPin = machine.SCK2
|
||||
sdoPin = machine.SDO2
|
||||
sdiPin = machine.SDI2
|
||||
|
||||
@@ -8,7 +8,7 @@ import (
|
||||
)
|
||||
|
||||
func init() {
|
||||
spi = &machine.SPI0
|
||||
spi = machine.SPI0
|
||||
sckPin = machine.SPI0_SCK_PIN
|
||||
sdoPin = machine.SPI0_SDO_PIN
|
||||
sdiPin = machine.SPI0_SDI_PIN
|
||||
|
||||
@@ -8,7 +8,7 @@ import (
|
||||
)
|
||||
|
||||
func init() {
|
||||
spi = &machine.SPI1
|
||||
spi = machine.SPI1
|
||||
sckPin = machine.SDCARD_SCK_PIN
|
||||
sdoPin = machine.SDCARD_SDO_PIN
|
||||
sdiPin = machine.SDCARD_SDI_PIN
|
||||
|
||||
@@ -8,7 +8,7 @@ import (
|
||||
)
|
||||
|
||||
func init() {
|
||||
spi = &machine.SPI0
|
||||
spi = machine.SPI0
|
||||
sckPin = machine.SPI0_SCK_PIN
|
||||
sdoPin = machine.SPI0_SDO_PIN
|
||||
sdiPin = machine.SPI0_SDI_PIN
|
||||
|
||||
@@ -11,7 +11,7 @@ import (
|
||||
)
|
||||
|
||||
var (
|
||||
spi *machine.SPI
|
||||
spi machine.SPI
|
||||
sckPin machine.Pin
|
||||
sdoPin machine.Pin
|
||||
sdiPin machine.Pin
|
||||
@@ -20,6 +20,8 @@ var (
|
||||
)
|
||||
|
||||
func main() {
|
||||
waitSerial()
|
||||
|
||||
sd := sdcard.New(spi, sckPin, sdoPin, sdiPin, csPin)
|
||||
err := sd.Configure()
|
||||
if err != nil {
|
||||
@@ -38,3 +40,10 @@ func main() {
|
||||
|
||||
console.RunFor(&sd, filesystem)
|
||||
}
|
||||
|
||||
// Wait for user to open serial console
|
||||
func waitSerial() {
|
||||
for !machine.Serial.DTR() {
|
||||
time.Sleep(100 * time.Millisecond)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -8,7 +8,7 @@ import (
|
||||
)
|
||||
|
||||
func init() {
|
||||
spi = &machine.SDCARD_SPI
|
||||
spi = machine.SDCARD_SPI
|
||||
sckPin = machine.SDCARD_SCK_PIN
|
||||
sdoPin = machine.SDCARD_SDO_PIN
|
||||
sdiPin = machine.SDCARD_SDI_PIN
|
||||
|
||||
@@ -8,7 +8,7 @@ import (
|
||||
)
|
||||
|
||||
func init() {
|
||||
spi = &machine.SPI0
|
||||
spi = machine.SPI0
|
||||
sckPin = machine.SPI0_SCK_PIN
|
||||
sdoPin = machine.SPI0_SDO_PIN
|
||||
sdiPin = machine.SPI0_SDI_PIN
|
||||
|
||||
@@ -8,7 +8,7 @@ import (
|
||||
)
|
||||
|
||||
func init() {
|
||||
spi = &machine.SPI0
|
||||
spi = machine.SPI0
|
||||
sckPin = machine.SPI0_SCK_PIN
|
||||
sdoPin = machine.SPI0_SDO_PIN
|
||||
sdiPin = machine.SPI0_SDI_PIN
|
||||
|
||||
@@ -1,18 +0,0 @@
|
||||
//go:build thingplus_rp2040
|
||||
// +build thingplus_rp2040
|
||||
|
||||
package main
|
||||
|
||||
import (
|
||||
"machine"
|
||||
)
|
||||
|
||||
func init() {
|
||||
spi = machine.SPI1
|
||||
sckPin = machine.SPI1_SCK_PIN
|
||||
sdoPin = machine.SPI1_SDO_PIN
|
||||
sdiPin = machine.SPI1_SDI_PIN
|
||||
csPin = machine.GPIO9
|
||||
|
||||
ledPin = machine.LED
|
||||
}
|
||||
@@ -8,7 +8,7 @@ import (
|
||||
)
|
||||
|
||||
func init() {
|
||||
spi = &machine.SPI2
|
||||
spi = machine.SPI2
|
||||
sckPin = machine.SCK2
|
||||
sdoPin = machine.SDO2
|
||||
sdiPin = machine.SDI2
|
||||
|
||||
@@ -4,11 +4,12 @@ package main
|
||||
// module will be in RX mode between two transmissions
|
||||
|
||||
import (
|
||||
"device/stm32"
|
||||
"machine"
|
||||
"runtime/interrupt"
|
||||
"time"
|
||||
|
||||
"tinygo.org/x/device/stm32"
|
||||
|
||||
rfswitch "tinygo.org/x/drivers/examples/sx126x/rfswitch"
|
||||
|
||||
"tinygo.org/x/drivers/sx126x"
|
||||
|
||||
@@ -1,49 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"image/color"
|
||||
"machine"
|
||||
|
||||
"tinygo.org/x/drivers/uc8151"
|
||||
)
|
||||
|
||||
var display uc8151.Device
|
||||
var led machine.Pin
|
||||
|
||||
func main() {
|
||||
led = machine.LED
|
||||
led.Configure(machine.PinConfig{Mode: machine.PinOutput})
|
||||
machine.SPI0.Configure(machine.SPIConfig{
|
||||
Frequency: 12000000,
|
||||
SCK: machine.EPD_SCK_PIN,
|
||||
SDO: machine.EPD_SDO_PIN,
|
||||
})
|
||||
|
||||
display = uc8151.New(machine.SPI0, machine.EPD_CS_PIN, machine.EPD_DC_PIN, machine.EPD_RESET_PIN, machine.EPD_BUSY_PIN)
|
||||
display.Configure(uc8151.Config{
|
||||
Rotation: uc8151.ROTATION_270,
|
||||
Speed: uc8151.MEDIUM,
|
||||
Blocking: true,
|
||||
})
|
||||
black := color.RGBA{1, 1, 1, 255}
|
||||
|
||||
display.ClearBuffer()
|
||||
display.Display()
|
||||
for i := int16(0); i < 37; i++ {
|
||||
for j := int16(0); j < 16; j++ {
|
||||
if (i+j)%2 == 0 {
|
||||
showRect(i*8, j*8, 8, 8, black)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
display.Display()
|
||||
}
|
||||
|
||||
func showRect(x int16, y int16, w int16, h int16, c color.RGBA) {
|
||||
for i := x; i < x+w; i++ {
|
||||
for j := y; j < y+h; j++ {
|
||||
display.SetPixel(i, j, c)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,5 +1,5 @@
|
||||
//go:build !digispark && !arduino && !qtpy && !m5stamp_c3 && !thingplus_rp2040
|
||||
// +build !digispark,!arduino,!qtpy,!m5stamp_c3,!thingplus_rp2040
|
||||
//go:build !digispark && !arduino && !qtpy && !m5stamp_c3
|
||||
// +build !digispark,!arduino,!qtpy,!m5stamp_c3
|
||||
|
||||
package main
|
||||
|
||||
|
||||
@@ -1,13 +0,0 @@
|
||||
//go:build thingplus_rp2040
|
||||
// +build thingplus_rp2040
|
||||
|
||||
package main
|
||||
|
||||
import "machine"
|
||||
|
||||
// This is the pin assignment for the internal neopixel of the
|
||||
// Sparkfun thingplus rp2040.
|
||||
// Replace neo and led in the code below to match the pin
|
||||
// that you are using if different.
|
||||
var neo machine.Pin = machine.GPIO8
|
||||
var led = machine.LED
|
||||
@@ -6,7 +6,8 @@ require (
|
||||
github.com/eclipse/paho.mqtt.golang v1.2.0
|
||||
github.com/frankban/quicktest v1.10.2
|
||||
golang.org/x/net v0.0.0-20210614182718-04defd469f4e
|
||||
tinygo.org/x/tinyfont v0.3.0
|
||||
tinygo.org/x/tinyfs v0.2.0
|
||||
tinygo.org/x/device v0.0.0-20220213155215-c873563f9ed5
|
||||
tinygo.org/x/tinyfont v0.2.1
|
||||
tinygo.org/x/tinyfs v0.1.0
|
||||
tinygo.org/x/tinyterm v0.1.0
|
||||
)
|
||||
|
||||
@@ -5,15 +5,12 @@ github.com/frankban/quicktest v1.10.2 h1:19ARM85nVi4xH7xPXuc5eM/udya5ieh7b/Sv+d8
|
||||
github.com/frankban/quicktest v1.10.2/go.mod h1:K+q6oSqb0W0Ininfk863uOk1lMy69l/P6txr3mVT54s=
|
||||
github.com/google/go-cmp v0.5.2 h1:X2ev0eStA3AbceY54o37/0PQ/UWqKEiiO2dKL5OPaFM=
|
||||
github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
|
||||
github.com/hajimehoshi/go-jisx0208 v1.0.0/go.mod h1:yYxEStHL7lt9uL+AbdWgW9gBumwieDoZCiB1f/0X0as=
|
||||
github.com/kr/pretty v0.2.1 h1:Fmg33tUaq4/8ym9TJN1x7sLJnHVwhP33CNkpYV/7rwI=
|
||||
github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
|
||||
github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
|
||||
github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
|
||||
github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
|
||||
github.com/sago35/go-bdf v0.0.0-20200313142241-6c17821c91c4/go.mod h1:rOebXGuMLsXhZAC6mF/TjxONsm45498ZyzVhel++6KM=
|
||||
github.com/valyala/fastjson v1.6.3/go.mod h1:CLCAqky6SMuOcxStkYQvblddUtoRxhYMGLrsQns1aXY=
|
||||
golang.org/x/image v0.0.0-20210628002857-a66eb6448b8d/go.mod h1:023OzeP/+EPmXeapQh35lcL3II3LrY8Ic+EFFKVhULM=
|
||||
golang.org/x/net v0.0.0-20210614182718-04defd469f4e h1:XpT3nA5TvE525Ne3hInMh6+GETgn27Zfm9dxsThnX2Q=
|
||||
golang.org/x/net v0.0.0-20210614182718-04defd469f4e/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
|
||||
golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
|
||||
@@ -24,15 +21,14 @@ golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
|
||||
golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
|
||||
golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
|
||||
golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
|
||||
tinygo.org/x/device v0.0.0-20220213155215-c873563f9ed5 h1:rCFZxtddwZRG0F1JpZJ/1gNED7nK6BEarWplLrDkP+E=
|
||||
tinygo.org/x/device v0.0.0-20220213155215-c873563f9ed5/go.mod h1:Kw2xNGKK/STJw9D7LupWt6ilG/qtbe2yoCD2Ru0AbTI=
|
||||
tinygo.org/x/drivers v0.14.0/go.mod h1:uT2svMq3EpBZpKkGO+NQHjxjGf1f42ra4OnMMwQL2aI=
|
||||
tinygo.org/x/drivers v0.15.1/go.mod h1:uT2svMq3EpBZpKkGO+NQHjxjGf1f42ra4OnMMwQL2aI=
|
||||
tinygo.org/x/drivers v0.16.0/go.mod h1:uT2svMq3EpBZpKkGO+NQHjxjGf1f42ra4OnMMwQL2aI=
|
||||
tinygo.org/x/drivers v0.19.0/go.mod h1:uJD/l1qWzxzLx+vcxaW0eY464N5RAgFi1zTVzASFdqI=
|
||||
tinygo.org/x/tinyfont v0.2.1 h1:FAaemBzw8wsfhAtG6fWW+QjyWw/K8YqEeiWo4N1pv4o=
|
||||
tinygo.org/x/tinyfont v0.2.1/go.mod h1:eLqnYSrFRjt5STxWaMeOWJTzrKhXqpWw7nU3bPfKOAM=
|
||||
tinygo.org/x/tinyfont v0.3.0 h1:HIRLQoI3oc+2CMhPcfv+Ig88EcTImE/5npjqOnMD4lM=
|
||||
tinygo.org/x/tinyfont v0.3.0/go.mod h1:+TV5q0KpwSGRWnN+ITijsIhrWYJkoUCp9MYELjKpAXk=
|
||||
tinygo.org/x/tinyfs v0.1.0 h1:yx1Tq9L60rpCm6HURo45x+Tnag+O9RGSbQfgeCb6XYU=
|
||||
tinygo.org/x/tinyfs v0.1.0/go.mod h1:ysc8Y92iHfhTXeyEM9+c7zviUQ4fN9UCFgSOFfMWv20=
|
||||
tinygo.org/x/tinyfs v0.2.0 h1:M0lwZC/dEGFt16XYN5GTQsif/qCkAN2qUVNxELVD1xg=
|
||||
tinygo.org/x/tinyfs v0.2.0/go.mod h1:6ZHYdvB3sFYeMB3ypmXZCNEnFwceKc61ADYTYHpep1E=
|
||||
tinygo.org/x/tinyterm v0.1.0 h1:80i+j+KWoxCFa/Xfp6pWbh79x+8zUdMXC1vaKj2QhkY=
|
||||
tinygo.org/x/tinyterm v0.1.0/go.mod h1:/DDhNnGwNF2/tNgHywvyZuCGnbH3ov49Z/6e8LPLRR4=
|
||||
|
||||
+45
-53
@@ -29,33 +29,6 @@ type Device struct {
|
||||
rd machine.Pin
|
||||
}
|
||||
|
||||
var cmdBuf [6]byte
|
||||
|
||||
var initCmd = []byte{
|
||||
0xEF, 3, 0x03, 0x80, 0x02,
|
||||
0xCF, 3, 0x00, 0xC1, 0x30,
|
||||
0xED, 4, 0x64, 0x03, 0x12, 0x81,
|
||||
0xE8, 3, 0x85, 0x00, 0x78,
|
||||
0xCB, 5, 0x39, 0x2C, 0x00, 0x34, 0x02,
|
||||
0xF7, 1, 0x20,
|
||||
0xEA, 2, 0x00, 0x00,
|
||||
PWCTR1, 1, 0x23, // Power control VRH[5:0]
|
||||
PWCTR2, 1, 0x10, // Power control SAP[2:0];BT[3:0]
|
||||
VMCTR1, 2, 0x3e, 0x28, // VCM control
|
||||
VMCTR2, 1, 0x86, // VCM control2
|
||||
MADCTL, 1, 0x48, // Memory Access Control
|
||||
VSCRSADD, 1, 0x00, // Vertical scroll zero
|
||||
PIXFMT, 1, 0x55,
|
||||
FRMCTR1, 2, 0x00, 0x18,
|
||||
DFUNCTR, 3, 0x08, 0x82, 0x27, // Display Function Control
|
||||
0xF2, 1, 0x00, // 3Gamma Function Disable
|
||||
GAMMASET, 1, 0x01, // Gamma curve selected
|
||||
GMCTRP1, 15, 0x0F, 0x31, 0x2B, 0x0C, 0x0E, 0x08, // Set Gamma
|
||||
0x4E, 0xF1, 0x37, 0x07, 0x10, 0x03, 0x0E, 0x09, 0x00,
|
||||
GMCTRN1, 15, 0x00, 0x0E, 0x14, 0x03, 0x11, 0x07, // Set Gamma
|
||||
0x31, 0xC1, 0x48, 0x08, 0x0F, 0x0C, 0x31, 0x36, 0x0F,
|
||||
}
|
||||
|
||||
// Configure prepares display for use
|
||||
func (d *Device) Configure(config Config) {
|
||||
|
||||
@@ -108,15 +81,42 @@ func (d *Device) Configure(config Config) {
|
||||
delay(150)
|
||||
}
|
||||
|
||||
if config.DisplayInversion {
|
||||
initCmd = append(initCmd, INVON, 0x80)
|
||||
initCmd := []byte{
|
||||
0xEF, 3, 0x03, 0x80, 0x02,
|
||||
0xCF, 3, 0x00, 0xC1, 0x30,
|
||||
0xED, 4, 0x64, 0x03, 0x12, 0x81,
|
||||
0xE8, 3, 0x85, 0x00, 0x78,
|
||||
0xCB, 5, 0x39, 0x2C, 0x00, 0x34, 0x02,
|
||||
0xF7, 1, 0x20,
|
||||
0xEA, 2, 0x00, 0x00,
|
||||
PWCTR1, 1, 0x23, // Power control VRH[5:0]
|
||||
PWCTR2, 1, 0x10, // Power control SAP[2:0];BT[3:0]
|
||||
VMCTR1, 2, 0x3e, 0x28, // VCM control
|
||||
VMCTR2, 1, 0x86, // VCM control2
|
||||
MADCTL, 1, 0x48, // Memory Access Control
|
||||
VSCRSADD, 1, 0x00, // Vertical scroll zero
|
||||
PIXFMT, 1, 0x55,
|
||||
FRMCTR1, 2, 0x00, 0x18,
|
||||
DFUNCTR, 3, 0x08, 0x82, 0x27, // Display Function Control
|
||||
0xF2, 1, 0x00, // 3Gamma Function Disable
|
||||
GAMMASET, 1, 0x01, // Gamma curve selected
|
||||
GMCTRP1, 15, 0x0F, 0x31, 0x2B, 0x0C, 0x0E, 0x08, // Set Gamma
|
||||
0x4E, 0xF1, 0x37, 0x07, 0x10, 0x03, 0x0E, 0x09, 0x00,
|
||||
GMCTRN1, 15, 0x00, 0x0E, 0x14, 0x03, 0x11, 0x07, // Set Gamma
|
||||
0x31, 0xC1, 0x48, 0x08, 0x0F, 0x0C, 0x31, 0x36, 0x0F,
|
||||
}
|
||||
|
||||
initCmd = append(initCmd,
|
||||
if config.DisplayInversion {
|
||||
initCmd = append(initCmd, []byte{
|
||||
INVON, 0x80,
|
||||
}...)
|
||||
}
|
||||
|
||||
initCmd = append(initCmd, []byte{
|
||||
SLPOUT, 0x80, // Exit Sleep
|
||||
DISPON, 0x80, // Display on
|
||||
0x00, // End of list
|
||||
)
|
||||
}...)
|
||||
for i, c := 0, len(initCmd); i < c; {
|
||||
cmd := initCmd[i]
|
||||
if cmd == 0x00 {
|
||||
@@ -267,28 +267,24 @@ func (d *Device) SetRotation(rotation Rotation) {
|
||||
case Rotation270Mirror:
|
||||
madctl = MADCTL_MX | MADCTL_MY | MADCTL_MV | MADCTL_BGR
|
||||
}
|
||||
cmdBuf[0] = madctl
|
||||
d.sendCommand(MADCTL, cmdBuf[:1])
|
||||
d.sendCommand(MADCTL, []uint8{madctl})
|
||||
d.rotation = rotation
|
||||
}
|
||||
|
||||
// SetScrollArea sets an area to scroll with fixed top/bottom or left/right parts of the display
|
||||
// Rotation affects scroll direction
|
||||
func (d *Device) SetScrollArea(topFixedArea, bottomFixedArea int16) {
|
||||
cmdBuf[0] = uint8(topFixedArea >> 8)
|
||||
cmdBuf[1] = uint8(topFixedArea)
|
||||
cmdBuf[2] = uint8(d.height - topFixedArea - bottomFixedArea>>8)
|
||||
cmdBuf[3] = uint8(d.height - topFixedArea - bottomFixedArea)
|
||||
cmdBuf[4] = uint8(bottomFixedArea >> 8)
|
||||
cmdBuf[5] = uint8(bottomFixedArea)
|
||||
d.sendCommand(VSCRDEF, cmdBuf[:6])
|
||||
d.sendCommand(VSCRDEF, []uint8{
|
||||
uint8(topFixedArea >> 8), uint8(topFixedArea),
|
||||
uint8(d.height - topFixedArea - bottomFixedArea>>8),
|
||||
uint8(d.height - topFixedArea - bottomFixedArea),
|
||||
uint8(bottomFixedArea >> 8), uint8(bottomFixedArea),
|
||||
})
|
||||
}
|
||||
|
||||
// SetScroll sets the vertical scroll address of the display.
|
||||
func (d *Device) SetScroll(line int16) {
|
||||
cmdBuf[0] = uint8(line >> 8)
|
||||
cmdBuf[1] = uint8(line)
|
||||
d.sendCommand(VSCRSADD, cmdBuf[:2])
|
||||
d.sendCommand(VSCRSADD, []uint8{uint8(line >> 8), uint8(line)})
|
||||
}
|
||||
|
||||
// StopScroll returns the display to its normal state
|
||||
@@ -302,20 +298,16 @@ func (d *Device) setWindow(x, y, w, h int16) {
|
||||
//y += d.rowOffset
|
||||
x1 := x + w - 1
|
||||
if x != d.x0 || x1 != d.x1 {
|
||||
cmdBuf[0] = uint8(x >> 8)
|
||||
cmdBuf[1] = uint8(x)
|
||||
cmdBuf[2] = uint8(x1 >> 8)
|
||||
cmdBuf[3] = uint8(x1)
|
||||
d.sendCommand(CASET, cmdBuf[:4])
|
||||
d.sendCommand(CASET, []uint8{
|
||||
uint8(x >> 8), uint8(x), uint8(x1 >> 8), uint8(x1),
|
||||
})
|
||||
d.x0, d.x1 = x, x1
|
||||
}
|
||||
y1 := y + h - 1
|
||||
if y != d.y0 || y1 != d.y1 {
|
||||
cmdBuf[0] = uint8(y >> 8)
|
||||
cmdBuf[1] = uint8(y)
|
||||
cmdBuf[2] = uint8(y1 >> 8)
|
||||
cmdBuf[3] = uint8(y1)
|
||||
d.sendCommand(PASET, cmdBuf[:4])
|
||||
d.sendCommand(PASET, []uint8{
|
||||
uint8(y >> 8), uint8(y), uint8(y1 >> 8), uint8(y1),
|
||||
})
|
||||
d.y0, d.y1 = y, y1
|
||||
}
|
||||
d.sendCommand(RAMWR, nil)
|
||||
|
||||
+2
-2
@@ -1,5 +1,5 @@
|
||||
//go:build !atsamd51 && !atsame5x && !atsamd21
|
||||
// +build !atsamd51,!atsame5x,!atsamd21
|
||||
//go:build !atsamd51 && !atsamd21
|
||||
// +build !atsamd51,!atsamd21
|
||||
|
||||
package ili9341
|
||||
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
//go:build atsamd51 || atsame5x
|
||||
// +build atsamd51 atsame5x
|
||||
//go:build atsamd51
|
||||
// +build atsamd51
|
||||
|
||||
package ili9341
|
||||
|
||||
|
||||
@@ -773,10 +773,10 @@ func (d *decoder) convertToRGB() (image.Image, error) {
|
||||
|
||||
// Decode reads a JPEG image from r. Different from the standard package, the
|
||||
// decoded result will be received by the callback set by SetCallback().
|
||||
func Decode(r io.Reader) (image.Image, error) {
|
||||
func Decode(r io.Reader) error {
|
||||
var d decoder
|
||||
_, err := d.decode(r, false)
|
||||
return nil, err
|
||||
return err
|
||||
}
|
||||
|
||||
// DecodeConfig returns the color model and dimensions of a JPEG image without
|
||||
|
||||
+4
-4
@@ -965,7 +965,7 @@ func (d *decoder) checkHeader() error {
|
||||
|
||||
// Decode reads a PNG image from r. Different from the standard package, the
|
||||
// decoded result will be received by the callback set by SetCallback().
|
||||
func Decode(r io.Reader) (image.Image, error) {
|
||||
func Decode(r io.Reader) error {
|
||||
d := &decoder{
|
||||
r: r,
|
||||
crc: crc32.NewIEEE(),
|
||||
@@ -974,17 +974,17 @@ func Decode(r io.Reader) (image.Image, error) {
|
||||
if err == io.EOF {
|
||||
err = io.ErrUnexpectedEOF
|
||||
}
|
||||
return nil, err
|
||||
return err
|
||||
}
|
||||
for d.stage != dsSeenIEND {
|
||||
if err := d.parseChunk(); err != nil {
|
||||
if err == io.EOF {
|
||||
err = io.ErrUnexpectedEOF
|
||||
}
|
||||
return nil, err
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil, nil
|
||||
return nil
|
||||
}
|
||||
|
||||
// DecodeConfig returns the color model and dimensions of a PNG image without
|
||||
|
||||
@@ -1,225 +0,0 @@
|
||||
package irremote // import "tinygo.org/x/drivers/irremote"
|
||||
|
||||
import (
|
||||
"machine"
|
||||
"time"
|
||||
)
|
||||
|
||||
// NEC protocol references
|
||||
// https://www.sbprojects.net/knowledge/ir/nec.php
|
||||
// https://techdocs.altium.com/display/FPGA/NEC+Infrared+Transmission+Protocol
|
||||
// https://simple-circuit.com/arduino-nec-remote-control-decoder/
|
||||
|
||||
// Data encapsulates the data received by the ReceiverDevice.
|
||||
type Data struct {
|
||||
// Code is the raw IR data received.
|
||||
Code uint32
|
||||
// Address is the decoded address from the IR data received.
|
||||
Address uint16
|
||||
// Command is the decoded command from the IR data recieved
|
||||
Command uint16
|
||||
// Flags provides additional information about the IR data received. See DataFlags
|
||||
Flags DataFlags
|
||||
}
|
||||
|
||||
// DataFlags provides bitwise flags representing various information about recieved IR data.
|
||||
type DataFlags uint16
|
||||
|
||||
// Valid values for DataFlags
|
||||
const (
|
||||
// DataFlagIsRepeat set indicates that the IR data is a repeat commmand
|
||||
DataFlagIsRepeat DataFlags = 1 << iota
|
||||
)
|
||||
|
||||
// CommandHandler defines the callback function used to provide IR data received by the ReceiverDevice.
|
||||
type CommandHandler func(data Data)
|
||||
|
||||
// nec_ir_state represents the various internal states used to decode the NEC IR protocol commands
|
||||
type nec_ir_state uint8
|
||||
|
||||
// Valid values for nec_ir_state
|
||||
const (
|
||||
lead_pulse_start nec_ir_state = iota // Start receiving IR data, beginning of 9ms lead pulse
|
||||
lead_space_start // End of 9ms lead pulse, start of 4.5ms space
|
||||
lead_space_end // End of 4.5ms space, start of 562µs pulse
|
||||
bit_read_start // End of 562µs pulse, start of 562µs or 1687µs space
|
||||
bit_read_end // End of 562µs or 1687µs space
|
||||
trail_pulse_end // End of 562µs trailing pulse
|
||||
)
|
||||
|
||||
// ReceiverDevice is the device for receiving IR commands
|
||||
type ReceiverDevice struct {
|
||||
pin machine.Pin // IR input pin.
|
||||
ch CommandHandler // client callback function
|
||||
necState nec_ir_state // internal state machine
|
||||
data Data // decoded data for client
|
||||
lastTime time.Time // used to track states
|
||||
bitIndex int // tracks which bit (0-31) of necCode is being read
|
||||
}
|
||||
|
||||
// NewReceiver returns a new IR receiver device
|
||||
func NewReceiver(pin machine.Pin) ReceiverDevice {
|
||||
return ReceiverDevice{pin: pin}
|
||||
}
|
||||
|
||||
// Configure configures the input pin for the IR receiver device
|
||||
func (ir *ReceiverDevice) Configure() {
|
||||
// The IR receiver sends logic HIGH when NOT receiving IR, and logic LOW when receiving IR
|
||||
ir.pin.Configure(machine.PinConfig{Mode: machine.PinInputPullup})
|
||||
}
|
||||
|
||||
// SetCommandHandler is used to start or stop receiving IR commands via a callback function (pass nil to stop)
|
||||
func (ir *ReceiverDevice) SetCommandHandler(ch CommandHandler) {
|
||||
ir.ch = ch
|
||||
ir.resetStateMachine()
|
||||
if ch != nil {
|
||||
// Start monitoring IR output pin for changes
|
||||
ir.pin.SetInterrupt(machine.PinFalling|machine.PinRising, ir.pinChange)
|
||||
} else {
|
||||
// Stop monitoring IR output pin for changes
|
||||
ir.pin.SetInterrupt(0, nil)
|
||||
}
|
||||
}
|
||||
|
||||
// Internal helper function to reset state machine on protocol failure
|
||||
func (ir *ReceiverDevice) resetStateMachine() {
|
||||
ir.data = Data{}
|
||||
ir.bitIndex = 0
|
||||
ir.necState = lead_pulse_start
|
||||
}
|
||||
|
||||
// Internal pin rising/falling edge interrupt handler
|
||||
func (ir *ReceiverDevice) pinChange(pin machine.Pin) {
|
||||
/* Currently TinyGo is sending machine.NoPin (0xff) for all pins, at least on RP2040
|
||||
if pin != ir.pin {
|
||||
return // This is not the pin you're looking for
|
||||
}
|
||||
*/
|
||||
now := time.Now()
|
||||
duration := now.Sub(ir.lastTime)
|
||||
ir.lastTime = now
|
||||
switch ir.necState {
|
||||
case lead_pulse_start:
|
||||
if !ir.pin.Get() {
|
||||
// IR is 'on' (pin is pulled high and sent low when IR is received)
|
||||
ir.necState = lead_space_start // move to next state
|
||||
}
|
||||
case lead_space_start:
|
||||
if duration > time.Microsecond*9500 || duration < time.Microsecond*8500 {
|
||||
// Invalid interval for 9ms lead pulse. Reset
|
||||
ir.resetStateMachine()
|
||||
} else {
|
||||
// 9ms lead pulse detected, move to next state
|
||||
ir.necState = lead_space_end
|
||||
}
|
||||
case lead_space_end:
|
||||
if duration > time.Microsecond*5000 || duration < time.Microsecond*1750 {
|
||||
// Invalid interval for 4.5ms lead space OR 2.25ms repeat space. Reset
|
||||
ir.resetStateMachine()
|
||||
} else {
|
||||
// 4.5ms lead space OR 2.25ms repeat space detected
|
||||
if duration > time.Microsecond*3000 {
|
||||
// 4.5ms lead space detected, new code incoming, move to next state
|
||||
ir.resetStateMachine()
|
||||
ir.necState = bit_read_start
|
||||
} else {
|
||||
// 2.25ms repeat space detected.
|
||||
if ir.data.Code != 0 {
|
||||
// Valid repeat code. Invoke client callback with repeat flag set
|
||||
ir.data.Flags |= DataFlagIsRepeat
|
||||
if ir.ch != nil {
|
||||
ir.ch(ir.data)
|
||||
}
|
||||
ir.necState = lead_pulse_start
|
||||
} else {
|
||||
// ir.data is not in a valid state for a repeat. Reset
|
||||
ir.resetStateMachine()
|
||||
}
|
||||
}
|
||||
}
|
||||
case bit_read_start:
|
||||
if duration > time.Microsecond*700 || duration < time.Microsecond*400 {
|
||||
// Invalid interval for 562.5µs pulse. Reset
|
||||
ir.resetStateMachine()
|
||||
} else {
|
||||
// 562.5µs pulse detected, move to next state
|
||||
ir.necState = bit_read_end
|
||||
}
|
||||
case bit_read_end:
|
||||
if duration > time.Microsecond*1800 || duration < time.Microsecond*400 {
|
||||
// Invalid interval for 562.5µs space OR 1687.5µs space. Reset
|
||||
ir.resetStateMachine()
|
||||
} else {
|
||||
// 562.5µs OR 1687.5µs space detected
|
||||
mask := uint32(1 << ir.bitIndex)
|
||||
if duration > time.Microsecond*1000 {
|
||||
// 1687.5µs space detected (logic 1) - Set bit
|
||||
ir.data.Code |= mask
|
||||
} else {
|
||||
// 562.5µs space detected (logic 0) - Clear bit
|
||||
ir.data.Code &^= mask
|
||||
}
|
||||
|
||||
ir.bitIndex++
|
||||
if ir.bitIndex > 31 {
|
||||
// We've read all bits for this code, move to next state
|
||||
ir.necState = trail_pulse_end
|
||||
} else {
|
||||
// Read next bit
|
||||
ir.necState = bit_read_start
|
||||
}
|
||||
}
|
||||
case trail_pulse_end:
|
||||
if duration > time.Microsecond*700 || duration < time.Microsecond*400 {
|
||||
// Invalid interval for trailing 562.5µs pulse. Reset
|
||||
ir.resetStateMachine()
|
||||
} else {
|
||||
// 562.5µs trailing pulse detected. Decode & validate data
|
||||
err := ir.decode()
|
||||
if err == irDecodeErrorNone {
|
||||
// Valid data, invoke client callback
|
||||
if ir.ch != nil {
|
||||
ir.ch(ir.data)
|
||||
}
|
||||
// around we go again. Note: we don't resetStateMachine() since repeat codes are now possible
|
||||
ir.necState = lead_pulse_start
|
||||
} else {
|
||||
ir.resetStateMachine()
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Error type for NEC format decoding
|
||||
type irDecodeError int
|
||||
|
||||
// Valid values for irDecodeError
|
||||
const (
|
||||
irDecodeErrorNone irDecodeError = iota // no error occurred
|
||||
irDecodeErrorInverseCheckFail // validation of inverse cmd does not match cmd
|
||||
)
|
||||
|
||||
func (ir *ReceiverDevice) decode() irDecodeError {
|
||||
// Decode cmd and inverse cmd and perform validation check
|
||||
cmd := uint8((ir.data.Code & 0x00ff0000) >> 16)
|
||||
invCmd := uint8((ir.data.Code & 0xff000000) >> 24)
|
||||
if cmd != ^invCmd {
|
||||
// Validation failure. cmd and inverse cmd do not match
|
||||
return irDecodeErrorInverseCheckFail
|
||||
}
|
||||
// cmd validation pass, decode address
|
||||
ir.data.Command = uint16(cmd)
|
||||
addrLow := uint8(ir.data.Code & 0xff)
|
||||
addrHigh := uint8((ir.data.Code & 0xff00) >> 8)
|
||||
if addrHigh == ^addrLow {
|
||||
// addrHigh is inverse of addrLow. This is not a valid 16-bit address in extended NEC coding
|
||||
// since it is indistinguishable from 8-bit address with inverse validation. Use the 8-bit address
|
||||
ir.data.Address = uint16(addrLow)
|
||||
} else {
|
||||
// 16-bit extended NEC address
|
||||
ir.data.Address = (uint16(addrHigh) << 8) | uint16(addrLow)
|
||||
}
|
||||
// Clear repeat flag
|
||||
ir.data.Flags &^= DataFlagIsRepeat
|
||||
return irDecodeErrorNone
|
||||
}
|
||||
@@ -1,209 +0,0 @@
|
||||
// Package is31fl3731 provides a driver for the Lumissil IS31FL3731 matrix LED
|
||||
// driver.
|
||||
//
|
||||
// Driver supports following layouts:
|
||||
// - any custom LED matrix layout
|
||||
// - Adafruit 15x7 CharliePlex LED Matrix FeatherWing (CharlieWing)
|
||||
// https://www.adafruit.com/product/3163
|
||||
//
|
||||
// Datasheet:
|
||||
// https://www.lumissil.com/assets/pdf/core/IS31FL3731_DS.pdf
|
||||
//
|
||||
// This driver inspired by Adafruit Python driver:
|
||||
// https://github.com/adafruit/Adafruit_CircuitPython_IS31FL3731
|
||||
//
|
||||
package is31fl3731
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"time"
|
||||
|
||||
"tinygo.org/x/drivers"
|
||||
)
|
||||
|
||||
// Device implements TinyGo driver for Lumissil IS31FL3731 matrix LED driver
|
||||
type Device struct {
|
||||
Address uint8
|
||||
bus drivers.I2C
|
||||
|
||||
// Currently selected command register (one of the frame registers or the
|
||||
// function register)
|
||||
selectedCommand uint8
|
||||
}
|
||||
|
||||
// Configure chip for operating as a LED matrix display
|
||||
func (d *Device) Configure() (err error) {
|
||||
// Shutdown software
|
||||
err = d.writeFunctionRegister(SET_SHUTDOWN, []byte{SOFTWARE_OFF})
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to shutdown: %w", err)
|
||||
}
|
||||
|
||||
time.Sleep(time.Millisecond * 10)
|
||||
|
||||
// Wake up software
|
||||
err = d.writeFunctionRegister(SET_SHUTDOWN, []byte{SOFTWARE_ON})
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to wake up: %w", err)
|
||||
}
|
||||
|
||||
// Set display to a picture mode ("auto frame play mode" and "audio frame play
|
||||
// mode" are not supported in this version of the driver)
|
||||
err = d.writeFunctionRegister(SET_DISPLAY_MODE, []byte{DISPLAY_MODE_PICTURE})
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to switch to a picture move: %w", err)
|
||||
}
|
||||
|
||||
// Enable LEDs that are present (soldered) on the board. From the datasheet:
|
||||
// LEDs which are no connected must be off by LED Control Register (Frame
|
||||
// Registers) or it will affect other LEDs
|
||||
err = d.enableLEDs()
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to enable LEDs: %w", err)
|
||||
}
|
||||
|
||||
// Disable audiosync
|
||||
err = d.writeFunctionRegister(SET_AUDIOSYNC, []byte{AUDIOSYNC_OFF})
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to disable audiosync: %w", err)
|
||||
}
|
||||
|
||||
// Clear all frames
|
||||
for frame := FRAME_0; frame <= FRAME_7; frame++ {
|
||||
err = d.Clear(frame)
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to clear frame %d: %w", frame, err)
|
||||
}
|
||||
}
|
||||
|
||||
// 1st frame is displayed by default
|
||||
err = d.SetActiveFrame(FRAME_0)
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to set active frame: %w", err)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// selectCommand selects command register, can be:
|
||||
// - frame registers 0-7
|
||||
// - function register
|
||||
func (d *Device) selectCommand(command uint8) (err error) {
|
||||
if command != d.selectedCommand {
|
||||
d.selectedCommand = command
|
||||
return d.bus.WriteRegister(d.Address, COMMAND, []byte{command})
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// writeFunctionRegister selects the function register and writes data into it
|
||||
func (d *Device) writeFunctionRegister(operation uint8, data []byte) (err error) {
|
||||
err = d.selectCommand(FUNCTION)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
return d.bus.WriteRegister(d.Address, operation, data)
|
||||
}
|
||||
|
||||
// enableLEDs enables only LEDs that are soldered on the set board. Enabled
|
||||
// all 16x9 LEDs by default
|
||||
func (d *Device) enableLEDs() (err error) {
|
||||
for frame := FRAME_0; frame <= FRAME_7; frame++ {
|
||||
err = d.selectCommand(frame)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// Enable every LED (16 columns x 9 rows)
|
||||
for i := uint8(0); i < 16; i++ {
|
||||
err = d.bus.WriteRegister(d.Address, i, []byte{0xFF})
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// setPixelPWD sets individual pixel's PWM value [0-255] on the selected frame
|
||||
func (d *Device) setPixelPWD(frame, n, value uint8) (err error) {
|
||||
err = d.selectCommand(frame)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
return d.bus.WriteRegister(d.Address, LED_PWM_OFFSET+n, []byte{value})
|
||||
}
|
||||
|
||||
// SetActiveFrame sets frame to display with LEDs
|
||||
func (d *Device) SetActiveFrame(frame uint8) (err error) {
|
||||
if frame > FRAME_7 {
|
||||
return fmt.Errorf("frame %d is out of valid range [0-7]", frame)
|
||||
}
|
||||
|
||||
return d.writeFunctionRegister(SET_ACTIVE_FRAME, []byte{frame})
|
||||
}
|
||||
|
||||
// Fill the whole frame with provided PWM value [0-255]
|
||||
func (d *Device) Fill(frame, value uint8) (err error) {
|
||||
if frame > FRAME_7 {
|
||||
return fmt.Errorf("frame %d is out of valid range [0-7]", frame)
|
||||
}
|
||||
|
||||
err = d.selectCommand(frame)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
data := make([]byte, 24)
|
||||
for i := range data {
|
||||
data[i] = value
|
||||
}
|
||||
|
||||
for i := uint8(0); i < 6; i++ {
|
||||
err = d.bus.WriteRegister(d.Address, LED_PWM_OFFSET+i*24, data)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// Clear the whole frame
|
||||
func (d *Device) Clear(frame uint8) (err error) {
|
||||
return d.Fill(frame, 0x00)
|
||||
}
|
||||
|
||||
// DrawPixelIndex draws a single pixel on the selected frame by its index with
|
||||
// provided PWM value [0-255]
|
||||
func (d *Device) DrawPixelIndex(frame, index, value uint8) (err error) {
|
||||
if frame > FRAME_7 {
|
||||
return fmt.Errorf("frame %d is out of valid range [0-7]", frame)
|
||||
}
|
||||
|
||||
return d.setPixelPWD(frame, index, value)
|
||||
}
|
||||
|
||||
// DrawPixelXY draws a single pixel on the selected frame by its XY coordinates
|
||||
// with provided PWM value [0-255]. Raw LEDs layout assumed to be a 16x9 matrix,
|
||||
// and can be used with any custom board that has IS31FL3731 driver.
|
||||
func (d *Device) DrawPixelXY(frame, x, y, value uint8) (err error) {
|
||||
return d.setPixelPWD(frame, 16*x+y, value)
|
||||
}
|
||||
|
||||
// New creates a raw driver w/o any preset board layout.
|
||||
// Addresses:
|
||||
// - 0x74 (AD pin connected to GND)
|
||||
// - 0x75 (AD pin connected to SCL)
|
||||
// - 0x76 (AD pin connected to SDA)
|
||||
// - 0x77 (AD pin connected to VCC)
|
||||
func New(bus drivers.I2C, address uint8) Device {
|
||||
return Device{
|
||||
Address: address,
|
||||
bus: bus,
|
||||
}
|
||||
}
|
||||
@@ -1,106 +0,0 @@
|
||||
package is31fl3731
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
"tinygo.org/x/drivers"
|
||||
)
|
||||
|
||||
// DeviceAdafruitCharlieWing15x7 implements TinyGo driver for Lumissil
|
||||
// IS31FL3731 matrix LED driver on Adafruit 15x7 CharliePlex LED Matrix
|
||||
// FeatherWing (CharlieWing) board: https://www.adafruit.com/product/3163
|
||||
type DeviceAdafruitCharlieWing15x7 struct {
|
||||
Device
|
||||
}
|
||||
|
||||
// enableLEDs enables only LEDs that are soldered on the Adafruit CharlieWing
|
||||
// board. The board has following LEDs matrix layout:
|
||||
//
|
||||
// "o" - connected (soldered) LEDs
|
||||
// "x" - not connected LEDs
|
||||
//
|
||||
// + - - - - - - - - - - - - - - +
|
||||
// | + - - - - - - - - - - - - + |
|
||||
// | | | |
|
||||
// | | v v
|
||||
// +---------------------------------+
|
||||
// | o o o o o o o o o o o o o o o x |
|
||||
// | o o o o o o o o o o o o o o o x |
|
||||
// | o o o o o o o o o o o o o o o x |
|
||||
// | o o o o o o o o o o o o o o o x |
|
||||
// | o o o o o o o o o o o o o o o x |
|
||||
// | o o o o o o o o o o o o o o o x |
|
||||
// | o o o o o o o o o o o o o o o x |
|
||||
// | x x x x x x x x x x x x x x x x |
|
||||
// +---------------------------------+
|
||||
// ^ ^ | |
|
||||
// | | ... - - + |
|
||||
// | + - - - - - - - - - - - - - +
|
||||
// |
|
||||
// start (address 0x00)
|
||||
//
|
||||
func (d *DeviceAdafruitCharlieWing15x7) enableLEDs() (err error) {
|
||||
for frame := FRAME_0; frame <= FRAME_7; frame++ {
|
||||
err = d.selectCommand(frame)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// Enable left half
|
||||
for i := uint8(0); i < 16; i += 2 {
|
||||
err = d.bus.WriteRegister(d.Address, i, []byte{0b11111110})
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
// Enable right half
|
||||
for i := uint8(3); i < 16; i += 2 {
|
||||
err = d.bus.WriteRegister(d.Address, i, []byte{0b01111111})
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
// Disable invisible column on the right side
|
||||
err = d.bus.WriteRegister(d.Address, 1, []byte{0b00000000})
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// DrawPixelXY draws a single pixel on the selected frame by its XY coordinates
|
||||
// with provided PWM value [0-255]
|
||||
func (d *DeviceAdafruitCharlieWing15x7) DrawPixelXY(frame, x, y, value uint8) (err error) {
|
||||
var index uint8
|
||||
|
||||
if x >= 15 {
|
||||
return fmt.Errorf("invalid value: X is out of range [0, 15]")
|
||||
} else if y >= 7 {
|
||||
return fmt.Errorf("invalid value: Y is out of range [0, 7]")
|
||||
}
|
||||
|
||||
// Board is one pixel shorter (7 vs 8 supported pixels)
|
||||
if x < 8 {
|
||||
index = 16*x + y + 1
|
||||
} else {
|
||||
index = 16*(16-x) - y - 1 - 1
|
||||
}
|
||||
|
||||
return d.setPixelPWD(frame, index, value)
|
||||
}
|
||||
|
||||
// NewAdafruitCharlieWing15x7 creates a new driver with Adafruit 15x7
|
||||
// CharliePlex LED Matrix FeatherWing (CharlieWing) layout.
|
||||
// Available addresses:
|
||||
// - 0x74 (default)
|
||||
// - 0x77 (when the address jumper soldered)
|
||||
func NewAdafruitCharlieWing15x7(bus drivers.I2C, address uint8) DeviceAdafruitCharlieWing15x7 {
|
||||
return DeviceAdafruitCharlieWing15x7{
|
||||
Device: Device{
|
||||
Address: address,
|
||||
bus: bus,
|
||||
},
|
||||
}
|
||||
}
|
||||
@@ -1,52 +0,0 @@
|
||||
package is31fl3731
|
||||
|
||||
// Registers. Names taken from the datasheet:
|
||||
// https://www.lumissil.com/assets/pdf/core/IS31FL3731_DS.pdf
|
||||
const (
|
||||
// AD pin connected to GND
|
||||
I2C_ADDRESS_74 uint8 = 0x74
|
||||
// AD pin connected to SCL
|
||||
I2C_ADDRESS_75 uint8 = 0x75
|
||||
// AD pin connected to SDA
|
||||
I2C_ADDRESS_76 uint8 = 0x76
|
||||
// AD pin connected to VCC
|
||||
I2C_ADDRESS_77 uint8 = 0x77
|
||||
|
||||
// Main command register
|
||||
COMMAND uint8 = 0xFD
|
||||
|
||||
// Commands for each of 8 frames
|
||||
FRAME_0 uint8 = 0x00
|
||||
FRAME_1 uint8 = 0x01
|
||||
FRAME_2 uint8 = 0x02
|
||||
FRAME_3 uint8 = 0x03
|
||||
FRAME_4 uint8 = 0x04
|
||||
FRAME_5 uint8 = 0x05
|
||||
FRAME_6 uint8 = 0x06
|
||||
FRAME_7 uint8 = 0x07
|
||||
|
||||
// Command to set configuration
|
||||
FUNCTION uint8 = 0x0B
|
||||
|
||||
// Configuration:
|
||||
SET_DISPLAY_MODE uint8 = 0x00
|
||||
SET_ACTIVE_FRAME uint8 = 0x01
|
||||
SET_AUDIOSYNC uint8 = 0x06
|
||||
SET_SHUTDOWN uint8 = 0x0A
|
||||
|
||||
// Configuration: display mode
|
||||
DISPLAY_MODE_PICTURE uint8 = 0x00
|
||||
|
||||
// Configuration: audiosync (enable audio signal to modulate the intensity of
|
||||
// the matrix)
|
||||
AUDIOSYNC_OFF uint8 = 0x00
|
||||
AUDIOSYNC_ON uint8 = 0x01
|
||||
|
||||
// Configuration: software shutdown
|
||||
SOFTWARE_OFF uint8 = 0x00
|
||||
SOFTWARE_ON uint8 = 0x01
|
||||
|
||||
// Frame LEDs
|
||||
LED_CONTROL_OFFSET uint8 = 0x00 // to on/off each LED
|
||||
LED_PWM_OFFSET uint8 = 0x24 // to set PWM (0-255) for each LED
|
||||
)
|
||||
-141
@@ -1,141 +0,0 @@
|
||||
package l3gd20
|
||||
|
||||
import (
|
||||
"encoding/binary"
|
||||
"time"
|
||||
|
||||
"tinygo.org/x/drivers"
|
||||
)
|
||||
|
||||
const (
|
||||
fifoLen = 32 * 3 * 2
|
||||
)
|
||||
|
||||
type DevI2C struct {
|
||||
addr uint8
|
||||
// sensitivity or range.
|
||||
mul int32
|
||||
bus drivers.I2C
|
||||
buf [1]byte
|
||||
// gyro databuf.
|
||||
databuf [6]byte
|
||||
data [3]int32
|
||||
}
|
||||
|
||||
func NewI2C(bus drivers.I2C, addr uint8) *DevI2C {
|
||||
return &DevI2C{
|
||||
addr: addr,
|
||||
bus: bus,
|
||||
mul: sensMul250,
|
||||
}
|
||||
}
|
||||
|
||||
// Initializes and configures the device.
|
||||
func (d *DevI2C) Configure(cfg Config) error {
|
||||
err := cfg.validate()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
err = d.Reboot()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
// Reset then switch to normal mode and enable all three channels.
|
||||
err = d.write8(CTRL_REG1, 0)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
err = d.write8(CTRL_REG1, reg1NormalBits)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
// Reset REG2 values to default
|
||||
err = d.write8(CTRL_REG3, 0)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// Set sensitivity
|
||||
switch cfg.Range {
|
||||
case 1: // debugging range
|
||||
d.mul = 1
|
||||
cfg.Range = Range_2000
|
||||
case Range_250:
|
||||
d.mul = sensMul250
|
||||
case Range_500:
|
||||
d.mul = sensMul500
|
||||
case Range_2000:
|
||||
d.mul = sensMul2000
|
||||
default:
|
||||
return ErrBadRange
|
||||
}
|
||||
err = d.write8(CTRL_REG4, cfg.Range)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
// Finally verify whomai register and return error if
|
||||
// board is not who it says it is. Some counterfeit boards
|
||||
// have incorrect whomai but can still be used.
|
||||
whoami, err := d.read8(WHOAMI)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if whoami != expectedWHOAMI && whoami != expectedWHOAMI_H {
|
||||
return ErrBadIdentity
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (d *DevI2C) Update() error {
|
||||
err := d.bus.ReadRegister(d.addr, OUT_X_L, d.databuf[:2])
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
err = d.bus.ReadRegister(d.addr, OUT_Y_L, d.databuf[2:4])
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
err = d.bus.ReadRegister(d.addr, OUT_Z_L, d.databuf[4:6])
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
x := int16(binary.LittleEndian.Uint16(d.databuf[0:]))
|
||||
y := int16(binary.LittleEndian.Uint16(d.databuf[2:]))
|
||||
z := int16(binary.LittleEndian.Uint16(d.databuf[4:]))
|
||||
d.data[0] = d.mul * int32(x)
|
||||
d.data[1] = d.mul * int32(y)
|
||||
d.data[2] = d.mul * int32(z)
|
||||
return nil
|
||||
}
|
||||
|
||||
// Reboot sets reboot bit in CTRL_REG5 to true and unsets it.
|
||||
func (d *DevI2C) Reboot() error {
|
||||
reg5, err := d.read8(CTRL_REG5)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
// Write reboot bit and then unset it.
|
||||
err = d.write8(CTRL_REG5, reg5|reg5RebootBit)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
time.Sleep(50 * time.Microsecond)
|
||||
return d.write8(CTRL_REG5, reg5&^reg5RebootBit)
|
||||
}
|
||||
|
||||
// AngularVelocity returns result in microradians per second.
|
||||
func (d *DevI2C) AngularVelocity() (x, y, z int32) {
|
||||
return d.data[0], d.data[1], d.data[2]
|
||||
}
|
||||
|
||||
// func (d DevI2C) Update(measurement)
|
||||
|
||||
func (d DevI2C) read8(reg uint8) (byte, error) {
|
||||
err := d.bus.ReadRegister(d.addr, reg, d.buf[:1])
|
||||
return d.buf[0], err
|
||||
}
|
||||
|
||||
func (d DevI2C) write8(reg uint8, val byte) error {
|
||||
d.buf[0] = val
|
||||
return d.bus.WriteRegister(d.addr, reg, d.buf[:1])
|
||||
}
|
||||
@@ -1,49 +0,0 @@
|
||||
package l3gd20
|
||||
|
||||
import "errors"
|
||||
|
||||
var (
|
||||
ErrBadIdentity = errors.New("got unexpected identity from WHOMAI")
|
||||
ErrBadRange = errors.New("bad range configuration value")
|
||||
)
|
||||
|
||||
// Sensitivity factors
|
||||
const (
|
||||
// range at bits 4-5
|
||||
// 00 = 250 dps
|
||||
// 01 = 500 dps
|
||||
// 10 = 2000 dps
|
||||
// 11 = 2000 dps
|
||||
rangePos = 4
|
||||
Range_250 = 0b00 << rangePos // 8.75 mdps/digit
|
||||
Range_500 = 0b01 << rangePos // 17.5 mdps/digit
|
||||
Range_2000 = 0b11 << rangePos // 70 mdps/digit
|
||||
rangebits = Range_250 | Range_500 | Range_2000
|
||||
|
||||
// Sensitivities for degrees
|
||||
sensDiv250dps = 800
|
||||
sensDiv500dps = 400
|
||||
sensDiv2000dps = 100
|
||||
sens_250 = 7. / sensDiv250dps // Sensitivity at 250 dps
|
||||
sens_500 = 7. / sensDiv500dps // Sensitivity at 500 dps
|
||||
sens_2000 = 7. / sensDiv2000dps // Sensitivity at 500 dp
|
||||
|
||||
// 1e6*Pi/180. = 17453.292519943298 (constant for Degree to micro radians conversion)
|
||||
// sensitivities for radians
|
||||
sensMul250 = 7 * 1745329 / 100 / sensDiv250dps
|
||||
sensMul500 = 7 * 1745329 / 100 / sensDiv500dps
|
||||
sensMul2000 = 7 * 1745329 / 100 / sensDiv2000dps
|
||||
)
|
||||
|
||||
type Config struct {
|
||||
Range uint8
|
||||
}
|
||||
|
||||
// validate scans config for invalid data and returns non-nil
|
||||
// error indicating what data must be modified.
|
||||
func (cfg *Config) validate() error {
|
||||
if cfg.Range&^rangebits != 0 && cfg.Range != 1 {
|
||||
return ErrBadRange
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -1,99 +0,0 @@
|
||||
package l3gd20
|
||||
|
||||
// Expected identification number for L3GD20.
|
||||
const (
|
||||
// For L3GD20
|
||||
expectedWHOAMI = 0xD4
|
||||
// For L3GD20H
|
||||
expectedWHOAMI_H = 0xD7
|
||||
)
|
||||
|
||||
// Register bits masks
|
||||
const (
|
||||
reg5RebootBit = 1 << 7
|
||||
reg5FIFOEnableBit = 1 << 6
|
||||
reg1NormalBits = 0b1111
|
||||
)
|
||||
|
||||
// Register addresses. Comments from https://github.com/adafruit/Adafruit_L3GD20_U/blob/master/Adafruit_L3GD20_U.cpp
|
||||
const (
|
||||
// The Slave ADdress (SAD) associated with the L3GD20 is 110101xb
|
||||
I2CAddr = 0b1101011
|
||||
// The SDO pin can be used to modify the less significant bit of the device address.
|
||||
I2CAddrSDOLow = 0b1101010
|
||||
WHOAMI uint8 = 0x0F
|
||||
// CTRL_REG1 (0x20)
|
||||
// ====================================================================
|
||||
// BIT Symbol Description Default
|
||||
// --- ------ --------------------------------------------- -------
|
||||
// 7-6 DR1/0 Output data rate 00
|
||||
// 5-4 BW1/0 Bandwidth selection 00
|
||||
// 3 PD 0 = Power-down mode, 1 = normal/sleep mode 0
|
||||
// 2 ZEN Z-axis enable (0 = disabled, 1 = enabled) 1
|
||||
// 1 YEN Y-axis enable (0 = disabled, 1 = enabled) 1
|
||||
// 0 XEN X-axis enable (0 = disabled, 1 = enabled) 1
|
||||
CTRL_REG1 uint8 = 0x20
|
||||
// Set CTRL_REG2 (0x21)
|
||||
// ====================================================================
|
||||
// BIT Symbol Description Default
|
||||
// --- ------ --------------------------------------------- -------
|
||||
// 5-4 HPM1/0 High-pass filter mode selection 00
|
||||
// 3-0 HPCF3..0 High-pass filter cutoff frequency selection 0000
|
||||
CTRL_REG2 uint8 = 0x21
|
||||
// CTRL_REG3 (0x22)
|
||||
// ====================================================================
|
||||
// BIT Symbol Description Default
|
||||
// --- ------ --------------------------------------------- -------
|
||||
// 7 I1_Int1 Interrupt enable on INT1 (0=disable,1=enable) 0
|
||||
// 6 I1_Boot Boot status on INT1 (0=disable,1=enable) 0
|
||||
// 5 H-Lactive Interrupt active config on INT1 (0=high,1=low) 0
|
||||
// 4 PP_OD Push-Pull/Open-Drain (0=PP, 1=OD) 0
|
||||
// 3 I2_DRDY Data ready on DRDY/INT2 (0=disable,1=enable) 0
|
||||
// 2 I2_WTM FIFO wtrmrk int on DRDY/INT2 (0=dsbl,1=enbl) 0
|
||||
// 1 I2_ORun FIFO overrun int on DRDY/INT2 (0=dsbl,1=enbl) 0
|
||||
// 0 I2_Empty FIFI empty int on DRDY/INT2 (0=dsbl,1=enbl) 0
|
||||
CTRL_REG3 uint8 = 0x22
|
||||
// CTRL_REG4 (0x23)
|
||||
// ====================================================================
|
||||
// BIT Symbol Description Default
|
||||
// --- ------ --------------------------------------------- -------
|
||||
// 7 BDU Block Data Update (0=continuous, 1=LSB/MSB) 0
|
||||
// 6 BLE Big/Little-Endian (0=Data LSB, 1=Data MSB) 0
|
||||
// 5-4 FS1/0 Full scale selection 00
|
||||
// 00 = 250 dps
|
||||
// 01 = 500 dps
|
||||
// 10 = 2000 dps
|
||||
// 11 = 2000 dps
|
||||
// 0 SIM SPI Mode (0=4-wire, 1=3-wire) 0
|
||||
CTRL_REG4 uint8 = 0x23
|
||||
// CTRL_REG5 (0x24)
|
||||
// ====================================================================
|
||||
// BIT Symbol Description Default
|
||||
// --- ------ --------------------------------------------- -------
|
||||
// 7 BOOT Reboot memory content (0=normal, 1=reboot) 0
|
||||
// 6 FIFO_EN FIFO enable (0=FIFO disable, 1=enable) 0
|
||||
// 4 HPen High-pass filter enable (0=disable,1=enable) 0
|
||||
// 3-2 INT1_SEL INT1 Selection config 00
|
||||
// 1-0 OUT_SEL Out selection config 00
|
||||
CTRL_REG5 uint8 = 0x24
|
||||
REFERENCE uint8 = 0x25
|
||||
OUT_TEMP uint8 = 0x26
|
||||
STATUS_REG uint8 = 0x27
|
||||
OUT_X_L uint8 = 0x28
|
||||
OUT_X_H uint8 = 0x29
|
||||
OUT_Y_L uint8 = 0x2A
|
||||
OUT_Y_H uint8 = 0x2B
|
||||
OUT_Z_L uint8 = 0x2C
|
||||
OUT_Z_H uint8 = 0x2D
|
||||
FIFO_CTRL_REG uint8 = 0x2E
|
||||
FIFO_SRC_REG uint8 = 0x2F
|
||||
INT1_CFG uint8 = 0x30
|
||||
INT1_SRC uint8 = 0x31
|
||||
INT1_TSH_XH uint8 = 0x32
|
||||
INT1_TSH_XL uint8 = 0x33
|
||||
INT1_TSH_YH uint8 = 0x34
|
||||
INT1_TSH_YL uint8 = 0x35
|
||||
INT1_TSH_ZH uint8 = 0x36
|
||||
INT1_TSH_ZL uint8 = 0x37
|
||||
INT1_DURATION uint8 = 0x38
|
||||
)
|
||||
@@ -1,189 +0,0 @@
|
||||
// Package lsm6ds3tr implements a driver for the LSM6DS3TR
|
||||
// a 6 axis Inertial Measurement Unit (IMU)
|
||||
//
|
||||
// Datasheet: https://www.st.com/resource/en/datasheet/lsm6ds3tr.pdf
|
||||
//
|
||||
package lsm6ds3tr // import "tinygo.org/x/drivers/lsm6ds3tr"
|
||||
|
||||
import (
|
||||
"errors"
|
||||
|
||||
"tinygo.org/x/drivers"
|
||||
)
|
||||
|
||||
type AccelRange uint8
|
||||
type AccelSampleRate uint8
|
||||
type AccelBandwidth uint8
|
||||
|
||||
type GyroRange uint8
|
||||
type GyroSampleRate uint8
|
||||
|
||||
// Device wraps an I2C connection to a LSM6DS3TR device.
|
||||
type Device struct {
|
||||
bus drivers.I2C
|
||||
Address uint16
|
||||
accelRange AccelRange
|
||||
accelSampleRate AccelSampleRate
|
||||
gyroRange GyroRange
|
||||
gyroSampleRate GyroSampleRate
|
||||
buf [6]uint8
|
||||
}
|
||||
|
||||
// Configuration for LSM6DS3TR device.
|
||||
type Configuration struct {
|
||||
AccelRange AccelRange
|
||||
AccelSampleRate AccelSampleRate
|
||||
AccelBandWidth AccelBandwidth
|
||||
GyroRange GyroRange
|
||||
GyroSampleRate GyroSampleRate
|
||||
IsPedometer bool
|
||||
ResetStepCounter bool
|
||||
}
|
||||
|
||||
var errNotConnected = errors.New("lsm6ds3tr: failed to communicate with acel/gyro sensor")
|
||||
|
||||
// New creates a new LSM6DS3TR 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) doConfigure(cfg Configuration) (err error) {
|
||||
|
||||
// Verify unit communication
|
||||
if !d.Connected() {
|
||||
return errNotConnected
|
||||
}
|
||||
|
||||
if cfg.AccelRange != 0 {
|
||||
d.accelRange = cfg.AccelRange
|
||||
} else {
|
||||
d.accelRange = ACCEL_2G
|
||||
}
|
||||
|
||||
if cfg.AccelSampleRate != 0 {
|
||||
d.accelSampleRate = cfg.AccelSampleRate
|
||||
} else {
|
||||
d.accelSampleRate = ACCEL_SR_104
|
||||
}
|
||||
|
||||
if cfg.GyroRange != 0 {
|
||||
d.gyroRange = cfg.GyroRange
|
||||
} else {
|
||||
d.gyroRange = GYRO_2000DPS
|
||||
}
|
||||
|
||||
if cfg.GyroSampleRate != 0 {
|
||||
d.gyroSampleRate = cfg.GyroSampleRate
|
||||
} else {
|
||||
d.gyroSampleRate = GYRO_SR_104
|
||||
}
|
||||
|
||||
data := d.buf[:1]
|
||||
|
||||
// Configure accelerometer
|
||||
data[0] = uint8(d.accelRange) | uint8(d.accelSampleRate)
|
||||
err = d.bus.WriteRegister(uint8(d.Address), CTRL1_XL, data)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
// Set ODR bit
|
||||
err = d.bus.ReadRegister(uint8(d.Address), CTRL4_C, data)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
data[0] = data[0] &^ BW_SCAL_ODR_ENABLED
|
||||
data[0] |= BW_SCAL_ODR_ENABLED
|
||||
err = d.bus.WriteRegister(uint8(d.Address), CTRL4_C, data)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
// Configure gyroscope
|
||||
data[0] = uint8(d.gyroRange) | uint8(d.gyroSampleRate)
|
||||
err = d.bus.WriteRegister(uint8(d.Address), CTRL2_G, data)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// Connected returns whether a LSM6DS3TR has been found.
|
||||
// It does a "who am I" request and checks the response.
|
||||
func (d *Device) Connected() bool {
|
||||
data := d.buf[:1]
|
||||
d.bus.ReadRegister(uint8(d.Address), WHO_AM_I, data)
|
||||
return data[0] == 0x6A
|
||||
}
|
||||
|
||||
// ReadAcceleration reads the current acceleration from the device and returns
|
||||
// it in µg (micro-gravity). When one of the axes is pointing straight to Earth
|
||||
// and the sensor is not moving the returned value will be around 1000000 or
|
||||
// -1000000.
|
||||
func (d *Device) ReadAcceleration() (x, y, z int32, err error) {
|
||||
data := d.buf[:6]
|
||||
err = d.bus.ReadRegister(uint8(d.Address), OUTX_L_XL, data)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
// k comes from "Table 3. Mechanical characteristics" 3 of the datasheet * 1000
|
||||
k := int32(61) // 2G
|
||||
if d.accelRange == ACCEL_4G {
|
||||
k = 122
|
||||
} else if d.accelRange == ACCEL_8G {
|
||||
k = 244
|
||||
} else if d.accelRange == ACCEL_16G {
|
||||
k = 488
|
||||
}
|
||||
x = int32(int16((uint16(data[1])<<8)|uint16(data[0]))) * k
|
||||
y = int32(int16((uint16(data[3])<<8)|uint16(data[2]))) * k
|
||||
z = int32(int16((uint16(data[5])<<8)|uint16(data[4]))) * k
|
||||
return
|
||||
}
|
||||
|
||||
// ReadRotation reads the current rotation from the device and returns it in
|
||||
// µ°/s (micro-degrees/sec). This means that if you were to do a complete
|
||||
// rotation along one axis and while doing so integrate all values over time,
|
||||
// you would get a value close to 360000000.
|
||||
func (d *Device) ReadRotation() (x, y, z int32, err error) {
|
||||
data := d.buf[:6]
|
||||
err = d.bus.ReadRegister(uint8(d.Address), OUTX_L_G, data)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
// k comes from "Table 3. Mechanical characteristics" 3 of the datasheet * 1000
|
||||
k := int32(4375) // 125DPS
|
||||
if d.gyroRange == GYRO_245DPS {
|
||||
k = 8750
|
||||
} else if d.gyroRange == GYRO_500DPS {
|
||||
k = 17500
|
||||
} else if d.gyroRange == GYRO_1000DPS {
|
||||
k = 35000
|
||||
} else if d.gyroRange == GYRO_2000DPS {
|
||||
k = 70000
|
||||
}
|
||||
x = int32(int16((uint16(data[1])<<8)|uint16(data[0]))) * k
|
||||
y = int32(int16((uint16(data[3])<<8)|uint16(data[2]))) * k
|
||||
z = int32(int16((uint16(data[5])<<8)|uint16(data[4]))) * k
|
||||
return
|
||||
}
|
||||
|
||||
// ReadTemperature returns the temperature in celsius milli degrees (°C/1000)
|
||||
func (d *Device) ReadTemperature() (t int32, err error) {
|
||||
data := d.buf[:2]
|
||||
err = d.bus.ReadRegister(uint8(d.Address), OUT_TEMP_L, data)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
// From "Table 5. Temperature sensor characteristics"
|
||||
// temp = value/256 + 25
|
||||
t = 25000 + (int32(int16((int16(data[1])<<8)|int16(data[0])))*125)/32
|
||||
return
|
||||
}
|
||||
@@ -1,9 +0,0 @@
|
||||
//go:build !xiao_ble
|
||||
// +build !xiao_ble
|
||||
|
||||
package lsm6ds3tr
|
||||
|
||||
// Configure sets up the device for communication.
|
||||
func (d *Device) Configure(cfg Configuration) error {
|
||||
return d.doConfigure(cfg)
|
||||
}
|
||||
@@ -1,35 +0,0 @@
|
||||
//go:build xiao_ble
|
||||
// +build xiao_ble
|
||||
|
||||
package lsm6ds3tr
|
||||
|
||||
import (
|
||||
"device/nrf"
|
||||
"machine"
|
||||
"time"
|
||||
)
|
||||
|
||||
// Configure sets up the device for communication.
|
||||
func (d *Device) Configure(cfg Configuration) error {
|
||||
|
||||
// Following lines are XIAO BLE Sense specific, they have nothing to do with sensor per se
|
||||
// Implementation adapted from https://github.com/Seeed-Studio/Seeed_Arduino_LSM6DS3/blob/master/LSM6DS3.cpp#L68-L77
|
||||
|
||||
// Special mode for IMU power pin on this board.
|
||||
// Can not use pin.Configure() directly due to special mode and 32 bit size
|
||||
pinConfig := uint32(nrf.GPIO_PIN_CNF_DIR_Output<<nrf.GPIO_PIN_CNF_DIR_Pos) |
|
||||
uint32(nrf.GPIO_PIN_CNF_INPUT_Disconnect<<nrf.GPIO_PIN_CNF_INPUT_Pos) |
|
||||
uint32(nrf.GPIO_PIN_CNF_PULL_Disabled<<nrf.GPIO_PIN_CNF_PULL_Pos) |
|
||||
uint32(nrf.GPIO_PIN_CNF_DRIVE_H0H1<<nrf.GPIO_PIN_CNF_DRIVE_Pos) |
|
||||
uint32(nrf.GPIO_PIN_CNF_SENSE_Disabled<<nrf.GPIO_PIN_CNF_SENSE_Pos)
|
||||
nrf.P1.PIN_CNF[8].Set(pinConfig) // LSM_PWR == P1_08
|
||||
|
||||
// Enable IMU
|
||||
machine.LSM_PWR.High()
|
||||
|
||||
// Wait a moment
|
||||
time.Sleep(10 * time.Millisecond)
|
||||
|
||||
// Common initialisation code
|
||||
return d.doConfigure(cfg)
|
||||
}
|
||||
@@ -1,79 +0,0 @@
|
||||
package lsm6ds3tr
|
||||
|
||||
// Constants/addresses used for I2C.
|
||||
|
||||
// The I2C address which this device listens to.
|
||||
const Address = 0x6A
|
||||
|
||||
const (
|
||||
WHO_AM_I = 0x0F
|
||||
STATUS = 0x1E
|
||||
CTRL1_XL = 0x10
|
||||
CTRL2_G = 0x11
|
||||
CTRL3_C = 0x12
|
||||
CTRL4_C = 0x13
|
||||
CTRL5_C = 0x14
|
||||
CTRL6_C = 0x15
|
||||
CTRL7_G = 0x16
|
||||
CTRL8_XL = 0x17
|
||||
CTRL9_XL = 0x18
|
||||
CTRL10_C = 0x19
|
||||
OUTX_L_G = 0x22
|
||||
OUTX_H_G = 0x23
|
||||
OUTY_L_G = 0x24
|
||||
OUTY_H_G = 0x25
|
||||
OUTZ_L_G = 0x26
|
||||
OUTZ_H_G = 0x27
|
||||
OUTX_L_XL = 0x28
|
||||
OUTX_H_XL = 0x29
|
||||
OUTY_L_XL = 0x2A
|
||||
OUTY_H_XL = 0x2B
|
||||
OUTZ_L_XL = 0x2C
|
||||
OUTZ_H_XL = 0x2D
|
||||
OUT_TEMP_L = 0x20
|
||||
OUT_TEMP_H = 0x21
|
||||
BW_SCAL_ODR_DISABLED = 0x00
|
||||
BW_SCAL_ODR_ENABLED = 0x80
|
||||
STEP_TIMESTAMP_L = 0x49
|
||||
STEP_TIMESTAMP_H = 0x4A
|
||||
STEP_COUNTER_L = 0x4B
|
||||
STEP_COUNTER_H = 0x4C
|
||||
STEP_COUNT_DELTA = 0x15
|
||||
TAP_CFG = 0x58
|
||||
INT1_CTRL = 0x0D
|
||||
|
||||
ACCEL_2G AccelRange = 0x00
|
||||
ACCEL_4G AccelRange = 0x08
|
||||
ACCEL_8G AccelRange = 0x0C
|
||||
ACCEL_16G AccelRange = 0x04
|
||||
|
||||
ACCEL_SR_OFF AccelSampleRate = 0x00
|
||||
ACCEL_SR_13 AccelSampleRate = 0x10
|
||||
ACCEL_SR_26 AccelSampleRate = 0x20
|
||||
ACCEL_SR_52 AccelSampleRate = 0x30
|
||||
ACCEL_SR_104 AccelSampleRate = 0x40
|
||||
ACCEL_SR_208 AccelSampleRate = 0x50
|
||||
ACCEL_SR_416 AccelSampleRate = 0x60
|
||||
ACCEL_SR_833 AccelSampleRate = 0x70
|
||||
ACCEL_SR_1666 AccelSampleRate = 0x80
|
||||
ACCEL_SR_3332 AccelSampleRate = 0x90
|
||||
ACCEL_SR_6664 AccelSampleRate = 0xA0
|
||||
|
||||
GYRO_125DPS GyroRange = 0x02
|
||||
GYRO_245DPS GyroRange = 0x00
|
||||
GYRO_500DPS GyroRange = 0x04
|
||||
GYRO_1000DPS GyroRange = 0x08
|
||||
GYRO_2000DPS GyroRange = 0x0C
|
||||
|
||||
GYRO_SR_OFF GyroSampleRate = 0x00
|
||||
GYRO_SR_13 GyroSampleRate = 0x10
|
||||
GYRO_SR_26 GyroSampleRate = 0x20
|
||||
GYRO_SR_52 GyroSampleRate = 0x30
|
||||
GYRO_SR_104 GyroSampleRate = 0x40
|
||||
GYRO_SR_208 GyroSampleRate = 0x50
|
||||
GYRO_SR_416 GyroSampleRate = 0x60
|
||||
GYRO_SR_833 GyroSampleRate = 0x70
|
||||
GYRO_SR_1666 GyroSampleRate = 0x80
|
||||
GYRO_SR_3332 GyroSampleRate = 0x90
|
||||
GYRO_SR_6664 GyroSampleRate = 0xA0
|
||||
)
|
||||
@@ -1,46 +0,0 @@
|
||||
package makeybutton
|
||||
|
||||
const bufferSize = 6
|
||||
|
||||
// Buffer is a buffer to keep track of the most recent readings for a button.
|
||||
type Buffer struct {
|
||||
readings [bufferSize]bool
|
||||
index int
|
||||
}
|
||||
|
||||
// NewBuffer returns a new buffer.
|
||||
func NewBuffer() *Buffer {
|
||||
return &Buffer{}
|
||||
}
|
||||
|
||||
// Used returns how many bytes in buffer have been used.
|
||||
func (b *Buffer) Used() int {
|
||||
return b.index
|
||||
}
|
||||
|
||||
// Put stores a boolean in the buffer.
|
||||
func (b *Buffer) Put(val bool) bool {
|
||||
b.index++
|
||||
if b.index >= bufferSize {
|
||||
b.index = 0
|
||||
}
|
||||
|
||||
b.readings[b.index] = val
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
// Avg returns the "average" of all the readings in the buffer, by
|
||||
// treating a true as 1 and a false as -1.
|
||||
func (b *Buffer) Avg() int {
|
||||
avg := 0
|
||||
for i := 0; i < bufferSize; i++ {
|
||||
if b.readings[i] {
|
||||
avg += 1
|
||||
} else {
|
||||
avg -= 1
|
||||
}
|
||||
}
|
||||
|
||||
return avg
|
||||
}
|
||||
@@ -1,91 +0,0 @@
|
||||
// Package makeybutton providers a driver for a button that can be triggered
|
||||
// by anything that is conductive by using an ultra high value resistor.
|
||||
//
|
||||
// Inspired by the amazing MakeyMakey
|
||||
// https://makeymakey.com/
|
||||
//
|
||||
package makeybutton
|
||||
|
||||
import (
|
||||
"machine"
|
||||
"time"
|
||||
)
|
||||
|
||||
// ButtonState represents the state of a MakeyButton.
|
||||
type ButtonState int
|
||||
|
||||
const (
|
||||
NeverPressed ButtonState = 0
|
||||
Press = 1
|
||||
Release = 2
|
||||
)
|
||||
|
||||
// ButtonEvent represents when the state of a Button changes.
|
||||
type ButtonEvent int
|
||||
|
||||
const (
|
||||
NotChanged ButtonEvent = 0
|
||||
Pressed = 1
|
||||
Released = 2
|
||||
)
|
||||
|
||||
// Button is a "button"-like device that acts like a MakeyMakey.
|
||||
type Button struct {
|
||||
pin machine.Pin
|
||||
state ButtonState
|
||||
readings *Buffer
|
||||
HighMeansPressed bool
|
||||
}
|
||||
|
||||
// NewButton creates a new Button.
|
||||
func NewButton(pin machine.Pin) *Button {
|
||||
return &Button{
|
||||
pin: pin,
|
||||
state: NeverPressed,
|
||||
readings: NewBuffer(),
|
||||
HighMeansPressed: false,
|
||||
}
|
||||
}
|
||||
|
||||
// Configure configures the Makey Button pin to have the correct settings to detect touches.
|
||||
func (b *Button) Configure() error {
|
||||
// Note that we have to first turn on the pullup, and then turn off the pullup,
|
||||
// in order for the pin to be properly floating.
|
||||
b.pin.Configure(machine.PinConfig{Mode: machine.PinInputPullup})
|
||||
time.Sleep(10 * time.Millisecond)
|
||||
b.pin.Configure(machine.PinConfig{Mode: machine.PinInput})
|
||||
b.pin.Set(false)
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// Get returns a ButtonEvent based on the most recent state of the button,
|
||||
// and if it has changed by being pressed or released.
|
||||
func (b *Button) Get() ButtonEvent {
|
||||
// if pin is pulled up, a low value means the key is pressed
|
||||
pressed := !b.pin.Get()
|
||||
if b.HighMeansPressed {
|
||||
// otherwise, a high value means the key is pressed
|
||||
pressed = !pressed
|
||||
}
|
||||
|
||||
avg := b.readings.Avg()
|
||||
b.readings.Put(pressed)
|
||||
|
||||
switch {
|
||||
case pressed && avg > -1*bufferSize+2:
|
||||
if b.state == Press {
|
||||
return NotChanged
|
||||
}
|
||||
|
||||
b.state = Press
|
||||
return Pressed
|
||||
case !pressed:
|
||||
if b.state == Press {
|
||||
b.state = Release
|
||||
return Released
|
||||
}
|
||||
}
|
||||
|
||||
return NotChanged
|
||||
}
|
||||
+1
-10
@@ -31,16 +31,7 @@ func (driver *Device) Configure() {
|
||||
// SetScanLimit sets the scan limit. Maximum is 8.
|
||||
// Example: a 4 digit 7SegmentDisplay has a scan limit of 4
|
||||
func (driver *Device) SetScanLimit(digitNumber uint8) {
|
||||
driver.WriteCommand(REG_SCANLIMIT, digitNumber-1)
|
||||
}
|
||||
|
||||
// SetIntensity sets the intensity of the diplays.
|
||||
// There are 16 possible intensity levels. The valid range is 0x00-0x0F
|
||||
func (driver *Device) SetIntensity(intensity uint8) {
|
||||
if intensity > 0x0F {
|
||||
intensity = 0x0F
|
||||
}
|
||||
driver.WriteCommand(REG_INTENSITY, intensity)
|
||||
driver.WriteCommand(byte(REG_SCANLIMIT), byte(digitNumber-1))
|
||||
}
|
||||
|
||||
// SetDecodeMode sets the decode mode for 7 segment displays.
|
||||
|
||||
+9
-24
@@ -20,11 +20,6 @@ func SetBuf(b []byte) {
|
||||
}
|
||||
|
||||
func (c *Client) Do(req *Request) (*Response, error) {
|
||||
if c.Jar != nil {
|
||||
for _, cookie := range c.Jar.Cookies(req.URL) {
|
||||
req.AddCookie(cookie)
|
||||
}
|
||||
}
|
||||
switch req.URL.Scheme {
|
||||
case "http":
|
||||
return c.doHTTP(req)
|
||||
@@ -36,17 +31,15 @@ func (c *Client) Do(req *Request) (*Response, error) {
|
||||
}
|
||||
|
||||
func (c *Client) doHTTP(req *Request) (*Response, error) {
|
||||
// make TCP connection
|
||||
ip := net.ParseIP(req.URL.Hostname())
|
||||
port := 80
|
||||
if req.URL.Port() != "" {
|
||||
p, err := strconv.ParseUint(req.URL.Port(), 0, 64)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
if c.Jar != nil {
|
||||
for _, cookie := range c.Jar.Cookies(req.URL) {
|
||||
req.AddCookie(cookie)
|
||||
}
|
||||
port = int(p)
|
||||
}
|
||||
raddr := &net.TCPAddr{IP: ip, Port: port}
|
||||
|
||||
// make TCP connection
|
||||
ip := net.ParseIP(req.URL.Host)
|
||||
raddr := &net.TCPAddr{IP: ip, Port: 80}
|
||||
laddr := &net.TCPAddr{Port: 8080}
|
||||
|
||||
conn, err := net.DialTCP("tcp", laddr, raddr)
|
||||
@@ -185,17 +178,12 @@ func (c *Client) doResp(conn net.Conn, req *Request) (*Response, error) {
|
||||
if err != nil {
|
||||
println("Read error: " + err.Error())
|
||||
} else {
|
||||
// Take care of the case where "\r\n\r\n" is on the boundary of a buffer
|
||||
start := ofs
|
||||
if start > 3 {
|
||||
start -= 3
|
||||
}
|
||||
idx := bytes.Index(buf[start:ofs+n], []byte("\r\n\r\n"))
|
||||
idx := bytes.Index(buf[ofs:ofs+n], []byte("\r\n\r\n"))
|
||||
if idx == -1 {
|
||||
ofs += n
|
||||
continue
|
||||
}
|
||||
idx += start + 4
|
||||
idx += ofs + 4
|
||||
|
||||
scanner = bufio.NewScanner(bytes.NewReader(buf[0 : ofs+n]))
|
||||
if resp.Status == "" && scanner.Scan() {
|
||||
@@ -273,9 +261,6 @@ func (c *Client) doResp(conn net.Conn, req *Request) (*Response, error) {
|
||||
return nil, fmt.Errorf("slice out of range : use http.SetBuf() to change the allocation to %d bytes or more", end)
|
||||
}
|
||||
n, err := conn.Read(buf[ofs : ofs+0x400])
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if n == 0 {
|
||||
continue
|
||||
}
|
||||
|
||||
@@ -100,12 +100,6 @@ func (c *mqttclient) Connect() Token {
|
||||
connectPkt.ProtocolName = "MQTT"
|
||||
connectPkt.Keepalive = 60
|
||||
|
||||
connectPkt.WillFlag = c.opts.WillEnabled
|
||||
connectPkt.WillTopic = c.opts.WillTopic
|
||||
connectPkt.WillMessage = c.opts.WillPayload
|
||||
connectPkt.WillQos = c.opts.WillQos
|
||||
connectPkt.WillRetain = c.opts.WillRetained
|
||||
|
||||
err = connectPkt.Write(c.conn)
|
||||
if err != nil {
|
||||
return &mqtttoken{err: err}
|
||||
@@ -152,7 +146,6 @@ func (c *mqttclient) Publish(topic string, qos byte, retained bool, payload inte
|
||||
pub := packets.NewControlPacket(packets.Publish).(*packets.PublishPacket)
|
||||
pub.Qos = qos
|
||||
pub.TopicName = topic
|
||||
pub.Retain = retained
|
||||
switch payload.(type) {
|
||||
case string:
|
||||
pub.Payload = []byte(payload.(string))
|
||||
|
||||
+7
-3
@@ -89,14 +89,18 @@ func (d Dev) Top() uint32 {
|
||||
}
|
||||
|
||||
// Set sets the `on` value of a PWM channel in the range [0..15].
|
||||
// Max value `on` can take is 4095.
|
||||
// Example:
|
||||
// d.Set(1, d.Top()/4)
|
||||
// sets the dutycycle of second (LED1) channel to 25%.
|
||||
func (d Dev) Set(channel uint8, on uint32) {
|
||||
if on > maxtop {
|
||||
panic("pca9685: value must be in range 0..4095")
|
||||
switch {
|
||||
case on > maxtop:
|
||||
panic("pca9685: value must be in range 0..4096")
|
||||
case on == 0:
|
||||
d.SetPhased(channel, 0, maxtop)
|
||||
return
|
||||
}
|
||||
|
||||
d.SetPhased(channel, on, 0)
|
||||
}
|
||||
|
||||
|
||||
@@ -1,53 +0,0 @@
|
||||
package pca9685
|
||||
|
||||
import (
|
||||
"encoding/binary"
|
||||
|
||||
"tinygo.org/x/drivers"
|
||||
)
|
||||
|
||||
// 16 PWM channels, 2 2 byte values each (on, off 16bits)
|
||||
const buffLen = 16 * 2 * 2
|
||||
|
||||
// DevBuffered provides a way of performing one-shot writes
|
||||
// on all PWM signals. This is useful when working with systems
|
||||
// which require as little as possible I/O overhead.
|
||||
type DevBuffered struct {
|
||||
Dev
|
||||
// LED buffer, first value is address, following values correspond to LED registers.
|
||||
// [0]: LEDSTART register address
|
||||
// [1:5]: LED0 corresponding to PWM channel 0
|
||||
// [5:9]: LED1 PWM channel 1
|
||||
// ...
|
||||
// [1 + N*4 : 1 + N*4 + 4] : channnel N up to channel 15
|
||||
ledBuf [buffLen + 1]byte
|
||||
}
|
||||
|
||||
// New creates a new instance of a PCA9685 device. It performs
|
||||
// no IO on the i2c bus.
|
||||
func NewBuffered(bus drivers.I2C, addr uint8) *DevBuffered {
|
||||
db := &DevBuffered{
|
||||
Dev: New(bus, addr),
|
||||
}
|
||||
db.ledBuf[0] = LEDSTART
|
||||
return db
|
||||
}
|
||||
|
||||
// PrepSet prepares a value to be written to the
|
||||
// channel's PWM register on Update() call.
|
||||
func (b *DevBuffered) PrepSet(channel uint8, on uint32) {
|
||||
b.PrepPhasedSet(channel, on, 0)
|
||||
}
|
||||
|
||||
// PrepPhasedSet prepares a phased PWM value to be written to the
|
||||
// channel's register on Update() call.
|
||||
func (b *DevBuffered) PrepPhasedSet(channel uint8, on, off uint32) {
|
||||
onLReg := 1 + channel*4
|
||||
binary.LittleEndian.PutUint16(b.ledBuf[onLReg:], uint16(on)&maxtop)
|
||||
binary.LittleEndian.PutUint16(b.ledBuf[onLReg+2:], uint16(off)&maxtop)
|
||||
}
|
||||
|
||||
// Update writes the prepared values to the PWM device registers in one shot.
|
||||
func (b *DevBuffered) Update() error {
|
||||
return b.bus.Tx(uint16(b.addr), b.ledBuf[:], nil)
|
||||
}
|
||||
@@ -118,9 +118,6 @@ func (r *RTL8720DN) ConnectSSLSocket(addr, port string) error {
|
||||
if r.debug {
|
||||
fmt.Printf("ConnectSSLSocket(%q, %q)\r\n", addr, port)
|
||||
}
|
||||
if r.root_ca == nil {
|
||||
return fmt.Errorf("root_ca is not set")
|
||||
}
|
||||
|
||||
client, err := r.Rpc_wifi_ssl_client_create()
|
||||
if err != nil {
|
||||
|
||||
+1
-32
@@ -1,10 +1,6 @@
|
||||
package rtl8720dn
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"io"
|
||||
"time"
|
||||
)
|
||||
import "io"
|
||||
|
||||
const maxUartRecvSize = 128
|
||||
|
||||
@@ -42,33 +38,6 @@ func New(r io.ReadWriter) *RTL8720DN {
|
||||
return ret
|
||||
}
|
||||
|
||||
func (r *RTL8720DN) Rpc_tcpip_adapter_init_with_timeout(d time.Duration) (int32, error) {
|
||||
timeout := make(chan bool)
|
||||
go func() {
|
||||
time.Sleep(d)
|
||||
timeout <- true
|
||||
}()
|
||||
|
||||
var ret int32
|
||||
var err error
|
||||
done := make(chan bool)
|
||||
go func() {
|
||||
ret, err = r.Rpc_tcpip_adapter_init()
|
||||
done <- true
|
||||
}()
|
||||
|
||||
select {
|
||||
case <-timeout:
|
||||
return ret, fmt.Errorf("Rpc_tcpip_adapter_init: timeout")
|
||||
case <-done:
|
||||
if err != nil {
|
||||
return ret, err
|
||||
}
|
||||
}
|
||||
|
||||
return ret, nil
|
||||
}
|
||||
|
||||
func (r *RTL8720DN) SetSeq(s uint64) {
|
||||
r.seq = s
|
||||
}
|
||||
|
||||
@@ -1,25 +0,0 @@
|
||||
package scd4x
|
||||
|
||||
const (
|
||||
// Address is default I2C address.
|
||||
Address = 0x62
|
||||
|
||||
CmdDataReady = 0xE4B8
|
||||
CmdFactoryReset = 0x3632
|
||||
CmdForcedRecal = 0x362F
|
||||
CmdGetAltitude = 0x2322
|
||||
CmdGetASCE = 0x2313
|
||||
CmdGetTempOffset = 0x2318
|
||||
CmdPersistSettings = 0x3615
|
||||
CmdReadMeasurement = 0xEC05
|
||||
CmdReinit = 0x3646
|
||||
CmdSelfTest = 0x3639
|
||||
CmdSerialNumber = 0x3682
|
||||
CmdSetAltitude = 0x2427
|
||||
CmdSetASCE = 0x2416
|
||||
CmdSetPressure = 0xE000
|
||||
CmdSetTempOffset = 0x241D
|
||||
CmdStartLowPowerPeriodicMeasurement = 0x21AC
|
||||
CmdStartPeriodicMeasurement = 0x21B1
|
||||
CmdStopPeriodicMeasurement = 0x3F86
|
||||
)
|
||||
-180
@@ -1,180 +0,0 @@
|
||||
// Package scd4x provides a driver for the scd4x I2C envrironment sensor.
|
||||
//
|
||||
// Datasheet: https://sensirion.com/media/documents/C4B87CE6/627C2DCD/CD_DS_SCD40_SCD41_Datasheet_D1.pdf
|
||||
//
|
||||
// This driver is heavily influenced by the scd4x code from Adafruit for CircuitPython:
|
||||
// https://github.com/adafruit/Adafruit_CircuitPython_SCD4X
|
||||
// Thank you!
|
||||
//
|
||||
package scd4x // import "tinygo.org/x/drivers/scd4x"
|
||||
|
||||
import (
|
||||
"encoding/binary"
|
||||
"time"
|
||||
|
||||
"tinygo.org/x/drivers"
|
||||
)
|
||||
|
||||
type Device struct {
|
||||
bus drivers.I2C
|
||||
tx []byte
|
||||
rx []byte
|
||||
Address uint8
|
||||
|
||||
// used to cache the most recent readings
|
||||
co2 uint16
|
||||
temperature uint16
|
||||
humidity uint16
|
||||
}
|
||||
|
||||
// New returns SCD4x device for the provided I2C bus using default address of 0x62.
|
||||
func New(i2c drivers.I2C) *Device {
|
||||
return &Device{
|
||||
bus: i2c,
|
||||
tx: make([]byte, 5),
|
||||
rx: make([]byte, 18),
|
||||
Address: Address,
|
||||
}
|
||||
}
|
||||
|
||||
// Configure the device.
|
||||
func (d *Device) Configure() (err error) {
|
||||
if err := d.StopPeriodicMeasurement(); err != nil {
|
||||
return err
|
||||
}
|
||||
time.Sleep(500 * time.Millisecond)
|
||||
|
||||
// reset the chip
|
||||
if err := d.sendCommand(CmdReinit); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
time.Sleep(20 * time.Millisecond)
|
||||
return
|
||||
}
|
||||
|
||||
// Connected returns whether sensor has been found.
|
||||
func (d *Device) Connected() bool {
|
||||
// TODO: something here to check if the sensor is connected
|
||||
return true
|
||||
}
|
||||
|
||||
// DataReady checks the sensor to see if new data is available.
|
||||
func (d *Device) DataReady() (bool, error) {
|
||||
if err := d.sendCommandWithResult(CmdDataReady, d.rx[0:3]); err != nil {
|
||||
return false, err
|
||||
}
|
||||
return !(d.rx[0]&0x07 == 0 && d.rx[1] == 0), nil
|
||||
}
|
||||
|
||||
// StartPeriodicMeasurement puts the sensor into working mode, about 5s per measurement.
|
||||
func (d *Device) StartPeriodicMeasurement() error {
|
||||
return d.sendCommand(CmdStartPeriodicMeasurement)
|
||||
}
|
||||
|
||||
// StopPeriodicMeasurement stops the sensor reading data.
|
||||
func (d *Device) StopPeriodicMeasurement() error {
|
||||
return d.sendCommand(CmdStopPeriodicMeasurement)
|
||||
}
|
||||
|
||||
// StartLowPowerPeriodicMeasurement puts the sensor into low power working mode,
|
||||
// about 30s per measurement.
|
||||
func (d *Device) StartLowPowerPeriodicMeasurement() error {
|
||||
return d.sendCommand(CmdStartLowPowerPeriodicMeasurement)
|
||||
}
|
||||
|
||||
// ReadData reads the data from the sensor and caches it.
|
||||
func (d *Device) ReadData() error {
|
||||
if err := d.sendCommandWithResult(CmdReadMeasurement, d.rx[0:9]); err != nil {
|
||||
return err
|
||||
}
|
||||
d.co2 = binary.BigEndian.Uint16(d.rx[0:2])
|
||||
d.temperature = binary.BigEndian.Uint16(d.rx[3:5])
|
||||
d.humidity = binary.BigEndian.Uint16(d.rx[6:8])
|
||||
return nil
|
||||
}
|
||||
|
||||
// ReadCO2 returns the CO2 concentration in PPM (parts per million).
|
||||
func (d *Device) ReadCO2() (co2 int32, err error) {
|
||||
ok, err := d.DataReady()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
if ok {
|
||||
err = d.ReadData()
|
||||
}
|
||||
return int32(d.co2), err
|
||||
}
|
||||
|
||||
// ReadTemperature returns the temperature in celsius milli degrees (°C/1000)
|
||||
func (d *Device) ReadTemperature() (temperature int32, err error) {
|
||||
ok, err := d.DataReady()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
if ok {
|
||||
err = d.ReadData()
|
||||
}
|
||||
// temp = -45 + 175 * value / 2¹⁶
|
||||
return (-1 * 45000) + (21875 * (int32(d.temperature)) / 8192), err
|
||||
}
|
||||
|
||||
// ReadTempC returns the value in the temperature value in Celsius.
|
||||
func (d *Device) ReadTempC() float32 {
|
||||
t, _ := d.ReadTemperature()
|
||||
return float32(t) / 1000
|
||||
}
|
||||
|
||||
// ReadTempF returns the value in the temperature value in Fahrenheit.
|
||||
func (d *Device) ReadTempF() float32 {
|
||||
return d.ReadTempC()*1.8 + 32.0
|
||||
}
|
||||
|
||||
// ReadHumidity returns the current relative humidity in %rH.
|
||||
func (d *Device) ReadHumidity() (humidity int32, err error) {
|
||||
ok, err := d.DataReady()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
if ok {
|
||||
err = d.ReadData()
|
||||
}
|
||||
// humidity = 100 * value / 2¹⁶
|
||||
return (25 * int32(d.humidity)) / 16384, err
|
||||
}
|
||||
|
||||
func (d *Device) sendCommand(command uint16) error {
|
||||
binary.BigEndian.PutUint16(d.tx[0:], command)
|
||||
return d.bus.Tx(uint16(d.Address), d.tx[0:2], nil)
|
||||
}
|
||||
|
||||
func (d *Device) sendCommandWithValue(command, value uint16) error {
|
||||
binary.BigEndian.PutUint16(d.tx[0:], command)
|
||||
binary.BigEndian.PutUint16(d.tx[2:], value)
|
||||
d.tx[4] = crc8(d.tx[2:4])
|
||||
return d.bus.Tx(uint16(d.Address), d.tx[0:5], nil)
|
||||
}
|
||||
|
||||
func (d *Device) sendCommandWithResult(command uint16, result []byte) error {
|
||||
binary.BigEndian.PutUint16(d.tx[0:], command)
|
||||
if err := d.bus.Tx(uint16(d.Address), d.tx[0:2], nil); err != nil {
|
||||
return err
|
||||
}
|
||||
time.Sleep(time.Millisecond)
|
||||
return d.bus.Tx(uint16(d.Address), nil, result)
|
||||
}
|
||||
|
||||
func crc8(buf []byte) uint8 {
|
||||
var crc uint8 = 0xff
|
||||
for _, b := range buf {
|
||||
crc ^= b
|
||||
for i := 0; i < 8; i++ {
|
||||
if crc&0x80 != 0 {
|
||||
crc = (crc << 1) ^ 0x31
|
||||
} else {
|
||||
crc <<= 1
|
||||
}
|
||||
}
|
||||
}
|
||||
return crc & 0xff
|
||||
}
|
||||
@@ -1,15 +0,0 @@
|
||||
package scd4x
|
||||
|
||||
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))
|
||||
}
|
||||
+2
-2
@@ -28,7 +28,7 @@ var (
|
||||
)
|
||||
|
||||
type Device struct {
|
||||
bus *machine.SPI
|
||||
bus machine.SPI
|
||||
sck machine.Pin
|
||||
sdo machine.Pin
|
||||
sdi machine.Pin
|
||||
@@ -41,7 +41,7 @@ type Device struct {
|
||||
CSD *CSD
|
||||
}
|
||||
|
||||
func New(b *machine.SPI, sck, sdo, sdi, cs machine.Pin) Device {
|
||||
func New(b machine.SPI, sck, sdo, sdi, cs machine.Pin) Device {
|
||||
return Device{
|
||||
bus: b,
|
||||
cs: cs,
|
||||
|
||||
+1
-1
@@ -103,7 +103,7 @@ func (d *Device) Configure(cfg Config) {
|
||||
d.Command(SET_MUX_RATIO)
|
||||
d.Data(0x7F)
|
||||
d.Command(SET_REMAP_COLORDEPTH)
|
||||
d.Data(0x62)
|
||||
d.Data(0x72)
|
||||
d.Command(SET_COLUMN_ADDRESS)
|
||||
d.Data(0x00)
|
||||
d.Data(0x7F)
|
||||
|
||||
@@ -4,9 +4,9 @@
|
||||
package sx126x
|
||||
|
||||
import (
|
||||
"device/stm32"
|
||||
"errors"
|
||||
"machine"
|
||||
"tinygo.org/x/device/stm32"
|
||||
"tinygo.org/x/drivers"
|
||||
)
|
||||
|
||||
|
||||
@@ -1,153 +0,0 @@
|
||||
package uc8151
|
||||
|
||||
// Registers
|
||||
const (
|
||||
// Display resolution
|
||||
EPD_WIDTH = 128
|
||||
EPD_HEIGHT = 296
|
||||
|
||||
PSR = 0x00
|
||||
PWR = 0x01
|
||||
POF = 0x02
|
||||
PFS = 0x03
|
||||
PON = 0x04
|
||||
PMES = 0x05
|
||||
BTST = 0x06
|
||||
DSLP = 0x07
|
||||
DTM1 = 0x10
|
||||
DSP = 0x11
|
||||
DRF = 0x12
|
||||
DTM2 = 0x13
|
||||
LUT_VCOM = 0x20
|
||||
LUT_WW = 0x21
|
||||
LUT_BW = 0x22
|
||||
LUT_WB = 0x23
|
||||
LUT_BB = 0x24
|
||||
PLL = 0x30
|
||||
TSC = 0x40
|
||||
TSE = 0x41
|
||||
TSR = 0x43
|
||||
TSW = 0x42
|
||||
CDI = 0x50
|
||||
LPD = 0x51
|
||||
TCON = 0x60
|
||||
TRES = 0x61
|
||||
REV = 0x70
|
||||
FLG = 0x71
|
||||
AMV = 0x80
|
||||
VV = 0x81
|
||||
VDCS = 0x82
|
||||
PTL = 0x90
|
||||
PTIN = 0x91
|
||||
PTOU = 0x92
|
||||
PGM = 0xa0
|
||||
APG = 0xa1
|
||||
ROTP = 0xa2
|
||||
CCSET = 0xe0
|
||||
PWS = 0xe3
|
||||
TSSET = 0xe5
|
||||
|
||||
RES_96x230 = 0b00000000
|
||||
RES_96x252 = 0b01000000
|
||||
RES_128x296 = 0b10000000
|
||||
RES_160x296 = 0b11000000
|
||||
|
||||
LUT_OTP = 0b00000000
|
||||
LUT_REG = 0b00100000
|
||||
|
||||
FORMAT_BWR = 0b00000000
|
||||
FORMAT_BW = 0b00010000
|
||||
|
||||
SCAN_DOWN = 0b00000000
|
||||
SCAN_UP = 0b00001000
|
||||
|
||||
SHIFT_LEFT = 0b00000000
|
||||
SHIFT_RIGHT = 0b00000100
|
||||
|
||||
BOOSTER_OFF = 0b00000000
|
||||
BOOSTER_ON = 0b00000010
|
||||
|
||||
RESET_SOFT = 0b00000000
|
||||
RESET_NONE = 0b00000001
|
||||
|
||||
VDS_EXTERNAL = 0b00000000
|
||||
VDS_INTERNAL = 0b00000010
|
||||
|
||||
VDG_EXTERNAL = 0b00000000
|
||||
VDG_INTERNAL = 0b00000001
|
||||
|
||||
VCOM_VD = 0b00000000
|
||||
VCOM_VG = 0b00000100
|
||||
|
||||
VGHL_16V = 0b00000000
|
||||
VGHL_15V = 0b00000001
|
||||
VGHL_14V = 0b00000010
|
||||
VGHL_13V = 0b00000011
|
||||
|
||||
START_10MS = 0b00000000
|
||||
START_20MS = 0b01000000
|
||||
START_30MS = 0b10000000
|
||||
START_40MS = 0b11000000
|
||||
|
||||
STRENGTH_1 = 0b00000000
|
||||
STRENGTH_2 = 0b00001000
|
||||
STRENGTH_3 = 0b00010000
|
||||
STRENGTH_4 = 0b00011000
|
||||
STRENGTH_5 = 0b00100000
|
||||
STRENGTH_6 = 0b00101000
|
||||
STRENGTH_7 = 0b00110000
|
||||
STRENGTH_8 = 0b00111000
|
||||
|
||||
OFF_0_27US = 0b00000000
|
||||
OFF_0_34US = 0b00000001
|
||||
OFF_0_40US = 0b00000010
|
||||
OFF_0_54US = 0b00000011
|
||||
OFF_0_80US = 0b00000100
|
||||
OFF_1_54US = 0b00000101
|
||||
OFF_3_34US = 0b00000110
|
||||
OFF_6_58US = 0b00000111
|
||||
|
||||
FRAMES_1 = 0b00000000
|
||||
FRAMES_2 = 0b00010000
|
||||
FRAMES_3 = 0b00100000
|
||||
FRAMES_4 = 0b00110000
|
||||
|
||||
TEMP_INTERNAL = 0b00000000
|
||||
TEMP_EXTERNAL = 0b10000000
|
||||
|
||||
OFFSET_0 = 0b00000000
|
||||
OFFSET_1 = 0b00000001
|
||||
OFFSET_2 = 0b00000010
|
||||
OFFSET_3 = 0b00000011
|
||||
OFFSET_4 = 0b00000100
|
||||
OFFSET_5 = 0b00000101
|
||||
OFFSET_6 = 0b00000110
|
||||
OFFSET_7 = 0b00000111
|
||||
|
||||
OFFSET_MIN_8 = 0b00001000
|
||||
OFFSET_MIN_7 = 0b00001001
|
||||
OFFSET_MIN_6 = 0b00001010
|
||||
OFFSET_MIN_5 = 0b00001011
|
||||
OFFSET_MIN_4 = 0b00001100
|
||||
OFFSET_MIN_3 = 0b00001101
|
||||
OFFSET_MIN_2 = 0b00001110
|
||||
OFFSET_MIN_1 = 0b00001111
|
||||
|
||||
HZ_29 = 0b00111111
|
||||
HZ_33 = 0b00111110
|
||||
HZ_40 = 0b00111101
|
||||
HZ_50 = 0b00111100
|
||||
HZ_67 = 0b00111011
|
||||
HZ_100 = 0b00111010
|
||||
HZ_200 = 0b00111001
|
||||
|
||||
NO_ROTATION Rotation = 0
|
||||
ROTATION_90 Rotation = 1 // 90 degrees clock-wise rotation
|
||||
ROTATION_180 Rotation = 2
|
||||
ROTATION_270 Rotation = 3
|
||||
|
||||
DEFAULT Speed = 0
|
||||
MEDIUM Speed = 1
|
||||
FAST Speed = 2
|
||||
TURBO Speed = 3
|
||||
)
|
||||
@@ -1,634 +0,0 @@
|
||||
// Package uc8151 implements a driver for e-ink displays controlled by UC8151
|
||||
//
|
||||
// Inspired by https://github.com/pimoroni/pimoroni-pico/blob/main/drivers/uc8151/uc8151.cpp
|
||||
// Datasheet: https://www.buydisplay.com/download/ic/UC8151C.pdf
|
||||
//
|
||||
package uc8151 // import "tinygo.org/x/drivers/uc8151"
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"image/color"
|
||||
"machine"
|
||||
"time"
|
||||
|
||||
"tinygo.org/x/drivers"
|
||||
)
|
||||
|
||||
type Config struct {
|
||||
Width int16
|
||||
Height int16
|
||||
Rotation Rotation // Rotation is clock-wise
|
||||
Speed Speed // Value from DEFAULT, MEDIUM, FAST, TURBO
|
||||
Blocking bool
|
||||
}
|
||||
|
||||
type Device struct {
|
||||
bus drivers.SPI
|
||||
cs machine.Pin
|
||||
dc machine.Pin
|
||||
rst machine.Pin
|
||||
busy machine.Pin
|
||||
width int16
|
||||
height int16
|
||||
buffer []uint8
|
||||
bufferLength uint32
|
||||
rotation Rotation
|
||||
speed Speed
|
||||
blocking bool
|
||||
}
|
||||
|
||||
type Rotation uint8
|
||||
type Speed uint8
|
||||
|
||||
// New returns a new epd2in13x driver. Pass in a fully configured SPI bus.
|
||||
func New(bus drivers.SPI, csPin, dcPin, rstPin, busyPin machine.Pin) Device {
|
||||
csPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
|
||||
dcPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
|
||||
rstPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
|
||||
busyPin.Configure(machine.PinConfig{Mode: machine.PinInput})
|
||||
return Device{
|
||||
bus: bus,
|
||||
cs: csPin,
|
||||
dc: dcPin,
|
||||
rst: rstPin,
|
||||
busy: busyPin,
|
||||
}
|
||||
}
|
||||
|
||||
// Configure sets up the device.
|
||||
func (d *Device) Configure(cfg Config) {
|
||||
if cfg.Width != 0 {
|
||||
d.width = cfg.Width
|
||||
} else {
|
||||
d.width = EPD_WIDTH
|
||||
}
|
||||
if cfg.Height != 0 {
|
||||
d.height = cfg.Height
|
||||
} else {
|
||||
d.height = EPD_HEIGHT
|
||||
}
|
||||
d.rotation = cfg.Rotation
|
||||
d.speed = cfg.Speed
|
||||
d.blocking = cfg.Blocking
|
||||
d.bufferLength = (uint32(d.width) * uint32(d.height)) / 8
|
||||
d.buffer = make([]uint8, d.bufferLength)
|
||||
for i := uint32(0); i < d.bufferLength; i++ {
|
||||
d.buffer[i] = 0xFF
|
||||
}
|
||||
|
||||
d.Reset()
|
||||
|
||||
d.SendCommand(PSR)
|
||||
if d.speed == 0 {
|
||||
d.SendData(RES_128x296 | LUT_OTP | FORMAT_BW | SHIFT_RIGHT | BOOSTER_ON | RESET_NONE | SCAN_UP)
|
||||
} else {
|
||||
d.SendData(RES_128x296 | LUT_REG | FORMAT_BW | SHIFT_RIGHT | BOOSTER_ON | RESET_NONE | SCAN_UP)
|
||||
}
|
||||
|
||||
d.SetLUT(d.speed)
|
||||
|
||||
d.SendCommand(PWR)
|
||||
d.SendData(VDS_INTERNAL | VDG_INTERNAL)
|
||||
d.SendData(VCOM_VG | VGHL_16V)
|
||||
d.SendData(0x2B)
|
||||
d.SendData(0x2B)
|
||||
d.SendData(0x2B)
|
||||
|
||||
d.SendCommand(PON)
|
||||
d.WaitUntilIdle()
|
||||
|
||||
d.SendCommand(BTST)
|
||||
d.SendData(START_10MS | STRENGTH_3 | OFF_6_58US)
|
||||
d.SendData(START_10MS | STRENGTH_3 | OFF_6_58US)
|
||||
d.SendData(START_10MS | STRENGTH_3 | OFF_6_58US)
|
||||
|
||||
d.SendCommand(PFS)
|
||||
d.SendData(FRAMES_1)
|
||||
|
||||
d.SendCommand(TSE)
|
||||
d.SendData(TEMP_INTERNAL | OFFSET_0)
|
||||
|
||||
d.SendCommand(TCON)
|
||||
d.SendData(0x22)
|
||||
|
||||
d.SendCommand(CDI)
|
||||
d.SendData(0x4C) // 4C //5C
|
||||
|
||||
d.SendCommand(PLL)
|
||||
d.SendData(HZ_100)
|
||||
|
||||
d.SendCommand(POF)
|
||||
d.WaitUntilIdle()
|
||||
|
||||
}
|
||||
|
||||
// Reset resets the device
|
||||
func (d *Device) Reset() {
|
||||
d.rst.Low()
|
||||
time.Sleep(10 * time.Millisecond)
|
||||
d.rst.High()
|
||||
time.Sleep(10 * time.Millisecond)
|
||||
d.WaitUntilIdle()
|
||||
}
|
||||
|
||||
// PowerOff power off the device
|
||||
func (d *Device) PowerOff() {
|
||||
d.SendCommand(POF)
|
||||
}
|
||||
|
||||
// SendCommand sends a command to the display
|
||||
func (d *Device) SendCommand(command uint8) {
|
||||
d.sendDataCommand(true, command)
|
||||
}
|
||||
|
||||
// SendData sends a data byte to the display
|
||||
func (d *Device) SendData(data uint8) {
|
||||
d.sendDataCommand(false, data)
|
||||
}
|
||||
|
||||
// sendDataCommand sends image data or a command to the screen
|
||||
func (d *Device) sendDataCommand(isCommand bool, data uint8) {
|
||||
if isCommand {
|
||||
d.dc.Low()
|
||||
} else {
|
||||
d.dc.High()
|
||||
}
|
||||
d.cs.Low()
|
||||
d.bus.Transfer(data)
|
||||
d.cs.High()
|
||||
}
|
||||
|
||||
// SetPixel modifies the internal buffer in a single pixel.
|
||||
// The display have 2 colors: black and white
|
||||
// We use RGBA(0,0,0, 255) as white (transparent)
|
||||
// Anything else as black
|
||||
func (d *Device) SetPixel(x int16, y int16, c color.RGBA) {
|
||||
x, y = d.xy(x, y)
|
||||
|
||||
if x < 0 || x >= d.width || y < 0 || y >= d.height {
|
||||
return
|
||||
}
|
||||
byteIndex := x/8 + y*(d.width/8)
|
||||
if c.R == 0 && c.G == 0 && c.B == 0 { // TRANSPARENT / WHITE
|
||||
d.buffer[byteIndex] &^= 0x80 >> uint8(x%8)
|
||||
} else { // WHITE / EMPTY
|
||||
d.buffer[byteIndex] |= 0x80 >> uint8(x%8)
|
||||
}
|
||||
}
|
||||
|
||||
// Display sends the buffer to the screen.
|
||||
func (d *Device) Display() error {
|
||||
if d.blocking {
|
||||
d.WaitUntilIdle()
|
||||
}
|
||||
d.SendCommand(PON)
|
||||
d.SendCommand(PTOU)
|
||||
d.SendCommand(DTM2)
|
||||
for i := uint32(0); i < d.bufferLength; i++ {
|
||||
d.SendData(d.buffer[i])
|
||||
}
|
||||
|
||||
d.SendCommand(DSP)
|
||||
d.SendCommand(DRF)
|
||||
if d.blocking {
|
||||
d.WaitUntilIdle()
|
||||
d.PowerOff()
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// DisplayRect sends only an area of the buffer to the screen.
|
||||
// The rectangle points need to be a multiple of 8 in the screen.
|
||||
// They might not work as expected if the screen is rotated.
|
||||
func (d *Device) DisplayRect(x int16, y int16, width int16, height int16) error {
|
||||
if d.blocking {
|
||||
d.WaitUntilIdle()
|
||||
}
|
||||
|
||||
x, y = d.xy(x, y)
|
||||
if x < 0 || y < 0 || x >= d.width || y >= d.height || width < 0 || height < 0 {
|
||||
return errors.New("wrong rectangle")
|
||||
}
|
||||
if d.rotation == ROTATION_90 {
|
||||
width, height = height, width
|
||||
x -= width
|
||||
} else if d.rotation == ROTATION_180 {
|
||||
x -= width - 1
|
||||
y -= height - 1
|
||||
} else if d.rotation == ROTATION_270 {
|
||||
width, height = height, width
|
||||
y -= height
|
||||
}
|
||||
x &= 0xF8
|
||||
width &= 0xF8
|
||||
width = x + width // reuse variables
|
||||
if width >= d.width {
|
||||
width = d.width
|
||||
}
|
||||
height = y + height
|
||||
if height > d.height {
|
||||
height = d.height
|
||||
}
|
||||
|
||||
d.SendCommand(PON)
|
||||
d.SendCommand(PTIN)
|
||||
d.SendCommand(PTL)
|
||||
|
||||
d.SendData(uint8(x))
|
||||
d.SendData(uint8(x+width-1) | 0x07)
|
||||
d.SendData(uint8(y >> 8))
|
||||
d.SendData(uint8(y))
|
||||
d.SendData(uint8((y + height - 1) >> 8))
|
||||
d.SendData(uint8(y + height - 1))
|
||||
d.SendData(0x01)
|
||||
|
||||
d.SendCommand(DTM2)
|
||||
x = x / 8
|
||||
width = width / 8
|
||||
for ; y < height; y++ {
|
||||
for i := x; i < width; i++ {
|
||||
d.SendData(d.buffer[i+y*(d.width/8)])
|
||||
}
|
||||
}
|
||||
|
||||
d.SendCommand(DSP)
|
||||
d.SendCommand(DRF)
|
||||
|
||||
if d.blocking {
|
||||
d.WaitUntilIdle()
|
||||
d.PowerOff()
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// ClearDisplay erases the device SRAM
|
||||
func (d *Device) ClearDisplay() {
|
||||
d.ClearBuffer()
|
||||
d.Display()
|
||||
}
|
||||
|
||||
// WaitUntilIdle waits until the display is ready
|
||||
func (d *Device) WaitUntilIdle() {
|
||||
for !d.busy.Get() {
|
||||
time.Sleep(100 * time.Millisecond)
|
||||
}
|
||||
}
|
||||
|
||||
// IsBusy returns the busy status of the display
|
||||
func (d *Device) IsBusy() bool {
|
||||
return d.busy.Get()
|
||||
}
|
||||
|
||||
// ClearBuffer sets the buffer to 0xFF (white)
|
||||
func (d *Device) ClearBuffer() {
|
||||
for i := uint32(0); i < d.bufferLength; i++ {
|
||||
d.buffer[i] = 0x00
|
||||
}
|
||||
}
|
||||
|
||||
// Size returns the current size of the display.
|
||||
func (d *Device) Size() (w, h int16) {
|
||||
if d.rotation == ROTATION_90 || d.rotation == ROTATION_270 {
|
||||
return d.height, d.width
|
||||
}
|
||||
return d.width, d.height
|
||||
}
|
||||
|
||||
// SetRotation changes the rotation (clock-wise) of the device
|
||||
func (d *Device) SetRotation(rotation Rotation) {
|
||||
d.rotation = rotation
|
||||
}
|
||||
|
||||
// SetBlocking changes the blocking flag of the device
|
||||
func (d *Device) SetBlocking(blocking bool) {
|
||||
d.blocking = blocking
|
||||
}
|
||||
|
||||
// xy chages the coordinates according to the rotation
|
||||
func (d *Device) xy(x, y int16) (int16, int16) {
|
||||
switch d.rotation {
|
||||
case NO_ROTATION:
|
||||
return x, y
|
||||
case ROTATION_90:
|
||||
return d.width - y - 1, x
|
||||
case ROTATION_180:
|
||||
return d.width - x - 1, d.height - y - 1
|
||||
case ROTATION_270:
|
||||
return y, d.height - x - 1
|
||||
}
|
||||
return x, y
|
||||
}
|
||||
|
||||
// SetSpeed changes the refresh speed of the device (the display needs to re-configure)
|
||||
func (d *Device) SetSpeed(speed Speed) {
|
||||
d.Configure(Config{
|
||||
Width: d.width,
|
||||
Height: d.height,
|
||||
Rotation: d.rotation,
|
||||
Speed: speed,
|
||||
Blocking: d.blocking,
|
||||
})
|
||||
}
|
||||
|
||||
// Invert sets the display' invert mode
|
||||
func (d *Device) Invert(invert bool) {
|
||||
if invert {
|
||||
d.SendData(0x5C)
|
||||
} else {
|
||||
d.SendData(0x4C)
|
||||
}
|
||||
}
|
||||
|
||||
// SetLUT sets the look up tables for full or partial updates
|
||||
func (d *Device) SetLUT(speed Speed) {
|
||||
switch speed {
|
||||
case MEDIUM:
|
||||
var lut = [44]uint8{
|
||||
0x00, 0x16, 0x16, 0x0d, 0x00, 0x01,
|
||||
0x00, 0x23, 0x23, 0x00, 0x00, 0x02,
|
||||
0x00, 0x16, 0x16, 0x0d, 0x00, 0x01,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00,
|
||||
}
|
||||
d.SendCommand(LUT_VCOM)
|
||||
for i := 0; i < 44; i++ {
|
||||
d.SendData(lut[i])
|
||||
}
|
||||
lut = [44]uint8{
|
||||
0x54, 0x16, 0x16, 0x0d, 0x00, 0x01,
|
||||
0x60, 0x23, 0x23, 0x00, 0x00, 0x02,
|
||||
0xa8, 0x16, 0x16, 0x0d, 0x00, 0x01,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
|
||||
d.SendCommand(LUT_WW)
|
||||
// do not send last two bytes
|
||||
for i := 0; i < 42; i++ {
|
||||
d.SendData(lut[i])
|
||||
}
|
||||
|
||||
lut = [44]uint8{
|
||||
0x54, 0x16, 0x16, 0x0d, 0x00, 0x01,
|
||||
0x60, 0x23, 0x23, 0x00, 0x00, 0x02,
|
||||
0xa8, 0x16, 0x16, 0x0d, 0x00, 0x01,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
|
||||
d.SendCommand(LUT_BW)
|
||||
// do not send last two bytes
|
||||
for i := 0; i < 42; i++ {
|
||||
d.SendData(lut[i])
|
||||
}
|
||||
|
||||
lut = [44]uint8{
|
||||
0xa8, 0x16, 0x16, 0x0d, 0x00, 0x01,
|
||||
0x60, 0x23, 0x23, 0x00, 0x00, 0x02,
|
||||
0x54, 0x16, 0x16, 0x0d, 0x00, 0x01,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
|
||||
d.SendCommand(LUT_WB)
|
||||
// do not send last two bytes
|
||||
for i := 0; i < 42; i++ {
|
||||
d.SendData(lut[i])
|
||||
}
|
||||
|
||||
lut = [44]uint8{
|
||||
0xa8, 0x16, 0x16, 0x0d, 0x00, 0x01,
|
||||
0x60, 0x23, 0x23, 0x00, 0x00, 0x02,
|
||||
0x54, 0x16, 0x16, 0x0d, 0x00, 0x01,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
|
||||
d.SendCommand(LUT_BB)
|
||||
// do not send last two bytes
|
||||
for i := 0; i < 42; i++ {
|
||||
d.SendData(lut[i])
|
||||
}
|
||||
|
||||
break
|
||||
case FAST:
|
||||
var lut = [44]uint8{
|
||||
0x00, 0x04, 0x04, 0x07, 0x00, 0x01,
|
||||
0x00, 0x0c, 0x0c, 0x00, 0x00, 0x02,
|
||||
0x00, 0x04, 0x04, 0x07, 0x00, 0x02,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00,
|
||||
}
|
||||
d.SendCommand(LUT_VCOM)
|
||||
for i := 0; i < 44; i++ {
|
||||
d.SendData(lut[i])
|
||||
}
|
||||
lut = [44]uint8{
|
||||
0x54, 0x04, 0x04, 0x07, 0x00, 0x01,
|
||||
0x60, 0x0c, 0x0c, 0x00, 0x00, 0x02,
|
||||
0xa8, 0x04, 0x04, 0x07, 0x00, 0x02,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
|
||||
d.SendCommand(LUT_WW)
|
||||
// do not send last two bytes
|
||||
for i := 0; i < 42; i++ {
|
||||
d.SendData(lut[i])
|
||||
}
|
||||
|
||||
lut = [44]uint8{
|
||||
0x54, 0x04, 0x04, 0x07, 0x00, 0x01,
|
||||
0x60, 0x0c, 0x0c, 0x00, 0x00, 0x02,
|
||||
0xa8, 0x04, 0x04, 0x07, 0x00, 0x02,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
|
||||
d.SendCommand(LUT_BW)
|
||||
// do not send last two bytes
|
||||
for i := 0; i < 42; i++ {
|
||||
d.SendData(lut[i])
|
||||
}
|
||||
|
||||
lut = [44]uint8{
|
||||
0xa8, 0x04, 0x04, 0x07, 0x00, 0x01,
|
||||
0x60, 0x0c, 0x0c, 0x00, 0x00, 0x02,
|
||||
0x54, 0x04, 0x04, 0x07, 0x00, 0x02,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
|
||||
d.SendCommand(LUT_WB)
|
||||
// do not send last two bytes
|
||||
for i := 0; i < 42; i++ {
|
||||
d.SendData(lut[i])
|
||||
}
|
||||
|
||||
lut = [44]uint8{
|
||||
0xa8, 0x04, 0x04, 0x07, 0x00, 0x01,
|
||||
0x60, 0x0c, 0x0c, 0x00, 0x00, 0x02,
|
||||
0x54, 0x04, 0x04, 0x07, 0x00, 0x02,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
|
||||
d.SendCommand(LUT_BB)
|
||||
// do not send last two bytes
|
||||
for i := 0; i < 42; i++ {
|
||||
d.SendData(lut[i])
|
||||
}
|
||||
|
||||
break
|
||||
case TURBO:
|
||||
var lut = [44]uint8{
|
||||
0x00, 0x01, 0x01, 0x02, 0x00, 0x01,
|
||||
0x00, 0x02, 0x02, 0x00, 0x00, 0x02,
|
||||
0x00, 0x02, 0x02, 0x03, 0x00, 0x02,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00,
|
||||
}
|
||||
d.SendCommand(LUT_VCOM)
|
||||
for i := 0; i < 44; i++ {
|
||||
d.SendData(lut[i])
|
||||
}
|
||||
lut = [44]uint8{
|
||||
0x54, 0x01, 0x01, 0x02, 0x00, 0x01,
|
||||
0x60, 0x02, 0x02, 0x00, 0x00, 0x02,
|
||||
0xa8, 0x02, 0x02, 0x03, 0x00, 0x02,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
|
||||
d.SendCommand(LUT_WW)
|
||||
// do not send last two bytes
|
||||
for i := 0; i < 42; i++ {
|
||||
d.SendData(lut[i])
|
||||
}
|
||||
|
||||
lut = [44]uint8{
|
||||
0x54, 0x01, 0x01, 0x02, 0x00, 0x01,
|
||||
0x60, 0x02, 0x02, 0x00, 0x00, 0x02,
|
||||
0xa8, 0x02, 0x02, 0x03, 0x00, 0x02,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
|
||||
d.SendCommand(LUT_BW)
|
||||
// do not send last two bytes
|
||||
for i := 0; i < 42; i++ {
|
||||
d.SendData(lut[i])
|
||||
}
|
||||
|
||||
lut = [44]uint8{
|
||||
0xa8, 0x01, 0x01, 0x02, 0x00, 0x01,
|
||||
0x60, 0x02, 0x02, 0x00, 0x00, 0x02,
|
||||
0x54, 0x02, 0x02, 0x03, 0x00, 0x02,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
|
||||
d.SendCommand(LUT_WB)
|
||||
// do not send last two bytes
|
||||
for i := 0; i < 42; i++ {
|
||||
d.SendData(lut[i])
|
||||
}
|
||||
|
||||
lut = [44]uint8{
|
||||
0xa8, 0x01, 0x01, 0x02, 0x00, 0x01,
|
||||
0x60, 0x02, 0x02, 0x00, 0x00, 0x02,
|
||||
0x54, 0x02, 0x02, 0x03, 0x00, 0x02,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
|
||||
d.SendCommand(LUT_BB)
|
||||
// do not send last two bytes
|
||||
for i := 0; i < 42; i++ {
|
||||
d.SendData(lut[i])
|
||||
}
|
||||
|
||||
break
|
||||
default:
|
||||
var lut = [44]uint8{
|
||||
0x00, 0x64, 0x64, 0x37, 0x00, 0x01,
|
||||
0x00, 0x8c, 0x8c, 0x00, 0x00, 0x04,
|
||||
0x00, 0x64, 0x64, 0x37, 0x00, 0x01,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00,
|
||||
}
|
||||
d.SendCommand(LUT_VCOM)
|
||||
for i := 0; i < 44; i++ {
|
||||
d.SendData(lut[i])
|
||||
}
|
||||
lut = [44]uint8{
|
||||
0x54, 0x64, 0x64, 0x37, 0x00, 0x01,
|
||||
0x60, 0x8c, 0x8c, 0x00, 0x00, 0x04,
|
||||
0xa8, 0x64, 0x64, 0x37, 0x00, 0x01,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
|
||||
d.SendCommand(LUT_WW)
|
||||
// do not send last two bytes
|
||||
for i := 0; i < 42; i++ {
|
||||
d.SendData(lut[i])
|
||||
}
|
||||
|
||||
lut = [44]uint8{
|
||||
0x54, 0x64, 0x64, 0x37, 0x00, 0x01,
|
||||
0x60, 0x8c, 0x8c, 0x00, 0x00, 0x04,
|
||||
0xa8, 0x64, 0x64, 0x37, 0x00, 0x01,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
|
||||
d.SendCommand(LUT_BW)
|
||||
// do not send last two bytes
|
||||
for i := 0; i < 42; i++ {
|
||||
d.SendData(lut[i])
|
||||
}
|
||||
|
||||
lut = [44]uint8{
|
||||
0xa8, 0x64, 0x64, 0x37, 0x00, 0x01,
|
||||
0x60, 0x8c, 0x8c, 0x00, 0x00, 0x04,
|
||||
0x54, 0x64, 0x64, 0x37, 0x00, 0x01,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
|
||||
d.SendCommand(LUT_WB)
|
||||
// do not send last two bytes
|
||||
for i := 0; i < 42; i++ {
|
||||
d.SendData(lut[i])
|
||||
}
|
||||
|
||||
lut = [44]uint8{
|
||||
0xa8, 0x64, 0x64, 0x37, 0x00, 0x01,
|
||||
0x60, 0x8c, 0x8c, 0x00, 0x00, 0x04,
|
||||
0x54, 0x64, 0x64, 0x37, 0x00, 0x01,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
|
||||
d.SendCommand(LUT_BB)
|
||||
// do not send last two bytes
|
||||
for i := 0; i < 42; i++ {
|
||||
d.SendData(lut[i])
|
||||
}
|
||||
|
||||
break
|
||||
}
|
||||
}
|
||||
+1
-1
@@ -2,4 +2,4 @@ package drivers
|
||||
|
||||
// Version returns a user-readable string showing the version of the drivers package for support purposes.
|
||||
// Update this value before release of new version of software.
|
||||
const Version = "0.21.0"
|
||||
const Version = "0.19.0"
|
||||
|
||||
@@ -7,7 +7,6 @@ const Address = 0x29 //0x52
|
||||
const (
|
||||
CHIP_ID = 0xEACC
|
||||
SOFT_RESET = 0x0000
|
||||
I2C_SLAVE_DEVICE_ADDRESS = 0x0001
|
||||
OSC_MEASURED_FAST_OSC_FREQUENCY = 0x0006
|
||||
VHV_CONFIG_TIMEOUT_MACROP_LOOP_BOUND = 0x0008
|
||||
VHV_CONFIG_INIT = 0x000B
|
||||
@@ -47,8 +46,6 @@ const (
|
||||
SD_CONFIG_INITIAL_PHASE_SD1 = 0x007B
|
||||
SYSTEM_GROUPED_PARAMETER_HOLD_1 = 0x007C
|
||||
SD_CONFIG_QUANTIFIER = 0x007E
|
||||
ROI_CONFIG_USER_ROI_CENTRE_SPAD = 0x007F
|
||||
ROI_CONFIG_USER_ROI_REQUESTED_GLOBAL_XY_SIZE = 0x0080
|
||||
SYSTEM_SEQUENCE_CONFIG = 0x0081
|
||||
SYSTEM_GROUPED_PARAMETER_HOLD = 0x0082
|
||||
SYSTEM_INTERRUPT_CLEAR = 0x0086
|
||||
|
||||
+17
-48
@@ -10,7 +10,6 @@
|
||||
package vl53l1x // import "tinygo.org/x/drivers/vl53l1x"
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"time"
|
||||
|
||||
"tinygo.org/x/drivers"
|
||||
@@ -133,17 +132,6 @@ func (d *Device) Configure(use2v8Mode bool) bool {
|
||||
return true
|
||||
}
|
||||
|
||||
// SetAddress sets the I2C address which this device listens to.
|
||||
func (d *Device) SetAddress(address uint8) {
|
||||
d.writeReg(I2C_SLAVE_DEVICE_ADDRESS, address)
|
||||
d.Address = uint16(address)
|
||||
}
|
||||
|
||||
// GetAddress returns the I2C address which this device listens to.
|
||||
func (d *Device) GetAddress() uint8 {
|
||||
return uint8(d.Address)
|
||||
}
|
||||
|
||||
// SetTimeout configures the timeout
|
||||
func (d *Device) SetTimeout(timeout uint32) {
|
||||
d.timeout = timeout
|
||||
@@ -169,6 +157,7 @@ func (d *Device) SetDistanceMode(mode DistanceMode) bool {
|
||||
d.writeReg(SD_CONFIG_WOI_SD1, 0x05)
|
||||
d.writeReg(SD_CONFIG_INITIAL_PHASE_SD0, 6)
|
||||
d.writeReg(SD_CONFIG_INITIAL_PHASE_SD1, 6)
|
||||
break
|
||||
case MEDIUM:
|
||||
// timing config
|
||||
d.writeReg(RANGE_CONFIG_VCSEL_PERIOD_A, 0x0B)
|
||||
@@ -180,6 +169,7 @@ func (d *Device) SetDistanceMode(mode DistanceMode) bool {
|
||||
d.writeReg(SD_CONFIG_WOI_SD1, 0x09)
|
||||
d.writeReg(SD_CONFIG_INITIAL_PHASE_SD0, 10)
|
||||
d.writeReg(SD_CONFIG_INITIAL_PHASE_SD1, 10)
|
||||
break
|
||||
case LONG:
|
||||
// timing config
|
||||
d.writeReg(RANGE_CONFIG_VCSEL_PERIOD_A, 0x0F)
|
||||
@@ -191,6 +181,7 @@ func (d *Device) SetDistanceMode(mode DistanceMode) bool {
|
||||
d.writeReg(SD_CONFIG_WOI_SD1, 0x0D)
|
||||
d.writeReg(SD_CONFIG_INITIAL_PHASE_SD0, 14)
|
||||
d.writeReg(SD_CONFIG_INITIAL_PHASE_SD1, 14)
|
||||
break
|
||||
default:
|
||||
return false
|
||||
}
|
||||
@@ -342,35 +333,44 @@ func (d *Device) AmbientRate() int32 {
|
||||
func (d *Device) getRangingData() {
|
||||
d.rangingData.mm = uint16((uint32(d.results.mmCrosstalkSD0)*2011 + 0x0400) / 0x0800)
|
||||
switch d.results.status {
|
||||
case 1, // VCSELCONTINUITYTESTFAILURE
|
||||
2, // VCSELWATCHDOGTESTFAILURE
|
||||
3, // NOVHVVALUEFOUND
|
||||
17: // MULTCLIPFAIL
|
||||
case 17: // MULTCLIPFAIL
|
||||
case 2: // VCSELWATCHDOGTESTFAILURE
|
||||
case 1: // VCSELCONTINUITYTESTFAILURE
|
||||
case 3: // NOVHVVALUEFOUND
|
||||
d.rangingData.status = HardwareFail
|
||||
break
|
||||
|
||||
case 13: // USERROICLIP
|
||||
d.rangingData.status = MinRangeFail
|
||||
break
|
||||
|
||||
case 18: // GPHSTREAMCOUNT0READY
|
||||
d.rangingData.status = SynchronizationInt
|
||||
break
|
||||
|
||||
case 5: // RANGEPHASECHECK
|
||||
d.rangingData.status = OutOfBoundsFail
|
||||
break
|
||||
|
||||
case 4: // MSRCNOTARGET
|
||||
d.rangingData.status = SignalFail
|
||||
break
|
||||
|
||||
case 6: // SIGMATHRESHOLDCHECK
|
||||
d.rangingData.status = SignalFail
|
||||
break
|
||||
|
||||
case 7: // PHASECONSISTENCY
|
||||
d.rangingData.status = WrapTargetFail
|
||||
break
|
||||
|
||||
case 12: // RANGEIGNORETHRESHOLD
|
||||
d.rangingData.status = XtalkSignalFail
|
||||
break
|
||||
|
||||
case 8: // MINCLIP
|
||||
d.rangingData.status = RangeValidMinRangeClipped
|
||||
break
|
||||
|
||||
case 9: // RANGECOMPLETE
|
||||
if d.results.streamCount == 0 {
|
||||
@@ -378,6 +378,7 @@ func (d *Device) getRangingData() {
|
||||
} else {
|
||||
d.rangingData.status = RangeValid
|
||||
}
|
||||
break
|
||||
|
||||
default:
|
||||
d.rangingData.status = None
|
||||
@@ -429,38 +430,6 @@ func (d *Device) StopContinuous() {
|
||||
d.writeReg(PHASECAL_CONFIG_OVERRIDE, 0x00)
|
||||
}
|
||||
|
||||
// SetROI sets the 'region of interest' for x and y coordinates. Valid ranges are from 4/4 to 16/16.
|
||||
func (d *Device) SetROI(x, y uint8) error {
|
||||
if !validROIRange(x, y) {
|
||||
return errors.New("ROI value out of range")
|
||||
}
|
||||
|
||||
if x > 10 || y > 10 {
|
||||
d.writeReg(ROI_CONFIG_USER_ROI_CENTRE_SPAD, 199)
|
||||
}
|
||||
|
||||
d.writeReg(ROI_CONFIG_USER_ROI_REQUESTED_GLOBAL_XY_SIZE, (y-1)<<4|(x-1))
|
||||
return nil
|
||||
}
|
||||
|
||||
// GetROI returns the currently configured 'region of interest' for x and y coordinates.
|
||||
func (d *Device) GetROI() (x, y uint8, err error) {
|
||||
reg := d.readReg(ROI_CONFIG_USER_ROI_REQUESTED_GLOBAL_XY_SIZE)
|
||||
|
||||
x = (reg & 0x0f) + 1
|
||||
y = ((reg & 0xf0) >> 4) + 1
|
||||
|
||||
if !validROIRange(x, y) {
|
||||
err = errors.New("ROI value out of range")
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
func validROIRange(x, y uint8) bool {
|
||||
return x >= 4 && x <= 16 && y >= 4 && y <= 16
|
||||
}
|
||||
|
||||
// writeReg sends a single byte to the specified register address
|
||||
func (d *Device) writeReg(reg uint16, value uint8) {
|
||||
msb := byte((reg >> 8) & 0xFF)
|
||||
|
||||
@@ -12,7 +12,6 @@ import (
|
||||
"fmt" // used only in debug printouts and is optimized out when debugging is disabled
|
||||
"strconv"
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"machine"
|
||||
@@ -289,7 +288,6 @@ type Device struct {
|
||||
proto uint8
|
||||
ip uint32
|
||||
port uint16
|
||||
mu sync.Mutex
|
||||
}
|
||||
|
||||
// New returns a new Wifinina device.
|
||||
@@ -365,9 +363,6 @@ func (d *Device) GetClientState(sock uint8) (uint8, error) {
|
||||
}
|
||||
|
||||
func (d *Device) SendData(buf []byte, sock uint8) (uint16, error) {
|
||||
d.mu.Lock()
|
||||
defer d.mu.Unlock()
|
||||
|
||||
if err := d.waitForChipSelect(); err != nil {
|
||||
d.spiChipDeselect()
|
||||
return 0, err
|
||||
@@ -381,9 +376,6 @@ func (d *Device) SendData(buf []byte, sock uint8) (uint16, error) {
|
||||
}
|
||||
|
||||
func (d *Device) CheckDataSent(sock uint8) (bool, error) {
|
||||
d.mu.Lock()
|
||||
defer d.mu.Unlock()
|
||||
|
||||
var lastErr error
|
||||
for timeout := 0; timeout < 10; timeout++ {
|
||||
sent, err := d.getUint8(d.reqUint8(CmdDataSentTCP, sock))
|
||||
@@ -399,9 +391,6 @@ func (d *Device) CheckDataSent(sock uint8) (bool, error) {
|
||||
}
|
||||
|
||||
func (d *Device) GetDataBuf(sock uint8, buf []byte) (int, error) {
|
||||
d.mu.Lock()
|
||||
defer d.mu.Unlock()
|
||||
|
||||
if err := d.waitForChipSelect(); err != nil {
|
||||
d.spiChipDeselect()
|
||||
return 0, err
|
||||
@@ -422,9 +411,6 @@ func (d *Device) GetDataBuf(sock uint8, buf []byte) (int, error) {
|
||||
}
|
||||
|
||||
func (d *Device) StopClient(sock uint8) error {
|
||||
d.mu.Lock()
|
||||
defer d.mu.Unlock()
|
||||
|
||||
if _debug {
|
||||
println("[StopClient] called StopClient()\r")
|
||||
}
|
||||
@@ -433,9 +419,6 @@ func (d *Device) StopClient(sock uint8) error {
|
||||
}
|
||||
|
||||
func (d *Device) StartServer(port uint16, sock uint8, mode uint8) error {
|
||||
d.mu.Lock()
|
||||
defer d.mu.Unlock()
|
||||
|
||||
if err := d.waitForChipSelect(); err != nil {
|
||||
d.spiChipDeselect()
|
||||
return err
|
||||
@@ -452,9 +435,6 @@ func (d *Device) StartServer(port uint16, sock uint8, mode uint8) error {
|
||||
|
||||
// InsertDataBuf adds data to the buffer used for sending UDP data
|
||||
func (d *Device) InsertDataBuf(buf []byte, sock uint8) (bool, error) {
|
||||
d.mu.Lock()
|
||||
defer d.mu.Unlock()
|
||||
|
||||
if err := d.waitForChipSelect(); err != nil {
|
||||
d.spiChipDeselect()
|
||||
return false, err
|
||||
@@ -470,9 +450,6 @@ func (d *Device) InsertDataBuf(buf []byte, sock uint8) (bool, error) {
|
||||
|
||||
// SendUDPData sends the data previously added to the UDP buffer
|
||||
func (d *Device) SendUDPData(sock uint8) (bool, error) {
|
||||
d.mu.Lock()
|
||||
defer d.mu.Unlock()
|
||||
|
||||
if err := d.waitForChipSelect(); err != nil {
|
||||
d.spiChipDeselect()
|
||||
return false, err
|
||||
|
||||
+41
-75
@@ -59,23 +59,21 @@ var architectures = map[string]architectureImpl{
|
||||
maxBaseCyclesT0H: 1 + 3 + 2, // shift + branch (not taken) + store
|
||||
minBaseCyclesT1H: 1 + 1 + 2, // shift + branch (taken) + store
|
||||
maxBaseCyclesT1H: 1 + 3 + 2, // shift + branch (taken) + store
|
||||
minBaseCyclesTLD: 1 + 2 + 2, // subtraction + branch x2 + store (in next cycle)
|
||||
valueTemplate: "(uint32_t)c << 24",
|
||||
minBaseCyclesTLD: 1 + 1 + 2, // subtraction + branch + store (in next cycle)
|
||||
valueTemplate: "uint32(c) << 24",
|
||||
template: `
|
||||
1: @ send_bit
|
||||
str %[maskSet], %[portSet] @ [2] T0H and T0L start here
|
||||
str {maskSet}, {portSet} @ [2] T0H and T0L start here
|
||||
@DELAY1
|
||||
lsls %[value], #1 @ [1]
|
||||
bcs.n 2f @ [1/3] skip_store
|
||||
str %[maskClear], %[portClear] @ [2] T0H -> T0L transition
|
||||
lsls {value}, #1 @ [1]
|
||||
bcs.n 2f @ [1/3] skip_store
|
||||
str {maskClear}, {portClear} @ [2] T0H -> T0L transition
|
||||
2: @ skip_store
|
||||
@DELAY2
|
||||
str %[maskClear], %[portClear] @ [2] T1H -> T1L transition
|
||||
str {maskClear}, {portClear} @ [2] T1H -> T1L transition
|
||||
@DELAY3
|
||||
subs %[i], #1 @ [1]
|
||||
beq.n 3f @ [1/3] end
|
||||
b 1b @ [1/3] send_bit
|
||||
3: @ end
|
||||
subs {i}, #1 @ [1]
|
||||
bne.n 1b @ [1/3] send_bit
|
||||
`,
|
||||
},
|
||||
"tinygoriscv": {
|
||||
@@ -90,25 +88,25 @@ var architectures = map[string]architectureImpl{
|
||||
minBaseCyclesT1H: 1 + 1 + 1, // shift + branch (taken) + store
|
||||
maxBaseCyclesT1H: 1 + 3 + 1, // shift + branch (taken) + store
|
||||
minBaseCyclesTLD: 1 + 1 + 1, // subtraction + branch + store (in next cycle)
|
||||
valueTemplate: "(uint32_t)c << 23",
|
||||
valueTemplate: "uint32(c) << 23",
|
||||
template: `
|
||||
1: // send_bit
|
||||
sw %[maskSet], %[portSet] // [1] T0H and T0L start here
|
||||
sw {maskSet}, {portSet} // [1] T0H and T0L start here
|
||||
@DELAY1
|
||||
slli %[value], %[value], 1 // [1] shift value left by 1
|
||||
bltz %[value], 2f // [1/3] skip_store
|
||||
sw %[maskClear], %[portClear] // [1] T0H -> T0L transition
|
||||
slli {value}, {value}, 1 // [1] shift value left by 1
|
||||
bltz {value}, 2f // [1/3] skip_store
|
||||
sw {maskClear}, {portClear} // [1] T0H -> T0L transition
|
||||
2: // skip_store
|
||||
@DELAY2
|
||||
sw %[maskClear], %[portClear] // [1] T1H -> T1L transition
|
||||
sw {maskClear}, {portClear} // [1] T1H -> T1L transition
|
||||
@DELAY3
|
||||
addi %[i], %[i], -1 // [1]
|
||||
bnez %[i], 1b // [1/3] send_bit
|
||||
addi {i}, {i}, -1 // [1]
|
||||
bnez {i}, 1b // [1/3] send_bit
|
||||
`,
|
||||
},
|
||||
}
|
||||
|
||||
func writeCAssembly(f *os.File, arch string, megahertz int) error {
|
||||
func writeImplementation(f *os.File, arch string, megahertz int) error {
|
||||
cycleTimeNS := 1 / float64(megahertz)
|
||||
// These timings are taken from the table "Updated simplified timing
|
||||
// constraints for NeoPixel strings" at:
|
||||
@@ -205,44 +203,6 @@ func writeCAssembly(f *os.File, arch string, megahertz int) error {
|
||||
actualMinCyclesTLD := archImpl.minBaseCyclesTLD + delay3
|
||||
actualMinNanosecondsTLD := float64(actualMinCyclesTLD) / float64(megahertz) * 1000
|
||||
|
||||
// Create the Go function in a buffer. Using a buffer here to be able to
|
||||
// ignore I/O errors.
|
||||
buf := &bytes.Buffer{}
|
||||
fmt.Fprintf(buf, "\n")
|
||||
fmt.Fprintf(buf, "__attribute__((always_inline))\nvoid ws2812_writeByte%d(char c, uint32_t *portSet, uint32_t *portClear, uint32_t maskSet, uint32_t maskClear) {\n", megahertz)
|
||||
fmt.Fprintf(buf, " // Timings:\n")
|
||||
fmt.Fprintf(buf, " // T0H: %2d - %2d cycles or %.1fns - %.1fns\n", actualMinCyclesT0H, actualMaxCyclesT0H, actualMinNanosecondsT0H, actualMaxNanosecondsT0H)
|
||||
fmt.Fprintf(buf, " // T1H: %2d - %2d cycles or %.1fns - %.1fns\n", actualMinCyclesT1H, actualMaxCyclesT1H, actualMinNanosecondsT1H, actualMaxNanosecondsT1H)
|
||||
fmt.Fprintf(buf, " // TLD: %2d - cycles or %.1fns -\n", actualMinCyclesTLD, actualMinNanosecondsTLD)
|
||||
fmt.Fprintf(buf, " uint32_t value = %s;\n", archImpl.valueTemplate)
|
||||
asm := archImpl.template
|
||||
asm = strings.TrimSpace(asm)
|
||||
asm = strings.ReplaceAll(asm, " @DELAY1\n", strings.Repeat(" nop\n", delay1))
|
||||
asm = strings.ReplaceAll(asm, " @DELAY2\n", strings.Repeat(" nop\n", delay2))
|
||||
asm = strings.ReplaceAll(asm, " @DELAY3\n", strings.Repeat(" nop\n", delay3))
|
||||
asm = strings.ReplaceAll(asm, "\n", "\n\t")
|
||||
fmt.Fprintf(buf, " char i = 8;\n")
|
||||
fmt.Fprintf(buf, " __asm__ __volatile__(\n")
|
||||
for _, line := range strings.Split(asm, "\n") {
|
||||
fmt.Fprintf(buf, "\t\t%#v\n", line+"\n")
|
||||
}
|
||||
// Note: [value] and [i] must be input+output operands because they modify
|
||||
// the value.
|
||||
fmt.Fprintf(buf, ` : [value]"+r"(value),
|
||||
[i]"+r"(i)
|
||||
: [maskSet]"r"(maskSet),
|
||||
[portSet]"m"(*portSet),
|
||||
[maskClear]"r"(maskClear),
|
||||
[portClear]"m"(*portClear));
|
||||
}
|
||||
`)
|
||||
|
||||
// Now write the buffer contents (with the assembly function) to a file.
|
||||
_, err := f.Write(buf.Bytes())
|
||||
return err
|
||||
}
|
||||
|
||||
func writeGoWrapper(f *os.File, arch string, megahertz int) error {
|
||||
// Create the Go function in a buffer. Using a buffer here to be able to
|
||||
// ignore I/O errors.
|
||||
buf := &bytes.Buffer{}
|
||||
@@ -251,9 +211,26 @@ func writeGoWrapper(f *os.File, arch string, megahertz int) error {
|
||||
fmt.Fprintf(buf, " portSet, maskSet := d.Pin.PortMaskSet()\n")
|
||||
fmt.Fprintf(buf, " portClear, maskClear := d.Pin.PortMaskClear()\n")
|
||||
fmt.Fprintf(buf, "\n")
|
||||
fmt.Fprintf(buf, " // Timings:\n")
|
||||
fmt.Fprintf(buf, " // T0H: %2d - %2d cycles or %.1fns - %.1fns\n", actualMinCyclesT0H, actualMaxCyclesT0H, actualMinNanosecondsT0H, actualMaxNanosecondsT0H)
|
||||
fmt.Fprintf(buf, " // T1H: %2d - %2d cycles or %.1fns - %.1fns\n", actualMinCyclesT1H, actualMaxCyclesT1H, actualMinNanosecondsT1H, actualMaxNanosecondsT1H)
|
||||
fmt.Fprintf(buf, " // TLD: %2d - cycles or %.1fns -\n", actualMinCyclesTLD, actualMinNanosecondsTLD)
|
||||
fmt.Fprintf(buf, " mask := interrupt.Disable()\n")
|
||||
fmt.Fprintf(buf, " C.ws2812_writeByte%d(C.char(c), (*uint32)(unsafe.Pointer(portSet)), (*uint32)(unsafe.Pointer(portClear)), maskSet, maskClear)\n", megahertz)
|
||||
fmt.Fprintf(buf, " value := %s\n", archImpl.valueTemplate)
|
||||
asm := archImpl.template
|
||||
asm = strings.ReplaceAll(asm, " @DELAY1\n", strings.Repeat(" nop\n", delay1))
|
||||
asm = strings.ReplaceAll(asm, " @DELAY2\n", strings.Repeat(" nop\n", delay2))
|
||||
asm = strings.ReplaceAll(asm, " @DELAY3\n", strings.Repeat(" nop\n", delay3))
|
||||
asm = strings.ReplaceAll(asm, "\n", "\n\t")
|
||||
fmt.Fprintf(buf, " device.AsmFull(`%s`, map[string]interface{}{", asm)
|
||||
buf.WriteString(`
|
||||
"value": value,
|
||||
"i": 8,
|
||||
"maskSet": maskSet,
|
||||
"portSet": portSet,
|
||||
"maskClear": maskClear,
|
||||
"portClear": portClear,
|
||||
})
|
||||
interrupt.Restore(mask)
|
||||
}
|
||||
`)
|
||||
@@ -292,27 +269,16 @@ package ws2812
|
||||
// Warning: autogenerated file. Instead of modifying this file, change
|
||||
// gen-ws2812.go and run "go generate".
|
||||
|
||||
import "runtime/interrupt"
|
||||
import "unsafe"
|
||||
|
||||
/*
|
||||
#include <stdint.h>
|
||||
import (
|
||||
"device"
|
||||
"runtime/interrupt"
|
||||
)
|
||||
`)
|
||||
for _, megahertz := range clockFrequencies {
|
||||
err := writeCAssembly(f, *arch, megahertz)
|
||||
err := writeImplementation(f, *arch, megahertz)
|
||||
if err != nil {
|
||||
fmt.Fprintf(os.Stderr, "could not generate WS2812 assembly code for %s and %dMHz: %s\n", *arch, megahertz, err)
|
||||
os.Exit(1)
|
||||
}
|
||||
}
|
||||
f.WriteString(`*/
|
||||
import "C"
|
||||
`)
|
||||
for _, megahertz := range clockFrequencies {
|
||||
err := writeGoWrapper(f, *arch, megahertz)
|
||||
if err != nil {
|
||||
fmt.Fprintf(os.Stderr, "could not generate Go wrapper: %w\n", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+999
-1337
File diff suppressed because it is too large
Load Diff
+1094
-1107
File diff suppressed because it is too large
Load Diff
+1
-1
@@ -1,7 +1,7 @@
|
||||
// Package ws2812 implements a driver for WS2812 and SK6812 RGB LED strips.
|
||||
package ws2812 // import "tinygo.org/x/drivers/ws2812"
|
||||
|
||||
//go:generate go run gen-ws2812.go -arch=cortexm 16 48 64 120 125 168
|
||||
//go:generate go run gen-ws2812.go -arch=cortexm 16 48 64 120 168
|
||||
//go:generate go run gen-ws2812.go -arch=tinygoriscv 160 320
|
||||
|
||||
import (
|
||||
|
||||
+32
-40
@@ -6,49 +6,11 @@ package ws2812
|
||||
// This file implements the WS2812 protocol for AVR microcontrollers.
|
||||
|
||||
import (
|
||||
"device/avr"
|
||||
"machine"
|
||||
"runtime/interrupt"
|
||||
"unsafe"
|
||||
)
|
||||
|
||||
/*
|
||||
#include <stdint.h>
|
||||
|
||||
__attribute__((always_inline))
|
||||
void ws2812_writeByte16(char c, uint8_t *port, uint8_t maskSet, uint8_t maskClear) {
|
||||
// See:
|
||||
// https://wp.josh.com/2014/05/13/ws2812-neopixels-are-not-so-finicky-once-you-get-to-know-them/
|
||||
// T0H: 4 cycles or 250ns
|
||||
// T0L: 14 cycles or 875ns -> together 18 cycles or 1125ns
|
||||
// T1H: 9 cycles or 562ns
|
||||
// T1L: 8 cycles or 500ns -> together 17 cycles or 1062ns
|
||||
char i = 8;
|
||||
__asm__ __volatile__(
|
||||
"1:\n"
|
||||
"\t st %[port], %[maskSet] ; [2] set output high\n"
|
||||
"\t lsl %[value] ; [1] shift off the next bit, store it in C\n"
|
||||
"\t brcs 2f ; [1/2] branch if this bit is high (long pulse)\n"
|
||||
"\t st %[port], %[maskClear] ; [2] set output low (short pulse)\n"
|
||||
"\t2:\n"
|
||||
"\t nop ; [4] wait before changing the output again\n"
|
||||
"\t nop\n"
|
||||
"\t nop\n"
|
||||
"\t nop\n"
|
||||
"\t st %[port], %[maskClear] ; [2] set output low (end of pulse)\n"
|
||||
"\t nop ; [3]\n"
|
||||
"\t nop\n"
|
||||
"\t nop\n"
|
||||
"\t subi %[i], 1 ; [1] subtract one (for the loop)\n"
|
||||
"\t brne 1b ; [1/2] send the next bit, if not at the end of the loop\n"
|
||||
: [value]"+r"(c),
|
||||
[i]"+r"(i)
|
||||
: [maskSet]"r"(maskSet),
|
||||
[maskClear]"r"(maskClear),
|
||||
[port]"m"(*port));
|
||||
}
|
||||
*/
|
||||
import "C"
|
||||
|
||||
// Send a single byte using the WS2812 protocol.
|
||||
func (d Device) WriteByte(c byte) error {
|
||||
// On AVR, the port is always the same for setting and clearing a register
|
||||
@@ -61,7 +23,37 @@ func (d Device) WriteByte(c byte) error {
|
||||
|
||||
switch machine.CPUFrequency() {
|
||||
case 16e6: // 16MHz
|
||||
C.ws2812_writeByte16(C.char(c), (*uint8)(unsafe.Pointer(port)), maskSet, maskClear)
|
||||
// See:
|
||||
// https://wp.josh.com/2014/05/13/ws2812-neopixels-are-not-so-finicky-once-you-get-to-know-them/
|
||||
// T0H: 4 cycles or 250ns
|
||||
// T0L: 14 cycles or 875ns -> together 18 cycles or 1125ns
|
||||
// T1H: 9 cycles or 562ns
|
||||
// T1L: 8 cycles or 500ns -> together 17 cycles or 1062ns
|
||||
avr.AsmFull(`
|
||||
send_bit:
|
||||
st {portSet}, {maskSet} ; [2] set output high
|
||||
lsl {value} ; [1] shift off the next bit, store it in C
|
||||
brcs skip_store ; [1/2] branch if this bit is high (long pulse)
|
||||
st {portClear}, {maskClear} ; [2] set output low (short pulse)
|
||||
skip_store:
|
||||
nop ; [4] wait before changing the output again
|
||||
nop
|
||||
nop
|
||||
nop
|
||||
st {portClear}, {maskClear} ; [2] set output low (end of pulse)
|
||||
nop ; [3]
|
||||
nop
|
||||
nop
|
||||
subi {i}, 1 ; [1] subtract one (for the loop)
|
||||
brne send_bit ; [1/2] send the next bit, if not at the end of the loop
|
||||
`, map[string]interface{}{
|
||||
"value": c,
|
||||
"i": byte(8),
|
||||
"maskSet": maskSet,
|
||||
"portSet": port,
|
||||
"maskClear": maskClear,
|
||||
"portClear": port,
|
||||
})
|
||||
interrupt.Restore(mask)
|
||||
return nil
|
||||
default:
|
||||
|
||||
@@ -29,9 +29,6 @@ func (d Device) WriteByte(c byte) error {
|
||||
case 120_000_000: // 120MHz
|
||||
d.writeByte120(c)
|
||||
return nil
|
||||
case 125_000_000: // 125 MHz e.g. rp2040
|
||||
d.writeByte125(c)
|
||||
return nil
|
||||
case 168_000_000: // 168MHz, e.g. stm32f405
|
||||
d.writeByte168(c)
|
||||
return nil
|
||||
|
||||
Reference in New Issue
Block a user