Merge tag 'v1.17' into merge-v1.17
F-strings, new machine.I2S class, ESP32-C3 support and LEGO_HUB_NO6 board
This release of MicroPython adds support for f-strings (PEP-498), with a
few limitations compared to normal Python. F-strings are essentially
syntactic sugar for "".format() and make formatting strings a lot more
convenient. Other improvements to the core runtime include pretty printing
OSError when it has two arguments (an errno code and a string), scheduling
of KeyboardInterrupt on the main thread, and support for a single argument
to the optimised form of StopIteration.
In the machine module a new I2S class has been added, with support for
esp32 and stm32 ports. This provides a consistent API for transmit and
receive of audio data in blocking, non-blocking and asyncio-based
operation. Also, the json module has support for the "separators" argument
in the dump and dumps functions, and framebuf now includes a way to blit
between frame buffers of different formats using a palette. A new,
portable machine.bitstream function is also added which can output a stream
of bits with configurable timing, and is used as the basis for driving
WS2812 LEDs in a common way across ports.
There has been some restructuring of the repository directory layout, with
all third-party code now in the lib/ directory. And a new top-level
directory shared/ has been added with first-party code that was previously
in lib/ moved there.
The docs have seen further improvement with enhancements and additions to
the rp2 parts, as well as a new quick reference for the zephyr port.
The terms master/slave have been replaced with controller/peripheral,
mainly relating to I2C and SPI usage. And u-module references have been
replaced with just the module name without the u-prefix to help clear up
the intended usage of modules in MicroPython.
For the esp8266 and esp32 ports, hidden networks are now included in WLAN
scan results. On the esp32 the RMT class is enhanced with idle_level and
write_pulses modes. There is initial support for ESP32-C3 chips with
GENERIC_C3 and GENERIC_C3_USB boards.
The javascript port has had its Makefile and garbage collector
implementation reworked so it compiles and runs with latest the Emscripten
using asyncify.
The mimxrt port sees the addition of hardware I2C and SPI support, as well
as some additional methods to the machine module. There is also support
for Hyperflash chips.
The nrf port now has full VFS storage support, enables source-line on
traceback, and has .mpy features consistent with other ports.
For the rp2 port there is now more configurability for boards, and more
boards added.
The stm32 port has a new LEGO_HUB_NO6 board definition with detailed
information how to get this LEGO Hub running stock MicroPython. There is
also now support to change the CPU frequency on STM32WB MCUs. And USBD_xxx
descriptor options have been renamed to MICROPY_HW_USB_xxx.
Thanks to everyone who contributed to this release: Amir Gonnen, Andrew
Scheller, Bryan Tong Minh, Chris Wilson, Damien George, Daniel Mizyrycki,
David Lechner, David P, Fernando, finefoot, Frank Pilhofer, Glenn Ruben
Bakke, iabdalkader, Jeff Epler, Jim Mussared, Jonathan Hogg, Josh Klar,
Josh Lloyd, Julia Hathaway, Krzysztof Adamski, Matúš Olekšák, Michael
Weiss, Michel Bouwmans, Mike Causer, Mike Teachman, Ned Konz, NitiKaur,
oclyke, Patrick Van Oosterwijck, Peter Hinch, Peter Züger, Philipp
Ebensberger, robert-hh, Roberto Colistete Jr, Sashkoiv, Seon Rozenblum,
Tobias Thyrrestrup, Tom McDermott, Will Sowerbutts, Yonatan Goldschmidt.
What follows is a detailed list of changes, generated from the git commit
history, and organised into sections.
Main components
===============
all:
- fix signed shifts and NULL access errors from -fsanitize=undefined
- update to point to files in new shared/ directory
py core:
- mpstate: make exceptions thread-local
- mpstate: schedule KeyboardInterrupt on main thread
- mperrno: add MP_ECANCELED error code
- makeqstrdefs.py: don't include .h files explicitly in preprocessing
- mark unused arguments from bytecode decoding macros
- objexcept: pretty print OSError also when it has 2 arguments
- makeversionhdr: add --tags arg to git describe
- vm: simplify handling of MP_OBJ_STOP_ITERATION in yield-from opcode
- objexcept: make mp_obj_exception_get_value support subclassed excs
- support single argument to optimised MP_OBJ_STOP_ITERATION
- introduce and use mp_raise_type_arg helper
- modsys: optimise sys.exit for code size by using exception helpers
- objexcept: make mp_obj_new_exception_arg1 inline
- obj: fix formatting of comment for mp_obj_is_integer
- emitnative: reuse need_reg_all func in need_stack_settled
- emitnative: ensure stack settling is safe mid-branch
- runtime: fix bool unary op for subclasses of native types
- builtinimport: fix condition for including do_execute_raw_code()
- mkrules: automatically build mpy-cross if it doesn't exist
- implement partial PEP-498 (f-string) support
- lexer: clear fstring_args vstr on lexer free
- mkrules.mk: do submodule sync in "make submodules"
extmod:
- btstack: add missing call to mp_bluetooth_hci_uart_deinit
- btstack: check that BLE is active before performing operations
- uasyncio: get addr and bind server socket before creating task
- axtls-include: add axtls_os_port.h to customise axTLS
- update for move of crypto-algorithms, re1.5, uzlib to lib
- moduselect: conditionally compile select()
- nimble: fix leak in l2cap_send if send-while-stalled
- btstack/btstack.mk: use -Wno-implicit-fallthrough, not =0
- utime: always invoke mp_hal_delay_ms when >= to 0ms
- modbluetooth: clamp MTU values to 32->UINT16_MAX
- nimble: allow modbluetooth binding to hook "sent HCI packet"
- nimble: add "memory stalling" mechanism for l2cap_send
- uasyncio: in open_connection use address info in socket creation
- modujson: add support for dump/dumps separators keyword-argument
- modlwip: fix close and clean up of UDP and raw sockets
- modbluetooth: add send_update arg to gatts_write
- add machine.bitstream
- modframebuf: enable blit between different formats via a palette
lib:
- tinyusb: update to version 0.10.1
- pico-sdk: update to version 1.2.0
- utils/stdout_helpers: make mp_hal_stdout_tx_strn_cooked efficient
- axtls: switch to repo at micropython/axtls
- axtls: update to latest axtls 2.1.5 wih additional commits
- re1.5: move re1.5 code from extmod to lib
- uzlib: move uzlib code from extmod to lib
- crypto-algorithms: move crypto-algorithms code from extmod to lib
- update README's based on contents of these dirs
drivers:
- neopixel: add common machine.bitstream-based neopixel module
- neopixel: optimize fill() for speed
- neopixel: reduce code size of driver
- cyw43: fix cyw43_deinit so it can be called many times in a row
- cyw43: make wifi join fail if interface is not active
mpy-cross:
- disable stack check when building with Emscripten
Support components
==================
docs:
- library: document new esp32.RMT features and fix wait_done
- library: warn that ustruct doesn't handle spaces in format strings
- esp8266/tutorial: change flash mode from dio to dout
- replace master/slave with controller/peripheral in I2C and SPI
- rp2: enhance quickref and change image to Pico pinout
- rp2: update general section to give a brief technical overview
- library/utime.rst: clarify behaviour and precision of sleep ms/us
- library/uasyncio.rst: document stream readexactly() method
- library/machine.I2S.rst: fix use of sd pin in examples
- zephyr: add quick reference for the Zephyr port
- library/zephyr: add libraries specific to the Zephyr port
- templates: add unix and zephyr quickref links to top-index
- rename ufoo.rst to foo.rst
- replace ufoo with foo in all docs
- library/index.rst: clarify module naming and purpose
- library/builtins.rst: add module title
- library/network.rst: simplify socket import
- add docs for machine.bitstream and neopixel module
- library: fix usage of :term: for frozen module reference
- esp8266: use monospace for software tools
- reference: mention that slicing a memoryview causes allocation
examples: no changes specific to this component/port
tests:
- extmod: make uasyncio_heaplock test more deterministic
- cpydiff/modules_struct_whitespace_in_format: run black
- extmod/ujson: add tests for dump/dumps separators argument
- run-multitests.py: add broadcast and wait facility
- multi_bluetooth/ble_subscribe.py: add test for subscription
- extmod/vfs_fat_finaliser.py: ensure alloc at never-used GC blocks
- basics: split f-string debug printing to separate file with .exp
- pybnative: make while.py test run on boards without pyb.delay
tools:
- autobuild: add scripts to build release firmware
- remove obsolete build-stm-latest.sh script
- ci.sh: run apt-get update in ci_powerpc_setup
- makemanifest.py: allow passing flags to mpy-tool.py
- autobuild: add mimxrt port to build scripts for nightly builds
- pyboard.py: add cmd-line option to make soft reset configurable
- mpremote: swap order of PID and VID in connect-list output
- ci.sh: build unix dev variant as part of macOS CI
- ci.sh: build GENERIC_C3 board as part of esp32 CI
- autobuild: use separate IDF version to build newer esp32 SoCs
- autobuild: add FeatherS2 and TinyS2 to esp32 auto builds
- mpremote: add seek whence for mounted files
- mpremote: raise OSError on unsupported RemoteFile.seek
- autobuild: add the MIMXRT1050_EVKB board to the daily builds
- ci.sh: add mpy-cross build to nrf port
- codeformat.py: include ports/nrf/modules/nrf in code formatting
- gen-cpydiff.py: don't rename foo to ufoo in diff output
- autobuild: add auto build for Silicognition wESP32
- mpremote: fix connect-list in case VID/PID are None
- mpremote: add "devs" shortcut for "connect list"
- mpremote: remove support for pyb.USB_VCP in/out specialisation
- autobuild: don't use "-B" for make, it's already a fresh build
- pyboard.py: move --no-exclusive/--soft-reset out of mutex group
- pyboard.py: make --no-follow use same variable as --follow
- pyboard.py: add --exclusive to match --no-exclusive
- pyboard.py: make --no-soft-reset consistent with other args
- uncrustify: force 1 newline at end of file
- mpremote: bump version to 0.0.6
CI:
- workflows: add workflow to build and test javascript port
- workflows: switch from Coveralls to Codecov
- workflows: switch from lcov to gcov
- workflows: add workflow to build and test unix dev variant
The ports
=========
all ports:
- use common mp_hal_stdout_tx_strn_cooked instead of custom one
- update for move of crypto-algorithms, uzlib to lib
- rename USBD_VID/PID config macros to MICROPY_HW_USB_VID/PID
bare-arm port: no changes specific to this component/port
cc3200 port: no changes specific to this component/port
esp8266 port:
- add __len__ to NeoPixel driver to support iterating
- Makefile: add more libm files to build
- include hidden networks in WLAN.scan results
- replace esp.neopixel with machine.bitstream
- remove dead code for end_ticks in machine_bitstream
esp32 port:
- boards/sdkconfig.base: disable MEMPROT_FEATURE to alloc from IRAM
- add __len__ to NeoPixel driver to support iterating
- main: allow MICROPY_DIR to be overridden
- esp32_rmt: fix RMT looping in newer IDF versions
- esp32_rmt: enhance RMT with idle_level and write_pulses modes
- add new machine.I2S class for I2S protocol support
- machine_spi: calculate actual attained baudrate
- machine_hw_spi: use a 2 item SPI queue for long transfers
- machine_dac: add MICROPY_PY_MACHINE_DAC option, enable by default
- machine_i2s: add MICROPY_PY_MACHINE_I2S option, enable by default
- fix use of mp_int_t, size_t and uintptr_t
- add initial support for ESP32C3 SoCs
- boards/GENERIC_C3: add generic C3-based board
- modmachine: release the GIL in machine.idle()
- mphalport: always yield at least once in delay_ms
- machine_uart: add flow kw-arg to enable hardware flow control
- boards: add Silicognition wESP32 board configuration
- mpconfigport.h: enable reverse and inplace special methods
- include hidden networks in WLAN.scan results
- makeimg.py: get bootloader and partition offset from sdkconfig
- enable MICROPY_PY_FSTRINGS by default
- machine_hw_spi: release GIL during transfers
- machine_pin: make check for non-output pins respect chip variant
- replace esp.neopixel with machine.bitstream
- remove dead code for end_ticks in machine_bitstream
- boards: add GENERIC_C3_USB board with USB serial/JTAG support
javascript port:
- rework Makefile and GC so it works with latest Emscripten
- Makefile: suppress compiler errors from array bounds
- Makefile: change variable to EXPORTED_RUNTIME_METHODS
mimxrt port:
- move calc_weekday helper function to timeutils
- machine_spi: add the SPI class to the machine module
- moduos: seed the PRNG on boot using the TRNG
- boards: set vfs partition start to 1 MBbyte
- main: skip running main.py if boot.py failed
- main: extend the information returned by help()
- mimxrt_flash: remove commented-out code
- modmachine: add a few minor methods to the machine module
- machine_led: use mp_raise_msg_varg helper
- machine_i2c: add hardware-based machine.I2C to machine module
- add support for Hyperflash chips
- boards: add support for the MIMXRT1050_EVKB board
- machine_pin: implement ioctl for Pin
minimal port:
- Makefile: add support for building with user C modules
nrf port:
- modules: replace master/slave with controller/peripheral in SPI
- boards/common.ld: calculate unused flash region
- modules/nrf: add new nrf module with flash block device
- drivers: add support for using flash block device with SoftDevice
- mpconfigport.h: expose nrf module when MICROPY_PY_NRF is set
- README: update README.md to reflect internal file systems
- mpconfigport.h: tune FAT FS configuration
- Makefile: add _fs_size linker script override from make
- modules/uos: allow a board to configure MICROPY_VFS_FAT/LFS1/LFS2
- mpconfigport.h: enable MICROPY_PY_IO_FILEIO when an FS is enabled
- qstrdefsport.h: add entries for in-built FS mount points
- main: add auto mount and auto format hook for internal flash FS
- boards: enable needed features for FAT/LFS1/LFS2
- facilitate use of freeze manifest
- boards: set FROZEN_MANIFEST blank when SD present on nrf51 targets
- modules/scripts: add file system formatting script
- Makefile: set default manifest file for all targets
- mphalport: add dummy function for mp_hal_time_ns()
- boards: enable MICROPY_VFS_LFS2 for all target boards
- modules/uos: add ilistdir to uos module
- modules/nrf: add function to enable/disable DCDC
- enable source line on tracebacks
- set .mpy features consistent with documentation and other ports
pic16bit port: no changes specific to this component/port
powerpc port: no changes specific to this component/port
qemu-arm port: no changes specific to this component/port
rp2 port:
- use 0=Monday datetime convention in RTC
- machine_rtc: in RTC.datetime, compute weekday automatically
- CMakeLists.txt: suppress compiler errors for pico-sdk and tinyusb
- tusb_config.h: set CFG_TUD_CDC_EP_BUFSIZE to 256
- machine_uart: add hardware flow control support
- machine_uart: allow overriding default machine UART pins
- machine_i2c: allow boards to configure I2C pins using new macros
- machine_spi: allow boards to configure SPI pins using new macros
- machine_uart: fix poll ioctl to also check hardware FIFO
- machine_uart: fix read when FIFO has chars but ringbuf doesn't
- tusb_port: allow boards to configure USB VID and PID
- boards/ADAFRUIT_FEATHER_RP2040: configure custom VID/PID
- boards/ADAFRUIT_FEATHER_RP2040: configure I2C/SPI default pins
- boards/SPARKFUN_PROMICRO: configure UART/I2C/SPI default pins
- boards/SPARKFUN_THINGPLUS: configure I2C/SPI default pins
- boards: add Adafruit ItsyBitsy RP2040
- boards: add Adafruit QT Py RP2040
- boards: add Pimoroni Pico LiPo 4MB
- boards: add Pimoroni Pico LiPo 16MB
- boards: add Pimoroni Tiny 2040
- CMakeLists.txt: allow a board's cmake to set the manifest path
- enable MICROPY_PY_FSTRINGS by default
- Makefile: add "submodules" target, to match other ports
- rp2_flash: disable IRQs while calling flash_erase/program
- CMakeLists.txt: add option to enable double tap reset to bootrom
- mpconfigport.h: allow boards to add root pointers
samd port:
- add support for building with user C modules
stm32 port:
- softtimer: add soft_timer_reinsert() helper function
- mpbthciport: change from systick to soft-timer for BT scheduling
- provide a custom BTstack runloop that integrates with soft timer
- usb: make irq's default trigger enable all events
- boardctrl: skip running main.py if boot.py had an error
- sdio: fix undefined reference to DMA stream on H7
- dma: add DMAMUX configuration for H7 to fix dma_nohal_init
- main: call mp_deinit() at end of main
- adc: allow using ADC12 and ADC3 for H7
- adc: define the ADC instance used for internal channels
- adc: simplify and generalise how pin_adcX table is defined
- add new machine.I2S class for I2S protocol support
- boards/NUCLEO_F446RE: fix I2C1 pin assignment to match datasheet
- replace master/slave with controller/peripheral in I2C and SPI
- systick: always POLL_HOOK when delaying for milliseconds
- sdram: make SDRAM test cache aware, and optional failure with msg
- boards/NUCLEO_F446RE: enable CAN bus support
- boards: add support for SparkFun STM32 MicroMod Processor board
- uart: fix LPUART1 baudrate set/get
- uart: support low baudrates on LPUART1
- boards/STM32F429DISC: set correct UART2 pins and add UART3/6
- boards/NUCLEO_F439ZI: add board definition for NUCLEO_F439ZI
- boards/LEGO_HUB_NO6: add board definition for LEGO_HUB_NO6
- Makefile: update to only pull in used Bluetooth library
- README.md: update supported MCUs, and submodule and mboot use
- usbd_desc: rename USBD_xxx descriptor opts to MICROPY_HW_USB_xxx
- usbd_cdc_interface: rename USBD_CDC_xx opts to MICROPY_HW_USB_xx
- powerctrl: support changing frequency on WB MCUs
- boards/NUCLEO_H743ZI2: add modified version of NUCLEO_H743ZI
- mbedtls: fix compile warning about uninitialized val
- enable MICROPY_PY_FSTRINGS by default
- add implementation of machine.bitstream
- Makefile: allow GIT_SUBMODULES and LIBS to be extended
- stm32_it: support TIM17 IRQs on WB MCUs
- disable computed goto on constrained boards
- storage: make extended-block-device more configurable
- boards/LEGO_HUB_NO6: change SPI flash storage to use hardware SPI
- boards/LEGO_HUB_NO6: skip first 1MiB of SPI flash for storage
- boards/LEGO_HUB_NO6: add make commands to backup/restore firmware
teensy port: no changes specific to this component/port
unix port:
- modffi: add option to lock GC in callback, and cfun access
- Makefile: add back LIB_SRC_C to list of object files
- variants: enable help and help("modules") on standard and dev
- Makefile: disable error compression on arm-linux-gnueabi-gcc
windows port:
- Makefile: add .exe extension to executables name
- appveyor: update to VS 2017 and use Python 3.8 for build/test
zephyr port:
- machine_spi: add support for hardware SPI
This commit is contained in:
Amir Gonnen
commit
3df3a82703
3
.gitmodules
vendored
3
.gitmodules
vendored
@ -1,7 +1,6 @@
|
||||
[submodule "lib/axtls"]
|
||||
path = lib/axtls
|
||||
url = https://github.com/pfalcon/axtls
|
||||
branch = micropython
|
||||
url = https://github.com/micropython/axtls.git
|
||||
[submodule "lib/libffi"]
|
||||
path = lib/libffi
|
||||
url = https://github.com/atgreen/libffi
|
||||
|
||||
7
LICENSE
7
LICENSE
@ -38,10 +38,6 @@ used during the build process and is not part of the compiled source code.
|
||||
/cc3000 (BSD-3-clause)
|
||||
/cc3100 (BSD-3-clause)
|
||||
/wiznet5k (BSD-3-clause)
|
||||
/extmod
|
||||
/crypto-algorithms (NONE)
|
||||
/re15 (BSD-3-clause)
|
||||
/uzlib (Zlib)
|
||||
/lib
|
||||
/asf4 (Apache-2.0)
|
||||
/axtls (BSD-3-clause)
|
||||
@ -52,6 +48,7 @@ used during the build process and is not part of the compiled source code.
|
||||
/berkeley-db-1xx (BSD-4-clause)
|
||||
/btstack (See btstack/LICENSE)
|
||||
/cmsis (BSD-3-clause)
|
||||
/crypto-algorithms (NONE)
|
||||
/libhydrogen (ISC)
|
||||
/littlefs (BSD-3-clause)
|
||||
/lwip (BSD-3-clause)
|
||||
@ -60,9 +57,11 @@ used during the build process and is not part of the compiled source code.
|
||||
/nxp_driver (BSD-3-Clause)
|
||||
/oofatfs (BSD-1-clause)
|
||||
/pico-sdk (BSD-3-clause)
|
||||
/re15 (BSD-3-clause)
|
||||
/stm32lib (BSD-3-clause)
|
||||
/tinytest (BSD-3-clause)
|
||||
/tinyusb (MIT)
|
||||
/uzlib (Zlib)
|
||||
/logo (uses OFL-1.1)
|
||||
/ports
|
||||
/cc3200
|
||||
|
||||
@ -74,7 +74,7 @@ copyright = '- The MicroPython Documentation is Copyright © 2014-2021, Damien P
|
||||
#
|
||||
# We don't follow "The short X.Y version" vs "The full version, including alpha/beta/rc tags"
|
||||
# breakdown, so use the same version identifier for both to avoid confusion.
|
||||
version = release = '1.16'
|
||||
version = release = '1.17'
|
||||
|
||||
# The language for content autogenerated by Sphinx. Refer to documentation
|
||||
# for a list of supported languages.
|
||||
|
||||
@ -34,7 +34,7 @@ An example is the ``gc`` module discussed in :ref:`memorymanagement`.
|
||||
>>> gc.enable()
|
||||
>>>
|
||||
|
||||
MicroPython has several other builtin standard/core modules like ``io``, ``uarray`` etc.
|
||||
MicroPython has several other builtin standard/core modules like ``io``, ``array`` etc.
|
||||
Adding a new core module involves several modifications.
|
||||
|
||||
First, create the ``C`` file in the ``py/`` directory. In this example we are adding a
|
||||
|
||||
@ -42,8 +42,8 @@ The basic MicroPython firmware is implemented in the main port file, e.g ``main.
|
||||
#include "py/gc.h"
|
||||
#include "py/mperrno.h"
|
||||
#include "py/stackctrl.h"
|
||||
#include "lib/utils/gchelper.h"
|
||||
#include "lib/utils/pyexec.h"
|
||||
#include "shared/runtime/gchelper.h"
|
||||
#include "shared/runtime/pyexec.h"
|
||||
|
||||
// Allocate memory for the MicroPython GC heap.
|
||||
static char heap[4096];
|
||||
@ -106,10 +106,10 @@ We also need a Makefile at this point for the port:
|
||||
SRC_C = \
|
||||
main.c \
|
||||
mphalport.c \
|
||||
lib/mp-readline/readline.c \
|
||||
lib/utils/gchelper_generic.c \
|
||||
lib/utils/pyexec.c \
|
||||
lib/utils/stdout_helpers.c \
|
||||
shared/readline/readline.c \
|
||||
shared/runtime/gchelper_generic.c \
|
||||
shared/runtime/pyexec.c \
|
||||
shared/runtime/stdout_helpers.c \
|
||||
|
||||
# Define the required object files.
|
||||
OBJ = $(PY_CORE_O) $(addprefix $(BUILD)/, $(SRC_C:.c=.o))
|
||||
@ -245,8 +245,8 @@ That should give a MicroPython REPL. You can then run commands like:
|
||||
.. code-block:: bash
|
||||
|
||||
MicroPython v1.13 on 2021-01-01; example-board with unknown-cpu
|
||||
>>> import usys
|
||||
>>> usys.implementation
|
||||
>>> import sys
|
||||
>>> sys.implementation
|
||||
('micropython', (1, 13, 0))
|
||||
>>>
|
||||
|
||||
|
||||
@ -98,7 +98,7 @@ A useful function for connecting to your local WiFi network is::
|
||||
pass
|
||||
print('network config:', wlan.ifconfig())
|
||||
|
||||
Once the network is established the :mod:`socket <usocket>` module can be used
|
||||
Once the network is established the :mod:`socket <socket>` module can be used
|
||||
to create and use TCP/UDP sockets as usual, and the ``urequests`` module for
|
||||
convenient HTTP requests.
|
||||
|
||||
@ -113,7 +113,7 @@ to reconnect forever).
|
||||
Delay and timing
|
||||
----------------
|
||||
|
||||
Use the :mod:`time <utime>` module::
|
||||
Use the :mod:`time <time>` module::
|
||||
|
||||
import time
|
||||
|
||||
@ -361,7 +361,7 @@ accessed via the :ref:`machine.SoftI2C <machine.SoftI2C>` class::
|
||||
i2c.writeto(0x3a, '12') # write '12' to device with address 0x3a
|
||||
|
||||
buf = bytearray(10) # create a buffer with 10 bytes
|
||||
i2c.writeto(0x3a, buf) # write the given buffer to the slave
|
||||
i2c.writeto(0x3a, buf) # write the given buffer to the peripheral
|
||||
|
||||
Hardware I2C bus
|
||||
----------------
|
||||
@ -385,6 +385,24 @@ has the same methods as software I2C above::
|
||||
i2c = I2C(0)
|
||||
i2c = I2C(1, scl=Pin(5), sda=Pin(4), freq=400000)
|
||||
|
||||
I2S bus
|
||||
-------
|
||||
|
||||
See :ref:`machine.I2S <machine.I2S>`. ::
|
||||
|
||||
from machine import I2S, Pin
|
||||
|
||||
i2s = I2S(0, sck=Pin(13), ws=Pin(14), sd=Pin(34), mode=I2S.TX, bits=16, format=I2S.STEREO, rate=44100, ibuf=40000) # create I2S object
|
||||
i2s.write(buf) # write buffer of audio samples to I2S device
|
||||
|
||||
i2s = I2S(1, sck=Pin(33), ws=Pin(25), sd=Pin(32), mode=I2S.RX, bits=16, format=I2S.MONO, rate=22050, ibuf=40000) # create I2S object
|
||||
i2s.readinto(buf) # fill buffer with audio samples from I2S device
|
||||
|
||||
The I2S class is currently available as a Technical Preview. During the preview period, feedback from
|
||||
users is encouraged. Based on this feedback, the I2S class API and implementation may be changed.
|
||||
|
||||
ESP32 has two I2S buses with id=0 and id=1
|
||||
|
||||
Real time clock (RTC)
|
||||
---------------------
|
||||
|
||||
@ -441,15 +459,15 @@ SD card
|
||||
|
||||
See :ref:`machine.SDCard <machine.SDCard>`. ::
|
||||
|
||||
import machine, uos
|
||||
import machine, os
|
||||
|
||||
# Slot 2 uses pins sck=18, cs=5, miso=19, mosi=23
|
||||
sd = machine.SDCard(slot=2)
|
||||
uos.mount(sd, "/sd") # mount
|
||||
os.mount(sd, "/sd") # mount
|
||||
|
||||
uos.listdir('/sd') # list directory contents
|
||||
os.listdir('/sd') # list directory contents
|
||||
|
||||
uos.umount('/sd') # eject
|
||||
os.umount('/sd') # eject
|
||||
|
||||
RMT
|
||||
---
|
||||
|
||||
@ -117,7 +117,7 @@ Real-time clock
|
||||
|
||||
RTC in ESP8266 has very bad accuracy, drift may be seconds per minute. As
|
||||
a workaround, to measure short enough intervals you can use
|
||||
``utime.time()``, etc. functions, and for wall clock time, synchronize from
|
||||
``time.time()``, etc. functions, and for wall clock time, synchronize from
|
||||
the net using included ``ntptime.py`` module.
|
||||
|
||||
Due to limitations of the ESP8266 chip the internal real-time clock (RTC)
|
||||
@ -203,7 +203,7 @@ limitation with usage of TLS on the low-memory devices:
|
||||
communication with other devices.
|
||||
|
||||
There are also some not implemented features specifically in MicroPython's
|
||||
``ussl`` module based on axTLS:
|
||||
``ssl`` module based on axTLS:
|
||||
|
||||
6. Certificates are not validated (this makes connections susceptible
|
||||
to man-in-the-middle attacks).
|
||||
|
||||
@ -78,13 +78,13 @@ A useful function for connecting to your local WiFi network is::
|
||||
pass
|
||||
print('network config:', wlan.ifconfig())
|
||||
|
||||
Once the network is established the :mod:`socket <usocket>` module can be used
|
||||
Once the network is established the :mod:`socket <socket>` module can be used
|
||||
to create and use TCP/UDP sockets as usual.
|
||||
|
||||
Delay and timing
|
||||
----------------
|
||||
|
||||
Use the :mod:`time <utime>` module::
|
||||
Use the :mod:`time <time>` module::
|
||||
|
||||
import time
|
||||
|
||||
@ -171,15 +171,15 @@ attaches the REPL).
|
||||
|
||||
To detach the REPL from UART0, use::
|
||||
|
||||
import uos
|
||||
uos.dupterm(None, 1)
|
||||
import os
|
||||
os.dupterm(None, 1)
|
||||
|
||||
The REPL is attached by default. If you have detached it, to reattach
|
||||
it use::
|
||||
|
||||
import uos, machine
|
||||
import os, machine
|
||||
uart = machine.UART(0, 115200)
|
||||
uos.dupterm(uart, 1)
|
||||
os.dupterm(uart, 1)
|
||||
|
||||
PWM (pulse width modulation)
|
||||
----------------------------
|
||||
@ -270,11 +270,11 @@ alias of :ref:`machine.SoftI2C <machine.SoftI2C>`)::
|
||||
# construct an I2C bus
|
||||
i2c = I2C(scl=Pin(5), sda=Pin(4), freq=100000)
|
||||
|
||||
i2c.readfrom(0x3a, 4) # read 4 bytes from slave device with address 0x3a
|
||||
i2c.writeto(0x3a, '12') # write '12' to slave device with address 0x3a
|
||||
i2c.readfrom(0x3a, 4) # read 4 bytes from peripheral device with address 0x3a
|
||||
i2c.writeto(0x3a, '12') # write '12' to peripheral device with address 0x3a
|
||||
|
||||
buf = bytearray(10) # create a buffer with 10 bytes
|
||||
i2c.writeto(0x3a, buf) # write the given buffer to the slave
|
||||
i2c.writeto(0x3a, buf) # write the given buffer to the peripheral
|
||||
|
||||
Real time clock (RTC)
|
||||
---------------------
|
||||
|
||||
@ -109,10 +109,12 @@ PC. You may also need to reduce the baudrate if you get errors when flashing
|
||||
that you have.
|
||||
|
||||
For some boards with a particular FlashROM configuration (e.g. some variants of
|
||||
a NodeMCU board) you may need to use the following command to deploy
|
||||
the firmware (note the ``-fm dio`` option)::
|
||||
a NodeMCU board) you may need to manually set a compatible
|
||||
`SPI Flash Mode <https://github.com/espressif/esptool/wiki/SPI-Flash-Modes>`_.
|
||||
You'd usually pick the fastest option that is compatible with your device, but
|
||||
the ``-fm dout`` option (the slowest option) should have the best compatibility::
|
||||
|
||||
esptool.py --port /dev/ttyUSB0 --baud 460800 write_flash --flash_size=detect -fm dio 0 esp8266-20170108-v1.8.7.bin
|
||||
esptool.py --port /dev/ttyUSB0 --baud 460800 write_flash --flash_size=detect -fm dout 0 esp8266-20170108-v1.8.7.bin
|
||||
|
||||
If the above commands run without error then MicroPython should be installed on
|
||||
your board!
|
||||
|
||||
@ -18,9 +18,9 @@ the REPL directly from your PC. Otherwise you will need to have a way of
|
||||
communicating with the UART.
|
||||
|
||||
To access the prompt over USB-serial you need to use a terminal emulator program.
|
||||
On Windows TeraTerm is a good choice, on Mac you can use the built-in screen
|
||||
program, and Linux has picocom and minicom. Of course, there are many other
|
||||
terminal programs that will work, so pick your favourite!
|
||||
On Windows TeraTerm is a good choice, on Mac you can use the built-in ``screen``
|
||||
program, and Linux has ``picocom`` and ``minicom``. Of course, there are many
|
||||
other terminal programs that will work, so pick your favourite!
|
||||
|
||||
For example, on Linux you can try running::
|
||||
|
||||
@ -37,9 +37,9 @@ WebREPL allows you to use the Python prompt over WiFi, connecting through a
|
||||
browser. The latest versions of Firefox and Chrome are supported.
|
||||
|
||||
For your convenience, WebREPL client is hosted at
|
||||
`<http://micropython.org/webrepl>`__ . Alternatively, you can install it
|
||||
`<http://micropython.org/webrepl>`__. Alternatively, you can install it
|
||||
locally from the the GitHub repository
|
||||
`<https://github.com/micropython/webrepl>`__ .
|
||||
`<https://github.com/micropython/webrepl>`__.
|
||||
|
||||
Before connecting to WebREPL, you should set a password and enable it via
|
||||
a normal serial connection. Initial versions of MicroPython for ESP8266
|
||||
|
||||
@ -14,3 +14,4 @@ MicroPython documentation and references
|
||||
rp2/quickref.rst
|
||||
wipy/quickref.rst
|
||||
unix/quickref.rst
|
||||
zephyr/quickref.rst
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
:mod:`uarray` -- arrays of numeric data
|
||||
=======================================
|
||||
:mod:`array` -- arrays of numeric data
|
||||
======================================
|
||||
|
||||
.. module:: uarray
|
||||
.. module:: array
|
||||
:synopsis: efficient arrays of numeric data
|
||||
|
||||
|see_cpython_module| :mod:`python:array`.
|
||||
@ -1,7 +1,7 @@
|
||||
:mod:`ubinascii` -- binary/ASCII conversions
|
||||
============================================
|
||||
:mod:`binascii` -- binary/ASCII conversions
|
||||
===========================================
|
||||
|
||||
.. module:: ubinascii
|
||||
.. module:: binascii
|
||||
:synopsis: binary/ASCII conversions
|
||||
|
||||
|see_cpython_module| :mod:`python:binascii`.
|
||||
@ -1,7 +1,7 @@
|
||||
:mod:`ubluetooth` --- low-level Bluetooth
|
||||
=========================================
|
||||
:mod:`bluetooth` --- low-level Bluetooth
|
||||
========================================
|
||||
|
||||
.. module:: ubluetooth
|
||||
.. module:: bluetooth
|
||||
:synopsis: Low-level Bluetooth radio functionality
|
||||
|
||||
This module provides an interface to a Bluetooth controller on a board.
|
||||
@ -110,7 +110,7 @@ Event Handling
|
||||
|
||||
**Note:** As an optimisation to prevent unnecessary allocations, the ``addr``,
|
||||
``adv_data``, ``char_data``, ``notify_data``, and ``uuid`` entries in the
|
||||
tuples are read-only memoryview instances pointing to ubluetooth's internal
|
||||
tuples are read-only memoryview instances pointing to :mod:`bluetooth`'s internal
|
||||
ringbuffer, and are only valid during the invocation of the IRQ handler
|
||||
function. If your program needs to save one of these values to access after
|
||||
the IRQ handler has returned (e.g. by saving it in a class instance or global
|
||||
@ -293,7 +293,7 @@ For the ``_IRQ_PASSKEY_ACTION`` event, the available actions are::
|
||||
_PASSKEY_ACTION_NUMERIC_COMPARISON = const(4)
|
||||
|
||||
In order to save space in the firmware, these constants are not included on the
|
||||
:mod:`ubluetooth` module. Add the ones that you need from the list above to your
|
||||
:mod:`bluetooth` module. Add the ones that you need from the list above to your
|
||||
program.
|
||||
|
||||
|
||||
@ -485,10 +485,14 @@ writes from a client to a given characteristic, use
|
||||
Reads the local value for this handle (which has either been written by
|
||||
:meth:`gatts_write <BLE.gatts_write>` or by a remote client).
|
||||
|
||||
.. method:: BLE.gatts_write(value_handle, data, /)
|
||||
.. method:: BLE.gatts_write(value_handle, data, send_update=False, /)
|
||||
|
||||
Writes the local value for this handle, which can be read by a client.
|
||||
|
||||
If *send_update* is ``True``, then any subscribed clients will be notified
|
||||
(or indicated, depending on what they're subscribed to and which operations
|
||||
the characteristic supports) about this write.
|
||||
|
||||
.. method:: BLE.gatts_notify(conn_handle, value_handle, data=None, /)
|
||||
|
||||
Sends a notification request to a connected client.
|
||||
@ -499,17 +503,20 @@ writes from a client to a given characteristic, use
|
||||
Otherwise, if *data* is ``None``, then the current local value (as
|
||||
set with :meth:`gatts_write <BLE.gatts_write>`) will be sent.
|
||||
|
||||
**Note:** The notification will be sent regardless of the subscription
|
||||
status of the client to this characteristic.
|
||||
|
||||
.. method:: BLE.gatts_indicate(conn_handle, value_handle, /)
|
||||
|
||||
Sends an indication request to a connected client.
|
||||
|
||||
**Note:** This does not currently support sending a custom value, it will
|
||||
always send the current local value (as set with :meth:`gatts_write
|
||||
<BLE.gatts_write>`).
|
||||
Sends an indication request containing the characteristic's current value to
|
||||
a connected client.
|
||||
|
||||
On acknowledgment (or failure, e.g. timeout), the
|
||||
``_IRQ_GATTS_INDICATE_DONE`` event will be raised.
|
||||
|
||||
**Note:** The indication will be sent regardless of the subscription
|
||||
status of the client to this characteristic.
|
||||
|
||||
.. method:: BLE.gatts_set_buffer(value_handle, len, append=False, /)
|
||||
|
||||
Sets the internal buffer size for a value in bytes. This will limit the
|
||||
@ -22,7 +22,7 @@ Example::
|
||||
|
||||
# First, we need to open a stream which holds a database
|
||||
# This is usually a file, but can be in-memory database
|
||||
# using uio.BytesIO, a raw flash partition, etc.
|
||||
# using io.BytesIO, a raw flash partition, etc.
|
||||
# Oftentimes, you want to create a database file if it doesn't
|
||||
# exist and open if it exists. Idiom below takes care of this.
|
||||
# DO NOT open database with "a+b" access mode.
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
Builtin functions and exceptions
|
||||
================================
|
||||
:mod:`builtins` -- builtin functions and exceptions
|
||||
===================================================
|
||||
|
||||
All builtin functions and exceptions are described here. They are also
|
||||
available via ``builtins`` module.
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
:mod:`ucollections` -- collection and container types
|
||||
=====================================================
|
||||
:mod:`collections` -- collection and container types
|
||||
====================================================
|
||||
|
||||
.. module:: ucollections
|
||||
.. module:: collections
|
||||
:synopsis: collection and container types
|
||||
|
||||
|see_cpython_module| :mod:`python:collections`.
|
||||
@ -49,7 +49,7 @@ Classes
|
||||
a string with space-separated field named (but this is less efficient).
|
||||
Example of use::
|
||||
|
||||
from ucollections import namedtuple
|
||||
from collections import namedtuple
|
||||
|
||||
MyTuple = namedtuple("MyTuple", ("id", "name"))
|
||||
t1 = MyTuple(1, "foo")
|
||||
@ -63,7 +63,7 @@ Classes
|
||||
added. When ordered dict is iterated over, keys/items are returned in
|
||||
the order they were added::
|
||||
|
||||
from ucollections import OrderedDict
|
||||
from collections import OrderedDict
|
||||
|
||||
# To make benefit of ordered keys, OrderedDict should be initialized
|
||||
# from sequence of (key, value) pairs.
|
||||
@ -1,7 +1,7 @@
|
||||
:mod:`ucryptolib` -- cryptographic ciphers
|
||||
==========================================
|
||||
:mod:`cryptolib` -- cryptographic ciphers
|
||||
=========================================
|
||||
|
||||
.. module:: ucryptolib
|
||||
.. module:: cryptolib
|
||||
:synopsis: cryptographic ciphers
|
||||
|
||||
Classes
|
||||
@ -21,9 +21,9 @@ Classes
|
||||
* *key* is an encryption/decryption key (bytes-like).
|
||||
* *mode* is:
|
||||
|
||||
* ``1`` (or ``ucryptolib.MODE_ECB`` if it exists) for Electronic Code Book (ECB).
|
||||
* ``2`` (or ``ucryptolib.MODE_CBC`` if it exists) for Cipher Block Chaining (CBC).
|
||||
* ``6`` (or ``ucryptolib.MODE_CTR`` if it exists) for Counter mode (CTR).
|
||||
* ``1`` (or ``cryptolib.MODE_ECB`` if it exists) for Electronic Code Book (ECB).
|
||||
* ``2`` (or ``cryptolib.MODE_CBC`` if it exists) for Cipher Block Chaining (CBC).
|
||||
* ``6`` (or ``cryptolib.MODE_CTR`` if it exists) for Counter mode (CTR).
|
||||
|
||||
* *IV* is an initialization vector for CBC mode.
|
||||
* For Counter mode, *IV* is the initial value for the counter.
|
||||
@ -1,7 +1,7 @@
|
||||
:mod:`uerrno` -- system error codes
|
||||
===================================
|
||||
:mod:`errno` -- system error codes
|
||||
==================================
|
||||
|
||||
.. module:: uerrno
|
||||
.. module:: errno
|
||||
:synopsis: system error codes
|
||||
|
||||
|see_cpython_module| :mod:`python:errno`.
|
||||
@ -20,9 +20,9 @@ Constants
|
||||
where ``exc`` is an instance of `OSError`. Usage example::
|
||||
|
||||
try:
|
||||
uos.mkdir("my_dir")
|
||||
os.mkdir("my_dir")
|
||||
except OSError as exc:
|
||||
if exc.errno == uerrno.EEXIST:
|
||||
if exc.errno == errno.EEXIST:
|
||||
print("Directory already exists")
|
||||
|
||||
.. data:: errorcode
|
||||
@ -30,5 +30,5 @@ Constants
|
||||
Dictionary mapping numeric error codes to strings with symbolic error
|
||||
code (see above)::
|
||||
|
||||
>>> print(uerrno.errorcode[uerrno.EEXIST])
|
||||
>>> print(errno.errorcode[errno.EEXIST])
|
||||
EEXIST
|
||||
@ -91,7 +91,7 @@ methods to enable over-the-air (OTA) updates.
|
||||
|
||||
These methods implement the simple and :ref:`extended
|
||||
<block-device-interface>` block protocol defined by
|
||||
:class:`uos.AbstractBlockDev`.
|
||||
:class:`os.AbstractBlockDev`.
|
||||
|
||||
.. method:: Partition.set_boot()
|
||||
|
||||
|
||||
@ -103,16 +103,23 @@ Other methods
|
||||
Shift the contents of the FrameBuffer by the given vector. This may
|
||||
leave a footprint of the previous colors in the FrameBuffer.
|
||||
|
||||
.. method:: FrameBuffer.blit(fbuf, x, y[, key])
|
||||
.. method:: FrameBuffer.blit(fbuf, x, y, key=-1, palette=None)
|
||||
|
||||
Draw another FrameBuffer on top of the current one at the given coordinates.
|
||||
If *key* is specified then it should be a color integer and the
|
||||
corresponding color will be considered transparent: all pixels with that
|
||||
color value will not be drawn.
|
||||
|
||||
This method works between FrameBuffer instances utilising different formats,
|
||||
but the resulting colors may be unexpected due to the mismatch in color
|
||||
formats.
|
||||
The *palette* argument enables blitting between FrameBuffers with differing
|
||||
formats. Typical usage is to render a monochrome or grayscale glyph/icon to
|
||||
a color display. The *palette* is a FrameBuffer instance whose format is
|
||||
that of the current FrameBuffer. The *palette* height is one pixel and its
|
||||
pixel width is the number of colors in the source FrameBuffer. The *palette*
|
||||
for an N-bit source needs 2**N pixels; the *palette* for a monochrome source
|
||||
would have 2 pixels representing background and foreground colors. The
|
||||
application assigns a color to each pixel in the *palette*. The color of the
|
||||
current pixel will be that of that *palette* pixel whose x position is the
|
||||
color of the corresponding source pixel.
|
||||
|
||||
Constants
|
||||
---------
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
:mod:`uhashlib` -- hashing algorithms
|
||||
=====================================
|
||||
:mod:`hashlib` -- hashing algorithms
|
||||
====================================
|
||||
|
||||
.. module:: uhashlib
|
||||
.. module:: hashlib
|
||||
:synopsis: hashing algorithms
|
||||
|
||||
|see_cpython_module| :mod:`python:hashlib`.
|
||||
@ -27,15 +27,15 @@ be implemented:
|
||||
Constructors
|
||||
------------
|
||||
|
||||
.. class:: uhashlib.sha256([data])
|
||||
.. class:: hashlib.sha256([data])
|
||||
|
||||
Create an SHA256 hasher object and optionally feed ``data`` into it.
|
||||
|
||||
.. class:: uhashlib.sha1([data])
|
||||
.. class:: hashlib.sha1([data])
|
||||
|
||||
Create an SHA1 hasher object and optionally feed ``data`` into it.
|
||||
|
||||
.. class:: uhashlib.md5([data])
|
||||
.. class:: hashlib.md5([data])
|
||||
|
||||
Create an MD5 hasher object and optionally feed ``data`` into it.
|
||||
|
||||
@ -53,5 +53,5 @@ Methods
|
||||
|
||||
.. method:: hash.hexdigest()
|
||||
|
||||
This method is NOT implemented. Use ``ubinascii.hexlify(hash.digest())``
|
||||
This method is NOT implemented. Use ``binascii.hexlify(hash.digest())``
|
||||
to achieve a similar effect.
|
||||
@ -1,7 +1,7 @@
|
||||
:mod:`uheapq` -- heap queue algorithm
|
||||
=====================================
|
||||
:mod:`heapq` -- heap queue algorithm
|
||||
====================================
|
||||
|
||||
.. module:: uheapq
|
||||
.. module:: heapq
|
||||
:synopsis: heap queue algorithm
|
||||
|
||||
|see_cpython_module| :mod:`python:heapq`.
|
||||
@ -7,47 +7,39 @@ MicroPython libraries
|
||||
|
||||
Important summary of this section
|
||||
|
||||
* MicroPython implements a subset of Python functionality for each module.
|
||||
* To ease extensibility, MicroPython versions of standard Python modules
|
||||
usually have ``u`` ("micro") prefix.
|
||||
* Any particular MicroPython variant or port may miss any feature/function
|
||||
described in this general documentation (due to resource constraints or
|
||||
other limitations).
|
||||
|
||||
* MicroPython provides built-in modules that mirror the functionality of the
|
||||
Python standard library (e.g. :mod:`os`, :mod:`time`), as well as
|
||||
MicroPython-specific modules (e.g. :mod:`bluetooth`, :mod:`machine`).
|
||||
* Most standard library modules implement a subset of the functionality of
|
||||
the equivalent Python module, and in a few cases provide some
|
||||
MicroPython-specific extensions (e.g. :mod:`array`, :mod:`os`)
|
||||
* Due to resource constraints or other limitations, some ports or firmware
|
||||
versions may not include all the functionality documented here.
|
||||
* To allow for extensibility, the built-in modules can be extended from
|
||||
Python code loaded onto the device.
|
||||
|
||||
This chapter describes modules (function and class libraries) which are built
|
||||
into MicroPython. There are a few categories of such modules:
|
||||
into MicroPython. This documentation in general aspires to describe all modules
|
||||
and functions/classes which are implemented in the MicroPython project.
|
||||
However, MicroPython is highly configurable, and each port to a particular
|
||||
board/embedded system may include only a subset of the available MicroPython
|
||||
libraries.
|
||||
|
||||
* Modules which implement a subset of standard Python functionality and are not
|
||||
intended to be extended by the user.
|
||||
* Modules which implement a subset of Python functionality, with a provision
|
||||
for extension by the user (via Python code).
|
||||
* Modules which implement MicroPython extensions to the Python standard libraries.
|
||||
* Modules specific to a particular :term:`MicroPython port` and thus not portable.
|
||||
|
||||
Note about the availability of the modules and their contents: This documentation
|
||||
in general aspires to describe all modules and functions/classes which are
|
||||
implemented in MicroPython project. However, MicroPython is highly configurable, and
|
||||
each port to a particular board/embedded system makes available only a subset
|
||||
of MicroPython libraries. For officially supported ports, there is an effort
|
||||
to either filter out non-applicable items, or mark individual descriptions
|
||||
with "Availability:" clauses describing which ports provide a given feature.
|
||||
|
||||
With that in mind, please still be warned that some functions/classes
|
||||
in a module (or even the entire module) described in this documentation **may be
|
||||
unavailable** in a particular build of MicroPython on a particular system. The
|
||||
best place to find general information of the availability/non-availability
|
||||
of a particular feature is the "General Information" section which contains
|
||||
information pertaining to a specific :term:`MicroPython port`.
|
||||
With that in mind, please be warned that some functions/classes in a module (or
|
||||
even the entire module) described in this documentation **may be unavailable**
|
||||
in a particular build of MicroPython on a particular system. The best place to
|
||||
find general information of the availability/non-availability of a particular
|
||||
feature is the "General Information" section which contains information
|
||||
pertaining to a specific :term:`MicroPython port`.
|
||||
|
||||
On some ports you are able to discover the available, built-in libraries that
|
||||
can be imported by entering the following at the REPL::
|
||||
can be imported by entering the following at the :term:`REPL`::
|
||||
|
||||
help('modules')
|
||||
|
||||
Beyond the built-in libraries described in this documentation, many more
|
||||
modules from the Python standard library, as well as further MicroPython
|
||||
extensions to it, can be found in `micropython-lib`.
|
||||
extensions to it, can be found in :term:`micropython-lib`.
|
||||
|
||||
Python standard libraries and micro-libraries
|
||||
---------------------------------------------
|
||||
@ -55,46 +47,33 @@ Python standard libraries and micro-libraries
|
||||
The following standard Python libraries have been "micro-ified" to fit in with
|
||||
the philosophy of MicroPython. They provide the core functionality of that
|
||||
module and are intended to be a drop-in replacement for the standard Python
|
||||
library. Some modules below use a standard Python name, but prefixed with "u",
|
||||
e.g. ``ujson`` instead of ``json``. This is to signify that such a module is
|
||||
micro-library, i.e. implements only a subset of CPython module functionality.
|
||||
By naming them differently, a user has a choice to write a Python-level module
|
||||
to extend functionality for better compatibility with CPython (indeed, this is
|
||||
what done by the `micropython-lib` project mentioned above).
|
||||
|
||||
On some embedded platforms, where it may be cumbersome to add Python-level
|
||||
wrapper modules to achieve naming compatibility with CPython, micro-modules
|
||||
are available both by their u-name, and also by their non-u-name. The
|
||||
non-u-name can be overridden by a file of that name in your library path (``sys.path``).
|
||||
For example, ``import json`` will first search for a file ``json.py`` (or package
|
||||
directory ``json``) and load that module if it is found. If nothing is found,
|
||||
it will fallback to loading the built-in ``ujson`` module.
|
||||
library.
|
||||
|
||||
.. toctree::
|
||||
:maxdepth: 1
|
||||
|
||||
array.rst
|
||||
binascii.rst
|
||||
builtins.rst
|
||||
cmath.rst
|
||||
collections.rst
|
||||
errno.rst
|
||||
gc.rst
|
||||
hashlib.rst
|
||||
heapq.rst
|
||||
io.rst
|
||||
json.rst
|
||||
math.rst
|
||||
uarray.rst
|
||||
os.rst
|
||||
re.rst
|
||||
select.rst
|
||||
socket.rst
|
||||
ssl.rst
|
||||
struct.rst
|
||||
sys.rst
|
||||
time.rst
|
||||
uasyncio.rst
|
||||
ubinascii.rst
|
||||
ucollections.rst
|
||||
uerrno.rst
|
||||
uhashlib.rst
|
||||
uheapq.rst
|
||||
uio.rst
|
||||
ujson.rst
|
||||
uos.rst
|
||||
ure.rst
|
||||
uselect.rst
|
||||
usocket.rst
|
||||
ussl.rst
|
||||
ustruct.rst
|
||||
usys.rst
|
||||
utime.rst
|
||||
uzlib.rst
|
||||
zlib.rst
|
||||
_thread.rst
|
||||
|
||||
|
||||
@ -107,13 +86,14 @@ the following libraries.
|
||||
.. toctree::
|
||||
:maxdepth: 1
|
||||
|
||||
bluetooth.rst
|
||||
btree.rst
|
||||
cryptolib.rst
|
||||
framebuf.rst
|
||||
machine.rst
|
||||
micropython.rst
|
||||
neopixel.rst
|
||||
network.rst
|
||||
ubluetooth.rst
|
||||
ucryptolib.rst
|
||||
uctypes.rst
|
||||
|
||||
|
||||
@ -131,7 +111,7 @@ To access platform-specific hardware use the appropriate library, e.g.
|
||||
|
||||
|
||||
Libraries specific to the pyboard
|
||||
---------------------------------
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
The following libraries are specific to the pyboard.
|
||||
|
||||
@ -143,7 +123,7 @@ The following libraries are specific to the pyboard.
|
||||
|
||||
|
||||
Libraries specific to the WiPy
|
||||
------------------------------
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
The following libraries and classes are specific to the WiPy.
|
||||
|
||||
@ -156,7 +136,7 @@ The following libraries and classes are specific to the WiPy.
|
||||
|
||||
|
||||
Libraries specific to the ESP8266 and ESP32
|
||||
-------------------------------------------
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
The following libraries are specific to the ESP8266 and ESP32.
|
||||
|
||||
@ -168,7 +148,7 @@ The following libraries are specific to the ESP8266 and ESP32.
|
||||
|
||||
|
||||
Libraries specific to the RP2040
|
||||
--------------------------------
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
The following libraries are specific to the RP2040, as used in the Raspberry Pi Pico.
|
||||
|
||||
@ -176,3 +156,34 @@ The following libraries are specific to the RP2040, as used in the Raspberry Pi
|
||||
:maxdepth: 2
|
||||
|
||||
rp2.rst
|
||||
|
||||
Libraries specific to Zephyr
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
The following libraries are specific to the Zephyr port.
|
||||
|
||||
.. toctree::
|
||||
:maxdepth: 2
|
||||
|
||||
zephyr.rst
|
||||
|
||||
Extending built-in libraries from Python
|
||||
----------------------------------------
|
||||
|
||||
In most cases, the above modules are actually named ``umodule`` rather than
|
||||
``module``, but MicroPython will alias any module prefixed with a ``u`` to the
|
||||
non-``u`` version. However a file (or :term:`frozen module`) named
|
||||
``module.py`` will take precedence over this alias.
|
||||
|
||||
This allows the user to provide an extended implementation of a built-in library
|
||||
(perhaps to provide additional CPython compatibility). The user-provided module
|
||||
(in ``module.py``) can still use the built-in functionality by importing
|
||||
``umodule`` directly. This is used extensively in :term:`micropython-lib`. See
|
||||
:ref:`packages` for more information.
|
||||
|
||||
This applies to both the Python standard libraries (e.g. ``os``, ``time``, etc),
|
||||
but also the MicroPython libraries too (e.g. ``machine``, ``bluetooth``, etc).
|
||||
The main exception is the port-specific libraries (``pyb``, ``esp``, etc).
|
||||
|
||||
*Other than when you specifically want to force the use of the built-in module,
|
||||
we recommend always using ``import module`` rather than ``import umodule``.*
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
:mod:`uio` -- input/output streams
|
||||
==================================
|
||||
:mod:`io` -- input/output streams
|
||||
=================================
|
||||
|
||||
.. module:: uio
|
||||
.. module:: io
|
||||
:synopsis: input/output streams
|
||||
|
||||
|see_cpython_module| :mod:`python:io`.
|
||||
@ -1,7 +1,7 @@
|
||||
:mod:`ujson` -- JSON encoding and decoding
|
||||
==========================================
|
||||
:mod:`json` -- JSON encoding and decoding
|
||||
=========================================
|
||||
|
||||
.. module:: ujson
|
||||
.. module:: json
|
||||
:synopsis: JSON encoding and decoding
|
||||
|
||||
|see_cpython_module| :mod:`python:json`.
|
||||
@ -12,14 +12,20 @@ data format.
|
||||
Functions
|
||||
---------
|
||||
|
||||
.. function:: dump(obj, stream)
|
||||
.. function:: dump(obj, stream, separators=None)
|
||||
|
||||
Serialise *obj* to a JSON string, writing it to the given *stream*.
|
||||
|
||||
.. function:: dumps(obj)
|
||||
If specified, separators should be an ``(item_separator, key_separator)``
|
||||
tuple. The default is ``(', ', ': ')``. To get the most compact JSON
|
||||
representation, you should specify ``(',', ':')`` to eliminate whitespace.
|
||||
|
||||
.. function:: dumps(obj, separators=None)
|
||||
|
||||
Return *obj* represented as a JSON string.
|
||||
|
||||
The arguments have the same meaning as in `dump`.
|
||||
|
||||
.. function:: load(stream)
|
||||
|
||||
Parse the given *stream*, interpreting it as a JSON string and
|
||||
@ -28,15 +28,15 @@ Example usage::
|
||||
# depending on the port, extra parameters may be required
|
||||
# to select the peripheral and/or pins to use
|
||||
|
||||
i2c.scan() # scan for slaves, returning a list of 7-bit addresses
|
||||
i2c.scan() # scan for peripherals, returning a list of 7-bit addresses
|
||||
|
||||
i2c.writeto(42, b'123') # write 3 bytes to slave with 7-bit address 42
|
||||
i2c.readfrom(42, 4) # read 4 bytes from slave with 7-bit address 42
|
||||
i2c.writeto(42, b'123') # write 3 bytes to peripheral with 7-bit address 42
|
||||
i2c.readfrom(42, 4) # read 4 bytes from peripheral with 7-bit address 42
|
||||
|
||||
i2c.readfrom_mem(42, 8, 3) # read 3 bytes from memory of slave 42,
|
||||
# starting at memory-address 8 in the slave
|
||||
i2c.writeto_mem(42, 2, b'\x10') # write 1 byte to memory of slave 42
|
||||
# starting at address 2 in the slave
|
||||
i2c.readfrom_mem(42, 8, 3) # read 3 bytes from memory of peripheral 42,
|
||||
# starting at memory-address 8 in the peripheral
|
||||
i2c.writeto_mem(42, 2, b'\x10') # write 1 byte to memory of peripheral 42
|
||||
# starting at address 2 in the peripheral
|
||||
|
||||
Constructors
|
||||
------------
|
||||
@ -95,7 +95,7 @@ General Methods
|
||||
Primitive I2C operations
|
||||
------------------------
|
||||
|
||||
The following methods implement the primitive I2C master bus operations and can
|
||||
The following methods implement the primitive I2C controller bus operations and can
|
||||
be combined to make any I2C transaction. They are provided if you need more
|
||||
control over the bus, otherwise the standard methods (see below) can be used.
|
||||
|
||||
@ -115,7 +115,7 @@ These methods are only available on the `machine.SoftI2C` class.
|
||||
read is the length of *buf*. An ACK will be sent on the bus after
|
||||
receiving all but the last byte. After the last byte is received, if *nack*
|
||||
is true then a NACK will be sent, otherwise an ACK will be sent (and in this
|
||||
case the slave assumes more bytes are going to be read in a later call).
|
||||
case the peripheral assumes more bytes are going to be read in a later call).
|
||||
|
||||
.. method:: I2C.write(buf)
|
||||
|
||||
@ -126,18 +126,18 @@ These methods are only available on the `machine.SoftI2C` class.
|
||||
Standard bus operations
|
||||
-----------------------
|
||||
|
||||
The following methods implement the standard I2C master read and write
|
||||
operations that target a given slave device.
|
||||
The following methods implement the standard I2C controller read and write
|
||||
operations that target a given peripheral device.
|
||||
|
||||
.. method:: I2C.readfrom(addr, nbytes, stop=True, /)
|
||||
|
||||
Read *nbytes* from the slave specified by *addr*.
|
||||
Read *nbytes* from the peripheral specified by *addr*.
|
||||
If *stop* is true then a STOP condition is generated at the end of the transfer.
|
||||
Returns a `bytes` object with the data read.
|
||||
|
||||
.. method:: I2C.readfrom_into(addr, buf, stop=True, /)
|
||||
|
||||
Read into *buf* from the slave specified by *addr*.
|
||||
Read into *buf* from the peripheral specified by *addr*.
|
||||
The number of bytes read will be the length of *buf*.
|
||||
If *stop* is true then a STOP condition is generated at the end of the transfer.
|
||||
|
||||
@ -145,7 +145,7 @@ operations that target a given slave device.
|
||||
|
||||
.. method:: I2C.writeto(addr, buf, stop=True, /)
|
||||
|
||||
Write the bytes from *buf* to the slave specified by *addr*. If a
|
||||
Write the bytes from *buf* to the peripheral specified by *addr*. If a
|
||||
NACK is received following the write of a byte from *buf* then the
|
||||
remaining bytes are not sent. If *stop* is true then a STOP condition is
|
||||
generated at the end of the transfer, even if a NACK is received.
|
||||
@ -153,7 +153,7 @@ operations that target a given slave device.
|
||||
|
||||
.. method:: I2C.writevto(addr, vector, stop=True, /)
|
||||
|
||||
Write the bytes contained in *vector* to the slave specified by *addr*.
|
||||
Write the bytes contained in *vector* to the peripheral specified by *addr*.
|
||||
*vector* should be a tuple or list of objects with the buffer protocol.
|
||||
The *addr* is sent once and then the bytes from each object in *vector*
|
||||
are written out sequentially. The objects in *vector* may be zero bytes
|
||||
@ -170,19 +170,19 @@ Memory operations
|
||||
|
||||
Some I2C devices act as a memory device (or set of registers) that can be read
|
||||
from and written to. In this case there are two addresses associated with an
|
||||
I2C transaction: the slave address and the memory address. The following
|
||||
I2C transaction: the peripheral address and the memory address. The following
|
||||
methods are convenience functions to communicate with such devices.
|
||||
|
||||
.. method:: I2C.readfrom_mem(addr, memaddr, nbytes, *, addrsize=8)
|
||||
|
||||
Read *nbytes* from the slave specified by *addr* starting from the memory
|
||||
Read *nbytes* from the peripheral specified by *addr* starting from the memory
|
||||
address specified by *memaddr*.
|
||||
The argument *addrsize* specifies the address size in bits.
|
||||
Returns a `bytes` object with the data read.
|
||||
|
||||
.. method:: I2C.readfrom_mem_into(addr, memaddr, buf, *, addrsize=8)
|
||||
|
||||
Read into *buf* from the slave specified by *addr* starting from the
|
||||
Read into *buf* from the peripheral specified by *addr* starting from the
|
||||
memory address specified by *memaddr*. The number of bytes read is the
|
||||
length of *buf*.
|
||||
The argument *addrsize* specifies the address size in bits (on ESP8266
|
||||
@ -192,7 +192,7 @@ methods are convenience functions to communicate with such devices.
|
||||
|
||||
.. method:: I2C.writeto_mem(addr, memaddr, buf, *, addrsize=8)
|
||||
|
||||
Write *buf* to the slave specified by *addr* starting from the
|
||||
Write *buf* to the peripheral specified by *addr* starting from the
|
||||
memory address specified by *memaddr*.
|
||||
The argument *addrsize* specifies the address size in bits (on ESP8266
|
||||
this argument is not recognised and the address size is always 8 bits).
|
||||
|
||||
162
docs/library/machine.I2S.rst
Normal file
162
docs/library/machine.I2S.rst
Normal file
@ -0,0 +1,162 @@
|
||||
.. currentmodule:: machine
|
||||
.. _machine.I2S:
|
||||
|
||||
class I2S -- Inter-IC Sound bus protocol
|
||||
========================================
|
||||
|
||||
I2S is a synchronous serial protocol used to connect digital audio devices.
|
||||
At the physical level, a bus consists of 3 lines: SCK, WS, SD.
|
||||
The I2S class supports controller operation. Peripheral operation is not supported.
|
||||
|
||||
The I2S class is currently available as a Technical Preview. During the preview period, feedback from
|
||||
users is encouraged. Based on this feedback, the I2S class API and implementation may be changed.
|
||||
|
||||
I2S objects can be created and initialized using::
|
||||
|
||||
from machine import I2S
|
||||
from machine import Pin
|
||||
|
||||
# ESP32
|
||||
sck_pin = Pin(14) # Serial clock output
|
||||
ws_pin = Pin(13) # Word clock output
|
||||
sd_pin = Pin(12) # Serial data output
|
||||
|
||||
or
|
||||
|
||||
# PyBoards
|
||||
sck_pin = Pin("Y6") # Serial clock output
|
||||
ws_pin = Pin("Y5") # Word clock output
|
||||
sd_pin = Pin("Y8") # Serial data output
|
||||
|
||||
audio_out = I2S(2,
|
||||
sck=sck_pin, ws=ws_pin, sd=sd_pin,
|
||||
mode=I2S.TX,
|
||||
bits=16,
|
||||
format=I2S.MONO,
|
||||
rate=44100,
|
||||
ibuf=20000)
|
||||
|
||||
audio_in = I2S(2,
|
||||
sck=sck_pin, ws=ws_pin, sd=sd_pin,
|
||||
mode=I2S.RX,
|
||||
bits=32,
|
||||
format=I2S.STEREO,
|
||||
rate=22050,
|
||||
ibuf=20000)
|
||||
|
||||
3 modes of operation are supported:
|
||||
- blocking
|
||||
- non-blocking
|
||||
- uasyncio
|
||||
|
||||
blocking::
|
||||
|
||||
num_written = audio_out.write(buf) # blocks until buf emptied
|
||||
|
||||
num_read = audio_in.readinto(buf) # blocks until buf filled
|
||||
|
||||
non-blocking::
|
||||
|
||||
audio_out.irq(i2s_callback) # i2s_callback is called when buf is emptied
|
||||
num_written = audio_out.write(buf) # returns immediately
|
||||
|
||||
audio_in.irq(i2s_callback) # i2s_callback is called when buf is filled
|
||||
num_read = audio_in.readinto(buf) # returns immediately
|
||||
|
||||
uasyncio::
|
||||
|
||||
swriter = uasyncio.StreamWriter(audio_out)
|
||||
swriter.write(buf)
|
||||
await swriter.drain()
|
||||
|
||||
sreader = uasyncio.StreamReader(audio_in)
|
||||
num_read = await sreader.readinto(buf)
|
||||
|
||||
Constructor
|
||||
-----------
|
||||
|
||||
.. class:: I2S(id, *, sck, ws, sd, mode, bits, format, rate, ibuf)
|
||||
|
||||
Construct an I2S object of the given id:
|
||||
|
||||
- ``id`` identifies a particular I2S bus.
|
||||
|
||||
``id`` is board and port specific:
|
||||
|
||||
- PYBv1.0/v1.1: has one I2S bus with id=2.
|
||||
- PYBD-SFxW: has two I2S buses with id=1 and id=2.
|
||||
- ESP32: has two I2S buses with id=0 and id=1.
|
||||
|
||||
Keyword-only parameters that are supported on all ports:
|
||||
|
||||
- ``sck`` is a pin object for the serial clock line
|
||||
- ``ws`` is a pin object for the word select line
|
||||
- ``sd`` is a pin object for the serial data line
|
||||
- ``mode`` specifies receive or transmit
|
||||
- ``bits`` specifies sample size (bits), 16 or 32
|
||||
- ``format`` specifies channel format, STEREO or MONO
|
||||
- ``rate`` specifies audio sampling rate (samples/s)
|
||||
- ``ibuf`` specifies internal buffer length (bytes)
|
||||
|
||||
For all ports, DMA runs continuously in the background and allows user applications to perform other operations while
|
||||
sample data is transfered between the internal buffer and the I2S peripheral unit.
|
||||
Increasing the size of the internal buffer has the potential to increase the time that user applications can perform non-I2S operations
|
||||
before underflow (e.g. ``write`` method) or overflow (e.g. ``readinto`` method).
|
||||
|
||||
Methods
|
||||
-------
|
||||
|
||||
.. method:: I2S.init(sck, ...)
|
||||
|
||||
see Constructor for argument descriptions
|
||||
|
||||
.. method:: I2S.deinit()
|
||||
|
||||
Deinitialize the I2S bus
|
||||
|
||||
.. method:: I2S.readinto(buf)
|
||||
|
||||
Read audio samples into the buffer specified by ``buf``. ``buf`` must support the buffer protocol, such as bytearray or array.
|
||||
"buf" byte ordering is little-endian. For Stereo format, left channel sample precedes right channel sample. For Mono format,
|
||||
the left channel sample data is used.
|
||||
Returns number of bytes read
|
||||
|
||||
.. method:: I2S.write(buf)
|
||||
|
||||
Write audio samples contained in ``buf``. ``buf`` must support the buffer protocol, such as bytearray or array.
|
||||
"buf" byte ordering is little-endian. For Stereo format, left channel sample precedes right channel sample. For Mono format,
|
||||
the sample data is written to both the right and left channels.
|
||||
Returns number of bytes written
|
||||
|
||||
.. method:: I2S.irq(handler)
|
||||
|
||||
Set a callback. ``handler`` is called when ``buf`` is emptied (``write`` method) or becomes full (``readinto`` method).
|
||||
Setting a callback changes the ``write`` and ``readinto`` methods to non-blocking operation.
|
||||
``handler`` is called in the context of the MicroPython scheduler.
|
||||
|
||||
.. staticmethod:: I2S.shift(buf, bits, shift)
|
||||
|
||||
bitwise shift of all samples contained in ``buf``. ``bits`` specifies sample size in bits. ``shift`` specifies the number of bits to shift each sample.
|
||||
Positive for left shift, negative for right shift.
|
||||
Typically used for volume control. Each bit shift changes sample volume by 6dB.
|
||||
|
||||
Constants
|
||||
---------
|
||||
|
||||
.. data:: I2S.RX
|
||||
|
||||
for initialising the I2S bus ``mode`` to receive
|
||||
|
||||
.. data:: I2S.TX
|
||||
|
||||
for initialising the I2S bus ``mode`` to transmit
|
||||
|
||||
.. data:: I2S.STEREO
|
||||
|
||||
for initialising the I2S bus ``format`` to stereo
|
||||
|
||||
.. data:: I2S.MONO
|
||||
|
||||
for initialising the I2S bus ``format`` to mono
|
||||
|
||||
|
||||
@ -27,10 +27,10 @@ vary from platform to platform.
|
||||
|
||||
This class provides access to SD or MMC storage cards using either
|
||||
a dedicated SD/MMC interface hardware or through an SPI channel.
|
||||
The class implements the block protocol defined by :class:`uos.AbstractBlockDev`.
|
||||
The class implements the block protocol defined by :class:`os.AbstractBlockDev`.
|
||||
This allows the mounting of an SD card to be as simple as::
|
||||
|
||||
uos.mount(machine.SDCard(), "/sd")
|
||||
os.mount(machine.SDCard(), "/sd")
|
||||
|
||||
The constructor takes the following parameters:
|
||||
|
||||
|
||||
@ -1,14 +1,14 @@
|
||||
.. currentmodule:: machine
|
||||
.. _machine.SPI:
|
||||
|
||||
class SPI -- a Serial Peripheral Interface bus protocol (master side)
|
||||
=====================================================================
|
||||
class SPI -- a Serial Peripheral Interface bus protocol (controller side)
|
||||
=========================================================================
|
||||
|
||||
SPI is a synchronous serial protocol that is driven by a master. At the
|
||||
SPI is a synchronous serial protocol that is driven by a controller. At the
|
||||
physical level, a bus consists of 3 lines: SCK, MOSI, MISO. Multiple devices
|
||||
can share the same bus. Each device should have a separate, 4th signal,
|
||||
SS (Slave Select), to select a particular device on a bus with which
|
||||
communication takes place. Management of an SS signal should happen in
|
||||
CS (Chip Select), to select a particular device on a bus with which
|
||||
communication takes place. Management of a CS signal should happen in
|
||||
user code (via machine.Pin class).
|
||||
|
||||
Both hardware and software SPI implementations exist via the
|
||||
@ -102,9 +102,9 @@ Methods
|
||||
Constants
|
||||
---------
|
||||
|
||||
.. data:: SPI.MASTER
|
||||
.. data:: SPI.CONTROLLER
|
||||
|
||||
for initialising the SPI bus to master; this is only used for the WiPy
|
||||
for initialising the SPI bus to controller; this is only used for the WiPy
|
||||
|
||||
.. data:: SPI.MSB
|
||||
|
||||
|
||||
@ -56,11 +56,22 @@ Methods
|
||||
|
||||
- *tx* specifies the TX pin to use.
|
||||
- *rx* specifies the RX pin to use.
|
||||
- *rts* specifies the RTS (output) pin to use for hardware receive flow control.
|
||||
- *cts* specifies the CTS (input) pin to use for hardware transmit flow control.
|
||||
- *txbuf* specifies the length in characters of the TX buffer.
|
||||
- *rxbuf* specifies the length in characters of the RX buffer.
|
||||
- *timeout* specifies the time to wait for the first character (in ms).
|
||||
- *timeout_char* specifies the time to wait between characters (in ms).
|
||||
- *invert* specifies which lines to invert.
|
||||
- *flow* specifies which hardware flow control signals to use. The value
|
||||
is a bitmask.
|
||||
|
||||
- ``0`` will ignore hardware flow control signals.
|
||||
- ``UART.RTS`` will enable receive flow control by using the RTS output pin to
|
||||
signal if the receive FIFO has sufficient space to accept more data.
|
||||
- ``UART.CTS`` will enable transmit flow control by pausing transmission when the
|
||||
CTS input pin signals that the receiver is running low on buffer space.
|
||||
- ``UART.RTS | UART.CTS`` will enable both, for full hardware flow control.
|
||||
|
||||
On the WiPy only the following keyword-only parameter is supported:
|
||||
|
||||
|
||||
@ -137,6 +137,28 @@ Miscellaneous functions
|
||||
above. The timeout is the same for both cases and given by *timeout_us* (which
|
||||
is in microseconds).
|
||||
|
||||
.. function:: bitstream(pin, encoding, timing, data, /)
|
||||
|
||||
Transmits *data* by bit-banging the specified *pin*. The *encoding* argument
|
||||
specifies how the bits are encoded, and *timing* is an encoding-specific timing
|
||||
specification.
|
||||
|
||||
The supported encodings are:
|
||||
|
||||
- ``0`` for "high low" pulse duration modulation. This will transmit 0 and
|
||||
1 bits as timed pulses, starting with the most significant bit.
|
||||
The *timing* must be a four-tuple of nanoseconds in the format
|
||||
``(high_time_0, low_time_0, high_time_1, low_time_1)``. For example,
|
||||
``(400, 850, 800, 450)`` is the timing specification for WS2812 RGB LEDs
|
||||
at 800kHz.
|
||||
|
||||
The accuracy of the timing varies between ports. On Cortex M0 at 48MHz, it is
|
||||
at best +/- 120ns, however on faster MCUs (ESP8266, ESP32, STM32, Pyboard), it
|
||||
will be closer to +/-30ns.
|
||||
|
||||
.. note:: For controlling WS2812 / NeoPixel strips, see the :mod:`neopixel`
|
||||
module for a higher-level API.
|
||||
|
||||
.. function:: rng()
|
||||
|
||||
Return a 24-bit software generated random number.
|
||||
@ -181,6 +203,7 @@ Classes
|
||||
machine.UART.rst
|
||||
machine.SPI.rst
|
||||
machine.I2C.rst
|
||||
machine.I2S.rst
|
||||
machine.RTC.rst
|
||||
machine.Timer.rst
|
||||
machine.WDT.rst
|
||||
|
||||
73
docs/library/neopixel.rst
Normal file
73
docs/library/neopixel.rst
Normal file
@ -0,0 +1,73 @@
|
||||
:mod:`neopixel` --- control of WS2812 / NeoPixel LEDs
|
||||
=====================================================
|
||||
|
||||
.. module:: neopixel
|
||||
:synopsis: control of WS2812 / NeoPixel LEDs
|
||||
|
||||
This module provides a driver for WS2818 / NeoPixel LEDs.
|
||||
|
||||
.. note:: This module is only included by default on the ESP8266 and ESP32
|
||||
ports. On STM32 / Pyboard, you can `download the module
|
||||
<https://github.com/micropython/micropython/blob/master/drivers/neopixel/neopixel.py>`_
|
||||
and copy it to the filesystem.
|
||||
|
||||
class NeoPixel
|
||||
--------------
|
||||
|
||||
This class stores pixel data for a WS2812 LED strip connected to a pin. The
|
||||
application should set pixel data and then call :meth:`NeoPixel.write`
|
||||
when it is ready to update the strip.
|
||||
|
||||
For example::
|
||||
|
||||
import neopixel
|
||||
|
||||
# 32 LED strip connected to X8.
|
||||
p = machine.Pin.board.X8
|
||||
n = neopixel.NeoPixel(p, 32)
|
||||
|
||||
# Draw a red gradient.
|
||||
for i in range(32):
|
||||
n[i] = (i * 8, 0, 0)
|
||||
|
||||
# Update the strip.
|
||||
n.write()
|
||||
|
||||
Constructors
|
||||
------------
|
||||
|
||||
.. class:: NeoPixel(pin, n, *, bpp=3, timing=1)
|
||||
|
||||
Construct an NeoPixel object. The parameters are:
|
||||
|
||||
- *pin* is a machine.Pin instance.
|
||||
- *n* is the number of LEDs in the strip.
|
||||
- *bpp* is 3 for RGB LEDs, and 4 for RGBW LEDs.
|
||||
- *timing* is 0 for 400KHz, and 1 for 800kHz LEDs (most are 800kHz).
|
||||
|
||||
Pixel access methods
|
||||
--------------------
|
||||
|
||||
.. method:: NeoPixel.fill(pixel)
|
||||
|
||||
Sets the value of all pixels to the specified *pixel* value (i.e. an
|
||||
RGB/RGBW tuple).
|
||||
|
||||
.. method:: NeoPixel.__len__()
|
||||
|
||||
Returns the number of LEDs in the strip.
|
||||
|
||||
.. method:: NeoPixel.__setitem__(index, val)
|
||||
|
||||
Set the pixel at *index* to the value, which is an RGB/RGBW tuple.
|
||||
|
||||
.. method:: NeoPixel.__getitem__(index)
|
||||
|
||||
Returns the pixel at *index* as an RGB/RGBW tuple.
|
||||
|
||||
Output methods
|
||||
--------------
|
||||
|
||||
.. method:: NeoPixel.write()
|
||||
|
||||
Writes the current pixel data to the strip.
|
||||
@ -46,6 +46,8 @@ Methods
|
||||
.. method:: WLAN.scan()
|
||||
|
||||
Scan for the available wireless networks.
|
||||
Hidden networks -- where the SSID is not broadcast -- will also be scanned
|
||||
if the WLAN interface allows it.
|
||||
|
||||
Scanning is only possible on STA interface. Returns list of tuples with
|
||||
the information about WiFi access points:
|
||||
@ -53,7 +55,7 @@ Methods
|
||||
(ssid, bssid, channel, RSSI, authmode, hidden)
|
||||
|
||||
*bssid* is hardware address of an access point, in binary form, returned as
|
||||
bytes object. You can use `ubinascii.hexlify()` to convert it to ASCII form.
|
||||
bytes object. You can use `binascii.hexlify()` to convert it to ASCII form.
|
||||
|
||||
There are five values for authmode:
|
||||
|
||||
|
||||
@ -9,7 +9,7 @@ This module provides network drivers and routing configuration. To use this
|
||||
module, a MicroPython variant/build with network capabilities must be installed.
|
||||
Network drivers for specific hardware are available within this module and are
|
||||
used to configure hardware network interface(s). Network services provided
|
||||
by configured interfaces are then available for use via the :mod:`usocket`
|
||||
by configured interfaces are then available for use via the :mod:`socket`
|
||||
module.
|
||||
|
||||
For example::
|
||||
@ -17,17 +17,17 @@ For example::
|
||||
# connect/ show IP config a specific network interface
|
||||
# see below for examples of specific drivers
|
||||
import network
|
||||
import utime
|
||||
import time
|
||||
nic = network.Driver(...)
|
||||
if not nic.isconnected():
|
||||
nic.connect()
|
||||
print("Waiting for connection...")
|
||||
while not nic.isconnected():
|
||||
utime.sleep(1)
|
||||
time.sleep(1)
|
||||
print(nic.ifconfig())
|
||||
|
||||
# now use usocket as usual
|
||||
import usocket as socket
|
||||
# now use socket as usual
|
||||
import socket
|
||||
addr = socket.getaddrinfo('micropython.org', 80)[0][-1]
|
||||
s = socket.socket()
|
||||
s.connect(addr)
|
||||
|
||||
@ -1,12 +1,12 @@
|
||||
:mod:`uos` -- basic "operating system" services
|
||||
===============================================
|
||||
:mod:`os` -- basic "operating system" services
|
||||
==============================================
|
||||
|
||||
.. module:: uos
|
||||
.. module:: os
|
||||
:synopsis: basic "operating system" services
|
||||
|
||||
|see_cpython_module| :mod:`python:os`.
|
||||
|
||||
The ``uos`` module contains functions for filesystem access and mounting,
|
||||
The ``os`` module contains functions for filesystem access and mounting,
|
||||
terminal redirection and duplication, and the ``uname`` and ``urandom``
|
||||
functions.
|
||||
|
||||
@ -116,7 +116,7 @@ Terminal redirection and duplication
|
||||
|
||||
Duplicate or switch the MicroPython terminal (the REPL) on the given `stream`-like
|
||||
object. The *stream_object* argument must be a native stream object, or derive
|
||||
from ``uio.IOBase`` and implement the ``readinto()`` and
|
||||
from ``io.IOBase`` and implement the ``readinto()`` and
|
||||
``write()`` methods. The stream should be in non-blocking mode and
|
||||
``readinto()`` should return ``None`` if there is no data available for reading.
|
||||
|
||||
@ -207,7 +207,7 @@ represented by VFS classes.
|
||||
otherwise the timestamps will remain untouched. Littlefs v2 filesystems without
|
||||
timestamps will work without reformatting and timestamps will be added
|
||||
transparently to existing files once they are opened for writing. When *mtime*
|
||||
is enabled `uos.stat` on files without timestamps will return 0 for the timestamp.
|
||||
is enabled `os.stat` on files without timestamps will return 0 for the timestamp.
|
||||
|
||||
See :ref:`filesystem` for more information.
|
||||
|
||||
@ -234,7 +234,7 @@ but an actual block device class must implement the methods described below.
|
||||
|
||||
A concrete implementation of this class will usually allow access to the
|
||||
memory-like functionality of a piece of hardware (like flash memory). A block
|
||||
device can be formatted to any supported filesystem and mounted using ``uos``
|
||||
device can be formatted to any supported filesystem and mounted using ``os``
|
||||
methods.
|
||||
|
||||
See :ref:`filesystem` for example implementations of block devices using the
|
||||
@ -43,7 +43,7 @@ Methods
|
||||
|
||||
These methods implement the simple and :ref:`extended
|
||||
<block-device-interface>` block protocol defined by
|
||||
:class:`uos.AbstractBlockDev`.
|
||||
:class:`os.AbstractBlockDev`.
|
||||
|
||||
Hardware Note
|
||||
-------------
|
||||
|
||||
@ -14,11 +14,11 @@ Example::
|
||||
|
||||
from pyb import I2C
|
||||
|
||||
i2c = I2C(1) # create on bus 1
|
||||
i2c = I2C(1, I2C.MASTER) # create and init as a master
|
||||
i2c.init(I2C.MASTER, baudrate=20000) # init as a master
|
||||
i2c.init(I2C.SLAVE, addr=0x42) # init as a slave with given address
|
||||
i2c.deinit() # turn off the peripheral
|
||||
i2c = I2C(1) # create on bus 1
|
||||
i2c = I2C(1, I2C.CONTROLLER) # create and init as a controller
|
||||
i2c.init(I2C.CONTROLLER, baudrate=20000) # init as a controller
|
||||
i2c.init(I2C.PERIPHERAL, addr=0x42) # init as a peripheral with given address
|
||||
i2c.deinit() # turn off the I2C unit
|
||||
|
||||
Printing the i2c object gives you information about its configuration.
|
||||
|
||||
@ -37,21 +37,21 @@ You can specify a timeout (in ms)::
|
||||
|
||||
i2c.send(b'123', timeout=2000) # timeout after 2 seconds
|
||||
|
||||
A master must specify the recipient's address::
|
||||
A controller must specify the recipient's address::
|
||||
|
||||
i2c.init(I2C.MASTER)
|
||||
i2c.send('123', 0x42) # send 3 bytes to slave with address 0x42
|
||||
i2c.init(I2C.CONTROLLER)
|
||||
i2c.send('123', 0x42) # send 3 bytes to peripheral with address 0x42
|
||||
i2c.send(b'456', addr=0x42) # keyword for address
|
||||
|
||||
Master also has other methods::
|
||||
|
||||
i2c.is_ready(0x42) # check if slave 0x42 is ready
|
||||
i2c.scan() # scan for slaves on the bus, returning
|
||||
i2c.is_ready(0x42) # check if peripheral 0x42 is ready
|
||||
i2c.scan() # scan for peripherals on the bus, returning
|
||||
# a list of valid addresses
|
||||
i2c.mem_read(3, 0x42, 2) # read 3 bytes from memory of slave 0x42,
|
||||
# starting at address 2 in the slave
|
||||
i2c.mem_write('abc', 0x42, 2, timeout=1000) # write 'abc' (3 bytes) to memory of slave 0x42
|
||||
# starting at address 2 in the slave, timeout after 1 second
|
||||
i2c.mem_read(3, 0x42, 2) # read 3 bytes from memory of peripheral 0x42,
|
||||
# starting at address 2 in the peripheral
|
||||
i2c.mem_write('abc', 0x42, 2, timeout=1000) # write 'abc' (3 bytes) to memory of peripheral 0x42
|
||||
# starting at address 2 in the peripheral, timeout after 1 second
|
||||
|
||||
Constructors
|
||||
------------
|
||||
@ -88,9 +88,9 @@ Methods
|
||||
|
||||
Initialise the I2C bus with the given parameters:
|
||||
|
||||
- ``mode`` must be either ``I2C.MASTER`` or ``I2C.SLAVE``
|
||||
- ``addr`` is the 7-bit address (only sensible for a slave)
|
||||
- ``baudrate`` is the SCL clock rate (only sensible for a master)
|
||||
- ``mode`` must be either ``I2C.CONTROLLER`` or ``I2C.PERIPHERAL``
|
||||
- ``addr`` is the 7-bit address (only sensible for a peripheral)
|
||||
- ``baudrate`` is the SCL clock rate (only sensible for a controller)
|
||||
- ``gencall`` is whether to support general call mode
|
||||
- ``dma`` is whether to allow the use of DMA for the I2C transfers (note
|
||||
that DMA transfers have more precise timing but currently do not handle bus
|
||||
@ -98,7 +98,7 @@ Methods
|
||||
|
||||
.. method:: I2C.is_ready(addr)
|
||||
|
||||
Check if an I2C device responds to the given address. Only valid when in master mode.
|
||||
Check if an I2C device responds to the given address. Only valid when in controller mode.
|
||||
|
||||
.. method:: I2C.mem_read(data, addr, memaddr, *, timeout=5000, addr_size=8)
|
||||
|
||||
@ -111,7 +111,7 @@ Methods
|
||||
- ``addr_size`` selects width of memaddr: 8 or 16 bits
|
||||
|
||||
Returns the read data.
|
||||
This is only valid in master mode.
|
||||
This is only valid in controller mode.
|
||||
|
||||
.. method:: I2C.mem_write(data, addr, memaddr, *, timeout=5000, addr_size=8)
|
||||
|
||||
@ -124,7 +124,7 @@ Methods
|
||||
- ``addr_size`` selects width of memaddr: 8 or 16 bits
|
||||
|
||||
Returns ``None``.
|
||||
This is only valid in master mode.
|
||||
This is only valid in controller mode.
|
||||
|
||||
.. method:: I2C.recv(recv, addr=0x00, *, timeout=5000)
|
||||
|
||||
@ -132,7 +132,7 @@ Methods
|
||||
|
||||
- ``recv`` can be an integer, which is the number of bytes to receive,
|
||||
or a mutable buffer, which will be filled with received bytes
|
||||
- ``addr`` is the address to receive from (only required in master mode)
|
||||
- ``addr`` is the address to receive from (only required in controller mode)
|
||||
- ``timeout`` is the timeout in milliseconds to wait for the receive
|
||||
|
||||
Return value: if ``recv`` is an integer then a new buffer of the bytes received,
|
||||
@ -143,7 +143,7 @@ Methods
|
||||
Send data on the bus:
|
||||
|
||||
- ``send`` is the data to send (an integer to send, or a buffer object)
|
||||
- ``addr`` is the address to send to (only required in master mode)
|
||||
- ``addr`` is the address to send to (only required in controller mode)
|
||||
- ``timeout`` is the timeout in milliseconds to wait for the send
|
||||
|
||||
Return value: ``None``.
|
||||
@ -151,15 +151,15 @@ Methods
|
||||
.. method:: I2C.scan()
|
||||
|
||||
Scan all I2C addresses from 0x01 to 0x7f and return a list of those that respond.
|
||||
Only valid when in master mode.
|
||||
Only valid when in controller mode.
|
||||
|
||||
Constants
|
||||
---------
|
||||
|
||||
.. data:: I2C.MASTER
|
||||
.. data:: I2C.CONTROLLER
|
||||
|
||||
for initialising the bus to master mode
|
||||
for initialising the bus to controller mode
|
||||
|
||||
.. data:: I2C.SLAVE
|
||||
.. data:: I2C.PERIPHERAL
|
||||
|
||||
for initialising the bus to slave mode
|
||||
for initialising the bus to peripheral mode
|
||||
|
||||
@ -1,19 +1,19 @@
|
||||
.. currentmodule:: pyb
|
||||
.. _pyb.SPI:
|
||||
|
||||
class SPI -- a master-driven serial protocol
|
||||
============================================
|
||||
class SPI -- a controller-driven serial protocol
|
||||
================================================
|
||||
|
||||
SPI is a serial protocol that is driven by a master. At the physical level
|
||||
SPI is a serial protocol that is driven by a controller. At the physical level
|
||||
there are 3 lines: SCK, MOSI, MISO.
|
||||
|
||||
See usage model of I2C; SPI is very similar. Main difference is
|
||||
parameters to init the SPI bus::
|
||||
|
||||
from pyb import SPI
|
||||
spi = SPI(1, SPI.MASTER, baudrate=600000, polarity=1, phase=0, crc=0x7)
|
||||
spi = SPI(1, SPI.CONTROLLER, baudrate=600000, polarity=1, phase=0, crc=0x7)
|
||||
|
||||
Only required parameter is mode, SPI.MASTER or SPI.SLAVE. Polarity can be
|
||||
Only required parameter is mode, SPI.CONTROLLER or SPI.PERIPHERAL. Polarity can be
|
||||
0 or 1, and is the level the idle clock line sits at. Phase can be 0 or 1
|
||||
to sample data on the first or second clock edge respectively. Crc can be
|
||||
None for no CRC, or a polynomial specifier.
|
||||
@ -55,8 +55,8 @@ Methods
|
||||
|
||||
Initialise the SPI bus with the given parameters:
|
||||
|
||||
- ``mode`` must be either ``SPI.MASTER`` or ``SPI.SLAVE``.
|
||||
- ``baudrate`` is the SCK clock rate (only sensible for a master).
|
||||
- ``mode`` must be either ``SPI.CONTROLLER`` or ``SPI.PERIPHERAL``.
|
||||
- ``baudrate`` is the SCK clock rate (only sensible for a controller).
|
||||
- ``prescaler`` is the prescaler to use to derive SCK from the APB bus frequency;
|
||||
use of ``prescaler`` overrides ``baudrate``.
|
||||
- ``polarity`` can be 0 or 1, and is the level the idle clock line sits at.
|
||||
@ -112,10 +112,10 @@ Methods
|
||||
Constants
|
||||
---------
|
||||
|
||||
.. data:: SPI.MASTER
|
||||
.. data:: SPI.SLAVE
|
||||
.. data:: SPI.CONTROLLER
|
||||
.. data:: SPI.PERIPHERAL
|
||||
|
||||
for initialising the SPI bus to master or slave mode
|
||||
for initialising the SPI bus to controller or peripheral mode
|
||||
|
||||
.. data:: SPI.LSB
|
||||
.. data:: SPI.MSB
|
||||
|
||||
@ -213,11 +213,11 @@ Miscellaneous functions
|
||||
.. function:: mount(device, mountpoint, *, readonly=False, mkfs=False)
|
||||
|
||||
.. note:: This function is deprecated. Mounting and unmounting devices should
|
||||
be performed by :meth:`uos.mount` and :meth:`uos.umount` instead.
|
||||
be performed by :meth:`os.mount` and :meth:`os.umount` instead.
|
||||
|
||||
Mount a block device and make it available as part of the filesystem.
|
||||
``device`` must be an object that provides the block protocol. (The
|
||||
following is also deprecated. See :class:`uos.AbstractBlockDev` for the
|
||||
following is also deprecated. See :class:`os.AbstractBlockDev` for the
|
||||
correct way to create a block device.)
|
||||
|
||||
- ``readblocks(self, blocknum, buf)``
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
:mod:`ure` -- simple regular expressions
|
||||
========================================
|
||||
:mod:`re` -- simple regular expressions
|
||||
=======================================
|
||||
|
||||
.. module:: ure
|
||||
.. module:: re
|
||||
:synopsis: regular expressions
|
||||
|
||||
|see_cpython_module| :mod:`python:re`.
|
||||
@ -95,11 +95,11 @@ Supported operators and special sequences are:
|
||||
|
||||
Example::
|
||||
|
||||
import ure
|
||||
import re
|
||||
|
||||
# As ure doesn't support escapes itself, use of r"" strings is not
|
||||
# As re doesn't support escapes itself, use of r"" strings is not
|
||||
# recommended.
|
||||
regex = ure.compile("[\r\n]")
|
||||
regex = re.compile("[\r\n]")
|
||||
|
||||
regex.split("line1\rline2\nline3\r\n")
|
||||
|
||||
@ -152,7 +152,7 @@ Regex objects
|
||||
-------------
|
||||
|
||||
Compiled regular expression. Instances of this class are created using
|
||||
`ure.compile()`.
|
||||
`re.compile()`.
|
||||
|
||||
.. method:: regex.match(string)
|
||||
regex.search(string)
|
||||
@ -32,5 +32,5 @@ Methods
|
||||
|
||||
These methods implement the simple and extended
|
||||
:ref:`block protocol <block-device-interface>` defined by
|
||||
:class:`uos.AbstractBlockDev`.
|
||||
:class:`os.AbstractBlockDev`.
|
||||
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
:mod:`uselect` -- wait for events on a set of streams
|
||||
========================================================================
|
||||
:mod:`select` -- wait for events on a set of streams
|
||||
====================================================
|
||||
|
||||
.. module:: uselect
|
||||
.. module:: select
|
||||
:synopsis: wait for events on a set of streams
|
||||
|
||||
|see_cpython_module| :mod:`python:select`.
|
||||
@ -35,15 +35,15 @@ Methods
|
||||
|
||||
Register `stream` *obj* for polling. *eventmask* is logical OR of:
|
||||
|
||||
* ``uselect.POLLIN`` - data available for reading
|
||||
* ``uselect.POLLOUT`` - more data can be written
|
||||
* ``select.POLLIN`` - data available for reading
|
||||
* ``select.POLLOUT`` - more data can be written
|
||||
|
||||
Note that flags like ``uselect.POLLHUP`` and ``uselect.POLLERR`` are
|
||||
Note that flags like ``select.POLLHUP`` and ``select.POLLERR`` are
|
||||
*not* valid as input eventmask (these are unsolicited events which
|
||||
will be returned from `poll()` regardless of whether they are asked
|
||||
for). This semantics is per POSIX.
|
||||
|
||||
*eventmask* defaults to ``uselect.POLLIN | uselect.POLLOUT``.
|
||||
*eventmask* defaults to ``select.POLLIN | select.POLLOUT``.
|
||||
|
||||
It is OK to call this function multiple times for the same *obj*.
|
||||
Successive calls will update *obj*'s eventmask to the value of
|
||||
@ -67,8 +67,8 @@ Methods
|
||||
Returns list of (``obj``, ``event``, ...) tuples. There may be other elements in
|
||||
tuple, depending on a platform and version, so don't assume that its size is 2.
|
||||
The ``event`` element specifies which events happened with a stream and
|
||||
is a combination of ``uselect.POLL*`` constants described above. Note that
|
||||
flags ``uselect.POLLHUP`` and ``uselect.POLLERR`` can be returned at any time
|
||||
is a combination of ``select.POLL*`` constants described above. Note that
|
||||
flags ``select.POLLHUP`` and ``select.POLLERR`` can be returned at any time
|
||||
(even if were not asked for), and must be acted on accordingly (the
|
||||
corresponding stream unregistered from poll and likely closed), because
|
||||
otherwise all further invocations of `poll()` may return immediately with
|
||||
@ -1,8 +1,8 @@
|
||||
*******************************
|
||||
:mod:`usocket` -- socket module
|
||||
*******************************
|
||||
******************************
|
||||
:mod:`socket` -- socket module
|
||||
******************************
|
||||
|
||||
.. module:: usocket
|
||||
.. module:: socket
|
||||
:synopsis: socket module
|
||||
|
||||
|see_cpython_module| :mod:`python:socket`.
|
||||
@ -21,13 +21,13 @@ This module provides access to the BSD socket interface.
|
||||
Socket address format(s)
|
||||
------------------------
|
||||
|
||||
The native socket address format of the ``usocket`` module is an opaque data type
|
||||
The native socket address format of the ``socket`` module is an opaque data type
|
||||
returned by `getaddrinfo` function, which must be used to resolve textual address
|
||||
(including numeric addresses)::
|
||||
|
||||
sockaddr = usocket.getaddrinfo('www.micropython.org', 80)[0][-1]
|
||||
sockaddr = socket.getaddrinfo('www.micropython.org', 80)[0][-1]
|
||||
# You must use getaddrinfo() even for numeric addresses
|
||||
sockaddr = usocket.getaddrinfo('127.0.0.1', 80)[0][-1]
|
||||
sockaddr = socket.getaddrinfo('127.0.0.1', 80)[0][-1]
|
||||
# Now you can use that address
|
||||
sock.connect(addr)
|
||||
|
||||
@ -35,7 +35,7 @@ Using `getaddrinfo` is the most efficient (both in terms of memory and processin
|
||||
power) and portable way to work with addresses.
|
||||
|
||||
However, ``socket`` module (note the difference with native MicroPython
|
||||
``usocket`` module described here) provides CPython-compatible way to specify
|
||||
``socket`` module described here) provides CPython-compatible way to specify
|
||||
addresses using tuples, as described below. Note that depending on a
|
||||
:term:`MicroPython port`, ``socket`` module can be builtin or need to be
|
||||
installed from `micropython-lib` (as in the case of :term:`MicroPython Unix port`),
|
||||
@ -54,13 +54,13 @@ Tuple address format for ``socket`` module:
|
||||
dot-notation numeric IPv4 address, e.g. ``"8.8.8.8"``, and *port* is and
|
||||
integer port number in the range 1-65535. Note the domain names are not
|
||||
accepted as *ipv4_address*, they should be resolved first using
|
||||
`usocket.getaddrinfo()`.
|
||||
`socket.getaddrinfo()`.
|
||||
* IPv6: *(ipv6_address, port, flowinfo, scopeid)*, where *ipv6_address*
|
||||
is a string with colon-notation numeric IPv6 address, e.g. ``"2001:db8::1"``,
|
||||
and *port* is an integer port number in the range 1-65535. *flowinfo*
|
||||
must be 0. *scopeid* is the interface scope identifier for link-local
|
||||
addresses. Note the domain names are not accepted as *ipv6_address*,
|
||||
they should be resolved first using `usocket.getaddrinfo()`. Availability
|
||||
they should be resolved first using `socket.getaddrinfo()`. Availability
|
||||
of IPv6 support depends on a :term:`MicroPython port`.
|
||||
|
||||
Functions
|
||||
@ -94,17 +94,17 @@ Functions
|
||||
|
||||
The following example shows how to connect to a given url::
|
||||
|
||||
s = usocket.socket()
|
||||
s = socket.socket()
|
||||
# This assumes that if "type" is not specified, an address for
|
||||
# SOCK_STREAM will be returned, which may be not true
|
||||
s.connect(usocket.getaddrinfo('www.micropython.org', 80)[0][-1])
|
||||
s.connect(socket.getaddrinfo('www.micropython.org', 80)[0][-1])
|
||||
|
||||
Recommended use of filtering params::
|
||||
|
||||
s = usocket.socket()
|
||||
s = socket.socket()
|
||||
# Guaranteed to return an address which can be connect'ed to for
|
||||
# stream operation.
|
||||
s.connect(usocket.getaddrinfo('www.micropython.org', 80, 0, SOCK_STREAM)[0][-1])
|
||||
s.connect(socket.getaddrinfo('www.micropython.org', 80, 0, SOCK_STREAM)[0][-1])
|
||||
|
||||
.. admonition:: Difference to CPython
|
||||
:class: attention
|
||||
@ -113,7 +113,7 @@ Functions
|
||||
of error in this function. MicroPython doesn't have ``socket.gaierror``
|
||||
and raises OSError directly. Note that error numbers of `getaddrinfo()`
|
||||
form a separate namespace and may not match error numbers from
|
||||
the :mod:`uerrno` module. To distinguish `getaddrinfo()` errors, they are
|
||||
the :mod:`errno` module. To distinguish `getaddrinfo()` errors, they are
|
||||
represented by negative numbers, whereas standard system errors are
|
||||
positive numbers (error numbers are accessible using ``e.args[0]`` property
|
||||
from an exception object). The use of negative values is a provisional
|
||||
@ -124,7 +124,7 @@ Functions
|
||||
Convert a binary network address *bin_addr* of the given address family *af*
|
||||
to a textual representation::
|
||||
|
||||
>>> usocket.inet_ntop(usocket.AF_INET, b"\x7f\0\0\1")
|
||||
>>> socket.inet_ntop(socket.AF_INET, b"\x7f\0\0\1")
|
||||
'127.0.0.1'
|
||||
|
||||
.. function:: inet_pton(af, txt_addr)
|
||||
@ -132,7 +132,7 @@ Functions
|
||||
Convert a textual network address *txt_addr* of the given address family *af*
|
||||
to a binary representation::
|
||||
|
||||
>>> usocket.inet_pton(usocket.AF_INET, "1.2.3.4")
|
||||
>>> socket.inet_pton(socket.AF_INET, "1.2.3.4")
|
||||
b'\x01\x02\x03\x04'
|
||||
|
||||
Constants
|
||||
@ -152,17 +152,17 @@ Constants
|
||||
IPPROTO_TCP
|
||||
|
||||
IP protocol numbers. Availability depends on a particular :term:`MicroPython port`.
|
||||
Note that you don't need to specify these in a call to `usocket.socket()`,
|
||||
Note that you don't need to specify these in a call to `socket.socket()`,
|
||||
because `SOCK_STREAM` socket type automatically selects `IPPROTO_TCP`, and
|
||||
`SOCK_DGRAM` - `IPPROTO_UDP`. Thus, the only real use of these constants
|
||||
is as an argument to `setsockopt()`.
|
||||
|
||||
.. data:: usocket.SOL_*
|
||||
.. data:: socket.SOL_*
|
||||
|
||||
Socket option levels (an argument to `setsockopt()`). The exact
|
||||
inventory depends on a :term:`MicroPython port`.
|
||||
|
||||
.. data:: usocket.SO_*
|
||||
.. data:: socket.SO_*
|
||||
|
||||
Socket options (an argument to `setsockopt()`). The exact
|
||||
inventory depends on a :term:`MicroPython port`.
|
||||
@ -260,7 +260,7 @@ Methods
|
||||
is put in blocking mode.
|
||||
|
||||
Not every :term:`MicroPython port` supports this method. A more portable and
|
||||
generic solution is to use `uselect.poll` object. This allows to wait on
|
||||
generic solution is to use `select.poll` object. This allows to wait on
|
||||
multiple objects at the same time (and not just on sockets, but on generic
|
||||
`stream` objects which support polling). Example::
|
||||
|
||||
@ -269,8 +269,8 @@ Methods
|
||||
s.read(10) # may timeout
|
||||
|
||||
# Use:
|
||||
poller = uselect.poll()
|
||||
poller.register(s, uselect.POLLIN)
|
||||
poller = select.poll()
|
||||
poller.register(s, select.POLLIN)
|
||||
res = poller.poll(1000) # time in milliseconds
|
||||
if not res:
|
||||
# s is still not ready for input, i.e. operation timed out
|
||||
@ -342,7 +342,7 @@ Methods
|
||||
|
||||
Return value: number of bytes written.
|
||||
|
||||
.. exception:: usocket.error
|
||||
.. exception:: socket.error
|
||||
|
||||
MicroPython does NOT have this exception.
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
:mod:`ussl` -- SSL/TLS module
|
||||
=============================
|
||||
:mod:`ssl` -- SSL/TLS module
|
||||
============================
|
||||
|
||||
.. module:: ussl
|
||||
.. module:: ssl
|
||||
:synopsis: TLS/SSL wrapper for socket objects
|
||||
|
||||
|see_cpython_module| :mod:`python:ssl`.
|
||||
@ -13,14 +13,14 @@ facilities for network sockets, both client-side and server-side.
|
||||
Functions
|
||||
---------
|
||||
|
||||
.. function:: ussl.wrap_socket(sock, server_side=False, keyfile=None, certfile=None, cert_reqs=CERT_NONE, ca_certs=None, do_handshake=True)
|
||||
.. function:: ssl.wrap_socket(sock, server_side=False, keyfile=None, certfile=None, cert_reqs=CERT_NONE, ca_certs=None, do_handshake=True)
|
||||
|
||||
Takes a `stream` *sock* (usually usocket.socket instance of ``SOCK_STREAM`` type),
|
||||
Takes a `stream` *sock* (usually socket.socket instance of ``SOCK_STREAM`` type),
|
||||
and returns an instance of ssl.SSLSocket, which wraps the underlying stream in
|
||||
an SSL context. Returned object has the usual `stream` interface methods like
|
||||
``read()``, ``write()``, etc.
|
||||
A server-side SSL socket should be created from a normal socket returned from
|
||||
:meth:`~usocket.socket.accept()` on a non-SSL listening server socket.
|
||||
:meth:`~socket.socket.accept()` on a non-SSL listening server socket.
|
||||
|
||||
- *do_handshake* determines whether the handshake is done as part of the ``wrap_socket``
|
||||
or whether it is deferred to be done as part of the initial reads or writes
|
||||
@ -36,7 +36,7 @@ Functions
|
||||
|
||||
.. warning::
|
||||
|
||||
Some implementations of ``ussl`` module do NOT validate server certificates,
|
||||
Some implementations of ``ssl`` module do NOT validate server certificates,
|
||||
which makes an SSL connection established prone to man-in-the-middle attacks.
|
||||
|
||||
CPython's ``wrap_socket`` returns an ``SSLSocket`` object which has methods typical
|
||||
@ -54,8 +54,8 @@ Exceptions
|
||||
Constants
|
||||
---------
|
||||
|
||||
.. data:: ussl.CERT_NONE
|
||||
ussl.CERT_OPTIONAL
|
||||
ussl.CERT_REQUIRED
|
||||
.. data:: ssl.CERT_NONE
|
||||
ssl.CERT_OPTIONAL
|
||||
ssl.CERT_REQUIRED
|
||||
|
||||
Supported values for *cert_reqs* parameter.
|
||||
@ -1,7 +1,7 @@
|
||||
:mod:`ustruct` -- pack and unpack primitive data types
|
||||
======================================================
|
||||
:mod:`struct` -- pack and unpack primitive data types
|
||||
=====================================================
|
||||
|
||||
.. module:: ustruct
|
||||
.. module:: struct
|
||||
:synopsis: pack and unpack primitive data types
|
||||
|
||||
|see_cpython_module| :mod:`python:struct`.
|
||||
@ -12,6 +12,11 @@ Supported format codes: ``b``, ``B``, ``h``, ``H``, ``i``, ``I``, ``l``,
|
||||
``L``, ``q``, ``Q``, ``s``, ``P``, ``f``, ``d`` (the latter 2 depending
|
||||
on the floating-point support).
|
||||
|
||||
.. admonition:: Difference to CPython
|
||||
:class: attention
|
||||
|
||||
Whitespace is not supported in format strings.
|
||||
|
||||
Functions
|
||||
---------
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
:mod:`usys` -- system specific functions
|
||||
========================================
|
||||
:mod:`sys` -- system specific functions
|
||||
=======================================
|
||||
|
||||
.. module:: usys
|
||||
.. module:: sys
|
||||
:synopsis: system specific functions
|
||||
|
||||
|see_cpython_module| :mod:`python:sys`.
|
||||
@ -28,10 +28,10 @@ Functions
|
||||
This function is a MicroPython extension intended to provide similar
|
||||
functionality to the :mod:`atexit` module in CPython.
|
||||
|
||||
.. function:: print_exception(exc, file=usys.stdout, /)
|
||||
.. function:: print_exception(exc, file=sys.stdout, /)
|
||||
|
||||
Print exception with a traceback to a file-like object *file* (or
|
||||
`usys.stdout` by default).
|
||||
`sys.stdout` by default).
|
||||
|
||||
.. admonition:: Difference to CPython
|
||||
:class: attention
|
||||
@ -84,7 +84,7 @@ Constants
|
||||
value directly, but instead count number of bits in it::
|
||||
|
||||
bits = 0
|
||||
v = usys.maxsize
|
||||
v = sys.maxsize
|
||||
while v:
|
||||
bits += 1
|
||||
v >>= 1
|
||||
@ -113,7 +113,7 @@ Constants
|
||||
is an identifier of a board, e.g. ``"pyboard"`` for the original MicroPython
|
||||
reference board. It thus can be used to distinguish one board from another.
|
||||
If you need to check whether your program runs on MicroPython (vs other
|
||||
Python implementation), use `usys.implementation` instead.
|
||||
Python implementation), use `sys.implementation` instead.
|
||||
|
||||
.. data:: stderr
|
||||
|
||||
@ -1,12 +1,12 @@
|
||||
:mod:`utime` -- time related functions
|
||||
======================================
|
||||
:mod:`time` -- time related functions
|
||||
=====================================
|
||||
|
||||
.. module:: utime
|
||||
.. module:: time
|
||||
:synopsis: time related functions
|
||||
|
||||
|see_cpython_module| :mod:`python:time`.
|
||||
|
||||
The ``utime`` module provides functions for getting the current time and date,
|
||||
The ``time`` module provides functions for getting the current time and date,
|
||||
measuring time intervals, and for delays.
|
||||
|
||||
**Time Epoch**: Unix port uses standard for POSIX systems epoch of
|
||||
@ -74,10 +74,19 @@ Functions
|
||||
|
||||
Delay for given number of milliseconds, should be positive or 0.
|
||||
|
||||
This function will delay for at least the given number of milliseconds, but
|
||||
may take longer than that if other processing must take place, for example
|
||||
interrupt handlers or other threads. Passing in 0 for *ms* will still allow
|
||||
this other processing to occur. Use `sleep_us()` for more precise delays.
|
||||
|
||||
.. function:: sleep_us(us)
|
||||
|
||||
Delay for given number of microseconds, should be positive or 0.
|
||||
|
||||
This function attempts to provide an accurate delay of at least *us*
|
||||
microseconds, but it may take longer if the system has other higher priority
|
||||
processing to perform.
|
||||
|
||||
.. function:: ticks_ms()
|
||||
|
||||
Returns an increasing millisecond counter with an arbitrary reference point, that
|
||||
@ -110,7 +119,7 @@ Functions
|
||||
in the system. This is usually CPU clocks, and that's why the function is named that
|
||||
way. But it doesn't have to be a CPU clock, some other timing source available in a
|
||||
system (e.g. high-resolution timer) can be used instead. The exact timing unit
|
||||
(resolution) of this function is not specified on ``utime`` module level, but
|
||||
(resolution) of this function is not specified on ``time`` module level, but
|
||||
documentation for a specific port may provide more specific information. This
|
||||
function is intended for very fine benchmarking or very tight real-time loops.
|
||||
Avoid using it in portable code.
|
||||
@ -248,6 +248,14 @@ TCP stream connections
|
||||
|
||||
This is a coroutine, and a MicroPython extension.
|
||||
|
||||
.. method:: Stream.readexactly(n)
|
||||
|
||||
Read exactly *n* bytes and return them as a bytes object.
|
||||
|
||||
Raises an ``EOFError`` exception if the stream ends before reading *n* bytes.
|
||||
|
||||
This is a coroutine.
|
||||
|
||||
.. method:: Stream.readline()
|
||||
|
||||
Read a line and return it.
|
||||
|
||||
@ -19,7 +19,7 @@ sub-fields.
|
||||
|
||||
.. seealso::
|
||||
|
||||
Module :mod:`ustruct`
|
||||
Module :mod:`struct`
|
||||
Standard Python way to access binary data structures (doesn't scale
|
||||
well to large and complex structures).
|
||||
|
||||
|
||||
38
docs/library/zephyr.DiskAccess.rst
Normal file
38
docs/library/zephyr.DiskAccess.rst
Normal file
@ -0,0 +1,38 @@
|
||||
.. currentmodule:: zephyr
|
||||
.. _zephyr.DiskAccess:
|
||||
|
||||
class DiskAccess -- access to disk storage
|
||||
==========================================
|
||||
|
||||
Uses `Zephyr Disk Access API <https://docs.zephyrproject.org/latest/reference/storage/disk/access.html>`_.
|
||||
|
||||
This class allows access to storage devices on the board, such as support for SD card controllers and
|
||||
interfacing with SD cards via SPI. Disk devices are automatically detected and initialized on boot using
|
||||
Zephyr devicetree data.
|
||||
|
||||
The Zephyr disk access class enables the transfer of data between a disk device and an accessible memory buffer given a disk name,
|
||||
buffer, starting disk block, and number of sectors to read. MicroPython reads as many blocks as necessary to fill the buffer, so
|
||||
the number of sectors to read is found by dividing the buffer length by block size of the disk.
|
||||
|
||||
Constructors
|
||||
------------
|
||||
|
||||
.. class:: DiskAccess(disk_name)
|
||||
|
||||
Gets an object for accessing disk memory of the specific disk.
|
||||
For accessing an SD card on the mimxrt1050_evk, ``disk_name`` would be ``SDHC``. See board documentation and
|
||||
devicetree for usable disk names for your board (ex. RT boards use style USDHC#).
|
||||
|
||||
Methods
|
||||
-------
|
||||
|
||||
.. method:: DiskAccess.readblocks(block_num, buf)
|
||||
DiskAccess.readblocks(block_num, buf, offset)
|
||||
.. method:: DiskAccess.writeblocks(block_num, buf)
|
||||
DiskAccess.writeblocks(block_num, buf, offset)
|
||||
.. method:: DiskAccess.ioctl(cmd, arg)
|
||||
|
||||
These methods implement the simple and extended
|
||||
:ref:`block protocol <block-device-interface>` defined by
|
||||
:class:`uos.AbstractBlockDev`.
|
||||
|
||||
40
docs/library/zephyr.FlashArea.rst
Normal file
40
docs/library/zephyr.FlashArea.rst
Normal file
@ -0,0 +1,40 @@
|
||||
.. currentmodule:: zephyr
|
||||
.. _zephyr.FlashArea:
|
||||
|
||||
class FlashArea -- access to built-in flash storage
|
||||
===================================================
|
||||
|
||||
Uses `Zephyr flash map API <https://docs.zephyrproject.org/latest/reference/storage/flash_map/flash_map.html#flash-map>`_.
|
||||
|
||||
This class allows access to device flash partition data.
|
||||
Flash area structs consist of a globally unique ID number, the name of the flash device the partition is in,
|
||||
the start offset (expressed in relation to the flash memory beginning address per partition),
|
||||
and the size of the partition that the device represents. For fixed flash partitions, data from the device
|
||||
tree is used; however, fixed flash partitioning is not enforced in MicroPython because MCUBoot is not enabled.
|
||||
|
||||
Constructors
|
||||
------------
|
||||
|
||||
.. class:: FlashArea(id, block_size)
|
||||
|
||||
Gets an object for accessing flash memory at partition specified by ``id`` and with block size of ``block_size``.
|
||||
|
||||
``id`` values are integers correlating to fixed flash partitions defined in the devicetree.
|
||||
A commonly used partition is the designated flash storage area defined as ``FlashArea.STORAGE`` if
|
||||
``FLASH_AREA_LABEL_EXISTS(storage)`` returns true at boot.
|
||||
Zephyr devicetree fixed flash partitions are ``boot_partition``, ``slot0_partition``, ``slot1_partition``, and
|
||||
``scratch_partition``. Because MCUBoot is not enabled by default for MicroPython, these fixed partitions can be accessed by
|
||||
ID integer values 1, 2, 3, and 4, respectively.
|
||||
|
||||
Methods
|
||||
-------
|
||||
|
||||
.. method:: FlashArea.readblocks(block_num, buf)
|
||||
FlashArea.readblocks(block_num, buf, offset)
|
||||
.. method:: FlashArea.writeblocks(block_num, buf)
|
||||
FlashArea.writeblocks(block_num, buf, offset)
|
||||
.. method:: FlashArea.ioctl(cmd, arg)
|
||||
|
||||
These methods implement the simple and extended
|
||||
:ref:`block protocol <block-device-interface>` defined by
|
||||
:class:`uos.AbstractBlockDev`.
|
||||
60
docs/library/zephyr.rst
Normal file
60
docs/library/zephyr.rst
Normal file
@ -0,0 +1,60 @@
|
||||
.. currentmodule:: zephyr
|
||||
|
||||
:mod:`zephyr` --- functionality specific to the Zephyr port
|
||||
===========================================================
|
||||
|
||||
.. module:: zephyr
|
||||
:synopsis: functionality specific to Zephyr
|
||||
|
||||
The ``zephyr`` module contains functions and classes specific to the Zephyr port.
|
||||
|
||||
Functions
|
||||
---------
|
||||
|
||||
.. function:: is_preempt_thread()
|
||||
|
||||
Returns true if the current thread is a preemptible thread.
|
||||
|
||||
Zephyr preemptible threads are those with non-negative priority values (low priority levels), which therefore,
|
||||
can be supplanted as soon as a higher or equal priority thread becomes ready.
|
||||
|
||||
.. function:: current_tid()
|
||||
|
||||
Returns the thread id of the current thread, which is used to reference the thread.
|
||||
|
||||
.. function:: thread_analyze()
|
||||
|
||||
Runs the Zephyr debug thread analyzer on the current thread and prints stack size statistics in the format:
|
||||
|
||||
"``thread_name``-20s: STACK: unused ``available_stack_space`` usage ``stack_space_used``
|
||||
/ ``stack_size`` (``percent_stack_space_used`` %); CPU: ``cpu_utilization`` %"
|
||||
|
||||
* *CPU utilization is only printed if runtime statistics are configured via the ``CONFIG_THREAD_RUNTIME_STATS`` kconfig*
|
||||
|
||||
This function can only be accessed if ``CONFIG_THREAD_ANALYZER`` is configured for the port in ``zephyr/prj.conf``.
|
||||
For more infomation, see documentation for Zephyr `thread analyzer
|
||||
<https://docs.zephyrproject.org/latest/guides/debug_tools/thread-analyzer.html#thread-analyzer>`_.
|
||||
|
||||
.. function:: shell_exec(cmd_in)
|
||||
|
||||
Executes the given command on an UART backend. This function can only be accessed if ``CONFIG_SHELL_BACKEND_SERIAL``
|
||||
is configured for the port in ``zephyr/prj.conf``.
|
||||
|
||||
A list of possible commands can be found in the documentation for Zephyr `shell commands <https://docs.zephyrproject.org/latest/reference/shell/index.html?highlight=shell_execute_cmd#commands>`_.
|
||||
|
||||
Classes
|
||||
-------
|
||||
|
||||
.. toctree::
|
||||
:maxdepth: 1
|
||||
|
||||
zephyr.DiskAccess.rst
|
||||
zephyr.FlashArea.rst
|
||||
|
||||
Additional Modules
|
||||
------------------
|
||||
|
||||
.. toctree::
|
||||
:maxdepth: 1
|
||||
|
||||
zephyr.zsensor.rst
|
||||
123
docs/library/zephyr.zsensor.rst
Normal file
123
docs/library/zephyr.zsensor.rst
Normal file
@ -0,0 +1,123 @@
|
||||
.. currentmodule:: zsensor
|
||||
|
||||
:mod:`zsensor` --- Zephyr sensor bindings
|
||||
=========================================
|
||||
|
||||
.. module:: zsensor
|
||||
:synopsis: zephyr sensor bindings
|
||||
|
||||
The ``zsensor`` module contains a class for using sensors with Zephyr.
|
||||
|
||||
.. _zsensor.Sensor:
|
||||
|
||||
class Sensor --- sensor control for the Zephyr port
|
||||
---------------------------------------------------
|
||||
|
||||
Use this class to access data from sensors on your board.
|
||||
See Zephyr documentation for sensor usage here: `Sensors
|
||||
<https://docs.zephyrproject.org/latest/reference/peripherals/sensor.html?highlight=sensor#sensors>`_.
|
||||
|
||||
Sensors are defined in the Zephyr devicetree for each board. The quantities that a given sensor can
|
||||
measure are called a sensor channels. Sensors can have multiple channels to represent different axes
|
||||
of one property or different properties a sensor can measure. See `Channels`_ below for defined sensor
|
||||
channels.
|
||||
|
||||
Constructor
|
||||
~~~~~~~~~~~
|
||||
|
||||
.. class:: Sensor(device_name)
|
||||
|
||||
Device names are defined in the devicetree for your board.
|
||||
For example, the device name for the accelerometer in the FRDM-k64f board is "FXOS8700".
|
||||
|
||||
Methods
|
||||
~~~~~~~
|
||||
|
||||
.. method:: Sensor.measure()
|
||||
|
||||
Obtains a measurement sample from the sensor device using Zephyr sensor_sample_fetch and
|
||||
stores it in an internal driver buffer as a useful value, a pair of (integer part of value,
|
||||
fractional part of value in 1-millionths).
|
||||
Returns none if successful or OSError value if failure.
|
||||
|
||||
.. method:: Sensor.get_float(sensor_channel)
|
||||
|
||||
Returns the value of the sensor measurement sample as a float.
|
||||
|
||||
.. method:: Sensor.get_micros(sensor_channel)
|
||||
|
||||
Returns the value of the sensor measurement sample in millionths.
|
||||
(Ex. value of ``(1, 500000)`` returns as ``1500000``)
|
||||
|
||||
.. method:: Sensor.get_millis(sensor_channel)
|
||||
|
||||
Returns the value of sensor measurement sample in thousandths.
|
||||
(Ex. value of ``(1, 500000)`` returns as ``1500``)
|
||||
|
||||
.. method:: Sensor.get_int(sensor_channel)
|
||||
|
||||
Returns only the integer value of the measurement sample.
|
||||
(Ex. value of ``(1, 500000)`` returns as ``1``)
|
||||
|
||||
Channels
|
||||
~~~~~~~~
|
||||
|
||||
.. data:: ACCEL_X
|
||||
|
||||
Acceleration on the X axis, in m/s^2.
|
||||
|
||||
.. data:: ACCEL_Y
|
||||
|
||||
Acceleration on the Y axis, in m/s^2.
|
||||
|
||||
.. data:: ACCEL_Z
|
||||
|
||||
Acceleration on the Z axis, in m/s^2.
|
||||
|
||||
.. data:: GYRO_X
|
||||
|
||||
Angular velocity around the X axis, in radians/s.
|
||||
|
||||
.. data:: GYRO_Y
|
||||
|
||||
Angular velocity around the Y axis, in radians/s.
|
||||
|
||||
.. data:: GYRO_Z
|
||||
|
||||
Angular velocity around the Z axis, in radians/s.
|
||||
|
||||
.. data:: MAGN_X
|
||||
|
||||
Magnetic field on the X axis, in Gauss.
|
||||
|
||||
.. data:: MAGN_Y
|
||||
|
||||
Magnetic field on the Y axis, in Gauss.
|
||||
|
||||
.. data:: MAGN_Z
|
||||
|
||||
Magnetic field on the Z axis, in Gauss.
|
||||
|
||||
.. data:: DIE_TEMP
|
||||
|
||||
Device die temperature in degrees Celsius.
|
||||
|
||||
.. data:: PRESS
|
||||
|
||||
Pressure in kilopascal.
|
||||
|
||||
.. data:: PROX
|
||||
|
||||
Proximity. Dimensionless. A value of 1 indicates that an object is close.
|
||||
|
||||
.. data:: HUMIDITY
|
||||
|
||||
Humidity, in percent.
|
||||
|
||||
.. data:: LIGHT
|
||||
|
||||
Illuminance in visible spectrum, in lux.
|
||||
|
||||
.. data:: ALTITUDE
|
||||
|
||||
Altitude, in meters.
|
||||
@ -1,7 +1,7 @@
|
||||
:mod:`uzlib` -- zlib decompression
|
||||
==================================
|
||||
:mod:`zlib` -- zlib decompression
|
||||
=================================
|
||||
|
||||
.. module:: uzlib
|
||||
.. module:: zlib
|
||||
:synopsis: zlib decompression
|
||||
|
||||
|see_cpython_module| :mod:`python:zlib`.
|
||||
@ -45,7 +45,7 @@ See :mod:`pyb`. ::
|
||||
Delay and timing
|
||||
----------------
|
||||
|
||||
Use the :mod:`time <utime>` module::
|
||||
Use the :mod:`time <time>` module::
|
||||
|
||||
import time
|
||||
|
||||
@ -191,7 +191,7 @@ See :ref:`pyb.SPI <pyb.SPI>`. ::
|
||||
|
||||
from pyb import SPI
|
||||
|
||||
spi = SPI(1, SPI.MASTER, baudrate=200000, polarity=1, phase=0)
|
||||
spi = SPI(1, SPI.CONTROLLER, baudrate=200000, polarity=1, phase=0)
|
||||
spi.send('hello')
|
||||
spi.recv(5) # receive 5 bytes on the bus
|
||||
spi.send_recv('hello') # send and receive 5 bytes
|
||||
@ -210,15 +210,35 @@ eg ``I2C(1)``. Software I2C is also available by explicitly specifying the
|
||||
i2c = I2C('X', freq=400000) # create hardware I2c object
|
||||
i2c = I2C(scl='X1', sda='X2', freq=100000) # create software I2C object
|
||||
|
||||
i2c.scan() # returns list of slave addresses
|
||||
i2c.writeto(0x42, 'hello') # write 5 bytes to slave with address 0x42
|
||||
i2c.readfrom(0x42, 5) # read 5 bytes from slave
|
||||
i2c.scan() # returns list of peripheral addresses
|
||||
i2c.writeto(0x42, 'hello') # write 5 bytes to peripheral with address 0x42
|
||||
i2c.readfrom(0x42, 5) # read 5 bytes from peripheral
|
||||
|
||||
i2c.readfrom_mem(0x42, 0x10, 2) # read 2 bytes from slave 0x42, slave memory 0x10
|
||||
i2c.writeto_mem(0x42, 0x10, 'xy') # write 2 bytes to slave 0x42, slave memory 0x10
|
||||
i2c.readfrom_mem(0x42, 0x10, 2) # read 2 bytes from peripheral 0x42, peripheral memory 0x10
|
||||
i2c.writeto_mem(0x42, 0x10, 'xy') # write 2 bytes to peripheral 0x42, peripheral memory 0x10
|
||||
|
||||
Note: for legacy I2C support see :ref:`pyb.I2C <pyb.I2C>`.
|
||||
|
||||
I2S bus
|
||||
-------
|
||||
|
||||
See :ref:`machine.I2S <machine.I2S>`. ::
|
||||
|
||||
from machine import I2S, Pin
|
||||
|
||||
i2s = I2S(2, sck=Pin('Y6'), ws=Pin('Y5'), sd=Pin('Y8'), mode=I2S.TX, bits=16, format=I2S.STEREO, rate=44100, ibuf=40000) # create I2S object
|
||||
i2s.write(buf) # write buffer of audio samples to I2S device
|
||||
|
||||
i2s = I2S(1, sck=Pin('X5'), ws=Pin('X6'), sd=Pin('Y4'), mode=I2S.RX, bits=16, format=I2S.MONO, rate=22050, ibuf=40000) # create I2S object
|
||||
i2s.readinto(buf) # fill buffer with audio samples from I2S device
|
||||
|
||||
The I2S class is currently available as a Technical Preview. During the preview period, feedback from
|
||||
users is encouraged. Based on this feedback, the I2S class API and implementation may be changed.
|
||||
|
||||
PYBv1.0/v1.1 has one I2S bus with id=2.
|
||||
PYBD-SFxW has two I2S buses with id=1 and id=2.
|
||||
I2S is shared with SPI.
|
||||
|
||||
CAN bus (controller area network)
|
||||
---------------------------------
|
||||
|
||||
|
||||
@ -30,7 +30,7 @@ To set the volume, define the following function::
|
||||
|
||||
import pyb
|
||||
def volume(val):
|
||||
pyb.I2C(1, pyb.I2C.MASTER).mem_write(val, 46, 0)
|
||||
pyb.I2C(1, pyb.I2C.CONTROLLER).mem_write(val, 46, 0)
|
||||
|
||||
Then you can do::
|
||||
|
||||
|
||||
@ -51,7 +51,7 @@ MPR121 capacitive touch sensor has address 90.
|
||||
To get started, try::
|
||||
|
||||
>>> import pyb
|
||||
>>> i2c = pyb.I2C(1, pyb.I2C.MASTER)
|
||||
>>> i2c = pyb.I2C(1, pyb.I2C.CONTROLLER)
|
||||
>>> i2c.mem_write(4, 90, 0x5e)
|
||||
>>> touch = i2c.mem_read(1, 90, 0)[0]
|
||||
|
||||
@ -68,7 +68,7 @@ directory or ``lib/`` directory) and then try::
|
||||
|
||||
>>> import pyb
|
||||
>>> import mpr121
|
||||
>>> m = mpr121.MPR121(pyb.I2C(1, pyb.I2C.MASTER))
|
||||
>>> m = mpr121.MPR121(pyb.I2C(1, pyb.I2C.CONTROLLER))
|
||||
>>> for i in range(100):
|
||||
... print(m.touch_status())
|
||||
... pyb.delay(100)
|
||||
@ -80,7 +80,7 @@ Try touching each one in turn.
|
||||
Note that if you put the LCD skin in the Y-position, then you need to
|
||||
initialise the I2C bus using::
|
||||
|
||||
>>> m = mpr121.MPR121(pyb.I2C(2, pyb.I2C.MASTER))
|
||||
>>> m = mpr121.MPR121(pyb.I2C(2, pyb.I2C.CONTROLLER))
|
||||
|
||||
There is also a demo which uses the LCD and the touch sensors together,
|
||||
and can be found `here <http://micropython.org/resources/examples/lcddemo.py>`__.
|
||||
|
||||
@ -122,7 +122,7 @@ execution from Flash, RAM may be saved as follows. The data should be located in
|
||||
Python modules and frozen as bytecode. The data must be defined as `bytes`
|
||||
objects. The compiler 'knows' that `bytes` objects are immutable and ensures
|
||||
that the objects remain in flash memory rather than being copied to RAM. The
|
||||
`ustruct` module can assist in converting between `bytes` types and other
|
||||
`struct` module can assist in converting between `bytes` types and other
|
||||
Python built-in types.
|
||||
|
||||
When considering the implications of frozen bytecode, note that in Python
|
||||
@ -261,7 +261,7 @@ were a string.
|
||||
The Python funcitons `eval` and `exec` invoke the compiler at runtime, which
|
||||
requires significant amounts of RAM. Note that the ``pickle`` library from
|
||||
`micropython-lib` employs `exec`. It may be more RAM efficient to use the
|
||||
`ujson` library for object serialisation.
|
||||
`json` library for object serialisation.
|
||||
|
||||
**Storing strings in flash**
|
||||
|
||||
@ -444,7 +444,7 @@ RAM usage and speed.
|
||||
|
||||
Where variables are required whose size is neither a byte nor a machine word
|
||||
there are standard libraries which can assist in storing these efficiently and
|
||||
in performing conversions. See the `array`, `ustruct` and `uctypes`
|
||||
in performing conversions. See the `array`, `struct` and `uctypes`
|
||||
modules.
|
||||
|
||||
Footnote: gc.collect() return value
|
||||
|
||||
@ -40,7 +40,7 @@ Block devices
|
||||
-------------
|
||||
|
||||
A block device is an instance of a class that implements the
|
||||
:class:`uos.AbstractBlockDev` protocol.
|
||||
:class:`os.AbstractBlockDev` protocol.
|
||||
|
||||
Built-in block devices
|
||||
~~~~~~~~~~~~~~~~~~~~~~
|
||||
@ -116,8 +116,8 @@ It can be used as follows::
|
||||
|
||||
An example of a block device that supports both the simple and extended
|
||||
interface (i.e. both signatures and behaviours of the
|
||||
:meth:`uos.AbstractBlockDev.readblocks` and
|
||||
:meth:`uos.AbstractBlockDev.writeblocks` methods) is::
|
||||
:meth:`os.AbstractBlockDev.readblocks` and
|
||||
:meth:`os.AbstractBlockDev.writeblocks` methods) is::
|
||||
|
||||
class RAMBlockDev:
|
||||
def __init__(self, block_size, num_blocks):
|
||||
@ -148,7 +148,7 @@ interface (i.e. both signatures and behaviours of the
|
||||
return 0
|
||||
|
||||
As it supports the extended interface, it can be used with :class:`littlefs
|
||||
<uos.VfsLfs2>`::
|
||||
<os.VfsLfs2>`::
|
||||
|
||||
import os
|
||||
|
||||
@ -166,8 +166,8 @@ normally would be used from Python code, for example::
|
||||
Filesystems
|
||||
-----------
|
||||
|
||||
MicroPython ports can provide implementations of :class:`FAT <uos.VfsFat>`,
|
||||
:class:`littlefs v1 <uos.VfsLfs1>` and :class:`littlefs v2 <uos.VfsLfs2>`.
|
||||
MicroPython ports can provide implementations of :class:`FAT <os.VfsFat>`,
|
||||
:class:`littlefs v1 <os.VfsLfs1>` and :class:`littlefs v2 <os.VfsLfs2>`.
|
||||
|
||||
The following table shows which filesystems are included in the firmware by
|
||||
default for given port/board combinations, however they can be optionally
|
||||
|
||||
@ -184,7 +184,7 @@ Glossary
|
||||
``close()``, etc. A stream is an important concept in MicroPython;
|
||||
many I/O objects implement the stream interface, and thus can be used
|
||||
consistently and interchangeably in different contexts. For more
|
||||
information on streams in MicroPython, see the `uio` module.
|
||||
information on streams in MicroPython, see the `io` module.
|
||||
|
||||
UART
|
||||
Acronym for "Universal Asynchronous Receiver/Transmitter". This is a
|
||||
|
||||
@ -1,3 +1,5 @@
|
||||
.. _packages:
|
||||
|
||||
Distribution packages, package management, and deploying applications
|
||||
=====================================================================
|
||||
|
||||
|
||||
@ -91,9 +91,11 @@ code these should be pre-allocated and passed as arguments or as bound objects.
|
||||
|
||||
When passing slices of objects such as `bytearray` instances, Python creates
|
||||
a copy which involves allocation of the size proportional to the size of slice.
|
||||
This can be alleviated using a `memoryview` object. `memoryview` itself
|
||||
is allocated on heap, but is a small, fixed-size object, regardless of the size
|
||||
of slice it points too.
|
||||
This can be alleviated using a `memoryview` object. The `memoryview` itself
|
||||
is allocated on the heap, but is a small, fixed-size object, regardless of the size
|
||||
of slice it points too. Slicing a `memoryview` creates a new `memoryview`, so this
|
||||
cannot be done in an interrupt service routine. Further, the slice syntax ``a:b``
|
||||
causes further allocation by instantiating a ``slice(a, b)`` object.
|
||||
|
||||
.. code:: python
|
||||
|
||||
@ -123,7 +125,7 @@ This is a process known as profiling and is covered in textbooks and
|
||||
(for standard Python) supported by various software tools. For the type of
|
||||
smaller embedded application likely to be running on MicroPython platforms
|
||||
the slowest function or method can usually be established by judicious use
|
||||
of the timing ``ticks`` group of functions documented in `utime`.
|
||||
of the timing ``ticks`` group of functions documented in `time`.
|
||||
Code execution time can be measured in ms, us, or CPU cycles.
|
||||
|
||||
The following enables any function or method to be timed by adding an
|
||||
@ -134,9 +136,9 @@ The following enables any function or method to be timed by adding an
|
||||
def timed_function(f, *args, **kwargs):
|
||||
myname = str(f).split(' ')[1]
|
||||
def new_func(*args, **kwargs):
|
||||
t = utime.ticks_us()
|
||||
t = time.ticks_us()
|
||||
result = f(*args, **kwargs)
|
||||
delta = utime.ticks_diff(utime.ticks_us(), t)
|
||||
delta = time.ticks_diff(time.ticks_us(), t)
|
||||
print('Function {} Time = {:6.3f}ms'.format(myname, delta/1000))
|
||||
return result
|
||||
return new_func
|
||||
|
||||
@ -10,9 +10,27 @@ the RP2040.
|
||||
Technical specifications and SoC datasheets
|
||||
-------------------------------------------
|
||||
|
||||
Datasheets!
|
||||
For detailed technical specifications, please refer to the `datasheets
|
||||
<https://datasheets.raspberrypi.org/rp2040/rp2040-datasheet.pdf>`_
|
||||
|
||||
Short summary of tech specs!
|
||||
The RP2040 microcontroller is manufactured on a 40 nm silicon process in a 7x7mm
|
||||
QFN-56 SMD package. The key features include:
|
||||
|
||||
Description of general structure of the port (it's built on top of the APIs
|
||||
provided by the Raspberry Pi SDK).
|
||||
* 133 MHz dual ARM Cortex-M0+ cores (overclockable to over 400 MHz)
|
||||
* 264KB SRAM in six independent banks
|
||||
* No internal Flash or EEPROM memory (after reset, the bootloader loads
|
||||
firmware from either the external flash memory or USB bus into internal SRAM)
|
||||
* QSPI bus controller, which
|
||||
supports up to 16 MB of external Flash memory
|
||||
* On-chip programmable LDO togenerate core voltage
|
||||
* 2 on-chip PLLs to generate USB and core clocks
|
||||
* 30 GPIOpins, of which 4 can optionally be used as analog inputs
|
||||
|
||||
The peripherals include:
|
||||
|
||||
* 2 UARTs
|
||||
* 2 SPI controllers
|
||||
* 2 I2C contollers
|
||||
* 16 PWM channels
|
||||
* USB 1.1 controller
|
||||
* 8 PIO state machines
|
||||
|
||||
BIN
docs/rp2/img/pico_pinout.png
Normal file
BIN
docs/rp2/img/pico_pinout.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 182 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 87 KiB |
@ -3,7 +3,7 @@
|
||||
Quick reference for the RP2
|
||||
===========================
|
||||
|
||||
.. image:: img/rpipico.jpg
|
||||
.. image:: img/pico_pinout.png
|
||||
:alt: Raspberry Pi Pico
|
||||
:width: 640px
|
||||
|
||||
@ -27,10 +27,9 @@ a troubleshooting subsection.
|
||||
General board control
|
||||
---------------------
|
||||
|
||||
The MicroPython REPL is on the USB serial port.
|
||||
Tab-completion is useful to find out what methods an object has.
|
||||
Paste mode (ctrl-E) is useful to paste a large slab of Python code into
|
||||
the REPL.
|
||||
The MicroPython REPL is accessed via the USB serial port. Tab-completion is useful to
|
||||
find out what methods an object has. Paste mode (ctrl-E) is useful to paste a
|
||||
large slab of Python code into the REPL.
|
||||
|
||||
The :mod:`machine` module::
|
||||
|
||||
@ -46,7 +45,7 @@ The :mod:`rp2` module::
|
||||
Delay and timing
|
||||
----------------
|
||||
|
||||
Use the :mod:`time <utime>` module::
|
||||
Use the :mod:`time <time>` module::
|
||||
|
||||
import time
|
||||
|
||||
@ -59,7 +58,19 @@ Use the :mod:`time <utime>` module::
|
||||
Timers
|
||||
------
|
||||
|
||||
How do they work?
|
||||
RP2040's system timer peripheral provides a global microsecond timebase and
|
||||
generates interrupts for it. The software timer is available currently,
|
||||
and there are unlimited number of them (memory permitting). There is no need
|
||||
to specify the timer id (id=-1 is supported at the moment) as it will default
|
||||
to this.
|
||||
|
||||
Use the :mod:`machine.Timer` class::
|
||||
|
||||
from machine import Timer
|
||||
|
||||
tim = Timer(period=5000, mode=Timer.ONE_SHOT, callback=lambda t:print(1))
|
||||
tim.init(period=2000, mode=Timer.PERIODIC, callback=lambda t:print(2))
|
||||
|
||||
|
||||
.. _rp2_Pins_and_GPIO:
|
||||
|
||||
@ -84,19 +95,28 @@ Use the :ref:`machine.Pin <machine.Pin>` class::
|
||||
UART (serial bus)
|
||||
-----------------
|
||||
|
||||
There are two UARTs, UART0 and UART1. UART0 can be mapped to GPIO 0/1, 12/13
|
||||
and 16/17, and UART1 to GPIO 4/5 and 8/9.
|
||||
|
||||
|
||||
See :ref:`machine.UART <machine.UART>`. ::
|
||||
|
||||
from machine import UART
|
||||
|
||||
uart1 = UART(1, baudrate=9600, tx=33, rx=32)
|
||||
from machine import UART, Pin
|
||||
uart1 = UART(1, baudrate=9600, tx=Pin(4), rx=Pin(5))
|
||||
uart1.write('hello') # write 5 bytes
|
||||
uart1.read(5) # read up to 5 bytes
|
||||
|
||||
.. note::
|
||||
|
||||
REPL over UART is disabled by default. You can see the :ref:`rp2_intro` for
|
||||
details on how to enable REPL over UART.
|
||||
|
||||
|
||||
PWM (pulse width modulation)
|
||||
----------------------------
|
||||
|
||||
How does PWM work on the RPi RP2xxx?
|
||||
There are 8 independent channels each of which have 2 outputs making it 16
|
||||
PWM channels in total which can be clocked from 7Hz to 125Mhz.
|
||||
|
||||
Use the ``machine.PWM`` class::
|
||||
|
||||
@ -112,14 +132,18 @@ Use the ``machine.PWM`` class::
|
||||
ADC (analog to digital conversion)
|
||||
----------------------------------
|
||||
|
||||
How does the ADC module work?
|
||||
RP2040 has five ADC channels in total, four of which are 12-bit SAR based
|
||||
ADCs: GP26, GP27, GP28 and GP29. The input signal for ADC0, ADC1, ADC2 and
|
||||
ADC3 can be connected with GP26, GP27, GP28, GP29 respectively (On Pico board,
|
||||
GP29 is connected to VSYS). The standard ADC range is 0-3.3V. The fifth
|
||||
channel is connected to the in-built temperature sensor and can be used for
|
||||
measuring the temperature.
|
||||
|
||||
Use the :ref:`machine.ADC <machine.ADC>` class::
|
||||
|
||||
from machine import ADC
|
||||
|
||||
adc = ADC(Pin(32)) # create ADC object on ADC pin
|
||||
adc.read_u16() # read value, 0-65535 across voltage range 0.0v - 3.3v
|
||||
from machine import ADC, Pin
|
||||
adc = ADC(Pin(26)) # create ADC object on ADC pin
|
||||
adc.read_u16() # read value, 0-65535 across voltage range 0.0v - 3.3v
|
||||
|
||||
Software SPI bus
|
||||
----------------
|
||||
@ -132,7 +156,7 @@ Software SPI (using bit-banging) works on all pins, and is accessed via the
|
||||
# construct a SoftSPI bus on the given pins
|
||||
# polarity is the idle state of SCK
|
||||
# phase=0 means sample on the first edge of SCK, phase=1 means the second
|
||||
spi = SoftSPI(baudrate=100000, polarity=1, phase=0, sck=Pin(0), mosi=Pin(2), miso=Pin(4))
|
||||
spi = SoftSPI(baudrate=100_000, polarity=1, phase=0, sck=Pin(0), mosi=Pin(2), miso=Pin(4))
|
||||
|
||||
spi.init(baudrate=200000) # set the baudrate
|
||||
|
||||
@ -156,14 +180,15 @@ Software SPI (using bit-banging) works on all pins, and is accessed via the
|
||||
Hardware SPI bus
|
||||
----------------
|
||||
|
||||
Hardware SPI is accessed via the :ref:`machine.SPI <machine.SPI>` class and
|
||||
has the same methods as software SPI above::
|
||||
The RP2040 has 2 hardware SPI buses which is accessed via the
|
||||
:ref:`machine.SPI <machine.SPI>` class and has the same methods as software
|
||||
SPI above::
|
||||
|
||||
from machine import Pin, SPI
|
||||
|
||||
spi = SPI(1, 10000000)
|
||||
spi = SPI(1, 10000000, sck=Pin(14), mosi=Pin(13), miso=Pin(12))
|
||||
spi = SPI(2, baudrate=80000000, polarity=0, phase=0, bits=8, firstbit=0, sck=Pin(18), mosi=Pin(23), miso=Pin(19))
|
||||
spi = SPI(1, 10_000_000) # Default assignment: sck=Pin(10), mosi=Pin(11), miso=Pin(8)
|
||||
spi = SPI(1, 10_000_000, sck=Pin(14), mosi=Pin(15), miso=Pin(12))
|
||||
spi = SPI(0, baudrate=80_000_000, polarity=0, phase=0, bits=8, sck=Pin(6), mosi=Pin(7), miso=Pin(4))
|
||||
|
||||
Software I2C bus
|
||||
----------------
|
||||
@ -173,7 +198,7 @@ accessed via the :ref:`machine.SoftI2C <machine.SoftI2C>` class::
|
||||
|
||||
from machine import Pin, SoftI2C
|
||||
|
||||
i2c = SoftI2C(scl=Pin(5), sda=Pin(4), freq=100000)
|
||||
i2c = SoftI2C(scl=Pin(5), sda=Pin(4), freq=100_000)
|
||||
|
||||
i2c.scan() # scan for devices
|
||||
|
||||
@ -181,7 +206,7 @@ accessed via the :ref:`machine.SoftI2C <machine.SoftI2C>` class::
|
||||
i2c.writeto(0x3a, '12') # write '12' to device with address 0x3a
|
||||
|
||||
buf = bytearray(10) # create a buffer with 10 bytes
|
||||
i2c.writeto(0x3a, buf) # write the given buffer to the slave
|
||||
i2c.writeto(0x3a, buf) # write the given buffer to the peripheral
|
||||
|
||||
Hardware I2C bus
|
||||
----------------
|
||||
@ -191,8 +216,8 @@ has the same methods as software I2C above::
|
||||
|
||||
from machine import Pin, I2C
|
||||
|
||||
i2c = I2C(0)
|
||||
i2c = I2C(1, scl=Pin(5), sda=Pin(4), freq=400000)
|
||||
i2c = I2C(0) # default assignment: scl=Pin(9), sda=Pin(8)
|
||||
i2c = I2C(1, scl=Pin(3), sda=Pin(2), freq=400_000)
|
||||
|
||||
Real time clock (RTC)
|
||||
---------------------
|
||||
@ -202,13 +227,15 @@ See :ref:`machine.RTC <machine.RTC>` ::
|
||||
from machine import RTC
|
||||
|
||||
rtc = RTC()
|
||||
rtc.datetime((2017, 8, 23, 2, 12, 48, 0, 0)) # set a specific date and time
|
||||
rtc.datetime((2017, 8, 23, 2, 12, 48, 0, 0)) # set a specific date and
|
||||
# time, eg. 2017/8/23 1:12:48
|
||||
rtc.datetime() # get date and time
|
||||
|
||||
WDT (Watchdog timer)
|
||||
--------------------
|
||||
|
||||
Is there a watchdog timer?
|
||||
The RP2040 has a watchdog which is a countdown timer that can restart
|
||||
parts of the chip if it reaches zero.
|
||||
|
||||
See :ref:`machine.WDT <machine.WDT>`. ::
|
||||
|
||||
@ -218,21 +245,6 @@ See :ref:`machine.WDT <machine.WDT>`. ::
|
||||
wdt = WDT(timeout=5000)
|
||||
wdt.feed()
|
||||
|
||||
Deep-sleep mode
|
||||
---------------
|
||||
|
||||
Is there deep-sleep support for the rp2?
|
||||
|
||||
The following code can be used to sleep, wake and check the reset cause::
|
||||
|
||||
import machine
|
||||
|
||||
# check if the device woke from a deep sleep
|
||||
if machine.reset_cause() == machine.DEEPSLEEP_RESET:
|
||||
print('woke from a deep sleep')
|
||||
|
||||
# put the device to sleep for 10 seconds
|
||||
machine.deepsleep(10000)
|
||||
|
||||
OneWire driver
|
||||
--------------
|
||||
|
||||
8
docs/templates/topindex.html
vendored
8
docs/templates/topindex.html
vendored
@ -66,6 +66,14 @@
|
||||
<a class="biglink" href="{{ pathto("wipy/quickref") }}">Quick reference for the WiPy/CC3200</a><br/>
|
||||
<span class="linkdescr">pinout for the WiPy/CC3200, snippets of useful code, and a tutorial</span>
|
||||
</p>
|
||||
<p class="biglink">
|
||||
<a class="biglink" href="{{ pathto("unix/quickref") }}">Quick reference for UNIX and Windows</a><br/>
|
||||
<span class="linkdescr">command-line reference</span>
|
||||
</p>
|
||||
<p class="biglink">
|
||||
<a class="biglink" href="{{ pathto("zephyr/quickref") }}">Quick reference for the Zephyr port</a><br/>
|
||||
<span class="linkdescr">snippets of useful code and a tutorial</span>
|
||||
</p>
|
||||
</td>
|
||||
</tr></table>
|
||||
|
||||
|
||||
@ -296,8 +296,8 @@ and put it in '/flash/cert/'. Then do::
|
||||
ss = ssl.wrap_socket(s, cert_reqs=ssl.CERT_REQUIRED, ca_certs='/flash/cert/ca.pem')
|
||||
ss.connect(socket.getaddrinfo('cloud.blynk.cc', 8441)[0][-1])
|
||||
|
||||
Incompatibilities in uhashlib module
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
Incompatibilities in hashlib module
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
Due to hardware implementation details of the WiPy, data must be buffered before being
|
||||
digested, which would make it impossible to calculate the hash of big blocks of data that
|
||||
@ -310,7 +310,7 @@ initial one) is a multiple of 4 bytes.** The last chunk may be of any length.
|
||||
|
||||
Example::
|
||||
|
||||
hash = uhashlib.sha1('abcd1234', 1001) # length of the initial piece is multiple of 4 bytes
|
||||
hash = hashlib.sha1('abcd1234', 1001) # length of the initial piece is multiple of 4 bytes
|
||||
hash.update('1234') # also multiple of 4 bytes
|
||||
...
|
||||
hash.update('12345') # last chunk may be of any length
|
||||
@ -366,7 +366,7 @@ Adhoc VFS-like support
|
||||
~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
WiPy doesn't implement full MicroPython VFS support, instead following
|
||||
functions are defined in ``uos`` module:
|
||||
functions are defined in ``os`` module:
|
||||
|
||||
.. function:: mount(block_device, mount_point, \*, readonly=False)
|
||||
|
||||
|
||||
@ -107,8 +107,8 @@ See :ref:`machine.SPI <machine.SPI>`. ::
|
||||
|
||||
from machine import SPI
|
||||
|
||||
# configure the SPI master @ 2MHz
|
||||
spi = SPI(0, SPI.MASTER, baudrate=200000, polarity=0, phase=0)
|
||||
# configure the SPI controller @ 2MHz
|
||||
spi = SPI(0, SPI.CONTROLLER, baudrate=2_000_000, polarity=0, phase=0)
|
||||
spi.write('hello')
|
||||
spi.read(5) # receive 5 bytes on the bus
|
||||
rbuf = bytearray(5)
|
||||
@ -122,11 +122,11 @@ See :ref:`machine.I2C <machine.I2C>`. ::
|
||||
from machine import I2C
|
||||
# configure the I2C bus
|
||||
i2c = I2C(baudrate=100000)
|
||||
i2c.scan() # returns list of slave addresses
|
||||
i2c.writeto(0x42, 'hello') # send 5 bytes to slave with address 0x42
|
||||
i2c.readfrom(0x42, 5) # receive 5 bytes from slave
|
||||
i2c.readfrom_mem(0x42, 0x10, 2) # read 2 bytes from slave 0x42, slave memory 0x10
|
||||
i2c.writeto_mem(0x42, 0x10, 'xy') # write 2 bytes to slave 0x42, slave memory 0x10
|
||||
i2c.scan() # returns list of peripheral addresses
|
||||
i2c.writeto(0x42, 'hello') # send 5 bytes to peripheral with address 0x42
|
||||
i2c.readfrom(0x42, 5) # receive 5 bytes from peripheral
|
||||
i2c.readfrom_mem(0x42, 0x10, 2) # read 2 bytes from peripheral 0x42, peripheral memory 0x10
|
||||
i2c.writeto_mem(0x42, 0x10, 'xy') # write 2 bytes to peripheral 0x42, peripheral memory 0x10
|
||||
|
||||
Watchdog timer (WDT)
|
||||
--------------------
|
||||
|
||||
22
docs/zephyr/general.rst
Normal file
22
docs/zephyr/general.rst
Normal file
@ -0,0 +1,22 @@
|
||||
.. _zephyr_general:
|
||||
|
||||
General information about the Zephyr port
|
||||
=========================================
|
||||
|
||||
The Zephyr Project is a Linux Foundation hosted Collaboration Project. It’s an open
|
||||
source collaborative effort uniting developers and users in building a
|
||||
small, scalable, real-time operating system (RTOS) optimized for resource-constrained
|
||||
devices, across multiple architectures.
|
||||
|
||||
Multitude of boards
|
||||
-------------------
|
||||
|
||||
There is a multitude of modules and boards from different sources that are supported
|
||||
by the Zephyr OS. All boards supported by Zephyr (with standard level of features
|
||||
support, like UART console) should work with MicroPython (but not all were tested).
|
||||
The FRDM-K64f board is taken as a reference board for the port for this documentation.
|
||||
If you have another board, please make sure you have a datasheet, schematics and other
|
||||
reference materials for your board handy to look up various aspects of your board
|
||||
functioning.
|
||||
|
||||
For a full list of Zephyr supported boards click `here (external link) <https://docs.zephyrproject.org/latest/boards/index.html#boards>`_
|
||||
157
docs/zephyr/quickref.rst
Normal file
157
docs/zephyr/quickref.rst
Normal file
@ -0,0 +1,157 @@
|
||||
.. _zephyr_quickref:
|
||||
|
||||
Quick reference for the Zephyr port
|
||||
===================================
|
||||
|
||||
Below is a quick reference for the Zephyr port. If it is your first time working with this port please consider reading the following sections first:
|
||||
|
||||
.. toctree::
|
||||
:maxdepth: 1
|
||||
|
||||
general.rst
|
||||
tutorial/index.rst
|
||||
|
||||
Running MicroPython
|
||||
-------------------
|
||||
|
||||
See the corresponding section of the tutorial: :ref:`intro`.
|
||||
|
||||
Delay and timing
|
||||
----------------
|
||||
|
||||
Use the :mod:`time <utime>` module::
|
||||
|
||||
import time
|
||||
|
||||
time.sleep(1) # sleep for 1 second
|
||||
time.sleep_ms(500) # sleep for 500 milliseconds
|
||||
time.sleep_us(10) # sleep for 10 microseconds
|
||||
start = time.ticks_ms() # get millisecond counter
|
||||
delta = time.ticks_diff(time.ticks_ms(), start) # compute time difference
|
||||
|
||||
Pins and GPIO
|
||||
-------------
|
||||
|
||||
Use the :ref:`machine.Pin <machine.Pin>` class::
|
||||
|
||||
from machine import Pin
|
||||
|
||||
pin = Pin(("GPIO_1", 21), Pin.IN) # create input pin on GPIO1
|
||||
print(pin) # print pin port and number
|
||||
|
||||
pin.init(Pin.OUT, Pin.PULL_UP, value=1) # reinitialize pin
|
||||
|
||||
pin.value(1) # set pin to high
|
||||
pin.value(0) # set pin to low
|
||||
|
||||
pin.on() # set pin to high
|
||||
pin.off() # set pin to low
|
||||
|
||||
pin = Pin(("GPIO_1", 21), Pin.IN) # create input pin on GPIO1
|
||||
|
||||
pin = Pin(("GPIO_1", 21), Pin.OUT, value=1) # set pin high on creation
|
||||
|
||||
pin = Pin(("GPIO_1", 21), Pin.IN, Pin.PULL_UP) # enable internal pull-up resistor
|
||||
|
||||
switch = Pin(("GPIO_2", 6), Pin.IN) # create input pin for a switch
|
||||
switch.irq(lambda t: print("SW2 changed")) # enable an interrupt when switch state is changed
|
||||
|
||||
Hardware I2C bus
|
||||
----------------
|
||||
|
||||
Hardware I2C is accessed via the :ref:`machine.I2C <machine.I2C>` class::
|
||||
|
||||
from machine import I2C
|
||||
|
||||
i2c = I2C("I2C_0") # construct an i2c bus
|
||||
print(i2c) # print device name
|
||||
|
||||
i2c.scan() # scan the device for available I2C slaves
|
||||
|
||||
i2c.readfrom(0x1D, 4) # read 4 bytes from slave 0x1D
|
||||
i2c.readfrom_mem(0x1D, 0x0D, 1) # read 1 byte from slave 0x1D at slave memory 0x0D
|
||||
|
||||
i2c.writeto(0x1D, b'abcd') # write to slave with address 0x1D
|
||||
i2c.writeto_mem(0x1D, 0x0D, b'ab') # write to slave 0x1D at slave memory 0x0D
|
||||
|
||||
buf = bytearray(8) # create buffer of size 8
|
||||
i2c.writeto(0x1D, b'abcd') # write buf to slave 0x1D
|
||||
|
||||
Hardware SPI bus
|
||||
----------------
|
||||
|
||||
Hardware SPI is accessed via the :ref:`machine.SPI <machine.SPI>` class::
|
||||
|
||||
from machine import SPI
|
||||
|
||||
spi = SPI("SPI_0") # construct a spi bus with default configuration
|
||||
spi.init(baudrate=100000, polarity=0, phase=0, bits=8, firstbit=SPI.MSB) # set configuration
|
||||
|
||||
# equivalently, construct spi bus and set configuration at the same time
|
||||
spi = SPI("SPI_0", baudrate=100000, polarity=0, phase=0, bits=8, firstbit=SPI.MSB)
|
||||
print(spi) # print device name and bus configuration
|
||||
|
||||
spi.read(4) # read 4 bytes on MISO
|
||||
spi.read(4, write=0xF) # read 4 bytes while writing 0xF on MOSI
|
||||
|
||||
buf = bytearray(8) # create a buffer of size 8
|
||||
spi.readinto(buf) # read into the buffer (reads number of bytes equal to the buffer size)
|
||||
spi.readinto(buf, 0xF) # read into the buffer while writing 0xF on MOSI
|
||||
|
||||
spi.write(b'abcd') # write 4 bytes on MOSI
|
||||
|
||||
buf = bytearray(4) # create buffer of size 8
|
||||
spi.write_readinto(b'abcd', buf) # write to MOSI and read from MISO into the buffer
|
||||
spi.write_readinto(buf, buf) # write buf to MOSI and read back into the buf
|
||||
|
||||
Disk Access
|
||||
-----------
|
||||
|
||||
Use the :ref:`zephyr.DiskAccess <zephyr.DiskAccess>` class to support filesystem::
|
||||
|
||||
import os
|
||||
from zephyr import DiskAccess
|
||||
|
||||
block_dev = DiskAccess('SDHC') # create a block device object for an SD card
|
||||
os.VfsFat.mkfs(block_dev) # create FAT filesystem object using the disk storage block
|
||||
os.mount(block_dev, '/sd') # mount the filesystem at the SD card subdirectory
|
||||
|
||||
# with the filesystem mounted, files can be manipulated as normal
|
||||
with open('/sd/hello.txt','w') as f: # open a new file in the directory
|
||||
f.write('Hello world') # write to the file
|
||||
print(open('/sd/hello.txt').read()) # print contents of the file
|
||||
|
||||
Flash Area
|
||||
----------
|
||||
|
||||
Use the :ref:`zephyr.FlashArea <zephyr.FlashArea>` class to support filesystem::
|
||||
|
||||
import os
|
||||
from zephyr import FlashArea
|
||||
|
||||
block_dev = FlashArea(4, 4096) # creates a block device object in the frdm-k64f flash scratch partition
|
||||
os.VfsLfs2.mkfs(block_dev) # create filesystem in lfs2 format using the flash block device
|
||||
os.mount(block_dev, '/flash') # mount the filesystem at the flash subdirectory
|
||||
|
||||
# with the filesystem mounted, files can be manipulated as normal
|
||||
with open('/flash/hello.txt','w') as f: # open a new file in the directory
|
||||
f.write('Hello world') # write to the file
|
||||
print(open('/flash/hello.txt').read()) # print contents of the file
|
||||
|
||||
Sensor
|
||||
------
|
||||
|
||||
Use the :ref:`zsensor.Sensor <zsensor.Sensor>` class to access sensor data::
|
||||
|
||||
import zsensor
|
||||
from zsensor import Sensor
|
||||
|
||||
accel = Sensor("FXOX8700") # create sensor object for the accelerometer
|
||||
|
||||
accel.measure() # obtain a measurement reading from the accelerometer
|
||||
|
||||
# each of these prints the value taken by measure()
|
||||
accel.float(zsensor.ACCEL_X) # print measurement value for accelerometer X-axis sensor channel as float
|
||||
accel.millis(zsensor.ACCEL_Y) # print measurement value for accelerometer Y-axis sensor channel in millionths
|
||||
accel.micro(zsensor.ACCEL_Z) # print measurement value for accelerometer Z-axis sensor channel in thousandths
|
||||
accel.int(zsensor.ACCEL_X) # print measurement integer value only for accelerometer X-axis sensor channel
|
||||
16
docs/zephyr/tutorial/index.rst
Normal file
16
docs/zephyr/tutorial/index.rst
Normal file
@ -0,0 +1,16 @@
|
||||
.. _zephyr_tutorial:
|
||||
|
||||
MicroPython tutorial for the Zephyr port
|
||||
========================================
|
||||
|
||||
This tutorial is intended to get you started with the Zephyr port.
|
||||
|
||||
.. toctree::
|
||||
:maxdepth: 1
|
||||
:numbered:
|
||||
|
||||
intro.rst
|
||||
repl.rst
|
||||
storage.rst
|
||||
pins.rst
|
||||
|
||||
30
docs/zephyr/tutorial/intro.rst
Normal file
30
docs/zephyr/tutorial/intro.rst
Normal file
@ -0,0 +1,30 @@
|
||||
.. _intro_zephyr:
|
||||
|
||||
Getting started with MicroPython on the Zephyr port
|
||||
===================================================
|
||||
|
||||
Let’s get started!
|
||||
|
||||
Requirements
|
||||
------------
|
||||
|
||||
To use the MicroPython Zephyr port, you will need a Zephyr supported board (for a list of acceptable
|
||||
boards see :ref:`zephyr_general`).
|
||||
|
||||
Powering up
|
||||
-----------
|
||||
|
||||
If your board has a USB connector on it then most likely it is powered
|
||||
through this when connected to your PC. Otherwise you will need to power
|
||||
it directly. Please refer to the documentation for your board for
|
||||
further details.
|
||||
|
||||
Getting and deploying the firmware
|
||||
----------------------------------
|
||||
|
||||
The first step you will need to do is either clone the `MicroPython repository <https://github.com/micropython/micropython.git>`_
|
||||
or download it from the `MicroPython downloads page <http://micropython.org/download>`_. If you are an end user of MicroPython,
|
||||
it is recommended to start with the stable firmware builds. If you would like to work on development, you may follow the daily
|
||||
builds on git.
|
||||
|
||||
Next, follow the Zephyr port readme document (``ports/zephyr/README.md``) to build and run the application on your board.
|
||||
46
docs/zephyr/tutorial/pins.rst
Normal file
46
docs/zephyr/tutorial/pins.rst
Normal file
@ -0,0 +1,46 @@
|
||||
.. _pins_zephyr:
|
||||
|
||||
GPIO Pins
|
||||
=========
|
||||
|
||||
Use :ref:`machine.Pin <machine.Pin>` to control I/O pins.
|
||||
|
||||
For Zephyr, pins are initialized using a tuple of port and pin number ``(\"GPIO_x\", pin#)``
|
||||
for the ``id`` value. For example to initialize a pin for the red LED on a FRDM-k64 board::
|
||||
|
||||
LED = Pin(("GPIO_1", 22), Pin.OUT)
|
||||
|
||||
Reference your board's datasheet or Zephyr documentation for pin numbers, see below for more examples.
|
||||
|
||||
.. list-table:: Pin Formatting
|
||||
:header-rows: 1
|
||||
|
||||
* - Board
|
||||
- Pin
|
||||
- Format
|
||||
* - frdm_k64f
|
||||
- Red LED = PTB22
|
||||
- ("GPIO_1", 22)
|
||||
* - 96b_carbon
|
||||
- LED1 = PD2
|
||||
- ("GPIOD", 2)
|
||||
* - mimxrt685_evk_cm33
|
||||
- Green LED = PIO0_14
|
||||
- ("GPIO0", 14)
|
||||
|
||||
Interrupts
|
||||
----------
|
||||
|
||||
The Zephyr port also supports interrupt handling for Pins using `machine.Pin.irq() <machine.Pin.irq>`.
|
||||
To respond to Pin change IRQs run::
|
||||
|
||||
from machine import Pin
|
||||
|
||||
SW2 = Pin(("GPIO_2", 6), Pin.IN) # create Pin object for switch 2
|
||||
SW3 = Pin(("GPIO_0", 4), Pin.IN) # create Pin object for switch 3
|
||||
|
||||
SW2.irq(lambda t: print("SW2 changed")) # print message when SW2 state is changed (triggers change IRQ)
|
||||
SW3.irq(lambda t: print("SW3 changed")) # print message when SW3 state is changed (triggers change IRQ)
|
||||
|
||||
while True: # wait
|
||||
pass
|
||||
75
docs/zephyr/tutorial/repl.rst
Normal file
75
docs/zephyr/tutorial/repl.rst
Normal file
@ -0,0 +1,75 @@
|
||||
Getting a MicroPython REPL prompt
|
||||
=================================
|
||||
|
||||
REPL stands for Read Evaluate Print Loop, and is the name given to the
|
||||
interactive MicroPython prompt that you can access on your board through
|
||||
Zephyr. It is recommended to use REPL to test out your code and run commands.
|
||||
|
||||
REPL over the serial port
|
||||
-------------------------
|
||||
|
||||
The REPL is available on a UART serial peripheral specified for the board by
|
||||
the ``zephyr,console`` devicetree node. The baudrate of the REPL is 115200.
|
||||
If your board has a USB-serial convertor on it then you should be able to access
|
||||
the REPL directly from your PC.
|
||||
|
||||
To access the prompt over USB-serial you will need to use a terminal emulator
|
||||
program. For a Linux or Mac machine, open a terminal and run::
|
||||
|
||||
screen /dev/ttyACM0 115200
|
||||
|
||||
You can also try ``picocom`` or ``minicom`` instead of screen. You may have to use
|
||||
``/dev/ttyACM1`` or a higher number for ``ttyACM``. Additional permissions
|
||||
may be necessary to access this device (eg group ``uucp`` or ``dialout``, or use sudo).
|
||||
For Windows, get a terminal software, such as puTTY and connect via a serial session
|
||||
using the proper COM port.
|
||||
|
||||
Using the REPL
|
||||
--------------
|
||||
|
||||
With your serial program open (PuTTY, screen, picocom, etc) you may see a
|
||||
blank screen with a flashing cursor. Press Enter (or reset the board) and
|
||||
you should be presented with the following text::
|
||||
|
||||
*** Booting Zephyr OS build v2.6.0-rc1-416-g3056c5ec30ad ***
|
||||
MicroPython v2.6.0-rc1-416-g3056c5ec30 on 2021-06-24; zephyr-frdm_k64f with mk64f12
|
||||
Type "help()" for more information.
|
||||
>>>
|
||||
|
||||
Now you can try running MicroPython code directly on your board.
|
||||
|
||||
Anything you type at the prompt, indicated by ``>>>``, will be executed after you press
|
||||
the Enter key. If there is an error with the text that you enter then an error
|
||||
message is printed.
|
||||
|
||||
Start by typing the following at the prompt to make sure it is working::
|
||||
|
||||
>>> print("hello world!")
|
||||
hello world!
|
||||
|
||||
If you already know some python you can now try some basic commands here. For
|
||||
example::
|
||||
|
||||
>>> 1 + 2
|
||||
3
|
||||
>>> 1 / 2
|
||||
0.5
|
||||
>>> 3 * 'Zephyr'
|
||||
ZephyrZephyrZephyr
|
||||
|
||||
If your board has an LED, you can blink it using the following code::
|
||||
|
||||
>>>import time
|
||||
>>>from machine import Pin
|
||||
|
||||
>>>LED = Pin(("GPIO_1", 21), Pin.OUT)
|
||||
>>>while True:
|
||||
... LED.value(1)
|
||||
... time.sleep(0.5)
|
||||
... LED.value(0)
|
||||
... time.sleep(0.5)
|
||||
|
||||
The above code uses an LED location for a FRDM-K64F board (port B, pin 21;
|
||||
following Zephyr conventions ports are identified by "GPIO_x", where *x*
|
||||
starts from 0). You will need to adjust it for another board using the board's
|
||||
reference materials.
|
||||
56
docs/zephyr/tutorial/storage.rst
Normal file
56
docs/zephyr/tutorial/storage.rst
Normal file
@ -0,0 +1,56 @@
|
||||
.. _storage_zephyr:
|
||||
|
||||
Filesystems and Storage
|
||||
=======================
|
||||
|
||||
Storage modules support virtual filesystem with FAT and littlefs formats, backed by either
|
||||
Zephyr DiskAccess or FlashArea (flash map) APIs depending on which the board supports.
|
||||
|
||||
See `os Filesystem Mounting <https://docs.micropython.org/en/latest/library/os.html?highlight=os#filesystem-mounting>`_.
|
||||
|
||||
Disk Access
|
||||
-----------
|
||||
|
||||
The :ref:`zephyr.DiskAccess <zephyr.DiskAccess>` class can be used to access storage devices, such as SD cards.
|
||||
This class uses `Zephyr Disk Access API <https://docs.zephyrproject.org/latest/reference/storage/disk/access.html>`_ and
|
||||
implements the `os.AbstractBlockDev` protocol.
|
||||
|
||||
For use with SD card controllers, SD cards must be present at boot & not removed; they will
|
||||
be auto detected and initialized by filesystem at boot. Use the disk driver interface and a
|
||||
file system to access SD cards via disk access (see below).
|
||||
|
||||
Example usage of FatFS with an SD card on the mimxrt1050_evk board::
|
||||
|
||||
import os
|
||||
from zephyr import DiskAccess
|
||||
bdev = zephyr.DiskAccess('SDHC') # create block device object using DiskAccess
|
||||
os.VfsFat.mkfs(bdev) # create FAT filesystem object using the disk storage block
|
||||
os.mount(bdev, '/sd') # mount the filesystem at the SD card subdirectory
|
||||
with open('/sd/hello.txt','w') as f: # open a new file in the directory
|
||||
f.write('Hello world') # write to the file
|
||||
print(open('/sd/hello.txt').read()) # print contents of the file
|
||||
|
||||
|
||||
Flash Area
|
||||
----------
|
||||
|
||||
The :ref:`zephyr.FlashArea <zephyr.FlashArea>` class can be used to implement a low-level storage system or
|
||||
customize filesystem configurations. To store persistent data on the device, using a higher-level filesystem
|
||||
API is recommended (see below).
|
||||
|
||||
This class uses `Zephyr Flash map API <https://docs.zephyrproject.org/latest/reference/storage/flash_map/flash_map.html#>`_ and
|
||||
implements the `os.AbstractBlockDev` protocol.
|
||||
|
||||
Example usage with the internal flash on the reel_board or the rv32m1_vega_ri5cy board::
|
||||
|
||||
import os
|
||||
from zephyr import FlashArea
|
||||
bdev = FlashArea(FlashArea.STORAGE, 4096) # create block device object using FlashArea
|
||||
os.VfsLfs2.mkfs(bdev) # create Little filesystem object using the flash area block
|
||||
os.mount(bdev, '/flash') # mount the filesystem at the flash storage subdirectory
|
||||
with open('/flash/hello.txt','w') as f: # open a new file in the directory
|
||||
f.write('Hello world') # write to the file
|
||||
print(open('/flash/hello.txt').read()) # print contents of the file
|
||||
|
||||
For boards such as the frdm_k64f in which the MicroPython application spills into the default flash storage
|
||||
partition, use the scratch partition by replacing ``FlashArea.STORAGE`` with the integer value 4.
|
||||
@ -28,7 +28,7 @@
|
||||
|
||||
#include "lwip/netif.h"
|
||||
#include "lwip/dhcp.h"
|
||||
#include "lib/netutils/dhcpserver.h"
|
||||
#include "shared/netutils/dhcpserver.h"
|
||||
#include "drivers/cyw43/cyw43_ll.h"
|
||||
|
||||
// For trace_flags
|
||||
|
||||
@ -27,6 +27,7 @@
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "py/mperrno.h"
|
||||
#include "py/mphal.h"
|
||||
#include "drivers/cyw43/cyw43.h"
|
||||
#include "pendsv.h"
|
||||
@ -52,6 +53,9 @@
|
||||
#define WIFI_JOIN_STATE_KEYED (0x0800)
|
||||
#define WIFI_JOIN_STATE_ALL (0x0e01)
|
||||
|
||||
#define CYW43_STA_IS_ACTIVE(self) (((self)->itf_state >> CYW43_ITF_STA) & 1)
|
||||
#define CYW43_AP_IS_ACTIVE(self) (((self)->itf_state >> CYW43_ITF_AP) & 1)
|
||||
|
||||
cyw43_t cyw43_state;
|
||||
void (*cyw43_poll)(void);
|
||||
uint32_t cyw43_sleep;
|
||||
@ -102,28 +106,25 @@ void cyw43_init(cyw43_t *self) {
|
||||
}
|
||||
|
||||
void cyw43_deinit(cyw43_t *self) {
|
||||
if (cyw43_poll == NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
CYW_ENTER
|
||||
|
||||
cyw43_ll_bus_sleep(&self->cyw43_ll, true);
|
||||
cyw43_delay_ms(2);
|
||||
// Stop the TCP/IP network interfaces.
|
||||
cyw43_tcpip_deinit(self, 0);
|
||||
cyw43_tcpip_deinit(self, 1);
|
||||
|
||||
self->itf_state = 0;
|
||||
|
||||
// Disable async polling
|
||||
// Turn off the SDIO bus.
|
||||
#if USE_SDIOIT
|
||||
sdio_enable_irq(false);
|
||||
cyw43_poll = NULL;
|
||||
|
||||
#ifdef pyb_pin_WL_RFSW_VDD
|
||||
// Turn the RF-switch off
|
||||
mp_hal_pin_low(pyb_pin_WL_RFSW_VDD);
|
||||
#endif
|
||||
|
||||
// Power down the WL chip and the SDIO bus
|
||||
mp_hal_pin_low(pyb_pin_WL_REG_ON);
|
||||
sdio_deinit();
|
||||
|
||||
// Power off the WLAN chip and make sure all state is reset.
|
||||
cyw43_init(self);
|
||||
|
||||
CYW_EXIT
|
||||
}
|
||||
|
||||
@ -478,7 +479,7 @@ void cyw43_wifi_set_up(cyw43_t *self, int itf, bool up) {
|
||||
|
||||
int cyw43_wifi_scan(cyw43_t *self, cyw43_wifi_scan_options_t *opts, void *env, int (*result_cb)(void*, const cyw43_ev_scan_result_t*)) {
|
||||
if (self->itf_state == 0) {
|
||||
return -1;
|
||||
return -MP_EPERM;
|
||||
}
|
||||
|
||||
cyw43_ensure_up(self);
|
||||
@ -521,6 +522,10 @@ int cyw43_wifi_link_status(cyw43_t *self, int itf) {
|
||||
// WiFi STA
|
||||
|
||||
int cyw43_wifi_join(cyw43_t *self, size_t ssid_len, const uint8_t *ssid, size_t key_len, const uint8_t *key, uint32_t auth_type, const uint8_t *bssid, uint32_t channel) {
|
||||
if (!CYW43_STA_IS_ACTIVE(self)) {
|
||||
return -MP_EPERM;
|
||||
}
|
||||
|
||||
int ret = cyw43_ensure_up(self);
|
||||
if (ret) {
|
||||
return ret;
|
||||
|
||||
@ -28,7 +28,7 @@
|
||||
#include <string.h>
|
||||
|
||||
#include "py/mphal.h"
|
||||
#include "lib/netutils/netutils.h"
|
||||
#include "shared/netutils/netutils.h"
|
||||
#include "lwip/etharp.h"
|
||||
#include "lwip/dns.h"
|
||||
#include "lwip/apps/mdns.h"
|
||||
|
||||
5
drivers/neopixel/manifest.py
Normal file
5
drivers/neopixel/manifest.py
Normal file
@ -0,0 +1,5 @@
|
||||
freeze(
|
||||
".",
|
||||
"neopixel.py",
|
||||
opt=3,
|
||||
)
|
||||
46
drivers/neopixel/neopixel.py
Normal file
46
drivers/neopixel/neopixel.py
Normal file
@ -0,0 +1,46 @@
|
||||
# NeoPixel driver for MicroPython
|
||||
# MIT license; Copyright (c) 2016 Damien P. George, 2021 Jim Mussared
|
||||
|
||||
from machine import bitstream
|
||||
|
||||
|
||||
class NeoPixel:
|
||||
# G R B W
|
||||
ORDER = (1, 0, 2, 3)
|
||||
|
||||
def __init__(self, pin, n, bpp=3, timing=1):
|
||||
self.pin = pin
|
||||
self.n = n
|
||||
self.bpp = bpp
|
||||
self.buf = bytearray(n * bpp)
|
||||
self.pin.init(pin.OUT)
|
||||
# Timing arg can either be 1 for 800kHz or 0 for 400kHz,
|
||||
# or a user-specified timing ns tuple (high_0, low_0, high_1, low_1).
|
||||
self.timing = (
|
||||
((400, 850, 800, 450) if timing else (800, 1700, 1600, 900))
|
||||
if isinstance(timing, int)
|
||||
else timing
|
||||
)
|
||||
|
||||
def __len__(self):
|
||||
return self.n
|
||||
|
||||
def __setitem__(self, i, v):
|
||||
offset = i * self.bpp
|
||||
for i in range(self.bpp):
|
||||
self.buf[offset + self.ORDER[i]] = v[i]
|
||||
|
||||
def __getitem__(self, i):
|
||||
offset = i * self.bpp
|
||||
return tuple(self.buf[offset + self.ORDER[i]] for i in range(self.bpp))
|
||||
|
||||
def fill(self, v):
|
||||
b = self.buf
|
||||
for i in range(self.bpp):
|
||||
c = v[i]
|
||||
for j in range(self.ORDER[i], len(self.buf), self.bpp):
|
||||
b[j] = c
|
||||
|
||||
def write(self):
|
||||
# BITSTREAM_TYPE_HIGH_LOW = 0
|
||||
bitstream(self.pin, 0, self.timing, self.buf)
|
||||
@ -82,9 +82,9 @@ endif
|
||||
endif
|
||||
|
||||
ifeq ($(MICROPY_USE_READLINE),1)
|
||||
INC += -I$(MPTOP)/lib/mp-readline
|
||||
INC += -I$(MPTOP)/shared/readline
|
||||
CFLAGS_MOD += -DMICROPY_USE_READLINE=1
|
||||
LIB_SRC_C_EXTRA += mp-readline/readline.c
|
||||
SHARED_SRC_C_EXTRA += readline/readline.c
|
||||
endif
|
||||
ifeq ($(MICROPY_USE_READLINE),2)
|
||||
CFLAGS_MOD += -DMICROPY_USE_READLINE=2
|
||||
@ -145,19 +145,19 @@ SRC_C = $(addprefix ports/unix/,\
|
||||
$(SRC_MOD) \
|
||||
)
|
||||
|
||||
LIB_SRC_C = $(addprefix lib/,\
|
||||
$(LIB_SRC_C_EXTRA) \
|
||||
utils/printf.c \
|
||||
utils/gchelper_generic.c \
|
||||
SHARED_SRC_C = $(addprefix shared/,\
|
||||
libc/printf.c \
|
||||
runtime/gchelper_generic.c \
|
||||
timeutils/timeutils.c \
|
||||
$(SHARED_SRC_C_EXTRA) \
|
||||
)
|
||||
|
||||
OBJ = $(PY_O)
|
||||
OBJ += $(addprefix $(BUILD)/, $(SRC_C:.c=.o))
|
||||
OBJ += $(addprefix $(BUILD)/, $(LIB_SRC_C:.c=.o))
|
||||
OBJ += $(addprefix $(BUILD)/, $(SHARED_SRC_C:.c=.o))
|
||||
|
||||
# List of sources for qstr extraction
|
||||
SRC_QSTR += $(SRC_C) $(LIB_SRC_C)
|
||||
SRC_QSTR += $(SRC_C) $(SHARED_SRC_C)
|
||||
# Append any auto-generated sources that are needed by sources listed in
|
||||
# SRC_QSTR
|
||||
SRC_QSTR_AUTO_DEPS +=
|
||||
|
||||
55
extmod/axtls-include/axtls_os_port.h
Normal file
55
extmod/axtls-include/axtls_os_port.h
Normal file
@ -0,0 +1,55 @@
|
||||
/*
|
||||
* This file is part of the MicroPython project, http://micropython.org/
|
||||
*
|
||||
* The MIT License (MIT)
|
||||
*
|
||||
* Copyright (c) 2021 Damien P. George
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
* THE SOFTWARE.
|
||||
*/
|
||||
#ifndef AXTLS_OS_PORT_H
|
||||
#define AXTLS_OS_PORT_H
|
||||
|
||||
#include <errno.h>
|
||||
#include "py/stream.h"
|
||||
#include "lib/crypto-algorithms/sha256.h"
|
||||
|
||||
#define SSL_CTX_MUTEX_INIT(mutex)
|
||||
#define SSL_CTX_MUTEX_DESTROY(mutex)
|
||||
#define SSL_CTX_LOCK(mutex)
|
||||
#define SSL_CTX_UNLOCK(mutex)
|
||||
|
||||
#define SOCKET_READ(s, buf, size) mp_stream_posix_read((void *)s, buf, size)
|
||||
#define SOCKET_WRITE(s, buf, size) mp_stream_posix_write((void *)s, buf, size)
|
||||
#define SOCKET_CLOSE(A) UNUSED
|
||||
#define SOCKET_ERRNO() errno
|
||||
|
||||
#define SHA256_CTX CRYAL_SHA256_CTX
|
||||
#define SHA256_Init(ctx) sha256_init(ctx)
|
||||
#define SHA256_Update(ctx, buf, size) sha256_update(ctx, buf, size)
|
||||
#define SHA256_Final(hash, ctx) sha256_final(ctx, hash)
|
||||
|
||||
#define TTY_FLUSH()
|
||||
|
||||
#ifdef WDEV_HWRNG
|
||||
// For esp8266 port: use the hardware RNG.
|
||||
#define PLATFORM_RNG_U8() (*WDEV_HWRNG)
|
||||
#endif
|
||||
|
||||
#endif // AXTLS_OS_PORT_H
|
||||
@ -67,7 +67,7 @@ endif
|
||||
LIB_SRC_C += $(SRC_BTSTACK)
|
||||
|
||||
# Suppress some warnings.
|
||||
BTSTACK_WARNING_CFLAGS = -Wno-old-style-definition -Wno-unused-variable -Wno-unused-parameter # -Wimplicit-fallthrough=0
|
||||
BTSTACK_WARNING_CFLAGS = -Wno-old-style-definition -Wno-unused-variable -Wno-unused-parameter -Wno-implicit-fallthrough
|
||||
ifneq ($(CC),clang)
|
||||
BTSTACK_WARNING_CFLAGS += -Wno-format
|
||||
endif
|
||||
|
||||
@ -1085,11 +1085,14 @@ int mp_bluetooth_gatts_read(uint16_t value_handle, uint8_t **value, size_t *valu
|
||||
return mp_bluetooth_gatts_db_read(MP_STATE_PORT(bluetooth_btstack_root_pointers)->gatts_db, value_handle, value, value_len);
|
||||
}
|
||||
|
||||
int mp_bluetooth_gatts_write(uint16_t value_handle, const uint8_t *value, size_t value_len) {
|
||||
int mp_bluetooth_gatts_write(uint16_t value_handle, const uint8_t *value, size_t value_len, bool send_update) {
|
||||
DEBUG_printf("mp_bluetooth_gatts_write\n");
|
||||
if (!mp_bluetooth_is_active()) {
|
||||
return ERRNO_BLUETOOTH_NOT_ACTIVE;
|
||||
}
|
||||
if (send_update) {
|
||||
return MP_EOPNOTSUPP;
|
||||
}
|
||||
return mp_bluetooth_gatts_db_write(MP_STATE_PORT(bluetooth_btstack_root_pointers)->gatts_db, value_handle, value, value_len);
|
||||
}
|
||||
|
||||
|
||||
@ -4,8 +4,9 @@ set(MICROPY_EXTMOD_DIR "${MICROPY_DIR}/extmod")
|
||||
set(MICROPY_OOFATFS_DIR "${MICROPY_DIR}/lib/oofatfs")
|
||||
|
||||
set(MICROPY_SOURCE_EXTMOD
|
||||
${MICROPY_DIR}/lib/embed/abort_.c
|
||||
${MICROPY_DIR}/lib/utils/printf.c
|
||||
${MICROPY_DIR}/shared/libc/abort_.c
|
||||
${MICROPY_DIR}/shared/libc/printf.c
|
||||
${MICROPY_EXTMOD_DIR}/machine_bitstream.c
|
||||
${MICROPY_EXTMOD_DIR}/machine_i2c.c
|
||||
${MICROPY_EXTMOD_DIR}/machine_mem.c
|
||||
${MICROPY_EXTMOD_DIR}/machine_pulse.c
|
||||
|
||||
@ -153,7 +153,7 @@ LWIP_DIR = lib/lwip/src
|
||||
INC += -I$(TOP)/$(LWIP_DIR)/include
|
||||
CFLAGS_MOD += -DMICROPY_PY_LWIP=1
|
||||
$(BUILD)/$(LWIP_DIR)/core/ipv4/dhcp.o: CFLAGS_MOD += -Wno-address
|
||||
SRC_MOD += extmod/modlwip.c lib/netutils/netutils.c
|
||||
SRC_MOD += extmod/modlwip.c shared/netutils/netutils.c
|
||||
SRC_MOD += $(addprefix $(LWIP_DIR)/,\
|
||||
apps/mdns/mdns.c \
|
||||
core/def.c \
|
||||
|
||||
65
extmod/machine_bitstream.c
Normal file
65
extmod/machine_bitstream.c
Normal file
@ -0,0 +1,65 @@
|
||||
/*
|
||||
* This file is part of the MicroPython project, http://micropython.org/
|
||||
*
|
||||
* The MIT License (MIT)
|
||||
*
|
||||
* Copyright (c) 2021 Jim Mussared
|
||||
* Copyright (c) 2021 Damien P. George
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
* THE SOFTWARE.
|
||||
*/
|
||||
|
||||
#include "py/runtime.h"
|
||||
#include "py/mphal.h"
|
||||
#include "extmod/machine_bitstream.h"
|
||||
|
||||
#if MICROPY_PY_MACHINE_BITSTREAM
|
||||
|
||||
// Timing is a 4-tuple of (high_time_0, low_time_0, high_time_1, low_time_1)
|
||||
// suitable for driving WS2812.
|
||||
#define MICROPY_MACHINE_BITSTREAM_TYPE_HIGH_LOW (0)
|
||||
|
||||
// machine.bitstream(pin, encoding, (timing), bytes)
|
||||
STATIC mp_obj_t machine_bitstream_(size_t n_args, const mp_obj_t *args) {
|
||||
mp_hal_pin_obj_t pin = mp_hal_get_pin_obj(args[0]);
|
||||
int encoding = mp_obj_get_int(args[1]);
|
||||
|
||||
mp_buffer_info_t bufinfo;
|
||||
mp_get_buffer_raise(args[3], &bufinfo, MP_BUFFER_READ);
|
||||
|
||||
switch (encoding) {
|
||||
case MICROPY_MACHINE_BITSTREAM_TYPE_HIGH_LOW: {
|
||||
uint32_t timing_ns[4];
|
||||
mp_obj_t *timing;
|
||||
mp_obj_get_array_fixed_n(args[2], 4, &timing);
|
||||
for (size_t i = 0; i < 4; ++i) {
|
||||
timing_ns[i] = mp_obj_get_int(timing[i]);
|
||||
}
|
||||
machine_bitstream_high_low(pin, timing_ns, bufinfo.buf, bufinfo.len);
|
||||
break;
|
||||
}
|
||||
default:
|
||||
mp_raise_ValueError(MP_ERROR_TEXT("encoding"));
|
||||
}
|
||||
|
||||
return mp_const_none;
|
||||
}
|
||||
MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(machine_bitstream_obj, 4, 4, machine_bitstream_);
|
||||
|
||||
#endif // MICROPY_PY_MACHINE_BITSTREAM
|
||||
37
extmod/machine_bitstream.h
Normal file
37
extmod/machine_bitstream.h
Normal file
@ -0,0 +1,37 @@
|
||||
/*
|
||||
* This file is part of the MicroPython project, http://micropython.org/
|
||||
*
|
||||
* The MIT License (MIT)
|
||||
*
|
||||
* Copyright (c) 2021 Jim Mussared
|
||||
* Copyright (c) 2021 Damien P. George
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
* THE SOFTWARE.
|
||||
*/
|
||||
#ifndef MICROPY_INCLUDED_EXTMOD_MACHINE_BITSTREAM_H
|
||||
#define MICROPY_INCLUDED_EXTMOD_MACHINE_BITSTREAM_H
|
||||
|
||||
#include "py/obj.h"
|
||||
#include "py/mphal.h"
|
||||
|
||||
void machine_bitstream_high_low(mp_hal_pin_obj_t pin, uint32_t *timing_ns, const uint8_t *buf, size_t len);
|
||||
|
||||
MP_DECLARE_CONST_FUN_OBJ_VAR_BETWEEN(machine_bitstream_obj);
|
||||
|
||||
#endif // MICROPY_INCLUDED_EXTMOD_MACHINE_BITSTREAM_H
|
||||
@ -717,15 +717,17 @@ STATIC mp_obj_t bluetooth_ble_gatts_read(mp_obj_t self_in, mp_obj_t value_handle
|
||||
}
|
||||
STATIC MP_DEFINE_CONST_FUN_OBJ_2(bluetooth_ble_gatts_read_obj, bluetooth_ble_gatts_read);
|
||||
|
||||
STATIC mp_obj_t bluetooth_ble_gatts_write(mp_obj_t self_in, mp_obj_t value_handle_in, mp_obj_t data) {
|
||||
(void)self_in;
|
||||
STATIC mp_obj_t bluetooth_ble_gatts_write(size_t n_args, const mp_obj_t *args) {
|
||||
mp_buffer_info_t bufinfo = {0};
|
||||
mp_get_buffer_raise(data, &bufinfo, MP_BUFFER_READ);
|
||||
int err = mp_bluetooth_gatts_write(mp_obj_get_int(value_handle_in), bufinfo.buf, bufinfo.len);
|
||||
bluetooth_handle_errno(err);
|
||||
mp_get_buffer_raise(args[2], &bufinfo, MP_BUFFER_READ);
|
||||
bool send_update = false;
|
||||
if (n_args > 3) {
|
||||
send_update = mp_obj_is_true(args[3]);
|
||||
}
|
||||
bluetooth_handle_errno(mp_bluetooth_gatts_write(mp_obj_get_int(args[1]), bufinfo.buf, bufinfo.len, send_update));
|
||||
return MP_OBJ_NEW_SMALL_INT(bufinfo.len);
|
||||
}
|
||||
STATIC MP_DEFINE_CONST_FUN_OBJ_3(bluetooth_ble_gatts_write_obj, bluetooth_ble_gatts_write);
|
||||
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(bluetooth_ble_gatts_write_obj, 3, 4, bluetooth_ble_gatts_write);
|
||||
|
||||
STATIC mp_obj_t bluetooth_ble_gatts_notify(size_t n_args, const mp_obj_t *args) {
|
||||
mp_int_t conn_handle = mp_obj_get_int(args[1]);
|
||||
@ -842,7 +844,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_2(bluetooth_ble_gattc_exchange_mtu_obj, bluetooth
|
||||
STATIC mp_obj_t bluetooth_ble_l2cap_listen(mp_obj_t self_in, mp_obj_t psm_in, mp_obj_t mtu_in) {
|
||||
(void)self_in;
|
||||
mp_int_t psm = mp_obj_get_int(psm_in);
|
||||
mp_int_t mtu = mp_obj_get_int(mtu_in);
|
||||
mp_int_t mtu = MAX(32, MIN(UINT16_MAX, mp_obj_get_int(mtu_in)));
|
||||
return bluetooth_handle_errno(mp_bluetooth_l2cap_listen(psm, mtu));
|
||||
}
|
||||
STATIC MP_DEFINE_CONST_FUN_OBJ_3(bluetooth_ble_l2cap_listen_obj, bluetooth_ble_l2cap_listen);
|
||||
@ -850,7 +852,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_3(bluetooth_ble_l2cap_listen_obj, bluetooth_ble_l
|
||||
STATIC mp_obj_t bluetooth_ble_l2cap_connect(size_t n_args, const mp_obj_t *args) {
|
||||
mp_int_t conn_handle = mp_obj_get_int(args[1]);
|
||||
mp_int_t psm = mp_obj_get_int(args[2]);
|
||||
mp_int_t mtu = mp_obj_get_int(args[3]);
|
||||
mp_int_t mtu = MAX(32, MIN(UINT16_MAX, mp_obj_get_int(args[3])));
|
||||
return bluetooth_handle_errno(mp_bluetooth_l2cap_connect(conn_handle, psm, mtu));
|
||||
}
|
||||
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(bluetooth_ble_l2cap_connect_obj, 4, 4, bluetooth_ble_l2cap_connect);
|
||||
|
||||
@ -334,8 +334,8 @@ int mp_bluetooth_gatts_register_service_end(void);
|
||||
|
||||
// Read the value from the local gatts db (likely this has been written by a central).
|
||||
int mp_bluetooth_gatts_read(uint16_t value_handle, uint8_t **value, size_t *value_len);
|
||||
// Write a value to the local gatts db (ready to be queried by a central).
|
||||
int mp_bluetooth_gatts_write(uint16_t value_handle, const uint8_t *value, size_t value_len);
|
||||
// Write a value to the local gatts db (ready to be queried by a central). Optionally send notifications/indications.
|
||||
int mp_bluetooth_gatts_write(uint16_t value_handle, const uint8_t *value, size_t value_len, bool send_update);
|
||||
// Notify the central that it should do a read.
|
||||
int mp_bluetooth_gatts_notify(uint16_t conn_handle, uint16_t value_handle);
|
||||
// Notify the central, including a data payload. (Note: does not set the gatts db value).
|
||||
|
||||
@ -491,6 +491,10 @@ STATIC mp_obj_t framebuf_blit(size_t n_args, const mp_obj_t *args) {
|
||||
if (n_args > 4) {
|
||||
key = mp_obj_get_int(args[4]);
|
||||
}
|
||||
mp_obj_framebuf_t *palette = NULL;
|
||||
if (n_args > 5 && args[5] != mp_const_none) {
|
||||
palette = MP_OBJ_TO_PTR(mp_obj_cast_to_native_base(args[5], MP_OBJ_FROM_PTR(&mp_type_framebuf)));
|
||||
}
|
||||
|
||||
if (
|
||||
(x >= self->width) ||
|
||||
@ -514,6 +518,9 @@ STATIC mp_obj_t framebuf_blit(size_t n_args, const mp_obj_t *args) {
|
||||
int cx1 = x1;
|
||||
for (int cx0 = x0; cx0 < x0end; ++cx0) {
|
||||
uint32_t col = getpixel(source, cx1, y1);
|
||||
if (palette) {
|
||||
col = getpixel(palette, col, 0);
|
||||
}
|
||||
if (col != (uint32_t)key) {
|
||||
setpixel(self, cx0, y0, col);
|
||||
}
|
||||
@ -523,7 +530,7 @@ STATIC mp_obj_t framebuf_blit(size_t n_args, const mp_obj_t *args) {
|
||||
}
|
||||
return mp_const_none;
|
||||
}
|
||||
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(framebuf_blit_obj, 4, 5, framebuf_blit);
|
||||
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(framebuf_blit_obj, 4, 6, framebuf_blit);
|
||||
|
||||
STATIC mp_obj_t framebuf_scroll(mp_obj_t self_in, mp_obj_t xstep_in, mp_obj_t ystep_in) {
|
||||
mp_obj_framebuf_t *self = MP_OBJ_TO_PTR(self_in);
|
||||
|
||||
@ -35,7 +35,7 @@
|
||||
#include "py/mperrno.h"
|
||||
#include "py/mphal.h"
|
||||
|
||||
#include "lib/netutils/netutils.h"
|
||||
#include "shared/netutils/netutils.h"
|
||||
|
||||
#include "lwip/init.h"
|
||||
#include "lwip/tcp.h"
|
||||
@ -1502,16 +1502,16 @@ STATIC mp_uint_t lwip_socket_ioctl(mp_obj_t self_in, mp_uint_t request, uintptr_
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Deregister callback (pcb.tcp is set to NULL below so must deregister now)
|
||||
tcp_arg(socket->pcb.tcp, NULL);
|
||||
tcp_err(socket->pcb.tcp, NULL);
|
||||
tcp_recv(socket->pcb.tcp, NULL);
|
||||
|
||||
// Free any incoming buffers or connections that are stored
|
||||
lwip_socket_free_incoming(socket);
|
||||
|
||||
switch (socket->type) {
|
||||
case MOD_NETWORK_SOCK_STREAM: {
|
||||
// Deregister callback (pcb.tcp is set to NULL below so must deregister now)
|
||||
tcp_arg(socket->pcb.tcp, NULL);
|
||||
tcp_err(socket->pcb.tcp, NULL);
|
||||
tcp_recv(socket->pcb.tcp, NULL);
|
||||
|
||||
if (socket->pcb.tcp->state != LISTEN) {
|
||||
// Schedule a callback to abort the connection if it's not cleanly closed after
|
||||
// the given timeout. The callback must be set before calling tcp_close since
|
||||
@ -1525,10 +1525,12 @@ STATIC mp_uint_t lwip_socket_ioctl(mp_obj_t self_in, mp_uint_t request, uintptr_
|
||||
break;
|
||||
}
|
||||
case MOD_NETWORK_SOCK_DGRAM:
|
||||
udp_recv(socket->pcb.udp, NULL, NULL);
|
||||
udp_remove(socket->pcb.udp);
|
||||
break;
|
||||
#if MICROPY_PY_LWIP_SOCK_RAW
|
||||
case MOD_NETWORK_SOCK_RAW:
|
||||
raw_recv(socket->pcb.raw, NULL, NULL);
|
||||
raw_remove(socket->pcb.raw);
|
||||
break;
|
||||
#endif
|
||||
|
||||
@ -218,7 +218,7 @@ STATIC mp_obj_t mod_binascii_b2a_base64(mp_obj_t data) {
|
||||
STATIC MP_DEFINE_CONST_FUN_OBJ_1(mod_binascii_b2a_base64_obj, mod_binascii_b2a_base64);
|
||||
|
||||
#if MICROPY_PY_UBINASCII_CRC32
|
||||
#include "uzlib/tinf.h"
|
||||
#include "lib/uzlib/tinf.h"
|
||||
|
||||
STATIC mp_obj_t mod_binascii_crc32(size_t n_args, const mp_obj_t *args) {
|
||||
mp_buffer_info_t bufinfo;
|
||||
|
||||
@ -40,7 +40,7 @@
|
||||
#if MICROPY_SSL_MBEDTLS
|
||||
#include "mbedtls/sha256.h"
|
||||
#else
|
||||
#include "crypto-algorithms/sha256.h"
|
||||
#include "lib/crypto-algorithms/sha256.h"
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@ -115,7 +115,7 @@ STATIC mp_obj_t uhashlib_sha256_digest(mp_obj_t self_in) {
|
||||
|
||||
#else
|
||||
|
||||
#include "crypto-algorithms/sha256.c"
|
||||
#include "lib/crypto-algorithms/sha256.c"
|
||||
|
||||
STATIC mp_obj_t uhashlib_sha256_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
|
||||
mp_arg_check_num(n_args, n_kw, 0, 1, false);
|
||||
|
||||
@ -34,6 +34,62 @@
|
||||
|
||||
#if MICROPY_PY_UJSON
|
||||
|
||||
#if MICROPY_PY_UJSON_SEPARATORS
|
||||
|
||||
enum {
|
||||
DUMP_MODE_TO_STRING = 1,
|
||||
DUMP_MODE_TO_STREAM = 2,
|
||||
};
|
||||
|
||||
STATIC mp_obj_t mod_ujson_dump_helper(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args, unsigned int mode) {
|
||||
enum { ARG_separators };
|
||||
static const mp_arg_t allowed_args[] = {
|
||||
{ MP_QSTR_separators, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
|
||||
};
|
||||
|
||||
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
|
||||
mp_arg_parse_all(n_args - mode, pos_args + mode, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
|
||||
|
||||
mp_print_ext_t print_ext;
|
||||
|
||||
if (args[ARG_separators].u_obj == mp_const_none) {
|
||||
print_ext.item_separator = ", ";
|
||||
print_ext.key_separator = ": ";
|
||||
} else {
|
||||
mp_obj_t *items;
|
||||
mp_obj_get_array_fixed_n(args[ARG_separators].u_obj, 2, &items);
|
||||
print_ext.item_separator = mp_obj_str_get_str(items[0]);
|
||||
print_ext.key_separator = mp_obj_str_get_str(items[1]);
|
||||
}
|
||||
|
||||
if (mode == DUMP_MODE_TO_STRING) {
|
||||
// dumps(obj)
|
||||
vstr_t vstr;
|
||||
vstr_init_print(&vstr, 8, &print_ext.base);
|
||||
mp_obj_print_helper(&print_ext.base, pos_args[0], PRINT_JSON);
|
||||
return mp_obj_new_str_from_vstr(&mp_type_str, &vstr);
|
||||
} else {
|
||||
// dump(obj, stream)
|
||||
print_ext.base.data = MP_OBJ_TO_PTR(pos_args[1]);
|
||||
print_ext.base.print_strn = mp_stream_write_adaptor;
|
||||
mp_get_stream_raise(pos_args[1], MP_STREAM_OP_WRITE);
|
||||
mp_obj_print_helper(&print_ext.base, pos_args[0], PRINT_JSON);
|
||||
return mp_const_none;
|
||||
}
|
||||
}
|
||||
|
||||
STATIC mp_obj_t mod_ujson_dump(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
|
||||
return mod_ujson_dump_helper(n_args, pos_args, kw_args, DUMP_MODE_TO_STREAM);
|
||||
}
|
||||
STATIC MP_DEFINE_CONST_FUN_OBJ_KW(mod_ujson_dump_obj, 2, mod_ujson_dump);
|
||||
|
||||
STATIC mp_obj_t mod_ujson_dumps(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
|
||||
return mod_ujson_dump_helper(n_args, pos_args, kw_args, DUMP_MODE_TO_STRING);
|
||||
}
|
||||
STATIC MP_DEFINE_CONST_FUN_OBJ_KW(mod_ujson_dumps_obj, 1, mod_ujson_dumps);
|
||||
|
||||
#else
|
||||
|
||||
STATIC mp_obj_t mod_ujson_dump(mp_obj_t obj, mp_obj_t stream) {
|
||||
mp_get_stream_raise(stream, MP_STREAM_OP_WRITE);
|
||||
mp_print_t print = {MP_OBJ_TO_PTR(stream), mp_stream_write_adaptor};
|
||||
@ -51,6 +107,8 @@ STATIC mp_obj_t mod_ujson_dumps(mp_obj_t obj) {
|
||||
}
|
||||
STATIC MP_DEFINE_CONST_FUN_OBJ_1(mod_ujson_dumps_obj, mod_ujson_dumps);
|
||||
|
||||
#endif
|
||||
|
||||
// The function below implements a simple non-recursive JSON parser.
|
||||
//
|
||||
// The JSON specification is at http://www.ietf.org/rfc/rfc4627.txt
|
||||
|
||||
@ -37,7 +37,7 @@
|
||||
|
||||
#define re1_5_stack_chk() MP_STACK_CHECK()
|
||||
|
||||
#include "re1.5/re1.5.h"
|
||||
#include "lib/re1.5/re1.5.h"
|
||||
|
||||
#define FLAG_DEBUG 0x1000
|
||||
|
||||
@ -68,7 +68,7 @@ STATIC mp_obj_t match_group(mp_obj_t self_in, mp_obj_t no_in) {
|
||||
mp_obj_match_t *self = MP_OBJ_TO_PTR(self_in);
|
||||
mp_int_t no = mp_obj_get_int(no_in);
|
||||
if (no < 0 || no >= self->num_matches) {
|
||||
nlr_raise(mp_obj_new_exception_arg1(&mp_type_IndexError, no_in));
|
||||
mp_raise_type_arg(&mp_type_IndexError, no_in);
|
||||
}
|
||||
|
||||
const char *start = self->caps[no * 2];
|
||||
@ -107,7 +107,7 @@ STATIC void match_span_helper(size_t n_args, const mp_obj_t *args, mp_obj_t span
|
||||
if (n_args == 2) {
|
||||
no = mp_obj_get_int(args[1]);
|
||||
if (no < 0 || no >= self->num_matches) {
|
||||
nlr_raise(mp_obj_new_exception_arg1(&mp_type_IndexError, args[1]));
|
||||
mp_raise_type_arg(&mp_type_IndexError, args[1]);
|
||||
}
|
||||
}
|
||||
|
||||
@ -334,7 +334,7 @@ STATIC mp_obj_t re_sub_helper(size_t n_args, const mp_obj_t *args) {
|
||||
}
|
||||
|
||||
if (match_no >= (unsigned int)match->num_matches) {
|
||||
nlr_raise(mp_obj_new_exception_arg1(&mp_type_IndexError, MP_OBJ_NEW_SMALL_INT(match_no)));
|
||||
mp_raise_type_arg(&mp_type_IndexError, MP_OBJ_NEW_SMALL_INT(match_no));
|
||||
}
|
||||
|
||||
const char *start_match = match->caps[match_no * 2];
|
||||
@ -454,11 +454,11 @@ const mp_obj_module_t mp_module_ure = {
|
||||
// only if module is enabled by config setting.
|
||||
|
||||
#define re1_5_fatal(x) assert(!x)
|
||||
#include "re1.5/compilecode.c"
|
||||
#include "lib/re1.5/compilecode.c"
|
||||
#if MICROPY_PY_URE_DEBUG
|
||||
#include "re1.5/dumpcode.c"
|
||||
#include "lib/re1.5/dumpcode.c"
|
||||
#endif
|
||||
#include "re1.5/recursiveloop.c"
|
||||
#include "re1.5/charclass.c"
|
||||
#include "lib/re1.5/recursiveloop.c"
|
||||
#include "lib/re1.5/charclass.c"
|
||||
|
||||
#endif // MICROPY_PY_URE
|
||||
|
||||
@ -107,6 +107,7 @@ STATIC mp_uint_t poll_map_poll(mp_map_t *poll_map, size_t *rwx_num) {
|
||||
return n_ready;
|
||||
}
|
||||
|
||||
#if MICROPY_PY_USELECT_SELECT
|
||||
// select(rlist, wlist, xlist[, timeout])
|
||||
STATIC mp_obj_t select_select(size_t n_args, const mp_obj_t *args) {
|
||||
// get array data from tuple/list arguments
|
||||
@ -173,6 +174,7 @@ STATIC mp_obj_t select_select(size_t n_args, const mp_obj_t *args) {
|
||||
}
|
||||
}
|
||||
MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_select_select_obj, 3, 4, select_select);
|
||||
#endif // MICROPY_PY_USELECT_SELECT
|
||||
|
||||
typedef struct _mp_obj_poll_t {
|
||||
mp_obj_base_t base;
|
||||
@ -355,7 +357,9 @@ MP_DEFINE_CONST_FUN_OBJ_0(mp_select_poll_obj, select_poll);
|
||||
|
||||
STATIC const mp_rom_map_elem_t mp_module_select_globals_table[] = {
|
||||
{ MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_uselect) },
|
||||
#if MICROPY_PY_USELECT_SELECT
|
||||
{ MP_ROM_QSTR(MP_QSTR_select), MP_ROM_PTR(&mp_select_select_obj) },
|
||||
#endif
|
||||
{ MP_ROM_QSTR(MP_QSTR_poll), MP_ROM_PTR(&mp_select_poll_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_POLLIN), MP_ROM_INT(MP_STREAM_POLL_RD) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_POLLOUT), MP_ROM_INT(MP_STREAM_POLL_WR) },
|
||||
|
||||
@ -33,7 +33,7 @@
|
||||
|
||||
#if MICROPY_PY_UZLIB
|
||||
|
||||
#include "uzlib/tinf.h"
|
||||
#include "lib/uzlib/tinf.h"
|
||||
|
||||
#if 0 // print debugging info
|
||||
#define DEBUG_printf DEBUG_printf
|
||||
@ -201,7 +201,7 @@ STATIC mp_obj_t mod_uzlib_decompress(size_t n_args, const mp_obj_t *args) {
|
||||
return res;
|
||||
|
||||
error:
|
||||
nlr_raise(mp_obj_new_exception_arg1(&mp_type_ValueError, MP_OBJ_NEW_SMALL_INT(st)));
|
||||
mp_raise_type_arg(&mp_type_ValueError, MP_OBJ_NEW_SMALL_INT(st));
|
||||
}
|
||||
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mod_uzlib_decompress_obj, 1, 3, mod_uzlib_decompress);
|
||||
|
||||
@ -223,10 +223,10 @@ const mp_obj_module_t mp_module_uzlib = {
|
||||
// Source files #include'd here to make sure they're compiled in
|
||||
// only if module is enabled by config setting.
|
||||
|
||||
#include "uzlib/tinflate.c"
|
||||
#include "uzlib/tinfzlib.c"
|
||||
#include "uzlib/tinfgzip.c"
|
||||
#include "uzlib/adler32.c"
|
||||
#include "uzlib/crc32.c"
|
||||
#include "lib/uzlib/tinflate.c"
|
||||
#include "lib/uzlib/tinfzlib.c"
|
||||
#include "lib/uzlib/tinfgzip.c"
|
||||
#include "lib/uzlib/adler32.c"
|
||||
#include "lib/uzlib/crc32.c"
|
||||
|
||||
#endif // MICROPY_PY_UZLIB
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
x
Reference in New Issue
Block a user