Taller de Microcontroladores: MSP430De IEEE-PUCEsta guía ha sido desarrollada por los integrantes del Capítulo Estudiantil IEEE-ICARO. En este documento se encuentra una gran cantidad de definiciones de distintos conceptos tanto relativos al mundo de los microprocesadores, como al mundo digital y la lógica binaria. Es necesario aclarar que los contenidos tienen un enfoque práctico, por lo que algunos tópicos fueron resumidos al punto de perder seriedad en la información (compresión con pérdida). Se recomienda al lector que use esta guía sólo como referencia. Ante cualquier duda o interés por alguno de los temas tratados, dirigirse a alguno de los integrantes de ICARO, quienes podrán ayudar a profundizar o conseguir más información respecto al tema. El taller se realizó el lunes 18 de noviembre de 2013 en la sala del Departamento de Ingeniería Eléctrica de la UC.

Contenido◾ 1 Introducción a los microcontroladores◾ 2 MSP430 y CCS ◾ 2.1 ¿Por qué MSP430?◾ 2.2 ¿Qué necesitamos para empezar a programar?◾ 2.3 Elementos básicos◾ 2.4 Archivos Importantes◾ 3 Manipulando los registros del microcontrolador ◾ 3.1 Lógica Binaria ◾ 3.1.1 NOT (~)◾ 3.1.2 AND (&)◾ 3.1.3 OR (|)◾ 3.1.4 OR exclusivo (^)◾ 3.1.5 Suma (+)◾ 3.2 ¿Qué es un registro?◾ 3.3 Enmascaramiento de Registros ◾ 3.3.1 Elevación de bits◾ 3.3.2 Hundimiento de bits◾ 3.4 Ejemplo: Manipulando el registro Watchdog Timer◾ 4 GPIO (General-purpose input/output) ◾ 4.1 Registros importantes ◾ 4.1.1 PxSEL, PxSEL2◾ 4.1.2 PxDIR◾ 4.1.3 PxOUT◾ 4.1.4 PxIN◾ 4.1.5 PxREN◾ 4.2 Ejemplo 1: Encendido de LEDs

Esquema simplificado de un microcontrolador.

◾ 4.2.1 Ejemplo 1.1◾ 4.2.2 Ejemplo 1.2◾ 4.2.3 Ejemplo 1.3◾ 4.2.4 Ejemplo 1.4◾ 4.2.5 Ejemplo 1.5◾ 5 ADC ◾ 5.1 Ejemplo 1: Uso básico del ADC◾ 6 Comunicación UART ◾ 6.1 Ejemplo 1: Enviando un caracter◾ 6.2 Ejemplo 2: Enviando strings (Arreglo de caracteres)◾ 7 Ejemplo final: Juego Snake

Introducción a los microcontroladores

Un Microcontrolador se puede describir en términos muy simplificados como un computador pequeño. Es un chip que se puede programar para una aplicación específica, es capaz de ejecutar un programa de manera secuencial y de responder a estímulos externos. En general, todos los microcontroladores son capaces de: ◾ Operar a una frecuencia mayor a unos cuántos MHz. ◾ Guardar datos en sus registros y realizar operaciones matemáticas y lógicas. ◾ Configurar entradas o salidas digitales. ◾ Generar interrupciones relacionadas a algún evento para responder adecuadamente ejecutando

un trozo de código específico. Cada tipo de microcontrolador se caracteriza de los demás según su frecuencia de operación y los

Launchpad

recursos o módulos que tiene disponibles. En este taller revisaremos los siguientes módulos: ◾ GPIO (General-purpose input/output). ◾ Timers (Contadores de ciclos de reloj). ◾ Conversor Análogo Digital (ADC). ◾ Módulos de comunicación con otros dispositivos.

Afortunadamente, hoy en día es muy común que existan compiladores de código C que traducen el código escrito por el usuario a lenguaje de máquina, por lo que el trabajo de programar el dispositivo se hace un poco más llevadero, ya que es posible definir variables, funciones y ocupar las estructuras típicas como los if() o el while().

MSP430 y CCS ¿Por qué MSP430? Si bien es cierto en la actualidad existe una gran cantidad de microcontroladores en el mercado, como los AVR de ATMEL (Arduino los ocupa), los PIC de microchip o el 8051 de Intel, en ICARO hemos decidido optar por la tecnología de Texas Intrument (MSP430) ya que cuentan con un alto desempeño, lo que los pone a la altura de un PIC, son sencillos de programar (se basa en el lenguaje C), no necesitan un periférico programador externo y además es muy barato: 9.9 dolares incluyendo costos de envio! . Más información. (http://www.ti.com/ww/en/launchpad/launchpads-msp430.html#tabs) ¿Qué necesitamos para empezar a programar? Si utilizas Windows, se recomienda altamenten instalar el software Code Composer Studio (CCS) Descargar (> 1Gb, requiere registro) (http://processors.wiki.ti.com/index.php/Download_CCS) . Si la descarga presenta problemas, el software también puede ser solicitado a los integrantes de Icaro (acércate a la oficina de la IEEE-PUC). Por ambos caminos obtendrás una versión de prueba del compilador que permite trabajar con códigos de hasta 16Kb, pero es más que suficiente para nuestras aplicaciones. Este software cuenta tanto con el compilador como con el programador, por lo que solo necesitamos un cable USB y nuestro launchpad para empezar a programar. Elementos básicos Para la realización de este taller se necesita: ◾ Launchpad MSP430 con el chip M430G2553 ◾ Cable USB ◾ Software Code Composer Studio (CCS). Descargar (>

1Gb, requiere registro)

(http://processors.wiki.ti.com/index.php/Download_CCS) ◾ Placa de testeo (Entregada por ICARO).

Archivos Importantes ◾ Descargar Userguide. Guía de usuario muy detallada que incluye todo lo que se puede hacer

con el MSP430 y qué registros modificar para lograr lo que se quiere. ◾ Descargar msp430g2553.h. Archivo de definiciones en lenguaje C para el chip msp430g2553. Incluye nombres para todos los registros y tipos de comportamiento, para hacer más llevadera la programación.

Manipulando los registros del microcontrolador Antes de empezar es necesario repasar algunos conceptos sobre lógica binaria, esto porque la base de los microcontroladores es totalmente digital, donde las cantidades y direcciones de memoria son representadas con números binarios. Lógica Binaria En la lógica binaria existen solo dos valores, 1 y 0. Estos valores son representados por un voltaje, generalmente Vcc para el 1 y tierra para el 0. A un número binario de una cifra se le llama bit, mientras que a un número binario de 8 bits (8 cifras) se le llama byte.

Decimal 0 1 2 3 4 5 6 7 8 Binario 0000 0001 0010 0011 0100 0101 0110 0111 1000

A si mismo es posible operar con las cifras binarias: NOT (~)

A ~A 0 1 1 0

AND (&) A B A&B 0 0 0 0 1 0 1 0 0 1 1 1

OR (|) A B A | B 0 0 0 0 1 1 1 0 1 1 1 1

OR exclusivo (^) A B A ^ B 0 0 0 0 1 1 1 0 1 1 1 0

Suma (+) A B A + B Carry 0 0 0 0 0 1 1 0 1 0 1 0 1 1 1 1

Notar que en la suma, el resultado es equivalente a hacer (A | B), y el carry es equivalente a hacer (A & B). Todas estas operaciones se pueden hacer sobre números de más bits, aplicando la operación para cada bit por separado.

A 1 0 1 1 0 0 1 0 B 1 1 0 1 1 0 1 1

A & B 1 0 0 1 0 0 1 0 ¿Qué es un registro? Podemos pensar, y sin entrar en detalles de la electrónica de por medio, en un registro como la una unidad mas básica de memoria del microcontrolador. Por lo general un registro es número de 8 bits (1 byte) que guarda información de dos tipos:

1. Registros que guardan información variable con la que podemos operar durante la ejecución de nuestro programa.

2. Registros que guardan información sobre la configuración del microcontrolador y que definen cómo se comporta y qué debe hacer en determinadas circunstancias.

Revisemos el siguiente código C: int8 A; // Definición del registro "A" como un entero de 8 bitsA = 0b10110010; // Asignación en formato binarioA = 0xB2; // Asignación en formato hexadecimalA = 178; // Asignación en formato decimal

En el código se muestran 3 de las formas de definir el contenido de un registro. Un estándar es hacerlo de la forma hexadecimal ya que permite definir completamente 1 byte con solo dos dígitos. Como todos los registros son 1 byte, resulta cómodo utilizar esta notación. Así mismo, podemos operar con los registros de manera muy simple: int8 A = 0xAF; // Definición del registrosint8 B = 0x08;int8 C = 0x00;C = ~A; // C = NOT AC = A & B; // C = A AND BC = A | B; // C = A OR BC = A + B; // C = A SUM BC = A ^ B; // C = A XOR BC &= B; // Equivalente a C = C & B;C |= A; // Equivalente a C = C | A;

Es importante destacar que si la suma de dos números de 8 bits resulta en un número mayor a 8 bits, y el registro de destino tiene 8 bits, el resultado será truncado, dejando como resultado los 8 bits menos significativos. Enmascaramiento de Registros Siguiendo con la misma idea, las dos últimas líneas del código anterior representan un "enmascaramiento" del registro C. Ésto porque se le está aplicando una operación sobre sí mismo. Se pueden distinguir dos tipos de enmascaramiento: ◾ Elevación de bits. ◾ Hundimiento de bits.

Elevación de bits Si se tiene dos registros A y B y se desea elevar los bits de B en A, basta con realizar la operación OR entre ellos. A = A | B. Esto significa tomar los bits que son igual a 1 en el registro B y hacerlos igual a 1 en el registro A.

A 1 0 1 1 0 0 1 0 B 1 1 0 1 1 0 1 1

A = A | B 1 1 1 1 1 0 1 1

Hundimiento de bits Si se tiene dos registros A y B y se desea hundir los bits de B en A, es necesario negar el registro B y luego aplicar un AND con el registro A, es decir, A = A & ~B. Esto significa tomar los bits que son igual a 1 en el registro B y hacerlos igual a 0 en el registro A.

A 1 0 1 1 0 0 1 0 ~B 0 0 1 0 0 1 0 0

A = A & ~B 0 0 1 0 0 0 0 0 Finalmente es útil ver como se realiza el enmascaramiento de registros en lenguaje C: int8 A = 0b00010010; // Definición de registrosint8 B = 0b00010001;A |= B; // Elevamos los bits de B en A. Resultado = 0b00010011A &= ~B; // Hundimos los bits de B en A. Resultado = 0b00000010

Ejemplo: Manipulando el registro Watchdog TimerEl MSP430 y muchos otros microcontroladores incorporan un contador de seguridad llamado Watchdog timer. Su principal función es la de evitar que el chip se bloquee por haber entrado en un loop infinito por un error de programación. Este contador está permanentemente contando y si supera cierto umbral, hace que todo el microprocesador se reinicie, ejecutando el programa desde el inicio. Por ahora, deshabilitaremos este contador para evitar que nuestros programas se reinicien. Detengámonos en el siguiente código: #include <msp430.h> // Incluimos el archivo de definiciones para el MSP430void main(void) { WDTCTL = WDTPW + WDTHOLD; // Paramos el watchdog

while(1){ } // Ciclo infinito}

El código muestra la estructura básica de los programas que escribiremos. La primera línea incluye el archivo de definiciones que nos ayudará en la programación. Luego se define el método main(), que representa la puerta de entrada a nuestro programa. El método main() se ejecuta secuencialmente línea por línea hasta que termina. En este tipo de programas es típico ver la aparición de un whileinfinito, que se ejecuta cíclicamente mientras el microcontrolador esté encendido. Antes del while infinito suelen encontrarse definiciones para los distintos registros del microcontrolador, y que definen su comportamiento. En el código sólo se ve una línea que deshabilita el whatchdog timer modificando el registro WDTCTL. Notar que para definir el registro se utilizan otros dos registros que no hemos definido anteriormente (WDTPW y WDTHOLD). Esto es posible ya que todos estos nombres están previamente definidos en el archivo msp430.h.

Finalmente, es importante mencionar que los nombres de los registros no son al azar y coinciden con los nombres que se manejan en el userguide. Para ver las posibilidades de configuración del registro WDTCTL, revisar la página 355 del userguide.

GPIO (General-purpose input/output) La via de comunicación más básica entre un microcontrolador y el mundo exterior son las entradas y salidas digitales. La utilización de lógica digital permite almacenar información de forma eléctrica sin ambigüedad en su lectura, además de permitir una manipulación más simple que en el caso analógico. Por salida o entrada digital se entiende que cada pin acepta solamente dos estados de voltaje: High = 1 (Vcc) y Low = 0 (Tierra). Registros importantes Para manipular cada pin GPIO se deben configurar los siguientes registros. PxSEL, PxSEL2 La combinación entre PxSEL y PxSEL2 determinará la función de cada pin, permitiendo optar entre I/O, función del periférico primario, etc. Prácticamente en todas las aplicaciones utilizaremos I/O. Los registros PxSEL y PxSEL2 son del tipo escritura y por defecto el valor de ambos es 0. PxDIRCorresponde a un registro de escritura en el cual se determina si cada pin seleccionado anteriormente como I/O es de entrada (I) o salida (O). Su valor por defecto es 0. ◾ Bit = 0: Pin de entrada. ◾ Bit = 1: Pin de salida.

PxOUTCorresponde al valor que escribiremos en los pines seleccionados como Output. ◾ Bit = 0: Output low. ◾ Bit = 1: Output high.

PxINCorresponde a un registro solo de lectura el cual almacena el valor de los pines de entrada. ◾ Bit = 0: Input low. ◾ Bit = 1: Input high.

PxRENRegistro solo de escritura que permite habilitar las resistencias de Pullup/Pulldown en los pines que fueron puestos como entrada. ◾ Bit = 0: Resistencias de Pullup/Pulldown desabilitadas. ◾ Bit = 1: Resistencias de Pullup/Pulldown habilitadas.

Para determinar si la resistencia puesta en la entrada corresponde a Pullup o Pulldown debemos utilizar el registro PxOUT. ◾ Bit = 0: Resistencia de Pulldown. ◾ Bit = 1: Resistencia de Pullup.

Ejemplo 1: Encendido de LEDs A continuación presentaremos un código que se encarga de prender y apagar un LED y le iremos haciendo modificaciones para explorar distintos aspectos de la programación de microcontroladores y GPIO. Ejemplo 1.1En este ejemplo buscamos implementar un código que haga parpadear un LED. Esto se logra cambiando el valor de una salida de 1 a 0 y viceversa, a una frecuencia que sea apreciable. (Recuerda que si el cambio es muy rápido no podrás verlo). /* Código que prende un LED espera un tiempo, luego apaga el LED. En este caso usaremos el LED de la tarjeta que se encuentra en el pin 0 del puerto 1 (P1.0) */#include <msp430.h> //inclusiones.#include <inttypes.h>void main(){ //funcion principal

WDTCTL= WDTPW+WDTHOLD; //Apagamos el watchdogP1SEL= 0x00;P1DIR|= BIT0; //Salida el bit 0 del puerto 1P1OUT|=BIT0; //LED parte apagado

while(1){ //Loop infinitoP1OUT|=BIT0; //prende el LED__delay_cycles(100000); //esperaP1OUT&=~BIT0; //apaga el LED__delay_cycles(100000); //espera

}}

Observación: la función __delay_cycles( ); se encarga de realizar ciclos muertos de procesamiento, en el fondo espera sin hacer nada una cantidad de ciclos que nosotros le damos como argumento.

Ejemplo 1.2Este ejemplo es análogo al anterior. Se utilizaran ambos LEDs disponibles en la placa. /* Código que hace parpadear ambos LEDs disponibles en la placa de forma sincronizada. Los LEDs de la placa están en los pines 0 y 6 del puerto 1 */#include <msp430.h> //Inlcusiones#include <inttypes.h>void main(){ //Función principal

WDTCTL= WDTPW+WDTHOLD;P1SEL= 0x00;P1DIR|= (BIT0+BIT6); //Pines 0 y 6 como salidaP1OUT|=BIT0; //Uno parte apagado y el otro prendidoP1OUT&=~BIT6;

while(1){__delay_cycles(100000);P1OUT^=BIT6;P1OUT^=BIT0;

}}

En esta oportunidad hemos utilizado la función XOR la cual se encarga de levantar los bit que estaba en 0 y bajar los que estaban en 1. De este modo el parpadeo solo necesita una sola linea. Ejemplo 1.3Ahora agregaremos la posibilidad de cambiar la frecuencia de parpadeo de los LED por medio de un botón como entrada. La idea es que cada vez que se presione el botón el LED parpadee más rápido, luego vuelve a la frecuencia original. /* Los LED se encuentran en los pines 0 y 6 del puerto 1 El botón se encuentra en el pin 3 del puerto 1 */#include <msp430.h> //Inculsiones#include <inttypes.h>int i=0; //Declaración de variables.int T=30000;void main(){

WDTCTL= WDTPW+WDTHOLD;P1SEL= 0x00;P1DIR|= (BIT0+BIT6); //SalidasP1DIR&=~BIT3; //EntradasP1REN|=BIT3; //Pull-down para la entradaP1OUT|=BIT0;P1OUT&=~BIT6;

while(1){for(i=0;i<T;i++); //primer for

if((P1IN&BIT3)==0){ // primer ifT=T-1500;}

P1OUT^=BIT6; //toggle para las salidasP1OUT^=BIT0;if(T<=1500){T=30000;} //segundo if

}}

Al principio se realizan las mismas declaraciones de siempre. Al momento de definir las salidas hemos agregado las lineas correspondiente a las entradas. Dentro del while, usamos el primer forpara esperar T ciclos vacíos. Luego entramos al primer if, en éste preguntamos si la entrada es igual a 0. De ser así, entonces el tiempo de espera T se disminuye. Luego hacemos parpadear los LEDs. El segundo if se preocupa de revisar las condiciones de borde para que T siempre sea un número valido. Ejemplo 1.4Ahora implementaremos el mismo código anterior con la diferencia principal de que utilizaremos interrupciones. En general éstas son útiles ya que nos permiten ahorrarnos lineas de código y implementar soluciones más eficientes. El programa se efectuara de forma normal hasta que ocurra un evento especifico (por ejemplo que se presione un botón). En ese caso el programa interrumpe su ejecución y se salta hasta la rutina de interrupción. Una vez terminada esta vuelve a ejecutarse de forma normal.

#include <msp430.h>#include <inttypes.h>int i=0;int T=30000;void main(){

WDTCTL= WDTPW+WDTHOLD;P1SEL= 0x00;P1DIR|= (BIT0+BIT6);P1DIR&=~BIT3;P1REN|=BIT3;P1IE|=BIT3; //Habilitamos las interrupciones, mas información en el userguide.P1IES|=BIT3;P1IFG&=~BIT3;P1OUT|=BIT0;P1OUT&=~BIT6;_BIS_SR(GIE); //Habilitamos las interrupciones generales. IMPORTANTE!!

while(1){ //El mismo código anteriorfor(i=0;i<T;i++);P1OUT^=BIT6;P1OUT^=BIT0;if(T<=1500){T=30000;}

}}

//Rutina de interrupción.#pragma vector= PORT1_VECTOR __interrupt void Led_ISR (void){

T=T-2000;}

Como podemos ver cuando se presione el botón el programa se interrumpirá y se salta hasta la rutina de interrupción. En ella se acorta el periodo de espera y luego se regresa al código original. Como podemos ver con esta solución no es necesario revisar en cada iteración si es que esta apretado o no el botón, el periodo T se acortara solo cuando sea necesario. Ejemplo 1.5 Finalmente en el siguiente código se muestra como realizar definiciones a conveniencia tanto de variables como de funciones. El programa es igual al ejemplo 1.4 en cuanto a funcionalidad se refiere. #include <msp430.h>#include <inttypes.h>#define led1 BIT0#define led2 BIT6void led_toggle(uint8_t led);void led_init();int i=0;int T=30000;void main(){

WDTCTL= WDTPW+WDTHOLD;led_init();_BIS_SR(GIE); //PAGINA 49 USER GUIDE.

while(1){for(i=0; i<T;i++);led_toggle(led1+led2);if(T<=1500){T=30000;}

}}

void led_toggle(uint8_t led){P1OUT^=led;

}void led_init(){

P1SEL= 0x00;P1DIR|= (BIT0+BIT6);P1DIR&=~ BIT3;P1REN|= BIT3;P1IE|=BIT3;P1IES|=BIT3;P1IFG&=~BIT3;P1OUT|=BIT0;P1OUT&=~BIT6;

}

#pragma vector= PORT1_VECTOR__interrupt void Led_ISR (void){

P1IFG&=~BIT3;T=T-2000;

}

ADC Ejemplo 1: Uso básico del ADC #include <msp430.h>void main(void) { WDTCTL = WDTPW + WDTHOLD; // Se detiene el watchdog

// ADC ADC10CTL0 = SREF_0 + ADC10SHT_2 + ADC10ON; // Vcc reference, 16 clocks, on ADC10CTL1 = INCH_5 + SHS_0 + ADC10DIV_0 + ADC10SSEL_0 + CONSEQ_0; // input channel 5, trigger on ADC10SC bit, no clock division, internal ADC clock, single channel single conversion ADC10AE0 = BIT5; // Entrada del ADC en P1.5 ADC10CTL0 |= ENC; // Se enciende

// LEDs P1SEL = 0; P1DIR |= BIT0 + BIT6; // set P1.0 and P1.6 as output (1) pins P1OUT &= ~BIT0; // Apaga led rojo P1OUT &= ~BIT6; // Apaga led verde

while(1){ __delay_cycles(100000); // Esperamos un poco ADC10CTL0 |= ADC10SC; // Empieza conversión del ADC

while( ADC10CTL1 & ADC10BUSY ); // Espero a que la conversión esté lista/*

* ADC10MEM guarda el valor de la conversión digital. * Es un registro de 10 bits, por lo que su valor máximo es 2^10 = 1024 * */

if( ADC10MEM > 512 ){ // Si el valor digital convertido supera la mitad de la escala, encender los leds. P1OUT |= BIT0; P1OUT |= BIT6;

} else { P1OUT &=~ BIT0; P1OUT &=~ BIT6;

}}

}

Comunicación UART Ejemplo 1: Enviando un caracter #include <msp430.h>void main(void) { WDTCTL = WDTPW + WDTHOLD; // Se detiene el watchdog

// Configuro el clock a 16MHz BCSCTL1 = CALBC1_16MHZ; DCOCTL = CALDCO_16MHZ; BCSCTL2 &=~ SELS;

// Configuración UART P1SEL |= (BIT1 + BIT2); // P1.1 = RXD, P1.2=TXD (Configuran Los Puertos)

P1SEL2 |= (BIT1 + BIT2); // P1.1 = RXD, P1.2=TXD UCA0CTL1 |= UCSSEL_2; // SMCLK UCA0CTL1 |= UCSWRST; // Resetea el modulo

/* * Los siguientes registros configuran la velocidad de transmisión: 9600 baud con 16.000.000 HZ * Las configuraciones posibles están listadas en el userguide, página 435. * * */ UCA0BR0 = 1666; UCA0BR1 = 1666>>8; UCA0MCTL = 6<<1; UCA0CTL1 &= ~UCSWRST; // **Initialize USCI state machine**

while (1){ __delay_cycles(100000);

while (!(IFG2&UCA0TXIFG)); // USCI_A0 TX buffer ready? UCA0TXBUF = 'N'; // Envío caracter 'N' permanentemente

}}

Ejemplo 2: Enviando strings (Arreglo de caracteres) #include <msp430.h>char palabra[8] = "HOLA\n"; // EL caracter "\n" indica un salto de línea en Windows, útil para mejorar la lectura de los datos.void UART_TXchar2(); // Declaro la función para poder usarla, la definición se encuentra al final del código.void main(void) { WDTCTL = WDTPW + WDTHOLD; // Se detiene el watchdog

// Configuro el clock a 16MHz BCSCTL1 = CALBC1_16MHZ; DCOCTL = CALDCO_16MHZ; BCSCTL2 &=~ SELS;

// Configuración UART P1SEL |= (BIT1 + BIT2); // P1.1 = RXD, P1.2=TXD (Configuran Los Puertos) P1SEL2 |= (BIT1 + BIT2); // P1.1 = RXD, P1.2=TXD UCA0CTL1 |= UCSSEL_2; // SMCLK UCA0CTL1 |= UCSWRST; // Resetea el modulo

// Configuración del Baudrate UCA0BR0 = 1666; UCA0BR1 = 1666>>8; UCA0MCTL = 6<<1; UCA0CTL1 &= ~UCSWRST; // **Initialize USCI state machine**

while (1){ __delay_cycles(100000); UART_TXchar2(palabra); // Envío "HOLA\n" permanentemente

}}// Para enviar strings (arreglo de char), es necesario enviar cada char individualmentevoid UART_TXchar2( unsigned char *c ){

int i = 0;for(i;i<20; i++){

if(c[i] == 0){break;

}else{while (!(IFG2&UCA0TXIFG)); // USCI_A0 TX buffer ready?

UCA0TXBUF = c[i]; // Envío el caracter "i" del arreglo de chars}

}}

Ejemplo final: Juego Snake Como experiencia final se preparó un juego simple basado en en clásico "Snake" para unir las funcionalidades GPIO, ADC y comunicación UART. El código que se provee instruye al microcontrolador para recibir interrupciones desde 4 pines (P1.3, P1.4, P1.6 y P1.7) para poder manejar a la culebra hacia arriba, abajo, izquierda o derecha. Al mismo tiempo está leyendo permanentemente una entrada analógica por el puerto P1.5 que maneja la velocidad del juego. Finalmente, el microcontrolador está permanentemente enviando señales mediante UART al PC en un formato entendible por el juego. Pin Funcionalidad Comentario P1.3 UP Entrada digital P1.4 DOWN Entrada digital P1.5 Velocidad Entrada analógica (por ejemplo, un potenciómetro) P1.6 LEFT Entrada digital. Es necesario desconectar el jumper del led para poder

ocuparlo como entrada digital. P1.7 RIGHT Entrada digital

Las palabras enviadas por el microcontrolador tienen el siguiente formato: "LEFT-VEL34A"

◾ La primera parte de la palabra contiene la dirección a la que se quiere dirigir la culebra. ◾ La segunda parte contiene un número en formato hexadecimal que indica la velocidad del juego.

El programa analiza este string y realiza los cambios necesarios según la instrucción recibida. El código fuente del juego se puede descargar desde [Aquí. (http://codesmesh.com/snake-game-in-c/) ] El software fue modificado para poder recibir las instrucciones del microcontrolador. Obtenido de «http://web.ing.puc.cl/~ieee/wiki/index.php?title=Taller_de_Microcontroladores:_MSP430&oldid=103»

◾ Esta página fue modificada por última vez el 1 ene 2014, a las 23:48.◾ Esta página ha sido visitada 17 045 veces.