uploaded 2 days ago
Board Support Package (BSP) for M5Stack CoreS3 with no graphical library
readme
> :warning: This is **No Graphical Library version** of m5stack_core_s3 BSP. If you want to use this BSP with LVGL use [m5stack_core_s3](https://components.espressif.com/components/espressif/m5stack_core_s3) component. # BSP: M5Stack CoreS3 | [HW Reference](https://docs.m5stack.com/en/core/CoreS3) | [HOW TO USE API](API.md) | [EXAMPLES](#compatible-bsp-examples) | [](https://components.espressif.com/components/espressif/m5stack_core_s3) |  | | --- | --- | --- | --- | -- | > [!WARNING] > The SD card is not working simultaneously with the LCD screen. We are working on a fix. ## Overview <table> <tr><td> CoreS3 is the third generation of the M5Stack Core series. Powered by the ESP32-S3 solution, this kit features a dual-core Xtensa LX7 processor running at 240MHz. CoreS3 comes equipped with built-in Wi-Fi functionality, enabling seamless connectivity. It boasts 16MB of onboard flash memory and 8MB of PSRAM, providing ample space for program storage. CoreS3 offers convenient programming options through its TYPE-C interface, supporting OTG and CDC functions. This allows for easy connection with external USB devices and hassle-free firmware flashing. CoreS3 features a 2.0-inch capacitive touch IPS screen, protected by high-strength glass material. Additionally, a 0.3 megapixel camera GC0308 is integrated at the bottom of the screen, accompanied by a proximity sensor LTR-553ALS-WA for enhanced functionality. Power management is handled by the AXP2101 power management core chip, employing a 4-way power flow control loop for efficient power distribution. The overall design emphasizes low power consumption. CoreS3 also features a 6-axis attitude sensor BMI270 and a magnetometer BMM150 for precise motion detection. With the onboard TF-card (microSD) card slot and BM8563 RTC chip, accurate timing and sleep-timer wake-up functions are readily available. </td><td width="200" valign="top"> <img src="doc/m5stack_core_s3.webp"> </td></tr> <tr><td colspan="2"> Sound output on CoreS3 is optimized with the high-fidelity 16-bit I2S power amplifier chip AW88298, accompanied by a built-in 1W speaker for clear audio playback. For sound input, the kit incorporates the ES7210 audio decoding chip and dual-microphone input. The side of the device includes an independent power button and restart (RST) button, complemented by a self-built delay circuit. By long-pressing the reset button, users can easily enter the program download mode. The CoreS3 kit comes with the DinBase Base, providing convenient options for Din rail, wall, and screw fixing. It can be powered by an external DC 12V (supports 9~24V) or an internal 500mAh lithium battery. The DinBase also offers multiple proto locations for users to customize and expand their projects. CoreS3 is an ideal choice for IoT development, various DIY project development, smart home control systems, and industrial automation control systems. </td></tr> </table>  ## Capabilities and dependencies <div align="center"> <!-- START_DEPENDENCIES --> | Available | Capability |Controller/Codec| Component | Version | |------------------|------------------------|----------------|------------------------------------------------------------------------------------------------------------|------------| |:heavy_check_mark:| :pager: DISPLAY | ili9341 | [espressif/esp_lcd_ili9341](https://components.espressif.com/components/espressif/esp_lcd_ili9341)<br/>idf |^1<br/>>=5.4| |:heavy_check_mark:|:black_circle: LVGL_PORT| | | | |:heavy_check_mark:| :point_up: TOUCH | ft5x06 |[espressif/esp_lcd_touch_ft5x06](https://components.espressif.com/components/espressif/esp_lcd_touch_ft5x06)| ^1 | | :x: | :radio_button: BUTTONS | | | | |:heavy_check_mark:| :musical_note: AUDIO | | [espressif/esp_codec_dev](https://components.espressif.com/components/espressif/esp_codec_dev) | ~1.3.1 | |:heavy_check_mark:| :speaker: AUDIO_SPEAKER| aw88298 | | | |:heavy_check_mark:| :microphone: AUDIO_MIC | es7210 | | | |:heavy_check_mark:| :floppy_disk: SDCARD | | idf | >=5.4 | | :x: | :video_game: IMU | | | | |:heavy_check_mark:| :camera: CAMERA | | [espressif/esp32-camera](https://components.espressif.com/components/espressif/esp32-camera) | ^2.0.11 | <!-- END_DEPENDENCIES --> </div> ## Compatible BSP Examples <div align="center"> <!-- START_EXAMPLES --> | Example | Description | Try with ESP Launchpad | | ------- | ----------- | ---------------------- | | [Display Example](https://github.com/espressif/esp-bsp/tree/master/examples/display) | Show an image on the screen with a simple startup animation (LVGL) | [Flash Example](https://espressif.github.io/esp-launchpad/?flashConfigURL=https://espressif.github.io/esp-bsp/config.toml&app=display) | | [Display, Audio and Photo Example](https://github.com/espressif/esp-bsp/tree/master/examples/display_audio_photo) | Complex demo: browse files from filesystem and play/display JPEG, WAV, or TXT files (LVGL) | [Flash Example](https://espressif.github.io/esp-launchpad/?flashConfigURL=https://espressif.github.io/esp-bsp/config.toml&app=display_audio_photo) | | [Camera Example](https://github.com/espressif/esp-bsp/tree/master/examples/display_camera) | Stream camera output to display (LVGL) | [Flash Example](https://espressif.github.io/esp-launchpad/?flashConfigURL=https://espressif.github.io/esp-bsp/config.toml&app=display_camera) | | [LVGL Benchmark Example](https://github.com/espressif/esp-bsp/tree/master/examples/display_lvgl_benchmark) | Run LVGL benchmark tests | - | | [LVGL Demos Example](https://github.com/espressif/esp-bsp/tree/master/examples/display_lvgl_demos) | Run the LVGL demo player - all LVGL examples are included (LVGL) | [Flash Example](https://espressif.github.io/esp-launchpad/?flashConfigURL=https://espressif.github.io/esp-bsp/config.toml&app=display_lvgl_demo) | | [Display Rotation Example](https://github.com/espressif/esp-bsp/tree/master/examples/display_rotation) | Rotate screen using buttons or an accelerometer (`BSP_CAPS_IMU`, if available) | [Flash Example](https://espressif.github.io/esp-launchpad/?flashConfigURL=https://espressif.github.io/esp-bsp/config.toml&app=display_rotation) | <!-- END_EXAMPLES --> </div> <!-- START_BENCHMARK --> ## LVGL Benchmark **DATE:** 11.06.2025 02:41 **LVGL version:** 9.3.0 | Name | Avg. CPU | Avg. FPS | Avg. time | render time | flush time | | ---- | :------: | :------: | :-------: | :---------: | :--------: | | Empty screen | 93% | 29 | 30 | 5 | 25 | | Moving wallpaper | 94% | 30 | 31 | 11 | 20 | | Single rectangle | 21% | 92 | 0 | 0 | 0 | | Multiple rectangles | 86% | 55 | 13 | 8 | 5 | | Multiple RGB images | 27% | 90 | 1 | 1 | 0 | | Multiple ARGB images | 25% | 89 | 4 | 4 | 0 | | Rotated ARGB images | 78% | 51 | 18 | 14 | 4 | | Multiple labels | 82% | 80 | 9 | 7 | 2 | | Screen sized text | 96% | 22 | 41 | 39 | 2 | | Multiple arcs | 21% | 91 | 0 | 0 | 0 | | Containers | 36% | 72 | 16 | 8 | 8 | | Containers with overlay | 87% | 28 | 30 | 21 | 9 | | Containers with opa | 41% | 73 | 16 | 10 | 6 | | Containers with opa_layer | 61% | 56 | 26 | 20 | 6 | | Containers with scrolling | 93% | 27 | 33 | 20 | 13 | | Widgets demo | 95% | 27 | 20 | 17 | 3 | | All scenes avg. | 64% | 57 | 17 | 11 | 6 | <!-- END_BENCHMARK -->
api
# API Reference
<div align="center">
| :1234: [CAPABILITIES](#1234-capabilities) | :floppy_disk: [SD CARD AND SPIFFS](#floppy_disk-sd-card-and-spiffs) | :musical_note: [AUDIO](#musical_note-audio) | :pager: [DISPLAY AND TOUCH](#pager-display-and-touch) | :electric_plug: [USB](#electric_plug-usb) | :camera: [CAMERA](#camera-camera) |
| :-------------------------: | :-------------------------: | :-------------------------: | :-------------------------: | :-------------------------: | :-------------------------: |
</div>
## Overview
This document provides an overview of the ESP-BSP (Board Support Package) API as implemented by this board.
While the ESP-BSP framework defines a unified API shared across multiple boards, this documentation focuses only on the APIs supported by the current board. Any APIs not applicable to this board's hardware are excluded or may not be functional.
The goal of this document is to make it easier for developers to understand the available APIs and how to use them consistently across different boards.
## General
### Pinout
Each BSP defines a set of macros for default pin assignments used by its hardware peripherals.
These macros allow users to configure or reference standard interfaces like I2C, SPI, LCD, audio, or SD cards easily.
- I2C: `BSP_I2C_*`
- Display: `BSP_LCD_*`
- Audio I2S: `BSP_I2S_*`
- USB: `BSP_USB_*`
- SD Card (MMC): `BSP_SD_*`
- SD Card (SPI): `BSP_SD_SPI_*`
> [!NOTE]
> Not all boards support all interfaces. You should always check if the related capability macro (e.g., BSP_CAPS_SDCARD) is defined.
### I2C
Some devices included in BSPs (e.g., sensors, displays, audio codecs) communicate via the I2C interface. In many cases, I2C is initialized automatically as part of the device setup. However, you can manually initialize or deinitialize the I2C peripheral using the following API:
```
/* Initialize the default I2C bus used by the BSP */
bsp_i2c_init();
...
/* Deinitialize the I2C bus */
bsp_i2c_deinit();
```
If you need direct access to the initialized I2C bus (e.g., to communicate with an external peripheral not handled by the BSP), you can retrieve the I2C bus handle:
```
i2c_master_bus_handle_t i2c = bsp_i2c_get_handle();
```
> [!NOTE]
> The BSP ensures that I2C initialization is performed only once, even if called multiple times. This helps avoid conflicts when multiple components rely on the same I2C bus.
### ADC
Some devices included in BSPs (such as buttons, battery monitoring, etc.) use the ADC peripheral. In most cases, the ADC is automatically initialized as part of the specific device setup. However, you can manually initialize the ADC using the following API:
```
/* Initialize the ADC peripheral */
bsp_adc_initialize();
```
If you need direct access to the ADC instance (e.g., for custom measurements), you can retrieve the handle:
```
adc_oneshot_unit_handle_t adc = bsp_adc_get_handle();
```
> [!NOTE]
> The BSP ensures the ADC is initialized only once, even if `bsp_adc_initialize()` is called multiple times.
### Features
Some boards support enabling or disabling specific hardware features (such as LCD, SD card, camera, etc.) to reduce power consumption or manage shared resources. The BSP provides a unified API to control these features:
```
/* Enable the LCD feature */
bsp_feature_enable(BSP_FEATURE_LCD, true);
/* Disable the speaker to reduce power usage */
bsp_feature_enable(BSP_FEATURE_SPEAKER, false);
```
Supported feature flags (may vary depending on the board):
- `BSP_FEATURE_LCD` - Display module
- `BSP_FEATURE_TOUCH` - Touch controller
- `BSP_FEATURE_SD` - SD card interface
- `BSP_FEATURE_SPEAKER`- Audio speaker
- `BSP_FEATURE_BATTERY` - Battery monitoring
- `BSP_FEATURE_VIBRATION` - Vibration motor
> [!NOTE]
> Not all BSPs support feature toggling, and some features may not be available or controllable via this API. Always check the BSP header or documentation for supported features.
> [!TIP]
> Disabling unused features can help reduce power consumption, especially in battery-powered applications.
## Identification
Each BSP defines an identifier macro in the form of `BSP_BOARD_*`.
### Board Name API Reference
## Macros
| Type | Name |
| ---: | :--- |
| define | [**BSP\_BOARD\_M5STACK\_CORE\_S3**](#define-bsp_board_m5stack_core_s3) <br> |
## :1234: Capabilities
Each BSP defines a set of capability macros that indicate which features are supported.
The list may look like this.
You can use these macros to conditionally compile code depending on feature availability.
### Capabilities API Reference
## Macros
| Type | Name |
| ---: | :--- |
| define | [**BSP\_CAPS\_AUDIO**](#define-bsp_caps_audio) 1<br> |
| define | [**BSP\_CAPS\_AUDIO\_MIC**](#define-bsp_caps_audio_mic) 1<br> |
| define | [**BSP\_CAPS\_AUDIO\_SPEAKER**](#define-bsp_caps_audio_speaker) 1<br> |
| define | [**BSP\_CAPS\_BUTTONS**](#define-bsp_caps_buttons) 0<br> |
| define | [**BSP\_CAPS\_CAMERA**](#define-bsp_caps_camera) 1<br> |
| define | [**BSP\_CAPS\_DISPLAY**](#define-bsp_caps_display) 1<br> |
| define | [**BSP\_CAPS\_IMU**](#define-bsp_caps_imu) 0<br> |
| define | [**BSP\_CAPS\_SDCARD**](#define-bsp_caps_sdcard) 1<br> |
| define | [**BSP\_CAPS\_TOUCH**](#define-bsp_caps_touch) 1<br> |
### I2C API Reference
## Functions
| Type | Name |
| ---: | :--- |
| esp\_err\_t | [**bsp\_i2c\_deinit**](#function-bsp_i2c_deinit) (void) <br>_Deinit I2C driver and free its resources._ |
| esp\_err\_t | [**bsp\_i2c\_init**](#function-bsp_i2c_init) (void) <br>_Init I2C driver._ |
## Macros
| Type | Name |
| ---: | :--- |
| define | [**BSP\_I2C\_NUM**](#define-bsp_i2c_num) CONFIG\_BSP\_I2C\_NUM<br> |
| define | [**BSP\_I2C\_SCL**](#define-bsp_i2c_scl) (GPIO\_NUM\_11)<br> |
| define | [**BSP\_I2C\_SDA**](#define-bsp_i2c_sda) (GPIO\_NUM\_12)<br> |
## Functions Documentation
### function `bsp_i2c_deinit`
_Deinit I2C driver and free its resources._
```c
esp_err_t bsp_i2c_deinit (
void
)
```
**Returns:**
* ESP\_OK On success
* ESP\_ERR\_INVALID\_ARG I2C parameter error
### function `bsp_i2c_init`
_Init I2C driver._
```c
esp_err_t bsp_i2c_init (
void
)
```
**Returns:**
* ESP\_OK On success
* ESP\_ERR\_INVALID\_ARG I2C parameter error
* ESP\_FAIL I2C driver installation error
## :floppy_disk: SD Card and SPIFFS
### SPIFFS Initialization / Deinitialization
Each BSP provides a simple API for mounting and unmounting the SPI Flash File System (SPIFFS).
```
/* Mount SPIFFS to the virtual file system */
bsp_spiffs_mount();
/* ... perform file operations ... */
/* Unmount SPIFFS from the virtual file system */
bsp_spiffs_unmount();
```
### SD Card Initialization / Deinitialization
The BSP offers a flexible API for working with SD cards. In addition to the default mount and unmount functions, you can also use a configuration structure or access preconfigured `host` and `slot` structures.
Mount with Default Configuration
```
/* Mount microSD card to the virtual file system */
bsp_sdcard_mount();
/* ... perform file operations ... */
/* Unmount microSD card */
bsp_sdcard_unmount();
```
Mount with Custom Configuration
Some BSPs allow selecting between SDMMC and SPI interfaces for the SD card. Use the appropriate API function based on your hardware:
```
bsp_sdcard_cfg_t cfg = {0};
/* Mount SD card using SDMMC interface */
bsp_sdcard_sdmmc_mount(&cfg);
```
or
```
bsp_sdcard_cfg_t cfg = {0};
/* Mount SD card using SPI interface */
bsp_sdcard_sdspi_mount(&cfg)
```
> [!NOTE]
> Not all BSPs support both SDMMC and SPI modes. Check the board documentation to see which interfaces are available.
> If an unsupported interface is used, the API will return `ESP_ERR_NOT_SUPPORTED` error.
### After Mounting
Once the SD card or SPIFFS is mounted, you can use standard file I/O functions (`fopen`, `fread`, `fwrite`, `fclose`, etc.) provided by ESP-IDF's VFS (Virtual File System).
To print basic SD card information (after mounting), you can use:
```
sdmmc_card_t *sdcard = bsp_sdcard_get_handle();
sdmmc_card_print_info(stdout, sdcard);
```
> [!TIP]
> The bsp_sdcard_get_handle() function returns a pointer to the sdmmc_card_t structure, which contains detailed information about the connected SD card.
### SD Card and SPIFFS API Reference
## Structures and Types
| Type | Name |
| ---: | :--- |
| struct | [**bsp\_sdcard\_cfg\_t**](#struct-bsp_sdcard_cfg_t) <br>_BSP SD card configuration structure._ |
## Functions
| Type | Name |
| ---: | :--- |
| sdmmc\_card\_t \* | [**bsp\_sdcard\_get\_handle**](#function-bsp_sdcard_get_handle) (void) <br>_Get SD card handle._ |
| void | [**bsp\_sdcard\_get\_sdmmc\_host**](#function-bsp_sdcard_get_sdmmc_host) (const int slot, sdmmc\_host\_t \*config) <br>_Get SD card MMC host config._ |
| void | [**bsp\_sdcard\_get\_sdspi\_host**](#function-bsp_sdcard_get_sdspi_host) (const int slot, sdmmc\_host\_t \*config) <br>_Get SD card SPI host config._ |
| esp\_err\_t | [**bsp\_sdcard\_mount**](#function-bsp_sdcard_mount) (void) <br>_Mount microSD card to virtual file system._ |
| void | [**bsp\_sdcard\_sdmmc\_get\_slot**](#function-bsp_sdcard_sdmmc_get_slot) (const int slot, sdmmc\_slot\_config\_t \*config) <br>_Get SD card MMC slot config._ |
| esp\_err\_t | [**bsp\_sdcard\_sdmmc\_mount**](#function-bsp_sdcard_sdmmc_mount) ([**bsp\_sdcard\_cfg\_t**](#struct-bsp_sdcard_cfg_t) \*cfg) <br>_Mount microSD card to virtual file system (MMC mode)_ |
| void | [**bsp\_sdcard\_sdspi\_get\_slot**](#function-bsp_sdcard_sdspi_get_slot) (const spi\_host\_device\_t spi\_host, sdspi\_device\_config\_t \*config) <br>_Get SD card SPI slot config._ |
| esp\_err\_t | [**bsp\_sdcard\_sdspi\_mount**](#function-bsp_sdcard_sdspi_mount) ([**bsp\_sdcard\_cfg\_t**](#struct-bsp_sdcard_cfg_t) \*cfg) <br>_Mount microSD card to virtual file system (SPI mode)_ |
| esp\_err\_t | [**bsp\_sdcard\_unmount**](#function-bsp_sdcard_unmount) (void) <br>_Unmount microSD card from virtual file system._ |
| esp\_err\_t | [**bsp\_spiffs\_mount**](#function-bsp_spiffs_mount) (void) <br>_Mount SPIFFS to virtual file system._ |
| esp\_err\_t | [**bsp\_spiffs\_unmount**](#function-bsp_spiffs_unmount) (void) <br>_Unmount SPIFFS from virtual file system._ |
## Macros
| Type | Name |
| ---: | :--- |
| define | [**BSP\_SDSPI\_HOST**](#define-bsp_sdspi_host) (SPI3\_HOST)<br> |
| define | [**BSP\_SD\_MOUNT\_POINT**](#define-bsp_sd_mount_point) CONFIG\_BSP\_SD\_MOUNT\_POINT<br> |
| define | [**BSP\_SD\_SPI\_CS**](#define-bsp_sd_spi_cs) (GPIO\_NUM\_4)<br> |
| define | [**BSP\_SD\_SPI\_MISO**](#define-bsp_sd_spi_miso) (GPIO\_NUM\_35)<br> |
| define | [**BSP\_SD\_SPI\_MOSI**](#define-bsp_sd_spi_mosi) (GPIO\_NUM\_37)<br> |
| define | [**BSP\_SD\_SPI\_SCK**](#define-bsp_sd_spi_sck) (GPIO\_NUM\_36)<br> |
| define | [**BSP\_SPIFFS\_MOUNT\_POINT**](#define-bsp_spiffs_mount_point) CONFIG\_BSP\_SPIFFS\_MOUNT\_POINT<br> |
## Structures and Types Documentation
### struct `bsp_sdcard_cfg_t`
_BSP SD card configuration structure._
Variables:
- sdmmc\_host\_t \* host
- const esp\_vfs\_fat\_sdmmc\_mount\_config\_t \* mount
- const sdmmc\_slot\_config\_t \* sdmmc
- const sdspi\_device\_config\_t \* sdspi
- union [**bsp\_sdcard\_cfg\_t**](#struct-bsp_sdcard_cfg_t) slot
## Functions Documentation
### function `bsp_sdcard_get_handle`
_Get SD card handle._
```c
sdmmc_card_t * bsp_sdcard_get_handle (
void
)
```
**Returns:**
SD card handle
### function `bsp_sdcard_get_sdmmc_host`
_Get SD card MMC host config._
```c
void bsp_sdcard_get_sdmmc_host (
const int slot,
sdmmc_host_t *config
)
```
**Parameters:**
* `slot` SD card slot
* `config` Structure which will be filled
### function `bsp_sdcard_get_sdspi_host`
_Get SD card SPI host config._
```c
void bsp_sdcard_get_sdspi_host (
const int slot,
sdmmc_host_t *config
)
```
**Parameters:**
* `slot` SD card slot
* `config` Structure which will be filled
### function `bsp_sdcard_mount`
_Mount microSD card to virtual file system._
```c
esp_err_t bsp_sdcard_mount (
void
)
```
**Returns:**
* ESP\_OK on success
* ESP\_ERR\_INVALID\_STATE if esp\_vfs\_fat\_sdmmc\_mount was already called
* ESP\_ERR\_NO\_MEM if memory can not be allocated
* ESP\_FAIL if partition can not be mounted
* other error codes from SDMMC or SPI drivers, SDMMC protocol, or FATFS drivers
### function `bsp_sdcard_sdmmc_get_slot`
_Get SD card MMC slot config._
```c
void bsp_sdcard_sdmmc_get_slot (
const int slot,
sdmmc_slot_config_t *config
)
```
**Parameters:**
* `slot` SD card slot
* `config` Structure which will be filled
### function `bsp_sdcard_sdmmc_mount`
_Mount microSD card to virtual file system (MMC mode)_
```c
esp_err_t bsp_sdcard_sdmmc_mount (
bsp_sdcard_cfg_t *cfg
)
```
**Parameters:**
* `cfg` SD card configuration
**Returns:**
* ESP\_OK on success
* ESP\_ERR\_INVALID\_STATE if esp\_vfs\_fat\_sdmmc\_mount was already called
* ESP\_ERR\_NO\_MEM if memory cannot be allocated
* ESP\_FAIL if partition cannot be mounted
* other error codes from SDMMC or SPI drivers, SDMMC protocol, or FATFS drivers
### function `bsp_sdcard_sdspi_get_slot`
_Get SD card SPI slot config._
```c
void bsp_sdcard_sdspi_get_slot (
const spi_host_device_t spi_host,
sdspi_device_config_t *config
)
```
**Parameters:**
* `spi_host` SPI host ID
* `config` Structure which will be filled
### function `bsp_sdcard_sdspi_mount`
_Mount microSD card to virtual file system (SPI mode)_
```c
esp_err_t bsp_sdcard_sdspi_mount (
bsp_sdcard_cfg_t *cfg
)
```
**Parameters:**
* `cfg` SD card configuration
**Returns:**
* ESP\_OK on success
* ESP\_ERR\_INVALID\_STATE if esp\_vfs\_fat\_sdmmc\_mount was already called
* ESP\_ERR\_NO\_MEM if memory cannot be allocated
* ESP\_FAIL if partition cannot be mounted
* other error codes from SDMMC or SPI drivers, SDMMC protocol, or FATFS drivers
### function `bsp_sdcard_unmount`
_Unmount microSD card from virtual file system._
```c
esp_err_t bsp_sdcard_unmount (
void
)
```
**Returns:**
* ESP\_OK on success
* ESP\_ERR\_NOT\_FOUND if the partition table does not contain FATFS partition with given label
* ESP\_ERR\_INVALID\_STATE if esp\_vfs\_fat\_spiflash\_mount was already called
* ESP\_ERR\_NO\_MEM if memory can not be allocated
* ESP\_FAIL if partition can not be mounted
* other error codes from wear levelling library, SPI flash driver, or FATFS drivers
### function `bsp_spiffs_mount`
_Mount SPIFFS to virtual file system._
```c
esp_err_t bsp_spiffs_mount (
void
)
```
**Returns:**
* ESP\_OK on success
* ESP\_ERR\_INVALID\_STATE if esp\_vfs\_spiffs\_register was already called
* ESP\_ERR\_NO\_MEM if memory can not be allocated
* ESP\_FAIL if partition can not be mounted
* other error codes
### function `bsp_spiffs_unmount`
_Unmount SPIFFS from virtual file system._
```c
esp_err_t bsp_spiffs_unmount (
void
)
```
**Returns:**
* ESP\_OK on success
* ESP\_ERR\_NOT\_FOUND if the partition table does not contain SPIFFS partition with given label
* ESP\_ERR\_INVALID\_STATE if esp\_vfs\_spiffs\_unregister was already called
* ESP\_ERR\_NO\_MEM if memory can not be allocated
* ESP\_FAIL if partition can not be mounted
* other error codes
## :musical_note: Audio
### Initialization
Before using speaker or microphone features, the audio codec must be initialized.
```
/* Initialize the speaker codec */
esp_codec_dev_handle_t spk_codec_dev = bsp_audio_codec_speaker_init();
/* Initialize the microphone codec */
esp_codec_dev_handle_t mic_codec_dev = bsp_audio_codec_microphone_init();
```
After initialization, the [esp_codec_dev](https://components.espressif.com/components/espressif/esp_codec_dev) API can be used to control playback and recording.
> [!NOTE]
> Some BSPs may only support playback (speaker) or only input (microphone). Use the capability macros (`BSP_CAPS_AUDIO`, `BSP_CAPS_AUDIO_SPEAKER`, `BSP_CAPS_AUDIO_MIC`) to check supported features.
### Example of audio usage
#### Speaker
Below is an example of audio playback using the speaker (source data not included):
```
/* Set volume to 50% */
esp_codec_dev_set_out_vol(spk_codec_dev, 50);
/* Define audio format */
esp_codec_dev_sample_info_t fs = {
.sample_rate = wav_header.sample_rate,
.channel = wav_header.num_channels,
.bits_per_sample = wav_header.bits_per_sample,
};
/* Open speaker stream */
esp_codec_dev_open(spk_codec_dev, &fs);
...
/* Play audio data */
esp_codec_dev_write(spk_codec_dev, wav_bytes, wav_bytes_len);
...
/* Close stream when done */
esp_codec_dev_close(spk_codec_dev);
```
> [!TIP]
> Audio data must be in raw PCM format. Use a decoder if playing compressed formats (e.g., WAV, MP3).
#### Microphone
Below is an example of recording audio using the microphone (destination buffer not included):
```
/* Set input gain (optional) */
esp_codec_dev_set_in_gain(mic_codec_dev, 42.0);
/* Define audio format */
esp_codec_dev_sample_info_t fs = {
.sample_rate = 16000,
.channel = 1,
.bits_per_sample = 16,
};
/* Open microphone stream */
esp_codec_dev_open(mic_codec_dev, &fs);
/* Read recorded data */
esp_codec_dev_read(mic_codec_dev, recording_buffer, BUFFER_SIZE)
...
/* Close stream when done */
esp_codec_dev_close(mic_codec_dev);
```
### Audio API Reference
## Functions
| Type | Name |
| ---: | :--- |
| esp\_codec\_dev\_handle\_t | [**bsp\_audio\_codec\_microphone\_init**](#function-bsp_audio_codec_microphone_init) (void) <br>_Initialize microphone codec device._ |
| esp\_codec\_dev\_handle\_t | [**bsp\_audio\_codec\_speaker\_init**](#function-bsp_audio_codec_speaker_init) (void) <br>_Initialize speaker codec device._ |
| const audio\_codec\_data\_if\_t \* | [**bsp\_audio\_get\_codec\_itf**](#function-bsp_audio_get_codec_itf) (void) <br>_Get codec I2S interface (initialized in bsp\_audio\_init)_ |
| esp\_err\_t | [**bsp\_audio\_init**](#function-bsp_audio_init) (const i2s\_std\_config\_t \*i2s\_config) <br>_Init audio._ |
## Macros
| Type | Name |
| ---: | :--- |
| define | [**BSP\_I2S\_DOUT**](#define-bsp_i2s_dout) (GPIO\_NUM\_13)<br> |
| define | [**BSP\_I2S\_DSIN**](#define-bsp_i2s_dsin) (GPIO\_NUM\_14)<br> |
| define | [**BSP\_I2S\_LCLK**](#define-bsp_i2s_lclk) (GPIO\_NUM\_33)<br> |
| define | [**BSP\_I2S\_MCLK**](#define-bsp_i2s_mclk) (GPIO\_NUM\_0)<br> |
| define | [**BSP\_I2S\_SCLK**](#define-bsp_i2s_sclk) (GPIO\_NUM\_34)<br> |
| define | [**BSP\_MUTE\_STATUS**](#define-bsp_mute_status) (GPIO\_NUM\_NC)<br> |
| define | [**BSP\_POWER\_AMP\_IO**](#define-bsp_power_amp_io) (GPIO\_NUM\_NC)<br> |
## Functions Documentation
### function `bsp_audio_codec_microphone_init`
_Initialize microphone codec device._
```c
esp_codec_dev_handle_t bsp_audio_codec_microphone_init (
void
)
```
**Returns:**
Pointer to codec device handle or NULL when error occured
### function `bsp_audio_codec_speaker_init`
_Initialize speaker codec device._
```c
esp_codec_dev_handle_t bsp_audio_codec_speaker_init (
void
)
```
**Returns:**
Pointer to codec device handle or NULL when error occured
### function `bsp_audio_get_codec_itf`
_Get codec I2S interface (initialized in bsp\_audio\_init)_
```c
const audio_codec_data_if_t * bsp_audio_get_codec_itf (
void
)
```
**Returns:**
* Pointer to codec I2S interface handle or NULL when error occured
### function `bsp_audio_init`
_Init audio._
```c
esp_err_t bsp_audio_init (
const i2s_std_config_t *i2s_config
)
```
**Note:**
There is no deinit audio function. Users can free audio resources by calling i2s\_del\_channel()
**Warning:**
The type of i2s\_config param is depending on IDF version.
**Parameters:**
* `i2s_config` I2S configuration. Pass NULL to use default values (Mono, duplex, 16bit, 22050 Hz)
**Returns:**
* ESP\_OK On success
* ESP\_ERR\_NOT\_SUPPORTED The communication mode is not supported on the current chip
* ESP\_ERR\_INVALID\_ARG NULL pointer or invalid configuration
* ESP\_ERR\_NOT\_FOUND No available I2S channel found
* ESP\_ERR\_NO\_MEM No memory for storing the channel information
* ESP\_ERR\_INVALID\_STATE This channel has not initialized or already started
## :pager: Display and Touch
### Initialization
ESP-BSP provides two ways to initialize the **display**, **touch** and **LVGL**.
Simple method:
```
/* Initialize display, touch, and LVGL */
lv_display_t display = bsp_display_start();
```
Configurable method:
```
bsp_display_cfg_t cfg = {
.lvgl_port_cfg = ESP_LVGL_PORT_INIT_CONFIG(), /* See LVGL Port for more info */
.buffer_size = BSP_LCD_V_RES * BSP_LCD_H_RES, /* Screen buffer size in pixels */
.double_buffer = true, /* Allocate two buffers if true */
.flags = {
.buff_dma = true, /* Use DMA-capable LVGL buffer */
.buff_spiram = false, /* Allocate buffer in PSRAM if true */
}
};
cfg.lvgl_port_cfg.task_stack = 10000; /* Example: change LVGL task stack size */
/* Initialize display, touch, and LVGL */
lv_display_t display = bsp_display_start_with_config(&cfg);
```
After initialization, you can use the [LVGL](https://docs.lvgl.io/master/) API or [LVGL Port](../components/esp_lvgl_port/README.md) API.
### Initialization without LVGL - NoGLIB BSP
To initialize the LCD without LVGL, use:
```
esp_lcd_panel_handle_t panel_handle;
esp_lcd_panel_io_handle_t io_handle;
const bsp_display_config_t bsp_disp_cfg = {
.max_transfer_sz = (BSP_LCD_H_RES * 100) * sizeof(uint16_t),
};
BSP_ERROR_CHECK_RETURN_NULL(bsp_display_new(&bsp_disp_cfg, &panel_handle, &io_handle));
```
To initialize the LCD touch without LVGL, use:
```
esp_lcd_touch_handle_t tp;
bsp_touch_new(NULL, &tp);
```
After initialization, you can use the [ESP-LCD](https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/peripherals/lcd/index.html) API and [ESP-LCD Touch](../components/lcd_touch/README.md) API.
### Set Brightness
```
/* Set display brightness to 100% */
bsp_display_backlight_on();
/* Set display brightness to 0% */
bsp_display_backlight_off();
/* Set display brightness to 50% */
bsp_display_brightness_set(50);
```
> [!NOTE]
> Some boards do not support changing brightness. They return an `ESP_ERR_NOT_SUPPORTED` error.
### LVGL API Usage (only when initialized with LVGL)
All LVGL calls must be protected using lock/unlock:
```
/* Wait until other tasks finish screen operations */
bsp_display_lock(0);
...
lv_obj_t * screen = lv_disp_get_scr_act(disp_handle);
lv_obj_t * obj = lv_label_create(screen);
...
/* Unlock after screen operations are done */
bsp_display_unlock();
```
### Screen rotation (only when initialized with LVGL)
```
bsp_display_lock(0);
/* Rotate display to 90 */
bsp_display_rotate(display, LV_DISPLAY_ROTATION_90);
bsp_display_unlock();
```
> [!NOTE]
> Some LCDs do not support hardware rotation and instead use software rotation, which consumes more memory.
### Available constants
Constants like screen resolution, pin configuration, and other options are defined in the BSP header files (`{bsp_name}.h`, `display.h`, `touch.h`).
Below are some of the most relevant predefined constants:
- `BSP_LCD_H_RES` - Horizontal resolution in pixels
- `BSP_LCD_V_RES` - Vertical resolution in pixels
- `BSP_LCD_SPI_NUM` - SPI bus used by the LCD (if applicable)
### Display and Touch API Reference
## Structures and Types
| Type | Name |
| ---: | :--- |
| struct | [**bsp\_display\_cfg\_t**](#struct-bsp_display_cfg_t) <br>_BSP display configuration structure._ |
| struct | [**bsp\_display\_config\_t**](#struct-bsp_display_config_t) <br>_BSP display configuration structure._ |
| struct | [**bsp\_touch\_config\_t**](#struct-bsp_touch_config_t) <br>_BSP touch configuration structure._ |
## Functions
| Type | Name |
| ---: | :--- |
| esp\_err\_t | [**bsp\_display\_backlight\_off**](#function-bsp_display_backlight_off) (void) <br>_Turn off display backlight._ |
| esp\_err\_t | [**bsp\_display\_backlight\_on**](#function-bsp_display_backlight_on) (void) <br>_Turn on display backlight._ |
| esp\_err\_t | [**bsp\_display\_brightness\_init**](#function-bsp_display_brightness_init) (void) <br>_Initialize display's brightness._ |
| esp\_err\_t | [**bsp\_display\_brightness\_set**](#function-bsp_display_brightness_set) (int brightness\_percent) <br>_Set display's brightness._ |
| lv\_indev\_t \* | [**bsp\_display\_get\_input\_dev**](#function-bsp_display_get_input_dev) (void) <br>_Get pointer to input device (touch, buttons, ...)_ |
| bool | [**bsp\_display\_lock**](#function-bsp_display_lock) (uint32\_t timeout\_ms) <br>_Take LVGL mutex._ |
| esp\_err\_t | [**bsp\_display\_new**](#function-bsp_display_new) (const [**bsp\_display\_config\_t**](#struct-bsp_display_config_t) \*config, esp\_lcd\_panel\_handle\_t \*ret\_panel, esp\_lcd\_panel\_io\_handle\_t \*ret\_io) <br>_Create new display panel._ |
| void | [**bsp\_display\_rotate**](#function-bsp_display_rotate) (lv\_display\_t \*disp, lv\_display\_rotation\_t rotation) <br>_Rotate screen._ |
| lv\_display\_t \* | [**bsp\_display\_start**](#function-bsp_display_start) (void) <br>_Initialize display._ |
| lv\_display\_t \* | [**bsp\_display\_start\_with\_config**](#function-bsp_display_start_with_config) (const [**bsp\_display\_cfg\_t**](#struct-bsp_display_cfg_t) \*cfg) <br>_Initialize display._ |
| void | [**bsp\_display\_unlock**](#function-bsp_display_unlock) (void) <br>_Give LVGL mutex._ |
| esp\_err\_t | [**bsp\_touch\_new**](#function-bsp_touch_new) (const [**bsp\_touch\_config\_t**](#struct-bsp_touch_config_t) \*config, esp\_lcd\_touch\_handle\_t \*ret\_touch) <br>_Create new touchscreen._ |
## Macros
| Type | Name |
| ---: | :--- |
| define | [**BSP\_LCD\_BACKLIGHT**](#define-bsp_lcd_backlight) (GPIO\_NUM\_NC)<br> |
| define | [**BSP\_LCD\_BIGENDIAN**](#define-bsp_lcd_bigendian) (1)<br> |
| define | [**BSP\_LCD\_BITS\_PER\_PIXEL**](#define-bsp_lcd_bits_per_pixel) (16)<br> |
| define | [**BSP\_LCD\_COLOR\_FORMAT**](#define-bsp_lcd_color_format) (ESP\_LCD\_COLOR\_FORMAT\_RGB565)<br> |
| define | [**BSP\_LCD\_COLOR\_SPACE**](#define-bsp_lcd_color_space) (ESP\_LCD\_COLOR\_SPACE\_BGR)<br> |
| define | [**BSP\_LCD\_CS**](#define-bsp_lcd_cs) (GPIO\_NUM\_3)<br> |
| define | [**BSP\_LCD\_DC**](#define-bsp_lcd_dc) (GPIO\_NUM\_35)<br> |
| define | [**BSP\_LCD\_DRAW\_BUFF\_DOUBLE**](#define-bsp_lcd_draw_buff_double) (1)<br> |
| define | [**BSP\_LCD\_DRAW\_BUFF\_SIZE**](#define-bsp_lcd_draw_buff_size) (BSP\_LCD\_H\_RES \* 50)<br> |
| define | [**BSP\_LCD\_H\_RES**](#define-bsp_lcd_h_res) (320)<br> |
| define | [**BSP\_LCD\_MISO**](#define-bsp_lcd_miso) (GPIO\_NUM\_35)<br> |
| define | [**BSP\_LCD\_MOSI**](#define-bsp_lcd_mosi) (GPIO\_NUM\_37)<br> |
| define | [**BSP\_LCD\_PCLK**](#define-bsp_lcd_pclk) (GPIO\_NUM\_36)<br> |
| define | [**BSP\_LCD\_PIXEL\_CLOCK\_HZ**](#define-bsp_lcd_pixel_clock_hz) (40 \* 1000 \* 1000)<br> |
| define | [**BSP\_LCD\_RST**](#define-bsp_lcd_rst) (GPIO\_NUM\_NC)<br> |
| define | [**BSP\_LCD\_SPI\_NUM**](#define-bsp_lcd_spi_num) (SPI3\_HOST)<br> |
| define | [**BSP\_LCD\_TOUCH\_INT**](#define-bsp_lcd_touch_int) (GPIO\_NUM\_NC)<br> |
| define | [**BSP\_LCD\_V\_RES**](#define-bsp_lcd_v_res) (240)<br> |
| define | [**ESP\_LCD\_COLOR\_FORMAT\_RGB565**](#define-esp_lcd_color_format_rgb565) (1)<br> |
| define | [**ESP\_LCD\_COLOR\_FORMAT\_RGB888**](#define-esp_lcd_color_format_rgb888) (2)<br> |
## Structures and Types Documentation
### struct `bsp_display_cfg_t`
_BSP display configuration structure._
Variables:
- unsigned int buff_dma <br>Allocated LVGL buffer will be DMA capable
- unsigned int buff_spiram <br>Allocated LVGL buffer will be in PSRAM
- uint32\_t buffer_size <br>Size of the buffer for the screen in pixels
- bool double_buffer <br>True, if should be allocated two buffers
- struct [**bsp\_display\_cfg\_t**](#struct-bsp_display_cfg_t) flags
- lvgl\_port\_cfg\_t lvgl_port_cfg <br>LVGL port configuration
### struct `bsp_display_config_t`
_BSP display configuration structure._
Variables:
- int max_transfer_sz <br>Maximum transfer size, in bytes.
### struct `bsp_touch_config_t`
_BSP touch configuration structure._
Variables:
- void \* dummy <br>Prepared for future use.
## Functions Documentation
### function `bsp_display_backlight_off`
_Turn off display backlight._
```c
esp_err_t bsp_display_backlight_off (
void
)
```
Backlight must be already initialized by calling [**bsp\_display\_brightness\_init()**](#function-bsp_display_brightness_init) or[**bsp\_display\_start()**](#function-bsp_display_start)
**Returns:**
* ESP\_OK On success
* ESP\_ERR\_INVALID\_ARG Parameter error
### function `bsp_display_backlight_on`
_Turn on display backlight._
```c
esp_err_t bsp_display_backlight_on (
void
)
```
Backlight must be already initialized by calling [**bsp\_display\_brightness\_init()**](#function-bsp_display_brightness_init) or[**bsp\_display\_start()**](#function-bsp_display_start)
**Returns:**
* ESP\_OK On success
* ESP\_ERR\_INVALID\_ARG Parameter error
### function `bsp_display_brightness_init`
_Initialize display's brightness._
```c
esp_err_t bsp_display_brightness_init (
void
)
```
Brightness is controlled with AXP2101 via I2C.
**Returns:**
* ESP\_OK On success
* ESP\_ERR\_INVALID\_ARG Parameter error
### function `bsp_display_brightness_set`
_Set display's brightness._
```c
esp_err_t bsp_display_brightness_set (
int brightness_percent
)
```
Brightness is controlled with AXP2101 via I2C. Backlight must be already initialized by calling [**bsp\_display\_brightness\_init()**](#function-bsp_display_brightness_init) or[**bsp\_display\_start()**](#function-bsp_display_start)
**Parameters:**
* `brightness_percent` Brightness in [%]
**Returns:**
* ESP\_OK On success
* ESP\_ERR\_INVALID\_ARG Parameter error
### function `bsp_display_get_input_dev`
_Get pointer to input device (touch, buttons, ...)_
```c
lv_indev_t * bsp_display_get_input_dev (
void
)
```
**Note:**
The LVGL input device is initialized in [**bsp\_display\_start()**](#function-bsp_display_start) function.
**Returns:**
Pointer to LVGL input device or NULL when not initialized
### function `bsp_display_lock`
_Take LVGL mutex._
```c
bool bsp_display_lock (
uint32_t timeout_ms
)
```
**Parameters:**
* `timeout_ms` Timeout in [ms]. 0 will block indefinitely.
**Returns:**
true Mutex was taken
**Returns:**
false Mutex was NOT taken
### function `bsp_display_new`
_Create new display panel._
```c
esp_err_t bsp_display_new (
const bsp_display_config_t *config,
esp_lcd_panel_handle_t *ret_panel,
esp_lcd_panel_io_handle_t *ret_io
)
```
For maximum flexibility, this function performs only reset and initialization of the display. You must turn on the display explicitly by calling esp\_lcd\_panel\_disp\_on\_off(). The display's backlight is not turned on either. You can use bsp\_display\_backlight\_on/off(), [**bsp\_display\_brightness\_set()**](#function-bsp_display_brightness_set) (on supported boards) or implement your own backlight control.
If you want to free resources allocated by this function, you can use esp\_lcd API, ie.:
````cpp
esp_lcd_panel_del(panel);
esp_lcd_panel_io_del(io);
spi_bus_free(spi_num_from_configuration);
````
**Parameters:**
* `config` display configuration
* `ret_panel` esp\_lcd panel handle
* `ret_io` esp\_lcd IO handle
**Returns:**
* ESP\_OK On success
* Else esp\_lcd failure
### function `bsp_display_rotate`
_Rotate screen._
```c
void bsp_display_rotate (
lv_display_t *disp,
lv_display_rotation_t rotation
)
```
Display must be already initialized by calling [**bsp\_display\_start()**](#function-bsp_display_start)
**Parameters:**
* `disp` Pointer to LVGL display
* `rotation` Angle of the display rotation
### function `bsp_display_start`
_Initialize display._
```c
lv_display_t * bsp_display_start (
void
)
```
This function initializes SPI, display controller and starts LVGL handling task. LCD backlight must be enabled separately by calling [**bsp\_display\_brightness\_set()**](#function-bsp_display_brightness_set)
**Returns:**
Pointer to LVGL display or NULL when error occured
### function `bsp_display_start_with_config`
_Initialize display._
```c
lv_display_t * bsp_display_start_with_config (
const bsp_display_cfg_t *cfg
)
```
This function initializes SPI, display controller and starts LVGL handling task. LCD backlight must be enabled separately by calling [**bsp\_display\_brightness\_set()**](#function-bsp_display_brightness_set)
**Parameters:**
* `cfg` display configuration
**Returns:**
Pointer to LVGL display or NULL when error occured
### function `bsp_display_unlock`
_Give LVGL mutex._
```c
void bsp_display_unlock (
void
)
```
### function `bsp_touch_new`
_Create new touchscreen._
```c
esp_err_t bsp_touch_new (
const bsp_touch_config_t *config,
esp_lcd_touch_handle_t *ret_touch
)
```
If you want to free resources allocated by this function, you can use esp\_lcd\_touch API, ie.:
````cpp
esp_lcd_touch_del(tp);
````
**Parameters:**
* `config` touch configuration
* `ret_touch` esp\_lcd\_touch touchscreen handle
**Returns:**
* ESP\_OK On success
* Else esp\_lcd\_touch failure
## :electric_plug: USB
Boards with USB support define macros for USB pins, such as `BSP_USB_POS` and `BSP_USB_NEG`, and may also provide control APIs for enabling or disabling USB functionality.
```
/* Initialize USB in device mode and enable power */
bsp_usb_host_start(BSP_USB_HOST_POWER_MODE_USB_DEV, true);
...
/* Deinitialize and stop USB */
bsp_usb_host_stop();
```
> [!NOTE]
> Not all BSPs implement USB support or provide power control. Refer to the board's documentation and the BSP header files for available functions and supported modes.
For more USB-related APIs and configuration options, check the corresponding BSP header files.
### USB API Reference
## Macros
| Type | Name |
| ---: | :--- |
| define | [**BSP\_USB\_NEG**](#define-bsp_usb_neg) (GPIO\_NUM\_19)<br> |
| define | [**BSP\_USB\_POS**](#define-bsp_usb_pos) (GPIO\_NUM\_20)<br> |
## :camera: Camera
There is no dedicated BSP API for camera functionality. Instead, the BSP provides default configuration macros:
- `BSP_CAMERA_DEFAULT_CONFIG`
- `BSP_CAMERA_VFLIP`
- `BSP_CAMERA_HMIRROR`
These macros are designed for use with the [esp32-camera](https://components.espressif.com/components/espressif/esp32-camera) component.
> [!NOTE]
> Don't forget to initialize I2C (`bsp_i2c_init()`) before using the camera, as some camera modules require I2C for configuration.
### Example Usage
```
/* Initialize I2C bus (required by camera module) */
bsp_i2c_init();
/* Initialize the camera using BSP default config */
const camera_config_t camera_config = BSP_CAMERA_DEFAULT_CONFIG;
esp_camera_init(&camera_config);
/* Optional: Set camera orientation */
sensor_t *s = esp_camera_sensor_get();
s->set_vflip(s, BSP_CAMERA_VFLIP); // Vertical flip
s->set_hmirror(s, BSP_CAMERA_HMIRROR); // Horizontal mirror
...
/* Capture a frame */
camera_fb_t * pic = esp_camera_fb_get();
if (pic) {
/* Access raw image data in pic->buf with size pic->len */
process_image(pic->buf, pic->len); // Replace with your function
esp_camera_fb_return(pic);
}
```
### Camera API Reference
## Macros
| Type | Name |
| ---: | :--- |
| define | [**BSP\_CAMERA\_D0**](#define-bsp_camera_d0) (GPIO\_NUM\_39)<br> |
| define | [**BSP\_CAMERA\_D1**](#define-bsp_camera_d1) (GPIO\_NUM\_40)<br> |
| define | [**BSP\_CAMERA\_D2**](#define-bsp_camera_d2) (GPIO\_NUM\_41)<br> |
| define | [**BSP\_CAMERA\_D3**](#define-bsp_camera_d3) (GPIO\_NUM\_42)<br> |
| define | [**BSP\_CAMERA\_D4**](#define-bsp_camera_d4) (GPIO\_NUM\_15)<br> |
| define | [**BSP\_CAMERA\_D5**](#define-bsp_camera_d5) (GPIO\_NUM\_16)<br> |
| define | [**BSP\_CAMERA\_D6**](#define-bsp_camera_d6) (GPIO\_NUM\_48)<br> |
| define | [**BSP\_CAMERA\_D7**](#define-bsp_camera_d7) (GPIO\_NUM\_47)<br> |
| define | [**BSP\_CAMERA\_DEFAULT\_CONFIG**](#define-bsp_camera_default_config) <br>_Camera default configuration._ |
| define | [**BSP\_CAMERA\_HMIRROR**](#define-bsp_camera_hmirror) 0<br> |
| define | [**BSP\_CAMERA\_HSYNC**](#define-bsp_camera_hsync) (GPIO\_NUM\_38)<br> |
| define | [**BSP\_CAMERA\_PCLK**](#define-bsp_camera_pclk) (GPIO\_NUM\_45)<br> |
| define | [**BSP\_CAMERA\_VFLIP**](#define-bsp_camera_vflip) 0<br> |
| define | [**BSP\_CAMERA\_VSYNC**](#define-bsp_camera_vsync) (GPIO\_NUM\_46)<br> |
| define | [**BSP\_CAMERA\_XCLK**](#define-bsp_camera_xclk) (GPIO\_NUM\_NC)<br> |
Links
Target
License: Apache-2.0
Tags
To add this component to your project, run:
or
download archive
idf.py add-dependency "espressif/m5stack_core_s3_noglib^3.0.0~1"
Stats
-
Archive size ~ 178.31 KB
-
Downloaded in total 31 times
-
This version: 0 times
Badge
