Arduino ArduCam – Motion Detection Spycam (PIR, RTC, SD)

This project allows you to create a Motion Detection Spycam with a PIR Sensor, and ArduCam, and a Data Logging Shield with Real Time Clock. This project takes a pictures when motion is detected, saving the image as a .jpg with a unix timestamp as a name, and logs the picture creation and time in a user readable log file.

Note:

  • FRAMES_NUM is what determines the number of pictures taken when the function is triggered. This has been modified to only take a single picture
  • The naming convention for saving a file to an SD card is 8.3. This means you can have a name that has 8 characters, a period, and then a 3 character extension.

Prerequisite Classes:

Library

Links

Functional Parts in the Project:

Connect the PIR Sensor to Digital Pin 2, and use a breadboard to split the 5V power for both the PIR and ArduCam
// This sketch modifies the example: ArduCAM_Mini_2MP_Plus_Multi_Capture2SD
#include <Wire.h>
#include <ArduCAM.h>
#include <SPI.h>
#include <SD.h>
#include "memorysaver.h"
//This demo can only work on OV5640_MINI_5MP_PLUS or OV5642_MINI_5MP_PLUS platform.
#if !(defined (OV2640_MINI_2MP_PLUS))
#error Please select the hardware platform and camera module in the ../libraries/ArduCAM/memorysaver.h file
#endif

//ETCG Note - Set pictures taken to 1
#define   FRAMES_NUM    0x00

// set pin 7 as the slave select for the digital pot:
const int CS = 7;

//ETCG Note -- Modify this for what your shield/module for the SD Card
#define SD_CS 10

bool is_header = false;
int total_time = 0;
#if defined (OV2640_MINI_2MP_PLUS)
ArduCAM myCAM( OV2640, CS );
#endif
uint8_t read_fifo_burst(ArduCAM myCAM);

//ETCG -- PIR Sensor
#define pirPin 2
int pirReading;

//ETCG Note -- RTC/ Real Time Clock Code
#include <DS3231.h>
DS3231 rtc(SDA, SCL);

//ETCG Note -- Create Log File
File logFile;
String fileName;

void setup() {

  //ETCG Note -- PIR Sensor
  pinMode(pirPin, INPUT);

  //ETCG Note -- RTC/ Real Time Clock Code
  rtc.begin();

  uint8_t vid, pid;
  uint8_t temp;
#if defined(__SAM3X8E__)
  Wire1.begin();
#else
  Wire.begin();
#endif
  Serial.begin(115200);
  Serial.println(F("ArduCAM Start!"));
  // set the CS as an output:
  pinMode(CS, OUTPUT);
  digitalWrite(CS, HIGH);
  // initialize SPI:
  SPI.begin();
  //Reset the CPLD
  myCAM.write_reg(0x07, 0x80);
  delay(100);
  myCAM.write_reg(0x07, 0x00);
  delay(100);
  while (1) {
    //Check if the ArduCAM SPI bus is OK
    myCAM.write_reg(ARDUCHIP_TEST1, 0x55);
    temp = myCAM.read_reg(ARDUCHIP_TEST1);
    if (temp != 0x55)
    {
      Serial.println(F("SPI interface Error!"));
      delay(1000); continue;
    } else {
      Serial.println(F("SPI interface OK.")); break;
    }
  }
#if defined (OV2640_MINI_2MP_PLUS)
  while (1) {
    //Check if the camera module type is OV2640
    myCAM.wrSensorReg8_8(0xff, 0x01);
    myCAM.rdSensorReg8_8(OV2640_CHIPID_HIGH, &vid);
    myCAM.rdSensorReg8_8(OV2640_CHIPID_LOW, &pid);
    if ((vid != 0x26 ) && (( pid != 0x41 ) || ( pid != 0x42 ))) {
      Serial.println(F("ACK CMD Can't find OV2640 module!"));
      delay(1000); continue;
    }
    else {
      Serial.println(F("ACK CMD OV2640 detected.")); break;
    }
  }
#endif
  //Initialize SD Card
  while (!SD.begin(SD_CS))
  {
    Serial.println(F("SD Card Error!")); delay(1000);
  }
  Serial.println(F("SD Card detected."));
  //Change to JPEG capture mode and initialize the OV5640 module
  myCAM.set_format(JPEG);
  myCAM.InitCAM();
  myCAM.clear_fifo_flag();
  myCAM.write_reg(ARDUCHIP_FRAMES, FRAMES_NUM);
}

void loop() {

  //ETCG Note -- Detect PIR Sensor
  pirReading = digitalRead(pirPin);
  if (pirReading == HIGH) {
    Serial.println("Motion Detected");

    //ETCG Note -- Create Filename for Image
    long timeStamp = rtc.getUnixTime(rtc.getTime());
    timeStamp = timeStamp - 1500000000;
    fileName = String(timeStamp) + ".jpg";

    //ETCG Note -- Create and Write to Log File
    logFile = SD.open("log.txt", FILE_WRITE);
    if (logFile) {
      logFile.print(rtc.getDOWStr());
      logFile.print(", ");
      logFile.print(rtc.getDateStr());
      logFile.print(", ");
      logFile.print(rtc.getTimeStr());
      logFile.print(", ");
      logFile.println(fileName);
      logFile.close();
    } else {
      Serial.println("Error Writing to LogFile");
    }

    // put your main code here, to run repeatedly:
    myCAM.flush_fifo();
    myCAM.clear_fifo_flag();
#if defined (OV2640_MINI_2MP_PLUS)
    myCAM.OV2640_set_JPEG_size(OV2640_1600x1200);
#endif
    //Start capture
    myCAM.start_capture();
    Serial.println(F("start capture."));
    total_time = millis();
    while ( !myCAM.get_bit(ARDUCHIP_TRIG, CAP_DONE_MASK));
    Serial.println(F("CAM Capture Done."));
    total_time = millis() - total_time;
    Serial.print(F("capture total_time used (in miliseconds):"));
    Serial.println(total_time, DEC);
    total_time = millis();
    read_fifo_burst(myCAM);
    total_time = millis() - total_time;
    Serial.print(F("save capture total_time used (in miliseconds):"));
    Serial.println(total_time, DEC);
    //Clear the capture done flag
    myCAM.clear_fifo_flag();
    delay(5000);
    //ETCG Note
  } else {
    Serial.println("no motion detected");
  }
}

uint8_t read_fifo_burst(ArduCAM myCAM)
{
  uint8_t temp = 0, temp_last = 0;
  uint32_t length = 0;
  static int i = 0;
  static long k = 0;
  char str[16];

  File outFile;
  byte buf[256];
  length = myCAM.read_fifo_length();
  Serial.print(F("The fifo length is :"));
  Serial.println(length, DEC);
  if (length >= MAX_FIFO_SIZE) //8M
  {
    Serial.println("Over size.");
    return 0;
  }
  if (length == 0 ) //0 kb
  {
    Serial.println(F("Size is 0."));
    return 0;
  }
  myCAM.CS_LOW();
  myCAM.set_fifo_burst();//Set fifo burst mode
  i = 0;
  while ( length-- )
  {
    temp_last = temp;
    temp =  SPI.transfer(0x00);
    //Read JPEG data from FIFO
    if ( (temp == 0xD9) && (temp_last == 0xFF) ) //If find the end ,break while,
    {
      buf[i++] = temp;  //save the last  0XD9
      //Write the remain bytes in the buffer
      myCAM.CS_HIGH();
      outFile.write(buf, i);
      //Close the file
      outFile.close();
      Serial.println(F("OK"));
      is_header = false;
      myCAM.CS_LOW();
      myCAM.set_fifo_burst();
      i = 0;
    }
    if (is_header == true)
    {
      //Write image data to buffer if not full
      if (i < 256)
        buf[i++] = temp;
      else
      {
        //Write 256 bytes image data to file
        myCAM.CS_HIGH();
        outFile.write(buf, 256);
        i = 0;
        buf[i++] = temp;
        myCAM.CS_LOW();
        myCAM.set_fifo_burst();
      }
    }
    else if ((temp == 0xD8) & (temp_last == 0xFF))
    {
      is_header = true;
      myCAM.CS_HIGH();

      //ETCG Note -- Create File
      Serial.println(fileName);
      //Open the new file
      outFile = SD.open(fileName, O_WRITE | O_CREAT | O_TRUNC);

      if (! outFile)
      {
        Serial.println(F("File open failed"));
        while (1);
      }
      myCAM.CS_LOW();
      myCAM.set_fifo_burst();
      buf[i++] = temp_last;
      buf[i++] = temp;
    }
  }
  myCAM.CS_HIGH();
  return 1;
}

Be the first to comment

Leave a Reply