Aprender

Leer el monitor serie en un Arduino

O mira todas las lecciones.

  • 526componentes en el banco de trabajo
  • 46placas funcionando ahora
  • 1.00xtiempo real, en todas las placas
Arduino Uno: comandos desde el monitor serieen vivo0.000 s 0.00x
Haz clic para abrirlo en el editor
Escribe o, f o b en el monitor serie y presiona Enter: on, off o blink, con respuesta cada vez.

Para leer lo que escribes en el monitor serie, revisa Serial.available() para ver si algo ha llegado, y luego llama a Serial.read() para tomar un carácter. if (Serial.available() > 0) { char c = Serial.read(); } es todo el patrón, y permite que un sketch reciba comandos de tu teclado mientras sigue con todo lo demás.

El circuito de arriba es un Uno con un LED en el pin 13, atento a tres comandos. Presiona Ejecutar, haz clic en la caja debajo del monitor serie, escribe o y presiona Enter. Responde "ok: on" y la lámpara se enciende. Escribe b para "ok: blink", f para "ok: off", y cualquier otra cosa para "unknown command: x", con tu letra en lugar de la x.

Below is what Serial.read() really hands you, reading a whole line, reading a number, and the one bug everyone meets with parseInt(): the extra 0 that turns up a second after the number you typed.

¿Quieres la versión paso a paso? La lección "Tomando comandos" recorre esto con puntos de control.

Abrir la lección

available() y read()

Serial.available() devuelve cuántos caracteres han llegado y están en espera. No espera nada. Serial.read() toma el más antiguo y lo devuelve, o -1 si no hay nada ahí; sin nada escrito, nuestro sketch imprimió -1 y un available() de 0. Ninguna de las dos llamadas espera jamás, así que el parpadeo del sketch de arriba sigue corriendo mientras escucha.

Escribe "hi" y presiona Enter, e imprime cada carácter como número en lugar de letra, y la placa imprimió 104 105 10. Son los códigos de h e i, y luego un 10, que es el salto de línea. El monitor serie del IDE de Arduino tiene un menú Line ending que decide qué envía después de tu texto; el monitor de Mokxi siempre envía un salto de línea, igual que la opción New Line del IDE. Por eso el sketch de arriba omite '\n' y '\r' en lugar de responder "unknown command".

firmware/uno/examples/commands (la mitad de lectura del sketch de arriba)
  while (Serial.available() > 0) {
    int c = Serial.read();
    if (c == '\n' || c == '\r') continue;
    if (c == 'o') {
      mode = ON;
      Serial.println("ok: on");
    } else if (c == 'f') {
      mode = OFF;
      Serial.println("ok: off");
    } else if (c == 'b') {
      mode = BLINK;
      Serial.println("ok: blink");
    } else {
      Serial.print("unknown command: ");
      Serial.println((char)c);
    }
  }

Leer una línea completa

Para comandos de más de una letra, lee hasta el salto de línea con Serial.readStringUntil('\n'). Reúne caracteres en un String hasta encontrar un salto de línea, lo quita y devuelve el resto. Al escribir "hello", el sketch de abajo imprimió "[hello] 5": cinco letras, sin salto de línea al final.

Si no llega nada, readStringUntil() espera hasta un segundo por el siguiente carácter, luego se rinde y devuelve lo que tiene. Llámalo solo cuando available() indique que hay algo, como abajo, y la espera nunca será mayor que el tiempo que tarda en llegar una línea.

Con la línea en un String, el resto es código común. if (line == "on") la compara, line.startsWith("speed ") revisa cómo empieza, y line.substring(6).toInt() convierte el resto en un número, así que un comando como speed 120 no necesita más de tres líneas para leerse.

If your sketch compares a line with == and it never matches on a real board, check the IDE’s Line ending menu. With Both NL & CR it sends a carriage return before the newline, and that carriage return stays on the end of the line. We sent "on" that way: the line was 3 characters long and line == "on" was false. After line.trim(); it was 2 characters and true. Mokxi’s monitor sends no carriage return, so this one only shows up on the bench, which is a good reason to call trim() anyway.

Leer hasta el salto de línea
void setup() {
  Serial.begin(9600);
}

void loop() {
  if (Serial.available() > 0) {
    String line = Serial.readStringUntil('\n');
    Serial.print("[");
    Serial.print(line);
    Serial.print("] ");
    Serial.println(line.length());
  }
}

Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.

Read a number, and the 0 a second later

Serial.parseInt() salta todo lo que no sea un dígito, lee un número completo y lo devuelve como long. Es la forma más rápida de escribir un número, y tiene una trampa. Ejecuta el sketch de abajo, escribe 42 y presiona Enter. Imprimió "got 42 at 502", y luego, un segundo después, "got 0 at 1502", un número que nunca escribiste.

Here is why. parseInt() stops at the first character that is not a digit and leaves it waiting, so the newline is still there. Next time round, available() is 1, so parseInt() runs again, skips the newline, finds nothing more, waits its one-second timeout and returns 0. Call Serial.setTimeout(50); in setup() and the 0 arrives sooner, at 552 ms, but it still arrives.

La solución es leer primero la línea y convertirla en número después. Con String line = Serial.readStringUntil('\n'); int n = line.toInt(); el mismo 42 imprimió "got 42 at 502" y nada más. parseInt() sigue siendo útil para dos números en una línea. Al escribir "12 30", dos llamadas seguidas imprimieron "42 at 505", la suma, y luego "0 at 2505": el salto de línea sobrante inició otra ronda, y ambas llamadas esperaron su segundo completo.

parseInt() and its extra 0
void setup() {
  Serial.begin(9600);
}

void loop() {
  if (Serial.available() > 0) {
    int n = Serial.parseInt();
    Serial.print("got ");
    Serial.print(n);
    Serial.print(" at ");
    Serial.println(millis());
  }
}

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: comandos desde el monitor serie, conectado tal como se ejecuta al principio de esta página. Cambia un componente o un valor y ejecútalo de nuevo.

Preguntas

¿Por qué Serial.parseInt() devuelve 0?

Porque el salto de línea enviado después de tu número todavía está en espera. El siguiente parseInt() lo salta, no encuentra dígitos, espera su tiempo límite de un segundo y devuelve 0. Mejor lee la línea con readStringUntil('\n') y conviértela con toInt().

¿Qué devuelve Serial.read() cuando no se ha enviado nada?

-1. Revisa primero Serial.available(), y llama a read() solo cuando sea mayor que 0.

¿Por qué mi entrada tiene un carácter extra al final?

El monitor serie envía un fin de línea después de tu texto: un salto de línea, un retorno de carro o ambos, según su configuración de fin de línea. readStringUntil('\n') quita el salto de línea pero conserva el retorno de carro. Llama a trim() sobre el String para eliminarlo.

¿Serial.read() espera una entrada?

No. Devuelve de inmediato el siguiente carácter o -1. readString(), readStringUntil() y parseInt() sí esperan, hasta el tiempo límite definido por Serial.setTimeout(), que es de 1000 ms salvo que lo cambies.

¿Puedo probar la entrada serie sin una placa?

Sí. El monitor serie de Mokxi envía a la placa simulada lo que escribes, seguido de un salto de línea, así que cada sketch de esta página se ejecuta en el navegador como lo haría en un Uno.

¿Cómo leo una cadena serie en un arreglo de char?

`int n = Serial.readBytesUntil('\n', buf, sizeof(buf) - 1);` copies everything up to the newline into buf and returns how many characters it copied. It does not end the text with a zero, so write `buf[n] = 0;` next. Typed hello, the sketch printed "got 5 bytes: hello".

Á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.