Código Arduino com inteligência artificial: prompts melhores, testes e correções

Escrever código Arduino com IA é descrever seu projeto para um assistente de chat como ChatGPT, Gemini, Claude ou Copilot e pedir um código que funcione em um Arduino, ESP32 ou Raspberry Pi Pico. Bem usado, ele transforma horas de trabalho em minutos: em vez de uma página em branco, você recebe um rascunho pronto para compilar. Mas a IA não vê seu circuito, não sabe qual placa está na sua bancada e pode afirmar algo errado com total confiança. Ela pode inventar uma função de biblioteca que não existe, escolher o pino errado ou escrever laços com delay() que travam tudo. Por isso a verdadeira habilidade não é pedir código, e sim pedir bem e verificar o que volta.

Neste guia você vai ver como um assistente de IA produz código Arduino e por que ele erra, como escrever um bom prompt que inclua a placa, os pinos, as bibliotecas e o comportamento esperado, e quais passos seguir para verificar o código antes de carregá-lo. Vamos passar pelos três erros mais comuns com mensagens reais do compilador e o código corrigido. Depois veremos o jeito certo de colar um erro de compilação e conseguir a correção, por que você não deve confiar na IA quando trabalha com a tensão da rede elétrica e como usar essas ferramentas sem deixar de aprender.

Como a IA escreve código Arduino e por que ela erra?

Grandes modelos de linguagem (LLMs) como o ChatGPT não escrevem código executando-o como um compilador; eles escrevem prevendo a continuação mais provável com base nos milhões de exemplos que viram durante o treinamento. Para temas com muitos exemplos na internet (piscar um LED, ler um DHT11, girar um servo), isso funciona muito bem. Mas o conhecimento do modelo fica congelado em uma certa data, então ele pode não conhecer funções que mudaram nas versões mais novas das bibliotecas. Ele pode misturar as funções de duas bibliotecas diferentes que têm o mesmo nome. E, o mais importante, em vez de dizer “não sei”, pode inventar uma resposta que parece plausível; isso se chama alucinação. Como o modelo não vê seu circuito, ele deduz números de pinos, níveis de tensão e versões de módulos a partir do que você escreveu ou dos próprios palpites.

Como escrever um bom prompt?

O código que a IA entrega não pode ser melhor do que as informações que você dá a ela. Com um pedido de uma linha como “escreva um código Arduino para medir temperatura”, o modelo escolhe sozinho a placa, o sensor, o pino e a biblioteca. Se as escolhas não baterem com o que você tem, o código ou não compila, ou compila e não funciona. Escreva um bom prompt como se estivesse explicando o projeto por telefone para um amigo que está ouvindo falar dele pela primeira vez: diga a placa, os componentes, as ligações, as bibliotecas, o comportamento esperado e as restrições, um por um. A tabela abaixo resume o que um prompt para Arduino deve conter:

Por exemplo, este prompt dá resultados muito melhores do que um pedido de uma linha: “Estou usando um Arduino Uno R3 e a Arduino IDE 2.3. O pino DATA do DHT22 está no D2, um buzzer ativo está no D8 e um LCD 16x2 com I2C (PCF8574, endereço 0x27) tem SDA no A4 e SCL no A5. A Adafruit DHT sensor library e a biblioteca LiquidCrystal I2C de Frank de Brabander estão instaladas. A cada 2 segundos, mostre a temperatura e a umidade no LCD e, se a temperatura passar de 30 °C, faça o buzzer apitar em toques curtos. Use millis() em vez de delay() e comente as linhas. No começo, liste as bibliotecas que preciso instalar e, no final, liste as suposições que você fez.” Com esse prompt, quase não sobra nada para o modelo adivinhar.

Passos para verificar o código gerado pela IA

Por mais arrumado que o código pareça, passe-o por uma lista de verificação antes de carregá-lo na placa. A maioria destes passos leva poucos minutos e sai muito mais barata do que um módulo queimado por um pino ligado errado:

1. Compile primeiro: Clique em Verificar (o botão de visto) sem a placa conectada. Se aparecer um erro, peça a correção com o método mais abaixo; para entender as mensagens, veja Erros de compilação do Arduino.
2. Confira as bibliotecas uma a uma: Procure cada linha #include no Gerenciador de Bibliotecas e instale a biblioteca cujo nome, autor e exemplos combinam com o código. Se não souber como, o guia como instalar biblioteca no Arduino mostra passo a passo.
3. Compare os pinos: Compare cada número de pino do código com a sua fiação e com o mapa de pinos da placa. Use a ferramenta Pinagem para ver os pinos PWM e os pinos que você deve evitar.
4. Calcule os valores elétricos: Confira o valor de resistor sugerido com a calculadora Resistor para LED. Se um sensor com saída de 5 V for ligado a um ESP32 ou Pico de 3,3 V, coloque um divisor de tensão no meio.
5. Teste em um simulador: Rode o código no Wokwi ou no Tinkercad antes de ligar o hardware real; você pega erros de lógica sem arriscar nenhuma peça.
6. Teste por partes: Não carregue o projeto inteiro de uma vez. Primeiro teste um sketch pequeno que só lê o sensor e imprime no Monitor Serial, depois acrescente o display e, por último, o buzzer ou o relé.
7. Acompanhe pelo Monitor Serial: Coloque Serial.println() em pontos importantes para ver se as variáveis recebem os valores esperados e confirme que o baud rate é igual ao do Serial.begin() no código. Mais detalhes em Monitor Serial do Arduino.
8. Peça para explicar o código: Para cada linha que você não entender, pergunte “o que esta linha faz e o que acontece se eu apagá-la?”. Nunca carregue um código que você não consegue explicar.

Erro comum 1: funções de biblioteca que não existem

O erro mais traiçoeiro da IA é escrever funções que na verdade não existem, mas têm nomes muito plausíveis. Por exemplo, a biblioteca Servo padrão tem attach(), write(), writeMicroseconds(), read() e detach(), mas não tem uma função setSpeed(); o modelo pode inventá-la quando você pede um servo que se mova devagar. Às vezes a função existe mesmo, mas em outra placa: Serial.printf() funciona no ESP32, mas não compila em um Arduino Uno. E às vezes a função pertence a uma versão antiga: ledcSetup() e ledcAttachPin() foram removidas na versão 3.x do core Arduino para ESP32, lançada em 2024, e mesmo assim a maioria dos modelos ainda escreve código com elas. Há também bibliotecas diferentes que usam o mesmo arquivo de cabeçalho: em uma biblioteca chamada LiquidCrystal_I2C.h o display é iniciado com lcd.init(), em outra com o mesmo nome é com lcd.begin(). Se aparecer o aviso “Multiple libraries were found” na saída do compilador, desconfie dessa confusão.

A armadilha da função antiga no ESP32: ledcAttach em vez de ledcSetup

Quando você pede um código para ESP32 que ajuste o brilho de um LED ou a velocidade de um motor, a IA provavelmente vai escrever o trio ledcSetup(canal, frequência, resolução), ledcAttachPin(pino, canal) e ledcWrite(canal, valor). Esse código funciona na versão 2.x do core. Na versão 3.x, porém, os canais são atribuídos automaticamente: ledcAttach(pino, frequência, resolução) prepara o pino de uma vez só, e ledcWrite(pino, valor) agora recebe o número do pino em vez do canal. Você vê qual versão está instalada ao lado do pacote esp32 no Gerenciador de Placas. O código abaixo verifica a versão na hora da compilação e por isso funciona nos dois cores:

1// ESP32 PWM: çekirdek 2.x ve 3.x ile uyumlu LED soldurma / LED fade for both core 2.x and 3.x
2#include <esp_arduino_version.h>   // ESP_ARDUINO_VERSION_MAJOR için / for ESP_ARDUINO_VERSION_MAJOR
3
4const int LED_PIN = 2;             // çoğu DevKit'te dahili LED / onboard LED on most DevKits
5const uint32_t FREKANS = 5000;     // PWM frekansı, Hz / PWM frequency, Hz
6const uint8_t COZUNURLUK = 8;      // 8 bit: 0-255 / 8-bit: 0-255
7
8#if ESP_ARDUINO_VERSION_MAJOR >= 3
9// Çekirdek 3.x: kanal otomatik seçilir, fonksiyonlar pin alır / Core 3.x: channel is automatic, functions take the pin
10void pwmBaslat() { ledcAttach(LED_PIN, FREKANS, COZUNURLUK); }
11void pwmYaz(uint32_t deger) { ledcWrite(LED_PIN, deger); }
12#else
13// Çekirdek 2.x: önce kanal kurulur, sonra pine bağlanır / Core 2.x: set up a channel, then attach the pin
14const uint8_t KANAL = 0;
15void pwmBaslat() { ledcSetup(KANAL, FREKANS, COZUNURLUK); ledcAttachPin(LED_PIN, KANAL); }
16void pwmYaz(uint32_t deger) { ledcWrite(KANAL, deger); }
17#endif
18
19void setup() {
20  Serial.begin(115200);
21  Serial.print("ESP32 Arduino cekirdegi / core: ");
22  Serial.println(ESP_ARDUINO_VERSION_MAJOR);
23  pwmBaslat();
24}
25
26void loop() {
27  // Tek iş yaptığı için burada delay() sorun değil / delay() is fine here: only one task
28  for (int d = 0; d <= 255; d++) { pwmYaz(d); delay(4); }   // yavaşça yan / fade in
29  for (int d = 255; d >= 0; d--) { pwmYaz(d); delay(4); }   // yavaşça sön / fade out
30}

A lição aqui não vale só para o ESP32: se você incluir as versões do core e das bibliotecas no prompt, o modelo tem chance de escolher as funções certas. Se mesmo informando a versão ele continuar usando funções antigas, abra um dos exemplos oficiais da biblioteca pelo menu Arquivo > Exemplos e cole no prompt com “reescreva usando as funções deste exemplo”. Os exemplos oficiais sempre combinam com a versão instalada. Se tiver curiosidade sobre como o PWM funciona, dê uma olhada em O que é PWM?

Erro comum 2: escolher o pino errado

Mesmo que o código compile e seja carregado, um pino errado significa um circuito que simplesmente não faz nada ou um módulo que queima. O compilador não consegue detectar isso, porque para ele o número do pino é só um número. Estes são os erros de pino que a IA mais comete, placa por placa:

Erro comum 3: travamentos com delay()

Como a maioria dos exemplos de Arduino na internet é escrita com delay(), a IA também usa delay() por padrão. Enquanto delay(1000) está rodando, o processador não faz mais nada por um segundo inteiro: não lê botões, não verifica sensores, não atualiza o display. Em um código que faz uma coisa só, tudo bem. Mas peça duas coisas ao mesmo tempo, como “piscar um LED e apitar o buzzer quando o botão for pressionado”, e muitas vezes você recebe um código assim:

1// Yapay zekanın sık ürettiği, kilitlenen kod / Blocking code that AI often produces
2const int BUTON_PIN = 2;    // buton: D2 ile GND arası / button between D2 and GND
3const int LED_PIN = 13;     // dahili LED / onboard LED
4const int BUZZER_PIN = 8;   // aktif buzzer / active buzzer
5
6void setup() {
7  pinMode(BUTON_PIN, INPUT_PULLUP);
8  pinMode(LED_PIN, OUTPUT);
9  pinMode(BUZZER_PIN, OUTPUT);
10}
11
12void loop() {
13  digitalWrite(LED_PIN, HIGH);
14  delay(1000);                          // 1 sn boyunca buton okunmaz / button is not read for 1 s
15  digitalWrite(LED_PIN, LOW);
16  delay(1000);                          // 1 sn daha kör bekleme / another blind second
17
18  if (digitalRead(BUTON_PIN) == LOW) {  // yalnızca tam bu anda basılıysa / only if pressed right now
19    digitalWrite(BUZZER_PIN, HIGH);
20    delay(200);
21    digitalWrite(BUZZER_PIN, LOW);
22  }
23}

Esse código compila sem erros, mas na maioria das vezes nada acontece quando você aperta o botão. Cerca de 2 segundos de cada ciclo do loop() são gastos dentro das duas chamadas de delay(), e o botão só é lido durante alguns microssegundos entre elas. Um toque curto quase sempre perde esse momento; para ter certeza de que o buzzer vai tocar, você precisa segurar o botão por mais de 2 segundos. A solução não é esperar, é olhar o relógio: millis() retorna os milissegundos desde que a placa ligou, cada tarefa verifica se chegou a sua hora e o loop() roda milhares de vezes por segundo:

1// millis() ile kilitlenmeyen sürüm / Non-blocking version with millis()
2const int BUTON_PIN = 2;    // buton: D2 ile GND arası / button between D2 and GND
3const int LED_PIN = 13;     // dahili LED / onboard LED
4const int BUZZER_PIN = 8;   // aktif buzzer / active buzzer
5
6const unsigned long LED_ARALIK = 1000;  // LED değişim aralığı, ms / LED toggle interval, ms
7const unsigned long BIP_SURE = 200;     // bip süresi, ms / beep length, ms
8const unsigned long SICRAMA = 30;       // debounce süresi, ms / debounce time, ms
9
10unsigned long ledZaman = 0;     // LED'in son değiştiği an / last LED toggle
11unsigned long bipZaman = 0;     // bipin başladığı an / beep start
12unsigned long butonZaman = 0;   // butonun son değiştiği an / last button change
13bool ledDurum = false;
14bool bipCaliyor = false;
15int oncekiButon = HIGH;         // önceki buton seviyesi / previous button level
16
17void setup() {
18  pinMode(BUTON_PIN, INPUT_PULLUP);
19  pinMode(LED_PIN, OUTPUT);
20  pinMode(BUZZER_PIN, OUTPUT);
21}
22
23void loop() {
24  unsigned long simdi = millis();
25
26  // 1) LED: zamanı geldiyse durum değiştir / toggle the LED when its time has come
27  if (simdi - ledZaman >= LED_ARALIK) {
28    ledZaman = simdi;
29    ledDurum = !ledDurum;
30    digitalWrite(LED_PIN, ledDurum ? HIGH : LOW);
31  }
32
33  // 2) Buton: yalnızca basıldığı anı yakala / catch only the moment of the press
34  int buton = digitalRead(BUTON_PIN);
35  if (buton != oncekiButon && simdi - butonZaman >= SICRAMA) {
36    butonZaman = simdi;
37    oncekiButon = buton;
38    if (buton == LOW && !bipCaliyor) {  // HIGH -> LOW: yeni basış / new press
39      bipCaliyor = true;
40      bipZaman = simdi;
41      digitalWrite(BUZZER_PIN, HIGH);
42    }
43  }
44
45  // 3) Buzzer: süre dolunca sustur / silence it when the time is up
46  if (bipCaliyor && simdi - bipZaman >= BIP_SURE) {
47    bipCaliyor = false;
48    digitalWrite(BUZZER_PIN, LOW);
49  }
50}

Nesta versão, o LED, o botão e o buzzer funcionam sem esperar um pelo outro. Uma subtração na forma simdi - ledZaman >= LED_ARALIK dá o resultado certo mesmo quando millis() volta a zero, mais ou menos a cada 49,7 dias, enquanto a comparação millis() > targetTime que a IA às vezes escreve quebra nesse estouro. Detectar o momento em que o botão passa de HIGH para LOW evita que o buzzer apite de novo e de novo enquanto o botão é mantido pressionado, e a espera de 30 ms filtra o repique dos contatos (debounce). Para o tema completo, veja o guia millis() em vez de delay() no Arduino e, para ligar o botão, veja como ligar um botão no Arduino.

Colar um erro de compilação e conseguir a correção

A IA é realmente boa em explicar erros de compilação, desde que você entregue o erro completo e o contexto. Escrever só “o código não funciona” obriga o modelo a adivinhar. Siga esta ordem:

1. Quando aparecer um erro de compilação na Arduino IDE 2, clique em Copiar mensagens de erro na notificação no canto inferior direito, ou selecione e copie todo o texto do painel Saída. O exit status 1 da última linha não serve para nada sozinho; a causa real está na linha error: mais acima.
2. Seu prompt deve ter, nesta ordem: a placa e a versão do core, o código completo, a mensagem de erro completa e os nomes e versões das bibliotecas instaladas.
3. Antes de pedir a correção, escreva “Primeiro explique a causa do erro, depois mostre só as linhas que precisam mudar”. Assim o modelo não reescreve o sketch inteiro acrescentando erros novos, e você aprende o que mudou e por quê.
4. Aplique a mudança sugerida e compile de novo. Se surgir um erro novo, cole novamente a linha error: que estiver mais acima; corrija um erro de cada vez.
5. Se o mesmo erro continuar depois de duas ou três rodadas, saia do ciclo e compile o exemplo oficial da biblioteca. Se o exemplo também não compilar, o problema não está no seu código, mas na instalação: placa errada selecionada, biblioteca faltando ou duas bibliotecas com o mesmo nome em conflito.

Se o erro acontece no carregamento e não na compilação (como “avrdude: stk500_recv(): programmer is not responding” ou, no ESP32, “Failed to connect to ESP32”), mudar o código não adianta; é preciso verificar a porta, o cabo, o driver e a placa selecionada. O guia Erro ao carregar código no Arduino mostra como resolver esses casos. Quando perguntar à IA sobre um erro de carregamento, inclua a mensagem completa e o sistema operacional que você usa.

Pedindo à IA código para Raspberry Pi Pico e MicroPython

As mesmas regras valem quando você pede código MicroPython, mas aqui a IA também pode confundir plataformas. Código escrito para os computadores Raspberry Pi com RPi.GPIO ou gpiozero não roda no Pico; no Pico se usa o módulo machine do MicroPython. Os módulos board e digitalio do CircuitPython também não existem no MicroPython. Por isso, coloque no prompt uma informação clara como “Raspberry Pi Pico W, MicroPython, Thonny”. O código abaixo roda tanto no Pico quanto no Pico W e usa ticks_ms() para temporizar em vez de esperar:

1# Pico ve Pico W: bekletmeden LED + buton / Pico and Pico W: LED + button without blocking
2from machine import Pin
3import time
4
5led = Pin("LED", Pin.OUT)             # Pico W'da Pin(25) çalışmaz / Pin(25) does not work on Pico W
6buton = Pin(14, Pin.IN, Pin.PULL_UP)  # buton: GP14 ile GND arası / button between GP14 and GND
7
8ARALIK = 500                          # LED değişim aralığı, ms / LED toggle interval, ms
9SICRAMA = 30                          # debounce süresi, ms / debounce time, ms
10son = time.ticks_ms()                 # LED'in son değiştiği an / last LED toggle
11degisim = time.ticks_ms()             # butonun son değiştiği an / last button change
12onceki = 1                            # önceki buton seviyesi / previous button level
13sayac = 0
14
15while True:
16    simdi = time.ticks_ms()
17    if time.ticks_diff(simdi, son) >= ARALIK:      # taşmada da doğru / correct even on overflow
18        son = simdi
19        led.toggle()
20    deger = buton.value()
21    if deger != onceki and time.ticks_diff(simdi, degisim) >= SICRAMA:
22        degisim = simdi
23        onceki = deger
24        if deger == 0:                # basıldığı an / moment of the press
25            sayac += 1
26            print("Basma / press:", sayac)

Quando você executa o código no Thonny, o LED integrado pisca a cada meio segundo e cada toque no botão imprime um número crescente na janela Shell. time.ticks_diff() dá a diferença correta mesmo quando o contador de ticks volta ao início, enquanto a subtração simples time.ticks_ms() - son que a IA costuma escrever pode dar um resultado errado em um código que roda por muito tempo. Se você está começando com o Pico, comece por O que é o Raspberry Pi Pico?

Rede elétrica: não confie na IA

Se o seu projeto vai funcionar na rede elétrica, teste primeiro em baixa tensão: use um LED no lugar da lâmpada e uma fita de LED de 12 V no lugar da tomada. Se o sistema realmente precisar chavear a rede, algumas regras não se negociam. Tire o circuito da tomada antes de mexer nele. O relé deve interromper a fase (L), não o neutro. Não ultrapasse a corrente e a tensão nominais impressas no módulo relé (10 A 250 VAC na maioria dos módulos) e coloque o lado de alta tensão em uma caixa fechada e isolada. Módulos relé baratos muitas vezes não deixam distância suficiente entre o lado de baixa e o de alta tensão; sempre que possível, prefira uma tomada inteligente ou caixa de relé pronta e certificada. A ligação do módulo relé está explicada em detalhes em O que é módulo relé?

Usar a IA sem deixar de aprender

Se a IA escrever todos os sketches por você, no primeiro dia em que o código não funcionar você não vai saber o que fazer. Se o seu objetivo é aprender eletrônica e programação, use-a não como uma máquina de código, mas como um professor paciente:

• Escreva você primeiro: Tente fazer o código sozinho e depois peça à IA para revisá-lo com “mostre os erros, mas não me dê o código corrigido”.
• Peça dicas, não respostas: Quando travar, diga “me dê só uma dica para o próximo passo”.
• Peça explicação linha por linha: Depois que o código for explicado, tente explicar a mesma lógica com suas palavras; o que você não consegue explicar é o que ainda não aprendeu.
• Digite em vez de copiar: Digitar o código à mão em vez de colar ensina a sintaxe e os nomes das funções muito mais rápido.
• Preveja e depois teste: Antes de mudar um valor, preveja o que vai acontecer (ex.: se LED_ARALIK virar 200), depois carregue e confira.
• Teste a si mesmo: Peça à IA cinco perguntas sobre o tema que você acabou de aprender; para revisar o básico, use Programação Arduino do zero.
• Siga as regras: Em trabalhos escolares e feiras de ciências, siga as regras sobre o uso de IA e diga claramente se você a usou.

Primeiros projetos para testar com IA

• Indicador de temperatura: Mostre os valores medidos por um DHT11 em um LCD I2C; informe no prompt o endereço do LCD e o autor da biblioteca.
• Sensor de estacionamento: Meça a distância com um HC-SR04 e faça o buzzer apitar mais rápido conforme o obstáculo se aproxima; peça temporização baseada em millis().
• Luz noturna: Acenda um LED quando escurecer usando um LDR; leia primeiro o limite no Monitor Serial e passe-o como número no prompt.
• Controle de LED por Wi-Fi: Ligue e desligue um LED por uma página aberta no celular com um ESP32; informe a versão do core no prompt.
• Sua própria ideia: Escolha um projeto da lista de ideias de projetos Arduino e descreva-o para a IA com o modelo de prompt deste guia.

A IA pode ser a ajudante mais rápida ao seu alcance enquanto você aprende Arduino, desde que você dê a ela as informações certas, compile o que vier, confira os pinos, teste por partes e nunca carregue uma linha que não entende. Se você procura exemplos confiáveis para comparar com o código escrito pela IA, o app BlueGrays tem projetos com LED, botão, DHT11, PWM no ESP32 e Pico, com esquemas do circuito passo a passo e código testado.