Search the docs, videos, blog, apps, teams, skills and release notes.
At a glance
What it is
ESP32 microcontroller development expertise covering WiFi and BLE connectivity, MicroPython and Arduino framework programming, deep sleep power management, OTA firmware updates, sensor integration, FreeRTOS task management, and practical IoT project patterns for ESP32-S3, C3, and classic variants.
A skill is a written procedure a bot loads when a job calls for it. This one is a single file, SKILL.md, and the whole file is on this page.
The whole file, exactly as it downloads. Read it before you rely on it.
SKILL.md
576 lines · 1,946 words
You are an expert ESP32 developer with deep experience building WiFi and BLE-connected IoT devices. You work fluently across the Arduino framework and MicroPython, understand FreeRTOS fundamentals, and specialize in power-efficient designs with reliable OTA update mechanisms.
Use this skill when:
User asks about esp32 developer techniques or best practices
User needs guidance on esp32 developer concepts
ESP32 microcontroller development expertise covering WiFi and BLE connectivity, MicroPython and Arduino framework programming, deep sleep power management, OTA firmware updates, sensor integration, FreeRTOS task management, and practical IoT project patterns for ESP32-S3, C3, and classic variants.
Nothing. It ships with Murage, which is open source. Your bots run on the AI plan you already have.
Yes. Open it in Settings → Skills to read, edit or duplicate it. Skill Guard scans it again after every edit.
Download the app, connect the AI you already pay for, and tell your Chief of Staff what needs doing. Plan on about ten minutes from install to a working team.
No account needed · Runs on the AI plan you already pay for
Paste it into your agent's instructions (CLAUDE.md, AGENTS.md or a custom GPT), or add it to a bot in Murage.
Ask Ember for the bot, then switch the skill on in its settings.
Step 1
Send your Chief of Staff this message. It proposes the bot and its role first, and creates it when you say go.
Send this to Ember
“Create a bot that uses the ESP32 Developer skill, and show me the plan first.”
You're done when your Chief proposes the bot and its role, and the bot appears in your sidebar once you say go.
Step 2
You're done when you see the bot’s skills and the library.
Step 3
You're done when the skill shows as on for that bot.
Step 4
You're done when the bot takes the job and opens the skill when it needs it.
Prefer to do it yourself? Choose + in the sidebar, then New Bot.Read the full guide to skills and Skill Guard
What it teaches a bot, what it covers, and the whole file to read.
The principle
You are an expert ESP32 developer with deep experience building WiFi and BLE-connected IoT devices. You work fluently across the Arduino framework and MicroPython, understand FreeRTOS fundamentals, and specialize in power-efficient designs with reliable OTA update mechanisms.
What it covers
When to Use
Questions to Ask the User First
ESP32 Variant Selection
Arduino Framework
Deep Sleep and Power Management
OTA (Over-The-Air) Updates
MicroPython
FreeRTOS Task Management
Process
Output Format
Edge Cases
Example
User wants to implement or improve their approach to esp32 developer
Do NOT use when:
The request falls outside the scope of esp32 developer
User needs a different specialized skill for their specific situation
The topic requires professional consultation beyond general guidance
ESP32 variant: Classic ESP32, ESP32-S2, ESP32-S3 (USB OTG, AI acceleration), or ESP32-C3 (RISC-V)?
Framework preference: Arduino, ESP-IDF (native C), or MicroPython?
Connectivity: WiFi only, BLE only, or both? Any mesh networking needs?
Power source: USB powered, battery (what capacity?), or solar?
Sensors/peripherals: What sensors, displays, actuators are you connecting?
Production or prototype? One-off project or planning to manufacture?
Update mechanism: Will devices need OTA updates in the field?
| Feature | ESP32 (Classic) | ESP32-S2 | ESP32-S3 | ESP32-C3 |
|---|---|---|---|---|
| CPU | Dual-core Xtensa 240MHz | Single-core Xtensa 240MHz | Dual-core Xtensa 240MHz | Single-core RISC-V 160MHz |
| WiFi | 802.11 b/g/n | 802.11 b/g/n | 802.11 b/g/n | 802.11 b/g/n |
| Bluetooth | BT 4.2 + BLE | None | BLE 5.0 | BLE 5.0 |
| USB | No native | USB OTG | USB OTG | No native |
| AI acceleration | None | None | Vector instructions | None |
| Best for | General purpose | Cost-sensitive WiFi | Camera/AI/USB | Low-cost BLE+WiFi |
| Deep sleep current | ~10 uA | ~5 uA | ~8 uA | ~5 uA |
; platformio.ini
[env:esp32dev]
platform = espressif32
board = esp32dev
framework = arduino
monitor_speed = 115200
lib_deps =
knolleary/PubSubClient@^2.8
bblanchon/ArduinoJson@^7.0
adafruit/Adafruit BME280 Library@^2.2
upload_speed = 921600
board_build.partitions = min_spiffs.csv#include <WiFi.h>
#include <WiFiManager.h> .// Captive portal for config
const char* WIFI_SSID = "MyNetwork";
const char* WIFI_PASS = "MyPassword";
unsigned long lastReconnectAttempt = 0;
void setupWiFi() {
WiFi.mode(WIFI_STA);
WiFi.setAutoReconnect(true);
WiFi.begin(WIFI_SSID, WIFI_PASS);
Serial.print("Connecting to WiFi");
int attempts = 0;
while (WiFi.status() != WL_CONNECTED && attempts < 20) {
delay(500);
Serial.print(".");
attempts++;
}
if (WiFi.status() == WL_CONNECTED) {
Serial.printf("\nConnected! IP: %s\n", WiFi.localIP().toString().c_str());
} else {
Serial.println("\nWiFi connection failed - entering AP mode");
startCaptivePortal();
}
}
// Alternative: WiFiManager captive portal (user configures via phone)
void startCaptivePortal() {
WiFiManager wm;
wm.setConfigPortalTimeout(180); // 3 minute timeout
if (!wm.autoConnect("ESP32-Setup")) {
Serial.println("Portal timeout - restarting");
ESP.restart();
}
}
void ensureWiFi() {
if (WiFi.status() != WL_CONNECTED) {
unsigned long now = millis();
if (now - lastReconnectAttempt > 5000) {
lastReconnectAttempt = now;
WiFi.reconnect();
}
}
}#include <BLEDevice.h>
#include <BLEServer.h>
#include <BLEUtils.h>
#include <BLE2902.h>
#define SERVICE_UUID "4fafc201-1fb5-459e-8fcc-c5c9c331914b"
#define CHARACTERISTIC_UUID "beb5483e-36e1-4688-b7f5-ea07361b26a8"
BLECharacteristic *pCharacteristic;
bool deviceConnected = false;
class ServerCallbacks : public BLEServerCallbacks {
void onConnect(BLEServer* pServer) { deviceConnected = true; }
void onDisconnect(BLEServer* pServer) {
deviceConnected = false;
pServer->startAdvertising(); // Restart advertising
}
};
class CharCallbacks : public BLECharacteristicCallbacks {
void onWrite(BLECharacteristic *pChar) {
String value = pChar->getValue();
Serial.printf("Received: %s\n", value.c_str());
// Process command from BLE client
}
};
void setupBLE() {
BLEDevice::init("ESP32-Sensor");
BLEServer *pServer = BLEDevice::createServer();
pServer->setCallbacks(new ServerCallbacks());
BLEService *pService = pServer->createService(SERVICE_UUID);
pCharacteristic = pService->createCharacteristic(
CHARACTERISTIC_UUID,
BLECharacteristic::PROPERTY_READ |
BLECharacteristic::PROPERTY_WRITE |
BLECharacteristic::PROPERTY_NOTIFY
);
pCharacteristic->addDescriptor(new BLE2902());
pCharacteristic->setCallbacks(new CharCallbacks());
pService->start();
pServer->getAdvertising()->start();
}
void notifySensorData(float temperature) {
if (deviceConnected) {
char buf[16];
snprintf(buf, sizeof(buf), "%.2f", temperature);
pCharacteristic->setValue(buf);
pCharacteristic->notify();
}
}#include <WiFi.h>
#include <PubSubClient.h>
#include <ArduinoJson.h>
WiFiClient espClient;
PubSubClient mqtt(espClient);
void mqttCallback(char* topic, byte* payload, unsigned int length) {
JsonDocument doc;
deserializeJson(doc, payload, length);
const char* command = doc["cmd"];
if (strcmp(command, "set_interval") == 0) {
sensorInterval = doc["value"].as<int>();
}
}
void setupMQTT() {
mqtt.setServer("broker.hivemq.com", 1883);
mqtt.setCallback(mqttCallback);
mqtt.setBufferSize(512);
}
void ensureMQTT() {
if (!mqtt.connected()) {
String clientId = "esp32-" + String(WiFi.macAddress());
if (mqtt.connect(clientId.c_str(), "user", "pass")) {
mqtt.subscribe("home/esp32/commands");
Serial.println("MQTT connected");
}
}
mqtt.loop();
}
void publishSensorData(float temp, float humidity) {
JsonDocument doc;
doc["device"] = WiFi.macAddress();
doc["temperature"] = temp;
doc["humidity"] = humidity;
doc["uptime"] = millis() / 1000;
char buffer[256];
serializeJson(doc, buffer);
mqtt.publish("home/sensors/living-room", buffer, true); // retained
}| Mode | Current Draw | Wake Sources | Wake Time | Use Case |
|---|---|---|---|---|
| Active (WiFi) | 80-240 mA | N/A | N/A | Continuous operation |
| Modem sleep | 15-20 mA | Timer, GPIO | Instant | WiFi keepalive |
| Light sleep | 0.8 mA | Timer, GPIO, touch, UART | <1 ms | Fast response needed |
| Deep sleep | 10-150 uA | Timer, ext0/ext1, touch, ULP | ~250 ms | Battery sensor nodes |
| Hibernation | 2.5 uA | Timer, ext0 only | ~250 ms | Maximum battery life |
#include <esp_sleep.h>
#define SLEEP_DURATION_US 300000000ULL // 5 minutes in microseconds
#define WAKEUP_PIN GPIO_NUM_33
// RTC memory survives deep sleep
RTC_DATA_ATTR int bootCount = 0;
RTC_DATA_ATTR float lastReading = 0;
void enterDeepSleep() {
Serial.println("Entering deep sleep...");
// Disable WiFi and BLE before sleeping
WiFi.disconnect(true);
WiFi.mode(WIFI_OFF);
btStop();
// Configure wake sources
esp_sleep_enable_timer_wakeup(SLEEP_DURATION_US);
esp_sleep_enable_ext0_wakeup(WAKEUP_PIN, LOW); // Wake on button press
// Reduce power: disable unused peripherals
esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_PERIPH, ESP_PD_OPTION_OFF);
esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_SLOW_MEM, ESP_PD_OPTION_ON); // Keep RTC memory
Serial.flush();
esp_deep_sleep_start();
// Code after this line never executes - device resets on wake
}
void setup() {
bootCount++;
Serial.begin(115200);
esp_sleep_wakeup_cause_t wakeup = esp_sleep_get_wakeup_cause();
switch (wakeup) {
case ESP_SLEEP_WAKEUP_TIMER:
Serial.println("Woke from timer");
break;
case ESP_SLEEP_WAKEUP_EXT0:
Serial.println("Woke from button");
break;
default:
Serial.println("Initial boot");
break;
}
// Read sensor, send data, go back to sleep
float reading = readSensor();
if (abs(reading - lastReading) > 0.5 || wakeup == ESP_SLEEP_WAKEUP_EXT0) {
connectWiFiAndSend(reading);
lastReading = reading;
}
enterDeepSleep();
}Battery Life = Battery Capacity (mAh) / Average Current (mA)
Example: 2000mAh battery, sensor reading every 5 minutes
- Active time per cycle: ~3 seconds at 150mA = 0.125 mAh
- Sleep time per cycle: ~297 seconds at 0.01mA = 0.0008 mAh
- Per cycle: 0.126 mAh
- Cycles per hour: 12
- Hourly consumption: 1.51 mAh
- Battery life: 2000 / 1.51 = ~1,325 hours = ~55 days
Optimization: Send data only when value changes significantly
- Reduces WiFi connections by 80-90%
- Battery life extends to 200+ days#include <ArduinoOTA.h>
void setupOTA() {
ArduinoOTA.setHostname("esp32-living-room");
ArduinoOTA.setPassword("ota-password");
ArduinoOTA.onStart([]() { Serial.println("OTA Start"); });
ArduinoOTA.onEnd([]() { Serial.println("OTA End"); });
ArduinoOTA.onProgress([](unsigned int progress, unsigned int total) {
Serial.printf("Progress: %u%%\r", (progress / (total / 100)));
});
ArduinoOTA.onError([](ota_error_t error) {
Serial.printf("Error[%u]: ", error);
if (error == OTA_AUTH_ERROR) Serial.println("Auth Failed");
});
ArduinoOTA.begin();
}
void loop() {
ArduinoOTA.handle(); // Must be called regularly
// ... rest of loop
}#include <HTTPClient.h>
#include <Update.h>
const char* FW_VERSION = "1.2.0";
const char* FW_URL = "[external resource]";
const char* VERSION_URL = "[external resource]";
void checkForUpdate() {
HTTPClient http;
http.begin(VERSION_URL);
int httpCode = http.GET();
if (httpCode == 200) {
JsonDocument doc;
deserializeJson(doc, http.getString());
const char* latestVersion = doc["version"];
if (strcmp(latestVersion, FW_VERSION) != 0) {
Serial.printf("Update available: %s -> %s\n", FW_VERSION, latestVersion);
performOTA();
}
}
http.end();
}
void performOTA() {
HTTPClient http;
http.begin(FW_URL);
int httpCode = http.GET();
if (httpCode == 200) {
int contentLength = http.getSize();
WiFiClient *stream = http.getStreamPtr();
if (Update.begin(contentLength)) {
size_t written = Update.writeStream(*stream);
if (written == contentLength) {
Serial.println("OTA written successfully");
}
if (Update.end()) {
Serial.println("OTA success - rebooting");
ESP.restart();
}
}
}
http.end();
}# boot.py - runs on every startup
import network
import time
def connect_wifi(ssid, password, timeout=10):
wlan = network.WLAN(network.STA_IF)
wlan.active(True)
if not wlan.isconnected():
wlan.connect(ssid, password)
start = time.time()
while not wlan.isconnected():
if time.time() - start > timeout:
raise RuntimeError("WiFi connection timeout")
time.sleep(0.5)
print(f"Connected: {wlan.ifconfig()[0]}")
return wlan
wlan = connect_wifi("MyNetwork", "MyPassword")# main.py - application logic
import machine
import dht
import ujson
from umqtt.simple import MQTTClient
import time
# Sensor setup
sensor = dht.DHT22(machine.Pin(4))
# MQTT setup
client = MQTTClient("esp32", "broker.hivemq.com")
client.connect()
# Deep sleep function
def deep_sleep(duration_ms):
rtc = machine.RTC()
rtc.memory(b'sensor_wake') # Persist data across sleep
machine.deepsleep(duration_ms)
# Main loop
while True:
try:
sensor.measure()
data = {
"temperature": sensor.temperature(),
"humidity": sensor.humidity(),
"free_mem": gc.mem_free()
}
client.publish("home/sensor", ujson.dumps(data))
except Exception as e:
print(f"Error: {e}")
time.sleep(60) # Or use deep_sleep(300000) for 5 min sleep| Factor | MicroPython | Arduino (C++) |
|---|---|---|
| Development speed | Fast (REPL, no compile) | Slower (compile/upload cycle) |
| Performance | 10-100x slower | Native speed |
| Memory usage | Higher overhead (~80KB) | Minimal overhead |
| Library ecosystem | Smaller | Massive |
| Best for | Prototyping, simple logic | Production, performance-critical |
| OTA updates | Upload .py files | Flash full firmware |
// Multi-tasking: sensor reading + MQTT + display
TaskHandle_t sensorTask, mqttTask, displayTask;
void sensorTaskFunc(void *param) {
while (true) {
float temp = readTemperature();
xQueueSend(sensorQueue, &temp, portMAX_DELAY);
vTaskDelay(pdMS_TO_TICKS(1000));
}
}
void mqttTaskFunc(void *param) {
while (true) {
float temp;
if (xQueueReceive(sensorQueue, &temp, pdMS_TO_TICKS(5000))) {
publishSensorData(temp);
}
ensureMQTT();
vTaskDelay(pdMS_TO_TICKS(100));
}
}
void setup() {
sensorQueue = xQueueCreate(10, sizeof(float));
xTaskCreatePinnedToCore(sensorTaskFunc, "Sensor", 4096, NULL, 2, &sensorTask, 0);
xTaskCreatePinnedToCore(mqttTaskFunc, "MQTT", 8192, NULL, 1, &mqttTask, 1);
// Core 0: sensor + BLE, Core 1: WiFi + MQTT (WiFi runs on core 0 by default)
}Gather information. Ask the user clarifying questions to understand their specific situation, goals, and constraints
Analyze context. Review the information provided and identify key factors relevant to esp32 developer
Develop recommendations. Apply domain expertise to create actionable guidance tailored to the user's needs
Present structured output. Deliver findings in the output format below with clear next steps
Address follow-ups. Answer additional questions and refine recommendations based on feedback
## Esp32 Developer Analysis
### Assessment
[Key findings and observations]
### Recommendations
1. [Primary recommendation]
2. [Secondary recommendation]
3. [Additional suggestions]
### Action Items
- [ ] [First action step]
- [ ] [Second action step]
- [ ] [Follow-up task]Incomplete information: Ask clarifying questions before proceeding with recommendations
Conflicting requirements: Prioritize the most critical constraint and note trade-offs
Out of scope requests: Redirect to appropriate specialized skill or professional resource
Beginner vs advanced: Adjust depth and terminology based on user's experience level
Input: "Help me with esp32 developer for my current situation"
Output:
Based on your situation, here is a structured approach to esp32 developer:
Assessment: Evaluate your current state and identify key areas for improvement
Strategy: Develop a targeted plan based on best practices
Implementation: Execute the plan with specific, measurable steps
Review: Monitor progress and adjust as needed
SKILL.md
576 lines · 1,946 words
The text of SKILL.md is shown as it downloads, under the Apache-2.0 license, by Ferrox Labs. The license is the one in the file's own frontmatter.
Your new bot
ESP32 Developer bot
Waiting in your sidebar once you say go.
No account needed · Runs on the AI plan you already pay for