The landscape of internet of things prototyping has undergone a massive transformation over the past decade. We have moved from basic eight bit microcontrollers with external, power hungry wireless modules to highly integrated, dual core system on chip solutions that fit on the tip of a finger. At the forefront of this evolution is SparkFun Electronics, a manufacturer renowned for creating robust, developer friendly hardware. Their SparkFun Thing Plus ESP32 WROOM, featuring the classic Micro B USB interface, represents a peak refinement of the ESP32 platform. It blends the highly capable Espressif silicon with the versatile Feather compatible footprint and SparkFun's own solderless Qwiic ecosystem.
In this comprehensive review and technical guide, we will dissect the hardware architecture of this board, analyze its power delivery systems, explore best practices for pin routing, and demonstrate how to leverage its dual core processor for advanced edge computing applications.
Silicon Architecture: The Heart of the Beast
At the core of the SparkFun Thing Plus is the ESP32 WROOM 32D module, which houses the Tensilica Xtensa dual core thirty two bit LX6 microprocessor. Unlike traditional single core microcontrollers that must multiplex time critical communication tasks with user application code, this dual core architecture allows for true parallel processing.
The two cores are designated as Protocol CPU (PRO_CPU) and Application CPU (APP_CPU). By default, the FreeRTOS operating system, which runs under the hood in the Arduino environment, manages the distribution of tasks. Typically, the PRO_CPU handles the heavy lifting of the WiFi and Bluetooth protocol stacks, while the APP_CPU is left entirely free to execute user code. This division of labor prevents wireless communication latency from interrupting time sensitive sensor readings or motor control loops.
Memory Mapping and Storage
The silicon is equipped with 520 kilobytes of internal SRAM, which is exceptionally generous for a microcontroller. This memory is split into instruction memory and data memory, optimized for high speed access by both cores. To complement this internal volatile memory, the WROOM module on this board includes 16 megabytes of external SPI flash memory. This massive storage capacity allows developers to store complex web assets, local databases, machine learning models, and extensive firmware images with ease. It also enables robust Over The Air firmware updates, as the flash can comfortably hold two full system images simultaneously alongside user data.
Wireless Coexistence
The wireless radio inside the ESP32 is a marvel of integration. It supports 802.11 b/g/n WiFi with speeds up to 150 megabits per second, alongside Bluetooth 4.2 classic and Bluetooth Low Energy. The radio shares a single internal antenna through an integrated RF switch, balun, and low noise amplifier. Thanks to sophisticated internal coexistence algorithms, the module can transition seamlessly between WiFi and Bluetooth communication, making it an ideal gateway for bridging local BLE sensor networks to cloud based MQTT brokers.
The Thing Plus Form Factor and Qwiic Integration
SparkFun's "Thing Plus" layout is their proprietary take on the popular Adafruit Feather footprint. This design choice is a massive win for developers, as it grants immediate access to a vast ecosystem of third party shields, accessories, and enclosures. The board layout is logical, clean, and optimized for breadboard prototyping, with all pins broken out to standard 0.1 inch pitch headers.
Perhaps the most significant usability feature of this board is the inclusion of a Qwiic connector. The Qwiic system is a four pin JST connector interface that utilizes the I2C protocol for communication. By standardizing power, ground, clock, and data lines on a polarized connector, SparkFun has eliminated the need for soldering or manual wiring when connecting sensors, displays, and controllers. You can daisy chain multiple Qwiic devices together on a single bus, drastically reducing prototyping time and eliminating common wiring errors.
Power Architecture and Battery Management
Portable, battery powered operation is a primary use case for the ESP32, and SparkFun has designed the power path of the Thing Plus with extreme care. The board features three primary power sources: the Micro B USB port, a two pin JST connector for a single cell Lithium Polymer battery, and the external pins.
Onboard Charging and Regulation
Battery charging is handled by the MCP73831 linear charge management controller. When the board is plugged into a USB power source, this controller charges the connected LiPo battery at a safe, pre configured rate of 500 milliamperes. A yellow charge status LED provides visual feedback, illuminating during the charge cycle and turning off once the battery is fully charged.
Power regulation is managed by the AP2112 3.3 volt low dropout regulator. This specific regulator was chosen for its ability to deliver up to 600 milliamperes of continuous current. This is a critical specification because the ESP32's WiFi radio is notoriously power hungry, drawing transient current spikes of up to 500 milliamperes during transmission phases. Cheaper development boards often use underpowered 300 milliampere regulators, leading to mysterious brownouts and system resets when the WiFi radio initializes. The AP2112 ensures rock solid stability even under heavy network loads.
Low Power Sleep States
For remote deployments, minimizing power consumption is paramount. The ESP32 WROOM module supports several low power modes, the most efficient of which is Deep Sleep. In this state, the CPUs, WiFi radio, and most internal peripherals are powered down. Only the Ultra Low Power co-processor and the Real Time Clock recovery memory remain active.
By utilizing deep sleep, the overall current draw of the board can be reduced to the microampere range. However, developers must be aware of the quiescent current drawn by the supporting circuitry. The AP2112 regulator and the battery monitoring voltage divider still consume a small amount of power, but the overall design remains highly optimized for multi month battery operation when proper sleep cycles are implemented.
Pinout Routing and Hardware Design Best Practices
While the ESP32 is incredibly flexible, its high pin count and multiplexed peripheral matrix require careful planning during hardware design. Not all pins are created equal, and misconfiguring certain pins can lead to boot failures or unexpected behavior.
Understanding Strapping Pins
The ESP32 uses a set of five strapping pins during the boot process to determine the chip's operating mode, flash voltage, and boot source. These pins are:
- GPIO 0: Determines boot mode (must be pulled high for normal execution, pulled low to enter flashing mode)
- GPIO 2: Must be left floating or pulled low during boot
- GPIO 5: Controls SDIO timing (must be pulled high during boot)
- GPIO 12: Selects flash voltage (must be pulled low for 3.3V flash, which is standard on this module)
- GPIO 15: Controls boot debug output (must be pulled high)
Because the SparkFun Thing Plus has onboard pull up and pull down resistors to handle these states automatically, you must be extremely cautious when connecting external hardware to these pins. If an external sensor pulls GPIO 12 high during boot, the internal flash memory will be supplied with 1.8V instead of 3.3V, causing an immediate boot loop.
Analog to Digital Converter Limitations
The ESP32 features two separate twelve bit Analog to Digital Converters: ADC1 and ADC2. This is a common source of frustration for developers. ADC2 is internally shared with the WiFi subsystem. Consequently, if your application has WiFi active, any attempt to read an analog voltage from a pin routed to ADC2 will fail or return highly inaccurate readings. For reliable analog sensor integration, always prioritize pins routed to ADC1, which include GPIO 32 through 39.
Edge Computing and Real World Applications
The combination of dual core processing, ample memory, and wireless connectivity makes the SparkFun Thing Plus ESP32 an exceptional platform for edge computing. Edge computing involves processing data locally on the device rather than sending raw sensor streams to the cloud. This reduces bandwidth consumption, lowers latency, and improves privacy.
For example, in a smart agriculture application, the board can interface with multiple SDI twelve soil moisture sensors, perform local digital filtering and anomaly detection on Core 1, and use Core 0 to securely transmit aggregated daily summaries over WiFi. In industrial environments, the board can run lightweight machine learning models, such as TinyML keyword spotting or vibration anomaly detection, directly on the edge, triggering local relays instantly if a fault is detected.
Firmware Implementation: Dual Core FreeRTOS Harness
To truly unlock the potential of the SparkFun Thing Plus, developers should write firmware that explicitly utilizes both processing cores. The following production grade Arduino C++ code demonstrates how to set up a dual core system. Core 0 is dedicated to managing a simulated WiFi connection and telemetry transmission, while Core 1 runs a high priority sensor acquisition loop.
CPP Test Harness#include <Arduino.h> // Define task handles for dual core execution TaskHandle_t TelemetryTaskHandle = NULL; TaskHandle_t SensorTaskHandle = NULL; // Shared resource mutex to prevent data corruption SemaphoreHandle_t resourceMutex; // Simulated shared sensor data structure struct SensorData { float temperature; float humidity; uint32_t readingCount; } sharedData; // Task for Core 0: Handling network operations and telemetry void TelemetryTask(void * pvParameters) { (void) pvParameters; Serial.print("Telemetry Task running on Core "); Serial.println(xPortGetCoreID()); for (;;) { // Acquire the mutex before accessing shared data if (xSemaphoreTake(resourceMutex, portMAX_DELAY) == pdTRUE) { Serial.println("--- Telemetry Report ---"); Serial.printf("Readings Collected: %u\n", sharedData.readingCount); Serial.printf("Temperature: %.2f C\n", sharedData.temperature); Serial.printf("Humidity: %.2f %%\n", sharedData.humidity); Serial.println("------------------------"); // Release the mutex xSemaphoreGive(resourceMutex); } // Simulate sending data over WiFi every five seconds vTaskDelay(pdMS_TO_TICKS(5000)); } } // Task for Core 1: High speed sensor acquisition void SensorTask(void * pvParameters) { (void) pvParameters; Serial.print("Sensor Task running on Core "); Serial.println(xPortGetCoreID()); for (;;) { // Simulate sensor read latency vTaskDelay(pdMS_TO_TICKS(1000)); // Acquire the mutex to update shared data safely if (xSemaphoreTake(resourceMutex, portMAX_DELAY) == pdTRUE) { sharedData.temperature = 20.0f + (float)(rand() % 150) / 10.0f; sharedData.humidity = 40.0f + (float)(rand() % 500) / 10.0f; sharedData.readingCount++; // Release the mutex xSemaphoreGive(resourceMutex); } } } void setup() { Serial.begin(115200); while (!Serial) { ; // Wait for serial port to connect } // Create the mutex semaphore resourceMutex = xSemaphoreCreateMutex(); if (resourceMutex == NULL) { Serial.println("Failed to create mutex semaphore!"); while (1); } // Initialize shared data structure sharedData.temperature = 0.0f; sharedData.humidity = 0.0f; sharedData.readingCount = 0; // Spawn Telemetry Task on Core 0 with lower priority xTaskCreatePinnedToCore( TelemetryTask, "TelemetryTask", 4096, NULL, 1, &TelemetryTaskHandle, 0 ); // Spawn Sensor Task on Core 1 with higher priority xTaskCreatePinnedToCore( SensorTask, "SensorTask", 4096, NULL, 2, &SensorTaskHandle, 1 ); } void loop() { // The main loop runs on Core 1 but can be left empty when using FreeRTOS tasks vTaskDelete(NULL); }
Common Prototyping Pitfalls to Avoid
Even seasoned engineers can run into issues when working with the ESP32 platform. Here are the most common pitfalls to avoid when working with the SparkFun Thing Plus:
- Powering High Current Peripherals from the 3.3V Pin: While the AP2112 regulator can supply 600 milliamperes, the ESP32 itself can consume up to 500 milliamperes during peak WiFi transmissions. This leaves very little headroom for external sensors, displays, or motors. Always power high current devices from an external power supply or directly from the VUSB pin when connected to USB.
- Using ADC2 Pins with WiFi: As discussed, attempting to read analog sensors on ADC2 pins while WiFi is active will result in garbage data. Always route critical analog inputs to ADC1 pins.
- Leaving Floating Inputs on Strapping Pins: If you connect external pull up or pull down resistors to GPIO 0, 2, 5, 12, or 15, ensure they do not interfere with the default boot states. A common mistake is connecting a button to GPIO 0 without a proper series resistor, which can accidentally force the chip into bootloader mode during a manual reset.
- Neglecting the Ground Plane in Custom Shields: When designing custom add on boards or shields for the Thing Plus, ensure you maintain a solid ground plane. The high frequency RF signals from the onboard antenna can easily couple into high impedance analog traces, causing severe noise and measurement errors.
The Verdict
The SparkFun Thing Plus ESP32 WROOM (Micro B) is an exceptionally well engineered development board that successfully tames the raw power of the ESP32. By pairing the dual core processor with the robust AP2112 regulator, the Feather compatible footprint, and the solderless Qwiic ecosystem, SparkFun has created a platform that is equally at home on a hobbyist's workbench or in an industrial deployment. It remains a gold standard for modern IoT prototyping.
Frequently Asked Questions
-
What is the maximum input voltage allowed on the VUSB pin of the SparkFun Thing Plus? The VUSB pin is designed to accept standard USB voltage, which is nominally 5 volts. The absolute maximum voltage should not exceed 5.5 volts to prevent damage to the MCP73831 charging IC and the AP2112 regulator.
-
Are the GPIO pins on this board 5V tolerant? No, all GPIO pins on the ESP32 are strictly 3.3V tolerant. Applying 5V directly to any digital or analog pin will cause permanent physical damage to the silicon.
-
Can I use the Qwiic connector and the standard I2C pins simultaneously? Yes, the Qwiic connector is internally wired to the same I2C bus as the standard physical SDA and SCL pins (GPIO 21 and GPIO 22). You can use both interfaces simultaneously, provided that all connected devices have unique I2C addresses.
-
How does the board handle power switching when both USB and a LiPo battery are connected? The board features an onboard P channel MOSFET and diode circuit that acts as an ideal diode switch. When USB power is present, it automatically powers the system and charges the battery. When USB is disconnected, the system transitions seamlessly to battery power without interrupting execution.
-
Why does the onboard yellow LED blink rapidly when no battery is connected? When the board is powered via USB and no battery is connected to the JST port, the MCP73831 charge controller detects the absence of a battery and enters a fault or search state, causing the yellow charge LED to flicker or blink rapidly. This is normal behavior.
-
What is the default clock frequency of the ESP32 on this board and can it be changed? The default clock frequency is 240 MHz. It can be scaled down to 160 MHz, 80 MHz, or lower in software to significantly reduce active power consumption when high processing speeds are not required.