PRÁCTICA 3: SysTick

PANTALLA
Materia : Sistemas embebidos
Grupo: 8°B3
Profesor: Oralia Soledad Godinez Vega
Fecha de entrega: 09/10/2023
OBJETIVO
Con el desarrollo de esta práctica se pretende que el alumno se familiarice con los registros de los periféricos de
GPIO y SysTick que le permitan controlar las entradas y salidas de un un microcontrolador de 32 bits
implementando una pantalla LCD 16x2 con el fin de aplicarlo posteriormente en diversos proyectos electrónicos.

ALGORITMO
1. Incluye las bibliotecas y archivos de encabezado necesarios.
2. Define las funciones `STick_delay`, `init_PINES`, `init_LCD`, `mensaje1` y `mensaje2`. Estas funciones se utilizarán para inicializar
los pines, controlar el retraso, y mostrar mensajes en la pantalla LCD.
3. En la función `main`:

a. Inicializa la placa y los periféricos.

b. Inicializa los pines utilizando `init_PINES`.

c. Entra en un bucle mientras `z` sea igual a 0.

d. En cada iteración del bucle:

- Inicializa la pantalla LCD utilizando `init_LCD`.

- Muestra el mensaje 1 utilizando `mensaje1`.

- Muestra el mensaje 2 utilizando `mensaje2`.

- Incrementa el valor de `z` en 1.

4. La función `STick_delay` se utiliza para crear un retraso utilizando el temporizador SysTick.

5. La función `init_PINES` configura los pines necesarios en las puertas B y E como salidas.

6. La función `init_LCD` configura y envía comandos iniciales a la pantalla LCD.

7. La función `mensaje1` muestra el mensaje "HOLA MUNDO" en la pantalla LCD.

8. La función `mensaje2` muestra el mensaje "19100128" en la pantalla LCD.

 DIAGRAMA DE FLUJO

FIN

Calculo de SysTick

𝑁 = ,015 ∗ 48000000 − 1 = 719999 = 7,19999 ∗ 10𝑒5

CÓDIGO DE PROGRAMA
}

DIAGRAMA ELÉCTRICO
Ejecución del programa

Imagen del circuito y programa funcionando

CONCLUSIONES
He realizado una práctica en la que programé un microcontrolador para controlar una pantalla LCD. En la parte superior
de la pantalla LCD, se muestra la palabra "Hola mundo", y en la parte inferior, se muestra mi número de registro escolar,
que es "19100128". Aquí están mis conclusiones sobre esta práctica:

1. Interfaz con pantalla LCD: La práctica se centró en aprender cómo comunicarse y controlar una pantalla LCD
utilizando un microcontrolador. Esto es útil para mostrar información en una pantalla en aplicaciones embebidas y
sistemas embebidos.

2. Inicialización de periféricos: La práctica involucró la inicialización de pines y periféricos en el microcontrolador para

establecer una conexión adecuada con la pantalla LCD. Esto es fundamental para asegurarse de que la pantalla responda
correctamente a los comandos enviados.

3. Generación de mensajes: Para lograr la visualización deseada, se escribieron funciones específicas para mostrar los
mensajes "Hola mundo" y "19100128" en la pantalla. Estas funciones se encargaron de enviar los caracteres correctos a la
pantalla LCD.

4. Uso de temporización: Se utilizó el temporizador SysTick para crear retrasos controlados entre las operaciones en la
pantalla LCD. Esto garantiza que los comandos se ejecuten en el momento adecuado y que los caracteres se muestren
correctamente en la pantalla.

5. Bucle principal: El bucle principal se utilizó para repetir el proceso de mostrar los mensajes en la pantalla. Se utilizó una
variable `z` para controlar cuántas veces se repetía el proceso. Esto es útil para crear ciclos en la operación del
microcontrolador.

6. Configuración de pines: Se configuraron los pines GPIO en el microcontrolador para controlar la pantalla LCD. Esto es
una parte esencial de la programación de sistemas embebidos, ya que permite interactuar con componentes externos.

7. Aplicación de conocimientos: La práctica me permitió aplicar conocimientos teóricos en la programación de

microcontroladores y la configuración de periféricos para lograr una funcionalidad específica.

En resumen, esta práctica me proporcionó experiencia práctica en el control de una pantalla LCD utilizando un
microcontrolador, y me ayudó a comprender cómo se pueden aplicar los conceptos de programación a nivel de registro
en un contexto real. También aprendí sobre la importancia de la temporización y la inicialización adecuada de periféricos
al trabajar en proyectos de sistemas embebidos.
 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"

void STick_delay(uint32_t load);

void init_PINES(void);
void init_LCD(void);
void mensaje1(void);
void mensaje2(void);
int z=0;

int main(void)
{
/* Init board hardware. */
BOARD_InitBootPins();
BOARD_InitBootClocks();
BOARD_InitBootPeripherals();
#ifndef BOARD_INIT_DEBUG_CONSOLE_PERIPHERAL
BOARD_InitDebugConsole();
#endif
init_PINES();
while (z==0)
{
init_LCD();

mensaje1();

mensaje2();
z= z+1;
}
}
void STick_delay (uint32_t Load){
GPIOE->PCOR|= 1;
uint32_t i=0;
SysTick -> CTRL = 0;
SysTick->LOAD = Load;
SysTick -> CTRL |= 0x04U;
SysTick -> CTRL |= 0x01U;
while(i == 0)
{
i= SysTick->CTRL;
i &= (1<<16);
}
i=0;
GPIOE->PSOR|= 1;
}

void init_PINES(void)
{
SIM-> SCGC5|= SIM_SCGC5_PORTB_MASK | SIM_SCGC5_PORTE_MASK;

PORTB->PCR[0]|= PORT_PCR_MUX(1);
PORTB->PCR[1]|= PORT_PCR_MUX(1);
PORTB->PCR[2]|= PORT_PCR_MUX(1);
PORTB->PCR[3]|= PORT_PCR_MUX(1);
PORTB->PCR[8]|= PORT_PCR_MUX(1);
PORTB->PCR[9]|= PORT_PCR_MUX(1);
PORTB->PCR[10]|= PORT_PCR_MUX(1);
PORTB->PCR[11]|= PORT_PCR_MUX(1);
GPIOB->PDDR |= 1<<0;
GPIOB->PDDR |= 1<<1;
GPIOB->PDDR |= 1<<2;
GPIOB->PDDR |= 1<<3;
GPIOB->PDDR |= 1<<8;
GPIOB->PDDR |= 1<<9;
GPIOB->PDDR |= 1<<10;
GPIOB->PDDR |= 1<<11;

PORTE->PCR[0]|= PORT_PCR_MUX(1);
PORTE->PCR[1]|= PORT_PCR_MUX(1);
GPIOE->PDDR |= 1<<0;
GPIOE->PDDR |= 1<<1;
}

void init_LCD(void)
{
GPIOE->PSOR|= 1;
GPIOE->PCOR |= 1<<1;
STick_delay(719999);
GPIOB->PDOR = 0x38;
STick_delay(719999);
GPIOB->PDOR = 0x38;
STick_delay(719999);
GPIOB->PDOR = 0x38;
STick_delay(719999);
GPIOB->PDOR = 0x0E;
STick_delay(719999);
GPIOB->PDOR = 0x0E;
STick_delay(719999);
GPIOB->PDOR = 0x06;
STick_delay(719999);
GPIOB->PDOR = 0x01;
STick_delay(719999);
}
void mensaje1(void)
{
unsigned char mensaje1[] = " HOLA MUNDO ";
unsigned char x = 0;
GPIOE->PCOR |= 1<<1;
GPIOB->PSOR = 0x80;
STick_delay(719999);
GPIOE->PSOR |= 1<<1;
for (x = 0; x <17; x++)
{
GPIOB->PDOR = mensaje1[x];
STick_delay(719999);
}
}
void mensaje2(void)
{
unsigned char y = 0;
unsigned char mensaje2[] = "19100128";
GPIOE->PCOR |= 1<<1;
GPIOB->PSOR = 0xC0;
STick_delay(719999);
GPIOE->PSOR |= 1<<1;
for (y = 0; y <8 ; y++)
{
GPIOB->PDOR = mensaje2[y];
STick_delay(719999);
}