PROYECTO FINAL
Instituto Politécnico Nacional
Escuela Superior de Ingeniería Mecánica y Eléctrica Unidad Zacatenco
Ingeniería en Comunicaciones y Electrónica
Circuitos Digitales
PROYECTO FINAL
Grupo: 5CV11
Nombre del alumno: Sanchez Hernández Abel Josue
Profesor: Ing. Felipe Calzada Serafín
Fecha de Entrega: 15/12/2020
Introducción
En el presente proyecto se desarrolló una araña mecanoide utilizando una estructura armada con piezas tipo
Meccano y controlada mediante una FPGA Cyclone IV. El objetivo principal fue aplicar los conocimientos adquiridos
en clase sobre sistemas digitales, lógica programable y control, integrándolos con un sistema mecánico real.
Objetivo
Objetivo general:
Diseñar e implementar un sistema electromecánico basado en una FPGA Cyclone IV capaz de controlar el
movimiento de una araña mecanoide.
Objetivos específicos:
- Aplicar conceptos de lógica digital y programación en FPGA.
- Integrar la FPGA con motores y sensores.
- Verificar el funcionamiento del sistema mediante pruebas físicas.
DESARROLLO
Para la construcción de la araña se utilizó un sistema mecánico tipo Meccano, lo cual facilitó el armado de
la estructura y la modificación del diseño durante el desarrollo del proyecto. La araña cuenta con varias patas
articuladas, cada una accionada por motores, los cuales son controlados de manera coordinada para simular
el desplazamiento del robot.
Durante la etapa de pruebas fue necesario desarmar parcialmente la RobotSpider con el fin de verificar el
correcto funcionamiento de los motores. En este proceso se detectó que el motor izquierdo presentaba
fallas mecánicas, las cuales afectaban el movimiento general del sistema. Al realizar el desensamble se
observó que dicho motor contaba con cables mordidos, lo que se atribuye a un mal ensamblaje previo.
Además, el motor izquierdo presentaba un desbalanceo en el sistema de giro, provocando que el
movimiento de las demás patas no fuera uniforme.
Derivado de estos problemas mecánicos, sumados a la falta de corriente adecuada en la pila y al peso
extra generado por la FPGA Cyclone IV y los demás componentes electrónicos, la araña no podía
desplazarse durante largos periodos de tiempo sin presentar fallas o pérdida de potencia.
El control del sistema se realizó mediante una FPGA Cyclone IV, programada en lenguaje VHDL utilizando
el entorno Quartus. En el código principal se implementó una máquina de estados, la cual define el
comportamiento del robot según la información recibida del sensor ultrasónico.
Para la detección de obstáculos se utilizó un sensor ultrasónico, haciendo uso de su librería
correspondiente. Este sensor funciona emitiendo un pulso ultrasónico a través de la señal TRIGGER y
midiendo el tiempo que tarda el eco en regresar mediante la señal ECHO. Con base en este tiempo, la librería
calcula la distancia al objeto en centímetros, información que es enviada a la lógica principal de la FPGA.
La máquina de estados cuenta con tres estados principales:
• Avanzar: ambos motores giran hacia adelante mientras el sensor no detecta obstáculos cercanos.
• Retroceder: al detectar un obstáculo a una distancia menor a 30 cm, el robot retrocede durante un
tiempo definido.
• Girar: posteriormente, el robot realiza un giro utilizando solo un motor para cambiar de dirección y
evitar el obstáculo.
El control de los motores se realiza mediante un puente H, el cual permite invertir el sentido de giro de los
motores activando las señales de avance o retroceso correspondientes. Asimismo, se incorporaron LEDs
RGB para indicar el estado del robot: color azul durante el avance normal, rojo al detectar un obstáculo y
amarillo parpadeante durante el giro.
Este desarrollo permitió comprender la interacción entre el software descrito en VHDL, el hardware digital de
la FPGA y los elementos mecánicos del sistema.
Codigo VHDL
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
entity robot_top is
port(
CLK : in std_logic;
-- SENSOR ULTRASONICO
ECHO : in std_logic;
TRIGGER : out std_logic;
-- MOTORES (PUENTE H)
MOT_DER_ADELANTE : out std_logic;
MOT_DER_ATRAS : out std_logic;
MOT_IZQ_ADELANTE : out std_logic;
MOT_IZQ_ATRAS : out std_logic;
-- LED RGB
LED_R : out std_logic;
LED_G : out std_logic;
LED_B : out std_logic
);
end robot_top;
architecture Behavioral of robot_top is
-- Instancia del sensor ultrasónico
COMPONENT INTESC_LIB_ULTRASONICO_RevC
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;
signal dato_listo_s : std_logic;
signal distancia_s : std_logic_vector(8 downto 0);
signal estado : integer := 0;
signal contador : integer := 0;
constant TIEMPO_RETROCEDER : integer := 250_000_000; -- 5 segundos @ 50 MHz
constant TIEMPO_GIRAR : integer := 150_000_000; -- 3 segundos @ 50 MHz
signal parpadeo : std_logic := '0';
signal contador_parp : integer := 0;
constant PARPADEO_MAX : integer := 25_000_000; -- 0.5 seg
begin
-- INSTANCIA DEL SENSOR
U1: INTESC_LIB_ULTRASONICO_RevC
port map(
CLK => CLK,
ECO => ECHO,
TRIGGER => TRIGGER,
DATO_LISTO => dato_listo_s,
DISTANCIA_CM => distancia_s
);
---------------------------------------------------
-- MÁQUINA DE ESTADOS PRINCIPAL
---------------------------------------------------
process(CLK)
begin
if rising_edge(CLK) then
---------------------------------------------------
-- PARPADEO PARA EL GIRO (color amarillo)
---------------------------------------------------
contador_parp <= contador_parp + 1;
if contador_parp = PARPADEO_MAX then
contador_parp <= 0;
parpadeo <= NOT parpadeo;
end if;
---------------------------------------------------
-- ESTADOS
---------------------------------------------------
case estado is
---------------------------------------------------
-- ESTADO 0: AVANZANDO
---------------------------------------------------
when 0 =>
-- Motores hacia adelante
MOT_DER_ADELANTE <= '1';
MOT_DER_ATRAS <= '0';
MOT_IZQ_ADELANTE <= '1';
MOT_IZQ_ATRAS <= '0';
-- LED azul (sin obstáculo)
LED_R <= '0';
LED_G <= '0';
LED_B <= '1';
if dato_listo_s = '1' then
if distancia_s < 30 then -- obstáculo detectado
estado <= 1;
contador <= 0;
end if;
end if;
---------------------------------------------------
-- ESTADO 1: RETROCEDIENDO 5s
---------------------------------------------------
when 1 =>
MOT_DER_ADELANTE <= '0';
MOT_DER_ATRAS <= '1';
MOT_IZQ_ADELANTE <= '0';
MOT_IZQ_ATRAS <= '1';
-- LED rojo (obstáculo)
LED_R <= '1';
LED_G <= '0';
LED_B <= '0';
contador <= contador + 1;
if contador >= TIEMPO_RETROCEDER then
contador <= 0;
estado <= 2;
end if;
---------------------------------------------------
-- ESTADO 2: GIRANDO
---------------------------------------------------
when 2 =>
-- Solo motor derecho hacia adelante
MOT_DER_ADELANTE <= '1';
MOT_DER_ATRAS <= '0';
MOT_IZQ_ADELANTE <= '0';
MOT_IZQ_ATRAS <= '0';
-- LED amarillo parpadeando
LED_R <= parpadeo;
LED_G <= parpadeo;
LED_B <= '0';
contador <= contador + 1;
if contador >= TIEMPO_GIRAR then
contador <= 0;
estado <= 0; -- volver a avanzar
end if;
when others =>
estado <= 0;
end case;
end if;
end process;
end Behavioral;
Asignación de pines (referencial para Cyclone IV EP4CE6E22C8)
Figura 1: Asignación de pines
Figura 2: Implementación del sensor y leds RGB.
Figura 3: Implementación del puente H.
Resultados
• Durante la realización del proyecto se logró implementar el control básico de la araña mecanoide utilizando la
FPGA Cyclone IV, integrando correctamente los motores, el sensor ultrasónico y los indicadores visuales
mediante LEDs RGB. La lógica programada permitió que el sistema respondiera a la detección de obstáculos,
ejecutando acciones de avance, retroceso y giro de manera automática.
• En las pruebas iniciales se detectaron fallas mecánicas en el motor izquierdo, lo que obligó al desarme parcial
de la estructura. Gracias a esta revisión se identificaron cables dañados por un mal ensamblaje previo y un
desbalanceo en el sistema de giro, lo cual afectaba la coordinación de las patas. Estas observaciones permitieron
comprender la importancia del correcto armado mecánico en sistemas electromecánicos.
• El sensor ultrasónico funcionó de manera adecuada, proporcionando lecturas de distancia confiables que fueron
utilizadas por la máquina de estados implementada en la FPGA. Los LEDs RGB permitieron visualizar
claramente el estado del robot durante su operación, facilitando la depuración y comprensión del
funcionamiento del sistema.
• Sin embargo, se observó que la duración del movimiento continuo era limitada, debido principalmente a la
falta de corriente suficiente en la pila y al peso adicional de la FPGA y los componentes electrónicos. A pesar
de estas limitaciones, el sistema cumplió con su objetivo principal de demostrar el control de un robot mediante
lógica programable.
• En general, los resultados obtenidos fueron satisfactorios, ya que se logró integrar hardware digital, electrónica
de potencia y mecánica en un sistema funcional, identificando además áreas de mejora para futuras versiones
del proyecto.
Conclusiones
El proyecto de la araña mecanoide permitió aplicar de manera práctica los conocimientos sobre FPGA y sistemas
digitales, demostrando que la Cyclone IV es una herramienta versátil para el control de sistemas electromecánicos.
Se concluye que el uso de una FPGA ofrece gran flexibilidad, ya que la lógica puede modificarse sin necesidad de
cambiar el hardware. Además, el proyecto ayudó a desarrollar habilidades de análisis, trabajo en equipo y resolución de
problemas reales, que son fundamentales en la formación de un ingeniero.
Finalmente, este trabajo sienta las bases para futuras mejoras, como la implementación de sensores, control automático
más avanzado o comunicación con otros dispositivos.
Referencias
• Altera (Intel). Cyclone IV Device Handbook, Volume 1. Intel Corporation.
• Quartus Prime User Guide. Intel FPGA Documentation.
• Mano, M. Morris. Diseño Digital: Principios y Prácticas. Pearson Educación, 2018.
• HDLBits. (2023). VHDL Sequential Logic Exercises.
• Documentación técnica de la tarjeta Cyclone IV EP4CE6E22C8.