Arduino strtok: cómo dividir texto y analizar comandos serie
- 526componentes en el banco de trabajo
- 46placas funcionando ahora
- 1.00xtiempo real, en todas las placas
strtok() divide un arreglo de char en piezas en los caracteres que tú indiques, como comas o espacios. La primera llamada recibe el arreglo, cada llamada siguiente recibe NULL y continúa donde se quedó la última, y devuelve NULL cuando ya no queda nada. Funciona con texto de C puro en lugar de un String, así que usa poca memoria y va bien con las líneas cortas que envía un sensor o el monitor serie.
El circuito de arriba es un Uno que hace eco de lo que escribes, un byte a la vez. Al escribir "on" y Enter, imprimió "you typed: o (0x6F)", "you typed: n (0x6E)" y "you typed: <newline>". Los bytes llegan uno por uno, así que un sketch primero los reúne en una línea y solo entonces la divide.
Abajo verás cómo dividir valores separados por comas en números, qué le hace strtok a tu arreglo, por qué un String necesita una copia, un analizador de comandos que enciende LEDs, y strtok_r para una división dentro de otra. Para dividir un String con indexOf() y substring() en su lugar, consulta la página de String.
¿Quieres la versión paso a paso? La lección "Tomando comandos" recorre esto con puntos de control.
Abrir la lecciónDividir valores separados por comas en un arreglo
Llama strtok(line, ",") una vez para la primera pieza, luego strtok(NULL, ",") en un bucle hasta que devuelva NULL, convirtiendo cada pieza con atof() para decimales o atoi() para enteros. El sketch de abajo imprimió "3 values", luego "21.50", "48.00" y "1013.00".
Detente en el tamaño de tu arreglo, como hace el count < 3: una línea con más comas de las esperadas no debe escribir más allá del final.
The last line shows what strtok leaves behind. It printed "line is now: 21.5". strtok writes a zero over each comma it finds, so the array now ends after the first piece. Copy the line first if you need it again.
void setup() {
Serial.begin(9600);
char line[] = "21.5,48,1013";
float values[3];
int count = 0;
char *piece = strtok(line, ",");
while (piece != NULL && count < 3) {
values[count] = atof(piece);
count++;
piece = strtok(NULL, ",");
}
Serial.print(count);
Serial.println(" values");
for (int i = 0; i < count; i++) {
Serial.println(values[i]);
}
Serial.print("line is now: ");
Serial.println(line);
}
void loop() {
}Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.
Los campos vacíos desaparecen
strtok trata una seguidilla de comas como una sola, así que un campo vacío se salta en lugar de devolverse vacío. El mismo sketch con "5,,7" imprimió "2 values", 5.00 y 7.00: el 7 pasó al segundo lugar. Cuando un campo puede quedar en blanco, revisa el conteo, o envía un 0 en lugar de nada.
strtok necesita un arreglo de char, no un String
strtok changes the text it splits, so it takes a char *. Giving it a String’s text with strtok(line.c_str(), ",") stopped the build with no matching function for call to 'strtok', and the note says 1st argument ('const char *') would lose const qualifier: c_str() is read only. The Arduino IDE’s GCC says invalid conversion from 'const char*' to 'char*'.
Copia primero el String en un arreglo de char con toCharArray(). El sketch de abajo imprimió "21.5" y "48". Un texto entre comillas escrito directo en la llamada, strtok("21.5,48", ","), solo dio una advertencia, ISO C++11 does not allow conversion from string literal to 'char *', y la de GCC es ISO C++ forbids converting a string constant to 'char*'. Aquí corrió e imprimió 21.5, pero no confíes en ello: el texto entre comillas debe quedarse tal cual, y strtok escribe en él.
void setup() {
Serial.begin(9600);
String line = "21.5,48";
char buf[32];
line.toCharArray(buf, sizeof(buf));
char *piece = strtok(buf, ",");
while (piece != NULL) {
Serial.println(piece);
piece = strtok(NULL, ",");
}
}
void loop() {
}Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.
Un analizador de comandos serie
El sketch de abajo reúne bytes en un búfer de 32 bytes hasta un salto de línea, luego divide la línea en espacios en un comando y dos argumentos, y compara el comando con strcmp(). Entiende "led 13 on", "led 12 off" y "blink 11 3". Cualquier otra cosa también recibe respuesta, así que un error de escritura nunca pasa en silencio.
Escribimos cinco líneas: led 13 on, led 12 on, led 13 off, blink 11 3 y hello. Imprimió "pin 13 on", "pin 12 on", "pin 13 off", "blinked 3 times" y "unknown: hello", y dejó encendido el LED del pin 12. La comprobación len < sizeof(buf) - 1 descarta lo que pase de 31 caracteres en lugar de escribir fuera del búfer, y la prueba de \r hace que funcione con cualquier final de línea que envíe el monitor. Para aceptar comas además de espacios entre las palabras, dale a strtok " ," como separadores en lugar de " ".
char buf[32];
byte len = 0;
void setup() {
Serial.begin(9600);
pinMode(13, OUTPUT);
pinMode(12, OUTPUT);
pinMode(11, OUTPUT);
Serial.println("ready");
}
void runCommand(char *line) {
char *cmd = strtok(line, " ");
char *arg1 = strtok(NULL, " ");
char *arg2 = strtok(NULL, " ");
if (cmd == NULL) return;
if (strcmp(cmd, "led") == 0 && arg1 && arg2) {
int pin = atoi(arg1);
digitalWrite(pin, strcmp(arg2, "on") == 0 ? HIGH : LOW);
Serial.print("pin ");
Serial.print(pin);
Serial.print(" ");
Serial.println(arg2);
} else if (strcmp(cmd, "blink") == 0 && arg1 && arg2) {
int pin = atoi(arg1);
int times = atoi(arg2);
for (int i = 0; i < times; i++) {
digitalWrite(pin, HIGH);
delay(100);
digitalWrite(pin, LOW);
delay(100);
}
Serial.print("blinked ");
Serial.print(times);
Serial.println(" times");
} else {
Serial.print("unknown: ");
Serial.println(cmd);
}
}
void loop() {
while (Serial.available() > 0) {
char c = Serial.read();
if (c == '\r') continue;
if (c == '\n') {
buf[len] = '\0';
runCommand(buf);
len = 0;
} else if (len < sizeof(buf) - 1) {
buf[len++] = c;
}
}
}Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.
Una división dentro de otra: strtok_r
strtok recuerda su lugar en una variable oculta, así que solo puede avanzar por una línea a la vez. Dividir "temp=21;hum=48;lux=310" en punto y coma, y cada par en el signo igual también con strtok, imprimió "temp -> 21" y se detuvo: las llamadas internas perdieron el lugar de la externa.
strtok_r recibe el lugar como tercer argumento, así que cada nivel conserva el suyo. La versión de abajo imprimió "temp -> 21", "hum -> 48" y "lux -> 310". Usa strtok_r siempre que una función que divide texto pueda llamarse dentro de otra división.
void setup() {
Serial.begin(9600);
char line[] = "temp=21;hum=48;lux=310";
char *outer;
char *pair = strtok_r(line, ";", &outer);
while (pair != NULL) {
char *inner;
char *key = strtok_r(pair, "=", &inner);
char *value = strtok_r(NULL, "=", &inner);
Serial.print(key);
Serial.print(" -> ");
Serial.println(atoi(value));
pair = strtok_r(NULL, ";", &outer);
}
}
void loop() {
}Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.
Abre este circuito en el editor. Arduino Uno: eco de lo que envía el monitor serie, cableado tal como corre arriba en esta página. Cambia un componente o un valor y ejecútalo de nuevo.
Preguntas
¿Cómo funciona strtok en Arduino?
The first call, strtok(line, ","), returns the first piece of a char array; each later call, strtok(NULL, ","), returns the next, and NULL means there are no more. It replaces each separator in the array with a zero as it goes.
¿Puedo usar strtok con un String?
No directamente: c_str() es de solo lectura y strtok escribe en el texto, así que la compilación se detiene. Copia el String en un arreglo de char con toCharArray() y divide ese.
¿Por qué strtok se salta mi campo vacío?
Trata dos separadores seguidos como uno, así que "5,,7" da dos piezas, no tres. Revisa cuántas piezas regresaron, o envía un 0 para un valor faltante.
¿Cómo analizo comandos del monitor serie?
Collect bytes into a char array until a newline, end it with a zero, split it at spaces with strtok, and compare the first piece with strcmp(). The parser on this page does it for LED commands.
¿Cuál es la diferencia entre strtok y strtok_r?
strtok guarda su lugar en una variable oculta, así que dos divisiones a la vez interfieren entre sí. strtok_r recibe el lugar como argumento, así que una división dentro de otra sí funciona.
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.