Aprender

Serial.print() y println() de Arduino, línea por línea

O mira todas las lecciones.

  • 526componentes en el banco de trabajo
  • 46placas funcionando ahora
  • 1.00xtiempo real, en todas las placas
Arduino Uno: imprimir en el monitor serieen vivo0.000 s 0.00x
Haz clic para abrirlo en el editor
Un saludo, pi con cinco decimales, el tiempo encendido una vez por segundo, y un eco de lo que escribas.

Serial.print(x) envía x al monitor serie y se queda en la misma línea. Serial.println(x) hace lo mismo y luego termina la línea, así que lo siguiente que se imprima empieza en una nueva. Llama a Serial.begin(9600) una sola vez en setup() primero, y configura el monitor serie a la misma velocidad.

El circuito de arriba es un Uno solo, comunicándose con el monitor serie. Presiona Ejecutar. Imprime "Mokxi Arduino Uno: serial example", luego "pi to five places is 3.14159", luego "up 1000 ms", "up 2000 ms" y así, una vez por segundo. Escribe una letra en la caja debajo del monitor y presiona Enter: una A vuelve como "you typed: A (0x41)", y el Enter como "you typed: <newline>".

Abajo verás en qué se diferencian print y println byte por byte, cómo elegir decimales y bases numéricas, la manera incorrecta de imprimir texto y un número juntos, y cuánto tiempo cuesta imprimir, cada uno ejecutado en un Uno con lo que imprimió.

¿Quieres la versión paso a paso? La lección "Haciendo que la placa hable" recorre esto con puntos de control.

Abrir la lección

El sketch

Aquí está el setup() del sketch que corre arriba. Serial.begin(115200) abre el puerto a 115200 baudios. print() escribe "pi to five places is " y deja la línea abierta, y println(3.14159265, 5) agrega el número con cinco decimales y termina la línea.

Si imprimes antes de Serial.begin(), no sale nada. Imprimimos "before begin" primero y "after begin" después, y solo llegó "after begin".

firmware/uno/examples/serial (el setup() que corre arriba)
void setup() {
  Serial.begin(115200);
  Serial.println("Mokxi Arduino Uno: serial example");
  Serial.print("pi to five places is ");
  Serial.println(3.14159265, 5);
}

print contra println

Tres print y un println, print("a"), print("b"), println("c"), imprimieron "abc" en una línea, y el siguiente println empezó una nueva. El final de línea que agrega println son dos bytes, un retorno de carro y un salto de línea, \r\n. El monitor serie los oculta; un programa que lea el puerto, u otra placa, ve ambos.

Serial.println() sin nada entre los paréntesis solo termina la línea, lo cual es útil después de una serie de print.

Una línea de cuatro llamadas
void setup() {
  Serial.begin(9600);
  Serial.print("a");
  Serial.print("b");
  Serial.println("c");
  Serial.println("next 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.

Decimales, HEX y BIN

Un float se imprime con dos decimales, salvo que digas otra cosa. Serial.println(3.14159) imprimió 3.14. Indica la cantidad de decimales como segundo valor: println(3.14159, 4) imprimió 3.1416, redondeado, y println(2.0 / 3, 3) imprimió 0.667. Con 0 decimales redondea a un número entero, los medios hacia arriba: 1.5 imprimió 2 y 2.5 imprimió 3.

Para un número entero, el segundo valor es la base. println(255, HEX) imprimió FF y println(5, BIN) imprimió 101, sin ceros a la izquierda, así que agrégaselos tú si quieres los ocho bits. Un número negativo en HEX muestra los cuatro bytes de un long: -1 imprimió FFFFFFFF.

Decimales y bases
void setup() {
  Serial.begin(9600);
  Serial.println(3.14159);
  Serial.println(3.14159, 4);
  Serial.println(2.0 / 3, 3);
  Serial.println(1.5, 0);
  Serial.println(2.5, 0);
  Serial.println(255, HEX);
  Serial.println(5, BIN);
  Serial.println(-1, HEX);
}

void loop() {
}

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

Números, letras y write()

print() decide cómo mostrar algo según su tipo. println(65) imprimió 65, println('A') imprimió A, y un bool imprimió 1. Serial.write(65) es diferente: envía el byte en sí, y el monitor muestra el carácter con ese código, una A. Usa print() para las personas y write() para enviar bytes crudos a otro dispositivo.

print() también devuelve cuántos caracteres envió. int n = Serial.print("hello"); dio 5.

Texto y un número en una línea

La forma rápida que no funciona: Serial.println("Temp: " + t); con t en 21 imprimió unos símbolos extraños. Sumar un número a un texto entre comillas avanza sobre el texto en lugar de unirlo, y a 21 letras de "Temp: " ya se pasó el final. Clang advirtió: adding 'int' to a string does not append to the string. La forma sencilla son dos llamadas, Serial.print("Temp: "); y luego Serial.println(t);, y "Temp: " + String(t) también funciona; ambos imprimieron "Temp: 21".

Quien conoce C recurre a sprintf(). Funciona con números enteros: "%02d:%02d" con 7 y 5 imprimió 07:05. En un Uno no maneja floats: %f imprimió "t=?", porque el printf pequeño del Uno deja fuera los floats. Usa dtostrf(t, 6, 2, buf), que imprimió " 21.50", o imprime el float por separado. Y %d es un int: con un long de 100000 imprimió -31072, con una advertencia; usa %ld para un long.

sprintf en un Uno
void setup() {
  Serial.begin(9600);
  char buf[40];
  float t = 21.5;
  sprintf(buf, "t=%f", t);
  Serial.println(buf);
  dtostrf(t, 6, 2, buf);
  Serial.println(buf);
  sprintf(buf, "%02d:%02d", 7, 5);
  Serial.println(buf);
  long big = 100000;
  sprintf(buf, "%d", big);
  Serial.println(buf);
  sprintf(buf, "%ld", big);
  Serial.println(buf);
}

void loop() {
}

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

Cuánto cuesta imprimir, y F()

Imprimir toma tiempo, fijado por la tasa de baudios. A 9600 baudios un carácter tarda alrededor de un milisegundo en enviarse. El Uno mantiene una cola de 64 bytes, así que una línea corta entra en la cola y el sketch continúa, pero una larga espera a que haya espacio. Una línea de 100 caracteres tardó 38504 microsegundos en imprimirse a 9600 baudios, y 3168 a 115200. Un sketch que imprime mucho a 9600 pasa la mayor parte del tiempo imprimiendo; usa 115200 salvo que algo más fije la velocidad.

En un Uno, cada texto entre comillas de un sketch también se copia a sus 2048 bytes de RAM al arrancar. Envuelve el texto fijo en F(), como en Serial.println(F("from flash"));, y se leerá desde la flash, donde hay mucho más espacio. Imprimió "from flash" igual que antes. Para un sketch con muchos mensajes es la RAM más fácil de recuperar.

Si el monitor muestra cosas sin sentido en lugar de palabras, su velocidad no coincide con Serial.begin(). La página de basura en el monitor serie explica eso y las demás causas.

Abre este circuito en el editor. Arduino Uno: imprimir en el monitor serie, cableado tal como se ejecuta en la parte superior de esta página. Cambia un componente o un valor y ejecútalo de nuevo.

Preguntas

¿Cuál es la diferencia entre Serial.print y Serial.println?

print() envía el texto y se queda en la misma línea. println() lo envía y luego un retorno de carro y un salto de línea, así que lo que venga después empieza en una línea nueva.

¿Cómo imprimo un float con más decimales?

Indica la cantidad de decimales después del valor: Serial.println(3.14159, 4) imprime 3.1416. Sin eso, un float se imprime con dos decimales.

¿Cómo imprimo texto y una variable en la misma línea?

Usa dos llamadas: Serial.print("Temp: "); y luego Serial.println(t);. O únelos como Strings, "Temp: " + String(t). Escribir "Temp: " + t sin String() imprime parte del texto o basura.

¿Por qué sprintf imprime un signo de interrogación para un float en Arduino?

El printf del Uno se compiló sin soporte de float, así que %f imprime ?. Convierte el float con dtostrf() primero, o imprímelo con Serial.print(t, 2).

¿Por qué mi monitor serie no muestra nada?

Verifica que Serial.begin() se ejecute antes del primer print y que el monitor esté configurado a la misma tasa de baudios. Todo lo que se imprima antes de Serial.begin() se pierde.

¿Cómo imprimo un número en HEX con un cero a la izquierda?

`Serial.println(10, HEX)` imprimió "A" y `Serial.println(255, HEX)` imprimió "FF": print() omite los ceros a la izquierda. Para un byte, imprime el cero tú mismo cuando sea menor que 0x10. `if (b < 0x10) Serial.print("0");` antes de `Serial.println(b, HEX);` imprimió "0A".

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