Crea un Black Magic Probe con un STM32F103
Tags: arm, arduino, gdb, electronic
Published: 2020-07-15 01:33:57

---
title: Crea un Black Magic Probe con un STM32F103
published: true
description: Utilizando un clon de la tarjeta de desarrollo del STM32F103 crearemos un Debugger usando el firmware de Black Magic Probe
tags: arm, arduino, gdb, electronic
cover_image: https://dev-to-uploads.s3.amazonaws.com/i/93xuif9n91pg5pl03w3b.jpg
---

En este post veremos como transformar una placa de desarrollo de ST en un Black Magic Probe, para lo cual requerimos el siguiente material: 

```
- STM32F103 Dev board
- FTDI FT232 (USB-Serial)
```

## Wiring
Lo primero que haremos es cablear nuestro hardware. para lo cual necesitamos un par de jumpers. Dependiendo de tu adaptador USB serial deberlas conectarte a la terminal de 5v o 3.3v en su defecto. 

```
FTDI       STM32F103
RXD  <---->  A9
TXD  <---->  A10
GND  <---->  GND
VCC  <---->  VCC
```

En esta ocacion programaremos nuestra placa utilizando el bootloadder Serial para lo cual debemos de mover el jumper `BOOT0 -> 1` y `BOOT1 -> 0` como se muestra en la imagen.

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/n6zwt6gtrm09iczq479e.jpg)

## Dependencias del sistema
Para poder utilizar el tool de `st` así como para compilar la el código de Black magic probe requerimos tener instalado python en nuestro sistema así como GIT y el compilador de ARM.

Para instalar `gcc-arm` basta con descargar paquete para tu sistema operativo desde [aqui](https://developer.arm.com/tools-and-software/open-source-software/developer-tools/gnu-toolchain/gnu-rm/downloads) descomprimirlo y agregarlo al `$PATH`.

*NOTA: Puede que tu adaptador USB-Serial requiera drivers específicos asegurarte de tenerlos instalados antes de continuar*

```shell
# ej:
$ export PATH=$PATH:~/gcc-arm-none-eabi/bin/
# en algunos casos se requiere `libncurses5`
$ apt-get install libncurses5
```

Para el resto clonaremos los repositorios necesarios e instalaremos las dependencias requeridas.

```shell
$ mkdir playground && cd playground
$ git clone https://github.com/jsnyder/stm32loader.git
$ git clone https://github.com/blacksphere/blackmagic.git

# creare un anviente con la version 2.7 de python 
# si tu version de python pory default es 3 esta 
# es la mejor opcion utilizando `virtualenv`
$ virtualenv --system-site-packages -p python2.7 ./myemv
$ source ./myenv/bin/activate
$ (myenv) pip install pyserial
```

En este punto debes de tener esta estructura
```
── playground
   ├── myemv
   ├── blackmagic
   └── stm32loader
```
## Compilando Black Magic

```shell
$ cd blackmagic
# ejecuta make para que se recopilen todos los submódulos
$ make
# si todo salio bien ahora debes entrar al directorio
# src y compilar la versión especifica para el STlink
$ cd src
$ make clean && make PROBE_HOST=stlink

# al terminal debes encontrar los siguientes archivos
$ ls
> blackmagic_dfu.bin 
> blackmagic.bin
cd ../.. # regresamos a la carpeta playground
```

## Flash ST Dev Board
Con ayuda de [stm32loader](https://github.com/jsnyder/stm32loader) agregaremos el firmware DFU para poder hacer mas fácil la carga de nuevas versiones.

```shell
$ cd stm32loader
# tty.SLAB_USBtoUART es igual al puerto de tu dispositivo
# en mi caso ttyUSB0
$ python ./stm32loader -p /dev/tty.SLAB_USBtoUART -e -w -v ../blackmagic/src/blackmagic_dfu.bin
```

Si todo salio bien ahora podremos usar `dfu-util` cada vez que debamos actualizar la versión de nuestro firmware. 

```shell
# podemos instalar dfu-util dede apt
$ apt install dfu-util # with sudo
# agregamos nuestro usuario al grupo `dialout`
$ usermod -a -G dialout $USER # with sudo

# este comando lista los dispositivos dfu
$ dfu-util -l
```

Reinicia tu dispositivo al terminal, desconecta todos los cables y conectarlo desde el puerto USB.

# Debugger

Una vez conectado nuestro dispositivo veras dos puertos nuevos `/dev/ttyACM0` y `/dev/ttyACM1` el primero es que requerimos para hacer el debug y el segundo es un monitor serial.

```shell
# con esto nos conectamos a nuestro debugger
$ arm-none-eabi-gdb -ex "target extended-remote /dev/ttyACM0"

# Dentro de la consola de gdb podemos usar comandos como
# `monitor swdp_scan` el cual nos muestra si tenemos un
# dispositivo conectado.
(gdb) monitor swdp_scan
> Target voltage: 2.94V
> Available Targets:
> No. Att Driver
>   1      STM32F40x M3/M4
```

Para conectarnos a un dispositivo por medio de JTAG/SWD usaremos el siguiente pinout

```
TARGET          DEBUGGER
GND             GND
SWDIO           PB14
SWCLK           PA5
POWER           3.3V
```

para una conexion Serial/UART este:

```
TARGET          DEBUGGER
RXD             PA3
TXD             PA2
```

`Disclaimer: Todas los pruebas mostradas en este articulo fueron realizadas sobre la distribución Ubuntu (GNU/Linux).`