Mejor depuración para Arduino IDE: Biblioteca SerialDebug (Parte 1)

¿Estás buscando la mejor manera de depurar tus proyectos en Arduino IDE? En esta serie de artículos te presentamos la biblioteca SerialDebug, una herramienta imprescindible para facilitar el proceso de depuración. En esta primera parte, descubriremos todas las ventajas que esta biblioteca tiene para ofrecer. ¡No te lo pierdas!

La biblioteca SerialDebug le permite mejorar la depuración en el IDE de Arduino. En esta publicación, João Lopes (creador de la biblioteca SerialDebug) te muestra cómo usarla en tus proyectos.

Advertencia: El desarrollador de esta herramienta ya no actualiza este proyecto.pero el código todavía está disponible en GitHub.

Después de programar el ESP32 con ESP-IDF, João notó que era necesario mejorar la depuración del IDE de Arduino. Entonces él creó eso biblioteca serialdebug para permitir una mejor depuración para Arduino IDE. También desarrolló una aplicación de escritorio llamada Aplicación SerialDebug que agrega una interfaz de usuario y otras funciones útiles.

Para mostrarle todas las funciones útiles de la biblioteca SerialDebug y SerialDebugApp, creó tres tutoriales sobre este tema:

• Parte 1: uso de la depuración por capas (actualmente leyendo)
• Parte 2: Depurador de software simple
• Parte 3 – Aplicación SerialDebug

Usando niveles de depuración

El ESP-IDF tiene un excelente resultado de depuración: el protocolo ESP-IDF tiene niveles de depuración y muestra los mensajes de depuración en su monitor serie en diferentes colores según el nivel.

Sin embargo, no tenemos esta característica en el IDE de Arduino. Esto me motivó (João) a crear una biblioteca para el IDE de Arduino: la biblioteca SerialDebug, que permite depurar con capas y otras funciones.

La siguiente imagen muestra SerialDebugApp, la aplicación complementaria de la biblioteca SerialDebug.

¿Por qué son importantes los niveles de depuración?

Los niveles de depuración le permiten establecer un nivel para cada mensaje según su importancia, mejorando la depuración. Si tenemos un proyecto lleno de “Unificación de correo«, es difícil de ver porque gran parte se genera en el monitor serie y no hay un orden particular en los mensajes de depuración.

Sin embargo, con las capas SerialDebug podemos tener un proyecto lleno de mensajes de depuración a través de Serial Monitor o SerialDebugApp. Puede configurar Depurar en Detallado para imprimir todos los mensajes o Depurar para mostrar solo los mensajes importantes.

Considere este ejemplo hipotético:

A medida que aumenta el nivel, la cantidad de mensajes disminuye.

Para proyectos que usan SerialDebug, podemos usar Arduino IDE Serial Monitor y obtener algo como la siguiente imagen:

Sin embargo, aquí no se muestran colores. Para que los mensajes sean más visibles, podemos asignar diferentes colores a cada capa de depuración. ESP-IDF, Android Studio y otros entornos de desarrollo tienen esta función.

Por eso desarrollé una aplicación de escritorio que Aplicación SerialDebug. En esta aplicación, los mensajes de depuración se muestran en color. Usando el ejemplo en Depuración en serie avanzada de la biblioteca SerialDebug, usando la capa de depuración estándar obtenemos algo como esto:

A nivel de detalle obtenemos lo siguiente:

nota: El nivel se puede cambiar a través del puerto serie (esta función ni siquiera es posible con ESP-IDF).

Depurador

Con la biblioteca SerialDebug obtienes un depurador de software simple y funcional. En Serial Monitor y con la biblioteca SerialDebug puedes:

• Llamar a una función
• Ver y cambiar valores de variables globales.
• Agregar o cambiar vigilancias de variables globales

Compatibilidad con placas SerialDebug

SerialDebug es compatible con cualquier placa compatible con Arduino IDE. Esta biblioteca está optimizada para velocidad y memoria y se puede usar en placas con poca memoria como UNO con solo 2 KB de RAM (sin algunas características debido a limitaciones de hardware), en placas modernas como ESP32, Arduino MKR, placas ARM MCU, como Teensy 3.x. , con todas las funciones activadas.

Migrando código a SerialDebug

Migrar el código para usar SerialDebug es muy fácil. Hay un convertidor que lee el código Arduino existente y genera un nuevo directorio con el código convertido y listo para usar.

Instalación de la biblioteca SerialDebug

Siga los siguientes pasos para instalar la biblioteca SerialDebug:

1. Haga clic aquí para descargar la biblioteca SerialDebug
2. deberías tener uno .Cremallera carpeta en tu Descargas Carpeta
3. Descomprime eso .p.ejcarpeta ip y deberías obtener Maestro de depuración en serie Carpeta
4. Cambie el nombre de su carpeta de Maestro de depuración en serie A Depuración en serie
5. mueve eso Depuración en serie Carpeta a la carpeta de bibliotecas de instalación de Arduino IDE

O utilice el administrador de biblioteca del IDE de Arduino.

1. Abra el IDE de Arduino
2. Ir a Bosquejo > Integrar biblioteca > Administrar bibliotecas
3. Buscar «Depuración en serie«Y haga clic en «Instalar»

Cómo utilizar SerialDebug – Ejemplo sencillo

En el IDE de Arduino, vaya a archivo > Ejemplos > Depuración en serie y seleccione el SerialDebug_basic Ejemplo.

Deberías ver el siguiente código:

////////
// Libraries Arduino
//
// Library: SerialDebug - Improved serial debugging to Arduino, with simple software debugger
// Author: Joao Lopes
// GitHub: https://github.com/JoaoLopesF/SerialDebug
//
// Basic example to show how to use it.
//
// Example of use:
//
//   print macros:
//
//		printA(F("This is a always - var "));
//		printlnA(var);
//		printV(F("This is a verbose - var "));
//		printlnV(var);
//		printD(F("This is a debug - var "));
//		printlnD(var);
//		printI(F("This is a information - var "));
//		printlnI(var);
//		printW(F("This is a warning - var "));
//		printlnW(var);
//		printE(F("This is a error - var "));
//		printlnE(var);
//
//		printlnV("This not have args");
//
///////

////// Includes

#include "Arduino.h"

// SerialDebug Library

// Disable all debug ? Good to release builds (production)
// as nothing of SerialDebug is compiled, zero overhead 🙂
// For it just uncomment the DEBUG_DISABLED
//#define DEBUG_DISABLED true

// Define the initial debug level here (uncomment to do it)
// #define DEBUG_INITIAL_LEVEL DEBUG_LEVEL_VERBOSE

// Disable SerialDebug debugger ? No more commands and features as functions and globals
// Uncomment this to disable it 
//#define DEBUG_DISABLE_DEBUGGER true

// Disable auto function name (good if your debug yet contains it)
//#define DEBUG_AUTO_FUNC_DISABLED true

// Force debug messages to can use flash ) ?
// Disable native Serial.printf (if have)
// Good for low memory, due use flash, but more slow and not use macros
//#define DEBUG_USE_FLASH_F true

// Include SerialDebug

#include "SerialDebug.h" //https://github.com/JoaoLopesF/SerialDebug

////// Variables

// Time

uint32_t mTimeSeconds = 0;

// Buildin Led ON ?

boolean mLedON = false;

////// Setup

void setup() {

    // Initialize the Serial

    Serial.begin(115200); // Can change it to 230400, if you dont use debugIsr* macros

#ifdef __AVR_ATmega32U4__ // Arduino AVR Leonardo

    while (!Serial) {
        ; // wait for serial port to connect. Needed for Leonardo only
    }

#else

    delay(500); // Wait a time

#endif

  	// Debug

	// Attention:
    // SerialDebug starts disabled and it only is enabled if have data avaliable in Serial
    // Good to reduce overheads.
	// if You want debug, just press any key and enter in monitor serial

    // Note: all debug in setup must be debugA (always), due it is disabled now.

    printlnA(F("**** Setup: initializing ..."));

    // Buildin led

    pinMode(LED_BUILTIN, OUTPUT);
    digitalWrite(LED_BUILTIN, LOW);

    // WiFi connection, etc ....

    // ...

    // End

    printlnA(F("*** Setup end"));

}

////// Loop

void loop()
{
	// SerialDebug handle
	// Notes: if in inactive mode (until receive anything from serial),
	// it show only messages of always or errors level type
	// And the overhead during inactive mode is very low
	// Only if not DEBUG_DISABLED

	debugHandle();

	// Blink the led

	mLedON = !mLedON;
	digitalWrite(LED_BUILTIN, (mLedON)?LOW:HIGH);

	// Debug the time (verbose level)

	printV(F("Time: "));
	printV(mTimeSeconds);
	printlnV(F(" seconds (VERBOSE)"));

	if (mTimeSeconds % 5 == 0) { // Each 5 seconds

		// Debug levels

		printlnV(F("This is a message of debug level VERBOSE"));
		printlnD(F("This is a message of debug level DEBUG"));
		printlnI(F("This is a message of debug level INFO"));
		printlnW(F("This is a message of debug level WARNING"));
		printlnE(F("This is a message of debug level ERROR"));

		// Functions example to show auto function name feature

		foo();

		bar();
	}

	// Time

	mTimeSeconds++;

	// Delay of 1 second

	delay(1000);
}


// Functions example to show auto function name feature

void foo() {

  uint8_t var = 1;

  printV(F("This is a debug - var "));
  printlnV(var);
}

void bar() {

  uint8_t var = 2;

  printD(F("This is a debug - var "));
  printlnD(var);

}

/////////// End

Ver código sin formato

Explicación del ejemplo básico.

1. Primero incluya la biblioteca SerialDebug:

#include "SerialDebug.h" // https://github.com/JoaoLopesF/SerialDebug

La biblioteca SerialDebug tiene varias opciones que deben configurarse antes de «#include». Estas están comentadas en el ejemplo para que puedas habilitar las opciones para tu caso específico:

// Disable all debug ? Good to release builds (production)
// as nothing of SerialDebug is compiled, zero overhead 🙂
// For it just uncomment the DEBUG_DISABLED
//#define DEBUG_DISABLED true

// Define the initial debug level here (uncomment to do it)
// #define DEBUG_INITIAL_LEVEL DEBUG_LEVEL_VERBOSE

// Disable SerialDebug debugger ? No more commands and features as functions and globals
// Uncomment this to disable it 
//#define DEBUG_DISABLE_DEBUGGER true

// Disable auto function name (good if your debug yet contains it)
//#define DEBUG_AUTO_FUNC_DISABLED true

// Force debug messages to can use flash ) ?
// Disable native Serial.printf (if have)
// Good for low memory, due use flash, but more slow and not use macros
//#define DEBUG_USE_FLASH_F true

Aquí hay una breve explicación de cada opción:

• DEBUG_DISABLED: Desactiva la biblioteca completa. Con esta opción, SerialDebug no compila nada y no se genera ninguna salida de depuración. Esto es bueno para lanzar una versión de producción.
• DEBUG_INITIAL_LEVEL: Esto se utiliza para establecer el nivel inicial; el valor predeterminado es el nivel de depuración.
• DEBUG_DISABLE_DEBUGGER: Esto desactivará el depurador de software simple. Esto es bueno para reducir el uso de memoria en tarjetas con poca memoria.
• DEBUG_AUTO_FUNC_DISABLED: Esto desactivará la función de denominación automática de funciones. Esto es útil si su código ya contiene esta función en los mensajes de depuración.

2. No se necesita código para SerialDebug para este ejemplo configuración() Función.

3. En el Cinta() Función: utilizamos macros de impresión para depurar.

printV(F("Time: "));
printV(mTimeSeconds);
printlnV(F(" seconds (VERBOSE)"));

if (mTimeSeconds % 5 == 0) { // Each 5 seconds
  // Debug levels

  printlnV(F("This is a message of debug level VERBOSE"));
  printlnD(F("This is a message of debug level DEBUG"));
  printlnI(F("This is a message of debug level INFO"));
  printlnW(F("This is a message of debug level WARNING"));
  printlnE(F("This is a message of debug level ERROR"));

  // Functions example to show auto function name feature

  foo();

  bar();
}

Imprimir macros

SerialDebug tiene varias macros de impresión para depurar la salida:

• imprimirV/imprimirlnV: Mensaje de nivel detallado.
• imprimirD/imprimirlnD: Mensaje de depuración de nivel
• imprimirI/imprimirlnI: Informes de información del nivel de llenado
• imprimirW/imprimirlnW: Notificación del aviso de nivel de llenado
• imprimirE/imprimirlnE: Mensaje de error de nivel: siempre se muestra
• imprimirA/imprimirlnA: Mensaje de nivel siempre: siempre se muestra

Estas macros reemplazan las estándar Unificación de correo Comandos.

Nota: Todas las rutinas para ver la depuración son macros precompiladoras de C/C++, por lo que no se requieren llamadas a funciones adicionales, solo Unificación de correo Y Serial.println (excepto cuando se utiliza el formateador Printf para tarjetas que no lo tienen de forma nativa).

Tome el siguiente código como ejemplo:

// Example from ladyada.net/learn/arduino/lesson4.html

int a = 5;
int b = 10;
int c = 20;

void setup()                    // run once, when the sketch starts
{
  Serial.begin(9600);           // set up Serial library at 9600 bps

  Serial.println("Here is some math: ");

  Serial.print("a = ");
  Serial.println(a);
  Serial.print("b = ");
  Serial.println(b);
  Serial.print("c = ");
  Serial.println(c);

  Serial.print("a + b = ");       // add
  Serial.println(a + b);

  Serial.print("a * c = ");       // multiply
  Serial.println(a * c);
  
  Serial.print("c / b = ");       // divide
  Serial.println(c / b);
  
  Serial.print("b - c = ");       // subtract
  Serial.println(b - c);
}

void loop()                     // we need this to be here even though its empty
{
}

Ver código sin formato

Este código se migra a SerialDebug con los siguientes cambios:

• sustituto Serial.println A imprimirD
• sustituto Unificación de correo A imprimirD

D representa el nivel de depuración. En lugar de D, puede utilizar V para obtener información detallada.

Como se mencionó anteriormente, SerialDebug tiene un convertidor que le ayuda a migrar códigos Arduino desde Serial.prints a esta biblioteca. Recomendamos utilizar el conversor para evitar errores innecesarios. Consulte SerialDebugConverter en el siguiente enlace:

• https://github.com/JoaoLopesF/SerialDebugConverter

Después de ejecutar el código en el convertidor, se genera un nuevo archivo en la carpeta del código fuente. Si pruebas el ejemplo anterior obtendrás esto:

// Example from ladyada.net/learn/arduino/lesson4.html

int a = 5;
int b = 10;
int c = 20;

// SerialDebug Library

// Disable all debug ? Good to release builds (production)
// as nothing of SerialDebug is compiled, zero overhead 🙂
// For it just uncomment the DEBUG_DISABLED
//#define DEBUG_DISABLED true

// Disable SerialDebug debugger ? No more commands and features as functions and globals
// Uncomment this to disable it 
//#define DEBUG_DISABLE_DEBUGGER true

// Define the initial debug level here (uncomment to do it)
//#define DEBUG_INITIAL_LEVEL DEBUG_LEVEL_VERBOSE

// Disable auto function name (good if your debug yet contains it)
//#define DEBUG_AUTO_FUNC_DISABLED true

// Include SerialDebug
#include "SerialDebug.h" // Download SerialDebug library: https://github.com/JoaoLopesF/SerialDebug

void setup()                    // run once, when the sketch starts
{
  Serial.begin(9600);           // set up Serial library at 9600 bps

  printlnA("Here is some math: ");

  printA("a = ");
  printlnA(a);
  printA("b = ");
  printlnA(b);
  printA("c = ");
  printlnA(c);

  printA("a + b = ");       // add
  printlnA(a + b);

  printA("a * c = ");       // multiply
  printlnA(a * c);
  
  printA("c / b = ");       // divide
  printlnA(c / b);
  
  printA("b - c = ");       // subtract
  printlnA(b - c);

#ifndef DEBUG_DISABLE_DEBUGGER

  // Add Functions and global variables to SerialDebug

  // Add functions that can called from SerialDebug

  //debugAddFunctionVoid(F("function"), &function); // Example for function without args
  //debugAddFunctionStr(F("function"), &function); // Example for function with one String arg
  //debugAddFunctionInt(F("function"), &function); // Example for function with one int arg

  // Add global variables that can showed/changed from SerialDebug
  // Note: Only global, if pass local for SerialDebug, can be dangerous

  debugAddGlobalInt(F("a"), &a);
  debugAddGlobalInt(F("b"), &b);
  debugAddGlobalInt(F("c"), &c);

#endif // DEBUG_DISABLE_DEBUGGER

}

void loop()                     // we need this to be here even though its empty
{

  // SerialDebug handle
  // Notes: if in inactive mode (until receive anything from serial),
  // it show only messages of always or errors level type
  // And the overhead during inactive mode is very low
  // Only if not DEBUG_DISABLED

  debugHandle();

}

Ver código sin formato

Macros de depuración

SerialDebug tiene tres tipos de macros de depuración:

• ¿prensa? – Reemplazo de impresión en serie
• ¿prensa? – Reemplazo de Serial.println
• ¿depurar? – Reemplazo de Serial.printf (con nueva línea)

El sufijo “?” indica el nivel del mensaje, por ejemplo: printV, printlnD, debugE.

Aquí hay un ejemplo:

printD("b - c = "); // subtract
printlnD(b - c);

Esto producirá la siguiente salida en el monitor serie:

V p:^1000 loop C1) b - c = 2

Dónde:

• V: es el nivel
• PAG: es un perfil del tiempo transcurrido entre esta y la depuración anterior
• Cinta: es el nombre de la función que activó este mensaje de depuración
• C1: es el núcleo que ejecutó este mensaje de depuración (solo se aplica al ESP32)
• el resto es el mensaje

Sube el ejemplo base

Cargue el ejemplo de SerialDebug_basic:

Usando SerialDebug en Arduino IDE Serial Monitor

Abra el monitor serie.

El estado inicial de SerialDebug es inactivo, es decir, no hay una salida de depuración normal ni desperdicio de CPU para la depuración. Esto es bueno para proyectos que no siempre están conectados mediante USB (por ejemplo, alimentados por batería o externamente). Los únicos mensajes que se procesan y muestran son Error o Siempre (importante).

Después de recibir el primer comando, SerialDebug se activa:

El nivel predeterminado es Depurar, pero se puede cambiar. Tenga en cuenta que los mensajes de nivel detallado no se muestran.

Comandos de depuración serie

SerialDebug tiene comandos que se pueden ejecutar desde el monitor serie. Por ejemplo:

• ? – Mostrar ayuda para los comandos.
• contra – Cambiar el nivel a detallado

Si usted ? y presione “Enviar”. Se muestran los comandos de ayuda:

Si desea cambiar el nivel a detallado (Comando contra y botón “Enviar”):

Tenga en cuenta que la cantidad de mensajes mostrados aumenta significativamente. Por eso es importante tener diferentes niveles de depuración.

Vídeo de demostración

Puede ver el siguiente vídeo sobre la biblioteca SerialDebug para verla en acción:

Envolver

Este primer artículo fue una introducción a la biblioteca SerialDebug para Arduino IDE. Con esta biblioteca podemos mejorar significativamente la depuración de Arduino IDE. También le mostramos cómo usar capas de depuración con la biblioteca y cómo interactuar con el monitor serie.

En la Parte 2, descubrirá funciones avanzadas de la biblioteca SerialDebug, como:

• Depurador de software sencillo: funciona incluso sin un depurador de hardware
• ¿depuración? Macros: formatear con el potente printf

sigue leyendo: Mejor depuración para Arduino IDE con Software Debugger (Parte 2)

Ayúdame a implementar una mejor depuración para Arduino IDE usando esta biblioteca. Visita la página de GitHub https://github.com/JoaoLopesF/SerialDebugpara más información, problemas y sugerencias. Tu también puedes hacer eso Sala de chat de cuadrícula para compartir sus comentarios.

Gracias a Random Nerd Tutorials por la oportunidad de publicar sobre la biblioteca SerialDebug.

Joao Lopes

Random Nerd Tutorials ofrece más de 200 proyectos y tutoriales de electrónica gratuitos. Échales un vistazo a todos en el siguiente enlace: Más de 200 proyectos y tutoriales de electrónica.

Mejor depuración para Arduino IDE: Biblioteca SerialDebug (Parte 1)

La biblioteca SerialDebug te permite mejorar y depurar de mejor manera en Arduino IDE. En esta publicación, João Lopes (creador de la biblioteca SerialDebug) te muestra cómo utilizarla en tus proyectos.

Advertencia: El desarrollador de esta herramienta ya no está actualizando este proyecto, pero el código sigue disponible en GitHub.

Después de programar el ESP32 usando ESP-IDF, João notó que la depuración en Arduino IDE necesitaba mejorar. Así que creó la biblioteca SerialDebug para ofrecer una mejor depuración en Arduino IDE. También creó una aplicación de escritorio llamada SerialDebugApp que añade una interfaz de usuario y otras funcionalidades útiles.

Para mostrarte todas las características útiles de la biblioteca SerialDebug y la SerialDebugApp, creó tres tutoriales dedicados a este tema:

1. Parte 1 – Uso de depuración con niveles (actualmente leyendo)
2. Parte 2 – Simple Software Debugger
3. Parte 3 – SerialDebugApp

Uso de Niveles de Depuración

Los niveles de depuración te permiten establecer un nivel para cada mensaje de acuerdo a su importancia, mejorando así la depuración. Si tenemos un proyecto lleno de «Serial.print», es difícil verlo, ya que se genera mucho en el monitor serie y no hay un orden específico en los mensajes de depuración.

Sin embargo, utilizando los niveles de SerialDebug, podemos tener un proyecto lleno de mensajes de depuración a través del Monitor Serie o SerialDebugApp. Puedes establecer la depuración en «Verbose» para tener todos los mensajes impresos, o en «Debug» para mostrar solo los mensajes importantes.

¿Por qué son importantes los niveles de depuración?

Los niveles de depuración te permiten establecer un nivel para cada mensaje de acuerdo a su importancia, mejorando así la depuración. Si tenemos un proyecto lleno de «Serial.print», es difícil verlo, ya que se genera mucho en el monitor serie y no hay un orden específico en los mensajes de depuración.

Compatibilidad de Placas SerialDebug

SerialDebug es compatible con cualquier placa compatible con Arduino IDE. Esta biblioteca está optimizada en velocidad y memoria, y se puede utilizar en placas con poca memoria, como UNO con solo 2k de RAM (sin algunas funciones, debido al límite de hardware), hasta placas más modernas, como ESP32, Arduino MKRs, placas ARM MCU, como Teeny 3.x, con todas las funciones habilitadas.

Migración de Código a SerialDebug

La migración del código para utilizar SerialDebug es muy sencilla. Existe un convertidor que lee el código de Arduino existente y genera un nuevo directorio con el código convertido y listo para usar.

Instalación de la Biblioteca SerialDebug

Sigue los siguientes pasos para instalar la biblioteca SerialDebug:

1. Haz clic aquí para descargar la biblioteca SerialDebug
2. Debes tener una carpeta .zip en tu carpeta de Descargas
3. Descomprime la carpeta .zip y deberías obtener la carpeta SerialDebug-master
4. Renombra tu carpeta de SerialDebug-master a SerialDebug
5. Mueve la carpeta SerialDebug a la carpeta de bibliotecas de instalación de Arduino IDE

O utiliza el administrador de bibliotecas de Arduino IDE.

Continúa leyendo: Mejor Depuración para Arduino IDE utilizando Software Debugger (Parte 2)

Ayúdame a llevar una mejor depuración a Arduino IDE usando esta biblioteca. Visita la página de GitHub https://github.com/JoaoLopesF/SerialDebug para obtener más información, publicar problemas y sugerencias. Además, puedes usar la sala de chat de gitter para compartir tus comentarios.