1. Ciencia

Introducción a la programación
con ARM Cortex M4
Firtec Capacitación en Electrónica
Realizado y editado por:
`
Calle San Lorenzo 2755 – Rosario (Santa Fe)
(S2000KPK) ARGENTINA
e-mail: [email protected]
[email protected]
Revisión: Noviembre 2014
Pagina 2
Índice de contenido
Prefacio..................................................................................................................................................5
Capitulo I...............................................................................................................................................6
Historia de la Arquitectura ARM.......................................................................................................6
Que es Cortex M4.............................................................................................................................8
Algunos detalles del STM32F407VG. ..............................................................................................9
Características heredadas de RISC...................................................................................................11
Algunas ventajas de RISC...............................................................................................................11
Desventajas de RISC. .....................................................................................................................11
Bus AMBA......................................................................................................................................11
Pipeline...........................................................................................................................................12
FPU.................................................................................................................................................14
ARM y Thumb................................................................................................................................14
Modos de Funcionamiento..............................................................................................................14
Modo usuario (Thread ). .................................................................................................................15
Modos de Privilegios (Handler).......................................................................................................15
El sistema de memoria ARM...........................................................................................................16
Que es CMSIS.................................................................................................................................18
Características de la placa entrenadora............................................................................................21
Configurando el entorno de trabajo..................................................................................................26
Puedo programar el microcontrolador sin un programador específico?............................................29
Mi Primer Programa en KEIL..........................................................................................................30
Capitulo II............................................................................................................................................39
Interrupciones. ................................................................................................................................39
Temporizador del sistema (SysTick)................................................................................................46
Funcionamiento de la USART.........................................................................................................55
Conversor Analógico con STM32F407VG......................................................................................62
Capitulo III..........................................................................................................................................65
Pantalla LCD 16x2 con STM32.......................................................................................................65
Voltímetro con pantalla LCD 16x2..............................................................................................67
Midiendo la temperatura del Núcleo Cortex................................................................................69
Canales DMA..................................................................................................................................74
Modo DMA de doble buffer.............................................................................................................87
Emular memoria EEPROM en FLASH...........................................................................................87
Protocolo I2C..................................................................................................................................90
Puerto SDIO con STM32...............................................................................................................100
Memoria SD con FAT....................................................................................................................105
Ejemplo de manejo de FAT con STM32....................................................................................112
Creando un disco extraíble a partir de una memoria SD............................................................116
Capitulo IV.........................................................................................................................................118
FSMC (Flexible Static Memory Controller)..................................................................................118
Pantallas TFT............................................................................................................................118
Pantalla TFT HY32C – HY32D................................................................................................119
Sensor de imagen OV7670 con STM32F407...........................................................................125
Formato de la imagen................................................................................................................126
RGB..........................................................................................................................................126
Pagina 3
Señales de la camara.................................................................................................................128
SCCB (Serial Camera Control Bus)..........................................................................................130
Estructura del proyecto DCMI_OV7670...................................................................................132
Manejo del Touch-Screen..........................................................................................................135
Protocolo 1-wire............................................................................................................................141
Niveles eléctricos del bus..........................................................................................................141
Envío y recepción de datos........................................................................................................142
Ejemplo con 1-Wire y el sensor DS18B20 & UART.................................................................142
Ejemplo con 1-Wire y el sensor DS18B20 & LCD TFT............................................................146
Ethernet y MII (Media Independent Interface)...............................................................................149
Señales del transmisor Ethernet.................................................................................................149
Señales del receptor Ethernet....................................................................................................149
Reducción Media Independent Interface (RMII).......................................................................150
El stackt LwIP controlando LED´s mediante CGI.....................................................................152
SSI (Server Side Include)..........................................................................................................156
CAN BUS ( Controller Area Network)..........................................................................................160
CAN BUS Loop Back (Sin la capa física).................................................................................162
CAN NORMAL (Con la capa física).........................................................................................170
Bibliografía........................................................................................................................................178
Carpetas con Ejemplos (Opcional).....................................................................................................179
Carpeta con Herramientas (Opcional)................................................................................................180
Pagina 4
Preámbulo.
Hace algún tiempo escuche a un técnico amigo decir “La electrónica ya no sirve como
negocio”, comentario que luego escucharía varias veces mas en dichos de otros técnicos.
Lo que me llevo a analizar lo que estaba realmente pasando ya que en general podemos
ver que los negocios tecnológicos nunca han sido tan rentables como en estos tiempos.
Estaba claro que el problema no era la rentabilidad en si, sino la imposibilidad de
evolucionar juntamente con la electrónica lo que lleva a los técnicos y desarrolladores a
trabajar con tecnologías obsoletas y porciones de mercado minoritarios o de bajo perfil
económico que impacta directamente en las ganancias que genera el trabajo.
La solución para revertir esta situación es clara, subir un escalón en la escalera
tecnológica, evolucionar y cambiar el escenario del simple técnico reparador al desarrollo
de aplicaciones con microcontroladores. El técnico tiene una posición de privilegio en este
camino ya que el conoce los principios básicos electrónicos y perfectamente puede
convertirse en reparador de sus propias invenciones, siendo posible armar toda una
estructura comercial con pilares como desarrollo, fabricación y mantenimiento.
También el ingeniero en software tiene la oportunidad de convertir su trabajo en un
paquete que puede integrar tanto Software como Hardware desarrollando la totalidad de
su proyecto, esto debido a la abstracción del Hardware que ofrecen los entornos de
programación actuales con librerías y módulos de Software que nos separan de los
enredosos laberintos de registros y configuraciones diversas de los microcontroladores
actuales siendo ahora mucho mas simple para los programadores informáticos acceder a
este segmento de electrónica programable.
En las páginas siguientes encontrará información sobre como trabajar con la arquitectura
de ARM tomando como ejemplo el Microcontrolador Cortex M4 de STMicroelectronics.
Como verá mas adelante ARM es líder mundial en núcleos de microcontroladores de 32 bits
lo que supone lo colocará en el campo del desarrollo con la última tecnología existente.
También es mi obligación comentar que las siguientes páginas tiene un grado de
complicación importante y se da por hecho que usted entiende de electrónica digital, sabe
lo que es un microcontrolador y está familiarizado con el lenguaje C ya que estará usted
programando en 32 bits en Ansi-C.
Espero que el presente trabajo sea útil para hacerle el camino un poco mas sencillo y solo
me resta agradecerle que nos permita acompañarlo en su crecimiento.
Daniel Schmidt
Dirección General de Firtec
Pagina 5
Esto último es muy importante porque marca una de las grandes diferencias con un microcontrolador
de 8 bits o de arquitectura “tradicional” en donde podemos tener la certeza de que cada operación dura
un determinado tiempo o ciclo de CPU lo que lleva a que los tiempos en juego se pueden determinar
con facilidad. En un micro de 32 bits hay varios buses y los tiempos ya no son tan fáciles de predecir ya
que otros periféricos pueden estar usando estos buses o si el micro tiene memoria cache esto altera los
tiempos en juego por lo que debe usted desterrar la idea que solo basta con contar las instrucciones y
multiplicar por la velocidad del bus.
Lo siguiente que puede resultar un poco confuso es que todo dentro del Cortex tiene su reloj individual
que por defecto esta desconectado.
Es decir entonces que para hacer uso de un módulo una de las configuraciones que debemos incluir es
activar y el reloj y determinar una frecuencia de operación dentro del rango que el bus admite.
Pipeline.
Se llama “pipeline” a la técnica que aprovecha un método para optimizar los recursos de hardware y
también el rendimiento del procesador.
Consiste en comenzar a procesar una instrucción antes de que se haya finalizado de procesar la actual.
En la siguiente figura se ilustra la ejecución de instrucciones con la técnica pipeline.
Tomando la secuencia de operaciones a partir de la instrucción “1”, el procesador se organiza de tal
manera que tan pronto como haya completado la primera etapa de esa instrucción, “fetch” y haya
avanzado hacia la segunda etapa, comenzará la primera etapa, “fetch”, de la próxima instrucción. En
principio, de esta manera el tiempo de ejecución debería ser hasta seis veces más veloz que el que
corresponde a instrucciones no superpuestas pero, como veremos luego, en la práctica no ocurre así.
Una de las características clave del alto desempeño de los microcontroladores ARM es el pipeline.
ARM7 tiene un pipeline de tres etapas que aumentan el flujo de instrucciones a través del procesador.
Así que cada instrucción se ejecuta en tres etapas:
1) Recoger: Se lee la instrucción de la memoria y se coloca en el pipeline
2) Decodificar: Se decodifica la instrucción.
3) Ejecutar: Se ejecuta la instrucción.
Pagina 12
(2UL << 2*13) |
(2UL << 2*14) |
(2UL << 2*15) );
GPIOD->PUPDR &= ~((3UL << 2*12) |
(3UL << 2*13) |
(3UL << 2*14) |
(3UL << 2*15) ); /* PD.12..15 is Pull up */
GPIOD->PUPDR |= ((1UL << 2*12) |
(1UL << 2*13) |
(1UL << 2*14) |
(1UL << 2*15) );
}
En las líneas siguientes vemos la misma configuración con CMSIS.
void Led_Init(void){
GPIO_InitTypeDef GPIO_InitStructure;
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE); /* GPIOD
/* Configure PD12, PD13, PD14 and PD15 in output pushpull mode */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12 | GPIO_Pin_13| GPIO_Pin_14| GPIO_Pin_15;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(GPIOD, &GPIO_InitStructure);
}
Como se puede observar la diferencia es importante siendo que ambos códigos hacen exactamente lo
mismo a nivel de hardware.
Lo primero que hace el micro al arrancar, es leer las dos primeras posiciones de la tabla de vectores de
excepciones. Esta tabla se puede reubicar luego, pero al momento del reset se encuentra en la dirección
0x00000000. La primera posición corresponde a la dirección de inicio del stack, al final del área
reservada para éste, dado que crece “hacia abajo”, es decir, su dirección se decrementa conforme
guarda mayor cantidad de elementos. El valor alojado aquí será cargado automáticamente en el Stack
Pointer al momento de iniciar luego de un reset. La segunda posición es el vector de reset, la dirección
donde se empieza a ejecutar el código.
En CMSIS, el archivo que contiene todo esto se denomina: startup_stm32f4xx.s será s para
Pagina 19
Desde la lengüeta Debug siempre dentro de Utilities indicamos que el programador es del tipo SW y no
del tipo JTAG. (Si olvido este paso el programador NO FUNCIONARÁ.)
Puedo programar el microcontrolador sin un programador específico?
El controlador STM32F407VG y todos los
dispositivos de STMicroelectronics tienen
incorporado un cargador que funciona con el
protocolo UART y que permite bajar nuestro
código directamente a la memoria FLASH de
controlador.
Solo se necesita un conversor USB-RS232 para
nuestra notebook, elegir el COM en uso,
conectar el TX al pin PB10 y RX al pin PB11 en
el caso del STM32F407VG.
Si durante el arranque del controlador detecta un
nivel alto en el pin Boot 0 ejecuta el cargador
que espera recibir el programa que se guardará
en FLASH a través del puerto COM.
Luego se cambia el nivel de Boot 0, un RESET y
se ejecuta el programa grabado.
Es importante comentar que este cargador no
consume recursos del microcontrolador ni memoria de programa, es un módulo aparte agregado por
STM para simplificar el proceso de grabación de la FLASH con la aplicación programada.
Pagina 29
Mi Primer Programa en KEIL
Teniendo todo ya configurado vamos a intentar escribir nuestro primer programa, una plantilla genérica
de un programa con CMSIS.
Podemos ver aquí los dos archivos para el inicio del sistema generados por CMSIS.
El archivo startup_stm32f4xx.s es el archivo de arranque del sistema dentro de este archivo se puede
leer lo siguiente:
El archivo startup_stm32f4xx.s llama a funciones que se encuentran en system_stm32f4xx.c, este
archivo es el que contiene la configuración de hardware del microcontrolador como velocidad de los
buses, tipo de cristal, reloj para USB, etc.
*===============================================================================
*
Supported STM32F4xx device revision
| Rev A
*----------------------------------------------------------------------------*
System Clock source
| PLL (HSE)
*----------------------------------------------------------------------------*
SYSCLK(Hz)
| 168000000
*----------------------------------------------------------------------------*
HCLK(Hz)
| 168000000
*----------------------------------------------------------------------------*
AHB Prescaler
| 1
*----------------------------------------------------------------------------*
APB1 Prescaler
| 4
*----------------------------------------------------------------------------*
APB2 Prescaler
| 2
*----------------------------------------------------------------------------*
HSE Frequency(Hz)
| 8000000
*----------------------------------------------------------------------------*
PLL_M
| 8
Pagina 30
Temporizador del sistema (SysTick).
Es un temporizador presente en el núcleo del controlador, es independiente del fabricante e
integrado al núcleo ARM esta disponible en todos los fabricantes.
El funcionamiento es bastante simple existiendo la función SysTick_Config() donde n
puede ser cualquier valor no mayor a 0xFFFFFF .
Importante:
Tel valor puesto como argumento en la función SysTick_Config() no puede ser mayor a un valor
de 24 bits 0xFFFFFF (16777215).
Como calcular el tiempo del Systick.
Suponiendo que estamos trabajando con un reloj de 168Mhz el período de este reloj será de:
1/168Mhz = 0.005952 nS
Ahora bien, si configurarmos el SysTick de la siguiente forma:
SysTick_Config(SystemCoreClock / 1000)
Tenemos un reloj de 168000, lo que llamaremos módulo del SysTick. Si multiplicamos el módulo por
el tiempo de CPU:
0.005952 * 168000 = 999.9 mS
El SysTick se interrumpe cada 999.9 milisegundos generando un señal de 500Hz.
Recordar:
Básicamente se multiplica el tiempo de CPU por el módulo establecido en SysTick_Config().
Veamos como funciona el siguiente programa que enciende el LED naranja de la entrenadora
Discovery al ritmo que fija la rutina de conteo:
void retardo(uint32_t nCount){
while(nCount--){}
}
Es decir que cambiando la variable nCount cambia la velocidad el bucle y también el tiempo de
encendido de este LED.
También se ha configurado el SysTick() para controlar el LED verde de la entrenadora.
SysTick_Config(SystemCoreClock / 1000);
En PD12 (LED Verde) deberíamos tener un señal de 500Hz con un periodo total de 2 milisegundos.
Importante:
Cuando una variable se declara de la siguiente forma: __IO uint32_t. es una variable volatile. Ej:
__I volatile const , __O volatile , __IO volatile.
Pagina 46
Funcionamiento de la USART
En la actualidad y ante la ausencia de puertos RS232
en las computadoras, acostumbramos a trabajar con
puentes USB-RS232 que solucionan muchos o todos
los problemas a la hora de vincularnos con
computadoras a través del viejo protocolo 232.
El STM32F407VG tiene un par de UART y varias
USART que podemos usar incluso en distintos pines
según nuestra conveniencia.
El controlador no resuelve la capa física, es decir que para
implementar las comunicaciones deberemos utilizar ya sea el
clásico MAX232 o los modernos puentes USB-232.
Esto es particularmente interesante porque con esta tecnología
podemos reutilizar los viejos programas en puertos COM que
por cuestiones de licencias o complejidad son mas simples de
implementar que las aplicaciones USB nativas.
El ejemplo que vamos a ver recibe los datos enviados desde el teclado de una PC y los re-transmite
como un eco por el mismo puerto serial.
Configuramos la USART 2 y le asignamos los pines GPIOA 2 para recibir y el GPIOA 3 para transmitir.
Observe que se declaran las estructuras correspondientes al puerto, al controlador de interrupción y la
estructura de la USART.
GPIO_InitTypeDef GPIO_InitStructure;
USART_InitTypeDef USART_InitStructure;
NVIC_InitTypeDef NVIC_InitStructure;
También se declaran las estructuras correspondientes a los relojes tanto del USART como del puerto
involucrado.
RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
Preste atención a que se hace referencia al bus APB1
dado que la USART que vamos a usar se encuentra en ese
bus.
Y desde luego AHB1 que es el bus para los puertos
GPIO.
Si observa la distribución de pines en el chip
STM32F407VG notará que es posible asignar los pines GPIO a voluntad a distintos módulos, por
ejemplo la USART2 podría también estar conectada a otros pines, lo cual lleva a pensar en que
momento y como se asignan los pines a los módulos.
Podemos ver aquí lo siguiente:
GPIO_PinAFConfig(GPIOA, GPIO_PinSource2 ,GPIO_AF_USART2);
GPIO_PinAFConfig(GPIOA, GPIO_PinSource3 ,GPIO_AF_USART2);
Aquí se conectan los pines al módulo, la denominación como AF lo define como alterno a otro módulo.
Pagina 55
Para el trabajo que proponemos como ejemplo, la memoria debe estar ya formateada, para esto se
puede usar el propio sistema operativo o la aplicación SDFormatter que encontrará entre las
herramientas del curso.
La idea es lograr escribir con el microcontrolador un archivo de texto (Hola.txt) con el contenido
“Manejando archivos con FAT”.
Luego podemos ver el contenido de este archivo en nuestra computadora como se muestra en la
siguiente imagen.
También vamos a crear un archivo de texto (Mensaje.txt) con un texto cualquiera que será leído por
nuestro controlador y toda la información del contenido de la memoria será enviada a través del puerto
serial .
La comunicación se establece a 11520 baudios.
El pin PC_7 es asginado a la recepción y el pin PC_6 a transmisión.
La trama se establece en 8 bits S/Paridad.
Pagina 110
Creando un disco extraíble a partir de una memoria SD.
Teniendo ya control del puerto SDIO y manejo de FAT lo siguiente que
vamos a intentar construir es un proyecto que usará el puerto USB de
usuario en la placa Discovery para crear un disco extraíble usando como
unidad de disco la propia memoria SD.
Esto puede resultar muy interesante a la hora de construir sistemas
colectores de datos donde la información es almacenada en la memoria SD
y al conectar el puerto USB a una computadora esta identifica nuestro micro
como una unidad de disco donde podemos descargar los datos guardados o incluso bajar a la memoria
SD nuevos datos, por ejemplo de configuración o variables usadas por nuestro dispositivo.
Vemos aquí una captura de pantalla al conectar la placa sin la memoria SD colocada, la computadora
detecta la unidad como unidad de disco.
Pagina 116
Captura de pantalla en el momento en que se conecta la memoria SD. Como se observa el sistema
detecta nuestra memoria como una unidad de disco donde podemos leer, borrar o guardar doscumentos
creados en nuestra computadora. El proyecto completo listo para ser compilado y/o reformado a
voluntad lo encontrará en la carpeta USB_MemSD.
Utiliza el puerto USB de usuario.
Proyecto completo
Pagina 117
Sin embargo para poder “programar” esta página dentro del controlador es necesario un paso
intermedio que es compilar el sitio web y darle un formato que nuestro Keil pueda manejar.
Para esto STM provee una herramienta que resuelve el problema makefsdata.exe es el “compilador”
de web´s.
Sin embargo hay algunas reglas a seguir, observe la imagen anterior en donde se ve una carpeta
llamada fs. Se debe llamar de esta forma puesto que el compilador espera encontrar en esta carpeta
todos los archivos de nuestra web.
Todos los archivos de la página web se almacenará en la memoria de programa Flash, se integrará en el
Pagina 153
servidor DHCP configura la placa asignándole una dirección IP.
Los archivos httpd.c, stm32f4x7_eth.c juntos con sus respectivos archivos de cabecera configuran el
resto de las funciones de red del stack LwIP.
SSI (Server Side Include).
El siguiente trabajo es ETHERNET_LED&Conversor donde trabajamos con los LED´s y medimos el
voltaje aplicado al pin GPA6 provisto por el conversor analógico uno.
Para esto usamos SSI que es un conjunto de directivas que se evaluan en uestra web cuando se pide
información desde la página web, SSI al igual que CGI se utiliza para generar contenidos dinámicos en
los sitios web.
Si observamos estos dos trabajos notaremos que en el primero desde el sitio web se envían comando al
hardware (LED´s). En este trabajo se lee una variable desde el hardware y se muestra la información en
la web, es decir el proceso inverso.
El archivo encargado del manejo de datos hacia y desde la web es httpd_cg_ssi.c donde vemos que se
declara un tag para la interfaz SSI .
char const* TAGCHAR="t";
char const** TAGS=&TAGCHAR;
Este identificador “t” se usará para “representar” los datos en la web
Pagina 156
derive a masa, el sistema trabajará con la señal Low con respecto a masa, en el caso de que se
interrumpa la línea L, ocurrirá lo contrario. Esta situación permite que el sistema siga trabajando con
uno de los cables cortados o comunicados a masa.
Es importante tener en cuenta que el trenzado entre ambas líneas sirve para anular los campos
magnéticos, por lo que no se debe modificar en ningún caso ni el paso ni la longitud de dichos cables.
Dado que la línea es un par trenzado se necesitan resistencias de terminación 120 ohm en ambos
extremos del bus, solo colocar la resistencias en los extremos no en los nodos individuales.
El controlador STM32F407VG tiene dos puertos CAN, estos puertos tienen todo lo necesario a nivel
lógico para el tratamiento de las tramas CAN sin embargo para implementar las comunicaciones se
necesita la capa física (al igual que Ethernet, RS-232, etc).
La capa física la implementamos con un integrado muy popular en el mundo CAN que ademas de ser
muy económico funciona muy bien y se puede conseguir ya montado en una placa como se ve en la
imagen. Para verificar el funcionamiento del CAN inicialmente no necesitamos la capa física puesto
que podemos colocar el puerto en modo Loop Back y establecer una comunicación entre los dos
puertos CAN a nivel de registros, es decir mover los datos internamente sin sacarlos al exterior.
Pagina 161