61bbd78eba
These classes are based on the Quadrature Encoder blocks of the i.MXRT MCUs. The i.MXRT 102x has two encoders, the other ones four. The i.MXRT 101x does not support this function. It is implemented as two classes, Encoder and Counter. The number of pins that can be uses as inputs is limited by the MCU architecture and the board schematics. The Encoder class supports: - Defining the module. - Defining the input pins. - Defining a pin for an index signal. - Defining a pin for a reset signal. - Defining an output pin showing the compare match signal. - Setting the number of cycles per revolution (min/max). - Setting the initial value for the position. - Setting the counting direction. - Setting a glitch filter. - Defining callbacks for getting to a specific position, overrun and underrun (starting the next revolution). These callbacks can be hard interrupts to ensure short latency. The encoder counts all phases of a cycle. The span for the position is 2**32, for the revolution is 2**16. The highest input frequency is CPU-Clock/24. Note that the "phases" argument is emulated at the API level (the hardware will always count all phases). The Counter mode counts single pulses on input A of the Encoder. The configuration supports: - Defining the module. - Defining the input pin. - Defining the counting direction, either fixed or controlled by the level of an input pin. - Defining a pin for an index signal. - Defining an output pin showing the compare match signal. - Setting the counter value. - Setting the glitch filter. - Defining a callback which is called at a certain value. - Settings for MIMXRT1015. The MIMXRT1015 MCU has only one encoder/counter unit. The counting range is 0 - 2**32-1 and a 16 bit overrun counter. The highest input frequency is CPU-Clock/12. The implementation of the `.irq()` method uses the common code from `shared/runtime/mpirq.c`, including the `irq().flags()` and `irq().trigger()` methods. Signed-off-by: robert-hh <robert@hammelrath.com>
The MicroPython project
This is the MicroPython project, which aims to put an implementation of Python 3.x on microcontrollers and small embedded systems. You can find the official website at micropython.org.
WARNING: this project is in beta stage and is subject to changes of the code-base, including project-wide name changes and API changes.
MicroPython implements the entire Python 3.4 syntax (including exceptions,
with, yield from, etc., and additionally async/await keywords from
Python 3.5 and some select features from later versions). The following core
datatypes are provided: str(including basic Unicode support), bytes,
bytearray, tuple, list, dict, set, frozenset, array.array,
collections.namedtuple, classes and instances. Builtin modules include
os, sys, time, re, and struct, etc. Some ports have support for
_thread module (multithreading), socket and ssl for networking, and
asyncio. Note that only a subset of Python 3 functionality is implemented
for the data types and modules.
MicroPython can execute scripts in textual source form (.py files) or from precompiled bytecode (.mpy files), in both cases either from an on-device filesystem or "frozen" into the MicroPython executable.
MicroPython also provides a set of MicroPython-specific modules to access hardware-specific functionality and peripherals such as GPIO, Timers, ADC, DAC, PWM, SPI, I2C, CAN, Bluetooth, and USB.
Getting started
See the online documentation for the API reference and information about using MicroPython and information about how it is implemented.
We use GitHub Discussions as our forum, and Discord for chat. These are great places to ask questions and advice from the community or to discuss your MicroPython-based projects.
For bugs and feature requests, please raise an issue and follow the templates there.
For information about the MicroPython pyboard, the officially supported board from the original Kickstarter campaign, see the schematics and pinouts and documentation.
Contributing
MicroPython is an open-source project and welcomes contributions. To be productive, please be sure to follow the Contributors' Guidelines and the Code Conventions. Note that MicroPython is licenced under the MIT license, and all contributions should follow this license.
About this repository
This repository contains the following components:
- py/ -- the core Python implementation, including compiler, runtime, and core library.
- mpy-cross/ -- the MicroPython cross-compiler which is used to turn scripts into precompiled bytecode.
- ports/ -- platform-specific code for the various ports and architectures that MicroPython runs on.
- lib/ -- submodules for external dependencies.
- tests/ -- test framework and test scripts.
- docs/ -- user documentation in Sphinx reStructuredText format. This is used to generate the online documentation.
- extmod/ -- additional (non-core) modules implemented in C.
- tools/ -- various tools, including the pyboard.py module.
- examples/ -- a few example Python scripts.
"make" is used to build the components, or "gmake" on BSD-based systems.
You will also need bash, gcc, and Python 3.3+ available as the command python3.
Some ports (rp2 and esp32) additionally use CMake.
Supported platforms & architectures
MicroPython runs on a wide range of microcontrollers, as well as on Unix-like (including Linux, BSD, macOS, WSL) and Windows systems.
Microcontroller targets can be as small as 256kiB flash + 16kiB RAM, although devices with at least 512kiB flash + 128kiB RAM allow a much more full-featured experience.
The Unix and Windows ports allow both development and testing of MicroPython itself, as well as providing lightweight alternative to CPython on these platforms (in particular on embedded Linux systems).
Over twenty different MicroPython ports are provided in this repository, split across three MicroPython Support Tiers.
Tier 1 Ports
👑 Ports in Tier 1 are mature and have the most active development, support and testing:
| Port | Target | Quick Reference |
|---|---|---|
| esp32* | Espressif ESP32 SoCs (ESP32, ESP32S2, ESP32S3, ESP32C3, ESP32C6) | here |
| mimxrt | NXP m.iMX RT | here |
| rp2 | Raspberry Pi RP2040 and RP2350 | here |
| samd | Microchip (formerly Atmel) SAMD21 and SAMD51 | here |
| stm32 | STMicroelectronics STM32 MCUs (F0, F4, F7, G0, G4, H5, H7, L0, L1, L4, N6, WB, WL) | here |
| unix | Linux, BSD, macOS, WSL | here |
| windows | Microsoft Windows | here |
An asterisk indicates that the port has ongoing financial support from the vendor.
Tier 2 Ports
✔ Ports in Tier 2 are less mature and less actively developed and tested than Tier 1, but still fully supported:
| Port | Target | Quick Reference |
|---|---|---|
| alif | Alif Semiconductor Ensemble MCUs (E3, E7) | |
| embed | Generates a set of .c/.h files for embedding into a project | |
| nrf | Nordic Semiconductor nRF51 and nRF52 | |
| renesas-ra | Renesas RA family | here |
| webassembly | Emscripten port targeting browsers and NodeJS | |
| zephyr | Zephyr RTOS | here |
Tier 3 Ports
Ports in Tier 3 are built in CI but not regularly tested by the MicroPython maintainers:
| Port | Target | Quick Reference |
|---|---|---|
| cc3200 | Texas Instruments CC3200 | For WiPy |
| esp8266 | Espressif ESP8266 SoC | here |
| pic16bit | Microchip PIC 16-bit | |
| powerpc | IBM PowerPC (including Microwatt) |
Additional Ports
In addition to the above there is a Tier M containing ports that are used primarily for maintenance, development and testing:
-
The "bare-arm" port is an example of the absolute minimum configuration that still includes the compiler, and is used to keep track of the code size of the core runtime and VM.
-
The "minimal" port provides an example of a very basic MicroPython port and can be compiled as both a standalone Linux binary as well as for ARM Cortex-M4. Start with this if you want to port MicroPython to another microcontroller.
-
The qemu port is a QEMU-based emulated target for Cortex-A, Cortex-M, RISC-V 32-bit and RISC-V 64-bit architectures.
The MicroPython cross-compiler, mpy-cross
Most ports require the MicroPython cross-compiler to be built first. This program, called mpy-cross, is used to pre-compile Python scripts to .mpy files which can then be included (frozen) into the firmware/executable for a port. To build mpy-cross use:
$ cd mpy-cross
$ make
External dependencies
The core MicroPython VM and runtime has no external dependencies, but a given port might depend on third-party drivers or vendor HALs. This repository includes several submodules linking to these external dependencies. Before compiling a given port, use
$ cd ports/name
$ make submodules
to ensure that all required submodules are initialised.