PONTIFICIA UNIVERSIDAD CATÓLICA DEL PERÚ

FACULTAD DE CIENCIAS E INGENIERÍA

SISTEMAS DIGITALES
IEE256 H0522

COMUNICACIÓN ASÍNCRONA
Programas desarrollados en clase.
Los diagramas esquemáticos, diagramas de flujo y características de las funciones son los vistos en clase.

Programa 01

/***************************************************************************/
/***************************************************************************/
/***** PONTIFICIA UNIVERSIDAD CATÓLICA DEL PERÚ *****/
/***** FACULTAD DE CIENCIAS E INGENIERÍA *****/
/***** SISTEMAS DIGITALES *****/
/***** Semestre 2016 I *****/
/***************************************************************************/
/***** Tema: Comunicación Serial UART *****/
/***** Proyecto: Prog01_UART_ECO *****/
/***************************************************************************/
/***** Microcontrolador: TM4C123GH6PM *****/
/***** EvalBoard: Tiva C Series TM4C123G LaunchPad *****/
/***** Autor: Rolando Sánchez Ponce *****/
/***** Fecha: Mayo 2016 *****/
/***************************************************************************/
/***** Estado: PROBADO EN MÓDULO *****/
/***************************************************************************/
/***** Enunciado: *****/
/***** Se utiliza el UART0 para realizar ECO: dato recibido por el *****/
/***** puerto serial lo transmite por el mismo puerto. *****/
/***************************************************************************/
/***************************************************************************/

#include <stdint.h>
#include "tm4c123gh6pm.h"

void ConfiguraUART0(void){
// Habilitamos reloj para el UART0
SYSCTL_RCGCUART_R |= SYSCTL_RCGCUART_R0;
while(!(SYSCTL_PRUART_R & SYSCTL_PRUART_R0));
// Inhabilitamos el UART0
UART0_CTL_R &= ~UART_CTL_UARTEN;
// Velocidad 9600bps (Fsysclk = 16MHz)
UART0_IBRD_R = (UART0_IBRD_R & 0xFFFF0000) | 104;
UART0_FBRD_R = (UART0_FBRD_R & 0xFFFFFFC0) | 11;
// 8, N, 1, FIFOs habilitados
UART0_LCRH_R = (UART0_LCRH_R & 0xFFFFFF00) | 0x70;
// Habilitamos el UART0, recepción y transmisión
UART0_CTL_R |= (UART_CTL_RXE | UART_CTL_TXE | UART_CTL_UARTEN);

// Habilitamos reloj para GPIOA

SYSCTL_RCGCGPIO_R |= SYSCTL_RCGCGPIO_R0;
while(!(SYSCTL_PRGPIO_R & SYSCTL_PRGPIO_R0));
// Desactivamos modo analógico en PA0 y PA1
GPIO_PORTA_AMSEL_R &= ~(0x03);
// Conectamos UART0 a PA0 y PA1
 GPIO_PORTA_PCTL_R = (GPIO_PORTA_PCTL_R&0xFFFFFF00)|0x00000011;
// Activamos funciones alternas en PA0 y PA1
GPIO_PORTA_AFSEL_R |= 0x03;
// Activamos funciones digitales en PA0 y PA1
GPIO_PORTA_DEN_R |= 0x03;
}

int main(void){
uint8_t datoRx;
ConfiguraUART0();
while(1){
// Esperamos mientras Buffer Rx esté vacío
while(UART0_FR_R & UART_FR_RXFE);
// Leemos dato recibido
datoRx = UART0_DR_R;
// Esperamos mientras Buffer Tx esté lleno
while(UART0_FR_R & UART_FR_TXFF);
// Escribimos el dato para su transmisión
UART0_DR_R = datoRx;
}
}

/***************************************************************************/
/***** F I N D E L P R O G R A M A *****/
/***************************************************************************/
Programa 02
/***************************************************************************/
/***************************************************************************/
/***** PONTIFICIA UNIVERSIDAD CATÓLICA DEL PERÚ *****/
/***** FACULTAD DE CIENCIAS E INGENIERÍA *****/
/***** SISTEMAS DIGITALES *****/
/***** Semestre 2016 I *****/
/***************************************************************************/
/***** Tema: Comunicación Serial UART *****/
/***** Proyecto: Prog02_UART_EcoCadMay *****/
/***************************************************************************/
/***** Microcontrolador: TM4C123GH6PM *****/
/***** EvalBoard: Tiva C Series TM4C123G LaunchPad *****/
/***** Autor: Rolando Sánchez Ponce *****/
/***** Fecha: Mayo 2016 *****/
/***************************************************************************/
/***** Estado: PROBADO EN MÓDULO *****/
/***************************************************************************/
/***** Enunciado: *****/
/***** Mediante el UART0 se espera la recepción de una cadena de carac-*****/
/***** teres ASCII, una vez recibida se retransmite toda la cadena en *****/
/***** mayúsculas. *****/
/***************************************************************************/
/***************************************************************************/

#include <stdint.h>
#include "tm4c123gh6pm.h"
#define LF 10 // Nueva línea
#define FF 12 // Nueva página
#define CR 13 // Retorno de carro

void ConfiguraUART0(void){
// UART0 a 9600, 8, N, 1 y FIFOs habilitados
// UART0 conectado a PA0 y PA1
SYSCTL_RCGCUART_R |= SYSCTL_RCGCUART_R0;
while(!(SYSCTL_PRUART_R & SYSCTL_PRUART_R0));
UART0_CTL_R &= ~UART_CTL_UARTEN;
UART0_IBRD_R = (UART0_IBRD_R & 0xFFFF0000) | 104;
UART0_FBRD_R = (UART0_FBRD_R & 0xFFFFFFC0) | 11;
UART0_LCRH_R = (UART0_LCRH_R & 0xFFFFFF00) | 0x70;
UART0_CTL_R |= (UART_CTL_RXE | UART_CTL_TXE | UART_CTL_UARTEN);

SYSCTL_RCGCGPIO_R |= SYSCTL_RCGCGPIO_R0;
while(!(SYSCTL_PRGPIO_R & SYSCTL_PRGPIO_R0));
GPIO_PORTA_AMSEL_R &= ~(0x03);
GPIO_PORTA_PCTL_R = (GPIO_PORTA_PCTL_R&0xFFFFFF00)|0x00000011;
GPIO_PORTA_AFSEL_R |= 0x03;
GPIO_PORTA_DEN_R |= 0x03;
}

uint8_t EsperaByte(void){
uint8_t datoRx;
while(UART0_FR_R & UART_FR_RXFE);
datoRx = UART0_DR_R;
return datoRx;
}

void TransmiteByte(uint8_t datoTx){

while(UART0_FR_R & UART_FR_TXFF);
UART0_DR_R = datoTx;
}
void RecibeCadena(uint8_t CadenaASCII[]){
uint8_t datoRx=0;
uint16_t i;
for(i=0; datoRx!=CR; i++){
datoRx=EsperaByte();
if (datoRx==CR) CadenaASCII[i]=0;
else {
CadenaASCII[i]=datoRx;
TransmiteByte(datoRx);
}
}
}

void TransmiteCadena(const uint8_t CadenaASCII[]){

uint16_t i;
for(i=0; CadenaASCII[i]; i++)
TransmiteByte(CadenaASCII[i]);
}

void CadMayuscula(uint8_t CadenaASCII[]){

uint16_t i;
for(i=0; CadenaASCII[i]; i++)
if(('a'<=CadenaASCII[i])&&(CadenaASCII[i]<='z'))
CadenaASCII[i]-=0x20;
}

void SiguienteLinea(void){
TransmiteByte(LF);
TransmiteByte(CR);
}

int main(void){
uint8_t MiCadena[25];
ConfiguraUART0();
while(1){
RecibeCadena(MiCadena);
SiguienteLinea();
CadMayuscula(MiCadena);
TransmiteCadena(MiCadena);
SiguienteLinea();
}
}
Programa 03
/***************************************************************************/
/***************************************************************************/
/***** PONTIFICIA UNIVERSIDAD CATÓLICA DEL PERÚ *****/
/***** FACULTAD DE CIENCIAS E INGENIERÍA *****/
/***** SISTEMAS DIGITALES *****/
/***** Semestre 2016 I *****/
/***************************************************************************/
/***** Tema: Comunicación Serial UART *****/
/***** Proyecto: Prog03_UART_SenX *****/
/***************************************************************************/
/***** Microcontrolador: TM4C123GH6PM *****/
/***** EvalBoard: Tiva C Series TM4C123G LaunchPad *****/
/***** Autor: Rolando Sánchez Ponce *****/
/***** Fecha: Mayo 2016 *****/
/***************************************************************************/
/***** Estado: PROBADO EN MÓDULO *****/
/***************************************************************************/
/***** Enunciado: *****/
/***** Se solicita el ingreso de un ángulo entre 0 y 90 grados, luego *****/
/***** se transmite el seno de dicho ángulo. *****/
/***** Se hace uso de la tabla TablaSeno. *****/
/***************************************************************************/
/***************************************************************************/

#include <stdint.h>
#include "tm4c123gh6pm.h"
#define FALSE 0
#define TRUE 1
#define LF 10 // Nueva línea
#define FF 12 // Nueva página
#define CR 13 // Retorno de carro

const uint8_t MSG_SOLICITA[] = "Ingrese angulo X [00, 90]: \0";

const uint8_t MSG_RESULTADO[] = "SenX = \0";
const uint8_t MSG_ERROR[] = "Angulo fuera de rango!!\0";
const uint16_t TablaSeno[] = {0, 1736, 3420, 5000, 6428, 7660, 8680, 9397, 9848, 10000};
void ConfiguraUART0(void){
// UART0: 9600, 8, N, 1
SYSCTL_RCGCUART_R |= SYSCTL_RCGCUART_R0;
while(!(SYSCTL_PRUART_R & SYSCTL_PRUART_R0));
UART0_CTL_R &= ~UART_CTL_UARTEN;
UART0_IBRD_R = (UART0_IBRD_R & 0xFFFF0000) | 104;
UART0_FBRD_R = (UART0_FBRD_R & 0xFFFFFFC0) | 11;
UART0_LCRH_R = (UART0_LCRH_R & 0xFFFFFF00) | 0x70;
UART0_CTL_R |= (UART_CTL_RXE | UART_CTL_TXE | UART_CTL_UARTEN);

SYSCTL_RCGCGPIO_R |= SYSCTL_RCGCGPIO_R0;
while(!(SYSCTL_PRGPIO_R & SYSCTL_PRGPIO_R0));
GPIO_PORTA_AMSEL_R &= ~(0x03);
GPIO_PORTA_PCTL_R = (GPIO_PORTA_PCTL_R&0xFFFFFF00)|0x00000011;
GPIO_PORTA_AFSEL_R |= 0x03;
GPIO_PORTA_DEN_R |= 0x03;
}

uint8_t EsperaByte(void){
uint8_t datoRx;
while(UART0_FR_R & UART_FR_RXFE);
datoRx = UART0_DR_R;
return datoRx;
}

void TransmiteByte(uint8_t datoTx){

while(UART0_FR_R & UART_FR_TXFF);
UART0_DR_R = datoTx;
}

void TransmiteCadena(const uint8_t CadenaASCII[]){

uint16_t i;
for(i=0; CadenaASCII[i]; i++)
TransmiteByte(CadenaASCII[i]);
}

void SiguienteLinea(void){
TransmiteByte(LF);
TransmiteByte(CR);
}

int SolicitaNumeroUART(uint8_t NumDig){

uint8_t ArregloDigitos[10];
uint8_t ERROR, digito, i;
uint16_t numero, pot10;

for(i=0; i<NumDig; i++){

do{
ERROR = FALSE;
digito=EsperaByte();
if((digito<'0')||(digito>'9')) ERROR = TRUE;
}while(ERROR);
TransmiteByte(digito);
ArregloDigitos[i]=digito-'0';
}
SiguienteLinea();

numero=0;
pot10=1;
for(i=0; i<NumDig; i++){
numero+=ArregloDigitos[NumDig-1-i]*pot10;
pot10*=10;
}
return numero;
}
void FormaCadNum(uint8_t ArregloNum[], uint16_t numero){
uint16_t div10;
uint16_t i;

div10=10000;
for(i=1; i<=5; i++){
ArregloNum[i]=numero/div10 + '0';
numero %= div10;
div10 /= 10;
}
ArregloNum[i]=0;
ArregloNum[0]=ArregloNum[1];
ArregloNum[1]='.';
}

uint16_t SenAprox(uint8_t x){

uint16_t SenX;
uint8_t xi, xj;
if(x<90){ // x [0, 89]
xi=x/10; // xi [0, 8]
xj=xi+1; // xj [1, 9]
SenX = (x-10*xi)*(TablaSeno[xj]-TablaSeno[xi])/10 + TablaSeno[xi];
}
else if(x==90) SenX = TablaSeno[x/10];
return SenX;
}

int main(void){
uint8_t ArregloNumero[10];
uint8_t ERROR, angulo;
uint16_t senAng;

ConfiguraUART0();
while(1){
do{
ERROR=FALSE;
TransmiteCadena(MSG_SOLICITA);
angulo = SolicitaNumeroUART(2);
if(angulo>90){
TransmiteCadena(MSG_ERROR);
SiguienteLinea();
ERROR = TRUE;
}
}while(ERROR);
senAng = SenAprox(angulo);
FormaCadNum(ArregloNumero, senAng);
TransmiteCadena(MSG_RESULTADO);
TransmiteCadena(ArregloNumero);
SiguienteLinea();
}
}

/***************************************************************************/
/***** F I N D E L P R O G R A M A *****/
/***************************************************************************/
Programa 04
/***************************************************************************/
/***************************************************************************/
/***** PONTIFICIA UNIVERSIDAD CATÓLICA DEL PERÚ *****/
/***** FACULTAD DE CIENCIAS E INGENIERÍA *****/
/***** SISTEMAS DIGITALES *****/
/***** Semestre 2016 I *****/
/***************************************************************************/
/***** Tema: Comunicación Serial UART *****/
/***** Proyecto: Prog04_UART_GPIO_Snd *****/
/***************************************************************************/
/***** Microcontrolador: TM4C123GH6PM *****/
/***** EvalBoard: Tiva C Series TM4C123G LaunchPad *****/
/***** Autor: Rolando Sánchez Ponce *****/
/***** Fecha: Mayo 2016 *****/
/***************************************************************************/
/***** Estado: PROBADO EN MÓDULO *****/
/***************************************************************************/
/***** Enunciado: *****/
/***** Se espera recibir por el puerto serial un caracter numérico (en-*****/
/***** tre '0' y '9') y se transmite una cadena de caracteres con el *****/
/***** nombre del número o una cadena con el número en romanos. *****/
/***** Se cambia el modo de transmisión al presionar el pulsador SW2. *****/
/***** El led rojo se enciende para indicar que se está en modo romano *****/
/***** y el led azul indica que se está en modo nombre. *****/
/***************************************************************************/
/***************************************************************************/

#include <stdint.h>
#include "tm4c123gh6pm.h"

#define TRUE 1
#define FALSE 0
#define SW2 0x00000001 // Conectado a PF0
#define ledROJO 0x00000002 // Conectado a PF1
#define ledAZUL 0x00000004 // Conectado a PF2
#define ledVERDE 0x00000008 // Conectado a PF3
#define SW1 0x00000010 // Conectado a PF4
#define ROJO ledROJO
#define VERDE ledVERDE
#define AZUL ledAZUL
#define MAGENTA ledROJO|ledAZUL
#define AMARILLO ledROJO|ledVERDE
#define CIAN ledAZUL|ledVERDE
#define BLANCO ledROJO|ledVERDE|ledAZUL
#define NEGRO 0

#define LF 10 // Nueva línea

#define FF 12 // Nueva página
#define CR 13 // Retorno de carro

const uint8_t TextoNumero[10][8]= {"CERO\0", "UNO\0", "DOS\0", "TRES\0", "CUATRO\0", "CINCO\0",

"SEIS\0", "SIETE\0", "OCHO\0", "NUEVE\0"};

void ConfiguraPuertos(void){
SYSCTL_RCGCGPIO_R |= SYSCTL_RCGCGPIO_R5;
while(!(SYSCTL_PRGPIO_R & SYSCTL_PRGPIO_R5));
GPIO_PORTF_AMSEL_R &= ~(0x1F);
GPIO_PORTF_PCTL_R = (GPIO_PORTF_PCTL_R&0xFFF00000)|0x00000000;
GPIO_PORTF_DIR_R |= 0x0E;
GPIO_PORTF_DIR_R &= ~(0x11);
GPIO_PORTF_LOCK_R = 0x4C4F434B;
GPIO_PORTF_CR_R |= 0x01;
GPIO_PORTF_AFSEL_R &= ~(0x1F);
GPIO_PORTF_PUR_R |= 0x11;
GPIO_PORTF_DR8R_R |= 0x0E;
GPIO_PORTF_DEN_R |= 0x1F;
GPIO_PORTF_DATA_R &= ~(0x0E);
}

void ConfiguraUART0(void){
// UART0 a 9600, 8, N, 1 y FIFOs habilitados
// UART0 conectado a PA0 y PA1
SYSCTL_RCGCUART_R |= SYSCTL_RCGCUART_R0;
while(!(SYSCTL_PRUART_R & SYSCTL_PRUART_R0));
UART0_CTL_R &= ~UART_CTL_UARTEN;
UART0_IBRD_R = (UART0_IBRD_R & 0xFFFF0000) | 104;
UART0_FBRD_R = (UART0_FBRD_R & 0xFFFFFFC0) | 11;
UART0_LCRH_R = (UART0_LCRH_R & 0xFFFFFF00) | 0x70;
UART0_CTL_R |= (UART_CTL_RXE | UART_CTL_TXE | UART_CTL_UARTEN);

SYSCTL_RCGCGPIO_R |= SYSCTL_RCGCGPIO_R0;
while(!(SYSCTL_PRGPIO_R & SYSCTL_PRGPIO_R0));
GPIO_PORTA_AMSEL_R &= ~(0x03);
GPIO_PORTA_PCTL_R = (GPIO_PORTA_PCTL_R&0xFFFFFF00)|0x00000011;
GPIO_PORTA_AFSEL_R |= 0x03;
GPIO_PORTA_DEN_R |= 0x03;
}

void colorLED(uint8_t COLOR){

GPIO_PORTF_DATA_R &= ~(ledROJO|ledVERDE|ledAZUL);
GPIO_PORTF_DATA_R |= COLOR;
}
uint8_t flancoBajada(uint8_t pulsador, uint8_t *antNivel){
uint8_t flancoBajada, nivel;
nivel = GPIO_PORTF_DATA_R & pulsador;
flancoBajada = FALSE;
if((*antNivel)&&(!nivel)) flancoBajada = TRUE;
*antNivel=nivel;
return flancoBajada;
}

uint8_t RecibeByte(uint8_t *datoRx){

uint8_t salida=FALSE;
if(!(UART0_FR_R & UART_FR_RXFE)){
*datoRx = UART0_DR_R;
salida=TRUE;
}
return salida;
}

void TransmiteByte(uint8_t datoTx){

while(UART0_FR_R & UART_FR_TXFF);
UART0_DR_R = datoTx;
}

void SiguienteLinea(void){
TransmiteByte(LF);
TransmiteByte(CR);
}

void TransmiteCadena(const uint8_t CadenaASCII[]){

uint16_t i;
for(i=0; CadenaASCII[i]; i++)
TransmiteByte(CadenaASCII[i]);
}

void aRomanos(uint8_t Arreglo[], uint8_t num){

uint8_t i;
switch(num){
case 0:
case 1:
case 2:
case 3: for(i=0; i<num; i++) Arreglo[i]='I';
Arreglo[i]=0;
break;
case 4: Arreglo[0]='I';
Arreglo[1]='V';
Arreglo[2]=0;
break;
case 5:
case 6:
case 7:
case 8: Arreglo[0]='V';
for(i=1; i<num-4; i++) Arreglo[i]='I';
Arreglo[i]=0;
break;
case 9: Arreglo[0]='I';
Arreglo[1]='X';
Arreglo[2]=0;
}
}
int main(void){
uint8_t NumeroRomano[5];
uint8_t datoRx;
uint8_t antSW2;
uint8_t NumRom;
ConfiguraPuertos();
ConfiguraUART0();
antSW2 = GPIO_PORTF_DATA_R & SW2;
NumRom = TRUE;
colorLED(ROJO);
while(1){
if(flancoBajada(SW2, &antSW2)){
if(NumRom){
NumRom=FALSE;
colorLED(AZUL);
}
else{
NumRom=TRUE;
colorLED(ROJO);
}
}
if(RecibeByte(&datoRx)){
if(('0'<=datoRx)&&(datoRx<='9')){
TransmiteByte(datoRx);
TransmiteByte(':');
datoRx-='0';
if(NumRom){
aRomanos(NumeroRomano, datoRx);
TransmiteCadena(NumeroRomano);
SiguienteLinea();
}
else{
TransmiteCadena(TextoNumero[datoRx]);
SiguienteLinea();
}
}
}
}
}
Programa 05
/***************************************************************************/
/***************************************************************************/
/***** PONTIFICIA UNIVERSIDAD CATÓLICA DEL PERÚ *****/
/***** FACULTAD DE CIENCIAS E INGENIERÍA *****/
/***** SISTEMAS DIGITALES *****/
/***** Semestre 2016 II *****/
/***************************************************************************/
/***** Tema: Comunicación Serial UART *****/
/***** Proyecto: Prog05_UART_Bluetooth *****/
/***************************************************************************/
/***** Microcontrolador: TM4C123GH6PM *****/
/***** EvalBoard: Tiva C Series TM4C123G LaunchPad *****/
/***** Autor: Rolando Sánchez Ponce *****/
/***** Fecha: Octubre 2016 *****/
/***************************************************************************/
/***** Estado: PROBADO EN MÓDULO *****/
/***************************************************************************/
/***** Enunciado: *****/
/***** Controlar mediante un smartphone el encendido del led RGB de la *****/
/***** módulo TIVA. Desde el celular se transmite via Bluetooth la *****/
/***** letra inicial del color que se quiere mostrar (excepto para el *****/
/***** amarillo donde se debe transmitir 'Y'). El microcontrolador *****/
/***** deberá encender el led con el color recibido y enviar un mensaje*****/
/***** de conformidad al smartphone. *****/
/***************************************************************************/
/***************************************************************************/

#include <stdint.h>
#include "tm4c123gh6pm.h"
#define SW2 0x00000001 // Conectado a PF0
#define ledROJO 0x00000002 // Conectado a PF1
#define ledAZUL 0x00000004 // Conectado a PF2
#define ledVERDE 0x00000008 // Conectado a PF3
#define SW1 0x00000010 // Conectado a PF4

#define ROJO ledROJO // 2

#define VERDE ledVERDE // 8
#define AZUL ledAZUL // 4
#define MAGENTA ledROJO|ledAZUL // 6
#define AMARILLO ledROJO|ledVERDE // 10
#define CIAN ledAZUL|ledVERDE // 12
#define BLANCO ledROJO|ledVERDE|ledAZUL // 14
#define NEGRO 0 // 0

#define LF 10 // Nueva línea

#define FF 12 // Nueva página
#define CR 13 // Retorno de carro

const uint8_t MSG_LED[] = "LED RGB color: ";

const uint8_t MSG_ERROR[] = "Entrada no valida\n\r";
const uint8_t TextoColor[8][10]= {"NNEGRO", "RROJO", "AAZUL", "MMAGENTA", "VVERDE",
"YAMARILLO", "CCIAN", "BBLANCO"};

void ConfiguraPuertos(void){
SYSCTL_RCGCGPIO_R |= SYSCTL_RCGCGPIO_R5;
while(!(SYSCTL_PRGPIO_R & SYSCTL_PRGPIO_R5));
GPIO_PORTF_AMSEL_R &= ~(0x1F);
GPIO_PORTF_PCTL_R = (GPIO_PORTF_PCTL_R&0xFFF00000)|0x00000000;
GPIO_PORTF_DIR_R |= 0x0E;
GPIO_PORTF_DIR_R &= ~(0x11);
 GPIO_PORTF_LOCK_R = 0x4C4F434B;
GPIO_PORTF_CR_R |= 0x01;
GPIO_PORTF_AFSEL_R &= ~(0x1F);
GPIO_PORTF_PUR_R |= 0x11;
GPIO_PORTF_DR8R_R |= 0x0E;
GPIO_PORTF_DEN_R |= 0x1F;
GPIO_PORTF_DATA_R &= ~(0x0E);
}

void ConfiguraUART1(void){
// 9600, 8, N, 1
SYSCTL_RCGCUART_R |= SYSCTL_RCGCUART_R1;
while(!(SYSCTL_PRUART_R & SYSCTL_PRUART_R1));
UART1_CTL_R &= ~UART_CTL_UARTEN;
UART1_IBRD_R = (UART1_IBRD_R & 0xFFFF0000) | 104;
UART1_FBRD_R = (UART1_FBRD_R & 0xFFFFFFC0) | 11;
UART1_LCRH_R = (UART1_LCRH_R & 0xFFFFFF00) | 0x70;
UART1_CTL_R |= (UART_CTL_RXE | UART_CTL_TXE | UART_CTL_UARTEN);

SYSCTL_RCGCGPIO_R |= SYSCTL_RCGCGPIO_R1;
while(!(SYSCTL_PRGPIO_R & SYSCTL_PRGPIO_R1));
GPIO_PORTB_AMSEL_R &= ~(0x03);
GPIO_PORTB_PCTL_R = (GPIO_PORTB_PCTL_R&0xFFFFFF00)|0x00000011;
GPIO_PORTB_AFSEL_R |= 0x03;
GPIO_PORTB_DEN_R |= 0x03;
}

void colorLED(uint8_t COLOR){

GPIO_PORTF_DATA_R &= ~(ledROJO|ledVERDE|ledAZUL);
GPIO_PORTF_DATA_R |= COLOR;
}

uint8_t EsperaByte(void){
uint8_t datoRx;
while(UART1_FR_R & UART_FR_RXFE);
datoRx = UART1_DR_R;
return datoRx;
}

void TransmiteByte(uint8_t datoTx){

while(UART1_FR_R & UART_FR_TXFF);
UART1_DR_R = datoTx;
}

void TransmiteCadena(const uint8_t CadenaASCII[]){

uint16_t i;
for(i=0; CadenaASCII[i]; i++)
TransmiteByte(CadenaASCII[i]);
}

void SiguienteLinea(void){
TransmiteByte(LF);
TransmiteByte(CR);
}

uint8_t aMayuscula(uint8_t letraMIN){

if(('a'<=letraMIN)&&(letraMIN<='z'))
letraMIN -= 0x20;
return letraMIN;
}
uint8_t BuscaColor(uint8_t letra){
uint8_t indiceColor = 10;
uint8_t i;
for(i=0; i<8; i++){
if(letra==TextoColor[i][0]){
indiceColor=i;
i=10;
}
}
return indiceColor;
}

int main(void){
uint8_t datoRx, color;
ConfiguraPuertos();
ConfiguraUART1();
while(1){
datoRx = EsperaByte();
datoRx = aMayuscula(datoRx);
color = BuscaColor(datoRx);
if (color<8){
TransmiteCadena(MSG_LED);
TransmiteCadena(&TextoColor[color][1]);
SiguienteLinea();
colorLED(color*2);
}
else TransmiteCadena(MSG_ERROR);
}
}

Rolando Sánchez Ponce

Mayo 2016
Octubre 2016