• MCU/module: ESP32-C3-WROOM-02-N4
• Framework: Arduino on PlatformIO
• Sensor: Sensirion SHT40-AD1B-R3, I2C address 0x44
• USB programming/debug: native ESP32-C3 USB Serial/JTAG on IO18/IO19

Ini
[env:esp32-c3-devkitm-1]
platform = espressif32
board = esp32-c3-devkitm-1
framework = arduino
monitor_speed = 115200
upload_speed = 460800
build_flags =
    -D ARDUINO_USB_MODE=1
    -D ARDUINO_USB_CDC_ON_BOOT=1
lib_deps =
    adafruit/Adafruit SHT4x Library@^1.0.5
    h2zero/NimBLE-Arduino@^1.4.2

Cpp
#include <Arduino.h>
#include <Wire.h>
#include <WiFi.h>
#include <HTTPClient.h>
#include <Adafruit_SHT4x.h>
#include <NimBLEDevice.h>

// Pin definitions from schematic
#define I2C_SDA_PIN      4
#define I2C_SCL_PIN      5
#define STATUS_LED_PIN   10
#define BOOT_BUTTON_PIN  9

// SHT40 default I2C address is 0x44. The Adafruit driver handles this internally.
#define SENSOR_READ_INTERVAL_MS 10000UL
#define WIFI_RETRY_INTERVAL_MS  30000UL

const char* WIFI_SSID = "YOUR_WIFI_SSID";
const char* WIFI_PASSWORD = "YOUR_WIFI_PASSWORD";
const char* HTTP_ENDPOINT = "http://example.local/environment";

Adafruit_SHT4x sht4;
unsigned long lastSensorRead = 0;
unsigned long lastWifiAttempt = 0;
bool sensorReady = false;

NimBLEServer* bleServer = nullptr;
NimBLECharacteristic* envCharacteristic = nullptr;

static void setStatusLed(bool on) {
  digitalWrite(STATUS_LED_PIN, on ? HIGH : LOW);
}

static void initI2CAndSensor() {
  Wire.begin(I2C_SDA_PIN, I2C_SCL_PIN, 400000);

  sensorReady = sht4.begin(&Wire);
  if (!sensorReady) {
    Serial.println("ERROR: SHT40 not found on I2C address 0x44");
    return;
  }

  sht4.setPrecision(SHT4X_HIGH_PRECISION);
  sht4.setHeater(SHT4X_NO_HEATER);  // Keep heater off for low-power normal operation.
  Serial.println("SHT40 initialized");
}

static void initWiFi() {
  WiFi.mode(WIFI_STA);
  WiFi.setSleep(true);
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  lastWifiAttempt = millis();
  Serial.print("Connecting to WiFi");
}

static void maintainWiFi() {
  if (WiFi.status() == WL_CONNECTED) {
    return;
  }

  unsigned long now = millis();
  if (now - lastWifiAttempt >= WIFI_RETRY_INTERVAL_MS) {
    Serial.println("Retrying WiFi connection");
    WiFi.disconnect(true);
    delay(50);
    WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
    lastWifiAttempt = now;
  }
}

static void initBLE() {
  NimBLEDevice::init("EnvNode-C3");
  NimBLEDevice::setPower(ESP_PWR_LVL_N0);  // Conservative BLE TX power for consumer node.

  bleServer = NimBLEDevice::createServer();
  NimBLEService* service = bleServer->createService("181A");  // Environmental Sensing service

  envCharacteristic = service->createCharacteristic(
      "2A6E",  // Temperature characteristic UUID
      NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::NOTIFY);

  envCharacteristic->setValue("0.00 C, 0.00 %RH");
  service->start();

  NimBLEAdvertising* adv = NimBLEDevice::getAdvertising();
  adv->addServiceUUID("181A");
  adv->setScanResponse(true);
  adv->start();

  Serial.println("BLE environmental service advertising");
}

static bool readSHT40(float& temperatureC, float& humidityPercent) {
  if (!sensorReady) {
    return false;
  }

  sensors_event_t humidity;
  sensors_event_t temp;
  bool ok = sht4.getEvent(&humidity, &temp);
  if (!ok) {
    Serial.println("ERROR: SHT40 read failed");
    return false;
  }

  temperatureC = temp.temperature;
  humidityPercent = humidity.relative_humidity;
  return true;
}

static void publishWiFi(float temperatureC, float humidityPercent) {
  if (WiFi.status() != WL_CONNECTED) {
    Serial.println("WiFi not connected; skipping HTTP publish");
    return;
  }

  HTTPClient http;
  http.begin(HTTP_ENDPOINT);
  http.addHeader("Content-Type", "application/json");

  String payload = "{\"temperature_c\":" + String(temperatureC, 2) +
                   ",\"humidity_percent\":" + String(humidityPercent, 2) + "}";

  int code = http.POST(payload);
  Serial.printf("HTTP POST %d: %s\n", code, payload.c_str());
  http.end();
}

static void publishBLE(float temperatureC, float humidityPercent) {
  if (envCharacteristic == nullptr) {
    return;
  }

  char payload[48];
  snprintf(payload, sizeof(payload), "%.2f C, %.2f %%RH", temperatureC, humidityPercent);
  envCharacteristic->setValue((uint8_t*)payload, strlen(payload));
  envCharacteristic->notify();
}

void setup() {
  pinMode(STATUS_LED_PIN, OUTPUT);
  pinMode(BOOT_BUTTON_PIN, INPUT_PULLUP);
  setStatusLed(false);

  Serial.begin(115200);
  delay(500);
  Serial.println("USB-C WiFi/BLE Environmental Sensor Node booting");

  initI2CAndSensor();
  initBLE();
  initWiFi();
}

void loop() {
  maintainWiFi();

  unsigned long now = millis();
  if (now - lastSensorRead >= SENSOR_READ_INTERVAL_MS) {
    lastSensorRead = now;

    float temperatureC = 0.0f;
    float humidityPercent = 0.0f;
    if (readSHT40(temperatureC, humidityPercent)) {
      setStatusLed(true);
      Serial.printf("T=%.2f C, RH=%.2f %%\n", temperatureC, humidityPercent);
      publishBLE(temperatureC, humidityPercent);
      publishWiFi(temperatureC, humidityPercent);
      delay(25);
      setStatusLed(false);
    } else {
      for (int i = 0; i < 3; ++i) {
        setStatusLed(true);
        delay(80);
        setStatusLed(false);
        delay(80);
      }
    }
  }

  delay(10);
}

Bash
pio run
pio run -t upload
pio device monitor

1. Hold SW_BOOT.
2. Press and release SW_RESET.
3. Release SW_BOOT.
4. Run pio run -t upload.

• Keep the SHT40 heater disabled for normal environmental monitoring.
• Increase SENSOR_READ_INTERVAL_MS to reduce Wi-Fi activity.
• For production battery-derived variants, use deep sleep and wake periodically; this USB-C version keeps USB/Wi-Fi services active by default.