/******************** - Executive Order Corporation - Arduino Tron ESP8266 MQTT Telemetry Transport Machine-to-Machine(M2M)/Internet of Things(IoT) - Arduino Tron Drools-jBPM :: Executive Order Arduino Tron Sensor Processor MQTT AI-IoTBPM Client using AI-IoTBPM Drools-jBPM - Arduino Tron AI-IoTBPM :: Internet of Things Drools-jBPM Expert System using Arduino Tron AI-IoTBPM Processing - Executive Order Corporation - Copyright © 1978, 2019: Executive Order Corporation, All Rights Reserved -Midly modified by Daniel Terletzkiy ********************/ #include "SPIFFS.h" #include "esp_camera.h" #include #include "esp_timer.h" #include "img_converters.h" #include "Arduino.h" #include "fb_gfx.h" #include "fd_forward.h" #include "fr_forward.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 // used for internet time #include "dl_lib.h" #include "esp_http_server.h" #define CAMERA_MODEL_AI_THINKER #define PART_BOUNDARY "123456789000000000000987654321" #define ENROLL_CONFIRM_TIMES 8 #define FACE_ID_SAVE_NUMBER 7 #define FACE_COLOR_WHITE 0x00FFFFFF #define FACE_COLOR_BLACK 0x00000000 #define FACE_COLOR_RED 0x000000FF #define FACE_COLOR_GREEN 0x0000FF00 #define FACE_COLOR_BLUE 0x00FF0000 #define FACE_COLOR_YELLOW (FACE_COLOR_RED | FACE_COLOR_GREEN) #define FACE_COLOR_CYAN (FACE_COLOR_BLUE | FACE_COLOR_GREEN) #define FACE_COLOR_PURPLE (FACE_COLOR_BLUE | FACE_COLOR_RED) #include #include "EEPROM.h" WiFiClient espClient; PubSubClient client(espClient); // Update these with WiFi network values const char* ssid ="your_ssid"; // your network SSID (name) const char* password ="your_password"; // your network password const char* mqtt_server="your_mqtt_ip"; //your mqtt server ip static const char* _STREAM_CONTENT_TYPE = "multipart/x-mixed-replace;boundary=" PART_BOUNDARY; static const char* _STREAM_BOUNDARY = "\r\n--" PART_BOUNDARY "\r\n"; static const char* _STREAM_PART = "Content-Type: image/jpeg\r\nContent-Length: %u\r\n\r\n"; typedef struct { size_t size; // number of values used for filtering size_t index; // current value index size_t count; // value count int sum; int * values; // array to be filled with values } ra_filter_t; static ra_filter_t ra_filter; httpd_handle_t stream_httpd = NULL; httpd_handle_t camera_httpd = NULL; String ver = "1.03E"; static mtmn_config_t mtmn_config = {0}; static int8_t recognition_enabled = 0; static int8_t is_enrolling = 0; static face_id_list id_list = {0}; typedef struct { httpd_req_t *req; size_t len; } jpg_chunking_t; const char* ntpServer = "pool.ntp.org"; // internet time server const long gmtOffset_sec = 3600;// internet time server const int daylightOffset_sec = 3600;// internet time server static int8_t detection_enabled = 0; int yes_id=0; int8_t left_sample_face; String face_id; static int run_face_recognition(dl_matrix3du_t *image_matrix, box_array_t *net_boxes) { dl_matrix3du_t *aligned_face = NULL; int matched_id = 0; aligned_face = dl_matrix3du_alloc(1, FACE_WIDTH, FACE_HEIGHT, 3); if (!aligned_face) { Serial.println("Could not allocate face recognition buffer"); return matched_id; } if (align_face(net_boxes, image_matrix, aligned_face) == ESP_OK) { if (is_enrolling == 1) { left_sample_face = enroll_face(&id_list, aligned_face); yes_id=3; if (left_sample_face == (ENROLL_CONFIRM_TIMES - 1)) { Serial.printf("Enrolling Face ID: %d\n", id_list.tail); } Serial.printf("Enrolling Face ID: %d sample %d\n", id_list.tail, ENROLL_CONFIRM_TIMES - left_sample_face); rgb_printf(image_matrix, FACE_COLOR_CYAN, "ID[%u] Sample[%u]", id_list.tail, ENROLL_CONFIRM_TIMES - left_sample_face); if (left_sample_face == 0) { is_enrolling = 0; Serial.printf("Enrolled Face ID: %d\n", id_list.tail); yes_id=4; } } else { matched_id = recognize_face(&id_list, aligned_face); if (matched_id >= 0) { yes_id=1; face_id=String(matched_id); Serial.printf("Match Face ID: %u\n", matched_id); rgb_printf(image_matrix, FACE_COLOR_GREEN, "ID: %u", matched_id); } else { yes_id=2; //loop(); Serial.println("No Match Found"); rgb_print(image_matrix, FACE_COLOR_RED, "NO MATCH!"); matched_id = -1; } } } else { Serial.println("Face Not Aligned"); // rgb_print(image_matrix, FACE_COLOR_YELLOW, "Human Detected"); } dl_matrix3du_free(aligned_face); return matched_id; } // sd methods void listDir(fs::FS &fs, const char * dirname, uint8_t levels) { Serial.printf("Listing directory: %s\n", dirname); File root = fs.open(dirname); if (!root) { Serial.println("Failed to open directory"); return; } if (!root.isDirectory()) { Serial.println("Not a directory"); return; } File file = root.openNextFile(); while (file) { if (file.isDirectory()) { Serial.print(" DIR : "); Serial.println(file.name()); if (levels) { listDir(fs, file.name(), levels - 1); } } else { Serial.print(" FILE: "); Serial.print(file.name()); Serial.print(" SIZE: "); Serial.println(file.size()); } file = root.openNextFile(); } } void createDir(fs::FS &fs, const char * path) { Serial.printf("Creating Dir: %s\n", path); if (fs.mkdir(path)) { Serial.println("Dir created"); } else { Serial.println("mkdir failed"); } } void removeDir(fs::FS &fs, const char * path) { Serial.printf("Removing Dir: %s\n", path); if (fs.rmdir(path)) { Serial.println("Dir removed"); } else { Serial.println("rmdir failed"); } } void readFile(fs::FS &fs, const char * path) { Serial.printf("Reading file: %s\n", path); File file = fs.open(path); if (!file) { Serial.println("Failed to open file for reading"); return; } Serial.print("Read from file: "); while (file.available()) { Serial.write(file.read()); } } void writeFile(fs::FS &fs, const char * path, const char * message) { Serial.printf("Writing file: %s\n", path); File file = fs.open(path, FILE_WRITE); if (!file) { Serial.println("Failed to open file for writing"); return; } //fwrite(fb->buf, 1, fb->len, file); if (file.print(message)) { Serial.println("File written"); } else { Serial.println("Write failed"); } } void appendFile(fs::FS &fs, const char * path, const char * message) { Serial.printf("Appending to file: %s\n", path); File file = fs.open(path, FILE_APPEND); if (!file) { Serial.println("Failed to open file for appending"); return; } if (file.print(message)) { Serial.println("Message appended"); } else { Serial.println("Append failed"); } } void renameFile(fs::FS &fs, const char * path1, const char * path2) { Serial.printf("Renaming file %s to %s\n", path1, path2); if (fs.rename(path1, path2)) { Serial.println("File renamed"); } else { Serial.println("Rename failed"); } } void deleteFile(fs::FS &fs, const char * path) { Serial.printf("Deleting file: %s\n", path); if (fs.remove(path)) { Serial.println("File deleted"); } else { Serial.println("Delete failed"); } } void testFileIO(fs::FS &fs, const char * path) { File file = fs.open(path); static uint8_t buf[512]; size_t len = 0; uint32_t start = millis(); uint32_t end = start; if (file) { len = file.size(); size_t flen = len; start = millis(); while (len) { size_t toRead = len; if (toRead > 512) { toRead = 512; } file.read(buf, toRead); len -= toRead; } end = millis() - start; Serial.printf("%u bytes read for %u ms\n", flen, end); file.close(); } else { Serial.println("Failed to open file for reading"); } file = fs.open(path, FILE_WRITE); if (!file) { Serial.println("Failed to open file for writing"); return; } size_t i; start = millis(); for (i = 0; i < 2048; i++) { file.write(buf, 512); } end = millis() - start; Serial.printf("%u bytes written for %u ms\n", 2048 * 512, end); file.close(); } // end sd methods static size_t jpg_encode_stream(void * arg, size_t index, const void* data, size_t len) { jpg_chunking_t *j = (jpg_chunking_t *)arg; if (!index) { j->len = 0; Serial.println("jpg-encode-stream !index (with FACE recognition pass here)"); } if (httpd_resp_send_chunk(j->req, (const char *)data, len) != ESP_OK) { Serial.println("http send chunk"); return 0; } j->len += len; return len; } static esp_err_t capture_handler(httpd_req_t *req) { camera_fb_t * fb = NULL; esp_err_t res = ESP_OK; int64_t fr_start = esp_timer_get_time(); fb = esp_camera_fb_get(); // get picture from cam if (!fb) { Serial.println("Camera capture failed"); httpd_resp_send_500(req); return ESP_FAIL; } httpd_resp_set_type(req, "image/jpeg"); httpd_resp_set_hdr(req, "Content-Disposition", "inline; filename=capture.jpg"); size_t out_len, out_width, out_height; uint8_t * out_buf; bool s; bool detected = false; int face_id = 0; if (!detection_enabled || fb->width > 400) { // Serial.println("lijn493"); size_t fb_len = 0; if (fb->format == PIXFORMAT_JPEG) { Serial.println("pixs format jpg for http send"); fb_len = fb->len; //typedef struct { // httpd_req_t *req; // size_t len; // //} jpg_chunking_t; res = httpd_resp_send(req, (const char *)fb->buf, fb->len); } else { jpg_chunking_t jchunk = {req, 0}; Serial.println(jchunk.len);// res = frame2jpg_cb(fb, 80, jpg_encode_stream, &jchunk) ? ESP_OK : ESP_FAIL; Serial.println("frame2jpg"); httpd_resp_send_chunk(req, NULL, 0); fb_len = jchunk.len; } //// Here, we will examine the files Serial.print("fb length = "); Serial.println( fb->len );//jpg filesize struct tm timeinfo; if (!getLocalTime(&timeinfo)) { Serial.println("Failed to obtain time"); } char timeStringBuff[50]; //50 chars should be enough strftime(timeStringBuff, sizeof(timeStringBuff), "%B %d %Y %H-%M-%S", &timeinfo); //Optional: Construct String object String asString(timeStringBuff); String dateTimeString = timeStringBuff; String dataFileName = "/" + dateTimeString + ".jpg"; char path[dataFileName.length() + 1]; dataFileName.toCharArray(path, sizeof(path)); // const char * path = "/capture.jpg"; fs::FS &fs = SD_MMC; Serial.printf("Writing file: %s\n", path); File file = fs.open(path, FILE_WRITE); if (!file) { Serial.println("Failed to open file for SD"); } else { file.write(fb->buf , fb->len); //payload , length vd payload Serial.println("success to open file for SD"); } writeFile(SD_MMC, "/info.txt", "saved 1 jpgfile"); ///einde SD esp_camera_fb_return(fb); int64_t fr_end = esp_timer_get_time(); // Serial.println(res); // is 1 if jpg convertion worked Serial.printf("JPG: %uB %ums\n\n\n\n", (uint32_t)(fb_len), (uint32_t)((fr_end - fr_start) / 1000)); return res; } dl_matrix3du_t *image_matrix = dl_matrix3du_alloc(1, fb->width, fb->height, 3); if (!image_matrix) { esp_camera_fb_return(fb); Serial.println("dl_matrix3du_alloc failed"); httpd_resp_send_500(req); return ESP_FAIL; } out_buf = image_matrix->item; out_len = fb->width * fb->height * 3; out_width = fb->width; out_height = fb->height; s = fmt2rgb888(fb->buf, fb->len, fb->format, out_buf); esp_camera_fb_return(fb); if (!s) { dl_matrix3du_free(image_matrix); Serial.println("to rgb888 failed"); httpd_resp_send_500(req); return ESP_FAIL; } box_array_t *net_boxes = face_detect(image_matrix, &mtmn_config); if (net_boxes) { detected = true; if (recognition_enabled) { face_id = run_face_recognition(image_matrix, net_boxes); } draw_face_boxes(image_matrix, net_boxes, face_id); free(net_boxes->box); free(net_boxes->landmark); free(net_boxes); } jpg_chunking_t jchunk = {req, 0}; s = fmt2jpg_cb(out_buf, out_len, out_width, out_height, PIXFORMAT_RGB888, 90, jpg_encode_stream, &jchunk); dl_matrix3du_free(image_matrix); if (!s) { Serial.println("JPEG compression failed"); return ESP_FAIL; } int64_t fr_end = esp_timer_get_time(); Serial.printf("FACE: %uB %ums %s%d\n", (uint32_t)(jchunk.len), (uint32_t)((fr_end - fr_start) / 1000), detected ? "DETECTED " : "", face_id); return res; } static int rgb_printf(dl_matrix3du_t *image_matrix, uint32_t color, const char *format, ...) { char loc_buf[64]; char * temp = loc_buf; int len; va_list arg; va_list copy; va_start(arg, format); va_copy(copy, arg); len = vsnprintf(loc_buf, sizeof(loc_buf), format, arg); va_end(copy); if (len >= sizeof(loc_buf)) { temp = (char*)malloc(len + 1); if (temp == NULL) { return 0; } } vsnprintf(temp, len + 1, format, arg); va_end(arg); rgb_print(image_matrix, color, temp); if (len > 64) { free(temp); } return len; } static ra_filter_t * ra_filter_init(ra_filter_t * filter, size_t sample_size) { memset(filter, 0, sizeof(ra_filter_t)); filter->values = (int *)malloc(sample_size * sizeof(int)); if (!filter->values) { return NULL; } memset(filter->values, 0, sample_size * sizeof(int)); filter->size = sample_size; return filter; } static int ra_filter_run(ra_filter_t * filter, int value) { if (!filter->values) { return value; } filter->sum -= filter->values[filter->index]; filter->values[filter->index] = value; filter->sum += filter->values[filter->index]; filter->index++; filter->index = filter->index % filter->size; if (filter->count < filter->size) { filter->count++; } return filter->sum / filter->count; } static void draw_face_boxes(dl_matrix3du_t *image_matrix, box_array_t *boxes, int face_id) { int x, y, w, h, i; uint32_t color = FACE_COLOR_YELLOW; if (face_id < 0) { color = FACE_COLOR_RED; } else if (face_id > 0) { color = FACE_COLOR_GREEN; } fb_data_t fb; fb.width = image_matrix->w; fb.height = image_matrix->h; fb.data = image_matrix->item; fb.bytes_per_pixel = 3; fb.format = FB_BGR888; for (i = 0; i < boxes->len; i++) { // rectangle box x = (int)boxes->box[i].box_p[0]; y = (int)boxes->box[i].box_p[1]; w = (int)boxes->box[i].box_p[2] - x + 1; h = (int)boxes->box[i].box_p[3] - y + 1; fb_gfx_drawFastHLine(&fb, x, y, w, color); fb_gfx_drawFastHLine(&fb, x, y + h - 1, w, color); fb_gfx_drawFastVLine(&fb, x, y, h, color); fb_gfx_drawFastVLine(&fb, x + w - 1, y, h, color); #if 0 // landmark int x0, y0, j; for (j = 0; j < 10; j += 2) { x0 = (int)boxes->landmark[i].landmark_p[j]; y0 = (int)boxes->landmark[i].landmark_p[j + 1]; fb_gfx_fillRect(&fb, x0, y0, 3, 3, color); } #endif } } static void rgb_print(dl_matrix3du_t *image_matrix, uint32_t color, const char * str) { fb_data_t fb; fb.width = image_matrix->w; fb.height = image_matrix->h; fb.data = image_matrix->item; fb.bytes_per_pixel = 3; fb.format = FB_BGR888; fb_gfx_print(&fb, (fb.width - (strlen(str) * 14)) / 2, 10, color, str); } static esp_err_t stream_handler(httpd_req_t *req) { camera_fb_t * fb = NULL; esp_err_t res = ESP_OK; size_t _jpg_buf_len = 0; uint8_t * _jpg_buf = NULL; char * part_buf[64]; dl_matrix3du_t *image_matrix = NULL; bool detected = false; int face_id = 0; int64_t fr_start = 0; int64_t fr_ready = 0; int64_t fr_face = 0; int64_t fr_recognize = 0; int64_t fr_encode = 0; static int64_t last_frame = 0; if (!last_frame) { last_frame = esp_timer_get_time(); } res = httpd_resp_set_type(req, _STREAM_CONTENT_TYPE); if (res != ESP_OK) { return res; } while (true) { detected = false; face_id = 0; fb = esp_camera_fb_get(); if (!fb) { Serial.println("Camera capture failed"); res = ESP_FAIL; } else { fr_start = esp_timer_get_time(); fr_ready = fr_start; fr_face = fr_start; fr_encode = fr_start; fr_recognize = fr_start; if (!detection_enabled || fb->width > 400) { if (fb->format != PIXFORMAT_JPEG) { bool jpeg_converted = frame2jpg(fb, 80, &_jpg_buf, &_jpg_buf_len); esp_camera_fb_return(fb); fb = NULL; if (!jpeg_converted) { Serial.println("JPEG compression failed"); res = ESP_FAIL; } } else { _jpg_buf_len = fb->len; _jpg_buf = fb->buf; } } else { image_matrix = dl_matrix3du_alloc(1, fb->width, fb->height, 3); if (!image_matrix) { Serial.println("dl_matrix3du_alloc failed"); res = ESP_FAIL; } else { if (!fmt2rgb888(fb->buf, fb->len, fb->format, image_matrix->item)) { Serial.println("fmt2rgb888 failed"); res = ESP_FAIL; } else { fr_ready = esp_timer_get_time(); box_array_t *net_boxes = NULL; if (detection_enabled) { net_boxes = face_detect(image_matrix, &mtmn_config); } fr_face = esp_timer_get_time(); fr_recognize = fr_face; if (net_boxes || fb->format != PIXFORMAT_JPEG) { if (net_boxes) { detected = true; if (recognition_enabled) { face_id = run_face_recognition(image_matrix, net_boxes); } fr_recognize = esp_timer_get_time(); draw_face_boxes(image_matrix, net_boxes, face_id); free(net_boxes->box); free(net_boxes->landmark); free(net_boxes); } if (!fmt2jpg(image_matrix->item, fb->width * fb->height * 3, fb->width, fb->height, PIXFORMAT_RGB888, 90, &_jpg_buf, &_jpg_buf_len)) { Serial.println("fmt2jpg failed"); res = ESP_FAIL; } esp_camera_fb_return(fb); fb = NULL; } else { _jpg_buf = fb->buf; _jpg_buf_len = fb->len; } fr_encode = esp_timer_get_time(); } dl_matrix3du_free(image_matrix); } } } if (res == ESP_OK) { size_t hlen = snprintf((char *)part_buf, 64, _STREAM_PART, _jpg_buf_len); res = httpd_resp_send_chunk(req, (const char *)part_buf, hlen); } if (res == ESP_OK) { res = httpd_resp_send_chunk(req, (const char *)_jpg_buf, _jpg_buf_len); } if (res == ESP_OK) { res = httpd_resp_send_chunk(req, _STREAM_BOUNDARY, strlen(_STREAM_BOUNDARY)); } if (fb) { esp_camera_fb_return(fb); fb = NULL; _jpg_buf = NULL; } else if (_jpg_buf) { free(_jpg_buf); _jpg_buf = NULL; } if (res != ESP_OK) { break; } int64_t fr_end = esp_timer_get_time(); int64_t ready_time = (fr_ready - fr_start) / 1000; int64_t face_time = (fr_face - fr_ready) / 1000; int64_t recognize_time = (fr_recognize - fr_face) / 1000; int64_t encode_time = (fr_encode - fr_recognize) / 1000; int64_t process_time = (fr_encode - fr_start) / 1000; int64_t frame_time = fr_end - last_frame; last_frame = fr_end; frame_time /= 1000; uint32_t avg_frame_time = ra_filter_run(&ra_filter, frame_time); Serial.printf("MJPG: %uB %ums (%.1ffps), AVG: %ums (%.1ffps), %u+%u+%u+%u=%u %s%d\n", (uint32_t)(_jpg_buf_len), (uint32_t)frame_time, 1000.0 / (uint32_t)frame_time, avg_frame_time, 1000.0 / avg_frame_time, (uint32_t)ready_time, (uint32_t)face_time, (uint32_t)recognize_time, (uint32_t)encode_time, (uint32_t)process_time, (detected) ? "DETECTED " : "", face_id ); } last_frame = 0; return res; } static esp_err_t cmd_handler(httpd_req_t *req) { char* buf; size_t buf_len; char variable[32] = {0,}; char value[32] = {0,}; buf_len = httpd_req_get_url_query_len(req) + 1; if (buf_len > 1) { buf = (char*)malloc(buf_len); if (!buf) { httpd_resp_send_500(req); return ESP_FAIL; } if (httpd_req_get_url_query_str(req, buf, buf_len) == ESP_OK) { if (httpd_query_key_value(buf, "var", variable, sizeof(variable)) == ESP_OK && httpd_query_key_value(buf, "val", value, sizeof(value)) == ESP_OK) { } else { free(buf); httpd_resp_send_404(req); return ESP_FAIL; } } else { free(buf); httpd_resp_send_404(req); return ESP_FAIL; } free(buf); } else { httpd_resp_send_404(req); return ESP_FAIL; } int val = atoi(value); sensor_t * s = esp_camera_sensor_get(); int res = 0; if (!strcmp(variable, "framesize")) { if (s->pixformat == PIXFORMAT_JPEG) res = s->set_framesize(s, (framesize_t)val); } else if (!strcmp(variable, "quality")) res = s->set_quality(s, val); else if (!strcmp(variable, "contrast")) res = s->set_contrast(s, val); else if (!strcmp(variable, "brightness")) res = s->set_brightness(s, val); else if (!strcmp(variable, "saturation")) res = s->set_saturation(s, val); else if (!strcmp(variable, "gainceiling")) res = s->set_gainceiling(s, (gainceiling_t)val); else if (!strcmp(variable, "colorbar")) res = s->set_colorbar(s, val); else if (!strcmp(variable, "awb")) res = s->set_whitebal(s, val); else if (!strcmp(variable, "agc")) res = s->set_gain_ctrl(s, val); else if (!strcmp(variable, "aec")) res = s->set_exposure_ctrl(s, val); else if (!strcmp(variable, "hmirror")) res = s->set_hmirror(s, val); else if (!strcmp(variable, "vflip")) res = s->set_vflip(s, val); else if (!strcmp(variable, "awb_gain")) res = s->set_awb_gain(s, val); else if (!strcmp(variable, "agc_gain")) res = s->set_agc_gain(s, val); else if (!strcmp(variable, "aec_value")) res = s->set_aec_value(s, val); else if (!strcmp(variable, "aec2")) res = s->set_aec2(s, val); else if (!strcmp(variable, "dcw")) res = s->set_dcw(s, val); else if (!strcmp(variable, "bpc")) res = s->set_bpc(s, val); else if (!strcmp(variable, "wpc")) res = s->set_wpc(s, val); else if (!strcmp(variable, "raw_gma")) res = s->set_raw_gma(s, val); else if (!strcmp(variable, "lenc")) res = s->set_lenc(s, val); else if (!strcmp(variable, "special_effect")) res = s->set_special_effect(s, val); else if (!strcmp(variable, "wb_mode")) res = s->set_wb_mode(s, val); else if (!strcmp(variable, "ae_level")) res = s->set_ae_level(s, val); else if (!strcmp(variable, "face_detect")) { detection_enabled = val; if (!detection_enabled) { recognition_enabled = 0; } } else if (!strcmp(variable, "face_enroll")) is_enrolling = val; else if (!strcmp(variable, "face_recognize")) { recognition_enabled = val; if (recognition_enabled) { detection_enabled = val; } } else { res = -1; } if (res) { return httpd_resp_send_500(req); } httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*"); return httpd_resp_send(req, NULL, 0); } static esp_err_t status_handler(httpd_req_t *req) { static char json_response[1024]; sensor_t * s = esp_camera_sensor_get(); char * p = json_response; *p++ = '{'; p += sprintf(p, "\"framesize\":%u,", s->status.framesize); p += sprintf(p, "\"quality\":%u,", s->status.quality); p += sprintf(p, "\"brightness\":%d,", s->status.brightness); p += sprintf(p, "\"contrast\":%d,", s->status.contrast); p += sprintf(p, "\"saturation\":%d,", s->status.saturation); p += sprintf(p, "\"special_effect\":%u,", s->status.special_effect); p += sprintf(p, "\"wb_mode\":%u,", s->status.wb_mode); p += sprintf(p, "\"awb\":%u,", s->status.awb); p += sprintf(p, "\"awb_gain\":%u,", s->status.awb_gain); p += sprintf(p, "\"aec\":%u,", s->status.aec); p += sprintf(p, "\"aec2\":%u,", s->status.aec2); p += sprintf(p, "\"ae_level\":%d,", s->status.ae_level); p += sprintf(p, "\"aec_value\":%u,", s->status.aec_value); p += sprintf(p, "\"agc\":%u,", s->status.agc); p += sprintf(p, "\"agc_gain\":%u,", s->status.agc_gain); p += sprintf(p, "\"gainceiling\":%u,", s->status.gainceiling); p += sprintf(p, "\"bpc\":%u,", s->status.bpc); p += sprintf(p, "\"wpc\":%u,", s->status.wpc); p += sprintf(p, "\"raw_gma\":%u,", s->status.raw_gma); p += sprintf(p, "\"lenc\":%u,", s->status.lenc); p += sprintf(p, "\"vflip\":%u,", s->status.vflip); p += sprintf(p, "\"hmirror\":%u,", s->status.hmirror); p += sprintf(p, "\"dcw\":%u,", s->status.dcw); p += sprintf(p, "\"colorbar\":%u,", s->status.colorbar); p += sprintf(p, "\"face_detect\":%u,", detection_enabled); p += sprintf(p, "\"face_enroll\":%u,", is_enrolling); p += sprintf(p, "\"face_recognize\":%u", recognition_enabled); *p++ = '}'; *p++ = 0; httpd_resp_set_type(req, "application/json"); httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*"); return httpd_resp_send(req, json_response, strlen(json_response)); } static const char PROGMEM INDEX2_HTML[] = R"rawliteral( Arduino Tron WebCam Arduino Tron IoT BPM
)rawliteral"; static esp_err_t index_handler(httpd_req_t *req){ httpd_resp_set_type(req, "text/html"); Serial.printf("webpage loading \n"); return httpd_resp_send(req, (const char *)INDEX2_HTML, strlen(INDEX2_HTML)); } void printLocalTime() { //internet time server struct tm timeinfo; if (!getLocalTime(&timeinfo)) { Serial.println("Failed to obtain time"); return; } Serial.print(&timeinfo, "%A, %B %d %Y %H:%M:%S"); } #if defined(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 #else #error "Camera model not selected" #endif void startCameraServer(); void printDebug(String data) { Serial.print(""); Serial.print(data); Serial.print("\r\n"); } #define FORMAT_SPIFFS_IF_FAILED true #define FACE_ID_PATH "/faceid.dat" bool faceIDInitFlash() { if(!SPIFFS.begin(FORMAT_SPIFFS_IF_FAILED)){ printDebug("SPIFFS Mount Failed"); return false; } return true; } bool readFaceIDFromFlash(face_id_list *l) { File file = SPIFFS.open(FACE_ID_PATH); if(!file || file.isDirectory()){ printDebug("failed to open file for reading"); return false; } l->head = file.read(); l->tail = file.read(); l->count = file.read(); l->size = file.read(); l->confirm_times = file.read(); dl_matrix3d_t **list = l->id_list; const int block_len = FACE_ID_SIZE * sizeof(float); for(uint8_t i =0;icount;i++) { list[i] = dl_matrix3d_alloc(1, 1, 1, FACE_ID_SIZE); file.read((uint8_t*)list[i]->item,block_len); } file.close(); return true; } bool writeFaceIDToFlash(face_id_list *l) { File file = SPIFFS.open(FACE_ID_PATH,FILE_WRITE); if(!file || file.isDirectory()){ printDebug("failed to open file for reading"); return false; } file.write(l->head); file.write(l->tail); file.write(l->count); file.write(l->size); file.write(l->confirm_times); const int block_len = FACE_ID_SIZE * sizeof(float); for(uint8_t i =0;icount;i++) { file.write((uint8_t*)l->id_list[i]->item,block_len); } file.close(); return true; } bool deleteFaceIDinFlash() { if(SPIFFS.remove(FACE_ID_PATH)){ printDebug("file deleted"); return true; } else { printDebug("delete failed"); } return false; } /*void callback(char* topic, byte* message, unsigned int length) { String messageTemp; for (int i = 0; i < length; i++) { messageTemp += (char)message[i]; } if (String(topic) == "espCam/delete_face"){ if(messageTemp=="YES"){ deleteFaceIDinFlash(); } } }*/ void setup() { WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0); // disable brownout detector // Arduino IDE Serial Monitor window to emulate what Arduino Tron sensors are reading Serial.begin(115200); // Serial connection from ESP-01 via 3.3v console cable Serial.setDebugOutput(true); Serial.println(); // Connect to WiFi network Serial.println("Executive Order Corporation - Arduino Tron ESP8266 MQTT Telemetry Transport Machine-to-Machine(M2M)/Internet of Things(IoT)"); Serial.println("Arduino Tron Drools-jBPM :: Executive Order Arduino Tron Sensor Processor MQTT AI-IoTBPM Client using AI-IoTBPM Drools-jBPM"); Serial.println("- Arduino Tron WebCam ver " + ver); Serial.println("Copyright © 1978, 2019: Executive Order Corporation, All Rights Reserved"); Serial.println(); Serial.print("Connecting to "); Serial.println(ssid); 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; // Format of the pixel data: PIXFORMAT_ + YUV422|GRAYSCALE|RGB565|JPEG we have psram config.frame_size = FRAMESIZE_QVGA; // FRAMESIZE_ + QVGA|CIF|VGA|SVGA|XGA|SXGA|UXGA config.jpeg_quality = 10; config.fb_count = 2; // 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; } // Wait for connection WiFi.begin(ssid, password); byte wifi_conn=0; while (WiFi.status() != WL_CONNECTED) { delay(200); Serial.print("."); wifi_conn++; if(wifi_conn>10){ client.publish("espCam/info","RE-STARTING"); ESP.restart(); } } Serial.println(""); Serial.println("WiFi connected"); Serial.println(); client.setServer(mqtt_server, 1883); client.connect("ESPCAM"); //client.setCallback(callback); client.publish("espCam/info","STARTED"); //client.subscribe("espCam/delete_face"); // init and get the internet-time configTime(gmtOffset_sec, daylightOffset_sec, ntpServer); printLocalTime(); // internet time server Serial.println(); // SD card init if(!SD_MMC.begin()){ Serial.println("Card Mount Failed"); return; } uint8_t cardType = SD_MMC.cardType(); if(cardType == CARD_NONE){ Serial.println("No SD_MMC card attached"); return; } Serial.print("SD_MMC Card Type: "); if(cardType == CARD_MMC){ Serial.println("MMC"); } else if(cardType == CARD_SD){ Serial.println("SDSC"); } else if(cardType == CARD_SDHC){ Serial.println("SDHC"); } else { Serial.println("UNKNOWN"); } uint64_t cardSize = SD_MMC.cardSize() / (1024 * 1024); Serial.printf("SD_MMC Card Size: %lluMB\n", cardSize); Serial.printf("Total space: %lluMB\n", SD_MMC.totalBytes() / (1024 * 1024)); Serial.printf("Used space: %lluMB\n", SD_MMC.usedBytes() / (1024 * 1024)); Serial.println(); startCameraServer(); // start camera webserver detection_enabled=1; recognition_enabled=1; is_enrolling=0; Serial.print("Camera Ready - Use 'http://"); Serial.print(WiFi.localIP()); Serial.println("' to connect, the live stream is on a different port channel 9601"); Serial.print("Stream Ready - Use 'http://"); Serial.print(WiFi.localIP()); Serial.println(":9601/stream'"); Serial.print(" Image Ready - Use 'http://"); Serial.print(WiFi.localIP()); Serial.println("/capture'"); } void recon(){ while (!client.connected()) { // Attempt to connect if(client.connect("MAIN-ESP")){ //client.publish("espCam/info","RE-CONNECTED"); }else{ delay(1000); } } } void loop() { if (!client.connected()) { recon(); } if(yes_id==1){ Serial.println("AUTHORIZED SENDING_________________________________________________________________________________________________________"); client.publish("espCam/face","Authorised"); client.publish("espCam/id", face_id.c_str()); yes_id=0; delay(3500); client.publish("espCam/face","WAITING"); client.publish("espCam/info","WORKING"); }else if(yes_id==2){ Serial.println("UN-AUTHORIZED SENDING______________________________________________________________________________________________________"); client.publish("espCam/face","UN-Auth!"); yes_id=0; client.publish("espCam/face","WAITING"); client.publish("espCam/info","WORKING"); }else if(yes_id==3){ int samples=left_sample_face; String sample_finale=String(samples); client.publish("espCam/info",sample_finale.c_str()); }else if(yes_id==4){ Serial.println("SAVING ID-----------------------------------------------------------------------------------------------------------------"); writeFaceIDToFlash(&id_list); } } void startCameraServer() { httpd_config_t config = HTTPD_DEFAULT_CONFIG(); config.server_port = 80; // overwrite httpd_uri_t index_uri = { .uri = "/", .method = HTTP_GET, .handler = index_handler, .user_ctx = NULL }; httpd_uri_t status_uri = { .uri = "/status", .method = HTTP_GET, .handler = status_handler, .user_ctx = NULL }; httpd_uri_t cmd_uri = { .uri = "/control", .method = HTTP_GET, .handler = cmd_handler, .user_ctx = NULL }; httpd_uri_t capture_uri = { .uri = "/capture", .method = HTTP_GET, .handler = capture_handler, .user_ctx = NULL }; httpd_uri_t stream_uri = { .uri = "/stream", .method = HTTP_GET, .handler = stream_handler, .user_ctx = NULL }; ra_filter_init(&ra_filter, 20); mtmn_config.min_face = 80; mtmn_config.pyramid = 0.7; mtmn_config.p_threshold.score = 0.6; mtmn_config.p_threshold.nms = 0.7; mtmn_config.r_threshold.score = 0.7; mtmn_config.r_threshold.nms = 0.7; mtmn_config.r_threshold.candidate_number = 4; mtmn_config.o_threshold.score = 0.7; mtmn_config.o_threshold.nms = 0.4; mtmn_config.o_threshold.candidate_number = 1; face_id_init(&id_list, FACE_ID_SAVE_NUMBER, ENROLL_CONFIRM_TIMES); if (faceIDInitFlash()){ //cam.deleteFaceIDinFlash(); //Delete face id list if (!readFaceIDFromFlash(&id_list)){ printDebug("Load face id list fail"); } else{ printDebug("Load face id list succes"); } }else{ printDebug("SPIFFS Fail"); } Serial.printf("Starting web server on port: '%d'\n", config.server_port); if (httpd_start(&camera_httpd, &config) == ESP_OK) { httpd_register_uri_handler(camera_httpd, &index_uri); httpd_register_uri_handler(camera_httpd, &cmd_uri); httpd_register_uri_handler(camera_httpd, &status_uri); httpd_register_uri_handler(camera_httpd, &capture_uri); } config.server_port = 9601; // server port config.ctrl_port = 9601; Serial.printf("Starting stream server on port: '%d'\n", config.server_port); if (httpd_start(&stream_httpd, &config) == ESP_OK) { httpd_register_uri_handler(stream_httpd, &stream_uri); } }