Introduction

The ESP32-C6-Pico is a low-cost, high-performance microcontroller development board with a compact size and rich peripheral interfaces.
Adopts ESP32-C6-MINI-1 as the main chip, with RISC-V 32-bit single-core processor, support up to 160 MHz, and built-in 320KB ROM, 512KB HP SRAM, 16KB LP SRAM and 4 MB flash. The pin interface is compatible with the Raspberry Pi Pico development board and multiple peripheral devices, easier to use in different application scenarios.
You can choose ESP-IDF or Arduino in software so that you can easily and quickly get started and apply it to the product.

Features

• Adopts ESP32-C6-MINI-1 as the main chip, with RISC-V 32-bit single-core processor, support up to 160 MHz.
• Integrated 320KB ROM, 512KB HP SRAM, 16KB LP SRAM and 4MB Flash memory.
• Integrated 2.4GHz WiFi 6 and BLE (Bluetooth LE) dual-mode wireless communication, with superior RF performance.
• Type-C connector, easier to use.
• Rich peripheral interfaces, including standard Raspberry Pi Pico interfaces, better compatibility and expandability.
• Castellated module allows soldering directly to carrier boards.
• Supports multiple low-power operating states, adjustable balance between communication distance, data rate and power consumption to meet the power requirements of various application scenarios.
• Please use the provided "WS_TCA9554PWR" file to set GPIO22 (SDA) and GPIO23 (SCL) as I2C functions for GPIO extension to make the device function complete.
• Please note that GPIO22 (SDA) and GPIO23 (SCL) are used for TCA9554PWR, and you only can connect these pins to I2C slave device, and do not use for other functions.

Function Block Diagram

Pinout

Dimensions

TCA9554PWR Function Description

• Please note that the corresponding library files are required before using EXIO1 ~ EXIO7. (#Add EXIO Control Demo in VScode, #Add EXIO Demo In Arduino IDE)

Items	Function name	Parameters	Functionality
Initialize TCA9554PWR	TCA9554PWR_Init	uint8_t PinState	Initialize all TCA9554PWR pins to PinState mode
Resister	Read_REG	uint8_t REG	Read the value in the REG register of the TCA9554PWR
	Write_REG	uint8_t REG,uint8_t Data	Write data to the REG register of the TCA9554PWR
Initialize EXIO mode	Mode_EXIO	uint8_t Pin,uint8_t State	Setting the mode of the Pin of the TCA9554PWR
	Mode_EXIOS	uint8_t PinState	Setting the mode of all TCA9554PWR pins
Read EXIO level	Read_EXIO	uint8_t Pin	Read the input level of the Pin of the TCA9554PWR
	Read_EXIOS	void	Setting the input level of all TCA9554PWR pins
Set EXIO output level	Set_EXIO	uint8_t Pin,uint8_t State	Set the output level of the Pin of the TCA9554PWR
	Set_EXIOS	int8_t PinState	Setting the output level of all TCA9554PWR pins
Toggle EXIO level	Set_Toggle	uint8_t Pin	Toggles the output level of the Pin of the TCA9554PWR

Working with ESP-IDF

The following development system defaults to Windows, and it is recommended to use the VSCode plug-in for development.

Develop with VSCode

Install VSCode

• Open the VSCode website to download according to the corresponding system and system bits.

• After running the installation package, the rest can be installed by default, but here for a better experience, it is recommended to check the box in the 1, 2 and 3 items.
  • After enabling the 1st and 2nd items, you can directly open the VScode by right-clicking the file or the directory to improve your experience.
  • After enabling the 3rd items, you can directly select VSCode when choosing how to open,

Install Espressif IDF Plug-in

• Note: Currently the latest version of the plugin is V1.6.4, users can choose the same version as ours for a consistent experience!
• Open VSCode, use Shift+Ctrl+X to enter the plug-in manager.

• In the search bar, enter Espressif IDF to select the corresponding plug-in and click "Install".

• Press F1 to input:

esp-idf: configure esp-idf extension

• Select express (this guide is for users who install it for the first time).

• Select download sever.

• Select the version of ESP-IDF you want to use now, we choose the latest V5.1.1 (note that only after V5.1 did ESP-IDF start to support ESP32-C6).

• The following two are the installation paths respectively for the ESP-IDF container directory and the ESP-IDF Tools directory.

• Note: If you have installed ESP-IDF before, or failed to do so, please be sure to delete the file completely.
• After configuring, click "Install" to download:

• Enter the download interface, and then it will automatically install the corresponding tools and environment, just wait for a second.

• After the installation is complete, you will enter the following interface, indicating that the installation is finished.

Official Demo Usage GUIDE

Create Demo (#Demo Example)

• Press F1 to enter:

esp-idf:show examples projects 

• Select the corresponding IDF version:

• Take the Hello World demo as an example:
  • ①Select the corresponding demo.
  • ②Its readme will state what chip the demo applies to (how the demo is used and the file structure are described below, omitted here).
  • ③Click to create the demo.

Select the path to place the demo, and no folder with the same name as the demo is required.

Modify COM Port

• The corresponding COM ports are shown here, click to modify them.
• Please select the COM ports according to your device.
• In case of a download failure, please press the reset button for more than 1 second and wait for the PC to recognize the device again before downloading once more.

• Select the project or demo to use:

• Then we finish the modification of the COM ports.

Modify the Driver Object

• The driver object is displayed here, and you can modify it by clicking on it.
• Select the project or demo to use.

• Wait for a minute after clicking.

• Select the object we need to drive, which is our main chip ESP32C6.

• Choose the path to openocd, it doesn't affect us here, so let's just choose one at random.

The Rest of the Status Bar

• ①SDK configuration editor, supports modifying most functions of ESP-IDF.
• ②All cleanup, and clear all compiled files.
  
• ③Compile.
• ④Current download mode, default is UART.
• ⑤Flash the current firmware, please do it after compiling.
• ⑥Open the serial port monitor, which is used to view the serial port information.
• ⑦All-in-one button, compile, burn and open the serial monitor (most commonly used for debugging).

Compile, Program, Serial Port Monitoring

• Click on the all-in-one button we described before to compile, program and open the serial port monitor.

• It may take a long time to compile especially for the first time.

• During this process, the ESP-IDF may take up a lot of CPU resources, so it may cause the system to lag.
• Uploading the demo for a new project for the first time, you will need to select the download method, and select UART.

• This can also be changed later in the Download Methods section (click on it to bring up the options).

• As it comes with the onboard automatic download circuit, there is no need for manual operation to download automatically.

• After successful download, automatically enter the serial monitor, you can see the chip output the corresponding information and be prompted to restart after 10S.

Add EXIO Control Demo in VScode

• Use the official example blink for modification demonstration.
• Official path: get-started -> blink.
• Follow the tutorial above to create an official example: blink (Create Demo).
• Enter the main project directory.

• Download EXIO Control Demo.

• Copy EXIO control demo to main file.

• Use TCA9554PWR file:

#include "TCA9554PWR.h"

• The current control demo after initializing the TCA9554PWR.
• As follows, add the following demo to realize that EXIO1~EXIO7 outputs a high level in order.

uint8_t count = 0;
TCA9554PWR_Init(0x00);

Set_EXIOS(0x01<<count);                           // Set 7 EXIO loops to output high levels
count++;          
if(count == 7)
    count = 0;          
uint8_t State = Read_EXIO(TCA9554_EXIO3);         // Read EXIO3's input level                  
printf("EXIO3: %d\r\n",State); 

• Select the COM port and the driver object, and then flash.
• The effect is as shown below:

Demo Example

Hello World

The official example path: get-started -> hello_world.
The example effect: Output Hello World! on the TERMINAL window every 10s.

    Software Operation

• Create the official example "hello_world" according to the above tutorial. (Create Example)
• The demo is compatible with ESP32-C6, and you can directly use it with no need to modify the demo.
• Modify the COM port and the driver object, click on the compile and burn to run the demo.

GPIO

Official path: peripherals -> gpio -> generic_gpio.
Sample effect: LED blinks at 1-second intervals.

    Hardware Connection

ESP32-C6	LED
GPIO18 (or GPIO19)	LED+
GND	LED-

    Software Operation

• Follow the tutorial above to create the official example generic_gpio. (Create Example).
• The demo is compatible with ESP32-C6 and can be used without modifying the demo content.
• Modify the COM port and the driver object, click compile and burn to run the demo.

• Go to the macro definition location of the demo to see what GPIOs are handled.

• Right-click and select "Go to Declaration".

• The actually handled GPIOs are GPIO18, GPIO19.

RGB

Official example path: get-started -> blink.
Sample effect: onboard RGB beads blink at 1-second intervals.

    Software Operation

• Follow the tutorial above to create the official example blink. (Create Example)
• The demo is compatible with ESP32-C6 and can be used without modifying the demo content.
• Modify the COM port and the driver object, click compile and burn to run the demo.

UART

Official example path: peripherals -> uart-> uart_async_rxtxtasks.
Example effect: shorting GPIO4 and GPIO5 to send/receive UART data.

    Hardware Connection

ESP32-C6	ESP32-C6 (the same one)
GPIO4	GPIO5

    Software Operation

• Create the official example uart_async_rxtxtasks according to the tutorial above. (Create Example).
• The demo is compatible with ESP32-C6 and can be used without modifying the demo content.
• Modify the COM port and driver object, click compile, and burn to run the demo.

• Hardware connection according to the GPIO used.

• You can go to the definition file to see the actual GPIOs used (check GPIO_NUM_4 -> Right click -> Go to Definition).

I2C

The official example path: peripherals -> lcd-> i2c_oled.
Example effect: turns on the 0.96-inch OLED (A) and displays a character.

    Hardware Connection

    Software Operation

• Create the official example i2c_oled according to the tutorial above. (Create Example)
• Modify the demo to be compatible with 0.96-inch OLED (A).

• Adapts to 0.96-inch OLED (A), defines RES pin as GPIO9.

• Modify the COM port and the driver object, and click on the compile and burn to run the demo.

• The effect is as shown below:

• You can view the actual use of GPIO:

SPI

The path of the official example: peripherals -> spi_master-> lcd.
The example effect: dynamic displaying picture effect on the 2.4inch LCD Module.

    Hardware Connection

    Software Operation

• Right-click on the VScode icon and run VScode as administrator:

• Create an official example lcd according to the tutorial above. (Create Example)
• Modify the demo to make it compatible with a 2.4inch LCD Module.
  

• Go to Declaration.

• As ESP32-C6 is currently used, you also need to block other chip definitions.

• And add macro-define ESP32-C6, CONFIG_IDF_TARGET_ESP32C6.

//#define CONFIG_IDF_TARGET_ESP32 1
#define CONFIG_IDF_TARGET_ESP32C6 1

• Modify D/C to use IOs.
  • Enter the 60th line of spi_master_example_main.c.

• Modify D/C to use IOs, select existing IOs (modify GPIO10 and GPIO9 to GPIO0 and GPIO1).

• Modify the backlight.

• Modify it as gpio_set_level(PIN_NUM_BCKL, 1);

• Modify the COM port and the driver object, click to compile and flash to run the demo.

• The effect is as shown below:

Bluetooth

Official sample path: bluetooth -> bluedroid -> ble -> gatt_server.
Example effect: ESP32-C6 and cell phone Bluetooth debugging assistant for data transmission.

    Software Operation

• Install the Bluetooth debugging assistant on your phone.
• Follow the tutorial above to create the official example gatt_server. (Create Example)
• The demo is compatible with ESP32-C6 and can be used without modifying the demo content.
• Bluetooth name and UUID, Bluetooth name is ESP_GATTS_DEMO.

• Modify the COM port and the driver object, click on the compile, and burn to run the demo.

• Connecting the ESP_GATTS_DEMO Bluetooth device on the phone.
• The effect of a successful connection is shown below:

• Based on the UUID value in the demo, select one of the two servers for upstream transmission.
• The ESP32-C6 receives data:

WIFI

Official example path: wifi -> getting_started -> station.
Sample effect: ESP32-C6 connects to WIFI.

    Software Operation

• Create the official example station according to the tutorial above. (Create Example)
• Modify the contents of the demo to connect to the required WiFi.
• Go to the Kconfig.projbuild file.

• Change the original WiFi SSID and WiFi Password to the WiFi information you want to connect to.

• Modify the COM port and the driver object, click on the compile, and upload to run the demo.

• You can check the value of CONFIG_ESP_WIFI_SSID.
• Go to the station_ example_ main.c file.

• Right-click to Go to Definition.

• The previously set value can be seen as:

Zigbee

• Official example 1 path: Zigbee -> light_sample -> HA_on_off_switch.
• Official example 2 path: Zigbee -> light_sample -> HA_on_off_light.
• Example effect: use 2x ESP32-C6 boards, use the BOOT key of one ESP32-C6 board (burn HA_on_off_switch demo) to control the RGB LED ON/OFF on the other one.
• Note: Please burn the HA_on_off_switch demo to one board first, and then burn the HA_on_off_light demo to the other board.

    Software Operation 1

• Create the official example HA_on_off_switch according to the tutorial above. (Create Example)
• The demo is compatible with ESP32-C6 and can be used without modifying the demo content.
• Modify the COM port and the driver object, click compile and burn to run the demo.

    Software Operation 2

• Follow the tutorial above to create the official example HA_on_off_light. (Create Example)
• The demo is compatible with ESP32-C6 and can be used without modifying the demo.
• Modify the COM port and driver object, click compile and burn to run the demo (you need to wait for a moment for the two chips to establish a connection).

• If the device remains unconnected, it may be due to residual network information on the device, so you can erase the device information (Erase Tutorial) and reorganize the network.

JTAG Debug

     Software Operation

• Create a debugging example, this example uses the official example hello_world. (Create Example)
• Modify the launch.json file.

• Input the following content:

{
 "version": "0.2.0",
 "configurations": [
   {
     "name": "GDB",
     "type": "cppdbg",
     "request": "launch",
     "MIMode": "gdb",
     "miDebuggerPath": "${command:espIdf.getXtensaGdb}",
     "program": "${workspaceFolder}/build/${command:espIdf.getProjectName}.elf",
     "windows": {
       "program": "${workspaceFolder}\\build\\${command:espIdf.getProjectName}.elf"
     },
     "cwd": "${workspaceFolder}",
     "environment": [{ "name": "PATH", "value": "${config:idf.customExtraPaths}" }],
     "setupCommands": [
       { "text": "target remote :3333" },
       { "text": "set remote hardware-watchpoint-limit 2"},
       { "text": "mon reset halt" },
       { "text": "thb app_main" },
       { "text": "flushregs" }
     ],
     "externalConsole": false,
     "logging": {
       "engineLogging": true
     }
   }
 ]
}

• The demo is compatible with ESP32-C6 and can be used without modifying the demo content.
• Modify the COM port and the driver object (Please use the USB interface; the UART interface does not support JTAG debugging. The corresponding COM port can be checked through the Device Manager.), click compile, and flash to run the demo.

• Press F1 and input:

ESP-IDF:Device configuration

• Select OpenOcd Config Files.

• Type board/esp32c6-builtin.cfg (if this is the default, just enter)

board/esp32c6-builtin.cfg

• Stretch the width of the window until [OpenOCD Server] is displayed at the bottom.

• Click [OpenOCD Server] and select Start OpenOCD.

• Successfully opened as follows:

• Go to the debug function and click Debug:

• Successfully enter the debugging interface:

Erase Device Flash

• Unpack the software resource package (Flash debugging software).
• Open flash_download_tool_3.9.5.exe software, select ESP32-C6 and UART.

• Select the UART port number, and click START (not select any bin file).

• After programming, click on "ERASE".

• Waiting for Erase to Finish.

Working with Arduino

Please note that Arduino 3.0.0-alpha is based on ESP-IDF v5.1, which is quite different from the previous ESP-IDF V4.X. The original program may need to be adjusted after the following operations.

Environment Set-up

• Install Arduino IDE.

• Enter Arduino IDE after installation.

• Enter Preferences.

• Add JSON link:

https://espressif.github.io/arduino-esp32/package_esp32_dev_index.json

• Modify the project file folder as C:\Users\Waveshare\AppData\Local\Arduino15\packages (Waveshare is the username).

• Enter the development board manager, search for "esp32", select version 3.0.0-alpha3 under "esp32 by Espressif Systems" below, and click to install. (If installation fails, try using a mobile hotspot.)

• Restart the Arduino IDE after installation, and then you can use it now.

If Installation Fails

• Failed to install version 3.0.0-alpha3:

• Download the resource file.

• Click on the path "c:\Users\Waveshare\AppData\Local\Arduino15\packages" (where Waveshare is the user name of the computer, and you need to turn on Show Hidden Files).

• Unzip the downloaded files to the packages file folder.

• Install it again.

• Restart the Arduino IDE after installation and you're ready to go!

Create Example

• After changing the project folder above to c:\Users\Waveshare\AppData\Local\Arduino15\packages ("Waveshare" is the computer username), you can create demos using the examples in the project folder under the files.

• The following is the RGB flashing example (File -> Sketchbook -> esp32 -> hardware -> esp32 -> 3.0.0-alpha3 -> libraries -> ESP32 -> examples -> BlinkRGB under GPIO).

• Select the development board and port.

• Search esp32c6, select ESP32C6 Dev Module and the port to download.

• After selecting, click to upload and Arduino IDE will start to compile and flash the demo.

• After uploading, you can see the effect on the development board.

Add EXIO Demo In Arduino IDE

• Take the modification of the official demo BlinkRGB as an example.
• According to the tutorial Create Demo above, create BlinkRGB demo.
• For convenience, you can store it at other paths.

• Download EXIO Control Demo.

• Enter the directory where you just saved it, and copy the EXIO control demo to the BlinkRGB project folder.

• Use the TCA9554PWR file in BlinkRGB.ino.

• Currently, you can use the EXIO control functions to operate EXIO1 ~ EXIO7.
• Below, adding the following code in the setup() and loop() functions will sequentially set EXIO1 to EXIO7 to a high level and print the real-time level status of EXIO3:

 TCA9554PWR_Init(0x00);

uint8_t count = 0;
while(1)
{
  Set_EXIOS(0x01<<count);                           // Set 7 EXIO loops to output high levels
  count++;          
  if(count == 7)
    count = 0;       
  delay(1000);                        
  uint8_t State = Read_EXIO(TCA9554_EXIO3);         // Read EXIO3's input level                  
  printf("EXIO3: %d\r\n",State);                     
}   

• Running effect as shown below:

Resource

Software

Compile

• VScode
• Arduino IDE

UART

• SSCOM5.13.1

Flash

• Flash

Bluetooth

• Bluetooth debugging assistant

Schematic

• Schematic

Datasheet

• ESP32-C6-MINI-1 Datasheet
• ESP32-C6 Technical Reference Manual
• ESP32-C6 Series Datasheet
• TCA9554PWR

Official Datasheet

• ESP-IDF Datasheet

FAQ

Support

Monday-Friday (9:30-6:30) Saturday (9:30-5:30)

Email: services01@spotpear.com