Capturar comandos de mando IR en Raspberry Pi sin LIRC: enfoque Python UART

Integrar un mando IR con Raspberry Pi es sencillo cuando evitas LIRC y accedes directamente a la interfaz serie UART. La siguiente guía recorre todo el proceso —desde configuración hardware hasta decodificación Python— para capturar señales de mando con código mínimo.

Por qué saltarse LIRC

LIRC proporciona un marco genérico para dispositivos IR, pero puede ser excesivo para proyectos simples y a veces introduce latencia o problemas de compatibilidad. Usando los pines UART integrados (TX/RX) y un protocolo serie de baja velocidad, logras una solución ligera, determinista y más fácil de depurar.

Visión general del hardware

• Sensor IR: HX1838 (o cualquier receptor IR 5V) que emite datos serie.
• GPIO Raspberry Pi: Conecta la salida del sensor a GPIO 15 (RX). Une VCC del sensor a 5V y GND a pin de tierra.
• Configuración pines UART: Deshabilita la consola por defecto en ttyAMA0 para usar UART solo para entrada del sensor.

Paso 1 – Preparar Raspberry Pi para UART

1. Haz backup de la línea de comandos del kernel:

sudo cp /boot/cmdline.txt /boot/cmdline_bp.txt

2. Elimina parámetros ttyAMA0 (ej. console=ttyAMA0,115200 y kgdboc=ttyAMA0,115200) de /boot/cmdline.txt:

sudo nano /boot/cmdline.txt

La línea resultante debería parecerse a:

dwc_otg.lpm_enable=0 console=tty1 root=/dev/mmcblk0p6 rootfstype=ext4 elevator=deadline rootwait

3. Enmascara el prompt de login ttyAMA0 en /etc/inittab:

sudo nano /etc/inittab

Comenta:

#X:23:respawn:/sbin/getty -L ttyAMA0 115200 vt100

Paso 2 – Instalar pySerial

Instala la librería Python serial, que provee el módulo serial para comunicación UART:

sudo apt-get install python-serial

Tras la instalación, puedes importarla en tu script:

import serial

Paso 3 – Cablear el sensor IR

• Conecta el pin de salida del sensor a GPIO 15 (RX).
• Alimenta el sensor con 5 V y tierra.
• Como el sensor solo emite datos, TX (GPIO 14) no se usa en este proyecto.

Paso 4 – Script Python básico para leer bytes IR

El HX1838 transmite un flujo serie a 2400 bps. El siguiente fragmento lee 12–16 bytes por pulsación e imprime sus códigos ASCII.

import serial
ser = serial.Serial('/dev/ttyAMA0')
ser.baudrate = 2400
for _ in range(15):  # captura hasta 15 bytes
    byte = ser.read(1)
    print(ord(byte))

Pruebas mostraron que 2400 bps ofrece captura más fiable, probablemente porque velocidades menores reducen probabilidad de error de bit por aire.

Paso 5 – Decodificar teclas de mando Samsung

Usando un mando de TV Samsung, descubrimos que cada pulsación produce 12–16 bytes:

• Bytes 0-5: Cabecera – constante en todas las teclas.
• Bytes 6-11: Carga útil – identifica únicamente el botón pulsado.
• Byte 12: Cola (específico de este mando).

Para mapear una tecla, calculamos una suma ponderada simple de bytes 6-11:

keyidentity = (byte[6] + 2*byte[7] + 3*byte[8] + 4*byte[9] + 5*byte[10] + 6*byte[11])

Aunque no es el método más robusto, produce un valor único por botón, facilitando comparación. Siéntete libre de reemplazarlo por hash o XOR si necesitas resistencia a colisiones más estricta.

Ejemplo completo: ir_serial3samsung.py

Abajo hay un script optimizado que:

• Captura 24 bytes (dos tramas completas) para vaciar buffer serie.
• Usa solo los primeros 12 bytes para decodificar la tecla.
• Imprime el keyidentity calculado para referencia rápida.

import serial
ser = serial.Serial('/dev/ttyAMA0', 2400)
while True:
    # Leer 24 bytes para limpiar buffer
    raw = ser.read(24)
    # Primeros 12 bytes corresponden a una pulsación
    key_bytes = raw[:12]
    key_id = sum((i+1)*b for i, b in enumerate(key_bytes[6:12]))
    print(f'Key ID: {key_id}')

Ejecuta el script y pulsa botones en el mando Samsung. Cada pulsación imprime un Key ID único. Guarda estos IDs en una tabla de búsqueda para mapear a acciones en tu aplicación.

Conclusión

Usar UART y un script Python simple para capturar señales IR elimina la necesidad de LIRC, reduce latencia y ofrece control total sobre la lógica de decodificación. Al ser el código mínimo y transparente, la depuración es directa. Puedes adaptar este patrón para cualquier mando IR que emita datos serie, convirtiéndolo en solución versátil para proyectos Raspberry Pi.

Para instrucciones más profundas, ver post original: How to Use and Emulate…