mirror of
https://github.com/tinygo-org/drivers.git
synced 2026-07-26 18:48:41 +00:00
Compare commits
1 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 Ayke van Laethem
|
09abe484ba |
@@ -1,20 +0,0 @@
|
||||
# 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,2 +0,0 @@
|
||||
build
|
||||
.vscode/
|
||||
-332
@@ -1,332 +0,0 @@
|
||||
0.17.1
|
||||
---
|
||||
- To correct an error in the release process. Same as 0.17.0.
|
||||
|
||||
0.17.0
|
||||
---
|
||||
- **new devices**
|
||||
- rtl8720dn: add support for rtl8720dn
|
||||
- sdcard: add support for spi sdcard driver, along with fatfs
|
||||
- **enhancements**
|
||||
- apa102: use 4-byte buffer to improve speed
|
||||
- bmi160: avoid heap allocations
|
||||
- ili9341: add standard SPI driver
|
||||
- wifinina
|
||||
- avoid fmt package
|
||||
- Fix RSSI command for WiFiNINA + Print current SSID + Wait for correct time before printing it out + Cleanup
|
||||
- ws2812
|
||||
- rename the pin to ws2812
|
||||
- add tag for nrf52833
|
||||
- Disable interrupts before sending ws2812 data
|
||||
- add support for qtpy and atsame5x
|
||||
- **core**
|
||||
- modules: switch to use tinygo-org version of tinyfs package
|
||||
- all: use machine.Serial as the default output
|
||||
|
||||
0.16.0
|
||||
---
|
||||
- **new devices**
|
||||
- aht20: add device
|
||||
- ina260: add new i2c device
|
||||
- keypad: add 4x4 keypad driver (#226)
|
||||
- max7219: add driver support
|
||||
- mcp2515: add support for mcp2515 CAN device
|
||||
- p1am: support the P1AM-100 hardware watchdog
|
||||
- pcf8563: add support for pcf8563 real time clock
|
||||
- servo: add driver using PWM
|
||||
- tm1637: add support for tm1637 7-segment LED
|
||||
- tone: add package for producing tones using the PWM interface
|
||||
- **enhancements**
|
||||
- pwm: update drivers with PWM to use new interface
|
||||
- wifinina: Make TLS work over WiFiNINA Verified on Arduino Nano33 IoT and nina fw v1.4.5
|
||||
- ssd1306: Enable reset screen for SSD1306 via I2C
|
||||
- st7789: add scrolling functions to match st7735
|
||||
- **bugfixes**
|
||||
- wifinina:
|
||||
- fix getMACAddress and getTime
|
||||
- fix println + cleanup
|
||||
- remove debug flag and remove unnecessary padding call
|
||||
- fix padding and implement missing functions
|
||||
- flash: fix EraseBlocks method which is erasing sectors instead
|
||||
- **core**
|
||||
- all: use interfaces for UART objects
|
||||
- all: do not take the pointer of an I2C object
|
||||
- adc: update drivers with ADC to use new config struct
|
||||
- **testing**
|
||||
- tester:
|
||||
- add a mock for command-oriented i2c devices
|
||||
- add 16-bit register mock device
|
||||
|
||||
- **docs**
|
||||
- ssd1306: example of ssd1306 with 128x64 display over I2C
|
||||
- wifinina:
|
||||
- add information about Adafruit boards with ESP32 wifi coprocessors, and modify examples to remove code that was both not being used, and also prevented many Adafruit boards from being able to be targeted by the examples
|
||||
- update docs to simplify the nina-fw update process
|
||||
- example that connects to AP and prints ip addresses, time and mac
|
||||
- p1am: documentation and example program
|
||||
- add missing new drivers added since last release
|
||||
|
||||
0.15.0
|
||||
---
|
||||
- **new devices**
|
||||
- dht: add DHTXX thermometer
|
||||
- mcp23017: new driver for MCP23017 (I2C port expander)
|
||||
- bmp388: Add bmp388 support (#219)
|
||||
- **enhancements**
|
||||
- hd44780: add a mode to work with boards where the RW pin is grounded
|
||||
- st7789: add scrolling functions to match st7735
|
||||
- microbitmatrix: matrix now working on microbit v2
|
||||
- ds1307: Better interface "ReadTime" instead of "Time"
|
||||
- ws2812: make AVR support more robust
|
||||
- **bugfixes**
|
||||
- all: fix main package in examples
|
||||
- **core**
|
||||
- adc: update all drivers with ADC to use new config struct
|
||||
- spi: remove machine.SPI and replace with drivers.SPI interface for almost all SPI drivers
|
||||
- **testing**
|
||||
- test: run unit tests against i2c drivers and any spi drivers without direct gpio
|
||||
- **docs**
|
||||
- st7789: correct errors on various godoc comments
|
||||
|
||||
0.14.0
|
||||
---
|
||||
- **new devices**
|
||||
- lis2mdl: add LIS2MDL magnetometer (#187)
|
||||
- waveshare: add Waveshare 4.2in B/W e-paper driver (#183)
|
||||
- **enhancements**
|
||||
- adt7410: add connection test and for that matter connection method
|
||||
- gps
|
||||
- add speed and heading to fix, as parsed from RMC NMEA sentence
|
||||
- improvements and bugfixes (#186)
|
||||
- ili9341
|
||||
- add support for setting framerate, vsync pause, and reading scanline data.
|
||||
- renamed NewSpi() to NewSPI() in accordance with Go naming conventions
|
||||
- ws2812
|
||||
- add support for ESP8266
|
||||
- add support for ESP32
|
||||
- **bugfixes**
|
||||
- ili9341
|
||||
- rix setWindow bug, add CS pin for Clue compatibility. (#180)
|
||||
- bugfix for RAMWR bug
|
||||
- lis2mdl: turn on read mode on every read, to ensure that magnetometer data is updated
|
||||
- **core**
|
||||
- i2c
|
||||
- switch all i2c drivers definitions to use i2c bus interface type instead of machine package concrete type
|
||||
- correct interface definition for I2C Tx function
|
||||
- **testing**
|
||||
- fix smoke-test unless avr-gcc installed
|
||||
- add very basic mock structs for testing i2c devices, based on work done by @rogpeppe
|
||||
- improve API surface and implement one more test function in lis2mdl driver
|
||||
- **docs**
|
||||
- replace README badge for godocs with pkgdocs
|
||||
|
||||
0.13.0
|
||||
---
|
||||
- **new devices**
|
||||
- bmi160: add initial support
|
||||
- bmp280: added support for the Bosch BMP280 temperature and pressure sensor. (#158)
|
||||
- lsm303agr: add lsm303agr (#162)
|
||||
- ssd1351: add SSD1351 OLED display driver (#146)
|
||||
- **enhancements**
|
||||
- hd44780: add Hd44780i2c driver (#173)
|
||||
- ili9341
|
||||
- add ILI9341 TFT driver (SPI) for ATSAMD2x (#174)
|
||||
- cache address window to prevent sending unnecessary commands (#171)
|
||||
- ILI9341 TFT driver (SPI) (#153)
|
||||
- improve performance of ILI9341 on ATSAMD5X
|
||||
- ST77xx: fix DrawFastHLine for ST77xx, SSD1331 and SSD1351 DrawFastHLine uses FillRectangle(x,y,width,height,c), so height must be 1 to draw a horizontal line
|
||||
- tmp102: add Connected func to check for device
|
||||
- wifinina: added UDP support
|
||||
- ws2812: update ws2812_avr_16m.go
|
||||
- **bugfixes**
|
||||
- apa102: avoid creating garbage
|
||||
- bmp180: fix temperature type conversion
|
||||
- **core**
|
||||
- all
|
||||
- added custom import path (#161)
|
||||
- changeover to eliminate all direct use of master/slave terminology
|
||||
- build: try vendor in working directory to match expected module path
|
||||
- ci: support Go modules
|
||||
- modules: update go version and dependency
|
||||
- **docs**
|
||||
- docs: reorder to correct alpha and adjust count of supported drivers
|
||||
|
||||
0.12.0
|
||||
---
|
||||
- **new devices**
|
||||
- hcsr04: Added HC-SR04 ultrasonic distance sensor. (#143)
|
||||
- spi/qspi: Low-level IO driver for serial flash memory via SPI and QSPI (#124)
|
||||
- tmp102: TMP102 low-power digital temperature sensor (#141)
|
||||
- amg88xx: AMG88xx thermal camera module
|
||||
- **bugfixes**
|
||||
- mqtt: reduce use of goroutines in router to not start a new goroutine for each invocation of each callback
|
||||
|
||||
0.11.0
|
||||
---
|
||||
- **new devices**
|
||||
- shiftregister: Support for various shift register chips (#135)
|
||||
- **enhancements**
|
||||
- shifter: simplify API surface for PyBadge (#137)
|
||||
- shifter: new API for shifter driver
|
||||
- mqtt: use buffered channels for incoming messages to handle bursts
|
||||
- ili9341: Adding scroll functionality (#121)
|
||||
- **bugfixes**
|
||||
- wifinina: fix typo on StartScanNetworks
|
||||
- ili9341: various bugfixes for display
|
||||
- **examples**
|
||||
- semihosting: add example
|
||||
- **docs**
|
||||
- readme: Use degree sign instead of ordinal
|
||||
- all: fix celsius symbol in all code comments
|
||||
|
||||
0.10.0
|
||||
---
|
||||
- **new devices**
|
||||
- adt7410: Support for ADT7410 temperature sensor (#109)
|
||||
- ili9341: ILI9341 TFT driver (#115)
|
||||
- l293x: added support for h-bridge motor controller
|
||||
- l9110x: add support for L9110x h-bridge motor driver
|
||||
- resistive: Adding driver for four-wire resistive touchscreen (#118)
|
||||
- **enhancements**
|
||||
- st7735: added scroll functionality to st7735
|
||||
- st7735: remove default offsets
|
||||
- st7789: remove default offsets
|
||||
- ws2812: Added nrf52840 tag to ws2812
|
||||
- ws2812: work-arounds to allow Digispark to control WS2812 LEDs
|
||||
- **docs**
|
||||
- readme: update README to include list of all 44 drivers
|
||||
- wifinina: update docs and add Dockerfile to build firmware
|
||||
- wifinina: update docs and info on how to install WiFiNINA driver
|
||||
|
||||
0.9.0
|
||||
---
|
||||
- **new devices**
|
||||
- net: shared implementation of net package for serial wifi devices
|
||||
- shifter: add support for bit Parallel In Serial Out (PISO) shifter
|
||||
- stepper: add support for dual stepper motor
|
||||
- wifinina: add implementation for WiFiNINA firmware
|
||||
- **enhancements**
|
||||
- st7735: improvements in st7735 driver
|
||||
- st7789: improvements in st7789 driver
|
||||
- ws2812: add support for 120Mhz Cortex-M4
|
||||
- ws2812: added Feather M0 and Trinket M0 to build tags for WS2812
|
||||
- ws2812: add support for simulation
|
||||
- **bugfixes**
|
||||
- ws2812: fix "invalid symbol redefinition" error
|
||||
- **examples**
|
||||
- Add examples for wifinina drivers
|
||||
|
||||
0.8.0
|
||||
---
|
||||
- **new devices**
|
||||
- mcp3008: add implementation for MCP3008 ADC with SPI interface
|
||||
- semihosting: initial implementation of ARM semihosting
|
||||
- **enhancements**
|
||||
- espat: refactor response processing for greater speed and efficiency
|
||||
- espat: implement mqtt subscribe functionality via blocking select/channels (experiemental)
|
||||
- **bugfixes**
|
||||
- st7789: fix index out of bounds error
|
||||
- **examples**
|
||||
- Add espat driver example for mqtt subscribe
|
||||
|
||||
0.7.0
|
||||
---
|
||||
- **new devices**
|
||||
- veml6070: add Vishay UV light sensor
|
||||
- **enhancements**
|
||||
- lis3dh: example uses I2C1 so requires config to specify pins since they are not default
|
||||
- ssd1331: make SPI TX faster
|
||||
- st7735: make SPI Tx faster
|
||||
- **docs**
|
||||
- complete missing GoDocs for main and sub-packages
|
||||
- **core**
|
||||
- add Version string for support purposes
|
||||
- **examples**
|
||||
- Change all espat driver examples to use Arduino Nano33 IoT by default
|
||||
|
||||
0.6.0
|
||||
---
|
||||
- **new devices**
|
||||
- Support software SPI for APA102 (Itsy Bitsy M0 on-board "Dotstar" LED as example)
|
||||
|
||||
0.5.0
|
||||
---
|
||||
- **new devices**
|
||||
- LSM6DS3 accelerometer
|
||||
- **bugfixes**
|
||||
- ws2812: fix timings for the nrf51
|
||||
- **enhancements**
|
||||
- ws2812: Add build tag for Arduino Nano33 IoT
|
||||
|
||||
0.4.0
|
||||
---
|
||||
- **new devices**
|
||||
- SSD1331 TFT color display
|
||||
- ST7735 TFT color display
|
||||
- ST7789 TFT color display
|
||||
- **docs**
|
||||
- espat
|
||||
- complete list of dependencies for flashing NINA-W102 as used in Arduino Nano33 IoT board.
|
||||
|
||||
0.3.0
|
||||
---
|
||||
- **new devices**
|
||||
- Buzzer for piezo or small speaker
|
||||
- PDM MEMS microphone support using I2S interface
|
||||
- **enhancements**
|
||||
- epd2in13: added rotation
|
||||
- espat
|
||||
- add built-in support for MQTT publish using the Paho library packets, alongside some modifications needed for the AT protocol.
|
||||
- add DialTLS and Dial methods, update MQTT example to allow both MQTT and MQTTS connections
|
||||
- add example that uses MQTT publish to open server
|
||||
- add README with information on how to flash ESP32 or ESP8266 with AT command set firmware.
|
||||
- add ResolveUDPAddr and ResolveTCPAddr implementations using AT command for DNS lookup
|
||||
- change Response() method to use a passed-in timeout value instead of fixed pauses.
|
||||
- implement TCPConn using AT command set
|
||||
- improve error handling for key TCP functions
|
||||
- refactor net and tls interface compatible code into separate sub-packages
|
||||
- update MQTT example for greater stability
|
||||
- use only AT commands that work on both ESP8266 and ESP32
|
||||
- add documentation on how to use Arduino Nano33 IoT built-in WiFi NINA-W102 chip.
|
||||
- **bugfixes**
|
||||
- core: Error strings should not be capitalized (unless beginning with proper nouns or acronyms) or end with punctuation, since they are usually printed following other context.
|
||||
- docs: add note to current/future contributors to please start by opening a GH issue to avoid duplication of efforts
|
||||
- examples: typo in package name of examples
|
||||
- mpu6050: properly scale the outputs of the accel/gyro
|
||||
|
||||
0.2.0
|
||||
---
|
||||
- **new devices**
|
||||
- AT24C32/64 2-wire serial EEPROM
|
||||
- BME280 humidity/pressure sensor
|
||||
- **bugfixes**
|
||||
- ws2812: better support for nrf52832
|
||||
|
||||
0.1.0
|
||||
---
|
||||
- **first release**
|
||||
- This is the first official release of the TinyGo drivers repo, matching TinyGo 0.6.0. The following devices are supported:
|
||||
- ADXL345
|
||||
- APA102
|
||||
- BH1750
|
||||
- BlinkM
|
||||
- BMP180
|
||||
- DS1307
|
||||
- DS3231
|
||||
- Easystepper
|
||||
- ESP8266/ESP32
|
||||
- GPS
|
||||
- HUB75
|
||||
- LIS3DH
|
||||
- MAG3110
|
||||
- microbit LED matrix
|
||||
- MMA8653
|
||||
- MPU6050
|
||||
- PCD8544
|
||||
- SHT3x
|
||||
- SSD1306
|
||||
- Thermistor
|
||||
- VL53L1X
|
||||
- Waveshare 2.13"
|
||||
- Waveshare 2.13" (B & C)
|
||||
- WS2812
|
||||
@@ -1,40 +0,0 @@
|
||||
# How to contribute
|
||||
|
||||
Thank you for your interest in improving the TinyGo drivers.
|
||||
|
||||
We would like your help to make this project better, so we appreciate any contributions. See if one of the following descriptions matches your situation:
|
||||
|
||||
### New to TinyGo
|
||||
|
||||
We'd love to get your feedback on getting started with TinyGo. Run into any difficulty, confusion, or anything else? You are not alone. We want to know about your experience, so we can help the next people. Please open a Github issue with your questions, or you can also get in touch directly with us on our Slack channel at [https://gophers.slack.com/messages/CDJD3SUP6](https://gophers.slack.com/messages/CDJD3SUP6).
|
||||
|
||||
### One of the TinyGo drivers is not working as you expect
|
||||
|
||||
Please open a Github issue with your problem, and we will be happy to assist.
|
||||
|
||||
### Some specific hardware you want to use does not appear to be in the TinyGo drivers
|
||||
|
||||
We probably have not implemented it yet. Your contribution adding the hardware support to TinyGo would be greatly appreciated.
|
||||
|
||||
Please first open a Github issue. We want to help, and also make sure that there is no duplications of efforts. Sometimes what you need is already being worked on by someone else.
|
||||
|
||||
## How to use our Github repository
|
||||
|
||||
The `release` branch of this repo will always have the latest released version of the TinyGo drivers. All of the active development work for the next release will take place in the `dev` branch. The TinyGo drivers will use semantic versioning and will create a tag/release for each release.
|
||||
|
||||
Here is how to contribute back some code or documentation:
|
||||
|
||||
- Fork repo
|
||||
- Create a feature branch off of the `dev` branch
|
||||
- Make some useful change
|
||||
- Make sure the tests still pass
|
||||
- Submit a pull request against the `dev` branch.
|
||||
- Be kind
|
||||
|
||||
## How to run tests
|
||||
|
||||
To run the tests:
|
||||
|
||||
```
|
||||
make test
|
||||
```
|
||||
@@ -1,27 +0,0 @@
|
||||
Copyright (c) 2018-2021 The TinyGo Authors. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are
|
||||
met:
|
||||
|
||||
* Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
* Redistributions in binary form must reproduce the above
|
||||
copyright notice, this list of conditions and the following disclaimer
|
||||
in the documentation and/or other materials provided with the
|
||||
distribution.
|
||||
* Neither the name of the copyright holder nor the names of its
|
||||
contributors may be used to endorse or promote products derived from
|
||||
this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
@@ -1,213 +0,0 @@
|
||||
|
||||
clean:
|
||||
@rm -rf build
|
||||
|
||||
FMT_PATHS = ./*.go ./examples/**/*.go
|
||||
|
||||
fmt-check:
|
||||
@unformatted=$$(gofmt -l $(FMT_PATHS)); [ -z "$$unformatted" ] && exit 0; echo "Unformatted:"; for fn in $$unformatted; do echo " $$fn"; done; exit 1
|
||||
|
||||
smoke-test:
|
||||
@mkdir -p build
|
||||
tinygo build -size short -o ./build/test.hex -target=itsybitsy-m0 ./examples/adt7410/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=itsybitsy-m0 ./examples/adxl345/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=pybadge ./examples/amg88xx
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=itsybitsy-m0 ./examples/apa102/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=itsybitsy-m0 ./examples/apa102/itsybitsy-m0/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=microbit ./examples/at24cx/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=itsybitsy-m0 ./examples/bh1750/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=itsybitsy-m0 ./examples/blinkm/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=itsybitsy-m0 ./examples/bmi160/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=itsybitsy-m0 ./examples/bmp180/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=itsybitsy-m0 ./examples/bmp280/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=trinket-m0 ./examples/bmp388/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=bluepill ./examples/ds1307/sram/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=bluepill ./examples/ds1307/time/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=itsybitsy-m0 ./examples/ds3231/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=microbit ./examples/easystepper/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=arduino-nano33 ./examples/espat/espconsole/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=arduino-nano33 ./examples/espat/esphub/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=arduino-nano33 ./examples/espat/espstation/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=itsybitsy-m0 ./examples/flash/console/spi
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=pyportal ./examples/flash/console/qspi
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=feather-m0 ./examples/gps/i2c/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=feather-m0 ./examples/gps/uart/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=itsybitsy-m0 ./examples/hcsr04/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=microbit ./examples/hd44780/customchar/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=microbit ./examples/hd44780/text/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=arduino-nano33 ./examples/hd44780i2c/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=microbit ./examples/hub75/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=pyportal ./examples/ili9341/basic
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=xiao ./examples/ili9341/basic
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=pyportal ./examples/ili9341/pyportal_boing
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=pyportal ./examples/ili9341/scroll
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=xiao ./examples/ili9341/scroll
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=circuitplay-express ./examples/lis3dh/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=microbit ./examples/lsm303agr/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=arduino-nano33 ./examples/lsm6ds3/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=itsybitsy-m0 ./examples/mag3110/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=itsybitsy-m0 ./examples/mcp23017/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=itsybitsy-m0 ./examples/mcp23017-multiple/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=itsybitsy-m0 ./examples/mcp3008/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=itsybitsy-m0 ./examples/mcp2515/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=microbit ./examples/microbitmatrix/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=itsybitsy-m0 ./examples/mma8653/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=itsybitsy-m0 ./examples/mpu6050/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=p1am-100 ./examples/p1am/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=microbit ./examples/pcd8544/setbuffer/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=microbit ./examples/pcd8544/setpixel/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=arduino ./examples/servo
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=pybadge ./examples/shifter/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=microbit ./examples/sht3x/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=microbit ./examples/ssd1306/i2c_128x32/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=microbit ./examples/ssd1306/spi_128x64/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=microbit ./examples/ssd1331/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=microbit ./examples/st7735/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=microbit ./examples/st7789/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=circuitplay-express ./examples/thermistor/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=circuitplay-bluefruit ./examples/tone
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=arduino-nano33 ./examples/tm1637/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=pyportal ./examples/touch/resistive/fourwire/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=pyportal ./examples/touch/resistive/pyportal_touchpaint/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=itsybitsy-m0 ./examples/vl53l1x/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=microbit ./examples/waveshare-epd/epd2in13/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=microbit ./examples/waveshare-epd/epd2in13x/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=microbit ./examples/waveshare-epd/epd4in2/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=arduino-nano33 ./examples/wifinina/ntpclient/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=arduino-nano33 ./examples/wifinina/udpstation/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=arduino-nano33 ./examples/wifinina/tcpclient/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=arduino-nano33 ./examples/wifinina/webclient/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=circuitplay-express ./examples/ws2812
|
||||
@md5sum ./build/test.hex
|
||||
ifneq ($(AVR), 0)
|
||||
tinygo build -size short -o ./build/test.hex -target=arduino ./examples/ws2812
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=digispark ./examples/ws2812
|
||||
@md5sum ./build/test.hex
|
||||
endif
|
||||
tinygo build -size short -o ./build/test.hex -target=trinket-m0 ./examples/bme280/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=circuitplay-express ./examples/microphone/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=circuitplay-express ./examples/buzzer/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=trinket-m0 ./examples/veml6070/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=arduino-nano33 ./examples/l293x/simple/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=arduino-nano33 ./examples/l293x/speed/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=arduino-nano33 ./examples/l9110x/simple/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=arduino-nano33 ./examples/l9110x/speed/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=nucleo-f103rb ./examples/shiftregister/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=hifive1b ./examples/ssd1351/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=circuitplay-express ./examples/lis2mdl/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=arduino-nano33 ./examples/max72xx/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=feather-m0 ./examples/dht/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=arduino ./examples/keypad4x4/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=xiao ./examples/pcf8563/alarm/
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=xiao ./examples/pcf8563/clkout/
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=xiao ./examples/pcf8563/time/
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=xiao ./examples/pcf8563/timer/
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=feather-m0 ./examples/ina260/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=nucleo-l432kc ./examples/aht20/main.go
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=feather-m4 ./examples/sdcard/console/
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=feather-m4 ./examples/sdcard/tinyfs/
|
||||
@md5sum ./build/test.hex
|
||||
tinygo build -size short -o ./build/test.hex -target=wioterminal ./examples/rtl8720dn/webclient/
|
||||
@md5sum ./build/test.hex
|
||||
|
||||
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
|
||||
TESTS = $(filter-out $(addsuffix /%,$(NOTESTS)),$(DRIVERS))
|
||||
|
||||
unit-test:
|
||||
@go test -v $(addprefix ./,$(TESTS))
|
||||
|
||||
test: clean fmt-check unit-test smoke-test
|
||||
@@ -1,135 +0,0 @@
|
||||
# TinyGo Drivers
|
||||
|
||||
[](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).
|
||||
|
||||
## Installing
|
||||
|
||||
```shell
|
||||
go get tinygo.org/x/drivers
|
||||
```
|
||||
|
||||
## How to use
|
||||
|
||||
Here is an example in TinyGo that uses the BMP180 digital barometer:
|
||||
|
||||
```go
|
||||
package main
|
||||
|
||||
import (
|
||||
"time"
|
||||
|
||||
"machine"
|
||||
|
||||
"tinygo.org/x/drivers/bmp180"
|
||||
)
|
||||
|
||||
func main() {
|
||||
machine.I2C0.Configure(machine.I2CConfig{})
|
||||
sensor := bmp180.New(machine.I2C0)
|
||||
sensor.Configure()
|
||||
|
||||
connected := sensor.Connected()
|
||||
if !connected {
|
||||
println("BMP180 not detected")
|
||||
return
|
||||
}
|
||||
println("BMP180 detected")
|
||||
|
||||
for {
|
||||
temp, _ := sensor.ReadTemperature()
|
||||
println("Temperature:", float32(temp)/1000, "°C")
|
||||
|
||||
pressure, _ := sensor.ReadPressure()
|
||||
println("Pressure", float32(pressure)/100000, "hPa")
|
||||
|
||||
time.Sleep(2 * time.Second)
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## Currently supported devices
|
||||
|
||||
The following 67 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 |
|
||||
| [AT24CX 2-wire serial EEPROM](https://www.openimpulse.com/blog/wp-content/uploads/wpsc/downloadables/24C32-Datasheet.pdf) | I2C |
|
||||
| [BBC micro:bit LED matrix](https://github.com/bbcmicrobit/hardware/blob/master/SCH_BBC-Microbit_V1.3B.pdf) | GPIO |
|
||||
| [BH1750 ambient light sensor](https://www.mouser.com/ds/2/348/bh1750fvi-e-186247.pdf) | I2C |
|
||||
| [BlinkM RGB LED](http://thingm.com/fileadmin/thingm/downloads/BlinkM_datasheet.pdf) | I2C |
|
||||
| [BME280 humidity/pressure sensor](https://cdn-shop.adafruit.com/datasheets/BST-BME280_DS001-10.pdf) | I2C |
|
||||
| [BMI160 accelerometer/gyroscope](https://www.bosch-sensortec.com/media/boschsensortec/downloads/datasheets/bst-bmi160-ds000.pdf) | SPI |
|
||||
| [BMP180 barometer](https://cdn-shop.adafruit.com/datasheets/BST-BMP180-DS000-09.pdf) | I2C |
|
||||
| [BMP280 temperature/barometer](https://www.bosch-sensortec.com/media/boschsensortec/downloads/datasheets/bst-bmp280-ds001.pdf) | I2C |
|
||||
| [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 |
|
||||
| [GPS module](https://www.u-blox.com/en/product/neo-6-series) | I2C/UART |
|
||||
| [HC-SR04 Ultrasonic distance sensor](https://cdn.sparkfun.com/datasheets/Sensors/Proximity/HCSR04.pdf) | GPIO |
|
||||
| [HD44780 LCD controller](https://www.sparkfun.com/datasheets/LCD/HD44780.pdf) | GPIO/I2C |
|
||||
| [HUB75 RGB led matrix](https://cdn-learn.adafruit.com/downloads/pdf/32x16-32x32-rgb-led-matrix.pdf) | SPI |
|
||||
| [ILI9341 TFT color display](https://cdn-shop.adafruit.com/datasheets/ILI9341.pdf) | SPI |
|
||||
| [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 |
|
||||
| [LSM6DS3 accelerometer](https://www.st.com/resource/en/datasheet/lsm6ds3.pdf) | I2C |
|
||||
| [MAG3110 magnetometer](https://www.nxp.com/docs/en/data-sheet/MAG3110.pdf) | I2C |
|
||||
| [MAX7219 & MAX7221 display driver](https://datasheets.maximintegrated.com/en/ds/MAX7219-MAX7221.pdf) | SPI |
|
||||
| [MCP23017 port expander](https://ww1.microchip.com/downloads/en/DeviceDoc/20001952C.pdf) | I2C |
|
||||
| [MCP3008 analog to digital converter (ADC)](http://ww1.microchip.com/downloads/en/DeviceDoc/21295d.pdf) | SPI |
|
||||
| [MCP2515 Stand-Alone CAN Controller with SPI Interface](https://ww1.microchip.com/downloads/en/DeviceDoc/MCP2515-Family-Data-Sheet-DS20001801K.pdf) | SPI |
|
||||
| [Microphone - PDM](https://cdn-learn.adafruit.com/assets/assets/000/049/977/original/MP34DT01-M.pdf) | I2S/PDM |
|
||||
| [MMA8653 accelerometer](https://www.nxp.com/docs/en/data-sheet/MMA8653FC.pdf) | I2C |
|
||||
| [MPU6050 accelerometer/gyroscope](https://store.invensense.com/datasheets/invensense/MPU-6050_DataSheet_V3%204.pdf) | I2C |
|
||||
| [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/0_Datasheets/Humidity/Sensirion_Humidity_Sensors_SHT3x_Datasheet_digital.pdf) | I2C |
|
||||
| [SPI NOR Flash Memory](https://en.wikipedia.org/wiki/Flash_memory#NOR_flash) | SPI/QSPI |
|
||||
| [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 |
|
||||
|
||||
## Contributing
|
||||
|
||||
Your contributions are welcome!
|
||||
|
||||
Please take a look at our [CONTRIBUTING.md](./CONTRIBUTING.md) document for details.
|
||||
|
||||
## License
|
||||
|
||||
This project is licensed under the BSD 3-clause license, just like the [Go project](https://golang.org/LICENSE) itself.
|
||||
@@ -1,92 +0,0 @@
|
||||
// Package adt7410 provides a driver for the adt7410 I2C Temperature Sensor.
|
||||
//
|
||||
// Datasheet: https://www.analog.com/media/en/technical-documentation/data-sheets/ADT7410.pdf
|
||||
//
|
||||
package adt7410 // import "tinygo.org/x/drivers/adt7410"
|
||||
|
||||
import (
|
||||
"time"
|
||||
|
||||
"tinygo.org/x/drivers"
|
||||
)
|
||||
|
||||
type Error uint8
|
||||
|
||||
const (
|
||||
ErrInvalidID Error = 0x1
|
||||
)
|
||||
|
||||
func (e Error) Error() string {
|
||||
switch e {
|
||||
case ErrInvalidID:
|
||||
return "Invalid chip ID"
|
||||
default:
|
||||
return "Unknown error"
|
||||
}
|
||||
}
|
||||
|
||||
type Device struct {
|
||||
bus drivers.I2C
|
||||
buf []byte
|
||||
Address uint8
|
||||
}
|
||||
|
||||
// New returns ADT7410 device for the provided I2C bus using default address.
|
||||
// of 0x48 (1001000). To use multiple ADT7410 devices, the last 2 bits of the address
|
||||
// can be set using by connecting to the A1 and A0 pins to VDD or GND (for a
|
||||
// total of up to 4 devices on a I2C bus). Also note that 10k pullups are
|
||||
// recommended for the SDA and SCL lines.
|
||||
func New(i2c drivers.I2C) *Device {
|
||||
return &Device{
|
||||
bus: i2c,
|
||||
buf: make([]byte, 2),
|
||||
Address: Address,
|
||||
}
|
||||
}
|
||||
|
||||
// Configure the ADT7410 device.
|
||||
func (d *Device) Configure() (err error) {
|
||||
// reset the chip
|
||||
d.writeByte(RegReset, 0xFF)
|
||||
time.Sleep(10 * time.Millisecond)
|
||||
return
|
||||
}
|
||||
|
||||
// Connected returns whether sensor has been found.
|
||||
func (d *Device) Connected() bool {
|
||||
data := []byte{0}
|
||||
d.bus.ReadRegister(uint8(d.Address), RegID, data)
|
||||
return data[0]&0xF8 == 0xC8
|
||||
}
|
||||
|
||||
// ReadTemperature returns the temperature in celsius milli degrees (°C/1000)
|
||||
func (d *Device) ReadTemperature() (temperature int32, err error) {
|
||||
return (int32(d.readUint16(RegTempValueMSB)) * 1000) / 128, nil
|
||||
}
|
||||
|
||||
// ReadTempC returns the value in the temperature value register, in Celsius.
|
||||
func (d *Device) ReadTempC() float32 {
|
||||
t := d.readUint16(RegTempValueMSB)
|
||||
return float32(int(t)) / 128.0
|
||||
}
|
||||
|
||||
// ReadTempF returns the value in the temperature value register, in Fahrenheit.
|
||||
func (d *Device) ReadTempF() float32 {
|
||||
return d.ReadTempC()*1.8 + 32.0
|
||||
}
|
||||
|
||||
func (d *Device) writeByte(reg uint8, data byte) {
|
||||
d.buf[0] = reg
|
||||
d.buf[1] = data
|
||||
d.bus.Tx(uint16(d.Address), d.buf, nil)
|
||||
}
|
||||
|
||||
func (d *Device) readByte(reg uint8) byte {
|
||||
d.bus.ReadRegister(d.Address, reg, d.buf)
|
||||
return d.buf[0]
|
||||
}
|
||||
|
||||
func (d *Device) readUint16(reg uint8) uint16 {
|
||||
d.bus.ReadRegister(d.Address, reg, d.buf)
|
||||
return uint16(d.buf[0])<<8 | uint16(d.buf[1])
|
||||
}
|
||||
@@ -1,49 +0,0 @@
|
||||
package adt7410
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
qt "github.com/frankban/quicktest"
|
||||
"tinygo.org/x/drivers/tester"
|
||||
)
|
||||
|
||||
func TestDefaultI2CAddress(t *testing.T) {
|
||||
c := qt.New(t)
|
||||
bus := tester.NewI2CBus(c)
|
||||
dev := New(bus)
|
||||
c.Assert(dev.Address, qt.Equals, uint8(Address))
|
||||
}
|
||||
|
||||
func TestWhoAmI(t *testing.T) {
|
||||
c := qt.New(t)
|
||||
bus := tester.NewI2CBus(c)
|
||||
fake := tester.NewI2CDevice(c, Address)
|
||||
copy(fake.Registers[:], defaultRegisters())
|
||||
bus.AddDevice(fake)
|
||||
|
||||
dev := New(bus)
|
||||
c.Assert(dev.Connected(), qt.Equals, true)
|
||||
|
||||
fake.Registers[RegID] = 0x99
|
||||
c.Assert(dev.Connected(), qt.Equals, false)
|
||||
}
|
||||
|
||||
// defaultRegisters returns the default values for all of the device's registers.
|
||||
// see table 22 on page 27 of the datasheet.
|
||||
func defaultRegisters() []uint8 {
|
||||
return []uint8{
|
||||
RegTempValueMSB: 0,
|
||||
RegTempValueLSB: 0,
|
||||
RegStatus: 0,
|
||||
RegConfig: 0,
|
||||
RegTHIGHMsbReg: 0x20,
|
||||
RegTHIGHLsbReg: 0,
|
||||
RegTLOWMsbReg: 0x05,
|
||||
RegTLOWLsbReg: 0,
|
||||
RegTCRITMsbReg: 0x49,
|
||||
RegTCRITLsbReg: 0x80,
|
||||
RegTHYSTReg: 0x05,
|
||||
RegID: 0xC8,
|
||||
RegReset: 0,
|
||||
}
|
||||
}
|
||||
@@ -1,70 +0,0 @@
|
||||
package adt7410
|
||||
|
||||
// 0x00 Temperature value most significant byte 0x00
|
||||
// 0x01 Temperature value least significant byte 0x00
|
||||
// 0x02 Status 0x00
|
||||
// 0x03 Configuration 0x00
|
||||
// 0x04 THIGH setpoint most significant byte 0x20 (64°C)
|
||||
// 0x05 THIGH setpoint least significant byte 0x00 (64°C)
|
||||
// 0x06 TLOW setpoint most significant byte 0x05 (10°C)
|
||||
// 0x07 TLOW setpoint least significant byte 0x00 (10°C)
|
||||
// 0x08 TCRIT setpoint most significant byte 0x49 (147°C)
|
||||
// 0x09 TCRIT setpoint least significant byte 0x80 (147°C)
|
||||
// 0x0A THYST setpoint 0x05 (5°C)
|
||||
// 0x0B ID 0xCX
|
||||
// 0x0C Reserved 0xXX
|
||||
// 0x0D Reserved 0xXX
|
||||
// 0x2E Reserved 0xXX
|
||||
// 0x2F Software reset 0xXX
|
||||
|
||||
const (
|
||||
// Address is default I2C address.
|
||||
Address = 0x48
|
||||
// Address1 is for first device, aka the default.
|
||||
Address1 = Address
|
||||
// Address2 is for second device.
|
||||
Address2 = 0x49
|
||||
// Address3 is for third device.
|
||||
Address3 = 0x4A
|
||||
// Address4 is for fourth device.
|
||||
Address4 = 0x4B
|
||||
|
||||
// Temperature Value MSB Register
|
||||
RegTempValueMSB = 0x0
|
||||
|
||||
// Temperature Value LSB Register
|
||||
RegTempValueLSB = 0x1
|
||||
|
||||
// Status Register
|
||||
RegStatus = 0x2
|
||||
|
||||
// Config Register
|
||||
RegConfig = 0x3
|
||||
|
||||
// THIGH setpoint most significant byte 0x20 (64°C)
|
||||
RegTHIGHMsbReg = 0x4
|
||||
|
||||
// THIGH setpoint least significant byte 0x00 (64°C)
|
||||
RegTHIGHLsbReg = 0x5
|
||||
|
||||
// TLOW setpoint most significant byte 0x05 (10°C)
|
||||
RegTLOWMsbReg = 0x6
|
||||
|
||||
// TLOW setpoint least significant byte 0x00 (10°C)
|
||||
RegTLOWLsbReg = 0x7
|
||||
|
||||
// TCRIT setpoint most significant byte 0x49 (147°C)
|
||||
RegTCRITMsbReg = 0x8
|
||||
|
||||
// TCRIT setpoint least significant byte 0x80 (147°C)
|
||||
RegTCRITLsbReg = 0x9
|
||||
|
||||
// THYST setpoint 0x05 (5°C)
|
||||
RegTHYSTReg = 0xA
|
||||
|
||||
// ID Register (0xCx)
|
||||
RegID = 0x0B
|
||||
|
||||
// Software Reset Register
|
||||
RegReset = 0x2F
|
||||
)
|
||||
@@ -1,193 +0,0 @@
|
||||
// Package adxl345 provides a driver for the ADXL345 digital accelerometer.
|
||||
//
|
||||
// Datasheet EN: http://www.analog.com/media/en/technical-documentation/data-sheets/ADXL345.pdf
|
||||
//
|
||||
// Datasheet JP: http://www.analog.com/media/jp/technical-documentation/data-sheets/ADXL345_jp.pdf
|
||||
//
|
||||
package adxl345 // import "tinygo.org/x/drivers/adxl345"
|
||||
|
||||
import "tinygo.org/x/drivers"
|
||||
|
||||
type Range uint8
|
||||
type Rate uint8
|
||||
|
||||
// Internal structure for the power configuration
|
||||
type powerCtl struct {
|
||||
link uint8
|
||||
autoSleep uint8
|
||||
measure uint8
|
||||
sleep uint8
|
||||
wakeUp uint8
|
||||
}
|
||||
|
||||
// Internal structure for the sensor's data format configuration
|
||||
type dataFormat struct {
|
||||
selfTest uint8
|
||||
spi uint8
|
||||
intInvert uint8
|
||||
fullRes uint8
|
||||
justify uint8
|
||||
sensorRange Range
|
||||
}
|
||||
|
||||
// Internal structure for the sampling rate configuration
|
||||
type bwRate struct {
|
||||
lowPower uint8
|
||||
rate Rate
|
||||
}
|
||||
|
||||
// Device wraps an I2C connection to a ADXL345 device.
|
||||
type Device struct {
|
||||
bus drivers.I2C
|
||||
Address uint16
|
||||
powerCtl powerCtl
|
||||
dataFormat dataFormat
|
||||
bwRate bwRate
|
||||
}
|
||||
|
||||
// New creates a new ADXL345 connection. The I2C bus must already be
|
||||
// configured.
|
||||
//
|
||||
// This function only creates the Device object, it does not init the device.
|
||||
// To do that you must call the Configure() method on the Device before using it.
|
||||
func New(bus drivers.I2C) Device {
|
||||
return Device{
|
||||
bus: bus,
|
||||
powerCtl: powerCtl{
|
||||
measure: 1,
|
||||
},
|
||||
dataFormat: dataFormat{
|
||||
sensorRange: RANGE_2G,
|
||||
},
|
||||
bwRate: bwRate{
|
||||
lowPower: 1,
|
||||
rate: RATE_100HZ,
|
||||
},
|
||||
Address: AddressLow,
|
||||
}
|
||||
}
|
||||
|
||||
// Configure sets up the device for communication
|
||||
func (d *Device) Configure() {
|
||||
d.bus.WriteRegister(uint8(d.Address), REG_BW_RATE, []byte{d.bwRate.toByte()})
|
||||
d.bus.WriteRegister(uint8(d.Address), REG_POWER_CTL, []byte{d.powerCtl.toByte()})
|
||||
d.bus.WriteRegister(uint8(d.Address), REG_DATA_FORMAT, []byte{d.dataFormat.toByte()})
|
||||
}
|
||||
|
||||
// Halt stops the sensor, values will not updated
|
||||
func (d *Device) Halt() {
|
||||
d.powerCtl.measure = 0
|
||||
d.bus.WriteRegister(uint8(d.Address), REG_POWER_CTL, []byte{d.powerCtl.toByte()})
|
||||
}
|
||||
|
||||
// Restart makes reading the sensor working again after a halt
|
||||
func (d *Device) Restart() {
|
||||
d.powerCtl.measure = 1
|
||||
d.bus.WriteRegister(uint8(d.Address), REG_POWER_CTL, []byte{d.powerCtl.toByte()})
|
||||
}
|
||||
|
||||
// ReadAcceleration reads the current acceleration from the device and returns
|
||||
// it in µg (micro-gravity). When one of the axes is pointing straight to Earth
|
||||
// and the sensor is not moving the returned value will be around 1000000 or
|
||||
// -1000000.
|
||||
func (d *Device) ReadAcceleration() (x int32, y int32, z int32, err error) {
|
||||
rx, ry, rz := d.ReadRawAcceleration()
|
||||
|
||||
x = d.dataFormat.convertToIS(rx)
|
||||
y = d.dataFormat.convertToIS(ry)
|
||||
z = d.dataFormat.convertToIS(rz)
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
// ReadRawAcceleration reads the sensor values and returns the raw x, y and z axis
|
||||
// from the adxl345.
|
||||
func (d *Device) ReadRawAcceleration() (x int32, y int32, z int32) {
|
||||
data := []byte{0, 0, 0, 0, 0, 0}
|
||||
d.bus.ReadRegister(uint8(d.Address), REG_DATAX0, data)
|
||||
|
||||
x = readIntLE(data[0], data[1])
|
||||
y = readIntLE(data[2], data[3])
|
||||
z = readIntLE(data[4], data[5])
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
// UseLowPower sets the ADXL345 to use the low power mode.
|
||||
func (d *Device) UseLowPower(power bool) {
|
||||
if power {
|
||||
d.bwRate.lowPower = 1
|
||||
} else {
|
||||
d.bwRate.lowPower = 0
|
||||
}
|
||||
d.bus.WriteRegister(uint8(d.Address), REG_BW_RATE, []byte{d.bwRate.toByte()})
|
||||
}
|
||||
|
||||
// SetRate change the current rate of the sensor
|
||||
func (d *Device) SetRate(rate Rate) bool {
|
||||
d.bwRate.rate = rate & 0x0F
|
||||
d.bus.WriteRegister(uint8(d.Address), REG_BW_RATE, []byte{d.bwRate.toByte()})
|
||||
return true
|
||||
}
|
||||
|
||||
// SetRange change the current range of the sensor
|
||||
func (d *Device) SetRange(sensorRange Range) bool {
|
||||
d.dataFormat.sensorRange = sensorRange & 0x03
|
||||
d.bus.WriteRegister(uint8(d.Address), REG_DATA_FORMAT, []byte{d.dataFormat.toByte()})
|
||||
return true
|
||||
}
|
||||
|
||||
// convertToIS adjusts the raw values from the adxl345 with the range configuration
|
||||
func (d *dataFormat) convertToIS(rawValue int32) int32 {
|
||||
switch d.sensorRange {
|
||||
case RANGE_2G:
|
||||
return rawValue * 4 // rawValue * 2 * 1000 / 512
|
||||
case RANGE_4G:
|
||||
return rawValue * 8 // rawValue * 4 * 1000 / 512
|
||||
case RANGE_8G:
|
||||
return rawValue * 16 // rawValue * 8 * 1000 / 512
|
||||
case RANGE_16G:
|
||||
return rawValue * 32 // rawValue * 16 * 1000 / 512
|
||||
default:
|
||||
return 0
|
||||
}
|
||||
}
|
||||
|
||||
// toByte returns a byte from the powerCtl configuration
|
||||
func (p *powerCtl) toByte() (bits uint8) {
|
||||
bits = 0x00
|
||||
bits = bits | (p.link << 5)
|
||||
bits = bits | (p.autoSleep << 4)
|
||||
bits = bits | (p.measure << 3)
|
||||
bits = bits | (p.sleep << 2)
|
||||
bits = bits | p.wakeUp
|
||||
|
||||
return bits
|
||||
}
|
||||
|
||||
// toByte returns a byte from the dataFormat configuration
|
||||
func (d *dataFormat) toByte() (bits uint8) {
|
||||
bits = 0x00
|
||||
bits = bits | (d.selfTest << 7)
|
||||
bits = bits | (d.spi << 6)
|
||||
bits = bits | (d.intInvert << 5)
|
||||
bits = bits | (d.fullRes << 3)
|
||||
bits = bits | (d.justify << 2)
|
||||
bits = bits | uint8(d.sensorRange)
|
||||
|
||||
return bits
|
||||
}
|
||||
|
||||
// toByte returns a byte from the bwRate configuration
|
||||
func (b *bwRate) toByte() (bits uint8) {
|
||||
bits = 0x00
|
||||
bits = bits | (b.lowPower << 4)
|
||||
bits = bits | uint8(b.rate)
|
||||
|
||||
return bits
|
||||
}
|
||||
|
||||
// readInt converts two bytes to int16
|
||||
func readIntLE(msb byte, lsb byte) int32 {
|
||||
return int32(uint16(msb) | uint16(lsb)<<8)
|
||||
}
|
||||
@@ -1,61 +0,0 @@
|
||||
package adxl345
|
||||
|
||||
const AddressLow = 0x53
|
||||
const AddressHigh = 0x1D
|
||||
|
||||
const (
|
||||
// Data rate
|
||||
RATE_3200HZ Rate = 0x0F // 3200 Hz
|
||||
RATE_1600HZ Rate = 0x0E // 1600 Hz
|
||||
RATE_800HZ Rate = 0x0D // 800 Hz
|
||||
RATE_400HZ Rate = 0x0C // 400 Hz
|
||||
RATE_200HZ Rate = 0x0B // 200 Hz
|
||||
RATE_100HZ Rate = 0x0A // 100 Hz
|
||||
RATE_50HZ Rate = 0x09 // 50 Hz
|
||||
RATE_25HZ Rate = 0x08 // 25 Hz
|
||||
RATE_12_5HZ Rate = 0x07 // 12.5 Hz
|
||||
RATE_6_25HZ Rate = 0x06 // 6.25 Hz
|
||||
RATE_3_13HZ Rate = 0x05 // 3.13 Hz
|
||||
RATE_1_56HZ Rate = 0x04 // 1.56 Hz
|
||||
RATE_0_78HZ Rate = 0x03 // 0.78 Hz
|
||||
RATE_0_39HZ Rate = 0x02 // 0.39 Hz
|
||||
RATE_0_20HZ Rate = 0x01 // 0.20 Hz
|
||||
RATE_0_10HZ Rate = 0x00 // 0.10 Hz
|
||||
|
||||
// Data range
|
||||
RANGE_2G Range = 0x00 // +-2 g
|
||||
RANGE_4G Range = 0x01 // +-4 g
|
||||
RANGE_8G Range = 0x02 // +-8 g
|
||||
RANGE_16G Range = 0x03 // +-16 g)
|
||||
|
||||
REG_DEVID = 0x00 // R, 11100101, Device ID
|
||||
REG_THRESH_TAP = 0x1D // R/W, 00000000, Tap threshold
|
||||
REG_OFSX = 0x1E // R/W, 00000000, X-axis offset
|
||||
REG_OFSY = 0x1F // R/W, 00000000, Y-axis offset
|
||||
REG_OFSZ = 0x20 // R/W, 00000000, Z-axis offset
|
||||
REG_DUR = 0x21 // R/W, 00000000, Tap duration
|
||||
REG_LATENT = 0x22 // R/W, 00000000, Tap latency
|
||||
REG_WINDOW = 0x23 // R/W, 00000000, Tap window
|
||||
REG_THRESH_ACT = 0x24 // R/W, 00000000, Activity threshold
|
||||
REG_THRESH_INACT = 0x25 // R/W, 00000000, Inactivity threshold
|
||||
REG_TIME_INACT = 0x26 // R/W, 00000000, Inactivity time
|
||||
REG_ACT_INACT_CTL = 0x27 // R/W, 00000000, Axis enable control for activity and inactiv ity detection
|
||||
REG_THRESH_FF = 0x28 // R/W, 00000000, Free-fall threshold
|
||||
REG_TIME_FF = 0x29 // R/W, 00000000, Free-fall time
|
||||
REG_TAP_AXES = 0x2A // R/W, 00000000, Axis control for single tap/double tap
|
||||
REG_ACT_TAP_STATUS = 0x2B // R, 00000000, Source of single tap/double tap
|
||||
REG_BW_RATE = 0x2C // R/W, 00001010, Data rate and power mode control
|
||||
REG_POWER_CTL = 0x2D // R/W, 00000000, Power-saving features control
|
||||
REG_INT_ENABLE = 0x2E // R/W, 00000000, Interrupt enable control
|
||||
REG_INT_MAP = 0x2F // R/W, 00000000, Interrupt mapping control
|
||||
REG_INT_SOUCE = 0x30 // R, 00000010, Source of interrupts
|
||||
REG_DATA_FORMAT = 0x31 // R/W, 00000000, Data format control
|
||||
REG_DATAX0 = 0x32 // R, 00000000, X-Axis Data 0
|
||||
REG_DATAX1 = 0x33 // R, 00000000, X-Axis Data 1
|
||||
REG_DATAY0 = 0x34 // R, 00000000, Y-Axis Data 0
|
||||
REG_DATAY1 = 0x35 // R, 00000000, Y-Axis Data 1
|
||||
REG_DATAZ0 = 0x36 // R, 00000000, Z-Axis Data 0
|
||||
REG_DATAZ1 = 0x37 // R, 00000000, Z-Axis Data 1
|
||||
REG_FIFO_CTL = 0x38 // R/W, 00000000, FIFO control
|
||||
REG_FIFO_STATUS = 0x39 // R, 00000000, FIFO status
|
||||
)
|
||||
-108
@@ -1,108 +0,0 @@
|
||||
package aht20
|
||||
|
||||
import (
|
||||
"time"
|
||||
|
||||
"tinygo.org/x/drivers"
|
||||
)
|
||||
|
||||
// Device wraps an I2C connection to an AHT20 device.
|
||||
type Device struct {
|
||||
bus drivers.I2C
|
||||
Address uint16
|
||||
humidity uint32
|
||||
temp uint32
|
||||
}
|
||||
|
||||
// New creates a new AHT20 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 the device
|
||||
func (d *Device) Configure() {
|
||||
// Check initialization state
|
||||
status := d.Status()
|
||||
if status&0x08 == 1 {
|
||||
// Device is initialized
|
||||
return
|
||||
}
|
||||
|
||||
// Force initialization
|
||||
d.bus.Tx(d.Address, []byte{CMD_INITIALIZE, 0x08, 0x00}, nil)
|
||||
time.Sleep(10 * time.Millisecond)
|
||||
}
|
||||
|
||||
// Reset the device
|
||||
func (d *Device) Reset() {
|
||||
d.bus.Tx(d.Address, []byte{CMD_SOFTRESET}, nil)
|
||||
}
|
||||
|
||||
// Status of the device
|
||||
func (d *Device) Status() byte {
|
||||
data := []byte{0}
|
||||
|
||||
d.bus.Tx(d.Address, []byte{CMD_STATUS}, data)
|
||||
|
||||
return data[0]
|
||||
}
|
||||
|
||||
// Read the temperature and humidity
|
||||
//
|
||||
// The actual temperature and humidity are stored
|
||||
// and can be accessed using `Temp` and `Humidity`.
|
||||
func (d *Device) Read() error {
|
||||
d.bus.Tx(d.Address, []byte{CMD_TRIGGER, 0x33, 0x00}, nil)
|
||||
|
||||
data := []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
|
||||
for retry := 0; retry < 3; retry++ {
|
||||
time.Sleep(80 * time.Millisecond)
|
||||
err := d.bus.Tx(d.Address, nil, data)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// If measurement complete, store values
|
||||
if data[0]&0x04 != 0 && data[0]&0x80 == 0 {
|
||||
d.humidity = uint32(data[1])<<12 | uint32(data[2])<<4 | uint32(data[3])>>4
|
||||
d.temp = (uint32(data[3])&0xF)<<16 | uint32(data[4])<<8 | uint32(data[5])
|
||||
return nil
|
||||
}
|
||||
}
|
||||
|
||||
return ErrTimeout
|
||||
}
|
||||
|
||||
func (d *Device) RawHumidity() uint32 {
|
||||
return d.humidity
|
||||
}
|
||||
|
||||
func (d *Device) RawTemp() uint32 {
|
||||
return d.temp
|
||||
}
|
||||
|
||||
func (d *Device) RelHumidity() float32 {
|
||||
return (float32(d.humidity) * 100) / 0x100000
|
||||
}
|
||||
|
||||
func (d *Device) DeciRelHumidity() int32 {
|
||||
return (int32(d.humidity) * 1000) / 0x100000
|
||||
}
|
||||
|
||||
// Temperature in degrees celsius
|
||||
func (d *Device) Celsius() float32 {
|
||||
return (float32(d.temp*200.0) / 0x100000) - 50
|
||||
}
|
||||
|
||||
// Temperature in mutiples of one tenth of a degree celsius
|
||||
//
|
||||
// Using this method avoids floating point calculations.
|
||||
func (d *Device) DeciCelsius() int32 {
|
||||
return ((int32(d.temp) * 2000) / 0x100000) - 500
|
||||
}
|
||||
@@ -1,74 +0,0 @@
|
||||
package aht20
|
||||
|
||||
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(uint8(dev.Address), qt.Equals, uint8(Address))
|
||||
}
|
||||
|
||||
func TestInitialization(t *testing.T) {
|
||||
c := qt.New(t)
|
||||
bus := tester.NewI2CBus(c)
|
||||
fdev := tester.NewI2CDeviceCmd(c, Address)
|
||||
fdev.Commands = defaultCommands()
|
||||
bus.AddDevice(fdev)
|
||||
|
||||
// Set status to uninitialized to force initialization
|
||||
fdev.Commands[CMD_STATUS].Response[0] = 0x0C
|
||||
|
||||
dev := New(bus)
|
||||
dev.Configure()
|
||||
|
||||
// Check initialization command invoked
|
||||
c.Assert(fdev.Commands[CMD_INITIALIZE].Invocations > 0, qt.Equals, true)
|
||||
}
|
||||
|
||||
func TestRead(t *testing.T) {
|
||||
c := qt.New(t)
|
||||
bus := tester.NewI2CBus(c)
|
||||
fdev := tester.NewI2CDeviceCmd(c, Address)
|
||||
fdev.Commands = defaultCommands()
|
||||
bus.AddDevice(fdev)
|
||||
|
||||
dev := New(bus)
|
||||
dev.Read()
|
||||
|
||||
// Should be 25deg (250 decidegrees)
|
||||
c.Assert(dev.DeciCelsius(), qt.Equals, int32(250))
|
||||
|
||||
// Should be 36.3% (363 decipercent)
|
||||
c.Assert(dev.DeciRelHumidity(), qt.Equals, int32(363))
|
||||
}
|
||||
|
||||
func defaultCommands() map[uint8]*tester.Cmd {
|
||||
return map[uint8]*tester.Cmd{
|
||||
CMD_INITIALIZE: {
|
||||
Command: []byte{0xBE},
|
||||
Mask: []byte{0xFF},
|
||||
Response: []byte{},
|
||||
},
|
||||
CMD_TRIGGER: {
|
||||
Command: []byte{0xAC, 0x33, 0x00},
|
||||
Mask: []byte{0xFF, 0xFF, 0xFF},
|
||||
Response: []byte{0x1C, 0x5D, 0x10, 0x66, 0x01, 0xD2, 0x93},
|
||||
},
|
||||
CMD_SOFTRESET: {
|
||||
Command: []byte{0xBA},
|
||||
Mask: []byte{0xFF},
|
||||
Response: []byte{},
|
||||
},
|
||||
CMD_STATUS: {
|
||||
Command: []byte{0x71},
|
||||
Mask: []byte{0xFF},
|
||||
Response: []byte{0x1C},
|
||||
},
|
||||
}
|
||||
}
|
||||
@@ -1,20 +0,0 @@
|
||||
package aht20
|
||||
|
||||
import "errors"
|
||||
|
||||
const (
|
||||
Address = 0x38
|
||||
|
||||
CMD_INITIALIZE = 0xBE
|
||||
CMD_STATUS = 0x71
|
||||
CMD_TRIGGER = 0xAC
|
||||
CMD_SOFTRESET = 0xBA
|
||||
|
||||
STATUS_BUSY = 0x80
|
||||
STATUS_CALIBRATED = 0x08
|
||||
)
|
||||
|
||||
var (
|
||||
ErrBusy = errors.New("device busy")
|
||||
ErrTimeout = errors.New("timeout")
|
||||
)
|
||||
@@ -1,159 +0,0 @@
|
||||
// Package amg88xx provides a driver for the AMG88XX Thermal Camera
|
||||
//
|
||||
// Datasheet:
|
||||
// https://cdn-learn.adafruit.com/assets/assets/000/043/261/original/Grid-EYE_SPECIFICATIONS%28Reference%29.pdf
|
||||
package amg88xx // import "tinygo.org/x/drivers/amg88xx"
|
||||
|
||||
import (
|
||||
"time"
|
||||
|
||||
"tinygo.org/x/drivers"
|
||||
)
|
||||
|
||||
// Device wraps an I2C connection to a AMG88xx device.
|
||||
type Device struct {
|
||||
bus drivers.I2C
|
||||
Address uint16
|
||||
data []uint8
|
||||
interruptMode InterruptMode
|
||||
interruptEnable uint8
|
||||
}
|
||||
|
||||
type InterruptMode uint8
|
||||
|
||||
type Config struct {
|
||||
}
|
||||
|
||||
// New creates a new AMG88xx connection. The I2C bus must already be
|
||||
// configured.
|
||||
//
|
||||
// This function only creates the Device object, it does not touch the device.
|
||||
func New(bus drivers.I2C) Device {
|
||||
return Device{
|
||||
bus: bus,
|
||||
Address: AddressHigh,
|
||||
}
|
||||
}
|
||||
|
||||
// Configure sets up the device for communication
|
||||
func (d *Device) Configure(cfg Config) {
|
||||
d.data = make([]uint8, 128)
|
||||
|
||||
d.SetPCTL(NORMAL_MODE)
|
||||
d.SetReset(INITIAL_RESET)
|
||||
d.SetFrameRate(FPS_10)
|
||||
|
||||
time.Sleep(100 * time.Millisecond)
|
||||
}
|
||||
|
||||
// ReadPixels returns the 64 values (8x8 grid) of the sensor converted to millicelsius
|
||||
func (d *Device) ReadPixels(buffer *[64]int16) {
|
||||
d.bus.ReadRegister(uint8(d.Address), PIXEL_OFFSET, d.data)
|
||||
for i := 0; i < 64; i++ {
|
||||
buffer[i] = int16((uint16(d.data[2*i+1]) << 8) | uint16(d.data[2*i]))
|
||||
if (buffer[i] & (1 << 11)) > 0 { // temperature negative
|
||||
buffer[i] &= ^(1 << 11)
|
||||
buffer[i] = -buffer[i]
|
||||
}
|
||||
buffer[i] *= PIXEL_TEMP_CONVERSION
|
||||
}
|
||||
}
|
||||
|
||||
// SetPCTL sets the PCTL
|
||||
func (d *Device) SetPCTL(pctl uint8) {
|
||||
d.bus.WriteRegister(uint8(d.Address), PCTL, []byte{pctl})
|
||||
}
|
||||
|
||||
// SetReset sets the reset value
|
||||
func (d *Device) SetReset(rst uint8) {
|
||||
d.bus.WriteRegister(uint8(d.Address), RST, []byte{rst})
|
||||
}
|
||||
|
||||
// SetFrameRate configures the frame rate
|
||||
func (d *Device) SetFrameRate(framerate uint8) {
|
||||
d.bus.WriteRegister(uint8(d.Address), FPSC, []byte{framerate & 0x01})
|
||||
}
|
||||
|
||||
// SetMovingAverageMode sets the moving average mode
|
||||
func (d *Device) SetMovingAverageMode(mode bool) {
|
||||
var value uint8
|
||||
if mode {
|
||||
value = 1
|
||||
}
|
||||
d.bus.WriteRegister(uint8(d.Address), AVE, []byte{value << 5})
|
||||
}
|
||||
|
||||
// SetInterruptLevels sets the interrupt levels
|
||||
func (d *Device) SetInterruptLevels(high int16, low int16) {
|
||||
d.SetInterruptLevelsHysteresis(high, low, (high*95)/100)
|
||||
}
|
||||
|
||||
// SetInterruptLevelsHysteresis sets the interrupt levels with hysteresis
|
||||
func (d *Device) SetInterruptLevelsHysteresis(high int16, low int16, hysteresis int16) {
|
||||
high = high / PIXEL_TEMP_CONVERSION
|
||||
if high < -4095 {
|
||||
high = -4095
|
||||
}
|
||||
if high > 4095 {
|
||||
high = 4095
|
||||
}
|
||||
d.bus.WriteRegister(uint8(d.Address), INTHL, []byte{uint8(high & 0xFF)})
|
||||
d.bus.WriteRegister(uint8(d.Address), INTHL, []byte{uint8((high & 0xFF) >> 4)})
|
||||
|
||||
low = low / PIXEL_TEMP_CONVERSION
|
||||
if low < -4095 {
|
||||
low = -4095
|
||||
}
|
||||
if low > 4095 {
|
||||
low = 4095
|
||||
}
|
||||
d.bus.WriteRegister(uint8(d.Address), INTHL, []byte{uint8(low & 0xFF)})
|
||||
d.bus.WriteRegister(uint8(d.Address), INTHL, []byte{uint8((low & 0xFF) >> 4)})
|
||||
|
||||
hysteresis = hysteresis / PIXEL_TEMP_CONVERSION
|
||||
if hysteresis < -4095 {
|
||||
hysteresis = -4095
|
||||
}
|
||||
if hysteresis > 4095 {
|
||||
hysteresis = 4095
|
||||
}
|
||||
d.bus.WriteRegister(uint8(d.Address), INTHL, []byte{uint8(hysteresis & 0xFF)})
|
||||
d.bus.WriteRegister(uint8(d.Address), INTHL, []byte{uint8((hysteresis & 0xFF) >> 4)})
|
||||
}
|
||||
|
||||
// EnableInterrupt enables the interrupt pin on the device
|
||||
func (d *Device) EnableInterrupt() {
|
||||
d.interruptEnable = 1
|
||||
d.bus.WriteRegister(uint8(d.Address), INTC, []byte{((uint8(d.interruptMode) << 1) | d.interruptEnable) & 0x03})
|
||||
}
|
||||
|
||||
// DisableInterrupt disables the interrupt pin on the device
|
||||
func (d *Device) DisableInterrupt() {
|
||||
d.interruptEnable = 0
|
||||
d.bus.WriteRegister(uint8(d.Address), INTC, []byte{((uint8(d.interruptMode) << 1) | d.interruptEnable) & 0x03})
|
||||
}
|
||||
|
||||
// SetInterruptMode sets the interrupt mode
|
||||
func (d *Device) SetInterruptMode(mode InterruptMode) {
|
||||
d.interruptMode = mode
|
||||
d.bus.WriteRegister(uint8(d.Address), INTC, []byte{((uint8(d.interruptMode) << 1) | d.interruptEnable) & 0x03})
|
||||
}
|
||||
|
||||
// GetInterrupt reads the state of the triggered interrupts
|
||||
func (d *Device) GetInterrupt() []uint8 {
|
||||
data := make([]uint8, 8)
|
||||
d.bus.ReadRegister(uint8(d.Address), INT_OFFSET, data)
|
||||
return data
|
||||
}
|
||||
|
||||
// ClearInterrupt clears any triggered interrupts
|
||||
func (d *Device) ClearInterrupt() {
|
||||
d.SetReset(FLAG_RESET)
|
||||
}
|
||||
|
||||
// ReadThermistor reads the onboard thermistor
|
||||
func (d *Device) ReadThermistor() int16 {
|
||||
data := make([]uint8, 2)
|
||||
d.bus.ReadRegister(uint8(d.Address), TTHL, data)
|
||||
return (int16((uint16(data[1])<<8)|uint16(data[0])) * THERMISTOR_CONVERSION) / 10
|
||||
}
|
||||
@@ -1,46 +0,0 @@
|
||||
package amg88xx
|
||||
|
||||
// The I2C address which this device listens to.
|
||||
const AddressHigh = 0x69
|
||||
const AddressLow = 0x68
|
||||
|
||||
const (
|
||||
PCTL = 0x00
|
||||
RST = 0x01
|
||||
FPSC = 0x02
|
||||
INTC = 0x03
|
||||
STAT = 0x04
|
||||
SCLR = 0x05
|
||||
AVE = 0x07
|
||||
INTHL = 0x08
|
||||
INTHH = 0x09
|
||||
INTLL = 0x0A
|
||||
INTLH = 0x0B
|
||||
IHYSL = 0x0C
|
||||
IHYSH = 0x0D
|
||||
TTHL = 0x0E
|
||||
TTHH = 0x0F
|
||||
INT_OFFSET = 0x010
|
||||
PIXEL_OFFSET = 0x80
|
||||
|
||||
// power modes
|
||||
NORMAL_MODE = 0x00
|
||||
SLEEP_MODE = 0x01
|
||||
STAND_BY_60 = 0x20
|
||||
STAND_BY_10 = 0x21
|
||||
|
||||
// resets
|
||||
FLAG_RESET = 0x30
|
||||
INITIAL_RESET = 0x3F
|
||||
|
||||
// frame rates
|
||||
FPS_10 = 0x00
|
||||
FPS_1 = 0x01
|
||||
|
||||
// interrupt modes
|
||||
DIFFERENCE InterruptMode = 0x00
|
||||
ABSOLUTE_VALUE InterruptMode = 0x01
|
||||
|
||||
PIXEL_TEMP_CONVERSION = 250
|
||||
THERMISTOR_CONVERSION = 625
|
||||
)
|
||||
@@ -1,98 +0,0 @@
|
||||
// Package apa102 implements a driver for the APA102 SPI LED.
|
||||
//
|
||||
// Datasheet: https://cdn-shop.adafruit.com/product-files/2343/APA102C.pdf
|
||||
package apa102 // import "tinygo.org/x/drivers/apa102"
|
||||
|
||||
import (
|
||||
"image/color"
|
||||
"machine"
|
||||
|
||||
"tinygo.org/x/drivers"
|
||||
)
|
||||
|
||||
const (
|
||||
// BGR aka "Blue Green Red" is the current APA102 LED color order.
|
||||
BGR = iota
|
||||
|
||||
// BRG aka "Blue Red Green" is the typical APA102 color order from 2015-2017.
|
||||
BRG
|
||||
|
||||
// GRB aka "Green Red Blue" is the typical APA102 color order from pre-2015.
|
||||
GRB
|
||||
)
|
||||
|
||||
var startFrame = []byte{0x00, 0x00, 0x00, 0x00}
|
||||
|
||||
// Device wraps APA102 SPI LEDs.
|
||||
type Device struct {
|
||||
bus drivers.SPI
|
||||
Order int
|
||||
buf [4]byte
|
||||
}
|
||||
|
||||
// New returns a new APA102 driver. Pass in a fully configured SPI bus.
|
||||
func New(b drivers.SPI) *Device {
|
||||
return &Device{bus: b, Order: BGR}
|
||||
}
|
||||
|
||||
// NewSoftwareSPI returns a new APA102 driver that will use a software based
|
||||
// implementation of the SPI protocol.
|
||||
func NewSoftwareSPI(sckPin, sdoPin machine.Pin, delay uint32) *Device {
|
||||
return New(&bbSPI{SCK: sckPin, SDO: sdoPin, Delay: delay})
|
||||
}
|
||||
|
||||
// WriteColors writes the given RGBA color slice out using the APA102 protocol.
|
||||
// The A value (Alpha channel) is used for brightness, set to 0xff (255) for maximum.
|
||||
func (d *Device) WriteColors(cs []color.RGBA) (n int, err error) {
|
||||
d.startFrame()
|
||||
|
||||
// write data
|
||||
for _, c := range cs {
|
||||
// brightness is scaled to 5 bit value
|
||||
d.buf[0] = 0xe0 | (c.A >> 3)
|
||||
|
||||
// set the colors
|
||||
switch d.Order {
|
||||
case BRG:
|
||||
d.buf[1] = c.B
|
||||
d.buf[2] = c.R
|
||||
d.buf[3] = c.G
|
||||
case GRB:
|
||||
d.buf[1] = c.G
|
||||
d.buf[2] = c.R
|
||||
d.buf[3] = c.B
|
||||
case BGR:
|
||||
d.buf[1] = c.B
|
||||
d.buf[2] = c.G
|
||||
d.buf[3] = c.R
|
||||
}
|
||||
d.bus.Tx(d.buf[:], nil)
|
||||
}
|
||||
|
||||
d.endFrame(len(cs))
|
||||
|
||||
return len(cs), nil
|
||||
}
|
||||
|
||||
// Write the raw bytes using the APA102 protocol.
|
||||
func (d *Device) Write(buf []byte) (n int, err error) {
|
||||
d.startFrame()
|
||||
d.bus.Tx(buf, nil)
|
||||
d.endFrame(len(buf) / 4)
|
||||
|
||||
return len(buf), nil
|
||||
}
|
||||
|
||||
// startFrame sends the start bytes for a strand of LEDs.
|
||||
func (d *Device) startFrame() {
|
||||
d.bus.Tx(startFrame, nil)
|
||||
}
|
||||
|
||||
// endFrame sends the end frame marker with one extra bit per LED so
|
||||
// long strands of LEDs receive the necessary termination for updates.
|
||||
// See https://cpldcpu.wordpress.com/2014/11/30/understanding-the-apa102-superled/
|
||||
func (d *Device) endFrame(count int) {
|
||||
for i := 0; i < count/16; i++ {
|
||||
d.bus.Transfer(0xff)
|
||||
}
|
||||
}
|
||||
@@ -1,70 +0,0 @@
|
||||
package apa102
|
||||
|
||||
import "machine"
|
||||
|
||||
// bbSPI is a dumb bit-bang implementation of SPI protocol that is hardcoded
|
||||
// to mode 0 and ignores trying to receive data. Just enough for the APA102.
|
||||
// Note: making this unexported for now because it is probable not suitable
|
||||
// most purposes other than the APA102 package. It might be desirable to make
|
||||
// this more generic and include it in the TinyGo "machine" package instead.
|
||||
type bbSPI struct {
|
||||
SCK machine.Pin
|
||||
SDO machine.Pin
|
||||
Delay uint32
|
||||
}
|
||||
|
||||
// Configure sets up the SCK and SDO pins as outputs and sets them low
|
||||
func (s *bbSPI) Configure() {
|
||||
s.SCK.Configure(machine.PinConfig{Mode: machine.PinOutput})
|
||||
s.SDO.Configure(machine.PinConfig{Mode: machine.PinOutput})
|
||||
s.SCK.Low()
|
||||
s.SDO.Low()
|
||||
if s.Delay == 0 {
|
||||
s.Delay = 1
|
||||
}
|
||||
}
|
||||
|
||||
// Tx matches signature of machine.SPI.Tx() and is used to send multiple bytes.
|
||||
// The r slice is ignored and no error will ever be returned.
|
||||
func (s *bbSPI) Tx(w []byte, r []byte) error {
|
||||
s.Configure()
|
||||
for _, b := range w {
|
||||
s.Transfer(b)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// delay represents a quarter of the clock cycle
|
||||
func (s *bbSPI) delay() {
|
||||
for i := uint32(0); i < s.Delay; {
|
||||
i++
|
||||
}
|
||||
}
|
||||
|
||||
// Transfer matches signature of machine.SPI.Transfer() and is used to send a
|
||||
// single byte. The received data is ignored and no error will ever be returned.
|
||||
func (s *bbSPI) Transfer(b byte) (byte, error) {
|
||||
for i := uint8(0); i < 8; i++ {
|
||||
|
||||
// half clock cycle high to start
|
||||
s.SCK.High()
|
||||
s.delay()
|
||||
|
||||
// write the value to SDO (MSB first)
|
||||
if b&(1<<(7-i)) == 0 {
|
||||
s.SDO.Low()
|
||||
} else {
|
||||
s.SDO.High()
|
||||
}
|
||||
s.delay()
|
||||
|
||||
// half clock cycle low
|
||||
s.SCK.Low()
|
||||
s.delay()
|
||||
|
||||
// for actual SPI would try to read the SDI value here
|
||||
s.delay()
|
||||
}
|
||||
|
||||
return 0, nil
|
||||
}
|
||||
@@ -1,172 +0,0 @@
|
||||
// Package at24cx provides a driver for the AT24C32/64/128/256/512 2-wire serial EEPROM
|
||||
//
|
||||
// Datasheet:
|
||||
// https://www.openimpulse.com/blog/wp-content/uploads/wpsc/downloadables/24C32-Datasheet.pdf
|
||||
package at24cx // import "tinygo.org/x/drivers/at24cx"
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"time"
|
||||
|
||||
"tinygo.org/x/drivers"
|
||||
)
|
||||
|
||||
// Device wraps an I2C connection to a DS3231 device.
|
||||
type Device struct {
|
||||
bus drivers.I2C
|
||||
Address uint16
|
||||
pageSize uint16
|
||||
currentRAMAddress uint16
|
||||
startRAMAddress uint16
|
||||
endRAMAddress uint16
|
||||
}
|
||||
|
||||
type Config struct {
|
||||
PageSize uint16
|
||||
StartRAMAddress uint16
|
||||
EndRAMAddress uint16
|
||||
}
|
||||
|
||||
// New creates a new AT24C32/64 connection. The I2C bus must already be
|
||||
// configured.
|
||||
//
|
||||
// This function only creates the Device object, it does not touch the device.
|
||||
func New(bus drivers.I2C) Device {
|
||||
return Device{
|
||||
bus: bus,
|
||||
Address: Address,
|
||||
}
|
||||
}
|
||||
|
||||
// Configure sets up the device for communication
|
||||
func (d *Device) Configure(cfg Config) {
|
||||
if cfg.PageSize == 0 {
|
||||
d.pageSize = 32
|
||||
} else {
|
||||
d.pageSize = cfg.PageSize
|
||||
}
|
||||
if cfg.EndRAMAddress == 0 {
|
||||
d.endRAMAddress = 4096
|
||||
} else {
|
||||
d.endRAMAddress = cfg.EndRAMAddress
|
||||
}
|
||||
d.startRAMAddress = cfg.StartRAMAddress
|
||||
}
|
||||
|
||||
// WriteByte writes a byte at the specified address
|
||||
func (d *Device) WriteByte(eepromAddress uint16, value uint8) error {
|
||||
address := []uint8{
|
||||
uint8((eepromAddress >> 8) & 0xFF),
|
||||
uint8(eepromAddress & 0xFF),
|
||||
value,
|
||||
}
|
||||
return d.bus.Tx(d.Address, address, nil)
|
||||
}
|
||||
|
||||
// ReadByte reads the byte at the specified address
|
||||
func (d *Device) ReadByte(eepromAddress uint16) (uint8, error) {
|
||||
address := []uint8{
|
||||
uint8(eepromAddress >> 8),
|
||||
uint8(eepromAddress & 0xFF),
|
||||
}
|
||||
data := make([]uint8, 1)
|
||||
err := d.bus.Tx(d.Address, address, data)
|
||||
return data[0], err
|
||||
}
|
||||
|
||||
// WriteAt writes a byte array at the specified address
|
||||
func (d *Device) WriteAt(data []byte, offset int64) (n int, err error) {
|
||||
return d.writeAt(data, uint16(offset))
|
||||
}
|
||||
|
||||
// writeAt writes a byte array at the specified address
|
||||
func (d *Device) writeAt(data []byte, offset uint16) (n int, err error) {
|
||||
values := make([]uint8, 32)
|
||||
dataLeft := uint16(len(data))
|
||||
d.currentRAMAddress = offset
|
||||
offset = 0
|
||||
var offsetPage uint16
|
||||
var chunkLength uint16
|
||||
for dataLeft > 0 {
|
||||
offsetPage = d.currentRAMAddress % d.pageSize
|
||||
if dataLeft < 30 { // The 32K/64K EEPROM is capable of 32-byte page writes and we're using 2 for the address
|
||||
chunkLength = dataLeft
|
||||
} else {
|
||||
chunkLength = 30
|
||||
}
|
||||
if (d.pageSize - offsetPage) < chunkLength {
|
||||
chunkLength = d.pageSize - offsetPage
|
||||
}
|
||||
for i := uint16(0); i < chunkLength; i++ {
|
||||
values[2+i] = data[offset+i]
|
||||
}
|
||||
values[0] = uint8(d.currentRAMAddress >> 8)
|
||||
values[1] = uint8(d.currentRAMAddress & 0xFF)
|
||||
err := d.bus.Tx(d.Address, values[:chunkLength+2], nil)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
dataLeft -= chunkLength
|
||||
offset += chunkLength
|
||||
if d.endRAMAddress-chunkLength < d.currentRAMAddress {
|
||||
d.currentRAMAddress = d.startRAMAddress + (d.currentRAMAddress+uint16(len(data)))%d.endRAMAddress
|
||||
} else {
|
||||
d.currentRAMAddress += chunkLength
|
||||
}
|
||||
time.Sleep(2 * time.Millisecond) // writing again too soon will block the device
|
||||
}
|
||||
return len(data), nil
|
||||
}
|
||||
|
||||
// ReadAt reads the bytes at the specified address
|
||||
func (d *Device) ReadAt(data []byte, offset int64) (n int, err error) {
|
||||
return d.readAt(data, uint16(offset))
|
||||
}
|
||||
|
||||
// readAt reads the bytes at the specified address
|
||||
func (d *Device) readAt(data []byte, offset uint16) (n int, err error) {
|
||||
address := []uint8{
|
||||
uint8((offset >> 8) & 0xFF),
|
||||
uint8(offset & 0xFF),
|
||||
}
|
||||
err = d.bus.Tx(d.Address, address, data)
|
||||
|
||||
if d.endRAMAddress-uint16(len(data)) < offset {
|
||||
d.currentRAMAddress = d.startRAMAddress + (offset+uint16(len(data)))%d.endRAMAddress
|
||||
} else {
|
||||
d.currentRAMAddress = offset + uint16(len(data))
|
||||
}
|
||||
return len(data), err
|
||||
}
|
||||
|
||||
// Seek sets the offset for the next Read or Write on SRAM to offset, interpreted
|
||||
// according to whence: 0 means relative to the origin of the SRAM, 1 means
|
||||
// relative to the current offset, and 2 means relative to the end.
|
||||
// returns new offset and error, if any
|
||||
func (d *Device) Seek(offset int64, whence int) (int64, error) {
|
||||
w := uint16(0)
|
||||
switch whence {
|
||||
case 0:
|
||||
w = d.startRAMAddress
|
||||
case 1:
|
||||
w = d.currentRAMAddress
|
||||
case 2:
|
||||
w = d.endRAMAddress
|
||||
default:
|
||||
return 0, errors.New("invalid whence")
|
||||
}
|
||||
d.currentRAMAddress = w + uint16(offset)
|
||||
return int64(d.currentRAMAddress), nil
|
||||
}
|
||||
|
||||
// Write writes len(data) bytes to SRAM
|
||||
// returns number of bytes written and error, if any
|
||||
func (d *Device) Write(data []byte) (n int, err error) {
|
||||
return d.writeAt(data, d.currentRAMAddress)
|
||||
}
|
||||
|
||||
// Read reads len(data) from SRAM
|
||||
// returns number of bytes written and error, if any
|
||||
func (d *Device) Read(data []uint8) (n int, err error) {
|
||||
return d.readAt(data, d.currentRAMAddress)
|
||||
}
|
||||
@@ -1,4 +0,0 @@
|
||||
package at24cx
|
||||
|
||||
// The I2C address which this device listens to.
|
||||
const Address = 0x57
|
||||
@@ -1,72 +0,0 @@
|
||||
// Package bh1750 provides a driver for the BH1750 digital Ambient Light
|
||||
//
|
||||
// Datasheet:
|
||||
// https://www.mouser.com/ds/2/348/bh1750fvi-e-186247.pdf
|
||||
//
|
||||
package bh1750 // import "tinygo.org/x/drivers/bh1750"
|
||||
|
||||
import (
|
||||
"time"
|
||||
|
||||
"tinygo.org/x/drivers"
|
||||
)
|
||||
|
||||
// SamplingMode is the sampling's resolution of the measurement
|
||||
type SamplingMode byte
|
||||
|
||||
// Device wraps an I2C connection to a bh1750 device.
|
||||
type Device struct {
|
||||
bus drivers.I2C
|
||||
Address uint16
|
||||
mode SamplingMode
|
||||
}
|
||||
|
||||
// New creates a new bh1750 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,
|
||||
mode: CONTINUOUS_HIGH_RES_MODE,
|
||||
}
|
||||
}
|
||||
|
||||
// Configure sets up the device for communication
|
||||
func (d *Device) Configure() {
|
||||
d.bus.Tx(d.Address, []byte{POWER_ON}, nil)
|
||||
d.SetMode(d.mode)
|
||||
}
|
||||
|
||||
// RawSensorData returns the raw value from the bh1750
|
||||
func (d *Device) RawSensorData() uint16 {
|
||||
|
||||
buf := []byte{1, 0}
|
||||
d.bus.Tx(d.Address, nil, buf)
|
||||
return (uint16(buf[0]) << 8) | uint16(buf[1])
|
||||
}
|
||||
|
||||
// Illuminance returns the adjusted value in mlx (milliLux)
|
||||
func (d *Device) Illuminance() int32 {
|
||||
|
||||
lux := uint32(d.RawSensorData())
|
||||
var coef uint32
|
||||
if d.mode == CONTINUOUS_HIGH_RES_MODE || d.mode == ONE_TIME_HIGH_RES_MODE {
|
||||
coef = HIGH_RES
|
||||
} else if d.mode == CONTINUOUS_HIGH_RES_MODE_2 || d.mode == ONE_TIME_HIGH_RES_MODE_2 {
|
||||
coef = HIGH_RES2
|
||||
} else {
|
||||
coef = LOW_RES
|
||||
}
|
||||
// 100 * coef * lux * (5/6)
|
||||
// 5/6 = measurement accuracy as per the datasheet
|
||||
return int32(250 * coef * lux / 3)
|
||||
}
|
||||
|
||||
// SetMode changes the reading mode for the sensor
|
||||
func (d *Device) SetMode(mode SamplingMode) {
|
||||
d.mode = mode
|
||||
d.bus.Tx(d.Address, []byte{byte(d.mode)}, nil)
|
||||
time.Sleep(10 * time.Millisecond)
|
||||
}
|
||||
@@ -1,24 +0,0 @@
|
||||
package bh1750
|
||||
|
||||
// Constants/addresses used for I2C.
|
||||
|
||||
// The I2C address which this device listens to.
|
||||
const Address = 0x23
|
||||
|
||||
// Registers. Names, addresses and comments copied from the datasheet.
|
||||
const (
|
||||
POWER_DOWN = 0x00
|
||||
POWER_ON = 0x01
|
||||
RESET = 0x07
|
||||
CONTINUOUS_HIGH_RES_MODE SamplingMode = 0x10
|
||||
CONTINUOUS_HIGH_RES_MODE_2 SamplingMode = 0x11
|
||||
CONTINUOUS_LOW_RES_MODE SamplingMode = 0x13
|
||||
ONE_TIME_HIGH_RES_MODE SamplingMode = 0x20
|
||||
ONE_TIME_HIGH_RES_MODE_2 SamplingMode = 0x21
|
||||
ONE_TIME_LOW_RES_MODE SamplingMode = 0x23
|
||||
|
||||
// resolution in 10*lx
|
||||
HIGH_RES = 10
|
||||
HIGH_RES2 = 5
|
||||
LOW_RES = 40
|
||||
)
|
||||
+12
-17
@@ -1,59 +1,54 @@
|
||||
// Package blinkm implements a driver for the BlinkM I2C RGB LED.
|
||||
//
|
||||
// Datasheet: http://thingm.com/fileadmin/thingm/downloads/BlinkM_datasheet.pdf
|
||||
//
|
||||
package blinkm // import "tinygo.org/x/drivers/blinkm"
|
||||
package blinkm
|
||||
|
||||
import "tinygo.org/x/drivers"
|
||||
import (
|
||||
"machine"
|
||||
)
|
||||
|
||||
// Device wraps an I2C connection to a BlinkM device.
|
||||
type Device struct {
|
||||
bus drivers.I2C
|
||||
Address uint16
|
||||
bus machine.I2C
|
||||
}
|
||||
|
||||
// New creates a new BlinkM 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, Address}
|
||||
}
|
||||
|
||||
// Configure sets up the device for communication
|
||||
func (d *Device) Configure() {
|
||||
d.bus.Tx(d.Address, []byte{'o'}, nil)
|
||||
func New(bus machine.I2C) Device {
|
||||
return Device{bus}
|
||||
}
|
||||
|
||||
// Version returns the version of firmware on the BlinkM.
|
||||
func (d Device) Version() (major, minor byte, err error) {
|
||||
version := []byte{0, 0}
|
||||
d.bus.Tx(d.Address, []byte{GET_FIRMWARE}, version)
|
||||
d.bus.ReadRegister(Address, GET_FIRMWARE, version)
|
||||
return version[0], version[1], nil
|
||||
}
|
||||
|
||||
// SetRGB sets the RGB color on the BlinkM.
|
||||
func (d Device) SetRGB(r, g, b byte) error {
|
||||
d.bus.Tx(d.Address, []byte{TO_RGB, r, g, b}, nil)
|
||||
d.bus.WriteRegister(Address, TO_RGB, []byte{r, g, b})
|
||||
return nil
|
||||
}
|
||||
|
||||
// GetRGB gets the current RGB color on the BlinkM.
|
||||
func (d Device) GetRGB() (r, g, b byte, err error) {
|
||||
color := []byte{0, 0, 0}
|
||||
d.bus.Tx(d.Address, []byte{GET_RGB}, color)
|
||||
d.bus.ReadRegister(Address, GET_RGB, color)
|
||||
return color[0], color[1], color[2], nil
|
||||
}
|
||||
|
||||
// FadeToRGB sets the RGB color on the BlinkM by fading from the current color
|
||||
// to the new color.
|
||||
func (d Device) FadeToRGB(r, g, b byte) error {
|
||||
d.bus.Tx(d.Address, []byte{FADE_TO_RGB, r, g, b}, nil)
|
||||
d.bus.WriteRegister(Address, FADE_TO_RGB, []byte{r, g, b})
|
||||
return nil
|
||||
}
|
||||
|
||||
// StopScript stops whatever script is currently running on the BlinkM.
|
||||
func (d Device) StopScript() error {
|
||||
d.bus.Tx(d.Address, []byte{STOP_SCRIPT}, nil)
|
||||
d.bus.WriteRegister(Address, STOP_SCRIPT, nil)
|
||||
return nil
|
||||
}
|
||||
|
||||
@@ -1,258 +0,0 @@
|
||||
// Package bme280 provides a driver for the BME280 digital combined
|
||||
// humidity and pressure sensor by Bosch.
|
||||
//
|
||||
// Datasheet:
|
||||
// https://cdn-shop.adafruit.com/datasheets/BST-BME280_DS001-10.pdf
|
||||
//
|
||||
package bme280
|
||||
|
||||
import (
|
||||
"math"
|
||||
|
||||
"tinygo.org/x/drivers"
|
||||
)
|
||||
|
||||
// calibrationCoefficients reads at startup and stores the calibration coefficients
|
||||
type calibrationCoefficients struct {
|
||||
t1 uint16
|
||||
t2 int16
|
||||
t3 int16
|
||||
p1 uint16
|
||||
p2 int16
|
||||
p3 int16
|
||||
p4 int16
|
||||
p5 int16
|
||||
p6 int16
|
||||
p7 int16
|
||||
p8 int16
|
||||
p9 int16
|
||||
h1 uint8
|
||||
h2 int16
|
||||
h3 uint8
|
||||
h4 int16
|
||||
h5 int16
|
||||
h6 int8
|
||||
}
|
||||
|
||||
// Device wraps an I2C connection to a BME280 device.
|
||||
type Device struct {
|
||||
bus drivers.I2C
|
||||
Address uint16
|
||||
calibrationCoefficients calibrationCoefficients
|
||||
}
|
||||
|
||||
// New creates a new BME280 connection. The I2C bus must already be
|
||||
// configured.
|
||||
//
|
||||
// This function only creates the Device object, it does not touch the device.
|
||||
func New(bus drivers.I2C) Device {
|
||||
return Device{
|
||||
bus: bus,
|
||||
Address: Address,
|
||||
}
|
||||
}
|
||||
|
||||
// Configure sets up the device for communication and
|
||||
// read the calibration coefficientes.
|
||||
func (d *Device) Configure() {
|
||||
|
||||
var data [24]byte
|
||||
err := d.bus.ReadRegister(uint8(d.Address), REG_CALIBRATION, data[:])
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
var h1 [1]byte
|
||||
err = d.bus.ReadRegister(uint8(d.Address), REG_CALIBRATION_H1, h1[:])
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
var h2lsb [7]byte
|
||||
err = d.bus.ReadRegister(uint8(d.Address), REG_CALIBRATION_H2LSB, h2lsb[:])
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
d.calibrationCoefficients.t1 = readUintLE(data[0], data[1])
|
||||
d.calibrationCoefficients.t2 = readIntLE(data[2], data[3])
|
||||
d.calibrationCoefficients.t3 = readIntLE(data[4], data[5])
|
||||
d.calibrationCoefficients.p1 = readUintLE(data[6], data[7])
|
||||
d.calibrationCoefficients.p2 = readIntLE(data[8], data[9])
|
||||
d.calibrationCoefficients.p3 = readIntLE(data[10], data[11])
|
||||
d.calibrationCoefficients.p4 = readIntLE(data[12], data[13])
|
||||
d.calibrationCoefficients.p5 = readIntLE(data[14], data[15])
|
||||
d.calibrationCoefficients.p6 = readIntLE(data[16], data[17])
|
||||
d.calibrationCoefficients.p7 = readIntLE(data[18], data[19])
|
||||
d.calibrationCoefficients.p8 = readIntLE(data[20], data[21])
|
||||
d.calibrationCoefficients.p9 = readIntLE(data[22], data[23])
|
||||
|
||||
d.calibrationCoefficients.h1 = h1[0]
|
||||
d.calibrationCoefficients.h2 = readIntLE(h2lsb[0], h2lsb[1])
|
||||
d.calibrationCoefficients.h3 = h2lsb[2]
|
||||
d.calibrationCoefficients.h6 = int8(h2lsb[6])
|
||||
d.calibrationCoefficients.h4 = 0 + (int16(h2lsb[3]) << 4) | (int16(h2lsb[4] & 0x0F))
|
||||
d.calibrationCoefficients.h5 = 0 + (int16(h2lsb[5]) << 4) | (int16(h2lsb[4]) >> 4)
|
||||
|
||||
d.bus.WriteRegister(uint8(d.Address), CTRL_HUMIDITY_ADDR, []byte{0x3f})
|
||||
d.bus.WriteRegister(uint8(d.Address), CTRL_MEAS_ADDR, []byte{0xB7})
|
||||
d.bus.WriteRegister(uint8(d.Address), CTRL_CONFIG, []byte{0x00})
|
||||
|
||||
}
|
||||
|
||||
// Connected returns whether a BME280 has been found.
|
||||
// It does a "who am I" request and checks the response.
|
||||
func (d *Device) Connected() bool {
|
||||
data := []byte{0}
|
||||
d.bus.ReadRegister(uint8(d.Address), WHO_AM_I, data)
|
||||
return data[0] == CHIP_ID
|
||||
}
|
||||
|
||||
// Reset the device
|
||||
func (d *Device) Reset() {
|
||||
d.bus.WriteRegister(uint8(d.Address), CMD_RESET, []byte{0xB6})
|
||||
}
|
||||
|
||||
// ReadTemperature returns the temperature in celsius milli degrees (°C/1000)
|
||||
func (d *Device) ReadTemperature() (int32, error) {
|
||||
data, err := d.readData()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
|
||||
temp, _ := d.calculateTemp(data)
|
||||
return temp, nil
|
||||
}
|
||||
|
||||
// ReadPressure returns the pressure in milli pascals mPa
|
||||
func (d *Device) ReadPressure() (int32, error) {
|
||||
data, err := d.readData()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
_, tFine := d.calculateTemp(data)
|
||||
pressure := d.calculatePressure(data, tFine)
|
||||
return pressure, nil
|
||||
}
|
||||
|
||||
// ReadHumidity returns the relative humidity in hundredths of a percent
|
||||
func (d *Device) ReadHumidity() (int32, error) {
|
||||
data, err := d.readData()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
_, tFine := d.calculateTemp(data)
|
||||
humidity := d.calculateHumidity(data, tFine)
|
||||
return humidity, nil
|
||||
}
|
||||
|
||||
// ReadAltitude returns the current altitude in meters based on the
|
||||
// current barometric pressure and estimated pressure at sea level.
|
||||
// Calculation is based on code from Adafruit BME280 library
|
||||
// https://github.com/adafruit/Adafruit_BME280_Library
|
||||
func (d *Device) ReadAltitude() (alt int32, err error) {
|
||||
mPa, _ := d.ReadPressure()
|
||||
atmP := float32(mPa) / 100000
|
||||
alt = int32(44330.0 * (1.0 - math.Pow(float64(atmP/SEALEVEL_PRESSURE), 0.1903)))
|
||||
return
|
||||
}
|
||||
|
||||
// convert2Bytes converts two bytes to int32
|
||||
func convert2Bytes(msb byte, lsb byte) int32 {
|
||||
return int32(readUint(msb, lsb))
|
||||
}
|
||||
|
||||
// convert3Bytes converts three bytes to int32
|
||||
func convert3Bytes(msb byte, b1 byte, lsb byte) int32 {
|
||||
return int32(((((uint32(msb) << 8) | uint32(b1)) << 8) | uint32(lsb)) >> 4)
|
||||
}
|
||||
|
||||
// readUint converts two bytes to uint16
|
||||
func readUint(msb byte, lsb byte) uint16 {
|
||||
return (uint16(msb) << 8) | uint16(lsb)
|
||||
}
|
||||
|
||||
// readUintLE converts two little endian bytes to uint16
|
||||
func readUintLE(msb byte, lsb byte) uint16 {
|
||||
temp := readUint(msb, lsb)
|
||||
return (temp >> 8) | (temp << 8)
|
||||
}
|
||||
|
||||
// readIntLE converts two little endian bytes to int16
|
||||
func readIntLE(msb byte, lsb byte) int16 {
|
||||
return int16(readUintLE(msb, lsb))
|
||||
}
|
||||
|
||||
// readData does a burst read from 0xF7 to 0xF0 according to the datasheet
|
||||
// resulting in an slice with 8 bytes 0-2 = pressure / 3-5 = temperature / 6-7 = humidity
|
||||
func (d *Device) readData() (data [8]byte, err error) {
|
||||
err = d.bus.ReadRegister(uint8(d.Address), REG_PRESSURE, data[:])
|
||||
if err != nil {
|
||||
println(err)
|
||||
return
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// calculateTemp uses the data slice and applies calibrations values on it to convert the value to milli degrees
|
||||
// it also calculates the variable tFine which is used by the pressure and humidity calculation
|
||||
func (d *Device) calculateTemp(data [8]byte) (int32, int32) {
|
||||
|
||||
rawTemp := convert3Bytes(data[3], data[4], data[5])
|
||||
|
||||
var1 := (((rawTemp >> 3) - (int32(d.calibrationCoefficients.t1) << 1)) * int32(d.calibrationCoefficients.t2)) >> 11
|
||||
var2 := (((((rawTemp >> 4) - int32(d.calibrationCoefficients.t1)) * ((rawTemp >> 4) - int32(d.calibrationCoefficients.t1))) >> 12) * int32(d.calibrationCoefficients.t3)) >> 14
|
||||
|
||||
tFine := var1 + var2
|
||||
T := (tFine*5 + 128) >> 8
|
||||
return (10 * T), tFine
|
||||
}
|
||||
|
||||
// calculatePressure uses the data slice and applies calibrations values on it to convert the value to milli pascals mPa
|
||||
func (d *Device) calculatePressure(data [8]byte, tFine int32) int32 {
|
||||
|
||||
rawPressure := convert3Bytes(data[0], data[1], data[2])
|
||||
|
||||
var1 := int64(tFine) - 128000
|
||||
var2 := var1 * var1 * int64(d.calibrationCoefficients.p6)
|
||||
var2 = var2 + ((var1 * int64(d.calibrationCoefficients.p5)) << 17)
|
||||
var2 = var2 + (int64(d.calibrationCoefficients.p4) << 35)
|
||||
var1 = ((var1 * var1 * int64(d.calibrationCoefficients.p3)) >> 8) + ((var1 * int64(d.calibrationCoefficients.p2)) << 12)
|
||||
var1 = ((int64(1) << 47) + var1) * int64(d.calibrationCoefficients.p1) >> 33
|
||||
|
||||
if var1 == 0 {
|
||||
return 0 // avoid exception caused by division by zero
|
||||
}
|
||||
p := int64(1048576 - rawPressure)
|
||||
p = (((p << 31) - var2) * 3125) / var1
|
||||
var1 = (int64(d.calibrationCoefficients.p9) * (p >> 13) * (p >> 13)) >> 25
|
||||
var2 = (int64(d.calibrationCoefficients.p8) * p) >> 19
|
||||
|
||||
p = ((p + var1 + var2) >> 8) + (int64(d.calibrationCoefficients.p7) << 4)
|
||||
p = (p / 256)
|
||||
return int32(1000 * p)
|
||||
}
|
||||
|
||||
// calculateHumidity uses the data slice and applies calibrations values on it to convert the value to relative humidity in hundredths of a percent
|
||||
func (d *Device) calculateHumidity(data [8]byte, tFine int32) int32 {
|
||||
|
||||
rawHumidity := convert2Bytes(data[6], data[7])
|
||||
|
||||
h := float32(tFine) - 76800
|
||||
|
||||
if h == 0 {
|
||||
println("invalid value")
|
||||
}
|
||||
|
||||
var1 := float32(rawHumidity) - (float32(d.calibrationCoefficients.h4)*64.0 +
|
||||
(float32(d.calibrationCoefficients.h5) / 16384.0 * h))
|
||||
|
||||
var2 := float32(d.calibrationCoefficients.h2) / 65536.0 *
|
||||
(1.0 + float32(d.calibrationCoefficients.h6)/67108864.0*h*
|
||||
(1.0+float32(d.calibrationCoefficients.h3)/67108864.0*h))
|
||||
|
||||
h = var1 * var2
|
||||
h = h * (1 - float32(d.calibrationCoefficients.h1)*h/524288)
|
||||
return int32(100 * h)
|
||||
|
||||
}
|
||||
@@ -1,25 +0,0 @@
|
||||
package bme280
|
||||
|
||||
// Constants/addresses used for I2C.
|
||||
|
||||
// The I2C address which this device listens to.
|
||||
const Address = 0x76
|
||||
|
||||
// Registers. Names, addresses and comments copied from the datasheet.
|
||||
const (
|
||||
CTRL_MEAS_ADDR = 0xF4
|
||||
CTRL_HUMIDITY_ADDR = 0xF2
|
||||
CTRL_CONFIG = 0xF5
|
||||
REG_PRESSURE = 0xF7
|
||||
REG_CALIBRATION = 0x88
|
||||
REG_CALIBRATION_H1 = 0xA1
|
||||
REG_CALIBRATION_H2LSB = 0xE1
|
||||
CMD_RESET = 0xE0
|
||||
|
||||
WHO_AM_I = 0xD0
|
||||
CHIP_ID = 0x60
|
||||
)
|
||||
|
||||
const (
|
||||
SEALEVEL_PRESSURE float32 = 1013.25 // in hPa
|
||||
)
|
||||
@@ -1,223 +0,0 @@
|
||||
package bmi160
|
||||
|
||||
import (
|
||||
"machine"
|
||||
"time"
|
||||
|
||||
"tinygo.org/x/drivers"
|
||||
)
|
||||
|
||||
// DeviceSPI is the SPI interface to a BMI160 accelerometer/gyroscope. There is
|
||||
// also an I2C interface, but it is not yet supported.
|
||||
type DeviceSPI struct {
|
||||
// Chip select pin
|
||||
CSB machine.Pin
|
||||
|
||||
buf [7]byte
|
||||
|
||||
// SPI bus (requires chip select to be usable).
|
||||
Bus drivers.SPI
|
||||
}
|
||||
|
||||
// NewSPI returns a new device driver. The pin and SPI interface are not
|
||||
// touched, provide a fully configured SPI object and call Configure to start
|
||||
// using this device.
|
||||
func NewSPI(csb machine.Pin, spi drivers.SPI) *DeviceSPI {
|
||||
return &DeviceSPI{
|
||||
CSB: csb, // chip select
|
||||
Bus: spi,
|
||||
}
|
||||
}
|
||||
|
||||
// Configure configures the BMI160 for use. It configures the CSB pin and
|
||||
// configures the BMI160, but it does not configure the SPI interface (it is
|
||||
// assumed to be up and running).
|
||||
func (d *DeviceSPI) Configure() error {
|
||||
d.CSB.Configure(machine.PinConfig{Mode: machine.PinOutput})
|
||||
d.CSB.High()
|
||||
|
||||
// The datasheet recommends doing a register read from address 0x7F to get
|
||||
// SPI communication going:
|
||||
// > If CSB sees a rising edge after power-up, the BMI160 interface switches
|
||||
// > to SPI until a reset or the next power-up occurs. Therefore, a CSB
|
||||
// > rising edge is needed before starting the SPI communication. Hence, it
|
||||
// > is recommended to perform a SPI single read access to the ADDRESS 0x7F
|
||||
// > before the actual communication in order to use the SPI interface.
|
||||
d.readRegister(0x7F)
|
||||
|
||||
// Power up the accelerometer. 0b0001_00nn is the command format, with 0b01
|
||||
// indicating normal mode.
|
||||
d.runCommand(0b0001_0001)
|
||||
|
||||
// Power up the gyroscope. 0b0001_01nn is the command format, with 0b01
|
||||
// indicating normal mode.
|
||||
d.runCommand(0b0001_0101)
|
||||
|
||||
// Wait until the device is fully initialized. Even after the command has
|
||||
// finished, the gyroscope may not be fully powered on. Therefore, wait
|
||||
// until we get an expected value.
|
||||
// This takes 30ms or so.
|
||||
for {
|
||||
// Wait for the acc_pmu_status and gyr_pmu_status to both be 0b01.
|
||||
if d.readRegister(reg_PMU_STATUS) == 0b0001_0100 {
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// Connected check whether the device appears to be properly connected. It reads
|
||||
// the CHIPID, which must be 0xD1 for the BMI160.
|
||||
func (d *DeviceSPI) Connected() bool {
|
||||
return d.readRegister(reg_CHIPID) == 0xD1
|
||||
}
|
||||
|
||||
// Reset restores the device to the state after power up. This can be useful to
|
||||
// easily disable the accelerometer and gyroscope to reduce current consumption.
|
||||
func (d *DeviceSPI) Reset() error {
|
||||
d.runCommand(0xB6) // softreset
|
||||
return nil
|
||||
}
|
||||
|
||||
// ReadTemperature returns the temperature in celsius milli degrees (°C/1000).
|
||||
func (d *DeviceSPI) ReadTemperature() (temperature int32, err error) {
|
||||
data := d.buf[:3]
|
||||
data[0] = 0x80 | reg_TEMPERATURE_0
|
||||
data[1] = 0
|
||||
data[2] = 0
|
||||
d.CSB.Low()
|
||||
err = d.Bus.Tx(data, data)
|
||||
d.CSB.High()
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
rawTemperature := int16(uint16(data[1]) | uint16(data[2])<<8)
|
||||
// 0x0000 is 23°C
|
||||
// 0x7fff is ~87°C
|
||||
// We use 0x8000 instead of 0x7fff to make the formula easier. The result
|
||||
// should be near identical and shouldn't affect the result too much (the
|
||||
// temperature sensor has an offset of around 2°C so isn't very reliable).
|
||||
// So the formula is as follows:
|
||||
// 1. Scale from 0x0000..0x8000 to 0..(87-23).
|
||||
// rawTemperature * (87-23) / 0x8000
|
||||
// 2. Convert to centidegrees.
|
||||
// rawTemperature * 1000 * (87-23) / 0x8000
|
||||
// 3. Add 23°C offset.
|
||||
// rawTemperature * 1000 * (87-23) / 0x8000 + 23000
|
||||
// 4. Simplify.
|
||||
// rawTemperature * 1000 * 64 / 0x8000 + 23000
|
||||
// rawTemperature * 64000 / 0x8000 + 23000
|
||||
// rawTemperature * 125 / 64 + 23000
|
||||
temperature = int32(rawTemperature)*125/64 + 23000
|
||||
return
|
||||
}
|
||||
|
||||
// ReadAcceleration reads the current acceleration from the device and returns
|
||||
// it in µg (micro-gravity). When one of the axes is pointing straight to Earth
|
||||
// and the sensor is not moving the returned value will be around 1000000 or
|
||||
// -1000000.
|
||||
func (d *DeviceSPI) ReadAcceleration() (x int32, y int32, z int32, err error) {
|
||||
data := d.buf[:7]
|
||||
data[0] = 0x80 | reg_ACC_XL
|
||||
for i := 1; i < len(data); i++ {
|
||||
data[i] = 0
|
||||
}
|
||||
d.CSB.Low()
|
||||
err = d.Bus.Tx(data, data)
|
||||
d.CSB.High()
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
// Now do two things:
|
||||
// 1. merge the two values to a 16-bit number (and cast to a 32-bit integer)
|
||||
// 2. scale the value to bring it in the -1000000..1000000 range.
|
||||
// This is done with a trick. What we do here is essentially multiply by
|
||||
// 1000000 and divide by 16384 to get the original scale, but to avoid
|
||||
// overflow we do it at 1/64 of the value:
|
||||
// 1000000 / 64 = 15625
|
||||
// 16384 / 64 = 256
|
||||
x = int32(int16(uint16(data[1])|uint16(data[2])<<8)) * 15625 / 256
|
||||
y = int32(int16(uint16(data[3])|uint16(data[4])<<8)) * 15625 / 256
|
||||
z = int32(int16(uint16(data[5])|uint16(data[6])<<8)) * 15625 / 256
|
||||
return
|
||||
}
|
||||
|
||||
// ReadRotation reads the current rotation from the device and returns it in
|
||||
// µ°/s (micro-degrees/sec). This means that if you were to do a complete
|
||||
// rotation along one axis and while doing so integrate all values over time,
|
||||
// you would get a value close to 360000000.
|
||||
func (d *DeviceSPI) ReadRotation() (x int32, y int32, z int32, err error) {
|
||||
data := d.buf[:7]
|
||||
data[0] = 0x80 | reg_GYR_XL
|
||||
for i := 1; i < len(data); i++ {
|
||||
data[i] = 0
|
||||
}
|
||||
d.CSB.Low()
|
||||
err = d.Bus.Tx(data, data)
|
||||
d.CSB.High()
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
// First the value is converted from a pair of bytes to a signed 16-bit
|
||||
// value and then to a signed 32-bit value to avoid integer overflow.
|
||||
// Then the value is scaled to µ°/s (micro-degrees per second).
|
||||
// The default is 2000°/s full scale range for -32768..32767.
|
||||
// The formula works as follows (taking X as an example):
|
||||
// 1. Scale from 32768 to 2000. This means that it is in °/s units.
|
||||
// rawX * 2000 / 32768
|
||||
// 2. Scale to µ°/s by multiplying by 1e6.
|
||||
// rawX * 1e6 * 2000 / 32768
|
||||
// 3. Simplify.
|
||||
// rawX * 2e9 / 32768
|
||||
// rawX * 1953125 / 32
|
||||
rawX := int32(int16(uint16(data[1]) | uint16(data[2])<<8))
|
||||
rawY := int32(int16(uint16(data[3]) | uint16(data[4])<<8))
|
||||
rawZ := int32(int16(uint16(data[5]) | uint16(data[6])<<8))
|
||||
x = int32(int64(rawX) * 1953125 / 32)
|
||||
y = int32(int64(rawY) * 1953125 / 32)
|
||||
z = int32(int64(rawZ) * 1953125 / 32)
|
||||
return
|
||||
}
|
||||
|
||||
// runCommand runs a BMI160 command through the CMD register. It waits for the
|
||||
// command to complete before returning.
|
||||
func (d *DeviceSPI) runCommand(command uint8) {
|
||||
d.writeRegister(reg_CMD, command)
|
||||
for {
|
||||
response := d.readRegister(reg_CMD)
|
||||
if response == 0 {
|
||||
return // command was completed
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// readRegister reads from a single BMI160 register. It should only be used for
|
||||
// single register reads, not for reading multiple registers at once.
|
||||
func (d *DeviceSPI) readRegister(address uint8) uint8 {
|
||||
// I don't know why but it appears necessary to sleep for a bit here.
|
||||
time.Sleep(time.Millisecond)
|
||||
|
||||
data := d.buf[:2]
|
||||
data[0] = 0x80 | address
|
||||
data[1] = 0
|
||||
d.CSB.Low()
|
||||
d.Bus.Tx(data, data)
|
||||
d.CSB.High()
|
||||
return data[1]
|
||||
}
|
||||
|
||||
// writeRegister writes a single byte BMI160 register. It should only be used
|
||||
// for writing to a single register.
|
||||
func (d *DeviceSPI) writeRegister(address, data uint8) {
|
||||
// I don't know why but it appears necessary to sleep for a bit here.
|
||||
time.Sleep(time.Millisecond)
|
||||
|
||||
buf := d.buf[:2]
|
||||
buf[0] = address
|
||||
buf[1] = data
|
||||
|
||||
d.CSB.Low()
|
||||
d.Bus.Tx(buf, buf)
|
||||
d.CSB.High()
|
||||
}
|
||||
@@ -1,44 +0,0 @@
|
||||
package bmi160
|
||||
|
||||
const (
|
||||
reg_CHIPID = 0x00
|
||||
reg_ERR_REG = 0x02
|
||||
reg_PMU_STATUS = 0x03
|
||||
reg_MAG_XL = 0x04
|
||||
reg_MAG_XH = 0x05
|
||||
reg_MAG_YL = 0x06
|
||||
reg_MAG_YH = 0x07
|
||||
reg_MAG_ZL = 0x08
|
||||
reg_MAG_ZH = 0x09
|
||||
reg_RHALL_L = 0x0A
|
||||
reg_RHALL_H = 0x0B
|
||||
reg_GYR_XL = 0x0C
|
||||
reg_GYR_XH = 0x0D
|
||||
reg_GYR_YL = 0x0E
|
||||
reg_GYR_YH = 0x0F
|
||||
reg_GYR_ZL = 0x10
|
||||
reg_GYR_ZH = 0x11
|
||||
reg_ACC_XL = 0x12
|
||||
reg_ACC_XH = 0x13
|
||||
reg_ACC_YL = 0x14
|
||||
reg_ACC_YH = 0x15
|
||||
reg_ACC_ZL = 0x16
|
||||
reg_ACC_ZH = 0x17
|
||||
reg_SENSORTIME_0 = 0x18
|
||||
reg_SENSORTIME_1 = 0x19
|
||||
reg_SENSORTIME_2 = 0x1A
|
||||
reg_STATUS = 0x1B
|
||||
reg_INT_STATUS_0 = 0x1C
|
||||
reg_INT_STATUS_1 = 0x1D
|
||||
reg_INT_STATUS_2 = 0x1E
|
||||
reg_INT_STATUS_3 = 0x1F
|
||||
reg_TEMPERATURE_0 = 0x20
|
||||
reg_TEMPERATURE_1 = 0x21
|
||||
reg_FIFO_LENGTH_0 = 0x22
|
||||
reg_FIFO_LENGTH_1 = 0x23
|
||||
reg_FIFO_DATA = 0x24
|
||||
|
||||
// ...
|
||||
|
||||
reg_CMD = 0x7E
|
||||
)
|
||||
@@ -1,183 +0,0 @@
|
||||
// Package bmp180 provides a driver for the BMP180 digital pressure sensor
|
||||
// by Bosch.
|
||||
//
|
||||
// Datasheet:
|
||||
// https://cdn-shop.adafruit.com/datasheets/BST-BMP180-DS000-09.pdf
|
||||
//
|
||||
package bmp180 // import "tinygo.org/x/drivers/bmp180"
|
||||
|
||||
import (
|
||||
"time"
|
||||
|
||||
"tinygo.org/x/drivers"
|
||||
)
|
||||
|
||||
// OversamplingMode is the oversampling ratio of the pressure measurement.
|
||||
type OversamplingMode uint
|
||||
|
||||
// calibrationCoefficients reads at startup and stores the calibration coefficients
|
||||
type calibrationCoefficients struct {
|
||||
ac1 int16
|
||||
ac2 int16
|
||||
ac3 int16
|
||||
ac4 uint16
|
||||
ac5 uint16
|
||||
ac6 uint16
|
||||
b1 int16
|
||||
b2 int16
|
||||
mb int16
|
||||
mc int16
|
||||
md int16
|
||||
}
|
||||
|
||||
// Device wraps an I2C connection to a BMP180 device.
|
||||
type Device struct {
|
||||
bus drivers.I2C
|
||||
Address uint16
|
||||
mode OversamplingMode
|
||||
calibrationCoefficients calibrationCoefficients
|
||||
}
|
||||
|
||||
// New creates a new BMP180 connection. The I2C bus must already be
|
||||
// configured.
|
||||
//
|
||||
// This function only creates the Device object, it does not initialize the device.
|
||||
// You must call Configure() first in order to use the device itself.
|
||||
func New(bus drivers.I2C) Device {
|
||||
return Device{
|
||||
bus: bus,
|
||||
Address: Address,
|
||||
mode: ULTRAHIGHRESOLUTION,
|
||||
}
|
||||
}
|
||||
|
||||
// Connected returns whether a BMP180 has been found.
|
||||
// It does a "who am I" request and checks the response.
|
||||
func (d *Device) Connected() bool {
|
||||
data := []byte{0}
|
||||
d.bus.ReadRegister(uint8(d.Address), WHO_AM_I, data)
|
||||
return data[0] == CHIP_ID
|
||||
}
|
||||
|
||||
// Configure sets up the device for communication and
|
||||
// read the calibration coefficients.
|
||||
func (d *Device) Configure() {
|
||||
data := make([]byte, 22)
|
||||
err := d.bus.ReadRegister(uint8(d.Address), AC1_MSB, data)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
d.calibrationCoefficients.ac1 = readInt(data[0], data[1])
|
||||
d.calibrationCoefficients.ac2 = readInt(data[2], data[3])
|
||||
d.calibrationCoefficients.ac3 = readInt(data[4], data[5])
|
||||
d.calibrationCoefficients.ac4 = readUint(data[6], data[7])
|
||||
d.calibrationCoefficients.ac5 = readUint(data[8], data[9])
|
||||
d.calibrationCoefficients.ac6 = readUint(data[10], data[11])
|
||||
d.calibrationCoefficients.b1 = readInt(data[12], data[13])
|
||||
d.calibrationCoefficients.b2 = readInt(data[14], data[15])
|
||||
d.calibrationCoefficients.mb = readInt(data[16], data[17])
|
||||
d.calibrationCoefficients.mc = readInt(data[18], data[19])
|
||||
d.calibrationCoefficients.md = readInt(data[20], data[21])
|
||||
}
|
||||
|
||||
// ReadTemperature returns the temperature in celsius milli degrees (°C/1000).
|
||||
func (d *Device) ReadTemperature() (temperature int32, err error) {
|
||||
rawTemp, err := d.rawTemp()
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
b5 := d.calculateB5(rawTemp)
|
||||
t := (b5 + 8) >> 4
|
||||
return 100 * t, nil
|
||||
}
|
||||
|
||||
// ReadPressure returns the pressure in milli pascals (mPa).
|
||||
func (d *Device) ReadPressure() (pressure int32, err error) {
|
||||
rawTemp, err := d.rawTemp()
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
rawPressure, err := d.rawPressure(d.mode)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
b5 := d.calculateB5(rawTemp)
|
||||
b6 := b5 - 4000
|
||||
x1 := (int32(d.calibrationCoefficients.b2) * (b6 * b6 >> 12)) >> 11
|
||||
x2 := (int32(d.calibrationCoefficients.ac2) * b6) >> 11
|
||||
x3 := x1 + x2
|
||||
b3 := (((int32(d.calibrationCoefficients.ac1)*4 + x3) << uint(d.mode)) + 2) >> 2
|
||||
x1 = (int32(d.calibrationCoefficients.ac3) * b6) >> 13
|
||||
x2 = (int32(d.calibrationCoefficients.b1) * ((b6 * b6) >> 12)) >> 16
|
||||
x3 = ((x1 + x2) + 2) >> 2
|
||||
b4 := (uint32(d.calibrationCoefficients.ac4) * uint32(x3+32768)) >> 15
|
||||
b7 := uint32(rawPressure-b3) * (50000 >> uint(d.mode))
|
||||
var p int32
|
||||
if b7 < 0x80000000 {
|
||||
p = int32((b7 << 1) / b4)
|
||||
} else {
|
||||
p = int32((b7 / b4) << 1)
|
||||
}
|
||||
x1 = (p >> 8) * (p >> 8)
|
||||
x1 = (x1 * 3038) >> 16
|
||||
x2 = (-7357 * p) >> 16
|
||||
return 1000 * (p + ((x1 + x2 + 3791) >> 4)), nil
|
||||
}
|
||||
|
||||
// rawTemp returns the sensor's raw values of the temperature
|
||||
func (d *Device) rawTemp() (int32, error) {
|
||||
d.bus.WriteRegister(uint8(d.Address), REG_CTRL, []byte{CMD_TEMP})
|
||||
time.Sleep(5 * time.Millisecond)
|
||||
data := make([]byte, 2)
|
||||
err := d.bus.ReadRegister(uint8(d.Address), REG_TEMP_MSB, data)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return int32(uint16(data[0])<<8 | uint16(data[1])), nil
|
||||
}
|
||||
|
||||
// calculateB5 calculates intermediate value B5 as per page 15 of datasheet
|
||||
func (d *Device) calculateB5(rawTemp int32) int32 {
|
||||
x1 := (rawTemp - int32(d.calibrationCoefficients.ac6)) * int32(d.calibrationCoefficients.ac5) >> 15
|
||||
x2 := int32(d.calibrationCoefficients.mc) << 11 / (x1 + int32(d.calibrationCoefficients.md))
|
||||
return x1 + x2
|
||||
}
|
||||
|
||||
// rawPressure returns the sensor's raw values of the pressure
|
||||
func (d *Device) rawPressure(mode OversamplingMode) (int32, error) {
|
||||
d.bus.WriteRegister(uint8(d.Address), REG_CTRL, []byte{CMD_PRESSURE + byte(mode<<6)})
|
||||
time.Sleep(pauseForReading(mode))
|
||||
data := make([]byte, 3)
|
||||
err := d.bus.ReadRegister(uint8(d.Address), REG_PRESSURE_MSB, data)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
rawPressure := int32((uint32(data[0])<<16 + uint32(data[1])<<8 + uint32(data[2])) >> (8 - uint(mode)))
|
||||
return rawPressure, nil
|
||||
}
|
||||
|
||||
// pauseForReading returns the pause duration depending on the sampling mode
|
||||
func pauseForReading(mode OversamplingMode) time.Duration {
|
||||
var d time.Duration
|
||||
switch mode {
|
||||
case ULTRALOWPOWER:
|
||||
d = 5 * time.Millisecond
|
||||
case STANDARD:
|
||||
d = 8 * time.Millisecond
|
||||
case HIGHRESOLUTION:
|
||||
d = 14 * time.Millisecond
|
||||
case ULTRAHIGHRESOLUTION:
|
||||
d = 26 * time.Millisecond
|
||||
}
|
||||
return d
|
||||
}
|
||||
|
||||
// readInt converts two bytes to int16
|
||||
func readInt(msb byte, lsb byte) int16 {
|
||||
return int16(uint16(msb)<<8 | uint16(lsb))
|
||||
}
|
||||
|
||||
// readUint converts two bytes to uint16
|
||||
func readUint(msb byte, lsb byte) uint16 {
|
||||
return (uint16(msb) << 8) | uint16(lsb)
|
||||
}
|
||||
@@ -1,30 +0,0 @@
|
||||
package bmp180
|
||||
|
||||
// Constants/addresses used for I2C.
|
||||
|
||||
// The I2C address which this device listens to.
|
||||
const Address = 0x77
|
||||
|
||||
// Registers. Names, addresses and comments copied from the datasheet.
|
||||
const (
|
||||
AC1_MSB = 0xAA // Calibration coefficients start at 0xAA ends at 0xBF
|
||||
CMD_TEMP = 0x2E
|
||||
CMD_PRESSURE = 0x34
|
||||
REG_CTRL = 0xF4
|
||||
REG_TEMP_MSB = 0xF6
|
||||
REG_PRESSURE_MSB = 0xF6
|
||||
|
||||
WHO_AM_I = 0xD0
|
||||
CHIP_ID = 0x55
|
||||
)
|
||||
|
||||
const (
|
||||
// ULTRALOWPOWER is the lowest oversampling mode of the pressure measurement.
|
||||
ULTRALOWPOWER OversamplingMode = iota
|
||||
// BSTANDARD is the standard oversampling mode of the pressure measurement.
|
||||
STANDARD
|
||||
// HIGHRESOLUTION is a high oversampling mode of the pressure measurement.
|
||||
HIGHRESOLUTION
|
||||
// ULTRAHIGHRESOLUTION is the highest oversampling mode of the pressure measurement.
|
||||
ULTRAHIGHRESOLUTION
|
||||
)
|
||||
@@ -1,244 +0,0 @@
|
||||
package bmp280
|
||||
|
||||
import (
|
||||
"time"
|
||||
|
||||
"tinygo.org/x/drivers"
|
||||
)
|
||||
|
||||
// OversamplingMode is the oversampling ratio of the temperature or pressure measurement.
|
||||
type Oversampling uint
|
||||
|
||||
// Mode is the Power Mode.
|
||||
type Mode uint
|
||||
|
||||
// Standby is the inactive period between the reads when the sensor is in normal power mode.
|
||||
type Standby uint
|
||||
|
||||
// Filter unwanted changes in measurement caused by external (environmental) or internal changes (IC).
|
||||
type Filter uint
|
||||
|
||||
// Device wraps an I2C connection to a BMP280 device.
|
||||
type Device struct {
|
||||
bus drivers.I2C
|
||||
Address uint16
|
||||
cali calibrationCoefficients
|
||||
Temperature Oversampling
|
||||
Pressure Oversampling
|
||||
Mode Mode
|
||||
Standby Standby
|
||||
Filter Filter
|
||||
}
|
||||
|
||||
type calibrationCoefficients struct {
|
||||
// Temperature compensation
|
||||
t1 uint16
|
||||
t2 int16
|
||||
t3 int16
|
||||
|
||||
// Pressure compensation
|
||||
p1 uint16
|
||||
p2 int16
|
||||
p3 int16
|
||||
p4 int16
|
||||
p5 int16
|
||||
p6 int16
|
||||
p7 int16
|
||||
p8 int16
|
||||
p9 int16
|
||||
}
|
||||
|
||||
// New creates a new BMP280 connection. The I2C bus must already be
|
||||
// configured.
|
||||
//
|
||||
// This function only creates the Device object, it does not initialize the device.
|
||||
// You must call Configure() first in order to use the device itself.
|
||||
func New(bus drivers.I2C) Device {
|
||||
return Device{
|
||||
bus: bus,
|
||||
Address: Address,
|
||||
}
|
||||
}
|
||||
|
||||
// Connected returns whether a BMP280 has been found.
|
||||
// It does a "who am I" request and checks the response.
|
||||
func (d *Device) Connected() bool {
|
||||
data := make([]byte, 1)
|
||||
d.bus.ReadRegister(uint8(d.Address), REG_ID, data)
|
||||
return data[0] == CHIP_ID
|
||||
}
|
||||
|
||||
// Reset preforms complete power-on-reset procedure.
|
||||
// It is required to call Configure afterwards.
|
||||
func (d *Device) Reset() {
|
||||
d.bus.WriteRegister(uint8(d.Address), REG_RESET, []byte{CMD_RESET})
|
||||
}
|
||||
|
||||
// Configure sets up the device for communication and
|
||||
// read the calibration coefficients.
|
||||
func (d *Device) Configure(standby Standby, filter Filter, temp Oversampling, pres Oversampling, mode Mode) {
|
||||
d.Standby = standby
|
||||
d.Filter = filter
|
||||
d.Temperature = temp
|
||||
d.Pressure = pres
|
||||
d.Mode = mode
|
||||
|
||||
// Write the configuration (standby, filter, spi 3 wire)
|
||||
config := uint(d.Standby<<5) | uint(d.Filter<<2) | 0x00
|
||||
d.bus.WriteRegister(uint8(d.Address), REG_CONFIG, []byte{byte(config)})
|
||||
|
||||
// Write the control (temperature oversampling, pressure oversampling,
|
||||
config = uint(d.Temperature<<5) | uint(d.Pressure<<2) | uint(d.Mode)
|
||||
d.bus.WriteRegister(uint8(d.Address), REG_CTRL_MEAS, []byte{byte(config)})
|
||||
|
||||
// Read Calibration data
|
||||
data := make([]byte, 24)
|
||||
err := d.bus.ReadRegister(uint8(d.Address), REG_CALI, data)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
// Datasheet: 3.11.2 Trimming parameter readout
|
||||
d.cali.t1 = readUintLE(data[0], data[1])
|
||||
d.cali.t2 = readIntLE(data[2], data[3])
|
||||
d.cali.t3 = readIntLE(data[4], data[5])
|
||||
|
||||
d.cali.p1 = readUintLE(data[6], data[7])
|
||||
d.cali.p2 = readIntLE(data[8], data[9])
|
||||
d.cali.p3 = readIntLE(data[10], data[11])
|
||||
d.cali.p4 = readIntLE(data[12], data[13])
|
||||
d.cali.p5 = readIntLE(data[14], data[15])
|
||||
d.cali.p6 = readIntLE(data[16], data[17])
|
||||
d.cali.p7 = readIntLE(data[18], data[19])
|
||||
d.cali.p8 = readIntLE(data[20], data[21])
|
||||
d.cali.p9 = readIntLE(data[22], data[23])
|
||||
}
|
||||
|
||||
// PrintCali prints the Calibration information.
|
||||
func (d *Device) PrintCali() {
|
||||
println("T1:", d.cali.t1)
|
||||
println("T2:", d.cali.t2)
|
||||
println("T3:", d.cali.t3)
|
||||
|
||||
println("P1:", d.cali.p1)
|
||||
println("P2:", d.cali.p2)
|
||||
println("P3:", d.cali.p3)
|
||||
println("P4:", d.cali.p4)
|
||||
println("P5:", d.cali.p5)
|
||||
println("P6:", d.cali.p6)
|
||||
println("P7:", d.cali.p7)
|
||||
println("P8:", d.cali.p8)
|
||||
println("P9:", d.cali.p9, "\n")
|
||||
}
|
||||
|
||||
// ReadTemperature returns the temperature in celsius milli degrees (°C/1000).
|
||||
func (d *Device) ReadTemperature() (temperature int32, err error) {
|
||||
data, err := d.readData(REG_TEMP, 3)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
rawTemp := convert3Bytes(data[0], data[1], data[2])
|
||||
|
||||
// Datasheet: 8.2 Compensation formula in 32 bit fixed point
|
||||
// Temperature compensation
|
||||
var1 := ((rawTemp >> 3) - int32(d.cali.t1<<1)) * int32(d.cali.t2) >> 11
|
||||
var2 := (((rawTemp >> 4) - int32(d.cali.t1)) * ((rawTemp >> 4) - int32(d.cali.t1)) >> 12) *
|
||||
int32(d.cali.t3) >> 14
|
||||
|
||||
tFine := var1 + var2
|
||||
|
||||
// Convert from degrees to milli degrees by multiplying by 10.
|
||||
// Will output 30250 milli degrees celsius for 30.25 degrees celsius
|
||||
temperature = 10 * ((tFine*5 + 128) >> 8)
|
||||
return
|
||||
}
|
||||
|
||||
// ReadPressure returns the pressure in milli pascals (mPa).
|
||||
func (d *Device) ReadPressure() (pressure int32, err error) {
|
||||
// First 3 bytes are Pressure, last 3 bytes are Temperature
|
||||
data, err := d.readData(REG_PRES, 6)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
rawTemp := convert3Bytes(data[3], data[4], data[5])
|
||||
|
||||
// Datasheet: 8.2 Compensation formula in 32 bit fixed point
|
||||
// Calculate tFine (temperature), used for the Pressure compensation
|
||||
var1 := ((rawTemp >> 3) - int32(d.cali.t1<<1)) * int32(d.cali.t2) >> 11
|
||||
var2 := (((rawTemp >> 4) - int32(d.cali.t1)) * ((rawTemp >> 4) - int32(d.cali.t1)) >> 12) *
|
||||
int32(d.cali.t3) >> 14
|
||||
|
||||
tFine := var1 + var2
|
||||
|
||||
rawPres := convert3Bytes(data[0], data[1], data[2])
|
||||
|
||||
// Datasheet: 8.2 Compensation formula in 32 bit fixed point
|
||||
// Pressure compensation
|
||||
var1 = (tFine >> 1) - 64000
|
||||
var2 = (((var1 >> 2) * (var1 >> 2)) >> 11) * int32(d.cali.p6)
|
||||
var2 = var2 + ((var1 * int32(d.cali.p5)) << 1)
|
||||
var2 = (var2 >> 2) + (int32(d.cali.p4) << 16)
|
||||
var1 = (((int32(d.cali.p3) * (((var1 >> 2) * (var1 >> 2)) >> 13)) >> 3) +
|
||||
((int32(d.cali.p2) * var1) >> 1)) >> 18
|
||||
var1 = ((32768 + var1) * int32(d.cali.p1)) >> 15
|
||||
|
||||
if var1 == 0 {
|
||||
return 0, nil
|
||||
}
|
||||
|
||||
p := uint32(((1048576 - rawPres) - (var2 >> 12)) * 3125)
|
||||
if p < 0x80000000 {
|
||||
p = (p << 1) / uint32(var1)
|
||||
} else {
|
||||
p = (p / uint32(var1)) * 2
|
||||
}
|
||||
|
||||
var1 = (int32(d.cali.p9) * int32(((p>>3)*(p>>3))>>13)) >> 12
|
||||
var2 = (int32(p>>2) * int32(d.cali.p8)) >> 13
|
||||
|
||||
return 1000 * (int32(p) + ((var1 + var2 + int32(d.cali.p7)) >> 4)), nil
|
||||
}
|
||||
|
||||
// readData reads n number of bytes of the specified register
|
||||
func (d *Device) readData(register int, n int) ([]byte, error) {
|
||||
// If not in normal mode, set the mode to FORCED mode, to prevent incorrect measurements
|
||||
// After the measurement in FORCED mode, the sensor will return to SLEEP mode
|
||||
if d.Mode != MODE_NORMAL {
|
||||
config := uint(d.Temperature<<5) | uint(d.Pressure<<2) | uint(MODE_FORCED)
|
||||
d.bus.WriteRegister(uint8(d.Address), REG_CTRL_MEAS, []byte{byte(config)})
|
||||
}
|
||||
|
||||
// Check STATUS register, wait if data is not available yet
|
||||
status := make([]byte, 1)
|
||||
for d.bus.ReadRegister(uint8(d.Address), uint8(REG_STATUS), status[0:]); status[0] != 4 && status[0] != 0; d.bus.ReadRegister(uint8(d.Address), uint8(REG_STATUS), status[0:]) {
|
||||
time.Sleep(time.Millisecond)
|
||||
}
|
||||
|
||||
// Read the requested register
|
||||
data := make([]byte, n)
|
||||
err := d.bus.ReadRegister(uint8(d.Address), uint8(register), data[:])
|
||||
return data, err
|
||||
}
|
||||
|
||||
// convert3Bytes converts three bytes to int32
|
||||
func convert3Bytes(msb byte, b1 byte, lsb byte) int32 {
|
||||
return int32(((((uint32(msb) << 8) | uint32(b1)) << 8) | uint32(lsb)) >> 4)
|
||||
}
|
||||
|
||||
// readUint converts two bytes to uint16
|
||||
func readUint(msb byte, lsb byte) uint16 {
|
||||
return (uint16(msb) << 8) | uint16(lsb)
|
||||
}
|
||||
|
||||
// readUintLE converts two little endian bytes to uint16
|
||||
func readUintLE(msb byte, lsb byte) uint16 {
|
||||
temp := readUint(msb, lsb)
|
||||
return (temp >> 8) | (temp << 8)
|
||||
}
|
||||
|
||||
// readIntLE converts two little endian bytes to int16
|
||||
func readIntLE(msb byte, lsb byte) int16 {
|
||||
return int16(readUintLE(msb, lsb))
|
||||
}
|
||||
@@ -1,56 +0,0 @@
|
||||
// Package bmp280 provides a driver for the BMP280 digital temperature & pressure sensor by Bosch.
|
||||
//
|
||||
// Datasheet: https://www.bosch-sensortec.com/media/boschsensortec/downloads/datasheets/bst-bmp280-ds001.pdf
|
||||
package bmp280
|
||||
|
||||
// The I2C address which this device listens to.
|
||||
const Address = 0x77
|
||||
|
||||
// Registers
|
||||
const (
|
||||
REG_ID = 0xD0 // WHO_AM_I
|
||||
REG_RESET = 0xE0
|
||||
REG_STATUS = 0xF3
|
||||
REG_CTRL_MEAS = 0xF4
|
||||
REG_CONFIG = 0xF5
|
||||
REG_TEMP = 0xFA
|
||||
REG_PRES = 0xF7
|
||||
REG_CALI = 0x88
|
||||
|
||||
CHIP_ID = 0x58
|
||||
CMD_RESET = 0xB6
|
||||
)
|
||||
|
||||
const (
|
||||
SAMPLING_SKIPPED Oversampling = iota
|
||||
SAMPLING_1X
|
||||
SAMPLING_2X
|
||||
SAMPLING_4X
|
||||
SAMPLING_8X
|
||||
SAMPLING_16X
|
||||
)
|
||||
|
||||
const (
|
||||
MODE_SLEEP Mode = 0x00
|
||||
MODE_FORCED Mode = 0x01
|
||||
MODE_NORMAL Mode = 0x03
|
||||
)
|
||||
|
||||
const (
|
||||
STANDBY_1MS Standby = iota
|
||||
STANDBY_63MS
|
||||
STANDBY_125MS
|
||||
STANDBY_250MS
|
||||
STANDBY_500MS
|
||||
STANDBY_1000MS
|
||||
STANDBY_2000MS
|
||||
STANDBY_4000MS
|
||||
)
|
||||
|
||||
const (
|
||||
FILTER_OFF Filter = iota
|
||||
FILTER_2X
|
||||
FILTER_4X
|
||||
FILTER_8X
|
||||
FILTER_16X
|
||||
)
|
||||
@@ -1,249 +0,0 @@
|
||||
package bmp388
|
||||
|
||||
import (
|
||||
"errors"
|
||||
|
||||
"tinygo.org/x/drivers"
|
||||
)
|
||||
|
||||
var (
|
||||
errConfigWrite = errors.New("bmp388: failed to configure sensor, check connection")
|
||||
errConfig = errors.New("bmp388: there is a problem with the configuration, try reducing ODR")
|
||||
errCaliRead = errors.New("bmp388: failed to read calibration coefficient register")
|
||||
errSoftReset = errors.New("bmp388: failed to perform a soft reset")
|
||||
errNotConnected = errors.New("bmp388: not connected")
|
||||
)
|
||||
|
||||
type Oversampling byte
|
||||
type Mode byte
|
||||
type OutputDataRate byte
|
||||
type FilterCoefficient byte
|
||||
|
||||
// Config contains settings for filtering, sampling, and modes of operation
|
||||
type Config struct {
|
||||
Pressure Oversampling
|
||||
Temperature Oversampling
|
||||
Mode Mode
|
||||
ODR OutputDataRate
|
||||
IIR FilterCoefficient
|
||||
}
|
||||
|
||||
// Device wraps the I2C connection and configuration values for the BMP388
|
||||
type Device struct {
|
||||
bus drivers.I2C
|
||||
Address uint8
|
||||
cali calibrationCoefficients
|
||||
Config Config
|
||||
}
|
||||
|
||||
type calibrationCoefficients struct {
|
||||
// Temperature compensation
|
||||
t1 uint16
|
||||
t2 uint16
|
||||
t3 int8
|
||||
|
||||
// Pressure compensation
|
||||
p1 int16
|
||||
p2 int16
|
||||
p3 int8
|
||||
p4 int8
|
||||
p5 uint16
|
||||
p6 uint16
|
||||
p7 int8
|
||||
p8 int8
|
||||
p9 int16
|
||||
p10 int8
|
||||
p11 int8
|
||||
}
|
||||
|
||||
// New returns a bmp388 struct with the default I2C address. Configure must also be called after instanting
|
||||
func New(bus drivers.I2C) Device {
|
||||
return Device{
|
||||
bus: bus,
|
||||
Address: Address,
|
||||
}
|
||||
}
|
||||
|
||||
// Configure can enable settings on the BMP388 and reads the calibration coefficients
|
||||
func (d *Device) Configure(config Config) (err error) {
|
||||
d.Config = config
|
||||
|
||||
if d.Config == (Config{}) {
|
||||
d.Config.Mode = Normal
|
||||
}
|
||||
|
||||
// Turning on the pressure and temperature sensors and setting the measurement mode
|
||||
err = d.writeRegister(RegPwrCtrl, PwrPress|PwrTemp|byte(d.Config.Mode))
|
||||
|
||||
// Configure the oversampling, output data rate, and iir filter coefficient settings
|
||||
err = d.writeRegister(RegOSR, byte(d.Config.Pressure|d.Config.Temperature<<3))
|
||||
err = d.writeRegister(RegODR, byte(d.Config.ODR))
|
||||
err = d.writeRegister(RegIIR, byte(d.Config.IIR<<1))
|
||||
|
||||
if err != nil {
|
||||
return errConfigWrite
|
||||
}
|
||||
|
||||
// Check if there is a problem with the given configuration
|
||||
if d.configurationError() {
|
||||
return errConfig
|
||||
}
|
||||
|
||||
// Reading the builtin calibration coefficients and parsing them per the datasheet. The compensation formula given
|
||||
// in the datasheet is implemented in floating point
|
||||
buffer, err := d.readRegister(RegCali, 21)
|
||||
if err != nil {
|
||||
return errCaliRead
|
||||
}
|
||||
|
||||
d.cali.t1 = uint16(buffer[1])<<8 | uint16(buffer[0])
|
||||
d.cali.t2 = uint16(buffer[3])<<8 | uint16(buffer[2])
|
||||
d.cali.t3 = int8(buffer[4])
|
||||
|
||||
d.cali.p1 = int16(buffer[6])<<8 | int16(buffer[5])
|
||||
d.cali.p2 = int16(buffer[8])<<8 | int16(buffer[7])
|
||||
d.cali.p3 = int8(buffer[9])
|
||||
d.cali.p4 = int8(buffer[10])
|
||||
d.cali.p5 = uint16(buffer[12])<<8 | uint16(buffer[11])
|
||||
d.cali.p6 = uint16(buffer[14])<<8 | uint16(buffer[13])
|
||||
d.cali.p7 = int8(buffer[15])
|
||||
d.cali.p8 = int8(buffer[16])
|
||||
d.cali.p9 = int16(buffer[18])<<8 | int16(buffer[17])
|
||||
d.cali.p10 = int8(buffer[19])
|
||||
d.cali.p11 = int8(buffer[20])
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// Read the temperature registers and compute a compensation value for the temperature and pressure compensation
|
||||
// calculations. This is not the temperature itself.
|
||||
func (d *Device) tlinCompensate() (int64, error) {
|
||||
rawTemp, err := d.readSensorData(RegTemp)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
|
||||
// pulled from C driver: https://github.com/BoschSensortec/BMP3-Sensor-API/blob/master/bmp3.c
|
||||
partialData1 := rawTemp - (256 * int64(d.cali.t1))
|
||||
partialData2 := int64(d.cali.t2) * partialData1
|
||||
partialData3 := (partialData1 * partialData1)
|
||||
partialData4 := partialData3 * int64(d.cali.t3)
|
||||
partialData5 := (partialData2 * 262144) + partialData4
|
||||
return partialData5 / 4294967296, nil
|
||||
|
||||
}
|
||||
|
||||
// ReadTemperature returns the temperature in centicelsius, i.e 2426 / 100 = 24.26 C
|
||||
func (d *Device) ReadTemperature() (int32, error) {
|
||||
|
||||
tlin, err := d.tlinCompensate()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
|
||||
temp := (tlin * 25) / 16384
|
||||
return int32(temp), nil
|
||||
}
|
||||
|
||||
// ReadPressure returns the pressure in centipascals, i.e 10132520 / 100 = 101325.20 Pa
|
||||
func (d *Device) ReadPressure() (int32, error) {
|
||||
|
||||
tlin, err := d.tlinCompensate()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
rawPress, err := d.readSensorData(RegPress)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
|
||||
// code pulled from bmp388 C driver: https://github.com/BoschSensortec/BMP3-Sensor-API/blob/master/bmp3.c
|
||||
partialData1 := tlin * tlin
|
||||
partialData2 := partialData1 / 64
|
||||
partialData3 := (partialData2 * tlin) / 256
|
||||
partialData4 := (int64(d.cali.p8) * partialData3) / 32
|
||||
partialData5 := (int64(d.cali.p7) * partialData1) * 16
|
||||
partialData6 := (int64(d.cali.p6) * tlin) * 4194304
|
||||
offset := (int64(d.cali.p5) * 140737488355328) + partialData4 + partialData5 + partialData6
|
||||
partialData2 = (int64(d.cali.p4) * partialData3) / 32
|
||||
partialData4 = (int64(d.cali.p3) * partialData1) * 4
|
||||
partialData5 = (int64(d.cali.p2) - 16384) * tlin * 2097152
|
||||
sensitivity := ((int64(d.cali.p1) - 16384) * 70368744177664) + partialData2 + partialData4 + partialData5
|
||||
partialData1 = (sensitivity / 16777216) * rawPress
|
||||
partialData2 = int64(d.cali.p10) * tlin
|
||||
partialData3 = partialData2 + (65536 * int64(d.cali.p9))
|
||||
partialData4 = (partialData3 * rawPress) / 8192
|
||||
|
||||
// dividing by 10 followed by multiplying by 10
|
||||
// To avoid overflow caused by (pressure * partial_data4)
|
||||
partialData5 = (rawPress * (partialData4 / 10)) / 512
|
||||
partialData5 = partialData5 * 10
|
||||
partialData6 = (int64)(uint64(rawPress) * uint64(rawPress))
|
||||
partialData2 = (int64(d.cali.p11) * partialData6) / 65536
|
||||
partialData3 = (partialData2 * rawPress) / 128
|
||||
partialData4 = (offset / 4) + partialData1 + partialData5 + partialData3
|
||||
compPress := ((uint64(partialData4) * 25) / uint64(1099511627776))
|
||||
return int32(compPress), nil
|
||||
}
|
||||
|
||||
// SoftReset commands the BMP388 to reset of all user configuration settings
|
||||
func (d *Device) SoftReset() error {
|
||||
err := d.writeRegister(RegCmd, SoftReset)
|
||||
if err != nil {
|
||||
return errSoftReset
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// Connected tries to reach the bmp388 and check its chip id register. Returns true if it was able to successfully
|
||||
// communicate over i2c and returns the correct value
|
||||
func (d *Device) Connected() bool {
|
||||
data, err := d.readRegister(RegChipId, 1)
|
||||
return err == nil && data[0] == ChipId // returns true if i2c comm was good and response equals 0x50
|
||||
}
|
||||
|
||||
// SetMode changes the run mode of the sensor, NORMAL is the one to use for most cases. Use FORCED if you plan to take
|
||||
// measurements infrequently and want to conserve power. SLEEP will of course put the sensor to sleep
|
||||
func (d *Device) SetMode(mode Mode) error {
|
||||
d.Config.Mode = mode
|
||||
return d.writeRegister(RegPwrCtrl, PwrPress|PwrTemp|byte(d.Config.Mode))
|
||||
}
|
||||
|
||||
func (d *Device) readSensorData(register byte) (data int64, err error) {
|
||||
|
||||
if !d.Connected() {
|
||||
return 0, errNotConnected
|
||||
}
|
||||
|
||||
// put the sensor back into forced mode to get a reading, the sensor goes back to sleep after taking one read in
|
||||
// forced mode
|
||||
if d.Config.Mode != Normal {
|
||||
err = d.SetMode(Forced)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
bytes, err := d.readRegister(register, 3)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
data = int64(bytes[2])<<16 | int64(bytes[1])<<8 | int64(bytes[0])
|
||||
return
|
||||
}
|
||||
|
||||
// configurationError checks the register error for the configuration error bit. The bit is cleared on read by the bmp.
|
||||
func (d *Device) configurationError() bool {
|
||||
data, err := d.readRegister(RegErr, 1)
|
||||
return err == nil && (data[0]&0x04) != 0
|
||||
}
|
||||
|
||||
func (d *Device) readRegister(register byte, len int) (data []byte, err error) {
|
||||
data = make([]byte, len)
|
||||
err = d.bus.ReadRegister(d.Address, register, data)
|
||||
return
|
||||
}
|
||||
|
||||
func (d *Device) writeRegister(register byte, data byte) error {
|
||||
return d.bus.WriteRegister(d.Address, register, []byte{data})
|
||||
}
|
||||
@@ -1,84 +0,0 @@
|
||||
// Package bmp388 provides a driver for Bosch's BMP388 digital temperature & pressure sensor.
|
||||
// The datasheet can be found here: https://www.bosch-sensortec.com/media/boschsensortec/downloads/datasheets/bst-bmp388-ds001.pdf
|
||||
package bmp388
|
||||
|
||||
const Address byte = 0x77 // default I2C address
|
||||
|
||||
const (
|
||||
RegChipId byte = 0x00 // useful for checking the connection
|
||||
RegCali byte = 0x31 // pressure & temperature compensation calibration coefficients
|
||||
RegPress byte = 0x04 // start of pressure data registers
|
||||
RegTemp byte = 0x07 // start of temperature data registers
|
||||
RegPwrCtrl byte = 0x1B // measurement mode & pressure/temperature sensor power register
|
||||
RegOSR byte = 0x1C // oversampling settings register
|
||||
RegODR byte = 0x1D //
|
||||
RegCmd byte = 0x7E // miscellaneous command register
|
||||
RegStat byte = 0x03 // sensor status register
|
||||
RegErr byte = 0x02 // error status register
|
||||
RegIIR byte = 0x1F
|
||||
)
|
||||
|
||||
const (
|
||||
ChipId byte = 0x50 // correct response if reading from chip id register
|
||||
PwrPress byte = 0x01 // power on pressure sensor
|
||||
PwrTemp byte = 0x02 // power on temperature sensor
|
||||
SoftReset byte = 0xB6 // command to reset all user configuration
|
||||
DRDYPress byte = 0x20 // for checking if pressure data is ready
|
||||
DRDYTemp byte = 0x40 // for checking if pressure data is ready
|
||||
)
|
||||
|
||||
// The difference between forced and normal mode is the bmp388 goes to sleep after taking a measurement in forced mode.
|
||||
// Set it to forced if you intend to take measurements sporadically and want to save power. The driver will handle
|
||||
// waking the sensor up when the sensor is in forced mode.
|
||||
const (
|
||||
Normal Mode = 0x30
|
||||
Forced Mode = 0x16
|
||||
Sleep Mode = 0x00
|
||||
)
|
||||
|
||||
// Increasing sampling rate increases precision but also the wait time for measurements. The datasheet has a table of
|
||||
// suggested values for oversampling, output data rates, and iir filter coefficients by use case.
|
||||
const (
|
||||
Sampling1X Oversampling = iota
|
||||
Sampling2X
|
||||
Sampling4X
|
||||
Sampling8X
|
||||
Sampling16X
|
||||
Sampling32X
|
||||
)
|
||||
|
||||
// Output data rates in Hz. If increasing the sampling rates you need to decrease the output data rates, else the bmp388
|
||||
// will freeze and Configure() will return a configuration error message. In that case keep decreasing the data rate
|
||||
// until the bmp is happy
|
||||
const (
|
||||
Odr200 OutputDataRate = iota
|
||||
Odr100
|
||||
Odr50
|
||||
Odr25
|
||||
Odr12p5
|
||||
Odr6p25
|
||||
Odr3p1
|
||||
Odr1p5
|
||||
Odr0p78
|
||||
Odr0p39
|
||||
Odr0p2
|
||||
Odr0p1
|
||||
Odr0p05
|
||||
Odr0p02
|
||||
Odr0p01
|
||||
Odr0p006
|
||||
Odr0p003
|
||||
Odr0p0015
|
||||
)
|
||||
|
||||
// IIR filter coefficients, higher values means steadier measurements but slower reaction times
|
||||
const (
|
||||
Coeff0 FilterCoefficient = iota
|
||||
Coeff1
|
||||
Coeff3
|
||||
Coeff7
|
||||
Coeff15
|
||||
Coeff31
|
||||
Coeff63
|
||||
Coeff127
|
||||
)
|
||||
@@ -1,71 +0,0 @@
|
||||
// Package buzzer provides a very simplistic driver for a connected buzzer or low-fidelity speaker.
|
||||
//
|
||||
package buzzer // import "tinygo.org/x/drivers/buzzer"
|
||||
|
||||
import (
|
||||
"machine"
|
||||
|
||||
"time"
|
||||
)
|
||||
|
||||
// Device wraps a GPIO connection to a buzzer.
|
||||
type Device struct {
|
||||
pin machine.Pin
|
||||
High bool
|
||||
BPM float64
|
||||
}
|
||||
|
||||
// New returns a new buzzer driver given which pin to use
|
||||
func New(pin machine.Pin) Device {
|
||||
return Device{
|
||||
pin: pin,
|
||||
High: false,
|
||||
BPM: 96.0,
|
||||
}
|
||||
}
|
||||
|
||||
// On sets the buzzer to a high state.
|
||||
func (l *Device) On() (err error) {
|
||||
l.pin.Set(true)
|
||||
l.High = true
|
||||
return
|
||||
}
|
||||
|
||||
// Off sets the buzzer to a low state.
|
||||
func (l *Device) Off() (err error) {
|
||||
l.pin.Set(false)
|
||||
l.High = false
|
||||
return
|
||||
}
|
||||
|
||||
// Toggle sets the buzzer to the opposite of it's current state
|
||||
func (l *Device) Toggle() (err error) {
|
||||
if l.High {
|
||||
err = l.Off()
|
||||
} else {
|
||||
err = l.On()
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// Tone plays a tone of the requested frequency and duration.
|
||||
func (l *Device) Tone(hz, duration float64) (err error) {
|
||||
// calculation based off https://www.arduino.cc/en/Tutorial/Melody
|
||||
tone := (1.0 / (2.0 * hz)) * 1000000.0
|
||||
|
||||
tempo := ((60 / l.BPM) * (duration * 1000))
|
||||
|
||||
for i := 0.0; i < tempo*1000; i += tone * 2.0 {
|
||||
if err = l.On(); err != nil {
|
||||
return
|
||||
}
|
||||
time.Sleep(time.Duration(tone) * time.Microsecond)
|
||||
|
||||
if err = l.Off(); err != nil {
|
||||
return
|
||||
}
|
||||
time.Sleep(time.Duration(tone) * time.Microsecond)
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
-121
@@ -1,121 +0,0 @@
|
||||
package buzzer
|
||||
|
||||
const (
|
||||
Whole = 4
|
||||
Half = 2
|
||||
Quarter = 1
|
||||
Eighth = 0.500
|
||||
)
|
||||
|
||||
// The values seem like they are little off, so feel free to make corrections, as needed.
|
||||
const (
|
||||
Rest = 0
|
||||
C0 = 16.35
|
||||
Db0 = 17.32
|
||||
D0 = 18.35
|
||||
Eb0 = 19.45
|
||||
E0 = 20.60
|
||||
F0 = 21.83
|
||||
Gb0 = 23.12
|
||||
G0 = 24.50
|
||||
Ab0 = 25.96
|
||||
A0 = 27.50
|
||||
Bb0 = 29.14
|
||||
B0 = 30.87
|
||||
C1 = 32.70
|
||||
Db1 = 34.65
|
||||
D1 = 36.71
|
||||
Eb1 = 38.89
|
||||
E1 = 41.20
|
||||
F1 = 43.65
|
||||
Gb1 = 46.25
|
||||
G1 = 49.00
|
||||
Ab1 = 51.91
|
||||
A1 = 55.00
|
||||
Bb1 = 58.27
|
||||
B1 = 61.74
|
||||
C2 = 65.41
|
||||
Db2 = 69.30
|
||||
D2 = 73.42
|
||||
Eb2 = 77.78
|
||||
E2 = 82.41
|
||||
F2 = 87.31
|
||||
Gb2 = 92.50
|
||||
G2 = 98.00
|
||||
Ab2 = 103.83
|
||||
A2 = 110.00
|
||||
Bb2 = 116.54
|
||||
B2 = 123.47
|
||||
C3 = 130.81
|
||||
Db3 = 138.59
|
||||
D3 = 146.83
|
||||
Eb3 = 155.56
|
||||
E3 = 164.81
|
||||
F3 = 174.61
|
||||
Gb3 = 185.00
|
||||
G3 = 196.00
|
||||
Ab3 = 207.65
|
||||
A3 = 220.00
|
||||
Bb3 = 233.08
|
||||
B3 = 246.94
|
||||
C4 = 261.63
|
||||
Db4 = 277.18
|
||||
D4 = 293.66
|
||||
Eb4 = 311.13
|
||||
E4 = 329.63
|
||||
F4 = 349.23
|
||||
Gb4 = 369.99
|
||||
G4 = 392.00
|
||||
Ab4 = 415.30
|
||||
A4 = 440.00
|
||||
Bb4 = 466.16
|
||||
B4 = 493.88
|
||||
C5 = 523.25
|
||||
Db5 = 554.37
|
||||
D5 = 587.33
|
||||
Eb5 = 622.25
|
||||
E5 = 659.25
|
||||
F5 = 698.46
|
||||
Gb5 = 739.99
|
||||
G5 = 783.99
|
||||
Ab5 = 830.61
|
||||
A5 = 880.00
|
||||
Bb5 = 932.33
|
||||
B5 = 987.77
|
||||
C6 = 1046.50
|
||||
Db6 = 1108.73
|
||||
D6 = 1174.66
|
||||
Eb6 = 1244.51
|
||||
E6 = 1318.51
|
||||
F6 = 1396.91
|
||||
Gb6 = 1479.98
|
||||
G6 = 1567.98
|
||||
Ab6 = 1661.22
|
||||
A6 = 1760.00
|
||||
Bb6 = 1864.66
|
||||
B6 = 1975.53
|
||||
C7 = 2093.00
|
||||
Db7 = 2217.46
|
||||
D7 = 2349.32
|
||||
Eb7 = 2489.02
|
||||
E7 = 2637.02
|
||||
F7 = 2793.83
|
||||
Gb7 = 2959.96
|
||||
G7 = 3135.96
|
||||
Ab7 = 3322.44
|
||||
A7 = 3520.00
|
||||
Bb7 = 3729.31
|
||||
B7 = 3951.07
|
||||
C8 = 4186.01
|
||||
Db8 = 4434.92
|
||||
D8 = 4698.63
|
||||
Eb8 = 4978.03
|
||||
E8 = 5274.04
|
||||
F8 = 5587.65
|
||||
Gb8 = 5919.91
|
||||
G8 = 6271.93
|
||||
Ab8 = 6644.88
|
||||
A8 = 7040.00
|
||||
Bb8 = 7458.62
|
||||
B8 = 7902.13
|
||||
)
|
||||
@@ -1,116 +0,0 @@
|
||||
// Package dht provides a driver for DHTXX family temperature and humidity sensors.
|
||||
//
|
||||
// [1] Datasheet DHT11: https://www.mouser.com/datasheet/2/758/DHT11-Technical-Data-Sheet-Translated-Version-1143054.pdf
|
||||
// [2] Datasheet DHT22: https://cdn-shop.adafruit.com/datasheets/Digital+humidity+and+temperature+sensor+AM2302.pdf
|
||||
// Adafruit C++ driver: https://github.com/adafruit/DHT-sensor-library
|
||||
|
||||
package dht // import "tinygo.org/x/drivers/dht"
|
||||
|
||||
import (
|
||||
"encoding/binary"
|
||||
"machine"
|
||||
"time"
|
||||
)
|
||||
|
||||
// enum type for device type
|
||||
type DeviceType uint8
|
||||
|
||||
// DeviceType specific parsing of information received from the sensor
|
||||
func (d DeviceType) extractData(buf []byte) (temp int16, hum uint16) {
|
||||
if d == DHT11 {
|
||||
temp = int16(buf[2])
|
||||
if buf[3]&0x80 > 0 {
|
||||
temp = -1 - temp
|
||||
}
|
||||
temp *= 10
|
||||
temp += int16(buf[3] & 0x0f)
|
||||
hum = 10*uint16(buf[0]) + uint16(buf[1])
|
||||
} else {
|
||||
hum = binary.LittleEndian.Uint16(buf[0:2])
|
||||
temp = int16(buf[3])<<8 + int16(buf[2]&0x7f)
|
||||
if buf[2]&0x80 > 0 {
|
||||
temp = -temp
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// Celsius and Fahrenheit temperature scales
|
||||
type TemperatureScale uint8
|
||||
|
||||
func (t TemperatureScale) convertToFloat(temp int16) float32 {
|
||||
if t == C {
|
||||
return float32(temp) / 10
|
||||
} else {
|
||||
// Fahrenheit
|
||||
return float32(temp)*(9.0/50.) + 32.
|
||||
}
|
||||
}
|
||||
|
||||
// All functions return ErrorCode instance as error. This class can be used for more efficient error processing
|
||||
type ErrorCode uint8
|
||||
|
||||
const (
|
||||
startTimeout = time.Millisecond * 200
|
||||
startingLow = time.Millisecond * 20
|
||||
|
||||
DHT11 DeviceType = iota
|
||||
DHT22
|
||||
|
||||
C TemperatureScale = iota
|
||||
F
|
||||
|
||||
ChecksumError ErrorCode = iota
|
||||
NoSignalError
|
||||
NoDataError
|
||||
UpdateError
|
||||
UninitializedDataError
|
||||
)
|
||||
|
||||
// error interface implementation for ErrorCode
|
||||
func (e ErrorCode) Error() string {
|
||||
switch e {
|
||||
case ChecksumError:
|
||||
// DHT returns ChecksumError if all the data from the sensor was received, but the checksum does not match.
|
||||
return "checksum mismatch"
|
||||
case NoSignalError:
|
||||
// DHT returns NoSignalError if there was no reply from the sensor. Check sensor connection or the correct pin
|
||||
// sis chosen,
|
||||
return "no signal"
|
||||
case NoDataError:
|
||||
// DHT returns NoDataError if the connection was successfully initialized, but not all 40 bits from
|
||||
// the sensor is received
|
||||
return "no data"
|
||||
case UpdateError:
|
||||
// DHT returns UpdateError if ReadMeasurements function is called before time specified in UpdatePolicy or
|
||||
// less than 2 seconds after past measurement
|
||||
return "cannot update now"
|
||||
case UninitializedDataError:
|
||||
// DHT returns UninitializedDataError if user attempts to access data before first measurement
|
||||
return "no measurements done"
|
||||
}
|
||||
// should never be reached
|
||||
return "unknown error"
|
||||
}
|
||||
|
||||
// Update policy of the DHT device. UpdateTime cannot be shorter than 2 seconds. According to dht specification sensor
|
||||
// will return undefined data if update requested less than 2 seconds before last usage
|
||||
type UpdatePolicy struct {
|
||||
UpdateTime time.Duration
|
||||
UpdateAutomatically bool
|
||||
}
|
||||
|
||||
var (
|
||||
// timeout counter equal to number of ticks per 1 millisecond
|
||||
timeout counter
|
||||
)
|
||||
|
||||
func init() {
|
||||
timeout = cyclesPerMillisecond()
|
||||
}
|
||||
|
||||
func cyclesPerMillisecond() counter {
|
||||
freq := machine.CPUFrequency()
|
||||
freq /= 1000
|
||||
return counter(freq)
|
||||
}
|
||||
@@ -1,6 +0,0 @@
|
||||
// +build mimxrt1062 stm32f405 atsamd51 stm32f103xx k210 stm32f407
|
||||
|
||||
package dht // import "tinygo.org/x/drivers/dht"
|
||||
|
||||
// This file provides a definition of the counter for boards with frequency higher than 2^8 ticks per millisecond (>64MHz)
|
||||
type counter uint32
|
||||
@@ -1,6 +0,0 @@
|
||||
// +build arduino atmega1284p nrf52840 digispark nrf52 arduino_nano nrf51 atsamd21 fe310 arduino_nano33 circuitplay_express arduino_mega2560
|
||||
|
||||
package dht // import "tinygo.org/x/drivers/dht"
|
||||
|
||||
// This file provides a definition of the counter for boards with frequency lower than 2^8 ticks per millisecond (<64MHz)
|
||||
type counter uint16
|
||||
@@ -1,218 +0,0 @@
|
||||
// Package dht provides a driver for DHTXX family temperature and humidity sensors.
|
||||
//
|
||||
// [1] Datasheet DHT11: https://www.mouser.com/datasheet/2/758/DHT11-Technical-Data-Sheet-Translated-Version-1143054.pdf
|
||||
// [2] Datasheet DHT22: https://cdn-shop.adafruit.com/datasheets/Digital+humidity+and+temperature+sensor+AM2302.pdf
|
||||
// Adafruit C++ driver: https://github.com/adafruit/DHT-sensor-library
|
||||
|
||||
package dht // import "tinygo.org/x/drivers/dht"
|
||||
|
||||
import (
|
||||
"machine"
|
||||
"time"
|
||||
)
|
||||
|
||||
// DummyDevice provides a basic interface for DHT devices.
|
||||
type DummyDevice interface {
|
||||
ReadMeasurements() error
|
||||
Measurements() (temperature int16, humidity uint16, err error)
|
||||
Temperature() (int16, error)
|
||||
TemperatureFloat(scale TemperatureScale) (float32, error)
|
||||
Humidity() (uint16, error)
|
||||
HumidityFloat() (float32, error)
|
||||
}
|
||||
|
||||
// Basic implementation of the DummyDevice
|
||||
// This implementation takes measurements from sensor only with ReadMeasurements function
|
||||
// and does not provide a protection from too frequent calls for measurements.
|
||||
// Since taking measurements from the sensor is time consuming procedure and blocks interrupts,
|
||||
// user can avoid any hidden calls to the sensor.
|
||||
type device struct {
|
||||
pin machine.Pin
|
||||
|
||||
measurements DeviceType
|
||||
initialized bool
|
||||
|
||||
temperature int16
|
||||
humidity uint16
|
||||
}
|
||||
|
||||
// ReadMeasurements reads data from the sensor.
|
||||
// According to documentation pin should be always, but the t *device restores pin to the state before call.
|
||||
func (t *device) ReadMeasurements() error {
|
||||
// initial waiting
|
||||
state := powerUp(t.pin)
|
||||
defer t.pin.Set(state)
|
||||
err := t.read()
|
||||
if err == nil {
|
||||
t.initialized = true
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
// Getter for temperature. Temperature method returns temperature as it is sent by device.
|
||||
// The temperature is measured temperature in Celsius multiplied by 10.
|
||||
// If no successful measurements for this device was performed, returns UninitializedDataError.
|
||||
func (t *device) Temperature() (int16, error) {
|
||||
if !t.initialized {
|
||||
return 0, UninitializedDataError
|
||||
}
|
||||
return t.temperature, nil
|
||||
}
|
||||
|
||||
// Getter for temperature. TemperatureFloat returns temperature in a given scale.
|
||||
// If no successful measurements for this device was performed, returns UninitializedDataError.
|
||||
func (t *device) TemperatureFloat(scale TemperatureScale) (float32, error) {
|
||||
if !t.initialized {
|
||||
return 0, UninitializedDataError
|
||||
}
|
||||
return scale.convertToFloat(t.temperature), nil
|
||||
}
|
||||
|
||||
// Getter for humidity. Humidity returns humidity as it is sent by device.
|
||||
// The humidity is measured in percentages multiplied by 10.
|
||||
// If no successful measurements for this device was performed, returns UninitializedDataError.
|
||||
func (t *device) Humidity() (uint16, error) {
|
||||
if !t.initialized {
|
||||
return 0, UninitializedDataError
|
||||
}
|
||||
return t.humidity, nil
|
||||
}
|
||||
|
||||
// Getter for humidity. HumidityFloat returns humidity in percentages.
|
||||
// If no successful measurements for this device was performed, returns UninitializedDataError.
|
||||
func (t *device) HumidityFloat() (float32, error) {
|
||||
if !t.initialized {
|
||||
return 0, UninitializedDataError
|
||||
}
|
||||
return float32(t.humidity) / 10., nil
|
||||
}
|
||||
|
||||
// Perform initialization of the communication protocol.
|
||||
// Device lowers the voltage on pin for startingLow=20ms and starts listening for response
|
||||
// Section 5.2 in [1]
|
||||
func initiateCommunication(p machine.Pin) {
|
||||
// Send low signal to the device
|
||||
p.Configure(machine.PinConfig{Mode: machine.PinOutput})
|
||||
p.Low()
|
||||
time.Sleep(startingLow)
|
||||
// Set pin to high and wait for reply
|
||||
p.High()
|
||||
p.Configure(machine.PinConfig{Mode: machine.PinInput})
|
||||
}
|
||||
|
||||
// Measurements returns both measurements: temperature and humidity as they sent by the device.
|
||||
// If no successful measurements for this device was performed, returns UninitializedDataError.
|
||||
func (t *device) Measurements() (temperature int16, humidity uint16, err error) {
|
||||
if !t.initialized {
|
||||
return 0, 0, UninitializedDataError
|
||||
}
|
||||
temperature = t.temperature
|
||||
humidity = t.humidity
|
||||
err = nil
|
||||
return
|
||||
}
|
||||
|
||||
// Main routine that performs communication with the sensor
|
||||
func (t *device) read() error {
|
||||
// initialize loop variables
|
||||
|
||||
// buffer for the data sent by the sensor. Sensor sends 40 bits = 5 bytes
|
||||
bufferData := [5]byte{}
|
||||
buf := bufferData[:]
|
||||
|
||||
// We perform measurements of the signal from the sensor by counting low and high cycles.
|
||||
// The bit is determined by the relative length of the high signal to low signal.
|
||||
// For 1, high signal will be longer than low, for 0---low is longer.
|
||||
// See section 5.3 [1]
|
||||
signalsData := [80]counter{}
|
||||
signals := signalsData[:]
|
||||
|
||||
// Start communication protocol with sensor
|
||||
initiateCommunication(t.pin)
|
||||
// Wait for sensor's response and abort if sensor does not reply
|
||||
err := waitForDataTransmission(t.pin)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
// count low and high cycles for sensor's reply
|
||||
receiveSignals(t.pin, signals)
|
||||
|
||||
// process received signals and store the result in the buffer. Abort if data transmission was interrupted and not
|
||||
// all 40 bits were received
|
||||
err = t.extractData(signals[:], buf)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
// Compute checksum and compare it to the one in data. Abort if checksum is incorrect
|
||||
if !isValid(buf[:]) {
|
||||
return ChecksumError
|
||||
}
|
||||
|
||||
// Extract temperature and humidity data from buffer
|
||||
t.temperature, t.humidity = t.measurements.extractData(buf)
|
||||
return nil
|
||||
}
|
||||
|
||||
// receiveSignals counts number of low and high cycles. The execution is time critical, so the function disables
|
||||
// interrupts
|
||||
func receiveSignals(pin machine.Pin, result []counter) {
|
||||
i := uint8(0)
|
||||
machine.UART1.Interrupt.Disable()
|
||||
defer machine.UART1.Interrupt.Enable()
|
||||
for ; i < 40; i++ {
|
||||
result[i*2] = expectChange(pin, false)
|
||||
result[i*2+1] = expectChange(pin, true)
|
||||
}
|
||||
}
|
||||
|
||||
// extractData process signal counters and transforms them into bits.
|
||||
// if any of the bits were not received (timed-out), returns NoDataError
|
||||
func (t *device) extractData(signals []counter, buf []uint8) error {
|
||||
for i := uint8(0); i < 40; i++ {
|
||||
lowCycle := signals[i*2]
|
||||
highCycle := signals[i*2+1]
|
||||
if lowCycle == timeout || highCycle == timeout {
|
||||
return NoDataError
|
||||
}
|
||||
byteN := i >> 3
|
||||
buf[byteN] <<= 1
|
||||
if highCycle > lowCycle {
|
||||
buf[byteN] |= 1
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// waitForDataTransmission waits for reply from the sensor.
|
||||
// If no reply received, returns NoSignalError.
|
||||
// For more details, see section 5.2 in [1]
|
||||
func waitForDataTransmission(p machine.Pin) error {
|
||||
// wait for thermometer to pull down
|
||||
if expectChange(p, true) == timeout {
|
||||
return NoSignalError
|
||||
}
|
||||
//wait for thermometer to pull up
|
||||
if expectChange(p, false) == timeout {
|
||||
return NoSignalError
|
||||
}
|
||||
// wait for thermometer to pull down and start sending the data
|
||||
if expectChange(p, true) == timeout {
|
||||
return NoSignalError
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// Constructor function for a DummyDevice implementation.
|
||||
// This device provides full control to the user.
|
||||
// It does not do any hidden measurements calls and does not check
|
||||
// for 2 seconds delay between measurements.
|
||||
func NewDummyDevice(pin machine.Pin, deviceType DeviceType) DummyDevice {
|
||||
pin.High()
|
||||
return &device{
|
||||
pin: pin,
|
||||
measurements: deviceType,
|
||||
initialized: false,
|
||||
temperature: 0,
|
||||
humidity: 0,
|
||||
}
|
||||
}
|
||||
@@ -1,154 +0,0 @@
|
||||
// Package dht provides a driver for DHTXX family temperature and humidity sensors.
|
||||
//
|
||||
// [1] Datasheet DHT11: https://www.mouser.com/datasheet/2/758/DHT11-Technical-Data-Sheet-Translated-Version-1143054.pdf
|
||||
// [2] Datasheet DHT22: https://cdn-shop.adafruit.com/datasheets/Digital+humidity+and+temperature+sensor+AM2302.pdf
|
||||
// Adafruit C++ driver: https://github.com/adafruit/DHT-sensor-library
|
||||
|
||||
package dht // import "tinygo.org/x/drivers/dht"
|
||||
|
||||
import (
|
||||
"machine"
|
||||
"time"
|
||||
)
|
||||
|
||||
// Device interface provides main functionality of the DHTXX sensors.
|
||||
type Device interface {
|
||||
DummyDevice
|
||||
Configure(policy UpdatePolicy)
|
||||
}
|
||||
|
||||
// managedDevice struct provides time control and optional automatic data retrieval from the sensor.
|
||||
// It delegates all the functionality to device
|
||||
type managedDevice struct {
|
||||
t device
|
||||
lastUpdate time.Time
|
||||
policy UpdatePolicy
|
||||
}
|
||||
|
||||
// Measurements returns both measurements: temperature and humidity as they sent by the device.
|
||||
// Depending on the UpdatePolicy of the device may update cached measurements.
|
||||
func (m *managedDevice) Measurements() (temperature int16, humidity uint16, err error) {
|
||||
err = m.checkForUpdateOnDataRequest()
|
||||
if err != nil {
|
||||
return 0, 0, err
|
||||
}
|
||||
return m.t.Measurements()
|
||||
}
|
||||
|
||||
// Getter for temperature. Temperature method returns temperature as it is sent by device.
|
||||
// The temperature is measured temperature in Celsius multiplied by 10.
|
||||
// Depending on the UpdatePolicy of the device may update cached measurements.
|
||||
func (m *managedDevice) Temperature() (temp int16, err error) {
|
||||
err = m.checkForUpdateOnDataRequest()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
temp, err = m.t.Temperature()
|
||||
return
|
||||
}
|
||||
|
||||
func (m *managedDevice) checkForUpdateOnDataRequest() (err error) {
|
||||
// update if necessary
|
||||
if m.policy.UpdateAutomatically {
|
||||
err = m.ReadMeasurements()
|
||||
}
|
||||
// ignore error if the data was updated recently
|
||||
// interface comparison does not work in tinygo. Therefore need to cast to explicit type
|
||||
if code, ok := err.(ErrorCode); ok && code == UpdateError {
|
||||
err = nil
|
||||
}
|
||||
// add error if the data is not initialized
|
||||
if !m.t.initialized {
|
||||
err = UninitializedDataError
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
// Getter for temperature. TemperatureFloat returns temperature in a given scale.
|
||||
// Depending on the UpdatePolicy of the device may update cached measurements.
|
||||
func (m *managedDevice) TemperatureFloat(scale TemperatureScale) (float32, error) {
|
||||
err := m.checkForUpdateOnDataRequest()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return m.t.TemperatureFloat(scale)
|
||||
}
|
||||
|
||||
// Getter for humidity. Humidity returns humidity as it is sent by device.
|
||||
// The humidity is measured in percentages multiplied by 10.
|
||||
// Depending on the UpdatePolicy of the device may update cached measurements.
|
||||
func (m *managedDevice) Humidity() (hum uint16, err error) {
|
||||
err = m.checkForUpdateOnDataRequest()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return m.t.Humidity()
|
||||
}
|
||||
|
||||
// Getter for humidity. HumidityFloat returns humidity in percentages.
|
||||
// Depending on the UpdatePolicy of the device may update cached measurements.
|
||||
func (m *managedDevice) HumidityFloat() (float32, error) {
|
||||
err := m.checkForUpdateOnDataRequest()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return m.t.HumidityFloat()
|
||||
}
|
||||
|
||||
// ReadMeasurements reads data from the sensor.
|
||||
// The function will return UpdateError if it is called more frequently than specified in UpdatePolicy
|
||||
func (m *managedDevice) ReadMeasurements() (err error) {
|
||||
timestamp := time.Now()
|
||||
if !m.t.initialized || timestamp.Sub(m.lastUpdate) > m.policy.UpdateTime {
|
||||
err = m.t.ReadMeasurements()
|
||||
} else {
|
||||
err = UpdateError
|
||||
}
|
||||
if err == nil {
|
||||
m.lastUpdate = timestamp
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// Configure configures UpdatePolicy for Device.
|
||||
// Configure checks for policy.UpdateTime and prevent from updating more frequently than specified in [1][2]
|
||||
// to prevent undefined behaviour of the sensor.
|
||||
func (m *managedDevice) Configure(policy UpdatePolicy) {
|
||||
if policy.UpdateAutomatically && policy.UpdateTime < time.Second*2 {
|
||||
policy.UpdateTime = time.Second * 2
|
||||
}
|
||||
m.policy = policy
|
||||
}
|
||||
|
||||
// Constructor of the Device implementation.
|
||||
// This implementation updates data every 2 seconds during data access.
|
||||
func New(pin machine.Pin, deviceType DeviceType) Device {
|
||||
pin.High()
|
||||
return &managedDevice{
|
||||
t: device{
|
||||
pin: pin,
|
||||
measurements: deviceType,
|
||||
initialized: false,
|
||||
},
|
||||
lastUpdate: time.Time{},
|
||||
policy: UpdatePolicy{
|
||||
UpdateTime: time.Second * 2,
|
||||
UpdateAutomatically: true,
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
// Constructor of the Device implementation with given UpdatePolicy
|
||||
func NewWithPolicy(pin machine.Pin, deviceType DeviceType, updatePolicy UpdatePolicy) Device {
|
||||
pin.High()
|
||||
result := &managedDevice{
|
||||
t: device{
|
||||
pin: pin,
|
||||
measurements: deviceType,
|
||||
initialized: false,
|
||||
},
|
||||
lastUpdate: time.Time{},
|
||||
}
|
||||
result.Configure(updatePolicy)
|
||||
return result
|
||||
}
|
||||
-34
@@ -1,34 +0,0 @@
|
||||
package dht // import "tinygo.org/x/drivers/dht"
|
||||
|
||||
import (
|
||||
"machine"
|
||||
"time"
|
||||
)
|
||||
|
||||
// Check if the pin is disabled
|
||||
func powerUp(p machine.Pin) bool {
|
||||
state := p.Get()
|
||||
if !state {
|
||||
p.High()
|
||||
time.Sleep(startTimeout)
|
||||
}
|
||||
return state
|
||||
}
|
||||
|
||||
func expectChange(p machine.Pin, oldState bool) counter {
|
||||
cnt := counter(0)
|
||||
for ; p.Get() == oldState && cnt != timeout; cnt++ {
|
||||
}
|
||||
return cnt
|
||||
}
|
||||
|
||||
func checksum(buf []uint8) uint8 {
|
||||
return buf[4]
|
||||
}
|
||||
func computeChecksum(buf []uint8) uint8 {
|
||||
return buf[0] + buf[1] + buf[2] + buf[3]
|
||||
}
|
||||
|
||||
func isValid(buf []uint8) bool {
|
||||
return checksum(buf) == computeChecksum(buf)
|
||||
}
|
||||
@@ -1,14 +0,0 @@
|
||||
package drivers
|
||||
|
||||
import "image/color"
|
||||
|
||||
type Displayer interface {
|
||||
// Size returns the current size of the display.
|
||||
Size() (x, y int16)
|
||||
|
||||
// SetPizel modifies the internal buffer.
|
||||
SetPixel(x, y int16, c color.RGBA)
|
||||
|
||||
// Display sends the buffer (if any) to the screen.
|
||||
Display() error
|
||||
}
|
||||
+4
-42
@@ -1,42 +1,4 @@
|
||||
// Package drivers provides a collection of hardware drivers for TinyGo (https://tinygo.org)
|
||||
// for devices such as sensors and displays.
|
||||
//
|
||||
// Here is an example in TinyGo that uses the BMP180 digital barometer:
|
||||
//
|
||||
// package main
|
||||
//
|
||||
// import (
|
||||
// "time"
|
||||
// "machine"
|
||||
//
|
||||
// "tinygo.org/x/drivers/bmp180"
|
||||
// )
|
||||
//
|
||||
// func main() {
|
||||
// machine.I2C0.Configure(machine.I2CConfig{})
|
||||
// sensor := bmp180.New(machine.I2C0)
|
||||
// sensor.Configure()
|
||||
//
|
||||
// connected := sensor.Connected()
|
||||
// if !connected {
|
||||
// println("BMP180 not detected")
|
||||
// return
|
||||
// }
|
||||
// println("BMP180 detected")
|
||||
//
|
||||
// for {
|
||||
// temp, _ := sensor.ReadTemperature()
|
||||
// println("Temperature:", float32(temp)/1000, "°C")
|
||||
//
|
||||
// pressure, _ := sensor.ReadPressure()
|
||||
// println("Pressure", float32(pressure)/100000, "hPa")
|
||||
//
|
||||
// time.Sleep(2 * time.Second)
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// Each individual driver is contained within its own sub-package within this package and
|
||||
// there are no interdependencies in order to minimize the final size of compiled code that
|
||||
// uses any of these drivers.
|
||||
//
|
||||
package drivers // import "tinygo.org/x/drivers"
|
||||
// Package drivers is just a placeholder for the sub-packages.
|
||||
// It is here just to be able to install the package without errors using
|
||||
// go get -d github.com/ayke/tinygo-drivers
|
||||
package drivers
|
||||
|
||||
@@ -1,173 +0,0 @@
|
||||
// Package ds1307 provides a driver for the DS1307 RTC
|
||||
//
|
||||
// Datasheet:
|
||||
// https://datasheets.maximintegrated.com/en/ds/DS1307.pdf
|
||||
//
|
||||
package ds1307 // import "tinygo.org/x/drivers/ds1307"
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"time"
|
||||
|
||||
"tinygo.org/x/drivers"
|
||||
)
|
||||
|
||||
// Device wraps an I2C connection to a DS1307 device.
|
||||
type Device struct {
|
||||
bus drivers.I2C
|
||||
Address uint8
|
||||
AddressSRAM uint8
|
||||
}
|
||||
|
||||
// New creates a new DS1307 connection. I2C bus must be already configured.
|
||||
func New(bus drivers.I2C) Device {
|
||||
return Device{bus: bus,
|
||||
Address: uint8(I2CAddress),
|
||||
AddressSRAM: SRAMBeginAddres,
|
||||
}
|
||||
}
|
||||
|
||||
// SetTime sets the time and date
|
||||
func (d *Device) SetTime(t time.Time) error {
|
||||
data := make([]byte, 8)
|
||||
data[0] = uint8(TimeDate)
|
||||
data[1] = decToBcd(t.Second())
|
||||
data[2] = decToBcd(t.Minute())
|
||||
data[3] = decToBcd(t.Hour())
|
||||
data[4] = decToBcd(int(t.Weekday() + 1))
|
||||
data[5] = decToBcd(t.Day())
|
||||
data[6] = decToBcd(int(t.Month()))
|
||||
data[7] = decToBcd(t.Year() - 2000)
|
||||
err := d.bus.Tx(uint16(d.Address), data, nil)
|
||||
return err
|
||||
}
|
||||
|
||||
// ReadTime returns the date and time
|
||||
func (d *Device) ReadTime() (time.Time, error) {
|
||||
data := make([]byte, 8)
|
||||
err := d.bus.ReadRegister(d.Address, uint8(TimeDate), data)
|
||||
if err != nil {
|
||||
return time.Time{}, err
|
||||
}
|
||||
seconds := bcdToDec(data[0] & 0x7F)
|
||||
minute := bcdToDec(data[1])
|
||||
hour := hoursBCDToInt(data[2])
|
||||
day := bcdToDec(data[4])
|
||||
month := time.Month(bcdToDec(data[5]))
|
||||
year := bcdToDec(data[6])
|
||||
year += 2000
|
||||
|
||||
t := time.Date(year, month, day, hour, minute, seconds, 0, time.UTC)
|
||||
return t, nil
|
||||
}
|
||||
|
||||
// Seek sets the offset for the next Read or Write on SRAM to offset, interpreted
|
||||
// according to whence: 0 means relative to the origin of the SRAM, 1 means
|
||||
// relative to the current offset, and 2 means relative to the end.
|
||||
// returns new offset and error, if any
|
||||
func (d *Device) Seek(offset int64, whence int) (int64, error) {
|
||||
switch whence {
|
||||
case 0:
|
||||
whence = SRAMBeginAddres
|
||||
case 1:
|
||||
whence = int(d.AddressSRAM)
|
||||
case 2:
|
||||
whence = SRAMEndAddress
|
||||
default:
|
||||
return 0, errors.New("invalid starting point")
|
||||
}
|
||||
d.AddressSRAM = uint8(whence) + uint8(offset)
|
||||
if d.AddressSRAM > SRAMEndAddress {
|
||||
return 0, errors.New("EOF")
|
||||
}
|
||||
return int64(d.AddressSRAM), nil
|
||||
}
|
||||
|
||||
// Write writes len(data) bytes to SRAM
|
||||
// returns number of bytes written and error, if any
|
||||
func (d *Device) Write(data []byte) (n int, err error) {
|
||||
if int(d.AddressSRAM)+len(data)-1 > SRAMEndAddress {
|
||||
return 0, errors.New("writing outside of SRAM")
|
||||
}
|
||||
buffer := make([]byte, len(data)+1)
|
||||
buffer[0] = d.AddressSRAM
|
||||
copy(buffer[1:], data)
|
||||
err = d.bus.Tx(uint16(d.Address), buffer, nil)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
d.Seek(int64(len(data)), 1)
|
||||
return len(data), nil
|
||||
}
|
||||
|
||||
// Read reads len(data) from SRAM
|
||||
// returns number of bytes written and error, if any
|
||||
func (d *Device) Read(data []uint8) (n int, err error) {
|
||||
if int(d.AddressSRAM)+len(data)-1 > SRAMEndAddress {
|
||||
return 0, errors.New("EOF")
|
||||
}
|
||||
err = d.bus.ReadRegister(d.Address, d.AddressSRAM, data)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
d.Seek(int64(len(data)), 1)
|
||||
return len(data), nil
|
||||
}
|
||||
|
||||
// SetOscillatorFrequency sets output oscillator frequency
|
||||
// Available modes: SQW_OFF, SQW_1HZ, SQW_4KHZ, SQW_8KHZ, SQW_32KHZ
|
||||
func (d *Device) SetOscillatorFrequency(sqw uint8) error {
|
||||
data := []byte{uint8(Control), sqw}
|
||||
err := d.bus.Tx(uint16(d.Address), data, nil)
|
||||
return err
|
||||
}
|
||||
|
||||
// IsOscillatorRunning returns if the oscillator is running
|
||||
func (d *Device) IsOscillatorRunning() bool {
|
||||
data := []byte{0}
|
||||
err := d.bus.ReadRegister(d.Address, uint8(TimeDate), data)
|
||||
if err != nil {
|
||||
return false
|
||||
}
|
||||
return (data[0] & (1 << CH)) == 0
|
||||
}
|
||||
|
||||
// SetOscillatorRunning starts/stops internal oscillator by toggling halt bit
|
||||
func (d *Device) SetOscillatorRunning(running bool) error {
|
||||
data := make([]byte, 3)
|
||||
err := d.bus.ReadRegister(d.Address, uint8(TimeDate), data)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if running {
|
||||
data[0] &^= (1 << CH)
|
||||
} else {
|
||||
data[0] |= (1 << CH)
|
||||
}
|
||||
data[1], data[0] = data[0], uint8(TimeDate)
|
||||
err = d.bus.Tx(uint16(d.Address), data[:2], nil)
|
||||
return err
|
||||
}
|
||||
|
||||
// decToBcd converts int to BCD
|
||||
func decToBcd(dec int) uint8 {
|
||||
return uint8(dec + 6*(dec/10))
|
||||
}
|
||||
|
||||
// bcdToDec converts BCD to int
|
||||
func bcdToDec(bcd uint8) int {
|
||||
return int(bcd - 6*(bcd>>4))
|
||||
}
|
||||
|
||||
// hoursBCDToInt converts the BCD hours to int
|
||||
func hoursBCDToInt(value uint8) (hour int) {
|
||||
if value&0x40 != 0x00 {
|
||||
hour = bcdToDec(value & 0x1F)
|
||||
if (value & 0x20) != 0x00 {
|
||||
hour += 12
|
||||
}
|
||||
} else {
|
||||
hour = bcdToDec(value)
|
||||
}
|
||||
return
|
||||
}
|
||||
@@ -1,19 +0,0 @@
|
||||
package ds1307
|
||||
|
||||
const (
|
||||
I2CAddress = 0x68
|
||||
TimeDate = 0x00
|
||||
Control = 0x7
|
||||
//CH is oscillator halt bit
|
||||
CH = 0x7
|
||||
SRAMBeginAddres = 0x8
|
||||
SRAMEndAddress = 0x3F
|
||||
)
|
||||
|
||||
const (
|
||||
SQW_OFF = 0x0
|
||||
SQW_1HZ = 0x10
|
||||
SQW_4KHZ = 0x11
|
||||
SQW_8KHZ = 0x12
|
||||
SQW_32KHZ = 0x13
|
||||
)
|
||||
@@ -1,167 +0,0 @@
|
||||
// Package ds3231 provides a driver for the DS3231 RTC
|
||||
//
|
||||
// Datasheet:
|
||||
// https://datasheets.maximintegrated.com/en/ds/DS3231.pdf
|
||||
package ds3231 // import "tinygo.org/x/drivers/ds3231"
|
||||
|
||||
import (
|
||||
"time"
|
||||
|
||||
"tinygo.org/x/drivers"
|
||||
)
|
||||
|
||||
type Mode uint8
|
||||
|
||||
// Device wraps an I2C connection to a DS3231 device.
|
||||
type Device struct {
|
||||
bus drivers.I2C
|
||||
Address uint16
|
||||
}
|
||||
|
||||
// New creates a new DS3231 connection. The I2C bus must already be
|
||||
// configured.
|
||||
//
|
||||
// This function only creates the Device object, it does not touch the device.
|
||||
func New(bus drivers.I2C) Device {
|
||||
return Device{
|
||||
bus: bus,
|
||||
Address: Address,
|
||||
}
|
||||
}
|
||||
|
||||
// Configure sets up the device for communication
|
||||
func (d *Device) Configure() bool {
|
||||
return true
|
||||
}
|
||||
|
||||
// IsTimeValid return true/false is the time in the device is valid
|
||||
func (d *Device) IsTimeValid() bool {
|
||||
data := []byte{0}
|
||||
err := d.bus.ReadRegister(uint8(d.Address), REG_STATUS, data)
|
||||
if err != nil {
|
||||
return false
|
||||
}
|
||||
return (data[0] & (1 << OSF)) == 0x00
|
||||
}
|
||||
|
||||
// IsRunning returns if the oscillator is running
|
||||
func (d *Device) IsRunning() bool {
|
||||
data := []uint8{0}
|
||||
err := d.bus.ReadRegister(uint8(d.Address), REG_CONTROL, data)
|
||||
if err != nil {
|
||||
return false
|
||||
}
|
||||
return (data[0] & (1 << EOSC)) == 0x00
|
||||
}
|
||||
|
||||
// SetRunning starts the internal oscillator
|
||||
func (d *Device) SetRunning(isRunning bool) error {
|
||||
data := []uint8{0}
|
||||
err := d.bus.ReadRegister(uint8(d.Address), REG_CONTROL, data)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if isRunning {
|
||||
data[0] &^= uint8(1 << EOSC)
|
||||
} else {
|
||||
data[0] |= 1 << EOSC
|
||||
}
|
||||
err = d.bus.WriteRegister(uint8(d.Address), REG_CONTROL, data)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// SetTime sets the date and time in the DS3231
|
||||
func (d *Device) SetTime(dt time.Time) error {
|
||||
data := []byte{0}
|
||||
err := d.bus.ReadRegister(uint8(d.Address), REG_STATUS, data)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
data[0] &^= 1 << OSF
|
||||
err = d.bus.WriteRegister(uint8(d.Address), REG_STATUS, data)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
data = make([]uint8, 7)
|
||||
data[0] = uint8ToBCD(uint8(dt.Second()))
|
||||
data[1] = uint8ToBCD(uint8(dt.Minute()))
|
||||
data[2] = uint8ToBCD(uint8(dt.Hour()))
|
||||
|
||||
year := uint8(dt.Year() - 2000)
|
||||
centuryFlag := uint8(0)
|
||||
if year >= 100 {
|
||||
year -= 100
|
||||
centuryFlag = 1 << 7
|
||||
}
|
||||
|
||||
data[3] = uint8ToBCD(uint8(dt.Weekday()))
|
||||
data[4] = uint8ToBCD(uint8(dt.Day()))
|
||||
data[5] = uint8ToBCD(uint8(dt.Month()) | centuryFlag)
|
||||
data[6] = uint8ToBCD(year)
|
||||
|
||||
err = d.bus.WriteRegister(uint8(d.Address), REG_TIMEDATE, data)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// ReadTime returns the date and time
|
||||
func (d *Device) ReadTime() (dt time.Time, err error) {
|
||||
data := make([]uint8, 7)
|
||||
err = d.bus.ReadRegister(uint8(d.Address), REG_TIMEDATE, data)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
second := bcdToInt(data[0] & 0x7F)
|
||||
minute := bcdToInt(data[1])
|
||||
hour := hoursBCDToInt(data[2])
|
||||
day := bcdToInt(data[4])
|
||||
monthRaw := data[5]
|
||||
year := bcdToInt(data[6]) + 2000
|
||||
if monthRaw&(1<<7) != 0x00 {
|
||||
year += 100
|
||||
}
|
||||
month := time.Month(bcdToInt(monthRaw & 0x7F))
|
||||
|
||||
dt = time.Date(year, month, day, hour, minute, second, 0, time.UTC)
|
||||
return
|
||||
}
|
||||
|
||||
// ReadTemperature returns the temperature in millicelsius (mC)
|
||||
func (d *Device) ReadTemperature() (int32, error) {
|
||||
data := make([]uint8, 2)
|
||||
err := d.bus.ReadRegister(uint8(d.Address), REG_TEMP, data)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return int32(data[0])*1000 + int32((data[1]>>6)*25)*10, nil
|
||||
}
|
||||
|
||||
// uint8ToBCD converts a byte to BCD for the DS3231
|
||||
func uint8ToBCD(value uint8) uint8 {
|
||||
return value + 6*(value/10)
|
||||
}
|
||||
|
||||
// bcdToInt converts BCD from the DS3231 to int
|
||||
func bcdToInt(value uint8) int {
|
||||
return int(value - 6*(value>>4))
|
||||
}
|
||||
|
||||
// hoursBCDToInt converts the BCD hours to int
|
||||
func hoursBCDToInt(value uint8) (hour int) {
|
||||
if value&0x40 != 0x00 {
|
||||
hour = bcdToInt(value & 0x1F)
|
||||
if (value & 0x20) != 0x00 {
|
||||
hour += 12
|
||||
}
|
||||
} else {
|
||||
hour = bcdToInt(value)
|
||||
}
|
||||
return
|
||||
}
|
||||
@@ -1,48 +0,0 @@
|
||||
package ds3231
|
||||
|
||||
// The I2C address which this device listens to.
|
||||
const Address = 0x68
|
||||
|
||||
// Registers
|
||||
const (
|
||||
REG_TIMEDATE = 0x00
|
||||
REG_ALARMONE = 0x07
|
||||
REG_ALARMTWO = 0x0B
|
||||
|
||||
REG_CONTROL = 0x0E
|
||||
REG_STATUS = 0x0F
|
||||
REG_AGING = 0x10
|
||||
|
||||
REG_TEMP = 0x11
|
||||
|
||||
REG_ALARMONE_SIZE = 4
|
||||
REG_ALARMTWO_SIZE = 3
|
||||
|
||||
// DS3231 Control Register Bits
|
||||
A1IE = 0
|
||||
A2IE = 1
|
||||
INTCN = 2
|
||||
RS1 = 3
|
||||
RS2 = 4
|
||||
CONV = 5
|
||||
BBSQW = 6
|
||||
EOSC = 7
|
||||
|
||||
// DS3231 Status Register Bits
|
||||
A1F = 0
|
||||
A2F = 1
|
||||
BSY = 2
|
||||
EN32KHZ = 3
|
||||
OSF = 7
|
||||
|
||||
AlarmFlag_Alarm1 = 0x01
|
||||
AlarmFlag_Alarm2 = 0x02
|
||||
AlarmFlag_AlarmBoth = 0x03
|
||||
|
||||
None Mode = 0
|
||||
BatteryBackup Mode = 1
|
||||
Clock Mode = 2
|
||||
AlarmOne Mode = 3
|
||||
AlarmTwo Mode = 4
|
||||
ModeAlarmBoth Mode = 5
|
||||
)
|
||||
@@ -1,160 +0,0 @@
|
||||
// Package easystepper provides a simple driver to rotate a 4-wire stepper motor.
|
||||
package easystepper // import "tinygo.org/x/drivers/easystepper"
|
||||
|
||||
import (
|
||||
"machine"
|
||||
"time"
|
||||
)
|
||||
|
||||
// Device holds the pins and the delay between steps
|
||||
type Device struct {
|
||||
pins [4]machine.Pin
|
||||
stepDelay int32
|
||||
stepNumber uint8
|
||||
}
|
||||
|
||||
// DualDevice holds information for controlling 2 motors
|
||||
type DualDevice struct {
|
||||
devices [2]Device
|
||||
}
|
||||
|
||||
// New returns a new easystepper driver given 4 pins, number of steps and rpm
|
||||
func New(pin1, pin2, pin3, pin4 machine.Pin, steps int32, rpm int32) Device {
|
||||
return Device{
|
||||
pins: [4]machine.Pin{pin1, pin2, pin3, pin4},
|
||||
stepDelay: 60000000 / (steps * rpm),
|
||||
}
|
||||
}
|
||||
|
||||
// Configure configures the pins of the Device
|
||||
func (d *Device) Configure() {
|
||||
for _, pin := range d.pins {
|
||||
pin.Configure(machine.PinConfig{Mode: machine.PinOutput})
|
||||
}
|
||||
}
|
||||
|
||||
// NewDual returns a new dual easystepper driver given 8 pins, number of steps and rpm
|
||||
func NewDual(pin1, pin2, pin3, pin4, pin5, pin6, pin7, pin8 machine.Pin, steps int32, rpm int32) DualDevice {
|
||||
var dual DualDevice
|
||||
dual.devices[0] = Device{
|
||||
pins: [4]machine.Pin{pin1, pin2, pin3, pin4},
|
||||
stepDelay: 60000000 / (steps * rpm),
|
||||
}
|
||||
dual.devices[1] = Device{
|
||||
pins: [4]machine.Pin{pin5, pin6, pin7, pin8},
|
||||
stepDelay: 60000000 / (steps * rpm),
|
||||
}
|
||||
return dual
|
||||
}
|
||||
|
||||
// Configure configures the pins of the DualDevice
|
||||
func (d *DualDevice) Configure() {
|
||||
d.devices[0].Configure()
|
||||
d.devices[1].Configure()
|
||||
}
|
||||
|
||||
// Move rotates the motor the number of given steps
|
||||
// (negative steps will rotate it the opposite direction)
|
||||
func (d *Device) Move(steps int32) {
|
||||
direction := steps > 0
|
||||
if steps < 0 {
|
||||
steps = -steps
|
||||
}
|
||||
steps += int32(d.stepNumber)
|
||||
var s int32
|
||||
d.stepMotor(d.stepNumber)
|
||||
for s = int32(d.stepNumber); s < steps; s++ {
|
||||
time.Sleep(time.Duration(d.stepDelay) * time.Microsecond)
|
||||
d.moveDirectionSteps(direction, s)
|
||||
}
|
||||
}
|
||||
|
||||
// Off turns off all motor pins
|
||||
func (d *Device) Off() {
|
||||
for _, pin := range d.pins {
|
||||
pin.Low()
|
||||
}
|
||||
}
|
||||
|
||||
// Move rotates the motors the number of given steps
|
||||
// (negative steps will rotate it the opposite direction)
|
||||
func (d *DualDevice) Move(stepsA, stepsB int32) {
|
||||
min := uint8(1)
|
||||
max := uint8(0)
|
||||
var directions [2]bool
|
||||
var minStep int32
|
||||
|
||||
directions[0] = stepsA > 0
|
||||
directions[1] = stepsB > 0
|
||||
if stepsA < 0 {
|
||||
stepsA = -stepsA
|
||||
}
|
||||
if stepsB < 0 {
|
||||
stepsB = -stepsB
|
||||
}
|
||||
if stepsB > stepsA {
|
||||
stepsA, stepsB = stepsB, stepsA
|
||||
max, min = min, max
|
||||
}
|
||||
d.devices[0].stepMotor(d.devices[0].stepNumber)
|
||||
d.devices[1].stepMotor(d.devices[1].stepNumber)
|
||||
stepsA += int32(d.devices[max].stepNumber)
|
||||
minStep = int32(d.devices[min].stepNumber)
|
||||
for s := int32(d.devices[max].stepNumber); s < stepsA; s++ {
|
||||
time.Sleep(time.Duration(d.devices[0].stepDelay) * time.Microsecond)
|
||||
d.devices[max].moveDirectionSteps(directions[max], s)
|
||||
|
||||
if ((s * stepsB) / stepsA) > minStep {
|
||||
minStep++
|
||||
d.devices[min].moveDirectionSteps(directions[min], minStep)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Off turns off all motor pins
|
||||
func (d *DualDevice) Off() {
|
||||
d.devices[0].Off()
|
||||
d.devices[1].Off()
|
||||
}
|
||||
|
||||
// stepMotor changes the pins' state to the correct step
|
||||
func (d *Device) stepMotor(step uint8) {
|
||||
switch step {
|
||||
case 0:
|
||||
d.pins[0].High()
|
||||
d.pins[1].Low()
|
||||
d.pins[2].High()
|
||||
d.pins[3].Low()
|
||||
break
|
||||
case 1:
|
||||
d.pins[0].Low()
|
||||
d.pins[1].High()
|
||||
d.pins[2].High()
|
||||
d.pins[3].Low()
|
||||
break
|
||||
case 2:
|
||||
d.pins[0].Low()
|
||||
d.pins[1].High()
|
||||
d.pins[2].Low()
|
||||
d.pins[3].High()
|
||||
break
|
||||
case 3:
|
||||
d.pins[0].High()
|
||||
d.pins[1].Low()
|
||||
d.pins[2].Low()
|
||||
d.pins[3].High()
|
||||
break
|
||||
}
|
||||
d.stepNumber = step
|
||||
}
|
||||
|
||||
// moveDirectionSteps uses the direction to calculate the correct step and change the motor to it.
|
||||
// Direction true: 0, 1, 2, 3, 0, 1, 2, ...
|
||||
// Direction false: 0, 3, 2, 1, 0, 3, 2, ...
|
||||
func (d *Device) moveDirectionSteps(direction bool, step int32) {
|
||||
if direction {
|
||||
d.stepMotor(uint8(step % 4))
|
||||
} else {
|
||||
d.stepMotor(uint8((step + 2*(step%2)) % 4))
|
||||
}
|
||||
}
|
||||
@@ -1,84 +0,0 @@
|
||||
# ESP-AT Driver
|
||||
|
||||
This package provides a driver to use a separate connected WiFi processor either the ESP8266 or the ESP32 from Espressif.
|
||||
|
||||
The way this driver works is by using the UART interface to communicate with the WiFi chip using the Espressif AT command set.
|
||||
|
||||
## ESP-AT Firmware Installation
|
||||
|
||||
In order to use this driver, you must have the ESP-AT firmware installed on the ESP8266/ESP32 chip.
|
||||
|
||||
### Installing on Arduino Nano33 IoT
|
||||
|
||||
In order to install the needed firmware on the Arduino Nano33 IoT board's built-in NINA W102 chip, you will need to use the `arduino-nano33-iot` branch of this fork of the firmware:
|
||||
|
||||
https://github.com/hybridgroup/esp32-at
|
||||
|
||||
To flash this firmware on the Arduino Nano33 IoT you will need to follow the following procedure:
|
||||
|
||||
- Install _Arduino SAMD Boards_ from the Boards Manager.
|
||||
- Install _WiFiNANO_ from the Library Manager.
|
||||
- Using the normal Arduino software, load the `SerialNINAPassthrough` sketch on to the board (in File -> Examples -> WiFiNINA-> Tools).
|
||||
- Flash the NINA 102 firmware using the `make flash` command in the https://github.com/hybridgroup/esp32-at repo.
|
||||
|
||||
You only need to do this one time, and then the correct ESP-AT firmware will be on the NINA chip, and you can just flash the Arduino Nano33 IoT board using TinyGo. We should be able to remove some of these step in a future release of this software.
|
||||
|
||||
### Installing on ESP32
|
||||
|
||||
The official repository for the ESP-AT for the ESP32 processor is located here:
|
||||
|
||||
https://github.com/espressif/esp32-at
|
||||
|
||||
Your best option is to follow the instructions in the official repo.
|
||||
|
||||
### Installing on ESP8266
|
||||
|
||||
The official repository for the AT command set firmware for the ESP8266 processor is located here:
|
||||
|
||||
https://github.com/espressif/ESP8266_NONOS_SDK
|
||||
|
||||
First clone the repo:
|
||||
|
||||
```shell
|
||||
git clone https://github.com/espressif/ESP8266_NONOS_SDK.git
|
||||
```
|
||||
|
||||
You will also need to install the Espressif `esptool` to flash this firmware on your ESP8266:
|
||||
|
||||
https://github.com/espressif/esptool
|
||||
|
||||
Once you have obtained the binary code, and installed `esptool`, you can flash the ESP8266.
|
||||
|
||||
Here is an example shell script that flashes a Wemos D1 Mini board:
|
||||
|
||||
|
||||
```python
|
||||
#!/bin/sh
|
||||
SPToolDir="$HOME/.local/lib/python2.7/site-packages"
|
||||
FirmwareDir="$HOME/Development/ESP8266_NONOS_SDK"
|
||||
cd "$SPToolDir"
|
||||
port=/dev/ttyUSB0
|
||||
if [ ! -c $port ]; then
|
||||
port=/dev/ttyUSB0
|
||||
fi
|
||||
if [ ! -c $port ]; then
|
||||
echo "No device appears to be plugged in. Stopping."
|
||||
fi
|
||||
printf "Writing AT firmware to the Wemos D1 Mini in 3..."
|
||||
sleep 1; printf "2..."
|
||||
sleep 1; printf "1..."
|
||||
sleep 1; echo "done."
|
||||
echo "Erasing the flash first"
|
||||
esptool.py --port $port erase_flash
|
||||
esptool.py --port /dev/ttyUSB0 --baud 115200 \
|
||||
write_flash -fm dio -ff 20m -fs detect \
|
||||
0x0000 "$FirmwareDir/bin/boot_v1.7.bin" \
|
||||
0x01000 "$FirmwareDir/bin/at/512+512/user1.1024.new.2.bin" \
|
||||
0x3fc000 "$FirmwareDir/bin/esp_init_data_default_v05.bin" \
|
||||
0x7e000 "$FirmwareDir/bin/blank.bin" \
|
||||
0x3fe000 "$FirmwareDir/bin/blank.bin"
|
||||
|
||||
echo "Check the boot by typing: miniterm $port 74800"
|
||||
echo " and then resetting. Use Ctrl-] to quit miniterm."
|
||||
|
||||
```
|
||||
@@ -1,111 +0,0 @@
|
||||
package espat
|
||||
|
||||
// Basic AT commands
|
||||
const (
|
||||
// Test that the device is working.
|
||||
Test = ""
|
||||
|
||||
// Restart module
|
||||
Restart = "+RST"
|
||||
|
||||
// Version show info about the current software version.
|
||||
Version = "+GMR"
|
||||
|
||||
// Enter deep-sleep mode
|
||||
Sleep = "+GSLP"
|
||||
|
||||
// Configure echo.
|
||||
EchoConfig = "E"
|
||||
|
||||
// EchoConfigOn
|
||||
EchoConfigOn = EchoConfig + "1"
|
||||
|
||||
// EchoConfigOff
|
||||
EchoConfigOff = EchoConfig + "0"
|
||||
|
||||
// Configure UART
|
||||
UARTConfig = "+UART"
|
||||
)
|
||||
|
||||
// WiFi commands.
|
||||
const (
|
||||
// WiFi mode (sta/AP/sta+AP)
|
||||
WifiMode = "+CWMODE"
|
||||
|
||||
// Connect to an access point.
|
||||
ConnectAP = "+CWJAP"
|
||||
|
||||
// List available AP's
|
||||
ListAP = "+CWLAP"
|
||||
|
||||
// Disconnect from the current AP
|
||||
Disconnect = "+CWQAP"
|
||||
|
||||
// Set softAP configuration. This also activates the ESP8266/ESP32 to act as an access point.
|
||||
// On the ESP8266 the settings will not be saved in flash memory, so they will be forgotten on next reset.
|
||||
// On the ESP32 the settings WILL be saved in flash memory, so they will be used on next reset.
|
||||
SoftAPConfigCurrent = "+CWSAP"
|
||||
|
||||
// Set softAP configuration. This also activates the ESP8266/ESP32 to act as an access point.
|
||||
// On the ESP8266 the settings will not be saved in flash memory, so they will be forgotten on next reset.
|
||||
// On the ESP32 the settings WILL be saved in flash memory, so they will be used on next reset.
|
||||
SoftAPConfigFlash = "+CWSAP"
|
||||
|
||||
// List station IP's connected to softAP
|
||||
ListConnectedIP = "+CWLIF"
|
||||
|
||||
// Enable/disable DHCP
|
||||
DHCPConfig = "+CWDHCP"
|
||||
|
||||
// Set MAC address of station
|
||||
SetStationMACAddress = "+CIPSTAMAC"
|
||||
|
||||
// Set MAC address of softAP
|
||||
SetAPMACAddress = "+CIPAPMAC"
|
||||
|
||||
// Set IP address of ESP8266/ESP32 station
|
||||
SetStationIP = "+CIPSTA"
|
||||
|
||||
// Set IP address of ESP8266/ESP32 when acting as access point.
|
||||
// On the ESP8266 the IP address will not be saved in flash memory, so it will be forgotten on next reset.
|
||||
// On the ESP32 the IP address WILL be saved in flash memory, so it will be used on next reset.
|
||||
SetSoftAPIPCurrent = "+CIPAP"
|
||||
|
||||
// Set IP address of ESP8266/ESP32 when acting as access point.
|
||||
// On the ESP8266 the IP address will not be saved in flash memory, so it will be forgotten on next reset.
|
||||
// On the ESP32 the IP address WILL be saved in flash memory, so it will be used on next reset.
|
||||
SetSoftAPIPFlash = "+CIPAP"
|
||||
)
|
||||
|
||||
// TCP/IP commands
|
||||
const (
|
||||
// Get connection status
|
||||
TCPStatus = "+CIPSTATUS"
|
||||
|
||||
// Establish TCP connection or register UDP port
|
||||
TCPConnect = "+CIPSTART"
|
||||
|
||||
// DNS Lookup
|
||||
TCPDNSLookup = "+CIPDOMAIN"
|
||||
|
||||
// Send Data
|
||||
TCPSend = "+CIPSEND"
|
||||
|
||||
// Close TCP/UDP connection
|
||||
TCPClose = "+CIPCLOSE"
|
||||
|
||||
// Get local IP address
|
||||
GetLocalIP = "+CIFSR"
|
||||
|
||||
// Set multiple connections mode
|
||||
TCPMultiple = "+CIPMUX"
|
||||
|
||||
// Configure as server
|
||||
ServerConfig = "+CIPSERVER"
|
||||
|
||||
// Set transmission mode
|
||||
TransmissionMode = "+CIPMODE"
|
||||
|
||||
// Set timeout when ESP8266/ESP32 runs as TCP server
|
||||
SetServerTimeout = "+CIPSTO"
|
||||
)
|
||||
-222
@@ -1,222 +0,0 @@
|
||||
// Package espat implements TCP/UDP wireless communication over serial
|
||||
// with a separate ESP8266 or ESP32 board using the Espressif AT command set
|
||||
// across a UART interface.
|
||||
//
|
||||
// In order to use this driver, the ESP8266/ESP32 must be flashed with firmware
|
||||
// supporting the AT command set. Many ESP8266/ESP32 chips already have this firmware
|
||||
// installed by default. You will need to install this firmware if you have an
|
||||
// ESP8266 that has been flashed with NodeMCU (Lua) or Arduino firmware.
|
||||
//
|
||||
// AT Command Core repository:
|
||||
// https://github.com/espressif/esp32-at
|
||||
//
|
||||
// Datasheet:
|
||||
// https://www.espressif.com/sites/default/files/documentation/0a-esp8266ex_datasheet_en.pdf
|
||||
//
|
||||
// AT command set:
|
||||
// https://www.espressif.com/sites/default/files/documentation/4a-esp8266_at_instruction_set_en.pdf
|
||||
//
|
||||
package espat // import "tinygo.org/x/drivers/espat"
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"tinygo.org/x/drivers"
|
||||
"tinygo.org/x/drivers/net"
|
||||
)
|
||||
|
||||
// Device wraps UART connection to the ESP8266/ESP32.
|
||||
type Device struct {
|
||||
bus drivers.UART
|
||||
|
||||
// command responses that come back from the ESP8266/ESP32
|
||||
response []byte
|
||||
|
||||
// data received from a TCP/UDP connection forwarded by the ESP8266/ESP32
|
||||
socketdata []byte
|
||||
}
|
||||
|
||||
// ActiveDevice is the currently configured Device in use. There can only be one.
|
||||
var ActiveDevice *Device
|
||||
|
||||
// New returns a new espat driver. Pass in a fully configured UART bus.
|
||||
func New(b drivers.UART) *Device {
|
||||
return &Device{bus: b, response: make([]byte, 512), socketdata: make([]byte, 0, 1024)}
|
||||
}
|
||||
|
||||
// Configure sets up the device for communication.
|
||||
func (d Device) Configure() {
|
||||
ActiveDevice = &d
|
||||
net.ActiveDevice = ActiveDevice
|
||||
}
|
||||
|
||||
// Connected checks if there is communication with the ESP8266/ESP32.
|
||||
func (d *Device) Connected() bool {
|
||||
d.Execute(Test)
|
||||
|
||||
// handle response here, should include "OK"
|
||||
_, err := d.Response(100)
|
||||
if err != nil {
|
||||
return false
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// Write raw bytes to the UART.
|
||||
func (d *Device) Write(b []byte) (n int, err error) {
|
||||
return d.bus.Write(b)
|
||||
}
|
||||
|
||||
// Read raw bytes from the UART.
|
||||
func (d *Device) Read(b []byte) (n int, err error) {
|
||||
return d.bus.Read(b)
|
||||
}
|
||||
|
||||
// how long in milliseconds to pause after sending AT commands
|
||||
const pause = 300
|
||||
|
||||
// Execute sends an AT command to the ESP8266/ESP32.
|
||||
func (d Device) Execute(cmd string) error {
|
||||
_, err := d.Write([]byte("AT" + cmd + "\r\n"))
|
||||
return err
|
||||
}
|
||||
|
||||
// Query sends an AT command to the ESP8266/ESP32 that returns the
|
||||
// current value for some configuration parameter.
|
||||
func (d Device) Query(cmd string) (string, error) {
|
||||
_, err := d.Write([]byte("AT" + cmd + "?\r\n"))
|
||||
return "", err
|
||||
}
|
||||
|
||||
// Set sends an AT command with params to the ESP8266/ESP32 for a
|
||||
// configuration value to be set.
|
||||
func (d Device) Set(cmd, params string) error {
|
||||
_, err := d.Write([]byte("AT" + cmd + "=" + params + "\r\n"))
|
||||
return err
|
||||
}
|
||||
|
||||
// Version returns the ESP8266/ESP32 firmware version info.
|
||||
func (d Device) Version() []byte {
|
||||
d.Execute(Version)
|
||||
r, err := d.Response(100)
|
||||
if err != nil {
|
||||
return []byte("unknown")
|
||||
}
|
||||
return r
|
||||
}
|
||||
|
||||
// Echo sets the ESP8266/ESP32 echo setting.
|
||||
func (d Device) Echo(set bool) {
|
||||
if set {
|
||||
d.Execute(EchoConfigOn)
|
||||
} else {
|
||||
d.Execute(EchoConfigOff)
|
||||
}
|
||||
// TODO: check for success
|
||||
d.Response(100)
|
||||
}
|
||||
|
||||
// Reset restarts the ESP8266/ESP32 firmware. Due to how the baud rate changes,
|
||||
// this messes up communication with the ESP8266/ESP32 module. So make sure you know
|
||||
// what you are doing when you call this.
|
||||
func (d Device) Reset() {
|
||||
d.Execute(Restart)
|
||||
d.Response(100)
|
||||
}
|
||||
|
||||
// ReadSocket returns the data that has already been read in from the responses.
|
||||
func (d *Device) ReadSocket(b []byte) (n int, err error) {
|
||||
// make sure no data in buffer
|
||||
d.Response(300)
|
||||
|
||||
count := len(b)
|
||||
if len(b) >= len(d.socketdata) {
|
||||
// copy it all, then clear socket data
|
||||
count = len(d.socketdata)
|
||||
copy(b, d.socketdata[:count])
|
||||
d.socketdata = d.socketdata[:0]
|
||||
} else {
|
||||
// copy all we can, then keep the remaining socket data around
|
||||
copy(b, d.socketdata[:count])
|
||||
copy(d.socketdata, d.socketdata[count:])
|
||||
d.socketdata = d.socketdata[:len(d.socketdata)-count]
|
||||
}
|
||||
|
||||
return count, nil
|
||||
}
|
||||
|
||||
// Response gets the next response bytes from the ESP8266/ESP32.
|
||||
// The call will retry for up to timeout milliseconds before returning nothing.
|
||||
func (d *Device) Response(timeout int) ([]byte, error) {
|
||||
// read data
|
||||
var size int
|
||||
var start, end int
|
||||
pause := 100 // pause to wait for 100 ms
|
||||
retries := timeout / pause
|
||||
|
||||
for {
|
||||
size = d.bus.Buffered()
|
||||
|
||||
if size > 0 {
|
||||
end += size
|
||||
d.bus.Read(d.response[start:end])
|
||||
|
||||
// if "+IPD" then read socket data
|
||||
if strings.Contains(string(d.response[:end]), "+IPD") {
|
||||
// handle socket data
|
||||
return nil, d.parseIPD(end)
|
||||
}
|
||||
|
||||
// if "OK" then the command worked
|
||||
if strings.Contains(string(d.response[:end]), "OK") {
|
||||
return d.response[start:end], nil
|
||||
}
|
||||
|
||||
// if "Error" then the command failed
|
||||
if strings.Contains(string(d.response[:end]), "ERROR") {
|
||||
return d.response[start:end], errors.New("response error:" + string(d.response[start:end]))
|
||||
}
|
||||
|
||||
// if anything else, then keep reading data in?
|
||||
start = end
|
||||
}
|
||||
|
||||
// wait longer?
|
||||
retries--
|
||||
if retries == 0 {
|
||||
return nil, errors.New("response timeout error:" + string(d.response[start:end]))
|
||||
}
|
||||
|
||||
time.Sleep(time.Duration(pause) * time.Millisecond)
|
||||
}
|
||||
}
|
||||
|
||||
func (d *Device) parseIPD(end int) error {
|
||||
// find the "+IPD," to get length
|
||||
s := strings.Index(string(d.response[:end]), "+IPD,")
|
||||
|
||||
// find the ":"
|
||||
e := strings.Index(string(d.response[:end]), ":")
|
||||
|
||||
// find the data length
|
||||
val := string(d.response[s+5 : e])
|
||||
|
||||
// TODO: verify count
|
||||
_, err := strconv.Atoi(val)
|
||||
if err != nil {
|
||||
// not expected data here. what to do?
|
||||
return err
|
||||
}
|
||||
|
||||
// load up the socket data
|
||||
d.socketdata = append(d.socketdata, d.response[e+1:end]...)
|
||||
return nil
|
||||
}
|
||||
|
||||
// IsSocketDataAvailable returns of there is socket data available
|
||||
func (d *Device) IsSocketDataAvailable() bool {
|
||||
return len(d.socketdata) > 0 || d.bus.Buffered() > 0
|
||||
}
|
||||
-147
@@ -1,147 +0,0 @@
|
||||
package espat
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"strconv"
|
||||
"strings"
|
||||
)
|
||||
|
||||
const (
|
||||
TCPMuxSingle = 0
|
||||
TCPMuxMultiple = 1
|
||||
|
||||
TCPTransferModeNormal = 0
|
||||
TCPTransferModeUnvarnished = 1
|
||||
)
|
||||
|
||||
// GetDNS returns the IP address for a domain name.
|
||||
func (d *Device) GetDNS(domain string) (string, error) {
|
||||
d.Set(TCPDNSLookup, "\""+domain+"\"")
|
||||
resp, err := d.Response(1000)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
if !strings.Contains(string(resp), ":") {
|
||||
return "", errors.New("GetDNS error:" + string(resp))
|
||||
}
|
||||
r := strings.Split(string(resp), ":")
|
||||
if len(r) != 2 {
|
||||
return "", errors.New("Invalid domain lookup result")
|
||||
}
|
||||
res := strings.Split(r[1], "\r\n")
|
||||
return res[0], nil
|
||||
}
|
||||
|
||||
// ConnectTCPSocket creates a new TCP socket connection for the ESP8266/ESP32.
|
||||
// Currently only supports single connection mode.
|
||||
func (d *Device) ConnectTCPSocket(addr, port string) error {
|
||||
protocol := "TCP"
|
||||
val := "\"" + protocol + "\",\"" + addr + "\"," + port + ",120"
|
||||
err := d.Set(TCPConnect, val)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
_, e := d.Response(3000)
|
||||
if e != nil {
|
||||
return e
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// ConnectUDPSocket creates a new UDP connection for the ESP8266/ESP32.
|
||||
func (d *Device) ConnectUDPSocket(addr, sendport, listenport string) error {
|
||||
protocol := "UDP"
|
||||
val := "\"" + protocol + "\",\"" + addr + "\"," + sendport + "," + listenport + ",2"
|
||||
err := d.Set(TCPConnect, val)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
_, e := d.Response(3000)
|
||||
if e != nil {
|
||||
return e
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// ConnectSSLSocket creates a new SSL socket connection for the ESP8266/ESP32.
|
||||
// Currently only supports single connection mode.
|
||||
func (d *Device) ConnectSSLSocket(addr, port string) error {
|
||||
protocol := "SSL"
|
||||
val := "\"" + protocol + "\",\"" + addr + "\"," + port + ",120"
|
||||
d.Set(TCPConnect, val)
|
||||
// this operation takes longer, so wait up to 6 seconds to complete.
|
||||
_, err := d.Response(6000)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// DisconnectSocket disconnects the ESP8266/ESP32 from the current TCP/UDP connection.
|
||||
func (d *Device) DisconnectSocket() error {
|
||||
err := d.Execute(TCPClose)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
_, e := d.Response(pause)
|
||||
if e != nil {
|
||||
return e
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// SetMux sets the ESP8266/ESP32 current client TCP/UDP configuration for concurrent connections
|
||||
// either single TCPMuxSingle or multiple TCPMuxMultiple (up to 4).
|
||||
func (d *Device) SetMux(mode int) error {
|
||||
val := strconv.Itoa(mode)
|
||||
d.Set(TCPMultiple, val)
|
||||
_, err := d.Response(pause)
|
||||
return err
|
||||
}
|
||||
|
||||
// GetMux returns the ESP8266/ESP32 current client TCP/UDP configuration for concurrent connections.
|
||||
func (d *Device) GetMux() ([]byte, error) {
|
||||
d.Query(TCPMultiple)
|
||||
return d.Response(pause)
|
||||
}
|
||||
|
||||
// SetTCPTransferMode sets the ESP8266/ESP32 current client TCP/UDP transfer mode.
|
||||
// Either TCPTransferModeNormal or TCPTransferModeUnvarnished.
|
||||
func (d *Device) SetTCPTransferMode(mode int) error {
|
||||
val := strconv.Itoa(mode)
|
||||
d.Set(TransmissionMode, val)
|
||||
_, err := d.Response(pause)
|
||||
return err
|
||||
}
|
||||
|
||||
// GetTCPTransferMode returns the ESP8266/ESP32 current client TCP/UDP transfer mode.
|
||||
func (d *Device) GetTCPTransferMode() ([]byte, error) {
|
||||
d.Query(TransmissionMode)
|
||||
return d.Response(pause)
|
||||
}
|
||||
|
||||
// StartSocketSend gets the ESP8266/ESP32 ready to receive TCP/UDP socket data.
|
||||
func (d *Device) StartSocketSend(size int) error {
|
||||
val := strconv.Itoa(size)
|
||||
d.Set(TCPSend, val)
|
||||
|
||||
// when ">" is received, it indicates
|
||||
// ready to receive data
|
||||
r, err := d.Response(2000)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if strings.Contains(string(r), ">") {
|
||||
return nil
|
||||
}
|
||||
return errors.New("StartSocketSend error:" + string(r))
|
||||
}
|
||||
|
||||
// EndSocketSend tell the ESP8266/ESP32 the TCP/UDP socket data sending is complete,
|
||||
// and to return to command mode. This is only used in "unvarnished" raw mode.
|
||||
func (d *Device) EndSocketSend() error {
|
||||
d.Write([]byte("+++"))
|
||||
|
||||
_, err := d.Response(pause)
|
||||
return err
|
||||
}
|
||||
-154
@@ -1,154 +0,0 @@
|
||||
package espat
|
||||
|
||||
import (
|
||||
"strconv"
|
||||
)
|
||||
|
||||
const (
|
||||
WifiModeClient = 1
|
||||
WifiModeAP = 2
|
||||
WifiModeDual = 3
|
||||
|
||||
WifiAPSecurityOpen = 1
|
||||
WifiAPSecurityWPA_PSK = 2
|
||||
WifiAPSecurityWPA2_PSK = 3
|
||||
WifiAPSecurityWPA_WPA2_PSK = 4
|
||||
)
|
||||
|
||||
// GetWifiMode returns the ESP8266/ESP32 wifi mode.
|
||||
func (d *Device) GetWifiMode() ([]byte, error) {
|
||||
d.Query(WifiMode)
|
||||
return d.Response(100)
|
||||
}
|
||||
|
||||
// SetWifiMode sets the ESP8266/ESP32 wifi mode.
|
||||
func (d *Device) SetWifiMode(mode int) error {
|
||||
val := strconv.Itoa(mode)
|
||||
d.Set(WifiMode, val)
|
||||
_, err := d.Response(pause)
|
||||
return err
|
||||
}
|
||||
|
||||
// Wifi Client
|
||||
|
||||
// GetConnectedAP returns the ESP8266/ESP32 is currently connected to as a client.
|
||||
func (d *Device) GetConnectedAP() ([]byte, error) {
|
||||
d.Query(ConnectAP)
|
||||
return d.Response(100)
|
||||
}
|
||||
|
||||
// ConnectToAP connects the ESP8266/ESP32 to an access point.
|
||||
// ws is the number of seconds to wait for connection.
|
||||
func (d *Device) ConnectToAP(ssid, pwd string, ws int) error {
|
||||
val := "\"" + ssid + "\",\"" + pwd + "\""
|
||||
d.Set(ConnectAP, val)
|
||||
|
||||
_, err := d.Response(ws * 1000)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// DisconnectFromAP disconnects the ESP8266/ESP32 from the current access point.
|
||||
func (d *Device) DisconnectFromAP() error {
|
||||
d.Execute(Disconnect)
|
||||
_, err := d.Response(1000)
|
||||
return err
|
||||
}
|
||||
|
||||
// GetClientIP returns the ESP8266/ESP32 current client IP addess when connected to an Access Point.
|
||||
func (d *Device) GetClientIP() (string, error) {
|
||||
d.Query(SetStationIP)
|
||||
r, err := d.Response(1000)
|
||||
return string(r), err
|
||||
}
|
||||
|
||||
// SetClientIP sets the ESP8266/ESP32 current client IP addess when connected to an Access Point.
|
||||
func (d *Device) SetClientIP(ipaddr string) error {
|
||||
val := "\"" + ipaddr + "\""
|
||||
d.Set(ConnectAP, val)
|
||||
_, err := d.Response(500)
|
||||
return err
|
||||
}
|
||||
|
||||
// Access Point
|
||||
|
||||
// GetAPConfig returns the ESP8266/ESP32 current configuration when acting as an Access Point.
|
||||
func (d *Device) GetAPConfig() (string, error) {
|
||||
d.Query(SoftAPConfigCurrent)
|
||||
r, err := d.Response(100)
|
||||
return string(r), err
|
||||
}
|
||||
|
||||
// SetAPConfig sets the ESP8266/ESP32 current configuration when acting as an Access Point.
|
||||
// ch indicates which radiochannel to use. security should be one of the const values
|
||||
// such as WifiAPSecurityOpen etc.
|
||||
func (d *Device) SetAPConfig(ssid, pwd string, ch, security int) error {
|
||||
chval := strconv.Itoa(ch)
|
||||
ecnval := strconv.Itoa(security)
|
||||
val := "\"" + ssid + "\",\"" + pwd + "\"," + chval + "," + ecnval
|
||||
d.Set(SoftAPConfigCurrent, val)
|
||||
_, err := d.Response(1000)
|
||||
return err
|
||||
}
|
||||
|
||||
// GetAPClients returns the ESP8266/ESP32 current clients when acting as an Access Point.
|
||||
func (d *Device) GetAPClients() (string, error) {
|
||||
d.Query(ListConnectedIP)
|
||||
r, err := d.Response(100)
|
||||
return string(r), err
|
||||
}
|
||||
|
||||
// GetAPIP returns the ESP8266/ESP32 current IP addess when configured as an Access Point.
|
||||
func (d *Device) GetAPIP() (string, error) {
|
||||
d.Query(SetSoftAPIPCurrent)
|
||||
r, err := d.Response(100)
|
||||
return string(r), err
|
||||
}
|
||||
|
||||
// SetAPIP sets the ESP8266/ESP32 current IP addess when configured as an Access Point.
|
||||
func (d *Device) SetAPIP(ipaddr string) error {
|
||||
val := "\"" + ipaddr + "\""
|
||||
d.Set(SetSoftAPIPCurrent, val)
|
||||
_, err := d.Response(500)
|
||||
return err
|
||||
}
|
||||
|
||||
// GetAPConfigFlash returns the ESP8266/ESP32 current configuration acting as an Access Point
|
||||
// from flash storage. These settings are those used after a reset.
|
||||
func (d *Device) GetAPConfigFlash() (string, error) {
|
||||
d.Query(SoftAPConfigFlash)
|
||||
r, err := d.Response(100)
|
||||
return string(r), err
|
||||
}
|
||||
|
||||
// SetAPConfigFlash sets the ESP8266/ESP32 current configuration acting as an Access Point,
|
||||
// and saves them to flash storage. These settings will be used after a reset.
|
||||
// ch indicates which radiochannel to use. security should be one of the const values
|
||||
// such as WifiAPSecurityOpen etc.
|
||||
func (d *Device) SetAPConfigFlash(ssid, pwd string, ch, security int) error {
|
||||
chval := strconv.Itoa(ch)
|
||||
ecnval := strconv.Itoa(security)
|
||||
val := "\"" + ssid + "\",\"" + pwd + "\"," + chval + "," + ecnval
|
||||
d.Set(SoftAPConfigFlash, val)
|
||||
_, err := d.Response(1000)
|
||||
return err
|
||||
}
|
||||
|
||||
// GetAPIPFlash returns the ESP8266/ESP32 IP address as saved to flash storage.
|
||||
// This is the IP address that will be used after a reset.
|
||||
func (d *Device) GetAPIPFlash() (string, error) {
|
||||
d.Query(SetSoftAPIPFlash)
|
||||
r, err := d.Response(100)
|
||||
return string(r), err
|
||||
}
|
||||
|
||||
// SetAPIPFlash sets the ESP8266/ESP32 current IP addess when configured as an Access Point.
|
||||
// The IP will be saved to flash storage, and will be used after a reset.
|
||||
func (d *Device) SetAPIPFlash(ipaddr string) error {
|
||||
val := "\"" + ipaddr + "\""
|
||||
d.Set(SetSoftAPIPFlash, val)
|
||||
_, err := d.Response(500)
|
||||
return err
|
||||
}
|
||||
@@ -1,27 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"machine"
|
||||
"time"
|
||||
|
||||
"tinygo.org/x/drivers/adt7410"
|
||||
)
|
||||
|
||||
var (
|
||||
i2c = machine.I2C0
|
||||
sensor = adt7410.New(i2c)
|
||||
)
|
||||
|
||||
func main() {
|
||||
|
||||
i2c.Configure(machine.I2CConfig{Frequency: machine.TWI_FREQ_400KHZ})
|
||||
sensor.Configure()
|
||||
|
||||
for {
|
||||
temp := sensor.ReadTempF()
|
||||
fmt.Printf("temperature: %f\r\n", temp)
|
||||
time.Sleep(time.Second)
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,25 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"machine"
|
||||
"time"
|
||||
|
||||
"tinygo.org/x/drivers/adxl345"
|
||||
)
|
||||
|
||||
func main() {
|
||||
machine.I2C0.Configure(machine.I2CConfig{})
|
||||
sensor := adxl345.New(machine.I2C0)
|
||||
sensor.Configure()
|
||||
|
||||
println("ADXL345 starts")
|
||||
for {
|
||||
x, y, z, _ := sensor.ReadAcceleration()
|
||||
println("X:", x, "Y:", y, "Z:", z)
|
||||
|
||||
rx, ry, rz := sensor.ReadRawAcceleration()
|
||||
println("X (raw):", rx, "Y (raw):", ry, "Z (raw):", rz)
|
||||
|
||||
time.Sleep(100 * time.Millisecond)
|
||||
}
|
||||
}
|
||||
@@ -1,55 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"machine"
|
||||
"time"
|
||||
|
||||
"tinygo.org/x/drivers/aht20"
|
||||
)
|
||||
|
||||
func main() {
|
||||
machine.I2C0.Configure(machine.I2CConfig{})
|
||||
|
||||
dev := aht20.New(machine.I2C0)
|
||||
dev.Configure()
|
||||
|
||||
dev.Reset()
|
||||
for {
|
||||
time.Sleep(500 * time.Millisecond)
|
||||
|
||||
err := dev.Read()
|
||||
if err != nil {
|
||||
println("Error", err)
|
||||
continue
|
||||
}
|
||||
|
||||
println("temp ", fmtD(dev.DeciCelsius(), 3, 1), "C")
|
||||
println("humidity", fmtD(dev.DeciRelHumidity(), 3, 1), "%")
|
||||
}
|
||||
}
|
||||
|
||||
func fmtD(val int32, i int, f int) string {
|
||||
result := make([]byte, i+f+1)
|
||||
neg := false
|
||||
|
||||
if val < 0 {
|
||||
val = -val
|
||||
neg = true
|
||||
}
|
||||
|
||||
for p := len(result) - 1; p >= 0; p-- {
|
||||
result[p] = byte(int32('0') + (val % 10))
|
||||
val = val / 10
|
||||
|
||||
if p == i+1 && p > 0 {
|
||||
p--
|
||||
result[p] = '.'
|
||||
}
|
||||
}
|
||||
|
||||
if neg {
|
||||
result[0] = '-'
|
||||
}
|
||||
|
||||
return string(result)
|
||||
}
|
||||
File diff suppressed because one or more lines are too long
@@ -1,56 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"image/color"
|
||||
"machine"
|
||||
|
||||
"tinygo.org/x/drivers/st7735"
|
||||
|
||||
"tinygo.org/x/drivers/amg88xx"
|
||||
)
|
||||
|
||||
func main() {
|
||||
|
||||
machine.SPI1.Configure(machine.SPIConfig{
|
||||
SCK: machine.SPI1_SCK_PIN,
|
||||
SDO: machine.SPI1_SDO_PIN,
|
||||
SDI: machine.SPI1_SDI_PIN,
|
||||
Frequency: 8000000,
|
||||
})
|
||||
machine.I2C0.Configure(machine.I2CConfig{SCL: machine.SCL_PIN, SDA: machine.SDA_PIN})
|
||||
|
||||
display := st7735.New(machine.SPI1, machine.TFT_RST, machine.TFT_DC, machine.TFT_CS, machine.TFT_LITE)
|
||||
display.Configure(st7735.Config{
|
||||
Rotation: st7735.ROTATION_90,
|
||||
})
|
||||
display.FillScreen(color.RGBA{0, 0, 0, 255})
|
||||
|
||||
camera := amg88xx.New(machine.I2C0)
|
||||
camera.Configure(amg88xx.Config{})
|
||||
|
||||
var data [64]int16
|
||||
var value int16
|
||||
for {
|
||||
// get the values of the sensor in millicelsius
|
||||
camera.ReadPixels(&data)
|
||||
|
||||
for j := int16(0); j < 8; j++ {
|
||||
for i := int16(0); i < 8; i++ {
|
||||
value = data[63-(i+j*8)]
|
||||
// treat anything below 18°C as 18°C
|
||||
if value < 18000 {
|
||||
value = 0
|
||||
} else {
|
||||
value = (value - 18000) / 36
|
||||
// our color array only have 433 values, avoid getting a value that doesn't exist
|
||||
if value > 432 {
|
||||
value = 432
|
||||
}
|
||||
}
|
||||
// show the image on the PyBadge's display
|
||||
display.FillRectangle(16+i*16, j*16, 16, 16, colors[value])
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,91 +0,0 @@
|
||||
// This example demostrates how to control the "Dotstar" (APA102) LED included
|
||||
// on the Adafruit Itsy Bitsy M0 board. It implements a "rainbow effect" based
|
||||
// on the following example:
|
||||
// https://github.com/adafruit/Adafruit_Learning_System_Guides/blob/master/CircuitPython_Essentials/CircuitPython_Internal_RGB_LED_rainbow.py
|
||||
package main
|
||||
|
||||
import (
|
||||
"image/color"
|
||||
"machine"
|
||||
"time"
|
||||
|
||||
"tinygo.org/x/drivers/apa102"
|
||||
)
|
||||
|
||||
var (
|
||||
apa *apa102.Device
|
||||
|
||||
pwm = machine.TCC0
|
||||
leds = make([]color.RGBA, 1)
|
||||
wheel = &Wheel{Brightness: 0x10}
|
||||
)
|
||||
|
||||
func init() {
|
||||
|
||||
// APA102 on Itsy Bitsy is connected to pins that require a software-based
|
||||
// SPI implementation.
|
||||
apa = apa102.NewSoftwareSPI(machine.PA00, machine.PA01, 1)
|
||||
|
||||
// Configure the regular on-board LED for PWM fading
|
||||
err := pwm.Configure(machine.PWMConfig{})
|
||||
if err != nil {
|
||||
println("failed to configure PWM")
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
func main() {
|
||||
channelLED, err := pwm.Channel(machine.LED)
|
||||
if err != nil {
|
||||
println("failed to configure LED PWM channel")
|
||||
return
|
||||
}
|
||||
|
||||
// We'll fade the on-board LED in a goroutine to show/ensure that the APA102
|
||||
// works fine with the scheduler enabled. Comment this out to test this code
|
||||
// with the scheduler disabled.
|
||||
go func() {
|
||||
for i, brightening := uint8(0), false; ; i++ {
|
||||
if i == 0 {
|
||||
brightening = !brightening
|
||||
continue
|
||||
}
|
||||
var brightness uint32 = uint32(i)
|
||||
if !brightening {
|
||||
brightness = 256 - brightness
|
||||
}
|
||||
pwm.Set(channelLED, pwm.Top()*brightness/256)
|
||||
time.Sleep(5 * time.Millisecond)
|
||||
}
|
||||
}()
|
||||
|
||||
// Use the "wheel" function from Adafruit's example to cycle the APA102
|
||||
for {
|
||||
leds[0] = wheel.Next()
|
||||
apa.WriteColors(leds)
|
||||
time.Sleep(25 * time.Millisecond)
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Wheel is a port of Adafruit's Circuit Python example referenced above.
|
||||
type Wheel struct {
|
||||
Brightness uint8
|
||||
pos uint8
|
||||
}
|
||||
|
||||
// Next increments the internal state of the color and returns the new RGBA
|
||||
func (w *Wheel) Next() (c color.RGBA) {
|
||||
pos := w.pos
|
||||
if w.pos < 85 {
|
||||
c = color.RGBA{R: 0xFF - pos*3, G: pos * 3, B: 0x0, A: w.Brightness}
|
||||
} else if w.pos < 170 {
|
||||
pos -= 85
|
||||
c = color.RGBA{R: 0x0, G: 0xFF - pos*3, B: pos * 3, A: w.Brightness}
|
||||
} else {
|
||||
pos -= 170
|
||||
c = color.RGBA{R: pos * 3, G: 0x0, B: 0xFF - pos*3, A: w.Brightness}
|
||||
}
|
||||
w.pos++
|
||||
return
|
||||
}
|
||||
@@ -1,35 +0,0 @@
|
||||
// Connects to an APA102 SPI RGB LED strip with 30 LEDS.
|
||||
package main
|
||||
|
||||
import (
|
||||
"image/color"
|
||||
"machine"
|
||||
"time"
|
||||
|
||||
"tinygo.org/x/drivers/apa102"
|
||||
)
|
||||
|
||||
func main() {
|
||||
machine.SPI0.Configure(machine.SPIConfig{
|
||||
Frequency: 500000,
|
||||
Mode: 0})
|
||||
|
||||
a := apa102.New(machine.SPI0)
|
||||
leds := make([]color.RGBA, 30)
|
||||
rg := false
|
||||
|
||||
for {
|
||||
rg = !rg
|
||||
for i := range leds {
|
||||
rg = !rg
|
||||
if rg {
|
||||
leds[i] = color.RGBA{R: 0xff, G: 0x00, B: 0x00, A: 0x77}
|
||||
} else {
|
||||
leds[i] = color.RGBA{R: 0x00, G: 0xff, B: 0x00, A: 0x77}
|
||||
}
|
||||
}
|
||||
|
||||
a.WriteColors(leds)
|
||||
time.Sleep(100 * time.Millisecond)
|
||||
}
|
||||
}
|
||||
@@ -1,122 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"machine"
|
||||
"time"
|
||||
|
||||
"tinygo.org/x/drivers/at24cx"
|
||||
)
|
||||
|
||||
func main() {
|
||||
machine.I2C0.Configure(machine.I2CConfig{})
|
||||
|
||||
eeprom := at24cx.New(machine.I2C0)
|
||||
eeprom.Configure(at24cx.Config{})
|
||||
|
||||
values := make([]uint8, 100)
|
||||
for i := uint16(0); i < 100; i++ {
|
||||
values[i] = uint8(65 + i%26)
|
||||
}
|
||||
_, err := eeprom.WriteAt(values, 0)
|
||||
if err != nil {
|
||||
println("There was an error in WriteAt:", err)
|
||||
return
|
||||
}
|
||||
|
||||
for i := uint16(0); i < 26; i++ {
|
||||
err = eeprom.WriteByte(100+i, uint8(90-i))
|
||||
if err != nil {
|
||||
println("There was an error in WriteByte:", i, err)
|
||||
return
|
||||
}
|
||||
time.Sleep(2 * time.Millisecond)
|
||||
}
|
||||
|
||||
println("\n\r\n\rRead 26 bytes one by one from address 0")
|
||||
println("Expected: ABCDEFGHIJKLMNOPQRSTUVWXYZ")
|
||||
print("Real: ")
|
||||
for i := uint16(0); i < 26; i++ {
|
||||
char, err := eeprom.ReadByte(i)
|
||||
print(string(char))
|
||||
if err != nil {
|
||||
println("There was an error in ReadByte:", i, err)
|
||||
return
|
||||
}
|
||||
}
|
||||
println("")
|
||||
|
||||
println("\n\r\n\rRead 100 bytes from address 26")
|
||||
println("Expected: ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVZYXWVUTSRQPONMLKJIHGFEDCBA")
|
||||
print("Real: ")
|
||||
data := make([]byte, 100)
|
||||
_, err = eeprom.ReadAt(data, 26)
|
||||
if err != nil {
|
||||
println("There was an error in ReadAt:", err)
|
||||
return
|
||||
}
|
||||
for i := 0; i < 100; i++ {
|
||||
print(string(data[i]))
|
||||
}
|
||||
println("")
|
||||
|
||||
// Move to the beginning of memory
|
||||
eeprom.Seek(0, 0)
|
||||
_, err = eeprom.Write([]uint8{88, 88, 88})
|
||||
if err != nil {
|
||||
println("There was an error in Write:", err)
|
||||
return
|
||||
}
|
||||
|
||||
println("\n\r\n\rRead 3 bytes")
|
||||
println("Expected: DEF")
|
||||
print("Real: ")
|
||||
data = make([]byte, 3)
|
||||
_, err = eeprom.Read(data)
|
||||
if err != nil {
|
||||
println("There was an error in Read:", err)
|
||||
return
|
||||
}
|
||||
for _, char := range data {
|
||||
print(string(char))
|
||||
}
|
||||
println("")
|
||||
|
||||
println("\n\r\n\rRead another 3 bytes (from the beginning this time)")
|
||||
eeprom.Seek(-6, 1)
|
||||
println("Expected: XXX")
|
||||
print("Real: ")
|
||||
data = make([]byte, 3)
|
||||
_, err = eeprom.Read(data)
|
||||
if err != nil {
|
||||
println("There was an error in Read:", err)
|
||||
return
|
||||
}
|
||||
for _, char := range data {
|
||||
print(string(char))
|
||||
}
|
||||
println("")
|
||||
|
||||
// Move to the end of memory
|
||||
eeprom.Seek(-4, 2)
|
||||
_, err = eeprom.Write([]uint8{89, 90, 89, 90})
|
||||
if err != nil {
|
||||
println("There was an error in Write:", err)
|
||||
return
|
||||
}
|
||||
|
||||
println("\n\r\n\rRead the last 4 bytes of the memory and the 3 of the beginning")
|
||||
eeprom.Seek(-4, 1)
|
||||
println("Expected: YZYZXXX")
|
||||
print("Real: ")
|
||||
data = make([]byte, 7)
|
||||
_, err = eeprom.Read(data)
|
||||
if err != nil {
|
||||
println("There was an error in Read:", err)
|
||||
return
|
||||
}
|
||||
for _, char := range data {
|
||||
print(string(char))
|
||||
}
|
||||
println("")
|
||||
|
||||
}
|
||||
@@ -1,22 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"time"
|
||||
|
||||
"machine"
|
||||
|
||||
"tinygo.org/x/drivers/bh1750"
|
||||
)
|
||||
|
||||
func main() {
|
||||
machine.I2C0.Configure(machine.I2CConfig{})
|
||||
sensor := bh1750.New(machine.I2C0)
|
||||
sensor.Configure()
|
||||
|
||||
for {
|
||||
lux := sensor.Illuminance()
|
||||
println("Illuminance:", lux, "lx")
|
||||
|
||||
time.Sleep(500 * time.Millisecond)
|
||||
}
|
||||
}
|
||||
@@ -1,41 +0,0 @@
|
||||
// Connects to an BlinkM I2C RGB LED.
|
||||
// http://thingm.com/fileadmin/thingm/downloads/BlinkM_datasheet.pdf
|
||||
package main
|
||||
|
||||
import (
|
||||
"machine"
|
||||
"time"
|
||||
|
||||
"tinygo.org/x/drivers/blinkm"
|
||||
)
|
||||
|
||||
func main() {
|
||||
machine.I2C0.Configure(machine.I2CConfig{})
|
||||
|
||||
bm := blinkm.New(machine.I2C0)
|
||||
bm.Configure()
|
||||
|
||||
maj, min, _ := bm.Version()
|
||||
|
||||
println("Firmware version:", string(maj), string(min))
|
||||
|
||||
count := 0
|
||||
for {
|
||||
switch count {
|
||||
case 0:
|
||||
// Crimson
|
||||
bm.SetRGB(0xdc, 0x14, 0x3c)
|
||||
count = 1
|
||||
case 1:
|
||||
// MediumPurple
|
||||
bm.SetRGB(0x93, 0x70, 0xdb)
|
||||
count = 2
|
||||
case 2:
|
||||
// MediumSeaGreen
|
||||
bm.SetRGB(0x3c, 0xb3, 0x71)
|
||||
count = 0
|
||||
}
|
||||
|
||||
time.Sleep(100 * time.Millisecond)
|
||||
}
|
||||
}
|
||||
@@ -1,35 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"machine"
|
||||
"strconv"
|
||||
"time"
|
||||
|
||||
"tinygo.org/x/drivers/bme280"
|
||||
)
|
||||
|
||||
func main() {
|
||||
|
||||
machine.I2C0.Configure(machine.I2CConfig{})
|
||||
sensor := bme280.New(machine.I2C0)
|
||||
sensor.Configure()
|
||||
|
||||
connected := sensor.Connected()
|
||||
if !connected {
|
||||
println("BME280 not detected")
|
||||
}
|
||||
println("BME280 detected")
|
||||
|
||||
for {
|
||||
temp, _ := sensor.ReadTemperature()
|
||||
println("Temperature:", strconv.FormatFloat(float64(temp)/1000, 'f', 2, 64), "°C")
|
||||
press, _ := sensor.ReadPressure()
|
||||
println("Pressure:", strconv.FormatFloat(float64(press)/100000, 'f', 2, 64), "hPa")
|
||||
hum, _ := sensor.ReadHumidity()
|
||||
println("Humidity:", strconv.FormatFloat(float64(hum)/100, 'f', 2, 64), "%")
|
||||
alt, _ := sensor.ReadAltitude()
|
||||
println("Altitude:", alt, "m")
|
||||
|
||||
time.Sleep(2 * time.Second)
|
||||
}
|
||||
}
|
||||
@@ -1,46 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"machine"
|
||||
"time"
|
||||
"tinygo.org/x/drivers/bmi160"
|
||||
)
|
||||
|
||||
func main() {
|
||||
time.Sleep(5 * time.Second)
|
||||
|
||||
machine.SPI0.Configure(machine.SPIConfig{})
|
||||
sensor := bmi160.NewSPI(machine.A5, machine.SPI0)
|
||||
sensor.Configure()
|
||||
|
||||
if !sensor.Connected() {
|
||||
println("BMI160 not connected")
|
||||
return
|
||||
}
|
||||
|
||||
for {
|
||||
time.Sleep(time.Second)
|
||||
|
||||
t, err := sensor.ReadTemperature()
|
||||
if err != nil {
|
||||
println("Error reading temperature", err)
|
||||
continue
|
||||
}
|
||||
fmt.Printf("Temperature: %.2f °C\n", float32(t)/1000)
|
||||
|
||||
accelX, accelY, accelZ, err := sensor.ReadAcceleration()
|
||||
if err != nil {
|
||||
println("Error reading acceleration", err)
|
||||
continue
|
||||
}
|
||||
fmt.Printf("Acceleration: %.2fg %.2fg %.2fg\n", float32(accelX)/1e6, float32(accelY)/1e6, float32(accelZ)/1e6)
|
||||
|
||||
gyroX, gyroY, gyroZ, err := sensor.ReadRotation()
|
||||
if err != nil {
|
||||
println("Error reading rotation", err)
|
||||
continue
|
||||
}
|
||||
fmt.Printf("Rotation: %.2f°/s %.2f°/s %.2f°/s\n", float32(gyroX)/1e6, float32(gyroY)/1e6, float32(gyroZ)/1e6)
|
||||
}
|
||||
}
|
||||
@@ -1,32 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"time"
|
||||
|
||||
"machine"
|
||||
|
||||
"tinygo.org/x/drivers/bmp180"
|
||||
)
|
||||
|
||||
func main() {
|
||||
machine.I2C0.Configure(machine.I2CConfig{})
|
||||
sensor := bmp180.New(machine.I2C0)
|
||||
sensor.Configure()
|
||||
|
||||
connected := sensor.Connected()
|
||||
if !connected {
|
||||
println("BMP180 not detected")
|
||||
return
|
||||
}
|
||||
println("BMP180 detected")
|
||||
|
||||
for {
|
||||
temp, _ := sensor.ReadTemperature()
|
||||
println("Temperature:", float32(temp)/1000, "°C")
|
||||
|
||||
pressure, _ := sensor.ReadPressure()
|
||||
println("Pressure", float32(pressure)/100000, "hPa")
|
||||
|
||||
time.Sleep(2 * time.Second)
|
||||
}
|
||||
}
|
||||
@@ -1,44 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"machine"
|
||||
"time"
|
||||
"tinygo.org/x/drivers/bmp280"
|
||||
)
|
||||
|
||||
func main() {
|
||||
time.Sleep(5 * time.Second)
|
||||
|
||||
machine.I2C0.Configure(machine.I2CConfig{})
|
||||
sensor := bmp280.New(machine.I2C0)
|
||||
sensor.Configure(bmp280.STANDBY_125MS, bmp280.FILTER_4X, bmp280.SAMPLING_16X, bmp280.SAMPLING_16X, bmp280.MODE_FORCED)
|
||||
|
||||
connected := sensor.Connected()
|
||||
if !connected {
|
||||
println("\nBMP280 Sensor not detected\n")
|
||||
return
|
||||
}
|
||||
println("\nBMP280 Sensor detected\n")
|
||||
|
||||
println("Calibration:")
|
||||
sensor.PrintCali()
|
||||
|
||||
for {
|
||||
t, err := sensor.ReadTemperature()
|
||||
if err != nil {
|
||||
println("Error reading temperature")
|
||||
}
|
||||
// Temperature in degrees Celsius
|
||||
fmt.Printf("Temperature: %.2f °C\n", float32(t)/1000)
|
||||
|
||||
p, err := sensor.ReadPressure()
|
||||
if err != nil {
|
||||
println("Error reading pressure")
|
||||
}
|
||||
// Pressure in hectoPascal
|
||||
fmt.Printf("Pressure: %.2f hPa\n", float32(p)/100000)
|
||||
|
||||
time.Sleep(5 * time.Second)
|
||||
}
|
||||
}
|
||||
@@ -1,53 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"machine"
|
||||
"strconv"
|
||||
"time"
|
||||
|
||||
"tinygo.org/x/drivers/bmp388"
|
||||
)
|
||||
|
||||
func main() {
|
||||
|
||||
machine.I2C0.Configure(machine.I2CConfig{})
|
||||
|
||||
sensor := bmp388.New(machine.I2C0)
|
||||
if !sensor.Connected() {
|
||||
println("Uh oh, BMP388 not detected")
|
||||
return
|
||||
}
|
||||
|
||||
// The accuracy of the sensor can be increased, at the cost of a slower output rate. Table 9 in Section 3.5 of the
|
||||
// datasheet has recommended settings for common use cases. If increasing the sampling rate, the output data rate
|
||||
// (ODR) will likely have to be decreased. Configure() will return an error if there's a problem with the
|
||||
// configuration settings - keep decreasing the ODR and cycling the power to the sensor until it is happy.
|
||||
err := sensor.Configure(bmp388.Config{
|
||||
Pressure: bmp388.Sampling8X,
|
||||
Temperature: bmp388.Sampling2X,
|
||||
ODR: bmp388.Odr25,
|
||||
IIR: bmp388.Coeff0,
|
||||
Mode: bmp388.Normal,
|
||||
})
|
||||
|
||||
// This is also fine
|
||||
// err := sensor.Configure(bmp388.BMP388Config{})
|
||||
|
||||
if err != nil {
|
||||
println(err)
|
||||
}
|
||||
|
||||
for {
|
||||
temp, err := sensor.ReadTemperature() // returns the temperature in centicelsius
|
||||
press, err := sensor.ReadPressure() // returns the pressure in centipascals
|
||||
|
||||
if err != nil {
|
||||
println(err)
|
||||
} else {
|
||||
println("Temperature: " + strconv.FormatInt(int64(temp), 10) + " cC")
|
||||
println("Pressure: " + strconv.FormatInt(int64(press), 10) + " cPa\n")
|
||||
}
|
||||
|
||||
time.Sleep(time.Second)
|
||||
}
|
||||
}
|
||||
@@ -1,40 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"machine"
|
||||
"time"
|
||||
|
||||
"tinygo.org/x/drivers/buzzer"
|
||||
)
|
||||
|
||||
type note struct {
|
||||
tone float64
|
||||
duration float64
|
||||
}
|
||||
|
||||
func main() {
|
||||
speaker := machine.PA30
|
||||
speaker.Configure(machine.PinConfig{Mode: machine.PinOutput})
|
||||
speaker.Set(true)
|
||||
|
||||
bzrPin := machine.A0
|
||||
bzrPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
|
||||
|
||||
bzr := buzzer.New(bzrPin)
|
||||
|
||||
song := []note{
|
||||
{buzzer.C3, buzzer.Quarter},
|
||||
{buzzer.D3, buzzer.Quarter},
|
||||
{buzzer.E3, buzzer.Quarter},
|
||||
{buzzer.F3, buzzer.Quarter},
|
||||
{buzzer.G3, buzzer.Quarter},
|
||||
{buzzer.A3, buzzer.Quarter},
|
||||
{buzzer.B3, buzzer.Quarter},
|
||||
{buzzer.C3, buzzer.Quarter},
|
||||
}
|
||||
|
||||
for _, val := range song {
|
||||
bzr.Tone(val.tone, val.duration)
|
||||
time.Sleep(10 * time.Millisecond)
|
||||
}
|
||||
}
|
||||
@@ -1,23 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"machine"
|
||||
"time"
|
||||
"tinygo.org/x/drivers/dht"
|
||||
)
|
||||
|
||||
func main() {
|
||||
pin := machine.D6
|
||||
dhtSensor := dht.New(pin, dht.DHT11)
|
||||
for {
|
||||
temp, hum, err := dhtSensor.Measurements()
|
||||
if err != nil {
|
||||
fmt.Printf("Temperature: %02d.%d°C, Humidity: %02d.%d%%\n", temp/10, temp%10, hum/10, hum%10)
|
||||
} else {
|
||||
fmt.Printf("Could not take measurements from the sensor: %s\n", err.Error())
|
||||
}
|
||||
// Measurements cannot be updated only 2 seconds. More frequent calls will return the same value
|
||||
time.Sleep(time.Second * 2)
|
||||
}
|
||||
}
|
||||
@@ -1,32 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"machine"
|
||||
|
||||
"tinygo.org/x/drivers/ds1307"
|
||||
)
|
||||
|
||||
func main() {
|
||||
machine.I2C0.Configure(machine.I2CConfig{})
|
||||
rtc := ds1307.New(machine.I2C0)
|
||||
read := make([]byte, 5)
|
||||
for {
|
||||
rtc.Seek(0, 0)
|
||||
_, err := rtc.Write([]byte{1, 2, 3, 4, 5})
|
||||
if err != nil {
|
||||
println("Error while writing data:", err)
|
||||
break
|
||||
}
|
||||
rtc.Seek(0, 0)
|
||||
_, err = rtc.Read(read)
|
||||
if err != nil {
|
||||
println("Error while reading data:", err)
|
||||
break
|
||||
}
|
||||
for data := range read {
|
||||
println(data, " ")
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,25 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"machine"
|
||||
"time"
|
||||
|
||||
"tinygo.org/x/drivers/ds1307"
|
||||
)
|
||||
|
||||
func main() {
|
||||
machine.I2C0.Configure(machine.I2CConfig{})
|
||||
rtc := ds1307.New(machine.I2C0)
|
||||
rtc.SetTime(time.Date(2019, 5, 15, 20, 34, 12, 0, time.UTC))
|
||||
|
||||
for {
|
||||
t, err := rtc.ReadTime()
|
||||
if err != nil {
|
||||
println("Error reading date:", err)
|
||||
break
|
||||
}
|
||||
println(t.Hour(), ":", t.Minute(), ":", t.Second(), " ", t.Day(), "/", t.Month(), "/", t.Year())
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,45 +0,0 @@
|
||||
// Connects to an MAG3110 I2C magnetometer.
|
||||
package main
|
||||
|
||||
import (
|
||||
"machine"
|
||||
"time"
|
||||
|
||||
"fmt"
|
||||
|
||||
"tinygo.org/x/drivers/ds3231"
|
||||
)
|
||||
|
||||
func main() {
|
||||
machine.I2C0.Configure(machine.I2CConfig{})
|
||||
|
||||
rtc := ds3231.New(machine.I2C0)
|
||||
rtc.Configure()
|
||||
|
||||
valid := rtc.IsTimeValid()
|
||||
if !valid {
|
||||
date := time.Date(2019, 12, 05, 20, 34, 12, 0, time.UTC)
|
||||
rtc.SetTime(date)
|
||||
}
|
||||
|
||||
running := rtc.IsRunning()
|
||||
if !running {
|
||||
err := rtc.SetRunning(true)
|
||||
if err != nil {
|
||||
fmt.Println("Error configuring RTC")
|
||||
}
|
||||
}
|
||||
|
||||
for {
|
||||
dt, err := rtc.ReadTime()
|
||||
if err != nil {
|
||||
fmt.Println("Error reading date:", err)
|
||||
} else {
|
||||
fmt.Printf("Date: %d/%s/%02d %02d:%02d:%02d \r\n", dt.Year(), dt.Month(), dt.Day(), dt.Hour(), dt.Minute(), dt.Second())
|
||||
}
|
||||
temp, _ := rtc.ReadTemperature()
|
||||
fmt.Printf("Temperature: %.2f °C \r\n", float32(temp)/1000)
|
||||
|
||||
time.Sleep(time.Second * 1)
|
||||
}
|
||||
}
|
||||
@@ -1,23 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"machine"
|
||||
"time"
|
||||
|
||||
"tinygo.org/x/drivers/easystepper"
|
||||
)
|
||||
|
||||
func main() {
|
||||
motor := easystepper.New(machine.P13, machine.P15, machine.P14, machine.P16, 200, 75)
|
||||
motor.Configure()
|
||||
|
||||
for {
|
||||
println("CLOCKWISE")
|
||||
motor.Move(2050)
|
||||
time.Sleep(time.Millisecond * 1000)
|
||||
|
||||
println("COUNTERCLOCKWISE")
|
||||
motor.Move(-2050)
|
||||
time.Sleep(time.Millisecond * 1000)
|
||||
}
|
||||
}
|
||||
@@ -1,143 +0,0 @@
|
||||
// This is a console to a ESP8266/ESP32 running on the device UART1.
|
||||
// Allows you to type AT commands from your computer via the microcontroller.
|
||||
//
|
||||
// In other words:
|
||||
// Your computer <--> UART0 <--> MCU <--> UART1 <--> ESP8266 <--> INTERNET
|
||||
//
|
||||
// More information on the Espressif AT command set at:
|
||||
// https://www.espressif.com/sites/default/files/documentation/4a-esp8266_at_instruction_set_en.pdf
|
||||
//
|
||||
package main
|
||||
|
||||
import (
|
||||
"machine"
|
||||
"time"
|
||||
|
||||
"tinygo.org/x/drivers/espat"
|
||||
)
|
||||
|
||||
// change actAsAP to true to act as an access point instead of connecting to one.
|
||||
const actAsAP = false
|
||||
|
||||
// access point info
|
||||
const ssid = "YOURSSID"
|
||||
const pass = "YOURPASS"
|
||||
|
||||
// these are the default pins for the Arduino Nano33 IoT.
|
||||
// change these to connect to a different UART or pins for the ESP8266/ESP32
|
||||
var (
|
||||
uart = machine.UART1
|
||||
tx = machine.PA22
|
||||
rx = machine.PA23
|
||||
|
||||
console = machine.Serial
|
||||
|
||||
adaptor *espat.Device
|
||||
)
|
||||
|
||||
func main() {
|
||||
uart.Configure(machine.UARTConfig{TX: tx, RX: rx})
|
||||
|
||||
// Init esp8266
|
||||
adaptor = espat.New(uart)
|
||||
adaptor.Configure()
|
||||
|
||||
// first check if connected
|
||||
if connectToESP() {
|
||||
println("Connected to wifi adaptor.")
|
||||
adaptor.Echo(false)
|
||||
|
||||
connectToAP()
|
||||
} else {
|
||||
println("")
|
||||
failMessage("Unable to connect to wifi adaptor.")
|
||||
return
|
||||
}
|
||||
|
||||
println("Type an AT command then press enter:")
|
||||
prompt()
|
||||
|
||||
input := make([]byte, 64)
|
||||
i := 0
|
||||
for {
|
||||
if console.Buffered() > 0 {
|
||||
data, _ := console.ReadByte()
|
||||
|
||||
switch data {
|
||||
case 13:
|
||||
// return key
|
||||
console.Write([]byte("\r\n"))
|
||||
|
||||
// send command to ESP8266
|
||||
input[i] = byte('\r')
|
||||
input[i+1] = byte('\n')
|
||||
adaptor.Write(input[:i+2])
|
||||
|
||||
// display response
|
||||
r, _ := adaptor.Response(500)
|
||||
console.Write(r)
|
||||
|
||||
// prompt
|
||||
prompt()
|
||||
|
||||
i = 0
|
||||
continue
|
||||
default:
|
||||
// just echo the character
|
||||
console.WriteByte(data)
|
||||
input[i] = data
|
||||
i++
|
||||
}
|
||||
}
|
||||
time.Sleep(10 * time.Millisecond)
|
||||
}
|
||||
}
|
||||
|
||||
func prompt() {
|
||||
print("ESPAT>")
|
||||
}
|
||||
|
||||
// connect to ESP8266/ESP32
|
||||
func connectToESP() bool {
|
||||
for i := 0; i < 5; i++ {
|
||||
println("Connecting to wifi adaptor...")
|
||||
if adaptor.Connected() {
|
||||
return true
|
||||
}
|
||||
time.Sleep(1 * time.Second)
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// connect to access point
|
||||
func connectToAP() {
|
||||
println("Connecting to wifi network '" + ssid + "'")
|
||||
|
||||
adaptor.SetWifiMode(espat.WifiModeClient)
|
||||
adaptor.ConnectToAP(ssid, pass, 10)
|
||||
|
||||
println("Connected.")
|
||||
ip, err := adaptor.GetClientIP()
|
||||
if err != nil {
|
||||
failMessage(err.Error())
|
||||
}
|
||||
|
||||
println(ip)
|
||||
}
|
||||
|
||||
// provide access point
|
||||
func provideAP() {
|
||||
println("Starting wifi network as access point '" + ssid + "'...")
|
||||
adaptor.SetWifiMode(espat.WifiModeAP)
|
||||
adaptor.SetAPConfig(ssid, pass, 7, espat.WifiAPSecurityWPA2_PSK)
|
||||
println("Ready.")
|
||||
ip, _ := adaptor.GetAPIP()
|
||||
println(ip)
|
||||
}
|
||||
|
||||
func failMessage(msg string) {
|
||||
for {
|
||||
println(msg)
|
||||
time.Sleep(1 * time.Second)
|
||||
}
|
||||
}
|
||||
@@ -1,129 +0,0 @@
|
||||
// This is a sensor hub that uses a ESP8266/ESP32 running on the device UART1.
|
||||
// It creates a UDP "server" you can use to get info to/from your computer via the microcontroller.
|
||||
//
|
||||
// In other words:
|
||||
// Your computer <--> UART0 <--> MCU <--> UART1 <--> ESP8266 <--> INTERNET
|
||||
//
|
||||
package main
|
||||
|
||||
import (
|
||||
"machine"
|
||||
"time"
|
||||
|
||||
"tinygo.org/x/drivers/espat"
|
||||
"tinygo.org/x/drivers/net"
|
||||
)
|
||||
|
||||
// change actAsAP to true to act as an access point instead of connecting to one.
|
||||
const actAsAP = false
|
||||
|
||||
// access point info
|
||||
const ssid = "YOURSSID"
|
||||
const pass = "YOURPASS"
|
||||
|
||||
// these are the default pins for the Arduino Nano33 IoT.
|
||||
// change these to connect to a different UART or pins for the ESP8266/ESP32
|
||||
var (
|
||||
uart = machine.UART1
|
||||
tx = machine.PA22
|
||||
rx = machine.PA23
|
||||
|
||||
adaptor *espat.Device
|
||||
)
|
||||
|
||||
func main() {
|
||||
uart.Configure(machine.UARTConfig{TX: tx, RX: rx})
|
||||
|
||||
// Init esp8266
|
||||
adaptor = espat.New(uart)
|
||||
adaptor.Configure()
|
||||
|
||||
readyled := machine.LED
|
||||
readyled.Configure(machine.PinConfig{Mode: machine.PinOutput})
|
||||
readyled.High()
|
||||
|
||||
// first check if connected
|
||||
if connectToESP() {
|
||||
println("Connected to wifi adaptor.")
|
||||
adaptor.Echo(false)
|
||||
|
||||
connectToAP()
|
||||
} else {
|
||||
println("")
|
||||
failMessage("Unable to connect to wifi adaptor.")
|
||||
return
|
||||
}
|
||||
|
||||
// now make UDP connection
|
||||
laddr := &net.UDPAddr{Port: 2222}
|
||||
println("Loading UDP listener...")
|
||||
conn, _ := net.ListenUDP("UDP", laddr)
|
||||
|
||||
println("Waiting for data...")
|
||||
data := make([]byte, 50)
|
||||
blink := true
|
||||
for {
|
||||
n, _ := conn.Read(data)
|
||||
if n > 0 {
|
||||
println(string(data[:n]))
|
||||
conn.Write([]byte("hello back\r\n"))
|
||||
}
|
||||
blink = !blink
|
||||
if blink {
|
||||
readyled.High()
|
||||
} else {
|
||||
readyled.Low()
|
||||
}
|
||||
time.Sleep(500 * time.Millisecond)
|
||||
}
|
||||
|
||||
// Right now this code is never reached. Need a way to trigger it...
|
||||
println("Disconnecting UDP...")
|
||||
conn.Close()
|
||||
println("Done.")
|
||||
}
|
||||
|
||||
// connect to ESP8266/ESP32
|
||||
func connectToESP() bool {
|
||||
for i := 0; i < 5; i++ {
|
||||
println("Connecting to wifi adaptor...")
|
||||
if adaptor.Connected() {
|
||||
return true
|
||||
}
|
||||
time.Sleep(1 * time.Second)
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// connect to access point
|
||||
func connectToAP() {
|
||||
println("Connecting to wifi network '" + ssid + "'")
|
||||
|
||||
adaptor.SetWifiMode(espat.WifiModeClient)
|
||||
adaptor.ConnectToAP(ssid, pass, 10)
|
||||
|
||||
println("Connected.")
|
||||
ip, err := adaptor.GetClientIP()
|
||||
if err != nil {
|
||||
failMessage(err.Error())
|
||||
}
|
||||
|
||||
println(ip)
|
||||
}
|
||||
|
||||
// provide access point
|
||||
func provideAP() {
|
||||
println("Starting wifi network as access point '" + ssid + "'...")
|
||||
adaptor.SetWifiMode(espat.WifiModeAP)
|
||||
adaptor.SetAPConfig(ssid, pass, 7, espat.WifiAPSecurityWPA2_PSK)
|
||||
println("Ready.")
|
||||
ip, _ := adaptor.GetAPIP()
|
||||
println(ip)
|
||||
}
|
||||
|
||||
func failMessage(msg string) {
|
||||
for {
|
||||
println(msg)
|
||||
time.Sleep(1 * time.Second)
|
||||
}
|
||||
}
|
||||
@@ -1,108 +0,0 @@
|
||||
// This is a sensor station that uses a ESP8266 or ESP32 running on the device UART1.
|
||||
// It creates a UDP connection you can use to get info to/from your computer via the microcontroller.
|
||||
//
|
||||
// In other words:
|
||||
// Your computer <--> UART0 <--> MCU <--> UART1 <--> ESP8266
|
||||
//
|
||||
package main
|
||||
|
||||
import (
|
||||
"machine"
|
||||
"time"
|
||||
|
||||
"tinygo.org/x/drivers/espat"
|
||||
"tinygo.org/x/drivers/net"
|
||||
)
|
||||
|
||||
// access point info
|
||||
const ssid = "YOURSSID"
|
||||
const pass = "YOURPASS"
|
||||
|
||||
// IP address of the listener aka "hub". Replace with your own info.
|
||||
const hubIP = "0.0.0.0"
|
||||
|
||||
// these are the default pins for the Arduino Nano33 IoT.
|
||||
// change these to connect to a different UART or pins for the ESP8266/ESP32
|
||||
var (
|
||||
uart = machine.UART1
|
||||
tx = machine.PA22
|
||||
rx = machine.PA23
|
||||
|
||||
adaptor *espat.Device
|
||||
)
|
||||
|
||||
func main() {
|
||||
uart.Configure(machine.UARTConfig{TX: tx, RX: rx})
|
||||
|
||||
// Init esp8266/esp32
|
||||
adaptor = espat.New(uart)
|
||||
adaptor.Configure()
|
||||
|
||||
// first check if connected
|
||||
if connectToESP() {
|
||||
println("Connected to wifi adaptor.")
|
||||
adaptor.Echo(false)
|
||||
|
||||
connectToAP()
|
||||
} else {
|
||||
println("")
|
||||
failMessage("Unable to connect to wifi adaptor.")
|
||||
return
|
||||
}
|
||||
|
||||
// now make UDP connection
|
||||
ip := net.ParseIP(hubIP)
|
||||
raddr := &net.UDPAddr{IP: ip, Port: 2222}
|
||||
laddr := &net.UDPAddr{Port: 2222}
|
||||
|
||||
println("Dialing UDP connection...")
|
||||
conn, _ := net.DialUDP("udp", laddr, raddr)
|
||||
|
||||
for {
|
||||
// send data
|
||||
println("Sending data...")
|
||||
conn.Write([]byte("hello\r\n"))
|
||||
|
||||
time.Sleep(1000 * time.Millisecond)
|
||||
}
|
||||
|
||||
// Right now this code is never reached. Need a way to trigger it...
|
||||
println("Disconnecting UDP...")
|
||||
conn.Close()
|
||||
println("Done.")
|
||||
}
|
||||
|
||||
// connect to ESP8266/ESP32
|
||||
func connectToESP() bool {
|
||||
for i := 0; i < 5; i++ {
|
||||
println("Connecting to wifi adaptor...")
|
||||
if adaptor.Connected() {
|
||||
return true
|
||||
}
|
||||
time.Sleep(1 * time.Second)
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// connect to access point
|
||||
func connectToAP() {
|
||||
println("Connecting to wifi network '" + ssid + "'")
|
||||
|
||||
adaptor.SetWifiMode(espat.WifiModeClient)
|
||||
adaptor.ConnectToAP(ssid, pass, 10)
|
||||
|
||||
println("Connected.")
|
||||
ip, err := adaptor.GetClientIP()
|
||||
if err != nil {
|
||||
failMessage(err.Error())
|
||||
}
|
||||
|
||||
println(ip)
|
||||
}
|
||||
|
||||
func failMessage(msg string) {
|
||||
for {
|
||||
println(msg)
|
||||
time.Sleep(1 * time.Second)
|
||||
}
|
||||
}
|
||||
@@ -1,142 +0,0 @@
|
||||
// This is a sensor station that uses a ESP8266 or ESP32 running on the device UART1.
|
||||
// It creates an MQTT connection that publishes a message every second
|
||||
// to an MQTT broker.
|
||||
//
|
||||
// In other words:
|
||||
// Your computer <--> UART0 <--> MCU <--> UART1 <--> ESP8266 <--> Internet <--> MQTT broker.
|
||||
//
|
||||
// You must install the Paho MQTT package to build this program:
|
||||
//
|
||||
// go get -u github.com/eclipse/paho.mqtt.golang
|
||||
//
|
||||
package main
|
||||
|
||||
import (
|
||||
"machine"
|
||||
"math/rand"
|
||||
"time"
|
||||
|
||||
"tinygo.org/x/drivers/espat"
|
||||
"tinygo.org/x/drivers/net/mqtt"
|
||||
)
|
||||
|
||||
// access point info
|
||||
const ssid = "YOURSSID"
|
||||
const pass = "YOURPASS"
|
||||
|
||||
// IP address of the MQTT broker to use. Replace with your own info.
|
||||
const server = "tcp://test.mosquitto.org:1883"
|
||||
|
||||
//const server = "ssl://test.mosquitto.org:8883"
|
||||
|
||||
// these are the default pins for the Arduino Nano33 IoT.
|
||||
// change these to connect to a different UART or pins for the ESP8266/ESP32
|
||||
var (
|
||||
uart = machine.UART2
|
||||
tx = machine.PA22
|
||||
rx = machine.PA23
|
||||
|
||||
console = machine.Serial
|
||||
|
||||
adaptor *espat.Device
|
||||
topic = "tinygo"
|
||||
)
|
||||
|
||||
func main() {
|
||||
time.Sleep(3000 * time.Millisecond)
|
||||
|
||||
uart.Configure(machine.UARTConfig{TX: tx, RX: rx})
|
||||
rand.Seed(time.Now().UnixNano())
|
||||
|
||||
// Init esp8266/esp32
|
||||
adaptor = espat.New(uart)
|
||||
adaptor.Configure()
|
||||
|
||||
// first check if connected
|
||||
if connectToESP() {
|
||||
println("Connected to wifi adaptor.")
|
||||
adaptor.Echo(false)
|
||||
|
||||
connectToAP()
|
||||
} else {
|
||||
println("")
|
||||
failMessage("Unable to connect to wifi adaptor.")
|
||||
return
|
||||
}
|
||||
|
||||
opts := mqtt.NewClientOptions()
|
||||
opts.AddBroker(server).SetClientID("tinygo-client-" + randomString(10))
|
||||
|
||||
println("Connecting to MQTT broker at", server)
|
||||
cl := mqtt.NewClient(opts)
|
||||
if token := cl.Connect(); token.Wait() && token.Error() != nil {
|
||||
failMessage(token.Error().Error())
|
||||
}
|
||||
|
||||
for {
|
||||
println("Publishing MQTT message...")
|
||||
data := []byte("{\"e\":[{ \"n\":\"hello\", \"v\":101 }]}")
|
||||
token := cl.Publish(topic, 0, false, data)
|
||||
token.Wait()
|
||||
if token.Error() != nil {
|
||||
println(token.Error().Error())
|
||||
}
|
||||
|
||||
time.Sleep(1000 * time.Millisecond)
|
||||
}
|
||||
|
||||
// Right now this code is never reached. Need a way to trigger it...
|
||||
println("Disconnecting MQTT...")
|
||||
cl.Disconnect(100)
|
||||
|
||||
println("Done.")
|
||||
}
|
||||
|
||||
// connect to ESP8266/ESP32
|
||||
func connectToESP() bool {
|
||||
for i := 0; i < 5; i++ {
|
||||
println("Connecting to wifi adaptor...")
|
||||
if adaptor.Connected() {
|
||||
return true
|
||||
}
|
||||
time.Sleep(1 * time.Second)
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// connect to access point
|
||||
func connectToAP() {
|
||||
println("Connecting to wifi network '" + ssid + "'")
|
||||
|
||||
adaptor.SetWifiMode(espat.WifiModeClient)
|
||||
adaptor.ConnectToAP(ssid, pass, 10)
|
||||
|
||||
println("Connected.")
|
||||
ip, err := adaptor.GetClientIP()
|
||||
if err != nil {
|
||||
failMessage(err.Error())
|
||||
}
|
||||
|
||||
println(ip)
|
||||
}
|
||||
|
||||
// Returns an int >= min, < max
|
||||
func randomInt(min, max int) int {
|
||||
return min + rand.Intn(max-min)
|
||||
}
|
||||
|
||||
// Generate a random string of A-Z chars with len = l
|
||||
func randomString(len int) string {
|
||||
bytes := make([]byte, len)
|
||||
for i := 0; i < len; i++ {
|
||||
bytes[i] = byte(randomInt(65, 90))
|
||||
}
|
||||
return string(bytes)
|
||||
}
|
||||
|
||||
func failMessage(msg string) {
|
||||
for {
|
||||
println(msg)
|
||||
time.Sleep(1 * time.Second)
|
||||
}
|
||||
}
|
||||
@@ -1,163 +0,0 @@
|
||||
// This is a sensor station that uses a ESP8266 or ESP32 running on the device UART1.
|
||||
// It creates an MQTT connection that publishes a message every second
|
||||
// to an MQTT broker.
|
||||
//
|
||||
// In other words:
|
||||
// Your computer <--> UART0 <--> MCU <--> UART1 <--> ESP8266 <--> Internet <--> MQTT broker.
|
||||
//
|
||||
// You must also install the Paho MQTT package to build this program:
|
||||
//
|
||||
// go get -u github.com/eclipse/paho.mqtt.golang
|
||||
//
|
||||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"machine"
|
||||
"math/rand"
|
||||
"time"
|
||||
|
||||
"tinygo.org/x/drivers/espat"
|
||||
"tinygo.org/x/drivers/net/mqtt"
|
||||
)
|
||||
|
||||
// access point info
|
||||
const ssid = "YOURSSID"
|
||||
const pass = "YOURPASS"
|
||||
|
||||
// IP address of the MQTT broker to use. Replace with your own info.
|
||||
//const server = "tcp://test.mosquitto.org:1883"
|
||||
|
||||
const server = "ssl://test.mosquitto.org:8883"
|
||||
|
||||
// change these to connect to a different UART or pins for the ESP8266/ESP32
|
||||
var (
|
||||
// these are defaults for the Arduino Nano33 IoT.
|
||||
uart = machine.UART1
|
||||
tx = machine.PA22
|
||||
rx = machine.PA23
|
||||
|
||||
console = machine.Serial
|
||||
|
||||
adaptor *espat.Device
|
||||
cl mqtt.Client
|
||||
topicTx = "tinygo/tx"
|
||||
topicRx = "tinygo/rx"
|
||||
)
|
||||
|
||||
func subHandler(client mqtt.Client, msg mqtt.Message) {
|
||||
fmt.Printf("[%s] ", msg.Topic())
|
||||
fmt.Printf("%s\r\n", msg.Payload())
|
||||
}
|
||||
|
||||
func main() {
|
||||
time.Sleep(3000 * time.Millisecond)
|
||||
|
||||
uart.Configure(machine.UARTConfig{TX: tx, RX: rx})
|
||||
rand.Seed(time.Now().UnixNano())
|
||||
|
||||
// Init esp8266/esp32
|
||||
adaptor = espat.New(uart)
|
||||
adaptor.Configure()
|
||||
|
||||
// first check if connected
|
||||
if connectToESP() {
|
||||
println("Connected to wifi adaptor.")
|
||||
adaptor.Echo(false)
|
||||
|
||||
connectToAP()
|
||||
} else {
|
||||
println("")
|
||||
failMessage("Unable to connect to wifi adaptor.")
|
||||
return
|
||||
}
|
||||
|
||||
opts := mqtt.NewClientOptions()
|
||||
opts.AddBroker(server).SetClientID("tinygo-client-" + randomString(10))
|
||||
|
||||
println("Connecting to MQTT broker at", server)
|
||||
cl = mqtt.NewClient(opts)
|
||||
if token := cl.Connect(); token.Wait() && token.Error() != nil {
|
||||
failMessage(token.Error().Error())
|
||||
}
|
||||
|
||||
// subscribe
|
||||
token := cl.Subscribe(topicRx, 0, subHandler)
|
||||
token.Wait()
|
||||
if token.Error() != nil {
|
||||
failMessage(token.Error().Error())
|
||||
}
|
||||
|
||||
go publishing()
|
||||
|
||||
select {}
|
||||
|
||||
// Right now this code is never reached. Need a way to trigger it...
|
||||
println("Disconnecting MQTT...")
|
||||
cl.Disconnect(100)
|
||||
|
||||
println("Done.")
|
||||
}
|
||||
|
||||
func publishing() {
|
||||
for {
|
||||
println("Publishing MQTT message...")
|
||||
data := []byte("{\"e\":[{ \"n\":\"hello\", \"v\":101 }]}")
|
||||
token := cl.Publish(topicTx, 0, false, data)
|
||||
token.Wait()
|
||||
if token.Error() != nil {
|
||||
println(token.Error().Error())
|
||||
}
|
||||
|
||||
time.Sleep(1000 * time.Millisecond)
|
||||
}
|
||||
}
|
||||
|
||||
// connect to ESP8266/ESP32
|
||||
func connectToESP() bool {
|
||||
for i := 0; i < 5; i++ {
|
||||
println("Connecting to wifi adaptor...")
|
||||
if adaptor.Connected() {
|
||||
return true
|
||||
}
|
||||
time.Sleep(1 * time.Second)
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// connect to access point
|
||||
func connectToAP() {
|
||||
println("Connecting to wifi network '" + ssid + "'")
|
||||
|
||||
adaptor.SetWifiMode(espat.WifiModeClient)
|
||||
adaptor.ConnectToAP(ssid, pass, 10)
|
||||
|
||||
println("Connected.")
|
||||
ip, err := adaptor.GetClientIP()
|
||||
if err != nil {
|
||||
failMessage(err.Error())
|
||||
}
|
||||
|
||||
println(ip)
|
||||
}
|
||||
|
||||
// Returns an int >= min, < max
|
||||
func randomInt(min, max int) int {
|
||||
return min + rand.Intn(max-min)
|
||||
}
|
||||
|
||||
// Generate a random string of A-Z chars with len = l
|
||||
func randomString(len int) string {
|
||||
bytes := make([]byte, len)
|
||||
for i := 0; i < len; i++ {
|
||||
bytes[i] = byte(randomInt(65, 90))
|
||||
}
|
||||
return string(bytes)
|
||||
}
|
||||
|
||||
func failMessage(msg string) {
|
||||
for {
|
||||
println(msg)
|
||||
time.Sleep(1 * time.Second)
|
||||
}
|
||||
}
|
||||
@@ -1,111 +0,0 @@
|
||||
// This is a sensor station that uses a ESP8266 or ESP32 running on the device UART1.
|
||||
// It creates a UDP connection you can use to get info to/from your computer via the microcontroller.
|
||||
//
|
||||
// In other words:
|
||||
// Your computer <--> UART0 <--> MCU <--> UART1 <--> ESP8266
|
||||
//
|
||||
package main
|
||||
|
||||
import (
|
||||
"machine"
|
||||
"time"
|
||||
|
||||
"tinygo.org/x/drivers/espat"
|
||||
"tinygo.org/x/drivers/net"
|
||||
)
|
||||
|
||||
// access point info
|
||||
const ssid = "YOURSSID"
|
||||
const pass = "YOURPASS"
|
||||
|
||||
// IP address of the server aka "hub". Replace with your own info.
|
||||
const serverIP = "0.0.0.0"
|
||||
|
||||
// these are the default pins for the Arduino Nano33 IoT.
|
||||
// change these to connect to a different UART or pins for the ESP8266/ESP32
|
||||
var (
|
||||
uart = machine.UART1
|
||||
tx = machine.PA22
|
||||
rx = machine.PA23
|
||||
|
||||
adaptor *espat.Device
|
||||
)
|
||||
|
||||
func main() {
|
||||
uart.Configure(machine.UARTConfig{TX: tx, RX: rx})
|
||||
|
||||
// Init esp8266/esp32
|
||||
adaptor = espat.New(uart)
|
||||
adaptor.Configure()
|
||||
|
||||
// first check if connected
|
||||
if connectToESP() {
|
||||
println("Connected to wifi adaptor.")
|
||||
adaptor.Echo(false)
|
||||
|
||||
connectToAP()
|
||||
} else {
|
||||
println("")
|
||||
failMessage("Unable to connect to wifi adaptor.")
|
||||
return
|
||||
}
|
||||
|
||||
// now make TCP connection
|
||||
ip := net.ParseIP(serverIP)
|
||||
raddr := &net.TCPAddr{IP: ip, Port: 8080}
|
||||
laddr := &net.TCPAddr{Port: 8080}
|
||||
|
||||
println("Dialing TCP connection...")
|
||||
conn, err := net.DialTCP("tcp", laddr, raddr)
|
||||
if err != nil {
|
||||
failMessage(err.Error())
|
||||
}
|
||||
|
||||
for {
|
||||
// send data
|
||||
println("Sending data...")
|
||||
conn.Write([]byte("hello\r\n"))
|
||||
|
||||
time.Sleep(1000 * time.Millisecond)
|
||||
}
|
||||
|
||||
// Right now this code is never reached. Need a way to trigger it...
|
||||
println("Disconnecting TCP...")
|
||||
conn.Close()
|
||||
println("Done.")
|
||||
}
|
||||
|
||||
// connect to ESP8266/ESP32
|
||||
func connectToESP() bool {
|
||||
for i := 0; i < 5; i++ {
|
||||
println("Connecting to wifi adaptor...")
|
||||
if adaptor.Connected() {
|
||||
return true
|
||||
}
|
||||
time.Sleep(1 * time.Second)
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// connect to access point
|
||||
func connectToAP() {
|
||||
println("Connecting to wifi network '" + ssid + "'")
|
||||
|
||||
adaptor.SetWifiMode(espat.WifiModeClient)
|
||||
adaptor.ConnectToAP(ssid, pass, 10)
|
||||
|
||||
println("Connected.")
|
||||
ip, err := adaptor.GetClientIP()
|
||||
if err != nil {
|
||||
failMessage(err.Error())
|
||||
}
|
||||
|
||||
println(ip)
|
||||
}
|
||||
|
||||
func failMessage(msg string) {
|
||||
for {
|
||||
println(msg)
|
||||
time.Sleep(1 * time.Second)
|
||||
}
|
||||
}
|
||||
@@ -1,259 +0,0 @@
|
||||
package console_example
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"io"
|
||||
"machine"
|
||||
"os"
|
||||
"strconv"
|
||||
"strings"
|
||||
|
||||
"tinygo.org/x/drivers/flash"
|
||||
)
|
||||
|
||||
const consoleBufLen = 64
|
||||
const storageBufLen = 512
|
||||
|
||||
var (
|
||||
debug = false
|
||||
|
||||
input [consoleBufLen]byte
|
||||
store [storageBufLen]byte
|
||||
|
||||
console = machine.Serial
|
||||
|
||||
dev *flash.Device
|
||||
|
||||
commands map[string]cmdfunc = map[string]cmdfunc{
|
||||
"": cmdfunc(noop),
|
||||
"erase": cmdfunc(erase),
|
||||
"lsblk": cmdfunc(lsblk),
|
||||
"write": cmdfunc(write),
|
||||
"xxd": cmdfunc(xxd),
|
||||
}
|
||||
)
|
||||
|
||||
type cmdfunc func(argv []string)
|
||||
|
||||
const (
|
||||
StateInput = iota
|
||||
StateEscape
|
||||
StateEscBrc
|
||||
StateCSI
|
||||
)
|
||||
|
||||
func RunFor(device *flash.Device) {
|
||||
|
||||
dev = device
|
||||
dev.Configure(&flash.DeviceConfig{
|
||||
Identifier: flash.DefaultDeviceIdentifier,
|
||||
})
|
||||
|
||||
prompt()
|
||||
|
||||
var state = StateInput
|
||||
|
||||
for i := 0; ; {
|
||||
if console.Buffered() > 0 {
|
||||
data, _ := console.ReadByte()
|
||||
if debug {
|
||||
fmt.Printf("\rdata: %x\r\n\r", data)
|
||||
prompt()
|
||||
console.Write(input[:i])
|
||||
}
|
||||
switch state {
|
||||
case StateInput:
|
||||
switch data {
|
||||
case 0x8:
|
||||
fallthrough
|
||||
case 0x7f: // this is probably wrong... works on my machine tho :)
|
||||
// backspace
|
||||
if i > 0 {
|
||||
i -= 1
|
||||
console.Write([]byte{0x8, 0x20, 0x8})
|
||||
}
|
||||
case 13:
|
||||
// return key
|
||||
console.Write([]byte("\r\n"))
|
||||
runCommand(string(input[:i]))
|
||||
prompt()
|
||||
|
||||
i = 0
|
||||
continue
|
||||
case 27:
|
||||
// escape
|
||||
state = StateEscape
|
||||
default:
|
||||
// anything else, just echo the character if it is printable
|
||||
if strconv.IsPrint(rune(data)) {
|
||||
if i < (consoleBufLen - 1) {
|
||||
console.WriteByte(data)
|
||||
input[i] = data
|
||||
i++
|
||||
}
|
||||
}
|
||||
}
|
||||
case StateEscape:
|
||||
switch data {
|
||||
case 0x5b:
|
||||
state = StateEscBrc
|
||||
default:
|
||||
state = StateInput
|
||||
}
|
||||
default:
|
||||
// TODO: handle escape sequences
|
||||
state = StateInput
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func runCommand(line string) {
|
||||
argv := strings.SplitN(strings.TrimSpace(line), " ", -1)
|
||||
cmd := argv[0]
|
||||
cmdfn, ok := commands[cmd]
|
||||
if !ok {
|
||||
println("unknown command: " + line)
|
||||
return
|
||||
}
|
||||
cmdfn(argv)
|
||||
}
|
||||
|
||||
func noop(argv []string) {}
|
||||
|
||||
func lsblk(argv []string) {
|
||||
attrs := dev.Attrs()
|
||||
status1, _ := dev.ReadStatus()
|
||||
status2, _ := dev.ReadStatus2()
|
||||
serialNumber1, _ := dev.ReadSerialNumber()
|
||||
fmt.Printf(
|
||||
"\n-------------------------------------\r\n"+
|
||||
" Device Information: \r\n"+
|
||||
"-------------------------------------\r\n"+
|
||||
" JEDEC ID: %v\r\n"+
|
||||
" Serial: %v\r\n"+
|
||||
" Status 1: %02x\r\n"+
|
||||
" Status 2: %02x\r\n"+
|
||||
" \r\n"+
|
||||
" Max clock speed (MHz): %d\r\n"+
|
||||
" Has Sector Protection: %t\r\n"+
|
||||
" Supports Fast Reads: %t\r\n"+
|
||||
" Supports QSPI Reads: %t\r\n"+
|
||||
" Supports QSPI Write: %t\r\n"+
|
||||
" Write Status Split: %t\r\n"+
|
||||
" Single Status Byte: %t\r\n"+
|
||||
"-------------------------------------\r\n\r\n",
|
||||
attrs.JedecID,
|
||||
serialNumber1,
|
||||
status1,
|
||||
status2,
|
||||
attrs.MaxClockSpeedMHz,
|
||||
attrs.HasSectorProtection,
|
||||
attrs.SupportsFastRead,
|
||||
attrs.SupportsQSPI,
|
||||
attrs.SupportsQSPIWrites,
|
||||
attrs.WriteStatusSplit,
|
||||
attrs.SingleStatusByte,
|
||||
)
|
||||
}
|
||||
|
||||
func erase(argv []string) {
|
||||
if len(argv) < 3 {
|
||||
println("usage: erase <chip|block|sector> <bytes>")
|
||||
return
|
||||
}
|
||||
var err error
|
||||
var addr uint64 = 0x0
|
||||
if addr, err = strconv.ParseUint(argv[2], 16, 32); err != nil {
|
||||
println("Invalid address: " + err.Error() + "\r\n")
|
||||
return
|
||||
}
|
||||
if argv[1] == "block" {
|
||||
if err = dev.EraseBlock(uint32(addr)); err != nil {
|
||||
println("Block erase error: " + err.Error() + "\r\n")
|
||||
}
|
||||
} else if argv[1] == "sector" {
|
||||
if err = dev.EraseSector(uint32(addr)); err != nil {
|
||||
println("Sector erase error: " + err.Error() + "\r\n")
|
||||
}
|
||||
} else if argv[1] == "chip" {
|
||||
if err = dev.EraseAll(); err != nil {
|
||||
println("Chip erase error: " + err.Error() + "\r\n")
|
||||
}
|
||||
} else {
|
||||
println("usage: erase <chip|block|sector> <bytes>")
|
||||
}
|
||||
}
|
||||
|
||||
func write(argv []string) {
|
||||
if len(argv) < 3 {
|
||||
println("usage: write <hex offset> <bytes>")
|
||||
}
|
||||
var err error
|
||||
var addr uint64 = 0x0
|
||||
if addr, err = strconv.ParseUint(argv[1], 16, 32); err != nil {
|
||||
println("Invalid address: " + err.Error() + "\r\n")
|
||||
return
|
||||
}
|
||||
buf := []byte(argv[2])
|
||||
if _, err = dev.WriteAt(buf, int64(addr)); err != nil {
|
||||
println("Write error: " + err.Error() + "\r\n")
|
||||
}
|
||||
}
|
||||
|
||||
func xxd(argv []string) {
|
||||
var err error
|
||||
var addr uint64 = 0x0
|
||||
var size int = 64
|
||||
switch len(argv) {
|
||||
case 3:
|
||||
if size, err = strconv.Atoi(argv[2]); err != nil {
|
||||
println("Invalid size argument: " + err.Error() + "\r\n")
|
||||
return
|
||||
}
|
||||
if size > storageBufLen || size < 1 {
|
||||
fmt.Printf("Size of hexdump must be greater than 0 and less than %d\r\n", storageBufLen)
|
||||
return
|
||||
}
|
||||
fallthrough
|
||||
case 2:
|
||||
if addr, err = strconv.ParseUint(argv[1], 16, 32); err != nil {
|
||||
println("Invalid address: " + err.Error() + "\r\n")
|
||||
return
|
||||
}
|
||||
fallthrough
|
||||
case 1:
|
||||
// no args supplied, so nothing to do here, just use the defaults
|
||||
default:
|
||||
println("usage: xxd <hex address, ex: 0xA0> <size of hexdump in bytes>\r\n")
|
||||
return
|
||||
}
|
||||
buf := store[0:size]
|
||||
dev.ReadAt(buf, int64(addr))
|
||||
xxdfprint(os.Stdout, uint32(addr), buf)
|
||||
}
|
||||
|
||||
func xxdfprint(w io.Writer, offset uint32, b []byte) {
|
||||
var l int
|
||||
var buf16 = make([]byte, 16)
|
||||
for i, c := 0, len(b); i < c; i += 16 {
|
||||
l = i + 16
|
||||
if l >= c {
|
||||
l = c
|
||||
}
|
||||
fmt.Fprintf(w, "%08x: % x ", offset+uint32(i), b[i:l])
|
||||
for j, n := 0, l-i; j < 16; j++ {
|
||||
if j >= n || !strconv.IsPrint(rune(b[i+j])) {
|
||||
buf16[j] = '.'
|
||||
} else {
|
||||
buf16[j] = b[i+j]
|
||||
}
|
||||
}
|
||||
console.Write(buf16)
|
||||
println()
|
||||
}
|
||||
}
|
||||
|
||||
func prompt() {
|
||||
print("==> ")
|
||||
}
|
||||
@@ -1,21 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"machine"
|
||||
|
||||
"tinygo.org/x/drivers/examples/flash/console"
|
||||
"tinygo.org/x/drivers/flash"
|
||||
)
|
||||
|
||||
func main() {
|
||||
console_example.RunFor(
|
||||
flash.NewQSPI(
|
||||
machine.QSPI_CS,
|
||||
machine.QSPI_SCK,
|
||||
machine.QSPI_DATA0,
|
||||
machine.QSPI_DATA1,
|
||||
machine.QSPI_DATA2,
|
||||
machine.QSPI_DATA3,
|
||||
),
|
||||
)
|
||||
}
|
||||
@@ -1,20 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"machine"
|
||||
|
||||
console_example "tinygo.org/x/drivers/examples/flash/console"
|
||||
"tinygo.org/x/drivers/flash"
|
||||
)
|
||||
|
||||
func main() {
|
||||
console_example.RunFor(
|
||||
flash.NewSPI(
|
||||
&machine.SPI1,
|
||||
machine.SPI1_SDO_PIN,
|
||||
machine.SPI1_SDI_PIN,
|
||||
machine.SPI1_SCK_PIN,
|
||||
machine.SPI1_CS_PIN,
|
||||
),
|
||||
)
|
||||
}
|
||||
@@ -1,50 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"machine"
|
||||
"time"
|
||||
|
||||
"tinygo.org/x/drivers/gps"
|
||||
)
|
||||
|
||||
func main() {
|
||||
println("GPS I2C Example")
|
||||
machine.I2C0.Configure(machine.I2CConfig{})
|
||||
ublox := gps.NewI2C(machine.I2C0)
|
||||
parser := gps.NewParser()
|
||||
var fix gps.Fix
|
||||
for {
|
||||
s, err := ublox.NextSentence()
|
||||
if err != nil {
|
||||
println(err)
|
||||
continue
|
||||
}
|
||||
|
||||
fix, err = parser.Parse(s)
|
||||
if err != nil {
|
||||
println(err)
|
||||
continue
|
||||
}
|
||||
if fix.Valid {
|
||||
print(fix.Time.Format("15:04:05"))
|
||||
print(", lat=")
|
||||
print(fix.Latitude)
|
||||
print(", long=")
|
||||
print(fix.Longitude)
|
||||
print(", altitude=", fix.Altitude)
|
||||
print(", satellites=", fix.Satellites)
|
||||
if fix.Speed != 0 {
|
||||
print(", speed=")
|
||||
print(fix.Speed)
|
||||
}
|
||||
if fix.Heading != 0 {
|
||||
print(", heading=")
|
||||
print(fix.Heading)
|
||||
}
|
||||
println()
|
||||
} else {
|
||||
println("No fix")
|
||||
}
|
||||
time.Sleep(200 * time.Millisecond)
|
||||
}
|
||||
}
|
||||
@@ -1,50 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"machine"
|
||||
"time"
|
||||
|
||||
"tinygo.org/x/drivers/gps"
|
||||
)
|
||||
|
||||
func main() {
|
||||
println("GPS UART Example")
|
||||
machine.UART1.Configure(machine.UARTConfig{BaudRate: 9600})
|
||||
ublox := gps.NewUART(machine.UART1)
|
||||
parser := gps.NewParser()
|
||||
var fix gps.Fix
|
||||
for {
|
||||
s, err := ublox.NextSentence()
|
||||
if err != nil {
|
||||
println(err)
|
||||
continue
|
||||
}
|
||||
|
||||
fix, err = parser.Parse(s)
|
||||
if err != nil {
|
||||
println(err)
|
||||
continue
|
||||
}
|
||||
if fix.Valid {
|
||||
print(fix.Time.Format("15:04:05"))
|
||||
print(", lat=")
|
||||
print(fix.Latitude)
|
||||
print(", long=")
|
||||
print(fix.Longitude)
|
||||
print(", altitude=", fix.Altitude)
|
||||
print(", satellites=", fix.Satellites)
|
||||
if fix.Speed != 0 {
|
||||
print(", speed=")
|
||||
print(fix.Speed)
|
||||
}
|
||||
if fix.Heading != 0 {
|
||||
print(", heading=")
|
||||
print(fix.Heading)
|
||||
}
|
||||
println()
|
||||
} else {
|
||||
println("No fix")
|
||||
}
|
||||
time.Sleep(200 * time.Millisecond)
|
||||
}
|
||||
}
|
||||
@@ -1,20 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"machine"
|
||||
"time"
|
||||
|
||||
"tinygo.org/x/drivers/hcsr04"
|
||||
)
|
||||
|
||||
func main() {
|
||||
sensor := hcsr04.New(machine.D10, machine.D9)
|
||||
sensor.Configure()
|
||||
|
||||
println("Ultrasonic starts")
|
||||
for {
|
||||
println("Distance:", sensor.ReadDistance(), "mm")
|
||||
|
||||
time.Sleep(100 * time.Millisecond)
|
||||
}
|
||||
}
|
||||
@@ -1,31 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"machine"
|
||||
|
||||
"tinygo.org/x/drivers/hd44780"
|
||||
)
|
||||
|
||||
func main() {
|
||||
|
||||
lcd, _ := hd44780.NewGPIO4Bit(
|
||||
[]machine.Pin{machine.P0, machine.P1, machine.P2, machine.P3},
|
||||
machine.P4,
|
||||
machine.P5,
|
||||
machine.P6,
|
||||
)
|
||||
|
||||
lcd.Configure(hd44780.Config{
|
||||
Width: 16,
|
||||
Height: 2,
|
||||
CursorOnOff: true,
|
||||
CursorBlink: true,
|
||||
})
|
||||
|
||||
lcd.CreateCharacter(0x0, []byte{0x04, 0x0E, 0x0E, 0x0E, 0x0E, 0x1F, 0x04, 0x0})
|
||||
lcd.Write([]byte{0x0})
|
||||
lcd.Display()
|
||||
for {
|
||||
|
||||
}
|
||||
}
|
||||
@@ -1,31 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"machine"
|
||||
|
||||
"tinygo.org/x/drivers/hd44780"
|
||||
)
|
||||
|
||||
func main() {
|
||||
|
||||
lcd, _ := hd44780.NewGPIO4Bit(
|
||||
[]machine.Pin{machine.P0, machine.P1, machine.P2, machine.P3},
|
||||
machine.P4,
|
||||
machine.P5,
|
||||
machine.P6,
|
||||
)
|
||||
|
||||
lcd.Configure(hd44780.Config{
|
||||
Width: 16,
|
||||
Height: 2,
|
||||
CursorOnOff: true,
|
||||
CursorBlink: true,
|
||||
})
|
||||
|
||||
lcd.Write([]byte("This is a long line"))
|
||||
lcd.Display()
|
||||
|
||||
for {
|
||||
|
||||
}
|
||||
}
|
||||
@@ -1,60 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"machine"
|
||||
"strconv"
|
||||
"time"
|
||||
|
||||
"tinygo.org/x/drivers/hd44780i2c"
|
||||
)
|
||||
|
||||
func main() {
|
||||
|
||||
// Note: most HD44780 LCD modules requires 5V power, however some variations
|
||||
// use 3.3V (and may be damaged by 5V).
|
||||
|
||||
machine.I2C0.Configure(machine.I2CConfig{
|
||||
Frequency: machine.TWI_FREQ_400KHZ,
|
||||
})
|
||||
|
||||
lcd := hd44780i2c.New(machine.I2C0, 0x27) // some modules have address 0x3F
|
||||
|
||||
lcd.Configure(hd44780i2c.Config{
|
||||
Width: 16, // required
|
||||
Height: 2, // required
|
||||
CursorOn: true,
|
||||
CursorBlink: true,
|
||||
})
|
||||
|
||||
lcd.Print([]byte(" TinyGo\n LCD Test "))
|
||||
|
||||
// CGRAM address 0x0-0x7 can be used to store 8 custom characters
|
||||
lcd.CreateCharacter(0x0, []byte{0x00, 0x11, 0x0E, 0x1F, 0x15, 0x1F, 0x1F, 0x1F})
|
||||
lcd.Print([]byte{0x0})
|
||||
|
||||
// You can use https://maxpromer.github.io/LCD-Character-Creator/
|
||||
// to crete your own characters.
|
||||
|
||||
time.Sleep(time.Millisecond * 7000)
|
||||
|
||||
for i := 0; i < 5; i++ {
|
||||
lcd.BacklightOn(false)
|
||||
time.Sleep(time.Millisecond * 250)
|
||||
lcd.BacklightOn(true)
|
||||
time.Sleep(time.Millisecond * 250)
|
||||
}
|
||||
|
||||
lcd.CursorOn(false)
|
||||
lcd.CursorBlink(false)
|
||||
|
||||
i := 0
|
||||
for {
|
||||
|
||||
lcd.ClearDisplay()
|
||||
lcd.SetCursor(2, 1)
|
||||
lcd.Print([]byte(strconv.FormatInt(int64(i), 10)))
|
||||
i++
|
||||
time.Sleep(time.Millisecond * 100)
|
||||
|
||||
}
|
||||
}
|
||||
@@ -1,142 +0,0 @@
|
||||
package gopherimg
|
||||
|
||||
import "image/color"
|
||||
|
||||
var ImageArray = []uint32{
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6015176, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6015176, 6015176, 6015176, 6015176, 6015176, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 0, 0, 0, 0, 0, 0, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 0, 0, 0, 0, 0, 0, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 0, 0, 0, 0, 0, 0,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 0, 0, 0, 0, 0, 0, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 0, 0, 0, 0, 0, 0, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 0, 0, 0, 0, 0, 0,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 0, 0, 0, 0, 0, 6015176, 6015176, 6015176, 6015176, 6015176, 16777215, 16777215, 16777215,
|
||||
16777215, 16777215, 16777215, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 0, 0, 0, 0, 0, 6015176, 6015176, 6015176, 6015176,
|
||||
16777215, 16777215, 0, 0, 0, 0, 16777215, 16777215, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 0, 0, 0, 0, 6015176, 6015176, 6015176,
|
||||
6015176, 16777215, 16777215, 16777215, 0, 0, 0, 0, 0, 16777215, 16777215, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 0, 0, 0, 0, 6015176,
|
||||
6015176, 6015176, 16777215, 16777215, 16777215, 16777215, 0, 0, 0, 0, 0, 16777215, 16777215, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 0, 0,
|
||||
0, 6015176, 6015176, 6015176, 6015176, 16777215, 16777215, 16777215, 16777215, 0, 0, 0, 0, 0, 16777215, 16777215,
|
||||
16777215, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 0, 0, 0, 6015176, 6015176, 6015176, 6015176, 16777215, 16777215, 16777215, 16777215, 16777215, 0,
|
||||
0, 0, 16777215, 16777215, 16777215, 16777215, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 0, 0, 6015176, 6015176, 6015176, 6015176, 6015176, 16777215,
|
||||
16777215, 16777215, 16777215, 16777215, 16777215, 16777215, 16777215, 16777215, 16777215, 16777215, 16777215,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 0, 0, 6015176, 6015176, 6015176, 6015176, 6015176, 16777215, 16777215, 16777215, 16777215, 16777215,
|
||||
16777215, 16777215, 16777215, 16777215, 16777215, 16777215, 16777215, 6015176, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 0, 0, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 16777215, 16777215, 16777215, 16777215, 16777215, 16777215, 16777215, 16777215, 16777215, 16777215,
|
||||
16777215, 16777215, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 0, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 16777215, 16777215, 16777215,
|
||||
16777215, 16777215, 16777215, 16777215, 16777215, 16777215, 16777215, 16777215, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 0, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 16777215, 16777215, 16777215, 16777215, 16777215, 16777215, 16777215,
|
||||
16777215, 16777215, 6015176, 6015176, 6015176, 6015176, 8145949, 8145949, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 0, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 16777215, 16777215, 16777215, 16777215, 16777215, 16777215, 16777215, 16777215, 6015176, 6015176, 6015176,
|
||||
8145949, 8145949, 8145949, 8145949, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 0,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 16777215, 16777215,
|
||||
16777215, 16777215, 6015176, 6015176, 6015176, 6015176, 8145949, 8145949, 8145949, 8145949, 8145949, 16777215,
|
||||
16777215, 16777215, 6015176, 6015176, 6015176, 6015176, 6015176, 0, 6015176, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 8145949, 8145949, 8145949, 8145949, 8145949, 15267831, 16645886, 16777215, 16777215, 6015176, 6015176,
|
||||
6015176, 6015176, 0, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 0, 0, 8145949, 8145949, 8145949, 8145949, 16777215,
|
||||
16777215, 16777215, 16777215, 6015176, 6015176, 6015176, 6015176, 0, 6015176, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 0, 0,
|
||||
8145949, 8145949, 8145949, 8145949, 6868429, 7786961, 7327695, 6015176, 6015176, 6015176, 6015176, 6015176, 0,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 0, 0, 8145949, 8145949, 8145949, 8145949, 16777215, 16777215,
|
||||
16777215, 16777215, 6015176, 6015176, 6015176, 6015176, 0, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 16777215, 16777215, 16777215, 16777215, 16777215, 6015176, 6015176, 6015176, 0, 0,
|
||||
8145949, 8145949, 8145949, 8145949, 15530489, 16121084, 16777215, 16777215, 6015176, 6015176, 6015176, 6015176, 0,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 16777215, 16777215, 0, 0, 0, 0, 16777215,
|
||||
6015176, 6015176, 6015176, 8145949, 8145949, 8145949, 8145949, 8145949, 16777215, 16777215, 16777215, 6015176,
|
||||
6015176, 6015176, 6015176, 6015176, 0, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 16777215,
|
||||
16777215, 0, 0, 0, 0, 0, 16777215, 16777215, 6015176, 6015176, 6015176, 8145949, 8145949, 8145949, 8145949,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 0, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 16777215, 16777215, 16777215, 0, 0, 0, 0, 0, 16777215, 16777215, 6015176, 6015176, 6015176,
|
||||
6015176, 8145949, 8145949, 8145949, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 0,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 16777215, 16777215, 16777215, 0, 0, 0, 0, 0, 16777215,
|
||||
16777215, 16777215, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 6015176, 0, 6015176, 6015176, 6015176, 6015176, 6015176, 16777215, 16777215, 16777215,
|
||||
16777215, 16777215, 16777215, 0, 0, 16777215, 16777215, 16777215, 16777215, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 0, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 16777215, 16777215, 16777215, 16777215, 16777215, 16777215, 16777215, 16777215,
|
||||
16777215, 16777215, 16777215, 16777215, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 0, 0, 6015176, 6015176, 6015176, 6015176, 16777215, 16777215,
|
||||
16777215, 16777215, 16777215, 16777215, 16777215, 16777215, 16777215, 16777215, 16777215, 16777215, 6015176,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 0, 0, 6015176, 6015176, 6015176, 6015176, 16777215, 16777215, 16777215, 16777215, 16777215, 16777215,
|
||||
16777215, 16777215, 16777215, 16777215, 16777215, 16777215, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 0, 0, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 16777215, 16777215, 16777215, 16777215, 16777215, 16777215, 16777215, 16777215, 16777215, 16777215,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 0, 0, 0, 6015176, 6015176, 6015176, 6015176, 16777215, 16777215, 16777215, 16777215,
|
||||
16777215, 16777215, 16777215, 16777215, 16777215, 16777215, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 0, 0, 0, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 16777215, 16777215, 16777215, 16777215, 16777215, 16777215, 16777215, 16777215, 6015176,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 0, 0, 0, 0, 6015176, 6015176, 6015176, 6015176, 6015176, 16777215, 16777215, 16777215,
|
||||
16777215, 16777215, 16777215, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 0, 0, 0, 0, 0, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 0, 0,
|
||||
0, 0, 0, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 6015176, 0, 0, 0, 0, 0, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 0, 0, 0, 0, 0, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 0, 0,
|
||||
0, 0, 0, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 6015176, 0, 0, 0, 0, 0, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 0, 0, 0, 0, 0, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 0, 0,
|
||||
0, 0, 0, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 0, 6015176,
|
||||
6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 0, 0, 0, 0, 0, 0, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 0, 0, 0, 0, 0, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 6015176, 6015176, 0, 0, 0, 0, 0, 0, 0, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 6015176, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6015176, 6015176, 6015176, 6015176,
|
||||
6015176, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
}
|
||||
|
||||
func Int2Color(intColor uint32) (col color.RGBA) {
|
||||
blue := uint8(intColor & 0xFF)
|
||||
green := uint8((intColor >> 8) & 0xFF)
|
||||
red := uint8((intColor >> 16) & 0xFF)
|
||||
|
||||
return color.RGBA{R: red, G: green, B: blue}
|
||||
}
|
||||
@@ -1,103 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"machine"
|
||||
|
||||
"image/color"
|
||||
"time"
|
||||
|
||||
"tinygo.org/x/drivers/examples/hub75/gopherimg"
|
||||
"tinygo.org/x/drivers/hub75"
|
||||
)
|
||||
|
||||
var display hub75.Device
|
||||
|
||||
func main() {
|
||||
machine.SPI0.Configure(machine.SPIConfig{
|
||||
Frequency: 8000000,
|
||||
Mode: 0},
|
||||
)
|
||||
|
||||
display = hub75.New(machine.SPI0, 11, 12, 6, 10, 18, 20)
|
||||
display.Configure(hub75.Config{
|
||||
Width: 64,
|
||||
Height: 32,
|
||||
RowPattern: 16,
|
||||
ColorDepth: 6,
|
||||
})
|
||||
|
||||
colors := []color.RGBA{
|
||||
{255, 0, 0, 255},
|
||||
{255, 255, 0, 255},
|
||||
{0, 255, 0, 255},
|
||||
{0, 255, 255, 255},
|
||||
{0, 0, 255, 255},
|
||||
{255, 0, 255, 255},
|
||||
{255, 255, 255, 255},
|
||||
}
|
||||
|
||||
display.ClearDisplay()
|
||||
display.SetBrightness(100)
|
||||
|
||||
step := 0
|
||||
then := time.Now()
|
||||
size := int16(8)
|
||||
x := int16(0)
|
||||
y := int16(0)
|
||||
dx := int16(1)
|
||||
dy := int16(1)
|
||||
c := 0
|
||||
for {
|
||||
if time.Since(then).Nanoseconds() > 800000000 {
|
||||
then = time.Now()
|
||||
step++
|
||||
|
||||
if step < 23 {
|
||||
showRect(size, x*size, y*size, colors[c])
|
||||
c = (c + 1) % 7
|
||||
x += dx
|
||||
y += dy
|
||||
if x >= (64 / size) {
|
||||
dx = -1
|
||||
x += 2 * dx
|
||||
}
|
||||
if y >= (32 / size) {
|
||||
dy = -1
|
||||
y += 2 * dy
|
||||
}
|
||||
if x < 0 {
|
||||
dx = 1
|
||||
x += 2 * dx
|
||||
}
|
||||
if y < 0 {
|
||||
dy = 1
|
||||
y += 2 * dy
|
||||
}
|
||||
} else if step == 23 {
|
||||
showGopher()
|
||||
} else if step == 30 {
|
||||
display.ClearDisplay()
|
||||
step = 0
|
||||
x = 0
|
||||
y = 0
|
||||
}
|
||||
}
|
||||
display.Display()
|
||||
}
|
||||
}
|
||||
|
||||
func showGopher() {
|
||||
for i := int16(0); i < 64; i++ {
|
||||
for j := int16(0); j < 32; j++ {
|
||||
display.SetPixel(i, j, gopherimg.Int2Color(gopherimg.ImageArray[32*i+j]))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func showRect(size int16, x int16, y int16, c color.RGBA) {
|
||||
for i := x; i < x+size; i++ {
|
||||
for j := y; j < y+size; j++ {
|
||||
display.SetPixel(i, j, c)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,29 +0,0 @@
|
||||
// +build atsamd21
|
||||
|
||||
package main
|
||||
|
||||
import (
|
||||
"machine"
|
||||
|
||||
"tinygo.org/x/drivers/ili9341"
|
||||
)
|
||||
|
||||
var (
|
||||
display = ili9341.NewSPI(
|
||||
machine.SPI0,
|
||||
machine.D0,
|
||||
machine.D1,
|
||||
machine.D2,
|
||||
)
|
||||
|
||||
backlight = machine.D3
|
||||
)
|
||||
|
||||
func init() {
|
||||
machine.SPI0.Configure(machine.SPIConfig{
|
||||
SCK: machine.SPI0_SCK_PIN,
|
||||
SDO: machine.SPI0_SDO_PIN,
|
||||
SDI: machine.SPI0_SDI_PIN,
|
||||
Frequency: 24000000,
|
||||
})
|
||||
}
|
||||
@@ -1,38 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"image/color"
|
||||
"machine"
|
||||
"time"
|
||||
|
||||
"tinygo.org/x/drivers/ili9341"
|
||||
)
|
||||
|
||||
var (
|
||||
black = color.RGBA{0, 0, 0, 255}
|
||||
white = color.RGBA{255, 255, 255, 255}
|
||||
red = color.RGBA{255, 0, 0, 255}
|
||||
blue = color.RGBA{0, 0, 255, 255}
|
||||
green = color.RGBA{0, 255, 0, 255}
|
||||
)
|
||||
|
||||
func main() {
|
||||
|
||||
backlight.Configure(machine.PinConfig{machine.PinOutput})
|
||||
|
||||
display.Configure(ili9341.Config{})
|
||||
width, height := display.Size()
|
||||
|
||||
display.FillScreen(black)
|
||||
backlight.High()
|
||||
|
||||
display.FillRectangle(0, 0, width/2, height/2, white)
|
||||
display.FillRectangle(width/2, 0, width/2, height/2, red)
|
||||
display.FillRectangle(0, height/2, width/2, height/2, green)
|
||||
display.FillRectangle(width/2, height/2, width/2, height/2, blue)
|
||||
display.FillRectangle(width/4, height/4, width/2, height/2, black)
|
||||
for {
|
||||
time.Sleep(time.Hour)
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,22 +0,0 @@
|
||||
// +build pyportal
|
||||
|
||||
package main
|
||||
|
||||
import (
|
||||
"machine"
|
||||
|
||||
"tinygo.org/x/drivers/ili9341"
|
||||
)
|
||||
|
||||
var (
|
||||
display = ili9341.NewParallel(
|
||||
machine.LCD_DATA0,
|
||||
machine.TFT_WR,
|
||||
machine.TFT_DC,
|
||||
machine.TFT_CS,
|
||||
machine.TFT_RESET,
|
||||
machine.TFT_RD,
|
||||
)
|
||||
|
||||
backlight = machine.TFT_BACKLIGHT
|
||||
)
|
||||
@@ -1,29 +0,0 @@
|
||||
// +build wioterminal
|
||||
|
||||
package main
|
||||
|
||||
import (
|
||||
"machine"
|
||||
|
||||
"tinygo.org/x/drivers/ili9341"
|
||||
)
|
||||
|
||||
var (
|
||||
display = ili9341.NewSPI(
|
||||
machine.SPI3,
|
||||
machine.LCD_DC,
|
||||
machine.LCD_SS_PIN,
|
||||
machine.LCD_RESET,
|
||||
)
|
||||
|
||||
backlight = machine.LCD_BACKLIGHT
|
||||
)
|
||||
|
||||
func init() {
|
||||
machine.SPI3.Configure(machine.SPIConfig{
|
||||
SCK: machine.LCD_SCK_PIN,
|
||||
SDO: machine.LCD_SDO_PIN,
|
||||
SDI: machine.LCD_SDI_PIN,
|
||||
Frequency: 40000000,
|
||||
})
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,228 +0,0 @@
|
||||
// Port of Adafruit's "pyportal_boing" demo found here:
|
||||
// https://github.com/adafruit/Adafruit_ILI9341/blob/master/examples/pyportal_boing
|
||||
package main
|
||||
|
||||
import (
|
||||
"machine"
|
||||
"time"
|
||||
|
||||
"tinygo.org/x/drivers/examples/ili9341/pyportal_boing/graphics"
|
||||
"tinygo.org/x/drivers/ili9341"
|
||||
)
|
||||
|
||||
const (
|
||||
BGCOLOR = 0xAD75
|
||||
GRIDCOLOR = 0xA815
|
||||
BGSHADOW = 0x5285
|
||||
GRIDSHADOW = 0x600C
|
||||
RED = 0xF800
|
||||
WHITE = 0xFFFF
|
||||
|
||||
YBOTTOM = 123 // Ball Y coord at bottom
|
||||
YBOUNCE = -3.5 // Upward velocity on ball bounce
|
||||
|
||||
_debug = false
|
||||
)
|
||||
|
||||
var (
|
||||
frameBuffer = [(graphics.BALLHEIGHT + 8) * (graphics.BALLWIDTH + 8) * 2]uint8{}
|
||||
|
||||
startTime int64
|
||||
frame int64
|
||||
|
||||
// Ball coordinates are stored floating-point because screen refresh
|
||||
// is so quick, whole-pixel movements are just too fast!
|
||||
ballx float32
|
||||
bally float32
|
||||
ballvx float32
|
||||
ballvy float32
|
||||
ballframe float32
|
||||
balloldx float32
|
||||
balloldy float32
|
||||
|
||||
// Color table for ball rotation effect
|
||||
palette [16]uint16
|
||||
)
|
||||
|
||||
func main() {
|
||||
|
||||
// configure backlight
|
||||
backlight.Configure(machine.PinConfig{machine.PinOutput})
|
||||
|
||||
// configure display
|
||||
display.Configure(ili9341.Config{})
|
||||
print("width, height == ")
|
||||
width, height := display.Size()
|
||||
println(width, height)
|
||||
|
||||
backlight.High()
|
||||
|
||||
display.SetRotation(ili9341.Rotation270)
|
||||
DrawBackground()
|
||||
|
||||
startTime = time.Now().UnixNano()
|
||||
frame = 0
|
||||
|
||||
ballx = 20.0
|
||||
bally = YBOTTOM // Current ball position
|
||||
ballvx = 0.8
|
||||
ballvy = YBOUNCE // Ball velocity
|
||||
ballframe = 3 // Ball animation frame #
|
||||
balloldx = ballx
|
||||
balloldy = bally // Prior ball position
|
||||
|
||||
for {
|
||||
|
||||
balloldx = ballx // Save prior position
|
||||
balloldy = bally
|
||||
ballx += ballvx // Update position
|
||||
bally += ballvy
|
||||
ballvy += 0.06 // Update Y velocity
|
||||
if (ballx <= 15) || (ballx >= graphics.SCREENWIDTH-graphics.BALLWIDTH) {
|
||||
ballvx *= -1 // Left/right bounce
|
||||
}
|
||||
if bally >= YBOTTOM { // Hit ground?
|
||||
bally = YBOTTOM // Clip and
|
||||
ballvy = YBOUNCE // bounce up
|
||||
}
|
||||
|
||||
// Determine screen area to update. This is the bounds of the ball's
|
||||
// prior and current positions, so the old ball is fully erased and new
|
||||
// ball is fully drawn.
|
||||
var minx, miny, maxx, maxy, width, height int16
|
||||
|
||||
// Determine bounds of prior and new positions
|
||||
minx = int16(ballx)
|
||||
if int16(balloldx) < minx {
|
||||
minx = int16(balloldx)
|
||||
}
|
||||
miny = int16(bally)
|
||||
if int16(balloldy) < miny {
|
||||
miny = int16(balloldy)
|
||||
}
|
||||
maxx = int16(ballx + graphics.BALLWIDTH - 1)
|
||||
if int16(balloldx+graphics.BALLWIDTH-1) > maxx {
|
||||
maxx = int16(balloldx + graphics.BALLWIDTH - 1)
|
||||
}
|
||||
maxy = int16(bally + graphics.BALLHEIGHT - 1)
|
||||
if int16(balloldy+graphics.BALLHEIGHT-1) > maxy {
|
||||
maxy = int16(balloldy + graphics.BALLHEIGHT - 1)
|
||||
}
|
||||
|
||||
width = maxx - minx + 1
|
||||
height = maxy - miny + 1
|
||||
|
||||
// Ball animation frame # is incremented opposite the ball's X velocity
|
||||
ballframe -= ballvx * 0.5
|
||||
if ballframe < 0 {
|
||||
ballframe += 14 // Constrain from 0 to 13
|
||||
} else if ballframe >= 14 {
|
||||
ballframe -= 14
|
||||
}
|
||||
|
||||
// Set 7 palette entries to white, 7 to red, based on frame number.
|
||||
// This makes the ball spin
|
||||
for i := 0; i < 14; i++ {
|
||||
if (int(ballframe)+i)%14 < 7 {
|
||||
palette[i+2] = WHITE
|
||||
} else {
|
||||
palette[i+2] = RED
|
||||
} // Palette entries 0 and 1 aren't used (clear and shadow, respectively)
|
||||
}
|
||||
|
||||
// Only the changed rectangle is drawn into the 'renderbuf' array...
|
||||
var c uint16 //, *destPtr;
|
||||
bx := minx - int16(ballx) // X relative to ball bitmap (can be negative)
|
||||
by := miny - int16(bally) // Y relative to ball bitmap (can be negative)
|
||||
bgx := minx // X relative to background bitmap (>= 0)
|
||||
bgy := miny // Y relative to background bitmap (>= 0)
|
||||
var bx1, bgx1 int16 // Loop counters and working vars
|
||||
var p uint8 // 'packed' value of 2 ball pixels
|
||||
var bufIdx int8 = 0
|
||||
|
||||
//tft.setAddrWindow(minx, miny, width, height)
|
||||
|
||||
for y := 0; y < int(height); y++ { // For each row...
|
||||
//destPtr = &renderbuf[bufIdx][0];
|
||||
bx1 = bx // Need to keep the original bx and bgx values,
|
||||
bgx1 = bgx // so copies of them are made here (and changed in loop below)
|
||||
for x := 0; x < int(width); x++ {
|
||||
var bgidx = int(bgy)*(graphics.SCREENWIDTH/8) + int(bgx1/8)
|
||||
if (bx1 >= 0) && (bx1 < graphics.BALLWIDTH) && // Is current pixel row/column
|
||||
(by >= 0) && (by < graphics.BALLHEIGHT) { // inside the ball bitmap area?
|
||||
// Yes, do ball compositing math...
|
||||
p = graphics.Ball[int(by*(graphics.BALLWIDTH/2))+int(bx1/2)] // Get packed value (2 pixels)
|
||||
if (bx1 & 1) != 0 {
|
||||
c = uint16(p & 0xF)
|
||||
} else {
|
||||
c = uint16(p >> 4)
|
||||
} // Unpack high or low nybble
|
||||
if c == 0 { // Outside ball - just draw grid
|
||||
if graphics.Background[bgidx]&(0x80>>(bgx1&7)) != 0 {
|
||||
c = GRIDCOLOR
|
||||
} else {
|
||||
c = BGCOLOR
|
||||
}
|
||||
} else if c > 1 { // In ball area...
|
||||
c = palette[c]
|
||||
} else { // In shadow area...
|
||||
if graphics.Background[bgidx]&(0x80>>(bgx1&7)) != 0 {
|
||||
c = GRIDSHADOW
|
||||
} else {
|
||||
c = BGSHADOW
|
||||
}
|
||||
}
|
||||
} else { // Outside ball bitmap, just draw background bitmap...
|
||||
if graphics.Background[bgidx]&(0x80>>(bgx1&7)) != 0 {
|
||||
c = GRIDCOLOR
|
||||
} else {
|
||||
c = BGCOLOR
|
||||
}
|
||||
}
|
||||
frameBuffer[(y*int(width)+x)*2] = byte(c >> 8)
|
||||
frameBuffer[(y*int(width)+x)*2+1] = byte(c)
|
||||
bx1++ // Increment bitmap position counters (X axis)
|
||||
bgx1++
|
||||
}
|
||||
//tft.dmaWait(); // Wait for prior line to complete
|
||||
//tft.writePixels(&renderbuf[bufIdx][0], width, false); // Non-blocking write
|
||||
bufIdx = 1 - bufIdx
|
||||
by++ // Increment bitmap position counters (Y axis)
|
||||
bgy++
|
||||
}
|
||||
|
||||
display.DrawRGBBitmap8(minx, miny, frameBuffer[:width*height*2], width, height)
|
||||
|
||||
// Show approximate frame rate
|
||||
frame++
|
||||
if frame&255 == 0 { // Every 256 frames...
|
||||
elapsed := (time.Now().UnixNano() - startTime) / int64(time.Second)
|
||||
if elapsed > 0 {
|
||||
println(frame/elapsed, " fps")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func DrawBackground() {
|
||||
w, h := display.Size()
|
||||
byteWidth := (w + 7) / 8 // Bitmap scanline pad = whole byte
|
||||
var b uint8
|
||||
for j := int16(0); j < h; j++ {
|
||||
for k := int16(0); k < w; k++ {
|
||||
if k&7 > 0 {
|
||||
b <<= 1
|
||||
} else {
|
||||
b = graphics.Background[j*byteWidth+k/8]
|
||||
}
|
||||
if b&0x80 == 0 {
|
||||
frameBuffer[2*k] = byte(BGCOLOR >> 8)
|
||||
frameBuffer[2*k+1] = byte(BGCOLOR & 0xFF)
|
||||
} else {
|
||||
frameBuffer[2*k] = byte(GRIDCOLOR >> 8)
|
||||
frameBuffer[2*k+1] = byte(GRIDCOLOR & 0xFF)
|
||||
}
|
||||
}
|
||||
display.DrawRGBBitmap8(0, j, frameBuffer[0:w*2], w, 1)
|
||||
}
|
||||
}
|
||||
@@ -1,22 +0,0 @@
|
||||
// +build pyportal
|
||||
|
||||
package main
|
||||
|
||||
import (
|
||||
"machine"
|
||||
|
||||
"tinygo.org/x/drivers/ili9341"
|
||||
)
|
||||
|
||||
var (
|
||||
display = ili9341.NewParallel(
|
||||
machine.LCD_DATA0,
|
||||
machine.TFT_WR,
|
||||
machine.TFT_DC,
|
||||
machine.TFT_CS,
|
||||
machine.TFT_RESET,
|
||||
machine.TFT_RD,
|
||||
)
|
||||
|
||||
backlight = machine.TFT_BACKLIGHT
|
||||
)
|
||||
@@ -1,29 +0,0 @@
|
||||
// +build wioterminal
|
||||
|
||||
package main
|
||||
|
||||
import (
|
||||
"machine"
|
||||
|
||||
"tinygo.org/x/drivers/ili9341"
|
||||
)
|
||||
|
||||
var (
|
||||
display = ili9341.NewSPI(
|
||||
machine.SPI3,
|
||||
machine.LCD_DC,
|
||||
machine.LCD_SS_PIN,
|
||||
machine.LCD_RESET,
|
||||
)
|
||||
|
||||
backlight = machine.LCD_BACKLIGHT
|
||||
)
|
||||
|
||||
func init() {
|
||||
machine.SPI3.Configure(machine.SPIConfig{
|
||||
SCK: machine.LCD_SCK_PIN,
|
||||
SDO: machine.LCD_SDO_PIN,
|
||||
SDI: machine.LCD_SDI_PIN,
|
||||
Frequency: 40000000,
|
||||
})
|
||||
}
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user