Automatic Door Opener using PIR Sensor with Servo Motor and Arduino

An automatic door opener removes the most-touched surface from the daily routine: the door handle. The Automatic Door Opener using PIR Sensor with Servo Motor and Arduino builds that behaviour at model scale: a passive infrared sensor watches the approach zone, an Arduino Uno interprets the signal, and a servo motor swings a model door open, then returns it after an adjustable delay. In hospitals, laboratories, offices and homes, a door that opens as a person approaches and closes itself behind them reduces contact and keeps conditioned air inside. The sensor works on first principles: its pyroelectric element sits behind a Fresnel lens divided into zones, and a moving warm body crossing zones changes the infrared pattern, which the module turns into a clean digital HIGH. That single mechanism — motion across zones, not proximity alone — is why the door opens for a person walking up and stays shut for a still room.

The chain from approaching person to swinging door has five links, and each one is visible on the prototype. The HC-SR501 PIR sensor watches the doorway through its Fresnel lens; when a warm body moves across its detection zones, the module's pyroelectric element produces a signal that its BISS0001 processor turns into a digital HIGH on the output pin. The Arduino Uno reads that pin and, on a rising edge, starts the open sequence: it writes a stepped series of PWM angles to the SG90 servo, which rotates its horn and pulls the linkage rod that swings the hinged model door open. While the door stands open, the firmware watches the sensor; every fresh detection restarts the auto-close countdown, so the door stays open as long as someone is in the approach zone. When the countdown expires with no further motion, the servo eases the door back to its closed angle and the system returns to watching the doorway.

1. On power-up, the HC-SR501 warms up for 30–60 s (datasheet) while the Arduino holds the servo at the closed angle and the status LED shows the system is not yet ready.
2. The PIR sensor watches the approach zone through its Fresnel lens; a person walking toward the door crosses detection zones and the module output goes HIGH (3.3 V).
3. The Arduino Uno reads the sensor output on a digital pin and, on a rising edge, starts the open sequence and lights the status LED.
4. The firmware steps the SG90 servo angle gradually from closed to open, and the servo horn pulls the linkage rod to swing the hinged model door to approximately 90 degrees (design target).
5. While the door is open, every fresh sensor detection restarts the auto-close countdown, so the door stays open as long as someone is in the approach zone.
6. When the countdown expires with no further motion, the firmware steps the servo back and the door eases to its closed angle.
7. The system returns to idle, watching the doorway for the next approach, with each event recorded on the serial monitor.

Tech stack:

• Arduino Uno R3 · ATmega328P
• HC-SR501 PIR motion sensor
• SG90 micro servo motor
• Arduino IDE · C/C++ firmware
• Breadboard · jumper wiring
• 5 V DC power supply
• Plywood model door · hinges
• Servo linkage · hardware

Three capabilities carry this build: reliable approach detection, a smooth servo-driven door swing, and a dependable auto-close that never leaves the door standing open. The HC-SR501 PIR sensor watches a cone of up to 120 degrees in front of the doorway, with its sensitivity and hold-time trimmers set for the approach distance the student actually needs, so the door opens for a person walking up and not for movement far down a corridor. The SG90 servo converts the Arduino's PWM command into a controlled swing through a metal linkage rod, and the firmware eases the horn between its closed and open angles instead of snapping the door, which protects the hinges and the servo gears. Finally, the auto-close timer counts down from the last detected motion and returns the door only when the approach zone is clear, so nobody is caught by a closing door. A status LED and serial log make every state visible during a demonstration.

• [PIR approach detection] The HC-SR501 watches the doorway through its Fresnel lens and raises a digital HIGH when a moving warm body crosses its detection zones, so the door responds to a person approaching and ignores a still room.
• [Servo-driven door swing] The SG90 servo pulls a metal linkage rod attached to the hinged model door, converting a PWM angle command into a real mechanical swing of approximately 90 degrees (design target).
• [Adjustable auto-close timer] The firmware counts down from the last detected motion and closes the door only when the approach zone is clear, with the delay set by the sensor's hold-time trimmer (3–300 s, datasheet).
• [Repeatable trigger mode] The sensor jumper is set to repeatable (H) mode, so continuous movement in the approach zone keeps refreshing the open state instead of letting the door close mid-entry.
• [Smooth eased motion] The servo angle is stepped gradually between closed and open positions, so the door swings smoothly instead of jerking, which protects the hinges and the servo gears.
• [Status LED and serial diagnostics] An onboard LED shows the door state at a glance, and the serial monitor logs each detection, open and close event for demonstration and debugging.
• [Tunable sensitivity and range] The sensor's sensitivity trimmer sets the detection distance between 3 m and 7 m (datasheet), so the approach zone can be matched to a corridor, a room entrance or a lab bench.

• Working model-door prototype: plywood door and frame, hinges, SG90 servo with linkage rod, HC-SR501 sensor and Arduino Uno, wired on a breadboard
• Complete Arduino firmware (commented): sensor read, eased servo motion, auto-close timer, LED and serial diagnostics
• Circuit diagram and wiring table for every connection
• Component list with the exact sensor, servo and board models used
• Project report PDF (background, PIR and servo theory, methodology, testing, limitations)
• PPT presentation for final review
• Viva Q&A preparation document (PIR sensing, PWM servo control, timing and linkage geometry)

Requirements

• The buyer provides a bench or table space of approximately 60 × 40 cm, a laptop with the Arduino IDE installed, a USB cable for the Arduino Uno, and a 5 V DC power outlet or USB power source for the prototype.
• No prior electronics experience is assumed: the build ships assembled and wired, with the firmware already uploaded, so the first demonstration runs from the supplied power source.
• The demonstration needs a clear approach path of approximately 2–3 m in front of the sensor, free of direct sunlight on the sensor dome and of strong draughts across the detection zone.

Timeline

• Typical build schedule is approximately 7–10 working days from order confirmation: component sourcing and frame assembly in the first 2–3 days, wiring and firmware in the next 2–3 days, then sensor tuning, linkage calibration and demonstration testing in the final 2–4 days.
• Sensor tuning and linkage calibration take the longest, because the sensitivity trimmer and the anchor point are set against the actual demonstration space rather than a nominal value.
• The report, PPT and Q&A document are prepared alongside the build and delivered with the finished prototype.

Support

• WhatsApp support during the build and the review period covers setup, the first demonstration, and answers to questions about the circuit, the firmware and the report.
• If the sensor needs re-tuning for the demonstration room, the sensitivity and hold-time adjustment procedure is explained step by step with the expected behaviour at each setting.
• Demonstration guidance is included: approach distance, sensor aiming, and the order of events to show so the door opens, holds and closes on cue.