Burn-in and the Bathtub Curve

// Burn-in controller and logger - stress a batch of parts and record when they die.
// Board: ESP32 DevKit v1.
//
// Burn-in exists because of one fact: a population of new parts does NOT fail at a constant
// rate. A small fraction carry latent manufacturing defects and fail early - the "infant
// mortality" arm of the bathtub curve. Running everything hot for a few hours kills those
// weak parts in the factory instead of in the field.
//
// Its cost is that it consumes some of the good parts' life too. Burn in too long and you
// ship parts already partway up the wear-out arm.
//
// WIRING
//   GPIO 25   heater MOSFET gate (through a driver) - the stress
//   GPIO 4    DS18B20 chamber temperature
//   GPIO 32-39  up to 8 device-under-test sense lines (ADC1)
//   GPIO 26   DUT power enable
//
// The DUTs here are whatever you choose to stress - LEDs, electrolytic capacitors,
// resistors run near their rating. Anything with a measurable degradation.

#include <OneWire.h>
#include <DallasTemperature.h>

#define HEATER_PIN    25
#define DUT_POWER_PIN 26
#define ONE_WIRE_PIN   4
#define N_DUT          6

const int DUT_PINS[N_DUT] = {32, 33, 34, 35, 36, 39};

#define TARGET_C       85.0f
#define HYSTERESIS_C    2.0f
#define SAMPLE_MS   60000UL
#define VREF           3.30f
#define ADC_MAX      4095.0f
#define FAIL_FRAC      0.80f   // below 80% of its own baseline = failed

OneWire oneWire(ONE_WIRE_PIN);
DallasTemperature sensors(&oneWire);

float baseline[N_DUT];
bool  failed[N_DUT];
unsigned long failedAt[N_DUT];
unsigned long lastSample = 0;
unsigned long startMs = 0;

float readDut(int i) {
  uint32_t acc = 0;
  for (int k = 0; k < 16; k++) { acc += analogRead(DUT_PINS[i]); delay(1); }
  return (acc / 16.0f) * (VREF / ADC_MAX);
}

void setup() {
  Serial.begin(115200);
  pinMode(HEATER_PIN, OUTPUT); digitalWrite(HEATER_PIN, LOW);
  pinMode(DUT_POWER_PIN, OUTPUT); digitalWrite(DUT_POWER_PIN, HIGH);
  for (int i = 0; i < N_DUT; i++) analogSetPinAttenuation(DUT_PINS[i], ADC_11db);
  sensors.begin();
  delay(2000);

  // Baseline EVERY device against ITSELF. Parts vary by more than they degrade,
  // so an absolute threshold would fail good parts and pass bad ones.
  Serial.println("# baselining at room temperature");
  for (int i = 0; i < N_DUT; i++) {
    baseline[i] = readDut(i);
    failed[i] = false; failedAt[i] = 0;
    Serial.printf("# DUT %d baseline %.4f V\n", i, baseline[i]);
  }

  startMs = millis();
  Serial.println("elapsed_min,chamber_c,dut,volts,frac_of_baseline,state");
}

void loop() {
  sensors.requestTemperatures();
  float t = sensors.getTempCByIndex(0);

  // bang-bang with hysteresis - a stress chamber does not need PID
  if (t < TARGET_C - HYSTERESIS_C)      digitalWrite(HEATER_PIN, HIGH);
  else if (t > TARGET_C + HYSTERESIS_C) digitalWrite(HEATER_PIN, LOW);

  // Runaway guard. A stuck heater with nobody watching is a fire, and this
  // is expected to run unattended for hours.
  if (t > TARGET_C + 25.0f || t < -50.0f) {
    digitalWrite(HEATER_PIN, LOW);
    digitalWrite(DUT_POWER_PIN, LOW);
    Serial.printf("# ABORT - chamber %.1f C, heater and DUT power off\n", t);
    while (1) delay(5000);
  }

  if (millis() - lastSample >= SAMPLE_MS) {
    lastSample = millis();
    unsigned long mins = (millis() - startMs) / 60000UL;
    for (int i = 0; i < N_DUT; i++) {
      float v = readDut(i);
      float frac = baseline[i] > 0.01f ? v / baseline[i] : 0.0f;
      if (!failed[i] && frac < FAIL_FRAC) {
        failed[i] = true; failedAt[i] = mins;
        Serial.printf("# DUT %d FAILED at %lu min\n", i, mins);
      }
      Serial.printf("%lu,%.2f,%d,%.4f,%.3f,%s\n",
                    mins, t, i, v, frac, failed[i] ? "FAILED" : "ok");
    }
  }
  delay(1000);
}