MicroMod ESP32 Processor Board Hookup Guide

2024-08-06 | By SparkFun Electronics

License: See Original Project Wifi Wireless ESP32 MicroMod Qwiic

Courtesy of SparkFun

Guide by ALEX THE GIANT, ELL C

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!‎

SparkFun MicroMod ESP32 Processor

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.‎

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:‎

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_1

MicroMod Ecosystem

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

Getting Started with MicroMod: Dive into the world of MicroMod - a compact interface to ‎connect a microcontroller to various peripherals via the M.2 Connector!‎
Designing with MicroMod: This tutorial will walk you through the specs of the MicroMod ‎processor and carrier board as well as the basics of incorporating the MicroMod form factor into ‎your own PCB designs!‎
SparkFun MicroMod Input and Display Carrier Board Hookup Guide: A short ‎Hookup Guide to get started with the SparkFun MicroMod Input and Display Carrier Board

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.‎

front_2

M2 Connector from the Front

back_3

M2 Connector from the Back

Espressif ESP32‎

Ahhh, the Espressif ESP32. It's one of the most unique microcontrollers on the market. In its 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‎
‎500µA sleep current under hibernation
‎10-electrode capacitive touch support
Hardware accelerated encryption (AES, SHA2, ECC, RSA-4096)‎
‎16MB Flash Storage‎

espressif_4

Stat LED

stat_5

Wireless Antenna

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

chip_6

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.‎

Note: The secondary I²C bus is shared with G1 and G2, as well as the I²S bus pins for ‎AUD_LRCLK and AUD_BCLK.‎

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.‎

Note: The secondary UART is shared with G3 and G4, as well as the I²S bus pins for AUD_OUT, ‎and AUD_IN.‎

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. Officially called "continuous serial clock, ‎and also known as the "bit clock"‎

Note: The I²S bus is shared with the secondary UART, secondary I²C bus, and general-purpose ‎pins G1-G4.‎

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

Note: You may not recognize the COPI/CIPO labels for SPI pins. SparkFun is working to move ‎away from using MISO/MOSI to describe signals between the controller and the peripheral. Check ‎out this page for more on our reasoning behind this change.‎

ESP32 MicroMod Processor Pin Functionality

function_7

ESP32 PROCESSOR BOARD PINOUT TABLE

esp32-processor-board-pinout-table_8

MICROMOD GENERAL PINOUT TABLE

microod-general-pinout-table_9

MICROMOD GENERAL PIN DESCRIPTIONS

micromod-general-pin-descriptions_10

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.‎

dimensions_11

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.‎

Note: There is no way to insert the processor backward since the key prevents it from mating with ‎the M.2 connector and as an extra safeguard to prevent inserting a processor that matches the key, ‎the mounting screw is offset so you will not be able to secure an improperly connected processor ‎board.‎

angle_12

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

socket_13

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

screw_14

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

assembled_15

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.‎

Note: If you've never connected a CP2104 device to your computer before, you may need to install ‎drivers for the USB-to-serial converter. Check out our section on How to Install CP2104 Drivers for ‎help with the installation.‎

Software Setup and Programming

Installing the CP2104 USB Driver

Note: Make sure to manually install the driver for the CP210X with the following instructions. The ‎driver that Windows auto-installs will not work with the auto-reset circuit on the board and cause ‎serial uploads to fail.‎

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

DOWNLOAD WINDOWS VCP DRIVER (ZIP)‎

DOWNLOAD MAC OSX VCP DRIVER (ZIP)‎

Note: If applicable, make sure you are using the proper driver files for your CPU architecture. This ‎is usually indicated by a folder or file name with "x86" for 32-bit processors or "x64" for 64-bit ‎processors.‎

Arduino IDE

Note: For first-time users, who have never programmed before and are looking to use the Arduino ‎IDE, we recommend beginning with the SparkFun Inventor's Kit (SIK), which includes a simpler ‎board like the Arduino Uno or SparkFun RedBoard and is designed to help users get started ‎programming with the 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:‎

Installing an Arduino Library: How do I install a custom Arduino library? It's easy! This ‎tutorial will go over how to install an Arduino library using the Arduino Library Manager. For libraries ‎not linked with the Arduino IDE, we will also go over manually installing an Arduino library.‎
What is an Arduino? What is this 'Arduino' thing anyway? This tutorial dives into what an ‎Arduino is and along with Arduino projects and widgets.‎
Installing Arduino IDE: A step-by-step guide to installing and testing the Arduino software on ‎Windows, Mac, and Linux.‎
Installing Board Definitions in the Arduino IDE: How do I install a custom Arduino ‎board/core? It's easy! This tutorial will go over how to install an Arduino board definition using the ‎Arduino Board Manager. We will also go over manually installing third-party cores, such as the ‎board definitions required for many of the SparkFun development boards.‎

Install Board Definition

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

installing_16

Installing Board Definitions in the Arduino IDE

How do I install a custom Arduino board/core? It's easy! This tutorial will go over how to install an ‎Arduino board definition using the Arduino Board Manager. We will also go over manually installing ‎third-party cores, such as the board definitions required for many of the SparkFun development ‎boards.‎

Note: For more instructions, users can follow this tutorial on Installing Additional Cores provided by ‎Arduino. Users will also need the .json file for the Espressif Arduino core:‎https://raw.githubusercontent.com/espressif/arduino-esp32/gh-‎pages/package_esp32_index.json

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.‎

menu_17

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

port_18

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:‎

Copy Code

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.‎

com_19

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

MicroMod_Input___Display_Carrier_Board_5

If the blue LED remains off, it's probably still sitting in the bootloader. After uploading a sketch, you ‎may need to tap the reset button to get your ESP32 MicroMod to run the sketch.‎

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.‎

‎Please note: Make sure you are connecting to the 2.4GHz band on your wireless router; the ‎ESP32 is not compatible with 5GHz signals.‎

Copy Code

#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.‎

serial_20

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:‎

Copy Code

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:‎

Copy Code

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

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

Copy Code

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

Secondary I²C Initialization Tips

The Wire bus is initialized with the begin function as:‎

Copy Code

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:‎

Copy Code

Wire1.begin(SDA1, SCL1);

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

Copy Code

Wire1.begin(26, 25);

‎Not working as expected and need help?

If you need technical assistance and more information on a product that is not working as you ‎expected, we recommend heading on over to the SparkFun Technical Assistance page for some ‎initial troubleshooting.

SPARKFUN TECHNICAL ASSISTANCE PAGE‎ ‎

If you don't find what you need there, the SparkFun Forums: MicroMod are a great place to find ‎and ask for help. If this is your first visit, you'll need to create a Forum Account to search product ‎forums and post questions.

SPARKFUN FORUMS: MICROMOD

Resources and Going Further

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

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