Jumpers para Arduino: tipos, AWG, corrente e testes
Jumpers para Arduino: tipos macho-macho, macho-fêmea e fêmea-fêmea, bitola AWG e corrente, mau contato, teste com multímetro e como crimpar fios Dupont.
Os jumpers para Arduino são fios finos com conectores Dupont de passo 2,54 mm nas duas pontas, usados para ligar em segundos uma protoboard, um Arduino e módulos de sensores sem solda. Resumindo, um jumper é uma ponte de fio encaixável para testar, mudar e desmontar um circuito. Conforme as pontas sejam macho (com pino) ou fêmea (com soquete), há três tipos básicos, macho-macho, macho-fêmea e fêmea-fêmea, e cada um foi pensado para um tipo de ligação.
Eles parecem a peça mais barata do kit, mas uma parte surpreendente dos problemas de iniciantes vem deles: um sensor que às vezes não responde, um display I2C que aparece e some, ou uma placa que reinicia quando você encosta em um fio. Neste artigo você vai aprender os tipos de jumpers e qual usar em cada ligação, quanta corrente cada bitola de fio (AWG) aguenta, como pegar um mau contato ou um fio partido com um multímetro e um pequeno sketch de Arduino, como fazer os seus próprios fios Dupont e como organizar a protoboard para Arduino Uno, ESP32 e Raspberry Pi Pico.

O que é um jumper e para que serve?
Um jumper tem três partes: um fio de cobre fino e flexível, um terminal metálico crimpado na ponta do fio e uma capa plástica em volta. O terminal pode ser macho, um pino de cerca de 0,6 mm que entra no furo da protoboard, ou fêmea, um soquete com mola que encaixa sobre um pino de barra. Esse sistema de conectores costuma ser chamado de Dupont. Como o passo é de 2,54 mm (0,1 polegada), ele encaixa em todas as barras de pinos padrão, protoboards, conectores fêmea do Arduino e pinos macho de módulos. Os jumpers costumam ser vendidos em fitas coloridas de 40 fios com 10, 20 e 30 cm, e você destaca quantos precisar. Atenção: "jumper" também significa outra coisa em eletrônica: a pequena tampinha plástica que põe dois pinos em curto em placas como o L298N também se chama jumper (shunt). Neste artigo, o jumper é o fio.
Tipos de jumpers: macho-macho, macho-fêmea, fêmea-fêmea
| Tipo | Pontas | Onde é usado? | Exemplo de ligação |
|---|---|---|---|
| Macho-macho (M-M) | Pinos nas duas pontas | Dentro da protoboard e entre a protoboard e os conectores fêmea do Arduino Uno | 5V do Uno → trilha + da protoboard |
| Macho-fêmea (M-F) | Pino em uma ponta, soquete na outra | Ligar um módulo com pinos à protoboard ou ao Uno | Pinos macho do HC-SR04 → D9 e D10 do Uno |
| Fêmea-fêmea (F-F) | Soquetes nas duas pontas | Unir duas barras de pinos macho direto, sem protoboard | Pinos do ESP32 → IN1–IN4 do L298N |
| Fio rígido para protoboard | Fio duro cortado e dobrado em U | Ligações curtas, rentes e organizadas na protoboard | Unir trilhas, ligar um LED ao resistor |
| Cabo com garra jacaré | Garras com mola | Ligações temporárias a baterias, multímetros e bornes de parafuso | Testar um pack de pilhas no circuito |
Para um primeiro kit recomendamos uma fita de cada tipo (40 fios, 20 cm); macho-macho e macho-fêmea são os que acabam primeiro. 20 cm é o ideal para a maioria dos circuitos de bancada. Fios de 30 cm ajudam a alcançar um sensor distante, mas bagunçam o circuito, e para as ligações dentro da protoboard um kit de jumpers rígidos fica muito mais organizado. Comparamos o conteúdo dos kits iniciais em kit inicial de Arduino.
Fio rígido ou flexível? Cobre ou CCA?
Os jumpers Dupont costumam ter condutor flexível (multifilar) feito de 7 ou mais fios finos: ele é maleável e aguenta dobras, mas se a ponta ficar desencapada os fios se abrem. Já os jumpers de protoboard têm um único fio grosso rígido: entra direto no furo e fica no lugar, mas quebra se for dobrado muitas vezes no mesmo ponto. Alguns fios baratos não são de cobre puro, e sim de alumínio com uma camada fina de cobre (CCA). O CCA tem cerca de 50–60% mais resistência que o cobre da mesma bitola e quebra com mais facilidade. É fácil identificar: corte a ponta e raspe o fio; se for prateado por dentro, é CCA. Serve para linhas de sinal, mas em linhas de alimentação de motores e servos aumenta a queda de tensão.
Bitola do fio (AWG) e capacidade de corrente
| AWG | Diâmetro | Seção | Resistência do cobre | Resistência de 20 cm | Limite prático como jumper |
|---|---|---|---|---|---|
| 30 | 0,25 mm | 0,05 mm² | 0,34 Ω/m | 0,068 Ω | 0,3 A |
| 28 | 0,32 mm | 0,08 mm² | 0,21 Ω/m | 0,043 Ω | 0,5 A |
| 26 | 0,40 mm | 0,13 mm² | 0,13 Ω/m | 0,027 Ω | 1 A |
| 24 | 0,51 mm | 0,21 mm² | 0,084 Ω/m | 0,017 Ω | 2 A |
| 22 | 0,64 mm | 0,33 mm² | 0,053 Ω/m | 0,011 Ω | 2–3 A no fio; os contatos da protoboard limitam a cerca de 1 A |
Quanto maior o número AWG (American Wire Gauge), mais fino o fio; a cada 6 números o diâmetro cai pela metade. A maioria dos jumpers do mercado é de 26 ou 28 AWG, e os mais baratos descem a 30 AWG. A última coluna da tabela tem mais a ver com os contatos Dupont do que com o fio em si: um contato barato esquenta acima de 1 A e sua resistência sobe. Mas o problema real aparece antes do calor: a queda de tensão, fácil de calcular com a lei de Ohm (V = I × R). Se você alimenta um servo por dois jumpers de 20 cm (ida e volta), fio CCA mais quatro contatos podem somar 0,3–0,5 Ω. Para um MG996R puxando 1,5 A na partida, isso significa 0,45–0,75 V perdidos: os 5 V da fonte chegam ao servo como cerca de 4,3 V, e um Arduino na mesma linha pode reiniciar. Faça as contas com os seus valores na calculadora da lei de Ohm.
Organização da protoboard: Arduino Uno, ESP32 e Raspberry Pi Pico
| Placa | Encaixa na protoboard? | Fio recomendado | Dica |
|---|---|---|---|
| Arduino Uno | Não, fica ao lado | Macho-macho | Leve primeiro o 5V e o GND às trilhas da protoboard e alimente os módulos pelas trilhas |
| Arduino Nano | Sim, sobre o canal central | Macho-macho ou fio rígido | Sobram 2–3 furos livres de cada lado; deixe a ponta do USB virada para a borda da protoboard |
| ESP32 DevKit (30 pinos) | Sim, mas apertado | Macho-macho, macho-fêmea se precisar | Só uma fileira de furos fica livre de cada lado; juntar duas protoboards lado a lado é a solução mais fácil |
| ESP32 DevKitC (38 pinos) | Cobre um lado inteiro | Fêmea-fêmea ou macho-fêmea | Deixe a placa fora da protoboard e ligue os pinos direto com pontas fêmea |
| Raspberry Pi Pico | Sim, encaixe perfeito | Macho-macho | Com os pinos nas fileiras c e h, sobram dois furos livres de cada lado; os 8 pinos GND facilitam chegar às trilhas |
Seja qual for a placa, a organização segue a mesma lógica: alimentação primeiro. Leve o pino 5V ou 3V3 da placa à trilha + da protoboard com um fio vermelho e o GND à trilha − com um fio preto, e alimente sensores e módulos por essas trilhas. Em algumas protoboards compridas de 830 pontos as trilhas são divididas no meio; não esqueça uma pontezinha entre as duas metades, ou confira de ponta a ponta com um multímetro. O ESP32 e o Pico trabalham em 3,3 V, então mantenha os 5 V em uma trilha separada e nunca encaixe em um GPIO um jumper que leva 5 V. Explicamos o interior de uma protoboard em detalhes em Como usar uma protoboard.
- Vermelho: alimentação de 5 V ou 3,3 V; se tiver as duas, use laranja para 3,3 V.
- Preto ou marrom: GND.
- Amarelo e branco: sinais digitais, como saídas de botões e sensores.
- Verde e azul: linhas de comunicação como I2C (SDA, SCL) ou UART (TX, RX).
- Roxo e cinza: saídas PWM e entradas analógicas.
Mau contato e fios partidos: sintomas e causas
Um jumper ruim raramente está totalmente partido; na maioria das vezes ele funciona "às vezes", e por isso é o defeito que mais faz perder tempo. Sintomas típicos: um sensor dá valores sem sentido ou saltando, o scanner I2C vê o display em um momento e no outro não, um LED pisca quando você encosta no fio, ou a placa reinicia quando você esbarra na mesa. As causas são poucas. A mola dentro das pontas fêmea se abre depois de ser encaixada muitas vezes em pinos grossos e deixa de prender. Pinos macho baratos são finos e ficam frouxos na protoboard ou nos conectores do Uno. A mais traiçoeira é a quebra dos fios dentro do isolamento bem onde o fio é crimpado no terminal: por fora o fio parece bom, mas perde a ligação quando dobrado. Em fios guardados muito tempo em lugar úmido, os terminais também oxidam e a resistência de contato sobe.
Como testar jumpers com multímetro
- Coloque o multímetro no modo de continuidade (bipe); se não houver, use a escala de 200 Ω.
- Encoste as pontas de prova uma na outra e anote a leitura (normalmente 0,1–0,3 Ω); essa é a resistência das próprias pontas.
- Encoste a ponta de prova direto na ponta macho; para uma ponta fêmea, encaixe nela um pino macho curto e encoste nesse pino.
- Um bom jumper de 20 cm bipa e acrescenta no máximo alguns décimos de ohm à resistência das pontas.
- Enquanto mede, dobre de leve as duas pontas do fio, principalmente logo atrás do conector. Se o bipe falhar ou o valor saltar, o fio está com defeito.
- Corte ou marque o fio com defeito na hora; se você o devolver à caixa, um dia ele vai parar nas suas mãos de novo.
Um testador de jumpers com Arduino: pegue o mau contato
Este pequeno sketch transforma um Arduino em um testador de fios que conta as quedas. Ligue uma ponta do fio em teste ao D2 e a outra ao GND. Como o resistor de pull-up interno do D2 está ativado, o pino lê LOW enquanto o fio está bom e HIGH no instante em que o contato se perde. O trabalho de verdade é feito por uma interrupção: toda vez que o pino passa de LOW para HIGH, mesmo que por poucos microssegundos, o contador sobe um. Se a contagem de quedas aumentar no Monitor Serial enquanto você dobra o fio, esse fio vai para o lixo. No ESP32 o código usa automaticamente o GPIO 4 e o LED da placa (GPIO 2).
1// Jumper kablo test cihazı / jumper wire tester
2// Kablonun bir ucu TEST_PIN'e, diğer ucu GND'ye / one end of the wire to TEST_PIN, the other to GND
3#if defined(ESP32)
4const byte TEST_PIN = 4; // ESP32: GPIO 4
5const byte LED_PIN = 2; // DevKit kart LED'i / DevKit on-board LED
6#else
7const byte TEST_PIN = 2; // Uno: kesme pini D2 (ya da D3) / interrupt pin D2 (or D3)
8const byte LED_PIN = LED_BUILTIN; // Uno: D13
9#endif
10
11#ifndef IRAM_ATTR
12#define IRAM_ATTR // AVR'de boş; ESP32'de kesmeyi RAM'e alır / empty on AVR; keeps the ISR in RAM on ESP32
13#endif
14
15volatile unsigned long dropouts = 0; // temas kesilme sayısı / number of contact dropouts
16
17void IRAM_ATTR onDropout() { // pin HIGH'a çıktı: temas koptu / pin went HIGH: contact lost
18 dropouts++;
19}
20
21void setup() {
22 pinMode(TEST_PIN, INPUT_PULLUP); // kablo yokken HIGH, sağlam kabloda LOW / HIGH with no wire, LOW with a good wire
23 pinMode(LED_PIN, OUTPUT);
24 Serial.begin(9600);
25 attachInterrupt(digitalPinToInterrupt(TEST_PIN), onDropout, RISING);
26 Serial.println(F("Kabloyu bagla ve uclarini kipirdat / connect the wire and wiggle the ends"));
27}
28
29void loop() {
30 bool ok = (digitalRead(TEST_PIN) == LOW); // LOW = kablo iletiyor / LOW = wire conducts
31 digitalWrite(LED_PIN, ok);
32
33 noInterrupts(); // sayacı güvenle oku / read the counter safely
34 unsigned long n = dropouts;
35 interrupts();
36
37 Serial.print(ok ? F("SAGLAM / OK ") : F("ACIK / OPEN "));
38 Serial.print(F("kopma / dropouts: "));
39 Serial.println(n);
40 delay(250);
41}No Raspberry Pi Pico o mesmo teste é feito em MicroPython. Ligue o fio entre o GP15 (pino físico 20) e o GND vizinho (pino físico 18); nas versões atuais do MicroPython, Pin("LED") aciona o LED da placa tanto no Pico quanto no Pico W. Antes de testar fios suspeitos, ligue o GP15 ao GND com um fio que você sabe que está bom e confira se aparece SAGLAM / OK, para saber que a montagem em si funciona.
1from machine import Pin
2import time
3
4test = Pin(15, Pin.IN, Pin.PULL_UP) # kablo GP15 (pin 20) ile GND (pin 18) arasında / wire between GP15 (pin 20) and GND (pin 18)
5led = Pin("LED", Pin.OUT) # kart üzerindeki LED / on-board LED
6dropouts = 0
7
8def on_dropout(pin): # pin 1'e çıktı: temas koptu / pin went to 1: contact lost
9 global dropouts
10 dropouts += 1
11
12test.irq(trigger=Pin.IRQ_RISING, handler=on_dropout)
13
14while True:
15 ok = test.value() == 0 # 0 = kablo iletiyor / 0 = wire conducts
16 led.value(ok)
17 print("SAGLAM / OK" if ok else "ACIK / OPEN", "kopma / dropouts:", dropouts)
18 time.sleep(0.25)Fazendo os seus próprios fios Dupont
| Material | Descrição |
|---|---|
| Alicate de crimpar | Tipo SN-28B ou PA-09 para terminais Dupont; alicate comum não serve para isso |
| Terminais Dupont (macho e fêmea) | 2,54 mm; costumam vir em pacotes de 100 |
| Capas plásticas | 1, 2, 3… posições (1×N ou 2×N); uma capa de vários pinos transforma o conector em uma peça só |
| Fio flexível | 26–28 AWG, de preferência cobre puro com isolamento de silicone ou PVC |
| Desencapador de fios | Um desencapador ajustável ou automático para fios finos |
- Corte o fio no comprimento desejado e tire 2–3 mm de isolamento das pontas; torça um pouco os fios para não se abrirem.
- Observe o terminal: as aletas pequenas da frente prendem o fio desencapado e as aletas maiores de trás prendem o isolamento.
- Coloque o terminal no encaixe certo do alicate com as aletas para cima e empurre o fio até o cobre desencapado ficar sob as aletas da frente.
- Aperte o alicate até o fim; em uma boa crimpagem as aletas envolvem o fio e o isolamento de forma arredondada.
- Puxe o fio de leve: o terminal não pode se mexer. Se mexer, corte e refaça.
- Empurre o terminal na capa com a travinha virada para a janela da capa; ele deve encaixar com um clique.
Fazer os próprios fios é barato e permite usar comprimentos exatos e conectores de vários pinos; por exemplo, você pode ligar os quatro pinos de um módulo de sensor com uma única capa 1×4, o que diminui a chance de encaixar ao contrário. Uma ponta fêmea frouxa também costuma ter conserto: levante com uma agulha a pequena trava plástica da capa, puxe o terminal, aperte de leve a parte da mola com uma pinça e encaixe de volta. Para circuitos permanentes, porém, uma ligação soldada é mais confiável que um jumper; veja Circuitos permanentes em placa perfurada.
Erros comuns e soluções
- Encaixar na fileira errada: é muito fácil escorregar uma fileira na protoboard; leia as letras e os números ao encaixar e compare o circuito com o esquema mais uma vez ao terminar.
- Forçar uma ponta fêmea em um pino grosso: terminais de borne de parafuso ou pinos de 1 mm abrem a mola da fêmea para sempre; não use pontas fêmea em pinos assim.
- Fios I2C e SPI longos: jumpers com mais de 30 cm captam ruído e atrapalham a comunicação rápida; use fios curtos para displays e sensores I2C e reduza a velocidade do I2C se preciso.
- Esquecer o GND comum: se você usa duas fontes separadas e não une os GNDs com um jumper, os sinais perdem o sentido; detalhes em Terra comum.
- Puxar o jumper pelo fio: segure a capa plástica, não o fio, ao desencaixar; puxar pelo fio é a causa número um de crimpagens partidas.
- Devolver um fio ruim à caixa: corte na hora o fio suspeito; brigar de novo com o mesmo defeito custa horas.
Os jumpers são as veias de um circuito: quando você escolhe o tipo certo, mantém os fios curtos e organizados e, de vez em quando, testa e descarta os cansados, o tempo gasto caçando defeitos despenca. Com um bom conjunto de fios na bancada, você está pronto para os primeiros circuitos. No app BlueGrays você encontra projetos iniciais de protoboard como o semáforo, o LED com botão, o medidor de distância e os primeiros passos com o Raspberry Pi Pico, com esquemas que mostram onde vai cada fio e código passo a passo.
Perguntas frequentes
Para que servem os jumpers?
Os jumpers servem para fazer ligações temporárias entre uma protoboard, um Arduino e módulos sem solda. Graças aos conectores Dupont de 2,54 mm eles encaixam e desencaixam dos pinos, então você monta e muda um circuito rapidamente.
Quando usar jumpers macho-fêmea?
Os fios macho-fêmea ligam um módulo com pinos macho a uma protoboard ou aos conectores fêmea do Arduino Uno. Por exemplo, você encaixa a ponta fêmea nos pinos de um módulo HC-SR04 ou DHT11 e a ponta macho no Arduino ou na protoboard.
Quanta corrente um jumper aguenta?
Para os jumpers comuns de 26 AWG o limite prático é de cerca de 1 A, e de cerca de 0,5 A para 28 AWG; na maioria das vezes o limite vem dos contatos Dupont, e não do fio. Para motores, fitas de LED e packs de baterias, use fio mais grosso e bornes de parafuso.
Como saber se um jumper está ruim?
Coloque o multímetro em continuidade, meça de ponta a ponta e dobre o fio logo atrás dos conectores enquanto mede. Se o bipe falhar ou a resistência saltar, o fio está com defeito; para pegar quedas muito curtas, você pode montar um testador simples com Arduino que usa interrupção.
Fios Dupont e jumpers são a mesma coisa?
No uso do dia a dia, sim. Dupont é o nome do sistema de conectores de passo 2,54 mm das pontas, e os fios prontos com esses conectores são chamados tanto de jumpers quanto de fios Dupont.
Quais jumpers comprar para a protoboard?
Para começar, o ideal é uma fita de 20 cm de cada tipo, macho-macho, macho-fêmea e fêmea-fêmea, mais uma caixa de fios rígidos para protoboard. Os fios rígidos deixam as ligações dentro da protoboard organizadas, enquanto os fios Dupont flexíveis alcançam placas e módulos.
Projetos para montar depois desta leitura
Ver todos os projetos
Semáforo
Uma pequena versão do semáforo que você vê na rua todos os dias. O vermelho fica aceso por dois segundos, o amarelo acende por um instante, o verde fica aceso por dois segundos e depois volta ao…

Controle de LED com botão (momentâneo)
É como uma campainha: a luz fica acesa enquanto você pressiona o botão e apaga quando você solta.

Medição da intensidade da luz com LDR
Quer ver a luminosidade do seu quarto em números? O LDR, um pequeno componente sensível à luz, mede a luz ambiente, e o Arduino exibe o valor na tela do computador a cada meio segundo.

Medição de distância com HC-SR04 (Monitor Serial)
O sensor HC-SR04 funciona como um morcego que se orienta no escuro: emite um som que você não consegue ouvir, escuta o eco e mede a distância até o objeto à sua frente.

LED piscando com ESP32
Ensina o uso básico de uma saída GPIO no ESP32. Fazemos um LED piscar ligando e desligando um pino digital. É a versão para ESP32 do clássico projeto blink do Arduino UNO: os comandos básicos de blink no ambiente Arduino são os mesmos, mas a disposição dos pinos e os níveis de 3,3 V dos GPIOs do ESP32 diferem dos do Arduino UNO.

Semáforo com ESP32
Simulação de um semáforo real com 3 LEDs: vermelho, amarelo e verde. Os tempos se aproximam da lógica real: vermelho longo, amarelo curto e verde longo. Um exemplo clássico de controle sequencial de GPIOs.

Raspberry Pi Pico: controle de LED externo (protoboard)
O próximo passo depois do LED integrado do Pico: conectar um LED externo na protoboard e controlá-lo pelo pino GP14. Você aprende a usar qualquer pino GPIO do Pico como saída, a polaridade do LED (terminal longo = ânodo/+, terminal curto = cátodo/–) e por que um resistor limitador de corrente (220Ω) é indispensável. Sem o resistor, passa corrente demais pelo LED e ele pode queimar.

Raspberry Pi Pico: semáforo (3 LEDs em sequência)
Simulamos um semáforo real com LEDs vermelho, amarelo e verde — o primeiro projeto com 3 LEDs da série Pico! Verde por 4 segundos: "siga"; amarelo por 1,5 segundo: "prepare-se"; vermelho por 3 segundos: "pare"; e vermelho+amarelo por 1 segundo: "saída" (padrão de semáforo europeu). Aprenda definição de funções (def all_off()), lógica de máquina de estados (sequência) e sincronização de vários GPIOs.
Mais artigos
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

