• Author / Uploaded
• Aaabel Ciex

Citation preview

Curso introductorio a la arquitectura ARM con Cortex M4

Microcontrolador STM32F407VG

Realizado y editado por:

`

Calle Urquiza 1695 – Gchú. (Entre Ríos) (2820) ARGENTINA e-mail: [email protected] [email protected] Revisión: Marzo 2017

2

Índice de contenido Prologo.......................................................................................................................................................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?.............................................30 Mi Primer Programa en KEIL.............................................................................................................31 Capitulo II................................................................................................................................................41 Interrupciones......................................................................................................................................41 Temporizador del sistema (SysTick)...................................................................................................48 Funcionamiento de la USART.............................................................................................................57 Conversor Analógico con STM32F407VG.........................................................................................64 Capitulo III...............................................................................................................................................67 Pantalla LCD 16x2 con STM32..........................................................................................................67 Voltímetro con pantalla LCD 16x2.................................................................................................69 Midiendo la temperatura del Núcleo Cortex..................................................................................71 Canales DMA......................................................................................................................................77 Modo DMA de doble buffer................................................................................................................90 Emular memoria EEPROM en FLASH..............................................................................................90 Protocolo I2C......................................................................................................................................93 Sensor para medir Temperatura y Humedad HDC1000....................................................................103 Driver para el sensor HDC1000...................................................................................................104 Sensor Barométrico LPS25HB..........................................................................................................110 Driver para el sensor LPS25HB....................................................................................................114 Sensor BME280 (Todo en uno).........................................................................................................119 Impresoras Térmicas.........................................................................................................................121 Puerto SDIO con STM32..................................................................................................................123 Memoria SD con FAT........................................................................................................................128 Ejemplo de manejo de FAT con STM32.......................................................................................135 Creando un disco extraíble a partir de una memoria SD..............................................................139 Control PID.......................................................................................................................................141 3

Funcionamiento general de un PID..............................................................................................142 Control PID con STM32F407......................................................................................................142 Datalogger de temperatura................................................................................................................147 Capitulo IV.............................................................................................................................................154 FSMC (Flexible Static Memory Controller)....................................................................................154 Pantallas TFT................................................................................................................................154 Que es RFID.................................................................................................................................161 Origen de los RFID.......................................................................................................................161 Frecuencias en distintos países.....................................................................................................161 Cantidad de información almacenada en una etiqueta de RFID...................................................162 Etiquetas de lectura y lectura/escritura.........................................................................................162 Etiquetas pasiva y etiquetas activas.............................................................................................162 Colisión entre tarjetas...................................................................................................................162 Modo lector denso........................................................................................................................163 Tags pasivos usados en el ejemplo...............................................................................................163 Receptor RFID CR95HF...............................................................................................................164 Comandos del CR95HF................................................................................................................166 Hardware usado en el proyecto.....................................................................................................176 Driver para RFID CR95HF...........................................................................................................178 Sensor de imagen OV7670 con STM32F407...............................................................................186 Formato de la imagen...................................................................................................................187 RGB..............................................................................................................................................187 Señales de la cámara.....................................................................................................................189 SCCB (Serial Camera Control Bus).............................................................................................191 Estructura del proyecto DCMI_OV7670......................................................................................193 Manejo del Touch-Screen.............................................................................................................196 Protocolo 1-wire................................................................................................................................202 Niveles eléctricos del bus.............................................................................................................202 Envío y recepción de datos...........................................................................................................203 Ejemplo con 1-Wire y el sensor DS18B20 & UART...................................................................203 Ejemplo con 1-Wire y el sensor DS18B20 & LCD TFT..............................................................207 Ethernet y MII (Media Independent Interface).................................................................................210 Señales del transmisor Ethernet....................................................................................................210 Señales del receptor Ethernet........................................................................................................210 Reducción Media Independent Interface (RMII)..........................................................................211 El stackt LwIP controlando LED´s mediante CGI.......................................................................213 SSI (Server Side Include).............................................................................................................217 Que es un socket?.........................................................................................................................220 Capturando paquetes con LwIP....................................................................................................221 Wi-Fi con ESP8266......................................................................................................................227 Enviando datos con ESP8266.......................................................................................................230 Sensor OPT3001................................................................................................................................236 CAN BUS ( Controller Area Network).............................................................................................239 CAN BUS Loop Back (Sin la capa física)....................................................................................241 CAN NORMAL (Con la capa física)...........................................................................................248 Bibliografía............................................................................................................................................256

4

Capitulo I. Historia de la Arquitectura ARM. ARM es una empresa presente en el mercado desde 1990 y que ha logrado en estos pocos años colocar productos de consumo global diseñando una arquitectura que lidera a escala mundial en 32 bits. Concebida originalmente por Acorn Computers para uso en computadoras, los primeros productos basados en ARM fueron los Acorn Archimedes lanzados en 1987. La relativa simplicidad de los procesadores ARM los ha convertido en la tecnología dominante en el mercado de la electrónica móvil integrada, microprocesadores y microcontroladores pequeños, de bajo consumo y relativamente bajo costo. En la actualidad alrededor del 98% de los teléfonos móviles vendidos cada año utilizan al menos un procesador ARM. Desde 2009, los procesadores ARM son aproximadamente el 90% de todos los procesadores RISC de 32 bits que se utilizan en la electrónica de consumo, incluyendo PDA, Tablets, Teléfonos inteligente,videoconsolas, calculadoras, reproductores digitales de música y medios (fotos, vídeos, etc.), y periféricos de computadoras como discos duros y routers. La arquitectura ARM es licenciable. Las empresas que son titulares de licencias ARM actuales o anteriores incluyen a empresas como Alcatel-Lucent, Apple Inc., AppliedMicro, Atmel, Broadcom, Cirrus Logic, Digital Equipment Corporation, Ember, Energy Micro, Freescale, Intel, LG,Marvell Technology Group, Microsemi, Microsoft, NEC, Nintendo, Nokia , Nuvoton, Nvidia, Sony, NXP (antes Philips), Oki, ON Semiconductor, Psion, Qualcomm, Samsung, Sharp, STMicroelectronics, Symbios Logic, Texas Instruments, VLSI Technology, Yamaha, y ZiiLABS. ARM solo desarrolla la arquitectura pero no fabrica chips, estos son fabricados por otras empresas que licencian esta arquitectura. El origen de ARM se remonta a 1983 como un proyecto de desarrollo en la empresa Acorn Computers cuya meta era, originalmente, el desarrollo de un procesador avanzado, pero con una arquitectura similar a la del MOS 6502. La razón era que Acorn tenía una larga línea de computadoras basados en ese micro. El equipo terminó el diseño preliminar y los primeros prototipos del procesador en el año 1985, al que llamaron ARM1. La primera versión utilizada comercialmente se bautizó como ARM2 y se lanzó al mercado en el año 1986. La arquitectura del ARM2 posee un bus de datos de 32 bits y ofrece un espacio de direcciones de 26 bits, junto con 16 registros de 32 bits. Uno de estos registros se utiliza como contador de programa, aprovechándose sus 4 bits superiores y los 2 inferiores para contener las banderas del propio procesador. El ARM2 es probablemente el procesador de 32 bits útil más simple del mundo, ya que posee sólo 30.000 transistores. Su simplicidad se debe a que no está basado en microcódigo (sistema que suele ocupar la cuarta parte de la cantidad total de transistores usados en un procesador) y a que, como era común en aquella época, no incluye caché. Gracias a esto, su consumo en energía es bastante bajo, a la vez que ofrece un mejor rendimiento que un 286. Su sucesor, el ARM3, incluye una pequeña memoria caché de 4 KB, lo que mejora los accesos a memoria repetitivos. A finales de los años 80 Apple Computer comenzó a trabajar con Acorn en nuevas versiones del núcleo ARM. 6

Características heredadas de RISC. La arquitectura ARM incorporó algunas características del diseño RISC de Berkeley, aunque no todas. Las que se mantuvieron son: • Arquitectura de carga y almacenamiento(load-store). Las instrucciones que acceden a memoria están separadas de las instrucciones que procesan los datos, ya que en este último caso los datos necesariamente están en registros. • Instrucciones de longitud fija de 32 bits. Campos de instrucciones uniforme y de longitud fija para simplificar la decodificación de las instrucciones. • Formatos de instrucción de 3 direcciones. Consta de “f” bits para el código de operación, “n” bits para especificar la dirección del 1er. operando, “n” bits para especificar la dirección del 2do. operando y “n” bits para especificar la dirección del resultado (el destino).

Algunas ventajas de RISC. •

• •

Menor desperdicio de área de silicio. Un procesador simple economiza transistores y área de silicio. En consecuencia una CPU RISC deja mayor área libre para realizar mejoras de rendimiento, tales como, memoria caché, funciones de manejo de memoria, punto flotante por hardware,etc. Menor tiempo de desarrollo. Un procesador simple tiene menor costo y lleva menos esfuerzo de diseño, se adapta mejor a sistemas de tecnología de procesos. Mayor rendimiento. Si se diseña un procesador simple y luego se le agregan instrucciones complejas hará en forma más eficiente varias funciones de alto nivel pero también decaerá un poco el reloj para el conjunto de las instrucciones. Midiendo los beneficios de esta técnica en programas típicos se comprueba que todos los sets de instrucciones complejos hacen que el programa corra a menor velocidad.

Desventajas de RISC. • •

No ejecuta códigos x86.Pero hay programas de emulación para varias plataformas RISCs. Pobre densidad de código. Comparada con CISC. Ésto es consecuencia del set de instrucciones de longitud fija. En ausencia de memoria caché, esta pobre densidad de código significa que la búsqueda de la instrucción necesita un aumento del ancho de banda de la memoria principal, dando por resultado un mayor consumo.

Bus AMBA. El significado de esta sigla es Advanced Microcontroller Bus Architecture. La misma se refiere a un standard de facto, abierto, que facilita la interconexión de bloques de propiedad intelectual para formar “Sistemas On Chip”, es decir, circuitos integrados formados por varios procesadores y periféricos, interconectados en un bus común. Los procesadores ARM utilizan esta arquitectura para interconexión de los diferentes bloques internos que forman el chip. Podemos ver en el gráfico anterior que en el procesador hay tres buses con tres velocidades distintas. • • •

AHB1 corriendo a 168Mhz. APB2 corriendo a 84Mhz. APB1 corriendo a 42Mhz. 11

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.

12

El pipeline se implementa en el nivel de hardware. Pipeline es lineal, lo que significa que el procesador ejecuta una instrucción mientras está cargando otra para ser decodificada. Si bien esto suena interesante presenta problemas con los saltos, por ejemplo cuando una instrucción necesita de un dato que todavía no ha sido decodificado por lo que se ve obligado a esperar la ejecución de la instrucción que contiene la información, esto se mejora con técnicas predictivas a nivel de hardware.

Registros del Procesador.

Existen trece registros de propósito general todos de 32 bits, otra gran diferencia con microcontroladores menores donde solo existen un registro de trabajo y la interacción de nuestras aplicaciones con este registro es fácilmente predecible, con trece registros la historia se complica y ya no es tan claro como el procesador usará estos registros cuando programamos en lenguajes como C donde la independencia con el hardware es importante. Dos registros para el manejo del Stack, Main Stack Pointer (MSP) que es cargado con el valor 0x00000000 luego de un Reset, y el Procesador Pointer (PSP. El Link Register (LR), registro R14 almacena la información de declaraciónes de subrutinas, llamadas a funciones y excepciones, valores de retorno. Luego de un reset el valor LR es 0xFFFFFFFF. El Program Status Register (PSR) se usa para para monitorear el estado del programa en ejecución, por ejemplo si un número es negativo o cero entre otras cosas. Luego de un RESET el PC se carga con el valor 0x00004 y el M4 puede dirección hasta un límite teórico de 4GB.

13

Procesadores Escalares: Los procesadores escalares son el tipo más simple de procesadores. Cada instrucción de un procesador escalar opera sobre un dato cada vez. En contraposición, en un procesador vectorial una sola instrucción opera simultáneamente sobre un conjunto de datos. La diferencia entre ambos es la misma que entre la aritmética escalar y la vectorial. Los procesadores escalares pueden ser CPUs completas o ALUs. En algunos casos, un procesador puede estar compuesto de una CPU y varias ALUs, formando el conjunto un procesador superescalar. Instrucciones Ortogonales: La ortogonalidad es una propiedad de las unidades centrales de procesamiento. Se dice que un conjunto de instrucciones es ortogonal cuando se puede utilizar cualquier modo de direccionamiento en cualquier instrucción. La búsqueda de la ortogonalidad hace que el diseño de la unidad central de procesamiento sea más complejo pero aporta una mayor facilidad de programación. La programación para este dispositivo es C casi podemos decir de manera obligada, la complejidad de sus funciones, estructura y posibles configuraciones de trabajo hacen que estos dispositivos no sean aptos para una total programación en lenguajes de bajo nivel. Existen en la actualidad herramientas/soft de programación para todos los sistemas operativos y muchas de estas herramientas basadas en Linux y Windows son de uso libre corriendo por ejemplo en Eclipse.

Nosotros en el curso usaremos el entorno de KEIL en Windows pero los programas pueden ser compilados en cualquier herramienta como veremos mas adelante.

17

Para trabajar con solo necesitamos una computadora con puerto USB puesto que la propia placa que estamos usando se alimenta desde el USB. Al conectar la placa entrenadora puede suceder que el firmware del programador STLink embebido en la placa este desactualizado, esto depende de las distintas versiones que hay en el mercado de esta entrenadora. Para actualizar el firmware solo debe ejecutar el siguiente programa que encontrará dentro de las herramientas del curso.

Esto actualizará el firmware de su programador a la versión mas resiente. 23

También encontrará un soft programador para esta arquitectura, si ha programado usted PIC´s podemos decir que sería algo como el PicKit, ICD3, etc. Todo lo necesario para instalarlo junto a los drivers USB están en el paquete de herramientas del curso. Antes de intentar trabajar con la entrenadora se deben instalar los drivers para que el sistema la reconozca. Sin embargo normalmente no necesitaremos lidiar con el programador ya que el entorno KEIL integra la placa entrenadora/programadora en sus herramientas y todo el trabajo lo haremos desde el mismo entorno sin necesidad de trabajar con ninguna herramienta exterior. Con KEIL podremos hacer una gran variedad de aplicaciones para distintos ambientes y necesidades. Una de las características mas interesantes que tiene la arquitectura ARM es que nos permite formar parte de una comunidad donde existen muchos desarrolladores de aplicaciones para hardware diverso donde hay mucho código y paquetes de programas ya resueltos, rutinas que son de uso libre que inclusive pueden haber sido escritas para Cortex M3 y son perfectamente portables a M4 con simples ajustes en el proyecto a compilar.

24

Configurando el entorno de trabajo.

Desde la lengüeta Device seleccionamos el micro-controlador, desde la lengüeta Target definimos algunas configuraciones básicas para nuestro controlador. MicroLib es una biblioteca altamente optimizado para aplicaciones embebidas escritas en C basados en ARM. Cuando se compara con la biblioteca de C estándar que se incluye con el compilador de ARM, MicroLib proporciona significativas ventajas en cuanto al tamaño de código requerido para muchos sistemas embebidos. 26

Aquí configuramos el entorno, las rutas de archivos y librerías, si en el paso anterior indicamos que usaremos librerías provistas por STM en este paso indicamos donde están estas librerías.

IMPORTANTE: MicroLib es una biblioteca altamente optimizado para aplicaciones embebidas escritas en C basados en ARM. Cuando se compara con la biblioteca de C estándar que se incluye con el compilador de ARM, MicroLib proporciona significativas ventajas en cuanto al tamaño de código requerido para muchos sistemas embebidos.

Recordar: Todos los trabajos ejemplos están para ser compilados con MICROLIB.

KEIL lo puede descargar directamente desde su pagina oficial.

28

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

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

31

Se declara el uso de la estructura para la configuración de los puertos GPIO. RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE); Aquí se activa el reloj que proviene del bus AHB1 y específicamente lo estamos activando para el puerto D. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_15; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT; Específicamente vamos a configurar el pin 15 del puerto D e indicamos que será salida. También se podrían configurar mas pines de una sola vez por ejemplo de la siguiente forma: GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12|GPIO_Pin_13| GPIO_Pin_14; En la siguiente línea indicamos que la salida será del tipo Push-Pull. (Opuesto a Open Drain). GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; Los pines del puerto en modo salida pueden ser configurados en tres modos distintos. • open drain Salida de colector abierto. • open drain, with pull-up Transistor para el nivel bajo y una resistencia a nivel alto. • push-pull Un transistor para el nivel alto y otro para el nivel bajo. En el modo entrada son tres también los modos de funcionamiento: • • •

pull-up Un resistor conectado a nivel alto. Pull-down Un resistor conectado a nivel bajo. pull-up and pull-down Un resistor conectado a nivel alto y otro a nivel bajo (Se utiliza en

raras ocasiones, no es una configuración usual). Se configura el puerto a 100Mhz. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz; No hay resistencias Pull-Up ya que el puerto funciona como salida. GPIO_InitStructure.GPIO_PuPd

= GPIO_PuPd_NOPULL;

Finalmente la estructura se hace activa. GPIO_Init(GPIOD,&GPIO_LED); Es en este momento que la configuración pasa a ser efectiva y el puerto es configurado.

Importante: Todo trabaja a 3V, por lo tanto los niveles lógicos son de 3V tenga especial cuidado de no mezclar niveles digitales de 5V puesto que podría dañar la placa entrenadora.

36

Para el tratamiento de estos datos con la información provista por el fabricante podemos crear una función que lo resuelva. float temperatura_leer_grados(void) { float grados; ADC_SoftwareStartConv(ADC1); // Inicia la conversión while(!ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC)){} grados = ADC_GetConversionValue(ADC1); grados = (grados *3.3)/4095; grados = ((grados - 0.76)/2.5)+25; return(grados); // Retorna el valor ya escalado }

Importante: Tenga en cuenta que incluso si usted no está usando un disparador externo mediante la instrucción: ADC_InitStructure.ADC_ExternalTrigConvEdge = ADC_ExternalTrigConvEdge_None En la declaración ADC_InitStructure.ADC_ExternalTrigConv sigue siendo necesaria para la estructura que se escriba “algo” válido de lo contrario se producen resultados extraños en las conversiones. La inicialización T1_CC1 es equivalente a la inicialización del miembro de estructura a 0. Para visualizar los datos usaremos una pantalla 16x2 Hitachi 44780, el controlador para esta pantalla lo encontramos en los archivos stm32f4_hd44780.c y stm32f4_hd44780.h donde se encuentran tanto las funciones para el manejo de la pantalla como la conexión de los pines.

La pantalla se puede conectar a cualquier puerto del controlador solo basta editar el archivo stm32f4_hd44780.h que es donde se encuentran estas definiciones. El archivo temperatura_intern.c tiene todas las funciones para la medición de temperatura y el archivo temperatura_intern.h las correspondientes declaraciones de variables y funciones.

72

Canales DMA. Hay dos controladores DMA “casi” idénticos siendo la principal diferencia que solo el DMA2 puede realizar transferencias de memoria a memoria y claro que los DMA están conectados a distintos buses de reloj.

Cada DMA puede manejar ocho stream (ocho canales FIFO), cada flujo de datos deberá estar asociado a uno de estos canales.

Los periféricos tienes asociado tanto el canal como el stream. En el manual del dispositivo se puede consultar el mapeo de los periféricos y su relación con los DMA. 77

ADC_InitStructure.ADC_ContinuousConvMode = ENABLE; ADC_InitStructure.ADC_ExternalTrigConvEdge = ADC_ExternalTrigConvEdge_None; ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_T1_CC1; ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right; ADC_InitStructure.ADC_NbrOfConversion = 4; // Cuatro conversiones en ADC3 ADC_Init(ADC3, &ADC_InitStructure); Configura el órden de lectura de los canales y la velocidad ADC_RegularChannelConfig(ADC3, ADC_Channel_10, 1, ADC_SampleTime_144Cycles); ADC_RegularChannelConfig(ADC3, ADC_Channel_11, 2, ADC_SampleTime_144Cycles); ADC_RegularChannelConfig(ADC3, ADC_Channel_13, 3, ADC_SampleTime_144Cycles); ADC_RegularChannelConfig(ADC3, ADC_Channel_12, 4, ADC_SampleTime_144Cycles); /* Habilita la transferencia DMA con el ADC3 (Modo Single-ADC) */ ADC_DMARequestAfterLastTransferCmd(ADC3, ENABLE); /* Habilita ADC3 DMA */ ADC_DMACmd(ADC3, ENABLE); /* Habilita ADC3 */ ADC_Cmd(ADC3, ENABLE); } /******************* FIRTEC Capacitación *****FIN DE ARCHIVO**********************/

Vemos otro ejemplo de uso del DMA tratando los datos desde la UART4. El objetivo es recibir 16 Bytes almacenarlos en el DMA y transmitirlos por el mismo puerto. De acuerdo al mapa de periféricos vemos que la recepción del UART4 se conecta al Canal4 con el Stream2 del DMA1. Observe que 16 Bytes son 128 bits que es lo máximo que puede manejar el FIFO del módulo DMA.

Se activan los relojes de los módulos que se usarán: RCC_APB1PeriphClockCmd(RCC_APB1Periph_UART4, ENABLE); RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE); RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA1, ENABLE);

Configuramos los pines que usaremos en el puerto UART. En este programa usaremos el PA0 para transmitir y el PA1 para recibir los datos. 83

Modo DMA de doble buffer. Funciona como el modo normal (single-buffer), con la diferencia de que se tiene dos punteros a memoria. Cuando el modo doble buffer está activo el modo circular es activado automáticamente y en cada extremo de la transacción (DMA_SxNDTR register reach 0), el punteros memoria se mantiene. Esto permite que el software pueda procesar un área de memoria mientras que la segunda área de memoria está siendo utilizado o completado por la transferencia DMA.

El modo de doble buffer es adecuado cuando necesitamos hacer el seguimiento de una señal o para el muestreo de una señal que evoluciona rápido en el tiempo y necesitamos que los datos en proceso de ser tratados no se interfieran con los datos que están siendo capturados.

Emular memoria EEPROM en FLASH. Muchos microcontroladores cuentan con memoria EEPROM para guardar datos que el usurario desea conservar cuando el controlador ha sido desconectado, un ejemplo podría ser la clave de una alarma. Es poco práctico que para cambiar la clave de una alarma o sistema de acceso debiéramos re-programar nuestro controlador, es mas lógico pensar que el usuario puede hacerlo por si mismo. El STM32F407 no dispone de memoria EEPROM sin embargo podemos emular esta memoria en la propia FLASH asignando sectores de FLASH a las que llamaremos páginas. La memoria de programa de este microcontrolador es de 1MB y está definida desde la dirección 0X200FFFFF a 0x20000000 (1,048,575 Bytes) si bien el procesador puede direccionar 4GB este Mega Byte está mapeado dentro de estos 4 GB teóricos. El ejemplo que tratamos esta basado en la nota de aplicación AN3969 de STM donde se crean dos páginas de 16K. • •

Página 0 con dirección de 0x0000 a 0x3FFF Página 1 con dirección de 0x4000 a 0x7FFF

La dirección FLASH donde inicia la emulación está en 0x08008000 y se usan dos sectores de 16K para crear estas páginas con direcciones virtuales.

90

Sensor para medir Temperatura y Humedad HDC1000. Con este sensor podemos medir temperatura con un rango que va desde -40 grados a +125 grados y humedad de 0 a 100%. Utiliza un conversor analógico de 14 bits lo que da una precisión mas que aceptable para aplicaciones donde el control de estas variables sea necesario. Un ejemplo podría ser un invernáculo, una bodega, una cámara frigorífica, etc.

Desarrollado por Texas Instruments y ha sido calibrado en fábrica por lo que no requiere ajuste alguno. Este sensor tiene una serie de registros de 16 bits para su configuración y uso. En la dirección 0x00 se guardan dos Bytes que corresponden a la temperatura y en la dirección 0x01 dos Bytes para la humedad.

La dirección 0x02 es el registro de configuración, en este registro nos interesa solamente el bit 12 que configura la forma en que los datos estarán disponibles. Si el bit es puesto a uno la temperatura y humedad serán accedidos en secuencia, primero la temperatura y luego la humedad. En nuestro ejemplo y para simplificar las cosas, estamos usando un sensor ya montado en una placa impresa construido por MikroElektronika y por su bajo costo no justifica construirla. (Sin embargo el fabricante de la placa brinda todos los diagramas de conexionado). Para el manejo de este sensor hemos desarrollado un pequeño driver que resuelve todo su 103

while(1); } HD44780_Puts(0, 0,"STM32F4HDC1000"); Config_Sensor(); while(1){ Leer_Sensor(); sprintf(floatStr,"T:%2.1f",temperature); HD44780_Puts(0, 1,floatStr); sprintf(floatStr,"Hum:%2.1f%%",humidity); HD44780_Puts(7, 1,floatStr); Delayms(500); } } /*** fin del archivo ***********************************************************/

El resultado final obtenido es el que se aprecia en la imagen. La dirección I2C de este sensor es 0x40 y su ID es 0x1000, este ID se encuentra escrito en el registro 0xFF y puede ser usado para verificar si el sensor accedido es el correcto.

Analizando la función que lee el sensor. void Leer_Sensor() { I2C_start(I2C1, SLAVE_ADDRESS