debugging-profesional-nanoframework

Depuración en nanoFramework: breakpoints y variables

  • 5 min

El debugging en nanoFramework es la capacidad de pausar e inspeccionar el código mientras corre en el microcontrolador.

Una de las ventajas más claras frente al ciclo de prueba y error habitual en sistemas embebidos es la depuración integrada.

Cualquiera que haya programado microcontroladores sabe lo doloroso que es el ciclo de “prueba y error”:

  1. Escribes código.
  2. Llenas todo de Serial.println("Entré en el IF");.
  3. Compilas y subes (esperas 1 minuto).
  4. Miras el monitor serie y rezas para entender qué ha pasado.

Con nanoFramework y Visual Studio, esto es historia. Podemos pausar el tiempo, inspeccionar el cerebro del microcontrolador mientras funciona y ver exactamente qué está ocurriendo.

Es una de las ventajas más claras de nanoFramework. En este artículo vamos a aprender a usar estas herramientas.

La ventana de salida

Empecemos por lo básico. En Arduino, para ver mensajes en el PC, necesitabas inicializar el puerto serie, configurar los baudios (115200) y usar un programa terminal.

En nanoFramework, la comunicación de depuración está integrada en el propio protocolo que usa Visual Studio.

using System.Diagnostics;

// ... dentro de tu código
Debug.WriteLine("Hola desde el ESP32");
Copied!

Al ejecutar tu programa (F5), este mensaje aparecerá automáticamente en la ventana Salida (Output) de Visual Studio.

No necesitas configurar baudios ni abrir puertos COM. Visual Studio canaliza estos mensajes a través de la conexión de depuración automáticamente.

Breakpoints: pausar la ejecución

Un Breakpoint (punto de interrupción) es una señal que le dice al microcontrolador: “Cuando llegues a esta línea, detente y espera órdenes”.

Para poner uno, simplemente haz clic en el margen gris a la izquierda de tu código, o pulsa F9 sobre la línea. Aparecerá un círculo rojo.

Cuando el programa llegue ahí:

La ejecución en el chip se congela.

Visual Studio se pone en modo “Depuración” (marco naranja en la parte inferior).

Una flecha amarilla indica la próxima instrucción que se va a ejecutar.

Una vez pausados, podemos controlar la ejecución. En la barra de herramientas superior verás los botones correspondientes, aunque también puedes usar estos atajos de teclado:

  • F10 (Step Over): Ejecuta la línea actual y pasa a la siguiente. Si la línea es una llamada a una función, la ejecuta entera y pasa a la siguiente línea de tu código.
  • F11 (Step Into): Si la línea es una llamada a una función, se mete dentro de esa función para que puedas depurarla línea a línea.
  • Shift + F11 (Step Out): Ejecuta lo que queda de la función actual y vuelve a quien la llamó.

Imagina que tienes un bucle for que falla en la iteración 3. Puedes ir pulsando F10 y ver ciclo a ciclo cómo cambia todo. Es como ver una película frame a frame.

Inspección de variables

Mientras el programa está pausado, puedes saber el valor de cualquier variable en ese instante exacto.

Existen tres formas de hacerlo:

Pasar el ratón (hover)

Simplemente pasa el cursor del ratón sobre una variable en tu código. Aparecerá un pequeño recuadro (DataTip) mostrándote su valor actual. Si es un objeto complejo (como un sensor), puedes desplegarlo y ver sus propiedades internas.

Ventana de locales (Locals)

En la parte inferior, busca la pestaña Locales. Aquí Visual Studio te muestra automáticamente todas las variables que existen en el contexto actual de la función. Es genial para ver de un vistazo cómo cambia el estado de todo tu método.

Ventana de inspección (Watch)

¿Quieres vigilar una variable específica que no está en el ámbito local, o una expresión matemática? Haz clic derecho sobre una variable -> Agregar a inspección (Add to Watch). Esto crea una lista personalizada donde puedes ver valores específicos siempre.

Modificar valores al vuelo

Esto suele dejar con la boca abierta a quien lo ve por primera vez.

Imagina que tienes este código:

if (temperatura > 50) 
{
    EncenderVentilador();
}
Copied!

Estás depurando, pero tu sensor marca 25ºC. No quieres calentar el sensor con un mechero para probar el if.

  1. Pon un Breakpoint en el if.
  2. Cuando se pare, busca la variable temperatura en la ventana de Locales.
  3. Haz doble clic en el valor 25.
  4. Escribe 60 y pulsa Enter.

¡Acabas de cambiar la memoria del microcontrolador en tiempo real! Al pulsar F10, el programa evaluará 60 > 50 y entrará en el if.

Esta capacidad para forzar condiciones y simular estados de error es muy útil para probar sistemas robustos sin tener que reproducir físicamente las condiciones extremas.

Breakpoints condicionales

A veces no quieres parar siempre. Imagina un bucle que se ejecuta 1000 veces y falla en la última. No vas a pulsar F5 1000 veces.

  1. Pon un Breakpoint (punto rojo).
  2. Haz clic derecho sobre el punto rojo -> Condiciones.
  3. Escribe una expresión booleana, por ejemplo: i == 999.

Visual Studio solo detendrá el microcontrolador cuando esa condición sea cierta.

¿Qué pasa con las excepciones?

En Arduino, si accedes a un array fuera de índice o divides por cero, el microcontrolador suele reiniciarse o quedarse colgado (el famoso Guru Meditation Error del ESP32).

En nanoFramework, Visual Studio capturará la Excepción.

La ejecución se detendrá automáticamente, te llevará a la línea exacta del error y te mostrará un mensaje emergente explicando qué pasó (System.IndexOutOfRangeException, System.NullReferenceException, etc.).

El depurador de Visual Studio con nanoFramework transforma el desarrollo de sistemas embebidos. Pasamos de “adivinar qué pasa” a “ver qué pasa”.