NodeMCU-ESP32-C2 Pinout

Overview

The NodeMCU-ESP32-C2 is a NodeMCU-style development board on a purple PCB, built around the ESP8684-WROOM-02 module with 4 MB of flash. It has a USB-C port with a CH340C USB-to-serial chip, an AMS1117 3.3 V regulator, EN and IO9 buttons and two rows of 15 pins, 22.86 mm apart. It is a different and larger module than the bare ESPC2-02 module in the ESP32-C2 guide: the same chip underneath, but with more pins broken out and a complete programming circuit on the board.

No 802.15.4 radio on this chip, so Thread and Zigbee are not possible here: that needs an ESP32-C6 or H2 instead. Only badges for what this exact chip supports are shown.

System-on-chip and board

The ESP32-C2 (marketed name for the ESP8684) is Espressif’s low-cost single-core 32-bit RISC-V chip, up to 120 MHz, with 2.4 GHz Wi-Fi 4 (802.11 b/g/n) and Bluetooth 5 LE. It has 272 KB of SRAM, a 12-bit ADC with up to five channels, secure boot and flash encryption. It has no USB controller, no touch pads and no DAC, which is why the board needs a USB-to-serial chip.

Getting started

The CH340C needs a driver on some systems (mainly older Windows versions). If the board does not show up as a serial port, install the CH340 driver before anything else.

Hello World: blink an LED

The microcontroller equivalent of “Hello World”: GPIO10 toggles once a second, shown here in two environments. Wire an LED (with a resistor) to GPIO10, a plain general-purpose pin with no other job on this board. The board has no LED of its own that you can drive from a pin.

ESP-IDF (stable v6.1)

#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/gpio.h"

#define LED_PIN GPIO_NUM_10

void app_main(void)
{
    gpio_reset_pin(LED_PIN);
    gpio_set_direction(LED_PIN, GPIO_MODE_OUTPUT);

    while (1) {
        gpio_set_level(LED_PIN, 1);
        vTaskDelay(pdMS_TO_TICKS(1000));
        gpio_set_level(LED_PIN, 0);
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

Arduino IDE

#define LED_PIN 10

void setup() {
  pinMode(LED_PIN, OUTPUT);
}

void loop() {
  digitalWrite(LED_PIN, HIGH);
  delay(1000);
  digitalWrite(LED_PIN, LOW);
  delay(1000);
}

ESP-IDF: build and flash with idf.py build flash monitor (target esp32c2). Arduino IDE: install ESP32 board support first, see Getting started above.

Specifications

Specifications for the NodeMCU-ESP32-C2 board and its ESP8684 chip.

Compute

Radio

Physical

Dimensions

The two pin rows are 22.86 mm apart and each has 15 pins on a 2.54 mm pitch, 35.56 mm from the first to the last pin. The board is about 25.4 x 48.1 mm with a mounting hole in each corner.

These sizes are read from the drawing of the board, using the 2.54 mm pin pitch as the scale, and not measured on a board. Check them with a caliper before you design an enclosure.

Pinout diagram

The component side with every header pin, its GPIO number and its functions: ADC channel, JTAG, the default SPI pins of the Arduino core, UART0 and the lines of the CH340C. The pin names are as printed on the board.

Underside

The underside is the same board seen from the other side. The left and right rows are mirrored compared with the component side.

The default SPI pins (SS 7, MOSI 6, MISO 5, SCK 4) and the UART pins (TX 20, RX 19) come from the ESP32C2 variant in the Arduino ESP32 core. The ADC, JTAG and strapping functions come from the ESP8684 data sheet.

GPIO map at a glance

The same pins grouped by what they can do. Only GPIO9 (BOOT button) needs care at power-up on this board, GPIO8 is not on the header.

Power

The board runs from the USB-C port. The AMS1117 regulator makes 3.3 V from the 5 V.

Use only one power source at a time: the USB-C port, the VIN pin or the 3V3 pins. A linear regulator wastes the voltage difference as heat, so do not run motors, servos or LED strips from the board’s 3.3 V. Give them their own supply with a shared ground.

USB-C, flashing and reset

The ESP32-C2 has no USB controller, so the single USB-C port goes to a CH340C USB-to-serial chip. That chip is connected to UART0.

If the upload does not start: hold the IO9 button, tap EN, then release IO9. Do not hold IO9 low outside flashing: it forces the board back into the bootloader instead of running your program.

ADC and the missing DAC and touch

The ESP32-C2 has one 12-bit ADC with five channels, no DAC and no touch pads.

The ADC input range is small with the default attenuation. Use a voltage divider for signals above the range and never put more than 3.3 V on any pin.

Pins with a second job

• GPIO9 is a strapping pin and the BOOT button (printed IO9). Do not pull it low at power-up unless you want download mode.
• GPIO8 is the second strapping pin of the chip and the Arduino default for I²C SDA, but it is not on this header. Choose other pins for I²C, for example GPIO6 and GPIO7.
• GPIO4, GPIO5, GPIO6 and GPIO7 are the default JTAG pins (MTMS, MTDI, MTCK, MTDO) and the default SPI pins (SCK, MISO, MOSI, SS) of the Arduino core. They work as normal pins, but you lose them when you debug with an external JTAG probe.
• GPIO19 and GPIO20 are UART0 RX and TX, used by the CH340C and the serial monitor. You can use them as normal pins, but not while you need the serial monitor.
• GPIO10 and GPIO18 have no other job on this board.

GPIO quick reference

The 13 GPIOs on the header. GPIO8 and the flash pins are not available. None of the GPIOs is input-only.

Flashing pins

Used by the onboard CH340C USB-to-serial chip to upload firmware. In case you connect your own adapter, these are the pins involved.

Programming

Arduino IDE, PlatformIO and ESP-IDF all work. In the Arduino IDE choose ESP32C2 Dev Module. In ESP-IDF set the target to esp32c2.

I²C scan on GPIO6 and GPIO7

#include <Wire.h>

void setup() {
  Serial.begin(115200);
  Wire.begin(6, 7);        // SDA = GPIO6, SCL = GPIO7 (GPIO8, the Arduino default SDA, is not on the header)
  delay(2000);
  for (uint8_t a = 1; a < 127; a++) {
    Wire.beginTransmission(a);
    if (Wire.endTransmission() == 0) Serial.printf("Found 0x%02Xn", a);
  }
}

void loop() {}

Read an analog sensor

void setup() {
  Serial.begin(115200);
}

void loop() {
  Serial.println(analogRead(1));   // GPIO1 is ADC1_CH1
  delay(200);
}

I did not run these two sketches on a board, they follow the Arduino ESP32 API. Start with the blink sketch: it needs only an LED.

Tips

• Use ADC1 for sensors. GPIO0 to GPIO4 are the analog pins.
• Move I²C away from the Arduino default. GPIO8 is not on the header, use GPIO6 and GPIO7 or other free pins.
• Keep GPIO9 free. Do not wire anything to the IO9 button pin that pulls it low at power-up.
• Check the fit before you use a breadboard. The pin rows are 22.86 mm apart, the same as other NodeMCU boards, but check how many holes remain next to the pins.
• Keep it simple. This is a small chip, use it for sensors and switches and not for heavy processing.

Real gotchas

• GPIO8 is not on the header. The Arduino default for I²C SDA is GPIO8, so Wire.begin() without arguments does not reach a pin.
• No USB on the chip. All serial traffic goes through the CH340C and UART0. The chip itself has no native USB.
• Two pairs of RX and TX. TX0 and RX0 are the chip’s UART0 pins, RX and TX next to the CH340C are the lines of the USB chip. Do not mix them up.
• No touch pads and no DAC. The ESP32-C2 has neither.
• No Thread or Zigbee. There is no 802.15.4 radio.
• Driver on older Windows. The CH340C may need a driver.
• 3.3 V logic. All GPIOs are 3.3 V only. Do not connect 5 V signals directly, and keep the VIN pin away from the GPIOs.
• Linear regulator. The AMS1117 gets warm when you draw a lot of current. Power motors, servos and strips from their own supply.

Compared with other boards

Common versions of these chips, with the facts that matter when you choose.

Take this board for the cheapest ESP32 with Wi-Fi and Bluetooth LE and the NodeMCU footprint. For more pins, memory and a native USB port see the AI-C3 or the AI-S3.

What to build with it

• A Wi-Fi or Bluetooth LE sensor node with an analog or I²C sensor.
• A wireless switch or relay controller on a spare GPIO.
• A battery-friendly sensor that sleeps between readings.
• A learning board for the NodeMCU footprint with a cheap RISC-V chip.

Safety notes

Conclusion

The NodeMCU-ESP32-C2 is a small, cheap board with 13 usable GPIOs, Wi-Fi and Bluetooth LE and a complete USB-C programming circuit. Keep analog sensors on GPIO0 to GPIO4, move I²C to GPIO6 and GPIO7 and use the IO9 and EN buttons when an upload does not start. For the family overview see the ESP32 family explained.

Sources: the pin names and layout from the drawing of the board, the ESP8684 data sheet, the ESP32C2 variant in the Arduino ESP32 core and the ESP-IDF documentation. The board size is read from the drawing, the flash size (4 MB) and the roles of the two serial pin sets are as given by the owner of the board.