Temperature alerts with your own firmware

Plug the ESP32-C6-Zero across the middle of the breadboard. The AM2301 has three wires:

Add a 10 kΩ resistor between the yellow wire's column and 3V3. It keeps the data line high between two readings.

Count the pins carefully. On the side of the USB connector, the pins are, in order: 5V, GND, 3V3, GP0. GP0 is the fourth pin, not the third one.

Most Zero boards ship with their pin headers not soldered. Solder them, or the pins will not touch the breadboard. The board still powers up over USB, so nothing looks wrong until you try to read the sensor.

Open Edges → Custom firmware → New project. Name it Climate sensor, pick the chip family ESP32-C6, and create it.

The editor opens with a starter sketch. Everything PNeX needs (Wi-Fi, the encrypted link to the server, over-the-air updates) lives in the PNeX library. Your file only holds your logic.

Click + Lib and pick DHT sensor library. The AM2301 is the same sensor family as the DHT21. The library shows up as a chip next to src/main.cpp.

Only libraries from this list can be used. Their versions are pinned, so the build is the same every time.

Replace the whole content of the editor with this sketch:

// Climate sensor: AM2301 (DHT21) on a Waveshare ESP32-C6-Zero.
// WiFi, device token and encryption key are injected by PneX at build time.
#include <Pnex.h>
#include <DHT.h>

#define DHT_PIN 0        // GP0, yellow wire
#define DHT_TYPE DHT21   // AM2301 = DHT21

PnexDevice pnex;
DHT dht(DHT_PIN, DHT_TYPE);

void setup() {
    Serial.begin(115200);
    dht.begin();

    // Each metric becomes a telemetry series of this device.
    pnex.addMetric("temperature", "°C");
    pnex.addMetric("humidity", "%");

    pnex.begin();  // WiFi + connection to your PneX server
}

unsigned long last_read_ms = 0;

void loop() {
    pnex.loop();  // call it on every iteration, never block with long delays

    // The AM2301 needs at least 2 s between two reads: read every 10 s.
    if (millis() - last_read_ms >= 10000) {
        last_read_ms = millis();
        float t = dht.readTemperature();
        float h = dht.readHumidity();
        if (isnan(t) || isnan(h)) {
            Serial.println("[APP] AM2301 read failed (check wiring)");
            return;
        }
        pnex.publish("temperature", t);
        pnex.publish("humidity", h);
        Serial.printf("[APP] %.1f °C  %.1f %%\n", t, h);
    }
}

Click Save and verify. The server compiles the code for the ESP32-C6 (the first build takes a couple of minutes).

Note what is not in the code: no Wi-Fi password, no server address, no key. PNeX injects them when it builds the firmware for your board.

Open Edges → Devices / Agents → Register. Give the board a name, e.g. climate-1. This name identifies the device everywhere in PNeX, flows included.

Pick Generic ESP32-C6 (Waveshare C6-Zero). Under Firmware, choose Climate sensor instead of the generic PNeX firmware.

Pick your Wi-Fi network, or click + to add one: SSID and password. Use a 2.4 GHz network: ESP boards do not see 5 GHz networks.

Wi-Fi networks you add are saved in Edges → Referentials and offered again for your next boards. The password is only used to compile the firmware.

The board needs the address of your PNeX server. If PNeX server is empty, click the + next to it: the field is pre-filled with the address you are using right now. Click Add. Detect PNeX servers on the LAN finds the server for you if you are not sure.

With an install on pnex.local, the board connects to the Pi's IP address (e.g. 192.168.1.20): ESP boards cannot resolve .local names. If you installed PNeX with a real domain name, this field is fixed and there is nothing to choose.

Check the summary and click Create & build. PNeX compiles a firmware for this board: your code, plus its Wi-Fi, server address and keys.

Plug the board into your computer with a USB data cable. In the device row, click Flash, then Flash again and pick the board's port. It shows up as a USB serial or "USB JTAG/serial debug unit" device.

Use Chrome, Edge or another Chromium browser: flashing uses Web Serial. If no port shows up, hold the BOOT button, press and release RESET, then release BOOT, and try again.

You only flash over USB once. Later versions of your code are installed over the air with Update over the air.

Open Visualization → Quick charts. Pick the metric temperature, the sensor climate-1, click Add, then do the same for humidity.

A new point arrives every 10 seconds. Breathe on the sensor: the humidity jumps within a few readings.

Open Automation → Functions → New function, name it Climate – comfort check, pick Starlark and create it.

Starlark is a small language with Python syntax: def, if, dictionaries, # comments. It runs in a sandbox, so it can only compute: no files, no network. Paste:

# Comfort check for the AM2301: converts the temperature and decides
# when it is too hot. Starlark = Python syntax, sandboxed.
# @input temperature number "Temperature from the sensor, in °C"
# @output too_hot bool "True above the threshold (wire it to the notification trigger)"
# @output celsius string "Temperature in °C, rounded"
# @output fahrenheit string "Temperature in °F, rounded"

THRESHOLD_C = 28.0  # send an alert above this temperature

def one_decimal(x):
    return str(int(x * 10 + 0.5) / 10.0)

def handle(inputs, msg):
    c = inputs["temperature"]
    f = c * 9 / 5 + 32
    return {
        "too_hot": c > THRESHOLD_C,
        "celsius": one_decimal(c),
        "fahrenheit": one_decimal(f),
    }

The @input and @output lines are not plain comments. Each @input becomes an input of the function node in the flow, and each @output becomes an output. handle returns one value per output, under the same name.

Click Save.

Click Test run, type 31.4 for temperature and click Run.

Change THRESHOLD_C to the temperature that matters for you, a greenhouse, a server cupboard or a baby's room, and save again.

Install the ntfy app on your phone and subscribe to a topic with a hard-to-guess name: pnex-climate- followed by a few random letters and digits of your own. Anyone who knows the topic name can read it, so never reuse one from a tutorial.

In PNeX, open Automation → Notifications → New channel → ntfy: server https://ntfy.sh, the same topic, then Create. Use the Test button of the channel: a test message pops up on your phone.

Email, Telegram, Slack or Discord work the same way. See Get alerts by email or on your phone.

Open the Templates tab, then New template:

• Name: Climate – too hot
• Subject: [climate-1] Too hot
• Body:

🌡️ It is {{ celsius }} °C ({{ fahrenheit }} °F) in the room, above your alert threshold.

Declare the two variables celsius and fahrenheit (Add variable), give them example values and click Preview.

At the bottom of the template, Send test to a channel renders the template with the example values and sends it right away. Pick your ntfy channel and click Test: the message pops up on your phone. Then click Save changes.

Open Automation → Flows → New flow and name it Climate – too hot alert.

1. Select the Inject node already on the canvas and set its interval to 300 seconds: the flow runs every 5 minutes.
2. Add a Device (read) node, pick climate-1 and check temperature (metric). Set the freshness window to 120 seconds, so an unplugged sensor never triggers an alert with an old value.

3. Add a Function node and pick Climate – comfort check.
4. Add a Notification node, add your ntfy channel (and in-app if you like) and pick the template Climate – too hot.

Drag the wires:

The notification is sent only while trigger is true. Click Save changes, then Deploy.

You don't have to wait for a heat wave:

• lower THRESHOLD_C below the current temperature in the function, save, select the new version in the flow's Function node and Deploy again;
• or hold the sensor in your hand for a minute.

At the next run (at most 5 minutes) your phone buzzes.

Every message is listed in Automation → Notifications → Events (or Journal on the channel row): date, channel, status (Sent, Failed, Blocked (anti-spam)) and the flow that sent it. Click a row to see the error detail of a failed send.

The ntfy app (or the ntfy web page of your topic) shows the alert with the values rendered by the template.

As long as it stays too hot, you get one message every 5 minutes. Change the Inject interval to get fewer.