UNIVERSIDAD AUTÓNOMA DE NUEVO

LEÓN
FACULTAD DE INGENIERÍA MECÁNICA Y
ELÉCTRICA

Diseño de Sistemas Embebidos

Docente: Dr. Héctor Gilberto Barrón González

Actividad Fundamental 3: Update Display Random Generator

Nombre: Alejandro Cisneros Pérez Matricula: 1823907

Hora: M4 Salón: 7215

Brigada: 001 Plan:401
Contenido
1.- Descripción del Problema.............................................................................................................3
2.- Objetivo........................................................................................................................................3
3.- Diagrama de Flujo Propuesto........................................................................................................4
4.- Diagrama de la Implementación del Circuito (Si fue requerido)...................................................6
5.- Evidencia Grafica (Si existe un circuito).......................................................................................6
6.- Explicación del código..................................................................................................................9
1.- Descripción del Problema
Utilizando dos displays de 4 dígitos de ánodo común se generará un barrido generando
persistencia visual en los displays. Para ello se utilizará un CI 74238 para controlar el
ánodo que enciende cada digito y un CI 7447 para generar el número que se escribirá en
cada digito. Para lograr el funcionamiento adecuado siga las siguientes instrucciones:

1.- Desarrolle el código necesario para enviar un número y su correspondiente señal de

activación en el lugar que le corresponda del display.

2.- Genere el efecto de persistencia visual de forma simultánea en los 8 dígitos del display.

3.- Generar un numero aleatorio de 8 dígitos desde la subrutina de interrupción.

4.- Desde el while principal imprimir constantemente el valor del número random en el
display

2.- Objetivo
 Desarrollar el código necesario para enviar un número y su correspondiente señal de
activación en el lugar que le corresponda del display
 Genere el efecto de persistencia visual de forma simultánea en los 8 dígitos del
display
 Genere un código que por medio de las interrupciones genere números aleatorios los
cuales se mostraran en el display
3.- Diagrama de Flujo Propuesto
4.- Diagrama de la Implementación del Circuito (Si fue requerido)
5.- Evidencia Grafica (Si existe un circuito)
6.-Prototipos de funciones principales
#include "main.h"
#include "stm32f4xx.h"
#include <stdlib.h>

En el encabezado tenemos el “main.h” que es la librería general, enseguida tenemos la

librería de instrucciones del microcontrolador (“stm32f4xx.h”) y por último tenemos la
librería “stdlib.h” que nos permite usar las funciones rand() y srand().

#include <time.h> //con esta librería podemos usar time(NULL)

#include <unistd.h> //con esta librería podemos usar getpid()

Las librerías que se muestran son las que se usan dentro del srand para obtener distintos
números bases o semilla. Con el time(NULL) tenemos como base la hora que está
cambiando a cada momento. Con el getpid tenemos como base el id del proceso del
programa y también estará cambiando constantemente.

DisplayNumber(Random);

Es la función que se encarga de segmentar el número de 8 dígitos y mostrarlo en el display

con un barrido. La variable dentro del paréntesis es el valor que se estará segmentando y
mostrando en los displays.

SetDisplay(dig8, dig7, dig6, dig5, dig4, dig3, dig2, dig1);

Esta función guarda los valores de los 8 dígitos ya segmentados y por medio de un barrido
los muestra en la posición en la que van en los displays.

void EXTI0_IRQHandler(void)

Dentro del void de la interrupción externa tenemos una función y una instrucción.

RandomNumber();

Esta función es la que se encarga de generar un número aleatorio de 8 dígitos.

HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_0);

Esta instrucción es la que está al tanto de las interrupciones externas

void RandomNumber(void)
Dentro del void de RandomNumber tenemos la instrucción srand(getpid()); que es la
encargada de generar un número base o semilla a partir del id del proceso que estará
cambiando continuamente.
También tenemos la instrucción rand()%(N+1) que es la encargada de generar un número
aleatorio del 0 al 9 usando como base o semilla el id del proceso que usamos en la
instrucción anterior.

7.- Explicación del código

 Escritura de un número y generación del barrido en los displays
 En la línea 1 tenemos el encabezado de la función DisplayNumber. Esta función se
encarga de segmentar y asignar los valores que corresponde a cada digito
En la línea 2 declaramos las variables que usaremos para cada digito del display
De la línea 3 a la 10 asignamos a las variables correspondientes el valor del digito
del display que le corresponde. Este valor se obtiene de una función
“RandomNumber” que se encarga de generar un numero aleatorio de 8 dígitos.
En la línea 11 tenemos el llamado a la función SetDisplay
En la línea 13 tenemos el encabezado de la función SetDisplay, es la que se encarga
de hacer el barrido en los displays.
Por medio de esta función mostraremos los dígitos en el display.
Con el comando GPIOE->ODR escribimos en el puerto E el digito que debe
mostrar en la posición del display que se le indique. Con un retardo (HAL_Delay)
entre cada acción
01.- void DisplayNumber(int count){
02.- int dig1,dig2,dig3,dig4,dig5,dig6,dig7,dig8;
03.- dig1=count%10;
04.- dig2=(count%100)/10;
05.- dig3=(count%1000)/100;
06.- dig4=(count%10000)/1000;
07.- dig5=(count%100000)/10000;
08.- dig6=(count%1000000)/100000;
09.- dig7=(count%10000000)/1000000;
10.- dig8=(count%100000000)/10000000;
11.- setDisplay(dig1,dig2,dig3,dig4,dig5,dig6,dig7,dig8);
12.- }
13.- void setDisplay(int dig1,int dig2,int dig3,int dig4,int dig5,int dig6,int
dig7,int dig8){
14.- GPIOE->ODR=numeros[dig1]+D1;
15.- HAL_Delay(1);
16.- GPIOE->ODR=numeros[dig2]+D2;
17.- HAL_Delay(1);
18.- GPIOE->ODR=numeros[dig3]+D3;
19.- HAL_Delay(1);
20.- GPIOE->ODR=numeros[dig4]+D4;
21.- HAL_Delay(1);
22.- GPIOE->ODR=numeros[dig5]+D5;
23.- HAL_Delay(1);
24.- GPIOE->ODR=numeros[dig6]+D6;
25.- HAL_Delay(1);
26.- GPIOE->ODR=numeros[dig7]+D7;
27.- HAL_Delay(1);
28.- GPIOE->ODR=numeros[dig8]+D8;
29.- HAL_Delay(1);
30.- }
 Proceso de interrupción y la subrutina de servicio de interrupción
En la línea 1 tenemos el encabezado de la función que se encarga de detectar la
interrupción
 En la línea 3 generamos un retardo para que no se repita la detección de la
interrupción
En la línea 4 preguntamos por el estado del puesto donde se genera la interrupción.
Si el estado es verdadero, se hace un llamado a la función RandomNumber en la
línea 5, la cual tiene como finalidad crear un numero aleatorio de 8 dígitos
En la línea 7 se hace un llamado a la función que controla la solicitud de
interrupciones exteriores
01.- void EXTI1_IRQHandler(void)
02.- {
03.- for(int i=0;i<30000;i++);
04.- if(HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_0)){
05.- RandomNumber();
06.- }
07.- HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_1);
08.- }

 Generación del valor aleatorio

Desde el main declaramos nuestra variable Random. En este vamos a almacenar el
valor del número aleatorio de 8 dígitos.
En la línea 2 tenemos el encabezado de la función RandomNumber, la cual se
encarga de generar un numero aleatorio de 8 dígitos cada que se detecte un valor
lógico alto en el Pin 0 del Puerto C.
En la línea 3 tenemos la instrucción sran, la cual se usa para establecer el valor
inicial para el proceso aleatorio. La instrucción getpid obtiene el id del proceso del
programa, el cual cambiará siempre.
En la línea 3 ingresamos un vector que nos ayudará a posicionar cada valor obtenido
de unidades hasta decenas de millón.
En la línea 4 ingresamos el número máximo que vamos a usar para obtener valores
aleatorios.
En la línea 5 y 6 hacemos un ciclo de 0 hasta el 7 para obtener 8 números aleatorios
y multiplicarlos por el vector para ponerlos en una posición que va desde las
unidades hasta las decenas de millón. Todos estos valores serán sumados y
almacenados en la variable Random que es la que mostramos en los displays con
ayuda de DisplayNumber.
En la línea 8 tenemos la parte que nos asegurará que nuestro número aleatorio se
quede dentro del rango de los 8 dígitos.
01.- void RandomNumber(void){
02.- srand (getpid());
03.- int vec[8]={1,10,100,1000,10000,100000,1000000,10000000};
04.- int N=9;
05.- for(int i=0;i<8;i++){
06.- Random+=(vec[i]*(rand()%(N+1)));
 07.- }
08.- Random=(Random%100000000);
09.- }

 El loop de control principal y las subrutinas que de él se derivan.

En la línea 1 tenemos el loop de control principal
En la línea 3 hacemos un llamado a nuestra función que se encargara de segmentar
el numero aleatorio que obtuvimos durante la interrupción y la asignara a una
variable asociada a un digito en el display. Luego que esta termino de segmentar y
asignar los valores, ahora los envía a una función semiprivada (SetDisplay) que se
encargara de mostrar los valores en el display
1.- while (1)
2.- {
3.- displayNumber(Random);
4.- }