Como ler um esquema de circuito: símbolos, junções e protoboard

Como ler um esquema de circuito? A resposta curta: o esquema é um mapa que usa símbolos padronizados para mostrar qual terminal está ligado eletricamente a qual, e não a aparência das peças. Para ler um, você primeiro reconhece os símbolos, depois segue cada linha como uma conexão, distingue os pontos de junção dos simples cruzamentos, lê rótulos e valores como R1 ou 220 e, por fim, descobre que parte do circuito os símbolos VCC e GND alimentam. Essas cinco habilidades bastam para entender qualquer desenho, de um circuito com um único LED ao próprio esquema do Arduino.

Neste guia, reunimos em uma tabela os símbolos que você vai encontrar com mais frequência e explicamos como ler o sentido dos símbolos de diodo e transistor, a diferença entre fios que se cruzam e fios conectados, as conexões ocultas criadas pelos nomes de net (os nomes escritos nos fios) e o que procurar nos esquemas de módulos prontos. Depois, transformamos o esquema de um circuito real com botão, LED e buzzer em uma lista de conexões (netlist), passamos tudo para a protoboard passo a passo e damos um código para testar o circuito pronto em um Arduino, um ESP32 e um Raspberry Pi Pico. Nas últimas seções, você encontra a diferença entre a vista de protoboard do Fritzing e um esquema de verdade, além dos erros de leitura mais comuns.

O que é um esquema de circuito e para que serve?

Um esquema de circuito (ou esquema elétrico) é um desenho que mostra a estrutura elétrica de um circuito eletrônico. Os componentes aparecem como símbolos, não no tamanho nem na posição reais, e as linhas entre eles não mostram o caminho real de um fio; elas só dizem que as duas pontas estão no mesmo ponto elétrico. Por isso, dois resistores desenhados lado a lado no esquema podem ficar longe um do outro na placa, e uma linha comprida no esquema pode ser uma única coluna de furos na protoboard. É aí que está a força do esquema: num relance, ele mostra como o circuito funciona, por onde passa a corrente e onde procurar quando algo falha.

Esquemas bem desenhados seguem alguns hábitos comuns: o sinal geralmente flui da esquerda para a direita (entradas à esquerda, saídas à direita), as tensões mais altas ficam em cima e o GND embaixo. Ao lado de cada componente há um rótulo (R1, C2, Q1) e um valor (220, 100n, BC547). CIs e módulos são desenhados como retângulos com os números e os nomes dos pinos. A tabela abaixo resume os elementos básicos que você vai ver em um esquema:

Os símbolos mais comuns em esquemas de circuito

Há duas tradições principais para desenhar símbolos: a IEC 60617, comum na Europa e em boa parte do mundo, e a americana ANSI/IEEE 315. A diferença mais conhecida é o resistor: nos esquemas IEC ele é um retângulo vazio; nos ANSI, uma linha em zigue-zague. Os dois representam o mesmo componente e, como você vai ver ambos nos esquemas de Arduino na internet, precisa reconhecer os dois. A tabela abaixo cobre quase todos os símbolos que você vai encontrar nos primeiros projetos:

Como ler o sentido nos símbolos de diodo, LED e transistor

Pense no triângulo do símbolo de diodo ou de LED como uma seta: a corrente flui no sentido para onde o triângulo aponta, do ânodo para o cátodo. A barra na ponta do triângulo é o cátodo e corresponde ao anel no corpo de um diodo real. No LED, as duas setinhas que saem do triângulo representam a luz; se as setas apontam para dentro, não é um LED, e sim uma peça que detecta luz, como um fotodiodo ou um fototransistor. Se o LED está do lado certo mas acende muito fraco ou queima logo, confira o resistor em série com a calculadora Resistor para LED.

No símbolo do transistor, a seta fica sempre no emissor e mostra o sentido da corrente convencional. No NPN, a seta aponta para fora: a corrente vai do coletor para o emissor, e o emissor geralmente vai ao GND. No PNP, a seta aponta para dentro e o emissor se liga à alimentação positiva. O terminal inclinado sem seta é o coletor, e o terminal que encontra a linha curta e grossa em ângulo reto é a base. Aqui há uma armadilha importante: as letras B, C e E no esquema não dizem a ordem dos pinos no encapsulamento real. Com o lado plano virado para você, as pernas do BC547 são C, B, E da esquerda para a direita, enquanto no 2N2222A e no S8050 são E, B, C. Então, ao passar do esquema para a protoboard, confira a pinagem de cada transistor no datasheet ou com a ferramenta Transistores; para mais detalhes, veja O que é um transistor?.

VCC, GND e símbolos de alimentação

Desenhar as linhas de alimentação até cada componente separadamente deixaria o esquema poluído, então se usam símbolos de alimentação. VCC, +5V ou 3V3 escrito ao lado de uma seta para cima ou de uma barrinha horizontal marca um ponto de alimentação, enquanto três linhas horizontais que vão encurtando para baixo (um triângulo para baixo em alguns desenhos) marcam o GND, o ponto de terra e de referência. Não esqueça a regra: todos os símbolos de alimentação com o mesmo nome estão conectados, mesmo sem linha entre eles. Um GND no canto inferior direito do esquema é o mesmo ponto que o GND no canto superior esquerdo. Por isso, todos os GNDs precisam ser unidos, mesmo em módulos com alimentação separada; O que é GND? explica o porquê em detalhes.

Os nomes da alimentação vêm dos terminais dos transistores: VCC da alimentação do coletor nos transistores bipolares, VDD e VSS do dreno e da fonte dos MOSFETs nos circuitos CMOS. Na prática, VCC e VDD significam a alimentação positiva, enquanto VSS e VEE significam GND ou uma alimentação negativa. Se você vir AGND (terra analógico) e DGND (terra digital), são terras desenhados separadamente para isolar o ruído, mas que no fim costumam ser unidos em um único ponto. A tensão que você deve aplicar ao pino VCC de um módulo não é dita pelo rótulo, e sim pelo esquema ou pelo datasheet do módulo.

Fios que se cruzam e fios conectados: a regra do ponto

O que mais confunde quem está começando a ler esquemas são os lugares onde duas linhas se sobrepõem. A regra é simples, mas rígida: se há um ponto cheio no encontro, as linhas estão conectadas; se não há ponto, elas só se cruzam. Esquemas antigos desenhavam os cruzamentos sem conexão como uma linha pulando a outra com um pequeno semicírculo, e você ainda vê isso em alguns livros didáticos. Programas de desenho modernos, como o KiCad e o EasyEDA, colocam o ponto automaticamente quando a ponta de uma linha toca o meio de outra.

• Junção em T com ponto: três linhas se encontram em um ponto; todas estão na mesma net. É a forma mais segura e mais comum de desenhar.
• Cruzamento em cruz, sem ponto: duas linhas passam uma sobre a outra sem se tocar; não há conexão entre elas.
• Cruzamento em cruz com ponto: as quatro linhas estão conectadas, mas, como o ponto pode sumir numa fotocópia ou numa tela pequena, bons projetistas desenham isso como duas junções em T deslocadas.
• Salto em semicírculo: estilo antigo; uma linha pula a outra, sem conexão.
• X na ponta de uma linha: pino não conectado (NC, no connect); deixar esse pino livre é uma escolha proposital.

Rótulos, valores e nomes de net

O designador de referência ao lado de cada componente é formado por um código de letra e um número de sequência: R1, R2, C1, D1, Q1, U1. A letra indica o tipo: R resistor, C capacitor, L indutor, D diodo, Q transistor, U CI, K relé, F fusível, SW chave, J ou P conector, Y cristal, BZ buzzer, M motor. Nas placas prontas, os mesmos rótulos vêm impressos na serigrafia, então você consegue achar na placa o C5 do esquema. Os valores são escritos de forma abreviada: 4k7 significa 4,7 kΩ, 100n 100 nF e 10u 10 µF; a letra ocupa o lugar da vírgula decimal. Se precisar ler um valor pelas faixas de cores, use a ferramenta Código de cores; os detalhes de cada família de componentes estão em Componentes eletrônicos básicos.

O verdadeiro segredo para ler esquemas são os nomes de net. Uma net é o ponto elétrico formado por todos os terminais ligados entre si. Como é impossível desenhar cada conexão como uma linha em esquemas grandes, o projetista escreve um nome na ponta de um fio: SDA, SCL, LED, TX e assim por diante. Dois fios com o mesmo nome estão conectados, mesmo sem linha entre eles. No esquema oficial do Arduino Uno, por exemplo, as linhas TX e RX do chip USB-serial se ligam ao processador principal assim, pelo nome. Um nome pode estar em um canto da página e o seu par no outro; enquanto você não os relacionar, ainda não leu o esquema de verdade.

Como ler um esquema de circuito passo a passo

1. Encontre as fontes de alimentação: marque a bateria, o USB, o VIN ou a entrada do adaptador e cada símbolo VCC, 3V3 e GND. Saiba desde o início com que tensão o circuito trabalha.
2. Identifique a peça principal: um Arduino, um ESP32, um Pico ou um CI costuma ser a caixa grande no meio do esquema; todo o resto é montado em volta dela.
3. Faça uma lista de peças: anote todos os rótulos e valores (R1 220 Ω, C1 100 nF, Q1 BC547). Essa lista vira ao mesmo tempo sua lista de compras e seu checklist.
4. Divida o circuito em blocos: desenhe molduras em volta das partes de alimentação, entrada (botão, sensor), processamento (placa) e saída (LED, buzzer, motor).
5. Siga cada net separadamente: comece em um pino, acompanhe a linha até os pontos e anote cada pino dessa net. Não esqueça os rótulos de net com o mesmo nome.
6. Marque as peças polarizadas: destaque no esquema o cátodo do diodo, o ânodo do LED, o positivo do capacitor eletrolítico e o emissor do transistor.
7. Descreva o caminho do sinal em uma frase: se você consegue dizer “apertar o botão leva o D2 a LOW, o código coloca o D8 em HIGH, o Q1 conduz e o buzzer toca”, você leu o esquema de verdade.

Exemplo: lendo o esquema de um circuito com botão, LED e buzzer

Agora vamos aplicar o que você aprendeu a um esquema real. Nosso circuito tem sete componentes. A net LED, que sai do pino D9 do Arduino, passa pelo resistor R1 (220 Ω) e chega ao ânodo do LED1; o cátodo do LED está ligado ao GND. A net BTN, no pino D2, desce até o GND pelo botão SW1 e pelo capacitor C1 (100 nF) em paralelo com ele. A net BZ, que sai do pino D8, chega à base do transistor Q1 (BC547) através do R2 (1 kΩ); o emissor do Q1 está no GND e o coletor no terminal negativo do buzzer ativo BZ1, cujo terminal positivo está no +5V. A forma mais confiável de ler um esquema é transformá-lo em uma lista de conexões (netlist) como a de baixo: cada linha da tabela é uma net, e todos os terminais dessa linha precisam se encontrar em um único ponto da protoboard.

Repare em dois detalhes da tabela. Primeiro, não há resistor de pull-up no botão do esquema, porque o código vai usar INPUT_PULLUP e o resistor interno do processador (cerca de 20–50 kΩ no Uno) fará esse papel. Bons esquemas indicam isso com um pequeno comentário ao lado do pino. Segundo, o C1 é um capacitor de debounce por hardware que suaviza o repique dos contatos do botão; junto com o pull-up interno, ele forma uma constante de tempo RC de aproximadamente 2–5 ms. Os nomes N1, N2 e N3 das nets sem nome fomos nós que demos; programas como o KiCad dão nomes a elas automaticamente. Para saber mais sobre a ligação de botões, veja Como ligar um botão no Arduino.

Passando um esquema para a protoboard

1. Imprima o esquema ou deixe-o na tela ao seu lado e tenha um marca-texto à mão; pinte cada conexão do esquema à medida que for montando.
2. Prepare as trilhas de alimentação: ligue o 5V da placa à trilha vermelha (+) e o GND à trilha azul (−). Em protoboards compridas, confira se as trilhas são divididas no meio.
3. Coloque as peças grandes: encaixe os CIs atravessando o canal central e espete os módulos e o transistor de modo que as pernas fiquem em colunas separadas.
4. Atribua uma coluna a cada net: os cinco furos verticais de uma protoboard já estão conectados; coloque as pernas da mesma net na mesma coluna ou una colunas com um jumper.
5. Monte as peças polarizadas comparando com as marcas do esquema: a perna longa do LED no N1 e o BC547 com o lado plano virado para você, para que a ordem C, B, E caia nas colunas certas.
6. Crie uma regra para as cores dos fios: vermelho para alimentação, preto ou azul para GND, outras cores para sinais. A cor não muda nada eletricamente, mas acelera a depuração.
7. Meça antes de ligar a alimentação: coloque o multímetro no modo de continuidade (bipe); primeiro garanta que não há curto entre 5V e GND e depois confirme o bipe entre os terminais de cada linha da netlist.

Testando o circuito montado: código para Arduino e ESP32

A forma mais rápida de saber se você passou o esquema corretamente é um pequeno programa de teste que confere cada net, uma por uma. O código abaixo primeiro acende o LED por um segundo na inicialização, depois faz o buzzer tocar rapidamente e mostra a etapa atual no Monitor Serial; em seguida, fica observando o botão. Mantivemos os nomes das constantes no código iguais aos nomes das nets no esquema, então a net BZ do esquema é BZ_PIN no código. No ESP32, o mesmo código troca os números dos pinos sozinho; faça a ligação conforme a tabela abaixo.

1// Şemadan kurulan devreyi net net test eder / Tests the circuit built from the schematic, net by net
2// Sabit isimleri şemadaki net isimleriyle aynı / Constant names match the net names on the schematic
3#if defined(ESP32)
4const int LED_PIN = 18;   // LED neti: R1 üzerinden LED1 anoduna / LED net: to LED1 anode via R1
5const int BTN_PIN = 4;    // BTN neti: SW1 ve C1, diğer uçları GND / BTN net: SW1 and C1, other ends to GND
6const int BZ_PIN  = 19;   // BZ neti: R2 üzerinden Q1 beyzine / BZ net: to Q1 base via R2
7#else
8const int LED_PIN = 9;
9const int BTN_PIN = 2;
10const int BZ_PIN  = 8;
11#endif
12
13bool lastPressed = false;
14
15void setup() {
16  Serial.begin(115200);
17  pinMode(LED_PIN, OUTPUT);
18  pinMode(BZ_PIN, OUTPUT);
19  pinMode(BTN_PIN, INPUT_PULLUP);   // dahili pull-up, şemada ayrı direnç yok / internal pull-up, no separate resistor on the schematic
20
21  Serial.println(F("1) LED testi / LED test"));
22  digitalWrite(LED_PIN, HIGH);      // N1 netine akım gider, LED1 yanar / current flows into N1, LED1 lights
23  delay(1000);
24  digitalWrite(LED_PIN, LOW);
25
26  Serial.println(F("2) Buzzer testi / Buzzer test"));
27  digitalWrite(BZ_PIN, HIGH);       // Q1 iletime geçer, N3 GND'ye çekilir / Q1 turns on, N3 is pulled to GND
28  delay(300);
29  digitalWrite(BZ_PIN, LOW);
30
31  Serial.println(F("3) Butona bas / Press the button"));
32}
33
34void loop() {
35  bool pressed = (digitalRead(BTN_PIN) == LOW);   // SW1 basılıyken BTN neti GND olur / BTN net goes to GND while SW1 is pressed
36  digitalWrite(LED_PIN, pressed ? HIGH : LOW);
37  digitalWrite(BZ_PIN, pressed ? HIGH : LOW);
38
39  if (pressed != lastPressed) {                    // yalnızca değişince yaz / print only on change
40    if (pressed) {
41      Serial.println(F("Basildi / Pressed"));
42    } else {
43      Serial.println(F("Birakildi / Released"));
44    }
45    lastPressed = pressed;
46  }
47  delay(10);
48}

Três linhas do programa têm relação direta com o esquema. INPUT_PULLUP liga o resistor de pull-up interno que não aparece no esquema, então o pino lê HIGH quando o botão não está pressionado e LOW quando está, porque o SW1 liga a net ao GND. digitalWrite(BZ_PIN, HIGH) envia corrente pelo R2 até a base do Q1: em um Uno de 5 V, essa corrente é (5 − 0,7) / 1000 ≈ 4,3 mA. Como o BC547 tem ganho de corrente de pelo menos 110, isso chaveia com folga os cerca de 30 mA que o buzzer consome; no ESP32, o pino fornece 3,3 V, então a corrente de base cai para 2,6 mA, o que ainda é suficiente. A corrente do LED no Uno é (5 − 2) / 220 ≈ 14 mA para um LED vermelho; você pode refazer esses cálculos com a calculadora Lei de Ohm.

O mesmo esquema com Raspberry Pi Pico e MicroPython

A beleza do esquema é que ele não depende da placa: para montar a mesma netlist em um Pico, basta escrever outros números de pino ao lado dos nomes das nets. No Pico, ligue o terminal positivo do buzzer ao pino VBUS (pino 40), que fornece os 5 V do USB. O GP16 só se liga à base do transistor através do R2; o lado de 5 V fica no coletor e nunca encosta diretamente no pino do Pico, então os pinos de 3,3 V ficam seguros. Salve o código no Pico como main.py com o Thonny:

1# Pico: şemadan kurulan devreyi net net test eder / tests the circuit built from the schematic, net by net
2from machine import Pin
3import time
4
5led = Pin(15, Pin.OUT)               # LED neti: GP15 -> R1 -> LED1 / LED net
6btn = Pin(14, Pin.IN, Pin.PULL_UP)   # BTN neti: GP14 -> SW1 + C1 -> GND / BTN net
7bz = Pin(16, Pin.OUT)                # BZ neti: GP16 -> R2 -> Q1 beyz / BZ net to Q1 base
8
9print("1) LED testi / LED test")
10led.on()
11time.sleep(1)
12led.off()
13
14print("2) Buzzer testi / Buzzer test")
15bz.on()                              # Q1 iletime geçer / Q1 turns on
16time.sleep(0.3)
17bz.off()
18
19print("3) Butona bas / Press the button")
20last = False
21while True:
22    pressed = btn.value() == 0       # basılıyken 0 okunur / reads 0 while pressed
23    led.value(pressed)
24    bz.value(pressed)
25    if pressed != last:              # yalnızca değişince yaz / print only on change
26        print("Basildi / Pressed" if pressed else "Birakildi / Released")
27        last = pressed
28    time.sleep_ms(10)

Lendo esquemas de módulos

Módulos prontos (placas de relé, adaptadores I2C para LCD, displays OLED, placas de sensores) também são pequenos circuitos, e a maioria dos esquemas pode ser encontrada na página do vendedor ou no datasheet do fabricante. Ao ler o esquema de um módulo, seu objetivo não é entender cada resistor, mas achar as cinco informações que dizem como ligar o módulo: tensão de alimentação e regulador, nível lógico, resistores de pull-up, entradas ativas em LOW e jumpers que selecionam endereço ou modo. O próprio esquema do Arduino Uno também é um bom exercício: só o esquema revela que, no Uno R3, o LED L não está ligado diretamente ao D13, e sim através de um buffer com amp-op, o LMV358.

Vista de protoboard do Fritzing ou esquema: qual é a diferença?

Os desenhos coloridos que você vê na maioria dos projetos de Arduino na internet não são, na verdade, esquemas, e sim a vista de protoboard de um programa chamado Fritzing. O Fritzing guarda o mesmo circuito em três vistas: a vista de protoboard, com desenhos parecidos com fotos das peças reais; a vista de esquema, com símbolos padronizados; e a vista de PCB, para o projeto da placa. Uma conexão feita em uma vista aparece nas outras como linhas tracejadas de ratsnest (conexões pendentes); o programa sabe que a conexão existe, mas deixa para você desenhá-la de forma organizada naquela vista. A vista de esquema que o Tinkercad Circuits desenha automaticamente tem um papel de ponte parecido; os detalhes estão em Simulação de Arduino no Tinkercad.

A vista de protoboard é muito confortável para iniciantes: ela mostra exatamente em que furo vai cada fio. Mas, à medida que o circuito cresce, os fios se cruzam, fica difícil ver em que fileira cada fio cai e não dá para entender por que o circuito foi montado daquele jeito. O esquema abandona totalmente a disposição física e mostra só a função; é por isso que você sempre volta ao esquema para depurar, passar o circuito para outra placa ou projetar uma PCB. Crie um bom hábito: olhe o desenho da protoboard enquanto monta um projeto e o esquema enquanto tenta entendê-lo.

Erros comuns e como corrigir

Ideias de projetos para praticar a leitura de esquemas

• Um único LED e um resistor: você começa com dois símbolos e três nets; transforme o circuito de O que é LED? primeiro em um esquema e depois em uma montagem na protoboard.
• Luz noturna automática: o divisor de tensão formado por um LDR e um resistor de 10 kΩ ensina a ler ligações em série e o ponto médio compartilhado em um esquema.
• Semáforo: com três LEDs e três resistores, o semáforo com Arduino é ideal para aprender a reconhecer blocos repetidos.
• Controle de lâmpada com relé: o esquema de um módulo relé reúne um transistor, um diodo e uma entrada ativa em LOW.
• Pisca-pisca com 555: o CI 555 timer é o exercício clássico para ler um símbolo de caixa com pinos numerados.
• Contador de 7 segmentos: os esquemas de display de 7 segmentos mostram como oito segmentos são desenhados de forma organizada com nomes de net.

Ler esquemas de circuito parece um alfabeto estrangeiro no começo, mas, depois que você aprende os símbolos, a regra do ponto e os nomes de net, passa a montar cada projeto novo entendendo, e não copiando. Como próximo passo, você pode redesenhar do zero o circuito de exemplo deste artigo no seu próprio programa de desenho e calcular as correntes e tensões de cada net com as leis de Kirchhoff. No app BlueGrays, você pode estudar passo a passo os esquemas de circuito de projetos como LED piscante, botões, luz noturna, buzzer e semáforo junto com o código, e testar na hora o que aprendeu com peças reais.