This class teaches you to save images from your ArduCam to an SD card using a Unix Timestamp for the name. This is useful not just as a timestamp, but also as a way to give images unique names that will not be overwritten when the Arduino restarts.
Notes:
- The naming convention for saving to an SD card with Arduino is 8.3. This means you can have 8 characters, a period, and then a 3 character extesnion. A full Unix timestamp is 10 characters. To shrink the timestamp to 8 characters I simply subtract 1500000000 from it. This is a blunt way of removing the first 2 characters. If you need to turn the image name, back into a real timestamp to view the time make sure to add 15 to the front of the number.
- The Data Logging Shield used in this video has a RTC/ Real Time Click built in.
Prerequisite Classes:
Library
- ArduCam Library – https://github.com/ArduCAM/Arduino
- DS3231 Library – http://www.rinkydinkelectronics.com/library.php?id=73
Links
- ArduCAM Mini Cameras Tutorial – https://www.arducam.com/knowledge-base/mini-tutorial/
Functional Parts in the Project:
- Arduino Uno – https://store.arduino.cc/usa/arduino-uno-rev3
- ArduCam 2MP Mini Module – https://amzn.to/3c7ydGT
- Data Recorder Shield with RTC – https://amzn.to/3c6kNuP
- CR1220 Batteries – https://amzn.to/2X6h4ch
// 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
#define FRAMES_NUM 0x06
// 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 Note -- RTC/ Real Time Clock Code
#include <DS3231.h>
DS3231 rtc(SDA, SCL);
void setup() {
//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() {
// 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);
}
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 Filename
long timeStamp = rtc.getUnixTime(rtc.getTime());
timeStamp = timeStamp - 1500000000;
Serial.println(timeStamp);
String fileName = String(timeStamp) + ".jpg";
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