Final Project

Slide

Video

Motivation

A low cost trap camera could be a very useful project for my experience. first, because with a project like this I could show to other science career students the possibility to bring useful scientific instruments for research from bits to atoms.

Other Possibilities

Next prototypes of the camera could include some IR LEDs which make it able to work with night vision, which would be a plus for wildlife research also a project of this type could be a useful device in the rural communities for farming and animal breeding where people interacts with wildlife every day. Between other possibilities, this device could include more features such as video and audio recording, Bluetooth, or wifi connection, another option would be related to training IA models for automatic identification of species.

Useful links from existing (Patents)

Waterproof Camera Housing 2017

Camera and Waterproof Camera Casing 2004

Waterproof Camera Housing 1987

Bill of materials

Component	Quantity	Price $	where I got it from ?
Battery 9V	1	4	Lab stock
Condensers	7	3,5	Lab stock
Resistors	5	1,5	Lab Stock
Atmega 328P	1	2,3	Lab stock
Button	2	1,6	Lab stock
Pin Header	8	2	Lab stock
Voltage regulator	1	0,88	Lab Stock
PCB board	1	1,4	Lab stock
LED SMD	1	0,4	Lab Stock
ESP32CAM	1	16	Lab Stock
SD card	1	5	Lab stock
PIR sensor	1	2	Lab stock
DHT 11 sensor	1	2	Lab Stock
Total		42,58

3D design

I designed the case for the camera, in order to be sure that all components will fit inside it I used the setup addon for FREECAD to design the case around the 3D Models of the components.

PCB board

I had some trouble during working with the ESP32 CAM to connect it to more than two sensors because it has almost all the pins busy with the sd card, also the people in the open class recommended me to include a PCB made by myself.

During that process, I consulted a lot of tutorials and info about the board related to the low power consumption, the wifi, and the Bluetooth connections.

So, for this project, I designed a PCB in Kicad which includes an Atmega 328P, and pin headers to connect the PIR, the DHT sensor, and SD card to save environmental data, the idea was that after movement detection and data saving this board sent a pulse to activate the camera where a photo is saved in another SD.

In this PCB I forgot to include the reset pin and the “CS” for the SD which was added for one of the sensors, so I solved using wires, to burn the bootloader I had to wash the board with acetone because it had a short circuit that gave connection problems.

There were also some phantom voltages that interrupted the trigger mechanism in the beginning, which was solved using a resistor.

Those lessons learned must be taken into account to improve the prototype of the project.

Code of the project

This is the code I used for programing the pcb designed for the project.

//variables del dht11
#include <SPI.h>
#include <SD.h>
#include <dht.h>
#define dht_apin 5 // Analog Pin sensor is connected to
dht DHT;
//variables del dht11

//variables del PIR
int ledPin = 13;                // LED
int pirPin = 6;                 // PIR Out pin
int pirStat = 0;                   // PIR status
int trigger = 7;
File myFile;
void setup(){

  Serial.begin(9600);
  delay(500);//Delay to let system boot
  //Serial.println("DHT11 Humidity & temperature Sensor\n\n");
  pinMode(ledPin, OUTPUT);     
  pinMode(pirPin, INPUT);
  pinMode(trigger, OUTPUT);
  //digitalWrite(trigger, HIGH);
  delay(1000);//Wait before accessing Sensor

Serial.print("Initializing SD card...");
if (!SD.begin(10)) {
Serial.println("initialization failed!");
return;
}
Serial.println("initialization done.");
  //myFile = SD.open("test.txt",FILE_WRITE);
}//end "setup()"


void loop(){
  //Start of Program

  pirStat = digitalRead(pirPin);
 if (pirStat == HIGH) {            // if motion detected
   digitalWrite(ledPin, HIGH);  // turn LED ON
   Serial.println("Hey I got you!!!");
  digitalWrite(trigger, HIGH);
  delay(50);
  digitalWrite(trigger, LOW);
  lectura();

 }
 else {
   digitalWrite(ledPin, LOW); // turn LED OFF if we have no motion
 }



}// end loop(

void lectura()
{
  DHT.read11(dht_apin);
    int temp = DHT.temperature;
    Serial.print("Current humidity = ");
    Serial.print(DHT.humidity);
    Serial.print("%  ");
    Serial.print("temperature = ");
    Serial.print(temp);
    Serial.println("C  ");
    delay(5000);//Wait 5 seconds before accessing sensor again.
 //Fastest should be once every two seconds.

// open the file. note that only one file can be open at a time,
// so you have to close this one before opening another.
myFile = SD.open("lectura.txt", FILE_WRITE);
// if the file opened okay, write to it:

Serial.print("Writing to test.txt...");
myFile.println("Current humidity = ");
delay(500);
myFile.println(DHT.humidity);
delay(500);
myFile.println ("temperature = ");
delay(500);
myFile.println (temp);
delay(500);
myFile.println ("C  ");
delay(500);

// close the file:
myFile.close();
Serial.println("done.");

}

For the Camera there was another code, I took an example from a tutorial available on the web and modified the wakeup mechanism to activate the camera with a pulse which comes from the Atmega 328P board.

/*********
  Rui Santos
  Complete project details at https://RandomNerdTutorials.com/esp32-cam-pir-motion-detector-photo-capture/

  IMPORTANT!!!
   - Select Board "AI Thinker ESP32-CAM"
   - GPIO 0 must be connected to GND to upload a sketch
   - After connecting GPIO 0 to GND, press the ESP32-CAM on-board RESET button to put your board in flashing mode

  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files.
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
*********/

#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;
  }

  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");
    return;
  }
  // 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());

  File file = fs.open(path.c_str(), FILE_WRITE);
  if(!file){
    Serial.println("Failed to open file in writing mode");
  }
  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);
  digitalWrite(4, LOW);
  rtc_gpio_hold_en(GPIO_NUM_4);

  //pinMode(12, INPUT_PULLDOWN);
  //esp_sleep_enable_ext0_wakeup(GPIO_NUM_12, 1);
  esp_sleep_enable_ext0_wakeup(GPIO_NUM_13, 1);

  Serial.println("Going to sleep now");
  delay(1000);
  esp_deep_sleep_start();
  Serial.println("This will never be printed");
}

void loop() {

}