DEV Community: Iddar Olivares

Rust para Embebidos?

Iddar Olivares — Mon, 20 Jul 2020 04:00:38 +0000

Durante los días pasados estuve leyendo sobre el tema para preparar este post, es mucha información y que lo mas seguro termine siendo toda una serie.

Quiero agradecer tanto al equipo de Electronic cats como al equipo de de nrf-rs que estuvieron ayudándome a resolver dudas sobre el hardware y el funcionamiento de las bibliotecas.

Material

Para la practica de hoy requerimos una placa con nrf52840 como lo es la Bast BLE y un debuger, yo usare el Black magic Probe que vimos como programar en post anteriores.

Software

En tu sistema debes contar con el toolchain de ARM instalado y agregado al path, Rust para este post se usa la versión 1.45.0 para el proyecto final usare GNU Make para cargar el firmware.

Estructura de un proyecto.

En este ejemplo quiero platicar como iniciar un proyecto de Rust para embebidos desde cero. Por lo cual debo comentar varias partes previas a código de nuestro uC.

$ mkdir nfr-blik
$ cd nrf-blink
$ cargo init

Creamos la carpeta para nuestro proyecto y dentro ejecutamos cargo init, cargo es un el manejador de paquetes de Rust y con el comando init le indicamos que cree un proyecto nuevo. El resultado de este comando se debe ver algo así:

.
├── Cargo.toml
└── src
    └── main.rs

Esta es la estructura base de cualquier proyecto en Rust:

src: este directorio almacena todos el codigo de nuestro proyecto, si vemos incluye por defecto un Hello world en el archivo main.rs
Cargo.toml: este archivo incluye la descripción de nuestro proyecto y las dependencias del mismo.

Dependencias

Para nuestro proyecto requerimos tres dependencias, las cuales nos facilitan el trabajo. Abre el archivo Cargo.toml en tu editor favorito y agrega las dependencias justo debajo de[dependancies] ver el ejemplo a continuación:

[dependencies]
nrf52840-hal = "0.11.0"
cortex-m-rt = "0.6.12"
panic-halt = "0.2.0"

cortex-m-rt: esta el la biblioteca base para trabajar con ARM Cortex-M incluye las configuraciones base del sistema manejo de memoria, registro etc, que son comunes en toda la familia microcontroladores.
panic-halt: Siempre debemos indicar un handler en caso de que algo salga mal, este paquete nos ahorra este paso dotándonos de una función genérica para esto.
nrf52840-hal: esta es una capa de abstracción creada por el equipo de nrf-rs la cual tiene mapeados todos los registro del uC al igual de dotarnos de algunas funciones y utilerias que veremos mas adelante.

Target

Debemos indicar al compilador de Rust cual es el target para nuestro binario, en este caso la plataforma es ARM; para esto crearemos un carpeta .cargo en la raiz de nuestro proyecto y dentro un archivo de nombre config en el colocaremos las derectiva, aprovecharemos para agregar el soporte para arm con el comando rustup.

$ mkdir .cargo # el nombre de la carpeta inicia con un punto
$ touch .cargo/confg # con este comando creamos el archivo
$ rustup target add thumbv7em-none-eabihf

Al archivo .cargo/confg agregamos las siguientes lineas

[build]
target = "thumbv7em-none-eabihf"

Hora del código

El momento esperado llego veamos como podemos controlar nuestro uC. Colocare el código y luego explicare cada parte

#![no_std]
#![no_main]

extern crate panic_halt;
extern crate nrf52840_hal;
use cortex_m_rt::entry;

use nrf52840_hal::prelude::*;
use nrf52840_hal::pac::Peripherals;
use nrf52840_hal::gpio::*;
use nrf52840_hal::Timer;

#[entry]
fn main() -> ! {
    let board = Peripherals::take().unwrap();
    let p0 = p0::Parts::new(board.P0);
    let mut led1 = p0.p0_24
        .into_push_pull_output(Level::High);

    let mut timer = Timer::new(board.TIMER0);

    loop {
        led1.set_low().unwrap();
        timer.delay(1_000_000);
        led1.set_high().unwrap();
        timer.delay(1_000_000);
    }
}

Como puedes ver son muy pocas lineas las que se requieren para esta tarea. Veamos cada una a detalle:

#![no_std] y #![no_main] la primera de ellas le dice al compilador que el programa debe compilarse sin la biblioteca entandar ya que no corre sobre un sistema operativo (no tenemos files ni sockets), la segunda que no tiene un punto de entrada definido.
Luego tenemos la sección de dependencias que ya hablamos antes.
#[entry] justo antes de la definición de nuestra función main vemos esta instrucción que lo que le indica al compilador es que esta sera principal de nuestro programa.
fn main() -> ! {}: si ya habías programado en rust antes seguro esto te llama la atención; el tipo de retorno ! indica que esta función nunca terminara, esto porque dentro tenemos un bucle infinito.
Peripherals::take() aquí creamos una instancia de nuestro uC esta es la forma en la que funcionan todos los Cortex-M en rust y desde aquí podemos interactuar e inicializar los periféricos.
p0::Parts::new(board.P0) aquí inicializamos el reloj de puerto 0, veremos mas sobre como funciona los relojes y los periféricos en ARM en aproximas entregas.
p0.p0_24.into_push_pull_output(Level::High)con figuramos el pin como push_pull (te recomiendo ver el esquema de los pines si tienes dudas sobre como funciona esto.) este nos regresa una instancia Pin que usaremos para configurar el estado del mismo. En este ejemplo el pin que utilizamos es el 24 del puerto 0
Timer::new(board.TIMER0) para poder generar un retraso para poder parpadear el led usaremos un instancia del Timer 0.
loop {} este es un bucle infinito equivalente a cuando usamos el metodo loop en un sketch de arduino.
led1.set_low() y led1.set_high() son métodos utilitarios para cambiar el estado de los pines.
timer.delay(1_000_000); utilizando la instancia del Timer 0 podemos ejecutar su método delay el cual genera un retardo.

Cargar el programa

Antes de grabar el programa debemos generar el binario para esto nos ayudamos de cargo como vemos a continuación:

$ cargo build --release

Esto nos genera un archivo en binario en la ruta

target/thumbv7em-none-eabihf/release/nrf-blink

Este archivo lo usaremos para grabar nuestro micro. Tal como vimos en articulos anteriores conectamos nuestra placa al depurador y ejecutamos arm-none-eabi-gdb

$ arm-none-eabi-gdb
# Con esto entramos a la consola para debug
GNU gdb (GNU Arm Embedded Toolchain)
For help, type "help".
(gdb)
(gdb) target extended-remote /dev/ttyACM0
(gdb) monitor swdp_scan
  > Target voltage: 2.9V
  > Available Targets:
  > No. Att Driver
  >   1      Nordic nRF52 M4
  >   2      Nordic nRF52 Access Port
(gdb) attach 1
(gdb) load target/thumbv7em-none-eabihf/release/nrf-blink
(gdb) compare-sections
(gdb) detach
# ctrl + d para salir

Listo tenemos nuestro Blink compilado y cargado en nuestro ARM felicidades.
En los próximos artículos hablaremos sobre los puertos seriales y otros periféricos.

Leer y escribir memorias SD desde arduino

Iddar Olivares — Fri, 17 Jul 2020 05:49:17 +0000

Uno de los motivos por lo que inicie este blog es documentar mi aprendizaje en el campo del machine learning para embebidos; el recurso mas vital para este campo son los datos, de los cuales nuestro modelos se nutren para aprender.

Es por eso que en esta entrega aprenderemos a trabajar con memorias SD y a la par aprender como podemos almacenar nuestro datos para que sea mas fácil trabajar con ellos.

Las memorias SD soportan varios protocolos de comunicación entre los cuales encontramos SPI el cual es un viejo amigo de los que trabajamos con microcontroladores. La parte divertida viene en como conectamos las memorias a nuestro integrado.

En el mercado puedes encontrar un sin fin de breakboard, adaptadores, conectores para este propósito. Si no puedes esperar a que el correo llegue puedes armar un adaptador como este que me encontré en mi caja de herramientas de mis tiempos de estudiante.

material

Adaptador microSD a SD
Tira de headers
Cautín y soldadura

Solo requieres un adaptador de microSD a SD y una tira de headers. Los headers se ajustan casi a la perfección con los pads del adaptador solo hace falta ajustarlos un poco, puedes ayudarte con unas pinzas para esto. Después de soldar los pines agregue un poco de resina epoxica solo para reforzar la unión.

Wiring

Para conectar nuestro improvisado adaptador debemos de revisar al pinout de la memoria para asi identificar cuales conexiones usar. Aqui debajo les dejo el diagrama de los pines.

Dependiendo del microcontrolador que estas usando deberas conectar los pines correspondientes, en caso de usar un Arduino UNO segun la documentacion son los siguentes.

 ** MOSI - pin 11 on Arduino Uno
 ** MISO - pin 12 on Arduino Uno
 ** CLK - pin 13 on Arduino Uno
 ** CS - depends on your SD card module.

En mi caso estoy trabajando con la Bast Ble de Electronic Cast la cual tiene etiquetados los puertos correspondientes y para el SS utilizo el Pin A3 por cercania.

para probar basta cargar el sketch de ejemplo de SD incluido en nuestro arduino IDE por default.

Si todo salio bien podemos ver en la consola serial lo siguiente.

Initializing SD card...
Wiring is correct and a card is present.

Card type:         SD2
....
....

Flash nrf52840 con OpenOCD y Black magic probe

Iddar Olivares — Wed, 15 Jul 2020 20:10:51 +0000

Hace unos días recibí una gran sorpresa por correo, la nueva placa de Electronic Cats que están por lanzar en un par de semanas, la Bast BLE la cual incluye con un chip nrf52840 de Nordic el cual es una verdadera bestia.

El nrf52840 esta basado en un ARM Cortex-M4 con FPU corre a un máximo de 64MHz, cuanta con un Radio de 2.4Ghz compatible con Bluetooth 5 y una larga muy larga lista de características te recomiendo darte una vuelta por el sitio oficial.

La placa que me enviaron aun esta en proceso de desarrollo por lo que es necesario actualizar y probar nuevas versiones del firmware.

Material

nrf52840 dev board (yo usare la Bast Ble)
Black magic probe (ver mi post anterior)

Wiring

Dependiendo de tu debbuger el pinout puede cambiar en mi caso usare el Black magic basado en ST de mi post pasado y la Bast Ble de la cual encontaras los pines SWD debajo de placa.

Bast Ble       Black magic
GND             GND
SWDIO           PB14
SWCLK           PA5
POWER           3.3V

Flash

Una vez que tenemos conectado todo podemos ir a la accion para esto es importante tener instalado y en PATH el toolchain de ARM en especial arm-none-eabi-gdb.

Identifica el puerto de tu debugger en mi caso ttyACM0.

$ arm-none-eabi-gdb
# Con esto entramos a la consola para debug
GNU gdb (GNU Arm Embedded Toolchain)
For help, type "help".
(gdb)
(gdb) target extended-remote /dev/ttyACM0
(gdb) monitor swdp_scan
> Target voltage: 2.9V
> Available Targets:
> No. Att Driver
>   1      Nordic nRF52 M4
>   2      Nordic nRF52 Access Port 
# ctrl + d para salir

Con esto verificamos que estemos conectados correctamente, explico un poco los comando de arriba

target extended-remote /my-current-port: con este commando nos conectamos al servidor para debug.
monitor swdp_scan: Con este listamos los dispositivos conectados por SWD, en este caso vemos el nRF52

Si todo va bien podemos conectarnos al dispositivo con el siguiente comando

# donde '1' corresponde al primer dispositivo de la lista
(gdb) attach 1

Podemos encontrar la ultima versión del firmwarwe para Bast Ble en el repositorio oficial de Electronic Cats, descarga el archivo HEX en tu directorio de trabajo.

wget https://raw.githubusercontent.com/ElectronicCats/ArduinoCore-nRF528x-mbedos/bast_ble/bootloaders/bastble/bast_ble_bootloader-0.3.2.hex

grabar el nuevo firmware usaremos la siguiente secuencia de comandos, ejecutando arm-none-eabi-gdb desde tu directorio de trabajo.

(gdb) target extended-remote /dev/debug-port
(gdb) monitor swdp_scan
(gdb) attach 1
(gdb) load bast_ble_bootloader-0.3.2.hex
(gdb) compare-sections
(gdb) mon hard_srst
(gdb) detach
(gdb) kill

Listo si todo salio bien solo resta desconectar el cableado y conectar tu Bast Ble por su puerto USB, al arrancar veras que se monta un dispositivo de almacenamiento y se lista un nuevo puerto serial, esto nos indica que todo salio bien ahora.

Ahora puedes usar adafruit-nrfutil o configurar tu arduino IDE siguiendo los pasos mostrados en la documentación de Electronic Cats

NOTA: Para programar tu Bast Ble debes presionar dos veces reset para entrar al modo boot.

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

Crea un Black Magic Probe con un STM32F103

Iddar Olivares — Wed, 15 Jul 2020 01:33:57 +0000

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.

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 descomprimirlo y agregarlo al $PATH.

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

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

$ 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

$ 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 agregaremos el firmware DFU para poder hacer mas fácil la carga de nuevas versiones.

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

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

# 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).