MicroMod ESP32 Processor Board Hookup Guide

Introduction

Introducing the SparkFun MicroMod ESP32 Processor Board! This bad boy pops an M.2 connector onto the ESP32 so you can take advantage of all that lovely ESP32 power with any of our MicroMod carrier boards. Grab yourself an ESP32 MicroMod Processor Board and let's dive in!

added to your cart!

SparkFun MicroMod ESP32 Processor

Only 7 left! WRL-16781

This board combines Espressif's ESP32 with our M.2 connector interface to bring a power-packed processor board into our Micro…

$16.95

1

Favorited Favorite 10

Wish List

Required Materials

In addition to your ESP32 Processor Board, you'll need a carrier board to get started. Here we use the Input and Display Carrier Board, but there are a number of others you can choose from.

added to your cart!

SparkFun MicroMod ATP Carrier Board

In stock DEV-16885

If you need a "lot" of GPIO with a simple to program, ready to go to market module, the ATP is the fix you need.

$19.95

1

Favorited Favorite 19

Wish List

added to your cart!

SparkFun MicroMod Input and Display Carrier Board

In stock DEV-16985

Add data, input, & visibility to your project with a 2.4" TFT display, 6 addressable LEDs, onboard voltage regulator, 6 pin I…

$59.95

4

Favorited Favorite 21

Wish List

added to your cart!

SparkFun MicroMod Machine Learning Carrier Board

In stock DEV-16400

The MicroMod Machine Learning Carrier combines the freedom to explore any processor in the MicroMod lineup without the need f…

$19.95

Favorited Favorite 27

Wish List

You'll also need a USB-C cable to connect the Carrier to your computer and if you want to add some Qwiic breakouts to your MicroMod project you'll want at least one Qwiic cable to connect it all together. Below are some options for both of those cables:

added to your cart!

SparkFun Qwiic Cable Kit

In stock KIT-15081

To make it even easier to get started, we've assembled this Qwiic Cable Kit with a variety of Qwiic cables from 50mm to 500mm…

$8.95

22

Favorited Favorite 91

Wish List

added to your cart!

Qwiic Cable - 100mm

In stock PRT-14427

This is a 100mm long 4-conductor cable with 1mm JST termination. It’s designed to connect Qwiic enabled components together…

$1.50

Favorited Favorite 43

Wish List

added to your cart!

Reversible USB A to C Cable - 2m

In stock CAB-15424

These 2m cables have minor modifications that allow them to be be plugged into their ports regardless of orientation on the U…

$8.95

1

Favorited Favorite 6

Wish List

added to your cart!

USB 3.1 Cable A to C - 3 Foot

In stock CAB-14743

USB C is fantastic. But until we have converted all our hubs, chargers, and ports over to USB C this is the cable you're goin…

$5.50

4

Favorited Favorite 10

Wish List

Depending on which Carrier Board you choose, you may need a few extra peripherals to take full advantage of them. Refer to the Carrier Boards' respective Hookup Guides for specific peripheral recommendations.

Suggested Reading

The SparkFun MicroMod ecosystem is a unique way to allow users to customize their project to their needs. Do you want to send your weather data via a wireless signal? There's a MicroMod processor for that. Looking to instead maximize efficiency and processing power? You guessed it, there's a MicroMod processor for that. If you are not familiar with the MicroMod system, take a look here:

MicroMod Ecosystem

We recommend taking a look through the following tutorials if you are not familiar with the concepts covered in them:

Hardware Overview

In this section we'll cover what's included on the MicroMod ESP32 Processor Board.

M.2 Connector

All of our MicroMod Processor boards come equipped with the M.2 MicroMod Connector, which leverages the M.2 standard and specification to allow you to install your MicroMod Processor board on your choice of carrier board.

M2 Connector from the Front	M2 Connector from the Back

Espressif ESP32

Ahhh, the Espressif ESP32. It's one of the most unique microcontrollers on the market. In it's native form, it has a laundry list of features. On the MicroMod Processor Board, we include the following:

• Dual-core Tensilica LX6 microprocessor
• Up to 240MHz clock frequency
• 520kB internal SRAM
• Integrated 802.11 B/G/N WiFi transceiver
• 2.7 to 3.6V operating range
• 10-electrode capacitive touch support
• Hardware accelerated encryption (AES, SHA2, ECC, RSA-4096)
• 16MB Flash Storage

Stat LED

Wireless Antenna

Need wireless? The Espressif chip provides a WiFi transceiver which sends and receives data through a 2.4GHz Antenna.

PinOut Notes

The ESP32 MicroMod has a few quirks. The ESP32's GPIO pins provide a lot of flexibility with what each pin can be used for. Whether it's I²C, I²S, SPI, UART, or PWM, the ESP32 MicroMod can do just about everything! However, with that flexibility and a fixed number of GPIO pins, the ESP32 isn't able to do it all at the same time. Below is a list of protocols the ESP32 supports, but pay close attention to the pins used, because some pins are assigned to two or possibly three functions.

Strapping Pins

One of the unique aspects of the ESP32 is the strapping pins. When the ESP32 comes out of reset, or as power is supplied, there are a few pins which control the behavior of the board. For a detailed description of these pins, check out the ESP32 Boot Mode Selection page on espressif's GitHub page. As a summary the strapping pins are:

GPIO 0

Having GPIO 0 pulled low as the ESP32 comes out of reset will enter the serial bootloader. Otherwise, the board will run the program stored in flash. On the MicroMod Processor, this pin is pulled high externally through a 10k resistor, and is connected to the boot button on the carrier boards, which can pull the pin low.

GPIO 2

Having GPIO 2 pulled high as the ESP32 comes out of reset will prevent the board from entering the serial bootloader. On the MicroMod Processor, this pin is connected to the status LED (active high) and does not interfere with the board from being able to enter the serial bootloader.

GPIO 12

If driven high, the flash voltage (VDD_SDIO) is set to 1.8V. If unconnected or pulled low, VDD_SDIO is set to 3.3V. The flash IC used on the MicroMod Processor has a minimum voltage of 2.7V, which would create a brownout condition and might corrupt the data stored to the flash, or simply prevent the program from running. On the ESP32 MicroMod Processor, this pin is connected to PWM1.

GPIO 15

If driven low, the boot messages printed by the ROM bootloader (at 115200 baud) are silenced. If unconnected or driven high, the messages will be printed as they normally are. On the ESP32 MicroMod Processor, this pin is connected to G0.

I²C

We love us some I²C! We've broken out two I²C buses, which can be used with our Qwiic system. The main I²C bus has dedicated GPIO pins 21/22 connected to MicroMod pads 12/14, along with a dedicated interrupt pin connected to GPIO pin 4, which is connected to pad 16 of the MicroMod connector.

If you need a second I²C bus, the ESP32 uses GPIO pins 25/26 (pads 42/44 on the MicroMod) for SCL1 and SDA1.

UART

The ESP32 Processor has two UARTs available. The primary UART has dedicated GPIO pins 1 and 3 which can be used for programming as well as printing debug messages to a terminal window. These GPIO pins aren't directly broken out, but instead are converted to USB which is connected to MicroMod pads 3 and 5.

The second UART is connected GPIO pins 16 and 17 (pads 19 and 17 on the MicroMod) for RX1 and TX1.

GPIO/BUS

The MicroMod connector supports a total of 12 general purpose IO pins, 7 of which are used on the ESP32 Processor, on top of the 6 dedicated pins. The dedicated pins are just that, and are not shared with any other pin, unlike the general purpose pins which may be shared with other pins. The pins used are:

Dedicated Pins

• A0 - GPIO pin 34, pad 34 on the MicroMod (Input Only!)
• A1 - GPIO pin 35, pad 38 on the MicroMod (Input Only!)
• D0 - GPIO pin 14, pad 10 on the MicroMod
• D1 - GPIO pin 27, pad 18 on the MicroMod
• PWM0 - GPIO pin 13, pad 32 on the MicroMod
• PWM1 - GPIO pin 12, pad 47 on the MicroMod

General Purpose IO pins

• G0 - GPIO pin 15, pad 40 on the MicroMod
• G1 - GPIO pin 25, pad 42 on the MicroMod - Shared with the I²S bus, and secondary I²C bus.
• G2 - GPIO pin 26, pad 44 on the MicroMod - Shared with the I²S bus, and secondary I²C bus.
• G3 - GPIO pin 17, pad 46 on the MicroMod - Shared with the I²S bus, and secondary UART.
• G4 - GPIO pin 16, pad 48 on the MicroMod - Shared with the I²S bus, and secondary UART.
• G5 - GPIO pin 32, pad 73 on the MicroMod - Shared with the 32KHz RTC crystal.
• G6 - GPIO pin 33, pad 71 on the MicroMod - Shared with the 32KHz RTC crystal.

AUDIO

The ESP32 Processor supports audio using the I²S standard. The pins used are:

• AUD_OUT - GPIO pin 17, pad 56 on the MicroMod, this is the digital audio output.
• AUD_IN - GPIO pin 16, pad 54 on the MicroMod, this is the digital audio input.
• AUD_LRCLK - GPIO pin 25, pad 52 on the MicroMod. Officially called "word select", and also known as "frame sync".
• AUD_BCLK - GPIO pin 26, pad 50 on the MicroMod. Offically called "continuous serial clock, and also known as the "bit clock"

SPI

The MicroMod standard supports two Serial Peripheral Interface (SPI) buses, but because of the limited GPIO pins here, only the primary SPI bus is used. This primary SPI bus is dedicated to the following pins:

• SCK - This is the clock pin, which is connected to GPIO 18, or MicroMod pad 57.
• SDO - This is the serial data output of the ESP32, which is connected to GPIO 23, or MicroMod pad 59.
• SDI - This is the serial data input of the ESP32, which is connected to GPIO 19, or MicroMod pad 61.
• #CS - This is the chip select pin, which is connected to GPIO 5, or MicroMod pad 55.

ESP32 MicroMod Processor Pin Functionality

• ESP32 Processor Board Pinout Table
• MicroMod General Pinout Table
• MicroMod General Pin Descriptions

Board Dimensions

The board measures 22mm x 22mm, with 15mm to the top notch and 12mm to the E key. For more information regarding the processor board physical standards, head on over to the Getting Started with MicroMod tutorial and check out the Hardware Overview section.

The overall thickness of the MicroMod ESP32 Processor Board is ~2.67mm. The height of the tallest component (ESP32 labeled as "U2" in the board file) on the Processor side is ~0.90mm. The PCB thickness is ~0.80mm. The height of the tallest component (transistor labeled as "Q2" in the board file) is about ~0.97mm.

Hardware Hookup

To get started with the ESP32 Processor Board, you'll need a carrier board. Here we are using the MicroMod Input and Display Carrier Board. Align the top key of the MicroMod ESP32 Processor Board to the screw terminal of the Input and Display Carrier Board and angle the board into the socket. Insert the board at an angle into the M.2 connector.

The Processor Board will stick up at an angle, as seen here:

Once the board is in the socket, gently hold the MicroMod Processor Board down and tighten the screw with a Phillip's head.

Once the board is secure, your assembled MicroMod system should look similar to the image below!

Connecting Everything Up

With your processor inserted and secured it's time to connect your carrier board to your computer using the USB-C connector on the Carrier. Depending on which carrier you choose and which drivers you already have installed, you may need to install drivers.

Software Setup and Programming

Installing the CP2104 USB Driver

Users will need to install the SiLabs CP2104 Driver, which can be found here: USB to UART Bridge VCP Driver

Arduino IDE

Most users may already be familiar with the Arduino IDE and it's use. However, for those of you who have never heard the name Arduino before, feel free to check out the Arduino website. To get started with using the Arduino IDE, check out our tutorials below:

Install Board Definition

Install the latest ESP32 board definitions in the Arduino IDE (must be v1.8.13 or later).

When selecting a board to program in the Arduino IDE, users should select the SparkFun ESP32 MicroMod from the Tools drop down menu (i.e. Tools > Board > ESP32 Arduino > SparkFun ESP32 MicroMod).

Arduino Example: Blink

With the SparkFun ESP32 Arduino core installed, you're ready to begin programming. Make sure you have the ESP32 MicroMod board definition selected under your Tools > Board menu.

Then select your serial port under the Tools > Port menu.

You can also select the Upload Speed: "921600" baud -- the fastest selectable rate -- will get the code loaded onto your ESP32 the fastest, but may fail to upload once-in-a-while. (It's still way worth it for the speed increase!)

Loading Blink

To make sure your toolchain and board are properly set up, we'll upload the simplest of sketches -- Blink! The STAT LED on the ESP32 Processor Board is perfect for this test. This is also a good time to test out serial communication. Copy and paste the example sketch below into a fresh Arduino sketch:

language:c
int ledPin = 2;

void setup()
{
    pinMode(ledPin, OUTPUT);
    Serial.begin(115200);
}

void loop()
{
    Serial.println("Hello, world!");
    digitalWrite(ledPin, HIGH);
    delay(500);
    digitalWrite(ledPin, LOW);
    delay(500);
}

With everything setup correctly, upload the code! Once the code finishes transferring, open the serial monitor and set the baud rate to 115200. You should see Hello, world!'s begin to fly by. You may also notice that when the ESP32 boots up it prints out a long sequence of debug messages. These are emitted every time the chip resets -- always at 115200 baud.

You should also see some blinking happening on the ESP32 Processor Board! Blink Blink Blink!

Arduino Example: WiFi

The ESP32 Arduino core includes a handful of WiFi examples, which demonstrate everything from scanning for nearby networks to sending data to a client server. You can find the examples under the File > Examples > WiFi menu.

Here's another example using the WiFi library, which demonstrates how to connect to a nearby WiFi network and poll a remote domain (http://example.com/) as a client.

language:c
#include <WiFi.h>

// WiFi network name and password:
const char * networkName = "YOUR_NETWORK_HERE";
const char * networkPswd = "YOUR_PASSWORD_HERE";

// Internet domain to request from:
const char * hostDomain = "example.com";
const int hostPort = 80;

const int BUTTON_PIN = 0;
const int LED_PIN = LED_BUILTIN;

void setup()
{
  // Initilize hardware:
  Serial.begin(115200);
  pinMode(BUTTON_PIN, INPUT_PULLUP);
  pinMode(LED_PIN, OUTPUT);

  // Connect to the WiFi network (see function below loop)
  connectToWiFi(networkName, networkPswd);

  digitalWrite(LED_PIN, LOW); // LED off
  Serial.print("Press the Boot button to connect to ");
  Serial.println(hostDomain);
}

void loop()
{
  if (digitalRead(BUTTON_PIN) == LOW)
  { // Check if button has been pressed
    while (digitalRead(BUTTON_PIN) == LOW)
      ; // Wait for button to be released

    digitalWrite(LED_PIN, HIGH); // Turn on LED
    requestURL(hostDomain, hostPort); // Connect to server
    digitalWrite(LED_PIN, LOW); // Turn off LED
  }
}

void connectToWiFi(const char * ssid, const char * pwd)
{
  int ledState = 0;

  printLine();
  Serial.println("Connecting to WiFi network: " + String(ssid));

  WiFi.begin(ssid, pwd);

  while (WiFi.status() != WL_CONNECTED) 
  {
    // Blink LED while we're connecting:
    digitalWrite(LED_PIN, ledState);
    ledState = (ledState + 1) % 2; // Flip ledState
    delay(500);
    Serial.print(".");
  }

  Serial.println();
  Serial.println("WiFi connected!");
  Serial.print("IP address: ");
  Serial.println(WiFi.localIP());
}

void requestURL(const char * host, uint8_t port)
{
  printLine();
  Serial.println("Connecting to domain: " + String(host));

  // Use WiFiClient class to create TCP connections
  WiFiClient client;
  if (!client.connect(host, port))
  {
    Serial.println("connection failed");
    return;
  }
  Serial.println("Connected!");
  printLine();

  // This will send the request to the server
  client.print((String)"GET / HTTP/1.1\r\n" +
               "Host: " + String(host) + "\r\n" +
               "Connection: close\r\n\r\n");
  unsigned long timeout = millis();
  while (client.available() == 0) 
  {
    if (millis() - timeout > 5000) 
    {
      Serial.println(">>> Client Timeout !");
      client.stop();
      return;
    }
  }

  // Read all the lines of the reply from server and print them to Serial
  while (client.available()) 
  {
    String line = client.readStringUntil('\r');
    Serial.print(line);
  }

  Serial.println();
  Serial.println("closing connection");
  client.stop();
}

void printLine()
{
  Serial.println();
  for (int i=0; i<30; i++)
    Serial.print("-");
  Serial.println();
}

Make sure you fill in the networkName and networkPswd variables with the name (or SSID) and password of your WiFi network! Once you've done that and uploaded the code, open your serial monitor.

After your ESP32 connects to the WiFi network, it will wait for you to press the "Boot" button on your carrier board. Tapping that will cause the ESP32 to make an HTTP request to example.com. You should see a string of HTTP headers and HTML similar to the screenshot above.

Further Examples

With the MicroMod system, the possibilities for examples with all the processor/carrier board are endless, and we just can't cover them all. You'll notice that in this tutorial, we've selected the Input and Display Carrier Board, but have focused our examples on the Esp32 Processor Board. If you're interested in examples specifically for our carrier board, head on over to our SparkFun MicroMod Input and Display Carrier Board Hookup Guide.

Troubleshooting

With the MicroMod Processors, you can change out the processors with little to no changes in the code. But because each processor board's architecture is different, the way communication protocols are initialized might be a little bit different. For the ESP32 Processor, the two main protocols are the Universal Asynchronous Receiver Transmitter (UART), aka Serial, and I²C, aka Wire.

Secondary Serial/UART Initialization Tips

The UART is initialized with the begin function as:

void begin(unsigned long baud, uint32_t config, int8_t rxPin, int8_t txPin, bool invert, unsigned long timeout_ms)

The primary UART works like any other Arduino board being able to initialize and send messages back to your computer over the USB cable using using Serial.begin(115200) for a baud rate of 115200 as an example. If you wanted to communicate at the same 115200 baud rate on the secondary UART you would initialize Serial1 as:

Serial1.begin(115200, SERIAL_8N1, RX1,TX1);

Or if you want to use the GPIO pin numbers instead, it would be:

Serial1.begin(115200, SERIAL_8N1, 16, 17);

Secondary I²C Initialization Tips

The Wire bus is initialized with the begin function as:

bool begin(int sda, int scl, uint32_t frequency);  // returns true, if successful init of i2c bus

With the primary Wire bus, these pins use the default SCL and SDA pins connected to GPIO pins 22 and 21 and can be initialized by simply calling Wire.begin(). If you plan on using the secondary Wire bus, you need to provide the pins, and possibly the desired frequnecy if the default 400kHz is too fast. For most applications though you can use:

Wire1.begin(SDA1, SCL1);

Or if you wanted to use the GPIO pin numbers, it would be:

Wire1.begin(26, 25);

Resources and Going Further

For more information about the MicroMod ESP32 Processor Board, check out the following links:

• Schematic (PDF)
• Eagle Files (ZIP)
• Board Dimensions (PNG)
• Graphical Datasheet (PDF)
• Datasheet (PDF) (ESP32-D0WDQ6-V3)
• GitHub Hardware Repo

For more information about the SparkFun MicroMod Ecosystem, take a look at the links below:

• Getting Started with MicroMod
• Designing with MicroMod
• MicroMod Info Page
• MicroMod Forums

Looking for some project inspiration using your ESP32 Processor Board? The tutorials below can help you get started!