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

En la segunda parte de nuestra serie sobre la depuración en Arduino IDE, exploraremos cómo mejorar aún más este proceso con el uso de un Software Debugger. Descubre cómo esta herramienta puede facilitar la identificación y corrección de errores en tus proyectos de Arduino. ¡Sigue leyendo para conocer todos los detalles!

La biblioteca SerialDebug creada por João Lopes permite mejorar la depuración del IDE de Arduino. En este artículo le mostrará cómo utilizar el sencillo depurador de software. biblioteca serialdebug que tiene la mayoría de las características de un depurador de hardware.

Esta es la parte 2 de una serie de artículos sobre la biblioteca SerialDebug. Puede leer todos los artículos utilizando los enlaces a continuación.

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

Depurador de software sencillo

Cuando yo (João) desarrollé en ESP-IDF (SDK nativo de ESP32), utilicé un depurador de hardware con hardware externo compatible con JTAG, servidor GDB y Eclipse CDT. Esta es una gran solución para la depuración, ya que puedo ver el valor de las variables, establecer puntos de interrupción (hasta 2 para ESP32), ejecutar código paso a paso y mucho más.

Sin embargo, Arduino IDE aún no admite un depurador de hardware. Si desea utilizar el depurador de hardware, necesita:

• Un hardware externo (JTAG, Atmel-Ice, etc.)
• Otro IDE (Eclipse, Atmel Studio, etc.)
• Habilidades de configuración y uso.

Existen soluciones más sencillas, pero no son gratuitas, como MicroStudio. Es por eso que hay tan pocas personas que utilizan el depurador en el IDE de Arduino. La depuración en Arduino IDE se realiza principalmente con Serie.princomandos t.

Cuando estaba desarrollando la biblioteca SerialDebug, estaba pensando en cómo podría integrar algunas funciones de depuración de hardware en Arduino sin necesidad de hardware ni conocimientos adicionales. La biblioteca SerialDebug tiene un depurador de software simple. Echemos un vistazo más de cerca a sus características:

• Simplemente: Es un depurador simple pero funcional. No tiene todas las características de un verdadero depurador de hardware (como la capacidad de recorrer el código).
• Software: Se implementa como software, no como un depurador de hardware. Sin embargo, está optimizado para reducir la memoria y la sobrecarga de procesamiento. Por este motivo, esta función está deshabilitada en la biblioteca SerialDebug hasta que se reciba el comando dbg.
• Depurador: Es un depurador. Puede enviar comandos en el monitor serie como:
  • Llamar a una función (funciona cuando el depurador está habilitado o deshabilitado)
  • Ver y cambiar valores de variables globales (solo funciona si el depurador está habilitado)
  • Agregar o cambiar relojes de variables globales (solo funciona si el depurador está habilitado)

Nota: Debido a limitaciones de memoria del programa, el depurador de software simple no se ejecuta en placas con poca memoria como Arduino Uno. Sin embargo, puedes probar el depurador con esta placa desactivando el modo DEBUG_MINIMUM. Para hacer esto, simplemente comente en la línea 64 de SerialDebug.h.

Cómo utilizar el depurador de software simple

Primero, siga los pasos de la Parte 1 de esta serie para instalar la biblioteca SerialDebug. Luego abra el ejemplo avanzado. En el archivo elegir Ejemplos > Depuración en serie > SerialDebug_Avanzado.

Entonces escoge Avr para Arduino con AVR-Arch, como Uno, Leonardo y Mega. O Otro para Arduino como Due, MKR, Teensy, Esp8266 y Esp32. Para esta publicación usaremos la placa ESP32 y el ejemplo en el directorio «Otros».

Debería abrirse el siguiente código:

////////
// Libraries Arduino
//
// Library: SerialDebug - Improved serial debugging to Arduino, with simple software debugger
// Author: Joao Lopes
//
// 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");
//
// 	debug macros (printf formatting):
//
//		debugA("This is a always - var %d", var);
//
//		debugV("This is a verbose - var %d", var);
//		debugD("This is a debug - var %d", var);
//		debugI("This is a information - var %d", var);
//		debugW("This is a warning - var %d", var);
//		debugE("This is a error - var %d", var);
//
//		debugV("This not have args");
//
///////

///////
// Note: this version is for Espressif or ARM boards,
//       Not using F() to reduce memory,
//       due these boards have memory a lot,
//	     and RAM memory is much faster than Flash memory
//       If want or need, please open the example in Directory Avr.
///////

////// 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

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

// Debug TAG ?
// Usefull with debug any modules
// For it, each module must have a TAG variable:
// 		const char* TAG = "...";
// Uncomment this to enable it
//#define DEBUG_USE_TAG true

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

// 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

#ifdef BOARD_LOW_MEMORY
	#error "This is not for low memoy boards, please use the basic example"
	// If this error occurs, your board is a low memory board,
	// and for this, the default is mininum mode,
	// to especially to reduce program memory (flash)
	// You can do it:
	// - Open the basic example, or
    // - Open Advanced/Avr example (this uses F() to reduce RAM usage),
    //   and before, comment the DEBUG_MININUM in SerialDebug.h - line 64
#endif

////// Variables

// Time

uint8_t mRunSeconds = 0;
uint8_t mRunMinutes = 0;
uint8_t mRunHours = 0;

// Buildin Led ON ?

#ifndef LED_BUILTIN // For compatibility
	#ifdef BUILTIN_LED
		#define LED_BUILTIN BUILTIN_LED
	#else
		#define LED_BUILTIN 2
	#endif
#endif

boolean mLedON = false;

// Globals for this example

boolean mBoolean = false;
char mChar="X";
byte mByte="Y";
int mInt = 1;
unsigned int mUInt = 2;
long mLong = 3;
unsigned long mULong = 4;
float mFloat = 5.0f;
double mDouble = 6.0;

String mString = "This is a string";
String mStringLarge = "This is a large stringggggggggggggggggggggggggggggggggggggggggggggg";

char mCharArray[] = "This is a char array";
char mCharArrayLarge[] = "This is a large char arrayyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy";

int mIntArray[5] = {1 ,2 ,3, 4, 5};

//const char mCharArrayConst[] = "This is const";

////// Setup

void setup() {

    // Initialize the Serial

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

    delay(500); // Wait a time

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

    Serial.println(); // To not stay in end of dirty chars in boot

    debugA("**** Setup: initializing ...");

    // Buildin led

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

    // WiFi connection, etc ....

    // ...

#ifndef DEBUG_DISABLE_DEBUGGER

    // Add Functions and global variables to SerialDebug

    // Notes: descriptions is optionals

    // Add functions that can called from SerialDebug

    if (debugAddFunctionVoid("benchInt", &benchInt) >= 0) {
    	debugSetLastFunctionDescription("To run a benchmark of integers");
    }
    if (debugAddFunctionVoid("benchFloat", &benchFloat) >= 0) {
    	debugSetLastFunctionDescription("To run a benchmark of float");
    }
    if (debugAddFunctionVoid("benchGpio", &benchGpio) >= 0) {
    	debugSetLastFunctionDescription("To run a benchmark of Gpio operations");
    }
    if (debugAddFunctionVoid("benchAll", &benchAll) >= 0) {
    	debugSetLastFunctionDescription("To run all benchmarks");
    }

    if (debugAddFunctionVoid("benchSerialPrints", &benchSerialPrint) >= 0) {
    	debugSetLastFunctionDescription("To benchmarks standard Serial debug");
    }
    if (debugAddFunctionVoid("benchSerialDebug", &benchSerialDebug) >= 0) {
    	debugSetLastFunctionDescription("To benchmarks SerialDebug");
    }
    if (debugAddFunctionVoid("benchSerialDbgPr", &benchSerialDbgPr) >= 0) {
    	debugSetLastFunctionDescription("To benchmarks SerialDebug print macros");
    }
    if (debugAddFunctionVoid("benchSerialAll", &benchSerialAll) >= 0) {
    	debugSetLastFunctionDescription("To benchmarks all Serial");
    }

    if (debugAddFunctionStr("funcArgStr", &funcArgStr) >= 0) {
    	debugSetLastFunctionDescription("To run with String arg");
    }
    if (debugAddFunctionChar("funcArgChar", &funcArgChar) >= 0) {
    	debugSetLastFunctionDescription("To run with Character arg");
    }
    if (debugAddFunctionInt("funcArgInt", &funcArgInt) >= 0) {
    	debugSetLastFunctionDescription("To run with Integer arg");
    }

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

    if (debugAddGlobalUInt8_t("mRunSeconds", &mRunSeconds) >= 0) {
    	debugSetLastGlobalDescription("Seconds of run time");
    }
    if (debugAddGlobalUInt8_t("mRunMinutes", &mRunMinutes) >= 0) {
    	debugSetLastGlobalDescription("Minutes of run time");
    }
    if (debugAddGlobalUInt8_t("mRunHours", &mRunHours) >= 0) {
    	debugSetLastGlobalDescription("Hours of run time");
    }

    // Note: easy way, no descriptions ....

    debugAddGlobalBoolean("mBoolean", 	&mBoolean);
    debugAddGlobalChar("mChar", 		&mChar);
    debugAddGlobalByte("mByte", 		&mByte);
    debugAddGlobalInt("mInt", 			&mInt);
    debugAddGlobalUInt("mUInt", 		&mUInt);
    debugAddGlobalLong("mLong", 		&mLong);
    debugAddGlobalULong("mULong", 		&mULong);
    debugAddGlobalFloat("mFloat", 		&mFloat);
    debugAddGlobalDouble("mDouble", 	&mDouble);

    debugAddGlobalString("mString", 	&mString);

    // Note: For char arrays, not use the '&'

    debugAddGlobalCharArray("mCharArray", mCharArray);

    // Note, here inform to show only 20 characteres of this string or char array

    debugAddGlobalString("mStringLarge", &mStringLarge, 20);

    debugAddGlobalCharArray("mCharArrayLarge",
    									mCharArrayLarge, 20);

    // For arrays, need add for each item (not use loop for it, due the name can not by a variable)
    // Notes: Is good added arrays in last order, to help see another variables
    //        In next versions, we can have a helper to do it in one command

	debugAddGlobalInt("mIntArray[0]", 	&mIntArray[0]);
	debugAddGlobalInt("mIntArray[1]", 	&mIntArray[1]);
	debugAddGlobalInt("mIntArray[2]", 	&mIntArray[2]);
	debugAddGlobalInt("mIntArray[3]",	&mIntArray[3]);
	debugAddGlobalInt("mIntArray[4]",	&mIntArray[4]);

    // Add watches for some global variables
    // Note: watches can be added/changed in serial monitor too

	// Watch -> mBoolean when changed (put 0 on value)

	debugAddWatchBoolean("mBoolean", DEBUG_WATCH_CHANGED, 0);

	// Watch -> mRunSeconds == 10

	debugAddWatchUInt8_t("mRunSeconds", DEBUG_WATCH_EQUAL, 10);

	// Watch -> mRunMinutes > 3

	debugAddWatchUInt8_t("mRunMinutes", DEBUG_WATCH_GREAT, 3);

	// Watch -> mRunMinutes == mRunSeconds (just for test)

	debugAddWatchCross("mRunMinutes", DEBUG_WATCH_EQUAL, "mRunSeconds");

#endif // DEBUG_DISABLE_DEBUGGER

    // End

    debugA("**** Setup: initialized.");

}

////// Loop

void loop()
{
	// SerialDebug handle
	// NOTE: 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 much low

	debugHandle();

	// Blink the led

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

	// Debug the time (verbose level)

	debugV("* Run time: %02u:%02u:%02u (VERBOSE)", mRunHours, mRunMinutes, mRunSeconds);

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

		// Debug levels

		debugV("* This is a message of debug level VERBOSE");
		debugD("* This is a message of debug level DEBUG");
		debugI("* This is a message of debug level INFO");
		debugW("* This is a message of debug level WARNING");

		if (mRunSeconds == 55) { // Just for not show initially
			debugE("* This is a message of debug level ERROR");
		}

		mBoolean = (mRunSeconds == 30); // Just to trigger the watch

		// Functions example to show auto function name feature

		foo();

		bar();

		// Example of float formatting:

		mFloat += 0.01f;

#ifndef ARDUINO_ARCH_AVR // Native float printf support
		debugV("mFloat = %.3f", mFloat);
#else // For AVR, it is not supported, using String instead
		debugV("mFloat = %s", String(mFloat).c_str());
#endif

	}

	// Count run time (just a test - for real suggest the TimeLib and NTP, if board have WiFi)

	mRunSeconds++;

	if (mRunSeconds == 60) {
		mRunMinutes++;
		mRunSeconds = 0;
	}
	if (mRunMinutes == 60) {
		mRunHours++;
		mRunMinutes = 0;
	}
	if (mRunHours == 24) {
		mRunHours = 0;
	}

	// Delay of 1 second

	delay(1000);
}


// Functions example to show auto function name feature

void foo() {

  uint8_t var = 1;

  debugV("This is a debug - var %u", var);
}

void bar() {

  uint8_t var = 2;

  debugD("This is a debug - var %u", var);
}

////// Benchmarks - simple

// Note: how it as called by SerialDebug, must be return type void and no args
// Note: Flash F variables is not used during the tests, due it is slow to use in loops

#define BENCHMARK_EXECS 10000

// Simple benckmark of integers

void benchInt() {

	int test = 0;

	for (int i = 0; i < BENCHMARK_EXECS; i++) {

		// Some integer operations

		test++;
		test += 2;
		test -= 2;
		test *= 2;
		test /= 2;
	}

	// Note: Debug always is used here

	debugA("*** Benchmark of integers. %u exec.", BENCHMARK_EXECS);

}

// Simple benckmark of floats

void benchFloat() {

	float test = 0;

	for (int i = 0; i < BENCHMARK_EXECS; i++) {

		// Some float operations

		test++;
		test += 2;
		test -= 2;
		test *= 2;
		test /= 2;
	}

	// Note: Debug always is used here

	debugA("*** Benchmark of floats, %u exec.", BENCHMARK_EXECS);

}

// Simple benckmark of GPIO

void benchGpio() {

//	const int execs = (BENCHMARK_EXECS / 10); // Reduce it
	const int execs = BENCHMARK_EXECS;

	for (int i = 0; i < execs; i++) {

		// Some GPIO operations

		digitalWrite(LED_BUILTIN, HIGH);
		digitalRead(LED_BUILTIN);
		digitalWrite(LED_BUILTIN, LOW);

		analogRead(A0);
		analogRead(A0);
		analogRead(A0);

	}

	// Note: Debug always is used here

	debugA("*** Benchmark of GPIO. %u exec.", execs);

}

// Run all benchmarks

void benchAll() {

	benchInt();
	benchFloat();
	benchGpio();

	// Note: Debug always is used here

	debugA("*** All Benchmark done.");

}

// Serial benchmarks, to compare Serial.prints with SerialDebug

#define BENCHMARK_SERIAL 25

void benchSerialPrint() {

	// Note: Serial.printf is not used, due most Arduino not have this
	// Show same info to compare real speed
	// Same data size of SerialDebug to compare speeds of processing and not the time elapsed to send it

	unsigned long timeBegin = micros();

	for (uint16_t i = 0; i < BENCHMARK_SERIAL; i++) {

		Serial.print("(A ");
		Serial.print(millis());
		Serial.print(" benchSerialPrint");
#ifdef ESP32
		Serial.print(" C");
		Serial.print(xPortGetCoreID());
#endif
		Serial.print(") Exec.: ");
		Serial.print(i+1);
		Serial.print(" of ");
		Serial.println(BENCHMARK_SERIAL);

	}

	unsigned long elapsed = (micros() - timeBegin);

	Serial.print("*** Benchmark of Serial prints. Execs.: ");
	Serial.print(BENCHMARK_SERIAL);
	Serial.print(" time elapsed -> ");
	Serial.print(elapsed);
	Serial.println(" us");

}

void benchSerialDebug() {

	// Notes: printf formats can be used,
	// even if Arduino not have this, this is done in internal debugPrintf
	// Debug always level is used here

	debugShowProfiler(false, 0, false); // Disable the profiler during the test (the Serial.print not have it)

	unsigned long timeBegin = micros();

	for (uint16_t i = 0; i < BENCHMARK_SERIAL; i++) {

		debugA("Exec.: %u of %u", (i+1), BENCHMARK_SERIAL);

	}

	unsigned long elapsed = (micros() - timeBegin);

	// Note not using SerialDebug macros below, to show equals that SerialPrints

	Serial.print("*** Benchmark of Serial debugA. Execs.: ");
	Serial.print(BENCHMARK_SERIAL);
	Serial.print(" time elapsed -> ");
	Serial.print(elapsed);
	Serial.println(" us");

	debugShowProfiler(true, 0, false); // Reenable

}

void benchSerialDbgPr() {

	// Using print macros to avoid printf
	// Same data size of SerialDebug to compare speeds of processing and not the time elapsed to send it

	debugSetProfiler(false); // Disable it, due standard prints not have it

	unsigned long timeBegin = micros();

	for (uint16_t i = 0; i < BENCHMARK_SERIAL; i++) {

		printA("Exec.: ");
		printA(i+1);
		printA(" of ");
		printlnA(BENCHMARK_SERIAL);

	}

	unsigned long elapsed = (micros() - timeBegin);

	debugSetProfiler(true); // Restore

	// Note not using SerialDebug macros below, to show equals that SerialPrints

	Serial.print("*** Benchmark of Serial printA. Execs.: ");
	Serial.print(BENCHMARK_SERIAL);
	Serial.print(" time elapsed -> ");
	Serial.print(elapsed);
	Serial.println(" us");

}

void benchSerialAll() {

	benchSerialPrint();

	delay(1000); // To give time to send any buffered

	benchSerialDebug();

	delay(1000); // To give time to send any buffered

	benchSerialDbgPr();
}

// Example functions with argument (only 1) to call from serial monitor
// Note others types is not yet available in this version of SerialDebug

void funcArgStr (String str) {

	debugA("*** called with arg.: %s", str.c_str());
}
void funcArgChar (char character) {

	debugA("*** called with arg.: %c", character);
}
void funcArgInt (int number) {

	debugA("*** called with arg.: %d", number);
}

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

Ver código sin formato

Códigos de configuración para el depurador

Para llamar funciones a través de Serial Monitor o SerialDebugApp (ver parte 3), debe usar el depurador en el configuración() Función de tu boceto. Por ejemplo:

// Add functions that can be called from SerialDebug

if (debugAddFunctionVoid("benchInt", &benchInt) >= 0) {
  debugSetLastFunctionDescription("To run a benchmark of integers");
}

if (debugAddFunctionVoid("benchFloat", &benchFloat) >= 0) {
  debugSetLastFunctionDescription("To run a benchmark of float");
}

if (debugAddFunctionVoid("benchGpio", &benchGpio) >= 0) {
  debugSetLastFunctionDescription("To run a benchmark of Gpio operations");
}

if (debugAddFunctionVoid("benchAll", &benchAll) >= 0) {
  debugSetLastFunctionDescription("To run all benchmarks");
}

if (debugAddFunctionVoid("benchSerialPrints", &benchSerialPrint) >= 0) {
  debugSetLastFunctionDescription("To benchmarks standard Serial debug");
}

if (debugAddFunctionVoid("benchSerialDebug", &benchSerialDebug) >= 0) {
  debugSetLastFunctionDescription("To benchmarks SerialDebug");
}
if (debugAddFunctionVoid("benchSerialDbgPr", &benchSerialDbgPr) >= 0) {
debugSetLastFunctionDescription("To benchmarks SerialDebug print macros");
}

if (debugAddFunctionVoid("benchSerialAll", &benchSerialAll) >= 0) {
  debugSetLastFunctionDescription("To benchmarks all Serial");
}

if (debugAddFunctionStr("funcArgStr", &funcArgStr) >= 0) {
  debugSetLastFunctionDescription("To run with String arg");
}

if (debugAddFunctionChar("funcArgChar", &funcArgChar) >= 0) {
  debugSetLastFunctionDescription("To run with Character arg");
}

if (debugAddFunctionInt("funcArgInt", &funcArgInt) >= 0) {
  debugSetLastFunctionDescription("To run with Integer arg");
}

También puedes hacerlo más corto y sin descripciones:

debugAddFunctionVoid("benchInt", &benchInt);

Nota: En la versión actual solo se admiten funciones con los siguientes requisitos:

• Sin argumento (nulo)
• O un argumento de tipo int, char o string

Consejo: Puede crear una función genérica con un argumento para fines de depuración. Luego puede llamar a esta función y pasar varios argumentos para probarla.

El código anterior establece funciones que comienzan con “F» Dominio:

Nota 1: dominio «F“sin argumentos enumera todas las funciones disponibles.

Nota 2: Para esta publicación estamos usando ESP32 con todas las características de SerialDebug porque tiene suficiente memoria.

Para invocar la primera función, simplemente ingrese el siguiente comando: f1

Para llamar a una función que requiere un argumento, puedes escribir un comando como este: «f 11 123“. En este caso, la función 11 recibió el valor 123 como argumento.

Ver/cambiar valores de variables globales

Para utilizar variables globales en el depurador, debe configurarlas en el configuración() Función:

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

if (debugAddGlobalUInt8_t("mRunSeconds", &mRunSeconds) >= 0) {
  debugSetLastGlobalDescription("Seconds of run time");
}
if (debugAddGlobalUInt8_t("mRunMinutes", &mRunMinutes) >= 0) {
  debugSetLastGlobalDescription("Minutes of run time");
}
if (debugAddGlobalUInt8_t("mRunHours", &mRunHours) >= 0) {
  debugSetLastGlobalDescription("Hours of run time");
}

// Note: easy way, no descriptions ....

debugAddGlobalBoolean("mBoolean", &mBoolean);
debugAddGlobalChar("mChar", &mChar);
debugAddGlobalByte("mByte", &mByte);
debugAddGlobalInt("mInt", &mInt);
debugAddGlobalUInt("mUInt", &mUInt);
debugAddGlobalLong("mLong", &mLong);
debugAddGlobalULong("mULong", &mULong);
debugAddGlobalFloat("mFloat", &mFloat);
debugAddGlobalDouble("mDouble", &mDouble);

debugAddGlobalString("mString", &mString);

// Note: For char arrays, not use the '&'

debugAddGlobalCharArray("mCharArray", mCharArray);

// Note, here inform to show only 20 characteres of this string or char array

debugAddGlobalString("mStringLarge", &mStringLarge, 20);

debugAddGlobalCharArray("mCharArrayLarge", mCharArrayLarge, 20);

Esto es lo que debe tener en cuenta al utilizar la función de depuración para ver/modificar valores de variables globales:

• Solo funciona con variables globales que se definen fuera de una función, generalmente antes de cualquier definición de función.
• No use esto para variables locales, ya que siempre se accede a ellas y una variable local es una posible inexistencia de esa variable que resultaría en un acceso a la memoria no válido.
• Deberías tener una función para cada tipo de valor, por ejemplo: depurarAddGlobalString()
• Para ayudarlo a migrar su código para usar SerialDebug, existe un convertidor que lee su código y genera automáticamente el código setup() para variables globales: Convertidor de depuración en serie

Listar variables globales

Para enumerar todas las variables globales, simplemente use el comando «GRAMOPrimero ingresa “dbg”para habilitar el depurador y luego use el comando “g”.

Nota: Para evitar la sobrecarga de procesamiento del depurador, siempre se inicia deshabilitado. Cuando está habilitado, el depurador monitorea los procesos, como puede ver en la siguiente imagen:

De forma predeterminada, el depurador del monitor se detiene. Si no quieres esto, usa el comando «wa ns«:

Ahora usa el comando “GRAMO”para enumerar todas las variables globales:

Para cambiar una variable global, por ejemplo el número global 07 – mInt(int)solo da la orden “g7 = 10«:

Nota: el depurador le pedirá confirmación para cambiar el valor de la variable. Sólo tienes que «j» en comando: «g 7 = 10 si«

Puedes usar el comando “¿GRAMO?”para ver ayuda sobre comandos de variables globales.

Agregar/modificar vigilancias de variables globales

El monitoreo es una buena característica de cualquier depurador. Supervisa una variable específica y muestra un mensaje cuando la variable ha cambiado o ha alcanzado un estado preestablecido. Por ejemplo, imagine el siguiente escenario:

• Tenemos una variable global mControl que no se puede poner a cero.
• Sin embargo, durante las pruebas el valor fue cero.
• Para detectar este error simplemente agregamos un monitor con la condición “mControl == 0“.
• Cuando esto ocurre, se activa un monitor y podemos verlo en el monitor serie.
• Al analizar el resultado de la depuración antes de monitorear, podemos determinar la posible fuente de este error.

Los relojes se pueden configurar de 2 maneras:

• En el configuración() Función (este reloj no se perderá cuando se apague o reinicie el dispositivo)
• En Serial Monitor o SerialDebugApp

Configuración de relojes en la función setup()

Para el ejemplo de SerialDebug_Advanced tenemos lo siguiente:

// Watch -> mBoolean when changed (put 0 on value)
debugAddWatchBoolean("mBoolean", DEBUG_WATCH_CHANGED, 0);

// Watch -> mRunSeconds == 10
debugAddWatchInt("mRunSeconds", DEBUG_WATCH_EQUAL, 10);

// Watch -> mRunMinutes > 3// Watch -> mRunMinutes > 3
debugAddWatchUInt8_t("mRunMinutes", DEBUG_WATCH_GREAT, 3);

// Watch -> mRunMinutes == mRunSeconds (just for test)
debugAddWatchCross("mRunMinutes", DEBUG_WATCH_EQUAL, F("mRunSeconds"));

Tenga en cuenta que la supervisión se puede configurar para una condición específica o para un cambio en variables (globales).

Se pueden utilizar los siguientes tipos de reloj:

• DEBUG_WATCH_CHANGED -> ¿Valor cambiado?
• DEBUG_WATCH_EQUAL -> Igual a (==)
• DEBUG_WATCH_DIFF -> Diferente (!=)
• DEBUG_WATCH_LESS -> Menos (<=)
• DEBUG_WATCH_GREAT -> Más grande (>)
• DEBUG_WATCH_LESS_EQ -> Menor o igual a (<=)
• DEBUG_WATCH_GREAT_EQ -> Mayor o igual a (>=)

Para enumerar los relojes en funcionamiento, utilice «que«:

Para ver ayuda para monitorear comandos, use “¿qué?» Dominio:

Macros de depuración

En la Parte 1 vimos las macros de impresión para la biblioteca SerialDebug. Es como un Serial.print() estándar. También podemos utilizar las macros de depuración con el potente imprimirf Formateo independientemente de si la tarjeta tiene Serial.printf de forma nativa o no. Hasta donde yo sé, sólo las tarjetas Espressif tienen Serial.printf de forma nativa.

Por ejemplo, este extracto:

Serial.print("*** Example - varA = ");
Serial.print(varA);
Serial.print(" varB = ");
Serial.print(varB);
Serial.print(" varC = ");
Serial.print(varC);
Serial.println();

Se puede convertir en un solo comando:

debugD("*** Example - varA = %d varB = %d varC = %d", varA, varB, varC);

Y puedes agregar más parámetros de formato:

debugD("*** Example - varA = %02d varB = %02d varC = %02d", varA, varB, varC);

“%02” significa: al menos 2 dígitos, posiblemente con cero al principio (por ejemplo, 2 se muestra como 02).

Comparación de diferentes tipos de resultados de depuración:

• Las macros de impresión son más fáciles de migrar y no tienen gastos generales (es una macro simple para el comando Serial.print).
• Las macros de depuración son más potentes, pero no son tan fáciles de migrar y tienen una sobrecarga adicional (aproximadamente un 1 % más).

Depende de usted, puede usar la macro de impresión simple o la poderosa macro printf o depuración.

Envolver

En este segundo artículo aprendiste a utilizar los sencillos comandos del depurador de software. biblioteca serialdebug en el IDE de Arduino para enumerar y ejecutar funciones, enumerar y modificar variables globales y configurar monitores.

En la Parte 3, aprenderá cómo aprovechar al máximo estas funciones con SerialDebugApp.

sigue leyendo: Mejor depuración para Arduino IDE: SerialDebugApp (Parte 3)

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 con Software Debugger (Parte 2)

Este tutorial fue escrito por João Lopes y editado por Sara Santos.

La biblioteca SerialDebug creada por João Lopes te permite mejorar la depuración para el Arduino IDE. En este artículo te mostrará cómo utilizar el simple software debugger de la biblioteca SerialDebug que tiene la mayoría de las funcionalidades de un hardware debugger.

Depurador de software simple

Cuando estaba desarrollando en ESP-IDF (SDK nativo ESP32), usaba un hardware debugger, utilizando hardware externo compatible con JTAG, GDB server y Eclipse CDT. Esta es una gran solución para la depuración porque puedo ver el valor de las variables, establecer puntos de interrupción, ejecutar el código paso a paso y más.

Sin embargo, hasta ahora el Arduino IDE no admite hardware debugger. Si deseas utilizar un hardware debugger, necesitas:

• Un hardware externo (JTAG, Atmel-Ice, etc.)
• Otro IDE (Eclipse, Atmel Studio, etc.)
• Habilidades para configurarlo y usarlo

Existen soluciones más simples, pero no son gratuitas, como MicroStudio. Es por eso que tan poca gente utiliza el debugger en Arduino IDE. Principalmente, toda la depuración en Arduino IDE se hace con comandos Serial.print.

Cuando estaba desarrollando la biblioteca SerialDebug, pensé en cómo llevar algunas características de un hardware debugger a Arduino sin necesidad de hardware ni habilidades adicionales. La biblioteca SerialDebug tiene un debugger de software simple. Echemos un vistazo más de cerca a sus características:

• Simple: Es un debugger simple, pero funcional. No tiene todas las características de un debugger de hardware real (como la capacidad de ejecutar el código paso a paso).
• Software: Está implementado en software, no en hardware como un debugger de hardware real. Pero está optimizado para reducir la memoria y el exceso de procesamiento. Por esta razón, esta característica en la biblioteca SerialDebug comienza deshabilitada hasta recibir el comando «dbg».
• Debugger: Es un debugger, puedes enviar comandos en el monitor serie como:
• Llamar a una función (funciona si el debugger está habilitado o deshabilitado)
• Mostrar y cambiar valores de variables globales (funciona solo si el debugger está habilitado)
• Agregar o cambiar watches para variables globales (funciona solo si el debugger está habilitado)

Nota: debido a las limitaciones de memoria del programa, el simple software debugger no se ejecuta en placas de baja memoria como Arduino Uno. Pero puedes probar el debugger con esta placa desactivando el modo DEBUG_MINIMUM, simplemente comenta la línea 64 de SerialDebug.h.

Cómo utilizar el Simple Software Debugger

Primero, sigue los pasos en la Parte 1 de esta serie para instalar la biblioteca SerialDebug. Luego, abre el ejemplo avanzado. En el menú Archivo, selecciona Ejemplos > SerialDebug > SerialDebug_Advanced.

Luego selecciona Avr para Arduino con arquitectura AVR, como Uno, Leonardo y Mega. O Otros para Arduino como Due, MKR, Teensy, Esp8266 y Esp32. Para este post, usamos la placa ESP32 y el ejemplo en el directorio «Others».

El siguiente código debería abrir:

(Incluir todo el código HTML aquí)

Configuración de Códigos para el Debugger:

Para llamar funciones a través del Monitor Serie, o SerialDebugApp (véelo en la Parte 3), debes configurar el debugger en la función setup() de tu esquema. Por ejemplo:

(Incluir todo el código HTML aquí)

Añadir / Cambiar Relojes para Variables Globales

Un reloj es una buena característica de cualquier debugger. Observa una cierta variable y muestra un mensaje si la variable ha cambiado o ha alcanzado una condición preestablecida.

(Incluir todo el código HTML aquí)

Estilos de escritura: Académico. Tono de voz: Narrativo.