How to build a very cheap but full featured Sound Card Oscilloscope Build Better Electronics Projects By: Steve Garratt

Arduino Motion Detector Software Sketch

<< Arduino Power Dissipated By Resistor: How To Blow Up A Circuit

Arduino Tachometer

<< Previous First 2 3 4 Last

Arduino Motion Detector Software Sketch

Click to get the full project details by subscribing free to HDE Magazine.

This is a modification to the software sketch for the Arduino Distance Sensor Project.

Copy the code sketch below, paste it into your Arduino programming software and load it into your Arduino to run the distance sensor project.

If you haven't done already you may also also need to download the timerOne library from https://code.google.com/p/arduino-timerone/downloads/detail?name=TimerOne-v9.zip&can=2&q=

Install the library using the guide https://arduino.cc/en/Guide/Libraries

/*******************************************************
 
arduino_distance_sensor_3
Arduino Uno + 2 x 16 LCD display + HC-SR04

Displays echos from an HC-SR04 ultrasonic distance finder
on the LCD.

Motion detection added 9/2/14

9th Feb 2014
********************************************************/
#include <LiquidCrystal.h>                            // LCD module
#include <TimerOne.h>                                 // Header file for TimerOne library
 
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);                  // select the pins used on the LCD panel
 
// define some values used by the panel and buttons
#define trigPin 12                                    // Pin 12 trigger output
#define echoPin 2                                     // Pin 2 Echo input
#define echo_int 0                                    // Interrupt id for echo pulse
#define motionLEDPin 13                               // Pin 13 motion detector indicator output
                                                      // Define constants for button presses
#define btnRIGHT  0                                   // Right
#define btnUP     1                                   // Up
#define btnDOWN   2                                   // Down
#define btnLEFT   3                                   // Left
#define btnSELECT 4                                   // Select
#define btnNONE   5                                   // None. No button pressed

#define TIMER_US 50                                   // 50 uS timer duration 
volatile int tick_counts = 4000;                      // define 200mS between trigger pulses
volatile int trigger_time_count = 0;                  // Count down counter to trigger pulse time
int display_mode = 0;                                 // Determine what the display does

volatile long echo_start = 0;                         // Records start of echo pulse 
volatile long echo_end = 0;                           // Records end of echo pulse
volatile long echo_duration = 0;                      // Duration - difference between end and start

#define RANGES 16                                     // Number of ranges
#define MAX_ZONE 18000                                // The last (maximum) zone range in uS
int zones[RANGES];                                    // Array to contain the zone values for each range
volatile int range_hits[RANGES];                      // Array of recent zone hit counts

volatile int range_cm;                                // The distance detected in centimeters

#define MOTION_BASE_SIZE      24                      // Length of the motion base samples array
#define MOTION_CURRENT_SIZE   6                       // Length of the motion current value array
volatile int motion_base_array[MOTION_BASE_SIZE];     // Motion base array
volatile int motion_current_array[MOTION_CURRENT_SIZE];// Motion current value array
volatile int motion_base;                             // Long term motion base value
volatile int motion_current;                          // Current motion distance value
volatile bool motion_detected = false;                // True when motion output triggering

// Define the special characters that will form vertical bar graph lcd charcters
byte bar0[8] = {B00000, B00000, B00000, B00000, B00000, B00000, B00000, B11111};
byte bar1[8] = {B00000, B00000, B00000, B00000, B00000, B00000, B11111, B11111};
byte bar2[8] = {B00000, B00000, B00000, B00000, B00000, B11111, B11111, B11111};
byte bar3[8] = {B00000, B00000, B00000, B00000, B11111, B11111, B11111, B11111};
byte bar4[8] = {B00000, B00000, B00000, B11111, B11111, B11111, B11111, B11111};
byte bar5[8] = {B00000, B00000, B11111, B11111, B11111, B11111, B11111, B11111};
byte bar6[8] = {B00000, B11111, B11111, B11111, B11111, B11111, B11111, B11111};
byte bar7[8] = {B11111, B11111, B11111, B11111, B11111, B11111, B11111, B11111};

// Define the special characters that will form horizontal bargraph lcd charcters
byte sbar0[8] = {B00000, B00000, B00000, B00000, B00000, B00000, B00000, B00000};
byte sbar1[8] = {B10000, B10000, B10000, B10000, B10000, B10000, B10000, B10000};
byte sbar2[8] = {B11000, B11000, B11000, B11000, B11000, B11000, B11000, B11000};
byte sbar3[8] = {B11100, B11100, B11100, B11100, B11100, B11100, B11100, B11100};
byte sbar4[8] = {B11110, B11110, B11110, B11110, B11110, B11110, B11110, B11110};
byte sbar5[8] = {B11111, B11111, B11111, B11111, B11111, B11111, B11111, B11111};

// --------------------------
// setup() 
// Initialize i/o pins.
// Initialize the timer and attach interrupt.
// Attach interrupt to echo input.
// Initialize the LCD.
// Initialize the serial monitor.
// Create the range_hits[] array.
// Start initial display mode.
// --------------------------
void setup()
{
  int i, zone_diff;
  
  pinMode(trigPin, OUTPUT);                           // Trigger pin set to output
  pinMode(echoPin, INPUT);                            // Echo pin set to input
  pinMode(motionLEDPin, OUTPUT);                      // Motion detector indicator pin set to output
  
  Timer1.initialize(TIMER_US);                        // Initialise timer 1
  Timer1.attachInterrupt(timerIsr);                   // Attach interrupt to the timer service routine 
  attachInterrupt(echo_int, echo_interrupt, CHANGE);  // Attach interrupt to the sensor echo input

lcd.begin(16, 2);                                   // start the LCD library
  Serial.begin (9600);                                // Initialise the serial monitor output
  
  zone_diff = (MAX_ZONE / RANGES);                    // Size of a distance zone
  for (i = 0; i < RANGES ; i++)                       
  {
     range_hits[i] = 0;                               // initialise the hits array
     zones[i] = zone_diff * (i + 1);                  // Create an array of distance zones
  }

setup_display_cm_mode();                            // Initialise display mode
}

// --------------------------
// loop() 
// Main loop. 
// Keypad buttons are serviced every 50mS.
// Display is updated every 500mS.
// --------------------------
void loop()
{
  static unsigned long print_timer = 0;               // For scheduling LCD updates
  static unsigned long button_timer = 0;              // For scheduling button polling
  int lcd_key     = 0;
  int i;

if ((millis() - button_timer) > 50)                 // Is it time to check the buttons?
  {
    button_timer = millis();                          // Reset the timer
    do_button_input();                                // Handle user input on buttons
  }
  
  if ((millis() - print_timer) > 500)                 // Is it time to update the display?
  {
    print_timer = millis();                           // Reset the timer

switch(display_mode)                              // Call one of the display routines
    {                                                 // depending on the mode.
      case 0:
        display_bar_distance_cm();                    // Histogram + distance in cm
        break;
      case 1:
        display_histogram();                         // Histogram + scale
        break;
      case 2:
        display_line_distance_cm();                  // Line + distance in cm
        break;
      case 3:
        display_motion_detector();                   // Histogram + motion detection
        break;
    }
  }
}

// --------------------------
// clear_display() Clear the display.
// --------------------------
void clear_display()
{
  char* blank = "                ";
  lcd.setCursor(0, 0);                                // Clear the bottom row;
  lcd.print(blank);                      
  lcd.setCursor(0, 1);                                // Clear the bottom row;
  lcd.print(blank);                      
}

// --------------------------
// create_bargraph_characters() Create the LCD bargraph characters.
// --------------------------
void create_bargraph_characters()
{
  lcd.createChar(0, bar0);                            // Create 8 LCD characters to use
  lcd.createChar(1, bar1);                            // as character sized bargraphs
  lcd.createChar(2, bar2);
  lcd.createChar(3, bar3);
  lcd.createChar(4, bar4);
  lcd.createChar(5, bar5);
  lcd.createChar(6, bar6);
  lcd.createChar(7, bar7);
}

// --------------------------
// create_side_bargraph_characters() Create sideways LCD bargraph characters.
// --------------------------
void create_side_bargraph_characters()
{
  lcd.createChar(0, sbar0);                           // Create 6 LCD characters to use
  lcd.createChar(1, sbar1);                           // as character sized bargraphs
  lcd.createChar(2, sbar2);
  lcd.createChar(3, sbar3);
  lcd.createChar(4, sbar4);
  lcd.createChar(5, sbar5);
}

// --------------------------
// setup_histogram_mode() Initialise for histogram mode.
// --------------------------
void setup_histogram_mode()
{
  create_bargraph_characters();                       // Create LCD mini bargraphs
  lcd.setCursor(0, 1);                                // Print the scale on the bottom
  lcd.print(0);                                       // row of the LCD.
  lcd.setCursor(6, 1);
  lcd.print(150);
  lcd.setCursor(13, 1);
  lcd.print(300);
}

// --------------------------
// setup_display_cm_mode() Initialise for centimeter distance mode.
// --------------------------
void setup_display_cm_mode()
{
  create_bargraph_characters();                        // Create LCD mini bargraphs
}

// --------------------------
// setup_line_cm_mode() Initialise for centimeter line distance mode.
// --------------------------
void setup_line_cm_mode()
{
  create_side_bargraph_characters();                    // Create LCD vertical line graph characters
}

// --------------------------
// setup_motion_detect_mode() 
// Initialise for displaying motion detector values;
// --------------------------
void setup_motion_detect_mode()
{
  create_bargraph_characters();                        // Create LCD mini bargraphs
}

// --------------------------
// display_histogram() Display the echo data in the range_hits[] array
// as a series of 16 bargraphs.
// --------------------------
void display_histogram()
{
  int i;

for (i = 0; i < RANGES; i++)                        // Print each zone as a character bar code
   {
     lcd.setCursor(i, 0);                              // Set the cursor at the start of the top line
 
     switch (range_hits[i])                            // The number of hits in each zone or range
     {                                                 // determines the height of the bargraph
        case 1:                                        // The range values are 0 - 10
          lcd.write(byte(1));                          // The characters have 7 rows
          break;
        case 2:
          lcd.write(byte(2));
          break;
        case 3:
          lcd.write(byte(3));
          break;
        case 4:
          lcd.write(byte(4));
          break;
        case 5:
          lcd.write(byte(5));
          break;
        case 6:
          lcd.write(byte(6));
          break;
        case 7:
          lcd.write(byte(6));
          break;
        case 8:
          lcd.write(byte(7));
          break;
        case 9:
          lcd.write(byte(7));
          break;
        case 10:
          lcd.write(byte(7));
          break;
        default:
          lcd.write(byte(0));
          break;
     }
   }   
}

// --------------------------
// display_distance_cm() 
// Display the echo distance in centimetres.
// --------------------------
void display_distance_cm()
{
  int range = range_cm;                           // Save range in case it changes
  
  if (range > 999) range = 999;                   // Limit the value to 3 digits
  
  lcd.setCursor(0, 1);                            // Set the cursor at the start of the bottom line
  lcd.print("Distance: ");                        // Print the label
  lcd.print(range);                               // The range in centimeters
  lcd.print("cm");                                // Now the units
  
  if (range < 10)                                 // Print an appropriate number of
  {                                               // spaces to clear to end of line.
    lcd.print("   ");                             // The number of spaces varies with the
  }                                               // length of the printed number value.
  else
  {
    if (range < 100) 
    {
      lcd.print("  ");
    }
    else
    {
      lcd.print(" ");
    }
  }
}

// --------------------------
// display_motion_vars() 
// Display the motion detection variables.
// --------------------------
void display_motion_vars()
{
  int base = motion_base;                         // Save base value in case it changes
  int current = motion_current;                   // Save current value in case it changes
  int diff;                                       // Difference between base and current
  
  if (base > 999) base = 999;                     // Limit the value to 3 digits
  
  lcd.setCursor(0, 1);                            // Set the cursor at the start of the bottom line
  display_3_digits(base);

if (current > 999) current = 999;               // Limit the value to 3 digits
  lcd.print(" ");
  display_3_digits(current);

diff = base - current;
  lcd.print(" ");
  display_3_digits(diff);
}

// --------------------------
// display_3_digits(val) 
// Print 3 digits to the display.
// Printed right justified with -ve in front.
// --------------------------
void display_3_digits(int val)
{
  int abs_val = abs(val);                         // Get absolute value
  bool neg = false;                               // True if negative                                   
  
  if (val < 0) neg = true;                        // Get +/- indicator
  
  if (abs_val < 10)                               // Print an appropriate number of
  {                                               // spaces to clear to end of line.
    lcd.print("  ");                             // The number of spaces varies with the
  }                                               // length of the printed number value.
  else
  {
    if (abs_val < 100) 
    {
      lcd.print(" ");
    }
  }
  
  if (neg)                                        // Print -ve symbol if needed
  {
    lcd.print("-");
  }
  else
  {
    lcd.print(" ");
  }
  
  lcd.print(abs_val);                            // Print the value
}

// --------------------------
// display_bar_distance_cm() 
// Display the echo distance data and the histogram
// --------------------------
void display_bar_distance_cm()
{
  display_histogram();                           // Display the histogram on the top line
  display_distance_cm();                         // Display distance value on the bottom line
}

// --------------------------
// display_motion_detector() 
// Display motion detection values
// --------------------------
void display_motion_detector()
{
  display_histogram();                           // Display the histogram on the top line
  display_motion_vars();                         // Display motion detection vars                         
}

// --------------------------
// display_line_distance() 
// Display the echo as a single horizontal bar.
// --------------------------

void display_line_distance()
{
  int range = range_cm;                           // Save range in case it changes
  int range_px;                                   // Range in horizontal pixels 
  int full_chars;                                 // Number of full characters to display
  int part_char;                                  // Value of the end part character 
  int i;                   
  int max_range_cm = 320;                         // Maximum centimetres to display
  int display_px_length = 80;                     // Length of the bar in pixels
  int char_px_length = 5;                         // Number of pixels per character
  
  if (range > max_range_cm) range = max_range_cm; // Limit the value to fit the display
                                                  // Calculate the number of pixels to light
  range_px = (range * display_px_length) / max_range_cm;
  full_chars = range_px / char_px_length;        // Calculate number of complete characters
  
  lcd.setCursor(0, 1);                            // Set the cursor at the start of the top line
  for (i = 0; i < full_chars; i++)                // Print fully populated pixels on left most   
  {                                               // full_chars.
    lcd.setCursor(i, 0);                          // Set the cursor on the top line
    lcd.write(byte(5));                           // All pixels on.
  }
  
  part_char = range_px % char_px_length;          // Calculate the part character value
  lcd.setCursor(i, 0);                            // Set the cursor to the end of the full characters.
  lcd.write(byte(part_char));                     // Select the special char and write it to the display.
  i++;

for (; i < 16; i++)                             // Fill the remainder of the line with spaces.
  {
    lcd.setCursor(i, 0);                          // Set the cursor
    lcd.print(" ");                               // Print a space.
  }
}

// --------------------------
// display_line_distance_cm() 
// Display the horizontal echo bar on the top line
// with the distance value on the bottom.
// --------------------------
void display_line_distance_cm()
{
  display_line_distance();                        // Print the horizontal bar.
  display_distance_cm();                          // Print the distance value.
}
 
// --------------------------
// timerIsr() 50uS second interrupt ISR()
// Called every time the hardware timer 1 times out.
// --------------------------
void timerIsr()
{
    trigger_pulse();                              // Schedule the trigger pulses
    motion_output();                              // Handle the motion detector output
}

// --------------------------
// trigger_pulse() called every 50 uS to schedule trigger pulses.
// Generates a pulse one timer tick long.
// Minimum trigger pulse width for the HC-SR04 is 10 us. This system
// delivers a 50 uS pulse.
// --------------------------
void trigger_pulse()
{
      static volatile int state = 0;                 // State machine variable

if (!(--trigger_time_count))                   // Count to 200mS
      {                                              // Time out - Initiate trigger pulse
         trigger_time_count = tick_counts;           // Reload
         
         if (digitalRead(echoPin) == LOW)           // Skip trigger if echo high
         {
           state = 1;                                // Changing to state 1 initiates a pulse
         }
      }
    
      switch(state)                                  // State machine handles delivery of trigger pulse
      {
        case 0:                                      // Normal state does nothing
            break;
        
        case 1:                                      // Initiate pulse
           digitalWrite(trigPin, HIGH);              // Set the trigger output high
           state = 2;                                // and set state to 2
           break;
        
        case 2:                                      // Complete the pulse
        default:      
           digitalWrite(trigPin, LOW);               // Set the trigger output low
           state = 0;                                // and return state to normal 0
           break;
     }
}

// --------------------------
// echo_interrupt() External interrupt from HC-SR04 echo signal. 
// Called every time the echo signal changes state.
//
// Note: this routine does not handle the case where the timer
//       counter overflows which will result in the occassional error.
// --------------------------
void echo_interrupt()
{
  int i;
  int found_hit;
  
  switch (digitalRead(echoPin))                     // Test to see if the signal is high or low
  {
    case HIGH:                                      // High so must be the start of the echo pulse
      echo_end = 0;                                 // Clear the end time
      echo_start = micros();                        // Save the start time
      break;
      
    case LOW:                                       // Low so must be the end of the echo pulse
      echo_end = micros();                          // Save the end time
      echo_duration = echo_end - echo_start;        // Calculate the echo duration
            
      found_hit = RANGES - 1;                       // Default the last zone 
      for(i = 0; i < RANGES - 1; i++)               // Determine the zone for this measurement 
      {
         if ((echo_duration < zones[i]))
         {
           found_hit = i;                           // zone 'found_hit' found
           break;
         }
      }
      
      // Weight the zone corresponding to the distance measured and slowly reduce
      // the other zones.
      range_hits[found_hit] += 3;                   // Add to the isolated zone
      
      for(i = 0; i < RANGES; i++)                   
      {
        // Now decrement all the other zones
        if (i != found_hit)                         
        {
          range_hits[i]--;
        }
        
        // Stop the values going out of bounds
        if (range_hits[i] < 0)
        {
          range_hits[i] = 0;
        }
        
        if (range_hits[i] > 10)
        {
          range_hits[i] = 10;
        }
      }
     
       range_cm = echo_duration / 58;
       
      break;
  }
  
  motion_detector();
}

// --------------------------
// read_LCD_buttons() 
// Read the buttons on the LCD mini keypad.
// The buttons are all wired through resistors to an
// analog input channel so which button has been pressed
// can be determined by the value read from the input.
// 
// Note: It may be neccessary to calibrate the keypad input as
//       voltages on your board may differ from those used here.
//       my buttons when read are centered at these valies: 0, 100, 250, 410, 640
//       we add approx 50 to those values and check to see if we are close
// --------------------------
int read_LCD_buttons()
{
  int adc_key_in;
 
  adc_key_in = analogRead(0);                          // read the value from the sensor
  
  // Debug code - Uncomment this to send the key value to the serial monitor for calibration.
  /* *******************************
  Serial.println(adc_key_in);
  Debug code End **************** */
  
                                                       // Each key will read a different value.
  if (adc_key_in > 1000) return btnNONE;               // 1st option for speed reasons since it will be the most likely result.
 
  if (adc_key_in < 50)   return btnRIGHT; 
  if (adc_key_in < 150)  return btnUP;
  if (adc_key_in < 300)  return btnDOWN;
  if (adc_key_in < 460)  return btnLEFT;
  if (adc_key_in < 690)  return btnSELECT; 
 
  return btnNONE;                                      // when all others fail, return this...
}

// --------------------------
// do_button_input() 
// Read the buttons on the LCD mini keypad.
// Determine and take appropriate action.
// The buttons are debounced using a simple finite state
// machine which requires the routine to be called frequently.
//
// The debug code prints the state transitions to the serial monitor.
// --------------------------
void do_button_input()
{
  static int button_state = 0;                         // Initialise the state machine to state 0
  int button_down;
  
  button_down = read_LCD_buttons();                    // Read the keypad
  
  switch(button_state)                                 // Begin the finite state machine key debouncer
  {
    case 0:                                            // 0 Normal or idle state. No buttons being pressed.
      if (button_down == btnSELECT)
      {                                                // SELECT button down.
        //* Debug code ********************
        Serial.println("button_state 0 => 1");
        //Debug code End **************** */
        button_state = 1;                              // Go to state 1 to begin the debounce
      }
      break;
      
    case 1:                                            // 1 SELECT was down on the previous call.
      if (button_down == btnSELECT)                    // Is it still down?
      {                                                // Yes, change mode.
        if(++display_mode > 3)
        {
          display_mode = 0;
        }
        
       clear_display();                                  // Clear the display
       
       switch(display_mode)                              // Change to selected mode
       {
          case 0:      
            setup_display_cm_mode();
            break;
          case 1:
            setup_histogram_mode();
            break;
          case 2:
            setup_line_cm_mode();
            break;
          case 3:
            setup_motion_detect_mode();
            break;
       }
        
        //* Debug code ********************
        Serial.print("SELECT DETECTED button_state 1 => 2 display_mode = ");
        Serial.println(display_mode);
        //Debug code End **************** */
      }
      else
      {
        //* Debug code ********************
        Serial.println("BOUNCED button_state 1 => 2");
        //Debug code End **************** */
      }

button_state = 2;                                  // Go to state 2 to wait for no button down
      break;
      
    case 2:                                              // 2 Waiting for btnNONE ensures no further action
      if (button_down == btnNONE)                        // until the button is released and pushed again.
      {
        //* Debug code ********************
        Serial.println("Reset button_state 2 => 0");
        //Debug code End **************** */
        button_state = 0;
      }
      break;
  }
}

// --------------------------
// motion_detector() 
// Detects when an object approaches the sensor and triggers the output.
//
// The distance sensor often flips between reading objects at different
// distances. This makes it difficult to use individual sensor readings
// for motion detection. To mitigate the multi reading problem the readings
// are accumulated and averaged before use.
//
// Two averages are maintained. The first average has a long time constant and
// is used as the base reading. The second average has a shorter time constant
// to react quickly to changes. The difference in the two average values can
// be used to detect motion.
// --------------------------
void motion_detector()
{
  int i;
  static int base_ind = 0;                              // Index into the base array
  static int current_ind = 0;                           // Index into the current array
  int base_sum;                                         // Sum of the base array
  int current_sum;                                      // Sum of the current array
  int range;                                            // Local value of the distance
  int diff;                                             // Difference between base and current
  
  range = range_cm;                                     // Copy the distance value
  if (range > 1000) range = 1000;                       // Limit the range value
  
  motion_base_array[base_ind++] = range;                // Insert value into the base array
  
  if (base_ind >= MOTION_BASE_SIZE)                     // Wrap the base index to the start
  {
    base_ind = 0;
  }
  
  base_sum = 0;                                        // Start the base value processing 
  for (i = 0; i < MOTION_BASE_SIZE; i++)
  {
    base_sum += motion_base_array[i];                  // Sum the contents of the array
  }
  
  motion_base = base_sum / MOTION_BASE_SIZE;           // Divide by the array size

motion_current_array[current_ind++] = range;         // Insert value into the current array
  
  if (current_ind >= MOTION_CURRENT_SIZE)              // Wrap the current index to the start
  {
    current_ind = 0;
  }

current_sum = 0;                                    // Start the current value processing
  for (i = 0; i < MOTION_CURRENT_SIZE; i++)
  {
    current_sum += motion_current_array[i];           // Sum the contents of the array
  }
  
  motion_current = current_sum / MOTION_CURRENT_SIZE;// Divide by the array size
  
  diff = motion_base - motion_current;               // Compute the difference
  if (diff > 40)                                     // Check for movement towards the sensor
  {
    motion_detected = true;
  }
}

// --------------------------
// motion_output() 
// Handle the output from the motion detector logic.
// Called from the 50uS interrupt routine. Divides
// down to execute every 100mS.
// --------------------------

void motion_output()
{
  static int state = 0;                           // State machine variable
  static int idle_timer = 0;                      // Time between considerations
  static int timer;                               // Determin on/off times
  int on_time = 20;                               // 20 ticks of 100mS = 2S
  int off_time = 40;                              // 40 ticks of 100mS = 4S
  int idle_time = 2000;                           // Waiting to run 2000 * 50uS = 100mS
  
  if (--idle_timer <= 0)                          // Count calls to run every idle_time executions
  {
    idle_timer = idle_time;                       // Reset idle timer for next run
    
    switch(state)                                 // The finite state machine
    {
      case 0:                                     // Waiting for motion detection
        if (motion_detected)
        {                                         // Motion has been detected
          digitalWrite(motionLEDPin, HIGH);       // so set LED high and
          timer = on_time;                        // set timer for the time on then
          state = 1;                              // wait for time out before resetting LED
        }
        break;
        
      case 1:                                     // LED is high after motion detected 
        if (--timer <= 0)
        {                                         // On timer time out
          digitalWrite(motionLEDPin, LOW);        // Reset the LED low
          timer = off_time;                       // set the timer for the off time
          state = 2;                              // and wait before looking for motion again
        }
        break;

case 2:                                     // LED has been reset now wait before re-arming
        if (--timer <= 0)
        {                                         // Waiting time over
          motion_detected = false;                // Reset the detector and
          state = 0;                              // return to the motion detection state
        }
        break;
    }
  }
}

Arduino Motion Detector Project Conclusion

<< Previous First 2 3 4 Last

Now subscribe to our newsletter and don't miss a thing