Componentes · 10 min de leitura

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.

Jumpers macho-macho, macho-fêmea e fêmea-fêmea
Jumpers vendidos em fita: conectores Dupont de 2,54 mm nas pontas e fios coloridos que você destaca um a um.

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

TipoPontasOnde é usado?Exemplo de ligação
Macho-macho (M-M)Pinos nas duas pontasDentro da protoboard e entre a protoboard e os conectores fêmea do Arduino Uno5V do Uno → trilha + da protoboard
Macho-fêmea (M-F)Pino em uma ponta, soquete na outraLigar um módulo com pinos à protoboard ou ao UnoPinos macho do HC-SR04 → D9 e D10 do Uno
Fêmea-fêmea (F-F)Soquetes nas duas pontasUnir duas barras de pinos macho direto, sem protoboardPinos do ESP32 → IN1–IN4 do L298N
Fio rígido para protoboardFio duro cortado e dobrado em ULigações curtas, rentes e organizadas na protoboardUnir trilhas, ligar um LED ao resistor
Cabo com garra jacaréGarras com molaLigações temporárias a baterias, multímetros e bornes de parafusoTestar 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

AWGDiâmetroSeçãoResistência do cobreResistência de 20 cmLimite prático como jumper
300,25 mm0,05 mm²0,34 Ω/m0,068 Ω0,3 A
280,32 mm0,08 mm²0,21 Ω/m0,043 Ω0,5 A
260,40 mm0,13 mm²0,13 Ω/m0,027 Ω1 A
240,51 mm0,21 mm²0,084 Ω/m0,017 Ω2 A
220,64 mm0,33 mm²0,053 Ω/m0,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.

Use jumpers e protoboard só para baixa tensão e baixa corrente (até 1 A). Para a alimentação de um driver de motor, uma fita de LED ou um pack de baterias, use bornes de parafuso e fio de pelo menos 20–22 AWG. E nunca passe tensão da rede (110–230 V) por jumpers ou protoboard.

Organização da protoboard: Arduino Uno, ESP32 e Raspberry Pi Pico

PlacaEncaixa na protoboard?Fio recomendadoDica
Arduino UnoNão, fica ao ladoMacho-machoLeve primeiro o 5V e o GND às trilhas da protoboard e alimente os módulos pelas trilhas
Arduino NanoSim, sobre o canal centralMacho-macho ou fio rígidoSobram 2–3 furos livres de cada lado; deixe a ponta do USB virada para a borda da protoboard
ESP32 DevKit (30 pinos)Sim, mas apertadoMacho-macho, macho-fêmea se precisarSó 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 inteiroFêmea-fêmea ou macho-fêmeaDeixe a placa fora da protoboard e ligue os pinos direto com pontas fêmea
Raspberry Pi PicoSim, encaixe perfeitoMacho-machoCom 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

  1. Coloque o multímetro no modo de continuidade (bipe); se não houver, use a escala de 200 Ω.
  2. 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.
  3. Encoste a ponta de prova direto na ponta macho; para uma ponta fêmea, encaixe nela um pino macho curto e encoste nesse pino.
  4. Um bom jumper de 20 cm bipa e acrescenta no máximo alguns décimos de ohm à resistência das pontas.
  5. 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.
  6. 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.
O bipe do multímetro é lento para pegar quedas curtas; você não vai ouvir perdas de contato de poucos milissegundos. Já um microcontrolador percebe até uma queda tão curta, e a comunicação I2C falha justo nesse momento. Por isso vale testar os fios suspeitos também com o código de teste da próxima seção. Para as outras funções do multímetro, veja Como usar um multímetro.

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).

C++ (Arduino IDE)
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.

MicroPython
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

MaterialDescrição
Alicate de crimparTipo 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ásticas1, 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ível26–28 AWG, de preferência cobre puro com isolamento de silicone ou PVC
Desencapador de fiosUm desencapador ajustável ou automático para fios finos
  1. 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.
  2. Observe o terminal: as aletas pequenas da frente prendem o fio desencapado e as aletas maiores de trás prendem o isolamento.
  3. 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.
  4. Aperte o alicate até o fim; em uma boa crimpagem as aletas envolvem o fio e o isolamento de forma arredondada.
  5. Puxe o fio de leve: o terminal não pode se mexer. Se mexer, corte e refaça.
  6. 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.

Ver todos os projetos
Semáforo
AR-3Iniciante

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…

4.8(137)
440
Controle de LED com botão (momentâneo)
AR-9Iniciante

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.

4.8(114)
253
Medição da intensidade da luz com LDR
AR-11Iniciante

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.

4.6(83)
143
Medição de distância com HC-SR04 (Monitor Serial)
AR-27Iniciante

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.

4.6(50)
82
LED piscando com ESP32
ES-1Iniciante

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.

4.7(37)
108
Semáforo com ESP32
ES-5Iniciante

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.

4.4(22)
45
Raspberry Pi Pico: controle de LED externo (protoboard)
PI-2Iniciante

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.

4.5(2)
7
Raspberry Pi Pico: semáforo (3 LEDs em sequência)
PI-4Iniciante

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.

4.0(1)
12