Blog
LED Piscando no Arduino pelo Navegador — Sem Placa
O primeiro projeto Arduino de todo mundo é o sketch do blink. É o “Hello, World!” dos microcontroladores, e há um motivo para ter sobrevivido décadas: ele prova que sua placa funciona, que seu código roda e que sua fiação faz o que você acha que faz — tudo com um LEDzinho.
E aqui está a parte que a maioria dos tutoriais não conta logo de cara: você não precisa comprar nada para aprender. Dá para montar e rodar tudo num simulador no navegador, ver o LED piscando e só pedir uma placa quando você de fato entender o que está acontecendo. É isso que vamos fazer aqui. Também vou contar onde a simulação deixa de ser igual à realidade, porque ela deixa.
O circuito é a placa
A maioria dos tutoriais de “monte um circuito” começa com uma lista de peças. Este não começa, porque o Arduino Uno já carrega o circuito inteiro na própria PCB: um LED pequeno (marcado com L) é ligado direto ao pino digital 13, com um resistor limitador de corrente em série já na placa. Nada para conectar, nada para soldar, nada para queimar.
Se depois você for para uma placa real e quiser um LED externo em vez do que vem na placa, a receita é: ânodo (a perna longa) → pino 13 passando por um resistor de 220Ω, cátodo (perna curta) → GND. Qualquer valor entre 220Ω e 1kΩ funciona; valores menores deixam ele mais brilhante e mais bravo. Mas, por enquanto, fique no simples.
Colocando a placa na tela
Abra o simulador e clique em Add (ou no botão de Componentes, dependendo da visualização). Abre um seletor de componentes com uma caixa de busca e uma grade de placas. Digite “Arduino Uno”, arraste para a tela e pronto.
A placa cai na tela com os rótulos dos pinos visíveis. Procure a marcação L ao lado do pino 13 — esse é o seu LED. Ele não vai parecer grande coisa até a simulação rodar.
As quatro linhas que importam
Clique no editor de código. Este é o sketch inteiro:
// Blink: toggle the onboard LED once a second
void setup() {
pinMode(13, OUTPUT);
}
void loop() {
digitalWrite(13, HIGH);
delay(1000);
digitalWrite(13, LOW);
delay(1000);
}
Sketches Arduino sempre têm duas funções. O setup() roda uma vez ao ligar; o loop() então roda para sempre, de cima a baixo, sem parar. Dentro delas, quatro linhas fazem todo o trabalho:
pinMode(13, OUTPUT)— diz ao chip que o pino 13 é para mandar tensão para fora, não para ler sinais. Pule isso e o pino continua como entrada; o LED pode brilhar fraquinho ou nem acender, o que confunde todo mundo da primeira vez.digitalWrite(13, HIGH)— leva o pino a 5V. LED aceso.delay(1000)— fica parado não fazendo nada por 1000 milissegundos. Sem ele, o LED piscaria milhões de vezes por segundo e pareceria aceso fixo para os seus olhos.digitalWrite(13, LOW)— leva o pino a 0V. LED apagado, e o segundodelay(1000)segura ele assim antes do loop repetir.
Esse é genuinamente o programa inteiro. Se isso pareceu anticlimático, ótimo — essa é a graça do blink.
Aperte Run
Aperte o botão Run na barra do editor. O simulador compila seu sketch e começa a executá-lo num chip AVR virtual — a mesma família que está num Uno real.
Fique de olho no LED L na tela: um segundo aceso, um segundo apagado. A barra da tela também dá pause, stop e reset, além de um serial monitor e um osciloscópio que você não vai precisar ainda, mas vai precisar em breve.
O que o simulador não vai te contar
Uma simulação é uma professora gentil, mas ela pula algumas lições que o hardware real ensina na hora:
- LEDs não morrem em simuladores. Ligue um LED real direto num pino sem resistor e ele vai funcionar — por pouco tempo. Depois queima, ou danifica o GPIO aos poucos. O simulador roda esse circuito feliz para sempre, então crie o hábito do resistor agora.
- Unos reais piscam ao ligar. O bootloader pisca o LED L algumas vezes quando a placa é energizada. Iniciantes vivem confundindo isso com código com defeito. É normal.
- Placas clone variam. Em clones baratos de Uno, o LED L pode ser de outra cor, mais apagado ou num pad ligeiramente diferente. O sim mostra uma placa idealizada; a sua gaveta não vai mostrar.
delay()bloqueia tudo. Neste sketch, tudo bem. Num projeto real com botões ou sensores, esses 1000ms congelados viram bug. Lembre da sensação de “por que ele não responde enquanto está no delay” — ela vai voltar.
Erros que custam tempo às pessoas
Eu já vi muitos primeiros sketches falharem. Quase sempre é um destes:
- Sem
pinMode()nosetup(). O clássico. Compila tudo, não acende nada. - LED externo ligado ao contrário. Perna longa no pino, perna curta no terra. Invertido, ele só fica apagado — sem dano, sem luz, sem graça.
- Editar o código e nunca apertar Run de novo. A simulação não reinicia sozinha.
- Digitar o pino como letra ou pegar o pino 12 por hábito. O LED da placa só escuta o pino 13.
Para onde ir daqui
Assim que o blink de 1 segundo ficar chato — o que leva uns dois minutos — comece a mudar as coisas. Reduza os delays para 250ms e veja ele estroboscopar. Mova um LED externo para o pino 12 com o próprio resistor e reescreva o sketch para acompanhar. Tente analogWrite() num pino marcado com ~ (esses são os que suportam PWM) e faça fade no LED em vez de alternar. Ou adicione um botão e faça o LED obedecer seu dedo.
Abra o simulador gratuito e carregue o exemplo Blink — o circuito e o código deste artigo já estão montados. Sem conta, sem instalação. Quando o LED piscar de volta para você, oficialmente você virou programador embarcado. Mais ou menos.