Arduino Move Sensor: PIR vs MPU6050 Motion Detection Build & Debug Guide

The term "arduino move sensor" is a catch-all that usually points to two completely different physical phenomena. Are you trying to detect a human walking into a room, or are you trying to detect if your project enclosure was bumped, tilted, or dropped? Confusing these two leads to wasted money and failed builds. Passive Infrared (PIR) sensors detect biological heat signatures moving across a field of view, while Inertial Measurement Units (IMUs) like the MPU6050 detect physical acceleration and gyroscopic displacement of the board itself.

This guide gives you the exact decision framework to pick the right module, the precise wiring for a dual-sensor bench test, and the debugging steps to fix the inevitable I2C bus lockups.

The Decision Tree: Which Arduino Move Sensor Do You Actually Need?

Before buying parts, map your physical requirement to the sensor technology. Here is the decision matrix to terminate your component search.

Criteria	HC-SR501 (PIR)	GY-521 (MPU6050 IMU)
Detects human/animal presence?	Yes (up to 7m range)	No (only detects physical board movement)
Detects device tilt/vibration?	No	Yes (6-axis accel/gyro)
Interface	Digital GPIO (HIGH/LOW)	I2C (SDA/SCL)
Quiescent Power Draw	~65 µA (standby)	~3.9 mA (active)
Blind Spot / Weakness	Fails if human moves very slowly or behind glass	Suffers from gyro drift over time without filtering

Hardware Spec Sheet & Exact Parts List

For this build, we are wiring both sensors to a single board so you can benchmark them side-by-side on your bench. Pricing reflects 2026 market averages for genuine or high-quality clone components.

Component	Exact Variant / Model	Est. Price	Bench Notes
Microcontroller	Arduino Uno R3 (ATmega328P)	$27.00	Use the classic R3. The newer R4 Minima has different I2C pull-up behaviors that can complicate beginner MPU6050 wiring.
PIR Sensor	HC-SR501	$2.50	Ensure it has the jumper block on the bottom (set to 'H' for repeatable trigger).
IMU Sensor	GY-521 Breakout (MPU-6050)	$4.00	Must be the GY-521 variant which includes the onboard 3.3V LDO and I2C pull-ups.
Wiring	22 AWG Solid Core Jumper Kit	$7.00	Do not use cheap 28 AWG ribbon cables for I2C; they cause capacitance issues on the SDA line.

Pin Mapping & Wiring Steps

The HC-SR501 requires a solid 5V supply to operate its internal voltage regulator reliably. The GY-521 can accept 5V on its VCC pin because the breakout board features an onboard LDO that steps it down to 3.3V for the MPU6050 silicon.

Arduino Uno R3 Pin	HC-SR501 (PIR)	GY-521 (MPU6050)
5V	VCC	VCC
GND	GND	GND
Digital Pin 3	OUT	-
Analog A4 (SDA)	-	SDA
Analog A5 (SCL)	-	SCL

Numbered Wiring Procedure

1. Power Rails: Connect the Arduino 5V and GND pins to your breadboard's positive and negative rails. Verify with a multimeter that you read 4.9V to 5.1V across the rails.
2. Wire the PIR: Connect the HC-SR501 VCC, GND, and OUT pins. Bench tip: The silkscreen on cheap HC-SR501 modules is sometimes reversed. Verify the pinout by tracing the ground pin to the metal can of the sensor; GND is almost always the pin closest to the metal shield.
3. Wire the IMU: Connect the GY-521 VCC and GND. Then route SDA to A4 and SCL to A5. Keep the SDA/SCL wires under 6 inches (15 cm) to avoid bus capacitance errors.
4. Tune the PIR Pots: Using a small Phillips screwdriver, turn the "Time Delay" potentiometer on the HC-SR501 fully counter-clockwise (minimum ~3 seconds) and the "Sensitivity" pot to the 12 o'clock position for bench testing.

The Code: Target Board, Pin Definitions, and Error Handling

Target Board Variant: This code is explicitly written and tested for the Arduino Uno R3 (ATmega328P). It uses the hardware I2C pins (A4/A5). If you are porting this to an ESP32 DevKit V1, you must change the I2C initialization to explicitly define the SDA/SCL pins, as ESP32 default I2C pins differ.

You will need to install the Adafruit MPU6050 and Adafruit Unified Sensor libraries via the Arduino Library Manager before compiling.

/*
 * Dual Arduino Move Sensor Sketch
 * Target: Arduino Uno R3 (ATmega328P)
 * Reads HC-SR501 (PIR) and GY-521 (MPU6050) simultaneously.
 */

#include <Wire.h>
#include <Adafruit_MPU6050.h>
#include <Adafruit_Sensor.h>

// --- PIN DEFINITIONS ---
#define PIR_PIN 3       // Digital pin for HC-SR501 OUT
#define LED_PIN 13      // Onboard Uno LED for visual feedback

// --- OBJECTS ---
Adafruit_MPU6050 mpu;

// --- STATE VARIABLES ---
unsigned long lastMotionTime = 0;
const unsigned long cooldownMs = 2000; // Prevent serial flood

void setup() {
  Serial.begin(115200);
  while (!Serial) { delay(10); } // Wait for serial monitor (Leonardo/Micro, harmless on Uno)
  
  pinMode(PIR_PIN, INPUT);
  pinMode(LED_PIN, OUTPUT);
  
  Serial.println(F("Initializing Arduino Move Sensor Array..."));

  // --- I2C INITIALIZATION & ERROR HANDLING ---
  Wire.begin();
  Wire.setClock(400000); // Fast I2C mode (400kHz)
  
  if (!mpu.begin()) {
    Serial.println(F("Failed to find MPU6050 chip"));
    // Blink LED rapidly to indicate hardware fault without needing serial monitor
    while (1) {
      digitalWrite(LED_PIN, HIGH); delay(100);
      digitalWrite(LED_PIN, LOW);  delay(100);
    }
  }
  
  Serial.println(F("MPU6050 Found! Configuring filters..."));
  mpu.setAccelerometerRange(MPU6050_RANGE_8_G);
  mpu.setGyroRange(MPU6050_RANGE_500_DEG);
  mpu.setFilterBandwidth(MPU6050_BAND_21_HZ);
  
  Serial.println(F("System Ready. Waiting for motion..."));
  delay(100); // Let sensor stabilize
}

void loop() {
  unsigned long currentMillis = millis();

  // 1. Read PIR Sensor (Biological Motion)
  int pirState = digitalRead(PIR_PIN);
  if (pirState == HIGH && (currentMillis - lastMotionTime > cooldownMs)) {
    Serial.println(F("[PIR] BIOLOGICAL MOTION DETECTED"));
    digitalWrite(LED_PIN, HIGH);
    lastMotionTime = currentMillis;
  } else if (pirState == LOW && digitalRead(LED_PIN) == HIGH) {
    digitalWrite(LED_PIN, LOW);
  }

  // 2. Read MPU6050 (Physical Displacement / Tilt)
  // We only poll the IMU every 50ms to save bus bandwidth
  static unsigned long lastImuRead = 0;
  if (currentMillis - lastImuRead >= 50) {
    lastImuRead = currentMillis;
    
    sensors_event_t a, g, temp;
    mpu.getEvent(&a, &g, &temp);
    
    // Calculate simple magnitude of acceleration to detect a "bump"
    float accelMagnitude = sqrt(sq(a.acceleration.x) + sq(a.acceleration.y) + sq(a.acceleration.z));
    
    // Gravity is ~9.8 m/s^2. A bump will spike this significantly.
    if (accelMagnitude > 15.0) {
      Serial.print(F("[IMU] PHYSICAL BUMP DETECTED! Magnitude: "));
      Serial.println(accelMagnitude, 2);
    }
  }
}

Debugging: "Failed to find MPU6050 chip" and Other Failures

When working with I2C sensors on the bench, you will eventually hit a wall. If your serial monitor outputs the exact string Failed to find MPU6050 chip, the Adafruit library's mpu.begin() function has failed to read the WHO_AM_I register (expected value 0x68) at the default I2C address (0x68).

The First Three Things to Check

1. Run the I2C Scanner: Upload the standard Arduino I2CScanner example sketch. If the serial monitor does not return I2C device found at address 0x68, your microcontroller cannot physically see the chip. The issue is wiring, not code.
2. Verify Power at the Breakout: Do not just assume the breadboard rail is live. Put your digital multimeter (DMM) in DC voltage mode. Put the black probe on the GY-521 GND pin and the red probe on the VCC pin. You must read >4.5V. If you read 0V or 1.2V, you have a broken jumper wire or a blown breadboard rail clip.
3. Check SDA/SCL Swap: On the Uno R3, SDA is A4 and SCL is A5. It is incredibly common to swap these when wiring blindly. Swap the wires and reset the board.

Ranked Causes for Persistent I2C Failures

What about the PIR sensor? If the HC-SR501 OUT pin is stuck HIGH, you are likely experiencing thermal stabilization. The HC-SR501 requires 30 to 60 seconds of "blind time" upon first power-up to calibrate its internal baseline temperature. Cover the dome with your hand and wait 60 seconds before testing.

Extending and Simplifying the Build

Once you have the baseline sketch running, you should tailor the architecture to your final deployment environment.

How to Simplify (For Low-Power or Basic Alarms)

• Drop the IMU: If you only care about room presence, remove the MPU6050 entirely. This frees up the I2C bus and eliminates the 3.9mA quiescent draw.
• Use Hardware Interrupts: Instead of polling digitalRead(PIR_PIN) in the main loop, wire the PIR OUT pin to Arduino Pin 2 (INT0). Use attachInterrupt(digitalPinToInterrupt(2), motionISR, RISING). This allows the ATmega328P to sleep via LowPower.h and only wake when a human actually walks by, dropping system draw to microamps.

How to Extend (For Smart Home / IoT Integration)

• Upgrade to ESP32: The Uno R3 lacks native networking. Swap the microcontroller for an ESP32 DevKit V1. The code logic remains 90% identical, but you can use the PubSubClient library to publish motion events to an MQTT broker (like Mosquitto or Home Assistant).
• Implement Sensor Fusion: The raw MPU6050 data is noisy. To get accurate tilt angles for a robotics or gimbal project, integrate the MadgwickAHRS or KalmanFilter libraries to fuse the accelerometer and gyroscope data, eliminating gyro drift over long runtimes.

By understanding the physical difference between biological presence (PIR) and mechanical displacement (IMU), you can stop guessing and start building reliable motion-triggered systems. Verify your I2C wiring with a DMM before blaming the code, and always let your PIR sensor thermally stabilize before bench testing.