Adding some serial prints to show the value of pictureNumber and path, along with what’s being returned by get_image(SD_MMC, path.c_str() might give you more of a clue about what is going on.
I still think that EEPROM.begin only needs to be called once.
Pete.
Good morning, on further deliberation i think you may be right, my fear was that when the camera lost power for whatever reason, i assumed it would forget what number picture it will be on, however i realise now , if it did loose power it would check the EEPROM on startup and pick up where it left off. i am going to try and spend a bit of time on this today
after a small tantrum this morning and getting very close to giving up on this project completely, i can now report that i am now successful
after failing for about a week with various codes salvaged throughout the web, i found a timelaps code this morning that had everything neatly set out in little functions,it was set to take a picture and save to SD card on a timed interval. i just deleted it and put the command on a virtual button. i just had to add the libraries and the blink write and connect it to the capture command, it now takes photos and saves them to sd card on command, 
here is the working code, this just add your button on V3 on the app. add your wifi details in the code, upload and away you go
#include <WiFi.h>
#include <WiFiClient.h>
#include "Arduino.h"
#include <BlynkSimpleEsp32.h>
// Time
#include "time.h"
#include "lwip/err.h"
#include "lwip/apps/sntp.h"
// MicroSD
#include "driver/sdmmc_host.h"
#include "driver/sdmmc_defs.h"
#include "sdmmc_cmd.h"
#include "esp_vfs_fat.h"
// Edit ssid, password, capture_interval:
const char* ssid = "MYwifiID";
const char* password = "PASSWORD";
char auth[] = "BLYNK AUTH CODE";
int capture_interval = 5000; // microseconds between captures
//
long current_millis;
long last_capture_millis = 0;
static esp_err_t cam_err;
static esp_err_t card_err;
char strftime_buf[64];
int file_number = 0;
bool internet_connected = false;
struct tm timeinfo;
time_t now;
// 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
void setup() {
Serial.begin(115200);
Blynk.begin(auth, ssid, password);
if (init_wifi()) { // Connected to WiFi
internet_connected = true;
Serial.println("Internet connected");
init_time();
time(&now);
setenv("TZ", "GMT0BST,M3.5.0/01,M10.5.0/02", 1);
tzset();
}
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;
//init with high specs to pre-allocate larger buffers
if (psramFound()) {
config.frame_size = FRAMESIZE_UXGA;
config.jpeg_quality = 10;
config.fb_count = 2;
} else {
config.frame_size = FRAMESIZE_SVGA;
config.jpeg_quality = 12;
config.fb_count = 1;
}
// camera init
cam_err = esp_camera_init(&config);
if (cam_err != ESP_OK) {
Serial.printf("Camera init failed with error 0x%x", cam_err);
return;
}
// SD camera init
card_err = init_sdcard();
if (card_err != ESP_OK) {
Serial.printf("SD Card init failed with error 0x%x", card_err);
return;
}
}
bool init_wifi()
{
int connAttempts = 0;
Serial.println("\r\nConnecting to: " + String(ssid));
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED ) {
delay(500);
Serial.print(".");
if (connAttempts > 10) return false;
connAttempts++;
}
return true;
}
void init_time()
{
sntp_setoperatingmode(SNTP_OPMODE_POLL);
sntp_setservername(0, "pool.ntp.org");
sntp_init();
// wait for time to be set
time_t now = 0;
timeinfo = { 0 };
int retry = 0;
const int retry_count = 10;
while (timeinfo.tm_year < (2016 - 1900) && ++retry < retry_count) {
Serial.printf("Waiting for system time to be set... (%d/%d)\n", retry, retry_count);
delay(2000);
time(&now);
localtime_r(&now, &timeinfo);
}
}
static esp_err_t init_sdcard()
{
esp_err_t ret = ESP_FAIL;
sdmmc_host_t host = SDMMC_HOST_DEFAULT();
sdmmc_slot_config_t slot_config = SDMMC_SLOT_CONFIG_DEFAULT();
esp_vfs_fat_sdmmc_mount_config_t mount_config = {
.format_if_mount_failed = false,
.max_files = 1,
};
sdmmc_card_t *card;
Serial.println("Mounting SD card...");
ret = esp_vfs_fat_sdmmc_mount("/sdcard", &host, &slot_config, &mount_config, &card);
if (ret == ESP_OK) {
Serial.println("SD card mount successfully!");
} else {
Serial.printf("Failed to mount SD card VFAT filesystem. Error: %s", esp_err_to_name(ret));
}
}
static esp_err_t save_photo_numbered()
{
file_number++;
Serial.print("Taking picture: ");
Serial.print(file_number);
camera_fb_t *fb = esp_camera_fb_get();
//char *filename = (char*)malloc(21 + sizeof(int));
char *filename = (char*)malloc(21 + sizeof(file_number));
sprintf(filename, "/sdcard/capture_%d.jpg", file_number);
Serial.println(filename);
FILE *file = fopen(filename, "w");
if (file != NULL) {
size_t err = fwrite(fb->buf, 1, fb->len, file);
Serial.printf("File saved: %s\n", filename);
} else {
Serial.println("Could not open file");
}
fclose(file);
esp_camera_fb_return(fb);
free(filename);
}
static esp_err_t save_photo_dated()
{
Serial.println("Taking picture...");
camera_fb_t *fb = esp_camera_fb_get();
time(&now);
localtime_r(&now, &timeinfo);
strftime(strftime_buf, sizeof(strftime_buf), "%F_%H_%M_%S", &timeinfo);
char *filename = (char*)malloc(21 + sizeof(strftime_buf));
sprintf(filename, "/sdcard/capture_%s.jpg", strftime_buf);
Serial.println(filename);
FILE *file = fopen(filename, "w");
if (file != NULL) {
size_t err = fwrite(fb->buf, 1, fb->len, file);
Serial.printf("File saved: %s\n", filename);
} else {
Serial.println("Could not open file");
}
fclose(file);
esp_camera_fb_return(fb);
free(filename);
}
void save_photo()
{
if (timeinfo.tm_year < (2016 - 1900) || internet_connected == false) { // if no internet or time not set
save_photo_numbered(); // filenames in numbered order
} else {
save_photo_dated(); // filenames with date and time
} }
BLYNK_WRITE(V3) {
int pinValue = param.asInt();
if (pinValue == 1) {
save_photo(); } // change to save_photo_numbered(); if you would like dated filenames
}
void loop()
{
Blynk.run();
}
final note. i couldn’t get the led to turn off between image captured, any attempt to turn it off, stopped the image being captured some how. i will design it in as a standby light…
next mission, add a visual display of the camera to blynk,
Dearest pete.I have a bit of progress in my project. I have had a dable with a good few codes the last few days. speaking to a load of different people all around the world. All with the same issue lol. I personally have failed to get a http or rtsp stream to blynk. However I have reverted back to the doorbell coded from techiesms. And I have realised if I press the capture button fast and repetivly on blynk app. I can get about 5 images per second to display in blynk image gallery widget . And this will do nicely for my purpose. However if I hold the button down. Or make it a switch. It only captures on image… My question is now how do I simulate what I am doing in code high low high low. I would asume it would be a while loop? While v2 high loop capture function. Do I need to use the blynk timer? Toggle state?
I have no idea what this code looks like, so it’s not possible for me to comment.
Pete.
#include <WiFi.h>
#include <WiFiClient.h>
#include <BlynkSimpleEsp32.h>
#define CAMERA_MODEL_AI_THINKER
#include "camera_pins.h"
const char* ssid = "SKY4ED26";
const char* password = "QDLMCXBMRT";
char auth[] = "1noR_elPy_pkZivlLlkX7HCtXUi-pbD3";
String my_Local_IP;
void startCameraServer();
void capture()
{
uint32_t number = random(40000000);
//Blynk.notify("Someone is at the door..");
Serial.println("http://"+my_Local_IP+"/capture?_cb="+ (String)number);
Blynk.setProperty(V1, "urls", "http://"+my_Local_IP+"/capture?_cb="+(String)number);
}
BLYNK_WRITE(V2)
{
int pinValue = param.asInt();
if (pinValue == 1) {
capture(); }
void setup() {
Serial.begin(115200);
Serial.setDebugOutput(true);
Serial.println();
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;
//init with high specs to pre-allocate larger buffers
if (psramFound()) {
config.frame_size = FRAMESIZE_UXGA;
config.jpeg_quality = 10;
config.fb_count = 2;
} else {
config.frame_size = FRAMESIZE_SVGA;
config.jpeg_quality = 12;
config.fb_count = 1;
}
#if defined(CAMERA_MODEL_ESP_EYE)
pinMode(13, INPUT_PULLUP);
pinMode(14, INPUT_PULLUP);
#endif
// camera init
esp_err_t err = esp_camera_init(&config);
if (err != ESP_OK) {
Serial.printf("Camera init failed with error 0x%x", err);
return;
}
sensor_t * s = esp_camera_sensor_get();
//initial sensors are flipped vertically and colors are a bit saturated
if (s->id.PID == OV3660_PID) {
s->set_vflip(s, 1);//flip it back
s->set_brightness(s, 1);//up the blightness just a bit
s->set_saturation(s, -2);//lower the saturation
}
//drop down frame size for higher initial frame rate
s->set_framesize(s, FRAMESIZE_QVGA);
#if defined(CAMERA_MODEL_M5STACK_WIDE)
s->set_vflip(s, 1);
s->set_hmirror(s, 1);
#endif
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("WiFi connected");
startCameraServer();
Serial.print("Camera Ready! Use 'http://");
Serial.print(WiFi.localIP());
my_Local_IP = WiFi.localIP().toString();
Serial.println("' to connect");
Blynk.begin(auth, ssid, password);
}
void loop() {
// put your main code here, to run repeatedly:
Blynk.run();BlynkTimer timer;/// in global
Void setup(){
timre.setInterval(1000L,capture);
this would enter function every one second? correct?
solution was…
{
int pinValue = param.asInt();
if (pinValue == 0) {
timer.setInterval(250L, capture);
}
//if (pinValue == 1) { sd card capture function }
}
....i had to learn all about simpletimer for that... now attempting to add the capture and save to sd card functionBlynkTimer, which is an improved version of SimpleTimer is already built into the Blynk library.
Pete.
it will work untill i iron out the kinks
this little bit of code (posted above) works around v2 and if statement. If V2 LOW, do this if HIGH do that. however the state of V2 is Neither HIGH or LOW on startup, until the user toggles the switch, and declares the state.this only needs to happen once on start up and works continuously as you leave and re open the app. i plan to remove this switch and change states using the eventor or simple timer, however the state needs to be declared on start up to remove any issues if a loss of power occures.
so to simplify. how do i declare V2 Low on Startup?
is it something simple like Blynk.virtualWrite(V1, 0)
another issue i have faced it that i cant get the function to stop looping IF V2 High how do i stop this?
As you will have seen when you researched the SimpleTimer commands, it’s possible to delete, enable, disable and toggle a timer.
Pete.