Colaboração
ARTE
BELEZA E BEM-ESTAR
ARTESANATO
CULTURA E HISTÓRIA
ENTRETENIMENTO
MEIO AMBIENTE
COMIDA E BEBIDAS
ENGENHARIA REVERSA
CIÊNCIAS
ESPORTES
TECNOLOGIA
TECNOLOGIA VESTÍVEL
Bring-Up: A Primeira Hora com o Seu Próprio Chip, Testado por um ESP32
English
Youblob (drawn from the sketch's pin map) · CC0
Ed

Criado por

Ed

29. setembro 2026FI
45
0
0
0
0

Bring-Up: A Primeira Hora com o Seu Próprio Chip, Testado por um ESP32

Bring-up é o nome que os engenheiros dão à primeira ligação de um novo silício, e a ordem dessa etapa importa mais do que qualquer teste isolado. Observe antes de ligar, ligue a energia antes de aplicar o clock, e limite a corrente antes de fazer qualquer outra coisa, porque um curto-circuito que um limitador de corrente teria detectado em um segundo pode destruir os únicos chips que você tem. Este degrau é o plano de bring-up para o PWM dimmer dos degraus anteriores, na placa de prototipagem do degrau 2. Um ESP32 faz o trabalho de um laboratório: gera o clock do chip, mantém o seu reset, define o duty em oito pads e mede o PWM que retorna, depois imprime PASS ou FAIL para cada duty. Um caderno transforma uma falha no nome do pad cujo fio está errado. Dito com honestidade: ainda não há chip. O sketch foi compilado para este blueprint e os números esperados vêm das simulações dos degraus anteriores; a primeira execução real é sua.
Avançado
Uma tarde, assim que o chip chegar

Instruções

1

Os números esperados e como interpretar uma falha

A carregar o notebook Jupyter…
2

O chip que você está ativando

O blueprint embutido coloca pull-downs em todas as entradas, então um chip desconectado fica desabilitado. Esse é o núcleo que este plano testa.
3

Antes de qualquer energia

Com nada conectado, observe o chip-on-board assentado na placa breakout sob a lupa: assentado em quadrado, sem ponte de solda, nada solto. Em seguida, meça com o multímetro a resistência entre um pad de IO VDD e um pad de IO GND da placa breakout, nas duas polaridades, e anote os dois valores. Uma leitura próxima de zero indica curto-circuito: pare aí. A tabela de pads da execução 1 indica quais pads da placa breakout são IO VDD e IO GND; use a tabela da sua execução, pois a wafer.space diz que as pinagens mudam entre execuções. Verifique da mesma forma que nenhum pad de dados está em curto com seu vizinho nem com o terra.

Materiais para este passo:

Chip ASIC personalizadoChip ASIC personalizado1 peça
Placa de circuito impressoPlaca de circuito impresso1 peça

Ferramentas necessárias:

MultímetroMultímetro
4

Energia, com o limite de corrente baixo

Ajuste a fonte de bancada para a tensão de alimentação do seu chip antes de conectá-lo. Essa tensão depende das bibliotecas com as quais o seu chip foi construído: as bibliotecas padrão do template são de 5 V, e ele também pode ser construído com bibliotecas de 3,3 V. Obtenha o valor exato na documentação da sua execução; a tabela de pads da execução 1 indica os pads de alimentação, mas não a sua tensão. Ajuste o limite de corrente para a configuração mais baixa que permita à fonte regular, conecte VDD IO e GND IO, e ligue com o ESP32 ainda desconectado. Sem clock e com todas as entradas puxadas para baixo, o chip deve permanecer em repouso. Anote a corrente. Se a fonte entrar imediatamente em limitação de corrente, desligue: há um curto-circuito. Meça a corrente mais duas vezes depois, em reset com o clock em funcionamento e enquanto ele executa um padrão. Esses três números são a assinatura própria do seu chip; uma placa que depois consumir bem mais do que consumia hoje apresenta uma falha.

Ferramentas necessárias:

Fonte de alimentação de bancadaFonte de alimentação de bancada
MultímetroMultímetro
5

Conecte o ESP32

Doze fios, conforme a imagem e o cabeçalho do esquema: GPIO 27 para o pad do clock, 26 para rst_n, 32 para a entrada 0 (enable), 13, 14, 18, 19, 21, 22, 23 e 25 para os pads bidirecionais 0 a 7, e o pad bidirecional 8 de volta para GPIO 34, além de um terra comum. GPIO 34 é um pino somente de entrada no ESP32, por isso nunca pode entrar em conflito com a saída do chip.

Materiais para este passo:

Conversor de níveis lógicosConversor de níveis lógicos3 peças
Fios de ligaçãoFios de ligação1 peça

Ferramentas necessárias:

Placa de ensaioPlaca de ensaio
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() {}

Ferramentas necessárias:

Placa de desenvolvimento ESP32Placa de desenvolvimento ESP32
Computador de secretáriaComputador de secretária
7

Como é uma boa saída do chip

Abra o monitor serial a 115200 baud. Um chip que funciona imprime, por linha, o duty, o tempo alto esperado e medido em microssegundos, e o resultado: # clock do chip 100000 Hz, PWM período 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 falha(s) Depois, observe o pino 8 com o osciloscópio também: um período deve ser de 2.560 microssegundos com este clock, com bordas limpas. O sketch mede o tempo; o osciloscópio mostra a forma, e uma borda lenta ou oscilante através de um conversor de nível só é visível ali.

Ferramentas necessárias:

Osciloscópio digitalOsciloscópio digital
8

Um chip que não inicializa

Solução de problemas de inicialização.

Flow

Loading...
9

Fontes e limites honestos

**Fontes**, consultadas em 29 de setembro de 2026: wafer-space/chip-on-board-wire-bonded-pcbs, run-1/README.md (a tabela de pads que nomeia os pads de IO VDD e de IO GND, e a nota de que as pinagens mudam entre execuções); wafer-space/gf180mcu-project-template, README.md e Makefile (a predefinição de 5 V e as opções de biblioteca de 3,3 V); as simulações dos degraus anteriores para os tempos altos esperados. **Limites honestos.** Ainda não existe nenhum chip: este plano e o seu esboço não foram testados em silício. A tensão e a corrente de alimentação não são indicadas aqui porque a documentação de execução disponível no momento da redação não as indica. O efeito do conversor de nível sobre os pull-downs depende da placa que utilizar.

Materiais

4

Ferramentas necessárias

6

CC0 Domínio Público

Este blueprint é liberado sob CC0. Você é livre para copiar, modificar, distribuir e usar este trabalho para qualquer finalidade, sem pedir permissão.

Apoie o Maker comprando produtos através do Blueprint, onde ele ganha uma Comissão Maker definida pelos vendedores, ou crie uma nova versão deste Blueprint e inclua-o como conexão no seu próprio Blueprint para compartilhar receita.

Discussão

(0)

Entrar para participar da discussão

Carregando comentários...