2020-04-17 19:23:28 -04:00
|
|
|
# Internal math library is substantially smaller than toolchain one
|
|
|
|
|
INTERNAL_LIBM = 1
|
|
|
|
|
|
|
|
|
|
# Longints can be implemented as mpz, as longlong, or not
|
|
|
|
|
LONGINT_IMPL = MPZ
|
|
|
|
|
|
2020-08-04 18:40:24 -04:00
|
|
|
# These modules are implemented in ports/<port>/common-hal:
|
2021-08-27 13:47:03 -04:00
|
|
|
CIRCUITPY_FULL_BUILD ?= 1
|
|
|
|
|
CIRCUITPY_ALARM ?= 1
|
|
|
|
|
CIRCUITPY_AUDIOCORE ?= 1
|
|
|
|
|
CIRCUITPY_AUDIOMP3 ?= 0
|
|
|
|
|
CIRCUITPY_AUDIOBUSIO ?= 1
|
|
|
|
|
CIRCUITPY_AUDIOBUSIO_PDMIN ?= 0
|
|
|
|
|
CIRCUITPY_AUDIOBUSIO_I2SOUT ?= 1
|
|
|
|
|
CIRCUITPY_AUDIOIO ?= 0
|
|
|
|
|
CIRCUITPY_AUDIOMIXER ?= 1
|
|
|
|
|
CIRCUITPY_CANIO ?= 1
|
|
|
|
|
CIRCUITPY_COUNTIO ?= 1
|
|
|
|
|
CIRCUITPY_DUALBANK ?= 1
|
|
|
|
|
CIRCUITPY_FRAMEBUFFERIO ?= 1
|
|
|
|
|
CIRCUITPY_FREQUENCYIO ?= 1
|
2022-06-29 19:31:55 -04:00
|
|
|
CIRCUITPY_HASHLIB ?= 1
|
add esp32-camera
This uses the esp32-camera code instead of our own homebrewed camera code.
In theory it supports esp32, esp32-s2 and esp32-s3, as long as they have
PSRAM.
This is very basic and doesn't support changing any camera parameters,
including switching resolution or pixelformat.
This is tested on the Kaluga (ESP32-S2) and ESP32-S3-Eye boards.
First, reserve some PSRAM by putting this line in `CIRCUITPY/_env`:
```
CIRCUITPY_RESERVED_PSRAM=524288
```
and hard-reset the board for it to take effect.
Now, the following script will take a very low-resolution jpeg file and print
it in the REPL in escape coded form:
```python
import board
import esp32_camera
c = esp32_camera.Camera(
data_pins=board.CAMERA_DATA,
external_clock_pin=board.CAMERA_XCLK,
pixel_clock_pin=board.CAMERA_PCLK,
vsync_pin=board.CAMERA_VSYNC,
href_pin=board.CAMERA_HREF,
pixel_format=esp32_camera.PixelFormat.JPEG,
i2c=board.I2C(),
external_clock_frequency=20_000_000)
m = c.take()
if m is not None:
print(bytes(m))
```
Then on desktop open a python repl and run something like
```python
>>> with open("my.jpg", "wb") as f: f.write(<BIG PASTE FROM REPL>)
```
and open my.jpg in a viewer.
2022-08-04 16:11:50 -04:00
|
|
|
CIRCUITPY_IMAGECAPTURE ?= 0
|
2022-08-09 13:06:18 -04:00
|
|
|
CIRCUITPY_I2CTARGET ?= 1
|
2021-12-29 23:30:01 -05:00
|
|
|
CIRCUITPY_RGBMATRIX ?= 1
|
2021-08-27 13:47:03 -04:00
|
|
|
CIRCUITPY_ROTARYIO ?= 1
|
|
|
|
|
CIRCUITPY_NVM ?= 1
|
2021-02-11 18:50:02 -05:00
|
|
|
CIRCUITPY_PS2IO ?= 1
|
|
|
|
|
CIRCUITPY_TOUCHIO_USE_NATIVE ?= 1
|
2021-08-03 14:39:57 -04:00
|
|
|
CIRCUITPY_WIFI ?= 1
|
2020-11-10 06:02:46 -05:00
|
|
|
CIRCUITPY_WATCHDOG ?= 1
|
2020-11-18 02:04:56 -05:00
|
|
|
|
2021-08-27 13:47:03 -04:00
|
|
|
CIRCUITPY_ESPIDF ?= 1
|
2020-10-22 12:02:44 -04:00
|
|
|
|
2022-06-23 15:59:06 -04:00
|
|
|
ifeq ($(IDF_TARGET),esp32)
|
|
|
|
|
CIRCUITPY_BLEIO = 0
|
|
|
|
|
CIRCUITPY_BLEIO_HCI = 0
|
2022-06-26 17:45:35 -04:00
|
|
|
CIRCUITPY_PARALLELDISPLAY = 0
|
|
|
|
|
# Protomatter needs to support ESP32.
|
|
|
|
|
CIRCUITPY_RGBMATRIX = 0
|
2022-06-23 15:59:06 -04:00
|
|
|
CIRCUITPY_USB = 0
|
2022-07-19 17:35:51 -04:00
|
|
|
CIRCUITPY_BUILD_EXTENSIONS ?= bin
|
add esp32-camera
This uses the esp32-camera code instead of our own homebrewed camera code.
In theory it supports esp32, esp32-s2 and esp32-s3, as long as they have
PSRAM.
This is very basic and doesn't support changing any camera parameters,
including switching resolution or pixelformat.
This is tested on the Kaluga (ESP32-S2) and ESP32-S3-Eye boards.
First, reserve some PSRAM by putting this line in `CIRCUITPY/_env`:
```
CIRCUITPY_RESERVED_PSRAM=524288
```
and hard-reset the board for it to take effect.
Now, the following script will take a very low-resolution jpeg file and print
it in the REPL in escape coded form:
```python
import board
import esp32_camera
c = esp32_camera.Camera(
data_pins=board.CAMERA_DATA,
external_clock_pin=board.CAMERA_XCLK,
pixel_clock_pin=board.CAMERA_PCLK,
vsync_pin=board.CAMERA_VSYNC,
href_pin=board.CAMERA_HREF,
pixel_format=esp32_camera.PixelFormat.JPEG,
i2c=board.I2C(),
external_clock_frequency=20_000_000)
m = c.take()
if m is not None:
print(bytes(m))
```
Then on desktop open a python repl and run something like
```python
>>> with open("my.jpg", "wb") as f: f.write(<BIG PASTE FROM REPL>)
```
and open my.jpg in a viewer.
2022-08-04 16:11:50 -04:00
|
|
|
CIRCUITPY_ESP32_CAMERA ?= 1
|
2022-06-23 15:59:06 -04:00
|
|
|
|
|
|
|
|
else ifeq ($(IDF_TARGET),esp32c3)
|
2022-03-22 13:46:57 -04:00
|
|
|
CIRCUITPY_AESIO = 0
|
2021-09-25 14:30:00 -04:00
|
|
|
CIRCUITPY_ALARM = 0
|
2022-03-18 15:05:54 -04:00
|
|
|
CIRCUITPY_AUDIOBUSIO = 0
|
2022-01-18 18:09:33 -05:00
|
|
|
CIRCUITPY_BLEIO = 1
|
|
|
|
|
CIRCUITPY_BLEIO_HCI = 0
|
2021-09-25 14:30:00 -04:00
|
|
|
CIRCUITPY_COUNTIO = 0
|
2022-03-22 13:46:57 -04:00
|
|
|
CIRCUITPY_DUALBANK = 0
|
2021-09-25 14:30:00 -04:00
|
|
|
CIRCUITPY_FREQUENCYIO = 0
|
|
|
|
|
CIRCUITPY_PARALLELDISPLAY = 0
|
2022-03-22 13:46:57 -04:00
|
|
|
CIRCUITPY_PS2IO = 0
|
2022-03-18 15:05:54 -04:00
|
|
|
CIRCUITPY_ROTARYIO = 0
|
2021-09-25 14:30:00 -04:00
|
|
|
CIRCUITPY_TOUCHIO ?= 1
|
|
|
|
|
CIRCUITPY_TOUCHIO_USE_NATIVE = 0
|
2022-03-18 15:05:54 -04:00
|
|
|
CIRCUITPY_USB = 0
|
2022-07-19 17:35:51 -04:00
|
|
|
CIRCUITPY_BUILD_EXTENSIONS ?= bin
|
2022-06-23 15:59:06 -04:00
|
|
|
|
2021-11-23 13:30:00 -05:00
|
|
|
else ifeq ($(IDF_TARGET),esp32s3)
|
2022-01-18 18:09:33 -05:00
|
|
|
CIRCUITPY_BLEIO = 1
|
|
|
|
|
CIRCUITPY_BLEIO_HCI = 0
|
2021-11-23 13:30:00 -05:00
|
|
|
CIRCUITPY_PARALLELDISPLAY = 0
|
2022-07-20 21:52:15 -04:00
|
|
|
CIRCUITPY_BUILD_EXTENSIONS ?= bin,uf2
|
add esp32-camera
This uses the esp32-camera code instead of our own homebrewed camera code.
In theory it supports esp32, esp32-s2 and esp32-s3, as long as they have
PSRAM.
This is very basic and doesn't support changing any camera parameters,
including switching resolution or pixelformat.
This is tested on the Kaluga (ESP32-S2) and ESP32-S3-Eye boards.
First, reserve some PSRAM by putting this line in `CIRCUITPY/_env`:
```
CIRCUITPY_RESERVED_PSRAM=524288
```
and hard-reset the board for it to take effect.
Now, the following script will take a very low-resolution jpeg file and print
it in the REPL in escape coded form:
```python
import board
import esp32_camera
c = esp32_camera.Camera(
data_pins=board.CAMERA_DATA,
external_clock_pin=board.CAMERA_XCLK,
pixel_clock_pin=board.CAMERA_PCLK,
vsync_pin=board.CAMERA_VSYNC,
href_pin=board.CAMERA_HREF,
pixel_format=esp32_camera.PixelFormat.JPEG,
i2c=board.I2C(),
external_clock_frequency=20_000_000)
m = c.take()
if m is not None:
print(bytes(m))
```
Then on desktop open a python repl and run something like
```python
>>> with open("my.jpg", "wb") as f: f.write(<BIG PASTE FROM REPL>)
```
and open my.jpg in a viewer.
2022-08-04 16:11:50 -04:00
|
|
|
CIRCUITPY_ESP32_CAMERA ?= 1
|
2022-06-23 15:59:06 -04:00
|
|
|
|
2022-01-26 12:46:29 -05:00
|
|
|
else ifeq ($(IDF_TARGET),esp32s2)
|
|
|
|
|
# No BLE on S2
|
|
|
|
|
CIRCUITPY_BLEIO = 0
|
|
|
|
|
CIRCUITPY_BLEIO_HCI = 0
|
2022-07-19 17:35:51 -04:00
|
|
|
CIRCUITPY_BUILD_EXTENSIONS ?= bin,uf2
|
add esp32-camera
This uses the esp32-camera code instead of our own homebrewed camera code.
In theory it supports esp32, esp32-s2 and esp32-s3, as long as they have
PSRAM.
This is very basic and doesn't support changing any camera parameters,
including switching resolution or pixelformat.
This is tested on the Kaluga (ESP32-S2) and ESP32-S3-Eye boards.
First, reserve some PSRAM by putting this line in `CIRCUITPY/_env`:
```
CIRCUITPY_RESERVED_PSRAM=524288
```
and hard-reset the board for it to take effect.
Now, the following script will take a very low-resolution jpeg file and print
it in the REPL in escape coded form:
```python
import board
import esp32_camera
c = esp32_camera.Camera(
data_pins=board.CAMERA_DATA,
external_clock_pin=board.CAMERA_XCLK,
pixel_clock_pin=board.CAMERA_PCLK,
vsync_pin=board.CAMERA_VSYNC,
href_pin=board.CAMERA_HREF,
pixel_format=esp32_camera.PixelFormat.JPEG,
i2c=board.I2C(),
external_clock_frequency=20_000_000)
m = c.take()
if m is not None:
print(bytes(m))
```
Then on desktop open a python repl and run something like
```python
>>> with open("my.jpg", "wb") as f: f.write(<BIG PASTE FROM REPL>)
```
and open my.jpg in a viewer.
2022-08-04 16:11:50 -04:00
|
|
|
CIRCUITPY_ESP32_CAMERA ?= 1
|
2022-07-20 21:52:15 -04:00
|
|
|
endif
|
2022-05-13 05:38:03 -04:00
|
|
|
|
2021-11-23 13:30:00 -05:00
|
|
|
# From ESP32-S2/S3 Technical Reference Manual:
|
2021-05-13 21:49:04 -04:00
|
|
|
#
|
|
|
|
|
# Endpoint number 0 always present (bi-directional, consisting of EP0 IN and EP0 OUT)
|
|
|
|
|
# Six additional endpoints (endpoint numbers 1 to 6), configurable as IN or OUT
|
|
|
|
|
# Maximum of five IN endpoints concurrently active at any time (including EP0 IN)
|
|
|
|
|
#
|
|
|
|
|
# Due to the limited number of endpoints, some USB devices will be off by default.
|
|
|
|
|
# For instance MIDI is available, but the device is turned off. It can be turned on
|
|
|
|
|
# only if something else is turned off, such as HID.
|
|
|
|
|
USB_NUM_ENDPOINT_PAIRS = 7
|
|
|
|
|
USB_NUM_IN_ENDPOINTS = 5
|
add esp32-camera
This uses the esp32-camera code instead of our own homebrewed camera code.
In theory it supports esp32, esp32-s2 and esp32-s3, as long as they have
PSRAM.
This is very basic and doesn't support changing any camera parameters,
including switching resolution or pixelformat.
This is tested on the Kaluga (ESP32-S2) and ESP32-S3-Eye boards.
First, reserve some PSRAM by putting this line in `CIRCUITPY/_env`:
```
CIRCUITPY_RESERVED_PSRAM=524288
```
and hard-reset the board for it to take effect.
Now, the following script will take a very low-resolution jpeg file and print
it in the REPL in escape coded form:
```python
import board
import esp32_camera
c = esp32_camera.Camera(
data_pins=board.CAMERA_DATA,
external_clock_pin=board.CAMERA_XCLK,
pixel_clock_pin=board.CAMERA_PCLK,
vsync_pin=board.CAMERA_VSYNC,
href_pin=board.CAMERA_HREF,
pixel_format=esp32_camera.PixelFormat.JPEG,
i2c=board.I2C(),
external_clock_frequency=20_000_000)
m = c.take()
if m is not None:
print(bytes(m))
```
Then on desktop open a python repl and run something like
```python
>>> with open("my.jpg", "wb") as f: f.write(<BIG PASTE FROM REPL>)
```
and open my.jpg in a viewer.
2022-08-04 16:11:50 -04:00
|
|
|
|
|
|
|
|
CIRCUITPY_ESP32_CAMERA ?= 0
|
2022-08-04 16:11:59 -04:00
|
|
|
CIRCUITPY_GIFIO ?= $(CIRCUITPY_ESP32_CAMERA)
|
|
|
|
|
CIRCUITPY_QRIO ?= $(CIRCUITPY_ESP32_CAMERA)
|
