Inbetriebnahme: Die erste Stunde mit deinem eigenen Chip, getestet von einem ESP32

// SPDX-License-Identifier: Apache-2.0
// First-light test for the PWM dimmer chip (Youblob silicon rungs 3 and 6), run from an ESP32.
// The ESP32 is the whole lab: it makes the chip's clock, holds its reset, sets the duty on eight
// pads, and times the PWM that comes back, then prints PASS or FAIL for each duty value.
//
// Wiring, through a logic level converter if your chip's I/O is not 3.3 V (see the blueprint):
//   CLK      GPIO 27  -> clk pad         RST_N  GPIO 26 -> rst_n pad   (both clear of the boot strapping pins)
//   EN       GPIO 32  -> input[0]        D0..D7 GPIO 13,14,18,19,21,22,23,25 -> bidir[0..7]
//   PWM_IN   GPIO 34  <- bidir[8]        (GPIO 34 is input-only on the ESP32: it cannot fight the chip)
//   and a common ground.

const int PIN_CLK = 27, PIN_RST = 26, PIN_EN = 32, PIN_PWM = 34;
const int DATA_PINS[8] = {13, 14, 18, 19, 21, 22, 23, 25};

// 100 kHz: slow enough for a level converter's pull-up edges, and one chip clock is 10 us,
// so pulseIn's 1 us resolution sees a tenth of a clock.
const uint32_t CHIP_CLK_HZ = 100000;
const float US_PER_CLK = 1e6f / CHIP_CLK_HZ;
const float PERIOD_US = 256 * US_PER_CLK;          // one PWM period: 256 chip clocks = 2560 us
const float TOL_US = 3.0f;                         // allowed error, about a third of a clock

void setDuty(uint8_t d) {
  for (int b = 0; b < 8; b++) digitalWrite(DATA_PINS[b], (d >> b) & 1);
}

// Average high time over n periods; returns -1 if the pin never went high (pulseIn timed out).
float meanHighUs(int n) {
  float sum = 0;
  for (int i = 0; i < n; i++) {
    unsigned long t = pulseIn(PIN_PWM, HIGH, 3 * (unsigned long)PERIOD_US);
    if (t == 0) return -1;
    sum += t;
  }
  return sum / n;
}

bool alwaysLow(unsigned long ms) {
  unsigned long t0 = millis();
  while (millis() - t0 < ms)
    if (digitalRead(PIN_PWM)) return false;
  return true;
}

void setup() {
  Serial.begin(115200);
  delay(500);
  for (int b = 0; b < 8; b++) pinMode(DATA_PINS[b], OUTPUT);
  pinMode(PIN_RST, OUTPUT);
  pinMode(PIN_EN, OUTPUT);
  pinMode(PIN_PWM, INPUT);

  // Reset low BEFORE the clock starts, then give the chip some clocks in reset.
  digitalWrite(PIN_RST, LOW);
  digitalWrite(PIN_EN, LOW);
  setDuty(0);
  if (!ledcAttach(PIN_CLK, CHIP_CLK_HZ, 1)) {      // 1-bit resolution: a plain square wave
    Serial.println("FAIL: could not start the clock on GPIO 27");
    return;
  }
  ledcWrite(PIN_CLK, 1);                           // 1 of 2 steps high = 50 % duty
  delay(10);                                       // 1,000 chip clocks in reset
  digitalWrite(PIN_RST, HIGH);

  Serial.printf("# chip clock %lu Hz, PWM period %.0f us\n", (unsigned long)CHIP_CLK_HZ, PERIOD_US);
  Serial.println("duty,expected_us,measured_us,result");
  int fails = 0;

  // Disabled: the output must stay low whatever the duty.
  setDuty(200);
  bool low = alwaysLow(20);
  Serial.printf("disabled,0,%s,%s\n", low ? "0" : "high seen", low ? "PASS" : "FAIL");
  fails += !low;

  digitalWrite(PIN_EN, HIGH);
  const uint8_t duties[] = {0, 1, 16, 64, 128, 200, 254};
  for (uint8_t d : duties) {
    setDuty(d);
    delay(10);                                     // let a few periods pass with the new value
    float expected = d * US_PER_CLK;
    float got;
    bool ok;
    if (d == 0) {
      ok = alwaysLow(20);
      got = ok ? 0 : meanHighUs(8);                // a pad stuck high shows up here as a duty above 0
    } else {
      got = meanHighUs(8);
      ok = got >= 0 && fabsf(got - expected) <= TOL_US;
    }
    Serial.printf("%u,%.1f,%.1f,%s\n", d, expected, got, ok ? "PASS" : "FAIL");
    fails += !ok;
  }
  Serial.printf("# %d failure(s)\n", fails);
}

void loop() {}