Monitor Serial do Arduino: baud rate, envio de dados e Plotter Serial

O Monitor Serial do Arduino é a janela da Arduino IDE que permite que a sua placa e o seu computador troquem texto pelo cabo USB. É ali que você lê a saída de cada linha Serial.println() do seu sketch e onde digita comandos para enviar de volta à placa. É o jeito mais rápido de ver o que um sensor está medindo agora, até onde o seu programa chegou ou se um botão está mesmo sendo pressionado, e por isso ele é a ferramenta de depuração número um no mundo Arduino. Para usá-lo, basta ter Serial.begin(9600) no código, a porta certa selecionada no seletor de placa e a mesma velocidade no monitor e no código.

Neste guia você começa abrindo o Monitor Serial e depois vê o que o baud rate significa de verdade, como mostrar números em decimal, hexadecimal e binário com print e println, como controlar o número de casas decimais e como montar linhas organizadas com snprintf. Com sketches de exemplo que compilam de fato, explicamos todas as causas de caracteres estranhos, como a configuração de final de linha afeta o seu código, como enviar números e comandos de texto do computador para a placa (Serial.read, parseInt, readStringUntil), como desenhar gráficos ao vivo com o Plotter Serial e técnicas de depuração que vão facilitar a sua vida. As últimas seções mostram como a saída serial muda no ESP32 e no Raspberry Pi Pico (com Arduino e com MicroPython) e como resolver problemas comuns, como um monitor vazio.

O que é o Monitor Serial do Arduino e como ele funciona?

O ATmega328P, o cérebro do Arduino Uno, conversa com o mundo exterior por meio de uma unidade de comunicação serial chamada UART: ele envia dados bit a bit por uma linha (TX) e recebe por outra (RX). Os computadores modernos não têm mais esse tipo de porta serial, então um segundo chip na placa (um ATmega16U2 no Uno original, normalmente um CH340 nos clones) converte o sinal para USB. O computador enxerga a placa como uma porta serial virtual: algo como COM3 no Windows, /dev/ttyACM0 ou /dev/ttyUSB0 no Linux e um nome que começa com /dev/cu.usbmodem ou /dev/cu.usbserial no macOS. O Monitor Serial abre essa porta, mostra os bytes que chegam como texto e envia de volta à placa, pelo mesmo caminho, o que você digita. Por padrão, o Arduino usa o formato 8N1: um bit de início, 8 bits de dados, nenhum bit de paridade e um bit de parada por byte. Ou seja, um único caractere ocupa 10 bits na linha; vamos usar esse número nos cálculos de velocidade.

Como abrir e usar o Monitor Serial

1. Acrescente a linha Serial.begin(9600); à seção setup() do seu sketch e carregue-o. Sem essa linha, a placa não escreve nada na porta serial.
2. Selecione a porta em que a sua placa está conectada no seletor de placa da barra superior ou no menu Ferramentas > Porta. Se nenhuma porta estiver selecionada, o Monitor Serial mostra o aviso Não conectado. Selecione uma placa e uma porta para conectar automaticamente. (na interface em inglês: Not connected. Select a board and a port to connect automatically.)
3. Clique no ícone de lupa no canto superior direito, use o menu Ferramentas > Monitor Serial ou pressione Ctrl+Shift+M (Cmd+Shift+M no macOS). Na IDE 2, o monitor abre no painel inferior, ao lado da seção Saída.
4. No menu de velocidade à direita do painel, escolha o mesmo baud rate do seu código; neste exemplo, 9600. Se a velocidade for diferente, caracteres estranhos invadem a tela.
5. Para enviar dados à placa, digite na caixa de mensagem no topo do painel e pressione Enter. Escolha o final de linha no menu logo ao lado; explicamos mais abaixo por que essa configuração importa.
6. Com os botões do canto superior direito, você pode pausar a rolagem automática (útil para ler linhas antigas), ativar a marcação de data e hora, que acrescenta a hora do seu computador ao início de cada linha, e limpar a saída.

Na antiga Arduino IDE 1.8, o Monitor Serial abre em uma janela separada; os controles fazem o mesmo trabalho, só ficam em lugares diferentes: as caixas de rolagem automática e de data e hora ficam no canto inferior esquerdo, e os menus de final de linha e de velocidade no canto inferior direito. Você também pode acompanhar a porta serial sem a IDE: o PuTTY ou o CoolTerm no Windows, o comando screen /dev/ttyUSB0 115200 no Linux e no macOS e arduino-cli monitor -p COM3 -c baudrate=115200 em qualquer sistema fazem o mesmo trabalho. Lembre-se de uma coisa: uma porta serial só pode ser aberta por um programa de cada vez. Enquanto um script Python ou o PuTTY estiver segurando a porta, você não consegue carregar código pela IDE; explicamos a instalação da IDE e o resto da interface no guia Como instalar a Arduino IDE.

Serial.begin() e baud rate: 9600 ou 115200?

Serial.begin(velocidade) inicia a porta serial na velocidade indicada e quase sempre é chamada uma única vez dentro de setup(). A velocidade é dada em baud, o número de bits transmitidos na linha por segundo. Como cada caractere ocupa 10 bits, 9600 baud significam no máximo 960 caracteres por segundo; enviar um único caractere leva cerca de 1,04 milissegundo. Uma linha de 30 caracteres leva 31 ms nessa velocidade, então, assim que você quiser mostrar centenas de leituras por segundo, esbarra nesse limite. A 115200 baud, a mesma linha leva só 2,6 ms. O valor do sketch e o do Monitor Serial precisam ser iguais, porque não existe um sinal de clock compartilhado e o receptor lê os bits apenas pela temporização.

O clock de 16 MHz do Uno não consegue gerar todas as velocidades com exatidão: 115200 baud na verdade funciona com um desvio de cerca de 2%, a 117647 baud. Esse erro não causa problema no Monitor Serial, mas pode provocar falhas na conversa com outro microcontrolador por um cabo longo; nesses casos, 57600 ou 250000 baud, que é gerado sem erro, são mais seguros. Se você está começando, use 9600 no Uno e no Nano e 115200 no ESP32 e no Pico. Se for ligar duas placas com fios TX-RX, a velocidade precisa ser a mesma dos dois lados, os GNDs precisam ser comuns e uma linha TX de 5 V precisa ser reduzida com um divisor de tensão antes de chegar a uma entrada RX de 3,3 V (ESP32, Pico). Você encontra os detalhes no artigo comunicação serial UART.

Serial.print() e Serial.println(): mostrar e formatar valores

Serial.print() escreve o valor que você passa e deixa o cursor na mesma linha; Serial.println() também acrescenta depois os caracteres de final de linha (\r\n), então a próxima saída começa em uma linha nova. Para mostrar vários valores em uma linha, escreva as primeiras partes com print e a última com println. Essas funções aceitam quase qualquer tipo, como int, long, float, char, texto e String, e o segundo parâmetro opcional define o formato. Para inteiros, você pode escolher DEC, HEX, BIN e OCT; para números de ponto flutuante, o segundo parâmetro é o número de casas decimais. Por padrão, os floats são mostrados com 2 casas decimais, arredondados. No código abaixo, escrevemos a saída de cada linha como comentário:

1// Biçimlendirme örnekleri: çıktılar yorumlarda / Formatting examples: output in the comments
2void setup() {
3  Serial.begin(9600);
4  int sayi = 78;
5  float pi = 3.14159;
6
7  Serial.println(sayi);           // 78
8  Serial.println(sayi, HEX);      // 4E
9  Serial.println(sayi, BIN);      // 1001110
10  Serial.println(sayi, OCT);      // 116
11  Serial.println(pi);             // 3.14 (varsayılan 2 basamak / 2 decimals by default)
12  Serial.println(pi, 4);          // 3.1416
13  Serial.write(65);               // A (ham bayt / raw byte)
14  Serial.println();               // yalnız satır sonu / line break only
15
16  Serial.print("Sicaklik:\t");    // \t = sekme / \t = tab
17  Serial.print(23.46, 1);         // 23.5
18  Serial.println(" C");           // Sicaklik:  23.5 C
19
20  char satir[32];
21  int saat = 9, dakika = 5;
22  snprintf(satir, sizeof(satir), "Saat %02d:%02d", saat, dakika);
23  Serial.println(satir);          // Saat 09:05
24
25  char metin[10];
26  dtostrf(pi, 6, 2, metin);       // Uno'da %f yerine / instead of %f on the Uno
27  Serial.println(metin);          // "  3.14"
28}
29
30void loop() {
31}

Em vez de mostrar linhas longas pedaço por pedaço, você pode montar uma única string com snprintf(): %d é um inteiro, %02d um inteiro de dois dígitos com zero à esquerda, %s texto e %lu um unsigned long, como millis(). Para economizar memória, a biblioteca C do Uno não suporta %f; se você tentar mostrar um float, verá um ? no lugar dele. Por isso, converta os floats em texto antes com dtostrf(numero, largura, casas, buffer). No ESP32 e no Pico, você pode usar Serial.printf() diretamente. O Uno tem só 2 KB de RAM; escrever textos fixos com a macro F(), como em Serial.println(F("Olá")), guarda esses textos na flash em vez da RAM e evita problemas de memória insuficiente em projetos grandes.

Caracteres estranhos no Monitor Serial e como resolver

Se você vê ⸮⸮⸮, � ou montes de letras e símbolos aleatórios, os dados estão chegando ao computador, mas estão sendo decodificados errado. Como a comunicação serial não tem um sinal de clock compartilhado, o receptor calcula o meio de cada bit a partir da própria velocidade, contando desde o momento em que vê o bit de início. Se a velocidade estiver errada, ou se o clock da placa não for o que deveria ser, os bits são lidos nos momentos errados e cada byte vira outro caractere. Normalmente a causa é uma única configuração; a tabela abaixo lista os casos mais comuns pelo sintoma. Para placas com opções de clock diferentes, como a Pro Mini, dê uma olhada também no artigo Arduino Pro Mini.

Configuração de final de linha: Sem final de linha, Nova linha, Retorno de carro, Ambos, NL e CR

Quando você digita na caixa de mensagem e pressiona Enter, o Monitor Serial não envia só os caracteres digitados, mas também um ou dois caracteres invisíveis, conforme o final de linha escolhido. Se o seu código não espera por eles, por exemplo se trata cada byte que chega como um comando, então '\n' (valor 10) e '\r' (13) também são lidos como comandos. Por outro lado, se o seu código espera um final de linha e a configuração está em Sem final de linha, a linha nunca termina; readStringUntil() fica esperando até o tempo limite se esgotar. A tabela abaixo mostra os bytes enviados à placa quando você digita 42 e pressiona Enter:

Uma regra prática: para código que lê linha por linha, escolha Nova linha e aplique trim() ao texto lido; assim o seu código funciona qualquer que seja a configuração escolhida pelo usuário. Para comandos de um único caractere, como 1, 0 ou a, Sem final de linha é a opção mais limpa. A IDE lembra a sua escolha, então não se esqueça de conferi-la quando passar para outro projeto.

Enviar dados do computador para o Arduino: Serial.read(), parseInt(), readStringUntil()

Os bytes que você envia pelo Monitor Serial entram em fila no buffer de recepção da placa (64 bytes no Uno). Serial.available() informa quantos bytes estão esperando nele, Serial.read() pega o próximo byte e o retira do buffer, retornando -1 se não houver dados, e Serial.peek() olha o próximo byte sem retirá-lo. Lembre-se de que tudo o que vem do teclado chega como caracteres ASCII: quando você digita 7, a placa não recebe o número 7, mas 55, o código do caractere '7'. Você encontra um exemplo de comandos simples de uma tecla no artigo Comandos do Arduino; aqui tratamos de números com vários dígitos e de comandos formados por palavras. Se o buffer encher, os bytes que chegam depois se perdem; por isso, controlar o tempo com millis() em vez de esperar muito com delay() dentro de loop() também deixa a leitura serial mais segura.

Serial.parseInt() extrai o primeiro inteiro dos caracteres que chegam: ignora letras e espaços no início, junta os dígitos e para no primeiro caractere que não é dígito; ele também entende o sinal de menos. Assim, o texto “128” vira o número 128. Para floats, Serial.parseFloat() faz o mesmo trabalho. Essas funções têm um hábito que você precisa conhecer: se nenhum número chegar, elas esperam 1000 ms por padrão e então retornam 0. O bug clássico acontece assim: com a configuração em Nova linha, você envia 42, o parseInt lê 42, mas o '\n' fica no buffer. Na volta seguinte, loop() vê available() maior que 0 e chama parseInt de novo, que espera um segundo e retorna 0. O resultado é um 0 depois de cada número, e você não entende por que o LED apaga um segundo depois de cada número. O código abaixo resolve o problema na raiz descartando o próximo caractere quando ele não é dígito e encurta a espera com setTimeout().

1// Seri Port Ekranı'ndan sayı al: LED parlaklığı 0-255
2// Read a number from the Serial Monitor: LED brightness 0-255
3const int LED_PIN = 9;   // ~9 PWM pini + 220 ohm direnç / ~9 PWM pin + 220 ohm resistor
4
5void setup() {
6  pinMode(LED_PIN, OUTPUT);
7  Serial.begin(9600);
8  Serial.setTimeout(100);   // parseInt en fazla 100 ms bekler / parseInt waits at most 100 ms
9  Serial.println(F("0-255 arasi bir sayi yaz / Type a number from 0 to 255"));
10}
11
12void loop() {
13  if (Serial.available() > 0) {
14    char c = Serial.peek();               // sıradakine bak, silme / look at the next byte, keep it
15    if (isDigit(c) || c == '-') {
16      int deger = Serial.parseInt();      // "128" -> 128
17      deger = constrain(deger, 0, 255);   // aralığın dışına çıkma / stay within range
18      analogWrite(LED_PIN, deger);
19      Serial.print(F("Parlaklik / Brightness: "));
20      Serial.println(deger);
21    } else {
22      Serial.read();                      // '\r', '\n' ve harfleri at / drop '\r', '\n' and letters
23    }
24  }
25}

Para comandos formados por palavras, o jeito mais fácil é ler a linha inteira como String. Serial.readStringUntil('\n') lê até chegar um '\n', descarta o caractere de final de linha e retorna o resto. Se a configuração for Ambos, NL e CR, sobra um '\r' no fim do texto, o seu comando “on” vira “on\r” e a comparação falha. Por isso, aplique trim() à linha logo em seguida: ele remove os espaços do início e do fim, além dos caracteres '\r' e '\n'. toLowerCase() deixa ON, On e on iguais. O exemplo abaixo entende os comandos on, off, blink 250 e status; use o Monitor Serial a 115200 baud com Nova linha. Como ele pisca com millis() em vez de delay(), responde na hora a um comando novo a qualquer momento.

1// Metin komutları: on, off, blink 250, status
2// Text commands: on, off, blink 250, status
3const int LED_PIN = LED_BUILTIN;   // Uno'da pin 13 / pin 13 on the Uno
4bool ledAcik = false;              // LED'in şu anki durumu / current LED state
5bool yanipSon = false;             // yanıp sönme modu / blink mode
6unsigned long aralik = 500;        // yanıp sönme aralığı (ms) / blink interval (ms)
7unsigned long sonDegisim = 0;      // LED'in son değiştiği an / last time the LED changed
8
9void ledYaz(bool acik) {
10  ledAcik = acik;
11  digitalWrite(LED_PIN, acik ? HIGH : LOW);
12}
13
14void komutuIsle(String komut) {
15  if (komut == "on") {
16    yanipSon = false;
17    ledYaz(true);
18    Serial.println(F("LED: on"));
19  } else if (komut == "off") {
20    yanipSon = false;
21    ledYaz(false);
22    Serial.println(F("LED: off"));
23  } else if (komut.startsWith("blink")) {
24    long ms = komut.substring(5).toInt();       // "blink 250" -> 250
25    aralik = (ms >= 50) ? ms : 500;             // çok küçükse 500 ms / fall back to 500 ms
26    yanipSon = true;
27    Serial.print(F("Blink (ms): "));
28    Serial.println(aralik);
29  } else if (komut == "status") {
30    Serial.print(F("LED: "));
31    Serial.print(ledAcik ? F("on") : F("off"));
32    Serial.print(F(", blink: "));
33    Serial.println(yanipSon ? F("yes") : F("no"));
34  } else {
35    Serial.print(F("Bilinmeyen komut / Unknown command: "));
36    Serial.println(komut);
37  }
38}
39
40void setup() {
41  pinMode(LED_PIN, OUTPUT);
42  Serial.begin(115200);
43  Serial.setTimeout(100);   // satır sonu gelmezse 100 ms sonra bırak / give up after 100 ms without a line ending
44  Serial.println(F("Komutlar / Commands: on, off, blink 250, status"));
45}
46
47void loop() {
48  if (Serial.available() > 0) {
49    String komut = Serial.readStringUntil('\n');   // Enter'a kadar oku / read up to Enter
50    komut.trim();                                  // '\r' ve boşlukları sil / strip '\r' and spaces
51    komut.toLowerCase();                           // ON ile on aynı olsun / treat ON like on
52    if (komut.length() > 0) {
53      komutuIsle(komut);
54    }
55  }
56
57  if (yanipSon && millis() - sonDegisim >= aralik) {   // delay() olmadan yanıp sön / blink without delay()
58    sonDegisim = millis();
59    ledYaz(!ledAcik);
60  }
61}

Desenhar gráficos ao vivo com o Plotter Serial

O Plotter Serial transforma os números que chegam pela porta serial em um gráfico de linhas ao vivo; abra-o pelo ícone de forma de onda no canto superior direito da IDE ou pelo menu Ferramentas > Plotter Serial. O formato é bem simples: separe os valores de uma linha com vírgulas, espaços ou tabulações e termine a linha com println. Cada linha vira um passo de tempo no gráfico, e cada valor da linha vira uma curva de cor diferente. Se você colocar um nome antes dos valores no formato rótulo:valor, as curvas recebem esse nome e podem ser ocultadas ou exibidas uma a uma pelas caixas de seleção acima do gráfico; sem rótulos, as curvas recebem nomes como value 1 e value 2. Aqui também o menu de velocidade precisa bater com o seu código. O código abaixo desenha no mesmo gráfico a leitura bruta do A0 e a versão suavizada dela:

1// Seri Çizici: ham değer ve yumuşatılmış değer / Serial Plotter: raw and smoothed value
2const int SENSOR_PIN = A0;   // potansiyometre ya da LDR bölücü çıkışı / potentiometer or LDR divider output
3float yumusak = 0;           // üstel ortalama / exponential moving average
4
5void setup() {
6  Serial.begin(115200);
7}
8
9void loop() {
10  int ham = analogRead(SENSOR_PIN);           // 0-1023
11  yumusak = yumusak * 0.9 + ham * 0.1;        // yeni ölçümün payı %10 / the new reading weighs 10%
12
13  Serial.print("Min:0,Max:1023,");            // dikey ekseni sabitler / keeps the y-axis fixed
14  Serial.print("Ham:");
15  Serial.print(ham);
16  Serial.print(",Yumusak:");
17  Serial.println(yumusak);                    // satırı bitir: bir ölçüm / end the line: one sample
18  delay(20);                                  // saniyede yaklaşık 50 satır / about 50 lines per second
19}

• Fixe a escala: o Plotter Serial reajusta o eixo vertical o tempo todo para caber os valores que chegam, então pequenas oscilações parecem enormes. Acrescentar dois valores constantes, como Min:0,Max:1023,, a cada linha mantém o eixo fixo.
• Não use espaços nos rótulos: como espaços e vírgulas contam como separadores, “Temp Sala:24” é dividido em duas partes; use nomes com sublinhado, como Temp_Sala.
• Só rótulos e números na linha: unidades e descrições como “Temp 24 C” bagunçam o gráfico; mostre as descrições para o Monitor Serial em um trecho de código separado.
• Ajuste a taxa de envio: delay(20) significa cerca de 50 linhas por segundo. Envie rápido demais e o gráfico passa voando num instante; envie devagar demais e a linha parece uma escada.
• Veja o filtro com os próprios olhos: desenhar o valor bruto e a média no mesmo gráfico mostra na hora o quanto um filtro reduz o ruído; os métodos estão no artigo filtragem de dados de sensores.
• Use outra ferramenta para registrar dados: o Plotter Serial não salva dados em arquivo. Para medições longas, mostre os valores como linhas CSV e importe-os no Excel ou leia-os com Python.

Técnicas de depuração com o Monitor Serial

O Arduino Uno não tem um depurador que execute o seu código passo a passo; o Monitor Serial faz esse papel. Mas linhas de print espalhadas ao acaso pelo código logo viram um monte de texto ilegível. Estes hábitos vão ajudar você a encontrar bugs muito mais rápido:

• Mostre primeiro uma mensagem em setup(): se você vê a linha “Started” uma vez sempre que a placa liga, ela está funcionando. Se essa linha se repete sem parar, a placa está reiniciando o tempo todo e o problema está na alimentação, não no código; veja o guia Arduino reiniciando sozinho.
• Mostre os valores com os nomes: em vez de mostrar só 512, escreva temp=24.5 umid=40; assim você não precisa adivinhar depois qual número pertence a quê.
• Marque onde você está: se o programa trava em algum ponto, coloque marcadores curtos como A, B, C antes das etapas importantes. O último marcador na tela mostra onde o programa empacou.
• Mostre quando mudar, não a cada volta: loop() roda milhares de vezes por segundo. Mostrar algo a cada volta inunda a tela e deixa o programa mais lento; mostre um valor só quando ele mudar, ou uma vez por segundo com millis().
• Meça o tempo: para ver quanto tempo uma operação leva, guarde o valor de micros() antes e depois dela e mostre a diferença. É assim que você pega uma leitura de sensor lenta ou um laço demorado.
• Não mostre nada dentro de interrupções: a saída serial leva tempo; usar Serial.print dentro de uma função de interrupção a deixa longa sem necessidade e pode fazer você perder outros eventos. Na interrupção, apenas ative uma variável de sinalização (flag) e faça a impressão em loop(); detalhes no artigo interrupções no Arduino.
• Coloque as linhas de depuração atrás de uma única chave: com as macros abaixo, você remove toda a saída de depuração do código de uma vez colocando DEBUG em 0; no projeto pronto, você economiza memória flash e tempo.

1// Hata ayıklama makroları: tek satırla aç ya da kapat
2// Debug macros: switch all debug output on or off with one line
3#define DEBUG 1                  // 0 yaparsan debug satırları koddan çıkar / set to 0 to strip debug lines
4
5#if DEBUG
6  #define DBG(x)   Serial.print(x)
7  #define DBGLN(x) Serial.println(x)
8#else
9  #define DBG(x)
10  #define DBGLN(x)
11#endif
12
13const int SENSOR_PIN = A0;
14const int ESIK = 800;            // uyarı eşiği / warning threshold
15bool esikUstunde = false;        // son durum / last state
16unsigned long sonRapor = 0;
17unsigned long turSayisi = 0;     // saniyedeki loop() turu / loop() passes per second
18
19void setup() {
20  Serial.begin(115200);
21  DBGLN(F("Basladi / Started"));
22}
23
24void loop() {
25  turSayisi++;
26  int deger = analogRead(SENSOR_PIN);
27
28  bool simdi = deger > ESIK;
29  if (simdi != esikUstunde) {          // yalnız değişince yaz / print only on change
30    esikUstunde = simdi;
31    DBG(F("[esik / threshold] "));
32    DBG(simdi ? F("ustunde / above") : F("altinda / below"));
33    DBG(F(", deger / value = "));
34    DBGLN(deger);
35  }
36
37  if (millis() - sonRapor >= 1000) {   // saniyede bir özet / one summary per second
38    sonRapor = millis();
39    DBG(F("t = "));
40    DBG(sonRapor);
41    DBG(F(" ms, tur/s / loops/s = "));
42    DBGLN(turSayisi);
43    turSayisi = 0;
44  }
45}

Lembre-se de que a saída serial tem um custo. No Uno, o buffer de transmissão também tem 64 bytes; quando ele enche, Serial.print() espera até haver espaço, e loop() fica mais lento. Você mesmo pode medir isso com o contador de voltas do código acima: se acrescentar uma linha de 25 caracteres que é mostrada a cada volta, a 9600 baud o programa cai para cerca de quarenta voltas por segundo, enquanto mostrar só quando o valor muda mantém milhares. Se quiser ter certeza do que a placa mostrou logo antes de travar ou reiniciar, chame Serial.flush() depois da linha crítica; ele espera até tudo o que está no buffer ter sido enviado. Em programas mais complexos, passar para uma estrutura de máquina de estados e mostrar uma única linha só quando o estado muda facilita muito rastrear os bugs.

Saída serial no ESP32

Nas placas ESP32 DevKit, a Serial é a UART0 no GPIO 1 (TX) e no GPIO 3 (RX), ligada à USB pelo chip CP2102 ou CH340 da placa. A velocidade usual é 115200 baud, porque a ROM dentro do chip também mostra nessa velocidade, durante o boot, linhas como rst:0x1 (POWERON_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT); se você deixar o monitor em 115200, essas linhas também ficam legíveis. O core Arduino do ESP32 oferece Serial.printf() e suporta mostrar floats com %f. As portas seriais extras Serial1 e Serial2 podem ser atribuídas a quaisquer pinos; ao ligar um módulo, é comum usar a Serial2 nos GPIO 16 e 17. Em placas com USB integrada, como o ESP32-S3 e o ESP32-C3, se o Monitor Serial continuar vazio, ajuste Ferramentas > USB CDC On Boot para Enabled. Para ver os avisos do próprio core, escolha Error, Warn, Info, Debug ou Verbose no menu Ferramentas > Core Debug Level; no seu próprio código, você pode mostrar registros com informação de arquivo e linha usando as macros log_e, log_w e log_i.

1// ESP32: Serial (USB), Serial2 (GPIO16/17), printf ve log
2// ESP32: Serial (USB), Serial2 (GPIO16/17), printf and logging
3const int POT_PIN = 34;              // ADC1, yalnız giriş pini / ADC1, input-only pin
4unsigned long sonYazdirma = 0;
5
6void setup() {
7  Serial.begin(115200);                       // açılış mesajlarıyla aynı hız / same rate as the boot messages
8  delay(500);
9  Serial2.begin(9600, SERIAL_8N1, 16, 17);    // RX = GPIO16, TX = GPIO17
10
11  Serial.printf("Model: %s, CPU: %lu MHz\n", ESP.getChipModel(), (unsigned long)ESP.getCpuFreqMHz());
12  Serial.printf("Bos RAM / Free heap: %lu bayt / bytes\n", (unsigned long)ESP.getFreeHeap());
13  log_i("Core Debug Level en az Info ise gorunur / shown when Core Debug Level is Info or higher");
14}
15
16void loop() {
17  while (Serial2.available() > 0) {           // Serial2'den geleni USB'ye aktar / forward Serial2 data to USB
18    Serial.write(Serial2.read());
19  }
20
21  if (millis() - sonYazdirma >= 1000) {       // delay() yok, tampon taşmaz / no delay(), no buffer overflow
22    sonYazdirma = millis();
23    float volt = analogReadMilliVolts(POT_PIN) / 1000.0;          // kalibre gerilim / calibrated voltage
24    Serial.printf("t=%lu ms, GPIO34=%.2f V\n", millis(), volt);   // ESP32'de %f çalışır / %f works on ESP32
25  }
26}

Em problemas de conexão Wi-Fi, reinicializações inesperadas e erros Guru Meditation, o Monitor Serial é o primeiro lugar para olhar: o tipo de erro, o motivo do reset e as linhas de backtrace aparecem ali. Explicamos como interpretar essas mensagens nos guias brownout e Guru Meditation no ESP32 e ESP32 não conecta ao Wi-Fi. Se é a primeira vez que você usa o ESP32, comece pelo artigo O que é o ESP32?.

Saída serial no Raspberry Pi Pico: Arduino e MicroPython

O Raspberry Pi Pico não tem chip ponte USB-serial; o próprio RP2040 cuida da USB e aparece para o computador diretamente como uma porta serial (USB CDC). No core Arduino-Pico de Earle Philhower, a Serial é essa porta USB e, como os dados fluem na velocidade da USB, o valor de velocidade em Serial.begin() é ignorado. Isso tem duas consequências: não importa mais qual velocidade você escolhe no monitor, mas a placa não reinicia como um Uno quando você abre o Monitor Serial. As primeiras mensagens que você mostra em setup() já foram enviadas e perdidas quando você abre o monitor, então espere um pouco até o computador abrir a porta, como mostrado abaixo. O mesmo vale para placas com ATmega32U4, como a Leonardo, a Micro e a Pro Micro. A UART de verdade do Pico, nos pinos GP0 e GP1, é usada com o nome Serial1.

1// Raspberry Pi Pico (Arduino-Pico çekirdeği): USB seri port
2// Raspberry Pi Pico (Arduino-Pico core): USB serial port
3void setup() {
4  Serial.begin(115200);                  // USB'de hız değeri önemsiz / the baud value is ignored over USB
5  unsigned long baslangic = millis();
6  while (!Serial && millis() - baslangic < 3000) {
7    delay(10);                           // port açılana kadar en çok 3 sn bekle / wait up to 3 s for the port
8  }
9  Serial1.begin(9600);                   // UART0: GP0 = TX, GP1 = RX
10  Serial.println("Pico hazir / Pico ready");
11}
12
13void loop() {
14  Serial.print("Sicaklik / Temperature (C): ");
15  Serial.println(analogReadTemp(), 1);   // dahili sensör, yaklaşık / internal sensor, approximate
16  Serial1.println(millis());             // aynı anda UART0'a da yaz / also write to UART0
17  delay(1000);
18}

No MicroPython, tudo é ainda mais simples: tudo o que você mostra com print() vai para o computador pela USB e aparece no Shell do Thonny; não há baud rate para configurar. Se você abrir o menu View > Plotter no Thonny, os números das linhas viram um gráfico ao vivo, igual ao Plotter Serial. Para receber dados do computador, você pode usar input(), mas input() para o programa até chegar uma linha. Para escutar comandos enquanto continua medindo, verifique com select.poll() se há dados esperando em stdin, como mostrado abaixo; basta digitar on ou off no Shell e pressionar Enter. Falamos do Pico e da instalação do MicroPython no artigo O que é o Raspberry Pi Pico?.

1# Pico MicroPython: print() ile yazdır, programı durdurmadan komut al
2# Pico MicroPython: print with print(), read commands without blocking
3import sys
4import select
5import time
6from machine import ADC, Pin
7
8led = Pin(25, Pin.OUT)            # Pico'da dahili LED; Pico W'de Pin("LED") / onboard LED; Pin("LED") on Pico W
9sensor = ADC(4)                   # dahili sıcaklık sensörü / internal temperature sensor
10poll = select.poll()
11poll.register(sys.stdin, select.POLLIN)
12
13while True:
14    volt = sensor.read_u16() * 3.3 / 65535
15    sicaklik = 27 - (volt - 0.706) / 0.001721
16    print("Sicaklik:{:.1f}".format(sicaklik))    # Thonny Plotter da çizer / Thonny's Plotter can graph it
17    if poll.poll(0):                              # bekleyen veri var mı? / is input waiting?
18        komut = sys.stdin.readline().strip()      # satırı al, boşlukları sil / read the line, strip spaces
19        if komut == "on":
20            led.value(1)
21        elif komut == "off":
22            led.value(0)
23        print("Komut / Command:", komut)
24    time.sleep(1)

Monitor Serial vazio ou porta ocupada: erros comuns e soluções

Ideias de projetos com comunicação serial

• LED e relé controlados pelo computador: amplie o parser de comandos deste artigo para controlar um relé ou um motor com os comandos on, off e blink.
• Registrador de dados de sensores: mostre temperatura e umidade como linhas CSV separadas por vírgula e transforme-as em tabela e gráfico no computador; o DHT11 é um bom sensor para começar.
• Gráfico de luz ao vivo: acompanhe o valor de um LDR ou de um potenciômetro no Plotter Serial e veja o efeito do filtro no mesmo gráfico.
• Painel de desktop com Python: leia os dados enviados pelo Arduino com um programa em Python e monte uma interface com botões; detalhes no artigo comunicação serial entre Arduino e Python.
• Estação de teste de módulos: módulos GPS, Bluetooth e GSM também usam porta serial; repasse os dados brutos do módulo para o Monitor Serial para ver se ele funciona (HC-05, GPS NEO-6M).
• Testar sem placa: se você não tem uma placa à mão, o Tinkercad também tem um Monitor Serial; você pode rodar o código deste artigo em uma simulação no Tinkercad.

Quando você pega o jeito do Monitor Serial, encontrar bugs no Arduino deixa de ser adivinhação e passa a ser questão de medir. Como próximo passo, leia o artigo comunicação serial UART para fazer duas placas conversarem por TX e RX, e o artigo conversor USB-TTL para programar placas sem USB. No app BlueGrays você encontra projetos como mostrar no Monitor Serial a distância medida por um HC-SR04, ler a intensidade de luz com um LDR, medir temperatura e umidade com um DHT11 e ligar dois Arduinos por uma linha serial, passo a passo, com esquema do circuito e código pronto.