Débogage sans fil STM32

Je veux parler de l'utilisation inhabituelle d'ESP8266 comme intermédiaire entre STM32 et openOCD. Cette méthode présente de nombreux inconvénients et son application ne peut être causée que par l'impossibilité d'utiliser l'outil de débogage habituel (câblé).

Cette méthode a un plus, et c'est évident, je vais donc aller directement aux inconvénients:

  1. Patch OpenOCD requis
  2. Besoin de changer le firmware dans ESP8266
  3. Basse vitesse

Comment ça marche? OpenOCD implémente le support du protocole SWD, en plus il y a un pilote appelé remote_bitbang. D'après le nom, on peut voir que les niveaux logiques sont simplement transmis par les chiffres 1 et 0 puis envoyés sur le réseau.

Le récepteur (dans notre cas ESP8266) doit régler le niveau correspondant sur les bornes conformément à ces numéros. Malheureusement, remote_bitbang manque de support SWD, mais l'ajouter n'est pas du tout difficile:

Voici un petit patch
--- 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,
 };


Ensuite, nous devons changer le firmware ESP8266 afin qu'il comprenne les commandes provenant d'openOCD. Pour cela, j'ai utilisé le SDK ouvert esp-open-rtos . Je ne donnerai pas l'intégralité du code du firmware - il est plutôt volumineux, je ne donnerai que sa partie concernant le traitement des données reçues d'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);
	}
}


Le code source complet peut être trouvé ici.

J'utilise ESP-01. Elle a deux jambes libres, GPIO-0 et GPIO-2, et lorsqu'elle est activée, la 2ème jambe doit être à un niveau élevé, sinon le contrôleur passera en mode bootloader. Par conséquent, il est conseillé de tirer la jambe vers l'alimentation via une résistance 10k.

Quant à la basse vitesse. Oui, il marche pas à pas assez tristement, mais vous pouvez remplir le firmware, régler une interruption ou lire une variable.

Théoriquement, si vous portez openOCD sur ESP8266, vous pouvez atteindre une vitesse comparable à st-link, mais je le laisse aux lecteurs.

J'espère que quelqu'un pourrait être utile.

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


All Articles