Bringing Legacy Devices Online: IR Control with ESPHome and Home Assistant

Bridging the Gap: IR Control with ESPHome and Home Assistant

In the age of smart homes, we often face a common challenge: what about all those perfectly functional devices that still rely on traditional infrared (IR) remote controls? TVs, air conditioners, fans, audio receivers – many are built without modern Wi-Fi or Bluetooth capabilities. Do you need to replace them? Not necessarily.

Home Assistant, combined with the flexibility of ESPHome, offers a powerful and cost-effective solution to bring these 'legacy' devices into your automated ecosystem. By building a simple, custom ESPHome device with an IR transmitter and receiver, you can capture the signals from your existing remotes and replay them via Home Assistant automations, scripts, or dashboards.

This guide will walk you through setting up an ESP32 or ESP8266 board with the necessary IR components, configuring ESPHome, integrating it with Home Assistant, and mastering the art of capturing and sending IR codes for reliable device control.

Why ESPHome for IR Control?

While commercial IR bridges exist (like Broadlink or Tuya devices), building your own with ESPHome offers significant advantages:

• Customization: You have full control over the hardware (choose the best IR components, add other sensors like temperature/humidity).
• Local Control: ESPHome devices integrate seamlessly with Home Assistant via its native API, ensuring low latency and local-only control without reliance on cloud services.
• Privacy: Your IR codes and control signals stay within your local network.
• Cost-Effective: ESP boards and IR components are relatively inexpensive.
• Flexibility: Easily integrate multiple IR transmitters/receivers, or combine IR control with other ESPHome projects on the same board.

Prerequisites

Before you begin, you'll need:

• An ESP32 or ESP8266 development board (e.g., NodeMCU, Wemos D1 Mini, ESP32-DevKitC).
• An IR receiver module (e.g., VS1838B, TSOP4838).
• An IR transmitter module (consisting of one or more IR LEDs and a transistor to drive them). You can often buy modules or build one easily with a suitable NPN transistor (like 2N2222) and a resistor (e.g., 100-ohm).
• Jumper wires and a breadboard (optional, for prototyping) or soldering equipment.
• A 5V power supply for the ESP board.
• Home Assistant instance with the ESPHome add-on installed (recommended) or the ESPHome command-line interface (CLI) set up on another machine.
• Basic understanding of Home Assistant and YAML configuration.

Hardware Setup

The exact pinouts depend on your specific ESP board and IR modules. Always check the datasheets for your components. Here’s a typical setup:

• IR Receiver: Connect its VCC to 3.3V or 5V on the ESP board (check module spec), GND to GND, and OUT to a digital GPIO pin on the ESP (e.g., D1 on ESP8266, GPIO16 on ESP32).
• IR Transmitter: Connect the anode of the IR LED(s) to VCC (preferably 5V if available and your transistor/resistor setup supports it for better range), the cathode to the collector of the NPN transistor. Connect the emitter of the transistor to GND. Connect a current-limiting resistor (100-200 ohms depending on LED specs and voltage) between a digital GPIO pin on the ESP (e.g., D2 on ESP8266, GPIO17 on ESP32) and the base of the transistor.

Ensure you choose GPIO pins that are suitable for output and input (avoiding pins used for boot modes etc.).

ESPHome Configuration

Using the ESPHome add-on in Home Assistant makes this easy. Create a new node for your device.

Add the following components to your YAML configuration:

esphome:
  name: ir_controller
  friendly_name: IR Controller

esp32:
  board: esp32dev # Or your specific board
  framework:
    type: esp-idf # Recommended for ESP32 IR

# For ESP8266, use:
# esp8266:
#   board: d1_mini
#   framework:
#     type: esp8266

wifi:
  ssid: "Your_SSID"
  password: "Your_Password"
  # Optional: static IP
  # static_ip:
  #   ipv4:
  #     address: 192.168.1.200
  #     gw: 192.168.1.1
  #     dns_servers:
  #       - 8.8.8.8

# Enable Home Assistant API
api:
  encryption:
    key: "YOUR_API_KEY"

oauth:

# Configure IR receiver
remote_receiver:
  pin:
    number: GPIO16 # Or the pin you connected OUT to
    # mode: INPUT_PULLUP # Often not needed for dedicated receiver modules
    # inverted: true # Adjust if needed
  dump:
    - nec
    - rc5
    # Add other protocols you want to try dumping, or 'all' for everything
    - all

# Configure IR transmitter
remote_transmitter:
  pin:
    number: GPIO17 # Or the pin connected to your transistor base resistor
    # inverted: true # Adjust if needed based on transistor logic

logger:

# Optional: Web server for easy access
web_server:
  port: 80

# Optional: OTA updates
o

Replace placeholders like Your_SSID, Your_Password, YOUR_API_KEY, and the GPIO pin numbers with your actual details. The dump section under remote_receiver tells ESPHome to print detected IR codes to the logs in specific formats (protocols like NEC, RC5) or as raw data ('all').

Build and Flash

Save your YAML file. Use the ESPHome add-on or CLI to build the firmware and flash it to your ESP board. Once connected to Wi-Fi, the device should appear in your Home Assistant Integrations dashboard (Settings > Devices & Services > Integrations) for easy addition.

Integrating with Home Assistant

After the ESPHome device is successfully added, Home Assistant will automatically create entities for the configured components. For IR, the primary interaction will be through services.

Capturing IR Codes

This is the crucial step to teach your smart home the commands from your old remotes. There are two main ways:

1. Via ESPHome Logs: Open the logs for your ESPHome device (ESPHome add-on or CLI). Point your physical remote at the IR receiver and press a button (e.g., TV Power On). Watch the ESPHome logs. You should see output like:
   

   [D][remote_receiver:160]: Received NEC (0x40) code: 0x10EF BITS=32
   [D][remote_receiver:160]: Received RC5 (0x0) code: 0x10EF BITS=12
   [D][remote_receiver:165]: Received Raw: 9000,-4500, 560,-560, 560,-560, ...

   Note down the protocol and code (e.g., NEC 0x10EF) or the raw data.
2. Via Home Assistant Service Calls: Home Assistant exposes a service called esphome.ir_controller_dump_codes (replace ir_controller with your device name). Go to Developer Tools > Services. Select this service. You can optionally specify protocols to dump. Call the service, then press a button on your physical remote while pointing it at the receiver. The detected codes will appear in your Home Assistant logs (Settings > System > Logs).

Repeat this process for every button you want to control (Power On, Power Off, Volume Up, Channel Down, Mute, etc.). Keep a list of the device, button, protocol, and code.

Sending IR Codes from Home Assistant

Now that you have the codes, you can send them using the remote.send service in Home Assistant. This service is automatically created when you add an ESPHome device with a remote_transmitter.

Go to Developer Tools > Services. Select the remote.send service. The target entity will be your ESPHome device (e.g., remote.ir_controller).

The service data payload depends on the code format you captured:

• For Protocol Codes (NEC, RC5, etc.):

  
  target:
    entity_id: remote.ir_controller
  data:
    protocol: nec
    num_bits: 32 # Use the BITS value from the log
    value: '0x10EF' # Use the code value from the log (needs quotes)
    # Or alternatively, using 'code':
    # code: '0x10EF'
    # type: 'nec' # Equivalent to protocol
    # bits: 32 # Equivalent to num_bits
  

• For Raw Codes: Raw codes are a list of timings (on/off durations). They are less reliable than protocol codes but necessary for devices using non-standard protocols.

  
  target:
    entity_id: remote.ir_controller
  data:
    type: raw
    code: [9000, -4500, 560, -560, ...]
  

You can test sending codes from this service page to ensure your hardware works and the codes are correct.

Putting it to Work: Automations and Scripts

The real power comes from using these IR codes in Home Assistant automations and scripts.

Example: Turn on the TV when the living room lights turn on after sunset.

automation:
  - alias: "Turn on TV with lights"
    trigger:
      - platform: state
        entity_id: light.living_room_lights
        to: "on"
    condition:
      - condition: sun
        after: sunset
    action:
      - service: remote.send
        target:
          entity_id: remote.ir_controller
        data:
          protocol: nec
          num_bits: 32
          value: '0x10EF' # Your TV Power On code
      - delay: 2 # Add a small delay if sending multiple commands
      - service: remote.send
        target:
          entity_id: remote.ir_controller
        data:
          protocol: nec
          num_bits: 32
          value: '0xXXXX' # Your TV HDMI 1 input code (if needed)

Example: Create a script to toggle the AC power.

script:
  ac_toggle_power:
    alias: AC Toggle Power
    sequence:
      - service: remote.send
        target:
          entity_id: remote.ir_controller
        data:
          protocol: sharp
          num_bits: 15
          value: '0x20BF'

You can then expose this script as a button on your dashboard.

Advanced Tips and Best Practices

• Verify Codes: Always test captured codes by sending them back to the device to ensure they work correctly. Some remotes send different codes for ON and OFF, while others toggle with the same code.
• Protocols: Try specific protocols (NEC, RC5, Sony, etc.) first as they are more robust than raw codes. If your device protocol isn't automatically detected or listed, try dumping 'all' and analyze the raw data. Sometimes minor variations require raw codes.
• Repeating Codes: Some protocols require sending the code multiple times quickly (a 'repeat' signal) if the button is held down. The `remote.send` service often handles this automatically for standard protocols, but you might need to experiment or send the command twice in quick succession for some devices.
• Combining Commands: For actions requiring multiple button presses (e.g., selecting an input), create a script that sends the codes sequentially with small delays (e.g., 50-200ms) between them.
• Placement: IR is line-of-sight. Place your ESPHome device where it has a clear view of the IR receiver on your target device. Consider building multiple smaller controllers for different rooms.
• Transmitter Power: The range and reliability of the IR transmitter depend on the LED(s), the driving circuit (transistor, resistor), and the voltage. Using a transistor allows you to draw more current than directly from an ESP GPIO pin, increasing range. Using 5V instead of 3.3V can also help, provided your circuit components are rated for it.
• Receiver Sensitivity: Ensure the receiver module is not saturated by direct sunlight or other strong IR sources.
• Power Reliability: Use a stable 5V power adapter for your ESP board.
• Complex Devices (ACs): Air conditioners often send a long, complex code with every button press that includes the current state (temperature, mode, fan speed). Capturing every combination is impractical. Look for existing Home Assistant custom components or ESPHome configurations specifically for common AC brands if protocol codes don't work easily. Some advanced users have reverse-engineered specific AC protocols.
• Feedback: IR is a send-and-forget protocol. The IR controller doesn't know if the command was received or if the device state changed. Combine IR control with state detection (e.g., a smart plug monitoring power draw for a TV, or an infrared presence sensor) to build more robust automations.

Conclusion

Integrating infrared-controlled devices into Home Assistant with ESPHome is a rewarding project that significantly expands the reach of your smart home automation. It allows you to control devices you thought were incompatible, automate sequences involving both modern and legacy equipment, and leverage the full power of Home Assistant's automation engine for a truly integrated living space. With a bit of hardware setup and careful code capturing, you can give your old remotes a smart, digital life.