1) What KY-022 is (and what it outputs)

The KY-022 module is built around a “1838” style IR receiver IC. That IC is tuned for IR remote controls: it filters the incoming light, looks specifically for a modulated carrier (commonly around 38kHz), and outputs a clean digital pulse stream when it detects valid bursts.

• Input: IR light bursts from a remote control (invisible to your eyes).
• Output: a digital signal (HIGH/LOW pulses) representing the remote’s data protocol.
• What you do: decode those pulses in firmware and trigger actions.

2) Key specs and practical expectations

• Receiver IC: 1838-style demodulating IR receiver (built into module)
• Output type: Digital (TTL-level style signal)
• Ambient light tolerance: listed to work under ~500 lux (bright indoor light)
• Typical carrier: ~38kHz (most common; some remotes differ)
• Uses: TV/stereo/set-top box remotes, IR toys, IR control for DIY devices

3) Pinout + wiring (Arduino / ESP32)

KY-022 modules usually present 3 pins:

• VCC: power (commonly 3.3V–5V; most modules are 5V-friendly)
• GND: ground
• OUT / S: digital output to your microcontroller input pin

3.1 Wiring to Arduino UNO/Nano

• VCC ? 5V
• GND ? GND
• OUT ? a digital pin (commonly D2 or D11; pick one and match your code)

3.2 Wiring to ESP32 / ESP8266 (3.3V logic)

• Power the module from 3.3V if your board provides it (good default)
• OUT ? any safe GPIO input pin
• GND shared with MCU

4) How IR remotes work: 38kHz carrier + protocols

Most IR remotes don’t just blink IR on/off. They “chop” the IR at a high frequency carrier (often ~38kHz), and then send data using bursts and gaps. Different brands use different protocols (NEC, Sony, RC5, etc.). The KY-022 removes the 38kHz carrier and outputs only the decoded envelope as digital pulses.

5) Quick test: see it detect signals

Many KY-022 boards have an onboard indicator LED that flickers when it receives IR bursts. This is a quick sanity check:

• Power the module
• Point a remote at it
• Press a button and watch for LED flicker

6) Decode remote buttons (IRremote) and get hex codes

The standard workflow is:

1. Run a “receiver dump” sketch
2. Press each button on your remote
3. Record the code for each button
4. Use those codes to trigger actions

6.1 Arduino example: print decoded values to Serial

This example uses the commonly used IRremote Arduino library. Install it via Arduino IDE: Tools ? Manage Libraries ? search “IRremote”.

/*
  KY-022 IR Receiver (#225) - Decode Remote Codes (Arduino)
  ---------------------------------------------------------
  Wiring:
    KY-022 VCC -> 5V
    KY-022 GND -> GND
    KY-022 OUT -> D2  (change below if needed)

  Library:
    Install "IRremote" via Library Manager.
*/

#include <IRremote.h>

const int PIN_IR = 2;

void setup() {
  Serial.begin(115200);
  IrReceiver.begin(PIN_IR, ENABLE_LED_FEEDBACK); // LED feedback if supported
  Serial.println("IR receiver ready. Press buttons on your remote...");
}

void loop() {
  if (IrReceiver.decode()) {
    // Print protocol + address + command (more stable than raw codes)
    Serial.print("Protocol: ");
    Serial.print(IrReceiver.decodedIRData.protocol);
    Serial.print("  Address: 0x");
    Serial.print(IrReceiver.decodedIRData.address, HEX);
    Serial.print("  Command: 0x");
    Serial.println(IrReceiver.decodedIRData.command, HEX);

    // If you need raw value:
    // Serial.print("Raw: 0x"); Serial.println(IrReceiver.decodedIRData.decodedRawData, HEX);

    IrReceiver.resume(); // Ready for next
  }
}
    

7) Example project: IR remote controls LED / relay / modes

Once you know your button codes, you can map them to actions. Below is a simple, robust pattern: toggle an LED, and switch between modes.

/*
  KY-022 IR Receiver (#225) - Simple Remote Control Example
  ---------------------------------------------------------
  Replace the CMD_* values with what you see in Serial Monitor from the decode sketch.
*/

#include <IRremote.h>

const int PIN_IR  = 2;
const int PIN_LED = 13;

bool ledOn = false;
int mode = 0;

// EXAMPLE placeholder commands (REPLACE THESE)
const uint8_t CMD_POWER = 0x45; // replace
const uint8_t CMD_UP    = 0x46; // replace
const uint8_t CMD_DOWN  = 0x15; // replace

void setLed(bool on) {
  digitalWrite(PIN_LED, on ? HIGH : LOW);
  ledOn = on;
}

void setup() {
  Serial.begin(115200);
  pinMode(PIN_LED, OUTPUT);
  setLed(false);

  IrReceiver.begin(PIN_IR, ENABLE_LED_FEEDBACK);
  Serial.println("Remote control ready.");
}

void loop() {
  if (!IrReceiver.decode()) return;

  auto &d = IrReceiver.decodedIRData;
  uint8_t cmd = d.command;

  Serial.print("Cmd: 0x"); Serial.println(cmd, HEX);

  if (cmd == CMD_POWER) {
    setLed(!ledOn);
  } else if (cmd == CMD_UP) {
    mode = (mode + 1) % 3;
    Serial.print("Mode -> "); Serial.println(mode);
  } else if (cmd == CMD_DOWN) {
    mode = (mode + 2) % 3; // backwards (mod 3)
    Serial.print("Mode -> "); Serial.println(mode);
  }

  // Example behavior per mode:
  if (mode == 0) {
    // normal
  } else if (mode == 1) {
    // do something else
  } else if (mode == 2) {
    // do another thing
  }

  IrReceiver.resume();
}
    

8) Improving range and reliability

8.1 Placement

• Face the receiver outward (don’t bury it behind opaque plastic).
• Avoid direct sunlight or direct high-intensity lamp light on the receiver.
• Mount away from heat sources (some enclosures get warm; temperature drift can affect stability).

8.2 Wiring and power

• Keep wiring short (especially OUT).
• Add a 0.1µF capacitor across VCC-GND near the module if you get false triggers.
• Use a stable supply and common ground.

8.3 Software handling of repeats

• Many remotes send a “repeat” signal when holding a button.
• Debounce in code: ignore repeats unless you want press-and-hold behavior.
• Prefer protocol/address/command fields over raw codes.

9) Common mistakes

• Mistake: Expecting distance measurement.
  Fix: It’s a remote-control receiver only (modulated IR).
• Mistake: Wrong pinout or missing ground.
  Fix: Verify VCC/GND/OUT and ensure common ground to MCU.
• Mistake: Placing it in sunlight or under harsh lighting.
  Fix: Shade it, move it, or use an enclosure window that doesn’t block IR.
• Mistake: Using raw codes only and getting inconsistent behavior.
  Fix: Use decoded command/address fields when possible.
• Mistake: Long unshielded wires acting like antennas.
  Fix: shorten wires, add decoupling, route away from switching loads.

10) Troubleshooting (random triggers, no decode, short range)

No output / nothing decodes

• Cause: wrong wiring or pin. Fix: confirm VCC/GND/OUT and match the code’s PIN_IR.
• Cause: remote uses unusual carrier/protocol. Fix: try a different remote first (TV remote is a good baseline).
• Cause: library mismatch. Fix: ensure you installed the correct IRremote library and used its current API.

Very short range

• Cause: bright ambient light. Fix: test in a darker room; avoid sunlight; reposition sensor.
• Cause: sensor not facing remote. Fix: rotate/angle the receiver toward expected direction.
• Cause: unstable supply / noise. Fix: add decoupling cap; clean wiring; move away from motors/relays.

Random triggers / noise

• Cause: EMI from switching loads (relays, motors, SSRs). Fix: separate wiring, add filtering, improve grounding.
• Cause: LED lighting flicker. Fix: move the sensor or add physical shielding / angle away from lights.
• Cause: floating input on MCU. Fix: ensure OUT is connected properly; use proper pin mode; avoid long input lines.

11) Quick checklist

KY-022 IR Receiver Module (#225) Checklist
------------------------------------------
 Wired correctly: VCC, GND, OUT (common ground to MCU)
 Positioned away from direct sunlight / harsh LED lighting
 IRremote installed and correct pin selected in code
 First run: decode sketch prints protocol/address/command
 Codes recorded and mapped to actions (prefer command/address over raw)
 If noisy: shorten wires + add 0.1µF decoupling near module + reroute away from motors/relays