b15348415e
Currently the `FrameBuffer.blit(buf, x, y)` method requires the `buf`
argument to be another `FrameBuffer`, which is quite restrictive because it
doesn't allow blit'ing read-only memory/data.
This commit extends `blit()` to allow the `buf` argument to be a tuple or
list of the form:
(buffer, width, height, format[, stride])
where `buffer` can be anything with the buffer protocol and may be
read-only, eg `bytes`.
Also, the palette argument to `blit()` may be of the same form.
The form of this tuple/list was chosen to be the same as the signature of
the `FrameBuffer` constructor (that saves quite a bit of code size doing it
that way).
Signed-off-by: Damien George <damien@micropython.org>
Dynamic Native Modules
Dynamic Native Modules are .mpy files that contain native machine code from a language other than Python. For more info see the documentation.
This should not be confused with User C Modules which are a mechanism to add additional out-of-tree modules into the firmware build.
Examples
This directory contains several examples of writing dynamic native modules, in two main categories:
-
Feature examples.
-
features0- A module containing a single "factorial" function which demonstrates working with integers. -
features1- A module that demonstrates some common tasks:- defining simple functions exposed to Python
- defining local, helper C functions
- defining constant integers and strings exposed to Python
- getting and creating integer objects
- creating Python lists
- raising exceptions
- allocating memory
- BSS and constant data (rodata)
- relocated pointers in rodata
-
features2- This is a hybrid module containing both Python and C code, and additionally the C code is spread over multiple files. It also demonstrates using floating point (only when the target supports hardware floating point). -
features3- A module that shows how to use types, constant objects, and creating dictionary instances. -
features4- A module that demonstrates how to define a class.
-
-
Dynamic version of existing built-ins.
This provides a way to add missing functionality to firmware that doesn't include certain built-in modules. See the
heapq,random,re,deflate,btree, andframebufdirectories.So for example, if your firmware was compiled with
MICROPY_PY_FRAMEBUFdisabled (e.g. to save flash space), then it would not include theframebufmodule. Theframebufnative module provides a way to add theframebufmodule dynamically.The way these work is they define a dynamic native module which
#include's the original module and then does the necessary initialisation of the module's globals dict.
Build instructions
To compile an example, you need to have the same toolchain available as
required for your target port. e.g. arm-none-eabi-gcc for any ARM Cortex M
target. See the port instructions for details.
You also need to have the pyelftools Python package available, either via
your system package manager or installed from PyPI in a virtual environment
with pip.
Each example provides a Makefile. You should specify the ARCH argument to
make (one of x86, x64, armv6m, armv7m, xtensa, xtensawin, rv32imc):
$ cd features0
$ make ARCH=armv7m
$ mpremote cp features0.mpy :