IR Presence Detection Techniques

Presence detection is used when our only concern is whether an object is in a specified area or not. We don’t care how far away it is or if it is moving. There are two common methods for presence detection using IR light.

The first method is by reflection, in this configuration the IR emitter is located adjacent to the receiver. When something is in front of the sensor the light is reflected from the emitter onto the receiver, as depicted in Figure 1. Common examples of this include automatic hand dryers and soap dispensers used in public bathrooms. Schäfer (2024) is a handy application note from VISHAY which discusses these applications and how to design your own. While simple to construct, some tuning is required to control the detection distance.

The second method is to create an IR Barrier or break-beam sensor. Unlike the reflection sensor, the emitter and receiver are set up to face each other. As the name suggests we detect presence when the continuous beam between the emitter and receiver is broken. This is the opposite logic to the reflection setup, we’re interested in when there is no light. These are useful for applications like burglar alarms (Vishay 2024).

Neither of these methods is generally superior and you should always consider what is appropriate for your application. From preliminary testing with no-name IR LEDs and TSSP4038 I found that the reflection setup had too much range. In a small model railway setup, precise control over the detection area is important. As the title suggests I decided to use an IR barrier, but the code I use here can easily be adapted for reflection.

Choosing an IR Detector

When choosing your IR receiver it’s best to avoid sensors with automatic gain control (AGC). IR receivers with AGC (such as the TSOP series or the common VS1838B) are designed for remote control systems (like TV remotes) and filter out continuous beams. It is possible to use these sensors but it requires complex emitter-receiver code to time pulses (see Pons 2025). The TSSP series lack AGC and are designed for these applications.

I also recommend getting a receiver that requires a modulated signal. The TSSP4038 I’m using requires 38kHz modulation, meaning that the IR emitter must be turned on and off at 38,000 times per second. By requiring a modulated signal external sources of IR can be ignored (like the Sun) (Pons 2025).

The setup

As a simple project I made a simple IR barrier that would turn on an LED when blocked, this allowed me to experiment with different trains and lighting conditions.

The full code and schematic are in my Codeberg repository for the project, but I will go through it all here.

Of particular interest in Figure 2 are C1 and R1 which act as a low-pass noise filter on the receiver, without it I found the receiver output to be useless.

C2 was needed to smooth the power supply for the ATtiny85 and filter the electrical noise from the railway. Without it, I found that the ATtiny85 would be constantly switching off and on.

The code

In this setup the ATtiny85 has two tasks, it needs to control both the emitter and receiver ends of the barrier. In setups requiring longer range these tasks would be handled by separate circuits as running wires between each would be impractical.

#include <avr/io.h>

void init_timer0(void)
{
    TCCR0A |= (1 << WGM01) // Put Timer0 into CTC mode
        | (1 << COM0A0); // Toggle OC0A each cycle (blink the IR LED)
    TCCR0B |= (1 << CS00); // no prescaler
    OCR0A = 12; // Oscillate at approx 38.46kHz
}

int main(void)
{
    DDRB |= (1 << PIN_IR_LED);
    init_timer0();
    // ...

void update_indicator(void)
{
    // Sensor pin will be high when blocked
    if (PINB & (1 << PIN_SENSOR))
        PORTB |= (1 << PIN_INDICATOR);
    else
        PORTB &= ~(1 << PIN_INDICATOR);
}

void update_indicator(void)
{
    // Sensor pin will be low when train present
    if (PINB & (1 << PIN_SENSOR))
        PORTB &= ~(1 << PIN_INDICATOR);
    else
        PORTB |= (1 << PIN_INDICATOR);
}

#include <avr/interrupt.h>

ISR(INT0_vect)
{
    update_indicator();
}

void init_interrupt0(void)
{
    GIMSK |= (1 << INT0); // Enable INT0
    MCUCR |= (1 << ISC00); // Interrupt on any change
    sei();
}

int main(void)
{
    DDRB |= (1 << PIN_IR_LED) | (1 << PIN_INDICATOR);
    PORTB |= (1 << PIN_SENSOR); // Pullup the IR sensor
    init_interrupt0();
    init_timer0();

    // Since the interrupt will only fire on a change,
    // check the initial state of the barrier incase
    // it is already blocked
    update_indicator();

    while (1) {} // Loop forever
    return 0;
}

Results

With all of that set up here’s a photo of my simple IR barrier in action:

The IR barrier worked great at detecting solid objects (like the Mallard), however light could travel through carriages with windows. A possible solution is to move the sensor to be above and below the train. With some fine tuning I may change this to a reflective sensor either mounted under the track or on some overhead structure.

This is a part of an ongoing project to automate my railway.