Skip to main content

Motion Detector Camera

Motion Detector With Photo Capture Camera 


 Hello friends!! Welcome to This Blog. In this Blog, we will make a motion sensor detector with photo capture using ESP32CAM and the PIR module. The logic behind is when the PIR sensor detects any motion, the ESP32CAM will start taking the pictures. So you can use this project as a security camera.



In thisblog, I will share the circuitdiagram, Arduino sketch, and the component list, so after reading the complete article you can easily make this project. Now ESP32 CAM is a small camera module that has ESP32S chip on the back and some GPIO pins to connect peripherals and it also has a micro-SD card slot, where you can insert the micro-SD card and store the pictures. Now before going to the circuit diagram and Arduino sketch, let me give you a quick overview of this project. 

Components Required

  1. ESP32-CAM 
  2. PIR Motion Sensor Module
  3. BC547 NPN Transistor
  4. 220ohm, 1k, 10k Resistor.
  5. LED 5-mm
  6. FTDI 232 USB to Serial Interface board
  7. 5 volt DC supply 
The ESP32CAM is in deep sleep mode with external wake up enable. Whenever the PIR module detects any motion,the ESP32CAM will wake up and take the picture. Then it will save the picture to the micro-SD card and then after a certain delay again it will go to deep sleep mode.

Now to program this ESP32 CAM we will use this USB to Serial interface board. Now to connect this USB to serial interface board with ESP32-CAM you can refer to this circuit diagram.

Connections


Now here you can see I have connected this USB to serial interface board with ESP32-CAM. While uploading the code, I have to connected the GPIO-0 with GND. Now I will connect it with my laptop to upload the code. Now, this is the sketch for this project.

 And in the sketch, you can see we are using GPIO-13 pin to get the external wake up signal for ESP32CAM. And after taking the picture, and save it to the micro-SD card, it will go to deep sleep after a certain delay. So you want me to explain the code in details,let me know, I will write a separate blog for that. Now I am going to upload the code, but before that let me tell you if go to File --> preference, you have to copy-paste this URL for this board in that place. Then you have to install the ESP32 board. For that, you have to go to Board Manager and then type ESP 32. SO you have to install this ESP32 board.  After that, you have to go to Tools and select ESP32 Wrover Module and here in the partition scheme I have selected the "Huge App..." So after doing that you have to select the proper PORT. Then you can upload the sketch. If you see this "connecting..... " text then you have to press the RESET button mounted on the ESP32-CAM board. Now after uploading the code I can remove this USB to Serial interface board.

 Now I will connect this PIR sensor with this ESP32 CAM and the output pin of the PIR sensor is connected with the BASE of the NPN transistor througha 1k resistor. So when the PIR module detects any motion,it will give a high pulse at the output pin and the transistor will turn on. So when the transistor will turn on the current can flow COLLECTOR to EMITTER. So as you can see the GPIO-13 is connectedwith the COLLECTOR of the transistor through a 10k resistor. So when the transistor will turn on, it will ground the GPIO-13, as you see the EMITTER is connected with the GND. So when the PIR sensor sense any motion, thetransistor will turn on and this ESP32CAM will wake up. Then it will take the picture and save it to the micro-SD card and after a certain delay again it will go to deep sleep mode. Like that this circuit works.

Working Logic


Code

#include "esp_camera.h"
#include "Arduino.h"
#include "FS.h"                // SD Card ESP32
#include "SD_MMC.h"            // SD Card ESP32
#include "soc/soc.h"           // Disable brownour problems
#include "soc/rtc_cntl_reg.h"  // Disable brownour problems
#include "driver/rtc_io.h"
#include <EEPROM.h>            // read and write from flash memory
// define the number of bytes you want to access
#define EEPROM_SIZE 1
 
RTC_DATA_ATTR int bootCount = 0;

// Pin definition for CAMERA_MODEL_AI_THINKER
#define PWDN_GPIO_NUM     32
#define RESET_GPIO_NUM    -1
#define XCLK_GPIO_NUM      0
#define SIOD_GPIO_NUM     26
#define SIOC_GPIO_NUM     27
#define Y9_GPIO_NUM       35
#define Y8_GPIO_NUM       34
#define Y7_GPIO_NUM       39
#define Y6_GPIO_NUM       36
#define Y5_GPIO_NUM       21
#define Y4_GPIO_NUM       19
#define Y3_GPIO_NUM       18
#define Y2_GPIO_NUM        5
#define VSYNC_GPIO_NUM    25
#define HREF_GPIO_NUM     23
#define PCLK_GPIO_NUM     22
 
int pictureNumber = 0;
  
void setup() {
  WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0); //disable brownout detector
  Serial.begin(115200);
 
  Serial.setDebugOutput(true);
 
  camera_config_t config;
  config.ledc_channel = LEDC_CHANNEL_0;
  config.ledc_timer = LEDC_TIMER_0;
  config.pin_d0 = Y2_GPIO_NUM;
  config.pin_d1 = Y3_GPIO_NUM;
  config.pin_d2 = Y4_GPIO_NUM;
  config.pin_d3 = Y5_GPIO_NUM;
  config.pin_d4 = Y6_GPIO_NUM;
  config.pin_d5 = Y7_GPIO_NUM;
  config.pin_d6 = Y8_GPIO_NUM;
  config.pin_d7 = Y9_GPIO_NUM;
  config.pin_xclk = XCLK_GPIO_NUM;
  config.pin_pclk = PCLK_GPIO_NUM;
  config.pin_vsync = VSYNC_GPIO_NUM;
  config.pin_href = HREF_GPIO_NUM;
  config.pin_sscb_sda = SIOD_GPIO_NUM;
  config.pin_sscb_scl = SIOC_GPIO_NUM;
  config.pin_pwdn = PWDN_GPIO_NUM;
  config.pin_reset = RESET_GPIO_NUM;
  config.xclk_freq_hz = 20000000;
  config.pixel_format = PIXFORMAT_JPEG;
  
  pinMode(4, INPUT);
  digitalWrite(4, LOW);
  rtc_gpio_hold_dis(GPIO_NUM_4);
 
  if(psramFound()){
    config.frame_size = FRAMESIZE_UXGA; // FRAMESIZE_ + QVGA|CIF|VGA|SVGA|XGA|SXGA|UXGA
    config.jpeg_quality = 10;
    config.fb_count = 2;
  } else {
    config.frame_size = FRAMESIZE_SVGA;
    config.jpeg_quality = 12;
    config.fb_count = 1;
  }
 
  // Init Camera
  esp_err_t err = esp_camera_init(&config);
  if (err != ESP_OK) {
    Serial.printf("Camera init failed with error 0x%x", err);
    return;
  }

   //set the camera parameters
  sensor_t * s = esp_camera_sensor_get();
  s->set_contrast(s, 2);    //min=-2, max=2
  s->set_brightness(s, 2);  //min=-2, max=2
  s->set_saturation(s, 2);  //min=-2, max=2
  delay(100);               //wait a little for settings to take effect
 
  Serial.println("Starting SD Card");
 
  delay(500);
  if(!SD_MMC.begin()){
    Serial.println("SD Card Mount Failed");
    //return;
  }
 
  uint8_t cardType = SD_MMC.cardType();
  if(cardType == CARD_NONE){
    Serial.println("No SD Card attached");
    return;
  }
   
  camera_fb_t * fb = NULL;
 
  // Take Picture with Camera
  fb = esp_camera_fb_get();  
  if(!fb) {
    Serial.println("Camera capture failed");
    Serial.println("Exiting now"); 
    while(1);   //wait here as something is not right
  }
  // initialize EEPROM with predefined size
  EEPROM.begin(EEPROM_SIZE);
  pictureNumber = EEPROM.read(0) + 1;
 
  // Path where new picture will be saved in SD Card
  String path = "/picture" + String(pictureNumber) +".jpg";
 
  fs::FS &fs = SD_MMC;
  Serial.printf("Picture file name: %s\n", path.c_str());
 //create new file
  File file = fs.open(path.c_str(), FILE_WRITE);
  if(!file){
    Serial.println("Failed to open file in writing mode");
    Serial.println("Exiting now"); 
    while(1);   //wait here as something is not right
  }
  else {
    file.write(fb->buf, fb->len); // payload (image), payload length
    Serial.printf("Saved file to path: %s\n", path.c_str());
    EEPROM.write(0, pictureNumber);
    EEPROM.commit();
  }
  file.close();
  esp_camera_fb_return(fb);
  
  delay(1000);
  
  // Turns off the ESP32-CAM white on-board LED (flash) connected to GPIO 4
  pinMode(4, OUTPUT);  //GPIO for LED flash
  digitalWrite(4, LOW);  //turn OFF flash LED
  rtc_gpio_hold_en(GPIO_NUM_4);  //make sure flash is held LOW in sleep

  esp_sleep_enable_ext0_wakeup(GPIO_NUM_13, 0);
 
  Serial.println("Going to sleep now");
  delay(3000);
  esp_deep_sleep_start();
  Serial.println("Now in Deep Sleep Mode");
} 
 
void loop() {
 
}

Conclusion

 I have made the circuit on the breadboard. Now I will insert the micro-SD card. And after that, I will give the 5 volt supply from my mobile charger. You can also use a power bank for this purpose. So let me connect the 5 volt supply. Now if I move my hand in front of the PIR sensor, it will detect the motion and accordingly, ESP32 CAM will take the picture and save it to the micro-SD card, and after a certain delay, it will again go to deep sleep mode.  I have placed this motion detector circuit in front of the main door. So whenever someone enters or exits from the main door, it will detect the motion, and accordingly, the ESP32 CAM will take the picture. So we have taken some sample pictures, now I will turn off the 5 volt supply then I will remove the SD card from ESP32Cam module. Now I will insert the SD card to my laptop to what are the pictures taken by this ESP32CAM.  you can see, these are the pictures taken by the ESP32CAM. So you can also use this circuit as a security camera. If you have any doubts, or you are facing any problem during making this project, let me know in the comment section. And if you enjoyed the blog, please give Thump up and share it with your friends.
Labels:

Comments

Post a Comment

If you have any doubts ,Please let me know.

amazon banner

Popular posts from this blog

Obstacle Avoiding Robot

Obstacle Avoiding Robot using Arduino and Ultrasonic Sensor A simple project on Obstacle Avoiding Robot is meant here. Robotics is a stimulating and fast growing field. Being a branch of engineering, the applications of robotics are increasing with the advancement of technology.The concept of Mobile Robot is fast evolving and therefore the number of mobile robots and their complexities are increasing with different applications. There are many kind of mobile robot navigation techniques like path planning, self – localization and map interpreting. An Obstacle Avoiding Robot may be a sort of autonomous mobile robot that avoids collision with unexpected obstacles. In this project, an Obstacle Avoiding Robot is supposed. It's an Arduino based robot that uses Ultrasonic range finder sensors to avoid collisions.  Components Required Arduino NANO or Uno  🛒 HC-SR04 Ultrasonic Sensor  🛒 LM298N Motor Driver Module  🛒 5V DC Motors  🛒 Battery  🛒 Wheels 🛒 Chassis...
Post a Comment
Read more

Bidirectional Visitor Counter

Bidirectional Visitor Counter using Arduino A bidirectional visitor counter using Arduino may be a reliable circuit that takes over the task of counting variety of Persons/Visitors within the Room very accurately. if somebody enters into the space then the Counter is incremented by one and also leaves it might be incremented. MATERIALS REQUIRED: Arduino IR Module 16*2 LED 5V Relay Resistor(1K,220 ohm) Breadboard Jumper Wires The total number of persons inside the space is Shows on the 16X2 LCD module. The microcontroller does the work it receives the signals from the sensors, and this signals operated under the control of software which is stored in EPROM of Arduino. There are two IR Modules are used. first, one are often wont to count the amount of persons entering a hall within the up mode at the doorway gate. and therefore the other can count the amount of persons leaving the hall by decrementing the count at the exit gate. In this Project will helps to Wastage of electricity. In ou...
Post a Comment
Read more