Fundamentos · 12 min de lectura

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.

Placa Arduino Uno
Arduino Uno: su procesador ATmega328P tiene solo 2 KB de RAM, y ese límite es decisivo cuando trabajas con texto.

¿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ísticaStringArray de char
Facilidad de usoMuy fácil: +, ==, substring()Más difícil: strcat(), strcmp(), strtok()
Ubicación en memoriaMontón (heap), dinámicaFija; zona global o pila (stack)
TamañoCrece soloSe define de antemano
Riesgo de desbordamientoNo, pero si se acaba la memoria la operación falla en silencioSí; el control de límites lo haces tú
Riesgo de fragmentaciónSí (sobre todo en la Uno)No
Dónde encajaESP32, Pico, textos cortos y poco frecuentesProyectos que funcionan sin parar en Uno y Nano

Memoria según la plataforma y conexión de prueba

CaracterísticaArduino UnoESP32Raspberry Pi Pico
RAM2 KB SRAM520 KB SRAM264 KB SRAM
Memoria de programa32 KB flash4 MB flash externa (en la mayoría de placas)2 MB flash externa
Pin del LED de pruebaD9 (PWM) + 220 ΩGPIO 4 + 220 ΩGP15 + 220 Ω
Velocidad del puerto serie (en los ejemplos)9600 baudios115200 baudiosUSB (consola de Thonny)
Macro F()Ahorra RAMSin efecto, existe por compatibilidadNo existe (MicroPython)
Tipo de textoString y char[]String y char[]str (Python)
Si el ajuste de fin de línea, abajo a la derecha en el Monitor Serie, se queda en No line ending, al pulsar Enter no se envía el carácter '\n'; tu analizador, que espera el fin de línea, esperará hasta el tiempo de espera o no se activará nunca. Para los ejemplos de este artículo elige Newline o Both NL & CR. Con la segunda opción, el carácter '\r' que llega se pega al final del texto; por eso en los códigos usamos trim() o ignoramos '\r'.

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.

C++ (Arduino IDE)
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ónQué haceEjemplo (s = "LED,128")
s.length()Devuelve el número de caracteres7
s.indexOf(',')Posición de la primera coincidencia, o -1 si no hay3
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álido128
s.startsWith("LED")¿Empieza con este texto?true
s.equalsIgnoreCase("led,128")Compara sin distinguir mayúsculas de minúsculastrue
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 charstrcmp(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 situs ahora es "LED;128"
Cuidado al añadir un número a un texto: la línea String s = "Valor: " + 5; compila, pero no funciona como esperas. Aquí no hay ningún objeto String; el compilador suma 5 a la dirección del texto "Valor: " y en s se guarda un trozo sin sentido como ": ". En el extremo izquierdo de la cadena tiene que haber siempre un String: escribe String s = String("Valor: ") + 5; o primero String s = "Valor: "; y luego añade s += 5;.

Analizar comandos del puerto serie paso a paso

  1. 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.
  2. 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.
  3. Lee la línea del puerto serie hasta el carácter Enter ('\n') y limpia los caracteres invisibles con trim().
  4. Con indexOf(',') localiza la coma; con substring() separa lo anterior a la coma como comando y lo posterior como valor.
  5. Convierte el valor en número con toInt(), pasa el comando a mayúsculas con toUpperCase(), compáralo y ejecuta la acción correspondiente.
  6. Después de cada comando, imprime una respuesta corta en el Monitor Serie; así ves enseguida si el comando se ha entendido.
C++ (Arduino IDE)
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().

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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ónQué haceEjemplo
strlen(s)Devuelve el número de caracteres sin contar '\0'strlen("LED") → 3
strncpy(destino, origen, n)Copia como máximo n caracteresstrncpy(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 igualesstrcmp(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 / atofConvierte el texto en un número int, long o doubleatoi("128") → 128
snprintf(buf, tamaño, ...)Genera texto con formato, protegido contra desbordamientosnprintf(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.

C++ (Arduino IDE)
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.

MicroPython
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íntomaCausaSolución
El comando no se detecta nuncaEl fin de línea está en No line ending o queda un '\r' al final del textoElige Newline y usa trim()
Un segundo de retraso en cada comandoreadStringUntil() espera el tiempo de espera predeterminado de 1000 msSerial.setTimeout(50) o lectura carácter a carácter
"PWM,abc" apaga el LEDtoInt() devuelve 0 con un texto no válidoComprueba el primer carácter con isDigit()
== siempre da false con arrays de char== compara direcciones, no contenidoUsa strcmp(a, b) == 0
Caracteres sin sentido al final del textoFalta '\0' en el array de char o el array es pequeñoCrea el array con la longitud del texto + 1 y termina con '\0'
Bloqueo o reinicio tras horasFragmentación del montón en la Uno, se agota la RAMUsa reserve(), F() y arrays de char
snprintf muestra "?" en lugar del floatEl soporte de %f está desactivado en AVRConvierte con dtostrf()
length() da de más con texto con acentosLetras como ñ, á, é ocupan 2 bytes en UTF-8Calcula según el número de bytes o usa ASCII
Si no te decides por uno de los dos caminos, aplica una regla sencilla: en la Uno y la Nano, array de char y F() para el código que funciona sin parar; String para el código de pruebas y para ESP32 y Pico. Fíjate también en la línea "Global variables use ... bytes" que escribe el IDE de Arduino al terminar de compilar; en la Uno, si ese porcentaje supera el 75 %, el IDE avisa de poca memoria. Para más detalles sobre problemas de memoria, echa un vistazo al artículo Arduino sin memoria suficiente.

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.

Ver todos los proyectos
HC-SR04 Medición de distancia (pantalla en serie)
AR-27Principiante

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.

4.6(50)
82
Controlar un LED desde el móvil por Bluetooth
AR-34Principiante
Premium

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.

4.8(69)
91
Comunicación unidireccional entre 2 Arduino
AR-57Intermedio
Premium

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.

4.4(37)
50
Comunicación bidireccional entre 2 Arduino
AR-58Intermedio
Premium

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.

4.5(20)
26
Mostrar un mensaje en una pantalla LCD 2x16
AR-29Avanzado
Premium

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…

4.6(37)
51
Uso de la pantalla LCD con I2C
AR-32Principiante
Premium

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…

4.8(53)
70
Teclado para desarrolladores de Python
AR-66Intermedio
Premium

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.

4.6(35)
45
Coche controlado por Bluetooth con L298N
AR-80Avanzado
Premium

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…

5.0(39)
66