Arduino String: cadenas de texto, char, substring y toInt
Cómo usar String en Arduino: concatenar, indexOf, substring, toInt, analizar comandos del puerto serie, arrays char, macro F() y fragmentación de memoria.
Arduino String es una clase lista para usar que te permite guardar texto en una sola variable, unirlo y trocearlo. Es lo primero que usarás cuando quieras separar un comando como "LED,1" que llega por el puerto serie, mostrar un valor de sensor como "Temperatura: 24 C" en una pantalla o reconocer un mensaje que llega por Bluetooth. En Arduino hay dos formas de trabajar con texto: el objeto String, fácil de usar, y el array de char, de más bajo nivel y heredado del lenguaje C. Ambos hacen lo mismo, pero usan la memoria de forma muy distinta.
En este artículo verás primero las operaciones más habituales con String, como concatenar, indexOf, substring y toInt, con sus salidas reales. Después escribiremos un analizador que recibe comandos por el puerto serie, enciende y apaga un LED y ajusta el brillo con PWM. A continuación veremos por qué String puede dar problemas con el tiempo en los 2 KB de RAM de la Arduino Uno, qué es la fragmentación de memoria y para qué sirve la macro F(). En las últimas secciones aprenderás a escribir el mismo analizador con arrays de char, en ESP32 y en Raspberry Pi Pico con MicroPython.

¿Qué es String en Arduino y en qué se diferencia de un array de char?
String (con S mayúscula) es una clase definida en el núcleo de Arduino. Guarda el texto en una zona de memoria llamada montón (heap) y, a medida que el texto crece, ella misma amplía ese espacio. Gracias a eso puedes concatenar con +, comparar con == y convertir a número con una sola instrucción. Un array de char, en cambio, es un bloque fijo de bytes cuyo tamaño decides tú de antemano. El final del texto siempre lo marca un carácter invisible '\0' (nulo); por eso, para la palabra "Hello" de 5 letras necesitas un array de al menos 6 bytes: char ad[6] = "Hello";. Con arrays de char, para concatenar y comparar usas funciones de C como strcat y strcmp; el operador == no compara el contenido de los dos arrays, sino sus direcciones de memoria. Esta diferencia es una de las cosas con las que más se atascan los principiantes.
| Característica | String | Array de char |
|---|---|---|
| Facilidad de uso | Muy fácil: +, ==, substring() | Más difícil: strcat(), strcmp(), strtok() |
| Ubicación en memoria | Montón (heap), dinámica | Fija; zona global o pila (stack) |
| Tamaño | Crece solo | Se define de antemano |
| Riesgo de desbordamiento | No, pero si se acaba la memoria la operación falla en silencio | Sí; el control de límites lo haces tú |
| Riesgo de fragmentación | Sí (sobre todo en la Uno) | No |
| Dónde encaja | ESP32, Pico, textos cortos y poco frecuentes | Proyectos que funcionan sin parar en Uno y Nano |
Memoria según la plataforma y conexión de prueba
| Característica | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| RAM | 2 KB SRAM | 520 KB SRAM | 264 KB SRAM |
| Memoria de programa | 32 KB flash | 4 MB flash externa (en la mayoría de placas) | 2 MB flash externa |
| Pin del LED de prueba | D9 (PWM) + 220 Ω | GPIO 4 + 220 Ω | GP15 + 220 Ω |
| Velocidad del puerto serie (en los ejemplos) | 9600 baudios | 115200 baudios | USB (consola de Thonny) |
| Macro F() | Ahorra RAM | Sin efecto, existe por compatibilidad | No existe (MicroPython) |
| Tipo de texto | String y char[] | String y char[] | str (Python) |
Operaciones básicas con String: concatenar, indexOf, substring, toInt
Para añadir texto a un String se usa += o concat(). indexOf() te dice en qué posición está el carácter o la palabra que buscas; se cuenta desde 0 y, si no se encuentra, devuelve -1. substring(inicio, fin) copia un trozo del texto: la posición inicial está incluida y la final excluida, es decir, substring(8, 12) toma los caracteres de las posiciones 8, 9, 10 y 11. toInt() convierte los dígitos del comienzo del texto en un número de tipo long. Si cargas el código siguiente y abres el Monitor Serie a 9600 baudios, puedes comparar la salida de cada línea con el valor del comentario.
1void setup() {
2 Serial.begin(9600);
3
4 String ad = "Blue";
5 ad += "Grays"; // birleştirme / concatenation
6 String mesaj = "Merhaba " + ad; // "Merhaba BlueGrays"
7 int sicaklik = 24;
8 String satir = String("Sicaklik: ") + sicaklik + " C"; // sayı eklemek / appending a number
9
10 Serial.println(mesaj); // Merhaba BlueGrays
11 Serial.println(satir); // Sicaklik: 24 C
12 Serial.println(mesaj.length()); // 17
13 Serial.println(mesaj.indexOf(' ')); // 7
14 Serial.println(mesaj.indexOf("Grays")); // 12
15 Serial.println(mesaj.substring(8)); // BlueGrays
16 Serial.println(mesaj.substring(8, 12)); // Blue
17 mesaj.toUpperCase(); // yerinde değiştirir / modifies in place
18 Serial.println(mesaj); // MERHABA BLUEGRAYS
19
20 String sayiMetni = "1250";
21 long n = sayiMetni.toInt() + 1; // 1251
22 Serial.println(n);
23 float f = String("3.75").toFloat(); // 3.75
24 Serial.println(f, 2);
25 Serial.println(String(255, HEX)); // ff
26}
27
28void loop() {
29}| Función | Qué hace | Ejemplo (s = "LED,128") |
|---|---|---|
| s.length() | Devuelve el número de caracteres | 7 |
| s.indexOf(',') | Posición de la primera coincidencia, o -1 si no hay | 3 |
| s.substring(0, 3) | Desde 0 hasta la posición 3 (sin incluirla) | "LED" |
| s.substring(4) | Desde la posición 4 hasta el final | "128" |
| s.substring(4).toInt() | Lo convierte en número (long); 0 si no es válido | 128 |
| s.startsWith("LED") | ¿Empieza con este texto? | true |
| s.equalsIgnoreCase("led,128") | Compara sin distinguir mayúsculas de minúsculas | true |
| s.charAt(0) | Devuelve un solo carácter | 'L' |
| s.trim() | Borra espacios, \r y \n del principio y del final (in situ) | No cambia (no hay espacios) |
| s.c_str() | Devuelve un puntero que se lee como un array de char | strcmp(s.c_str(), "LED,128") == 0 |
| String(3.14159, 2) | Convierte un decimal en texto con ese número de decimales | "3.14" |
| s.replace(",", ";") | Sustituye un fragmento in situ | s ahora es "LED;128" |
Analizar comandos del puerto serie paso a paso
- Conecta la pata larga del LED (ánodo) al pin D9 de la Uno a través de una resistencia de 220 Ω, y la pata corta a GND. D9 admite PWM, así que también se puede regular el brillo.
- Define el formato del comando: COMANDO,VALOR. Por ejemplo, LED,1 enciende el LED, LED,0 lo apaga y PWM,128 da aproximadamente medio brillo.
- Lee la línea del puerto serie hasta el carácter Enter ('\n') y limpia los caracteres invisibles con trim().
- Con indexOf(',') localiza la coma; con substring() separa lo anterior a la coma como comando y lo posterior como valor.
- Convierte el valor en número con toInt(), pasa el comando a mayúsculas con toUpperCase(), compáralo y ejecuta la acción correspondiente.
- Después de cada comando, imprime una respuesta corta en el Monitor Serie; así ves enseguida si el comando se ha entendido.
1const int LED_PIN = 9; // PWM destekli pin / PWM capable pin
2
3void setup() {
4 Serial.begin(9600);
5 Serial.setTimeout(50); // satır bekleme süresi (ms) / line wait timeout (ms)
6 pinMode(LED_PIN, OUTPUT);
7 Serial.println(F("Komutlar / Commands: LED,1 LED,0 PWM,0-255"));
8}
9
10void loop() {
11 if (Serial.available() > 0) {
12 String satir = Serial.readStringUntil('\n'); // Enter'a kadar oku / read until Enter
13 satir.trim(); // CR ve boşlukları sil / remove CR and spaces
14 if (satir.length() == 0) return;
15
16 String komut = satir;
17 String deger = "";
18 int virgul = satir.indexOf(',');
19 if (virgul >= 0) {
20 komut = satir.substring(0, virgul); // virgülden önce / before the comma
21 deger = satir.substring(virgul + 1); // virgülden sonra / after the comma
22 }
23 komut.toUpperCase();
24 long sayi = deger.toInt(); // geçersizse 0 / 0 if invalid
25
26 if (komut == "LED") {
27 digitalWrite(LED_PIN, sayi ? HIGH : LOW);
28 Serial.print(F("LED -> "));
29 Serial.println(sayi ? "ACIK / ON" : "KAPALI / OFF");
30 } else if (komut == "PWM") {
31 sayi = constrain(sayi, 0, 255); // 0-255 arasında tut / keep in 0-255
32 analogWrite(LED_PIN, (int)sayi);
33 Serial.print(F("PWM -> "));
34 Serial.println(sayi);
35 } else {
36 Serial.print(F("Bilinmeyen komut / Unknown command: "));
37 Serial.println(komut);
38 }
39 }
40}La línea Serial.setTimeout(50) es importante: readStringUntil() espera por defecto 1000 ms al siguiente carácter; si no llega el fin de línea, el programa se queda parado un segundo. A 9600 baudios un carácter llega en aproximadamente 1 ms, así que 50 ms son más que suficientes. Si el comando no contiene coma, indexOf() devuelve -1; en ese caso tomamos toda la línea como comando y el valor queda vacío. Al aplicar toInt() a un String vacío el resultado es 0. Aquí hay una trampa: toInt() también devuelve 0 para un texto no válido, es decir, para tu código "PWM,abc" y "PWM,0" son lo mismo. En un proyecto real es buena costumbre comprobar con isDigit() que el primer carácter del valor sea un dígito. constrain(), por su parte, impide que el valor PWM se salga del rango 0–255.
Fragmentación de memoria: ¿por qué String puede bloquear la Uno?
Cada vez que un String crece, si el espacio disponible no basta, pide en el montón un espacio nuevo más grande, traslada el texto allí y libera el antiguo. Los espacios liberados no siempre se pueden reutilizar; con el tiempo el montón se convierte en un queso con pequeños agujeros entre medias. Aunque en total haya 300 bytes libres, si el mayor bloque continuo es de 40 bytes no se puede crear un String de 50 bytes. Esto se llama fragmentación de memoria (heap fragmentation). En los 2 KB de RAM de la Arduino Uno, el montón crece hacia arriba y la pila (stack), que usan las llamadas a funciones, hacia abajo; cuando chocan, las variables se corrompen, aparecen caracteres extraños en el Monitor Serie o la placa se reinicia sola. Lo más insidioso es que, cuando no se encuentra espacio, la operación con String falla sin dar error: tras concatenar, el texto queda a medias o vacío. Como estos problemas suelen aparecer después de horas de funcionamiento, no se notan en las pruebas cortas en la mesa.
- Reserva espacio con reserve(): Si puedes estimar la longitud de un String, escribe linea.reserve(64); en setup(); mientras el texto se mantenga dentro de ese límite no volverá a pedir espacio.
- Usa variables globales o static: Los String que se recrean en cada vuelta de loop() remueven el montón sin parar; es más seguro reutilizar un único String global.
- Pasa por referencia: Define el parámetro de la función como void escribir(const String &texto); pasar el String por valor crea una copia nueva en cada llamada.
- Divide las cadenas largas: Expresiones como a + b + c + d generan objetos temporales; añadir paso a paso con += usa menos memoria temporal.
- Imprime directamente: Si el texto solo se va a mostrar, en vez de concatenar usa varias instrucciones Serial.print() seguidas; así no se crea ningún String.
- No lo uses en interrupciones: No crees String en funciones llamadas con attachInterrupt(); reservar memoria dentro de una interrupción no es seguro.
Ahorra RAM en la Uno con la macro F()
En las placas con procesador AVR (Uno, Nano, Mega), cada texto constante que escribes en el código se copia de la memoria flash a la RAM al arrancar el programa. Solo diez textos de menú de 40 caracteres ya gastan 400 bytes, es decir, una quinta parte de la RAM de la Uno. La macro F("...") deja el texto en la flash y Serial.print() o lcd.print() lo leen desde allí. La regla es simple: mete en F() todo texto constante que imprimas en el Monitor Serie o en una pantalla. F() solo funciona con la familia print y con lugares que lo admiten, como añadir a un String; no se puede pasar directamente a funciones de C como strcmp(). El código siguiente muestra además la forma clásica de medir la RAM libre en placas AVR; puedes comparar este valor antes y después de usar F().
1// Yalnız AVR kartlar (Uno, Nano, Mega) / AVR boards only (Uno, Nano, Mega)
2extern int __heap_start, *__brkval;
3
4int bosRam() {
5 int v;
6 return (int)&v - (__brkval == 0 ? (int)&__heap_start : (int)__brkval);
7}
8
9void setup() {
10 Serial.begin(9600);
11 Serial.println("Bu metin RAM'e kopyalanir / This text is copied to RAM");
12 Serial.println(F("Bu metin flash'ta kalir / This text stays in flash"));
13
14 String s;
15 s.reserve(40); // tek seferde 40 bayt / 40 bytes at once
16 s += F("Sicaklik: "); // F() String'e de eklenebilir / F() works with String too
17 s += 24;
18 Serial.println(s);
19
20 Serial.print(F("Bos RAM / Free RAM: "));
21 Serial.println(bosRam());
22}
23
24void loop() {
25}Análisis seguro de comandos con un array de char
En proyectos en los que la placa debe funcionar días sin interrupción, sobre todo en Uno y Nano, recoger los comandos en un array de char de tamaño fijo es el camino más robusto. El código siguiente escribe los caracteres recibidos uno a uno en un búfer de 32 bytes, cierra la línea con '\0' cuando llega '\n' y la divide por la coma con strtok(). Cuando el búfer se llena, los caracteres sobrantes se descartan en silencio, de modo que no hay desbordamiento. Como el código no espera en ningún sitio con delay() ni con tiempos de espera, en loop() también pueden seguir otras tareas, como leer sensores o mover motores. La única diferencia es que la comparación distingue mayúsculas de minúsculas: debes escribir los comandos en mayúsculas.
1const int LED_PIN = 9;
2const byte MAX_UZUNLUK = 32; // en fazla 31 karakter + '\0' / max 31 chars + '\0'
3char tampon[MAX_UZUNLUK];
4byte konum = 0;
5
6void komutIsle(char *satir) {
7 char *komut = strtok(satir, ","); // ilk parça / first token
8 char *deger = strtok(NULL, ","); // ikinci parça / second token
9 if (komut == NULL) return;
10 int sayi = (deger != NULL) ? atoi(deger) : 0;
11
12 if (strcmp(komut, "LED") == 0) {
13 digitalWrite(LED_PIN, sayi ? HIGH : LOW);
14 } else if (strcmp(komut, "PWM") == 0) {
15 sayi = constrain(sayi, 0, 255);
16 analogWrite(LED_PIN, sayi);
17 } else {
18 Serial.print(F("Bilinmeyen / Unknown: "));
19 Serial.println(komut);
20 return;
21 }
22 char cevap[40];
23 snprintf(cevap, sizeof(cevap), "OK %s=%d", komut, sayi); // taşma korumalı / overflow safe
24 Serial.println(cevap);
25}
26
27void setup() {
28 Serial.begin(9600);
29 pinMode(LED_PIN, OUTPUT);
30}
31
32void loop() {
33 while (Serial.available() > 0) {
34 char c = Serial.read();
35 if (c == '\r') continue; // CR karakterini atla / skip CR
36 if (c == '\n') { // satır bitti / line complete
37 tampon[konum] = '\0';
38 if (konum > 0) komutIsle(tampon);
39 konum = 0;
40 } else if (konum < MAX_UZUNLUK - 1) {
41 tampon[konum++] = c; // yer varsa ekle / append if there is room
42 }
43 }
44}| Función | Qué hace | Ejemplo |
|---|---|---|
| strlen(s) | Devuelve el número de caracteres sin contar '\0' | strlen("LED") → 3 |
| strncpy(destino, origen, n) | Copia como máximo n caracteres | strncpy(buf, "PWM", sizeof(buf) - 1) |
| strcat(destino, origen) | Añade al final (el destino debe tener espacio) | strcat(buf, ",128") |
| strcmp(a, b) | Devuelve 0 si los textos son iguales | strcmp(comando, "LED") == 0 |
| strchr(s, c) | Devuelve la dirección del carácter, o NULL si no está | strchr(s, ',') |
| strtok(s, ",") | Divide el texto por el separador (modifica el original) | Para el siguiente trozo, strtok(NULL, ",") |
| atoi / atol / atof | Convierte el texto en un número int, long o double | atoi("128") → 128 |
| snprintf(buf, tamaño, ...) | Genera texto con formato, protegido contra desbordamiento | snprintf(buf, sizeof(buf), "%d", 42) |
| dtostrf(número, ancho, decimales, buf) | Convierte un float en texto (en AVR %f no funciona) | dtostrf(3.14159, 4, 2, buf) → "3.14" |
String en ESP32: ¿por qué es más cómodo y dónde hay que tener cuidado?
El ESP32 tiene 520 KB de SRAM, unas 260 veces la de la Uno. Por eso, en tareas con mucho texto, como un servidor web, JSON o mensajes MQTT, usar String es mucho más cómodo, y el analizador con String de arriba funciona tal cual en el ESP32 si pones LED_PIN a 4 y la velocidad a 115200 baudios. El String del núcleo del ESP32 guarda los textos cortos dentro del propio objeto, sin ir al montón, lo que reduce la fragmentación en etiquetas pequeñas. Como los textos constantes ya se leen de la flash, F() aquí no cambia nada; solo mantiene el código compatible con AVR. Aun así, en un servidor web que está encendido durante meses, generar String grandes en cada petición puede provocar fragmentación. Para vigilarlo, ESP.getFreeHeap() da la memoria libre total y ESP.getMaxAllocHeap() el mayor bloque continuo que se puede reservar; si la diferencia entre ambos crece con el tiempo, ha empezado la fragmentación.
1String satir; // global, tekrar kullanılır / global, reused
2
3void setup() {
4 Serial.begin(115200);
5 satir.reserve(96); // önceden yer ayır / pre-allocate
6 Serial.printf("Bos heap: %u bayt\n", (unsigned int)ESP.getFreeHeap());
7}
8
9void loop() {
10 static unsigned long son = 0;
11 if (millis() - son >= 2000) {
12 son = millis();
13 int ham = analogRead(34); // GPIO 34: yalnız giriş, ADC1 / input only, ADC1
14 satir = "t=";
15 satir += millis() / 1000;
16 satir += " s, adc=";
17 satir += ham;
18 satir += ", heap=";
19 satir += (unsigned long)ESP.getFreeHeap(); // toplam boş / total free
20 satir += ", blok=";
21 satir += (unsigned long)ESP.getMaxAllocHeap(); // en büyük blok / largest block
22 Serial.println(satir);
23 }
24}Procesar texto en Raspberry Pi Pico y MicroPython
En MicroPython el texto es de tipo str y, como en Python, es inmutable; cada operación produce un texto nuevo y el recolector de basura limpia los que ya no se usan. Como la Pico tiene 264 KB de RAM, tareas como analizar comandos no la exigen en absoluto. El equivalente de indexOf de String es find(), el de substring son los cortes (linea[0:3]), el de toInt es int() y el de trim es strip(). Lo más práctico es split(","), que divide el texto en partes en una sola línea. Con un texto no válido, int() no devuelve 0, sino que lanza un ValueError; esto es más seguro que la ambigüedad de toInt() en Arduino, pero tienes que capturar el error con try/except. Conecta el LED a GP15 con una resistencia de 220 Ω, ejecuta el código con Thonny y escribe los comandos en la ventana de la consola (Shell). Si programas la Pico con el IDE de Arduino, String y los arrays de char funcionan igual; la única diferencia es que la RAM sobra.
1import sys
2from machine import Pin, PWM
3
4led = PWM(Pin(15)) # GP15 + 220 ohm direnç / resistor
5led.freq(1000)
6
7print("Komutlar / Commands: LED,1 LED,0 PWM,0-255")
8
9while True:
10 satir = sys.stdin.readline().strip() # Enter'a kadar bekler / waits for Enter
11 if not satir:
12 continue
13 parcalar = satir.split(",") # "PWM,128" -> ["PWM", "128"]
14 komut = parcalar[0].upper()
15 try:
16 deger = int(parcalar[1]) if len(parcalar) > 1 else 0
17 except ValueError: # sayı değil / not a number
18 print("Gecersiz sayi / Invalid number:", parcalar[1])
19 continue
20 if komut == "LED":
21 led.duty_u16(65535 if deger else 0)
22 print("LED ->", "ACIK / ON" if deger else "KAPALI / OFF")
23 elif komut == "PWM":
24 deger = max(0, min(255, deger)) # 0-255 arasında tut / keep in 0-255
25 led.duty_u16(deger * 257) # 0-255 -> 0-65535
26 print("PWM ->", deger)
27 else:
28 print("Bilinmeyen komut / Unknown command:", komut)Ideas de proyectos con String y comunicación serie
- Control por Bluetooth: con un módulo Bluetooth HC-05, procesa con el mismo analizador los comandos "LED,1" o "SERVO,90" que llegan desde el móvil.
- Panel de control con Python: envía comandos desde un script de Python en el ordenador y recibe mediciones del Arduino; los detalles están en el artículo comunicación serie Arduino y Python.
- Mensajes entre dos Arduino: con la comunicación serie UART, una placa envía una medición y la otra analiza la línea "T,24" y la muestra en pantalla.
- Mensaje desplazable en el LCD: desplaza con substring() el texto que escribes por el puerto serie y muéstralo en una pantalla LCD I2C.
- Guarda los ajustes: guarda en la EEPROM el valor de umbral que llega con un comando como "ESIK,500"; así el ajuste no se pierde aunque la placa se reinicie.
- Registro de datos en Excel: envía los valores del sensor como líneas separadas por comas y expórtalos a Excel.
Errores frecuentes y soluciones
| Síntoma | Causa | Solución |
|---|---|---|
| El comando no se detecta nunca | El fin de línea está en No line ending o queda un '\r' al final del texto | Elige Newline y usa trim() |
| Un segundo de retraso en cada comando | readStringUntil() espera el tiempo de espera predeterminado de 1000 ms | Serial.setTimeout(50) o lectura carácter a carácter |
| "PWM,abc" apaga el LED | toInt() devuelve 0 con un texto no válido | Comprueba el primer carácter con isDigit() |
| == siempre da false con arrays de char | == compara direcciones, no contenido | Usa strcmp(a, b) == 0 |
| Caracteres sin sentido al final del texto | Falta '\0' en el array de char o el array es pequeño | Crea el array con la longitud del texto + 1 y termina con '\0' |
| Bloqueo o reinicio tras horas | Fragmentación del montón en la Uno, se agota la RAM | Usa reserve(), F() y arrays de char |
| snprintf muestra "?" en lugar del float | El soporte de %f está desactivado en AVR | Convierte con dtostrf() |
| length() da de más con texto con acentos | Letras como ñ, á, é ocupan 2 bytes en UTF-8 | Calcula según el número de bytes o usa ASCII |
Cuando entiendas la diferencia entre String y array de char, podrás procesar con seguridad cualquier comando del puerto serie, mensaje Bluetooth o línea de sensor. Para conocer mejor el Monitor Serie, consulta el artículo Arduino Serial Monitor, y para la lógica general de los arrays, Arduino arrays (matrices). En la aplicación BlueGrays puedes poner en práctica lo aprendido aquí probando, paso a paso y con esquemas y códigos, proyectos como encender un LED desde el móvil por Bluetooth, comunicación serie entre dos Arduino y mensajes en un LCD.
Preguntas frecuentes
¿Debo usar String o un array de char en Arduino?
En códigos de prueba cortos, en ESP32 y en Pico, usar String es rápido y legible. En placas con 2 KB de RAM como la Arduino Uno o la Nano, en un proyecto que va a funcionar durante días, un array de char de tamaño fijo es más seguro porque evita por completo la fragmentación de memoria. También puedes combinar ambos: la función c_str() de String te permite leerlo como un array de char.
¿Cómo se convierte un String a int en Arduino?
En un objeto String se usa texto.toInt(); el resultado es de tipo long y se leen los dígitos del comienzo del texto. Si el texto no contiene números devuelve 0, así que para distinguir un 0 real de una entrada errónea comprueba el primer carácter con isDigit(). Con un array de char hacen el mismo trabajo atoi(), atol() o strtol(), que ofrece control de errores.
¿Cómo se convierte un número a String en Arduino?
Lo más fácil es escribir String(numero); String(255, HEX) produce texto hexadecimal y String(3.14159, 2) un decimal con dos decimales. También puedes añadirlo directamente a un String existente con s += numero. Para un array de char se usan snprintf() o itoa(); en placas AVR, para los números float hace falta dtostrf().
¿Para qué sirve la macro F() de Arduino?
F() evita que los textos constantes que pasas a instrucciones como Serial.print() se copien en la RAM y hace que se lean desde la memoria flash. Como la Arduino Uno solo tiene 2 KB de RAM, en menús y mensajes largos ahorra cientos de bytes. En ESP32 y Pico los textos constantes ya se quedan en la flash, así que F() no cambia nada y solo existe por compatibilidad.
¿Cómo lee Arduino el texto que llega por el puerto serie?
El camino más corto es leer hasta el carácter Enter con Serial.readStringUntil('\n'); después debes limpiar '\r' y los espacios con trim(). Como esta función espera 1 segundo por defecto, conviene acortar el tiempo con Serial.setTimeout(). Si el programa no debe esperar nunca, lee los caracteres uno a uno con Serial.read(), acumúlalos en un array de char y procésalos cuando llegue '\n'.
¿Cómo se comparan dos String en Arduino?
En los objetos String, el operador == o equals() comparan el contenido; si no quieres distinguir mayúsculas de minúsculas, usa equalsIgnoreCase(). En los arrays de char, == solo compara direcciones de memoria y da un resultado erróneo; en su lugar debes escribir strcmp(a, b) == 0. Antes de comparar, no olvides borrar con trim() el carácter '\r' del final del texto.
Proyectos para hacer después de leer esto
Ver todos los proyectos
HC-SR04 Medición de distancia (pantalla en serie)
El sensor HC-SR04 funciona igual que un murciélago que se orienta en la oscuridad: emite un sonido que no puedes oír, escucha el eco y mide a qué distancia está el objeto que tiene delante.

Controlar un LED desde el móvil por Bluetooth
Un pequeño ensayo para encender y apagar las luces de tu habitación desde el móvil.

Comunicación unidireccional entre 2 Arduino
Haces que dos Arduino hablen por un solo cable: pulsas el botón de uno y se enciende el LED del otro, vuelves a pulsar y se apaga.

Comunicación bidireccional entre 2 Arduino
Dos Arduino se conectan con cables y hablan entre sí: pulsas el botón de uno y se enciende la luz del otro, lo pulsas otra vez y se apaga.

Mostrar un mensaje en una pantalla LCD 2x16
Tu primer paso para escribir texto en una pantalla. La pantalla LCD de dos líneas muestra primero un mensaje de espera, luego escribe un saludo en la línea de arriba y teclea una palabra letra a…

Uso de la pantalla LCD con I2C
Dale a tu Arduino su propia pantalla y haz que escriba su primer mensaje. La pantalla LCD de dos líneas se conecta con solo unos pocos cables; primero aparece un saludo en la línea de arriba, luego…

Teclado para desarrolladores de Python
Si te cansa escribir los mismos patrones una y otra vez mientras programas, este pequeño teclado está hecho para ti.

Coche controlado por Bluetooth con L298N
Convierte tu móvil en un mando y conduce tu propio coche robot. El Arduino recibe por un módulo Bluetooth las órdenes de una app de control remoto en el móvil y mueve las ruedas con un controlador de…
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

