The ESP32 family.

What it is.

A microcontroller is a whole little computer on a single chip: a processor, a bit of memory, and a set of pins it can read and switch. Unlike a Raspberry Pi it runs no operating system. It runs one program, forever, the moment it powers on. That makes it cheap, rugged, and frugal with power, which is what you want bolted to a bench in a greenhouse, waking every few minutes to take a reading.

What sets the ESP32 apart from the microcontrollers that came before it is that the radio is on the chip. Wi-Fi and Bluetooth are not add-on boards; they are built in. So a part that costs about as much as a sandwich can stand on its own, join your Wi-Fi, and send a number somewhere useful. It is the Collect layer made as small and as cheap as it honestly gets.

Why a grower cares.

A sensor on its own is usually not smart. Many of the cheap ones do nothing more than change a voltage or a resistance as the world around them changes: warmer, wetter, brighter. Something has to read that small electrical change and turn it into a number you can use. That job is the microcontroller’s, and the ESP32 does it for a few dollars while also carrying the number out over Wi-Fi. (Some sensors do include their own little chip and hand over a finished digital reading. The ESP32 talks to those just as happily.)

The point, in this work, is not the chip. It is what the chip lets you own. Because the part is commodity and the tools are open, the reading it produces is yours from the first second. It goes to the endpoint you name and lives in the place you keep, and it keeps working if any one vendor walks away. That is the own-your-data rule expressed in hardware. A grower with a ten-dollar board and an afternoon has a sensor network that no one can switch off or rent back to them.

On its own, or part of a system.

An ESP32 build works two ways, and the same board does both. On its own, it is self-contained: it reads its sensor, then sends each reading straight to an endpoint you choose, such as a webhook, a small script, or a database you run. Nothing else has to exist for it to do its job, and that is often all a single bench or tunnel needs.

As part of a system, it becomes one node among many, reporting into something larger that collects every reading, draws the graphs, and runs the automations. The system we embrace here is Home Assistant paired with ESPHome: you describe the board in a short config file, and it appears in Home Assistant with history, dashboards, and rules, and every reading stays yours to keep and export. It is one good option, not the only one. The same board will report to an MQTT broker, a Node-RED flow, or a cloud you run, because it sends wherever you point it. Start standalone and grow into a system later without changing the hardware.

The family at a glance.

“ESP32” names a family, not a single part. The 2016 original, now called the classic ESP32, was joined by a run of newer variants, each tuned for a different job. Two splits matter most. The first is the processor: the original and the S-series use Espressif’s Xtensa cores, while the newer C-, H- and P-series moved to the open RISC-V architecture. The second is the radios: each variant carries a different mix of Wi-Fi, Bluetooth, and the low-power 802.15.4 radio that speaks Thread and Zigbee (the basis of Matter). Get those two right and the rest is detail.

A quick read on the six you will actually meet:

• ESP32 (classic). The workhorse, with the most code examples and the only Bluetooth Classic in the family (for audio). Dirt cheap. Its one quirk: no USB on the chip, so the board carries a separate USB-to-serial bridge.
• ESP32-S2. Single-core with native USB, but no Bluetooth. A specialist for USB-peripheral projects, and the wrong pick for anything that needs BLE.
• ESP32-S3. The powerhouse: dual-core, Wi-Fi and BLE 5, native USB, extra memory, plus vector instructions for on-device AI. This is the one to grow into for cameras, displays, and machine learning.
• ESP32-C3. The value pick. A single RISC-V core, Wi-Fi and BLE 5, and native USB, at the lowest price in the family. The right default for an everyday sensor node, and the Open Agriculture Technology recommendation.
• ESP32-C6. The future-proof choice: Wi-Fi 6, BLE 5, and the 802.15.4 radio for Thread, Zigbee, and Matter, with a low-power second core. Pick it if you are building toward a smart-home mesh.
• ESP32-H2. The mesh specialist: BLE and Thread/Zigbee, but no Wi-Fi. For low-power battery devices on a Matter or Zigbee network, not for pushing to a cloud on its own.

Three more sit on the edges: the bargain ESP32-C2 (ESP8684), the dual-band Wi-Fi 6 ESP32-C5, and the high-horsepower ESP32-P4 application processor, which carries no radio at all and pairs with one of the others. Most growers never need them.

Compare the variants.

Here are the differences that change a buying decision, side by side. The tinted column is the Open Agriculture Technology value default. The last row ties back to the listener sketch, which needs both Wi-Fi and Bluetooth, so two variants are out.

GPIO counts are usable pins on a typical dev board and vary by package; clocks are in MHz. “Wi-Fi 4” is 802.11 b/g/n on 2.4 GHz; “Wi-Fi 6” adds 802.11ax. The classic ESP32 is the only variant with Bluetooth Classic; the rest are BLE-only.

What’s inside.

For all the variation, every ESP32 is the same handful of blocks on one die: one or two processor cores, a little fast memory, the radio and its antenna, a flash chip holding your program, and the pins and peripherals that touch the real world. A low-power coprocessor can keep watch while the main cores sleep.

Anatomy of a dev board.

You almost never buy the bare chip. You buy a development board: the chip’s module soldered onto a small circuit board that adds a USB socket, a voltage regulator, two buttons, and rows of header pins you can plug jumper wires into. That is the thing in your hand. Here is what you are looking at.

The two buttons matter the first time. BOOT (sometimes IO0) and RESET (EN) put the board into flashing mode. On most modern boards the tools handle that for you. On a stubborn classic ESP32 you hold BOOT, tap RESET, and release. Worth knowing before you decide a board is dead.

Where it fits, and where it doesn’t.

The honest line. The ESP32 is the right answer more often than not in this work. It is a microcontroller, not a computer, so a couple of jobs belong to something else.

How you program it.

There is a path for every comfort level, and all of them are free. You can start at the top and never go lower, or drop down a rung whenever you want more control.

• No code: flash a finished sketch. The Software Library flashes ready-made firmware straight from your browser. One button, and you never see the code unless you want to.
• ESPHome: config, not code. Describe your sensors in a short YAML file, and ESPHome builds the firmware and bridges it cleanly into Home Assistant. The sweet spot for most grower automations.
• Arduino IDE: the gentle on-ramp to code. Add the arduino-esp32 core and you can open, edit, and flash a .ino sketch. This is what most of our sketches are written in.
• PlatformIO: the project workbench. Builds for every variant from one project, with libraries and versions pinned. This is how we ship the firmware.
• ESP-IDF: the full control. Espressif’s own framework. Everything the chip can do, nothing hidden. The deep end.
• MicroPython: Python on the chip. If you already think in Python, you can write straight to the board.

A first ESPHome config is about this short. This one reads a temperature and humidity sensor and publishes it to Home Assistant:

esphome:
  name: greenhouse-node

esp32:
  board: esp32-c3-devkitm-1   # match your board

wifi:
  ssid: "BarnWiFi"
  password: !secret wifi_password

sensor:
  - platform: dht
    pin: GPIO4
    temperature:
      name: "Greenhouse Temperature"
    humidity:
      name: "Greenhouse Humidity"
    update_interval: 60s

Choosing one.

Skip the analysis paralysis. For almost everyone the answer is short:

Two rules cover the rest. Prefer a board with a USB-C socket and native USB (the C- and S-series) so flashing needs no driver. And buy from a seller who names the exact variant. “ESP32” alone on a listing is not enough to know what you are getting.

Buying and gotchas.

The board is cheap and forgiving, but a handful of things trip up nearly everyone the first time. Worth a read before you blame the hardware.

• 3.3 V, not 5 V. The ESP32’s logic is 3.3 V and the pins are not 5 V tolerant. Feeding a 5 V signal into a GPIO can kill it, so level-shift older 5 V sensors.
• The ADC is noisy. The built-in analog-to-digital converter is non-linear at the rails and jumpy. On the classic ESP32 the second ADC cannot be used while Wi-Fi is on. Average your readings, or use a sensor with a digital (I²C) output.
• Use a data USB cable. Charge-only cables are the most common “it won’t connect” culprit. If the board does not appear, swap the cable first.
• Classic boards may need a driver. The USB-to-serial chip on a classic ESP32 (CP2102 or CH340) sometimes needs a one-time driver. Native-USB variants (C3, S3, C6) do not.
• 2.4 GHz Wi-Fi only. No ESP32 joins a 5 GHz network (the C5 is the lone exception), so make sure your router exposes a 2.4 GHz band.
• Watch the antenna version. Most boards have a PCB trace antenna. Some come with a tiny external-antenna connector (U.FL or IPEX) and need one attached, or range collapses.
• Counterfeits and mislabels exist. A board sold as one variant is occasionally another. Buy from a reputable seller, and confirm the chip the tools report after flashing.

Official resources.

Straight to the source. These open in a new tab:

Espressif: all ESP32 chips and datasheets ESP-IDF documentation Arduino core (arduino-esp32) ESPHome (for Home Assistant) esptool (the flashing tool)