Practica #6

Julio Alberto Hernandez San Juan

19100128
Practica: UART
Sistemas embebidos
Maestra: Oralia Soledad Godinez Vega
Objetivos:
• Configuración de Comunicación UART:
• Configurar la comunicación UART en la tarjeta KL25z, estableciendo la velocidad de
transmisión adecuada y asegurando una conexión estable.
• Control del LED RGB mediante Comandos UART:
• Implementar un programa que permita el control del LED RGB en la tarjeta KL25z
mediante comandos enviados a través de UART, asegurándote de que sea posible
encender el LED con todos los colores posibles.

Resumen
Tarjeta kl25z
La tarjeta KL25z es una plataforma de desarrollo basada en un microcontrolador de la
familia Kinetis de NXP Semiconductors. Aquí hay un resumen de sus características
principales:
Microcontrolador:
La tarjeta KL25z está equipada con un microcontrolador Kinetis KL25Z128VLK4 de 32 bits.
Arquitectura ARM Cortex-M0+:
El microcontrolador utiliza la arquitectura ARM Cortex-M0+, que proporciona un
rendimiento eficiente y de bajo consumo de energía.
Memoria:
Dispone de memoria flash integrada para el almacenamiento del programa y memoria
RAM para el almacenamiento temporal de datos.
Periféricos Integrados:
Incluye una variedad de periféricos integrados, como UART (Universal Asynchronous
Receiver-Transmitter), GPIO (General Purpose Input/Output), temporizadores, entre otros.
Interfaz de Depuración y Programación:
Cuenta con una interfaz de depuración y programación, como la sonda OpenSDA, que
facilita el desarrollo y la depuración del firmware.
Conectividad:
Proporciona opciones de conectividad, como USB y puertos GPIO, que permiten la
comunicación con otros dispositivos y la expansión de funcionalidades.
LED RGB Integrado:
La tarjeta KL25z a menudo incluye un LED RGB integrado que puede ser controlado para
mostrar una amplia variedad de colores.
Placa de Expansión:
Algunos modelos pueden tener pines adicionales y una placa de expansión compatible con
Arduino, lo que facilita la conexión de sensores y otros periféricos.
Entorno de Desarrollo:
Se utiliza comúnmente con entornos de desarrollo como Keil u otros basados en Eclipse, y
el software de desarrollo se puede cargar a través de la interfaz de depuración y
programación integrada.
Aplicaciones:
La tarjeta KL25z es adecuada para el desarrollo de proyectos embebidos y aplicaciones que
requieren un microcontrolador de bajo costo y bajo consumo de energía, como sistemas
de control, dispositivos IoT y proyectos educativos.

UART
La UART (Universal Asynchronous Receiver-Transmitter) es un estándar de comunicación
serial que facilita la transmisión de datos entre dispositivos de manera asíncrona. Sus
componentes básicos incluyen un transmisor (TX) para enviar datos y un receptor (RX)
para recibirlos. La comunicación es full-dúplex, permitiendo la transmisión simultánea en
ambas direcciones.

La asincronía se logra mediante bits de inicio y parada, en lugar de depender de un reloj

compartido. La velocidad de transmisión se define mediante la tasa de baudios (baud
rate), que especifica la cantidad de bits transmitidos por segundo. El protocolo implica
paquetes de bytes con bits de inicio, bits de datos (generalmente 8), bits opcionales de
paridad y bits de parada.

La UART se utiliza ampliamente en aplicaciones como la comunicación entre

microcontroladores, entre microcontroladores y sensores, y en la configuración de
sistemas embebidos. Es una interfaz simple pero versátil, utilizada para la transmisión
eficiente de datos en entornos donde la sincronización puede ser un desafío.
Desarrollo Teórico
Proponer el objetivo. El ejercicio consiste en mandar un mensaje a la terminal, que diga
cual su nombre y número de registro, seguido de un mensaje similar al siguiente:
Captura un número:
Posteriormente, dentro de un ciclo infinito, pedirá que capturen un número, en caso de
que el número sea:
1: el led rojo prende,
2: el led azul prende,
3: el led verde prende,
4: prende el led rojo y azul,
5: prende el led rojo y verde,
6: prende el led azul y verde
7: prende el led azul, rojo y verde
8: se apagan todos los leds

Algoritmo
Mientras (True):
- Recibir comando UART
- Según el comando recibido:
- Caso '1': Encender LED rojo
- Caso '2': Encender LED azul
- Caso '3': Encender LED verde
- Caso '4': Encender LED morado (rojo + azul)
- Caso '5': Encender LED amarillo (rojo + verde)
- Caso '6': Encender LED azul claro (verde + azul)
- Caso '7': Encender LED blanco (rojo + verde + azul)
- Caso '8': Apagar todos los LEDs
Función uart_y_kl25_config():
- Configurar UART y pines para LEDs
Función leds_off():
- Apagar todos los LEDs
Diagrama de flujo
Desarrollo Practico
Para realizar el desarrollo practico se hizo uso del programa y compilador MCUXpresso en
el cual realizamos un código que lo que va a realizar mediante UART es prender el led RGB
de la tarjeta KL25Z el cual con diferentes números (del 1 al 8) iba a encender los diferentes
colores que se pueden hacer con las combinaciones de color del RGB hasta llegar al
numero 8 el cual iba a apagar por completo el led RGB de la tarjeta
Material

• SOFTWARE: MCUXPRESSO
• Consola: Tera Term
• Computadora
• Tarjeta KL25Z
Código de programa
Ejecución del programa
Foto del código funcionando
Conclusiones:
Concluyendo esta práctica de sistemas embebidos en la que trabajamos con UART y
controlamos LEDs en una tarjeta KL25z, puedo destacar algunas observaciones y
aprendizajes importantes.

En primer lugar, a través del código que desarrollamos, comprendí cómo establecer una
comunicación serial eficiente entre la tarjeta y la terminal, permitiéndonos enviar y recibir
información de manera sencilla. La configuración inicial de la UART y la transmisión de
mensajes iniciales, como mi nombre y número de registro, demostraron ser pasos
fundamentales para la interacción básica entre el sistema embebido y el usuario.

La implementación del ciclo infinito, en el que solicitamos al usuario que capture un

número, abrió la puerta a un control dinámico de los LEDs. Este enfoque basado en casos
(switch-case) nos proporcionó una manera clara y efectiva de interpretar los comandos
ingresados. Al capturar números específicos, logramos activar combinaciones de LEDs,
creando distintos colores y efectos visuales. En resumen, la práctica me brindó una valiosa
experiencia en el manejo de la comunicación serial y la interacción con periféricos en un
entorno embebido. Aprendí a traducir comandos simples en acciones concretas, como
encender y apagar LEDs, lo cual es esencial para el desarrollo de sistemas más complejos.
Además, la repetición del ciclo infinito y la respuesta en tiempo real del sistema me dieron
una comprensión más profunda de cómo los sistemas embebidos pueden interactuar de
manera efectiva con su entorno.
Anexos
#include <stdio.h>
#include "board.h"
#include "peripherals.h"
#include "pin_mux.h"
#include "clock_config.h"
#include "MKL25Z4.h"
#include "fsl_debug_console.h"

// FUNCIONES
void uart_y_kl25_config();
void leds_off();
int uart0_switch_case();

// VARIABLES
char numero = ' ';

// FUNCION PRINCIPAL
int main(void)
{
uart_y_kl25_config();
uart0_switch_case();
}

// DESARROLLO DE FUNCIONES
void uart_y_kl25_config()
{
/* Init board hardware. */
BOARD_InitBootPins();
BOARD_InitBootClocks();
BOARD_InitBootPeripherals();
#ifndef BOARD_INIT_DEBUG_CONSOLE_PERIPHERAL
/* Init FSL debug console. */
BOARD_InitDebugConsole();
#endif

PRINTF("Hello World \r\n");

/* PUERTO B Y PUERTO D PARA LEDS */

SIM->SCGC5 |= SIM_SCGC5_PORTB_MASK | SIM_SCGC5_PORTD_MASK;

PORTB->PCR[18] |= (1<<8);
GPIOB->PDDR |= (1<<18);
GPIOB->PDOR |= (1<<18);

PORTB->PCR[19] |= (1<<8);
GPIOB->PDDR |= (1<<19);
GPIOB->PDOR |= (1<<19);

PORTD->PCR[1] |= (1<<8);
GPIOD->PDDR |= (1<<1);
GPIOD->PDOR |= (1<<1);

/* INICIALIZACION DEL UART0 UTILIZADO A 115200 DE BAUDRATE */

 SIM -> SCGC4 |= SIM_SCGC4_UART0_MASK;
SIM -> SOPT2 |= 1<<26;
UART0 -> C2 = 0;
UART0 -> BDH = 0x00;
UART0 -> BDL = 0x1A;
UART0 -> C4 = 0x0F;
UART0 -> C1 = 0x00;
UART0 -> C2 = 0x0C;
}

int uart0_switch_case() //switch case para poder hacer seleccion de cada

color de led con un numero
{
while(1)
{
UART0 -> D = numero;
numero = UART0 -> D;
switch (numero)
{
case '1': // En este case el led rojo enciende
leds_off();
GPIOB->PDOR &= ~(1<<18); //Led rojo enciende
break;
case '2': //En este case el led azul enciende
leds_off();
GPIOD->PDOR &= ~(1<<1); //Led azul enciende
break;
case '3': //En este case el led verde enciende
leds_off();
GPIOB->PDOR &= ~(1<<19); //Led verde enciende
break;
case '4': //En este case se crea el color morado con el
encendido de dos colores el rojo y el azul
leds_off();
GPIOB->PDOR &= ~(1<<18); //led rojo enciende
GPIOD->PDOR &= ~(1<<1); //led azul enciende
break;
case '5': //En este case se crea el color amarillo con
el encendido de dos colores el rojo y el verde
leds_off();
GPIOB->PDOR &= ~(1<<18); // led rojo enciende
GPIOB->PDOR &= ~(1<<19); //led verde enciende
break;
case '6': //En este case se crea el color azul mas
claro con el encendido de dos colores el verde y el azul
leds_off();
GPIOB->PDOR &= ~(1<<19); //led verde enciende
GPIOD->PDOR &= ~(1<<1); //led azul enciende
break;
case '7': //En este case se crea el color blanco con el
encendido de tres colores el rojo, el verde y el azul
leds_off();
GPIOB->PDOR &= ~(1<<19); // led verde enciende
GPIOB->PDOR &= ~(1<<18); // led rojo enciende
GPIOD->PDOR &= ~(1<<1); // led azul enciende
break;
 case '8': //Se LLAMA a la funcion que apaga a a todos
los leds
leds_off(); // se llama funcion que apaga los leds
break;
}
}
return 0;
}

void leds_off()//Funcion para poder apagar los leds

{
GPIOB->PDOR |= (1<<18); //Se apaga led rojo
GPIOB->PDOR |= (1<<19); //se apaga led verde
GPIOD->PDOR |= (1<<1); //Se apaga led azul
}