Collaboration
ART
BEAUTÉ ET BIEN-ÊTRE
ARTISANAT
CULTURE ET HISTOIRE
DIVERTISSEMENT
ENVIRONNEMENT
NOURRITURE ET BOISSONS
INGÉNIERIE INVERSE
SCIENCES
SPORTS
TECHNOLOGIE
TECHNOLOGIE PORTABLE
Mise en service : la première heure avec votre propre puce, testée par un ESP32
English
Youblob (drawn from the sketch's pin map) · CC0
Ed

Créé par

Ed

29. septembre 2026FI
47
0
0
0
0

Mise en service : la première heure avec votre propre puce, testée par un ESP32

La mise en service (bring-up) est ce que les ingénieurs appellent la première mise sous tension d'un nouveau silicium, et l'ordre des opérations compte plus que n'importe quel test isolé. Vérifiez avant d'alimenter, alimentez avant de cadencer, et limitez le courant avant toute chose, car un court-circuit qu'une limite de courant aurait détecté en une seconde peut détruire les seules puces dont vous disposez. Cet échelon est le plan de mise en service du PWM gradateur des échelons précédents, sur la carte d'essai de l'échelon 2. Un ESP32 fait le travail d'un laboratoire : il génère l'horloge de la puce, maintient son reset, règle le rapport cyclique sur huit plots et mesure le PWM qui revient, puis affiche PASS ou FAIL pour chaque rapport cyclique. Un carnet transforme une panne en nom du plot dont le fil est mal câblé. Soyons honnêtes : il n'y a pas encore de puce. Le programme a été compilé pour ce schéma et les valeurs attendues proviennent des simulations des échelons précédents ; la première vraie exécution vous revient.
Avancé
Un après-midi, une fois la puce arrivée

Consignes

1

Les chiffres à attendre, et comment lire une défaillance

Chargement du notebook Jupyter…
2

La puce que vous mettez en service

Le plan intégré place des résistances de rappel sur chaque entrée, de sorte qu'une puce débranchée reste désactivée. C'est le cœur de ce que ce plan teste.
3

Avant toute mise sous tension

Sans rien connecté, observez à la loupe la puce chip-on-board posée sur la carte d'essai : elle doit être bien centrée et droite, sans pont de soudure, rien ne doit être désolidarisé. Mesurez ensuite au multimètre la résistance entre un plot IO VDD et un plot IO GND de la carte d'essai, dans les deux polarités, et notez les deux valeurs. Une lecture proche de zéro indique un court-circuit : arrêtez-vous là. Le tableau des plots de la version 1 indique quels plots de la carte sont des IO VDD et des IO GND ; utilisez le tableau de votre exécution, car wafer.space indique que les brochages changent d'une exécution à l'autre. Vérifiez de la même manière qu'aucun plot de données n'est court-circuité avec son voisin ou avec la masse.

Matériaux pour cette étape :

Puce ASIC sur mesurePuce ASIC sur mesure1 pièce
Circuit impriméCircuit imprimé1 pièce

Outils nécessaires :

MultimètreMultimètre
4

Alimentation, avec la limite de courant basse

Réglez l'alimentation de laboratoire sur la tension d'alimentation de votre puce avant de la connecter. Cette tension dépend des bibliothèques avec lesquelles votre puce a été construite : les bibliothèques par défaut du modèle sont des bibliothèques 5 V, et il peut aussi être construit avec des bibliothèques 3,3 V. Prenez la valeur exacte dans la documentation de votre run ; le tableau des plots du run 1 indique les plots d'alimentation, mais pas leur tension. Réglez la limite de courant sur le réglage le plus bas qui permet à l'alimentation de réguler, connectez VDD IO et GND IO, puis allumez avec ESP32 encore déconnecté. Sans horloge et avec toutes les entrées tirées vers le bas, la puce doit rester immobile. Notez le courant. Si l'alimentation passe directement en limitation de courant, éteignez : il y a un court-circuit. Notez le courant deux fois de plus, plus tard : en reset avec l'horloge en marche, puis pendant qu'elle joue un motif. Ces trois valeurs sont la signature propre de votre puce ; une carte qui consomme ensuite beaucoup plus qu'aujourd'hui présente un défaut.

Outils nécessaires :

Alimentation de laboratoireAlimentation de laboratoire
MultimètreMultimètre
5

Câblez le ESP32

Douze fils, comme sur l'image et dans l'en-tête du croquis : GPIO 27 vers la broche d'horloge, 26 vers rst_n, 32 vers l'entrée 0 (enable), 13, 14, 18, 19, 21, 22, 23 et 25 vers les broches bidirectionnelles 0 à 7, et la broche bidirectionnelle 8 revient vers GPIO 34, plus une masse commune. GPIO 34 est une broche d'entrée seulement sur le ESP32, donc elle ne peut jamais entrer en conflit avec la sortie de la puce. Le ESP32 est une pièce 3,3 V et ses entrées ne sont pas tolérantes au 5 V. Si les E/S de votre puce ne sont pas en 3,3 V, placez des convertisseurs de niveau sur les douze lignes : trois cartes à quatre canaux. Le modèle courant possède des résistances de tirage vers le haut des deux côtés, qui peuvent outrepasser les résistances de tirage vers le bas faibles de la puce jusqu'à ce que le ESP32 pilote ses broches ; le croquis maintient la réinitialisation et l'activation à l'état bas dès son démarrage, avant que l'horloge ne tourne.

Matériaux pour cette étape :

Adaptateur de niveaux logiquesAdaptateur de niveaux logiques3 pièces
Fils de liaisonFils de liaison1 pièce

Outils nécessaires :

Plaque d'essaiPlaque d'essai
6

The test sketch

bringup.ino. It starts the chip's clock with the ESP32's LED PWM peripheral at 100 kHz, with 1-bit resolution for a plain square wave; holds reset low for 1,000 chip clocks; checks that the output stays low while enable is off; then sets seven duty values and measures the high time with pulseIn, averaged over eight periods, against 10 microseconds per step, within 3 microseconds. It compiles for the ESP32 with the Arduino ESP32 core 3.3.12; it has not been run, because the chip does not exist yet.
bringup.inocpp
// 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() {}

Outils nécessaires :

Carte de développement ESP32Carte de développement ESP32
Ordinateur de bureauOrdinateur de bureau
7

Ce qu'affiche une bonne puce

Ouvrez le moniteur série à 115200 bauds. Une puce qui fonctionne affiche, par ligne, le rapport cyclique, le temps à l'état haut attendu et mesuré en microsecondes, ainsi que le résultat : # horloge de la puce 100000 Hz, PWM période 2560 us duty,expected_us,measured_us,result disabled,0,0,PASS 0,0.0,0.0,PASS 1,10.0,10.0,PASS ... 254,2540.0,2540.0,PASS # 0 échec(s) Regardez ensuite la broche 8 à l'oscilloscope également : à cette horloge, une période doit durer 2 560 microsecondes, avec des fronts propres. Le croquis mesure le temps ; l'oscilloscope montre la forme, et un front lent ou oscillant à travers un convertisseur de niveau n'est visible qu'à cet endroit.

Outils nécessaires :

Oscilloscope numériqueOscilloscope numérique
8

Une puce qui ne démarre pas

Dépannage de la mise en service.

Flow

Loading...
9

Sources et limites honnêtes

**Sources**, consultées le 29 septembre 2026 : wafer-space/chip-on-board-wire-bonded-pcbs, run-1/README.md (le tableau des plots nommant les plots IO VDD et IO GND, et la note indiquant que les brochages changent d'un run à l'autre) ; wafer-space/gf180mcu-project-template, README.md et Makefile (la valeur par défaut de 5 V et les options de bibliothèque à 3,3 V) ; les simulations des étapes précédentes pour les temps à l'état haut attendus. **Limites honnêtes.** Aucune puce n'existe encore : ce plan et son schéma n'ont pas encore été testés sur silicium. La tension et le courant d'alimentation ne sont pas indiqués ici, car la documentation de run disponible au moment de la rédaction ne les précise pas. L'effet du convertisseur de niveau sur les pull-downs dépend de la carte que vous utilisez.

Matériaux

4

Outils requis

6

CC0 Domaine public

Ce blueprint est publié sous CC0. Vous êtes libre de copier, modifier, distribuer et utiliser ce travail pour tout usage, sans demander la permission.

Soutenez le Maker en achetant des produits via son Blueprint où il perçoit une Commission Maker définie par les Vendeurs, ou créez une nouvelle itération de ce Blueprint et incluez-le comme connexion dans votre propre Blueprint pour partager les revenus.

Commentaires

(0)

Se connecter pour participer à la discussion

Chargement des commentaires...