UPIITA-IPN Materia: Circuitos Lógicos

Práctica No. 10: Control digital y automatización con circuitos Número de mesa: 1
secuenciales. Nombre de la empresa: Mexilogics
Álvarez Gómez Julio César Grupo: 2MV12
Galván Escobar Adrián Raúl
Mata Prieto Varush
Varela Alpizar Benjamin

Resumen
En este reporte se eligió una de las distintas aplicaciones sugeridas para implementar
haciendo uso de los circuitos secuenciales. Para nuestro caso, se presentarán los diagramas
esquemáticos, los códigos y las fotografías de funcionamiento de un medidor de distancia
digital que funciona con un sensor ultrasónico SRF04 y mostrará la distancia entre el objeto
y el receptor en displays de 7 segmentos, dicha medición estará en centímetros.
Astract
In this report, one of several suggested applications was chosen for implementation using
sequential circuits. For our case, we will present the schematic diagrams, codes and pictures
of operation of a digital distance meter that works with an SRF04 ultrasonic sensor and will
show the distance between the object and the receiver in 7-segment displays, this
measurement will be in centimetres.
Résumé
Dans ce compte-rendu, l'une des applications proposées a été choisie pour être mise en œuvre
à l'aide de circuits séquentiels. Dans notre cas, nous présenterons les schémas, les codes et
les images de fonctionnement d'un télémètre numérique qui fonctionne avec un capteur à
ultrasons SRF04 et qui affiche la distance entre l'objet et le récepteur sur des displays à 7
segments, cette mesure étant exprimée en centimètres.

Tabla de contenidos
Punto VHDL Verilog UCF Fotos Diagramas Tabla Simulación
2 (iv).- Digital
distance meter
✓ ✓ ✓ ✓
with US sensor.
 Desarrollo
Para este reporte únicamente se reportarán los diagramas, códigos y fotos del funcionamiento
del punto escogido presentado en laboratorio
2 (iv).- Medidor de distancia digital con un sensor ultrasónico
Para este punto fue solicitado un medidor de distancia digital con un sensor Ultrasónico
SRF05 o SRF04 (nosotros lo implementamos con un SRF04) donde el rango de nuestro
sensor abarco desde los 0 [cm] hasta aproximadamente 400 [cm] y con 1 [cm] de resolución.
El esquemático siguiente muestra la conexión del sensor Ultrasónico con los pines del puerto
de expansión de la FPGA Amiba 2 (ver figura 1):

Figura 1.- Diagrama esquemático para el medidor digital de distancia

Y en la siguiente figura se muestra el pinout del sensor US utilizado (ver figura 2):

Figura 2.- Pinout del sensor SRF04

Mientras que el código (en VHDL) se divide en los siguientes componentes:

• Librería para medir la distancia en cm en el sensor US (U1)
• Conversor de binario a decimal a través del algoritmo “Shift and Add 3” (U2)
• Muestreo de los datos numéricos en los displays de 7 segmentos incorporados en la
FPGA (U3)
 • Divisor de frecuencia para el muestreo de los datos numéricos en los displays de 7
segmentos. (U4)
El código empleado (en VHDL) fue el siguiente:
• Código principal
----------------------------------------------------------------------
-- MEXILOGICS: CONTROL DE UN MÓDULO ULTRASÓNICO PARA MOSTRAR DISTANCIA
EN CM
----------------------------------------------------------------------
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

entity Mide_dist is
port( CLK : IN STD_LOGIC;
ECO : IN STD_LOGIC;
TRIGGER : OUT STD_LOGIC;
SEG : OUT STD_LOGIC_VECTOR (7 DOWNTO 0);
AN : OUT STD_LOGIC_VECTOR (7 DOWNTO 0) );
end Mide_dist;

architecture Behavioral of Mide_dist is

component ULTRASONICO is
generic( FPGA_CLK : INTEGER := 50_000_000 );
PORT( CLK : IN STD_LOGIC;
ECO : IN STD_LOGIC;
TRIGGER : OUT STD_LOGIC;
DATO_LISTO : OUT STD_LOGIC;
DISTANCIA_CM : OUT STD_LOGIC_VECTOR(8 DOWNTO 0)
);
end component ULTRASONICO;

signal UNIint,DECint,CENint,MILint: std_logic_vector (3 downto 0); --

U-D-C-M
signal SAL_400Hz: std_logic;
signal dato_listo : std_logic := '0';
signal distancia_cm : std_logic_vector(8 downto 0) := (others => '0');
signal distanciona : std_logic_vector(8 downto 0) := (others => '0');

begin
u1: INTESC_LIB_ULTRASONICO_RevC
generic map( FPGA_CLK => 50_000_000 ) -- Reloj de FPGA opera a 50MHz
PORT map( CLK => CLK,
ECO => ECO,
TRIGGER => TRIGGER,
DATO_LISTO => dato_listo,
DISTANCIA_CM => distancia_cm );

u2: entity work.SHIFT_ADD port map(

CONT => distanciona or "00000000000000", --a seal p/LD y srmd
(U1)
UNI => UNIint, -- Seales a los displays
DEC => DECint,
 CEN => CENint,
MIL => MILint );

u3: entity work.DISPLAY_result port map(

UNI => UNIint, -- Seales a los displays
DEC => DECint,
CEN => CENint,
MIL => MILint,
SAL_400Hz => SAL_400Hz, --A seal de reloj U4
DISPLAY => SEG, --A segmentos de display
AN => AN --A nodos del display
);

u4: entity work.DIV_CLK port map(

clk => clk,
SAL_400Hz => SAL_400Hz );
process(clk) begin
distanciona <= distancia_cm;
end process;
end Behavioral;

• Componente U1
----------------------------------------------------------------------
-- MEXILOGICS LIBRERA PARA MEDIR LA DISTANCIA EN CM CON EL SENSOR
ULTRASNICO HSR-04
----------------------------------------------------------------------

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

entity ULTRASONICO is
generic(
FPGA_CLK : INTEGER := 50_000_000 );

PORT(
CLK : IN STD_LOGIC;
-- Reloj del FPGA.
ECO : IN STD_LOGIC;
-- Eco del sensor ultrasnico.
TRIGGER : OUT STD_LOGIC;
-- Trigger del sensor ultrasnico.
DATO_LISTO : OUT STD_LOGIC; --
Bandera que indica cuando el valor de la distancia es correcto.
DISTANCIA_CM : OUT STD_LOGIC_VECTOR(8 DOWNTO 0) --
Valor de la distancia en centmetros-
);
end ULTRASONICO;

architecture Behavioral of ULTRASONICO is

CONSTANT VAL_1US : INTEGER :=
(FPGA_CLK/1_000_000); -- Constante con el nmero de periodos de CLK que
hay en un microsegundo. Se utiliza para el clculo de la distancia.
CONSTANT ESCALA_PERIODO_TRIGGER : INTEGER := (FPGA_CLK/16); --
Constante para generar el periodo del Trigger.
CONSTANT ESCALA_TRIGGER : INTEGER :=
(FPGA_CLK/100_000); -- Constante para generar el ciclo de trabajo
del Trigger.

COMPONENT DIVISION_ULTRASONICO_RevA
PORT(
CLK : IN std_logic;
INI : IN std_logic;
DIVIDENDO : IN std_logic_vector(31 downto 0);
DIVISOR : IN std_logic_vector(31 downto 0);
RESULTADO : OUT std_logic_vector(31 downto 0);
OK : OUT std_logic
);
END COMPONENT;

signal ok : std_logic;
-- Bandera que indica fin de divisin.
signal ini : std_logic;
-- Bit que inicia el proceso de divisin.
signal trigger_s : std_logic := '0';
-- Bit auxiliar para Trigger y tambin se utiliza como indicador para
mandar la distancia.
signal calcular : std_logic := '0';
-- Bit que indica cundo calcular la divisin.
signal dividendo : std_logic_vector(31
downto 0); -- Operadior dividendo.
signal divisor : std_logic_vector(31
downto 0); -- Operador divisor.
signal resultado : std_logic_vector(31
downto 0); -- Resultado de la divisin.
signal conta_trigger : integer range 0 to
escala_periodo_trigger := 0; -- Contador para la generacin del
Trigger.
signal conta_eco : integer := 0;
-- Contador para el clculo del tiempo de Eco.
signal escala_total : integer := 0;
-- Auxiliar que adquiere el nmero de periodos que se obtubieron con
Eco en '1' y as calcular la distancia.
signal tiempo_microsegundos : integer := 0;
-- Seal que guarda el tiempo en microsegundos.
signal edo_res : integer range 0 to 7 := 0;
-- Seal para la mquina de estados que calcula la distancia.
signal edo_eco : integer range 0 to 7 := 0;
-- Seal para la mquina de estados que calcula los periodos de CLK con
Eco en '1'.

begin

-- Instancia del componente que realiza la divisin.

Inst_DIVISION_ULTRASONICO_RevA: DIVISION_ULTRASONICO_RevA PORT MAP(
CLK, INI, DIVIDENDO, DIVISOR, RESULTADO, OK );

--PROCESO QUE GENERA SEAL DE TRIGGER---

process(CLK)
begin
if rising_edge(CLK) then
conta_trigger <= conta_trigger+1;
if conta_trigger = 0 then
trigger_s <= '1';
elsif conta_trigger = escala_trigger then
trigger_s <= '0';
elsif conta_trigger = escala_periodo_trigger then
conta_trigger <= 0;
end if;
end if;
end process;

TRIGGER <= trigger_s;

----------------------------------------

--PROCESO QUE OBTIENE ESCALA DE ECO---

process(CLK)
begin
if rising_edge(CLK) then
case(edo_eco) is
when 0 => if eco = '1' then -- Se espera a que Eco se
ponga a '1'.
edo_eco <= 1;
end if;
when 1 => if eco = '1' then -- Cuenta el nmero de
periodos cuando Eco se encuentra en '1'.
conta_eco <= conta_eco+1;
else
edo_eco <= 2;
end if;

when 2 => conta_eco <= 0; -- Se reinicia el contador

cuando Eco se hace '0' y
--se almacena el ltimo valor registrado en "conta_eco".
Se pone a '1' "calcular".
escala_total <= conta_eco;
calcular <= '1';
edo_eco <= 3;

when 3 => calcular <= '0'; -- Se desactuva el bit

"calcular" y se regresa al estado 0.
edo_eco <= 0;
when others => null;
end case;
end if;
end process;

--------------------------------------
--Proceso que divide y obtiene el resultado final--
process(CLK)
begin
if rising_edge(CLK) then -- Espera a que transcurra el primer trigger
para realizar el primer clculo y tenerlo listo en el segundo trigger.
case(edo_res) is
when 0 => if trigger_s = '1' then
edo_res <= 1;
end if;
when 1 => if calcular = '1' then -- Espera a que se le indique
cundo realizar la divisin para obtener los microsegundos que dur
"Eco".
dividendo <=
conv_std_logic_vector(escala_total,32);
divisor <=
conv_std_logic_vector(VAL_1US,32);
edo_Res <= 3;
end if;
when 3 => if ok = '1' then -- Espera a que finalice el proceso
de divisin.
edo_res <= 4;
ini <= '0';
else
ini <= '1';
end if;
when 4 => dividendo <= resultado; -- Se realiza la divisin
Tmicrosegundos/58 para obtener el valor de la distancia.
divisor <= conv_std_logic_vector(58,32);
edo_res <= 5;
when 5 => -- Espera a que finalice el proceso de divisin.
if ok = '1' then
edo_res <= 6;
ini <= '0';
else
ini <= '1';
end if;
when 6 => -- Espera a que Trigger se ponga a '1' y se mande la
distancia por el puerto "DISTANCIA_CM". Se activa la bandera
"DATO_LISTO".
if trigger_s = '1' then
DATO_LISTO <= '1';
DISTANCIA_CM <= resultado(8
downto 0);
edo_res <= 7;
end if;
when 7 => -- Se desactiva la bandera "DATO_LISTO".
DATO_LISTO <= '0';
edo_res <= 1;
when others => null;
end case;
end if;
end process;
end Behavioral;
----------------------------------------------------------------------
-- MEXILOGICS: Cdigo que realiza divisiones mediante sumatorias, el
algoritmo cuenta el nmero de iteraciones que fueron necesarias para
que el divisor
--sea igual o mayor al dividendo.
----------------------------------------------------------------------
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_unsigned.ALL;

entity DIVISION_ULTRASONICO_RevA is
PORT(
CLK : IN STD_LOGIC; --
Reloj FPGA.
INI : IN STD_LOGIC; --
Bit que inicia proceso de divisin.
DIVIDENDO : IN STD_LOGIC_VECTOR(31 DOWNTO 0); --
Operador dividendo.
DIVISOR : IN STD_LOGIC_VECTOR(31 DOWNTO 0); --
Operador divisor.
RESULTADO : OUT STD_LOGIC_VECTOR(31 DOWNTO 0); --
Resultado de la divisin.
OK : OUT STD_LOGIC
-- Bit que indica fin de divisin.
);
end DIVISION_ULTRASONICO;

architecture Behavioral of DIVISION_ULTRASONICO is

signal iteraciones : std_logic_vector(31 downto 0) := (others => '0');
-- Seal que cuenta el nmero de iteraciones.
signal dividendo_s : std_logic_vector(31 downto 0) := (others => '0');
-- Seal auxiliar para el dividendo.
signal divisor_s : std_logic_vector(31 downto 0) := (others => '0');
-- Seal auxiliar para el divisor.
signal edo : integer range 0 to 3 := 0;
-- Seal para la mquina de estados.
begin
PROCESS(CLK)
begin
if rising_edge(CLK) then
case(edo) is
when 0 => if ini = '1' then -- Espera a que el bit "ini" se
ponga a '1'.
dividendo_s <= DIVIDENDO;
divisor_s <= DIVISOR;
iteraciones <= (others => '0');
edo <= 1;
end if;
when 1 => -- Proceso de aproximacin para calcular el nmero de
iteraciones.
if divisor_s <= dividendo_s then -- Si es menor o
igual el proceso contina.
divisor_s <= divisor_s + DIVISOR;
iteraciones <= iteraciones+1;
 edo <= 1;
else -- Si la condicin deja de cumplirse
entonces se manda el resultado como el nmero de iteraciones. Se activa
la bandera "ok".
resultado <= iteraciones;
ok <= '1';
edo <= 2;
end if;
when 2 => -- Se desactiva la bandera "ok".
ok <= '0';
edo <= 3;
when 3 => -- Estado dummy.
edo <= 0;
when others => null;
end case;
end if;
end process;
end Behavioral;

• Componente U2
----------------------------------------------------------------------
--MEXILOGICS
--Convertidor SHIFt and add 3
--------------------------------------------------------
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_arith.ALL;
use IEEE.STD_LOGIC_unsigned.ALL;
--------------------------------------------------------
--Declaracin de la entidad
entity SHIFT_ADD is
port(
CONT: in std_logic_vector (13 downto 0):=(others=>'0'); --8
bits
UNI,DEC,CEN,MIL: out std_logic_vector (3 downto 0)
);
end SHIFT_ADD;

--------------------------------------------------------
--Declaracin de la arquitectura
architecture Behavioral of SHIFT_ADD is
--DECLARACIN DE SEALES DE ASIGNACIN DE U-D-C
signal P:std_logic_vector(15 downto 0); --Asigna UNI,DEC,CEN

-----------CONVERTIR DE BIN A BCD------------------

-- Este proceso contiene un algoritmo recorre y suma 3 para
-- convertir un nmero binario abcd, que se manda a los displays.
-- El algoritmo consiste en desplazar (shift) el vector inicial
-- (en binario) el nmero de veces segn sea el nmero de bits,
-- y cuando alguno de los bloques de 4 bits (U-D-C-UM, que es el
-- nmero de bits necesarios para que cuente de 0 a 9 por cifra)
-- sea igual o mayor a 5 (por eso el >4) se le debe sumar 3
-- a ese bloque, despus se continua desplazando hasta que otro
-- (o el mismo) bloque cumpla con esa condicin y se le sumen 3.
-- Inicialmente se rota 3 veces porque es el nmero mnimo de bits
-- que debe tener para que sea igual o mayor a 5.
-- Finalmente se asigna a otro vector, el vector ya convertido,
-- que cuenta con 3 bloques para las 3 cifras de 4 bits cada una.
begin
PROCESS(CONT)
VARIABLE UM_C_D_U:STD_LOGIC_VECTOR(29 DOWNTO 0);
--30 bits para separar las U.Millar-Centenas-Decenas-Unidades
BEGIN

--ciclo de inicialización
FOR I IN 0 TO 29 LOOP --
UM_C_D_U(I):='0'; -- se inicializa con 0
END LOOP;
UM_C_D_U(13 DOWNTO 0):=CONT(13 downto 0); --contador de 14 bits
-- UM_C_D_U(17 DOWNTO 4):=CONT(13 downto 0); --contador de 14 bits,
carga desde
-- el shift4
--ciclo de asignación UM-C-D-U
FOR I IN 0 TO 13 LOOP
-- FOR I IN 0 TO 9 LOOP -- si carga desde shift4 solo hace 10 veces el
ciclo shift add
-- los siguientes condicionantes comparan (>=5) y suman 3
IF UM_C_D_U(17 DOWNTO 14) > 4 THEN -- U
UM_C_D_U(17 DOWNTO 14):= UM_C_D_U(17 DOWNTO 14)+3;
END IF;

IF UM_C_D_U(21 DOWNTO 18) > 4 THEN -- D

UM_C_D_U(21 DOWNTO 18):= UM_C_D_U(21 DOWNTO 18)+3;
END IF;

IF UM_C_D_U(25 DOWNTO 22) > 4 THEN -- C

UM_C_D_U(25 DOWNTO 22):= UM_C_D_U(25 DOWNTO 22)+3;
END IF;

IF UM_C_D_U(29 DOWNTO 26) > 4 THEN -- UM

UM_C_D_U(29 DOWNTO 26):= UM_C_D_U(29 DOWNTO 26)+3;
END IF;

-- realiza el corrimiento
UM_C_D_U(29 DOWNTO 1):= UM_C_D_U(28 DOWNTO 0);
END LOOP;
P<=UM_C_D_U(29 DOWNTO 14); -- guarda en P y en seguida se separan UM-
C-D-U
END PROCESS;

--UNIDADES
UNI<=P(3 DOWNTO 0);

--DECENAS
DEC<=P(7 DOWNTO 4);
--CENTENAS
CEN<=P(11 DOWNTO 8);

--MILLARES
MIL<=P(15 DOWNTO 12);

end Behavioral;

• Componente U3

----------------------------------------------------------------------
-- MEXILOGICS: MOSTRAR VALOR EN DISPLAYS
----------------------------------------------------------------------
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_arith.ALL;
use IEEE.STD_LOGIC_unsigned.ALL;

entity Display_result is
Port(
UNI,DEC,CEN,MIL: in std_logic_vector (3 downto 0); --U-D-C-M
SAL_400Hz : in std_logic; --Reloj de 400Hz
DISPLAY : out STD_LOGIC_VECTOR(7 downto 0); --segmentos del
display
AN : out std_logic_vector (7 downto 0) --nodos del display
);
end Display_result;

architecture Behavioral of Display_result is

-- Declaracin de seales de la multiplexacin y asignacin de U-D-C al
disp
signal SEL: std_logic_vector (1 downto 0):="00"; -- selector de
barrido
signal D: std_logic_vector (3 downto 0); -- almacena los valores del
disp
begin
PROCESS(SAL_400Hz, sel, UNI, DEC,CEN,MIL)
BEGIN
IF SAL_400Hz'EVENT and SAL_400Hz='1' THEN SEL <= SEL + '1';
CASE(SEL) IS
when "00" => AN <="11110111"; D <= UNI; -- UNIDADES
when "01" => AN <="11111011"; D <= DEC; -- DECENAS
when "10" => AN <="11111101"; D <= CEN; -- CENTENAS
when "11" => AN <="11111110"; D<= MIL; --MILLARES
when others =>AN <="11111111"; D <= x"0"; -- signo
END CASE;
end if;
END PROCESS; -- fin del proceso Multiplexor

process(D) begin
case(D) is

WHEN x"0" => DISPLAY <= "00000011"; --0

WHEN x"1" => DISPLAY <= "10011111"; --1
WHEN x"2" => DISPLAY <= "00100101"; --2
WHEN x"3" => DISPLAY <= "00001101"; --3
WHEN x"4" => DISPLAY <= "10011001"; --4
WHEN x"5" => DISPLAY <= "01001001"; --5
WHEN x"6" => DISPLAY <= "01000001"; --6
WHEN x"7" => DISPLAY <= "00011111"; --7
WHEN x"8" => DISPLAY <= "00000001"; --8
WHEN x"9" => DISPLAY <= "00001001"; --9
WHEN x"F" => DISPLAY <= "11111101"; --signo
WHEN OTHERS => DISPLAY <= "11111111"; --apagado
end case;
end process;
end Behavioral;

• Componente U4
----------------------------------------------------------------------
--MEXILOGICS
--DIVISOR DE 2.5ms
----------------------------------------------------------------------
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_unsigned.ALL;
use IEEE.STD_LOGIC_arith.ALL;

--Declaracin de entidad
entity DIV_CLK is
port(
clk: in std_logic; --reloj de 50MHz
SAL_400Hz: inout std_logic --salida 2.5ms
);
end DIV_CLK;

----------------------------------------------------------------------
--Declaracin de la arquitectura
architecture Behavioral of DIV_CLK is
--Declaracin de seales de divisores
signal conta_1250us : integer range 1 to 62_500 := 1; --pulso de 1250
us@400Hz (0.25ms)

begin
--Divisor 2.5ms = 400Hz
--Divisor nodos
process(clk) begin
if rising_edge(clk) then
if(conta_1250us = 62_500) then --cuenta 1250us (50MHz = 62500)
SAL_400Hz <= not(SAL_400Hz); --Genera un barrido de 2.5ms
conta_1250us <= 1;

else conta_1250us <= conta_1250us + 1;

end if;
end if;
end process; --Fin del proceso divisor de nodos
----------------------------------------------------------------------
--fin de la arquitectura
end Behavioral;

Y el archivo de restricciones de usuario (.ucf) es:

//MEXILOGICS
//Archivo de reestricciones de usuario (UCF)//

##Clock signal
Net "clk" LOC = E7 | IOSTANDARD=LVCMOS33;

## 7 segment display
Net "seg<0>" LOC = N15 | IOSTANDARD = LVCMOS33; //PD
Net "seg<1>" LOC = L14 | IOSTANDARD = LVCMOS33; //G
Net "seg<2>" LOC = K15 | IOSTANDARD = LVCMOS33; //F
Net "seg<3>" LOC = P14 | IOSTANDARD = LVCMOS33; //E
Net "seg<4>" LOC = P15 | IOSTANDARD = LVCMOS33; //D
Net "seg<5>" LOC = M15 | IOSTANDARD = LVCMOS33; //C
Net "seg<6>" LOC = L15 | IOSTANDARD = LVCMOS33; //B
Net "seg<7>" LOC = K13 | IOSTANDARD = LVCMOS33; //A

##ANODOS DE LOS DISPLAYS

Net "an<0>" LOC = G12 | IOSTANDARD = LVCMOS33;
Net "an<1>" LOC = F13 | IOSTANDARD = LVCMOS33;
Net "an<2>" LOC = H12 | IOSTANDARD = LVCMOS33;
Net "an<3>" LOC = G13 | IOSTANDARD = LVCMOS33;
Net "an<4>" LOC = H13 | IOSTANDARD = LVCMOS33;
Net "an<5>" LOC = K11 | IOSTANDARD = LVCMOS33;
Net "an<6>" LOC = J13 | IOSTANDARD = LVCMOS33;
Net "an<7>" LOC = K12 | IOSTANDARD = LVCMOS33;

##ECHO Y TRIGGER
Net "ECO" LOC = D6 | IOSTANDARD = LVCMOS33;
Net "TRIGGER" LOC = C4 | IOSTANDARD = LVCMOS33;

Y para las fotos del funcionamiento del circuito decidimos tomarlas en 3 mediciones
distintas: La primera a distancia cercana (17 [cm], ver figura 3), la segunda a distancia de 80
[cm] (ver figuras 4 y 5) y la última a 150 [cm] de distancia (ver figuras 6 y 7).
 Figura 3.- Sensor
ultrasónico HC-SR04
midiendo la distancia
que existe entre su
receptor y el objeto
(cuaderno). Medición de
17 [cm].

Figura 4.- Medición del flexómetro de 80 [cm]

Figura 5.- Lectura del sensor Ultrasónico para la distancia medida en la figura 4
 Figura 6.- Medición del flexómetro de 150 [cm]

Figura 7.- Lectura del sensor Ultrasónico para la distancia medida en la figura 6

Conclusiones
Álvarez Gómez Julio Cesar:
Práctica: El reto de esta ocasión consiste en un medidor de distancia con muestra de
resultado en centímetros para una pantalla LCD de 7 segmentos. Para lograr una
comunicación entre el sensor ultrasónico y la tarjeta de desarrollo se ha consultado con
librerías del fabricante (INTESC) para acto seguido procesar e interpretar cada bit de
información; cuya operación viene descrita por el método ‘shift and add 3’ y que convierte
de binario a decimal nuestra medición para después hacer la muestra en la pantalla.
Cada etapa viene escrita en código y completa un programa que realiza toda la tarea.
Finalmente, se le indica a la tarjeta el ritmo de muestreo para el proceso apoyándonos del
reloj de frecuencias incluido por el fabricante. El resultado es un medidor de distancias que
detecta automáticamente el objeto más próximo al sensor de entrada de datos y nos dice
cuántos centímetros hay hacia ella, además de actualizar en tiempo real la medida.
Lectura: La confusión entre una postura u otra para el relato viene dada por el hecho de que
uno hacia su trabajo con un ritmo muy diferente a su contraparte. Dice San Pedro que para
ellos es más valioso quien logró hacer rezar a más personas que quien las mantuvo sin
motivación o dormidas; bien pues, esto puede ser aplicable en la actitud y entrega para la que
un individuo emplea sus energías, pues al parecer ha hecho más con sus recursos quien más
pasión ha entregado a sus tareas en la vida.
Galván Escobar Adrián Raúl:
Práctica: Con respecto al punto que entregamos (Medidor digital de distancia mediante el
uso de un sensor US) concluyo que se trató de un sistema de control de lazo abierto, pues de
la entrada de nuestros datos (los tiempos que registraba el eco de nuestro sensor) los retenía
para, mediante los algoritmos del código presentado en el desarrollo, dar como respuesta una
interpretación física de esta señal, es decir, la distancia de nuestro módulo al objeto que
reflejo las ondas Ultrasónicas emitidas por el sensor. Por otro lado, concluyo que fue de lazo
abierto por que la salida (la distancia que medía en determinado instante) no tenía efecto
sobre los otros procesos de esta aplicación, es decir, esta salida no se realimenta para
compararla con la entrada. Gracias a esta práctica, comprendí de una mejor manera el uso de
los contadores, registros de corrimiento y nuevamente puse en práctica distintos circuitos
programados a lo largo del semestre, como lo es el convertidor de binario a decimal
(mediante el algoritmo shift and add 3) y su muestreo en los displays de 7 segmentos, así
como aprendí de los algoritmos y el modo de trabajo de un sensor Ultrasónico para la
implementación del medidor de distancia abarcado en esta práctica.
Lectura: En mi opinión, el mensaje del texto es que no importan los medios, al final lo que
importa es como se refleje en los resultados. En la lectura dan una comparación de 2 personas
del mismo nombre, una de ellas sacerdote (por lo que estaba en contacto constante con la
palabra del señor) mientras que el otro es taxista (y por lo que comenta el sacerdote, un taxista
imprudente y de mucho cuidado a la hora del volante). El evaluador San Pedro, determino
sus recompensas a los llegados al paraíso con base en la cantidad de gente que rezo oraciones
en consecuencia de las acciones de ellos. Por un lado, si bien el sacerdote ejercía la actividad
y tenía la preparación para este rubro a medir, sus resultados fueron menores a los del taxista,
que sin una preparación o cargo como la del sacerdote, con base en sus acciones (su forma
de conducir un carro) puso a mucha más gente despierta y rezando constantemente. Como
enseñanza o un punto a pensar de esta lectura retengo que todos tenemos la capacidad de
realizar las tareas, acciones, pero dependerá de la experiencia y la manera en que llevamos a
cabo estas acciones los resultados que obtendremos. Por otro lado, pensé en la frase “El fin
justifica los medios” cuando me enteré de que el taxista era más eficaz a la hora de poner a
rezar a la gente por la emoción/adrenalina que ocasionaba con sus hábitos de manejo,
mientras que el sacerdote, aunque de cátedra o predique la palabra del señor, no evoca el
mismo sentimiento en los creyentes.
Mata Prieto Varush:
Práctica: Al tener un sistema la respuesta de este puede variar mucho del resultado que
nosotros esperamos y más en sistemas de la vida real ya que las condiciones casi nunca van
a ser perfectas para nuestro sistema, por lo que es fundamental aplicar sistemas de control
para acercar el comportamiento del sistema en uno que nosotros necesitemos. Para lograr
esto son necesarios los sensores, ya sean analógicos o digitales debido a que estos nos darán
valores que se usarán con el fin de corregir trayectorias, velocidades, etc. del sistema. Gracias
a esta práctica aprendí más acerca del control digital lo que nos permitirá afrontar gran parte
de problemas conociendo los modelos del sistema que se planea controlar.
Lectura: La lectura nos habla de los métodos y resultados, aunque se realice el método más
antiguo eso no te garantiza que vas a lograr tu objetivo por lo que siempre se debe afrontar
los problemas con la mente abierta y la capacidad de cambiar de estrategia cuando no
funcione el método actual.
Varela Alpízar Benjamín:
Práctica: Gracias a esta práctica adquirimos conocimientos y habilidades fundamentales en
el diseño e implementación de sistemas de control utilizando circuitos secuenciales.
También obtuvimos la oportunidad de aplicar y poner a prueba los conocimientos teóricos
adquiridos sobre circuitos secuenciales, así como de identificar posibles mejoras.
Los conocimientos adquiridos en el uso de herramientas de diseño, lenguajes de descripción
de hardware y la aplicación de conceptos de lógica combinacional y secuencial serán de suma
importancia para desarrollar soluciones más complejas.
Lectura: En la vida, lo verdaderamente importante son los resultados, mas que las acciones.
Los logros y acciones concretas son los que verdaderamente nos definen y nos llevan a
obtener reconocimiento y recompensas".

Referencias bibliográficas
[1] INTESC. (s.f.). Librería sensor ultrasónico HC-SR04. https://intesc.mx/libreria-sensor-
ultrasonico-hc-sr04/