micropython/micropython
Micropython
MicroPython is a lean implementation of Python 3 optimized to run on microcontrollers and other resource-constrained systems. It serves as a cross-platform embedded runtime and hardware abstraction layer, providing a firmware framework that maps high-level software commands to specific microcontroller registers across diverse processor architectures.
The project functions as an embedded language interpreter that enables rapid prototyping on hardware through an interactive read-eval-print loop. It supports a wide range of target environments, including ARM, ESP32, STM32, RISC-V, and WebAssembly.
The runtime covers comprehensive hardware integration for GPIO pin management, analog signal processing, and serial protocol communication. It includes capabilities for networking via WiFi, Ethernet, and Bluetooth Low Energy, as well as data persistence through a virtual filesystem. The system also provides tools for asynchronous logic, bytecode compilation, and the integration of native C modules for low-level hardware access.
The environment can be deployed via firmware flashing or remote over-the-air updates, with support for embedding application code directly into the binary.
Features
- Cross-Platform Execution - Provides a lean Python 3 implementation that executes across diverse architectures including ARM, ESP32, STM32, RISC-V, and WebAssembly.
- Microcontroller Runtimes - Is a lean implementation of Python 3 optimized specifically for microcontrollers and resource-constrained systems.
- Native Hardware Modules - Supports the integration of custom C modules to provide low-level hardware access and performance.
- Read-Eval-Print Loops - Includes an interactive read-eval-print loop for real-time code execution and testing via serial interfaces.
- Resource-Constrained Runtimes - Provides a runtime optimized for minimal memory footprints and deterministic usage on constrained hardware.
- Virtual File Systems - Abstracts internal flash and external SD cards into a unified virtual filesystem for script storage.
- Analog-to-Digital Converters - Converts analog voltage levels from hardware pins into digital values for software processing.
- Board Configuration Profiles - Provides configuration profiles to map software drivers and SDK settings to specific microcontroller board layouts.
- Embedded Serial Protocols - Supports data exchange using I2C, SPI, and PWM protocols to interface with external peripherals.
- GPIO Pin Controllers - Controls general purpose input and output pins using interrupt requests to trigger actions.
- Microcontroller Firmware Frameworks - Offers a complete firmware framework integrating hardware drivers and a virtual filesystem for script storage.
- Peripheral Hardware Controllers - Provides APIs to manage physical pins and analog converters for pulse-width modulation and serial communication.
- Bare-Metal Runtimes - Implements a runtime for ARM-based microcontrollers that operates without external dependencies.
- Hardware Abstraction Layers - Implements a hardware abstraction layer to map high-level commands to microcontroller registers across architectures.
- Embedded Filesystem Abstractions - Implements a virtual filesystem for storing and retrieving Python scripts and data from internal flash or SD cards.
- Embedded Language Interpreters - Provides an interactive interpreter for rapid prototyping and direct peripheral control on hardware.
- Native C Interoperability - Provides interfaces for linking and calling native C libraries to achieve high-performance hardware access.
- Bytecode Interpreters - Utilizes a bytecode interpreter to execute compact binary formats, reducing memory overhead on microcontrollers.
- Firmware Bytecode Embedding - Allows embedding modules and applications directly into the firmware binary for automatic execution on boot.
- Firmware Build Variants - Allows the creation of minimal or full-featured firmware variants by toggling optional features.
- Remote Diagnostic Consoles - Allows connection to the device prompt over a network via Telnet or through a physical serial UART.
- Firmware Deployment Tools - Provides tools for flashing the runtime environment onto devices via USB mass storage or flashing interfaces.
- Microcontroller Development Platforms - Provides a full execution environment for the STM32 microcontroller series across various boards.
- Remote Firmware Updaters - Enables remote system updates by uploading binaries via FTP and resetting the device.
- USB Serial Interfaces - Provides support for connecting to devices for data communication and mass storage via USB interfaces.
- Programmable IO Interfaces - Implements custom hardware communication protocols using programmable IO and inline assembly.
- Bluetooth Connectivity - Provides a programmatic interface for short-range wireless data exchange via Bluetooth Low Energy.
- Socket Networking - Implements IPv4 and IPv6 socket connections for low-level network communication.
- Wireless Networking Tools - Provides utilities for configuring and managing WiFi connections and hardware antennas on embedded devices.
- Inline Assembly Interfaces - Enables the execution of low-level assembly instructions directly within the language for precise hardware control.
- Async-Await Flow Control - Implements async and await keywords to manage non-blocking cooperative multitasking on embedded systems.
- Binary Asset Embedding - Bakes precompiled bytecode directly into the firmware binary for execution without requiring a filesystem.
- Build-Time Bytecode Compilation - Ships a utility to transform scripts into architecture-optimized bytecode files for target runtimes.
- Bytecode - Executes pre-compiled bytecode to reduce storage requirements and bypass on-device compilation.
- Global Interpreter Locks - Employs a global interpreter lock to ensure thread safety during concurrent bytecode execution.
- Multi-threaded Execution - Executes multiple threads of execution using a global interpreter lock and native OS tasks.
- External Library Integrations - Enables the incorporation of third-party C libraries and SDKs for high-performance hardware functionality.
- Parallel Execution Strategies - Supports distributing workloads across multiple processor cores to increase execution performance.
- WebAssembly - Provides a runtime for WebAssembly allowing execution within JavaScript environments for server and browser use.
- Power Optimization Utilities - Supports reducing energy usage and extending battery life through low power modes on constrained devices.
- Embedded Programming Languages - Python 3 implementation for microcontroller hardware.
- Firmware - Python 3 implementation for ESP8266 and ESP32.
- Language Implementations - Lean and efficient Python implementation for microcontrollers.
- Language Runtimes - Lean Python implementation for constrained systems.
- Shells and Interfaces - Official shell for mounting host directories.
- Virtual Machines - Python 3.x implementation optimized for microcontrollers.
