Caso práctico: Monitorización de temperatura y presión

Prototipo de Monitorización de temperatura y presión (Maker Style)

Nivel: Medio. Implementar un circuito de seguridad industrial que active una alarma solo cuando los sensores de temperatura y presión excedan los límites de seguridad críticos.

Objetivo y caso de uso

En esta sesión, construirás un circuito lógico condicional utilizando un comparador LM393 para digitalizar señales de sensores analógicos y una puerta AND 74HC08 para procesar la lógica de seguridad.

  • Seguridad en calderas industriales: Previene fallos catastróficos detectando cuando una caldera está sobrecalentada y sobrepresurizada simultáneamente.
  • Sistemas hidráulicos: Monitoriza estados de fluidos para prevenir daños en bombas o roturas de tuberías durante operaciones de alto estrés.
  • Monitorización de reactores químicos: Asegura que las condiciones de reacción permanezcan dentro de zonas seguras, activando la refrigeración de emergencia solo cuando múltiples variables críticas se disparan.

Resultado esperado:
* Estado seguro: El LED permanece APAGADO si solo una o ninguna variable excede el límite.
* Estado crítico: El LED rojo se ENCIENDE (Lógica Alta) solo cuando Temp > Límite Y Presión > Límite.
* Nivel lógico: La salida del 74HC08 cambia de ~0V a ~5V.
* Público objetivo: Estudiantes de ingeniería y aficionados familiarizados con amplificadores operacionales/comparadores y lógica digital básica.

Materiales

  • V1: Fuente de alimentación de 5 V DC
  • U1: 74HC08, función: Puerta AND cuádruple de 2 entradas
  • U2: LM393, función: Comparador diferencial dual
  • RT1: Termistor NTC de 10 kΩ, función: Sensor de temperatura
  • R1: Resistencia de 10 kΩ, función: Parte inferior del divisor de tensión para el NTC
  • RP1: Potenciómetro lineal de 10 kΩ, función: Simulador de sensor de presión
  • RP2: Potenciómetro de 10 kΩ, función: Umbral de referencia de temperatura (V_REF_T)
  • RP3: Potenciómetro de 10 kΩ, función: Umbral de referencia de presión (V_REF_P)
  • R2: Resistencia de 4.7 kΩ, función: Pull-up para la salida del Comparador A (requerido para LM393)
  • R3: Resistencia de 4.7 kΩ, función: Pull-up para la salida del Comparador B (requerido para LM393)
  • R4: Resistencia de 330 Ω, función: Limitación de corriente del LED
  • D1: LED rojo, función: Indicador de alerta crítica

Pin-out del CI utilizado

Chip seleccionado: 74HC08 (Puerta AND cuádruple de 2 entradas)

Pin Nombre Función lógica Conexión en este caso
1 1A Entrada A Conectado a la salida del comparador de temperatura
2 1B Entrada B Conectado a la salida del comparador de presión
3 1Y Salida Conectado al LED (vía R4)
7 GND Tierra Conectado al raíl de alimentación de 0V
14 VCC Alimentación Conectado al raíl de alimentación de +5V

Nota: El comparador LM393 también se utiliza, pero la decisión lógica ocurre en el 74HC08.

Guía de conexionado

Construye el circuito utilizando las siguientes conexiones de nodos:

  • Raíl de alimentación: Conecta el terminal positivo de V1 al nodo VCC y el terminal negativo al nodo 0 (GND). Conecta el pin 14 de U1 y el pin 8 de U2 a VCC. Conecta el pin 7 de U1 y el pin 4 de U2 a 0.
  • Entrada del sensor de temperatura (V_TEMP): Conecta RT1 entre VCC y V_TEMP. Conecta R1 entre V_TEMP y 0. (A medida que sube la Temp, la resistencia baja, V_TEMP sube).
  • Entrada del sensor de presión (V_PRESS): Conecta el cursor de RP1 al nodo V_PRESS. Conecta las patas exteriores de RP1 a VCC y 0.
  • Umbrales de referencia: Conecta el cursor de RP2 al nodo V_REF_T (Límite Temp). Conecta el cursor de RP3 al nodo V_REF_P (Límite Presión).
  • Etapa de comparador (Digitalización):
    • Conecta V_TEMP al pin 3 de U2 (Entrada no inversora A).
    • Conecta V_REF_T al pin 2 de U2 (Entrada inversora A).
    • Conecta V_PRESS al pin 5 de U2 (Entrada no inversora B).
    • Conecta V_REF_P al pin 6 de U2 (Entrada inversora B).
  • Salidas del comparador (LOGIC_T y LOGIC_P):
    • Conecta el pin 1 de U2 (Salida A) al nodo LOGIC_T. Conecta la resistencia pull-up R2 entre LOGIC_T y VCC.
    • Conecta el pin 7 de U2 (Salida B) al nodo LOGIC_P. Conecta la resistencia pull-up R3 entre LOGIC_P y VCC.
  • Puerta lógica:
    • Conecta LOGIC_T al pin 1 de U1 (Entrada 1A).
    • Conecta LOGIC_P al pin 2 de U1 (Entrada 1B).
    • Conecta el pin 3 de U1 (Salida 1Y) al nodo ALERT.
  • Indicador: Conecta R4 entre ALERT y el ánodo de D1. Conecta el cátodo de D1 a 0.

Diagrama de bloques conceptual

Conceptual block diagram — 74HC08 AND gate

Esquemático

[ ANALOG INPUTS ]                  [ COMPARATORS ]                  [ LOGIC GATE ]               [ OUTPUT ]

[ Temp Sensor (RT1/R1) ] --(V_TEMP)---->+------------------+
                                        | U2: Comparator A |
                                        | (LM393)          |--(LOGIC_T)-->+
[ Temp Ref Pot (RP2)   ] --(V_REF_T)--->| w/ Pull-up R2    |              |
                                        +------------------+              |
                                                                          v
                                                                   +----------------+
                                                                   | U1: AND Gate   |
                                                                   | (74HC08)       |--(ALERT)--> [ Resistor R4 ] --> [ LED D1 ] --> GND
                                                                   +----------------+
                                                                          ^
                                        +------------------+              |
[ Press Sensor (RP1)   ] --(V_PRESS)--->| U2: Comparator B |              |
                                        | (LM393)          |--(LOGIC_P)-->+
[ Press Ref Pot (RP3)  ] --(V_REF_P)--->| w/ Pull-up R3    |
                                        +------------------+
Esquema Eléctrico

Diagrama eléctrico

Diagrama eléctrico para monitorización de temperatura y presión
Generado desde la netlist SPICE validada del caso.

🔒 Este diagrama eléctrico es premium. Con el pase de 7 días o la suscripción mensual podrás desbloquear el material didáctico completo y el pack PDF listo para imprimir.🔓 Ver planes de acceso premium

Tabla de verdad

Esta tabla representa los estados lógicos en las entradas del 74HC08 (después de la etapa de comparador) y la salida final.

Sensor: Temperatura Sensor: Presión Entrada 1A (Alerta Temp) Entrada 1B (Alerta Pres) Salida 1Y (Alarma Sistema) Estado LED
Bajo (< Ref) Bajo (< Ref) 0 0 0 APAGADO
Bajo (< Ref) Alto (> Ref) 0 1 0 APAGADO
Alto (> Ref) Bajo (< Ref) 1 0 0 APAGADO
Alto (> Ref) Alto (> Ref) 1 1 1 ENCENDIDO

Mediciones y pruebas

  1. Calibrar umbrales: Usa un voltímetro para ajustar V_REF_T (en el cursor de RP2) a 3.0V y V_REF_P (en el cursor de RP3) a 3.0V.
  2. Prueba de lógica de temperatura: Calienta RT1 (o simúlalo cortocircuitando R1 ligeramente) hasta que V_TEMP > 3.0V. Mide LOGIC_T; debería ser Alto (~5V). Verifica que el LED esté APAGADO (ya que la Presión es Baja).
  3. Prueba de lógica de presión: Gira RP1 hasta que V_PRESS > 3.0V. Mide LOGIC_P; debería ser Alto (~5V).
  4. Prueba de alerta del sistema: Crea una condición donde V_TEMP > 3.0V Y V_PRESS > 3.0V simultáneamente.
    • Mide el voltaje en ALERT (Pin 3 de U1): Esperado ~5V.
    • Visual: El LED rojo D1 debe ENCENDERSE.

Netlist SPICE y simulación

Netlist SPICE de referencia (ngspice) — extractoNetlist SPICE completo (ngspice)

* Practical case: Temperature and Pressure Monitoring

* --- Power Supply ---
* V1: 5 V DC supply
V1 VCC 0 DC 5

* --- Sensors and Inputs ---
* Temperature Sensor (RT1 NTC + R1 Divider)
* RT1: 10 kΩ NTC thermistor (Modeled as R_RT1)
* Connected between VCC and V_TEMP
R_RT1 VCC V_TEMP 10k
* R1: 10 kΩ resistor (Voltage divider bottom)
* Connected between V_TEMP and 0 (GND)
R1 V_TEMP 0 10k

* Pressure Sensor (RP1 Potentiometer)
* RP1: 10 kΩ linear potentiometer
* Modeled as two resistors (Top/Bot) representing the wiper position.
* Outer legs to VCC and 0, wiper to V_PRESS.
R_RP1_TOP VCC V_PRESS 5k
R_RP1_BOT V_PRESS 0 5k

* --- Dynamic Stimuli (Simulation) ---
* These voltage sources drive the sensor nodes to simulate physical changes
* over time, verifying the logic thresholds (sweeping 1V to 4V).
* They effectively override the static resistor dividers for transient analysis.
V_TEMP_STIM V_TEMP 0 PULSE(1 4 0.5m 100u 100u 1m 3m)
V_PRESS_STIM V_PRESS 0 PULSE(1 4 1m 100u 100u 1.5m 4m)

* --- Reference Thresholds ---
* ... (truncated in public view) ...

Copia este contenido en un archivo .cir y ejecútalo con ngspice.

🔒 Parte del contenido de esta sección es premium. Con el pase de 7 días o la suscripción mensual tendrás acceso al contenido completo (materiales, conexionado, compilación detallada, validación paso a paso, troubleshooting, mejoras/variantes y checklist) y podrás descargar el pack PDF listo para imprimir.

🔓 Ver planes de acceso premium 

* Practical case: Temperature and Pressure Monitoring

* --- Power Supply ---
* V1: 5 V DC supply
V1 VCC 0 DC 5

* --- Sensors and Inputs ---
* Temperature Sensor (RT1 NTC + R1 Divider)
* RT1: 10 kΩ NTC thermistor (Modeled as R_RT1)
* Connected between VCC and V_TEMP
R_RT1 VCC V_TEMP 10k
* R1: 10 kΩ resistor (Voltage divider bottom)
* Connected between V_TEMP and 0 (GND)
R1 V_TEMP 0 10k

* Pressure Sensor (RP1 Potentiometer)
* RP1: 10 kΩ linear potentiometer
* Modeled as two resistors (Top/Bot) representing the wiper position.
* Outer legs to VCC and 0, wiper to V_PRESS.
R_RP1_TOP VCC V_PRESS 5k
R_RP1_BOT V_PRESS 0 5k

* --- Dynamic Stimuli (Simulation) ---
* These voltage sources drive the sensor nodes to simulate physical changes
* over time, verifying the logic thresholds (sweeping 1V to 4V).
* They effectively override the static resistor dividers for transient analysis.
V_TEMP_STIM V_TEMP 0 PULSE(1 4 0.5m 100u 100u 1m 3m)
V_PRESS_STIM V_PRESS 0 PULSE(1 4 1m 100u 100u 1.5m 4m)

* --- Reference Thresholds ---
* RP2: 10 kΩ potentiometer (Temperature Reference)
* Configured as divider, wiper to V_REF_T. Set to ~2.5V.
R_RP2_TOP VCC V_REF_T 5k
R_RP2_BOT V_REF_T 0 5k

* RP3: 10 kΩ potentiometer (Pressure Reference)
* Configured as divider, wiper to V_REF_P. Set to ~2.5V.
R_RP3_TOP VCC V_REF_P 5k
R_RP3_BOT V_REF_P 0 5k

* --- Comparator Stage (U2: LM393) ---
* U2: Dual Differential Comparator
* Connections based on Wiring Guide:
*   Comp A (Temp): In+ (3)=V_TEMP, In- (2)=V_REF_T, Out (1)=LOGIC_T
*   Comp B (Press): In+ (5)=V_PRESS, In- (6)=V_REF_P, Out (7)=LOGIC_P
*   Power: VCC (8), GND (4)
XU2 LOGIC_T V_REF_T V_TEMP 0 V_PRESS V_REF_P LOGIC_P VCC LM393

* Pull-up resistors (Required for Open Collector Outputs)
* R2: 4.7 kΩ pull-up for Comparator A
R2 VCC LOGIC_T 4.7k
* R3: 4.7 kΩ pull-up for Comparator B
R3 VCC LOGIC_P 4.7k

* --- Logic Stage (U1: 74HC08) ---
* U1: Quad 2-Input AND Gate
* Connections:
*   Gate 1: Input 1A (1)=LOGIC_T, Input 1B (2)=LOGIC_P, Output 1Y (3)=ALERT
*   Power: VCC (14), GND (7)
*   Unused inputs (4,5,9,10,12,13) connected to 0 (GND) to prevent floating.
XU1 LOGIC_T LOGIC_P ALERT 0 0 0 0 0 0 0 0 0 0 VCC 74HC08

* --- Indicator ---
* R4: 330 Ω resistor (LED current limiting)
R4 ALERT LED_A 330
* D1: Red LED (Cathode to GND)
D1 LED_A 0 DLED

* --- Models and Subcircuits ---

* LED Model
.model DLED D(IS=1e-14 N=1.7 RS=10)

* LM393 Subcircuit (Behavioral Open Collector)
.subckt LM393 1 2 3 4 5 6 7 8
* Pinout: 1=OutA, 2=InA-, 3=InA+, 4=GND, 5=InB+, 6=InB-, 7=OutB, 8=VCC
* Logic: If In+ > In-, Output is High-Z (Pull-up High).
*        If In+ < In-, Output is Low (GND).
* Implementation uses Voltage Controlled Switch to GND.
* Control V = In(-) - In(+). If V > 0 (In- > In+), Switch Closed (Low).
B_A_CTRL 10 0 V = V(2) - V(3)
S_A 1 4 10 0 SW_OC
B_B_CTRL 20 0 V = V(6) - V(5)
S_B 7 4 20 0 SW_OC
.model SW_OC SW(Vt=0 Vh=1m Ron=10 Roff=100Meg)
.ends LM393

* 74HC08 Subcircuit (Behavioral AND Gate)
.subckt 74HC08 1 2 3 4 5 6 7 8 9 10 11 12 13 14
* Pinout: 1=1A, 2=1B, 3=1Y, 7=GND, 14=VCC ...
* Gate 1 Logic: Output High (VCC) if V(1)>2.5 and V(2)>2.5
B_Y1 3 7 V = V(14) * (1 / (1 + exp(-50*(V(1)-2.5)))) * (1 / (1 + exp(-50*(V(2)-2.5))))
.ends 74HC08

* --- Simulation Directives ---
.tran 10u 5ms
.print tran V(V_TEMP) V(V_PRESS) V(LOGIC_T) V(LOGIC_P) V(ALERT)

.end

Resultados de Simulación (Transitorio)

Resultados de Simulación (Transitorio)
Show raw data table (1124 rows) 
Index   time            v(v_temp)       v(v_press)      v(logic_t)
0	0.000000e+00	1.000000e+00	1.000000e+00	1.061571e-02
1	1.000000e-07	1.000000e+00	1.000000e+00	1.061571e-02
2	2.000000e-07	1.000000e+00	1.000000e+00	1.061571e-02
3	4.000000e-07	1.000000e+00	1.000000e+00	1.061571e-02
4	8.000000e-07	1.000000e+00	1.000000e+00	1.061571e-02
5	1.600000e-06	1.000000e+00	1.000000e+00	1.061571e-02
6	3.200000e-06	1.000000e+00	1.000000e+00	1.061571e-02
7	6.400000e-06	1.000000e+00	1.000000e+00	1.061571e-02
8	1.280000e-05	1.000000e+00	1.000000e+00	1.061571e-02
9	2.280000e-05	1.000000e+00	1.000000e+00	1.061571e-02
10	3.280000e-05	1.000000e+00	1.000000e+00	1.061571e-02
11	4.280000e-05	1.000000e+00	1.000000e+00	1.061571e-02
12	5.280000e-05	1.000000e+00	1.000000e+00	1.061571e-02
13	6.280000e-05	1.000000e+00	1.000000e+00	1.061571e-02
14	7.280000e-05	1.000000e+00	1.000000e+00	1.061571e-02
15	8.280000e-05	1.000000e+00	1.000000e+00	1.061571e-02
16	9.280000e-05	1.000000e+00	1.000000e+00	1.061571e-02
17	1.028000e-04	1.000000e+00	1.000000e+00	1.061571e-02
18	1.128000e-04	1.000000e+00	1.000000e+00	1.061571e-02
19	1.228000e-04	1.000000e+00	1.000000e+00	1.061571e-02
20	1.328000e-04	1.000000e+00	1.000000e+00	1.061571e-02
21	1.428000e-04	1.000000e+00	1.000000e+00	1.061571e-02
22	1.528000e-04	1.000000e+00	1.000000e+00	1.061571e-02
23	1.628000e-04	1.000000e+00	1.000000e+00	1.061571e-02
... (1100 more rows) ...

Errores comunes y cómo evitarlos

  1. Falta de resistencias pull-up en comparadores: El LM393 tiene salidas de colector abierto. Si omites R2 y R3, las entradas al 74HC08 quedarán flotantes o permanecerán bajas, impidiendo que el circuito funcione. Solución: Instala siempre pull-ups (4.7kΩ a 10kΩ) desde el pin de salida a VCC.
  2. Conexionado incorrecto del NTC: Conectar el NTC a tierra y la resistencia fija a VCC crea un voltaje que cae a medida que la temperatura sube. Solución: Conecta el NTC a VCC y la resistencia fija a Tierra para asegurar que el voltaje aumente con la temperatura, coincidiendo con la lógica del comparador no inversor.
  3. Entradas flotantes en el 74HC08: Dejar entradas no utilizadas en el chip lógico conectadas a nada puede causar ruido y mayor consumo de energía. Solución: Conecta las entradas no utilizadas (por ejemplo, pines 4, 5, 9, 10, 12, 13) a GND.

Solución de problemas

  • El LED nunca se ENCIENDE: Comprueba si faltan R2 o R3. Sin ellas, las entradas de la puerta AND ven un 0 lógico. Verifica la orientación del LED.
  • El LED está siempre ENCENDIDO: Comprueba RP2 y RP3. Si el voltaje de referencia está ajustado a 0V, los sensores siempre parecerán «Altos» en relación con la referencia.
  • LED errático/parpadeante: El voltaje en las entradas del comparador podría estar oscilando exactamente en el umbral. Esto crea ruido. Añadir una resistencia de retroalimentación de histéresis puede solucionar esto, pero asegurar conexiones de alimentación limpias suele ser suficiente para pruebas básicas.

Posibles mejoras y extensiones

  1. Añadir histéresis: Conecta una resistencia de alto valor (por ejemplo, 100kΩ) entre la salida del comparador y la entrada no inversora. Esto previene el efecto de «rebote» cuando los valores del sensor oscilan cerca del umbral.
  2. Alarma sonora: Conecta un zumbador con un transistor driver (como un 2N2222) a la salida del 74HC08 junto con el LED para una advertencia audible en un entorno industrial ruidoso.

Más Casos Prácticos en Prometeo.blog

Encuentra este producto y/o libros sobre este tema en Amazon

Ir a Amazon

Como afiliado de Amazon, gano con las compras que cumplan los requisitos. Si compras a través de este enlace, ayudas a mantener este proyecto.

Quiz rápido

Pregunta 1: ¿Cuál es el componente principal utilizado para digitalizar las señales analógicas de los sensores en este circuito?




Pregunta 2: ¿Qué función lógica utiliza el circuito para procesar la seguridad y activar la alarma?




Pregunta 3: ¿Qué condición debe cumplirse para que el LED rojo se encienda (Estado crítico)?




Pregunta 4: ¿Cuál es la función del componente 74HC08 en este circuito?




Pregunta 5: ¿Qué componente se utiliza para simular el sensor de presión en este ejercicio?




Pregunta 6: ¿Cuál es el voltaje aproximado de salida del 74HC08 cuando se alcanza el nivel lógico alto en este circuito de 5V?




Pregunta 7: ¿Qué sucede con el LED si solo una de las variables (temperatura o presión) excede el límite?




Pregunta 8: ¿Qué función cumple la resistencia R1 de 10 kΩ en relación con el termistor?




Pregunta 9: ¿Cuál de los siguientes es un caso de uso mencionado para este circuito?




Pregunta 10: ¿Cuál es el nivel de dificultad asignado a este ejercicio según el contexto?




Carlos Núñez Zorrilla
Carlos Núñez Zorrilla
Electronics & Computer Engineer

Ingeniero Superior en Electrónica de Telecomunicaciones e Ingeniero en Informática (titulaciones oficiales en España).

Sígueme:

Caso práctico: Control de acceso vehicular con barrera

Prototipo de Control de acceso vehicular con barrera (Maker Style)

Nivel: Medio — Diseñar un circuito lógico de seguridad que levante una barrera solo cuando ocurran simultáneamente la presencia del vehículo y la verificación de un ticket válido.

Objetivo y caso de uso

En este caso práctico, construirás un circuito de control digital utilizando una compuerta AND 74HC08 para simular la lógica de una barrera de estacionamiento automatizada. La barrera (representada por un LED) solo se activará cuando un sensor de presencia vehicular y un sistema de validación de tickets se activen simultáneamente.

Por qué es útil:
* Estacionamientos: Asegura que la barrera no se abra para peatones o si un ticket es inválido.
* Casetas de peaje: Sincroniza la confirmación del pago con la presencia física del vehículo.
* Seguridad industrial: Evita la operación de maquinaria a menos que haya una protección colocada y se emita una orden de arranque.
* Acceso seguro: Requiere factores de doble autenticación en sistemas de seguridad física.

Resultado esperado:
* Estado 0 (Reposo): El LED permanece APAGADO cuando no se presionan botones (salida de 0 V).
* Estado 1 (Parcial): El LED permanece APAGADO si solo se detecta el vehículo o solo se valida el ticket.
* Estado 2 (Activo): El LED se ENCIENDE (aprox. 5 V / Lógica alta) SOLO cuando ambas entradas están activas simultáneamente.
* Verificación lógica: Confirmación de la operación booleana AND estándar ($Y = A \cdot B$).

Público objetivo y nivel: Estudiantes de electrónica y aficionados / Medio.

Materiales

  • V1: Fuente de alimentación de 5 V CC, función: Alimentación principal del circuito
  • U1: 74HC08, función: CI de cuádruple compuerta AND de 2 entradas
  • S1: Pulsador (NA), función: Simula «Sensor de presencia vehicular»
  • S2: Pulsador (NA), función: Simula «Señal de validación de ticket»
  • R1: Resistencia de 10 kΩ, función: Pull-down para entrada de vehículo
  • R2: Resistencia de 10 kΩ, función: Pull-down para entrada de ticket
  • R3: Resistencia de 330 Ω, función: Limitación de corriente del LED
  • D1: LED verde, función: Simula «Motor de barrera/Señal de apertura»
  • Protoboard y cables puente

Pin-out del CI utilizado

Chip: 74HC08 (Cuádruple compuerta AND de 2 entradas)

Pin Nombre Función lógica Conexión en este caso
1 1A Entrada A Conectado al Sensor de Vehículo (S1)
2 1B Entrada B Conectado al Validador de Tickets (S2)
3 1Y Salida Conectado al Indicador de Barrera (LED)
7 GND Tierra Conectado a Tierra de la fuente (0 V)
14 VCC Alimentación Conectado a alimentación de +5 V

Nota: Los pines 4, 5, 6, 8, 9, 10, 11, 12 y 13 no se utilizan en este circuito específico.

Guía de conexionado

  • Fuente de alimentación:
    • V1 (+) se conecta al nodo VCC.
    • V1 (-) se conecta al nodo 0 (GND).
  • Alimentación del CI:
    • U1 Pin 14 se conecta al nodo VCC.
    • U1 Pin 7 se conecta al nodo 0.
  • Etapa de entrada (Sensor de vehículo):
    • S1 se conecta entre el nodo VCC y el nodo VEHICLE_IN.
    • R1 se conecta entre el nodo VEHICLE_IN y el nodo 0 (configuración activa en alto).
    • U1 Pin 1 se conecta al nodo VEHICLE_IN.
  • Etapa de entrada (Validador de ticket):
    • S2 se conecta entre el nodo VCC y el nodo TICKET_IN.
    • R2 se conecta entre el nodo TICKET_IN y el nodo 0 (configuración activa en alto).
    • U1 Pin 2 se conecta al nodo TICKET_IN.
  • Etapa de salida (Actuador de barrera):
    • U1 Pin 3 se conecta al nodo LOGIC_OUT.
    • R3 se conecta entre el nodo LOGIC_OUT y el nodo LED_ANODE.
    • D1 (Ánodo) se conecta al nodo LED_ANODE.
    • D1 (Cátodo) se conecta al nodo 0.

Diagrama de bloques conceptual

Conceptual block diagram — 74HC08 AND gate

Esquemático

[ INPUT SENSORS ]                     [ LOGIC PROCESSING ]                  [ ACTUATOR OUTPUT ]

 [ VCC ]
    |
 [ S1: Vehicle ]
    |
           +----(Node: VEHICLE_IN)----(Pin 1)-->+----------------------+
    |                                    |                      |
 [ R1: 10k ]                             |      U1: 74HC08      |
    |                                    |      (AND Gate)      |
 [ GND ]                                 |                      |--(Pin 3)--> [ R3: 330 ] --> [ D1: Green LED ] --> [ GND ]
                                         |  (Pin 14: VCC)       |
 [ VCC ]                                 |  (Pin 7:  GND)       |
    |                                    |                      |
 [ S2: Ticket ]                          |                      |
    |                                    |                      |
+----(Node: TICKET_IN)-----(Pin 2)-->+----------------------+
    |
 [ R2: 10k ]
    |
 [ GND ]
Esquema Eléctrico

Diagrama eléctrico

Diagrama eléctrico del control de acceso vehicular con barrera
Generado desde la netlist SPICE validada del caso.

🔒 Este diagrama eléctrico es premium. Con el pase de 7 días o la suscripción mensual podrás desbloquear el material didáctico completo y el pack PDF listo para imprimir.🔓 Ver planes de acceso premium

Tabla de verdad

El 74HC08 sigue la verificación lógica AND estándar:

Vehículo detectado (S1) Ticket validado (S2) Voltaje de salida (Pin 3) Estado de la barrera (LED)
Bajo (0) Bajo (0) ~0 V Cerrada (APAGADO)
Bajo (0) Alto (1) ~0 V Cerrada (APAGADO)
Alto (1) Bajo (0) ~0 V Cerrada (APAGADO)
Alto (1) Alto (1) ~5 V Abierta (ENCENDIDO)

Mediciones y pruebas

  1. Verificación en reposo: Asegúrate de que ni S1 ni S2 estén presionados. Mide el voltaje en el Pin 1 y el Pin 2 de U1 con respecto a GND. Debería leerse 0 V (Lógica baja). El LED debe estar APAGADO.
  2. Prueba de entrada única: Presiona solo S1 (Vehículo). Mide el voltaje en el Pin 1 (5 V) y el Pin 3 (0 V). El LED debe permanecer APAGADO. Repite para S2 (Ticket).
  3. Prueba de activación: Presiona S1 y S2 simultáneamente. Mide el voltaje en el Pin 3 de U1. Debería leerse cerca de 5 V (Lógica alta).
  4. Verificación de carga: Observa que el LED se ENCIENDE brillantemente cuando se mantienen presionados ambos botones. Esto confirma que la barrera se levantaría.

Netlist SPICE y simulación

Netlist SPICE de referencia (ngspice) — extractoNetlist SPICE completo (ngspice)

* TITLE: Practical case: Vehicle access control with barrier
* Ngspice Netlist
* Implements a 74HC08 AND gate circuit with push-button inputs and LED output

* --- Component Models ---
* Switch Model: Voltage Controlled Switch for Push-buttons
* Vt=2.5V (Threshold), Ron=1 ohm (Closed), Roff=100Meg (Open)
.model SW_PUSH SW(Vt=2.5 Ron=1 Roff=100Meg)

* LED Model: Generic Green LED
.model D_GREEN D(Is=1e-22 Rs=5 N=1.5 Cjo=10p BV=5)

* --- Power Supply ---
* V1: 5V DC Main Power Supply
V1 VCC 0 DC 5

* --- Dynamic Stimuli (User Button Presses) ---
* These sources actuate the switches S1 and S2 to simulate user interaction.
* They are not part of the physical circuit but provide the mechanical "push".
* Sequence designed to test Truth Table: 00 -> 10 -> 01 -> 11
* Time unit: microseconds (us)

* S1 Actuator (Vehicle Sensor): Toggles every 200us (starts at 100us)
V_ACT_S1 S1_CTRL 0 PULSE(0 5 100u 1u 1u 100u 200u)

* S2 Actuator (Ticket Validator): Toggles every 400us (starts at 200us)
V_ACT_S2 S2_CTRL 0 PULSE(0 5 200u 1u 1u 200u 400u)

* --- Input Stage: Vehicle Sensor ---
* S1: Push-button connecting VCC to VEHICLE_IN when pressed
* ... (truncated in public view) ...

Copia este contenido en un archivo .cir y ejecútalo con ngspice.

🔒 Parte del contenido de esta sección es premium. Con el pase de 7 días o la suscripción mensual tendrás acceso al contenido completo (materiales, conexionado, compilación detallada, validación paso a paso, troubleshooting, mejoras/variantes y checklist) y podrás descargar el pack PDF listo para imprimir.

🔓 Ver planes de acceso premium 

* TITLE: Practical case: Vehicle access control with barrier
* Ngspice Netlist
* Implements a 74HC08 AND gate circuit with push-button inputs and LED output

* --- Component Models ---
* Switch Model: Voltage Controlled Switch for Push-buttons
* Vt=2.5V (Threshold), Ron=1 ohm (Closed), Roff=100Meg (Open)
.model SW_PUSH SW(Vt=2.5 Ron=1 Roff=100Meg)

* LED Model: Generic Green LED
.model D_GREEN D(Is=1e-22 Rs=5 N=1.5 Cjo=10p BV=5)

* --- Power Supply ---
* V1: 5V DC Main Power Supply
V1 VCC 0 DC 5

* --- Dynamic Stimuli (User Button Presses) ---
* These sources actuate the switches S1 and S2 to simulate user interaction.
* They are not part of the physical circuit but provide the mechanical "push".
* Sequence designed to test Truth Table: 00 -> 10 -> 01 -> 11
* Time unit: microseconds (us)

* S1 Actuator (Vehicle Sensor): Toggles every 200us (starts at 100us)
V_ACT_S1 S1_CTRL 0 PULSE(0 5 100u 1u 1u 100u 200u)

* S2 Actuator (Ticket Validator): Toggles every 400us (starts at 200us)
V_ACT_S2 S2_CTRL 0 PULSE(0 5 200u 1u 1u 200u 400u)

* --- Input Stage: Vehicle Sensor ---
* S1: Push-button connecting VCC to VEHICLE_IN when pressed
S1 VCC VEHICLE_IN S1_CTRL 0 SW_PUSH
* R1: 10k Pull-down resistor for Vehicle input
R1 VEHICLE_IN 0 10k

* --- Input Stage: Ticket Validator ---
* S2: Push-button connecting VCC to TICKET_IN when pressed
S2 VCC TICKET_IN S2_CTRL 0 SW_PUSH
* R2: 10k Pull-down resistor for Ticket input
R2 TICKET_IN 0 10k

* --- Logic Stage: U1 (74HC08 Quad 2-Input AND Gate) ---
* Subcircuit representing one gate of the 74HC08 IC
* Pins mapped: 1(A), 2(B), 3(Y), 7(GND), 14(VCC)
.subckt 74HC08_GATE PIN1 PIN2 PIN3 PIN7 PIN14
    * Behavioral AND logic using continuous sigmoid functions for convergence
    * Y = VCC if (A > 2.5V) AND (B > 2.5V)
    B_LOGIC PIN3 PIN7 V = V(PIN14) * (1 / (1 + exp(-50*(V(PIN1)-2.5)))) * (1 / (1 + exp(-50*(V(PIN2)-2.5))))
.ends

* Instantiate U1 connected according to Wiring Guide
* Pin 1->VEHICLE_IN, Pin 2->TICKET_IN, Pin 3->LOGIC_OUT, Pin 7->0, Pin 14->VCC
XU1 VEHICLE_IN TICKET_IN LOGIC_OUT 0 VCC 74HC08_GATE

* --- Output Stage: Barrier Actuator ---
* R3: 330 ohm current limiting resistor
R3 LOGIC_OUT LED_ANODE 330
* D1: Green LED (Anode to R3, Cathode to GND)
D1 LED_ANODE 0 D_GREEN

* --- Simulation Directives ---
* Transient analysis for 500us to capture full sequence
.tran 1u 500u
.op

* Print signals to verify logic: 
* Expect LOGIC_OUT to be High (~5V) only when both Inputs are High (300us-400us)
.print tran V(VEHICLE_IN) V(TICKET_IN) V(LOGIC_OUT) V(LED_ANODE)

.end

Resultados de Simulación (Transitorio)

Resultados de Simulación (Transitorio)
Show raw data table (1254 rows) 
Index   time            v(vehicle_in)   v(ticket_in)    v(logic_out)
0	0.000000e+00	4.999500e-04	4.999500e-04	1.403014e-108
1	1.000000e-08	4.999500e-04	4.999500e-04	1.403014e-108
2	2.000000e-08	4.999500e-04	4.999500e-04	1.403014e-108
3	4.000000e-08	4.999500e-04	4.999500e-04	1.403014e-108
4	8.000000e-08	4.999500e-04	4.999500e-04	1.403014e-108
5	1.600000e-07	4.999500e-04	4.999500e-04	1.403014e-108
6	3.200000e-07	4.999500e-04	4.999500e-04	1.403014e-108
7	6.400000e-07	4.999500e-04	4.999500e-04	1.403014e-108
8	1.280000e-06	4.999500e-04	4.999500e-04	1.403014e-108
9	2.280000e-06	4.999500e-04	4.999500e-04	1.403014e-108
10	3.280000e-06	4.999500e-04	4.999500e-04	1.403014e-108
11	4.280000e-06	4.999500e-04	4.999500e-04	1.403014e-108
12	5.280000e-06	4.999500e-04	4.999500e-04	1.403014e-108
13	6.280000e-06	4.999500e-04	4.999500e-04	1.403014e-108
14	7.280000e-06	4.999500e-04	4.999500e-04	1.403014e-108
15	8.280000e-06	4.999500e-04	4.999500e-04	1.403014e-108
16	9.280000e-06	4.999500e-04	4.999500e-04	1.403014e-108
17	1.028000e-05	4.999500e-04	4.999500e-04	1.403014e-108
18	1.128000e-05	4.999500e-04	4.999500e-04	1.403014e-108
19	1.228000e-05	4.999500e-04	4.999500e-04	1.403014e-108
20	1.328000e-05	4.999500e-04	4.999500e-04	1.403014e-108
21	1.428000e-05	4.999500e-04	4.999500e-04	1.403014e-108
22	1.528000e-05	4.999500e-04	4.999500e-04	1.403014e-108
23	1.628000e-05	4.999500e-04	4.999500e-04	1.403014e-108
... (1230 more rows) ...

Errores comunes y cómo evitarlos

  1. Entradas flotantes: No incluir las resistencias R1 y R2 hace que las entradas «floten», provocando un parpadeo errático del LED incluso cuando no se presionan los botones. Usa siempre resistencias pull-down con la serie lógica 74HC.
  2. Conexiones de alimentación faltantes: Olvidar conectar el Pin 14 (VCC) y el Pin 7 (GND) es un error clásico. Los chips lógicos no funcionarán sin alimentación, incluso si las entradas están cableadas correctamente.
  3. LED sin resistencia: Conectar el LED directamente a la salida lógica (Pin 3) sin R3 puede dañar el LED o la etapa de salida del 74HC08 debido a una corriente excesiva.

Solución de problemas

  • Síntoma: El LED está siempre ENCENDIDO, incluso cuando se sueltan los botones.
    • Causa: Faltan resistencias pull-down o las entradas están conectadas directamente a VCC.
    • Solución: Asegúrate de que R1 y R2 estén instaladas correctamente entre las entradas y GND.
  • Síntoma: El LED no se enciende cuando se presionan ambos botones.
    • Causa: Polaridad del LED invertida o CI sin alimentación.
    • Solución: Verifica la orientación de D1 (el lado plano es el cátodo/GND) y mide 5 V entre los pines 14 y 7.
  • Síntoma: El LED es muy tenue cuando está activo.
    • Causa: El valor de la resistencia limitadora de corriente (R3) es demasiado alto.
    • Solución: Asegúrate de que R3 sea de 330 Ω (naranja-naranja-marrón). Si es de 10 kΩ o superior, el LED será apenas visible.

Posibles mejoras y extensiones

  1. Parada de emergencia: Introduce una tercera entrada usando una compuerta AND de 3 entradas (74HC11) o conectando en cascada otra compuerta 74HC08, conectada a un interruptor de «Parada» que anule el comando de apertura.
  2. Interfaz de controlador de motor: Reemplaza el LED con un transistor NPN (por ejemplo, 2N2222) y un relé para accionar un motor de CC real o un solenoide, simulando un mecanismo de barrera de alta potencia.

Más Casos Prácticos en Prometeo.blog

Encuentra este producto y/o libros sobre este tema en Amazon

Ir a Amazon

Como afiliado de Amazon, gano con las compras que cumplan los requisitos. Si compras a través de este enlace, ayudas a mantener este proyecto.

Quiz rápido

Pregunta 1: ¿Cuál es el objetivo principal del circuito descrito en el artículo?




Pregunta 2: ¿Qué componente específico se utiliza para realizar la operación lógica del circuito?




Pregunta 3: ¿Qué representa el LED en la simulación del circuito?




Pregunta 4: Según la lógica booleana del circuito AND descrito, ¿cuál es la ecuación que representa el funcionamiento?




Pregunta 5: ¿Qué sucede en el 'Estado 1 (Parcial)' descrito en el resultado esperado?




Pregunta 6: ¿Qué simula el primer botón o entrada en este contexto de estacionamiento?




Pregunta 7: ¿Qué voltaje aproximado se espera en la salida (LED) cuando ambas condiciones se cumplen (Estado Activo)?




Pregunta 8: ¿Por qué es útil este circuito en seguridad industrial según el texto?




Pregunta 9: ¿Qué ocurre en el 'Estado 0 (Reposo)' según el texto?




Pregunta 10: ¿Qué aplicación adicional se menciona para este tipo de lógica de doble condición?




Carlos Núñez Zorrilla
Carlos Núñez Zorrilla
Electronics & Computer Engineer

Ingeniero Superior en Electrónica de Telecomunicaciones e Ingeniero en Informática (titulaciones oficiales en España).

Sígueme:

Caso práctico: Sistema de riego automático condicional

Prototipo de Sistema de riego automático condicional (Maker Style)

Nivel: Básico – Construye un circuito lógico para activar una bomba solo cuando el suelo esté seco y haya agua disponible.

Objetivo y caso de uso

En este caso práctico, construirás un circuito de enclavamiento de seguridad utilizando una puerta AND 74HC08. El circuito simula un controlador de riego inteligente que decide si encender una bomba de agua basándose en dos condiciones ambientales.

Por qué es útil:
* Protección del equipo: Evita que las bombas funcionen «en seco» (sin entrada de agua), lo cual a menudo causa fallos mecánicos.
* Conservación de recursos: Asegura que el agua solo se dispense cuando el suelo realmente necesita humedad.
* Lógica industrial: Demuestra el concepto fundamental de «enclavamiento de seguridad» utilizado en maquinaria pesada (por ejemplo, la máquina funciona SOLO si la protección está cerrada Y el operador presiona el botón).
* Fundamentos de lógica digital: Proporciona una representación física clara de la función booleana AND ($Y = A \cdot B$).

Resultado esperado:
* El LED de salida (Bomba) se ENCIENDE solo cuando el Interruptor A (Sensor de suelo) está en ALTO Y el Interruptor B (Sensor de tanque) está en ALTO.
* Si el tanque está vacío (Interruptor B = BAJO), la bomba permanece APAGADA incluso si el suelo está seco.
* Lógica 0: Voltaje $\approx$ 0 V. Lógica 1: Voltaje $\approx$ 5 V.

Público objetivo: Estudiantes de electrónica y aficionados de nivel básico.

Materiales

  • U1: 74HC08, función: CI de cuádruple puerta AND de 2 entradas.
  • S1: Interruptor SPST, función: Simulación de sensor de humedad del suelo (Cerrado = Seco/Lógica 1).
  • S2: Interruptor SPST, función: Simulación de nivel del tanque de agua (Cerrado = Agua presente/Lógica 1).
  • R1: Resistencia de 10 kΩ, función: pull-down para la Entrada A.
  • R2: Resistencia de 10 kΩ, función: pull-down para la Entrada B.
  • R3: Resistencia de 330 Ω, función: limitación de corriente del LED.
  • D1: LED verde, función: indicador de bomba de agua activa.
  • V1: Fuente de alimentación de 5 V DC, función: fuente de alimentación principal.

Pin-out del CI utilizado: 74HC08

El 74HC08 contiene cuatro puertas AND independientes. Usaremos solo una de ellas para este experimento.

Pin Nombre Función lógica Conexión en este caso
1 1A Entrada A Conectado a S1 (Estado del suelo)
2 1B Entrada B Conectado a S2 (Estado del tanque)
3 1Y Salida Y Conectado a LED (Indicador de bomba)
7 GND Tierra Conectado a Tierra de la fuente (0V)
14 VCC Alimentación Conectado a fuente de +5V

Guía de conexionado

Sigue estas conexiones cuidadosamente. Los nombres de los nodos corresponden a la función del cable en el circuito.

  • V1 se conecta entre el nodo VCC y el nodo 0 (GND).
  • U1 (Pin 14) se conecta al nodo VCC.
  • U1 (Pin 7) se conecta al nodo 0 (GND).
  • S1 se conecta entre el nodo VCC y el nodo SOIL_Status.
  • R1 se conecta entre el nodo SOIL_Status y el nodo 0 (GND) (Mantiene la entrada en Bajo cuando el interruptor está abierto).
  • S2 se conecta entre el nodo VCC y el nodo TANK_Status.
  • R2 se conecta entre el nodo TANK_Status y el nodo 0 (GND) (Mantiene la entrada en Bajo cuando el interruptor está abierto).
  • U1 (Pin 1, Entrada A) se conecta al nodo SOIL_Status.
  • U1 (Pin 2, Entrada B) se conecta al nodo TANK_Status.
  • U1 (Pin 3, Salida Y) se conecta al nodo PUMP_Cmd.
  • R3 se conecta entre el nodo PUMP_Cmd y el nodo LED_Anode.
  • D1 se conecta entre el nodo LED_Anode (Ánodo) y el nodo 0 (GND) (Cátodo).

Diagrama de bloques conceptual

Conceptual block diagram — 74HC08 AND gate

Esquemático

[ INPUTS ]                                  [ LOGIC ]                             [ OUTPUT ]

[ S1: Soil Sensor ]
[ (Switch to VCC) ] --(Node: SOIL_Status)-->+---------------------+
[ (R1: 10k to GND)]                         |      U1: 74HC08     |
                                            |      (AND Gate)     |
                                            |                     |--(Node: PUMP_Cmd)--> [ R3: 330 Ohm ] --> [ D1: Green LED ] --> GND
                                            |   Pin 1 (Input A)   |                      (Current Lim.)      (Pump Active)
                                            |                     |
                                            |   Pin 2 (Input B)   |
[ S2: Tank Level  ] --(Node: TANK_Status)-->|                     |
[ (Switch to VCC) ]                         +---------------------+
[ (R2: 10k to GND)]
Esquema Eléctrico

Diagrama eléctrico

Diagrama eléctrico del sistema de riego automático condicional
Generado desde la netlist SPICE validada del caso.

🔒 Este diagrama eléctrico es premium. Con el pase de 7 días o la suscripción mensual podrás desbloquear el material didáctico completo y el pack PDF listo para imprimir.🔓 Ver planes de acceso premium

Tabla de verdad

Esta tabla define los estados lógicos.
0 = Interruptor abierto / 0V / Suelo húmedo / Tanque vacío / Bomba APAGADA
1 = Interruptor cerrado / 5V / Suelo seco / Tanque lleno / Bomba ENCENDIDA

Estado del suelo (A) Estado del tanque (B) Bomba de salida (Y) Estado en el mundo real
0 0 0 Suelo húmedo, Tanque vacío -> En espera
0 1 0 Suelo húmedo, Tanque lleno -> En espera
1 0 0 Suelo seco, Tanque vacío -> Corte de seguridad (Proteger bomba)
1 1 1 Suelo seco, Tanque lleno -> Riego activo

Mediciones y pruebas

Valida tu circuito utilizando un multímetro configurado en voltaje DC (rango de 20V).

  1. Comprobación de espera: Asegúrate de que tanto S1 como S2 estén abiertos (OFF). Mide el voltaje en el Pin 3 de U1.
    • Esperado: ~0 V. D1 está APAGADO.
  2. Prueba de protección contra funcionamiento en seco: Cierra S1 (el suelo está seco) pero deja S2 abierto (tanque vacío).
    • Esperado: El Pin 1 lee 5 V, el Pin 2 lee 0 V. La salida del Pin 3 debe permanecer en 0 V. D1 está APAGADO.
  3. Prueba sin demanda: Abre S1 (suelo húmedo) y cierra S2 (tanque lleno).
    • Esperado: El Pin 1 lee 0 V, el Pin 2 lee 5 V. La salida del Pin 3 debe permanecer en 0 V. D1 está APAGADO.
  4. Prueba de riego activo: Cierra ambos S1 y S2.
    • Esperado: El Pin 1 lee 5 V, el Pin 2 lee 5 V. La salida del Pin 3 debería leer ~5 V (Lógica Alta). D1 se ilumina en verde.

Netlist SPICE y simulación

Netlist SPICE de referencia (ngspice) — extractoNetlist SPICE completo (ngspice)

* Title: Practical case: Conditional automatic irrigation system

* -----------------------------------------------------------------------------
* POWER SUPPLY
* -----------------------------------------------------------------------------
* V1: 5V DC supply, function: Main power source.
V1 VCC 0 DC 5

* -----------------------------------------------------------------------------
* STIMULI GENERATION (Simulating User Interaction)
* -----------------------------------------------------------------------------
* These voltage sources drive the control pins of the ideal switches (S1, S2)
* to simulate the physical sensors changing state over time.
* They are not part of the BOM but are necessary for dynamic simulation.

* Control signal for S1 (Soil Sensor): Period 200us
* Logic: 0 -> 1 -> 0 -> 1
V_CTRL_S1 N_CTRL_S1 0 PULSE(0 5 10u 1u 1u 100u 200u)

* Control signal for S2 (Tank Sensor): Period 400us
* Logic: 0 -> 0 -> 1 -> 1
V_CTRL_S2 N_CTRL_S2 0 PULSE(0 5 10u 1u 1u 200u 400u)

* -----------------------------------------------------------------------------
* INPUT STAGE (Sensors and Pull-downs)
* -----------------------------------------------------------------------------
* S1: SPST Switch, function: Soil Moisture Sensor simulation.
* Wiring: Connects between node VCC and node SOIL_Status.
* Logic: Closed (Controlled by V_CTRL_S1 High) = Dry/Logic 1.
S1 VCC SOIL_Status N_CTRL_S1 0 SW_IDEAL
* ... (truncated in public view) ...

Copia este contenido en un archivo .cir y ejecútalo con ngspice.

🔒 Parte del contenido de esta sección es premium. Con el pase de 7 días o la suscripción mensual tendrás acceso al contenido completo (materiales, conexionado, compilación detallada, validación paso a paso, troubleshooting, mejoras/variantes y checklist) y podrás descargar el pack PDF listo para imprimir.

🔓 Ver planes de acceso premium 

* Title: Practical case: Conditional automatic irrigation system

* -----------------------------------------------------------------------------
* POWER SUPPLY
* -----------------------------------------------------------------------------
* V1: 5V DC supply, function: Main power source.
V1 VCC 0 DC 5

* -----------------------------------------------------------------------------
* STIMULI GENERATION (Simulating User Interaction)
* -----------------------------------------------------------------------------
* These voltage sources drive the control pins of the ideal switches (S1, S2)
* to simulate the physical sensors changing state over time.
* They are not part of the BOM but are necessary for dynamic simulation.

* Control signal for S1 (Soil Sensor): Period 200us
* Logic: 0 -> 1 -> 0 -> 1
V_CTRL_S1 N_CTRL_S1 0 PULSE(0 5 10u 1u 1u 100u 200u)

* Control signal for S2 (Tank Sensor): Period 400us
* Logic: 0 -> 0 -> 1 -> 1
V_CTRL_S2 N_CTRL_S2 0 PULSE(0 5 10u 1u 1u 200u 400u)

* -----------------------------------------------------------------------------
* INPUT STAGE (Sensors and Pull-downs)
* -----------------------------------------------------------------------------
* S1: SPST Switch, function: Soil Moisture Sensor simulation.
* Wiring: Connects between node VCC and node SOIL_Status.
* Logic: Closed (Controlled by V_CTRL_S1 High) = Dry/Logic 1.
S1 VCC SOIL_Status N_CTRL_S1 0 SW_IDEAL

* R1: 10 kΩ resistor, function: pull-down for Input A.
* Wiring: Connects between node SOIL_Status and node 0 (GND).
R1 SOIL_Status 0 10k

* S2: SPST Switch, function: Water Tank Level simulation.
* Wiring: Connects between node VCC and node TANK_Status.
* Logic: Closed (Controlled by V_CTRL_S2 High) = Water Present/Logic 1.
S2 VCC TANK_Status N_CTRL_S2 0 SW_IDEAL

* R2: 10 kΩ resistor, function: pull-down for Input B.
* Wiring: Connects between node TANK_Status and node 0 (GND).
R2 TANK_Status 0 10k

* -----------------------------------------------------------------------------
* LOGIC STAGE (74HC08 Quad 2-Input AND Gate)
* -----------------------------------------------------------------------------
* U1: 74HC08
* Wiring Guide:
* - Pin 1 (Input A) -> SOIL_Status
* - Pin 2 (Input B) -> TANK_Status
* - Pin 3 (Output Y) -> PUMP_Cmd
* - Pin 7 -> GND (0)
* - Pin 14 -> VCC
* Implemented as a subcircuit to strictly expose pins as nodes.
XU1 SOIL_Status TANK_Status PUMP_Cmd 0 VCC 74HC08_Behavioral

* -----------------------------------------------------------------------------
* OUTPUT STAGE (Indicator)
* -----------------------------------------------------------------------------
* R3: 330 Ω resistor, function: LED current limiting.
* Wiring: Connects between node PUMP_Cmd and node LED_Anode.
R3 PUMP_Cmd LED_Anode 330

* D1: Green LED, function: Water Pump active indicator.
* Wiring: Connects between node LED_Anode (Anode) and node 0 (GND).
D1 LED_Anode 0 LED_Green

* -----------------------------------------------------------------------------
* MODELS & SUBCIRCUITS
* -----------------------------------------------------------------------------
* Switch Model: Low On-Resistance, High Off-Resistance, Threshold 2.5V
.model SW_IDEAL SW(Vt=2.5 Ron=0.1 Roff=100Meg)

* LED Model: Generic Green LED approximation
.model LED_Green D(IS=1e-22 N=1.5 RS=5 BV=5 IBV=10u)

* 74HC08 Subcircuit (Behavioral Implementation)
* Pinout: 1=A, 2=B, 3=Y, 7=GND, 14=VCC
.subckt 74HC08_Behavioral 1 2 3 7 14
* Logic Y = A AND B
* Implementation: Continuous sigmoid function for robust convergence.
* Output voltage swings to V(14) (VCC) when both inputs > 2.5V.
B_AND 3 7 V = V(14,7) * (1 / (1 + exp(-40 * (V(1,7) - 2.5)))) * (1 / (1 + exp(-40 * (V(2,7) - 2.5))))
.ends

* -----------------------------------------------------------------------------
* ANALYSIS COMMANDS
* -----------------------------------------------------------------------------
* Transient analysis: 500us duration to capture all logic states (00, 10, 01, 11)
.tran 1u 500u

* Print critical nodes for verification
.print tran V(SOIL_Status) V(TANK_Status) V(PUMP_Cmd) V(LED_Anode)

* Calculate DC operating point
.op

.end

Resultados de Simulación (Transitorio)

Resultados de Simulación (Transitorio)
Show raw data table (1202 rows) 
Index   time            v(soil_status)  v(tank_status)  v(pump_cmd)
0	0.000000e+00	4.999500e-04	4.999500e-04	7.201843e-87
1	1.000000e-08	4.999500e-04	4.999500e-04	7.201843e-87
2	2.000000e-08	4.999500e-04	4.999500e-04	7.201843e-87
3	4.000000e-08	4.999500e-04	4.999500e-04	7.201843e-87
4	8.000000e-08	4.999500e-04	4.999500e-04	7.201843e-87
5	1.600000e-07	4.999500e-04	4.999500e-04	7.201843e-87
6	3.200000e-07	4.999500e-04	4.999500e-04	7.201843e-87
7	6.400000e-07	4.999500e-04	4.999500e-04	7.201843e-87
8	1.280000e-06	4.999500e-04	4.999500e-04	7.201843e-87
9	2.280000e-06	4.999500e-04	4.999500e-04	7.201843e-87
10	3.280000e-06	4.999500e-04	4.999500e-04	7.201843e-87
11	4.280000e-06	4.999500e-04	4.999500e-04	7.201843e-87
12	5.280000e-06	4.999500e-04	4.999500e-04	7.201843e-87
13	6.280000e-06	4.999500e-04	4.999500e-04	7.201843e-87
14	7.280000e-06	4.999500e-04	4.999500e-04	7.201843e-87
15	8.280000e-06	4.999500e-04	4.999500e-04	7.201843e-87
16	9.280000e-06	4.999500e-04	4.999500e-04	7.201843e-87
17	1.000000e-05	4.999500e-04	4.999500e-04	7.201843e-87
18	1.010000e-05	4.999500e-04	4.999500e-04	7.201843e-87
19	1.026000e-05	4.999500e-04	4.999500e-04	7.201843e-87
20	1.030750e-05	4.999500e-04	4.999500e-04	7.201843e-87
21	1.039062e-05	4.999500e-04	4.999500e-04	7.201843e-87
22	1.041363e-05	4.999500e-04	4.999500e-04	7.201843e-87
23	1.045390e-05	4.999500e-04	4.999500e-04	7.201843e-87
... (1178 more rows) ...

Errores comunes y cómo evitarlos

  • Entradas flotantes: Olvidar R1 o R2 hace que las entradas «floten», provocando que el LED parpadee o se encienda aleatoriamente cuando los interruptores están abiertos. Solución: Verifica siempre que las resistencias pull-down estén conectadas a Tierra.
  • Orientación del LED: Colocar el LED al revés impide que se encienda incluso cuando la lógica es correcta. Solución: Asegúrate de que la pata más larga (Ánodo) mire hacia la resistencia y el CI.
  • Confusión de chips: Usar un 74HC32 (puerta OR) en lugar de un 74HC08 (puerta AND). Solución: Lee el texto impreso en la parte superior del CI antes de insertarlo. Si se comporta como «Bomba encendida si CUALQUIERA de las condiciones se cumple», tienes el chip equivocado.

Solución de problemas

  • Síntoma: El LED está siempre ENCENDIDO, independientemente de los interruptores.
    • Causa: Las entradas podrían estar en cortocircuito directo a VCC, o el CI está dañado.
    • Solución: Revisa el cableado en los Pines 1 y 2. Asegúrate de que R1 y R2 vayan a Tierra, no a VCC.
  • Síntoma: El LED es muy tenue cuando está activo.
    • Causa: El valor de R3 es demasiado alto.
    • Solución: Reemplaza R3 con un valor entre 220 Ω y 470 Ω.
  • Síntoma: El circuito funciona inversamente (LED apagado cuando los interruptores están cerrados).
    • Causa: Podrías estar usando una puerta NAND (como 74HC00) o conectaste el LED a VCC en lugar de a Tierra (fuente vs sumidero).
    • Solución: Verifica que el número de parte sea 74HC08 y que el Cátodo del LED esté en Tierra.

Posibles mejoras y extensiones

  1. Interfaz de alta potencia: Reemplaza el LED con un transistor NPN (por ejemplo, 2N2222) y un relé para controlar una bomba de agua real de 12V.
  2. Control manual: Añade un tercer interruptor conectado a una puerta OR después de la salida de la puerta AND, permitiendo al usuario forzar el encendido de la bomba independientemente de los sensores.

Más Casos Prácticos en Prometeo.blog

Encuentra este producto y/o libros sobre este tema en Amazon

Ir a Amazon

Como afiliado de Amazon, gano con las compras que cumplan los requisitos. Si compras a través de este enlace, ayudas a mantener este proyecto.

Quiz rápido

Pregunta 1: ¿Cuál es el objetivo principal del circuito descrito en el artículo?




Pregunta 2: ¿Qué circuito integrado (CI) se utiliza como componente principal para la lógica?




Pregunta 3: ¿Qué función lógica representa el circuito construido?




Pregunta 4: ¿Qué condición simula el Interruptor A (Sensor de suelo) cuando está en ALTO?




Pregunta 5: ¿Qué sucede con el LED de salida si el tanque está vacío (Interruptor B = BAJO)?




Pregunta 6: ¿Cuál es uno de los beneficios mencionados sobre la protección del equipo?




Pregunta 7: ¿Qué fórmula booleana representa la función lógica de este circuito?




Pregunta 8: ¿Qué condiciones deben cumplirse para que el LED (Bomba) se ENCIENDA?




Pregunta 9: ¿Qué concepto de lógica industrial demuestra este proyecto?




Pregunta 10: ¿Qué función cumple el Interruptor B en la simulación?




Carlos Núñez Zorrilla
Carlos Núñez Zorrilla
Electronics & Computer Engineer

Ingeniero Superior en Electrónica de Telecomunicaciones e Ingeniero en Informática (titulaciones oficiales en España).

Sígueme:

Caso práctico: Activación de alarma con doble sensor

Prototipo de Activación de alarma con doble sensor (Maker Style)

Nivel: Básico. Implementa un circuito lógico donde una alarma suena solo si dos sensores distintos se activan simultáneamente.

Objetivo y caso de uso

En este tutorial, construirás un circuito lógico de seguridad utilizando un circuito integrado 74HC08 (puerta AND). El circuito procesa señales de dos interruptores independientes (simulando un sensor de puerta y uno de ventana) y activa un LED de salida solo cuando ambos interruptores están cerrados al mismo tiempo.

Por qué es útil:
* Enclavamientos de seguridad: Asegura que la maquinaria funcione solo cuando un operador presiona dos botones simultáneamente, manteniendo ambas manos alejadas del peligro.
* Sistemas de seguridad: Dispara una alarma específica de alta prioridad solo cuando se vulneran múltiples zonas simultáneamente.
* Validación de datos: Las puertas lógicas son fundamentales para validar que se cumplan dos condiciones necesarias (por ejemplo, «Sistema listo» Y «Comando de inicio») antes de ejecutar una acción.

Resultado esperado:
* Entrada A (Baja) + Entrada B (Baja): El LED permanece APAGADO (salida de 0 V).
* Entrada A (Alta) + Entrada B (Baja): El LED permanece APAGADO (salida de 0 V).
* Entrada A (Baja) + Entrada B (Alta): El LED permanece APAGADO (salida de 0 V).
* Entrada A (Alta) + Entrada B (Alta): El LED se ENCIENDE (salida de ~5 V).
* Público objetivo: Estudiantes de electrónica y aficionados que se inician en la lógica digital.

Materiales

  • V1: Fuente de CC de 5 V, función: Fuente de alimentación principal.
  • S1: Interruptor SPST, función: Sensor A (Puerta).
  • S2: Interruptor SPST, función: Sensor B (Ventana).
  • R1: Resistencia de 10 kΩ, función: Pull-down para el Sensor A (evita estado flotante).
  • R2: Resistencia de 10 kΩ, función: Pull-down para el Sensor B.
  • U1: Puerta AND cuádruple de 2 entradas 74HC08, función: Núcleo de decisión lógica.
  • R3: Resistencia de 330 Ω, función: Limitación de corriente del LED.
  • D1: LED rojo, función: Indicador visual de alarma.

Pin-out del CI utilizado

Chip seleccionado: 74HC08 (Puerta AND cuádruple de 2 entradas).
Nota: Este chip contiene cuatro puertas independientes. Usaremos solo una.

Pin Nombre Función lógica Conexión en este caso
1 1A Entrada A Conectar al nodo SENSOR_A
2 1B Entrada B Conectar al nodo SENSOR_B
3 1Y Salida Conectar al nodo ALARM_OUT
7 GND Tierra Conectar al nodo 0 (GND)
14 VCC Alimentación Conectar al nodo VCC (+5 V)

Guía de conexionado

Construye el circuito siguiendo estas conexiones utilizando nombres de nodo específicos:

  • V1: Conecta el terminal positivo al nodo VCC y el terminal negativo al nodo 0.
  • Alimentación U1: Conecta el Pin 14 a VCC y el Pin 7 a 0.
  • S1: Conecta un lado a VCC y el otro lado al nodo SENSOR_A.
  • R1: Conecta entre el nodo SENSOR_A y el nodo 0.
  • S2: Conecta un lado a VCC y el otro lado al nodo SENSOR_B.
  • R2: Conecta entre el nodo SENSOR_B y el nodo 0.
  • Lógica U1:
    • Conecta el Pin 1 al nodo SENSOR_A.
    • Conecta el Pin 2 al nodo SENSOR_B.
    • Conecta el Pin 3 al nodo ALARM_OUT.
  • Etapa de salida:
    • R3: Conecta entre el nodo ALARM_OUT y el nodo LED_ANODE.
    • D1: Conecta el Ánodo al nodo LED_ANODE y el Cátodo al nodo 0.

Diagrama de bloques conceptual

Conceptual block diagram — 74HC08 AND gate

Esquemático

[ INPUT SENSORS ]                          [ LOGIC CORE ]                       [ OUTPUT ALARM ]

                                                   +--------------+
    [ VCC ] --> [ S1: Door ] --(SENSOR_A)--------->| Pin 1        |
                                   |               |              |
                                   +-> [ R1: 10k ] |              |
                                          |        |  U1: 74HC08  |
                                       [ GND ]     |  (AND Gate)  |--(ALARM_OUT)--> [ R3: 330 Ω ] --> [ D1: LED ] --> [ GND ]
                                                   |              |
                                                   |              |
    [ VCC ] --> [ S2: Window ] --(SENSOR_B)------->| Pin 2        |
                                   |               |              |
                                   +-> [ R2: 10k ] | Power:       |
                                          |        | 14(VCC), 7(0)|
                                       [ GND ]     +--------------+
Esquema Eléctrico

Diagrama eléctrico

Diagrama eléctrico de la activación de alarma con doble sensor
Generado desde la netlist SPICE validada del caso.

🔒 Este diagrama eléctrico es premium. Con el pase de 7 días o la suscripción mensual podrás desbloquear el material didáctico completo y el pack PDF listo para imprimir.🔓 Ver planes de acceso premium

Tabla de verdad

La salida del 74HC08 es Alta (1) solo si ambas entradas son Altas (1).

Sensor A (S1) Sensor B (S2) Salida (Pin 3) Estado del LED
0 (Abierto) 0 (Abierto) 0 (Bajo) APAGADO
0 (Abierto) 1 (Cerrado) 0 (Bajo) APAGADO
1 (Cerrado) 0 (Abierto) 0 (Bajo) APAGADO
1 (Cerrado) 1 (Cerrado) 1 (Alto) ENCENDIDO

Mediciones y pruebas

  1. Verificación de alimentación: Mide el voltaje entre VCC y 0. Debe ser estable a 5 V.
  2. Estado de reposo: Asegúrate de que tanto S1 como S2 estén abiertos. Mide el voltaje en el Pin 1 y el Pin 2 de U1. Ambos deben ser 0 V (Lógica 0). El LED debe estar APAGADO.
  3. Prueba de disparo único: Cierra solo S1. El Pin 1 debe leer 5 V, el Pin 2 debe leer 0 V. Mide el Pin 3 (Salida); debe permanecer en 0 V. Repite solo para S2.
  4. Activación de alarma: Cierra tanto S1 como S2. Mide el Pin 1 y el Pin 2; ambos deben ser 5 V. Mide el Pin 3; debe saltar a ~5 V (Lógica 1).
  5. Corriente de salida: Comprueba que D1 se ilumina intensamente. La caída de voltaje a través de R3 debe ser de aproximadamente 3 V (dependiendo del color del LED).

Netlist SPICE y simulación

Netlist SPICE de referencia (ngspice) — extractoNetlist SPICE completo (ngspice)

* Title: Practical case: Dual sensor alarm activation

* ==============================================================================
* Models
* ==============================================================================
* Generic Red LED Model
* IS: Saturation current, N: Emission coefficient, RS: Series resistance
.model DLED D(IS=1e-14 N=1.5 RS=5 BV=5 IBV=10u CJO=10p TT=10n)

* Voltage Controlled Switch Model (for S1, S2)
* Simulates a physical SPST switch
* Vt: Threshold voltage (2.5V), Ron: On resistance (1 ohm), Roff: Off resistance (100Meg)
.model SW_SENSOR SW(Vt=2.5 Ron=1 Roff=100Meg)

* ==============================================================================
* Subcircuits
* ==============================================================================
* U1: 74HC08 Quad 2-Input AND Gate (Single Gate Implementation)
* Pins: 1=A, 2=B, 3=Y, 7=GND, 14=VCC
.subckt 74HC08_GATE 1 2 3 7 14
* Behavioral implementation using continuous sigmoid functions for convergence robustness.
* Logic: V_out = VCC * sigmoid(A) * sigmoid(B)
* The slope factor (50) ensures a sharp transition near the 2.5V threshold.
B_LOGIC 3 7 V = V(14) * (1 / (1 + exp(-50 * (V(1) - 2.5)))) * (1 / (1 + exp(-50 * (V(2) - 2.5))))
.ends

* ==============================================================================
* Main Circuit
* ==============================================================================

* ... (truncated in public view) ...

Copia este contenido en un archivo .cir y ejecútalo con ngspice.

🔒 Parte del contenido de esta sección es premium. Con el pase de 7 días o la suscripción mensual tendrás acceso al contenido completo (materiales, conexionado, compilación detallada, validación paso a paso, troubleshooting, mejoras/variantes y checklist) y podrás descargar el pack PDF listo para imprimir.

🔓 Ver planes de acceso premium 

* Title: Practical case: Dual sensor alarm activation

* ==============================================================================
* Models
* ==============================================================================
* Generic Red LED Model
* IS: Saturation current, N: Emission coefficient, RS: Series resistance
.model DLED D(IS=1e-14 N=1.5 RS=5 BV=5 IBV=10u CJO=10p TT=10n)

* Voltage Controlled Switch Model (for S1, S2)
* Simulates a physical SPST switch
* Vt: Threshold voltage (2.5V), Ron: On resistance (1 ohm), Roff: Off resistance (100Meg)
.model SW_SENSOR SW(Vt=2.5 Ron=1 Roff=100Meg)

* ==============================================================================
* Subcircuits
* ==============================================================================
* U1: 74HC08 Quad 2-Input AND Gate (Single Gate Implementation)
* Pins: 1=A, 2=B, 3=Y, 7=GND, 14=VCC
.subckt 74HC08_GATE 1 2 3 7 14
* Behavioral implementation using continuous sigmoid functions for convergence robustness.
* Logic: V_out = VCC * sigmoid(A) * sigmoid(B)
* The slope factor (50) ensures a sharp transition near the 2.5V threshold.
B_LOGIC 3 7 V = V(14) * (1 / (1 + exp(-50 * (V(1) - 2.5)))) * (1 / (1 + exp(-50 * (V(2) - 2.5))))
.ends

* ==============================================================================
* Main Circuit
* ==============================================================================

* --- Power Supply ---
* V1: 5 V DC supply (Main Power)
V1 VCC 0 DC 5

* --- Actuation Control Signals (Simulation Stimuli) ---
* These voltage sources act as the "hand" pressing the switches.
* They define the timing for the Truth Table test.
* ACT_A: Period 200us (High 0-100us)
V_ACT_A ACT_A 0 PULSE(0 5 0 1u 1u 100u 200u)
* ACT_B: Period 400us (High 0-200us)
V_ACT_B ACT_B 0 PULSE(0 5 0 1u 1u 200u 400u)

* --- Input A: Door Sensor ---
* S1: SPST Switch. Connects VCC to SENSOR_A when ACT_A is High (>2.5V).
S1 VCC SENSOR_A ACT_A 0 SW_SENSOR
* R1: 10 kΩ resistor. Pull-down for Sensor A.
R1 SENSOR_A 0 10k

* --- Input B: Window Sensor ---
* S2: SPST Switch. Connects VCC to SENSOR_B when ACT_B is High (>2.5V).
S2 VCC SENSOR_B ACT_B 0 SW_SENSOR
* R2: 10 kΩ resistor. Pull-down for Sensor B.
R2 SENSOR_B 0 10k

* --- Logic Core: U1 (74HC08) ---
* Instantiating the logic gate subcircuit.
* Mapping: Pin 1->SENSOR_A, Pin 2->SENSOR_B, Pin 3->ALARM_OUT, Pin 7->0, Pin 14->VCC
XU1 SENSOR_A SENSOR_B ALARM_OUT 0 VCC 74HC08_GATE

* --- Output Stage ---
* R3: 330 Ω resistor (Current limiting)
R3 ALARM_OUT LED_ANODE 330
* D1: Red LED (Visual indicator)
D1 LED_ANODE 0 DLED

* ==============================================================================
* Analysis Directives
* ==============================================================================
* Transient analysis: Step 1us, Stop 500us
* This duration covers all combinations of the input pulses (00, 01, 10, 11).
.tran 1u 500u

* Print required nodes for log output
.print tran V(SENSOR_A) V(SENSOR_B) V(ALARM_OUT) V(LED_ANODE)

* Calculate DC operating point
.op

.end

Resultados de Simulación (Transitorio)

Resultados de Simulación (Transitorio)
Show raw data table (1294 rows) 
Index   time            v(sensor_a)     v(sensor_b)     v(alarm_out)
0	0.000000e+00	4.999500e-04	4.999500e-04	1.403014e-108
1	1.000000e-08	4.999500e-04	4.999500e-04	1.403014e-108
2	2.000000e-08	4.999500e-04	4.999500e-04	1.403014e-108
3	4.000000e-08	4.999500e-04	4.999500e-04	1.403014e-108
4	8.000000e-08	4.999500e-04	4.999500e-04	1.403014e-108
5	1.600000e-07	4.999500e-04	4.999500e-04	1.403014e-108
6	3.200000e-07	4.999500e-04	4.999500e-04	1.403014e-108
7	3.562500e-07	4.999500e-04	4.999500e-04	1.403014e-108
8	4.196875e-07	4.999500e-04	4.999500e-04	1.403014e-108
9	4.372461e-07	4.999500e-04	4.999500e-04	1.403014e-108
10	4.679736e-07	4.999500e-04	4.999500e-04	1.403014e-108
11	4.795524e-07	4.999500e-04	4.999500e-04	1.403014e-108
12	4.902290e-07	4.999500e-04	4.999500e-04	1.403014e-108
13	5.023412e-07	4.999500e+00	4.999500e+00	5.000000e+00
14	5.138119e-07	4.999500e+00	4.999500e+00	5.000000e+00
15	5.256739e-07	4.999500e+00	4.999500e+00	5.000000e+00
16	5.378128e-07	4.999500e+00	4.999500e+00	5.000000e+00
17	5.539238e-07	4.999500e+00	4.999500e+00	5.000000e+00
18	5.828205e-07	4.999500e+00	4.999500e+00	5.000000e+00
19	6.384927e-07	4.999500e+00	4.999500e+00	5.000000e+00
20	7.166884e-07	4.999500e+00	4.999500e+00	5.000000e+00
21	8.730798e-07	4.999500e+00	4.999500e+00	5.000000e+00
22	1.000000e-06	4.999500e+00	4.999500e+00	5.000000e+00
23	1.031278e-06	4.999500e+00	4.999500e+00	5.000000e+00
... (1270 more rows) ...

Errores comunes y cómo evitarlos

  1. Entradas flotantes: Omitir R1 o R2 hace que las entradas «floten» cuando los interruptores están abiertos. El 74HC08 puede captar ruido y dispararse erráticamente. Solución: Usa siempre resistencias pull-down (10 kΩ) conectadas a tierra.
  2. Falta de alimentación al CI: Los estudiantes a menudo cablean los pines lógicos pero olvidan los Pines 14 (VCC) y 7 (GND). Solución: Cablea siempre los rieles de alimentación primero.
  3. Sin limitación de corriente: Conectar el LED directamente a la salida del CI sin R3 dañará el LED o el 74HC08. Solución: Asegúrate de que haya una resistencia de 220 Ω a 470 Ω en serie con el LED.

Solución de problemas

  • El LED nunca se ENCIENDE:
    • Comprueba si la polaridad del LED es correcta (Ánodo a resistencia, Cátodo a tierra).
    • Verifica que el 74HC08 tenga alimentación en el Pin 14.
    • Asegúrate de que ambos interruptores estén haciendo buen contacto.
  • El LED actúa erráticamente o se ENCIENDE cuando los interruptores están APAGADOS:
    • Comprueba si faltan las resistencias pull-down R1 y R2.
    • Verifica que estás usando un 74HC08 (AND) y no un 74HC32 (OR) o 74HC00 (NAND).
  • El LED es muy tenue:
    • El valor de R3 podría ser demasiado alto (p. ej., 100 kΩ en lugar de 330 Ω).
    • El voltaje de la fuente V1 podría ser demasiado bajo (< 3 V).

Posibles mejoras y extensiones

  1. Alarma audible: Conecta un zumbador activo de 5 V en paralelo con el LED (y su resistencia) o usa un controlador de transistor para emitir un ruido cuando se active la alarma.
  2. Cerrojo de memoria: Alimenta la salida a un Latch Set-Reset (SR) o Flip-Flop para que, una vez activada la alarma, permanezca ENCENDIDA incluso si los sensores se cierran de nuevo, requiriendo un botón de reinicio manual.

Más Casos Prácticos en Prometeo.blog

Encuentra este producto y/o libros sobre este tema en Amazon

Ir a Amazon

Como afiliado de Amazon, gano con las compras que cumplan los requisitos. Si compras a través de este enlace, ayudas a mantener este proyecto.

Quiz rápido

Pregunta 1: ¿Qué circuito integrado se utiliza en este tutorial para implementar la lógica de seguridad?




Pregunta 2: ¿Cuál es la función principal del circuito descrito?




Pregunta 3: ¿Qué sucede con el LED si la Entrada A es Alta y la Entrada B es Baja?




Pregunta 4: ¿Por qué es útil este circuito en maquinaria industrial según el texto?




Pregunta 5: ¿Qué condición lógica representa el funcionamiento de este circuito?




Pregunta 6: ¿Qué nivel de dificultad tiene este tutorial según el contexto?




Pregunta 7: ¿Qué ejemplo de validación de datos se menciona en el texto?




Pregunta 8: ¿Qué simulan los dos interruptores independientes en el circuito?




Pregunta 9: ¿Cuál es el resultado esperado si ambas entradas (A y B) son bajas?




Pregunta 10: ¿Qué aplicación de seguridad se menciona para disparar una alarma de alta prioridad?




Carlos Núñez Zorrilla
Carlos Núñez Zorrilla
Electronics & Computer Engineer

Ingeniero Superior en Electrónica de Telecomunicaciones e Ingeniero en Informática (titulaciones oficiales en España).

Sígueme:

Caso práctico: Control de iluminación desde dos puntos

Prototipo de Control de iluminación desde dos puntos (Maker Style)

Nivel: Básico. Construya un circuito donde una luz piloto pueda ser activada desde dos interruptores independientes utilizando lógica digital.

Objetivo y caso de uso

En este proyecto, construirá un circuito de control digital utilizando una compuerta OR 74HC32 para alimentar un indicador LED cuando se accione cualquiera de los dos pulsadores. Esto demuestra la función lógica fundamental donde una salida es verdadera si al menos una entrada es verdadera.

Por qué es útil:
* Domótica: Simula un sistema de luz de pasillo donde múltiples interruptores pueden encender una luz.
* Sistemas de seguridad: Representa una zona de disparo de alarma donde cualquier sensor individual (puerta o ventana) activa la sirena.
* Automotriz: Funciona como las luces interiores del techo que se encienden si la puerta del conductor O la del pasajero se abre.
* Seguridad industrial: Actúa como un sistema de parada de emergencia donde presionar cualquier botón en una línea de producción detiene la máquina.

Resultado esperado:
* Estado del LED: El LED permanece APAGADO (Lógica 0) solo cuando ambos botones están liberados.
* Pulsación única: Presionar el Botón A ENCIENDE el LED (Lógica 1).
* Pulsación única: Presionar el Botón B ENCIENDE el LED (Lógica 1).
* Pulsación simultánea: Presionar ambos botones mantiene el LED ENCENDIDO (Lógica 1).
* Público objetivo: Estudiantes y aficionados que aprenden compuertas lógicas digitales básicas.

Materiales

  • V1: Fuente de alimentación de 5 V CC
  • U1: 74HC32 (CI de cuádruple compuerta OR de 2 entradas)
  • S1: Pulsador momentáneo (NO – Normalmente Abierto), función: Entrada A
  • S2: Pulsador momentáneo (NO – Normalmente Abierto), función: Entrada B
  • R1: Resistencia de 10 kΩ, función: Pull-down para Entrada A
  • R2: Resistencia de 10 kΩ, función: Pull-down para Entrada B
  • R3: Resistencia de 330 Ω, función: Limitación de corriente del LED
  • D1: LED rojo, función: Indicador de salida lógica

Pin-out del CI utilizado

Chip: 74HC32 (Cuádruple compuerta OR de 2 entradas)

Pin Nombre Función lógica Conexión en este caso
1 1A Entrada A Conectado a S1 y R1
2 1B Entrada B Conectado a S2 y R2
3 1Y Salida Conectado a R3 (driver del LED)
7 GND Tierra (Masa) Conectado a 0V
14 VCC Fuente de alimentación Conectado a +5V

Guía de conexionado

Esta guía define las conexiones utilizando nombres de nodo específicos para asegurar un ensamblaje limpio del circuito.

  • Nodos de alimentación:

    • VCC: Conecte el terminal positivo de V1 al Pin 14 de U1.
    • 0 (GND): Conecte el terminal negativo de V1 al Pin 7 de U1.

  • Lógica de entrada A (NODE_A):

    • Conecte S1 entre VCC y NODE_A.
    • Conecte R1 entre NODE_A y 0 (GND).
    • Conecte el Pin 1 de U1 a NODE_A.

  • Lógica de entrada B (NODE_B):

    • Conecte S2 entre VCC y NODE_B.
    • Conecte R2 entre NODE_B y 0 (GND).
    • Conecte el Pin 2 de U1 a NODE_B.

  • Lógica de salida (NODE_Y):

    • Conecte el Pin 3 de U1 a un extremo de R3.
    • Conecte el otro extremo de R3 al ánodo (patilla larga) de D1.
    • Conecte el cátodo (patilla corta) de D1 a 0 (GND).

Diagrama de bloques conceptual

Conceptual block diagram — 74HC32 OR gate

Esquemático

[ INPUTS ]                                  [ LOGIC ]                                [ OUTPUT ]

[ VCC ]--> [ S1 (NO) ] --+--(NODE_A)----------->+-------------+
                         |  (Pin 1)             |             |
                    [ R1 (10k) ]                |  U1: 74HC32 |
                         v                      |  (OR Gate)  |--(NODE_Y)--> [ R3 (330) ] --> [ D1 (LED) ] --> [ GND ]
                      [ GND ]                   |  (Pin 3)    |
                                                |             |
[ VCC ]--> [ S2 (NO) ] --+--(NODE_B)----------->+-------------+
                         |  (Pin 2)
                    [ R2 (10k) ]
                         v
                      [ GND ]
Esquema Eléctrico

Diagrama eléctrico

Diagrama eléctrico del caso: Control de iluminación desde dos puntos
Generado desde la netlist SPICE validada del caso.

🔒 Este diagrama eléctrico es premium. Con el pase de 7 días o la suscripción mensual podrás desbloquear el material didáctico completo y el pack PDF listo para imprimir.🔓 Ver planes de acceso premium

Tabla de verdad

El 74HC32 sigue la tabla lógica OR estándar:

Entrada A (S1) Entrada B (S2) Salida Y (LED) Descripción del estado
0 (Liberado) 0 (Liberado) 0 (OFF) Sin señal activa
0 (Liberado) 1 (Pulsado) 1 (ON) Activado por B
1 (Pulsado) 0 (Liberado) 1 (ON) Activado por A
1 (Pulsado) 1 (Pulsado) 1 (ON) Activado por ambos

Mediciones y pruebas

  1. Comprobación en reposo: Antes de presionar nada, mida el voltaje en NODE_A y NODE_B con respecto a GND. Debería ser cercano a 0V (Lógica 0) debido a las resistencias pull-down. El LED debería estar apagado.
  2. Prueba de entrada A: Presione S1. Mida el voltaje en NODE_A; debería subir a 5V. Verifique que D1 se enciende.
  3. Prueba de entrada B: Presione S2. Mida el voltaje en NODE_B; debería subir a 5V. Verifique que D1 se enciende.
  4. Prueba combinada: Presione ambos botones simultáneamente. El LED debería permanecer encendido sin parpadear.

Netlist SPICE y simulación

Netlist SPICE de referencia (ngspice) — extractoNetlist SPICE completo (ngspice)

* Practical case: Lighting control from two points

* --- Power Supply ---
* V1: 5V DC Supply connected to VCC and GND (0)
V1 VCC 0 DC 5

* --- Input A ---
* S1: Momentary Push Button (NO)
* Modeled as a voltage-controlled switch (S1) driven by a pulse source (V_ACT_A)
* to simulate the physical user action of pressing the button.
V_ACT_A ACT_A 0 PULSE(0 5 50u 1u 1u 100u 200u)
S1 VCC NODE_A ACT_A 0 SW_BTN

* R1: 10k Pull-down resistor for Input A
R1 NODE_A 0 10k

* --- Input B ---
* S2: Momentary Push Button (NO)
* Modeled as a voltage-controlled switch (S2) driven by a pulse source (V_ACT_B)
V_ACT_B ACT_B 0 PULSE(0 5 50u 1u 1u 200u 400u)
S2 VCC NODE_B ACT_B 0 SW_BTN

* R2: 10k Pull-down resistor for Input B
R2 NODE_B 0 10k

* --- Logic IC U1: 74HC32 (Quad 2-Input OR Gate) ---
* Wiring Guide: Pin 1 to NODE_A, Pin 2 to NODE_B, Pin 3 to NODE_Y
* Pin 7 to GND (0), Pin 14 to VCC
XU1 NODE_A NODE_B NODE_Y 0 VCC 74HC32

* ... (truncated in public view) ...

Copia este contenido en un archivo .cir y ejecútalo con ngspice.

🔒 Parte del contenido de esta sección es premium. Con el pase de 7 días o la suscripción mensual tendrás acceso al contenido completo (materiales, conexionado, compilación detallada, validación paso a paso, troubleshooting, mejoras/variantes y checklist) y podrás descargar el pack PDF listo para imprimir.

🔓 Ver planes de acceso premium 

* Practical case: Lighting control from two points

* --- Power Supply ---
* V1: 5V DC Supply connected to VCC and GND (0)
V1 VCC 0 DC 5

* --- Input A ---
* S1: Momentary Push Button (NO)
* Modeled as a voltage-controlled switch (S1) driven by a pulse source (V_ACT_A)
* to simulate the physical user action of pressing the button.
V_ACT_A ACT_A 0 PULSE(0 5 50u 1u 1u 100u 200u)
S1 VCC NODE_A ACT_A 0 SW_BTN

* R1: 10k Pull-down resistor for Input A
R1 NODE_A 0 10k

* --- Input B ---
* S2: Momentary Push Button (NO)
* Modeled as a voltage-controlled switch (S2) driven by a pulse source (V_ACT_B)
V_ACT_B ACT_B 0 PULSE(0 5 50u 1u 1u 200u 400u)
S2 VCC NODE_B ACT_B 0 SW_BTN

* R2: 10k Pull-down resistor for Input B
R2 NODE_B 0 10k

* --- Logic IC U1: 74HC32 (Quad 2-Input OR Gate) ---
* Wiring Guide: Pin 1 to NODE_A, Pin 2 to NODE_B, Pin 3 to NODE_Y
* Pin 7 to GND (0), Pin 14 to VCC
XU1 NODE_A NODE_B NODE_Y 0 VCC 74HC32

* --- Output Stage ---
* R3: 330 Ohm LED current limiting resistor
R3 NODE_Y NODE_LED 330

* D1: Red LED Logic output indicator
D1 NODE_LED 0 LED_RED

* --- Models and Subcircuits ---

* Switch Model (Normally Open)
* Vt=2.5V: Threshold voltage for switching
* Ron=0.1: Low resistance when closed
* Roff=10Meg: High resistance when open
.model SW_BTN SW(Vt=2.5 Ron=0.1 Roff=10Meg)

* LED Model (Generic Red LED)
.model LED_RED D(IS=1e-22 N=1.5 RS=5 BV=5 IBV=10u CJO=10p)

* 74HC32 Behavioral Subcircuit
* Implements robust continuous logic to avoid convergence issues
.subckt 74HC32 1 2 3 7 14
* Pin Definitions: 1=InputA, 2=InputB, 3=OutputY, 7=GND, 14=VCC
* Logic: Y = A OR B
* Implemented using Sigmoid function S(x) = 1 / (1 + exp(-k*(x-threshold)))
* OR(A,B) is equivalent to 1 - (NOT_A * NOT_B)
* V(14) scales the output to the supply rail
B_OR 3 7 V = V(14) * (1 - ( (1/(1+exp(-20*(V(1)-2.5)))) * (1/(1+exp(-20*(V(2)-2.5)))) ))
.ends

* --- Simulation Directives ---
* Transient analysis for 600us to capture all logic states of the pulses
.tran 1u 600u

* Print required voltages for analysis
.print tran V(NODE_A) V(NODE_B) V(NODE_Y) V(NODE_LED)

* Calculate DC operating point
.op

.end

Resultados de Simulación (Transitorio)

Resultados de Simulación (Transitorio)
Show raw data table (1562 rows) 
Index   time            v(node_a)       v(node_b)       v(node_y)
0	0.000000e+00	4.995005e-03	4.995005e-03	5.000000e+00
1	1.000000e-08	4.995005e-03	4.995005e-03	5.000000e+00
2	2.000000e-08	4.995005e-03	4.995005e-03	5.000000e+00
3	4.000000e-08	4.995005e-03	4.995005e-03	5.000000e+00
4	8.000000e-08	4.995005e-03	4.995005e-03	5.000000e+00
5	1.600000e-07	4.995005e-03	4.995005e-03	5.000000e+00
6	3.200000e-07	4.995005e-03	4.995005e-03	5.000000e+00
7	6.400000e-07	4.995005e-03	4.995005e-03	5.000000e+00
8	1.280000e-06	4.995005e-03	4.995005e-03	5.000000e+00
9	2.280000e-06	4.995005e-03	4.995005e-03	5.000000e+00
10	3.280000e-06	4.995005e-03	4.995005e-03	5.000000e+00
11	4.280000e-06	4.995005e-03	4.995005e-03	5.000000e+00
12	5.280000e-06	4.995005e-03	4.995005e-03	5.000000e+00
13	6.280000e-06	4.995005e-03	4.995005e-03	5.000000e+00
14	7.280000e-06	4.995005e-03	4.995005e-03	5.000000e+00
15	8.280000e-06	4.995005e-03	4.995005e-03	5.000000e+00
16	9.280000e-06	4.995005e-03	4.995005e-03	5.000000e+00
17	1.028000e-05	4.995005e-03	4.995005e-03	5.000000e+00
18	1.128000e-05	4.995005e-03	4.995005e-03	5.000000e+00
19	1.228000e-05	4.995005e-03	4.995005e-03	5.000000e+00
20	1.328000e-05	4.995005e-03	4.995005e-03	5.000000e+00
21	1.428000e-05	4.995005e-03	4.995005e-03	5.000000e+00
22	1.528000e-05	4.995005e-03	4.995005e-03	5.000000e+00
23	1.628000e-05	4.995005e-03	4.995005e-03	5.000000e+00
... (1538 more rows) ...

Errores comunes y cómo evitarlos

  1. Dejar entradas flotantes: No instalar las resistencias pull-down (R1, R2) hace que las entradas «floten», lo que a menudo lleva a que el LED parpadee o se quede encendido permanentemente debido al ruido estático. Siempre conecte las entradas no utilizadas a GND o VCC.
  2. Falta de alimentación al chip: Olvidar conectar el Pin 14 a +5V y el Pin 7 a GND. Las compuertas lógicas dentro del chip no pueden funcionar sin energía.
  3. Orientación del LED: Insertar el LED al revés (ánodo a tierra). El LED actuará como un circuito abierto y nunca se encenderá.

Solución de problemas

  • El LED está siempre ENCENDIDO:
    • Verifique si falta R1 o R2 o si están desconectadas.
    • Verifique que está usando un botón Normalmente Abierto (NO/NA), no uno Normalmente Cerrado (NC).
  • El LED no se ENCIENDE cuando se presionan los botones:
    • Verifique las conexiones de alimentación de U1 (Pines 7 y 14).
    • Asegúrese de que el LED esté orientado correctamente (Lado plano/patilla corta a GND).
  • El LED es muy tenue:
    • El valor de R3 podría ser demasiado alto (por ejemplo, usar 10 kΩ en lugar de 330 Ω).
    • El voltaje de alimentación V1 podría ser demasiado bajo.

Posibles mejoras y extensiones

  1. Control de tres puntos: Conecte en cascada una segunda compuerta OR (usando las compuertas restantes en el chip 74HC32) para agregar un tercer interruptor, permitiendo el control desde tres ubicaciones.
  2. Circuito de enclavamiento (Latch): Agregue un bucle de retroalimentación o use un latch SR para que presionar un botón una vez encienda la luz y la mantenga encendida hasta que se presione un botón de «Reset» (simulando una memoria de alarma).

Más Casos Prácticos en Prometeo.blog

Encuentra este producto y/o libros sobre este tema en Amazon

Ir a Amazon

Como afiliado de Amazon, gano con las compras que cumplan los requisitos. Si compras a través de este enlace, ayudas a mantener este proyecto.

Quiz rápido

Pregunta 1: ¿Qué componente principal se utiliza para realizar la función lógica en este circuito?




Pregunta 2: ¿Cuál es el objetivo principal del circuito descrito?




Pregunta 3: ¿Qué sucede con el LED si se presiona únicamente uno de los botones?




Pregunta 4: ¿En qué condición permanece el LED APAGADO?




Pregunta 5: ¿Qué aplicación de la vida real en el sector automotriz se menciona como ejemplo?




Pregunta 6: ¿Qué función lógica fundamental demuestra este proyecto?




Pregunta 7: ¿Cómo se aplica este circuito en un sistema de seguridad industrial?




Pregunta 8: ¿Qué ocurre si se presionan ambos botones simultáneamente en una compuerta OR?




Pregunta 9: ¿Qué nivel de dificultad se asigna a este proyecto en el contexto?




Pregunta 10: ¿Qué ejemplo de domótica se utiliza para ilustrar este circuito?




Carlos Núñez Zorrilla
Carlos Núñez Zorrilla
Electronics & Computer Engineer

Ingeniero Superior en Electrónica de Telecomunicaciones e Ingeniero en Informática (titulaciones oficiales en España).

Sígueme:

Caso práctico: Sistema de alarma con doble sensor

Prototipo de Sistema de alarma con doble sensor (Maker Style)

Nivel: Básico — Implementar un circuito lógico que active una alarma si cualquiera de dos sensores detecta una intrusión.

Objetivo y caso de uso

En este caso práctico, construirás un circuito lógico digital utilizando un circuito integrado 74HC32 (puerta OR). El circuito monitorea dos interruptores que representan sensores de puerta; si se activa cualquiera de los interruptores (lógica ALTA o HIGH), el LED de salida (alarma) se enciende.

Por qué es útil:
* Seguridad en el hogar: Simula un sistema donde abrir la puerta delantera o la trasera activa la sirena.
* Seguridad automotriz: Funciona como la luz de «puerta abierta» del tablero, que se ilumina si alguna puerta de los pasajeros no está completamente cerrada.
* Controles industriales: Actúa como un monitor de fallos simplificado donde múltiples señales de error pueden activar una única luz de advertencia.

Resultado esperado:
* Estado de espera: Cuando ambos interruptores están abiertos (entrada de 0 V), el LED permanece APAGADO.
* Estado activo 1: Cuando el interruptor A está cerrado (entrada de 5 V), el LED se ENCIENDE.
* Estado activo 2: Cuando el interruptor B está cerrado (entrada de 5 V), el LED se ENCIENDE.
* Estado activo dual: Cuando ambos interruptores están cerrados, el LED permanece ENCENDIDO.
* Público objetivo: Estudiantes de electrónica y aficionados que aprenden puertas lógicas digitales básicas.

Materiales

  • V1: Fuente de alimentación de 5 V CC o paquete de baterías
  • U1: CI 74HC32 con cuádruple puerta OR de 2 entradas
  • S1: Interruptor de palanca SPST o pulsador, función: Sensor de puerta delantera (Entrada A)
  • S2: Interruptor de palanca SPST o pulsador, función: Sensor de puerta trasera (Entrada B)
  • R1: Resistencia de 10 kΩ, función: pull-down para Entrada A
  • R2: Resistencia de 10 kΩ, función: pull-down para Entrada B
  • R3: Resistencia de 330 Ω, función: limitación de corriente del LED
  • D1: LED rojo, función: Indicador de alarma
  • Protoboard y cables de conexión

Pin-out del CI utilizado

Chip seleccionado: 74HC32 (Cuádruple puerta OR de 2 entradas)

Pin Nombre Función lógica Conexión en este caso
1 1A Entrada A (Puerta 1) Conectado a S1 y R1
2 1B Entrada B (Puerta 1) Conectado a S2 y R2
3 1Y Salida (Puerta 1) Conectado a R3 (controlador de LED)
7 GND Tierra Conectado a 0 (Riel negativo)
14 VCC Alimentación positiva Conectado al riel de 5 V

Guía de conexionado

Construye el circuito en la protoboard siguiendo estas conexiones. Los nombres de los nodos (por ejemplo, IN_A, VCC) indican uniones eléctricas.

  • Fuente de alimentación:
    • V1: Terminal positivo al nodo VCC.
    • V1: Terminal negativo al nodo 0 (GND).
  • Alimentación del CI:
    • U1 (Pin 14): Conectar a VCC.
    • U1 (Pin 7): Conectar a 0.
  • Sensor A (Puerta delantera):
    • S1: Conectar entre VCC y el nodo IN_A.
    • R1: Conectar entre el nodo IN_A y 0 (Funciona como resistencia pull-down para asegurar un 0 lógico cuando el interruptor está abierto).
    • U1 (Pin 1): Conectar al nodo IN_A.
  • Sensor B (Puerta trasera):
    • S2: Conectar entre VCC y el nodo IN_B.
    • R2: Conectar entre el nodo IN_B y 0 (Funciona como resistencia pull-down).
    • U1 (Pin 2): Conectar al nodo IN_B.
  • Etapa de salida:
    • U1 (Pin 3): Conectar al nodo SIG_OUT.
    • R3: Conectar entre el nodo SIG_OUT y el nodo LED_ANODE.
    • D1: Ánodo al nodo LED_ANODE, Cátodo a 0.

Diagrama de bloques conceptual

Conceptual block diagram — 74HC32 OR gate

Esquemático

[ INPUT SENSORS ]                        [ LOGIC PROCESSING ]                  [ OUTPUT ALARM ]

[ VCC ] --> [ S1: Front Door ] --+--(IN_A)--> [ Pin 1 ] --+
                                 |                        |
                           [ R1: 10k ]                    |
                                 |                        v
                               [ GND ]             +-------------+
                                                   |  U1: 74HC32 |
                                                   |  (OR Gate)  | --(Pin 3)--> [ R3: 330 ] --> [ D1: LED ] --> GND
                                                   +-------------+
                               [ GND ]                    ^
                                 |                        |
                           [ R2: 10k ]                    |
                                 |                        |
[ VCC ] --> [ S2: Back Door  ] --+--(IN_B)--> [ Pin 2 ] --+
Esquema Eléctrico

Diagrama eléctrico

Diagrama eléctrico del caso: Sistema de alarma con doble sensor
Generado desde la netlist SPICE validada del caso.

🔒 Este diagrama eléctrico es premium. Con el pase de 7 días o la suscripción mensual podrás desbloquear el material didáctico completo y el pack PDF listo para imprimir.🔓 Ver planes de acceso premium

Tabla de verdad

El 74HC32 se comporta según la lógica OR estándar:

Sensor A (S1) Sensor B (S2) Pin 1 (Voltios) Pin 2 (Voltios) Pin de salida 3 (Voltios) Estado del LED
Abierto Abierto 0 V 0 V 0 V (BAJO) APAGADO
Abierto Cerrado 0 V 5 V 5 V (ALTO) ENCENDIDO
Cerrado Abierto 5 V 0 V 5 V (ALTO) ENCENDIDO
Cerrado Cerrado 5 V 5 V 5 V (ALTO) ENCENDIDO

Mediciones y pruebas

  1. Verificación de alimentación: Antes de insertar el CI, energiza los rieles y mide el voltaje entre VCC y 0. Debería leer aproximadamente 5 V.
  2. Verificación de entrada:
    • Mantén U1 insertado. Mide el voltaje en el Pin 1 con respecto a GND. Debería ser 0 V.
    • Presiona S1. El voltaje en el Pin 1 debería saltar a ~5 V.
    • Repite para S2 y el Pin 2.
  3. Prueba lógica:
    • Asegúrate de que ambos interruptores estén abiertos. Mide el Pin 3 (Salida); debería estar cerca de 0 V.
    • Cierra solo S1. Mide el Pin 3; debería estar cerca de 5 V. El LED debería encenderse.
    • Cierra solo S2. Mide el Pin 3; debería estar cerca de 5 V. El LED debería encenderse.

Netlist SPICE y simulación

Netlist SPICE de referencia (ngspice) — extractoNetlist SPICE completo (ngspice)

* Practical case: Dual Sensor Alarm System
* Corrected SPICE Netlist based on BOM and Wiring Guide

* ==============================================================================
* POWER SUPPLY
* ==============================================================================
* V1: 5V DC Supply
* Wiring: Positive to VCC, Negative to 0 (GND)
V1 VCC 0 DC 5

* ==============================================================================
* INPUT SENSORS
* ==============================================================================
* Sensor A: Front Door (S1, R1)
* Wiring: S1 connects VCC to IN_A. R1 connects IN_A to 0 (Pull-down).
* Simulation: S1 is modeled as a voltage-controlled switch driven by a control pulse
* to simulate a button press sequence.
V_CTRL_A CTRL_A 0 PULSE(0 5 10u 1u 1u 100u 200u)
S1 VCC IN_A CTRL_A 0 SW_GEN
R1 IN_A 0 10k

* Sensor B: Back Door (S2, R2)
* Wiring: S2 connects VCC to IN_B. R2 connects IN_B to 0 (Pull-down).
* Simulation: S2 control pulse is offset to test all truth table combinations.
V_CTRL_B CTRL_B 0 PULSE(0 5 10u 1u 1u 200u 400u)
S2 VCC IN_B CTRL_B 0 SW_GEN
R2 IN_B 0 10k

* ==============================================================================
* LOGIC IC: U1 (74HC32)
* ... (truncated in public view) ...

Copia este contenido en un archivo .cir y ejecútalo con ngspice.

🔒 Parte del contenido de esta sección es premium. Con el pase de 7 días o la suscripción mensual tendrás acceso al contenido completo (materiales, conexionado, compilación detallada, validación paso a paso, troubleshooting, mejoras/variantes y checklist) y podrás descargar el pack PDF listo para imprimir.

🔓 Ver planes de acceso premium 

* Practical case: Dual Sensor Alarm System
* Corrected SPICE Netlist based on BOM and Wiring Guide

* ==============================================================================
* POWER SUPPLY
* ==============================================================================
* V1: 5V DC Supply
* Wiring: Positive to VCC, Negative to 0 (GND)
V1 VCC 0 DC 5

* ==============================================================================
* INPUT SENSORS
* ==============================================================================
* Sensor A: Front Door (S1, R1)
* Wiring: S1 connects VCC to IN_A. R1 connects IN_A to 0 (Pull-down).
* Simulation: S1 is modeled as a voltage-controlled switch driven by a control pulse
* to simulate a button press sequence.
V_CTRL_A CTRL_A 0 PULSE(0 5 10u 1u 1u 100u 200u)
S1 VCC IN_A CTRL_A 0 SW_GEN
R1 IN_A 0 10k

* Sensor B: Back Door (S2, R2)
* Wiring: S2 connects VCC to IN_B. R2 connects IN_B to 0 (Pull-down).
* Simulation: S2 control pulse is offset to test all truth table combinations.
V_CTRL_B CTRL_B 0 PULSE(0 5 10u 1u 1u 200u 400u)
S2 VCC IN_B CTRL_B 0 SW_GEN
R2 IN_B 0 10k

* ==============================================================================
* LOGIC IC: U1 (74HC32)
* ==============================================================================
* Wiring: Pin 1=IN_A, Pin 2=IN_B, Pin 3=SIG_OUT, Pin 7=0, Pin 14=VCC
* Uses a subcircuit to model the OR gate logic
XU1 IN_A IN_B SIG_OUT 0 VCC 74HC32

* ==============================================================================
* OUTPUT STAGE
* ==============================================================================
* Wiring: SIG_OUT -> R3 -> LED_ANODE -> D1 -> 0
R3 SIG_OUT LED_ANODE 330
D1 LED_ANODE 0 LED_RED

* ==============================================================================
* MODELS & SUBCIRCUITS
* ==============================================================================

* Model for Switch (Idealized Push-Button)
.model SW_GEN SW(Vt=2.5 Ron=0.1 Roff=10Meg)

* Model for Red LED
.model LED_RED D(IS=1u N=3 RS=5)

* Subcircuit for 74HC32 (Quad 2-Input OR Gate)
* Implements OR logic: Y = A OR B
* Mathematical implementation using De Morgan's Law for continuous signals:
* Y = 1 - ( (1-A) * (1-B) )  (normalized 0-1 logic)
.subckt 74HC32 A B Y GND_PIN VCC_PIN
    * Sigmoid function to normalize inputs: 1/(1+exp(-20*(V(in)-2.5)))
    * Logic formula: V(Y) = V(VCC) * (1 - ( (1-Sig(A)) * (1-Sig(B)) ))
    B_OR Y GND_PIN V = V(VCC_PIN) * (1 - ( (1 - 1/(1+exp(-20*(V(A)-2.5)))) * (1 - 1/(1+exp(-20*(V(B)-2.5)))) ))
.ends

* ==============================================================================
* ANALYSIS
* ==============================================================================
* Transient analysis to verify truth table (00, 10, 01, 11)
.tran 1u 500u

* Monitor Input and Output Voltages
.print tran V(IN_A) V(IN_B) V(SIG_OUT) V(LED_ANODE)

* Compute DC Operating Point
.op

.end

Resultados de Simulación (Transitorio)

Resultados de Simulación (Transitorio)
Show raw data table (1202 rows) 
Index   time            v(in_a)         v(in_b)         v(sig_out)
0	0.000000e+00	4.995005e-03	4.995005e-03	5.000000e+00
1	1.000000e-08	4.995005e-03	4.995005e-03	5.000000e+00
2	2.000000e-08	4.995005e-03	4.995005e-03	5.000000e+00
3	4.000000e-08	4.995005e-03	4.995005e-03	5.000000e+00
4	8.000000e-08	4.995005e-03	4.995005e-03	5.000000e+00
5	1.600000e-07	4.995005e-03	4.995005e-03	5.000000e+00
6	3.200000e-07	4.995005e-03	4.995005e-03	5.000000e+00
7	6.400000e-07	4.995005e-03	4.995005e-03	5.000000e+00
8	1.280000e-06	4.995005e-03	4.995005e-03	5.000000e+00
9	2.280000e-06	4.995005e-03	4.995005e-03	5.000000e+00
10	3.280000e-06	4.995005e-03	4.995005e-03	5.000000e+00
11	4.280000e-06	4.995005e-03	4.995005e-03	5.000000e+00
12	5.280000e-06	4.995005e-03	4.995005e-03	5.000000e+00
13	6.280000e-06	4.995005e-03	4.995005e-03	5.000000e+00
14	7.280000e-06	4.995005e-03	4.995005e-03	5.000000e+00
15	8.280000e-06	4.995005e-03	4.995005e-03	5.000000e+00
16	9.280000e-06	4.995005e-03	4.995005e-03	5.000000e+00
17	1.000000e-05	4.995005e-03	4.995005e-03	5.000000e+00
18	1.010000e-05	4.995005e-03	4.995005e-03	5.000000e+00
19	1.026000e-05	4.995005e-03	4.995005e-03	5.000000e+00
20	1.030750e-05	4.995005e-03	4.995005e-03	5.000000e+00
21	1.039062e-05	4.995005e-03	4.995005e-03	5.000000e+00
22	1.041363e-05	4.995005e-03	4.995005e-03	5.000000e+00
23	1.045390e-05	4.995005e-03	4.995005e-03	5.000000e+00
... (1178 more rows) ...

Errores comunes y cómo evitarlos

  1. Entradas flotantes: Olvidar R1 o R2 (resistencias pull-down).
    • Solución: Las puertas lógicas se comportan de manera impredecible si las entradas no están conectadas a un voltaje definido. Usa siempre resistencias pull-down (a tierra) o resistencias pull-up (a VCC) para interruptores mecánicos.
  2. Falta la resistencia del LED: Conectar el LED directamente a la salida del CI.
    • Solución: Incluye siempre R3 (330 Ω) para limitar la corriente. Sin ella, puedes dañar el LED o la etapa de salida del 74HC32.
  3. Orientación incorrecta del CI: Insertar el 74HC32 al revés.
    • Solución: Localiza la muesca o el punto en el encapsulado del CI. La muesca indica el extremo con el Pin 1 y el Pin 14.

Solución de problemas

  • El LED siempre está ENCENDIDO:
    • Comprueba si R1 o R2 están desconectadas (las entradas flotantes a menudo derivan a ALTO/HIGH).
    • Verifica que S1 o S2 no estén cableados como «normalmente cerrados» por error.
    • Busca cortocircuitos entre VCC y el Pin 1/Pin 2.
  • El LED nunca se ENCIENDE:
    • Comprueba si el CI tiene alimentación (Pin 14 a 5V, Pin 7 a GND).
    • Verifica la polaridad del LED (el Ánodo debe mirar hacia la resistencia/CI, el Cátodo a GND).
  • El LED brilla muy poco:
    • El valor de R3 podría ser demasiado alto (por ejemplo, usar 10 kΩ en lugar de 330 Ω).
    • El voltaje de la fuente de alimentación podría ser demasiado bajo (< 3 V).

Posibles mejoras y extensiones

  1. Alarma con enclavamiento: Añade un flip-flop o crea un circuito de enclavamiento (latch) para que la alarma permanezca ENCENDIDA incluso después de que el intruso cierre la puerta (S1/S2 se abran de nuevo), requiriendo un reinicio manual.
  2. Alerta sonora: Conecta un zumbador activo en paralelo con el LED (impulsado por un transistor si el requisito de corriente supera los 20 mA) para añadir sonido a la alarma visual.

Más Casos Prácticos en Prometeo.blog

Encuentra este producto y/o libros sobre este tema en Amazon

Ir a Amazon

Como afiliado de Amazon, gano con las compras que cumplan los requisitos. Si compras a través de este enlace, ayudas a mantener este proyecto.

Quiz rápido

Pregunta 1: ¿Qué circuito integrado se utiliza principalmente en este caso práctico?




Pregunta 2: ¿Qué tipo de puerta lógica representa el CI 74HC32?




Pregunta 3: ¿Cuál es el objetivo principal del circuito descrito?




Pregunta 4: ¿Qué sucede con el LED cuando ambos interruptores están abiertos (0 V)?




Pregunta 5: ¿Qué voltaje se considera como entrada en 'Estado activo' cuando se cierra un interruptor?




Pregunta 6: ¿Cuál es el resultado esperado si el interruptor A está cerrado y el interruptor B está abierto?




Pregunta 7: ¿Qué aplicación de seguridad automotriz se menciona como ejemplo para este circuito?




Pregunta 8: Según la lógica OR del circuito, ¿qué ocurre si ambos interruptores se cierran simultáneamente?




Pregunta 9: ¿Qué nivel de dificultad se asigna a este caso práctico?




Pregunta 10: ¿Cómo actúa este circuito en un contexto de controles industriales?




Carlos Núñez Zorrilla
Carlos Núñez Zorrilla
Electronics & Computer Engineer

Ingeniero Superior en Electrónica de Telecomunicaciones e Ingeniero en Informática (titulaciones oficiales en España).

Sígueme:

Caso práctico: Control seguro de prensa hidráulica

Prototipo de Control seguro de prensa hidráulica (Maker Style)

Nivel: Básico — Implementar un circuito lógico de seguridad que requiera dos entradas simultáneas para activar una carga.

Objetivo y caso de uso

En este caso práctico, construirás un circuito lógico digital que impone un mecanismo de seguridad de «mando a dos manos». La carga (simulada por un LED) solo se activará cuando se presionen dos pulsadores separados simultáneamente, evitando la operación accidental.

Por qué es útil:
* Seguridad industrial: Evita que los operadores se lesionen las manos en prensas hidráulicas o máquinas de corte al obligarlos a usar ambas manos para iniciar el ciclo.
* Doble autorización: Se utiliza una lógica similar en sistemas de seguridad donde se requieren dos llaves o señales para autorizar una acción (por ejemplo, bóvedas bancarias).
* Sistemas de enclavamiento: Asegura que se cumplan múltiples condiciones (por ejemplo, Puerta cerrada Y Botón de inicio presionado) antes de que una máquina funcione.

Resultado esperado:
* Estado de reposo: El LED de salida permanece APAGADO cuando no se presiona ningún botón o solo uno.
* Estado activo: El LED de salida se ENCIENDE estrictamente cuando ambos botones se mantienen presionados.
* Nivel lógico: El voltaje de salida en el pin de la compuerta lee Alto ($\approx$ 5 V) solo durante la activación simultánea.
* Retroalimentación visual: Respuesta inmediata del LED indicando la condición de «Seguro para operar».

Público objetivo: Estudiantes y aficionados que aprenden lógica digital básica y enclavamientos de seguridad.

Materiales

  • U1: 74HC08, función: CI cuádruple de compuertas AND de 2 entradas.
  • V1: Fuente de 5 V CC, función: Fuente de alimentación principal.
  • SW1: Pulsador Normalmente Abierto (NA), función: Disparador de seguridad mano izquierda.
  • SW2: Pulsador Normalmente Abierto (NA), función: Disparador de seguridad mano derecha.
  • R1: Resistencia de 10 kΩ, función: Resistencia pull-down para Entrada A.
  • R2: Resistencia de 10 kΩ, función: Resistencia pull-down para Entrada B.
  • R3: Resistencia de 330 Ω, función: Limitación de corriente para el LED de salida.
  • D1: LED verde, función: Indicador de «Motor Activo» (Carga).

Pin-out del 74HC08

El 74HC08 contiene cuatro compuertas AND independientes. Usaremos la primera compuerta.

Pin Nombre Función lógica Conexión en este caso
1 1A Entrada A Conectado al Nodo A (SW1)
2 1B Entrada B Conectado al Nodo B (SW2)
3 1Y Salida Conectado al Nodo Y (al controlador LED)
7 GND Tierra Conectado al Nodo 0
14 VCC Voltaje de alimentación Conectado al Nodo VCC (+5V)

Guía de conexionado

Construye el circuito utilizando las siguientes conexiones de nodos. Asegúrate de que la fuente de alimentación esté apagada mientras realizas el cableado.

  • Nodos de alimentación:

    • Conecta el terminal positivo de V1 al Nodo VCC.
    • Conecta el terminal negativo de V1 al Nodo 0 (GND).
    • Conecta el Pin 14 de U1 a VCC.
    • Conecta el Pin 7 de U1 a 0.

  • Lógica de Entrada A (Mano izquierda):

    • Conecta un lado de SW1 a VCC.
    • Conecta el otro lado de SW1 al Nodo A.
    • Conecta R1 entre el Nodo A y el Nodo 0 (Pull-down).
    • Conecta el Pin 1 de U1 al Nodo A.

  • Lógica de Entrada B (Mano derecha):

    • Conecta un lado de SW2 a VCC.
    • Conecta el otro lado de SW2 al Nodo B.
    • Conecta R2 entre el Nodo B y el Nodo 0 (Pull-down).
    • Conecta el Pin 2 de U1 al Nodo B.

  • Lógica de Salida (Carga):

    • Conecta el Pin 3 de U1 al Nodo Y.
    • Conecta R3 entre el Nodo Y y el Nodo LED_ANODE.
    • Conecta el Ánodo de D1 al Nodo LED_ANODE.
    • Conecta el Cátodo de D1 al Nodo 0.

Diagrama de bloques conceptual

Conceptual block diagram — 74HC08 Quad AND gate

Esquemático

Practical case: Safe Hydraulic Press Control

      [ INPUTS / SENSORS ]                  [ LOGIC PROCESSING ]                  [ OUTPUT / ACTUATOR ]

                                            +------------------+
(VCC) --> [ SW1: Left Hand ] --(Node A)---> |      Pin 1       |
               (NO Push)          |         |                  |
                                  v         |    U1: 74HC08    |
                              [ R1: 10k ]   |    (AND Gate)    |
                              (Pull-Down)   |                  | --(Node Y)--> [ R3: 330 ] --> [ D1: Green LED ] --> (GND)
                                  |         |      Pin 3       |               (Limit)         (Motor Active)
                                (GND)       |                  |
                                            |                  |
(VCC) --> [ SW2: Right Hand ]--(Node B)---> |      Pin 2       |
               (NO Push)          |         +------------------+
                                  v
                              [ R2: 10k ]
                              (Pull-Down)
                                  |
                                (GND)

Note: U1 Power Connections (Pin 14 to VCC, Pin 7 to GND) are implied for IC operation.
Esquema Eléctrico

Diagrama eléctrico

Diagrama eléctrico del control seguro de prensa hidráulica
Generado desde la netlist SPICE validada del caso.

🔒 Este diagrama eléctrico es premium. Con el pase de 7 días o la suscripción mensual podrás desbloquear el material didáctico completo y el pack PDF listo para imprimir.🔓 Ver planes de acceso premium

Tabla de verdad

Este circuito implementa la función booleana $Y = A \cdot B$.

SW1 (Entrada A) SW2 (Entrada B) Salida Y (Lógica) Estado del LED Estado del sistema
Abierto (0) Abierto (0) Bajo (0) APAGADO Seguro / Parada
Abierto (0) Cerrado (1) Bajo (0) APAGADO Seguro / Parada
Cerrado (1) Abierto (0) Bajo (0) APAGADO Seguro / Parada
Cerrado (1) Cerrado (1) Alto (1) ENCENDIDO Activo / Marcha

Mediciones y pruebas

  1. Preparación: Configura tu multímetro en modo de Voltaje CC. Enciende la fuente V1 (5 V).
  2. Comprobación en reposo: Sin presionar ningún botón, mide el voltaje en el Nodo Y. Debería ser $\approx$ 0 V. El LED está APAGADO.
  3. Prueba de un solo botón: Presiona y mantén presionado solo SW1. Mide el voltaje en el Nodo A ($\approx$ 5 V) y el Nodo Y ($\approx$ 0 V). El LED permanece APAGADO.
  4. Prueba de un solo botón: Presiona y mantén presionado solo SW2. Mide el voltaje en el Nodo B ($\approx$ 5 V) y el Nodo Y ($\approx$ 0 V). El LED permanece APAGADO.
  5. Activación simultánea: Presiona ambos SW1 y SW2. Mide el voltaje en el Nodo Y. Debería leer $\approx$ 3.5 V a 4.5 V (dependiendo de la familia lógica HC/LS específica y VCC). El LED se ENCIENDE.

Netlist SPICE y simulación

Netlist SPICE de referencia (ngspice) — extractoNetlist SPICE completo (ngspice)

* Practical case: Safe Hydraulic Press Control

.title Safe Hydraulic Press Control

*******************************************************************************
* Component Models
*******************************************************************************

* Pushbutton Switch Model (Ideal Voltage Controlled Switch)
* Simulates the mechanical contact closing when control voltage is high (> 2.5V)
.model SW_PUSH SW(Vt=2.5 Vh=0.1 Ron=0.01 Roff=10Meg)

* LED Model (Green)
* Standard Green LED parameters
.model LED_GREEN D(IS=1e-22 RS=10 N=2 BV=5 IBV=10u CJO=10p TT=10n)

* 74HC08 Quad 2-input AND Gate (Behavioral Model for Simulation)
* Implements one gate of the IC. 
* Pins: 1=InputA, 2=InputB, 3=OutputY, 7=GND, 14=VCC
.subckt 74HC08_GATE 1 2 3 7 14
    * Behavioral Voltage Source using continuous Sigmoid function for convergence
    * Y = VCC * (Sigmoid(A) * Sigmoid(B))
    * Threshold centered at 2.5V with steep slope (k=50)
    B1 3 7 V = V(14) * (1 / (1 + exp(-50 * (V(1) - 2.5)))) * (1 / (1 + exp(-50 * (V(2) - 2.5))))
.ends

*******************************************************************************
* Main Power Supply
*******************************************************************************
* V1: 5V DC supply connected to Node VCC and Node 0 (GND)
* ... (truncated in public view) ...

Copia este contenido en un archivo .cir y ejecútalo con ngspice.

🔒 Parte del contenido de esta sección es premium. Con el pase de 7 días o la suscripción mensual tendrás acceso al contenido completo (materiales, conexionado, compilación detallada, validación paso a paso, troubleshooting, mejoras/variantes y checklist) y podrás descargar el pack PDF listo para imprimir.

🔓 Ver planes de acceso premium 

* Practical case: Safe Hydraulic Press Control

.title Safe Hydraulic Press Control

*******************************************************************************
* Component Models
*******************************************************************************

* Pushbutton Switch Model (Ideal Voltage Controlled Switch)
* Simulates the mechanical contact closing when control voltage is high (> 2.5V)
.model SW_PUSH SW(Vt=2.5 Vh=0.1 Ron=0.01 Roff=10Meg)

* LED Model (Green)
* Standard Green LED parameters
.model LED_GREEN D(IS=1e-22 RS=10 N=2 BV=5 IBV=10u CJO=10p TT=10n)

* 74HC08 Quad 2-input AND Gate (Behavioral Model for Simulation)
* Implements one gate of the IC. 
* Pins: 1=InputA, 2=InputB, 3=OutputY, 7=GND, 14=VCC
.subckt 74HC08_GATE 1 2 3 7 14
    * Behavioral Voltage Source using continuous Sigmoid function for convergence
    * Y = VCC * (Sigmoid(A) * Sigmoid(B))
    * Threshold centered at 2.5V with steep slope (k=50)
    B1 3 7 V = V(14) * (1 / (1 + exp(-50 * (V(1) - 2.5)))) * (1 / (1 + exp(-50 * (V(2) - 2.5))))
.ends

*******************************************************************************
* Main Power Supply
*******************************************************************************
* V1: 5V DC supply connected to Node VCC and Node 0 (GND)
V1 VCC 0 DC 5

*******************************************************************************
* Input A Logic (Left Hand)
*******************************************************************************
* V_ACT_LEFT: Virtual actuator (Finger) for Left Button
* Generates a pulse: ON for 50us, OFF for 50us (Period 100us)
V_ACT_LEFT CTRL_LEFT 0 PULSE(0 5 0 1u 1u 50u 100u)

* SW1: Left Safety Trigger
* Connects VCC to Node_A when CTRL_LEFT is High
S1 VCC Node_A CTRL_LEFT 0 SW_PUSH

* R1: 10k Pull-down resistor for Input A
R1 Node_A 0 10k

*******************************************************************************
* Input B Logic (Right Hand)
*******************************************************************************
* V_ACT_RIGHT: Virtual actuator (Finger) for Right Button
* Generates a pulse: ON for 100us, OFF for 100us (Period 200us)
* Timing creates overlap with Left button to test AND logic (1+1, 0+1, 1+0, 0+0)
V_ACT_RIGHT CTRL_RIGHT 0 PULSE(0 5 0 1u 1u 100u 200u)

* SW2: Right Safety Trigger
* Connects VCC to Node_B when CTRL_RIGHT is High
S2 VCC Node_B CTRL_RIGHT 0 SW_PUSH

* R2: 10k Pull-down resistor for Input B
R2 Node_B 0 10k

*******************************************************************************
* Logic Processing (U1: 74HC08)
*******************************************************************************
* U1: AND Gate processing Left (A) and Right (B) inputs
* Connections: Pin1=Node_A, Pin2=Node_B, Pin3=Node_Y, Pin7=0(GND), Pin14=VCC
XU1 Node_A Node_B Node_Y 0 VCC 74HC08_GATE

*******************************************************************************
* Output Logic (Load)
*******************************************************************************
* R3: Current limiting resistor (330 Ohm)
R3 Node_Y Node_LED_ANODE 330

* D1: Green LED Indicator (Motor Active)
* Anode to R3, Cathode to GND
D1 Node_LED_ANODE 0 LED_GREEN

*******************************************************************************
* Simulation Commands
*******************************************************************************
* Transient analysis for 250us to cover full truth table sequence
.tran 1u 250u

* Print directives for logging signal states
.print tran V(Node_A) V(Node_B) V(Node_Y) V(Node_LED_ANODE)

.end

Resultados de Simulación (Transitorio)

Resultados de Simulación (Transitorio)
Show raw data table (786 rows) 
Index   time            v(node_a)       v(node_b)       v(node_y)
0	0.000000e+00	4.995005e-03	4.995005e-03	2.199277e-108
1	1.000000e-08	4.995005e-03	4.995005e-03	2.199277e-108
2	2.000000e-08	4.995005e-03	4.995005e-03	2.199277e-108
3	4.000000e-08	4.995005e-03	4.995005e-03	2.199277e-108
4	8.000000e-08	4.995005e-03	4.995005e-03	2.199277e-108
5	1.600000e-07	4.995005e-03	4.995005e-03	2.199277e-108
6	3.200000e-07	4.995005e-03	4.995005e-03	2.199277e-108
7	3.600000e-07	4.995005e-03	4.995005e-03	2.199277e-108
8	4.300000e-07	4.995005e-03	4.995005e-03	2.199277e-108
9	4.493750e-07	4.995005e-03	4.995005e-03	2.199277e-108
10	4.832812e-07	4.995005e-03	4.995005e-03	2.199277e-108
11	5.162979e-07	4.999995e+00	4.999995e+00	5.000000e+00
12	5.474468e-07	4.999995e+00	4.999995e+00	5.000000e+00
13	5.779894e-07	4.999995e+00	4.999995e+00	5.000000e+00
14	6.039341e-07	4.999995e+00	4.999995e+00	5.000000e+00
15	6.320124e-07	4.999995e+00	4.999995e+00	5.000000e+00
16	6.881690e-07	4.999995e+00	4.999995e+00	5.000000e+00
17	8.004820e-07	4.999995e+00	4.999995e+00	5.000000e+00
18	1.000000e-06	4.999995e+00	4.999995e+00	5.000000e+00
19	1.022463e-06	4.999995e+00	4.999995e+00	5.000000e+00
20	1.067388e-06	4.999995e+00	4.999995e+00	5.000000e+00
21	1.157238e-06	4.999995e+00	4.999995e+00	5.000000e+00
22	1.336939e-06	4.999995e+00	4.999995e+00	5.000000e+00
23	1.696341e-06	4.999995e+00	4.999995e+00	5.000000e+00
... (762 more rows) ...

Errores comunes y cómo evitarlos

  1. Entradas flotantes: Olvidar R1 o R2 hace que las entradas «floten» cuando los botones están abiertos, lo que provoca un parpadeo errático del LED o disparos falsos. Solución: Asegúrate de que las resistencias pull-down conecten las entradas a tierra.
  2. Confundir el 7408 con el 7400: El 7408 es una compuerta AND; el 7400 es una compuerta NAND. Si el LED está ENCENDIDO cuando no se presionan los botones, probablemente usaste el chip incorrecto. Solución: Verifica las marcas en el encapsulado del CI.
  3. Polaridad del LED: El LED no se enciende incluso cuando la Lógica Y es Alta. Solución: Asegúrate de que la pata más larga (Ánodo) mire hacia la resistencia/CI y la pata más corta (Cátodo) mire hacia Tierra.

Solución de problemas

  • Síntoma: El LED está siempre ENCENDIDO, independientemente de los botones.
    • Causa: Pines de entrada en cortocircuito a VCC o CI incorrecto (por ejemplo, compuerta OR 74HC32 usada por error).
    • Solución: Revisa el cableado en los Pines 1 y 2; verifica el número de parte del CI.
  • Síntoma: El LED es muy tenue cuando se presionan ambos botones.
    • Causa: El valor de R3 es demasiado alto o VCC es demasiado bajo.
    • Solución: Asegúrate de que R3 sea de alrededor de 220 Ω a 330 Ω; comprueba que V1 sea de 5 V.
  • Síntoma: El circuito funciona para un botón pero ignora el otro.
    • Causa: Interruptor roto o cable puente desconectado en una entrada.
    • Solución: Usa un multímetro para verificar la continuidad a través de SW1 y SW2 cuando se presionan.

Posibles mejoras y extensiones

  1. Interfaz de potencia: Reemplaza el LED con un transistor NPN (como el 2N2222) y un relé para controlar un motor real de alto voltaje.
  2. Interruptor de habilitación maestro: Agrega un tercer interruptor conectado a una tercera entrada (usando una compuerta AND de 3 entradas como el 74HC11) para actuar como un «Interruptor de llave» que debe estar activo antes de que funcionen los dos botones manuales.

Más Casos Prácticos en Prometeo.blog

Encuentra este producto y/o libros sobre este tema en Amazon

Ir a Amazon

Como afiliado de Amazon, gano con las compras que cumplan los requisitos. Si compras a través de este enlace, ayudas a mantener este proyecto.

Quiz rápido

Pregunta 1: ¿Cuál es el objetivo principal del circuito descrito en el artículo?




Pregunta 2: ¿Qué componente lógico es esencial para requerir dos entradas simultáneas?




Pregunta 3: ¿En qué condiciones se enciende el LED de salida?




Pregunta 4: ¿Cuál es una aplicación práctica de seguridad industrial mencionada para este circuito?




Pregunta 5: ¿Qué nivel de dificultad se asigna a este caso práctico?




Pregunta 6: ¿Cómo se comporta el LED si solo se presiona un botón?




Pregunta 7: ¿Qué simula la carga en este circuito?




Pregunta 8: ¿Qué ejemplo de 'doble autorización' se menciona en el contexto?




Pregunta 9: ¿Qué asegura un sistema de enclavamiento según el texto?




Pregunta 10: ¿Cuál es el estado del LED cuando el sistema está en reposo (sin presionar botones)?




Carlos Núñez Zorrilla
Carlos Núñez Zorrilla
Electronics & Computer Engineer

Ingeniero Superior en Electrónica de Telecomunicaciones e Ingeniero en Informática (titulaciones oficiales en España).

Sígueme:

Caso práctico: Sistema de seguridad de doble llave

Prototipo de Sistema de seguridad de doble llave (Maker Style)

Nivel: Básico – Construye un circuito lógico que active una alarma solo cuando se giren dos llaves de seguridad simultáneamente.

Objetivo y caso de uso

En este proyecto, construirás un circuito de enclavamiento de seguridad digital utilizando una compuerta AND cuádruple de 2 entradas 74HC08. El sistema imita un protocolo de alta seguridad donde un mecanismo (representado por un LED) se activa solo si dos entradas separadas (interruptores) se accionan exactamente al mismo tiempo.

  • Aplicaciones en el mundo real:

    • Maquinaria industrial: Prensas de seguridad que requieren que el operador coloque ambas manos en botones separados para evitar lesiones.
    • Bóvedas bancarias: Requisitos de doble llave donde dos gerentes deben estar presentes para abrir una caja fuerte.
    • Aeroespacial: Sistemas de control de lanzamiento que requieren comandos de confirmación dual.
    • Domótica: Lógica de cerradura «inteligente» donde los datos biométricos y un código PIN deben coincidir.

  • Resultado esperado:

    • Estado de reposo: El LED permanece completamente APAGADO (Lógica Baja, < 0.1 V) cuando los interruptores están abiertos.
    • Activación única: El LED permanece APAGADO si solo el Interruptor A o solo el Interruptor B está cerrado.
    • Estado activo: El LED se ENCIENDE (Lógica Alta, > 3.5 V) exclusivamente cuando el Interruptor A Y el Interruptor B están cerrados.
    • Visual: Una señal luminosa clara y estable que indica «Acceso Concedido».

  • Público objetivo y nivel: Estudiantes que exploran los conceptos básicos de la lógica digital y la familia de CI 7400.

Materiales

  • U1: CI 74HC08 Compuerta AND cuádruple de 2 entradas.
  • S1: Interruptor de palanca SPST o pulsador, función: Llave de Seguridad A.
  • S2: Interruptor de palanca SPST o pulsador, función: Llave de Seguridad B.
  • R1: Resistencia de 10 kΩ, función: resistencia pull-down para la Entrada A.
  • R2: Resistencia de 10 kΩ, función: resistencia pull-down para la Entrada B.
  • R3: Resistencia de 330 Ω, función: limitación de corriente del LED.
  • D1: LED rojo, función: Indicador de estado del sistema.
  • V1: Fuente de alimentación de 5 V DC.

Pin-out del CI utilizado

Chip seleccionado: 74HC08 (Compuerta AND cuádruple de 2 entradas)

Pin Nombre Función lógica Conexión en este caso
1 1A Entrada A (Compuerta 1) Conectado al nodo S1 (VA)
2 1B Entrada B (Compuerta 1) Conectado al nodo S2 (VB)
3 1Y Salida (Compuerta 1) Conectado al nodo del driver del LED (VOUT)
7 GND Tierra Conectado a 0 V
14 VCC Alimentación Conectado a +5 V

(Nota: Los pines 4, 5, 6, 8, 9, 10, 11, 12, 13 no se utilizan en esta implementación de una sola compuerta, pero técnicamente las entradas deberían conectarse a tierra en un diseño de PCB permanente para evitar ruido.)

Guía de conexionado

Sigue esta guía de conexión basada en nodos para ensamblar el circuito en tu protoboard.

  • Conexiones de los rieles de alimentación:

    • Conecta el terminal positivo de V1 al nodo VCC.
    • Conecta el terminal negativo de V1 al nodo 0 (GND).
    • Conecta el Pin 14 de U1 a VCC.
    • Conecta el Pin 7 de U1 a 0.

  • Etapa de entrada (Interruptor A):

    • Conecta S1 entre el nodo VCC y el nodo VA.
    • Conecta R1 entre el nodo VA y el nodo 0 (esto asegura que VA sea Bajo cuando S1 está abierto).
    • Conecta el Pin 1 de U1 al nodo VA.

  • Etapa de entrada (Interruptor B):

    • Conecta S2 entre el nodo VCC y el nodo VB.
    • Conecta R2 entre el nodo VB y el nodo 0 (esto asegura que VB sea Bajo cuando S2 está abierto).
    • Conecta el Pin 2 de U1 al nodo VB.

  • Etapa de salida:

    • Conecta el Pin 3 de U1 al nodo VOUT.
    • Conecta R3 entre el nodo VOUT y el Ánodo de D1.
    • Conecta el Cátodo de D1 al nodo 0.

Diagrama de bloques conceptual

Conceptual block diagram — 74HC08 Quad AND gate

Esquemático

[ INPUTS ]                                [ LOGIC ]                         [ OUTPUT ]

 [ VCC ] -> [ S1: Key A ] --+--(Node VA)-->+-------------------+
                            |              |  Pin 1            |
                       [ R1: 10k ]         |                   |
                            v              |    U1: 74HC08     |
                         [ GND ]           |    (AND Gate)     |--(Pin 3)--> [ R3: 330 Ω ] --> [ D1: LED ] --> [ GND ]
                                           |                   |
 [ VCC ] -> [ S2: Key B ] --+--(Node VB)-->+-------------------+
                            |                 Pin 2
                       [ R2: 10k ]
                            v
                         [ GND ]
Esquema Eléctrico

Diagrama eléctrico

Diagrama eléctrico del sistema de seguridad de doble llave
Generado desde la netlist SPICE validada del caso.

🔒 Este diagrama eléctrico es premium. Con el pase de 7 días o la suscripción mensual podrás desbloquear el material didáctico completo y el pack PDF listo para imprimir.🔓 Ver planes de acceso premium

Tabla de verdad

El 74HC08 sigue la lógica booleana positiva estándar (A AND B).

Llave A (S1) Llave B (S2) Entrada A (Pin 1) Entrada B (Pin 2) Salida Y (Pin 3) Estado del LED
Abierto Abierto 0 (Bajo) 0 (Bajo) 0 (Bajo) APAGADO
Abierto Cerrado 0 (Bajo) 1 (Alto) 0 (Bajo) APAGADO
Cerrado Abierto 1 (Alto) 0 (Bajo) 0 (Bajo) APAGADO
Cerrado Cerrado 1 (Alto) 1 (Alto) 1 (Alto) ENCENDIDO

Mediciones y pruebas

  1. Verificación de alimentación: Usa un multímetro para verificar 5 V entre VCC y 0 en los rieles del protoboard.
  2. Verificación de entrada:
    • Mantén S1 abierto: Mide el voltaje en VA. Debería ser 0 V.
    • Cierra S1: Mide el voltaje en VA. Debería ser ~5 V.
    • Repite para S2 y VB.
  3. Verificación lógica:
    • Cierra solo S1. Mide VOUT en el Pin 3. Esperado: ~0 V.
    • Cierra solo S2. Mide VOUT en el Pin 3. Esperado: ~0 V.
    • Cierra tanto S1 como S2. Mide VOUT. Esperado: > 3.5 V (Lógica Alta).
  4. Consumo de corriente (Opcional): Mide la corriente a través de R3 cuando el LED está ENCENDIDO. Debería ser aproximadamente 8–10 mA.

Netlist SPICE y simulación

Netlist SPICE de referencia (ngspice) — extractoNetlist SPICE completo (ngspice)

* Practical case: Double Key Security System

* --- Power Supply ---
* V1: 5V DC Power Supply connected to VCC and GND (0)
V1 VCC 0 DC 5

* --- Input Stage (Switch A) ---
* User actuation simulation for Switch A (Control Signal)
* Generates a pulse sequence to test logic states. 
* Logic sequence plan: 00 -> 01 -> 10 -> 11
* Actuation A: Low for 100us, High for 100us.
V_ACT_A ACT_A 0 PULSE(0 5 100u 1u 1u 99u 200u)

* S1: SPST Switch connecting VCC to VA when actuated
S1 VCC VA ACT_A 0 SW_PUSHBUTTON

* R1: 10k Pull-down resistor for Input A
R1 VA 0 10k

* --- Input Stage (Switch B) ---
* User actuation simulation for Switch B (Control Signal)
* Actuation B: Toggles every 50us.
V_ACT_B ACT_B 0 PULSE(0 5 50u 1u 1u 49u 100u)

* S2: SPST Switch connecting VCC to VB when actuated
S2 VCC VB ACT_B 0 SW_PUSHBUTTON

* R2: 10k Pull-down resistor for Input B
R2 VB 0 10k

* ... (truncated in public view) ...

Copia este contenido en un archivo .cir y ejecútalo con ngspice.

🔒 Parte del contenido de esta sección es premium. Con el pase de 7 días o la suscripción mensual tendrás acceso al contenido completo (materiales, conexionado, compilación detallada, validación paso a paso, troubleshooting, mejoras/variantes y checklist) y podrás descargar el pack PDF listo para imprimir.

🔓 Ver planes de acceso premium 

* Practical case: Double Key Security System

* --- Power Supply ---
* V1: 5V DC Power Supply connected to VCC and GND (0)
V1 VCC 0 DC 5

* --- Input Stage (Switch A) ---
* User actuation simulation for Switch A (Control Signal)
* Generates a pulse sequence to test logic states. 
* Logic sequence plan: 00 -> 01 -> 10 -> 11
* Actuation A: Low for 100us, High for 100us.
V_ACT_A ACT_A 0 PULSE(0 5 100u 1u 1u 99u 200u)

* S1: SPST Switch connecting VCC to VA when actuated
S1 VCC VA ACT_A 0 SW_PUSHBUTTON

* R1: 10k Pull-down resistor for Input A
R1 VA 0 10k

* --- Input Stage (Switch B) ---
* User actuation simulation for Switch B (Control Signal)
* Actuation B: Toggles every 50us.
V_ACT_B ACT_B 0 PULSE(0 5 50u 1u 1u 49u 100u)

* S2: SPST Switch connecting VCC to VB when actuated
S2 VCC VB ACT_B 0 SW_PUSHBUTTON

* R2: 10k Pull-down resistor for Input B
R2 VB 0 10k

* --- Logic Stage (U1: 74HC08) ---
* Quad 2-Input AND Gate. Using 1 gate (Pins 1, 2, 3).
* Connections: Pin1=VA, Pin2=VB, Pin3=VOUT, Pin7=GND, Pin14=VCC
XU1 VA VB VOUT 0 VCC 74HC08

* --- Output Stage ---
* R3: 330 Ohm Current Limiting Resistor
R3 VOUT LED_ANODE 330

* D1: Red LED System Status Indicator
D1 LED_ANODE 0 DLED

* --- Models ---

* Switch Model (Voltage Controlled Switch)
* Vt=2.5V threshold, Low resistance when ON, High when OFF
.model SW_PUSHBUTTON SW(Vt=2.5 Ron=1 Roff=100Meg)

* LED Model
.model DLED D(IS=1e-14 N=2 RS=10 BV=5)

* 74HC08 Subcircuit Model (Behavioral AND Gate)
* Implements Vout = VCC * AND(A, B) using continuous sigmoid functions for convergence
* Pins: 1=A, 2=B, 3=Y, 7=GND, 14=VCC
.subckt 74HC08 P1 P2 P3 P7 P14
* Behavioral Source B1: Logic AND function
* Sigmoid function: 1 / (1 + exp(-k*(V-Vth)))
* k=50 provides sharp transition, Vth=2.5V
B1 P3 P7 V = V(P14, P7) * (1 / (1 + exp(-50 * (V(P1, P7) - 2.5)))) * (1 / (1 + exp(-50 * (V(P2, P7) - 2.5))))
.ends

* --- Simulation Commands ---
* Transient analysis for 250us to cover all logic states (00, 01, 10, 11)
.tran 1u 250u

* Print directives for logging
.print tran V(VA) V(VB) V(VOUT)

* Calculate DC operating point
.op

.end

Resultados de Simulación (Transitorio)

Resultados de Simulación (Transitorio)
Show raw data table (322 rows) 
Index   time            v(va)           v(vb)           v(vout)
0	0.000000e+00	4.999500e-04	4.999500e-04	1.403014e-108
1	1.000000e-08	4.999500e-04	4.999500e-04	1.403014e-108
2	2.000000e-08	4.999500e-04	4.999500e-04	1.403014e-108
3	4.000000e-08	4.999500e-04	4.999500e-04	1.403014e-108
4	8.000000e-08	4.999500e-04	4.999500e-04	1.403014e-108
5	1.600000e-07	4.999500e-04	4.999500e-04	1.403014e-108
6	3.200000e-07	4.999500e-04	4.999500e-04	1.403014e-108
7	6.400000e-07	4.999500e-04	4.999500e-04	1.403014e-108
8	1.280000e-06	4.999500e-04	4.999500e-04	1.403014e-108
9	2.280000e-06	4.999500e-04	4.999500e-04	1.403014e-108
10	3.280000e-06	4.999500e-04	4.999500e-04	1.403014e-108
11	4.280000e-06	4.999500e-04	4.999500e-04	1.403014e-108
12	5.280000e-06	4.999500e-04	4.999500e-04	1.403014e-108
13	6.280000e-06	4.999500e-04	4.999500e-04	1.403014e-108
14	7.280000e-06	4.999500e-04	4.999500e-04	1.403014e-108
15	8.280000e-06	4.999500e-04	4.999500e-04	1.403014e-108
16	9.280000e-06	4.999500e-04	4.999500e-04	1.403014e-108
17	1.028000e-05	4.999500e-04	4.999500e-04	1.403014e-108
18	1.128000e-05	4.999500e-04	4.999500e-04	1.403014e-108
19	1.228000e-05	4.999500e-04	4.999500e-04	1.403014e-108
20	1.328000e-05	4.999500e-04	4.999500e-04	1.403014e-108
21	1.428000e-05	4.999500e-04	4.999500e-04	1.403014e-108
22	1.528000e-05	4.999500e-04	4.999500e-04	1.403014e-108
23	1.628000e-05	4.999500e-04	4.999500e-04	1.403014e-108
... (298 more rows) ...

Errores comunes y cómo evitarlos

  1. Entradas flotantes: Olvidar las resistencias R1 o R2. Sin ellas, las entradas «flotan» y pueden captar ruido estático, causando que el LED parpadee aleatoriamente incluso cuando los interruptores están abiertos.
  2. Falta de alimentación al CI: Olvidar conectar el Pin 14 a VCC y el Pin 7 a GND. El chip no funcionará y puede sobrecalentarse si se activan las entradas mientras el chip no tiene alimentación.
  3. Polaridad del LED: Insertar D1 al revés (Ánodo a Tierra). El LED nunca se encenderá, incluso si la lógica es correcta.

Solución de problemas

  • Síntoma: El LED está siempre ENCENDIDO, independientemente de la posición del interruptor.

    • Causa: Las resistencias de entrada (R1/R2) podrían estar conectadas a VCC en lugar de a GND, o el interruptor está cableado incorrectamente (cortocircuitando VCC a la Entrada directamente).
    • Solución: Verifica que R1 y R2 conecten las entradas a Tierra (configuración Pull-down).

  • Síntoma: El LED parpadea cuando toco los cables.

    • Causa: Pin de entrada flotante.
    • Solución: Asegúrate de que las resistencias pull-down estén firmemente asentadas en el protoboard y haciendo contacto.

  • Síntoma: El LED es muy tenue cuando se presionan ambos interruptores.

    • Causa: El valor de R3 es demasiado alto (ej. 10 kΩ en lugar de 330 Ω) o el voltaje de alimentación es demasiado bajo.
    • Solución: Reemplaza R3 con una resistencia de 220 Ω o 330 Ω.

Posibles mejoras y extensiones

  1. Triple seguridad: Reemplaza el 74HC08 con un 74HC11 (Compuerta AND triple de 3 entradas) para requerir tres llaves simultáneas.
  2. Salida de alta potencia: Conecta la salida VOUT a un transistor NPN (como el 2N2222) o un Módulo de Relé para accionar una sirena fuerte o un motor de 12V en lugar de un pequeño LED.

Más Casos Prácticos en Prometeo.blog

Encuentra este producto y/o libros sobre este tema en Amazon

Ir a Amazon

Como afiliado de Amazon, gano con las compras que cumplan los requisitos. Si compras a través de este enlace, ayudas a mantener este proyecto.

Quiz rápido

Pregunta 1: ¿Cuál es el objetivo principal del circuito descrito en el artículo?




Pregunta 2: ¿Qué componente principal se utiliza para realizar la lógica del circuito?




Pregunta 3: ¿Qué condición debe cumplirse para que el LED se active (Lógica Alta)?




Pregunta 4: ¿Cuál es una aplicación del mundo real mencionada para este tipo de circuito?




Pregunta 5: ¿Qué función cumplen las resistencias R1 y R2 de 10 kΩ en el circuito?




Pregunta 6: ¿Cuál es el estado del LED en 'reposo' según el texto?




Pregunta 7: ¿Qué tipo de interruptores se sugieren típicamente para S1 y S2 en este contexto?




Pregunta 8: ¿A qué familia de Circuitos Integrados (CI) pertenece el chip 74HC08 utilizado?




Pregunta 9: ¿Qué voltaje se menciona como umbral para la Lógica Alta en el resultado esperado?




Pregunta 10: ¿Cuál es el nivel de dificultad indicado para este proyecto?




Carlos Núñez Zorrilla
Carlos Núñez Zorrilla
Electronics & Computer Engineer

Ingeniero Superior en Electrónica de Telecomunicaciones e Ingeniero en Informática (titulaciones oficiales en España).

Sígueme:

Caso práctico: UGV Beast ROS2 con cámara en Raspberry Pi 4

Caso práctico: UGV Beast ROS2 con cámara en Raspberry Pi 4 — hero

Objetivo y caso de uso

Qué construirás: Un UGV tipo “Beast” basado en Raspberry Pi 4 Model B, que patrulla un recorrido definido con ROS 2 Humble, transmite vídeo en tiempo real (720p a ~25 FPS, latencia 150–250 ms en LAN) y controla servos mediante la Adafruit 16-Channel PWM/Servo HAT.

Para qué sirve

  • Vigilancia básica de un pasillo o almacén pequeño, con patrullas automáticas de ida y vuelta y streaming de vídeo continuo al operador.
  • Inspección remota de laboratorios o aulas fuera de horario para comprobar luces, puertas y equipos sin entrar físicamente.
  • Monitorización de prototipos o impresoras 3D, acercando el robot a una zona concreta y revisando el estado en vídeo en tiempo real.
  • Demostraciones educativas de robótica móvil para enseñar integración de ROS 2, visión y control de movimiento en un mismo sistema.
  • Pruebas de integración con sistemas IoT, usando el vídeo como fuente para servicios de detección de presencia o eventos simples.

Resultado esperado

  • Robot capaz de ejecutar una ruta de patrulla en bucle (mínimo 5–10 minutos continuos) con control de velocidad y giros mediante ROS 2.
  • Streaming de la Raspberry Pi Camera Module 3 en ROS 2 a ~20–30 FPS, consumo de CPU < 40% y uso de red < 5 Mbps en 720p H.264.
  • Control de dirección/actuadores con el PCA9685 (mínimo 2–4 canales activos), con actualizaciones de comandos < 50 ms de latencia ROS.
  • Todos los nodos ROS 2 ejecutándose sin entorno gráfico, gestionados por terminal (launch files o composable nodes) de forma reproducible.

Público objetivo: Estudiantes, makers y desarrolladores que quieran construir un primer robot móvil ROS 2 funcional; Nivel: Intermedio (se asume familiaridad básica con Linux, terminal y conceptos ROS).

Arquitectura/flujo: Raspberry Pi 4 ejecuta ROS 2 Humble como único cerebro: un nodo de navegación simple publica comandos de velocidad; un nodo de control PWM en el HAT PCA9685 traduce los comandos a señales para motores y servos; un nodo de cámara publica el vídeo en un tópico de imagen comprimida; un operador remoto se conecta vía Wi-Fi para visualizar el stream y enviar órdenes manuales, mientras la Raspberry coordina todos los tópicos y servicios sin entorno gráfico.

Prerrequisitos

Sistema operativo y hardware base

  • Raspberry Pi 4 Model B (4 GB o más recomendado).
  • SO: Ubuntu Server 22.04 LTS 64-bit (aarch64) para Raspberry Pi.
  • Acceso:
  • Red local vía Ethernet o Wi-Fi.
  • Acceso SSH desde otro PC para trabajar sin entorno gráfico (headless).

Toolchain exacta y versiones

Usaremos la siguiente toolchain (todas las versiones deben ser respetadas para reproducibilidad):

  • Sistema operativo
  • Ubuntu Server 22.04.4 LTS (64-bit, aarch64) para Raspberry Pi.
  • ROS 2
  • Distribución ROS 2 Humble Hawksbill (paquetes ros-humble-*).
  • Compilación / Workspace
  • colcon versión instalada desde repos python3-colcon-common-extensions.
  • Workspace: ~/ros2_ws (carpeta fija).
  • Lenguaje y bibliotecas
  • Python 3.10 (por defecto en Ubuntu 22.04).
  • Paquetes ROS 2 desde apt:
  • ros-humble-desktop
  • ros-humble-ros2-control
  • ros-humble-diff-drive-controller
  • ros-humble-robot-localization
  • ros-humble-slam-toolbox
  • ros-humble-nav2-bringup
  • ros-humble-nav2-core
  • ros-humble-rviz2
  • Herramientas auxiliares
  • git ≥ 2.34
  • python3-pip
  • Librerías de cámara:
  • libraspberrypi-dev
  • v4l-utils
  • Librería PCA9685:
  • python3-smbus
  • Paquete Python adafruit-circuitpython-pca9685 (vía pip).

Materiales

Lista de materiales principales

  • 1 × Raspberry Pi 4 Model B (mínimo 4 GB RAM recomendable).
  • 1 × Raspberry Pi Camera Module 3 (interfaz CSI, lente estándar).
  • 1 × Adafruit 16-Channel PWM/Servo HAT (PCA9685).
  • 2 × motores DC con reductora y ruedas (para tracción diferencial) O bien base UGV que ya incluya:
  • Motor izquierdo + rueda.
  • Motor derecho + rueda.
  • 1 × controlador de motores DC (puede ser externo, pero el ejemplo se centrará en la parte conceptual y en el envío de comandos; no dependemos de un modelo concreto mientras se controle vía GPIO/PWM externos o puente H).
  • 1 × batería adecuada para el UGV (p.ej., 2S/3S LiPo + regulador a 5 V para la Raspberry Pi).
  • 1 × tarjeta microSD (32 GB o más, clase 10).
  • Cables:
  • Cintas para la cámara CSI.
  • Jumpers macho-hembra para I2C (SDA, SCL, 5 V, GND).
  • (Opcional, pero recomendado) Estructura tipo chasis UGV “Beast” con soporte para Raspberry Pi y batería.

Preparación y conexión

1. Configuración inicial de Ubuntu y ROS 2 Humble

  1. Instalar Ubuntu Server 22.04.4 LTS aarch64 en la microSD (usando Raspberry Pi Imager desde otro PC).
  2. Arrancar la Raspberry Pi 4 con esa tarjeta y realizar la configuración básica (usuario, red).
  3. Actualizar paquetes:

bash
sudo apt update
sudo apt upgrade -y

  1. Añadir repositorios de ROS 2 Humble:

«`bash
sudo apt install -y software-properties-common
sudo add-apt-repository universe
sudo add-apt-repository restricted
sudo add-apt-repository multiverse

sudo apt update
sudo apt install -y curl gnupg lsb-release
sudo curl -sSL https://raw.githubusercontent.com/ros/rosdistro/master/ros.key \
-o /usr/share/keyrings/ros-archive-keyring.gpg

echo «deb [arch=$(dpkg –print-architecture) signed-by=/usr/share/keyrings/ros-archive-keyring.gpg] \
http://packages.ros.org/ros2/ubuntu $(. /etc/os-release && echo $UBUNTU_CODENAME) main» \
| sudo tee /etc/apt/sources.list.d/ros2.list > /dev/null

sudo apt update
«`

  1. Instalar toolchain ROS 2:

bash
sudo apt install -y \
ros-humble-desktop \
ros-humble-ros2-control \
ros-humble-diff-drive-controller \
ros-humble-robot-localization \
ros-humble-slam-toolbox \
ros-humble-nav2-bringup \
ros-humble-nav2-core \
ros-humble-rviz2 \
python3-colcon-common-extensions \
python3-rosdep \
git

  1. Inicializar rosdep:

bash
sudo rosdep init
rosdep update

  1. Añadir al ~/.bashrc:

bash
echo "source /opt/ros/humble/setup.bash" >> ~/.bashrc
source ~/.bashrc

2. Activar y probar la cámara

  1. Instalar utilidades:

bash
sudo apt install -y v4l-utils libraspberrypi-dev

  1. Comprobar detección:

bash
v4l2-ctl --list-devices

Debe aparecer algo como mmal service 16.1 o bcm2835-codec y un dispositivo /dev/video0.

3. Conexión del PCA9685 (Adafruit 16-Channel PWM/Servo HAT)

El PCA9685 se comunica por I2C. Por defecto, en la Raspberry Pi 4:

  • SDA: GPIO 2 (pin físico 3).
  • SCL: GPIO 3 (pin físico 5).
  • 5V: pins físicos 2 o 4.
  • GND: pins físicos 6, 9, 14, etc.

Tabla de conexiones PCA9685 ↔ Raspberry Pi 4

Función PCA9685 Pin en HAT Conectar a Raspberry Pi 4 Comentario
VCC (lógica) VCC 3.3 V (pin 1) Alimentación lógica (según versión del HAT)
GND GND GND (pin 6) Masa común
SDA SDA GPIO 2 (pin 3) I2C SDA
SCL SCL GPIO 3 (pin 5) I2C SCL
V+ (servos) V+ 5–6 V desde batería/regulador Alimentación de servos
Canal 0 PWM0 Servo 0 (ej. dirección) Señal PWM
Canal 1 PWM1 Servo 1 (opcional) Señal PWM

Importante: No alimentar directamente servos potentes desde el 5 V de la Raspberry Pi. Usar un regulador/batería externo.

Habilitar I2C en Ubuntu 22.04

Editar /boot/firmware/config.txt:

sudo nano /boot/firmware/config.txt

Asegurarse de tener:

dtparam=i2c_arm=on

Reiniciar:

sudo reboot

Tras reiniciar, comprobar:

sudo apt install -y i2c-tools
sudo i2cdetect -y 1

Debes ver la dirección típica del PCA9685 (0x40).

Código completo

Crearemos un paquete ROS 2 llamado ugv_beast_patrol con:

  1. Nodo Python para:
  2. Control del PCA9685 (servos).
  3. Publicación de comandos de velocidad /cmd_vel para patrulla simple.
  4. Nodo Python para:
  5. Publicar imágenes de la Raspberry Pi Camera en /camera/image_raw.

1. Crear el workspace y el paquete

mkdir -p ~/ros2_ws/src
cd ~/ros2_ws/src

ros2 pkg create --build-type ament_python ugv_beast_patrol

Estructura relevante:

  • ~/ros2_ws/src/ugv_beast_patrol/
  • package.xml
  • setup.py
  • ugv_beast_patrol/
    • __init__.py
    • patrol_node.py
    • camera_stream_node.py
  • resource/
  • launch/ (crearemos archivos de lanzamiento).

Instalar dependencias de Python para el PCA9685 y la cámara:

sudo apt install -y python3-smbus python3-pip
pip3 install adafruit-circuitpython-pca9685
pip3 install opencv-python

2. Código del nodo de patrulla y control PCA9685 (patrol_node.py)

# ~/ros2_ws/src/ugv_beast_patrol/ugv_beast_patrol/patrol_node.py

import rclpy
from rclpy.node import Node
from geometry_msgs.msg import Twist
import board
import busio
from adafruit_pca9685 import PCA9685
import time


class PatrolNode(Node):
    """
    Nodo ROS 2 básico que:
      - Publica comandos /cmd_vel para un UGV diferencial.
      - Controla un servo (ej. dirección o cámara) mediante PCA9685.
      - Implementa un bucle de patrulla muy simple (ida y vuelta).
    """

    def __init__(self):
        super().__init__('patrol_node')

        # Parámetros configurables
        self.declare_parameter('linear_speed', 0.15)     # m/s
        self.declare_parameter('angular_speed', 0.0)     # rad/s
        self.declare_parameter('patrol_time', 10.0)      # segundos hacia adelante
        self.declare_parameter('servo_channel', 0)       # canal PCA9685
        self.declare_parameter('servo_center', 0.0015)   # ancho de pulso (s) centro
        self.declare_parameter('servo_left', 0.0012)     # pulso izquierda
        self.declare_parameter('servo_right', 0.0018)    # pulso derecha
        self.declare_parameter('patrol_period', 30.0)    # periodo completo (s)

        self.linear_speed = float(self.get_parameter('linear_speed').value)
        self.angular_speed = float(self.get_parameter('angular_speed').value)
        self.patrol_time = float(self.get_parameter('patrol_time').value)
        self.servo_channel = int(self.get_parameter('servo_channel').value)
        self.servo_center = float(self.get_parameter('servo_center').value)
        self.servo_left = float(self.get_parameter('servo_left').value)
        self.servo_right = float(self.get_parameter('servo_right').value)
        self.patrol_period = float(self.get_parameter('patrol_period').value)

        # Publisher de velocidad
        self.cmd_vel_pub = self.create_publisher(Twist, 'cmd_vel', 10)

        # Inicialización de I2C y PCA9685
        i2c = busio.I2C(board.SCL, board.SDA)
        self.pca = PCA9685(i2c)
        self.pca.frequency = 50  # Hz, típico para servos

        self.get_logger().info('PCA9685 inicializado a 50 Hz')

        # Configurar servo en posición centro al inicio
        self._set_servo_pulse(self.servo_center)
        self.get_logger().info('Servo en posición centro')

        # Timer para el bucle de patrulla
        self.start_time = self.get_clock().now().to_msg().sec
        self.timer = self.create_timer(0.1, self.timer_callback)

    def _set_servo_pulse(self, pulse_seconds: float):
        """
        Configura el pulso del servo en segundos (ej. 0.0015 = 1.5 ms).
        El PCA9685 tiene 4096 pasos por periodo.
        """
        period_seconds = 1.0 / self.pca.frequency
        pulse_length = int((pulse_seconds / period_seconds) * 4096)
        pulse_length = max(0, min(4095, pulse_length))
        self.pca.channels[self.servo_channel].duty_cycle = pulse_length

    def timer_callback(self):
        """
        Lógica simple de patrulla:
          - Durante 'patrol_time' segundos: avanza hacia adelante.
          - Luego frena, gira servo a izquierda, espera corto tiempo.
          - Vuelve hacia atrás 'patrol_time' segundos.
          - Restaura servo al centro.
          - Espera hasta completar 'patrol_period' y repite.
        """
        now = self.get_clock().now().to_msg().sec
        elapsed = now - self.start_time

        msg = Twist()

        # Fase 1: avance
        if 0 <= elapsed < self.patrol_time:
            msg.linear.x = self.linear_speed
            msg.angular.z = self.angular_speed

        # Fase 2: detener y mirar a la izquierda
        elif self.patrol_time <= elapsed < self.patrol_time + 2.0:
            msg.linear.x = 0.0
            msg.angular.z = 0.0
            self._set_servo_pulse(self.servo_left)

        # Fase 3: retroceso
        elif self.patrol_time + 2.0 <= elapsed < 2 * self.patrol_time + 2.0:
            msg.linear.x = -self.linear_speed
            msg.angular.z = -self.angular_speed

        # Fase 4: detener y mirar a la derecha
        elif 2 * self.patrol_time + 2.0 <= elapsed < 2 * self.patrol_time + 4.0:
            msg.linear.x = 0.0
            msg.angular.z = 0.0
            self._set_servo_pulse(self.servo_right)

        # Fase 5: centro y espera
        else:
            msg.linear.x = 0.0
            msg.angular.z = 0.0
            self._set_servo_pulse(self.servo_center)

            if elapsed > self.patrol_period:
                # Reiniciar ciclo
                self.start_time = now
                self.get_logger().info('Reiniciando ciclo de patrulla')

        self.cmd_vel_pub.publish(msg)


def main(args=None):
    rclpy.init(args=args)
    node = PatrolNode()
    try:
        rclpy.spin(node)
    except KeyboardInterrupt:
        pass
    finally:
        node.pca.deinit()
        node.destroy_node()
        rclpy.shutdown()


if __name__ == '__main__':
    main()

Puntos clave del código

  • Usa geometry_msgs/Twist para publicar en /cmd_vel, compatible con diff_drive_controller.
  • Inicializa el PCA9685 vía I2C (board.SCL, board.SDA) y configura el servo.
  • Lógica simple de patrulla basada en el tiempo transcurrido.

3. Código del nodo de streaming de cámara (camera_stream_node.py)

# ~/ros2_ws/src/ugv_beast_patrol/ugv_beast_patrol/camera_stream_node.py

import rclpy
from rclpy.node import Node
from sensor_msgs.msg import Image
from cv_bridge import CvBridge
import cv2


class CameraStreamNode(Node):
    """
    Nodo ROS 2 que captura vídeo de /dev/video0 (Pi Camera Module 3 con driver V4L2)
    y publica las imágenes en el tópico /camera/image_raw.
    """

    def __init__(self):
        super().__init__('camera_stream_node')

        self.declare_parameter('device', '/dev/video0')
        self.declare_parameter('fps', 15)
        self.declare_parameter('width', 640)
        self.declare_parameter('height', 480)

        device = self.get_parameter('device').get_parameter_value().string_value
        self.fps = self.get_parameter('fps').get_parameter_value().integer_value
        width = self.get_parameter('width').get_parameter_value().integer_value
        height = self.get_parameter('height').get_parameter_value().integer_value

        self.bridge = CvBridge()
        self.publisher_ = self.create_publisher(Image, 'camera/image_raw', 10)

        # Abrir captura de vídeo
        self.cap = cv2.VideoCapture(device)
        if not self.cap.isOpened():
            self.get_logger().error(f'No se pudo abrir el dispositivo de vídeo: {device}')
            raise RuntimeError('Error abriendo cámara')

        self.cap.set(cv2.CAP_PROP_FPS, self.fps)
        self.cap.set(cv2.CAP_PROP_FRAME_WIDTH, width)
        self.cap.set(cv2.CAP_PROP_FRAME_HEIGHT, height)

        self.timer = self.create_timer(1.0 / float(self.fps), self.timer_callback)
        self.get_logger().info(f'Publicando vídeo desde {device} a {self.fps} fps')

    def timer_callback(self):
        ret, frame = self.cap.read()
        if not ret:
            self.get_logger().warning('No se pudo leer frame de la cámara')
            return

        # Convertir BGR (OpenCV) a mensaje ROS
        msg = self.bridge.cv2_to_imgmsg(frame, encoding='bgr8')
        msg.header.stamp = self.get_clock().now().to_msg()
        msg.header.frame_id = 'camera_link'
        self.publisher_.publish(msg)

    def destroy_node(self):
        if hasattr(self, 'cap') and self.cap.isOpened():
            self.cap.release()
        super().destroy_node()


def main(args=None):
    rclpy.init(args=args)
    node = CameraStreamNode()
    try:
        rclpy.spin(node)
    except KeyboardInterrupt:
        pass
    finally:
        node.destroy_node()
        rclpy.shutdown()


if __name__ == '__main__':
    main()

Puntos clave del código

  • Usa sensor_msgs/Image y cv_bridge para publicar imágenes en ROS 2.
  • Ajusta resolución y FPS desde parámetros.
  • Asigna frame_id="camera_link" para integrarlo con el árbol TF del robot.

4. Configuración de setup.py y package.xml

setup.py

# ~/ros2_ws/src/ugv_beast_patrol/setup.py

from setuptools import setup

package_name = 'ugv_beast_patrol'

setup(
    name=package_name,
    version='0.0.1',
    packages=[package_name],
    data_files=[
        ('share/ament_index/resource_index/packages',
         ['resource/' + package_name]),
        ('share/' + package_name, ['package.xml']),
        ('share/' + package_name + '/launch', ['launch/patrol_with_camera.launch.py']),
    ],
    install_requires=['setuptools'],
    zip_safe=True,
    maintainer='alumno',
    maintainer_email='alumno@example.com',
    description='UGV Beast patrol and camera streaming using Raspberry Pi 4, PCA9685 and Pi Camera 3',
    license='Apache License 2.0',
    tests_require=['pytest'],
    entry_points={
        'console_scripts': [
            'patrol_node = ugv_beast_patrol.patrol_node:main',
            'camera_stream_node = ugv_beast_patrol.camera_stream_node:main',
        ],
    },
)

package.xml (fragmento relevante)

Asegúrate de declarar dependencias:

<?xml version="1.0"?>
<package format="3">
  <name>ugv_beast_patrol</name>
  <version>0.0.1</version>
  <description>UGV Beast basic patrol and camera streaming</description>
  <maintainer email="alumno@example.com">Alumno</maintainer>
  <license>Apache License 2.0</license>

  <buildtool_depend>ament_python</buildtool_depend>

  <exec_depend>rclpy</exec_depend>
  <exec_depend>geometry_msgs</exec_depend>
  <exec_depend>sensor_msgs</exec_depend>
  <exec_depend>cv_bridge</exec_depend>

  <export>
  </export>
</package>

Instala cv_bridge:

sudo apt install -y ros-humble-cv-bridge

5. Archivo de lanzamiento (patrol_with_camera.launch.py)

# ~/ros2_ws/src/ugv_beast_patrol/launch/patrol_with_camera.launch.py

from launch import LaunchDescription
from launch_ros.actions import Node


def generate_launch_description():
    return LaunchDescription([
        Node(
            package='ugv_beast_patrol',
            executable='patrol_node',
            name='patrol_node',
            output='screen',
            parameters=[
                {'linear_speed': 0.15},
                {'angular_speed': 0.0},
                {'patrol_time': 8.0},
                {'patrol_period': 25.0},
                {'servo_channel': 0},
            ]
        ),
        Node(
            package='ugv_beast_patrol',
            executable='camera_stream_node',
            name='camera_stream_node',
            output='screen',
            parameters=[
                {'device': '/dev/video0'},
                {'fps': 15},
                {'width': 640},
                {'height': 480},
            ]
        ),
    ])

Compilación, instalación y ejecución

1. Compilar con colcon

Desde el workspace:

cd ~/ros2_ws
colcon build

Fuentea el setup.bash del workspace:

echo "source ~/ros2_ws/install/setup.bash" >> ~/.bashrc
source ~/.bashrc

2. Ejecutar el caso práctico de patrulla + streaming

En la Raspberry Pi (o vía SSH):

ros2 launch ugv_beast_patrol patrol_with_camera.launch.py

Debes ver en consola:

  • Logs de patrol_node indicando fases de patrulla.
  • Mensajes de camera_stream_node confirmando la publicación de vídeo.

3. Visualizar el vídeo y el movimiento desde otro PC

En otro PC (también con ROS 2 Humble y conectividad con la Raspberry Pi):

  1. Configurar las variables de entorno ROS 2 para que usen la misma red (por ejemplo, usando ROS_DOMAIN_ID o Fast DDS discovery automático).
  2. Comprobar tópico de la cámara:

bash
ros2 topic list
ros2 topic echo /camera/image_raw

(Verás datos en bruto; para ver vídeo, usar RViz o rqt_image_view).

  1. Visualizar con rqt_image_view:

bash
sudo apt install -y ros-humble-rqt-image-view
rqt_image_view

En la interfaz, seleccionar /camera/image_raw.

  1. Comprobar comandos de velocidad:

bash
ros2 topic echo /cmd_vel

Validación paso a paso

1. Validar comunicación con el PCA9685

  1. Desde la Raspberry Pi, antes de lanzar ROS:

bash
sudo i2cdetect -y 1

  • Debe aparecer 40 como dirección del PCA9685.

  • Si no aparece, revisar cableado, alimentación y config.txt.

  • Lanzar solo el nodo de patrulla:

bash
ros2 run ugv_beast_patrol patrol_node

  • Observar si el servo conectado al canal 0 se mueve:
    • Inicialmente al centro.
    • Luego a izquierda/derecha según el ciclo.

2. Validar publicación de /cmd_vel

Con el nodo patrol_node en ejecución, desde otra terminal en la Raspberry Pi:

ros2 topic hz /cmd_vel
  • Debes ver una frecuencia alrededor de 10 Hz (o la de tu timer).
  • Métrica: frecuencia estable (varianza < 1 Hz).

3. Validar la cámara

  1. Con la cámara conectada y el nodo camera_stream_node en marcha:

bash
ros2 run ugv_beast_patrol camera_stream_node

  1. En otra terminal:

bash
ros2 topic hz /camera/image_raw

  • Debes ver ~15 Hz, acorde al parámetro fps=15.

  • Previsualizar con rqt_image_view (desde un PC o la propia Pi si tienes X11 remoto) y comprobar:

  • Imagen estable, sin cortes frecuentes.

  • Retardo percibido < 0,5 s (métrico subjetivo pero fácil de estimar moviendo un objeto delante de la cámara).

4. Validar patrulla física

Con el robot en el suelo:

  1. Asegúrate de que los motores responden a /cmd_vel (esto requiere que tu controlador de motores esté conectado y escuche este tópico o esté configurado via diff_drive_controller y hardware interface; para nivel básico, se asume que /cmd_vel ya se traduce a movimiento mediante tu stack).
  2. Marca con cinta adhesiva:
  3. Punto inicial.
  4. Distancia de 3 m hacia adelante.
  5. ejecuta:

bash
ros2 launch ugv_beast_patrol patrol_with_camera.launch.py

  1. Observar:
  2. El robot avanza aproximadamente esos 3 m y se detiene.
  3. El servo gira izquierda/derecha.
  4. El robot retrocede y se detiene cerca de la marca inicial.
  5. Error de retorno ≤ 30 cm.

Troubleshooting (errores típicos y soluciones)

1. i2cdetect -y 1 no muestra la dirección 0x40

Causa probable: I2C deshabilitado o cableado incorrecto.

Solución:

  • Revisar /boot/firmware/config.txt: asegurarse de dtparam=i2c_arm=on.
  • Verificar conexiones:
  • SDA en GPIO 2 (pin 3).
  • SCL en GPIO 3 (pin 5).
  • GND común entre Pi y HAT.
  • Reiniciar y volver a ejecutar i2cdetect.

2. Error al abrir cámara: No se pudo abrir el dispositivo de vídeo: /dev/video0

Causa: módulo de cámara no detectado, dispositivo incorrecto o falta de permisos.

Solución:

  • Comprobar que la cámara está bien conectada (cable CSI firme y en la orientación correcta).
  • Ejecutar:

bash
v4l2-ctl --list-devices

  • Usar el dispositivo correcto (/dev/video1, etc.) en el parámetro device de camera_stream_node.
  • Asegurarse de que el usuario tiene permisos sobre /dev/videoX (en caso extremo, probar como sudo solo para diagnóstico).

3. Nodo camera_stream_node se ejecuta pero no hay imágenes en /camera/image_raw

Causa: cv_bridge no instalado o error silencioso.

Solución:

  • Verificar que cv_bridge esté instalado:

bash
sudo apt install -y ros-humble-cv-bridge

  • Revisar la salida de logs:

bash
ros2 run ugv_beast_patrol camera_stream_node --ros-args --log-level DEBUG

  • Verificar con ros2 topic list que el tópico está publicado.

4. colcon build falla por dependencias de Python o ROS 2

Causa: faltan paquetes como cv_bridge, geometry_msgs o sensor_msgs.

Solución:

  • Confirmar que el package.xml tiene:

xml
<exec_depend>geometry_msgs</exec_depend>
<exec_depend>sensor_msgs</exec_depend>
<exec_depend>cv_bridge</exec_depend>

  • Ejecutar de nuevo:

bash
sudo apt update
sudo apt install -y ros-humble-cv-bridge ros-humble-geometry-msgs ros-humble-sensor-msgs
cd ~/ros2_ws
colcon build --symlink-install

5. El servo no se mueve aunque el PCA9685 se detecta

Causa: alimentación insuficiente o pulso fuera del rango adecuado.

Solución:

  • Asegurarse de que el pin V+ de servos está alimentado con 5–6 V adecuados.
  • Verificar la masa común entre Raspberry Pi y PCA9685.
  • Ajustar los valores servo_left, servo_center, servo_right en el nodo:

bash
ros2 run ugv_beast_patrol patrol_node --ros-args -p servo_left:=0.0010 -p servo_center:=0.0015 -p servo_right:=0.0020

  • Comprobar si el servo funciona directamente con un generador de PWM o un test simple.

6. El robot se mueve de manera errática o demasiado rápido

Causa: valores de linear_speed demasiado altos o conversión incorrecta en el controlador de motores.

Solución:

  • Bajar la velocidad:

bash
ros2 run ugv_beast_patrol patrol_node --ros-args -p linear_speed:=0.05

  • Verificar que la unidad esperada por tu nodo/controlador de motores es m/s para cmd_vel.linear.x.

7. Latencia de vídeo muy alta (>1 s)

Causa: red saturada, resolución muy alta o CPU de la Pi sobrecargada.

Solución:

  • Reducir resolución y FPS:

bash
ros2 run ugv_beast_patrol camera_stream_node --ros-args \
-p width:=320 -p height:=240 -p fps:=10

  • Asegurarse de que no se ejecutan procesos pesados en la Pi (p.ej., RViz local).
  • Usar conexión Ethernet en lugar de Wi-Fi si es posible.

8. ros2 topic desde el PC no ve los tópicos de la Raspberry Pi

Causa: problemas de descubrimiento DDS o redes separadas.

Solución:

  • Verificar que ambas máquinas están en la misma subred IP.
  • Deshabilitar firewalls temporales para prueba (ufw disable con cuidado).
  • Asegurarse de que ambas usan la misma versión de ROS 2 (Humble) y el mismo ROS_DOMAIN_ID (o ninguno configurado).

Mejoras / variantes

Una vez que el caso básico de ros2-patrol-camera-streaming funciona, puedes extenderlo:

  1. Integración con diff_drive_controller y ros2_control
  2. Crear un archivo URDF del UGV con:
    • base_link
    • left_wheel_link
    • right_wheel_link

  3. Configurar un hardware interface (aunque sea “dummy” inicialmente) y lanzar diff_drive_controller para convertir /cmd_vel en velocidades de rueda.

  4. Odometría e IMU con robot_localization

  5. Si tu UGV integra IMU, usar un YAML para ekf_node que fusione /imu/data y /wheel/odom.

  6. Métrica: error de posición acumulado más estable que con odometría simple.

  7. SLAM y navegación (slam_toolbox, nav2)

  8. Ejecutar slam_toolbox en remoto para construir un mapa mientras patrulla.
  9. Guardar mapa con map_server.
  10. Usar Nav2 para mandar objetivos simples, en lugar de patrulla fija.

  11. Comprobar que el UGV puede repetir una ruta en el mapa guardado.

  12. Control avanzado de la cámara

  13. Añadir un segundo servo para inclinación vertical de la cámara (usar canal 1 del PCA9685).

  14. Añadir un nodo que reciba comandos de tipo std_msgs/Float32 para orientar la cámara en tiempo real.

  15. Grabación y análisis de rosbag

  16. Grabar /camera/image_raw, /cmd_vel y (cuando lo tengas) /odom con ros2 bag.
  17. Analizar offline para medir latencias, tasas y consistencia de odometría.

Checklist de verificación

Marca cada ítem cuando lo completes:

  • [ ] Ubuntu Server 22.04.4 LTS aarch64 instalado y actualizado en Raspberry Pi 4 Model B.
  • [ ] ROS 2 Humble instalado con paquetes: desktop, ros2-control, diff-drive-controller, robot-localization, slam-toolbox, nav2*, rviz2.
  • [ ] Workspace ~/ros2_ws creado y compilado con colcon build sin errores.
  • [ ] Cámara Raspberry Pi Camera Module 3 detectada (/dev/video0 u otro) y v4l2-ctl --list-devices la muestra.
  • [ ] I2C habilitado, i2cdetect -y 1 muestra la dirección 0x40 del PCA9685.
  • [ ] Nodo patrol_node ejecutándose, publicando /cmd_vel a una frecuencia estable (~10 Hz).
  • [ ] Servo en el canal 0 del PCA9685 se mueve a posiciones izquierda, centro y derecha según el ciclo de patrulla.
  • [ ] Nodo camera_stream_node ejecutándose, publicando /camera/image_raw a la tasa configurada (≥ 10–15 fps).
  • [ ] Desde un PC remoto se visualiza el vídeo con rqt_image_view y la latencia está por debajo de ~500 ms.
  • [ ] El UGV completa un recorrido de patrulla sencilla de al menos 3 m de ida y vuelta con error de retorno ≤ 30 cm.
  • [ ] Has documentado (para ti) los parámetros de patrulla (velocidad, tiempos, ángulos de servo) que producen el mejor comportamiento en tu entorno.

Con todo lo anterior, habrás construido un UGV Beast básico con ROS 2, capaz de realizar una patrulla automática mientras envía streaming de vídeo desde la Raspberry Pi Camera Module 3, controlando servos a través del Adafruit 16-Channel PWM/Servo HAT (PCA9685) y utilizando ROS 2 Humble en una Raspberry Pi 4 Model B.

Encuentra este producto y/o libros sobre este tema en Amazon

Ir a Amazon

Como afiliado de Amazon, gano con las compras que cumplan los requisitos. Si compras a través de este enlace, ayudas a mantener este proyecto.

Quiz rápido

Pregunta 1: ¿Qué tipo de robot se construirá según el artículo?




Pregunta 2: ¿Cuál es el propósito principal del UGV mencionado?




Pregunta 3: ¿Qué tecnología se utilizará para la transmisión de vídeo?




Pregunta 4: ¿Cuál es la latencia esperada en la transmisión de vídeo en LAN?




Pregunta 5: ¿Qué sistema operativo se utilizará en el UGV?




Pregunta 6: ¿Qué componente se usará para controlar los servos?




Pregunta 7: ¿Cuál es el objetivo de las patrullas automáticas del robot?




Pregunta 8: ¿Qué tipo de público está dirigido el proyecto?




Pregunta 9: ¿Qué se espera del consumo de CPU durante la transmisión de vídeo?




Pregunta 10: ¿Qué se utilizará para gestionar los nodos de ROS 2?




Carlos Núñez Zorrilla
Carlos Núñez Zorrilla
Electronics & Computer Engineer

Ingeniero Superior en Electrónica de Telecomunicaciones e Ingeniero en Informática (titulaciones oficiales en España).

Sígueme:

Caso práctico: Waypoints GPS en UGV Beast (ROS 2)

Caso práctico: Waypoints GPS en UGV Beast (ROS 2) — hero

Objetivo y caso de uso

Qué construirás: Un sistema ROS 2 Humble de navegación por waypoints GPS en un UGV Beast con Raspberry Pi 4, Adafruit Ultimate GPS HAT (MTK3339) y Waveshare 10-DOF IMU, capaz de ir de un punto A a B a C de forma autónoma suavizando la trayectoria con IMU + odometría.

Para qué sirve

  • Patrullar automáticamente el perímetro de una finca (p. ej. 4–6 waypoints formando un rectángulo) registrando vídeo o datos ambientales.
  • Recorrer una ruta fija en un aparcamiento para vigilancia periódica (pasadas cada 5–10 minutos, latencia de control < 50 ms).
  • Realizar demos de navegación autónoma al aire libre en un campus, mostrando cambios en tiempo real de la ruta desde RViz2.
  • Ejecutar rutas de reparto interno en almacenes semiabiertos donde el GPS es utilizable, con actualización de pose a > 10 Hz.
  • Montar un circuito educativo A–B–C–A para enseñar conceptos de ROS 2 (topics, frames TF, control de velocidad) en menos de 10 minutos de setup.

Resultado esperado

  • El robot recorre al menos 3 waypoints GPS consecutivos con un error de llegada típico de 3–5 m (limitado por la precisión del MTK3339).
  • Publicación estable en /fix, /imu, /odom y /cmd_vel a 10–20 Hz, con latencia de extremo a extremo (GPS → cmd_vel) < 100 ms.
  • Uso de CPU en la Raspberry Pi 4 < 45 % y carga de GPU irrelevante (< 5 %, sin aceleración pesada), garantizando > 30 Hz de lazo de control.
  • Transición limpia entre waypoints (sin oscilaciones fuertes ni cambios bruscos > 50 % en velocidad lineal/angular por ciclo).

Público objetivo: Estudiantes, makers y desarrolladores junior de robótica móvil; Nivel: Intermedio (se asume familiaridad básica con Linux, ROS 2 y cinemática diferencial).

Arquitectura/flujo: Nodo GPS lee /fix, se fusiona con IMU (MPU9250) y odometría en un filtro (p. ej. ekf_node) para generar /odom → nodo de navegación por waypoints calcula el error pose-objetivo, genera comandos de velocidad en /cmd_vel → controlador del UGV ejecuta la velocidad; monitorización desde RViz2 con TF entre map, odom y base_link.

Prerrequisitos

Sistema operativo y plataforma

  • Hardware principal:
  • Raspberry Pi 4 Model B (4 GB o 8 GB recomendado).
  • Sistema operativo:
  • Ubuntu Server 22.04 LTS 64-bit (aarch64) para Raspberry Pi 4.
  • ROS 2:
  • ROS 2 Humble Hawksbill (aarch64) instalado desde apt.

Versiones de toolchain

En este caso práctico usaremos:

  • Kernel y SO (ejemplo típico):
  • Ubuntu 22.04.4 LTS
  • Kernel Linux 5.15.x para Raspberry Pi
  • ROS 2:
  • ros-humble-desktop (meta-paquete principal)
  • Versiones instaladas por apt oficiales de Ubuntu.
  • Compilador y herramientas:
  • gcc 11.x
  • cmake 3.22+
  • python3 3.10
  • colcon (python3-colcon-common-extensions)
  • Librerías ROS 2 específicas:
  • ros-humble-ros2-control
  • ros-humble-diff-drive-controller
  • ros-humble-robot-localization
  • ros-humble-slam-toolbox
  • ros-humble-nav2-bringup
  • ros-humble-nav2-core
  • ros-humble-nav2-costmap-2d
  • ros-humble-nav2-planner
  • ros-humble-nav2-controller
  • ros-humble-nav2-lifecycle-manager
  • ros-humble-rviz2

Nota: Aunque instalamos SLAM y Nav2 completos según la pauta, en este caso práctico usaremos principalmente robot_localization y un nodo propio de navegación por GPS.

Otros prerrequisitos

  • Conocer comandos básicos de terminal: cd, ls, nano, vim.
  • Saber usar ssh para acceder a la Raspberry Pi.
  • Habilidad básica de lectura de pines GPIO e I2C desde documentación.

Materiales

Lista de materiales principales

  • Computadora a bordo
  • 1 × Raspberry Pi 4 Model B (4 GB o 8 GB RAM).
  • Sensor de posicionamiento
  • 1 × Adafruit Ultimate GPS HAT (MTK3339) para Raspberry Pi.
  • Unidad de medida inercial
  • 1 × Waveshare 10-DOF IMU Breakout
    • Acelerómetro + giroscopio: MPU9250
    • Presión/barómetro: BMP280
  • Robot base UGV Beast (ROS 2) – RPi
  • Chasis UGV Beast con motores de tracción diferencial.
  • Controlador de motores (p. ej. puente H doble o driver de motor compatible).
  • Batería adecuada para el UGV y la Raspberry Pi (ej. LiPo 3S con regulador 5 V).
  • Cables y accesorios
  • Cables dupont hembra-hembra para conexión I2C (Waveshare IMU → Raspberry Pi GPIO).
  • Separadores/espaciadores para montar el GPS HAT sobre la Raspberry Pi.
  • Tarjeta microSD (32 GB mínimo) para Ubuntu 22.04.
  • Red
  • Conexión Wi-Fi o Ethernet para acceso remoto a la Raspberry Pi.

Preparación y conexión

1. Instalación del sistema operativo y ROS 2 Humble

En tu PC:

  1. Descargar imagen de Ubuntu Server 22.04 64-bit para Raspberry Pi desde la web oficial de Ubuntu.
  2. Volcarla a la tarjeta microSD (con Raspberry Pi Imager o balenaEtcher).

En la Raspberry Pi (por consola, sin GUI):

Configurar Ubuntu 22.04 y ROS 2 Humble

# Actualizar sistema
sudo apt update
sudo apt upgrade -y

# Configurar locales (si aún no lo has hecho)
sudo apt install -y locales
sudo locale-gen en_US en_US.UTF-8
sudo update-locale LC_ALL=en_US.UTF-8 LANG=en_US.UTF-8

# Añadir repositorios ROS 2 Humble
sudo apt install -y software-properties-common
sudo add-apt-repository universe
sudo apt update

sudo apt install -y curl
sudo curl -sSL https://raw.githubusercontent.com/ros/rosdistro/master/ros.key \
  -o /usr/share/keyrings/ros-archive-keyring.gpg

echo "deb [arch=$(dpkg --print-architecture) \
signed-by=/usr/share/keyrings/ros-archive-keyring.gpg] \
http://packages.ros.org/ros2/ubuntu $(. /etc/os-release && echo $UBUNTU_CODENAME) main" \
| sudo tee /etc/apt/sources.list.d/ros2.list > /dev/null

sudo apt update

# Instalar ROS 2 Humble desktop
sudo apt install -y ros-humble-desktop

# Paquetes adicionales requeridos
sudo apt install -y \
  ros-humble-ros2-control \
  ros-humble-diff-drive-controller \
  ros-humble-robot-localization \
  ros-humble-slam-toolbox \
  ros-humble-nav2-bringup \
  ros-humble-nav2-core \
  ros-humble-nav2-costmap-2d \
  ros-humble-nav2-planner \
  ros-humble-nav2-controller \
  ros-humble-nav2-lifecycle-manager \
  ros-humble-rviz2

# Herramientas de compilación
sudo apt install -y \
  python3-colcon-common-extensions \
  build-essential \
  cmake \
  git

Añadir source de ROS 2 al .bashrc:

echo "source /opt/ros/humble/setup.bash" >> ~/.bashrc
source ~/.bashrc

2. Conexión de sensores a la Raspberry Pi

El Adafruit Ultimate GPS HAT se monta físicamente sobre la Raspberry Pi 4. El Waveshare 10-DOF IMU se conecta por I2C a los pines de la Raspberry Pi.

2.1. Adafruit Ultimate GPS HAT (MTK3339)

  • Se inserta encima del GPIO de la Raspberry Pi, haciendo contacto con los 40 pines.
  • Alimentación: toma 5 V directamente del conector.
  • Comunicación principal: UART (ttyAMA0/ttyS0) y también acceso por I2C a RTC (si está presente, según modelo).

Configuración esencial:

  • Habilitar UART en la Raspberry Pi.
  • Deshabilitar la consola serie sobre el UART principal para usarlo con GPS.

En Ubuntu 22.04 para RPi (sin GUI), editar:

sudo nano /boot/firmware/cmdline.txt

Eliminar cualquier referencia a console=serial0,115200 o similar. Deja solo la consola por tty1.

Luego, habilitar UART en:

sudo nano /boot/firmware/config.txt

Añadir:

enable_uart=1

Guardar y reiniciar:

sudo reboot

Tras el reinicio, el dispositivo serie del GPS suele aparecer como /dev/ttyAMA0 o /dev/serial0. Compruébalo:

ls -l /dev/ttyAMA0 /dev/serial0

2.2. Waveshare 10-DOF IMU Breakout (MPU9250 + BMP280) por I2C

Conectar los pines:

Elemento Pin Raspberry Pi 4 Descripción RPi GPIO Pin IMU Waveshare 10-DOF
Alimentación +3.3 V Pin 1 3V3 Power VCC
GND Pin 6 Ground GND
I2C SDA Pin 3 GPIO2 (SDA1, bus I2C-1) SDA
I2C SCL Pin 5 GPIO3 (SCL1, bus I2C-1) SCL

Asegúrate de que la IMU esté configurada para 3.3 V en caso de jumper/selector.

Habilitar I2C en config.txt:

sudo nano /boot/firmware/config.txt

Añadir:

dtparam=i2c_arm=on

Reiniciar:

sudo reboot

Comprobar que I2C funciona:

sudo apt install -y i2c-tools
sudo i2cdetect -y 1

Deberías ver direcciones típicas como:

  • 0x68 (MPU9250).
  • 0x76 o 0x77 (BMP280).

Código completo: paquete ROS 2 para ros2-gps-waypoint-nav

Crearemos un workspace ~/ros2_ws con:

  • Un paquete ugv_beast_description con URDF sencillo + ros2_control.
  • Un paquete ugv_beast_bringup con lanzadores.
  • Un paquete ros2_gps_waypoint_nav con un nodo Python para navegar waypoints GPS.

1. Crear el workspace y estructura

mkdir -p ~/ros2_ws/src
cd ~/ros2_ws

# Paquete descripción
cd src
ros2 pkg create --build-type ament_cmake ugv_beast_description

# Paquete bringup
ros2 pkg create --build-type ament_cmake ugv_beast_bringup

# Paquete de navegación por GPS (Python)
ros2 pkg create --build-type ament_python ros2_gps_waypoint_nav

2. URDF y ros2_control (ugv_beast_description)

No entraremos en todos los detalles mecánicos del UGV Beast, pero definimos un modelo mínimo.

Crear directorios:

cd ~/ros2_ws/src/ugv_beast_description
mkdir -p urdf config

Archivo urdf/ugv_beast.urdf.xacro (simplificado, parte clave mostrada):

<?xml version="1.0"?>
<robot name="ugv_beast" xmlns:xacro="http://www.ros.org/wiki/xacro">

  <!-- Parámetros físico-geométricos aproximados -->
  <xacro:property name="wheel_radius" value="0.1"/> <!-- 10 cm -->
  <xacro:property name="track_width"  value="0.35"/> <!-- distancia entre ruedas -->

  <link name="base_link">
    <inertial>
      <mass value="10.0"/>
      <origin xyz="0 0 0.1" rpy="0 0 0"/>
      <inertia ixx="0.5" iyy="0.5" izz="0.5"
               ixy="0.0" ixz="0.0" iyz="0.0"/>
    </inertial>
    <visual>
      <origin xyz="0 0 0.1" rpy="0 0 0"/>
      <geometry>
        <box size="0.5 0.3 0.2"/>
      </geometry>
      <material name="gray">
        <color rgba="0.6 0.6 0.6 1.0"/>
      </material>
    </visual>
  </link>

  <!-- Rueda izquierda -->
  <link name="left_wheel_link"/>
  <joint name="left_wheel_joint" type="continuous">
    <parent link="base_link"/>
    <child link="left_wheel_link"/>
    <origin xyz="0 ${track_width/2} 0" rpy="0 0 0"/>
    <axis xyz="0 1 0"/>
  </joint>

  <!-- Rueda derecha -->
  <link name="right_wheel_link"/>
  <joint name="right_wheel_joint" type="continuous">
    <parent link="base_link"/>
    <child link="right_wheel_link"/>
    <origin xyz="0 -${track_width/2} 0" rpy="0 0 0"/>
    <axis xyz="0 1 0"/>
  </joint>

  <!-- Plugin ros2_control dif-drive -->
  <ros2_control name="ugv_beast_controller" type="system">
    <hardware>
      <plugin>ros2_control_hardware_interface/GenericSystem</plugin>
      <!-- En la práctica, aquí iría tu driver propio hacia el controlador de motores -->
    </hardware>
    <joint name="left_wheel_joint">
      <command_interface name="velocity"/>
      <state_interface name="velocity"/>
    </joint>
    <joint name="right_wheel_joint">
      <command_interface name="velocity"/>
      <state_interface name="velocity"/>
    </joint>
  </ros2_control>

</robot>

Archivo config/diff_drive_controller.yaml:

diff_drive_controller:
  ros__parameters:
    use_sim_time: false
    publish_rate: 50.0
    base_frame_id: base_link
    odom_frame_id: odom
    left_wheel_names: ["left_wheel_joint"]
    right_wheel_names: ["right_wheel_joint"]
    wheel_separation: 0.35    # track_width
    wheel_radius: 0.1
    cmd_vel_timeout: 0.5
    publish_wheel_data: true
    enable_odom_tf: true
    velocity_rolling_window_size: 10
    linear:
      x:
        has_velocity_limits: true
        max_velocity: 0.6
        min_velocity: -0.6
    angular:
      z:
        has_velocity_limits: true
        max_velocity: 1.5
        min_velocity: -1.5

Calibración rápida:
– Mide el diámetro de la rueda: radio = diámetro/2.
– Mide la distancia entre centros de ruedas: wheel_separation.
– Ajusta los valores en diff_drive_controller.yaml para que el odómetro no derive demasiado.

3. Configurar robot_localization (EKF IMU + odom)

En ugv_beast_bringup, crear config/ekf.yaml:

cd ~/ros2_ws/src/ugv_beast_bringup
mkdir -p config launch

Archivo config/ekf.yaml:

ekf_filter_node:
  ros__parameters:
    frequency: 30.0
    sensor_timeout: 0.1
    two_d_mode: true
    transform_time_offset: 0.0
    transform_timeout: 0.0
    publish_tf: true
    map_frame: map
    odom_frame: odom
    base_link_frame: base_link
    world_frame: odom

    # Entrada de odometría (p.ej. de diff_drive_controller /odom)
    odom0: /odom
    odom0_config: [true,  true,  false,
                   false, false, true,
                   false, false, false,
                   false, false, false,
                   false, false, false]
    odom0_differential: false
    odom0_relative: false

    # IMU (Waveshare 10-DOF) publicando en /imu/data
    imu0: /imu/data
    imu0_config: [false, false, false,
                  true,  true,  true,
                  false, false, false,
                  false, false, false,
                  false, false, false]
    imu0_differential: false
    imu0_relative: false
    imu0_remove_gravitational_acceleration: true

Ajusta los topics odom0 e imu0 a los que efectivamente generes con tus drivers de IMU y odometría. En este caso asumimos:
– /odom publicado por el diff_drive_controller.
– /imu/data publicado por un driver de la IMU Waveshare (no desarrollamos aquí el driver específico; puedes usar uno basado en MPU9250 + BMP280 en Python o C++ que publique sensor_msgs/msg/Imu).

4. Nodo de navegación por waypoints GPS (ros2_gps_waypoint_nav)

4.1. Estructura del paquete

En ros2_gps_waypoint_nav, edita package.xml y setup.cfg/setup.py para incluir dependencias básicas: rclpy, sensor_msgs, geometry_msgs, nav_msgs, std_msgs.

package.xml (fragmentos clave):

<package format="3">
  <name>ros2_gps_waypoint_nav</name>
  <version>0.0.1</version>
  <description>Navegación por waypoints GPS para UGV Beast (ROS2)</description>
  <maintainer email="you@example.com">Tu Nombre</maintainer>
  <license>Apache-2.0</license>

  <buildtool_depend>ament_cmake</buildtool_depend>

  <depend>rclpy</depend>
  <depend>sensor_msgs</depend>
  <depend>geometry_msgs</depend>
  <depend>nav_msgs</depend>
  <depend>std_msgs</depend>

  <exec_depend>python3</exec_depend>

</package>

setup.py:

from setuptools import setup

package_name = 'ros2_gps_waypoint_nav'

setup(
    name=package_name,
    version='0.0.1',
    packages=[package_name],
    data_files=[
        ('share/ament_index/resource_index/packages',
         ['resource/' + package_name]),
        ('share/' + package_name, ['package.xml']),
    ],
    install_requires=['setuptools'],
    zip_safe=True,
    maintainer='Tu Nombre',
    maintainer_email='you@example.com',
    description='Navegación por waypoints GPS usando ROS2 y UGV Beast',
    license='Apache-2.0',
    tests_require=['pytest'],
    entry_points={
        'console_scripts': [
            'gps_waypoint_nav = ros2_gps_waypoint_nav.gps_waypoint_nav:main',
        ],
    },
)

Crear directorio de código:

cd ~/ros2_ws/src/ros2_gps_waypoint_nav
mkdir -p ros2_gps_waypoint_nav
touch ros2_gps_waypoint_nav/__init__.py

4.2. Lógica del nodo gps_waypoint_nav.py

Este nodo:

  • Se suscribe a /fix (sensor_msgs/msg/NavSatFix) del GPS MTK3339 en el HAT.
  • Se suscribe a /odometry/filtered (nav_msgs/msg/Odometry) para tener una mejor pose local.
  • Convierte una lista de waypoints GPS (lat, lon) a un sistema local plano (aprox. ENU simple).
  • Calcula la distancia y el ángulo hacia el siguiente waypoint respecto a la orientación actual.
  • Publica comandos /cmd_vel (geometry_msgs/msg/Twist) para avanzar hacia el waypoint.
  • Considera el waypoint alcanzado cuando la distancia es menor a un umbral (p. ej. 2 m).

Archivo ros2_gps_waypoint_nav/gps_waypoint_nav.py:

#!/usr/bin/env python3
import math
from typing import List, Tuple

import rclpy
from rclpy.node import Node
from sensor_msgs.msg import NavSatFix
from nav_msgs.msg import Odometry
from geometry_msgs.msg import Twist
from rclpy.qos import QoSProfile, ReliabilityPolicy, HistoryPolicy

# Utilidad: conversión simple lat/lon a sistema local (aprox UTM plano)
def geodetic_to_local(lat_ref, lon_ref, lat, lon):
    """
    Conversión aproximada de coordenadas geodésicas (lat, lon en grados)
    a coordenadas locales (x, y) en metros usando aproximación de equirectangular.
    Válido para recorridos cortos (< 1 km aprox.).
    """
    # Radio medio de la Tierra (m)
    R = 6378137.0
    # Convertir a radianes
    lat_ref_rad = math.radians(lat_ref)
    lat_rad = math.radians(lat)
    d_lat = lat_rad - lat_ref_rad
    d_lon = math.radians(lon - lon_ref)
    x = R * d_lon * math.cos(lat_ref_rad)
    y = R * d_lat
    return x, y


class GPSWaypointNavNode(Node):
    def __init__(self):
        super().__init__('gps_waypoint_nav')

        # Parámetros configurables
        self.declare_parameter('waypoints', [
            # Ejemplo: lista [lat1, lon1, lat2, lon2, ...]
            40.4168, -3.7038,  # Punto 1
            40.4169, -3.7035,  # Punto 2
            40.4170, -3.7032   # Punto 3
        ])
        self.declare_parameter('goal_tolerance', 2.0)        # en metros
        self.declare_parameter('linear_speed', 0.3)          # m/s
        self.declare_parameter('angular_speed_gain', 1.0)    # factor proporcional
        self.declare_parameter('max_angular_speed', 1.0)     # rad/s
        self.declare_parameter('fix_topic', '/fix')
        self.declare_parameter('odom_topic', '/odometry/filtered')
        self.declare_parameter('cmd_vel_topic', '/cmd_vel')

        # Cargar parámetros
        wp_list = self.get_parameter('waypoints').get_parameter_value().double_array_value
        if len(wp_list) % 2 != 0:
            self.get_logger().error('El parámetro "waypoints" debe tener longitud par (lat, lon)')
            wp_list = []

        self.waypoints: List[Tuple[float, float]] = []
        for i in range(0, len(wp_list), 2):
            self.waypoints.append((wp_list[i], wp_list[i+1]))

        self.goal_tolerance = self.get_parameter('goal_tolerance').get_parameter_value().double_value
        self.linear_speed = self.get_parameter('linear_speed').get_parameter_value().double_value
        self.angular_speed_gain = self.get_parameter('angular_speed_gain').get_parameter_value().double_value
        self.max_angular_speed = self.get_parameter('max_angular_speed').get_parameter_value().double_value

        fix_topic = self.get_parameter('fix_topic').get_parameter_value().string_value
        odom_topic = self.get_parameter('odom_topic').get_parameter_value().string_value
        cmd_vel_topic = self.get_parameter('cmd_vel_topic').get_parameter_value().string_value

        # Estado interno
        self.current_fix: NavSatFix = None
        self.current_yaw: float = 0.0
        self.local_ref_set: bool = False
        self.lat_ref: float = 0.0
        self.lon_ref: float = 0.0
        self.current_wp_idx: int = 0

        qos = QoSProfile(
            reliability=ReliabilityPolicy.BEST_EFFORT,
            history=HistoryPolicy.KEEP_LAST,
            depth=10
        )

        # Suscripciones
        self.fix_sub = self.create_subscription(
            NavSatFix, fix_topic, self.fix_callback, qos)

        self.odom_sub = self.create_subscription(
            Odometry, odom_topic, self.odom_callback, 10)

        # Publicador de velocidad
        self.cmd_vel_pub = self.create_publisher(Twist, cmd_vel_topic, 10)

        # Timer de control (10 Hz)
        self.control_timer = self.create_timer(0.1, self.control_loop)

        self.get_logger().info('Nodo gps_waypoint_nav inicializado.')
        self.get_logger().info(f'Waypoints cargados: {self.waypoints}')

    def fix_callback(self, msg: NavSatFix):
        self.current_fix = msg
        if not self.local_ref_set and msg.status.status >= 0:
            # Establecer referencia local en el primer fix válido
            self.lat_ref = msg.latitude
            self.lon_ref = msg.longitude
            self.local_ref_set = True
            self.get_logger().info(
                f'Referencia local establecida en lat={self.lat_ref}, lon={self.lon_ref}')

    def odom_callback(self, msg: Odometry):
        # Extraer yaw de la orientación cuaternión
        q = msg.pose.pose.orientation
        # Conversión quaternion -> yaw
        siny_cosp = 2.0 * (q.w * q.z + q.x * q.y)
        cosy_cosp = 1.0 - 2.0 * (q.y * q.y + q.z * q.z)
        self.current_yaw = math.atan2(siny_cosp, cosy_cosp)

    def control_loop(self):
        # Condiciones mínimas
        if not self.waypoints:
            self.get_logger().warn_once('No hay waypoints configurados.')
            return

        if self.current_fix is None or not self.local_ref_set:
            self.get_logger().warn_once('Esperando a posición GPS válida...')
            return

        if self.current_wp_idx >= len(self.waypoints):
            # Ruta completada
            self.stop_robot()
            self.get_logger().info_once('Todos los waypoints alcanzados.')
            return

        # Waypoint objetivo actual
        target_lat, target_lon = self.waypoints[self.current_wp_idx]

        # Posición actual en sistema local (x, y)
        cur_x, cur_y = geodetic_to_local(
            self.lat_ref, self.lon_ref,
            self.current_fix.latitude, self.current_fix.longitude
        )

        # Posición objetivo en sistema local (x, y)
        goal_x, goal_y = geodetic_to_local(
            self.lat_ref, self.lon_ref,
            target_lat, target_lon
        )

        dx = goal_x - cur_x
        dy = goal_y - cur_y
        distance = math.hypot(dx, dy)

        # Comprobar si el waypoint está alcanzado
        if distance <= self.goal_tolerance:
            self.get_logger().info(
                f'Waypoint {self.current_wp_idx} alcanzado. Distancia={distance:.2f} m')
            self.current_wp_idx += 1
            # Parar brevemente
            self.stop_robot()
            return

        # Ángulo hacia el objetivo en el sistema local
        target_yaw = math.atan2(dy, dx)
        yaw_error = self.normalize_angle(target_yaw - self.current_yaw)

        # Control sencillo P de la orientación y avance constante
        twist = Twist()
        twist.linear.x = self.linear_speed
        twist.angular.z = self.angular_speed_gain * yaw_error

        # Saturar velocidad angular
        if twist.angular.z > self.max_angular_speed:
            twist.angular.z = self.max_angular_speed
        elif twist.angular.z < -self.max_angular_speed:
            twist.angular.z = -self.max_angular_speed

        self.cmd_vel_pub.publish(twist)

    def stop_robot(self):
        twist = Twist()
        self.cmd_vel_pub.publish(twist)

    @staticmethod
    def normalize_angle(angle):
        # Llevar ángulo a rango [-pi, pi]
        while angle > math.pi:
            angle -= 2.0 * math.pi
        while angle < -math.pi:
            angle += 2.0 * math.pi
        return angle


def main(args=None):
    rclpy.init(args=args)
    node = GPSWaypointNavNode()
    try:
        rclpy.spin(node)
    except KeyboardInterrupt:
        pass
    node.stop_robot()
    node.destroy_node()
    rclpy.shutdown()


if __name__ == '__main__':
    main()

Dar permisos de ejecución:

chmod +x ~/ros2_ws/src/ros2_gps_waypoint_nav/ros2_gps_waypoint_nav/gps_waypoint_nav.py

Compilación y ejecución

1. Compilar el workspace con colcon

cd ~/ros2_ws
colcon build

Tras compilar sin errores:

source install/setup.bash

Para que se haga siempre:

echo "source ~/ros2_ws/install/setup.bash" >> ~/.bashrc
source ~/.bashrc

2. Lanzar los componentes requeridos

En una sesión tmux o varias terminales SSH, seguiremos una secuencia.

  1. Lanzar driver GPS
    Puedes usar un nodo que publique sensor_msgs/NavSatFix en /fix a partir de /dev/ttyAMA0. Por ejemplo, usando nmea_navsat_driver (si lo instalas) o un script propio. Suponiendo que ya tienes un nodo publicando /fix:

bash
ros2 topic echo /fix # Para verificar

  1. Lanzar IMU driver
    De forma análoga, lanza tu driver para MPU9250 + BMP280 que publique en /imu/data (tipo sensor_msgs/msg/Imu).

bash
ros2 topic echo /imu/data

  1. Lanzar diff_drive_controller + robot_localization
    Crea un launch sencillo en ugv_beast_bringup/launch/ugv_beast_bringup.launch.py (esquema orientativo, sin mostrarlo entero aquí por extensión) que:

  2. Cargue el URDF de ugv_beast_description.

  3. Inicie controller_manager con diff_drive_controller.
  4. Inicie el nodo ekf_node de robot_localization con ekf.yaml.

Ejecútalo (ejemplo):

bash
ros2 launch ugv_beast_bringup ugv_beast_bringup.launch.py

  1. Lanzar el nodo ros2-gps-waypoint-nav

En otra terminal:

bash
ros2 run ros2_gps_waypoint_nav gps_waypoint_nav \
--ros-args \
-p waypoints:="[40.4168, -3.7038, 40.4169, -3.7035, 40.4170, -3.7032]" \
-p goal_tolerance:=2.0 \
-p linear_speed:=0.3 \
-p angular_speed_gain:=1.0 \
-p max_angular_speed:=0.8

Asegúrate de usar coordenadas GPS reales de tu entorno de prueba.

Validación paso a paso

1. Validar sensores

  1. GPS HAT (MTK3339):

  2. Comprobar dispositivo:

    bash
    ls -l /dev/ttyAMA0
    sudo cat /dev/ttyAMA0 | head

  3. Debes ver mensajes NMEA ($GPGGA, $GPRMC, etc.).

  4. En ROS 2, verifica el topic /fix:

    bash
    ros2 topic list
    ros2 topic echo /fix

  5. Señales de éxito:

    • Frecuencia ≥ 1 Hz (ros2 topic hz /fix).
    • status.status >= 0 (fix 2D/3D).

  6. IMU Waveshare 10-DOF:

  7. i2cdetect -y 1 muestra direcciones del MPU9250 y BMP280.

  8. En ROS 2:

    bash
    ros2 topic echo /imu/data
    ros2 topic hz /imu/data

  9. Espera al menos 50 Hz si el driver está configurado a esa tasa.

2. Validar odometría y EKF

  • Con diff_drive_controller activo:

bash
ros2 topic echo /odom
ros2 topic echo /odometry/filtered

  • Mover ligeramente el robot (o ruedas en el aire) y verificar que las posiciones cambian coherentemente.
  • Comprobar TF:

bash
ros2 run tf2_tools view_frames

Luego inspeccionar el PDF generado y verificar frames: odom -> base_link, map -> odom.

3. Validar /cmd_vel desde el nodo de navegación

  • Antes de mover el robot en el suelo, haz una prueba con el robot levantado (ruedas en el aire) o sin motores energizados:

  • Levanta el nodo de navegación.

  • En otra terminal:

    bash
    ros2 topic echo /cmd_vel

  • Fija waypoints cercanos a tu posición actual.

  • Comprueba que:
    • /cmd_vel tiene linear.x alrededor de 0.3.
    • angular.z cambia de signo según el ángulo hacia el objetivo.

4. Prueba de campo

  1. Coloca el robot en un espacio abierto con buena visibilidad de cielo.
  2. Espera a que el GPS consiga un fix estable (idealmente HDOP bajo, si expones este dato).
  3. Mide las coordenadas del punto inicial (puedes leer /fix y anotar latitude/longitude).
  4. Define 2–3 waypoints alrededor (p.ej. formar un triángulo de 10–15 m de lado).
  5. Lanza todos los nodos como en la sección anterior.
  6. Observa:
  7. El robot se orienta hacia el primer waypoint y avanza.
  8. Al entrar en el radio de tolerancia (~2 m), se detiene brevemente, cambia de orientación y se dirige al siguiente.
  9. Completa la secuencia de waypoints con desviación ≤ 3–5 m respecto a cada punto (limitado por precisión GPS).

Troubleshooting (errores típicos y soluciones)

  1. No aparece /fix en ROS 2
  2. Causas probables:
    • UART está todavía ocupado por la consola serie.
    • Driver del GPS no está usando /dev/ttyAMA0 correcto.

  3. Solución:

    • Revisa /boot/firmware/cmdline.txt y asegúrate de quitar console=serial0,....
    • Verifica enable_uart=1 en config.txt.
    • Confirma el dispositivo con ls -l /dev/ttyAMA0 /dev/serial0.

  4. /imu/data no existe

  5. Causas:
    • I2C no habilitado.
    • Cableado incorrecto (SDA/SCL invertidos o sin GND común).

  6. Solución:

    • Habilita dtparam=i2c_arm=on.
    • Revisa que el Waveshare IMU 10-DOF esté alimentado a 3.3 V.
    • Verifica direcciones con i2cdetect -y 1.

  7. El robot gira en círculos y no avanza hacia el waypoint

  8. Causas:
    • Frame de referencia de odometría mal configurado.
    • Orientación (yaw) no coincide con el eje del robot.

  9. Solución:

    • Comprueba que base_link está alineado con la dirección de avance del robot en el URDF.
    • Revisa TF (odom -> base_link) y confirmarlo en RViz.
    • Ajusta angular_speed_gain y max_angular_speed para evitar oscilaciones.

  10. El robot se detiene aleatoriamente aunque aún no llegó al waypoint

  11. Causas:
    • Pérdidas de señal GPS: status.status < 0 o saltos bruscos.
    • robot_localization no recibe datos a tiempo (time-out).

  12. Solución:

    • Verifica calidad de señal GPS en un espacio más abierto.
    • Asegúrate de que la frecuencia de /fix sea estable.
    • Ajusta sensor_timeout en ekf.yaml si es demasiado bajo.

  13. Error de compilación de ros2_gps_waypoint_nav

  14. Causas:
    • setup.py o package.xml mal configurados.

  15. Solución:

    • Revisa que packages=[package_name] en setup.py.
    • Verifica que __init__.py existe.
    • Asegúrate de que ros2_gps_waypoint_nav/gps_waypoint_nav.py es ejecutable.

  16. colcon build no encuentra dependencias como rclpy

  17. Causas:
    • ros-humble-desktop o python3-rclpy no instalados.

  18. Solución:

    • Reinstala paquetes ROS 2 básicos:

    bash
    sudo apt install -y ros-humble-desktop python3-rclpy

  19. El robot avanza demasiado rápido o se sale del área de pruebas

  20. Causas:
    • Parámetros de velocidad demasiado altos (linear_speed, max_angular_speed).

  21. Solución:

    • Reduce linear_speed a 0.1–0.2 m/s.
    • Limita max_angular_speed a 0.5 rad/s.
    • Aumenta goal_tolerance si es necesario.

  22. La ruta de waypoints no se completa (se queda en el waypoint 0)

  23. Causas:
    • La lista waypoints no está bien formateada o el umbral de cercanía es muy pequeño.
  24. Solución:
    • Revisa el parámetro waypoints: longitud par, en grados decimales.
    • Aumenta goal_tolerance a 3–4 m como prueba.

Mejoras y variantes

  • Uso de Nav2 completo:
    Integrar el nodo gps_waypoint_nav con Nav2, convirtiendo cada waypoint GPS a un objetivo en el frame map y dejando que Nav2 planifique la trayectoria detallada.
  • Planificación con obstáculos:
    Añadir un LiDAR (ej. RPLIDAR A1) y configurar slam_toolbox + costmaps de Nav2 para evitar obstáculos entre waypoints.
  • Fusión de barómetro (BMP280):
    Integrar lecturas de altitud (presión) en robot_localization para entornos con cambios de altura moderados.
  • Registro de datos:
    Usar ros2 bag record para guardar /fix, /imu/data, /odometry/filtered, /cmd_vel y analizar rutas recorridas.
  • Interfaz de configuración de waypoints:
    Implementar un servicio ROS 2 que permita cambiar dinámicamente la lista de waypoints sin reiniciar el nodo.
  • Modo “return-to-home”:
    Guardar la posición inicial y añadir un último waypoint que lleve al robot de vuelta a origen.

Checklist de verificación

Marca cada ítem cuando lo completes:

  • [ ] Ubuntu 22.04 64-bit instalado y accesible por SSH en la Raspberry Pi 4 Model B.
  • [ ] ROS 2 Humble instalado con ros-humble-desktop y paquetes adicionales (ros2-control, robot_localization, slam-toolbox, nav2*, rviz2).
  • [ ] Workspace ~/ros2_ws creado y compilado con colcon build.
  • [ ] Adafruit Ultimate GPS HAT (MTK3339) montado correctamente sobre la Raspberry Pi.
  • [ ] UART habilitado (enable_uart=1) y consola serie deshabilitada en /boot/firmware/cmdline.txt.
  • [ ] /dev/ttyAMA0 muestra datos NMEA y hay un nodo ROS 2 publicando en /fix (≥ 1 Hz).
  • [ ] Waveshare 10-DOF IMU Breakout (MPU9250 + BMP280) conectado por I2C (pines SDA/SCL correctos).
  • [ ] i2cdetect -y 1 detecta direcciones del MPU9250 y BMP280.
  • [ ] Nodo IMU operativo publicando /imu/data a ≥ 50 Hz.
  • [ ] URDF del robot cargado, diff_drive_controller operativo, publicando /odom.
  • [ ] robot_localization configurado con ekf.yaml y publicando /odometry/filtered.
  • [ ] Nodo gps_waypoint_nav se ejecuta sin errores y publica en /cmd_vel.
  • [ ] En prueba estática, /cmd_vel cambia según la posición del waypoint.
  • [ ] En prueba en campo, el robot recorre al menos 3 waypoints con error ≤ 3–5 m.
  • [ ] Has aplicado al menos una mejora (p. ej. ajuste de velocidades, tolerancias, o logging de datos).

Con todo esto, habrás completado con éxito el caso práctico de ros2-gps-waypoint-nav sobre el UGV Beast (ROS 2) – Raspberry Pi 4 Model B + Adafruit Ultimate GPS HAT (MTK3339) + Waveshare 10-DOF IMU Breakout (MPU9250 + BMP280), logrando un sistema funcional de navegación básica por waypoints GPS con ROS 2 Humble.

Encuentra este producto y/o libros sobre este tema en Amazon

Ir a Amazon

Como afiliado de Amazon, gano con las compras que cumplan los requisitos. Si compras a través de este enlace, ayudas a mantener este proyecto.

Quiz rápido

Pregunta 1: ¿Cuál es el objetivo principal del sistema que se va a construir?




Pregunta 2: ¿Qué hardware se utilizará para la navegación del UGV?




Pregunta 3: ¿Cuál es la precisión de llegada típica al waypoint según el artículo?




Pregunta 4: ¿Qué frecuencia de publicación se espera para los datos de odometría?




Pregunta 5: ¿Qué tipo de tareas se pueden realizar con este sistema?




Pregunta 6: ¿Qué se busca evitar en la transición entre waypoints?




Pregunta 7: ¿Cuál es la carga de CPU máxima permitida en la Raspberry Pi 4?




Pregunta 8: ¿Qué tipo de público está dirigido el sistema?




Pregunta 9: ¿Cuál es el propósito de usar RViz2 en el sistema?




Pregunta 10: ¿Qué tipo de rutas se pueden ejecutar en almacenes semiabiertos?




Carlos Núñez Zorrilla
Carlos Núñez Zorrilla
Electronics & Computer Engineer

Ingeniero Superior en Electrónica de Telecomunicaciones e Ingeniero en Informática (titulaciones oficiales en España).

Sígueme: