Depuración inalámbrica STM32

Quiero hablar sobre el uso inusual de ESP8266 como intermediario entre STM32 y openOCD. Este método tiene muchas desventajas y su aplicación solo puede ser causada por la incapacidad de usar la herramienta de depuración habitual (por cable).

Este método tiene una ventaja, y es obvio, así que iré directamente a las desventajas:

  1. Se requiere parche OpenOCD
  2. Necesita cambiar el firmware en ESP8266
  3. Baja velocidad

Como funciona OpenOCD implementa soporte para el protocolo SWD, además hay un controlador llamado remote_bitbang. Por el nombre se puede ver que los niveles lógicos son simplemente transmitidos por los números 1 y 0 y luego enviados a través de la red.

El receptor (en nuestro caso ESP8266) debe establecer el nivel correspondiente en los terminales de acuerdo con estos números. Desafortunadamente, remote_bitbang carece de soporte SWD, pero agregarlo no es nada difícil:

Aquí hay un pequeño parche
--- remote_bitbang.c	2016-10-31 11:06:57.812267924 +0600
+++ remote_bitbang.c	2016-10-31 12:33:57.921692808 +0600
@@ -120,11 +120,25 @@
 	remote_bitbang_putc(c);
 }
 
+static int remote_bitbang_swdio_read (void)
+{
+	remote_swd_putc ('R');
+	return remote_bitbang_rread ();
+}
+
+static void remote_bitbang_swdio_drive (bool is_output)
+{
+	char c = is_output ? 'o' : 'i';
+	remote_bitbang_putc (c);
+}
+
 static struct bitbang_interface remote_bitbang_bitbang = {
 	.read = &remote_bitbang_read,
 	.write = &remote_bitbang_write,
 	.reset = &remote_bitbang_reset,
 	.blink = &remote_bitbang_blink,
+	.swdio_read = &remote_bitbang_swdio_read,
+	.swdio_drive = &remote_bitbang_swdio_drive,	
 };
 
 static int remote_bitbang_init_tcp(void)
@@ -271,10 +285,14 @@
 	COMMAND_REGISTRATION_DONE,
 };
 
+static const char * const remote_bitbang_transport[] = { "jtag", "swd", NULL };
+
 struct jtag_interface remote_bitbang_interface = {
 	.name = "remote_bitbang",
+	.transports = remote_bitbang_transport,
 	.execute_queue = &bitbang_execute_queue,
 	.commands = remote_bitbang_command_handlers,
+	.swd = &bitbang_swd,
 	.init = &remote_bitbang_init,
 	.quit = &remote_bitbang_quit,
 };


Luego, necesitamos cambiar el firmware ESP8266 para que comprenda los comandos que provienen de openOCD. Para este propósito, utilicé el SDK abierto esp-open-rtos . No daré el código de firmware completo: es bastante voluminoso, solo daré su parte con respecto al procesamiento de los datos recibidos de openOCD.

Spoiler
#define SWCLK				0
#define SWDIO				2

IRAM void openocd_handler (void *pvParameters)
{
	struct netconn *nc = (struct netconn *) pvParameters;
	struct netbuf *rbuf = NULL;
	char *rx_buf;
	char d, r;
	err_t err;
	uint16_t len;
	uint16_t i;
	
	gpio_set_pullup (SWCLK, false, false);
	gpio_set_pullup (SWDIO, false, false);
	gpio_enable (SWCLK, GPIO_OUTPUT);
	gpio_enable (SWDIO, GPIO_OUTPUT);
	
	while (1)
	{
		if ((err = netconn_recv (nc, &rbuf)) != ERR_OK) {
			printf ("R ERROR %d\n", err);
			return;
		}
		
		netbuf_data (rbuf, (void **) &rx_buf, &len);	
		
		for (i = 0; i < len; i++)
		{
			switch (rx_buf [i])
			{
			case 'Q':		// Quit
				netconn_disconnect (nc);
				return;
			
			case '0'...'7':
				d = rx_buf [i] - '0';
				gpio_write (SWDIO, (d & 0x1));
				gpio_write (SWCLK, !!(d & 0x4));								
				break;
			
			case 'i':
				gpio_enable (SWDIO, GPIO_INPUT);
				break;
			
			case 'o':
				gpio_enable (SWDIO, GPIO_OUTPUT);
				break;
			
			case 'R':		// Writeback
				r = ((char) gpio_read (SWDIO)) + '0';
				netconn_write (nc, &r, 1, NETCONN_COPY);
				break; 
			}
		}
		
		netbuf_delete (rbuf);
	}
}


El código fuente completo se puede encontrar aquí.

Estoy usando ESP-01. Ella tiene dos patas libres, GPIO-0 y GPIO-2, y cuando se enciende, la segunda pata debe estar en un nivel alto, de lo contrario, el controlador entrará en modo de cargador de arranque. Por lo tanto, es aconsejable llevar la pata a la fuente de alimentación a través de una resistencia de 10k.

En cuanto a la baja velocidad. Sí, camina paso a paso con tristeza, pero puede completar el firmware, establecer una interrupción o leer una variable.

Teóricamente, si portas openOCD a ESP8266, puedes lograr una velocidad comparable a st-link, pero lo dejo a los lectores.

Espero que alguien pueda ser útil.

Source: https://habr.com/ru/post/es398781/


All Articles