Quark LXX .::. Módulo de desarrollo para Kinetis: MiniMoon

Acabo de terminar el desarrollo inicial de un pequeño módulo basado en un Kinetis MK22FN512VLH12.

Este micro tiene un núcleo ARM Cortex-M4F y una no desdeñable cantidad de memoria: 512KB de flash y 128KB de RAM. Trabaja hasta los 120MHz y, en este caso concreto, viene en un empaquetado LQFP de 64 pines.

Tras enrutar las alimentaciones, el puerto de programación SWD y los cristales, uno de 8MHz y otro de 32.768KHz, he dejado todos los demás pines accesibles, con lo que he necesitado dos conectores de 50, ha una distancia de 0,7 pulgadas, pare ser compatible con las placas de prototipos estándar.

El aspecto es el siguiente:

MiniMoon. Prototipo.

MiniMoon. Prototipo.

La placa tiene un tamaño aproximado de 64x21mm.

Acepta alimentación tanto desde el puerto USB como a través de uno de sus pines. Esta es derivada a un regulador de 3,3V y 800mA, que están disponibles en otro pin, para alimentar a otros dispositivos que puedan conectarse. En otro, aparecen los 5V provenientes del conector USB tras pasar por un diodo schottky de protección y baja caída de voltaje o, si se utiliza la alimentación opcional, del otro regulador, en este caso de 5V y, también, 800mA.

Dispone de un botón de reset, un LED para comprobar la correcta alimentación del módulo, y un conector SWD, para la programación/depuración con un J-Link o similar.

En resumen, una pequeña placa con todo el hardware mínimo necesario para su utilización en cualquier proyecto sin perder la disponibilidad de ninguna de sus entradas o salidas.

Tras darle un repaso a los archivos gerbers generados por KiCad, ya solo queda enviarlo a producción y, a su recepción, comprobar su funcionamiento adecuado o, en su caso, corregir los errores detectados.

 

Esperando a la versión 1.0…

Quark XLIII .::. Primer proyecto con Em::Blocks y Freescale Kinetis

En el Quark XLII vimos el software necesario para programar Kinetis con Em::Blocks. Ahora nos pondremos manos a la obra con la configuración del entorno para poder programar.

El primer proyecto con nuestro flamante Em::Blocks lo realizaremos con un MKL05Z32VFK4.

Evidentemente vosotros podéis utilizar el que queráis, simplemente eligiendo los archivos adecuados durante la configuración del proyecto.

Manos a la obra:

Abrimos Em::Blocks.

Pulsamos sobre Create a new project en la pantalla de bienvenida.

Se nos abrirá el configurador de proyectos, donde seleccionaremos Empty y pulsaremos Go.

Creando un nuevo proyecto.

Creando un nuevo proyecto.

Elegimos un nombre de proyecto y una carpeta para guardarlo. El mío se llamará EQTest.

Nombre y localización del proyecto.

Nombre y localización del proyecto.

Elegiremos nuestro compilador, ARM GCC Compiler, que Em::Blocks ha instalado automáticamente. Seleccionamos crear tanto las configuraciones de Debug como de Release.

Release y Debug.

Release y Debug.

Ahora, manualmente, copiamos a la carpeta de nuestro proyecto:

– desde Kinetis\MKL05Z4\Include los archivos MKL05Z4.h y system_MKL05Z4.h

– desde Kinetis\MKL05Z4\Source\Templates el archivo system_MKL05Z4.c

– y desde Kinetis\MKL05Z4\Source\Templates\gcc los archivos startup_MKL05Z4.S y MKL05Z32xxx4_flash.ld.

Todos son genéricos para toda la serie MKL05Z excepto el script para el Linker MKL05Z32xxx4_flash.ld que es exclusivo para cada micro en concreto.

Ahora los añadiremos a nuestro proyecto: Project -> Add files recursively…

Añadiendo archivos.

Añadiendo archivos.

Se nos abrirá un diálogo para seleccionar los archivos que queremos incluir en nuestro proyecto. Marcaremos todos excepto el de extensión elay.

Selección de archivos.

Selección de archivos.

Tras pulsar OK Em::Blocks nos pregúntará a qué versión del proyecto queremos añadirlos. Seleccionaremos ambas opciones:

Para Debug y Release.

Para Debug y Release.

Una vez los archivos hayan sido cargados, la extructura de nuestro proyecto será la siguiente:

Estructura del proyecto.

Extructura del proyecto.

Crearemos, ahora, nuestro archivo principal, main. File -> New -> File…

Que será del tipo C/C++ Source.

C/C++ Source.

C/C++ Source.

Concretamente será un archivo de C.

Archivo C.

Archivo C.

Lo guardamos con el nombre de main en la carpeta de nuestro proyecto.

main.

main.

Igualmente, lo añadimos a nuestro proyecto tanto para la versión Debug como Release.

Debug y Release.

Debug y Release.

Y la vista de nuestro proyecto quedará finalmente así:

main editable.

main editable.

Para poder comprobar que todo funciona correctamente necesitamos que main no esté vacía, por lo que que creamos una simple función.

main básica.

main básica.

Y terminamos de configurar el enterno. Project -> Build options…

Project -> Build options...

Project -> Build options…

Especificamos el tipo de microcontrolador, cortex-m0plus, en EQTest:

cortex-m0plus.

cortex-m0plus.

Y tres líneas más abajo, indicamos que utilice como Linker script el que hemos añadido previamente: MKL05Z32xxx4_flash.ld.

Linker script.

Linker script.

En EQTest -> Linker settings indicamos que añada los Start files.

INCLUDE Standar Start files.

INCLUDE Standard Start files.

Aceptamos y ya podemos comprobar que todo está listo para comenzar el diseño.

Pulsamos en Rebuild.

Compilamos.

Compilamos.

Y, si todo ha sido configurado correctamente, obtendremos del compilador una salida similar a esta:

Resultado de la compilación.

Resultado de la compilación.

Y esta:

Más.

Más.

Es un proceso algo tedioso, pero una vez que está terminado es muy fácil adaptarlo a cualquier otro Kinetis, simplemente seleccionando los archivos correspondientes durante la configuración del proceso.

En una próxima entrada configuraremos Em::Blocks para poder utilizar un SEGGER J-LINK con él.

Ahora: ¡A programar!

Quark XLII .::. Configurando Em::Blocks para trabajar con Freescale Kinetis: Software necesario

Últimamente estoy jugueteando con los micros basados en ARM de Freescale, la línea Kinetis.

Sin considerar los entornos profesionales, y astronómicamente caros como KEIL o IAR, hay varias herramientas de desarrollo disponibles para estos micros.

Freescale tiene disponibles un par: CodeWarrior y KDS (Kinetis Design Studio). El primero está basado en Eclipse y es de pago, además Freescale no lo actualizará a los nuevos desarrollos de la serie Kinetis, por lo que solo es/será utilizable con aquellos micros con los que es compatible actualmente. El segundo, por otro lado, también basado en Eclipse, es completamente gratuito e incluye el entorno Processor Expert, un sistema de desarrollo de alto nivel que facilita la creación rápida de aplicaciones.

Para un usuario no profesional como yo, la selección está clara, KDS. Así que lo instalé: un monstruo. Gigantesco, miles de ficheros, cientos de megas, lento, engorroso (lo siento, encuentro Eclipse sobrecargado).

Busqué más alternativas. Y encontré otra opción: Em::Blocks, basado en Code::Blocks, un entorno de desarrollo mucho más ligero. Y con él estoy empezando.

Una puntualización: Em::Blocks solo está disponible para Windows.

Em::Blocks necesita configurarse para trabajar con Kinetis, ya que estos micros aún no están soportados en él directamente, con lo que no existe la posibilidad de autoconfiguración. De eso trata esta serie de artículos que comienza aquí, de la configuración de Em::Blocks para desarrollar aplicaciones para micros Kinetis con el compilador ARM GCC y el depurador JLINK de SEGGER. Crearemos también una pequeña aplicación ejemplo para arrancar.

Em::Blocks tiene una ventaja añadida, soporta directamente las siguientes familias de microcontroladores:

  • Atmel ARM
  • EnergyMicro ARM
  • Microchip dsPIC
  • Microchip PIC18
  • Microchip PIC32
  • Nordic ARM
  • NXP ARM
  • STmicro ARM
  • Texas Instruments MSP430

Para preparar nuestro entorno de trabajo necesitaremos descargarnos lo siguiente:

  1. – Em::Blocks (¡Click!)
  2. – Freescale KDS (¡Click!
  3. – Software para SEGGER JLINK  (¡Click!

No hace falta explicar porqué nos descargamos Em::Blocks, pero la descarga de KDS necesita una explicación. Para la configuración de nuestros proyectos, necesitaremos los header files así como los ficheros de sistema correspondientes al los micros Kinetis y los scripts para el linker, y la única forma que he encontrado de conseguirlos es copiarlos de la instalación de KDS. Un engorro, pero eficaz.

Como he comentado antes, utilizaré un SEGGER JLINK para depurar los programas, así que también necesitamos descargar su software. La versión que utilizo es la de educación (JLINK EDU), que tiene las mismas prestaciones para nuestras necesidades que la version normal, mucho más cara. La version EDU no se puede utilizar para desarrollos comerciales y, una vez al día, muestra una pantalla con sus condiciones de uso.

Una vez completadas las descargas, instalamos todo. La instalación de KDS será temporal, ya que copiaremos los ficheros que necesitamos y procederemos a su desinstalación.

En mi caso he instalado Em::Blocks en C:\EmBlocks.

Y KDS en C:\KDS.

Creamos una nueva carpeta bajo EmBlocks: C:\EmBlocks\Kinetis

Y copiamos todo el contenido de C:\KDS\eclipse\ProcessorExpert\Config\PE\CPE\wizard_data\wizards\kds en ella.

Ya tenemos disponibles todos los archivos que necesitamos referentes a los micros, por lo que podemos desinstalar completamente KDS si no vamos a darle uso.

En el próximo artículo crearemos nuestro primer proyecto con Em::Blocks basado en Kinetis.

Quark XXVI .::. Adaptador JTAG 20 a 10 pines y cable correspondiente

Para juguetear con el microcontrolador Kinetis del que hablé en la entrada anterior, necesito un programador y un depurador hardware. O un programador-depurador. Y uno de los más reconocidos es el J-LINK de SEGGER. Existe en varias versiones, algunas de precio estratosférico, pero también existe una versión económica, el J-LINK EDU, con un precio en torno a los 58€. Este depurador dispone de las mismas capacidades con respecto a su hermano mayor inmediato, el J-LINk (a secas) en cuanto a software y hardware, pero está limitado por su licencia, que lo restringe a un uso estrictamente no comercial.

Así que me he comprado uno. Y ya me ha llegado. Y tiene un conector estandar JTAG de 20 pines. Y mi Kinetis utiliza el protocolo SWD que lleva menos pines. Y con un conector estandar de 10 pines me vale. Y el precio de un simple adaptador de este tipo es absurdamente alto para lo que es. Y entonces decido hacerme yo uno. Y aquí estamos. Y…

Al lío. Aquí tenemos el esquema de las conexiones entre un conector JTAG de 20 pines y uno de 10 pines:

Esquema JTAG de 20 a 10 pines.

Esquema JTAG de 20 a 10 pines.

Sencillo. ¿Porqué un adaptador comecial es tan caro? No lo sé. Quizá se me escape algo.

Del esquema pasamos al PCB y tenemos una plaquita pequeña, simple y de una única cara con pistas:

Vista de la PCB en Altium.

Vista en 2D de la PCB en Altium.

Puedes descargarte el fotolito de la placa en formato PDF desde aquí:

Adaptador JTAG de 20 a 10 pines
Adaptador JTAG de 20 a 10 pines
Adaptador JTAG.pdf
Version: 1.0
7.3 KiB
30 Descargas
Detalles

Una vez diseñada la placa, seguimos el procedimiento habitual (AQUÍ). Con la PCB lista, toca preparar materiales. A parte del adaptador JTAG, para programar el micro necesitaré un cable adecuado. Por ahora tenemos J-LINK <-> Adaptador JTAG 20 a 10, pero nos falta el cable desde el adaptador hasta el microcontrolador. Un cable de 10 pines. Así que necesitamos:

  • PCB del adaptador
  • Conector hembra de 20 pines para la PCB
  • Conector hembra de 10 pines para la PCB
  • Cable de 10 vías
  • Conector macho de 10 pines para el cable

Es decir, todo esto:

Preparado para el ensamblaje.

Preparado para el ensamblaje.

Comenzamos soldando los dos conectores hembra a la placa de circuito impreso, es decir, montamos el adaptador propiamente dicho. Y queda tal que así:

Adaptador JTAG de 20 a 10 pines.

Adaptador JTAG de 20 a 10 pines.

Los manchurrones son debidos al flux, que aún está sin limpiar.

Si le damos la vuelta vemos esto:

Vista de las conexiones.

Vista de las conexiones.

Insisto en la simplicidad de la placa.

Nos ponemos manos a la obra con el cable de seis vías.

Una nota sobre este adaptador y cable. Los conectores y cables de 10 vias “oficiales” para JTAG modernos tienen una separaciones entre pines de 2mm, no los habituales en este tipo de conectores de 2,54mm. En mi caso, y como lo quiero para conectar en una placa de prototipos, utilizo un conector normal y corriente de 10 pines y 2,54 de paso entre ellos.

Primer paso para montar el cable, presentamos éste en su posicion en el conector:

Hilos y "cuchillas" alineados.

Hilos y “cuchillas” alineados.

La parte estrecha del conector tiene surcos donde cada uno de los hilos del cable debe alojarse. La parte ancha, donde están los conectores individuales que encajan en la hembra, tiene unas cuchillas que atraviesan el aislante del cable y conectan físicamente con  el conductor. Hay un par de cuchillas por hilo, de forma que cada uno de ellos encaja entre las dos correspondientes.

Una vez situado el cable en su posicioón correcta con respecto a los surcos y las cuchillas, hay que confirmar la posición global del cable con respecto al conector. El perfil de éste debe ser perfectamente perpendicular con respecto a la dirección del cable:

El cable ha de estar colocado perpendicular a la carcasa.

El cable ha de estar colocado perpendicular a la carcasa.

En su posición definitiva, tendremos algo así:

Otro detalle de la posición adecuada.

Otro detalle de la posición adecuada.

Dejamos un exceso de cable que luego retiraremos, por lo que su longitud no es crítica.

Ahora hay que cerrar el conector. Esto puede hacerse a mano, con unos alicates, … Imaginación. En mi caso utilizo un tornillo con mordazas de goma. Ejerce una presión idéntica en toda la superficie del conector y lo cierra de forma homogénea y sin riesgos de desplazamiento del cable.

El tornillo ejerce una fuerza proporcional en toda la superficie del conector.

El tornillo ejerce una fuerza proporcional en toda la superficie del conector.

Se van cerrando poco a poco las mordazas del tornillo hasta que ambas partes del conector encajan completamente.

Este tipo de soportes tiene mil y una utilidades. Lo recomiendo encarecidamente. En mi caso lo compré hace tiempo en el Lidl. El cabezal es móvil en todas las direcciones. Creo recordar que costó menos de 10€. Búscate uno, me lo agradeceras.

Soporte-tornillo con ventosa del Lidl.

Soporte-tornillo con ventosa del Lidl.

Ahora nos haremos cargo del exceso de cable antes comentado. Una cuchilla y delicadeza para cortar al ras del conector y listo:

Perdón por la falta de foco. No tengo manos suficientes.

Perdón por la falta de foco. No tengo manos suficientes.

Queda así de bonito:

Sección del cable a ras del conector.

Sección del cable a ras del conector.

Hay dos tipos de conectores de esta clase, uno de ellos  el que estoy utilizando, dispone de reductor de tensiones. Esto evita que el punto de unión entre el cable y el conector sufra por el movimiento y el cable se rompa.

Para su instalación doblamos el cable 180º sobre la parte superior del conector y presentamos la grapa que lo sujetará:

El cable se gira 180 grados.

El cable se gira 180 grados.

Mientras sujetamos el cable para que esté bajo cierta tensión, nos ayudamos de nuevo del tornillo con mordazas de goma y terminamos definitivamente el conector:

Conector completamente instalado.

Conector completamente instalado.

Tras este trabajo maratoniano ya tenemos esto:

El conector de 20 pines ha sido reciclado.

El conector de 20 pines ha sido reciclado.

Ahora estamos en el punto:

J-LINK <-> Adaptador JTAG 20 a 10 <-> Cable de 10 pines

Para conseguir:

J-LINK <-> Adaptador JTAG 20 a 10 <-> Cable de 10 pines <-> Placa de prototipos

necesitamos terminar el cable de 10 vías con el conector adecuado.

Podría poner una cabecera de 10 pines, similar a la del adaptador, en la placa de prototipos, pero luego necesitaría cablear la placa desde esa cabecera hasta cada uno de los pines del micro y a la alimentación y masa. Además, cada tipo microcontrolador tiene sus conexiones para JTAG o SWD en pines diferentes. Así que lo mejor es que la terminación del cable sea lo más práctica posible: conectores individuales. Es decir, un pin en cada vía del cable.

Necesitamos una tira de pines, un poco de tubo aislante termoretráctil, y en un par de minutos tenemos:

Cable rematado.

Cable rematado.

Solo echo en falta una forma de indentificar cada cable sin tener que mirar la chuleta. Habrá que solucionarlo.

A probarlo:

Probando, probando...

Probando, probando…

El J-LINK reconoce el micro sin problemas y permite su programación y depuración.

Un par de notas:

  1. Hay que procurar que el cable sea lo más corto posible.
  2. Aunque en el adaptador todas las señales de masa están conectadas entre sí, conviene conectar todos los cables correspondientes a la masa de la placa de prototipos, ya que esto disminuye en ruido y las interferencias en el cable.