STM32F407 Discovery - Emulador Game Boy

Introducción

En busca de proyectos interesantes para mi Discovery STM32F407:

Me topé con bitbox:
http://bitboxconsole.blogspot.com.ar/

 

BitBox es un proyecto DIY desarrollado inicialmente para juegos "retro" y que fue derivando en distintos usos.

El creador del proyecto lo realizó para un STM32F405, pero son muy similares al F407 que posee la discovery. 

Las principales características son:
*- Soporte para gamepad, teclado o mouse.
*- Soporte para tarjetas uSD
*- Salida de audio stereo
*- Salida VGA 640x480 @ 15bpp
Y algunas virtudes mas.

A continuación describiré el método que utilicé para poner en marcha mi STM32F407 Discovery, con bitbox, y correr algunos juegos "nativos" como así también emuladores para zx spectrum (basic!!!) o gameboy.

Nos centraremos en "bitboy" que es el port de "gnuboy" para bitbox.

Lo descripto anteriormente se realizó sobre Debian 8. Aún no lo intenté en window$.

Comenzando

Software

La descarga del toolchain y del binario de OpenOcd y el método que utilizo personalmente fue descripto en esta entrada, por lo que aquí solo recordaré de donde descargarlo sin mayores preámbulos.

Lo primero que necesitaremos será el toolchain para compilar. Así que nos dirigiremos a la siguiente página y descargaremos el acorde a nuestra distribución.

https://developer.arm.com/open-source/gnu-toolchain/gnu-rm/downloads

Una vez descargado descomprimimos en una ruta de nuestra preferencia. Recomiendo un directorio en donde alojar los toolchains para las distintas arquitecturas que testearemos (anotemos o recordemos la ruta donde lo descomprimimos).

Necesitaremos también de OpenOcd http://openocd.org/.

Y el binario compilado para Debian (estimo que en ubuntu debería funcionar sin problemas), lo descargamos de aquí:

https://github.com/gnu-mcu-eclipse/openocd/releases

Finalmente lo descomprimimos en una ruta de nuestro agrado.

Siguiendo, descargaremos desde GitHub el repositorio del kernel bitbox:

https://github.com/makapuf/bitbox

Aquí podremos decargarlo con "git clone" desde consola, o simplemente presionamos en el botón verde que dice "clone or download" y luego seleccionamos "download zip".

Nuevamente elegimos una ruta de nuestro agrado y descomprimimos.

Por último descargamos también desde GitHub el repositorio de bitbox:

https://github.com/makapuf/bitboy

El método de descarga es el mismo que el anterior.

Recomiendo crear en su "home" el directorio "bitbox-workspace" y dentro de este descagar bitbox y bitboy. Esta es la manera que utilicé para este tutorial.

Hardware 

ADVERTENCIA!!:
Para las conexiones siguientes se debe poseer un mínimo de conocimiento en electrónica. Además entender que un error en el conexionado o cables que se unen incorrectamente o pines que se "tocan" entre sí y no corresponden, puede ocasionar daños IRREVERSIBLES sobre la Discovery. NO me hago cargo de nada de lo que aquí se describe, al seguir los siguientes pasos se entiende que ustedes, o quién sea, entiende los riesgos que se corren.


Con respecto al hardware, debo aclarar que aún no logré que funcionara correctamente la tarjeta SD, probablemente se deba a los componentes conectados en la Discovery y que utilizan los mismos puertos que la SD y de alguna forma interfiere. Logré leer y escribir pero al momento de hacer stream (audio o video) entre la SD y bitbox, funciona unos segundos y luego se tilda.

Entonces, para poder adaptar nuestra Discovery a bitbox, sin soporte para SD y utilizar bitboy haremos lo siguiente.

Primero, si han descargado y descomprimido el kernel del bitbox y navegan un poco por las carpetas que contiene, observarán un directorio nombrado "hardware", dentro de él encontrarán los distintos esquemas eléctricos y revisiones. Les facilito una imagen de la revisión actual y el utilizado aquí.

Imagen del archivo en eagle convertido a JPG de la rev2

Lo que a priori recomiendo, es que realicen solo las conexiones hacia monitor VGA.
Se puede observar que posee un DAC R2R conectado al puerto E (PE0-14) por cada canal RGB construído con resistencias. En la construcción que realicé, utilicé valores comerciales al 5% de tolerancia disponibles en la mayoría de las casas de electrónica.

DAC Hi-Tech by T'T :)

RGB0, RGB5, RGB10 = 8K2
RGB1, RGB6, RGB11 = 4K7
RGB2, RGB7, RGB12 = 2K2
RGB3, RGB8, RGB13 = 1K
RGB4, RGB9, RGB14 = 560 Ohm

Por supuesto que no es lo mismo que los valores originales al 1%, pero la calidad de imagen es mas que aceptable, al menos para los ensayos iniciales.

Los puertos utilizados para los distintos canales (para los que no están muy familizarizados con los esquemas) son:

Canal B (blue): PE0 a PE4 (RGB0 a RGB4)
Canal G (green): PE5 a PE9 (RGB5 a RGB9)
Canal R (red): PE10 a PE14 (RGB10 a RGB14)

Además, como pueden observar en la imagen, las puertos PA0 y PA1 corresponden al sincronismo vertical y al sincronismo horizontal respectivamente, hacia VGA.

En la misma imagen pueden notar a X1 que corresponde a un DB15 para VGA con la correspondencia de pines y conexiones.

Una vez realizadas las conexiones anteriores, están en condiciones de descargar el firmware para los primeros ensayos.

DAC conectado a la Discovery

En marcha.

Para los primeros ensayos NO compilaremos. Utilizaremos los .bin que las descargas poseen.

El autor del proyecto a creado una especie de "bootloader" el cual será lo primero que grabaremos en nuestra placa.

Dicho "Bootloader" permite el arranque del sistema desde la Flash o desde la SD solo presionando un botón, el llamado "user button" en el esquema.

No obstante para ls primeros ensayos no necesitamos de dicho botón. Así que comencemos grabando el 1st_boot.

Una vez que nuestra placa está conectada a la PC nos situaremos en el directorio de  openocd/bin.
 en mi caso:

~/openocd/gnu-mcu-eclipse/0.10.0-5-20171110-1117/bin$

Una vez allí tipearemos lo siguiente (cada quien con su ruta, reemplazar "usuario" por tu nombre en la sesión linux).

~/openocd/gnu-mcu-eclipse/0.10.0-5-20171110-1117/bin$ ./openocd -f ../scripts/board/stm32f4discovery.cfg -c "program /home/usuario/bitbox-workspace/bitbox-master/1st_boot/1st_boot_rev25.bin reset exit 0x08000000" 

Esto graba 1st_boot en la direccón de flash 0x08000000.

Una vez grabado lo anterior pasaremos a grabar a bitboy tal cual como lo descargamos y descomprimimos en bitbox-workspace.
Nuevamente la ruta de cada uno dentro de "bitbox-workspace"

~/openocd/gnu-mcu-eclipse/0.10.0-5-20171110-1117/bin$ ./openocd -f ../scripts/board/stm32f4discovery.cfg -c "program /home/usuario/bitbox-workspace/bitboy-master/bitboy.bin reset exit 0x08004000" 

Ahora notarán que grabamos en la flash a partir de 0x08004000 que es en donde 1st_boot busca lanzar si no se a presionado el user button.

Luego del comando anterior deberían observar en el monitor conectado algo así:

Muy bueno, no ?

Finalizando

Llegados aquí para continuar necesitamos habilitar la conexión USB para conectar un teclado, mouse o gamepad.

En la próxima entrada no solo comentaré como conecté el teclado y el gamepad, sino que explicaré como compilar y agregar juegos... con sonido también.

Los dejo con unos screenshoot de Mega Man y Super Mario Land:

Mi desarrollo para bitbox muy preliminar...

https://youtu.be/FjvIlrv5xZU

 T'T
 

Eclipse + STM32F4 Discovery, primeros pasos en Linux

Introducción

En esta entrada del blog crearemos el entorno para la programación de nuestra STM32F407 Discovery en Linux, específicamente Debian.

La placa que se ha utilizado para este desarrollo es la siguiente:

No obstante seguramente para las variantes de esta, también será válido.

Esta placa además de poseer el microcontrolador STM32F407 (target), también posee el stlink-v2-1, el cual se utiliza para flashear nuestro "target"; pudiendo a su vez programar otro microcontrolador fuera de la placa demo. (para mas info buscar sobre las specs de la placa discovery)

Comenzando

Antes que nada quisiera aclarar que si bien son varios pasos, una vez que se realizan no son tan complejos ni mucho menos. Además nos queda un entorno de trabajo free, sin limitaciones de ningún tipo, con capacidades de Debug y para toda la familia de ST (pronto crearé una entrada para la Blue-pill que posee un STM32F103).

Comenzamos descargando el ToolChain de aquí:
https://developer.arm.com/open-source/gnu-toolchain/gnu-rm/downloads

Seleccionamos acorde a nuestra PC.

Una vez descargado descomprimimos en una ruta de nuestra preferencia. Recomiendo un directorio en donde alojar los toolchains para las distintas arquitecturas que testearemos (anotemos o recordemos la ruta donde lo descomprimimos).

Luego descargamos Eclipse del sitio oficial:
https://www.eclipse.org/

Nuevamente, acorde a la PC de desarrollo.

Descomprimimos el archivo descargado en la ruta de nuestra preferencia.

Nos vamos a la ruta seleccionada y ejecutamos el archivo "eclipse-inst":

Con lo cual se lanzará el instalador, y cuando nos aparezca la siguiente ventana seleccionamos C/C++:

Seleccionamos donde instalar, (utilicé la misma ruta donde descomprimí) y esperamos a que finalice la descarga de los archivos necesarios.

El instalador nos consultará si deseamos lanzarlo o simplemente nos situamos en la ruta de instalación y ejecutamos el archivo "eclipse"

Al iniciar nos pedirá el directorio de trabajo, recomiendo que creen un directorio fuera de la instalación de eclipse.

Normalmente poseo una partición de disco dedicada a mis "source code", en ella creo un directorio con nombre significativo para el "workbench", y la selecciono.


Eclipse Iniciandose.

Una vez iniciado procedemos a instalar el plug-in para microcontroladores de eclipse.
Para ello vamos a Help->Install new software... , y nos aparece la siguiente ventana:

Clickeamos en Add... , y completamos los campos de la siguiente manera:

Para el copy/paste ;)...

Name: GNU MCU Eclipse Plug-ins
Location: http://gnu-mcu-eclipse.netlify.com/v4-neon-updates

Una vez que presionamos OK, buscará en la dirección ingresada, nuevo software.

Nos presentará la siguiente pantalla y seleccionamos todo.

Next...

Nos pedirá autorización y que estemos de acuerdo con la licencia...

Finish... y esperamos.

Una advertencia mas...

Install anyway...

Y restart...

Restart Now.

Si todo fue bien, ahora podremos hacer, "File->New->C Project" y nos aparecerá la siguiente pantalla...

Seleccionamos "STM32F4xx C/C++ Project" que es el microcontrolador que posee nuestra placa, y damos nombre al nuevo proyecto en este caso "testDiscover1" y luego Next, nos aparecerá la siguiente pantalla:

Si dan una ojeada notarán que crearán un proyecto "template" Blinky; el cual destellará uno de los led's. Por el momento dejamos todo como está.

Next..., Next..., Next... y aparecerá la siguiente pantalla:

Aquí indicamos que Toolchan utilizaremos, por lo que primero seleccionaremos en "Toolchain name = Custom (arm-none-eabi-gcc)" y luego escribimos (pegamos) la ruta donde descomprimimos el toolchain incluyendo el directorio "bin", en "Toolchain path", como se ve en la imagen.

Luego presionamos Finish. (dependiendo de la capacidad de la CPU, este proceso toma su tiempo debido a la indexación que realiza Eclipse, el progreso se suele mostrar en el margen inferior derecho).

Una vez finalizado podemos darle una ojeada al main.c

Con los pasos anteriores normalmente se crea un proyecto compatible con nuestra Discovery, por lo que no hay que modificar nada,... por el momento ;)

Ahora es momento de compilar "Ctrl+B" para verificar que todo está funcionando correctamente.

En la parte inferior, en la pestaña "console" se puede corroborar la correcta compilación del proyecto.

 

Descarga del binario en la Discovery.

Bien, con los pasos anteriores tenemos el entorno de desarrollo y el compilador cruzado funcionando, ahora necesitamos de una vía para alojar el binario resultante, en nuestra placa de desarrollo.

Para ello usaremos OpenOCD, que a breve descripción es un debugger abierto y gratuito. 

http://openocd.org/

Existen varias maneras de utilizar este fantástico programa:

*- Instalarlo desde los repositorios oficiales de nuestra plataforma. (googlear como hacerlo)

*- Descargar un binario pre-compilado para nuestra plataforma y utilizar un path absoluto. (esta es la utilizada en esta entrada del blog)

*- Descargar el código fuente y compilarlo nosotros mismo y decidir si lo instalamos o si utilizamos un path absoluto.

 La última opción es mi favorita ya que compilo y siempre dispongo de la versión actualizada del programa. Sin embargo, en ocasiones, me fue necesario conservar una versión anterior, por lo que, actualmente compilo el código fuente, pero no lo instalo, y hago referencia dentro de eclipse al path absoluto. Modificando ese path si algo no se comporta como debiera, y siempre puedo volver a la versión anterior.

  No obstante la compilación de código fuente de programas en la plataforma de desarrollo escapa de esta entrada, por lo que, en esta ocasión, descargaremos una versión compilada y mantenida por usuarios de OpenOcd, para Debian y Windows. Actualmente estoy utilizando esta y para el modesto uso que le doy funciona correctamente. 

 Si ustedes prefieren instalar el programa desde repositorios es totalmente válido, pero no es el método explicado en esta entrada.

https://github.com/gnu-mcu-eclipse/openocd/releases

En mi caso descargo la versión para Debian 64 bit. 

Lo descomprimimos en una ruta de nuestro agrado.

Luego volvemos a eclipse, para configurar el debugger.

Ingresamos a Run->Debug Configurations... y nos aparecerá la siguiente pantalla.

Luego seleccionamos la opción "GDB OpenOCD Debugging" y clickeamos en el botón "New Launch Configuration", quedando de la siguiente manera.

 

Ahora seleccionamos la pestaña "Debugger", y completamos los campos como muestra la imagen. (recuerden colocar la ruta absoluta correcta donde ustedes descomprimieron el OpenOCD.)

 

Dentro de la imagen anterior hay una campo muy importante y es el que se titula "Config Options", allí le decimos a eclipse con que opciones debe lanzar a OpenOCD, en esta caso la opción que le pasamos es la placa que estamos utilizando.

Con respecto a esta opción tuve un inconveniente menor, pero inconveniente en fin.

Al intentar conectar la consola de eclipse me devolvía el siguiente error:

Started by GNU MCU Eclipse
Info : Listening on port 6666 for tcl connections
Info : Listening on port 4444 for telnet connections
Info : Unable to match requested speed 2000 kHz, using 1800 kHz
Info : Unable to match requested speed 2000 kHz, using 1800 kHz
Info : clock speed 1800 kHz
Error: open failed
in procedure 'init'
in procedure 'ocd_bouncer'

Resulta ser que en el archivo "stm32f4discovery.cfg" está definido la versión del stlink-v2 y la placa que poseo tiene el stlink-v2-1, así que si les aparece el error anterior, solo deberán abrir y modificar el archivo con su editor favorito:

$ nano scripts/board/stm32f4discovery.cfg

Buscan la línea que dice:

source [find interface/stlink-v2.cfg]

y modificarla a

source [find interface/stlink-v2-1.cfg]

Una vez realizado lo anterior deberían poder presionar el botón "Debug" y automáticamente se conectarán a su placa por medio de OpenOCD, a la vez se abrirá la interfaz de Debug.

Presionando el botón "resume" o F8 debería correr el programa en su flamante Discovery, y podrán ver como el led verde comienza a parpadear dandonos la bienvenida.

Todos estos pasos solo se hacen una vez, ya que luego pueden volver al entorno de programación y desde allí podrán correr el Debug o Run.

Además si crean un nuevo proyecto todo lo anterior queda almacenado por default en eclipse.

Cerrando

Sería interesante que en estos primeros contactos con la discovery, en vez de que parpadee el led verde parpadee el azul, no?.

Pistas:
1:

Link al PDF completo de la placa 

2:
  include/BlinkLed.h

Final

Para escribir esta entrada, partí de una instalación limpia de eclipse+plug-in+toolchain+openocd, todo en un directorio especial para la ocasión e intenté documentar lo mejor posible los pasos.

Espero que sea de su agrado.

En breve intentaré hacer lo mismo en Window$, y documentarlo de la misma manera, seguro será un poco más fácil, pero dudo que sea divertido y a la vez customizable, como lo es en linux.

T'T.