Cadenas en Arduino: texto que puedes unir, comparar y desarmar
Principiante
- 526componentes en el banco de trabajo
- 46placas funcionando ahora
- 1.00xtiempo real, en todas las placas
Arduino tiene dos tipos de texto. Un String, con S mayúscula, es un objeto que crece según lo necesites: une dos con +, compáralos con == y convierte "42" en el número 42 con toInt(). Un arreglo de char, como char name[] = "Mokxi";, es el tipo antiguo de C: una fila de caracteres que termina en un byte cero. La mayoría de los principiantes quieren String; la mayoría de las bibliotecas te dan arreglos de char.
El circuito de arriba es un LCD de 16 por 2 en un Uno. Presiona Ejecutar. La línea de arriba dice "Mokxi LCD1602" y la línea de abajo hace pasar "Hello from the Uno!" por la pantalla, una letra a la vez. El mensaje es un arreglo de char, y el sketch lo imprime desde una letra inicial distinta cada 300 ms.
Abajo verás cómo construir, unir, convertir, comparar y dividir Strings, los cuatro errores que imprimen algo equivocado o detienen la compilación, y cómo se organiza un arreglo de char, cada uno ejecutado en un Uno con lo que imprimió.
El mensaje que se desplaza es un arreglo de letras
Aquí está el sketch que corre arriba. MESSAGE guarda 22 letras y espacios, y el compilador agrega un byte cero al final, así que sizeof(MESSAGE) - 1 es la cantidad de letras. En cada vuelta, el loop imprime 16 de ellas empezando en start, y % length regresa al principio, así que el final del mensaje se empalma con su inicio.
Cambia el texto entre las comillas y presiona Ejecutar, y el LCD desplazará tus palabras. Deja los tres espacios del final; son el hueco antes de que vuelva a empezar.
const char MESSAGE[] = "Hello from the Uno! ";
int start = 0;
void setup() {
lcd.begin(16, 2);
lcd.print("Mokxi LCD1602");
Serial.begin(9600);
Serial.println("Mokxi Uno: LCD1602 on pins 4, 6 and 10 to 13");
}
void loop() {
int length = sizeof(MESSAGE) - 1;
lcd.setCursor(0, 1);
for (int i = 0; i < 16; i++) lcd.print(MESSAGE[(start + i) % length]);
start = (start + 1) % length;
delay(300);
}Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.
Crear un String y unirlo
Un String se crea a partir de texto entre comillas dobles, y + lo une con más texto, otro String o un número envuelto en String(). El sketch de abajo imprimió "Hello, Mokxi!" y su length(), 13. += agrega al final de un String que ya tienes: "Count: 5" se convirtió en "Count: 5 lamps".
String() también escribe los números como se lo pidas. String(3.14159, 3) imprimió 3.142, con tres decimales. String(255, HEX) imprimió ff y String(5, BIN) imprimió 101, lo cual sirve para mostrar el registro de un sensor o los bits de un byte.
void setup() {
Serial.begin(9600);
String name = "Mokxi";
String greeting = "Hello, " + name + "!";
Serial.println(greeting);
Serial.println(greeting.length());
int count = 5;
String line = "Count: " + String(count);
Serial.println(line);
line += " lamps";
Serial.println(line);
Serial.println(String(3.14159, 3));
Serial.println(String(255, HEX));
Serial.println(String(5, BIN));
}
void loop() {
}Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.
El + que no une
El + solo une cuando un lado es un String. El texto entre comillas por sí solo es un arreglo de char, y sumarle un número a eso avanza sobre él. String line = "Count: " + count; con count en 5 se saltó las primeras cinco letras e imprimió ": ". Clang advirtió: adding 'int' to a string does not append to the string. La solución es la de arriba: "Count: " + String(count).
Dos fragmentos de texto entre comillas no se pueden sumar en absoluto. String both = "Hello" + "World"; detuvo la compilación: clang dice invalid operands to binary expression ('const char[6]' and 'const char[6]'), y el GCC del Arduino IDE dice invalid operands of types 'const char [6]' and 'const char [6]' to binary 'operator+'. Convierte el primero en un String, String("Hello") + "World", y el resto sigue.
Las comillas también importan. Las comillas simples son para un solo carácter, 'A'. String s = 'hi'; detuvo la compilación con no viable conversion from 'int' to 'String', tras una advertencia sobre una constante de carácter múltiple. El texto siempre va entre comillas dobles.
De String a int, y de regreso
toInt() lee el número al inicio de un String. String a = "42"; y luego a.toInt() + 1 imprimió 43. Se detiene en el primer carácter que no es parte de un número, así que "12abc" dio 12; se salta los espacios al inicio, así que " 7" dio 7; y da 0 cuando no hay ningún número: "abc" dio 0. toFloat() hace lo mismo con decimales, y "3.75" al duplicarse imprimió 7.50.
toInt() devuelve un long, así que puede leer números grandes, pero la variable donde lo guardes también tiene que ser suficientemente grande. "99999" imprimió 99999 directamente de toInt(), y -31073 una vez guardado en un int, que en un Uno llega hasta 32767. Guárdalo en un long. Al revés, un número se convierte en String con String(42).
void setup() {
Serial.begin(9600);
String a = "42";
Serial.println(a.toInt() + 1);
Serial.println(String("12abc").toInt());
Serial.println(String("abc").toInt());
Serial.println(String(" 7").toInt());
String t = "3.75";
float f = t.toFloat();
Serial.println(f * 2);
Serial.println(String("99999").toInt());
int n = String("99999").toInt();
Serial.println(n);
}
void loop() {
}Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.
Comparar Strings y arreglos de char
== compara dos Strings letra por letra, y las mayúsculas cuentan: "ON" == "on" imprimió 0, falso. equalsIgnoreCase() imprimió 1, o llama primero a toLowerCase() en el String y luego compara. compareTo() ordena las palabras alfabéticamente: "apple" comparada con "banana" da menos que cero.
Con arreglos de char, == no compara las letras en absoluto; pregunta si están guardadas en el mismo lugar. char word[] = "on"; y luego if (word == "on") imprimió "different". Clang advirtió: result of comparison against a string literal is unspecified (use an explicit string comparison function instead). Esa función es strcmp(), que devuelve 0 cuando los dos coinciden: strcmp(word, "on") == 0 imprimió "strcmp: same".
void setup() {
Serial.begin(9600);
String cmd = "ON";
Serial.println(cmd == "on");
Serial.println(cmd.equalsIgnoreCase("on"));
cmd.toLowerCase();
Serial.println(cmd == "on");
char word[] = "on";
if (word == "on") Serial.println("same");
else Serial.println("different");
if (strcmp(word, "on") == 0) Serial.println("strcmp: same");
}
void loop() {
}Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.
Dividir una línea: indexOf() y substring()
Un sensor u otra placa a menudo envía varios valores en una sola línea separados por comas, como "21.5,48,1013". indexOf(',') encuentra dónde está la primera coma, aquí 4, y indexOf(',', first + 1) encuentra la siguiente después de esa. substring(from, to) recorta la parte de en medio, desde from hasta pero sin incluir to, y toFloat() o toInt() convierte cada parte en un número. El sketch de abajo imprimió 21.50, 48 y 1013.
indexOf() devuelve -1 cuando no encuentra nada, así que verifica eso antes de recortar. Algunos más que suelen aparecer: charAt(0) o data[0] es un carácter, replace("l", "L") convirtió "Hello" en "HeLLo", toUpperCase() lo dejó en "HELLO", y trim() quita los espacios y los saltos de línea de ambos extremos, lo cual, como muestra la página de lectura serie, a menudo es lo que necesita una comparación.
void setup() {
Serial.begin(9600);
String data = "21.5,48,1013";
int first = data.indexOf(',');
int second = data.indexOf(',', first + 1);
float temp = data.substring(0, first).toFloat();
int humidity = data.substring(first + 1, second).toInt();
long pressure = data.substring(second + 1).toInt();
Serial.println(temp);
Serial.println(humidity);
Serial.println(pressure);
}
void loop() {
}Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.
Arreglos de char y el cero del final
char name[] = "Mokxi"; guarda cinco letras y un byte más, un cero, que marca el final. sizeof(name) imprimió 6 y strlen(name), que cuenta hasta el cero, imprimió 5. Cada letra es una entrada como en cualquier arreglo: name[0] imprimió M, y tras name[0] = 'm'; el nombre imprimió "mokxi".
Un String y un arreglo de char se convierten en ambos sentidos. String s = name; crea un String a partir del arreglo, y s.c_str() pasa un String a una función que quiere un arreglo de char, como lo hacen muchas funciones de biblioteca.
Un String guarda sus letras en memoria que pide mientras el sketch corre, y la devuelve cuando termina. En un Uno, con 2048 bytes de RAM para todo, un sketch que construye Strings largos una y otra vez en loop() puede quedarse sin memoria tras horas de ejecución. Para mensajes cortos no hay de qué preocuparse. Para un sketch que corre durante días, guarda el texto en arreglos de char o llama una vez a reserve() en setup(); la página de memoria baja tiene el resto.
Abre este circuito en el editor. Arduino Uno: un mensaje desplazándose en un LCD 16x2, cableado tal como corre en la parte superior de esta página. Cambia un componente o un valor y ejecútalo de nuevo.
Abrir el circuitoPreguntas
¿Cuál es la diferencia entre String y string en Arduino?
String con S mayúscula es el objeto de Arduino que puedes unir con +, comparar con == y convertir con toInt(). Una string con s minúscula normalmente significa un arreglo de chars, como char name[] = "Mokxi";, una fila de caracteres que termina en un byte cero.
¿Cómo convierto un String a un int en Arduino?
Llama toInt() sobre él: String("42").toInt() es 42. Devuelve un long y da 0 cuando el texto no empieza con un número. Usa toFloat() para decimales.
¿Cómo uno un String y un número?
Envuelve el número en String(): "Count: " + String(count). Sin eso, "Count: " + count avanza a lo largo del texto count letras en vez de unir, e imprime parte de él.
¿Cómo comparo dos strings en Arduino?
Dos Strings se comparan con ==, y las mayúsculas cuentan; usa equalsIgnoreCase() para ignorarlas. Para arreglos de chars usa strcmp(a, b) == 0, porque == sobre arreglos de chars compara dónde están guardados, no lo que dicen.
¿Cómo divido un String por comas?
Busca cada coma con indexOf(','), corta las piezas con substring() y conviértelas con toInt() o toFloat(). El ejemplo de esta página lee tres valores de "21.5,48,1013".
¿Cómo obtengo la longitud de un String en Arduino?
`s.length()` cuenta los caracteres: "Hello" con " world" agregado imprimió 11. Para un arreglo de chars, `strlen(c)` también da 11, mientras que `sizeof(c)` da 12, porque también cuenta el byte cero que termina el texto.
Sigue así
De dónde vienen los datos de esta página
Ármalo en la vida real
Abre el editor, cambia un valor y mira cómo cambia el número con él. Nada que instalar y sin necesidad de cuenta.