Reporte Practica N° 3 Angeles Estrada Ricardo

Fecha de entrega: 19/09/2023

1. Introducci´on
En esta practica se aprendi´o a utilizar y configurar los pines de la GPIO de la Raspberry
esto por medio de la creaci´on de un circuito en donde us´abamos leds y un display de 7
segmentos, y con ayuda de c´odigos de Python poder realizar diversos experimentos de
parpadeo de leds.

2. Antecedentes
74LS47 TTL Decodificador y Controlador BCD a Siete Segmentos El 74LS47N es un
decodificador/controlador de BCD, que es un c´odigo que se utiliza para poder representar
n´umeros decimales en binario (Universidad Aut´onoma de Ciudad Ju´arez, s/f), a siete
segmentos con salidas de activaci´on en bajo. A este decodificador se le puede dar una
entrada en BCD (4 bits) y es capaz de decodificarlo para encender y apagar los segmentos
adecuados para mostrar el d´ıgito correspondiente para el display de 7 segmentos. En este
modelo se tiene las salidas negadas, por lo que adecua para ser utilizado en un display de
´anodo com´un. (Jfvilla, s/f).

Threading.
thereading es una biblioteca de Python que nos permite usar hilos, los cuales permiten que
un programa ejecute m´ultiples operaciones simult´aneamente en el mismo espacio de un
proceso. La forma m´as sencilla de usar un Thread es crear una instancia con una funci´on
de destino y llamar a start() para que comience a funcionar, por ejemplo:
import t h r e a di n g

def worker ( ) :
””” t h r e a d worker f u n c t i o n ”””
pr int ( ’Worker ’ )

threads=[]
for i in range ( 5 ) :
t = t h r e a di n g . Thread ( t a r g e t=worker )
t h r e a d s . append ( t )
[Link]()

Donde hacemos que la funci´on worker se ejecute en cada ciclo del for, esto lo que nos
permite se hagan las instrucciones de una funci´on al mismo tiempo, los hilos nos permiten
usar el multipro cesador de nuestras computadoras para ejecutar varias instrucciones a la
vez, como subprocesos independientes (threading — Gestionar operaciones concurrentes
dentro de un proceso, s/f).
 1
Reporte Practica N° 3 Angeles Estrada Ricardo
Fecha de entrega: 19/09/2023

3. Desarrollo
Inicialmente se realiz´o el siguiente circuito utilizando Leds, un display de 7 segmentos,
resis tencias de 330W, Capacitor de 0.1µF, un decodificador de 7 segmentos ´anodo com´un
(74LS47) y requerimos de una fuente de alimentaci´on regulada a 5V y al menos 2 amperios
de salida y diversos conectores:

Figura 1: Diagrama de Circuito a alambrar

Entonces nuestro circuito ya armado y conectado a la Raspberry m´as o menos se ve´ıa de la
si guiente manera:
 Figura 2: Circuito alambrado
Una vez armado se vieron algunos c´odigos de funciones que nos ayudar´ıa a realizar tareas
como por ejemplo hacer un Led parpadeante de forma normal y otra usando PWM y un
c´odigo para

2
Reporte Practica N° 3 Angeles Estrada Ricardo
Fecha de entrega: 19/09/2023

ver el funcionamiento del display de siete segmentos. Estos c´odigos nos ayudar´ıan a
realizar los experimentos de esta pr´actica, cabe mencionar que adjunto a este documento se
agregara un archivo .rar llamado Codigos Practica 01 AEER P03 en donde al extraer los
archivos estar´an los archivos de cada experimento, a continuaci´on, se muestran los
enunciados de cada experimento y entre par´entesis el nombre de su archivo .py
correspondiente, as´ı como una breve explicaci´on delo que se realiz´o.

3.1. Experimentos
1. Modificar los c´odigos ejemplo de forma normal para todos los leds de la fila parpadeen
(ejer [Link]).
Para realizar este experimento usaremos la funci´on sleep de la librer´ıa de time,
entonces primeramente configuramos los pines de salida de GPIO de la Raspberry de
tal manera que se encuentren apagados o en bajo con ayuda de la siguiente l´ınea:
GPIO. se tup ( 3 2 , [Link], i n i t i a l=[Link])

Esta l´ınea se realizo con todos los pines a usar los cuales fueron el 32, 26, 24, 22, 18,
16 y 12, cabe mencionar que estos pines se usaran en los 5 experimentos, por lo tanto,
esto estar´a presente en todos los c´odigos. Ahora bien, dentro de un while, el cual
configuramos como un bucle infinito, primeramente, encendemos todos los pines o los
ponemos en alto, con la siguiente l´ınea:
 GPIO. output ( 3 2 , [Link])

Lo anterior repitiendo la linea solo cambiando el numero del pin de salida, esto con los 7
pines, despu´es con un sleep hacemos que se espere 500ms, para despu´es apagar los
pines o ponerlos en bajo, esto con la linea:
GPIO. output ( 3 2 , [Link])

Donde de igual forma repetimos cambiando el valor del pin de salida, con cada uno de
los pines.

2. Modificar los c´odigos ejemplo para que los leds de la fila enciendan de manera continua
en una marquesina de izquierda a derecha ([Link]).
Entonces para este c´odigo lo que se hizo fue hacer casi lo mismo que lo anterior, solo
que en vez de encender todos, esperar 500ms y luego apagar todos los pines, aqu´ı
encendemos un pin, esperamos 500ms, apagamos el mismo pin y luego encendemos
otro pin esto con todos los pins, entonces:

GPIO. output ( 3 2 , [Link]) #e nc ie n de

sleep(0.5)

3
Reporte Practica N° 3 Angeles Estrada Ricardo
Fecha de entrega: 19/09/2023

GPIO. output ( 3 2 , [Link]) #apaga

Y estas l´ıneas la repetimos con cada pin, como se nos pidi´o de izquierda a derecha
conside ramos que ser´a del led conectado al pin 32 al led conectado al pin 12 entonces
repetiremos las l´ıneas anteriores con cada pin en el siguiente orden 32, 26, 24, 22, 18,
16 y 12.

3. Modificar los c´odigos ejemplo para que los leds de la fila enciendan de manera continua
en una marquesina de derecha a izquierda con velocidad variable definida por el
usuario (ejer [Link]).
Este experimentamos lo configuramos detal forma que us´aramos PWM, entonces
primera mente volvemos a configurar los pines de salida, luego creamos un pwm para
cada una de las salidas y las configuramos a 1 MHz, esto con ayuda de la siguiente
l´ınea:
pwm1 = [Link]( 3 2 , 1 )
 Y esto se repite con cada pin de salida, donde al final tendremos del pwm1 al pwm7,
ahora bien, como es una marquesina de derecha a izquierda entonces ahora ser´a del
led conectado al pin 12 al led conectado al pin 32, que ser´ıa del pwm7 al pwm1,
entonces iniciaremos los pwm en ese orden con un ciclo de reloj inicial de 10 y entre
cada inicio de los pwm usaremos un sleep para realizar la apariencia de un corrimiento
de los leds, con ayda de las l´ıneas siguientes:
pwm7. s t a r t ( 1 0 )
sleep(0.1)

Esto con cada pwm, ahora bien, en un while configurado con una bandera para que, si
recibe un false detengamos todos los pwm y le demos un reset a todos los puertos y en
caso de la bandera se mantenga en True entonces constantemente preguntemos por un
nuevo ciclo de trabajo y podamos cambiar a todos los pwm que creamos, esto con las
siguientes l´ıneas:
dutyCycle = int (input ( ” I n g r e s e c i c l o de t r a b a j o : ” ) )
pwm7. ChangeDutyCycle ( dutyCycle )
sleep(0.1)

Entonces a cada pwm le pasaremos el valor de “dutyCycle”.

4. Con base en las modificaciones anteriores, genere una marquesina que haga parecer
que ≪la luz rebota≫ al llegar a las orillas (efecto ping-pong) con velocidad variable
definida por el usuario. ([Link]).
Para la realizaci´on de esta actividad usaremos hilos, para lo cual importamos la
librer´ıa threading, entonces inicialmente creamos una variable llamada “vel” para poder
guardar la velocidad, ya que esta debe ser variable, luego creamos un funci´on llamada
“pedir” donde guardaremos en la variable vel el valor que le solicitamos al usuario,
luego creamos otra funci´on llamada “leds” donde repetiremos lo realizado en el
experimento 2 solo que aqu´ı

4
Reporte Practica N° 3 Angeles Estrada Ricardo
Fecha de entrega: 19/09/2023

debemos ir de izquierda a derecha y luego viceversa entonces iremos de pin 32 al 12 y

luego cuando se este ´ultimo se apague el siguiente en encender sea el pin 16 y repetir
hasta el 32, esto con ayuda de lo siguiente:
GPIO. output ( 3 2 , [Link]) #e nc ie n de
s l e e p ( v el )
GPIO. output ( 3 2 , [Link]) #apaga
 Entonces con ayuda del sleep modificaremos la velocidad de parpadeo de cada led
usando la variable “vel” que se ira modificando con la funci´on anterior, y como se dijo
anteriormente se repiti´o las l´ıneas anteriores con cada pin en el siguiente orden 32,
26, 24, 22, 18, 16, 12, 16, 18, 22, 24, 26 y 32. Ahora fuera de esta funci´on crearemos 2
hilos donde el primero los relacionaremos con la funci´on “pedir” y el segundo con la
funci´on “leds”, esto con las siguientes l´ıneas:
th re ad 1 = t h r e a di n g . Thread ( t a r g e t=p e di r )
th re ad 2 = t h r e a di n g . Thread ( t a r g e t=l e d s )

con esto lo que hacemos es que amabas funciones se realicen al mismo tiempo como
subpro cesos, as´ı cuando modifique el valor de “vel” en la funci´on “pedir” se vea
reflejado en los sleeps de “leds”, y lo anterior lo iniciamos con:
th re ad 1 . s t a r t ( )
th re ad 2 . s t a r t ( )

Y con ayuda de .join() hacemos que se bloquen el llamado a estos hilos hasta que
terminen su proceso, esto para evitar que alg´un proceso se corte en alg´un punto y as´ı
hacer que se vea fluido nuestra marquesina

5. Modificar los c´odigos ejemplo de tal forma que haga que uno de los leds encienda
gradualmen te a lo largo de un segundo hasta adquirir m´axima potencia, permanezca
encendido medio segundo, y despu´es se apague gradualmente a lo largo de otro
segundo.([Link]). Para esto volveremos a usar PWM entonces creamos los pwm
para cada pin de salida, tam bi´en los inicializamos con .start(10), esto es que inician
con ciclo de reloj de 10, entonces ahora dentro de un While, configurado con un ciclo
infinito, crearemos un for que ira de 0 a 100, que se ira almacenado en “i” y donde le
pasaremos el valor de “i” a cada pwm como ciclo de reloj, con ayuda de la l´ınea:
pwm7. ChangeDutyCycle ( i )

Y para notar cada cambio le daremos un sleep de una cent´esima de segundo, luego
crearemos un nuevo ciclo for pero esta vez iremos de 100 a 0 y nuevamente se los
pasaremos a cada pwm, y al final le daremos un sleep de medio segundo

5
Reporte Practica N° 3 Angeles Estrada Ricardo
Fecha de entrega: 19/09/2023

4. Conclusiones
 Cada experimento tuvo su grado de dificultad, solo que donde nos complicamos mas fue
con el experimento 4 ya que inicialmente quer´ıamos realizarlo con PWM, y se trato de varias
formas, pero no nos quedaba ya hasta que se nos dijo que era complicado realizarlo con
PWM, entonces cambiamos el enfoque y lo terminamos realizando con hilos, en cuanto a los
otros no presentaron gran dificultad tal vez solo que a veces, por ejemplo en los que le
ten´ıamos que pedir un valor al usuario cada vez que le d´abamos un nuevo valor a vez se
trababa o los leds ya no segu´ıan el orden de encendido, y estos se solucionaron con
agregando sleep o cambiando el orden de encendido.

5. Bibliograf´ıa
jfvilla. (s/f). Decodificadores de BCD a 7 segmentos. 7Robot - Mobile Education and
Engi neering. [Link]

Universidad Aut´onoma de Ciudad Ju´arez. (s/f). C´odogo BCD. [Link].

[Link]
/[Link]

threading-Gestionar operaciones concurrentes dentro de un proceso. (s/f).

[Link]. [Link]