Skip to content

Community hardware coverage — draft

Draft only. Not published. Publication still needs Andrii's explicit OK.

This page starts the demand-ranked coverage list with runnable board examples. Each entry links to the exact hardware scope, copy-paste example, vendor status, and simulator evidence. More demand-ranked targets remain to be added.

ESP32 — rank 1, 38% of reported MCU use

ESP32-C6-DevKitC-1-N8 + BME280

The exact N8 board is listed in Espressif's current user guide; the dated 2026-11-10 receipt records 178 in stock at DigiKey. The 8 MB profile boots a direct-register smoke that reads BME280 ID 0x60 and raw temperature over I2C0 on GPIO6/GPIO7. This adds board depth on the existing ESP32-C6 model, not new silicon.

The hosted catalog lists the C6 DevKitC as design_only, so this draft links the exact local CLI smoke and does not claim hosted labwired_verify coverage or physical hardware validation.

#include <Adafruit_BME280.h>
#include <Arduino.h>
#include <Wire.h>

Adafruit_BME280 bme;

void setup() {
  Serial.begin(115200);
  Wire.begin(6, 7, 100000);  // SDA=GPIO6, SCL=GPIO7
  if (!bme.begin(0x77, &Wire)) {
    Serial.println("BME280 not found");
    return;
  }
  Serial.printf("BME280_ID=0x%02X\n", bme.sensorID());
  Serial.printf("Temperature C: %.2f\n", bme.readTemperature());
}

void loop() {}

Waveshare ESP32-C6-Zero-M + BME280

ESP32 remains rank 1 (38% of reported MCU use); demand for this exact board is not measured separately. Waveshare's current page lists the C6-Zero-M header SKU, and Electrokit listed 232 units in stock on 2026-11-18. Their flash specifications disagree: Waveshare lists C6FH8 / 8 MB, while Electrokit lists C6FH4 / 4 MB. The model uses the conservative 4 MB profile. The smoke reads BME280 ID 0x60 and raw temperature over I2C0 on GPIO6/GPIO7. The onboard RGB, USB, radio, LP core, and reset/strap behavior are outside this profile.

ESP32-C5-DevKitC-1-N8R8 + BME280 + onboard RGB

ESP32 remains demand rank 1 (38% of reported MCU use); C5-specific use is unmeasured. Espressif's current catalog lists this exact N8R8 board with a $15 sample-price reference and distributor links. The bare-ELF smoke reads BME280 ID 0x60 and raw temperature over I2C0 on GPIO8/GPIO9, toggles GPIO5, and bit-bangs a red WS2812 frame on the onboard GPIO27 LED. The WS2812 observer decodes the frame; this does not claim RMT support, mask-ROM boot, or physical board confirmation.

ESP32-H2-DevKitM-1-N4S + onboard RGB

ESP32 is demand rank 1 (38% of reported MCU use); the survey does not score H2 separately. Espressif's live guide lists the N4S order code as current, marks the older N4 as NRND, and maps the onboard addressable RGB LED to GPIO8. DigiKey currently marks the exact N4S board Active and lists it in stock. The existing bare-RISC-V board smoke now exercises UART0 and bit-bangs a red GRB frame through GPIO8; the NeoPixel observer must decode one lit pixel. This adds board-peripheral coverage to the existing H2 descriptor. USB-to-UART, IO_MUX pad routing, RMT, BLE, Thread, Zigbee, and USB remain outside the smoke.

#include <Adafruit_NeoPixel.h>
#include <Arduino.h>

Adafruit_NeoPixel rgb(1, 8, NEO_GRB + NEO_KHZ800);  // onboard LED: GPIO8

void setup() {
  Serial.begin(115200);
  rgb.begin();
  rgb.setPixelColor(0, rgb.Color(255, 0, 0));
  rgb.show();
  Serial.println("H2_N4S_RGB_OK");
}

void loop() {}

ESP32-C3-DevKitM-1-N4X + onboard RGB

ESP32 is demand rank 1 (38% of reported MCU use); C3-specific use is not separately measured. Checked 2026-11-18, Espressif's current guide lists the N4X order code with 4 MB flash and marks only the older unsuffixed order code EOL. DigiKey lists the exact N4X board as Active and in stock. The local bare-RISC-V smoke sends UART0 output and bit-bangs one red WS2812 frame through GPIO8; the observer must decode one lit pixel. This adds a current, official C3 board profile to the existing C3 chip model. It does not claim ROM boot, USB-UART bridge, IO_MUX, or timed RMT playback.

#include <Adafruit_NeoPixel.h>
#include <Arduino.h>

Adafruit_NeoPixel rgb(1, 8, NEO_GRB + NEO_KHZ800);  // onboard LED: GPIO8

void setup() {
  Serial.begin(115200);
  rgb.begin();
  rgb.setPixelColor(0, rgb.Color(255, 0, 0));
  rgb.show();
  Serial.println("C3_N4X_RGB_OK");
}

void loop() {}

ESP8684-DevKitM-1-H4X + UART0 and red LED

ESP32 remains demand rank 1 (38% of reported MCU use); ESP32-C2 is not ranked separately. Espressif's live guide lists the H4X order code with 4 MB flash and marks the older H4 variant NRND. Mouser showed 35 H4X boards in stock on 2026-11-17. The board smoke sends a UART0 marker and observes GPIO0 transitions on the onboard red LED channel. This adds a working board profile and C2 clock pacing; it does not claim ROM boot, the USB-UART bridge, or pad electrical routing.

#include "driver/gpio.h"
#include "driver/uart.h"
#include "esp_rom_sys.h"
#include <stddef.h>

void app_main(void) {
    const uart_config_t uart_cfg = {
        .baud_rate = 115200,
        .data_bits = UART_DATA_8_BITS,
        .parity = UART_PARITY_DISABLE,
        .stop_bits = UART_STOP_BITS_1,
        .flow_ctrl = UART_HW_FLOWCTRL_DISABLE,
        .source_clk = UART_SCLK_DEFAULT,
    };
    uart_driver_install(UART_NUM_0, 256, 0, 0, NULL, 0);
    uart_param_config(UART_NUM_0, &uart_cfg);
    gpio_reset_pin(GPIO_NUM_0);
    gpio_set_direction(GPIO_NUM_0, GPIO_MODE_OUTPUT);
    static const char marker[] = "C2_H4X_GPIO0_UART_OK\n";
    uart_write_bytes(UART_NUM_0, marker, sizeof(marker) - 1);
    for (;;) {
        gpio_set_level(GPIO_NUM_0, 1);
        esp_rom_delay_us(250000);
        gpio_set_level(GPIO_NUM_0, 0);
        esp_rom_delay_us(250000);
    }
}

ESP32-S3-DevKitC-1-N16R8 + Adafruit BME280

ESP32 remains demand rank 1 (38% of reported MCU use). Espressif lists the N16R8 board SKU; the v1.1 guide gives 16 MB flash / 8 MB PSRAM and marks the older N8/N8R2 variants EOL. Adafruit listed the BME280 breakout in stock on 2026-11-13. The profile uses I2C0 on GPIO8/GPIO9 and asserts the sensor ID plus raw temperature registers. This adds board and sensor coverage over the existing S3 model, not new silicon. The hosted Arduino oracle verifies the copy-paste setup path; its ideal-rail assumption excludes power-on and brown-out behavior.

#include <Arduino.h>
#include <Wire.h>

constexpr uint8_t SDA_PIN = 8;
constexpr uint8_t SCL_PIN = 9;
constexpr uint8_t BME280_ADDR = 0x77;

bool readRegister(uint8_t reg, uint8_t &value) {
  Wire.beginTransmission(BME280_ADDR);
  Wire.write(reg);
  if (Wire.endTransmission(false) != 0 || Wire.requestFrom(BME280_ADDR, 1) != 1) {
    return false;
  }
  value = Wire.read();
  return true;
}

void setup() {
  Serial.begin(115200);
  Wire.begin(SDA_PIN, SCL_PIN, 100000);
  uint8_t id = 0;
  if (readRegister(0xD0, id) && id == 0x60) {
    Serial.printf("BME280_ID=0x%02X\n", id);
  } else {
    Serial.println("BME280_I2C_ERROR");
  }
}

void loop() {}

Seeed Studio XIAO ESP32C3 + Adafruit BME280

The XIAO ESP32C3 is a USD 4.90 ESP32-C3 board; Seeed listed it in stock on 2026-11-13. The breakout sits on the board's default Wire pins, D4 (GPIO6) and D5 (GPIO7). The simulator boots the unmodified Arduino build in full and the sketch prints the BME280 ID, the raw temperature and the compensated 25.00 degC on the USB console. This adds board and sensor coverage over the existing C3 model, not new silicon.

#include <Arduino.h>
#include <Wire.h>

constexpr uint8_t BME280_ADDR = 0x77;

void setup() {
  Serial.begin(115200);
  Wire.begin();  // XIAO ESP32C3: SDA = D4 (GPIO6), SCL = D5 (GPIO7)
  Wire.beginTransmission(BME280_ADDR);
  Wire.write(0xD0);
  uint8_t id = 0;
  if (Wire.endTransmission(false) == 0 && Wire.requestFrom(BME280_ADDR, 1) == 1) {
    id = Wire.read();
  }
  Serial.printf("BME280_ID=0x%02X\n", id);
}

void loop() {}

Arduino kit boards — rank 3, 37% of main-project kits

Arduino UNO R4 Minima + BME280

Arduino lists the UNO R4 Minima as orderable SKU ABX00080, and Renesas lists RA4M1 orderable parts as Active. The Adafruit BME280 STEMMA QT breakout was in stock on 2026-11-17. This adds an IIC1 sensor path to the existing UNO R4 Minima model; RA4M1 itself is not separately ranked in the MCU-use table.

The sketch reads the BME280 chip ID over Wire/IIC1 on A4/A5 and reports it over Serial1/SCI2 on D0/D1. USB-C Serial uses USBFS, which remains outside this profile.

#include <Arduino.h>
#include <Wire.h>

constexpr uint8_t BME280_ADDRESS = 0x77;

void setup() {
  Serial1.begin(115200);  // SCI2 on D0/D1
  Wire.begin();           // IIC1 on A4/A5
  Wire.setClock(100000);

  Wire.beginTransmission(BME280_ADDRESS);
  Wire.write(0xD0);
  if (Wire.endTransmission(false) != 0 ||
      Wire.requestFrom(static_cast<int>(BME280_ADDRESS), 1) != 1) {
    Serial1.println("BME280_I2C_ERROR");
    return;
  }

  Serial1.print("BME280_ID=0x");
  Serial1.println(Wire.read(), HEX);
}

void loop() {}

Arduino Nano Every + Adafruit BME280

Arduino lists the Nano Every as orderable SKU ABX00028, and Microchip's live page reported ATMEGA4809 as In Production on 2026-11-19. The Adafruit BME280 breakout was in stock on the same date. The ATmega4809 is not ranked separately; the Nano Every is the in-production Arduino board in the classic Nano form factor. This adds a TWI0 host model to the ATmega4809, so stock Wire runs.

The sketch uses the stock Adafruit BME280 library on A4/A5 and prints compensated readings on USB Serial: T=25.00 C, P=1013.25 hPa, RH=50.00 % with the sensor model at its defaults. Timer pad outputs and the TWI0 pads are not modelled. No physical board test was run.

#include <Arduino.h>
#include <Wire.h>
#include <Adafruit_BME280.h>

Adafruit_BME280 bme;

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
  Serial.begin(115200);
  if (!bme.begin(0x77)) {
    Serial.println("BME280 not found at 0x77");
    return;
  }
  Serial.print("NANO_EVERY_BME280 ID=0x");
  Serial.println(bme.sensorID(), HEX);
  Serial.print("T=");
  Serial.print(bme.readTemperature(), 2);
  Serial.println(" C");
  Serial.print("P=");
  Serial.print(bme.readPressure() / 100.0F, 2);
  Serial.println(" hPa");
  Serial.print("RH=");
  Serial.print(bme.readHumidity(), 2);
  Serial.println(" %");
  digitalWrite(LED_BUILTIN, HIGH);
}

void loop() {}

Arduino Nano 33 IoT + Adafruit BME280

Arduino lists the Nano 33 IoT as orderable SKU ABX00027, and Microchip's live page reported ATSAMD21G18 as In Production on 2026-11-19. The ATSAMD21G18A is not ranked separately; the board is on the Arduino kits line (37%). This adds a USB device model to the ATSAMD21G18A with a scripted host, so a stock sketch whose Serial is the native USB port prints.

The sketch waits for the terminal (while (!Serial)), reads the sensor with the stock Adafruit BME280 library on A4/A5 and prints compensated readings on USB Serial: T=25.00 C, P=1013.25 hPa, RH=50.00 % with the sensor model at its defaults. The on-board Wi-Fi module, crypto chip and IMU are not attached. No physical board test was run.

#include <Arduino.h>
#include <Wire.h>
#include <Adafruit_BME280.h>

Adafruit_BME280 bme;

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
  Serial.begin(115200);
  // Native USB: wait until a terminal opens the port (DTR), or the first
  // lines are lost.
  while (!Serial) {
    delay(1);
  }
  if (!bme.begin(0x77)) {
    Serial.println("BME280 not found at 0x77");
    return;
  }
  Serial.print("NANO_33_IOT_BME280 ID=0x");
  Serial.println(bme.sensorID(), HEX);
  Serial.print("T=");
  Serial.print(bme.readTemperature(), 2);
  Serial.println(" C");
  Serial.print("P=");
  Serial.print(bme.readPressure() / 100.0F, 2);
  Serial.println(" hPa");
  Serial.print("RH=");
  Serial.print(bme.readHumidity(), 2);
  Serial.println(" %");
  digitalWrite(LED_BUILTIN, HIGH);
}

void loop() {}

Arduino Nano 33 BLE Rev2 + Adafruit BME280

Arduino lists the Nano 33 BLE Rev2 as SKU ABX00071; on 2026-11-20 its own store showed it sold out and one authorized distributor listed 100 in stock. The nRF52840 is not ranked separately; the board is on the Arduino kits line (37%). This adds a USB device model to the nRF52840 with a scripted host, and the TWI master that Mbed OS uses for Wire, so a stock ArduinoCore-mbed sketch whose Serial is the native USB port prints.

The sketch waits for the terminal (while (!Serial)), reads the sensor with the stock Adafruit BME280 library on A4/A5 and prints compensated readings on USB Serial: T=25.00 C, P=1013.25 hPa, RH=50.00 % with the sensor model at its defaults. The board's bootloader is not modelled; the on-board IMU and the BLE stack are not attached or exercised. No physical board test was run.

#include <Arduino.h>
#include <Wire.h>
#include <Adafruit_BME280.h>

Adafruit_BME280 bme;

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
  Serial.begin(115200);
  // Native USB: wait until a terminal opens the port (DTR), or the first
  // lines are lost.
  while (!Serial) {
    delay(1);
  }
  if (!bme.begin(0x77)) {
    Serial.println("BME280 not found at 0x77");
    return;
  }
  Serial.print("NANO_33_BLE_BME280 ID=0x");
  Serial.println(bme.sensorID(), HEX);
  Serial.print("T=");
  Serial.print(bme.readTemperature(), 2);
  Serial.println(" C");
  Serial.print("P=");
  Serial.print(bme.readPressure() / 100.0F, 2);
  Serial.println(" hPa");
  Serial.print("RH=");
  Serial.print(bme.readHumidity(), 2);
  Serial.println(" %");
  digitalWrite(LED_BUILTIN, HIGH);
}

void loop() {}

Arduino Nano Every + Adafruit MAX31855

Same board and the same live checks on 2026-11-19: Nano Every SKU ABX00028 orderable, ATMEGA4809 In Production. The Adafruit MAX31855 breakout was in stock on that date; the MAX31855 lifecycle page at Analog Devices was not readable. This adds an SPI0 host model to the ATmega4809, so stock SPI runs.

The sketch uses the stock Adafruit MAX31855 library on D13 / D12 with CS on D10 and prints both junction temperatures on USB Serial: TC=25.00 C, CJ=22.0000 C with the converter model at its defaults. SPI0 Buffer mode and client mode are refused; the SPI clock phase and polarity and timer pad outputs are not modelled. No physical board test was run.

#include <Arduino.h>
#include <SPI.h>
#include <Adafruit_MAX31855.h>

static const uint8_t kChipSelect = 10;

Adafruit_MAX31855 thermocouple(kChipSelect);

void setup() {
  Serial.begin(115200);
  thermocouple.begin();
  Serial.println("NANO_EVERY_MAX31855");
  double hot = thermocouple.readCelsius();
  if (isnan(hot)) {
    Serial.print("MAX31855 fault 0x");
    Serial.println(thermocouple.readError(), HEX);
    return;
  }
  Serial.print("TC=");
  Serial.print(hot, 2);
  Serial.println(" C");
  Serial.print("CJ=");
  Serial.print(thermocouple.readInternal(), 4);
  Serial.println(" C");
}

void loop() {}

ESP32-C61-DevKitC-1-N8R2

ESP32 is demand rank 1 (38% of reported MCU use); the survey does not score C61 separately. Espressif lists the exact N8R2 board, and Mouser showed 378 in stock on 2026-11-17. The C61 profile now exercises UART0, GPIO4 output, and I2C0 routed through GPIO6/GPIO22 to a BME280. It reads the BME280 ID (0x60) and a deterministic raw-temperature vector. ROM/bootloader, electrical IO_MUX, PSRAM, Wi-Fi, Bluetooth LE, and the onboard RGB LED remain outside scope.

#include <stdint.h>

#include "driver/gpio.h"
#include "driver/i2c_master.h"
#include "esp_err.h"
#include "esp_log.h"

#define BME280_ADDRESS 0x77

void app_main(void) {
    i2c_master_bus_handle_t bus;
    const i2c_master_bus_config_t bus_config = {
        .i2c_port = I2C_NUM_0,
        .sda_io_num = GPIO_NUM_6,   // J1 pin 5
        .scl_io_num = GPIO_NUM_22,  // J3 pin 6
        .clk_source = I2C_CLK_SRC_DEFAULT,
        .glitch_ignore_cnt = 7,
    };
    ESP_ERROR_CHECK(i2c_new_master_bus(&bus_config, &bus));

    i2c_master_dev_handle_t sensor;
    const i2c_device_config_t sensor_config = {
        .dev_addr_length = I2C_ADDR_BIT_LEN_7,
        .device_address = BME280_ADDRESS,
        .scl_speed_hz = 100000,
    };
    ESP_ERROR_CHECK(i2c_master_bus_add_device(bus, &sensor_config, &sensor));

    const uint8_t chip_id_register = 0xD0;
    uint8_t chip_id = 0;
    ESP_ERROR_CHECK(i2c_master_transmit_receive(
        sensor, &chip_id_register, 1, &chip_id, 1, 1000));
    if (chip_id != 0x60) {
        ESP_LOGE("bme280", "unexpected chip id: 0x%02x", chip_id);
        return;
    }
    ESP_LOGI("bme280", "BME280_ID=0x%02x", chip_id);
}

Arduino Nano ESP32 + Adafruit BME280

ESP32 remains demand rank 1 (38% of reported MCU use), and Arduino kits were used by 37% of respondents' main projects. Arduino's current store listing offers the Nano ESP32 ABX00092; Adafruit listed the BME280 STEMMA QT breakout in stock on 2026-11-17. The board profile wires I2C0 to the official A4/A5 route, GPIO11/GPIO12. Its local smoke reads BME280 ID 0x60 and the raw temperature registers. The copy-paste Arduino sketch is hosted model-verified for the BME280 ID using an explicit GPIO11/GPIO12 diagram; that result assumes an ideal power rail and does not cover startup or brown-out behavior. The connected hosted catalog's default A4/A5 description still says GPIO8/GPIO9, so the example spells out the vendor-published GPIO numbers. This adds board/peripheral depth to the existing ESP32-S3 model, not a new silicon family.

#include <Arduino.h>
#include <Wire.h>

constexpr uint8_t SDA_PIN = 11;  // A4 / GPIO11
constexpr uint8_t SCL_PIN = 12;  // A5 / GPIO12
constexpr uint8_t BME280_ADDR = 0x77;

void setup() {
  Serial.begin(115200);
  Wire.begin(SDA_PIN, SCL_PIN, 100000);
  Wire.beginTransmission(BME280_ADDR);
  Wire.write(0xD0);
  if (Wire.endTransmission(false) == 0 && Wire.requestFrom(BME280_ADDR, 1) == 1) {
    Serial.printf("NANO_ESP32_BME280_ID=0x%02X\n", Wire.read());
  } else {
    Serial.println("NANO_ESP32_BME280_I2C_ERROR");
  }
}

void loop() {}

RP2040 / RP2350 — demand group 2

Raspberry Pi Pico W + BME280

RP2040 is survey rank 5 at 12% of reported MCU use and belongs to target-list group #2. Raspberry Pi's current Pico W product brief keeps the board in production through January 2036; Mouser listed exact board SKU SC0918 in stock. The profile reads the BME280 chip ID 0x60 on I2C0 GP4/GP5 and reports the result over UART0 GP0. Wi-Fi, Bluetooth, USB, and the CYW43439-driven onboard LED remain outside the profile.

#include <Arduino.h>
#include <Wire.h>

constexpr uint8_t BME280_ADDRESS = 0x77;

void setup() {
  Serial1.setTX(0);
  Serial1.setRX(1);
  Serial1.begin(115200);  // UART0 TX on GP0
  Wire.setSDA(4);         // I2C0 SDA on GP4
  Wire.setSCL(5);         // I2C0 SCL on GP5
  Wire.begin();

  Wire.beginTransmission(BME280_ADDRESS);
  Wire.write(0xD0);  // BME280 chip-ID register
  if (Wire.endTransmission(false) == 0 &&
      Wire.requestFrom(BME280_ADDRESS, static_cast<uint8_t>(1)) == 1 &&
      Wire.read() == 0x60) {
    Serial1.println("PICO_W_BME280_ID=0x60_I2C0_GP4_GP5");
  } else {
    Serial1.println("PICO_W_BME280_I2C_ERROR");
  }
}

void loop() {}

Adafruit Feather RP2350 with HSTX (no-PSRAM, Product ID 6000)

RP2040 was reported by 12% of respondents (MCU rank 5); RP2350 was not measured separately. Adafruit's live product listing showed the no-PSRAM Feather in stock on 2026-11-13. The local smoke toggles red D13 on GPIO7 and captures UART0 output on the existing RP2350 model. HSTX/DVI, NeoPixel, USB, charging, and PSRAM behavior are outside this coverage.

#include <Arduino.h>

constexpr uint8_t LED_PIN = 7;  // D13, onboard red LED

void setup() {
  pinMode(LED_PIN, OUTPUT);
  Serial1.begin(115200);  // UART0 on TX=GP0, RX=GP1
  Serial1.println("FEATHER_RP2350_GPIO7_UART_OK");
}

void loop() {
  digitalWrite(LED_PIN, HIGH);
  delay(500);
  digitalWrite(LED_PIN, LOW);
  delay(500);
}

Raspberry Pi Pico 2 W + BME280

The RP2040/RP2350 target group is demand group #2; RP2040 measured rank 5 at 12%, while RP2350 was not scored separately. The Pico 2 W is Raspberry Pi's current RP2350 wireless board. Its profile runs a register-level I2C0 smoke on GP4/GP5, checks both I/O mux selections, and requires the attached BME280 to return chip ID 0x60. This adds board and sensor coverage to the existing RP2350 model; the CYW43439 Wi-Fi/Bluetooth path and wireless user LED remain unmodelled.

Raspberry Pi Pico 2 + BME280

The RP2040/RP2350 target group is demand group #2; RP2040 measured rank 5 at 12%, while RP2350 was not scored separately. This profile covers the exact non-wireless Pico 2 on I2C0 GP4/GP5, reads the attached BME280 chip ID 0x60, and checks both IO_BANK0 pin-function selections. It extends the existing RP2350 model to the non-W board variant; it does not claim USB or boot-ROM behavior. The shared RP2350 descriptor still has storage-only powman and tbman stubs, which this smoke does not exercise.

STM32F103 — rank 3, 17% of reported MCU use

NUCLEO-F103RB + BME280

The NUCLEO-F103RB's STM32F103RBT6 boots a register-level smoke, reads the BME280's CHIP_ID (0x60) over the I2C1 board route (D15/SCL = PB8, D14/SDA = PB9), and pulses LD2 after the successful read.

#include <Wire.h>
#include <Adafruit_BME280.h>

Adafruit_BME280 bme;

void setup() {
  Serial.begin(115200);
  Wire.begin();  // NUCLEO-F103RB D14/D15: PB9/PB8, I2C1
  if (!bme.begin(0x77, &Wire)) {
    Serial.println("BME280 not found");
    while (true) delay(10);
  }
  Serial.println("NUCLEO_F103RB_BME280_OK");
}

void loop() {
  Serial.print("Temperature C: ");
  Serial.println(bme.readTemperature());
  Serial.print("Pressure hPa: ");
  Serial.println(bme.readPressure() / 100.0F);
  Serial.print("Humidity %: ");
  Serial.println(bme.readHumidity());
  delay(2000);
}

STM32F103C8T6 Blue Pill

The exact STM32F103C8T6 is still Active and in volume production on ST's live product page. The retailer listing checked for this round showed the Blue Pill board in stock. This is board depth for the measured rank-3 STM32F103 target, not a new chip family. The smoke checks the reference board's active-low PC13 LED and USART1 header output. It makes no USB, debugger, clone-uniformity, or physical-hardware claim.

#include <Arduino.h>

void setup() {
  pinMode(PC13, OUTPUT);
  Serial1.begin(115200);  // USART1 TX=PA9, RX=PA10
  Serial1.println("BLUEPILL_F103C8_OK");
}

void loop() {
  digitalWrite(PC13, LOW);   // active-low user LED on
  delay(500);
  digitalWrite(PC13, HIGH);  // user LED off
  delay(500);
}

STM32F103C6T6A low-density MCU

STM32F103 is measured MCU rank 3 (17%). ST currently lists the exact STM32F103C6T6A as Active and In Stock. This is exact-variant validation within the existing STM32F103 family, not a new demand pick. The C6 profile boots a 32 KB Flash / 10 KB SRAM image, sends a USART2 marker on PA2/PA3, and toggles an LED on PA5. The profile uses only low-density peripherals; the USB-device and backup-register windows remain explicit stubs. ST errata ES0348 says user-mode firmware reads DBGMCU_IDCODE as zero, which the descriptor reflects. No physical board or silicon result is claimed.

#include <Arduino.h>

void setup() {
  pinMode(PA5, OUTPUT);
  Serial2.begin(115200);  // USART2: PA2 TX, PA3 RX
  Serial2.println("STM32F103C6_LOW_DENSITY_OK");
}

void loop() {
  digitalWrite(PA5, HIGH);
  delay(500);
  digitalWrite(PA5, LOW);
  delay(500);
}

STM32F103R6T6A low-density MCU

STM32F103 is measured MCU rank #3 (17%). ST lists the exact STM32F103R6T6A as Active and In stock. This is exact-variant validation in the existing STM32F103 family, not a new demand pick. The R6 LQFP64 profile runs a register-level smoke that prints over USART2 on PA2/PA3 and toggles PA5. The descriptor exposes the low-density SPI1, I2C1, USART1/2, TIM1-3, ADC1/2, and DMA1 instances; USB and backup registers remain explicit untouched stubs. No physical board or silicon test is claimed.

#include <Arduino.h>

void setup() {
  pinMode(PA5, OUTPUT);
  Serial2.begin(115200);  // USART2: PA2 TX, PA3 RX
  Serial2.println("STM32F103R6_LOW_DENSITY_OK");
}

void loop() {
  digitalWrite(PA5, HIGH);
  delay(500);
  digitalWrite(PA5, LOW);
  delay(500);
}

STM32 Nucleo/Discovery — kit rank 4, 23% of main projects

NUCLEO-H533RE + STM32H533RE + BME280

Other STM32 is MCU demand rank 4 (13%), and Nucleo/Discovery kits rank 4 (23%). ST's live eStore lists the NUCLEO-H533RE as Active and in stock. The profile boots firmware that reads the BME280 CHIP_ID (0x60) on I2C1 over Arduino D15/D14 (PB6/PB7), prints a USART2 success marker, and toggles LD2 on PA5. H533RE-specific usage was not measured. The model exposes only RCC, GPIOA/GPIOB, USART2, I2C1, and those five pins; other peripherals remain unmapped. It is simulator evidence, with no H533RE silicon capture or physical board result.

With I2C1 configured for PB6/PB7 (AF4), this HAL call checks the BME280 ID at its default address:

#include "main.h"  // CubeMX-generated hi2c1 declaration
#include <stdbool.h>
#include <stdint.h>

static bool bme280_connected(void) {
  uint8_t id = 0;
  return HAL_I2C_Mem_Read(&hi2c1, (uint16_t)(0x77u << 1), 0xD0u,
                          I2C_MEMADD_SIZE_8BIT, &id, 1, 100u) == HAL_OK &&
         id == 0x60u;
}

NUCLEO-U5A5ZJ-Q + STM32U5A5 secure AES

Other STM32 parts were reported by 13% of respondents (MCU rank 4), and Nucleo/Discovery kits by 23% of respondents' main projects (kit rank 4). ST lists the NUCLEO-U5A5ZJ-Q as Active and In Stock. This board profile drives the U5A5-specific SAES peripheral with an AES-128 ECB known-answer block from NIST SP 800-38A; firmware compares all four returned words before printing the success marker. The SAES model does not cover GCM/CCM, TrustZone key selection, side-channel behavior, or hardware timing. This extends the existing U5A5 board profile and does not add a new MCU descriptor.

The copy-paste firmware is nucleo_u5a5_saes_smoke.rs. Build and run it from the repository root:

examples/nucleo-u5a5zj/ci/build-saes-smoke.sh
cargo run -q -p labwired-cli -- test --script examples/nucleo-u5a5zj/saes-smoke.yaml

Expected output: U5A5_SAES_AES128_ECB_OK. This is simulator-model evidence, not physical-silicon or side-channel validation.

WCH — Tier C vendor bet (not a measured survey rank)

WCH CH32V003EVT

This exact evaluation board is currently listed in stock by two retailers. The profile uses its CH32V003F4P6 and the board's LED connector: LED1 on P4-1 is jumpered to PC0 and toggled as an active-low output. A separate smoke writes through polled USART1 TX on the exposed PD5 pin. USB-C is power-only. The model does not claim WCH-Link, USB data, PFIC, ADC, I2C, SPI, or timers.

#include <stdint.h>

#define RCC_APB2PCENR (*(volatile uint32_t *)0x40021018u)
#define GPIOC_CFGLR   (*(volatile uint32_t *)0x40011000u)
#define GPIOC_BSHR    (*(volatile uint32_t *)0x40011010u)
#define GPIOC_BCR     (*(volatile uint32_t *)0x40011014u)

void main(void) {
  RCC_APB2PCENR |= 1u << 4;  // enable GPIOC
  GPIOC_CFGLR = 0x2u;        // PC0 push-pull output
  for (;;) {
    GPIOC_BSHR = 1u;         // LED1 off
    for (volatile uint32_t i = 0; i < 500; ++i) __asm__ volatile("nop");
    GPIOC_BCR = 1u;          // LED1 on
    for (volatile uint32_t i = 0; i < 500; ++i) __asm__ volatile("nop");
  }
}