Aprender

Cómo depurar código de Arduino, de impresiones serie a puntos de interrupción

Principiante

O mira todas las lecciones.

  • 526componentes en el banco de trabajo
  • 46placas funcionando ahora
  • 1.00xtiempo real, en todas las placas
Arduino Uno: una perilla y un LEDen vivo0.000 s 0.00x
Haz clic para abrirlo en el editor
Un potenciómetro en A0 controla un LED en el pin 9. Ábrelo, pega el ejemplo resuelto y gira la perilla con el monitor serie abierto.

Un Arduino no tiene pantalla, así que cuando un sketch se comporta mal no puedes ver qué está pensando. El Uno y el Nano clásicos tampoco se pueden recorrer paso a paso en el Arduino IDE: el depurador del IDE admite ciertas placas más recientes, y no las de AVR que usan la mayoría de las clases y los kits. Así que la mayoría depura con Serial.print, y funciona bien cuando lo usas con intención.

Esta página es un método para acotar un bug, y luego tres herramientas: imprimir, graficar y detener la placa en una línea. El circuito de arriba es un Uno con un potenciómetro en A0 y un LED en el pin 9, lo cual basta para mostrar las tres, incluido un bug real que solo ocurre en un Uno.

Haz el bug pequeño antes de perseguirlo

Escribe lo que esperabas y lo que pasó en su lugar, en una oración cada uno. "El LED debería brillar más mientras giro la perilla, y pasa de brillante a oscuro y luego a brillante" es un bug que puedes probar; "no funciona" no lo es.

Luego reduce el problema. Revisa el cableado contra los números de pin del código primero, porque eso atrapa una gran parte de los bugs. Comenta todo lo que no esté involucrado, o copia la parte sospechosa en un sketch nuevo. Cambia una cosa a la vez y ejecuta de nuevo. Un bug que sobrevive en diez líneas es un bug que encontrarás; el mismo bug en trescientas es adivinar.

Serial.print, con intención

Inicia el puerto en setup() con Serial.begin, y en una placa real configura el monitor serie a la misma velocidad en baudios, o verás caracteres basura. Imprime algo una vez al final de setup(). Si esa línea aparece una y otra vez, la placa se está reiniciando, lo que suele significar que un motor o un servo está hundiendo la alimentación.

Etiqueta cada valor, es decir botón: presionado en lugar de un 0 solo. Imprime cuando algo cambia, no en cada pasada por loop(), lo que inunda el monitor demasiado rápido para leerlo. Y envuelve las impresiones en una macro, para poder apagarlas en un solo lugar en vez de borrarlas y volver a escribirlas cuando el bug regrese.

Impresiones etiquetadas, al cambiar algo, tras un solo interruptor
#define DEBUG 1

#if DEBUG
#define DEBUG_PRINT(x) Serial.print(x)
#define DEBUG_PRINTLN(x) Serial.println(x)
#else
#define DEBUG_PRINT(x)
#define DEBUG_PRINTLN(x)
#endif

const int BUTTON_PIN = 2;
int lastState = HIGH;

void setup() {
  Serial.begin(115200);
  pinMode(BUTTON_PIN, INPUT_PULLUP);
  DEBUG_PRINTLN("setup done");  // printed again on every reset
}

void loop() {
  int state = digitalRead(BUTTON_PIN);
  if (state != lastState) {  // print on a change, not on every pass
    DEBUG_PRINT("button: ");
    DEBUG_PRINTLN(state == LOW ? "pressed" : "released");
    lastState = state;
  }
}

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

Imprimir toma tiempo

Cada carácter tarda alrededor de un milisegundo en enviarse a 9600 baudios, así que una línea de 20 caracteres cuesta unos 20 milisegundos. Un Uno real oculta los primeros 64 bytes en un búfer de transmisión, pero un sketch que imprime en cada pasada lo llena rápido y luego espera por cada carácter. Usa 115200 baudios, que es doce veces más rápido, e imprime menos.

Esto también explica por qué a veces agregar una impresión hace desaparecer un bug. Si volver lento el sketch lo arregla, el bug es de tiempo: un botón leído demasiado rápido, un sensor leído antes de estar listo, o una interrupción compitiendo con el bucle principal. Eso es una pista, no una solución. No imprimas dentro de un manejador de interrupciones; ahí pon una bandera e imprime desde loop().

Un ejemplo resuelto: el promedio que se vuelve negativo

Aquí hay un bug real. El sketch promedia 64 lecturas del potenciómetro para suavizarlas. Con el circuito de arriba y la perilla en 100, imprime total:6400 promedio:100, lo cual es correcto. Gira la perilla a la mitad, 512, e imprime total:-32768 promedio:-512. Arriba, en 1023, imprime total:-64 promedio:-1.

Las impresiones hacen visible la causa: el total está mal, así que el promedio no es el problema. En un Uno un int es de 16 bits y almacena como máximo 32,767, y 64 lecturas de 1023 suman 65,472, así que el total se desborda a negativo. El mismo sketch funciona en un ESP32, donde un int es de 32 bits, que es justo el tipo de diferencia que hace que un bug parezca aleatorio. La solución es long total = 0;. Sin imprimir el total, solo verías un promedio malo y probablemente buscarías en el lugar equivocado.

El bug, y su solución de una palabra en el comentario
const int SENSOR_PIN = A0;

void setup() {
  Serial.begin(115200);
}

void loop() {
  int total = 0;  // the bug: make this long
  for (int i = 0; i < 64; i++) {
    total += analogRead(SENSOR_PIN);
  }
  Serial.print("total:");
  Serial.print(total);
  Serial.print(" average:");
  Serial.println(total / 64);
  delay(250);
}

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

Grafica números en lugar de leerlos

Un valor que cambia con el tiempo es más fácil de juzgar como una línea. El Serial Plotter del Arduino IDE y la pestaña Gráfica de Mokxi leen el mismo formato: números en una línea separados por espacios o comas, cada uno opcionalmente etiquetado como nombre:valor. El ejemplo resuelto de arriba ya imprime en esa forma, así que abre la pestaña Gráfica y gira la perilla, y podrás ver el total doblarse hacia números negativos en el punto medio.

Imprimir un umbral junto a una lectura, como lectura:512 umbral:600, dibuja el umbral como una línea plana, así que puedes ver exactamente cuándo un sensor lo cruza y qué tan ruidoso es cerca del borde. Eso responde de un vistazo "por qué mi luz parpadea al atardecer".

Detén la placa en una línea

En Mokxi puedes detener cualquier placa con un punto de interrupción, incluido el Uno, porque el chip se simula en lugar de conectarse por USB. Haz clic en el margen a la izquierda de un número de línea y aparece un punto rojo; presiona Ejecutar, y la placa se detiene antes de que esa línea corra. Todo el circuito se detiene con ella, así que un LED queda exactamente tan brillante como estaba y millis() no avanza mientras miras.

La pestaña Depurar muestra entonces dónde se detuvo la placa, sus registros y una lista de observación para variables globales. Paso a paso por encima ejecuta una línea a la vez. La lista de observación solo lee globales, así que mientras depuras puede ayudar hacer global la variable que te interesa. En el ESP32 y el ESP8266, Pausa y la lista de observación funcionan, pero los puntos de interrupción no, porque el compilador del navegador no puede compilar para esos dos chips. El ejemplo de puntos de interrupción de abajo lo recorre en un ESP32-C3.

Abre este circuito en el editor. Arduino Uno: una perilla y un LED, conectados como se ejecuta en la parte superior de esta página. Cambia un componente o un valor y ejecútalo de nuevo.

Abrir el circuito

Preguntas

¿Se puede depurar un Arduino Uno con puntos de interrupción?

No con el depurador del IDE de Arduino, que no es compatible con las placas AVR. El ATmega328P tiene una interfaz de depuración de un solo cable, debugWIRE, pero necesita un depurador de hardware aparte. En Mokxi, los puntos de interrupción funcionan directamente en el Uno simulado.

¿Por qué mi monitor serie muestra caracteres extraños?

En una placa real, la velocidad en baudios del monitor no coincide con Serial.begin. Pon ambos en el mismo número, por ejemplo 115200.

¿Por qué agregar Serial.print hace que mi error desaparezca?

Imprimir hace que el sketch sea más lento, así que el error depende del tiempo: una lectura que ocurre demasiado pronto, un antirrebote que falta o una variable compartida con una interrupción.

¿Debo dejar las impresiones de depuración en un sketch terminado?

Es mejor apagarlas en lugar de borrarlas, con una macro DEBUG como la de arriba. Cuando están activas cuestan tiempo y memoria, y cuando están apagadas no cuestan nada.

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