Monitor Serie Arduino: Baudios, Enviar Datos y Serial Plotter

El monitor serie de Arduino (Serial Monitor) es la ventana del Arduino IDE que permite que tu placa y tu ordenador intercambien texto por el cable USB. Aquí lees la salida de cada línea Serial.println() de tu sketch y desde aquí envías comandos de vuelta a la placa. Es la forma más rápida de ver qué valor está midiendo un sensor en este momento, hasta qué línea ha llegado tu programa o si un pulsador se está pulsando de verdad, y por eso es la herramienta de depuración número uno en Arduino. Para usarlo solo necesitas Serial.begin(9600) en tu código, el puerto correcto seleccionado en el selector de placa y la misma velocidad en el monitor que en el código.

En esta guía empezarás abriendo el monitor serie y después verás qué significan realmente los baudios, cómo imprimir números en decimal, hexadecimal y binario con print y println, cómo controlar el número de decimales y cómo montar líneas ordenadas con snprintf. Con sketches de ejemplo que compilan de verdad, repasamos todas las causas de los caracteres raros, cómo afecta a tu código el ajuste de fin de línea, cómo enviar números y comandos de texto del ordenador a la placa (Serial.read, parseInt, readStringUntil), cómo dibujar gráficas en vivo con el Serial Plotter y técnicas de depuración que te harán la vida más fácil. Las últimas secciones muestran en qué cambia la salida serie en el ESP32 y en la Raspberry Pi Pico (con Arduino y con MicroPython) y cómo resolver problemas frecuentes como un monitor vacío.

¿Qué es el monitor serie de Arduino y cómo funciona?

El ATmega328P, el cerebro del Arduino Uno, se comunica con el exterior mediante una unidad de comunicación serie llamada UART: envía los datos bit a bit por una línea (TX) y los recibe por otra (RX). Los ordenadores actuales ya no tienen este tipo de puerto serie, así que un segundo chip de la placa (un ATmega16U2 en el Uno original, normalmente un CH340 en los clones) convierte la señal a USB. El ordenador ve la placa como un puerto serie virtual: algo como COM3 en Windows, /dev/ttyACM0 o /dev/ttyUSB0 en Linux y un nombre que empieza por /dev/cu.usbmodem o /dev/cu.usbserial en macOS. El monitor serie abre ese puerto, muestra los bytes que llegan como texto y envía lo que escribes a la placa por el mismo camino. Por defecto Arduino usa el formato 8N1: un bit de inicio, 8 bits de datos, sin bit de paridad y un bit de parada por cada byte. Así, un solo carácter ocupa 10 bits en la línea; usaremos esa cifra en los cálculos de velocidad.

Cómo abrir y usar el monitor serie

1. Añade la línea Serial.begin(9600); en la parte setup() de tu sketch y súbelo a la placa. Sin esta línea la placa no escribe nada en el puerto serie.
2. Elige el puerto al que está conectada tu placa en el selector de la barra superior o en el menú Herramientas > Puerto. Si no hay ningún puerto seleccionado, el monitor serie muestra el aviso No conectado. Selecciona una placa y un puerto para conectarte automáticamente. (en la interfaz en inglés: Not connected. Select a board and a port to connect automatically.)
3. Haz clic en el icono de la lupa de la esquina superior derecha, usa el menú Herramientas > Monitor Serie o pulsa Ctrl+Mayús+M (Cmd+Shift+M en macOS). En el IDE 2 el monitor se abre en el panel inferior, junto a la sección de salida.
4. En el menú de velocidad, a la derecha del panel, elige los mismos baudios que en tu código; en este ejemplo, 9600. Si la velocidad es distinta, aparecerán caracteres raros en pantalla.
5. Para enviar datos a la placa, escribe en el cuadro de mensaje de la parte superior del panel y pulsa Intro. En el menú de al lado eliges el fin de línea; más abajo te explicamos por qué importa este ajuste.
6. Con los botones de arriba a la derecha puedes detener el desplazamiento automático (útil para leer líneas antiguas), activar la marca de tiempo, que añade la hora de tu ordenador al principio de cada línea, y borrar la salida.

En el antiguo Arduino IDE 1.8 el monitor serie se abre en una ventana aparte; los controles hacen lo mismo, solo que están en otro sitio: las casillas de desplazamiento automático y marca de tiempo están abajo a la izquierda, y los menús de fin de línea y velocidad, abajo a la derecha. También puedes ver el puerto serie sin el IDE: PuTTY o CoolTerm en Windows, el comando screen /dev/ttyUSB0 115200 en Linux y macOS, y arduino-cli monitor -p COM3 -c baudrate=115200 en cualquier sistema hacen el mismo trabajo. Ten en cuenta una cosa: un puerto serie solo puede abrirlo un programa a la vez. Mientras un script de Python o PuTTY tenga el puerto ocupado, no podrás subir código desde el IDE; la instalación del IDE y el resto de su interfaz los explicamos en la guía cómo instalar Arduino IDE.

Serial.begin() y velocidad en baudios: ¿9600 o 115200?

Serial.begin(velocidad) inicia el puerto serie a la velocidad indicada y casi siempre se llama una sola vez dentro de setup(). La velocidad se expresa en baudios, es decir, en bits por segundo en la línea. Como cada carácter ocupa 10 bits, 9600 baudios equivalen como máximo a 960 caracteres por segundo; enviar un solo carácter tarda unos 1,04 milisegundos. Una línea de 30 caracteres ocupa 31 ms a esta velocidad, así que en cuanto quieras imprimir cientos de lecturas por segundo te toparás con este límite. A 115200 baudios la misma línea tarda solo 2,6 ms. El valor del sketch y el del monitor serie deben coincidir, porque no hay una señal de reloj común y el receptor lee los bits únicamente por tiempo.

El reloj de 16 MHz del Uno no puede generar todas las velocidades con exactitud: 115200 baudios funcionan en realidad con un desvío de alrededor del 2 %, a 117647 baudios. Ese desvío no da problemas en el monitor serie, pero puede provocar errores al comunicarse con otro microcontrolador a través de un cable largo; en esos casos, 57600 o 250000 baudios, que se generan sin error, son más seguros. Si estás empezando, usa 9600 con el Uno y el Nano y 115200 con el ESP32 y la Pico. Si conectas dos placas con cables TX-RX, la velocidad debe ser la misma en ambos lados, las GND deben estar unidas y una línea TX de 5 V debe reducirse con un divisor de tensión antes de llegar a una entrada RX de 3,3 V (ESP32, Pico). Encontrarás los detalles en el artículo comunicación serie UART.

Serial.print() y Serial.println(): imprimir y dar formato

Serial.print() escribe el valor que le das y deja el cursor en la misma línea; Serial.println() además añade al final los caracteres de fin de línea (\r\n), de modo que la siguiente salida empieza en una línea nueva. Para mostrar varios valores en una línea, escribe las primeras partes con print y la última con println. Estas funciones aceptan casi cualquier tipo, como int, long, float, char, texto y String, y el segundo parámetro opcional fija el formato. Con enteros puedes elegir DEC, HEX, BIN y OCT, mientras que con números decimales el segundo parámetro es la cantidad de decimales. Los decimales se imprimen por defecto con 2 cifras y redondeados. En el código siguiente hemos escrito la salida de cada línea como comentario:

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}

En lugar de imprimir líneas largas por partes, puedes preparar un solo texto con snprintf(): %d es un entero, %02d un entero de dos cifras con cero a la izquierda, %s un texto y %lu un unsigned long como millis(). Para ahorrar memoria, la biblioteca de C del Uno no admite %f; si intentas imprimir un decimal, verás un ? en su lugar. Por eso, convierte primero los decimales a texto con dtostrf(número, ancho, decimales, búfer). En el ESP32 y la Pico puedes usar directamente Serial.printf(). El Uno solo tiene 2 KB de RAM; escribir los textos fijos con la macro F(), como en Serial.println(F("Hola")), los guarda en la flash en lugar de la RAM y evita problemas de memoria insuficiente en proyectos grandes.

Caracteres raros en el monitor serie: causas y solución

Si ves ⸮⸮⸮, � o montones de letras y símbolos aleatorios, los datos llegan al ordenador pero se descodifican mal. Como la comunicación serie no tiene una señal de reloj común, el receptor calcula el centro de cada bit según su propia velocidad a partir del momento en que ve el bit de inicio. Si la velocidad es incorrecta o el reloj de la placa no es el que debería, los bits se leen en el momento equivocado y cada byte se convierte en otro carácter. Casi siempre la causa es un único ajuste; la tabla siguiente ordena los casos más frecuentes por síntoma. Para placas con distintas opciones de reloj, como la Pro Mini, echa también un vistazo al artículo Arduino Pro Mini.

Ajuste de fin de línea: No Line Ending, New Line, Carriage Return, Both NL & CR

Cuando escribes en el cuadro de mensaje y pulsas Intro, el monitor serie no envía solo los caracteres que has tecleado, sino también uno o dos caracteres invisibles según el fin de línea elegido. Si tu código no los espera, por ejemplo porque trata cada byte que llega como un comando, también leerá '\n' (valor 10) y '\r' (13) como comandos. Al revés, si tu código espera un fin de línea y el ajuste es No Line Ending, la línea nunca termina; readStringUntil() espera hasta que se agota el tiempo. La tabla muestra los bytes que llegan a la placa al escribir 42 y pulsar Intro:

Una regla práctica: para código que lee línea a línea, elige New Line y aplica trim() al texto leído; así tu código funciona con cualquier ajuste que elija el usuario. Para comandos de un solo carácter como 1, 0 o a, No Line Ending es la opción más limpia. El IDE recuerda tu elección, así que revísala cuando cambies a otro proyecto.

Enviar datos del ordenador a Arduino: Serial.read(), parseInt(), readStringUntil()

Los bytes que envías desde el monitor serie se ponen en cola en el búfer de recepción de la placa (64 bytes en el Uno). Serial.available() te dice cuántos bytes esperan en él, Serial.read() toma el siguiente byte y lo saca del búfer, devolviendo -1 si no hay datos, y Serial.peek() mira el siguiente byte sin sacarlo. Recuerda que todo lo que llega del teclado son caracteres ASCII: si escribes 7, la placa no recibe el número 7 sino 55, el código del carácter '7'. Tienes un ejemplo de comandos sencillos de una tecla en el artículo comandos de Arduino; aquí tratamos números de varias cifras y comandos formados por palabras. Si el búfer se llena, los bytes nuevos se pierden, así que temporizar con millis() en lugar de esperar mucho con delay() dentro de loop() también hace más segura la lectura serie.

Serial.parseInt() extrae el primer número entero de los caracteres que llegan: salta las letras y espacios iniciales, une las cifras y se detiene en el primer carácter que no es una cifra; también entiende el signo menos. Así, el texto "128" se convierte en el número 128. Para decimales, Serial.parseFloat() hace lo mismo. Estas funciones tienen una costumbre que debes conocer: si no llega ningún número, esperan por defecto 1000 ms y luego devuelven 0. El error clásico ocurre así: con el ajuste en New Line envías 42, parseInt lee 42 pero el '\n' se queda en el búfer. En la siguiente vuelta, loop() ve que available() es mayor que 0 y vuelve a llamar a parseInt, que espera un segundo y devuelve 0. Resultado: tras cada número llega también un 0, y no entiendes por qué el LED se apaga un segundo después de cada número. El código siguiente resuelve el problema de raíz descartando el siguiente carácter si no es una cifra, y acorta la espera con 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 palabras, lo más cómodo es leer la línea entera como String. Serial.readStringUntil('\n') lee hasta que llega un '\n', descarta el carácter de fin de línea y devuelve el resto. Si el ajuste es Both NL & CR, queda un '\r' al final del texto, tu comando "on" se convierte en "on\r" y la comparación falla. Por eso conviene aplicar trim() a la línea en cuanto la lees: elimina los espacios iniciales y finales y los caracteres '\r' y '\n'. toLowerCase() hace que ON, On y on sean iguales. El ejemplo siguiente entiende los comandos on, off, blink 250 y status; usa el monitor serie a 115200 baudios y con New Line. Como parpadea con millis() en lugar de delay(), responde al instante a un comando nuevo en cualquier 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}

Gráficas en vivo con el Serial Plotter

El Serial Plotter (Plotter Serie en el IDE en español) convierte los números que llegan por el puerto serie en una gráfica de líneas en vivo; se abre con el icono de onda de la esquina superior derecha del IDE o desde el menú Herramientas > Plotter Serie. El formato es muy sencillo: separa los valores de una línea con comas, espacios o tabuladores y termina la línea con println. Cada línea es un paso de tiempo en la gráfica y cada valor de la línea, una curva de color distinto. Si pones un nombre delante de los valores con el formato etiqueta:valor, las curvas llevan ese nombre y puedes ocultarlas o mostrarlas una a una con las casillas que hay sobre la gráfica; sin etiquetas, las curvas se llaman value 1, value 2, etc. Aquí también el menú de velocidad debe coincidir con tu código. El código siguiente dibuja en la misma gráfica la lectura en bruto de A0 y su versión suavizada:

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}

• Fija la escala: El Serial Plotter reajusta constantemente el eje vertical a los valores que llegan, por eso las pequeñas variaciones parecen enormes. Añadir a cada línea dos valores fijos como Min:0,Max:1023, mantiene el eje fijo.
• No uses espacios en las etiquetas: Como los espacios y las comas cuentan como separadores, "Temp Sala:24" se divide en dos partes; usa nombres con guion bajo como Temp_Sala.
• En la línea, solo etiquetas y números: Unidades y descripciones como "Temp 24 C" estropean la gráfica; imprime las descripciones para el monitor serie en código aparte.
• Ajusta el ritmo de envío: delay(20) significa unas 50 líneas por segundo. Si envías demasiado rápido, la gráfica se desplaza en un instante; si envías demasiado despacio, la línea parece una escalera.
• Ve el filtro con tus propios ojos: Dibujar el valor en bruto y la media en la misma gráfica muestra al instante cuánto reduce el ruido un filtro; tienes los métodos en el artículo filtrar datos de sensores.
• Para registrar, usa otra herramienta: El Serial Plotter no guarda los datos en un archivo. Para mediciones largas, imprime los valores como líneas CSV y pásalos a Excel o léelos con Python.

Técnicas de depuración con el monitor serie

El Arduino Uno no tiene un depurador que ejecute tu código paso a paso; ese trabajo lo hace el monitor serie. Pero las líneas print repartidas al azar por el código se convierten pronto en un montón de texto ilegible. Estos hábitos te ayudarán a encontrar los errores mucho más rápido:

• Imprime primero un mensaje desde setup(): Si ves la línea "Started" una vez en cada arranque, la placa funciona. Si esa línea se repite sin parar, la placa se reinicia continuamente y el problema está más en la alimentación que en el código; consulta la guía Arduino se reinicia solo.
• Imprime los valores con su nombre: En lugar de escribir solo 512, escribe temp=24.5 hum=40; así no tendrás que pensar después a qué corresponde cada número.
• Marca por dónde vas: Si el programa se cuelga en algún punto, pon marcas cortas como A, B, C antes de los pasos importantes. La última marca que aparece en pantalla indica dónde se ha quedado atascado.
• Imprime cuando cambie, no en cada vuelta: loop() se ejecuta miles de veces por segundo. Imprimir en cada vuelta inunda la pantalla y ralentiza el programa; imprime un valor solo cuando cambie o una vez por segundo con millis().
• Mide el tiempo: Para ver cuánto tarda una operación, guarda el valor de micros() antes y después e imprime la diferencia. Así pillas una lectura de sensor lenta o un bucle largo.
• No imprimas dentro de interrupciones: La salida serie lleva tiempo; usar Serial.print dentro de una función de interrupción la alarga sin necesidad y puede hacer que se te escapen otros eventos. En la interrupción marca solo una variable y haz la impresión en loop(); detalles en el artículo interrupciones en Arduino.
• Pon las líneas de depuración tras un solo interruptor: Con las macros siguientes puedes eliminar por completo del código toda la salida de depuración poniendo DEBUG a 0; en el proyecto terminado ahorras memoria flash y tiempo.

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}

Recuerda que la salida serie tiene un coste. En el Uno el búfer de envío también es de 64 bytes; cuando se llena, Serial.print() espera hasta que haya sitio y loop() se ralentiza. Puedes medirlo tú mismo con el contador de vueltas del código anterior: si añades una línea de 25 caracteres que se imprima en cada vuelta, a 9600 baudios el programa baja a unas cuarenta vueltas por segundo, mientras que imprimir solo cuando cambia mantiene miles. Si quieres ver con seguridad qué imprimió la placa justo antes de colgarse o reiniciarse, llama a Serial.flush() después de la línea crítica; espera hasta que se haya enviado todo lo que hay en el búfer. En programas más complejos, pasar a una estructura de máquina de estados e imprimir una sola línea solo cuando cambia el estado facilita mucho seguir la pista a los errores.

Salida serie en el ESP32

En las placas ESP32 DevKit, Serial es la UART0 de GPIO 1 (TX) y GPIO 3 (RX), conectada al USB a través del chip CP2102 o CH340 de la placa. La velocidad habitual es 115200 baudios, porque la ROM interna del chip también imprime al arrancar líneas como rst:0x1 (POWERON_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT) a esa velocidad; si dejas el monitor en 115200, también podrás leerlas. El núcleo Arduino del ESP32 ofrece Serial.printf() y admite imprimir decimales con %f. Los puertos serie adicionales Serial1 y Serial2 pueden asignarse a los pines que quieras; al conectar un módulo es habitual usar Serial2 en GPIO 16 y 17. En las placas con USB integrado como el ESP32-S3 y el ESP32-C3, si el monitor serie se queda vacío, pon Herramientas > USB CDC On Boot en Enabled. Para ver los avisos del propio núcleo, elige Error, Warn, Info, Debug o Verbose en el menú Herramientas > Core Debug Level, y en tu propio código puedes imprimir registros con el archivo y la línea usando las macros log_e, log_w y 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}

Ante problemas de conexión Wi-Fi, reinicios inesperados y errores Guru Meditation, el monitor serie es el primer sitio donde mirar: aquí aparecen el tipo de error, el motivo del reinicio y las líneas de backtrace. Explicamos cómo interpretar estos mensajes en las guías ESP32 brownout y Guru Meditation y el ESP32 no se conecta al Wi-Fi. Si es la primera vez que usas el ESP32, empieza por el artículo ¿Qué es el ESP32?.

Salida serie en la Raspberry Pi Pico: Arduino y MicroPython

La Raspberry Pi Pico no tiene chip puente USB-serie; el RP2040 gestiona el USB por sí mismo y aparece en el ordenador directamente como puerto serie (USB CDC). En el núcleo Arduino-Pico de Earle Philhower, Serial es ese puerto USB y, como los datos viajan a velocidad USB, el valor de velocidad de Serial.begin() se ignora. Esto tiene dos consecuencias: ya no importa qué velocidad elijas en el monitor, pero la placa no se reinicia como un Uno al abrir el monitor serie. Los primeros mensajes que imprimes en setup() ya se han enviado y perdido cuando abres el monitor, así que espera un momento a que el ordenador abra el puerto, como en el ejemplo siguiente. Lo mismo ocurre con las placas con ATmega32U4 como Leonardo, Micro y Pro Micro. La UART real de la Pico, en los pines GP0 y GP1, se usa con el nombre 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}

En MicroPython todo es aún más sencillo: todo lo que imprimes con print() va al ordenador por USB y aparece en la Shell de Thonny; no hay baudios que ajustar. Si abres el menú View > Plotter de Thonny, los números de las líneas se convierten en una gráfica en vivo, igual que en el Serial Plotter. Para recibir datos del ordenador puedes usar input(), pero input() detiene el programa hasta que llega una línea. Para escuchar comandos mientras sigues midiendo, comprueba con select.poll() si hay datos esperando en stdin, como en el ejemplo siguiente; basta con escribir on u off en la Shell y pulsar Intro. Explicamos la Pico y la instalación de MicroPython en el artículo ¿Qué es la 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 serie vacío o puerto ocupado: errores frecuentes y soluciones

Ideas de proyectos con comunicación serie

• LED y relé controlados desde el ordenador: Amplía el analizador de comandos de este artículo para controlar un relé o un motor con los comandos on, off y blink.
• Registrador de datos de sensores: Imprime la temperatura y la humedad como líneas CSV separadas por comas y conviértelas en tabla y gráfica en el ordenador; el DHT11 es un buen sensor para empezar.
• Gráfica de luz en vivo: Observa el valor de una LDR o de un potenciómetro en el Serial Plotter y ve el efecto del filtro en la misma gráfica.
• Panel de escritorio con Python: Lee los datos que envía el Arduino con un programa en Python y crea una interfaz con botones; detalles en el artículo comunicación serie entre Arduino y Python.
• Banco de pruebas de módulos: Los módulos GPS, Bluetooth y GSM también usan un puerto serie; reenvía los datos en bruto del módulo al monitor serie para comprobar si funciona (HC-05, GPS NEO-6M).
• Pruebas sin placa: Si no tienes una placa a mano, Tinkercad también tiene un monitor serie; puedes ejecutar el código de este artículo en una simulación en Tinkercad.

Cuando te sientas cómodo con el monitor serie, encontrar errores en Arduino dejará de ser adivinar y pasará a ser medir. Como siguiente paso, lee el artículo comunicación serie UART para hacer que dos placas hablen por TX y RX, y el de conversor USB-TTL para programar placas sin USB. En la app BlueGrays encontrarás proyectos como mostrar en el monitor serie la distancia medida con un HC-SR04, leer la intensidad de luz con una LDR, medir temperatura y humedad con un DHT11 y comunicar dos Arduino por una línea serie, paso a paso con esquemas de circuito y código listo para usar.