Integrantes del equipo: Borbon Elizabeth, Leslie, Mendoza Campos Alan

Profesor: Salazar Silva Gastón Hugo.

Procesador digital de señales
6 de septiembre del 2019

Actividad 5: Encendido de un
despliegue de LED controlado por
un botón
Introducción

El display 7 Segmentos es un dispositivo opto-electrónico que permite visualizar números del 0

al 9. Existen dos tipos de display, de cátodo común y de ánodo común. Este tipo de elemento
de salida digital o display, se utilizaba en los primeros dispositivos electrónicos de la década de
los 70’s y 80’s. Hoy en día es muy utilizado en proyectos educativos o en sistemas vintage.
También debido a su facilidad de uso, mantenimiento y costo, son utilizados en relojes gigantes
o incluso como marcadores en algunos tipos de canchas deportivas.

Es importante mencionar que los display de 7 segmentos, dado que están construidos con
diodos LED, requieren una corriente máxima. En otras palabras, se requiere colocar una
resistencia para limitar la corriente. Dicha resistencia depende de la corriente que se quiera
suministrar al LED, así como de la caída de voltaje. Para calcular la resistencia usamos la Ley
de Ohm. Pueden ver este tutorial para calcular la resistencia de un led. También te puede
interesar el código de colores para resistencias.

Los Procesadores Digitales de señal son microprocesadores particulares para tratamiento de

señales, este tipo de procesos son útiles para procesamiento de cualquier tipo de señal en
tiempo real. Cuando se habla de señales se refiere a una magnitud de naturaleza física que se
encuentra en una función temporal, estas señales provienen del mundo real y por lo tanto se
necesita un sensor o un transductor para transformarla en una magnitud variable, generalmente
un voltaje.
Las herramientas básicas de procesado son:

o Filtrado: Hace uso de filtros digitales para cambiar la frecuencia de la señal a procesar,
estos filtros tienen la capacidad de aplicar nuevos filtros no existentes de forma
analógica como los llamados “de fase lineal”.
o Análisis de espectro: Cuando se quieren saber las frecuencias encontradas en una
señal, se utiliza esta herramienta, que es la aplicación de transformaciones para la
descripción de las señales en términos de valores en el dominio del tiempo o también
en el dominio de la frecuencia.
o Síntesis: Los PDS’s tienen la capacidad de generar funciones trigonométricas,
osciladores digitales, números aleatorios, etc.
o Correlación: Se puede ver esta herramienta como un filtro particular ya que deja pasar
cierto tipo de señal, se utiliza para detectar las periodicidades de una señal, esto a través
 de contrastar intervalos anteriores con otros más actuales y así, en general, señalar las
similitudes entre señales.

Métodos

Material utilizado
o Cable USB tipo A a Mini-B.
o Tablero de prototipado (protoboard).
o Despliegue LED de 7 segmentos de anodo común.
o 1 resistencia de 220 Ohms.
o Cables Jump Wire.
Equipo utilizado
1. Tarjeta de procesamiento.
2. Computadora
Software utilizado
o Embitz: Es un IDE de alto rendimiento open source escrito en C++.
o STM32 ST-LINK utility: Interfaz de software para programación de microcontroladores
STM32 proporcionando un entorno de uso fácil y eficiente para la lectura, escritura y
verificación de un dispositivo de memoria. Esta herramienta proporciona una gama muy
amplia de funciones para la programación de memorias internas de STM32, memorias
externas, verificación de contenido de la programación y automatización de la
programación de STM32.

Procedimiento seguido
Actividad autónoma 1: Modifique el programa para modificar la
frecuencia con la que se realiza la secuencia a partir de un comando
enviado por el botón de usuario.
El programa consiste en 5 principales partes, las cuales son:

1. Definir librerías y variables globales (#include y define).

2. Definir las variables para activar el display de siete segmentos de anodo común. En esta parte
se definen los números del cero al F (en typedef enum) y consecuentemente se guardan las
variables en un vector (const unsigned short int segmentos) .

3. Se definen los registros y los espacios de memoria necesarios para poder utilizar el código
de manera eficaz en la tarjeta Nucleo-f401re (configuración máquina) y se inicializan las
variables que se requieran (en este caso DISPLAY=CERO, para que de esta manera el primer
número que se muestre en pantalla sea en cero).

4. Se define la lógica con la cual haremos el programa (void loop(void)) en la cual declaramos
variables de tipo estático (“static”) y se define la lógica con la cual desplegaremos los números
deseados en una secuencia lógica en el display de 7 segmentos de la manera correcta.
5. El código principal (int main(void)) se encuentra en esta parte, el cual no tendrá más
relevancia en este código que repetir el loop() en un ciclo while indefinidas veces.

Una vez identificadas las partes del código relevantes, podemos proceder a realizar los cambios
necesarios para poder cambiar la frecuencia con la que el display muestra la secuencia de
números hexadecimales, el procedimiento es el siguiente:

1. Se definieron 2 variables globales para cambiar la frecuencia, las cuales son DELAY con una
frecuencia de 500000 milisegundos y la otra es DELAYS con una frecuencia de 250000
milisegundos (es dos veces más rápida).

2. Se inicializan las variable en el ciclo loop, en donde:

• display_count es la variable que determina el número hexadecimal que será mostrada en
pantalla (todo esto con la ayuda del vector segmentos “segmentos display_count”).
• delay_count y del_count las cuales almacenan las variables DELAY y DELAYS
respectivamente.
• m que es la variable que nos ayudará a cambiar de una frecuencia a otra (cuando m==0 el
tiempo será el de DELAY, cuando m==1 el tiempo será el de DELAYS).

3. Por medio de cuatro ciclos IF’S se determina la lógica de cambio de frecuencias.

• El primer IF lo que hace es poner el primer tiempo “DELAY” si la variable m==0, esta variable
cambia si presionamos el botón físico de nuestra tarjeta.
• Es segundo IF lo que hace es poner el segundo tiempo “DELAYS” si la variable m==1, esta
variable cambia si presionamos el botón físico de nuestra tarjeta.
• El tercer IF es el que cambia de valor la variable m, la cual mientras se presione el botón su
valor será igual a cero, si no se presiona su valor será igual a uno.
• El cuarto IF inicializa la variable m en cero cada vez que sea esta mayor a uno, esto lo hacer
porque para cambiar el valor de m a m siempre se le suma un 1 (m=m+1), por lo que para evitar
que se desborde de sus valores principales (cero y uno) se decide inicializarla.

Actividad autónoma 2: Modifique el programa para que la secuencia en

el despliegue cambie de números a letras, y de letras a números al
presionar el botón de usuario.
Este programa tiene una variación a partir del punto 4 respecto al anterior, por lo que se
especifica a partir de este:

4. Se define la lógica con la cual haremos el programa (void loop(void)) en la cual declaramos
variables de tipo estático (“static”) y se define la lógica con la cual desplegaremos los números
deseados en una secuencia lógica en el display de 7 segmentos de la manera correcta.

5. El código principal (int main(void)) se encuentra en esta parte, el cual no tendrá más
relevancia en este código que repetir el loop() en un ciclo while indefinidas veces.

Una vez identificadas las partes del código relevantes, podemos proceder a realizar los cambios
necesarios para poder cambiar la secuencia de números hexadecimales por la secuencia de
letras que tienen el mensaje HOLA en el DISPLAY cada vez que se acciona el botón, para esto
el procedimiento que se realizó fue el siguiente:

1. Se definieron 2 variables globales, las cuales son DELAY con una frecuencia de 500000
milisegundos.
2. Se definieron 3 letras más en los valores para activar el Display de 7 segmentos (typedef
enum) las cuales fueron H, O y L, para formar la palabra HOLA (la letra A no era necesario
definirla nuevamente, ya estaba previamente en el programa).

3. Además del vector segmentos , se agregó otro vector llamado seg el cual contiene las
palabras ordenadas para formar la palabra HOLA.

4. Se inicializan las variable en el ciclo loop, en donde:

• display_count es la variable que determina el número hexadecimal que será mostrado en
pantalla (todo esto con la ayuda del vector segmentos “segmentos display_count”).
• dis_count es la variable que determina la letra (de la palabra HOLA) que será mostrada en
pantalla (todo esto con la ayuda del vector segmentos “seg dis_count”).
• delay_count la cual almacena la variable DELAY que determina el tiempo.
• m que es la variable que nos ayudará a cambiar de la secuencia hexadecimal a la secuencia
de la palabra HOLA (cuando m==0 la secuencia será hexadecimal, cuando m==1 la secuencia
será la palabra HOLA).

5. Por medio de cuatro ciclos IF’S se determina la lógica de cambio de frecuencias.

• El primer IF lo que hace es mostrar la secuencia hexadecimal si la variable m==0, esta variable
cambia si presionamos el botón físico de nuestra tarjeta.
• El segundo IF lo que hace es mostrar la palabra HOLA si la variable m==1, esta variable
cambia si presionamos el botón físico de nuestra tarjeta.
• El tercer IF es el que cambia de valor la variable m, la cual mientras se presione el botón su
valor será igual a cero, si no se presiona su valor será igual a uno.
• El cuarto IF inicializa la variable m en cero cada vez que sea esta mayor a uno, esto lo hacer
porque para cambiar el valor de m a m siempre se le suma un 1 (m=m+1), por lo que para evitar
que se desborde de sus valores principales (cero y uno) se decide inicializarla.

Resultados

Código de las actividades autónomas

Código: ---- ------- -----

/** @file main.c

PB0 A blue

@author Gastón SALAZAR || Equipo

PB1 B red
12

PB2 C yellow
# Interface #

PB3 D green
## Physical connections ##

PB4 E orange
Port Segment Color
PB5 F violet #define DELAY 500000UL //Frecuencia
original

PB6 G gray
#define DELAYS 250000UL //Frecuencia
modificada

## LEDS on a 7-segment Display ##

// Values for activating LEDs on a 7-

segments display with common anode
AAA

typedef enum {
F B

CERO = 0xc0,
F B

UNO = 0xf9,
F B

DOS = 0xa4,
GGG

TRES = 0xb0,
E C

CUATRO = 0x99,
E C

CINCO = 0x92,
E C

SEIS = 0x82,
DDD

SIETE = 0xf8,
*/

OCHO = 0x80,
#include "stm32f4xx_conf.h"

NUEVE = 0x90,
#define DISPLAY GPIOB->ODR

CA = 0x88,
#define BUTTON (GPIOC->IDR &
GPIO_IDR_IDR_13)

CB = 0x83,
 CC = 0xc6, |
GPIO_MODER_MODER4 | GPIO_MODER_MODER5
| GPIO_MODER_MODER6);

CD = 0xa1,

GPIOB->MODER |=
(GPIO_MODER_MODER0_0 |
CE = 0x86, GPIO_MODER_MODER1_0 |
GPIO_MODER_MODER2_0 |
GPIO_MODER_MODER3_0
CF = 0x8e

|
GPIO_MODER_MODER4_0 |
} digits;
GPIO_MODER_MODER5_0 |
GPIO_MODER_MODER6_0);

const unsigned short int segmentos[]

= {CERO, UNO, DOS, TRES, CUATRO,
GPIOB->PUPDR &=
CINCO,
~(GPIO_PUPDR_PUPDR0 |
GPIO_PUPDR_PUPDR1 | GPIO_PUPDR_PUPDR2
| GPIO_PUPDR_PUPDR3

SEIS, SIETE, OCHO, NUEVE,

|
GPIO_PUPDR_PUPDR4 | GPIO_PUPDR_PUPDR5
| GPIO_PUPDR_PUPDR6);
CA, CB, CC, CD, CE, CF};

GPIOC->MODER &=
void setup() ~GPIO_MODER_MODER13;

{ GPIOC->PUPDR &=
~GPIO_PUPDR_PUPDR13;

// Configuraci de m痃uina
// Inicializaci de variables

RCC->AHB1ENR |=
DISPLAY = CERO;
RCC_AHB1ENR_GPIOBEN;

}
RCC->AHB1ENR |=
RCC_AHB1ENR_GPIOCEN;

void loop(void)
GPIOB->MODER &=
~(GPIO_MODER_MODER0 |
GPIO_MODER_MODER1 | GPIO_MODER_MODER2 {
| GPIO_MODER_MODER3
 static short unsigned int display_count++;
display_count = 0;

display_count &= 0x0f;

//static short unsigned int
dis_count = 0;

DISPLAY =
segmentos[display_count];
static short unsigned int m = 0;
// inicialización (variable de
control)
delay_count = DELAYS;

static long unsigned int

delay_count = DELAY; // }
inicialización (frecuencia original)

if (BUTTON)
static long unsigned int del_count
= DELAYS; // inicialización
(frecuencia modificada)
{

if (m==0 && !delay_count)

delay_count--;
//rutina con la frecuencia original

del_count--;
{

//m = m+1;
display_count++;

m = m; // variable m igual a m
display_count &= 0x0f;

}
DISPLAY =
segmentos[display_count];

else // variable m mas uno

delay_count = DELAY;

{
}

m = m+1;
if (m==1 && !delay_count) //rutina
con la frecuencia modificada
}

{
 if (m>1) //caso if variable m @author Gastón SALAZAR || equipo
mayor a 1 12

{ # Interface #

m = 0; ## Physical connections ##

} Port Segment Color

} ---- ------- -----

int main(void) PB0 A blue

{ PB1 B red

setup(); PB2 C yellow

while(1) PB3 D green

{ PB4 E orange

loop(); PB5 F violet

} PB6 G gray

} ## LEDS on a 7-segment Display ##

Código: Modifique el programa

AAA
para que la secuencia en el
despliegue cambie de números a
letras, y de letras a números al F B
presionar el botón de usuario.

F B
/** @file main.c

F B
GGG TRES = 0xb0,

E C CUATRO = 0x99,

E C CINCO = 0x92,

E C SEIS = 0x82,

DDD SIETE = 0xf8,

*/ OCHO = 0x80,

#include "stm32f4xx_conf.h" NUEVE = 0x90,

#define DISPLAY GPIOB->ODR CA = 0x88,

#define BUTTON (GPIOC->IDR & CB = 0x83,

GPIO_IDR_IDR_13)

CC = 0xc6,
#define DELAY 500000UL

CD = 0xa1,
#define ms 1UL

CE = 0x86,
// Values for activating LEDs on a 7-
segments display with common anode

CF = 0x8e,

typedef enum {

CH = 0x89,

CERO = 0xc0,

CO = 0xc0,

UNO = 0xf9,

CL = 0xc7

DOS = 0xa4,
} digits;
const unsigned short int segmentos[] |
= {CERO, UNO, DOS, TRES, CUATRO, GPIO_MODER_MODER4_0 |
CINCO, GPIO_MODER_MODER5_0 |
GPIO_MODER_MODER6_0);

SEIS, SIETE, OCHO, NUEVE, GPIOB->PUPDR &=

~(GPIO_PUPDR_PUPDR0 |
GPIO_PUPDR_PUPDR1 | GPIO_PUPDR_PUPDR2
| GPIO_PUPDR_PUPDR3

CA, CB, CC, CD, CE, CF};

const unsigned short int seg[] = {CH,
CO, CL, CA}; // designación de los
nuevos caracteres
|
GPIO_PUPDR_PUPDR4 | GPIO_PUPDR_PUPDR5
| GPIO_PUPDR_PUPDR6);

GPIOC->MODER &=
~GPIO_MODER_MODER13;
void setup()

GPIOC->PUPDR &=
{ ~GPIO_PUPDR_PUPDR13;

// Configuraci de m痃uina // Inicializaci de variables

RCC->AHB1ENR |= DISPLAY = CERO;

RCC_AHB1ENR_GPIOBEN;

}
RCC->AHB1ENR |=
RCC_AHB1ENR_GPIOCEN;

void loop(void)

GPIOB->MODER &=
~(GPIO_MODER_MODER0 |
GPIO_MODER_MODER1 | GPIO_MODER_MODER2 {
| GPIO_MODER_MODER3

static short unsigned int

| display_count = 0;
GPIO_MODER_MODER4 | GPIO_MODER_MODER5
| GPIO_MODER_MODER6);
static short unsigned int
dis_count = 0;
GPIOB->MODER |=
(GPIO_MODER_MODER0_0 |
GPIO_MODER_MODER1_0 |
GPIO_MODER_MODER2_0 | static long unsigned int
GPIO_MODER_MODER3_0 delay_count = DELAY;
 static short unsigned int m = 0; {
// inicialización de la variable m

delay_count--;
if (m==0 && !delay_count) //
contador de 0 a f

//m = m+1;

m = m; // m igual a m
resignación de estado
display_count++;

}
display_count &= 0x0f;

else
DISPLAY =
segmentos[display_count];

delay_count = DELAY;

m = m+1; // variable m
= m+1 (cambio de estados)
}

}
if (m==1 && !delay_count)
//contador caracter H-O-L-A

if (m>1) //condiciones de
estado m mayor a 1
{

{
dis_count++;

m = 0;
dis_count &= 0x03;

}
DISPLAY = seg[dis_count];

}
delay_count = DELAY;

int main(void)
}

{
if (BUTTON)
 setup(); loop();

while(1) }

{ }

Efecto percibido en el despliegue de 7 segmentos

Se pudo visualizar a través de un display (ánodo común) el conteo de números hexadecimales
(de 0 a f), el cual su frecuencia se veía afectada por su interacción con el botón de usuario
dentro de la tarjeta de desarrollo, se logro observar que el despliegue de leds inicializa su
rutina con una frecuencia inicial y conforme el botón es presionado su frecuencia tiende a
cambiar mostrando un despliegue mas rápido de los caracteres.

En el segundo programa se logra visualizar que la rutina de características del despliegue de

leds cambia con respecto al botón presionado, inicializa con la rutina de conteo y conforme se
presione el botón de usuario la rutina cambia al despliegue del mensaje HOLA.

Dificultades encontradas
Durante la realización de los dos programas la única dificultad que se encontró fue la función y
los estados del botón de usuario, ya que al inicio de la programación teníamos de escaso a
nulo conocimiento de este.

Conclusiones

Discusión de los resultados y su impacto.

Así como en la práctica anterior, el saber realizar cambios de frecuencia para modificar el
tiempo de muestreo en el display 7 segmentos y de forma general resulta muy útil para
diversas aplicaciones. Ahora bien, poder agregar una variable controlada por el usuario como
lo es un botón agrega un parámetro físico que afecta directamente a nuestro programa y
modifica los resultados y por ende lo que se muestra en el 7 segmentos. Esto nos resulta muy
conveniente y es la base para la realización del proyecto, que si bien, no tenemos
conocimiento de la utilización de otros registros si que podemos desarrollar aplicaciones
sencillas con lo aprendido hasta ahora.

Referencias

Salazar, Gaston., “dsp03”. github.com. N.p. , 23 Feb. 2019. Web. 13 Feb 2019.
Yiu, Joseph., “ARM Cortex-M for Beginners”. community.arm.com. N.p., Mar. 2017. Web. 22
Feb 2019.