UNIVERSIDAD TÉCNICA FEDERICO SANTA MARÍA DEPARTAMENTO DE ELECTRÓNICA

Desarrollo de Herramientas de Programación de Alto Nivel y Aplicaciones de Conectividad y Almacenamiento para el

Microcontrolador MSP430

Memoria presentada por Carlos Pablo Silva Lütty

Como requisito parcial para optar al título de Ingeniero Civil Electrónico

Mención Computadores.

Comisión:

Profesor Guía: Wolfgang Freund G. Co-Referente: Tomás Arredondo V.

Noviembre 2007

2

3

Dedico esta memoria a mi padre, profesor, mentor, guía y amigo:

Leopoldo Silva Bijit.

4

5

Resumen En la actualidad el uso de microcontroladores en la industria nacional está en constante crecimiento. Su utilización abarca casi toda la industria, desde el cobre, las salmoneras y la industria maderera hasta pequeñas y medianas empresas. Las aplicaciones industriales están cada vez más orientadas al bajo consumo de energía y a la conectividad con Internet, dando paso a aplicaciones de telemetría o control a distancia. Este trabajo está orientado a documentar algunos aspectos de la programación con el microcontrolador MSP430 que serán útiles a los alumnos del Departamento de Electrónica, cómo es el manejo avanzado del módulo de señales de reloj, el uso de los modos de bajo consumo y por último, la configuración de la tasa de baudios de la comunicación serial asincrónica. Adicionalmente este trabajo presenta el desarrollo de herramientas de conectividad entre el microcontrolador MSP430 y una base de datos. Para esto se incluye un driver y una biblioteca de entrada/salida para manejo de memorias SD y la utilización de un Bridge WiFi con comunicación serial. Finalmente se diseña una aplicación que sintetiza los conceptos aplicados en este trabajo.

6

7

Índice

Índice de Contenidos Índice ................................................................................................................................ 7 Capítulo 1: Introducción............................................................................................ 13

1.1 Aplicaciones de los microcontroladores......................................................... 13 1.2 Microcontroladores en la industria nacional .................................................. 13

1.2.1 Gestión de combustible .......................................................................... 13 1.2.2 Monitoreo de parámetros ambientales en industria Salmonera.............. 14

1.3 El mercado de los microcontroladores ........................................................... 15 1.4 Sobre el resto de este trabajo .......................................................................... 16

Parte I Diseño básico con el MSP430. ...................................................................... 17 Capítulo 2: Manejo de fuentes y señales de reloj .................................................. 19

2.1 Relevancia del módulo de relojes............................................................... 19 2.2 Fuentes y señales de reloj ........................................................................... 20

2.2.1 Fuentes de reloj................................................................................... 21 2.2.2 Señales de reloj................................................................................... 22

2.3 Diagrama de bloques .................................................................................. 24 2.4 Consideraciones de diseño e implementación............................................ 25

2.4.1 Registros de control del módulo de relojes ........................................ 25 2.4.2 Aplicaciones con alimentación por baterías ....................................... 25 2.4.3 Fuentes disponibles en el módulo....................................................... 26

2.4.3.1 LFXTAL......................................................................................... 26 2.4.3.2 XT2................................................................................................. 26 2.4.3.3 DCO................................................................................................ 27

2.5 Procedimiento de prueba para el módulo de relojes................................... 28 2.6 Diseño de un DRIVER para manejo de relojes .......................................... 29 2.7 Ejemplos de funcionamiento y manejo de relojes ...................................... 30

Capítulo 3: Manejo del consumo de energía ......................................................... 33 3.1 Consideraciones para definir el modo de operación................................... 33 3.2 Modos de operación.................................................................................... 33 3.3 Modos de operación.................................................................................... 34 3.4 Empleo de los modos de bajo consumo ..................................................... 35 3.5 Consideraciones para aplicaciones de bajo consumo................................. 35 3.6 Definiciones para el manejo de los modos de operación............................ 35 2.7 Datos experimentales de consumo de corriente ......................................... 38

Capítulo 4: UART: Comunicación serial asincrónica ........................................... 41 4.1 Módulo UART............................................................................................ 41 4.2 Generación de tasas de baudios .................................................................. 41 4.3 Procedimiento de diseño............................................................................. 42 4.4 Determinación del valor del modulador ..................................................... 43 4.5 Modelo de Programación Lineal Entera..................................................... 43 4.6 Ejemplos de uso del modelo y funcionamiento en la MSP430 .................. 44

8

Parte II Integración de periféricos con el MSP430 ..................................................... 47 Capítulo 5: SD/MMC: Almacenamiento masivo .................................................. 49

5.1 Secure Digital Card .................................................................................... 49 5.2 Bus de comunicación SPI ........................................................................... 50 5.3 Módulo MSP430-SD .................................................................................. 52

5.3.1 Socket SD ........................................................................................... 52 5.3.2 Alimentación ...................................................................................... 54 5.3.3 Bus SPI ............................................................................................... 54 5.3.4 Protección ........................................................................................... 55 5.3.5 Leds Indicadores................................................................................. 55 5.3.6 Esquemático ....................................................................................... 56

5.4 Driver para manejo de memorias SD ......................................................... 57 5.4.1 Descripción de la tarjeta SD ............................................................... 57

5.4.1.1 Interfaz SPI ..................................................................................... 57 5.4.1.2 Tamaño del bloque ......................................................................... 58 5.4.1.3 Estructura de los comandos ............................................................ 58 5.4.1.4 Estructura de las respuestas ............................................................ 58

5.4.2 Inicialización ...................................................................................... 58 5.4.3 Lectura de datos.................................................................................. 61 5.4.4 Escritura de datos ............................................................................... 62

5.5 Biblioteca de entrada/salida........................................................................ 64 5.5.1 Abrir una conexión ............................................................................. 64 5.5.2 Cerrar una conexión............................................................................ 64 5.5.3 Posicionar el puntero de lectura escritura........................................... 64 5.5.4 Leer datos de la tarjeta SD.................................................................. 65 5.5.5 Escribir datos en la tarjeta SD ............................................................ 65

5.6 Documentación del driver y la biblioteca................................................... 65 5.7 Ejemplo de uso del driver y la biblioteca ................................................... 66

Capítulo 6: Comunicación por WIFI..................................................................... 67 6.1 Módulo Airbon Direct Serial Bridge.......................................................... 67 6.2 Utilidad VCOM .......................................................................................... 68 6.3 Configuración del Serial Bridge ................................................................. 69 6.4 Ejemplo de uso del Serial Bridge ............................................................... 69

Parte III Conectividad con base de datos.................................................................. 73 Capítulo 7: Aplicación: Data Logger .................................................................... 75

7.1 Descripción de la aplicación....................................................................... 75 7.2 Plataforma de Gestión ................................................................................ 76 7.3 El sistema embebido................................................................................... 77

Capítulo 8: Conclusiones........................................................................................... 79 8.1 Resultados de este trabajo .............................................................................. 79 8.2 Trabajos futuros.............................................................................................. 80

Referencias ..................................................................................................................... 81

9

Anexos ............................................................................................................................ 83 Anexo A: Registros del módulo de relojes ............................................................ 83

A-1 Control del DCO......................................................................................... 83 A-2 Control básico del sistema de reloj 1.......................................................... 83 A-3 Control básico del sistema de reloj 2.......................................................... 84 A-4 Habilitación de interrupciones.................................................................... 85 A-5 Señalización de interrupciones ................................................................... 85

Anexo B: DRIVER para manejo de Relojes.......................................................... 87 B-1 Definiciones................................................................................................ 87

B-1.1 Interrupciones ..................................................................................... 87 B-1.2 XT2..................................................................................................... 87 B-1.3 Fuentes para SMCLK ......................................................................... 87 B-1.4 Fuentes para MCLK ........................................................................... 87 B-1.5 Frecuencias para ACLK ..................................................................... 88 B-1.6 Frecuencias para SMCLK .................................................................. 88 B-1.7 Frecuencias para MCLK..................................................................... 88 B-1.8 Frecuencias máxima y mínima para DCO.......................................... 88

B-2 Funciones.................................................................................................... 88 B-2.1 Puertos de prueba .............................................................................. 88 B-2.2 Inicializar el oscilador ....................................................................... 89 B-2.3 Frecuencia del DCO .......................................................................... 89

Anexo C: DRIVER de comunicación con tarjeta SD ............................................ 91 C-1 Hardware .................................................................................................... 91 C-2 Software...................................................................................................... 91

C-2.1 Inicialización del MSP430 ................................................................ 91 C-2.2 Inicialización del módulo UART1 .................................................... 92 C-2.3 Detección de tarjeta SD ..................................................................... 92 C-2.4 Enviar y recibir un byte por el bus SPI.............................................. 92 C-2.5 Activación de la tarjeta SD................................................................ 93 C-2.6 Desactivación de la tarjeta SD........................................................... 93 C-2.7 Enviar comandos a la tarjeta SD........................................................ 93 C-2.8 Esperar por una respuesta de la tarjeta SD ........................................ 94 C-2.9 Inicialización de la tarjeta SD............................................................ 94 C-2.10 Formatear la dirección de memoria .................................................... 94 C-2.11 Verificar el estado de la escritura en la tarjeta SD ............................. 95 C-2.12 Enviar datos a la tarjeta SD ................................................................ 95 C-2.13 Recibir datos desde la tarjeta SD........................................................ 95

Anexo D: Biblioteca de entrada/salida para tarjeta SD.......................................... 97 D-1 Obtener la posición inicial de lectura/escritura ...................................... 97 D-2 Fijar la posición inicial de lectura/escritura............................................ 97 D-3 Abrir un archivo (conexión con tarjeta SD) ........................................... 98 D-4 Cerrar un archivo (conexión con tarjeta SD).......................................... 98 D-5 Posicionamiento del puntero de lectura/escritura................................... 98 D-6 Leer bytes desde la tarjeta SD ................................................................ 98 D-7 Escribir bytes en la tarjeta SD ................................................................ 99

10

Índice de Figuras Figura 2.1: LFXT1CLK.................................................................................................. 21 Figura 2.2: XT2CLK. ..................................................................................................... 21 Figura 2.3: DCOCLK. .................................................................................................... 22 Figura 2.4: ACLK........................................................................................................... 22 Figura 2.5: MCLK. ......................................................................................................... 23 Figura 2.6: SMCLK........................................................................................................ 23 Figura 2.7: Diagrama de bloques del módulo de relojes. ............................................... 24 Figura 2.8: Falla del oscilador. ....................................................................................... 27 Figura 3.1: Modos de bajo consumo. ............................................................................. 34 Figura 3.2: Consumo de corriente en aplicaciones de bajo consumo............................. 37 Figura 3.3: Consumo de corriente en los modos de operación....................................... 38 Figura 3.4: Conexión para medir consumo de corriente. ............................................... 38 Figura 3.5: Consumo de corriente experimental. ........................................................... 39 Figura 4.1: Generador de baudios. ................................................................................. 41 Figura 5.1: Ráfagas de 8 ciclos de reloj. ........................................................................ 50 Figura 5.2: Ejemplo de utilización del bus SPI. ............................................................. 50 Figura 5.3: Socket SD..................................................................................................... 53 Figura 5.4: Circuito detector de tarjetas. ........................................................................ 53 Figura 5.5: Circuito de alimentación .............................................................................. 54 Figura 5.6: Led indicador. .............................................................................................. 56 Figura 5.7: Circuito esquemático del módulo MSP430-SD. .......................................... 56 Figura 5.8: Estructura de un comando............................................................................ 58 Figura 5.9: Estructura de la respuesta............................................................................. 58 Figura 5.10: Inicialización de la tarjeta SD. ................................................................... 59 Figura 5.11: Esquema temporal del comando reset........................................................ 60 Figura 5.12: Esquema temporal del comando de inicialización..................................... 61 Figura 5.13: Esquema temporal de la lectura. ................................................................ 62 Figura 5.14: Esquema temporal de la escritura. ............................................................. 63 Figura 5.15: Estados de la escritura................................................................................ 63 Figura 5.16: Ejemplo de lectura. .................................................................................... 65 Figura 6.1: Airbone Direct Serial Bridge. ...................................................................... 67 Figura 6.2: Aplicación básica del Serial Bridge. ............................................................ 68 Figura 6.3: Ejemplo de uso del Serial Bridge................................................................. 71 Figura 7.1: Esquema de la aplicación............................................................................. 75 Figura 7.2: Interfaz Visual.............................................................................................. 76 Figura 7.3: Esquema de conectividad............................................................................. 77

11

Índice de Tablas Tabla 2.1: Registros del módulo de relojes. ................................................................... 25 Tabla 3.1: Modos de bajo consumo................................................................................ 34 Tabla 5.1: Asignación de pines del bus SPI. .................................................................. 51

Indice de Códigos Código 2.1: Redirigir los relojes al osciloscopio............................................................ 28 Código 2.2: SMCLK a 16 kHz sin Driver. ..................................................................... 29 Código 2.3: SMCLK a 16 kHz con Driver..................................................................... 29 Código 2.4: Ejemplo de uso de driver 1. ........................................................................ 30 Código 2.5: Ejemplo de uso de driver 2. ........................................................................ 30 Código 2.6: Ejemplo de uso de driver 3. ........................................................................ 31 Código 3.1: Bits de control de modo de operación. ....................................................... 35 Código 3.2: Entrar y salir de modos de operación. ........................................................ 36 Código 3.3: Ejemplo de flujo para modos de bajo consumo.......................................... 36 Código 3.4: Medición de consumo de corriente para modos de operación.................... 39 Código 5.1: Configuración de UART1 para SPI............................................................ 51 Código 5.2: Envía y recibe un byte por SPI. .................................................................. 52 Código 5.3: Ejemplo de uso de Driver y Biblioteca SD................................................. 66 Código 6.1: Host Serial en MSP430............................................................................... 70 Código 6.2: Cliente TCP. ............................................................................................... 71

12

13

Capítulo 1: Introducción Los microcontroladores están trasformando el mundo. Están presentes en nuestro trabajo, en nuestra casa y en nuestra vida en general. Se pueden encontrar controlando el funcionamiento de los teclados de los computadores, en los teléfonos celulares, en los hornos microondas y los televisores de nuestro hogar. Pero la invasión acaba de comenzar y el nacimiento del siglo XXI será testigo de la conquista masiva de estos diminutos computadores, que gobernarán la mayor parte de los aparatos que se fabriquen y utilicen.

1.1 Aplicaciones de los microcontroladores Cada vez existen más productos que incorporan un microcontrolador con el fin de aumentar sustancialmente sus prestaciones, reducir su tamaño y costo, mejorar su fiabilidad y disminuir el consumo de energía. Algunos fabricantes de microcontroladores superan el millón de unidades, de un modelo determinado, producidas en una semana. Este dato puede dar una idea de la masiva utilización de estos componentes. Los microcontroladores están siendo empleados en multitud de sistemas presentes en nuestra vida diaria, como pueden ser juguetes, hornos microondas, refrigeración, televisores, computadoras, impresoras, módems, el sistema de arranque de nuestro automóvil, etc. Además existen otras aplicaciones con las que seguramente no estaremos tan familiarizados como instrumentación electrónica, control de sistemas en una nave espacial, etc. Una aplicación típica podría emplear varios microcontroladores para controlar pequeñas partes del sistema. Estos pequeños controladores podrían comunicarse entre si y con un procesador central, probablemente más potente, para compartir la información y coordinar sus acciones, como ya ocurre habitualmente en cualquier PC.

1.2 Microcontroladores en la industria nacional Como ejemplo de la aplicación de los microcontroladores a la industria nacional, se comentarán dos casos reales donde se utilizan microcontroladores. El primero es el caso de la industria de la automoción y el segundo de la industria salmonera.

1.2.1 Gestión de combustible Existen hoy en Chile una gran cantidad de vehículos convertidos a gas licuado, y las máquinas expendedoras de este combustible son muy similares a las máquinas expendedoras de bencina o petróleo. El problema era el poder gestionar el combustible de manera remota, tanto la gestión del combustible vendido en la estación de servicio como en

14

algunos casos el combustible consumido por alguna flota de vehículos de una misma empresa. La solución está basada en un microcontrolador ARM7, el cual tiene una arquitectura de 32 bits y capacidad de procesar instrucciones a una frecuencia de 20 [MHz]. El ARM7 hace lectura de un “encoder” análogo y calcula la cantidad de combustible servido. Además cuenta con una memoria SD para almacenar datos localmente. Adicionalmente el ARM7 está conectado a un teléfono celular con el que se comunica con el protocolo RS-232 utilizando comandos AT. Por último el mismo microcontrolador interactúa con un display y un teclado. La aplicación consiste en que el operador debe ingresar su código y el código del cliente por el teclado, luego de realizar la venta el microcontrolador almacena estos datos en la memoria SD, junto con la cantidad de combustible servido, el precio actual de venta, la fecha y la hora. Una vez al día un servidor central conectado a un celular llama a todas las estaciones de servicio y recupera los datos almacenados en la memoria de cada uno de los dispositivos. Desde el servidor central se puede encuestar la base de datos desde una aplicación web.

1.2.2 Monitoreo de parámetros ambientales en industria Salmonera Actualmente la industria salmonera de Chile se está regulando con exigencias ambientales por parte del gobierno. Esto ha generado un replanteamiento de su funcionamiento, debido a no cumplir las regulaciones mínimas. El parámetro que, en casi todos los casos, es crítico es la cantidad de nitratos que se deja en el océano. Los nitratos son altamente nocivos para el fondo marino y en general para la vida submarina, por lo que disminuir su emisión es un tema de importancia en esta industria. Los nitratos vienen en altas concentraciones en el alimento que se les suministra a los peces y representa en algunos casos hasta un 70% de los costos operacionales de las empresas, por lo que se tiene una motivación económica y ecológica para disminuir la cantidad de alimento que se deja en el mar. El problema a resolver era entonces la disminución de la cantidad de alimento que se arroja al mar y que los peces no comen debido a corrientes marinas o exceso de alimento, puesto que es altamente contaminante. La solución se basa en un microcontrolador PIC que se conecta a sensores de temperatura y oxígeno disuelto, para calcular el porcentaje de saturación de oxígeno. El microcontrolador se comunica con un módulo RF que envía los datos periódicamente a un computador que cuenta con una base de datos y una conexión a Internet vía satélite. La idea es almacenar datos en el tiempo y poder generar conocimiento sobre las conductas alimentarias de los salmones que respondan a variaciones en la temperatura del agua y a

15

variaciones en la cantidad de oxígeno disuelto en el agua, para de esta forma poder tomar decisiones adecuadas sobre la cantidad de alimento que se arroja al mar y así reducir la cantidad de comida que llega al fondo marino sin que los peces la coman.

1.3 El mercado de los microcontroladores Aunque en el mercado de la microelectrónica la mayor atención la acaparan los desarrollos de los microprocesadores, lo cierto es que se venden cientos de microcontroladores por cada uno de aquéllos. Existe una gran diversidad de microcontroladores. Quizá la clasificación más importante sea entre microcontroladores de 4, 8, 16 ó 32 bits. Aunque las prestaciones de los microcontroladores de 16 y 32 bits son superiores a los de 4 y 8 bits, la realidad es que los microcontroladores de 8 bits dominan el mercado y los de 4 bits se resisten a desaparecer. La razón de esta tendencia es que los microcontroladores de 4 y 8 bits son apropiados para la gran mayoría de las aplicaciones, lo que hace cuestionable el emplear micros más potentes y consecuentemente más caros. Uno de los sectores que más exige un aumento del mercado del microcontrolador es el mercado automovilístico. De hecho, algunas de las familias de microcontroladores actuales se desarrollaron pensando en este sector, siendo modificadas posteriormente para adaptarse a sistemas más genéricos. El mercado del automóvil es además uno de los más exigentes: los componentes electrónicos deben operar bajo condiciones extremas de vibraciones, choques, ruido, etc. y seguir siendo fiables. El fallo de cualquier componente en un automóvil puede ser el origen de un accidente. En cuanto a las técnicas de fabricación, cabe decir que prácticamente la totalidad de los microcontroladores actuales se fabrican con tecnología CMOS 4 (Complementary Metal Oxide Semiconductor). Esta tecnología supera a las técnicas anteriores por su bajo consumo y alta inmunidad al ruido. La distribución de las ventas según su aplicación es la siguiente:

• Una tercera parte se absorbe en las aplicaciones relacionadas con los computadores y sus periféricos.

• La cuarta parte se utiliza en las aplicaciones de consumo (electrodomésticos, juegos,

TV, vídeo, etc.)

• El 16% de las ventas mundiales se destinó al área de las comunicaciones.

• Otro 16% fue empleado en aplicaciones industriales.

• El resto de los microcontroladores vendidos en el mundo, aproximadamente un 10% fueron adquiridos por las industrias de automoción.

16

También los modernos microcontroladores de 32 bits van afianzando sus posiciones en el mercado, siendo las áreas de más interés el procesamiento de imágenes, las comunicaciones, las aplicaciones militares, los procesos industriales y el control de los dispositivos de almacenamiento masivo de datos.

1.4 Sobre el resto de este trabajo Como resultado de los últimos cursos del Laboratorio de Estructura de Computadores se tiene que los alumnos que los cursan han mostrado tener dificultades para manejar algunos módulos del microcontrolador MSP430. Por lo anterior, este trabajo contribuye a mejorar la documentación referente a los módulos donde los alumnos tienen mayores dificultades de aprendizaje. Adicionalmente los sistemas embebidos son hoy en la industria chilena ampliamente utilizados. Una de las características donde el Área de Computadores desea profundizar es en el almacenamiento masivo de información en microcontroladores y su posterior conectividad con bases de datos. Este tipo de herramientas se utilizan para control de acceso, estaciones de monitoreo y sistemas transaccionales entre otras. Este trabajo nace entonces por dos necesidades, la primera es generar material de apoyo para los alumnos de la especialidad de Computadores, y para todos aquellos que utilizan el microcontrolador MSP430. En segundo lugar este trabajo presentará técnicas de almacenamiento masivo en memorias no volátiles para el microcontrolador MSP430, además de herramientas de conectividad para consulta y respaldo de información en bases de datos. Este trabajo se dividirá estructuralmente en tres partes. Cada una de las dos primeras partes y en particular cada capítulo responden a una necesidad del área de Computadores, ya sea como material de apoyo académico o como nuevas aplicaciones y técnicas de diseño con el microcontrolador MSP430 [1]. La tercera parte contiene sólo un capítulo dedicado a mostrar una aplicación que integre las tecnologías estudiadas en las partes previas. Todos los códigos propuestos en este trabajo se podrán encontrar en el CD adjunto y no se incluirán como anexo en el escrito por motivos ecológicos de desperdicio de papel, pues su posterior utilización es de mayor utilidad desde un archivo que contenga el código fuente, utilizable rápidamente desde un entorno de desarrollo y no desde una hoja de papel.

17

Parte I Diseño básico con el MSP430. En esta primera parte se tratarán tres temas referentes a la programación básica del microcontrolador MSP430. El primer tema es referente al manejo de relojes. Se verá que el trabajo con sistemas embebidos está a menudo ligado a problemas de tiempo real, por lo que el estudio de este módulo será fundamental en el diseño de cualquier aplicación. Un segundo tema a tratar es referente a los modos de operación y aplicaciones de bajo consumo de energía. Se darán técnicas de implementación y usos de los distintos modos de ahorro de energía, la cual es una de las principales características de la familia de microcontroladores MSP430. Por último se tratará la generación de tasas de transmisión para la comunicación serial asíncrona. Aunque ya existe material referente a este tipo de comunicación, no hay documentación que describa una forma de diseñar tasas de baudios no estándares.

18

19

Capítulo 2: Manejo de fuentes y señales de reloj

2.1 Relevancia del módulo de relojes El módulo básico de reloj [2] es de vital importancia en el diseño de aplicaciones con microcontroladores. El caso del microcontrolador MSP430 no es diferente pues la mayor parte de sus periféricos integrados dependen de las señales de reloj de este módulo para cumplir su función. La interacción con periféricos externos va casi siempre de la mano con la definición de la frecuencia del reloj. Un primer punto a mencionar es que la velocidad de ejecución de instrucciones del microcontrolador es proporcional a la frecuencia del reloj que alimenta la CPU. De la misma forma la energía consumida por el microcontrolador también es proporcional a la frecuencia de la fuente de reloj, generándose así un compromiso de diseño entre bajo consumo y mayor velocidad de ejecución de instrucciones. Un segundo ejemplo de importancia del diseño del módulo básico de reloj es en el uso de temporizadores (timers) para la generación de una interrupción periódica. La frecuencia con que se generan las interrupciones será proporcional a la frecuencia de reloj que alimenta el timer e inversamente proporcional al número de ciclos que define el período de la interrupción.

Tff c

i =

donde: fi: frecuencia de interrupciones fc: frecuencia del reloj T: período en ciclos de reloj

Un razonamiento similar se utiliza para la generación de señales PWM (Pulse Width Modulation) a través del timer, pues los dos factores a considerar son la frecuencia de salida y el ancho del pulso. Ambos factores son calculados en relación directa a la frecuencia del reloj y en relación inversa al número de ciclos de reloj. Cuando se estudia el módulo ADC (Analog to Digital Converter) se puede ver que la conversión se realiza según dos tiempos.

shcadc ttt += donde:

tadc: tiempo total de conversión tc: tiempo de conversión tsh: tiempo de simple and hola

20

Típicamente el tiempo de conversión es de 13 ciclos de reloj y el tiempo de muestreo es configurable entre 4 y 1024 ciclos de reloj. Como ya puede intuirse el tiempo de muestreo será proporcional a la frecuencia del reloj, puesto que a mayor frecuencia, mayor número de instrucciones por segundo, se pueden realizar mayor cantidad de muestras en un segundo. Otro módulo que depende directamente de la frecuencia del reloj que lo alimenta es la comunicación serial, se usará como ejemplo el modo asíncrono. La generación de la velocidad en BAUDIOS está sujeta al valor que se le asigne a los registros disponibles para ese efecto, y el valor queda definido según:

BAUDfREG c=

donde:

REG: registro de configuración fc: frecuencia de reloj BAUD: tasa de baudios

De una manera similar el módulo básico de reloj será de suma importancia para el correcto funcionamiento de los dos modos de comunicación serial síncrona; SPI e I2C. De esta forma se podría continuar nombrando periféricos integrados del microcontrolador MSP430 que dependen del manejo de relojes. Así mismo y para concluir se menciona que la utilización de módulos de comunicación externos está casi siempre ligada y dependen fuertemente del diseño del módulo básico de reloj, ya sea RS232, USB, TCP/IP u otros. El anexo A muestra una descripción detallada de los registros asociados al módulo.

2.2 Fuentes y señales de reloj Una vez establecida la importancia que tiene este módulo para el diseño de aplicaciones con microcontroladores se introducen las fuentes y señales de reloj presentes en el microcontrolador MSP430. Este microcontrolador cuenta con tres fuentes de reloj y tres señales internas. Una fuente de reloj es un dispositivo físico capaz de generar una señal de frecuencia fija; mientras que una señal de reloj, es un valor en Hertz, es utilizada para alimentar los distintos periféricos internos o la CPU del microcontrolador. Las fuentes de reloj no están físicamente conectadas a los periféricos por ser dispositivos analógicos, por lo que deben ser digitalizadas. De esta forma se generan las señales de reloj, las que tienen la característica de estabilidad en forma (ciclo de trabajo del 50%), amplitud y frecuencia, asegurando así el correcto funcionamiento de los periféricos que alimentan.

21

2.2.1 Fuentes de reloj LFXT1CLK: Oscilador de baja/alta frecuencia que puede ser alimentado por un cristal de 32.768 Hz o bien por un cristal en el rango de los 450 kHz – 8 MHz. En el caso de los módulos disponibles en la Universidad, sólo se dispone del cristal de 32,768 kHz. Un esquema de esta fuente se muestra en la figura 2.1 [2].

Figura 2.1: LFXT1CLK.

XT2CLK: Oscilador de cristal opcional en el rango de los 450 kHz – 8 MHz. En el caso del módulo de la Universidad cuenta con un cristal de 8 MHz. En la figura 2.2 [2] se muestra el esquema de esta fuente.

Figura 2.1: XT2CLK.

22

DCOCLK: Oscilador interno controlado por voltaje (DCO) con características RC. Se puede seleccionar por software una resistencia externa para disminuir la temperatura. La figura 2.3 [2] muestra el esquema de esta fuente de reloj.

Figura 2.2: DCOCLK.

2.2.2 Señales de reloj ACLK: Reloj auxiliar conectado únicamente por la fuente LFXT1CLK, puede ser dividido por 1, 2, 4 u 8. Es seleccionable por software para alimentar los distintos periféricos. Muy utilizado en aplicaciones de bajo consumo y para implementación de un reloj de tiempo real por software. Se muestra el esquema para ACLK en la figura 2.4 [2].

Figura 2.3: ACLK.

23

MCLK: Reloj maestro alimentable por las tres fuentes de reloj y divisible por 1, 2, 4 u 8. Usado por la CPU y como reloj de sistema. Esta señal fija la velocidad de procesamiento del microcontrolador. La figura 2.5 [2] presenta el esquema de MCLK.

Figura 2.4: MCLK.

SMCLK: Reloj sub-maestro alimentable por las tres fuentes de reloj y divisible por 1, 2, 4 u 8. Se puede seleccionar como fuente el DCOCLK o el XT2CLK, pero si éste último está apagado, entonces toma como fuente LFXT1CLK. Seleccionable por software para alimentar periféricos. Generalmente utilizado para periféricos que requieran alta frecuencia, pues ACLK está limitado por LFXT1CLK a 32,678 kHz. Se presenta el esquema para SMCLK en la figura 2.6 [2].

Figura 2.5: SMCLK.

24

2.3 Diagrama de bloques Ya se presentaron todas las fuentes y señales de reloj disponibles en el microcontrolador MSP430. En la figura 2.7 [2] se presenta el diagrama de bloques del módulo básico de reloj, que da una idea general de cómo se deberán manipular los registros para seleccionar las fuentes que tendrá cada señal de reloj.

Figura 2.6: Diagrama de bloques del módulo de relojes.

Como se muestra en la figura 2.7 cada señal de reloj cuenta con un divisor. Las señales de control CPUOFF, OSCOFF, SCG0 y SCG1 tienen relación con los modos de bajo consumo y serán tratadas en el próximo capítulo.

25

Las señales de control DCOx, RSELx y MODx son utilizadas para ajustar la frecuencia del DCO. El resto de las señales de control se detallarán cuando se estudien los registros del módulo básico de reloj.

2.4 Consideraciones de diseño e implementación

2.4.1 Registros de control del módulo de relojes Para profundizando en este módulo es conveniente definir todas las señales de control asociadas. La mejor forma es presentarlas dentro de los registros a las que pertenecen. La tabla 2.1 [2] presenta un resumen de los registros de control.

Tabla 2.1: Registros del módulo de relojes.

Se destaca que el significado del estado inicial de los registros es el valor de éstos frente a una condición de RESET. Por ejemplo, el registro DCOCTL se inicializa en 0x56, o en su binario 01010110. El valor de Reset del registro BCSCTL2 será 0x00. Una representación detallada de cada registro puede encontrarse en el Anexo A.

2.4.2 Aplicaciones con alimentación por baterías Existe un conflicto de requerimientos en la elección de los relojes de una aplicación. Por un lado se requiere el ahorro de energía, por lo que es recomendable tener una frecuencia de reloj baja, sin embargo cuando se requiere una capacidad de procesamiento de CPU rápida, para procesamiento de datos, es necesario contar con frecuencias de reloj más altas. Es recomendable en aplicaciones con requerimientos de bajo consumo activar como fuente de ACLK el cristal de 32,768 kHz y alimentar MCLK con el DCO. Además se recomienda pasar a modos de bajo consumo y activar el DCO por eventos de interrupción.

26

2.4.3 Fuentes disponibles en el módulo

2.4.3.1 LFXTAL Debido a que el módulo que se dispone cuenta con un cristal de 32,768 kHz no es posible utilizar esta fuente como oscilador de alta frecuencia, es por esto que el BIT XTS del registro BCSCTL1 nunca debe ser puesto en valor 1, de lo contrario se obtiene como resultado que las señales que tengan esta fuente de reloj dejen de oscilar. Lo anterior se debe a que el módulo no presenta un cristal de 8 MHz en paralelo al cristal antes mencionado, por lo que si se selecciona esta fuente como oscilador de alta frecuencia ésta entregara una señal continua con valor igual a Vcc. Se debe recordar que ésta es la única fuente de la señal ACLK, por lo que no será posible variar la frecuencia del reloj auxiliar. Si el diseño de la aplicación no requiere de un reloj a esta frecuencia se recomienda apagar esta fuente para ahorrar energía por medio del BIT OSCOFF. Si la aplicación requiere esta fuente de reloj sólo en algunos momentos, no se recomienda apagar la fuente, puesto que este cristal es de bajo consumo y el tiempo requerido para estabilizar la oscilación es alto.

2.4.3.2 XT2 El microcontrolador cuenta con un cristal de alta frecuencia de 8 MHz que no es de bajo consumo, por lo que se recomienda utilizar esta fuente sólo si se requiere alta velocidad de procesamiento de CPU o una velocidad de respuesta mayor en algún periférico, como el módulo ADC o los TIMER A y/o B. Por omisión esta fuente está apagada y para activarla se debe fijar un valor 0 en el BIT XT2OFF del registro BCSCTL1. Al iniciar la oscilación de esta fuente, es común que se requiera de un tiempo para la estabilización de la frecuencia, por lo que si se piensa alimentar la CPU con esta fuente se deberá utilizar una rutina con este fin. Si se utiliza esta fuente para alimentar un periférico, la utilización de una rutina de estabilización no es necesaria. La rutina para estabilizar la fuente de reloj consiste en esperar por la estabilidad de la frecuencia y luego esperar por la estabilidad de la amplitud de la señal. Se presentará esta rutina más adelante en esta sección junto a los ejemplos de uso de los relojes.

27

La figura 2.8 presenta una imagen que muestra la problemática planteada anteriormente y sirve como guía para la implementación de una rutina a prueba de fallos de oscilación de la fuente de reloj que alimenta la CPU del microcontrolador.

Figura 2.7: Falla del oscilador.

2.4.3.3 DCO Como cualquier oscilador controlado por voltaje, la frecuencia de oscilación que genera este tipo de fuente de reloj depende fuertemente de la temperatura y del voltaje de alimentación. A mayor voltaje de alimentación, mayor será la frecuencia de oscilación entregada por el DCO, pero también lo será el consumo de energía. Si se requiere una aplicación de menor consumo se deberá elegir un voltaje de alimentación menor. El mínimo valor de VCC es de 1,8 V, que generará como máximo una frecuencia de 4 MHz a la salida del DCO; por el contrario, si la aplicación requiere un procesamiento más veloz, es posible generar con el DCO una frecuencia de aproximadamente 6 MHz alimentando el microcontrolador con el mayor valor de VCC posible, que es 3,6 V. Por último se destaca que la frecuencia que entrega el DCO se puede diseñar modificando los bits DCOx, RSELx y MODx. El rango de frecuencias posibles está aproximadamente entre los 100 kHz y los 5MHz.

28

2.5 Procedimiento de prueba para el módulo de relojes Una vez que se tiene claro el diseño de los relojes para una aplicación es recomendable verificar que las señales responden en la práctica a los valores esperados. Para esto se presenta una rutina que permite ver mediante un osciloscopio las señales de reloj. La idea de tener un programa de pruebas es útil ya que las señales de reloj están asociadas a puertos digitales del microcontrolador y es posible que la aplicación necesite estos recursos. Por lo anterior, se recomienda utilizar un programa de pruebas y verificar el correcto funcionamiento de los relojes para luego, una vez que se está seguro de que los relojes cumplen con el diseño, desocupar los puertos digitales asociados a los relojes y liberarlos para la aplicación. El programa de prueba para los relojes consiste en seleccionar como periféricos los puertos digitales asociados a las señales ACLK, MCLK y SMCLK. Luego se manipulan los registros para lograr las frecuencias deseadas y por último se ejecuta el programa y se ven las salidas en el osciloscopio.

Código 2.1: Redirigir los relojes al osciloscopio.

Como puede verse en el código 2.1 la rutina es bastante sencilla. Sólo deben modificarse los valores de los registros de control para poder fijar las frecuencias deseadas. El osciloscopio debe conectarse a los pines 48, 49 y 50 para ver las señales MCLK, SMCLK y ACLK respectivamente. No se debe olvidar conectar la tierra del osciloscopio al pin 62 ó 63 del módulo.

29

2.6 Diseño de un DRIVER para manejo de relojes Teniendo en cuenta la importancia de un buen diseño del módulo de relojes se puede decir que es sólo una herramienta para cumplir con requisitos de diseño de otros módulos y periféricos. Los relojes no son un objetivo, sino un instrumento para ser utilizado en el diseño de una aplicación con microcontroladores. Es por esto que el tiempo que se le dedique al diseño de los relojes debiese ser lo más corto posible, pues seguramente los tiempos de programación de la aplicación propiamente tal serán mucho mayores y es ahí donde deben estar concentrados los mayores esfuerzos. Con lo anterior se justifica el diseño de un driver para este módulo con el fin de ocultar su complejidad y enmascarar la utilización de los registros asociados a instrucciones simples que tengan nombres de acuerdo con la función que realizan. Como ejemplo veamos las instrucciones necesarias para fijar la frecuencia de SMCLK a 16,384 kHz que se muestran en el código 2.2.

Código 2.2: SMCLK a 16 kHz sin Driver.

Como se observa son sólo dos instrucciones, pero para utilizarlas se debe tener presente la función de los registros del módulo, además se debe tener conocimiento del divisor de frecuencia presente en SMCLK y que para tener como fuente de reloj LFXTAL1 se hace un set del BIT SELS, al igual que para tener como fuente el XT2, con la diferencia que se debe apagar este último antes de realizar la asignación. En el código 2.3 se muestra como se logra lo mismo utilizando un driver.

Código 2.3: SMCLK a 16 kHz con Driver.

En este caso se debe utilizar sólo una instrucción, que además se nombra con la acción que uno espera realizar, ocultando las complicaciones propias del diseño y generando así una plataforma de alto nivel para el diseño de los relojes del microcontrolador. Por último se destaca que el driver implementado se basa en el módulo disponible en el Departamento de Electrónica de la Universidad Santa María, incluyendo solamente las funcionalidades de éste. La documentación del driver se incluye como material en el Anexo B.

30

2.7 Ejemplos de funcionamiento y manejo de relojes El código 2.4 muestra la utilización del driver para obtener ACLK = 32,768 [kHz], SMCLK = 1 [MHz] y MCLK = 8 [MHz].

Código 2.4: Ejemplo de uso de driver 1.

El código 2.5 muestra como alimentar la señal MCLK con la fuente de reloj DCO y obtener una frecuencia múltiplo de 4096 [Hz]. En este ejemplo se desea que MCLK = 81,920 [kHz], SMCLK = 8,192 [kHz] y ACLK = 4,096 [kHz].

Código 2.5: Ejemplo de uso de driver 2.

31

Por último se muestra en el código 2.6 como el driver permite fijar la frecuencia máxima de DCO para alimentar MCLK y SMCLK y hacer que ACLK = 16,384 [kHz].

Código 2.6: Ejemplo de uso de driver 3.

32

33

Capítulo 3: Manejo del consumo de energía

3.1 Consideraciones para definir el modo de operación La familia MSP430 está diseñada para aplicaciones de bajo consumo de energía [3]. El programador deberá seleccionar uno de los 5 modos de operación disponibles tomando en cuenta 3 aspectos:

• Bajo consumo de energía • Velocidad y rendimiento • Minimización de corriente consumida en los periféricos

Generalmente se deberá penalizar uno o dos de los puntos anteriores para favorecer uno de ellos. Si se requiere que la aplicación consuma la mínima energía posible, entonces se deberá sacrificar la velocidad con que la CPU ejecuta las instrucciones, pues como ya se mencionó en el capítulo 1, a mayor velocidad de oscilación, mayor es la energía consumida.

3.2 Modos de operación Los modos de operación se configuran manipulando los bits CPUOFF, OSCOFF, SCG0 y SCG1, todos pertenecientes al registro de estado SR (STATUS REGISTER). La razón por la cual el modo de operación se maneja en el registro de estado, es que éste es guardado en el stack durante la atención de una rutina de interrupción. De este modo al salir de la rutina que atiende la interrupción se regresa al modo en que el microcontrolador operaba antes de atender la interrupción. Si en alguna aplicación se desea regresar a un modo de operación distinto, basta con modificar el registro de estado que se encuentra en el stack. Lo anterior se logra manipulándolo dentro de la rutina que atiende la interrupción. Cuando se modifica alguno de los bits mencionados, el microcontrolador cambia su modo de operación de manera inmediata. Es por esto que se debe tener especial cuidado de no apagar fuentes de reloj que la aplicación contempla utilizar. Como ejemplo de condición de riesgo se presenta el caso de una aplicación que opera en bajo consumo y la CPU se activa con las interrupciones del timer A. Si en algún punto del programa se apaga la fuente de reloj que alimenta al timer A, entonces no se generará la interrupción y el microcontrolador nunca entrará en operación.

34

3.3 Modos de operación En la práctica los cinco modos de operación presentes en la familia MSP430 se traducen a señales de control del módulo de relojes estudiado en el capítulo previo. La diferencia entre uno y otro modo de operación son las fuentes de reloj que se mantienen activas. En la figura 3.1 [3] se presenta el diagrama de bloque que muestra cada uno de los modos de operación.

Figura 3.1: Modos de bajo consumo.

La tabla 3.1 [3] resume los modos de operación, incluyendo bits del registro de estado y su relevancia en el módulo de relojes.

SCG1 SCG0 OSCOFF CPUOFF Mode Estado de la CPU y los Relojes 0 0 0 0 Activo CPU activa, todos los relojes habilitados activos 0 0 0 1 LPM0 CPU, MCLK deshabilitados SMCLK, ACLK activos

0 1 0 1 LPM1 CPU, MCLK, DCO deshabilitados

Generador DC deshabilitado si DCO no es fuente de MCLK o SMCLK

ACLK activo 1 0 0 1 LPM2 CPU, MCLK, SMCLK, DCO deshabilitados Generador DC permanece activo ACLK activo

1 1 0 1 LPM3 CPU, MCLK, SMCLK, DCO deshabilitados Generador DC deshabilitado ACLK activo

1 1 1 1 LPM4 CPU y todos los relojes deshabilitados

Tabla 3.1: Modos de bajo consumo.

35

3.4 Empleo de los modos de bajo consumo Un evento de interrupción despierta al microcontrolador de cualquiera de los modos de bajo consumo. El flujo del programa es el siguiente:

• Ingreso a la rutina de servicio de interrupción. o Los registros PC y SR son guardados en el stack. o Los bits del SR son limpiados automáticamente.

• Opciones para retornar de la rutina de servicio de interrupción. o El estado de los bits del SR son restaurados desde el stack y se regresa al

modo de operación previo. o Los bits del SR almacenado en el stack pueden ser modificados, retornando

así a un modo de operación distinto.

3.5 Consideraciones para aplicaciones de bajo consumo Para aplicaciones de bajo consumo se deberá maximizar el tiempo de operación en el LPM3, pues el consumo promedio alcanza los 2 μA. De esta forma se tiene activo el cristal de 32,768 kHz que alimenta la señal ACLK. En los períodos de actividad de la CPU se debe seleccionar como fuente de reloj el DCO, pues su tiempo de respuesta es de 6 μs y es el que menos energía consume.

3.6 Definiciones para el manejo de los modos de operación Para manipular los bits del registro de estado existen dos instrucciones: Para fijar valor alto del bit “X_bit” _BIS_SR(X_bit); Para fijar valor bajo del bit “X_bit” _BIC_SR_IRQ(X_bit); Se debe tener presente que las interrupciones deben estar habilitadas al entrar a los modos de bajo consumo, esto se logra con el bit GIE. De lo contrario no habrá posibilidad de interrumpir al microcontrolador. En el código 3.1 se proporcionan definiciones para los bits de cada modo.

Código 3.1: Bits de control de modo de operación.

36

De esta forma, para entrar al LPM2, se usará la instrucción: _BIS_SR(LPM2_bits + GIE); En el código 3.2 se presentan las definiciones para entrar y salir de los modos de bajo consumo.

Código 3.2: Entrar y salir de modos de operación.

Como ejemplo consideremos la situación presentada en el código 3.3 de un programa que entra en bajo consumo, se activa la CPU por interrupción de timer, se realiza una acción y se vuelve a bajo consumo.

Código 3.3: Ejemplo de flujo para modos de bajo consumo.

37

En la figura 3.2 [4] se presenta una imagen que muestra el consumo de corriente esperado para el código anterior. Cuando se está en bajo consumo, la corriente suministrada al microcontrolador es de aproximadamente 2 µA.

Figura 3.2: Consumo de corriente en aplicaciones de bajo consumo.

38

3.7 Datos experimentales de consumo de corriente La figura 3.3 [3] presenta el consumo típico del microcontrolador según el fabricante.

Figura 3.3: Consumo de corriente en los modos de operación.

Ahora se quiere medir los datos de consumo experimentalmente, pero para esto se debe tener presente que medir el consumo de corriente del microcontrolador directamente no es el objetivo, pues interesa saber cuánto consume el módulo que está disponible en pañol. Aparte del microcontrolador MSP430F1612, el módulo cuenta con cristales osciladores, resistencias de Pull-Up y Pull-Down y otras componentes capacitivas, todas ellas consumidoras de corriente, por lo que los resultados experimentales debiesen arrojar valores de corriente consumida superiores a los entregados por el fabricante, que toma sus mediciones en condiciones ideales. Para tomar las mediciones se utilizó la conexión mostrada en la figura 3.4.

Figura 3.4: Conexión para medir consumo de corriente.

Como puede verse en la figura 3.4 se conectó un Amperímetro en serie entre la fuente de alimentación y la señal Vcc de la tarjeta de desarrollo.

39

Los experimentos realizados fueron medir el consumo de corriente para cada uno de los seis modos de operación existentes. Se comenzó por la condición de inactividad, para el caso del modo activo se deja al procesador en Idle. Para esta prueba se utilizó el código 3.4.

Código 3.4: Medición de consumo de corriente para modos de operación.

Como se aprecia en el código 3.4, basta descomentar una de las seis líneas finales para elegir uno de los modos de operación. Este experimento se realizó fijando Vcc en 3,18 V para poder generar la figura 3.5, que se debe comparar con la figura 3.3 para tener un contraste entre el consumo del microcontrolador y el consumo del módulo completo.

Figura 3.5: Consumo de corriente experimental.

Tal como se esperaba, el consumo de corriente de la tarjeta de desarrollo disponible en el Departamento de Electrónica es superior al consumo del microcontrolador por si sólo. Adicionalmente se destaca que incluso la temperatura hace variar la medición de corriente consumida. Si se hace el simple ejercicio de poner un dedo sobre el microcontrolador, se verá que la corriente suministrada por la fuente puede subir hasta 150 μA, dependiendo de la presión ejercida y si se frota o no.

40

41

Capítulo 4: UART: Comunicación serial asincrónica

4.1 Módulo UART Existen en el Departamento de Electrónica varios documentos donde se hace referencia a este módulo [5]. Adicionalmente existe ya una experiencia de laboratorio que cubre esta materia [6]. Un tópico sobre la comunicación serial asíncrona no tratado anteriormente es la generación de tasas de baudios. Este capítulo cubre los procedimientos necesarios para diseñar una tasa de transmisión, sea ésta estándar o no.

4.2 Generación de tasas de baudios El generador de tasas de baudios del módulo USART es capaz de producir tasas estándares a partir de fuentes de frecuencia no estándares. Para lograr una tasa de baudios deseada es necesario alimentar el módulo USART con una fuente de reloj y asignar valores a tres registros. Dos de estos registros se utilizan para fijar una frecuencia nominal, el tercer registro pertenece a un modulador, el que permitirá hacer un ajuste fino de frecuencia, con el objeto de minimizar el error. Los tres registros asociados y el multiplexor selector de relojes de entrada se muestran en la figura 4.1 [5].

Figura 4.1: Generador de baudios.

Como se verá en este capítulo el procedimiento para fijar el valor del modulador es interactivo, por lo que se propondrá un modelo de programación lineal entera para obtener las tasas de transmisión necesarias, minimizando el máximo error por bit.

42

4.3 Procedimiento de diseño La primera etapa de diseño será determinar el valor del factor de división entre la frecuencia que tenga la fuente de reloj seleccionada y la tasa de baudios deseada. Internamente el microcontrolador MSP430 cuenta con un contador de 16 bits y un comparador. Con esta etapa se logra generar la parte entera del factor de división mencionado. Para la parte decimal, se utilizará el modulador.

ratebaudBRCLKN

_=

donde: N: factor de división BRCLK: reloj

El contador de 16 bits está construido con 2 registros de 8 bits, por lo tanto la parte entera de N se genera con la unión de UxBR1 y UxBR0, la cual llamaremos UxBR. Por otro lado la parte decimal de N se generará con el modulador, procedimiento que se describirá en la sección siguiente.

∑−

=

+=1

0

1 n

iim

nUxBRN

donde:

N: factor de división objetivo UxBR: representación de 16 bits de UxBR0 y UxBR1 i: posición del BIT en el frame n: BITS por frame mi: valor del BIT (1 o 0)

Luego se ve que la tasa de baudios deseada se compone según:

∑−

=

+== 1

0

1_ n

iim

nUxBR

BRCLKN

BRCLKratebaud

Si un bit del modulador está en estado SET, entonces el factor de división se incrementa en uno. En caso contrario éste se mantiene en el valor dado por UxBR.

43

4.4 Determinación del valor del modulador El timing para el bit de inicio está dado por UxBR + m0, para el siguiente bit es UxBR + m1, y así sucesivamente. Cuando el carácter es mayor que 8 bits, la secuencia del modulador se reinicia con m0 hasta que termina el proceso. Utilizando la fórmula del error propuesta en el manual del microcontrolador MSP430, se comienza con el bit de inicio. Se calcula el error para ambos casos en que m0 esté en estado SET o RESET. Se elige el valor de m0 según el menor error. Luego se procede a calcular el error para el siguiente bit. El proceso termina cuando se han calculado todos los valores para el frame. Si éste cuenta con más de 8 bits, entonces el noveno usa el bit del modulador m0, el décimo usa m1 y así sucesivamente. El error para cada BIT puede entonces ser calculado según la fórmula propuesta que se presenta en la ecuación 1 [5].

%100)1()1(_[%]1

0×

⎭⎬⎫

⎩⎨⎧

+−⎥⎦

⎤⎢⎣

⎡+×+×= ∑

−

=

jmUxBRjBRCLK

ratebaudERRORn

ii (1)

donde: baud_rate: tasa de baudios deseada BRCLK: frecuencia de entrada (ACLK, SMCLK, etc…) j: posición del BIT dentro del frame UxBR: factor de división en registros UxBR0 y UxBR1

4.5 Modelo de Programación Lineal Entera Para el modelo se utiliza el método Simplex [18] de George B Dantzig [19]. No es objeto de este trabajo fundamentar el método ni tampoco abordar la solución del problema con operaciones matriciales. A continuación se presentará el modelo propuesto. Variables: m0, m1, m2, m3, m4, m5, m6 y m7. Función Objetivo: MINIMIZAR el Máximo error por bit en valor absoluto. Sujeto a: m0, m1, m2, m3, m4, m5, m6 y m7 son binarios.

44

4.6 Ejemplos de uso del modelo y funcionamiento en la MSP430 Para probar el funcionamiento del modelo del punto 4.5 se presenta un ejemplo donde se requiere utilizar el módulo UART0 para establecer una comunicación a una tasa de 2400 baudios. Lo primero es utilizar el archivo uart.xls disponible en el CD adjunto. La presentación del archivo se muestra a continuación:

BAUD RATE 2400 BAUDIOS RELOJES BRCLK 32768 MODULADOR 1200 UxBR 13 5 2400 = 4800 m0 1 5 9600 32768 m1 1 19200 m2 0 38400 m3 1 76800 m4 0 115200 m5 1 230400 1048576 m6 1 460800 m7 0 921600 1843200 8388608j ABS MAX ERROR 0 Start Bit 2,54 2,54 5,08 1 D0 5,08 5,08 2 D1 0,29 0,29 3 D2 2,83 2,83 4 D3 -1,95 1,95 5 D4 0,59 0,59 6 D5 3,13 3,13 7 D6 -1,66 1,66 8 D7 0,88 0,88 9 Stop Bit 3,42 3,42 15,15 22,37

Lo único que el usuario debe hacer es poner la tasa de baudios deseada en la casilla gris claro y la frecuencia del reloj que alimenta el módulo en la casilla gris oscuro. Luego debe ir al menú “herramientas”, la opción “Solver” y seleccionar “Resolver”.

45

El resultado son los valores de los registros UBR0, UBR1 y UMCTL0. El valor para UBR0 y UBR1 vienen de UxBR. El valor para UMCTL0 está dado por los bits m0-7, siendo m0 el lsb y m7 el msb. En este caso se lee de m7 a m0: 0 1 1 0 1 0 1 1. UBR1 = 0x00 UBR2 = 0x13 UMCTL0 = 0x6d

46

47

Parte II Integración de periféricos con el MSP430 La segunda parte de esta memoria cuenta con 2 capítulos orientados a resolver la conectividad del microcontrolador MSP430 con una base de datos. El capítulo 5 aborda el tema del almacenamiento masivo, local con el MSP430, en una memoria SD. Para esto se desarrollará un driver y una biblioteca de entrada y salida. El capítulo 6 desarrolla el tema de conectividad WiFi.

48

49

Capítulo 5: SD/MMC: Almacenamiento masivo

5.1 Secure Digital Card La tarjeta digital segura [7] (SD) es una memoria flash diseñada para cumplir con los requerimientos de seguridad, capacidad y desempeño del masivo crecimiento del mercado de electrónica de consumo, como lo son dispositivos de audio y video, como también para soportar aplicaciones industriales como Data Loggers. La comunicación con la tarjeta SD se basa en una interfaz de 9 pines, soportando 2 modalidades de bus, el bus SD y el bus SPI. El bus SD consta de una señal de reloj, una señal de comandos, 4 señales de datos y 3 señales de alimentación. El bus SPI funciona de acuerdo al estándar con 2 señales de alimentación, 1 señal de reloj, 2 señales de datos y una señal de control. Se destaca que el estándar SD se especificó para la compatibilidad con el estándar de la tarjeta multimedia [8] (MMC), por lo que el diseño del nodo anfitrión (Host) controlador soportará ambas tarjetas. La elección del bus SPI por sobre el bus SD radica mayormente en que el microcontrolador MSP430F1612 que se utiliza como Host posee una interfaz SPI, por lo que el tiempo de desarrollo se disminuye considerablemente. Adicionalmente se le da mayor provecho al hardware dedicado del microcontrolador, puesto que desarrollar un software para el bus SD demandaría la utilización de puertos digitales generales y una excesiva recarga de procesamiento de la CPU, dado que no se utilizaría un periférico integrado, como en el caso del bus SPI. La principal motivación para el desarrollo de un driver para la MSP430 que controle la comunicación con tarjetas SD es que actualmente el Departamento de Electrónica desarrolla conectividad del microcontrolador MSP430 con periféricos y es de interés integrar, dentro de las experiencias de laboratorio de estructura de computadores, la utilización de un hardware dedicado al almacenamiento masivo de datos. Dado que la estructura interna de la tarjeta SD agrupa los datos en bloques de 512 bytes, toda transmisión, ya sea de lectura o escritura, está sujeta a este tamaño de bloque, por lo que finalmente, para ocultar las restricciones del hardware, nace el objetivo de crear una biblioteca de entrada/salida para manejar la comunicación desde el microcontrolador como si se tratara de un archivo.

50

5.2 Bus de comunicación SPI Como se mencionó en el punto 4.1 la utilización del bus SPI se debe a que el microcontrolador MSP430 posee un periférico dedicado a las comunicaciones seriales. Este módulo es el llamado UART y es configurable vía registros para funcionar en modalidad SPI [9]. No es un objetivo de esta memoria la descripción del protocolo SPI, por lo que se mencionan sólo sus características de interés para este trabajo. SPI es un protocolo de transmisión serial sincrónico. Utiliza el sistema cliente/servidor, vía 2 líneas de comunicación. El servidor envía al cliente por un canal half duplex 8 ciclos de reloj, equivalentes a un byte. Por esto se dice que el protocolo SPI es orientado al byte, puesto que cada transmisión del cliente al servidor o viceversa se realiza durante el envío de esos 8 ciclos de reloj. La figura 5.1 muestra las ráfagas de 8 ciclos de reloj que envía el servidor al cliente, esta línea se designa como CLK, las líneas de datos tienen nombres lógicos referentes a quien envía y quien recibe. Puesto que las líneas de datos son half duplex, por una línea la información la envía el servidor y la recibe el cliente. Esta línea se designa como SIMO, que es la sigla en inglés para slave in master out. La otra línea se designa como SOMI, slave out master in.

Figura 5.1: Ráfagas de 8 ciclos de reloj.

La figura 5.2 muestra el caso de que el maestro envíe el número 14 y el esclavo responda con el número 6.

Figura 5.2: Ejemplo de utilización del bus SPI.

51

Adicionalmente SPI proporciona un canal de control por el cual el maestro tiene la facultad de habilitar o no el canal SOMI. Esta línea de control se designa como CS, que en inglés es Chip Select. Esta señal funciona con lógica negativa, lo que significa que por lo general la línea estará en valor lógico 1 y cuando se desea habilitar al cliente, se aserta la señal poniéndola en el nivel lógico 0. La asignación de pines para el bus SPI de la tarjeta SD se muestra en la tabla 5.1 [10].

Tabla 5.1: Asignación de pines del bus SPI.

El método initSPI() tiene como objetivo inicializar el módulo UART1 como maestro en modo SPI de 8 bits, en modo de 3 pines, validando los datos en el canto de subida del reloj, con un desfase de ½ ciclo de reloj y con una frecuencia de reloj de 4 MHz.

Código 5.1: Configuración de UART1 para SPI.

52

El método sdSendByte() ilustra el beneficio de haber utilizado el bus SPI. Como se mencionó el módulo SPI integrado nos permite enviar y recibir datos de una manera muy sencilla. Básicamente se espera que el módulo UART1 esté desocupado y se pone el carácter a enviar en el registro TXBUF1; luego se espera tener una transmisión completa del carácter y la recepción completa del carácter de respuesta. Luego se lee el registro RXBUF1 y se retorna su valor.

Código 5.2: Envía y recibe un byte por SPI.

5.3 Módulo MSP430-SD Para el laboratorio de estructura de computadores, se encuentra en desarrollo el diseño de nuevos módulos en base al microcontrolador MSP430. Uno de éstos es el MSP430-SD. Cada módulo cuenta con un bus de comunicación I2C más la alimentación de 5 Volts. El módulo MSP430-SD tendrá que contar con un socket SD y todo el hardware necesario para la comunicación, alimentación y seguridad. El objetivo no es el diseño del PCB del módulo, sino obtener el esquemático y las bibliotecas de software necesarios para su integración con otros módulos. Las siguientes secciones de este capítulo abordan los temas referentes al software necesario. El diseño del esquemático y hardware necesario para responder a las siguientes especificaciones:

• Se dispone de 3.3 [V], 5 [V] y GND común. • La alimentación de la tarjeta SD debe ser controlada por el MSP430. • Se debe proporcionar un bus SPI entre la MSP430 y la tarjeta SD. • El MSP430 debe detectar la presencia o ausencia de una tarjeta SD. • Se deben utilizar 2 Leds indicadores de lectura/escritura y error. • Se debe proporcionar la protección necesaria para compatibilidad de hardware.

5.3.1 Socket SD El Socket SD debe proporcionar una carcasa metálica para la inserción de la tarjeta SD y acceso a los 9 pines de la misma. Adicionalmente debe proporcionar la capacidad de detectar eléctricamente si existe una tarjeta inserta en el Socket o no.

53

La figura 5.3 [11] muestra un ejemplo de PCB con un Socket SD.

Figura 5.3: Socket SD.

Para la detección de la presencia de una tarjeta en el Socket basta con incorporar un switch de contacto entre la carcasa y una señal que denominaremos CD, del inglés Card Detect. Para esto necesitamos definir una señal para la carcasa, la que denominamos COM, que abrevia la palabra común. El circuito sugerido se muestra en la figura 5.4.

Figura 5.4: Circuito detector de tarjetas.

Como puede verse en la figura 5.4 la carcasa está acoplada a tierra, designada como GND, del inglés Ground. La señal CD tiene una resistencia de pull-up. Cuando no hay una tarjeta inserta el switch está abierto y la señal CD está en 1 lógico. Cuando se inserta una tarjeta se cierra el switch completando el circuito entre VCC y tierra por medio de COM y CD, por lo que la señal CD estará en el nivel 0 lógico. Es la señal CD la que se conecta a un puerto digital del MSP430 configurado como entrada, por lo que del lado del microcontrolador la tarjeta SD verá una alta impedancia, validando así el diseño del circuito.

54

5.3.2 Alimentación La alimentación de la tarjeta SD debe poder controlarse por software, esto para disponer de un reset de hardware desde el microcontrolador. Existe una limitación de corriente, puesto que los puertos digitales del MSP430 permiten como máximo una corriente de entrada/salida de ±2 [mA] (recomendación del fabricante), lo que está muy por debajo de 70 [mA], que es la máxima corriente que consume la tarjeta SD cuando se encuentra en la operación de escritura. Por lo anterior es que el circuito debe disponer de un interruptor controlado por voltaje, para lo cual se utiliza un transistor NPN modelo bc-547 y un transistor PNP modelo 2N3906. La figura 5.5 muestra el circuito sugerido.

Figura 5.5: Circuito de alimentación.

Como se aprecia en la figura 5.5 el transistor NPN está en su configuración de inversor, por lo que una señal en alto desde el microcontrolador hará que el transistor NPN esté en saturación, de esta forma el transistor PNP logra que la señal VCC_SD esté en bajo (Vce ~ 0.2 [V]). Si P5.5 está en bajo, entonces el transistor NPN entra en corte y la señal VCC_SD queda en alto recibiendo la corriente directamente de la fuente externa, a través del PNP que opera como interruptor.

5.3.3 Bus SPI Como se mencionó en la sección 5.3.2, la alimentación y la detección de la tarjeta SD se logran utilizando 2 puertos digitales del microcontrolador. Para alimentar la base del transistor se declara P5.5 como salida y para detectar la presencia de tarjeta se declara como entrada P5.0. MSP SD ----------------------------------------- P5.5 Pin4/Vcc P5.0 Pin6/CD Vss Pin3/GND

55

Para proporcionar el bus SPI se utilizan 4 puertos digitales del microcontrolador. P5.4 se configura como salida y es la señal de control que habilita a la tarjeta SD. Los otros 3 pines se configuran como periféricos para utilizar el hardware integrado dentro del MSP430. La asignación de pines se muestra a continuación. MSP SD ----------------------------------------- P5.4 Pin1/CS P5.1/SIMO1 Pin2/DIN P5.2/SOMI1 Pin7/DOUT P5.3/UCLK1 Pin5/CLK Se destaca la necesidad de algunas resistencias de pull-up, que se describirán en la sección 5.3.4

5.3.4 Protección La tarjeta SD proporciona la interfaz para el bus SPI y también para el bus SD, por lo que existen pines que no utilizaremos. Por restricciones físicas de la tarjeta, el fabricante recomienda utilizar resistencias de pull-up en los terminales de datos del bus SD que no se utilizan en el bus SPI. La tarjeta SD soporta la inserción/extracción en caliente, lo que significa que la tarjeta puede ser insertada o removida con alimentación aplicada. El problema que esto presenta son los peaks de corriente que se producen; los cuales, en la práctica, llevan al MSP a perder corriente de alimentación y lo lleva a un estado de RESET. Esto se soluciona con el mismo circuito mostrado en la figura 5.5. Esto evitará que el microcontrolador y la tarjeta SD compartan directamente la alimentación. Por recomendaciones del fabricante del MSP430 la salida de datos SPI denominada SIMO debe contar con una resistencia de pull-up.

5.3.5 Leds Indicadores Con el objetivo de contar con indicadores de error y de estado de lectura o escritura, se añaden 2 Leds. El primero indicará si ha ocurrido un error en la comunicación. El segundo indica si se está realizando una operación de lectura o escritura, y en general si se están enviando datos por el bus SPI.

56

Para lo anterior se utiliza un circuito simple con un par resistencia-led y para esto se utilizan 2 puertos digitales del MSP430 como salidas. Esto se ilustra en la figura 5.6.

Figura 5.6: Led indicador.

5.3.6 Esquemático Dado que se requieren exactamente 8 señales del microcontrolador es que se elige utilizar por completo el puerto 5 del MSP430 debido a que el periférico integrado UART1 se encuentra físicamente ligado a este puerto. Cumpliendo con los requerimientos de diseño y protección anteriores, se presenta el esquemático propuesto para crear el módulo MSP430-SD a integrar en el módulo estándar del área de computadores. El circuito esquemático del diseño propuesto se presenta en la figura 5.7.

Figura 5.7: Circuito esquemático del módulo MSP430-SD.

57

5.4 Driver para manejo de memorias SD Lo primero que debe hacerse cuando se requiere desarrollar un driver para un dispositivo es estar familiarizado con sus características y los protocolos que utiliza. En el caso de las tarjetas SD, existe un organismo llamado SD Card Association [7], que tiene patentes sobre el estándar SD. Lamentablemente la documentación sobre el funcionamiento de las tarjetas SD es limitado puesto que la asociación lucra con el protocolo. Afortunadamente existen fabricantes que tienen disponibles la documentación necesaria para diseñar un Host que controle sus productos. El driver desarrollado se basa en el documento SanDisk Secure Digital Card, Product Manual, Version 1.9, de SanDisk [12].

5.4.1 Descripción de la tarjeta SD

5.4.1.1 Interfaz SPI La interfaz SPI de la tarjeta SD es compatible con cualquier host SPI del mercado, quiere decir que cuenta con 4 señales de interés:

• CS señal de Chip Select del host a la tarjeta • CLK señal de reloj del host a la tarjeta • DataIn señal de datos del host a la tarjeta • DataOut señal de datos de la tarjeta al host

La señal CS habilita la tarjeta cuando está en el nivel 0 lógico y la deshabilita cuando está en nivel lógico 1. Físicamente se debe conectar a un puerto digital del microcontrolador configurado como salida. En este driver se elige utilizar P5.4. La máxima frecuencia para la señal CLK es de 25 [MHz]. El reloj con que cuenta el módulo del MSP430 es de 8 [MHz], y según las especificaciones del módulo UART la máxima frecuencia de salida de la señal CLK será de la mitad de la frecuencia de entrada. En este diseño se fija la frecuencia de la señal CLK en 4 [MHz]. Físicamente se conecta al microcontrolador al puerto digital configurado como periférico que cuenta con el reloj del módulo UART, en este driver se utiliza el UART1, por lo que el puerto elegido es P5.3/UCLK. DataIn es la entrada de datos de la tarjeta, por lo que se debe conectar al puerto digital del microcontrolador habilitado para la señal SIMO, que es P5.1/SIMO. DataOut es la salida de datos de la tarjeta, por lo que se conecta a P5.2/SOMI.

58

5.4.1.2 Tamaño del bloque El tamaño del bloque de datos por omisión en la tarjeta es de 512 bytes. Este es fijo y según la literatura en Internet puede variarse vía comando. Según el fabricante esto no es posible, pues induce a errores de escritura, por lo que en este driver la lectura y escritura será siempre de 512 bytes consecutivos y pertenecientes al mismo bloque de datos.

5.4.1.3 Estructura de los comandos Los comandos son siempre enviados por el host a la tarjeta y tienen un largo de 6 bytes. El primer byte corresponde al comando a enviar. Los siguientes 4 bytes son para el argumento del comando. El último byte se utiliza para enviar el CRC. La figura 5.8 [12] muestra la estructura de un comando SD.

Figura 5.8: Estructura de un comando.

5.4.1.4 Estructura de las respuestas Las respuestas son siempre enviadas por la tarjeta al host. El tamaño de una respuesta es de 1 byte. El significado de la respuesta puede verse en la figura 5.9 [12].

Figura 5.9: Estructura de la respuesta.

5.4.2 Inicialización Al momento de alimentar la tarjeta SD, ésta necesita de un tiempo para alcanzar el voltaje de alimentación mínimo con el cual pueda recibir comandos desde el host. El fabricante recomienda que el host no espere este tiempo con retardos, sino que envíe ciclos de reloj con lo que además de esperar que el voltaje de alimentación sobrepase el mínimo umbral, se aprovecha de sincronizar la velocidad de baudios del reloj que envía el host a la tarjeta. El fabricante recomienda enviar 74 ciclos de reloj. Como la comunicación SPI del lado del

59

microcontrolador está configurado para enviar ráfagas de 8 ciclos de reloj, lo recomendado es enviar 10 ráfagas, así se envían 80 ciclos de reloj, lo que cumple la recomendación del fabricante. Luego de un reset de hardware la tarjeta se encuentra en modo SD, esto significa que se encuentra preparada para comunicarse por un bus SD. Como lo que se desea es utilizar el bus SPI, se debe enviar el comando reset a la tarjeta con la señal CS en bajo, pues la señal CS (card select) tiene lógica negativa. Al hacer esto la tarjeta queda en modo SPI en estado Idle. Antes de enviar comandos para transferencia de datos a la tarjeta, hay que esperar que esta salga del estado Idle, para conseguirlo se debe enviar a la tarjeta un comando que envía las condiciones de operación. La respuesta a este comando es de 1 byte y contiene un bit con el estado de Idle. Otro asunto a considerar es que al hacer un reset de hardware, la tarjeta se encuentra con cálculo de CRC activado; al pasar al modo SPI, se desactiva automáticamente el cálculo de CRC. Por esto es que al enviar el comando reset, se debe enviar un CRC correcto. El resto de los comandos se envía con CRC, pero su valor es superfluo. La estructura de los comandos, como fue mencionada en el punto 4.4.1, es de 6 bytes de largo. El primero lleva el comando a enviar, los siguientes 4 el argumento y por último el byte con el CRC. El fabricante proporciona el CRC calculado para el comando de reset, por lo que si no se desea utilizar comprobación de errores CRC, no se necesita ahondar en el tema. Al ser la primera versión del driver se escoge no utilizar detección de errores, pues el objetivo básico es lograr comunicación con la tarjeta SD. La figura 5.10 [10] muestra la inicialización desde que se alimenta la tarjeta SD hasta que se encuentra lista para transferencia de datos.

Figura 5.10: Inicialización de la tarjeta SD.

60

En resumen, el proceso de inicialización consiste en:

• Alimentar Vcc de la tarjeta SD con 3.3 [V]. • Enviar 10 ráfagas de 8 ciclos de reloj. (80 ciclos) • Fijar la señal CS en 0. • Enviar el comando reset. (0x 40 00 00 00 00 95) • Esperar respuesta. (0x 01) • Enviar comando de inicialización. (0x 41 00 00 00 00 ff) • Esperar respuesta. (0x 00)

Debido a que pueden ocurrir fallas, si la respuesta del comando reset no es 0x01, se debe comenzar desde el principio; ya que el error puede ser porque la tarjeta no ha alcanzado el umbral de voltaje de alimentación mínimo o porque no fue posible la auto negociación de velocidad de baudios. La figura 5.11 [13] muestra un esquema temporal del comando de reset.

Figura 5.11: Esquema temporal del comando reset.

Diferente es el caso en que el error se produce porque la respuesta del comando de inicialización no es 0x00, sólo se debe volver a enviar este comando hasta que la respuesta sea la esperada.

61

La figura 5.12 [13] muestra el esquema temporal del comando de inicialización.

Figura 5.12: Esquema temporal del comando de inicialización.

5.4.3 Lectura de datos Una vez que la tarjeta SD termina con éxito su inicialización ya está preparada para recibir comandos de lectura. Para la lectura los pasos a seguir son los siguientes:

• Fijar el valor de la señal CS en 0. • Enviar el comando de lectura. • Esperar la respuesta 0x00. • Esperar el data token 0x0fe. • Leer 512 bytes de datos. • Leer 2 bytes de CRC. • Fijar el valor de la señal CS en 1.

62

El esquema temporal de la lectura se muestra en la figura 5.13 [13].

Figura 5.13: Esquema temporal de la lectura.

5.4.4 Escritura de datos El caso de la escritura es similar al de la lectura y los pasos a seguir son:

• Fijar el valor de la señal CS en 0. • Enviar el comando de escritura. • Esperar la respuesta 0x00. • Enviar el data token 0xfe. • Enviar 512 bytes de datos. • Enviar 2 bytes de CRC. • Recibir la respuesta XXX00101 b • Esperar que la tarjeta finalice la escritura internamente. • Fijar el valor de la señal CS en 1.

63

Un esquema temporal para la escritura de datos se presenta en la figura 5.14 [13].

Figura 5.14: Esquema temporal de la escritura.

Al escribir en la tarjeta, lo que ocurre es que los datos son almacenados en un buffer de entrada de 512 bytes, por lo que luego de finalizada la transferencia de datos, se debe esperar mientras la tarjeta internamente guarda los datos recibidos en el sector especificado, antes de poder enviar otro comando. Una vez enviados los datos a la tarjeta, ésta envía una respuesta con el estado de la escritura, la cual se presenta en la figura 5.15 [12].

Figura 5.15: Estados de la escritura.

Para rescatar el estado de la operación de escritura se utiliza una herramienta denominada máscara, que consiste en aplicar la operación lógica AND con la máscara 00011111 b. Si la operación retorna el valor 00000101 b, quiere decir que se tuvo éxito.

64

5.5 Biblioteca de entrada/salida El driver propuesto en el punto 4.4 es dependiente de la tarjeta SD. Como se menciona, los bloques de datos condicionan las operaciones de lectura y escritura a 512 bytes consecutivos. Generalmente las aplicaciones de usuario usarán bloques de datos distintos a 512 bytes, la mayoría de las veces mucho menores en tamaño. Esto llevaría a perder una gran cantidad de memoria si es que se guarda un bloque de la aplicación en cada bloque de la memoria, por lo que es necesario desarrollar una biblioteca estándar de entrada y salida para que el usuario de la biblioteca no se enfrente a las dificultades propias de la arquitectura de la tarjeta SD. La propuesta es una biblioteca de entrada y salida que funcione de manera similar a la de UNIX, lo que significa que la conexión con la tarjeta SD será manejada como un archivo, proporcionando así métodos conocidos a los programadores que utilicen la tarjeta SD como Open, Close, Seek, Read y Write.

5.5.1 Abrir una conexión Abrir una conexión significa inicializar el módulo UART1 en modo SPI, inicializar la tarjeta SD y obtener el bloque actual y el offset dentro del bloque. Para esto fue necesario crear una estructura OpenFile, similar a la estructura para archivos abiertos que se utiliza en los sistemas operativos, donde en este caso, además del descriptor de archivo, se guarda la posición real dentro de la tarjeta donde terminó la última operación de lectura o escritura.

5.5.2 Cerrar una conexión Para cerrar la conexión con la tarjeta se debe simplemente deshabilitar la tarjeta SD y liberar el módulo UART1.

5.5.3 Posicionar el puntero de lectura escritura En sistemas operativos el offset se mide en bytes, pero se mostró que la tarjeta se divide en bloques, por lo tanto la biblioteca permite ocultar esto al usuario, transformando las distancias en bytes que éste proporciona, a cantidad de bloques y offset dentro del bloque. Para esto basta hacer algunas operaciones con los operadores de módulo. Como ejemplo, si queremos hacer un offset de 1489 bytes, y los bloques son de 512 bytes, en realidad lo que sucede es que nos movemos 2 bloques y el offset dentro del bloque final será de 465 bytes.

65

5.5.4 Leer datos de la tarjeta SD La operación de lectura clásica de sistemas operativos es en bytes. Si queremos leer menos de 512 bytes, lo que sucede es que traemos un bloque de 512 bytes y sólo se retorna al usuario los bytes deseados. De igual forma si el usuario desea leer más de un bloque, se llama repetidamente a la rutina de lectura hasta leer todos los bytes requeridos por el usuario. Se dará un ejemplo para mayor claridad. Suponer que el bloque actual es el 4 y que el offset dentro del bloque es 348, esto es se requieren leer 1692 bytes. La figura 5.16 muestra la situación del ejemplo.

Figura 5.16: Ejemplo de lectura.

Como se puede ver en la figura 5.16, la zona azul es la que se ha solicitado a la memoria. Se realizan 4 operaciones de lectura y se almacenan los bloques 4, 5, 6 y 7 en un buffer temporal. Luego se descartan los primeros 348 bytes del bloque 4 y los últimos 8 bytes del bloque 7. Finalmente el nuevo offset se fija en el bloque 7 con un offset dentro del bloque de 504 bytes. Esta última será la posición donde comience la próxima operación de lectura o escritura.

5.5.5 Escribir datos en la tarjeta SD El caso de escritura es similar al de lectura, sólo que ahora se debe tener una precaución adicional. Como cuando escribimos en la tarjeta, sólo podemos hacerlo en bloques de tamaño 512 bytes, si deseamos escribir 2 bytes, se sobrescribirán los bytes restantes del bloque, por lo que primero se debe leer el bloque a escribir y guardarlo en un buffer temporal; luego se escribe sobre este buffer temporal, para finalmente enviar a escribir este buffer a la tarjeta SD.

5.6 Documentación del driver y la biblioteca La documentación del driver para el módulo MSP430-SD se encuentra en el anexo C y la documentación de la biblioteca de entrada y salida se muestra en el anexo D.

66

5.7 Ejemplo de uso del driver y la biblioteca En el código 5.3 se puede ver un ejemplo que muestra el uso de los desarrollos propuestos en el capítulo 5. El programa escribirá la palabra “hola” 2 veces en la memoria. Lee los primeros 2 caracteres y luego prueba el método que informa cuantos bytes se han escrito y no se han leído, para por último leerlos.

Código 5.3: Ejemplo de uso de Driver y Biblioteca SD

67

Capítulo 6: Comunicación por WIFI

6.1 Módulo Airbon Direct Serial Bridge El módulo Airbone Direct Serial Bridge [14] es un puente que permite comunicar a Internet, vía protocolo 802.11, a dispositivos que tengan un puerto serial y trabajen con el estándar RS232. Como todos los dispositivos que cumplen función de bridge, la idea es permitir cambiar el medio de transmisión de los datos sin modificar el hardware del que se dispone. En este caso se aplica para dispositivos que pueden comunicarse vía puerto serial con el protocolo RS232 y que necesitan enviar o recibir datos de una WLAN. En la figura 6.1 se muestra una imagen del Serial Bridge.

Figura 6.1: Airbone Direct Serial Bridge.

68

En la figura 6.2 [15] se muestra un diagrama de la aplicación que tiene el Serial Bridge.

Figura 6.2: Aplicación básica del Serial Bridge.

La configuración del Serial Bridge se realiza vía WEB ya que este dispositivo posee un servidor HTTP. El Serial Bridge incluye un software para realizar pruebas llamado VCOM. El nombre VCOM viene de Virtual Communication y es que permite al usuario conectarse vía inalámbrica con el serial bridge creando un COM virtual en el hyperterminal de Windows. Esto permite realizar pruebas utilizando un solo computador, pues se conecta vía cable serial y vía WLAN. Más información acerca de esta utilidad se encuentra en la sección 6.2. Los parámetros de configuración para la operación de una aplicación se encuentran en la sección 6.3. Por último una aplicación de ejemplo que contempla el uso de un cliente JAVA se encuentra en la sección 6.4.

6.2 Utilidad VCOM Antes de comenzar a utilizar el Serial Bridge es recomendable verificar que todo esté en orden, para así aislar problemas que puedan surgir en la conexión con el microcontrolador. Los problemas pueden ser ocasionados por una mala configuración del Serial Bridge o porque la red inalámbrica en la que se está utilizando el dispositivo tiene cerrado los puertos necesarios para lograr la comunicación o utiliza clave WEP. Lo primero que se debe hacer es habilitar en la red donde se trabaje el puerto 8023, que es el utilizado por el Serial Bridge para redirigir el tráfico. Luego se debe ingresar al Access

69

Point y verificar que reconoce dentro de la red al Serial Bridge y además conocer la IP que le asigna dentro del dominio inalámbrico. Una vez que se tienen los accesos del párrafo anterior se debe alimentar el Serial Bridge y luego desde un PC que se encuentre en la misma red inalámbrica acceder a la página del Access Point. Generalmente esto se consigue desde un navegador web visitando la dirección del Access Point, que generalmente es http://192.168.0.1, o bien, http://192.168.1.1. Se debe verificar que el modo de operación del Access Point sea Infraestructura y no Ad-Hoc. Luego se debe ingresar a la sección de configuración inalámbrica, ahí se debe guardar el nombre de la SSID, para posteriormente utilizarla en la configuración del Serial Bridge. Además se debe encontrar la tabla de todos los dispositivos conectados y se debe registrar la IP asignada al serial Bridge. Si la IP asignada al Serial Bridge es, por ejemplo, 192.168.0.102, en el navegador web se debe acceder a esa dirección. Se debe ingresar al menú SERIAL. Ahí debe completarse la información registrada en el Access Point, es decir, el nombre de la SSID. Por último se debe instalar la utilidad VCOM que se encuentra en el CD que incluye el Serial Bridge. Para realizar la prueba se debe conectar el terminal serial del PC al Serial Bridge y abrir el programa Hyperterminal. Se debe establecer la comunicación por la COM1 con la configuración: (9600, 8, n, 1). Ahora se debe abrir otra ventana del programa Hyperterminal, esta vez se debe elegir la comunicación por la COM7, que es la utilizada por la utilidad VCOM. Si todo está en orden, lo que se escriba por la COM1 viaja por el cable serial hasta el Serial Bridge y éste redirige el tráfico por la WLAN hacia el PC, por lo que se debe ver que los caracteres son recibidos en la COM7.

6.3 Configuración del Serial Bridge Además de la configuración descrita en el punto 6.2 se debe activar el re direccionamiento TCP por el puerto 8023, para esto en el menú SERIAL se debe activar la opción de Túnel TCP. Con lo anterior se especifica que el Serial Bridge funcionará como un servidor TCP por el puerto 8023, por lo que del lado del Host se debe programar un cliente TCP, que abra un Socket al puerto 8023.

6.4 Ejemplo de uso del Serial Bridge El siguiente ejemplo consiste en conectar el puerto serial del Serial Bridge al microcontrolador MSP430. Por otro lado un PC que pertenece a la misma WLAN que el Serial Bridge tiene un cliente TCP. Al ejecutarlo éste envía un caracter al servidor TCP que se encuentra en el Serial Bridge. El caracter es enviado entonces con el protocolo RS-232 al

70

microcontrolador. En microcontrolador responde enviando un string hacia el Serial Bridge, y a su vez, éste redirige el string hacia el cliente TCP que corre en el host. En la consola del PC se ve el string que envía el microcontrolador. El código 6.1 muestra el programa que corre en el microcontrolador.

Código 6.1: Host Serial en MSP430.

71

El código 6.2 muestra el cliente TCP que corre en el PC.

Código 6.2: Cliente TCP.

Por último se ejecuta el cliente serial desde el PC y se recibe el string, en este ejemplo, “Hello World!”. La figura 6.3 muestra el resultado del ejemplo.

Figura 6.3: Ejemplo de uso del Serial Bridge.

Con este resultado se comprueba que la comunicación del microcontrolador vía WiFi es correcta y que puede utilizarse este medio de comunicaciones para aplicaciones de conectividad.

72

73

Parte III Conectividad con base de datos Esta tercera parte pretende mostrar una aplicación donde se utilicen las tecnologías estudiadas en las partes previas. Para esto se utilizará el microcontrolador MSP430, una tarjeta SD y un módulo de comunicación WiFi. Adicionalmente se utilizará un servidor de base de datos Derby embebido en una aplicación Java que cuenta con un cliente TCP para poder mostrar el funcionamiento de la aplicación.

74

75

Capítulo 7: Aplicación: Data Logger

7.1 Descripción de la aplicación En los capítulos anteriores se han expuesto ideas y desarrollado herramientas de programación que abarcan desde manejar el módulo de relojes de una manera intuitiva hasta drivers que permiten comunicar el microcontrolador MSP430 de manera inalámbrica con otros dispositivos. El objetivo de este capítulo es presentar una aplicación en la cual se utilicen las herramientas desarrolladas. La aplicación consiste en un adquisidor de datos que permite el rescate de información, almacenada localmente, a través de Internet. Su capacidad se extiende a actuar sobre señales de salida en lazo abierto, dependiendo del estado de las entradas. Para esto se utilizan botones y switches para simular sensores y leds para representar la actuación. Adicionalmente se controlará la posición de dos servomotores, que simulan un brazo mecánico con 2 grados de libertad. Se utiliza una memoria SD para almacenar los datos localmente. Las variables a almacenar serán el estado de los sensores. La conectividad se realiza mediante el módulo WiFi que se maneja con comunicación serial asíncrona. Lo anterior presenta la funcionalidad del microcontrolador MSP430. Para dar valor agregado a la aplicación embebida se utiliza un programa visual escrito en JAVA que cuenta con una base de datos y un cliente TCP. Desde la interfaz visual el usuario puede solicitar los datos almacenados en la memoria SD a través de Internet, para almacenar los datos recibidos en la base de datos. Adicionalmente el usuario podrá exportar la base de datos a formato Excel. Por último el usuario podrá controlar la posición de los servomotores desde el cliente JAVA. La figura 7.1 muestra un esquema general de la aplicación.

MSP430 + SD + Sensores + Actuadores Servidor: Base de datos + Cliente TCP

Módulo WiFi

Figura 7.1: Esquema de la aplicación.

76

7.2 Plataforma de Gestión La plataforma de gestión es una aplicación visual escrita en Java que cuenta con un cliente TCP, utilizado para establecer la comunicación con el sistema embebido. Adicionalmente cuenta con una base de datos DERBY [16] donde los datos son almacenados para posteriormente ser exportados a Excel. Por último cuenta con un control visual para la posición del servomotor. Para la implementación de la plataforma de gestión se utiliza NetBeans 5.0 [17], pues cuenta con un ambiente de programación visual para la interfaz del cliente Debido a que el desarrollo de software de gestión no es parte de los objetivos planteados para este trabajo es que sólo se desarrolla una pequeña aplicación con las funcionalidades suficientes para mostrar el funcionamiento de la aplicación embebida. La interfaz visual se presenta en la figura 7.2.

Figura 7.2: Interfaz Visual.

Como se aprecia en la figura 7.2 la interfaz visual permite sincronizar los datos desde el microcontrolador mediante el botón “Sincronizar”, exportar los datos a un archivo Excel y controlar la posición del servomotor de manera remota.

77

7.3 El sistema embebido La aplicación consiste en un controlador ON-OFF en lazo abierto que cuenta con ocho entradas de sensores ON-OFF y ocho salidas de actuación ON-OFF. Cada entrada está asociada a una salida de manera independiente. Los sensores se simulan con botones y la actuación es simulada por LEDs. Adicionalmente la aplicación controla la posición de un brazo con dos grados de libertad, esto se logra con la utilización de servomotores, uno de base y otro simula un brazo. Para el almacenamiento de datos se utiliza una memoria SD, la cual se comunica con el microcontrolador por medio del protocolo SPI. Para la conectividad con Internet se utiliza el módulo Airbone Direct Serial Bridge, que permite la comunicación con el microcontrolador por el protocolo RS-232 y reenvía la información por WiFi. La figura 7.3 muestra un esquema de la conectividad.

Figura 7.3: Esquema de conectividad

78

79

Capítulo 8: Conclusiones El microcontrolador MSP430 es una herramienta ampliamente utilizada en la industria de la microelectrónica, ya que cuenta con modos de bajo consumo de energía. En algunas aplicaciones el consumo de energía es de hasta un 40% menor que el resto de los microcontroladores presentes en el mercado. Dada las características del microcontrolador MSP430, se puede decir que éste cumple con las exigencias de la industria actual, permitiendo realizar tareas de carácter análogo o digital, ya sea en aplicaciones de control o telemetría. Se mostró con este trabajo que el microcontrolador MSP430 puede ser utilizado en aplicaciones que requieran almacenamiento masivo de información, ya sea de manera local (en el sistema embebido) o remota (una base de datos externa), a través de una conexión a Internet, ya sea cableada o inalámbrica. Por último, podemos resumir que el microcontrolador MSP430 cumple con los requisitos de conectividad, bajo consumo y capacidad de almacenamiento que lo posicionan como uno de los microcontroladores más utilizados en el mundo entero para tareas que requieran bajo consumo de energía.

8.1 Resultados de este trabajo El trabajo realizado consistió en el estudio de las herramientas de hardware y software necesarios para el uso del microcontrolador MSP430 en aplicaciones industriales, por lo que los resultados del mismo son desarrollos que fueron necesarios para el cumplimiento de los objetivos planteados, los cuales se resumen en los siguientes puntos:

• Se creó un driver que maneja el módulo de relojes del microcontrolador MSP430 que permite a los usuarios abstraerse del uso de los registros y acelera los tiempos de desarrollo.

• Se documenta el uso de los modos de bajo consumo de energía.

• Se realizó un modelo de programación lineal entera que minimiza el error de

transmisión y recepción de la comunicación serial asincrónica. El modelo se deja en formato Excel para su utilización con el complemento Solver.

• Se desarrolla un driver de hardware y de software para el almacenamiento de datos

en una memoria SD. Adicionalmente se desarrolla una biblioteca de entrada/salida para el uso de memorias SD que permita a los usuarios trabajar en alto nivel, sin necesidad que conozcan el funcionamiento interno de las memorias SD.

80

• Se desarrolló el driver necesario para controlar un Bridge RS-232 a WiFi con el microcontrolador MSP430.

• Se desarrollo en JAVA una plataforma de gestión que permite ilustrar la

conectividad del microcontrolador MSP430 con bases de datos.

8.2 Trabajos futuros Un posible trabajo futuro es el de agregar al actual driver para manejo de memorias SD la funcionalidad de detección del seguro contra escrituras WP (Write Protect). Esto se lograría con un desarrollo similar al utilizado para la detección de tarjetas CD (Card Detect). Se recomienda desarrollar una biblioteca FAT32 que utilice el driver y la biblioteca de entrada / salida propuestos en este trabajo, para así sólo implementar el sistema de archivos, ya que el problema de comunicación con la tarjeta SD ya está resuelto. Esto permitiría que los datos guardados en una memoria SD pudiesen ser leídos posteriormente desde Windows o Linux. Se recomienda generar drivers para cada uno de los componentes del microcontrolador MSP430, para así poder disponer de un ambiente de desarrollo que permita a los usuarios disminuir los tiempos de desarrollo y así focalizarse en aplicaciones de alto nivel.

81

Referencias [1] Familia de microcontroladores MSP430 de Texas Instrument. Disponible en: http://focus.ti.com/mcu/docs/mcuprodoverview.tsp?sectionId=95& tabId=140&familyId=342 [2] “MSP430x1xx Family User´s Guide”, Texas Instrument, 2003. Chapter 4: Basic Clock Module. Disponible en: http://focus.ti.com/mcu/docs/mcuprodtechdoc.tsp?sectionId=95&tabId=1204&fa milyId=911&techDoc=6&documentCategoryId=6 [3] “MSP430x1xx Family User´s Guide”, Texas Instrument, 2003. Chapter 2: System Resets, Interrupts,and Operating Mode. Disponible en: http://focus.ti.com/mcu/docs/mcuprodtechdoc.tsp?sectionId=95&tabId=1204&fa milyId=911&techDoc=6&documentCategoryId=6 [4] “Choosing An Ultralow-Power MCU”, Texas Instrument, 2004. Disponible en: http://focus.ti.com/lit/an/slaa207/slaa207.pdf [5] “MSP430x1xx Family User´s Guide”, Texas Instrument, 2003. Chapter 13: USART Peripheral Interface, UART Mode. Disponible en: http://focus.ti.com/mcu/docs/mcuprodtechdoc.tsp?sectionId=95&tabId=1204&fa milyId=911&techDoc=6&documentCategoryId=6 [6] “Laboratorio 6: Teclado Matricial y Comunicación Serial Asíncrona”. Disponible en: http://www.elo.utfsm.cl/~lsb/elo311/labs/elo312-0206-lab06.pdf [7] Ver estándar en la “SD Card Association”. Disponible en: http://www.sdcard.org/ [8] Ver estándar en la “MM Card Association”. Disponible en: http://www.mmca.org/home [9] “MSP430x1xx Family User´s Guide”, Texas Instrument, 2003. Chapter 14: USART Peripheral Interface, SPI Mode. Disponible en: http://focus.ti.com/mcu/docs/mcuprodtechdoc.tsp?sectionId=95&tabId=1204&fa milyId=911&techDoc=6&documentCategoryId=6 [10] “SanDisk Secure Digital Card: Product Manual”, Versión 1.9, 2003. Chapter 3: SD Card Interface Description. Disponible en: http://www.sandisk.com/Oem/Manuals/ [11] “Socket SD/MMC” de Olimex. Disponible en: http://www.olimex.cl/product_info.php?products_id=186

82

[12] “SanDisk Secure Digital Card: Product Manual”, Versión 1.9, 2003. Chapter 5: SPI Protocol Definition. Disponible en: http://www.sandisk.com/Oem/Manuals/ [13] Sitio de “Ulrich Radig”. Disponible en: http://www.ulrichradig.de/site/atmel/avr_mmcsd/pdf/MMCSDTimming.pdf [14] DPAC Technologies. Disponible en: http://www.dpactech.com/ [15] “Airbone Direct Serial Server User´s Guide” Disponible es: http://www.dpactech.com/docs/wireless_products/ABD_Serial_User's_Guide_R evD.pdf [16] Sitio de “Apache Derby”. Disponible en: http://db.apache.org/derby/ [17] Sitio de “NetBeans”. Disponible en: http://www.netbeans.org/ [18] Sitio sobre el método Simplex. Disponible en: http://www.phpsimplex.com/ [19] Sitio sobre el método Simplex. Disponible en: http://www.phpsimplex.com/pages/Dantzig.htm

83

Anexos

Anexo A: Registros del módulo de relojes

A-1 Control del DCO

DCOx Bits Selecciona entre las ocho posibles frecuencias para cada nivel de 7-5 RSELx seleccionado. MODx Bits Selección del modulador. Define cuan seguido la frecuencia es

4-0 generada sin un período de 32 ciclos del DCOCLK. En el resto de los (32-MOD) ciclos se utiliza la frecuencia del DCO. Nota: No tiene validez si DCOx = 7.

A-2 Control básico del sistema de reloj 1

XT2OFF Bit 7 Apaga el oscilador XT2 0 XT2 on (8 MHz) 1 XT2 off (default) XTS Bit 6 Selección del modo de LFXT1 0 LF baja frecuencia (32,768 kHz) 1 HF alta frecuencia (No se dispone en módulo USM) DIVAx Bits Divisor de la señal ACLK 5-4 00 /1 (default) 01 /2 10 /4 11 /8

84

XT5V Bit 3 No usado. Debe ser siempre 0. RSELx Bits La resistencia interna tiene 8 valores seleccionables. 2-0 El valor de la resistencia es proporcional a la frecuencia nominal.

A-3 Control básico del sistema de reloj 2

SELMx Bits Selección de la fuente de MCLK 7-6 00 DCOCLK (default) 01 DCOCLK 10 XT2CLK si está desactivado, LFXT1CLK 11 LFXT1CLK DIVMx Bits Divisor de la señal MCLK 5-4 00 /1 (default) 01 /2 10 /4 11 /8 SELS Bits 3 Selección de la fuente de SMCLK 0 DCOCLK (default) 1 XT2CLK si está desactivado, LFXT1CLK DIVSx Bits Divisor de la señal SMCLK 2-1 00 /1 (default) 01 /2 10 /4 11 /8 DCOR Bit 0 Selección de la resistencia del DCO

0 Resistencia interna 1 Resistencia externa

85

A-4 Habilitación de interrupciones

OFIE Bit 1 Habilitación de la interrupción OFIFG, gatillada por la falla

del oscilador. Dado que el resto de los bits tienen otro propósito se recomienda utilizar operadores al bit. 0 OFIFG deshabilitada 1 OFIFG habilitada

A-5 Señalización de interrupciones

OFIFG Bit 1 Señal de interrupción por falla del oscilador. Dado que el resto de

los bits tienen otro propósito se debe utilizar operadores al bit. Se debe limpiar este bit por software cada vez que ocurre una falla del oscilador. Se usa para activar la fuente de reloj XT2. 0 Sin interrupciones que atender 1 Interrupción por atender

86

87

Anexo B: DRIVER para manejo de Relojes El driver para manejar las señales de reloj del microcontrolador MSP430 incluye todas las definiciones y funciones necesarias de manera de ocultar al usuario el uso de los registros y así dar una presentación funcional e intuitiva de las señales de reloj. Autor: Carlos Silva Lütty Marzo 2007 Versión 1.0

B-1 Definiciones Ya que el manejo de las señales de reloj se implementa mediante registros, la mayor parte de este driver sólo necesita de definiciones, las que se explican según funcionalidad.

B-1.1 Interrupciones

• CLK_IE: Habilitar las interrupciones del módulo • CLK_ID: Deshabilitar las interrupciones del módulo • CLK_CF: Fijar en valor 0 el flag de falla del oscilador

B-1.2 XT2

• XT2_ON: Alimentar con Vcc el cristal XT2 de 8 [MHz] • XT2_OFF: Quitar la alimentación del cristal XT2

B-1.3 Fuentes para SMCLK

• SMCLK_DCO: SMCLK alimentado por el DCO • SMCLK_XT1: SMCLK alimentado por el XT1 • SMCLK_XT2: SMCLK alimentado por el XT2

B-1.4 Fuentes para MCLK

• MCLK_DCO: MCLK alimentado por el DCO • MCLK_XT1: MCLK alimentado por el XT1 • MCLK_XT2: MCLK alimentado por el XT2

88

B-1.5 Frecuencias para ACLK

• ACLK_FREC: ACLK con frecuencia FREC en Hertz. Valores válidos para FREC: 32768, 16384, 8192, 4096

B-1.6 Frecuencias para SMCLK

• SMCLK_FREC: SMCLK con frecuencia FREC en Hertz. Valores válidos para FREC: 8M, 4M, 2M, 1M, 32768, 16384, 8192, 4096

B-1.7 Frecuencias para MCLK

• MCLK_FREC: ACLK con frecuencia FREC en Hertz. Valores válidos para FREC: 8M, 4M, 2M, 1M, 32768, 16384, 8192, 4096

B-1.8 Frecuencias máxima y mínima para DCO

• MAX_DCO: DCO con frecuencia máxima • MIN_DCO: DCO con frecuencia mínima

B-2 Funciones

B-2.1 Puertos de prueba Nombre: Test_Ports Argumentos: ninguno Retorno: ninguno Recursos MSP430: P5.4-6 como periférico Descripción: Configura el puerto 5 para dejar disponibles en los pines 4, 5 y 6 las

señales MCLK, SMCLK y ACLK respectivamente.

89

B-2.2 Inicializar el oscilador Nombre: Init_Ocs Argumentos: ninguno Retorno: ninguno Recursos MSP430: XT2, IFG1, IE1, BCSCTL2, WDTCTL Descripción: Alimenta con Vcc el cristal XT2 y espera hasta que la señal de reloj

sea estable en amplitud y frecuencia.

B-2.3 Frecuencia del DCO Nombre: Set_DCO_4096_ Argumentos: int DELTA Retorno: ninguno Recursos MSP430: DCO, ACLK, TA Descripción: Dado que esta fuente de reloj produce una frecuencia dependiendo

del voltaje que lo alimente de manera proporcional, una forma de configurar la frecuencia es fijar un valor proporcional a múltiplos de 4096 utilizando el timerA en modo captura. Los rangos admitidos para DELTA están entre 20 y 1170.

90

91

Anexo C: DRIVER de comunicación con tarjeta SD Este driver incluye las herramientas necesarias para establecer la comunicación entre el microcontrolador MSP430 y una tarjeta SD utilizando un bus SPI sin comprobación CRC. El driver incluye el hardware y software para controlar la comunicación con la tarjeta SD y manejar 2 LED para indicar errores y flujo de información por el bus SPI.

C-1 Hardware El circuito utilizado comprende un socket para la tarjeta SD, el bus SPI, control de alimentación de la tarjeta desde el microcontrolador, protección mediando resistencias de pull-up y 2 LED para indicar errores y flujo de información por el bus SPI.

C-2 Software

C-2.1 Inicialización del MSP430 Nombre: initMSP Argumentos: ninguno Retorno: ninguno Recursos MSP430: WDTimer, SVS, SMCLK, ACLK Descripción: Protege la inicialización del MSP430 con el SVS y fija las señales de reloj a la frecuencia deseada.

92

C-2.2 Inicialización del módulo UART1 Nombre: initSPI Argumentos: ninguno Retorno: ninguno Recursos MSP430: UART1 Descripción: Configura el módulo UART1 en modo SPI configurado como

maestro, en modo 3 pin, con palabras de 8 bit, frecuencia de reloj de 4 [MHz] y validando los datos en canto de subida.

C-2.3 Detección de tarjeta SD Nombre: sdPing Argumentos: ninguno Retorno: char Recursos MSP430: P5.0 como salida Descripción: Detecta si hay o no una tarjeta SD inserta en el socket. Retorna un 0

si hay una tarjeta.

C-2.4 Enviar y recibir un byte por el bus SPI Nombre: sdSendByte Argumentos: char data Retorno: unsigned char Recursos MSP430: UART1, P5.6 como salida Descripción: Envía 8 ciclos de reloj a la tarjeta SD, junto con el caracter recibido

como argumento. Retorna el caracter transmitido desde la tarjeta SD. Cada vez que se usa el bus SPI, se hace por medio de esta función. Para indicar la utilización del bus SPI se utiliza un LED verde que parpadea si hay actividad en el bus. Si el LED permanece encendido sin parpadear, entonces ha ocurrido un error y significa que el caracter a enviar o recibir no está completo.

93

C-2.5 Activación de la tarjeta SD Nombre: sdActiveMode Argumentos: ninguno Retorno: ninguno Recursos MSP430: P5.1-3 como UART1, P5.4-7 como salidas y P5.0 como entrada Descripción: Configura el puerto 5 para comunicación SPI, llama a la función

initSPI(). Alimenta con Vcc a la tarjeta SD y envía 80 ciclos de reloj.

C-2.6 Desactivación de la tarjeta SD Nombre: sdDeactiveMode Argumentos: ninguno Retorno: ninguno Recursos MSP430: UART1, P5.5 como salida Descripción: Quita la alimentación de la tarjeta SD y apaga la máquina de estados

del módulo UART1.

C-2.7 Enviar comandos a la tarjeta SD Nombre: sdSendCmd Argumentos: char cmd, arg1-4, crc Retorno: ninguno Recursos MSP430: UART1 Descripción: Envía un comando a la tarjeta SD. Cada comando tiene 6 bytes. El

primero es el código del comando, los 4 bytes siguientes son el argumento del comando y por último se envía un byte de comprobación CRC.

94

C-2.8 Esperar por una respuesta de la tarjeta SD Nombre: sdWaitResponse Argumentos: char expected Retorno: unsigned char Recursos MSP430: UART1 Descripción: Todas las respuestas de la tarjeta para los comandos que se utilizan

en este driver son de 1 byte. Esta función se utiliza para comprobar que las respuestas son las que se esperan. Retorna el caracter recibido.

C-2.9 Inicialización de la tarjeta SD Nombre: sdDeactiveMode Argumentos: ninguno Retorno: char Recursos MSP430: UART1, P5.4 como salida Descripción: Inicializa la tarjeta SD. Envía el comando 0 y espera que la tarjeta

entre en estado Idle. Envía el comando 1 y espera que la tarjeta salga del estado Idle. Retorna el estado de la inicialización. Un nivel bajo indica que la tarjeta está preparada para recibir comandos.

C-2.10 Formatear la dirección de memoria Nombre: sdFixAddress Argumentos: const unsigned long address, char *arg Retorno: ninguno Recursos MSP430: ninguno Descripción: Recibe como argumento la dirección de memoria de la tarjeta SD

que quiere ser accesada. Ésta es formateada como 4 caracteres que se guardan dentro del arreglo para luego ser utilizada por la función sdSendCmd().

95

C-2.11 Verificar el estado de la escritura en la tarjeta SD Nombre: checkWriteState Argumentos: ninguno Retorno: char Recursos MSP430: UART1 Descripción: Verifica si el bloque de datos enviado a la tarjeta SD se recibió con

éxito.

C-2.12 Enviar datos a la tarjeta SD Nombre: WriteSD Argumentos: const unsigned long address, char *pBuffer Retorno: char Recursos MSP430: UART1, P5.4 Descripción: Envía el contenido de pBuffer a la dirección address de la tarjeta SD.

Sin importar el tamaño de pBuffer, se envían 512 bytes. Si hay éxito en la operación retorna 0.

C-2.13 Recibir datos desde la tarjeta SD Nombre: ReadSD Argumentos: const unsigned long address, char *pBuffer Retorno: char Recursos MSP430: UART1, P5.4 Descripción: Solicita a la tarjeta SD en envío de los datos almacenados en la

dirección address, los datos son almacenados en pBuffer. Esta operación hace que la tarjeta envíe siempre 512 bytes. Si hay éxito en la operación retorna 0.

96

97

Anexo D: Biblioteca de entrada/salida para tarjeta SD La biblioteca de entrada y salida para tarjeta SD implementa las herramientas de software necesarias para dar al usuario la posibilidad de trabajar la conexión entre el microcontrolador MSP430 y una tarjeta de memoria SD como si esta última se tratara de un archivo. Para esto utiliza el driver de comunicación para tarjetas SD. Se define la estructura OpenFile, que contiene un descriptor de archivo, un bloque y el offset dentro del bloque. Una vez definido el bloque inicial donde se comenzará a leer/escribir, puede usarse la función sdSeek, que oculta los bloques de 512 bytes y tiene un único argumento en bytes. Las funciones sdWrite y sdRead permiten escribir y leer respectivamente, una cantidad de bytes dado como argumento, ocultando al usuario la capa física, como lo son el bus SPI y la organización interna de la tarjeta SD.

D-1 Obtener la posición inicial de lectura/escritura Nombre: getPosition Argumentos: ninguno Retorno: ninguno Recursos MSP430: ninguno Descripción: Obtiene el bloque y offset desde el sector 0 de la tarjeta SD.

D-2 Fijar la posición inicial de lectura/escritura Nombre: setPosition Argumentos: ninguno Retorno: ninguno Recursos MSP430: ninguno Descripción: Fija el bloque y offset en el sector 0 de la tarjeta SD.

98

D-3 Abrir un archivo (conexión con tarjeta SD) Nombre: sdOpen Argumentos: ninguno Retorno: int Recursos MSP430: P5.7 como salida Descripción: Abre la conexión con la tarjeta SD, indica errores con el LED rojo.

Retorna el status, 0 significa éxito.

D-4 Cerrar un archivo (conexión con tarjeta SD) Nombre: sdClose Argumentos: int fd Retorno: int Recursos MSP430: P5.7 como salida Descripción: Cierra la conexión con la tarjeta SD, indica errores con el LED rojo.

Retorna el status, 0 significa éxito.

D-5 Posicionamiento del puntero de lectura/escritura Nombre: sdSeek Argumentos: long offset Retorno: int Recursos MSP430: P5.7 como salida Descripción: Fija la nueva posición donde se realizará la próxima lectura/escritura.

El desplazamiento del puntero es en bytes y la cantidad se da como argumento. Soporta argumentos enteros. Indica errores con el LED rojo. Retorna el status, 0 significa éxito.

D-6 Leer bytes desde la tarjeta SD Nombre: sdRead Argumentos: int fd, char *buf, unsigned long bytes Retorno: int Recursos MSP430: P5.7 como salida Descripción: Lee la cantidad de bytes indicados en el argumento desde la tarjeta y

los guarda en un buffer, también dado como argumento. Indica errores con el LED rojo. Retorna el status, 0 significa éxito.

99

D-7 Escribir bytes en la tarjeta SD Nombre: sdWrite Argumentos: int fd, char *buf, unsigned long bytes Retorno: int Recursos MSP430: P5.7 como salida Descripción: Escribe la cantidad de bytes indicados en el argumento en la tarjeta.

Los datos se entregan en un buffer dado como argumento. Indica errores con el LED rojo. Retorna el status, 0 significa éxito.

100