compatibitly mit esp-idf pure

code/components/jomjol_tfliteclass/CMakeLists.txt

@@ -0,0 +1,7 @@
+FILE(GLOB_RECURSE app_sources ${CMAKE_CURRENT_SOURCE_DIR}/*.*)
+
+idf_component_register(SRCS ${app_sources}
+                    INCLUDE_DIRS "."
+                    REQUIRES jomjol_image_proc jomjol_logfile esp_http_server esp32-camera-master jomjol_controlcamera jomjol_flowcontroll)
+
+

code/components/jomjol_tfliteclass/CTfLiteClass._cpp_old

@@ -0,0 +1,254 @@
+#include "CTfLiteClass.h"
+
+#include "bitmap_image.hpp"
+
+#include <sys/stat.h>
+
+float CTfLiteClass::GetOutputValue(int nr)
+{
+    TfLiteTensor* output2 = this->interpreter->output(0);
+
+    int numeroutput = output2->dims->data[1];
+    if ((nr+1) > numeroutput)
+      return -1000;
+
+    return output2->data.f[nr];
+}
+
+
+int CTfLiteClass::GetClassFromImage(std::string _fn)
+{
+//  printf("Before Load image %s\n", _fn.c_str());
+    if (!LoadInputImage(_fn))
+      return -1000;
+//  printf("After Load image %s\n", _fn.c_str());
+
+    Invoke();
+  printf("After Invoke %s\n", _fn.c_str());
+
+    return GetOutClassification();
+//    return 0;
+}
+
+int CTfLiteClass::GetOutClassification()
+{
+  TfLiteTensor* output2 = interpreter->output(0);
+
+  float zw_max = 0;
+  float zw;
+  int zw_class = -1;
+
+  if (output2 == NULL)
+    return -1;
+
+  int numeroutput = output2->dims->data[1];
+  for (int i = 0; i < numeroutput; ++i)
+  {
+    zw = output2->data.f[i];
+    if (zw > zw_max)
+    {
+        zw_max = zw;
+        zw_class = i;
+    }
+  }
+//  printf("Result Ziffer: %d\n", zw_class);       
+  return zw_class;
+}
+
+void CTfLiteClass::GetInputDimension(bool silent = false)
+{
+  TfLiteTensor* input2 = this->interpreter->input(0);
+
+  int numdim = input2->dims->size;
+  if (!silent)  printf("NumDimension: %d\n", numdim);  
+
+  int sizeofdim;
+  for (int j = 0; j < numdim; ++j)
+  {
+    sizeofdim = input2->dims->data[j];
+    if (!silent) printf("SizeOfDimension %d: %d\n", j, sizeofdim);  
+    if (j == 1) im_height = sizeofdim;
+    if (j == 2) im_width = sizeofdim;
+    if (j == 3) im_channel = sizeofdim;
+  }
+}
+
+
+void CTfLiteClass::GetOutPut()
+{
+  TfLiteTensor* output2 = this->interpreter->output(0);
+
+  int numdim = output2->dims->size;
+  printf("NumDimension: %d\n", numdim);  
+
+  int sizeofdim;
+  for (int j = 0; j < numdim; ++j)
+  {
+    sizeofdim = output2->dims->data[j];
+    printf("SizeOfDimension %d: %d\n", j, sizeofdim);  
+  }
+
+
+  float fo;
+
+  // Process the inference results.
+  int numeroutput = output2->dims->data[1];
+  for (int i = 0; i < numeroutput; ++i)
+  {
+   fo = output2->data.f[i];
+    printf("Result %d: %f\n", i, fo);  
+  }
+}
+
+void CTfLiteClass::Invoke()
+{
+    interpreter->Invoke();
+//    printf("Invoke Done.\n");
+}
+
+
+bool CTfLiteClass::LoadInputImage(std::string _fn)
+{
+    bitmap_image image(_fn);
+    unsigned int w = image.width();
+    unsigned int h = image.height();
+    unsigned char red, green, blue;
+
+    input_i = 0;
+    float* input_data_ptr = (interpreter->input(0))->data.f;
+
+    for (int y = 0; y < h; ++y)
+        for (int x = 0; x < w; ++x)
+            {
+                red = image.red_channel(x, y);
+                green = image.green_channel(x, y);
+                blue = image.blue_channel(x, y);
+                *(input_data_ptr) = (float) red;
+                input_data_ptr++;
+                *(input_data_ptr) = (float) green;
+                input_data_ptr++;
+                *(input_data_ptr) = (float) blue;
+                input_data_ptr++;
+
+//                printf("BMP: %f %f %f\n", (float) red, (float) green, (float) blue);
+
+            }
+    return true;
+}
+
+
+void CTfLiteClass::MakeAllocate()
+{
+/*    
+  this->micro_op_resolver.AddBuiltin(
+                                tflite::BuiltinOperator_RESHAPE,
+                                tflite::ops::micro::Register_RESHAPE());
+  this->micro_op_resolver.AddBuiltin(tflite::BuiltinOperator_CONV_2D,
+                               tflite::ops::micro::Register_CONV_2D());
+  this->micro_op_resolver.AddBuiltin(tflite::BuiltinOperator_FULLY_CONNECTED,
+                               tflite::ops::micro::Register_FULLY_CONNECTED());
+  this->micro_op_resolver.AddBuiltin(tflite::BuiltinOperator_SOFTMAX,
+                               tflite::ops::micro::Register_SOFTMAX());
+  this->micro_op_resolver.AddBuiltin(tflite::BuiltinOperator_DEPTHWISE_CONV_2D,
+                               tflite::ops::micro::Register_DEPTHWISE_CONV_2D());
+
+
+    this->interpreter = new tflite::MicroInterpreter(this->model, this->micro_op_resolver, this->tensor_arena, this->kTensorArenaSize, this->error_reporter);
+*/
+
+
+    static tflite::ops::micro::AllOpsResolver resolver;
+    this->interpreter = new tflite::MicroInterpreter(this->model, resolver, this->tensor_arena, this->kTensorArenaSize, this->error_reporter);
+
+    TfLiteStatus allocate_status = this->interpreter->AllocateTensors();
+    if (allocate_status != kTfLiteOk) {
+        TF_LITE_REPORT_ERROR(error_reporter, "AllocateTensors() failed");
+    this->GetInputDimension();   
+    return;
+  }
+
+    printf("Allocate Done.\n");
+}
+
+void CTfLiteClass::GetInputTensorSize(){
+    float *zw = this->input;
+    int test = sizeof(zw);
+    printf("Input Tensor Dimension: %d\n", test);       
+
+    printf("Input Tensor Dimension: %d\n", test);   
+}
+
+long CTfLiteClass::GetFileSize(std::string filename)
+{
+    struct stat stat_buf;
+    long rc = stat(filename.c_str(), &stat_buf);
+    return rc == 0 ? stat_buf.st_size : -1;
+}
+
+
+unsigned char* CTfLiteClass::ReadFileToCharArray(std::string _fn)
+{
+    long size;
+    
+    size = this->GetFileSize(_fn);
+
+    if (size == -1)
+    {
+		printf("\nFile existiert nicht.\n");
+        return NULL;
+    }
+
+
+    unsigned char *result = (unsigned char*) malloc(size);
+  
+	if(result != NULL) {
+//		printf("\nSpeicher ist reserviert\n");
+        FILE* f = fopen(_fn.c_str(), "rb");     // vorher  nur "r"
+        fread(result, 1, size, f);
+        fclose(f);        
+	}else {
+		printf("\nKein freier Speicher vorhanden.\n");
+	}    
+
+
+    return result;
+}
+
+void CTfLiteClass::LoadModel(std::string _fn){
+
+
+    this->error_reporter = new tflite::MicroErrorReporter;
+
+    unsigned char *rd;
+    rd = this->ReadFileToCharArray(_fn.c_str());
+//    printf("loadedfile: %d", (int) rd);
+
+    this->model = tflite::GetModel(rd);
+    free(rd);
+    TFLITE_MINIMAL_CHECK(model != nullptr); 
+    printf("tfile Loaded.\n");  
+
+}
+
+
+
+CTfLiteClass::CTfLiteClass()
+{
+//    this->accessSD = _accessSD;
+    this->model = nullptr;
+    this->interpreter = nullptr;
+    this->input = nullptr;
+    this->output = nullptr;  
+    this->kTensorArenaSize = 600 * 1024;
+    this->tensor_arena = new uint8_t[kTensorArenaSize];    
+
+//      micro_op_resolver.AddBuiltin(tflite::BuiltinOperator_CONV_2D,
+//                               tflite::ops::micro::Register_CONV_2D());
+}
+
+CTfLiteClass::~CTfLiteClass()
+{
+  delete this->tensor_arena;
+}        
+
+

code/components/jomjol_tfliteclass/CTfLiteClass._h_old

@@ -0,0 +1,72 @@
+#pragma once
+
+#ifndef __CFINDTEMPLATE
+#define __CFINGTEMPLATE
+
+#define TFLITE_MINIMAL_CHECK(x)                              \
+  if (!(x)) {                                                \
+    fprintf(stderr, "Error at %s:%d\n", __FILE__, __LINE__); \
+    exit(1);                                                 \
+  }
+
+//#include "CAccessSD.h"
+#include "CFindTemplate.h"
+
+#include "tensorflow/lite/micro/kernels/all_ops_resolver.h"
+#include "tensorflow/lite/micro/micro_error_reporter.h"
+#include "tensorflow/lite/micro/micro_interpreter.h"
+#include "tensorflow/lite/schema/schema_generated.h"
+#include "tensorflow/lite/version.h"
+#include "tensorflow/lite/micro/kernels/micro_ops.h"
+#include "esp_err.h"
+#include "esp_log.h"
+
+//extern CAccessSDClass accessSD;
+
+class CTfLiteClass
+{
+    protected:
+//        CAccessSDClass *accessSD;
+
+        tflite::ErrorReporter* error_reporter;
+        
+        const tflite::Model* model;
+        tflite::MicroInterpreter* interpreter;
+//        TfLiteTensor* input = nullptr;
+        TfLiteTensor* output = nullptr;     
+        static tflite::ops::micro::AllOpsResolver *resolver; 
+
+        tflite::MicroOpResolver<5> micro_op_resolver;
+  
+
+        int kTensorArenaSize;
+        uint8_t *tensor_arena;
+
+        float* input;
+        int input_i;
+
+        int im_height, im_width, im_channel;
+
+        long GetFileSize(std::string filename);
+        unsigned char* ReadFileToCharArray(std::string _fn);
+        
+    public:
+//        CTfLiteClass(CAccessSDClass *_accessSD);
+        CTfLiteClass();
+        ~CTfLiteClass();        
+        void LoadModel(std::string _fn);
+        void MakeAllocate();
+        void GetInputTensorSize();
+        bool LoadInputImage(std::string _fn);
+        void Invoke();
+        void GetOutPut();
+        int GetOutClassification();
+        int GetClassFromImage(std::string _fn);
+
+        float GetOutputValue(int nr);
+        void GetInputDimension(bool silent);
+
+};
+
+
+#endif

code/components/jomjol_tfliteclass/CTfLiteClass.cpp

@@ -0,0 +1,260 @@
+#include "CTfLiteClass.h"
+
+#include "bitmap_image.hpp"
+
+#include "ClassLogFile.h"
+
+#include <sys/stat.h>
+
+bool debugdetailtflite = false;
+
+float CTfLiteClass::GetOutputValue(int nr)
+{
+    TfLiteTensor* output2 = this->interpreter->output(0);
+
+    int numeroutput = output2->dims->data[1];
+    if ((nr+1) > numeroutput)
+      return -1000;
+
+    return output2->data.f[nr];
+}
+
+
+int CTfLiteClass::GetClassFromImage(std::string _fn)
+{
+//  printf("Before Load image %s\n", _fn.c_str());
+    if (!LoadInputImage(_fn))
+      return -1000;
+//  printf("After Load image %s\n", _fn.c_str());
+
+    Invoke();
+  printf("After Invoke %s\n", _fn.c_str());
+
+    return GetOutClassification();
+//    return 0;
+}
+
+int CTfLiteClass::GetOutClassification()
+{
+  TfLiteTensor* output2 = interpreter->output(0);
+
+  float zw_max = 0;
+  float zw;
+  int zw_class = -1;
+
+  if (output2 == NULL)
+    return -1;
+
+  int numeroutput = output2->dims->data[1];
+  for (int i = 0; i < numeroutput; ++i)
+  {
+    zw = output2->data.f[i];
+    if (zw > zw_max)
+    {
+        zw_max = zw;
+        zw_class = i;
+    }
+  }
+//  printf("Result Ziffer: %d\n", zw_class);       
+  return zw_class;
+}
+
+void CTfLiteClass::GetInputDimension(bool silent = false)
+{
+  TfLiteTensor* input2 = this->interpreter->input(0);
+
+  int numdim = input2->dims->size;
+  if (!silent)  printf("NumDimension: %d\n", numdim);  
+
+  int sizeofdim;
+  for (int j = 0; j < numdim; ++j)
+  {
+    sizeofdim = input2->dims->data[j];
+    if (!silent) printf("SizeOfDimension %d: %d\n", j, sizeofdim);  
+    if (j == 1) im_height = sizeofdim;
+    if (j == 2) im_width = sizeofdim;
+    if (j == 3) im_channel = sizeofdim;
+  }
+}
+
+
+void CTfLiteClass::GetOutPut()
+{
+  TfLiteTensor* output2 = this->interpreter->output(0);
+
+  int numdim = output2->dims->size;
+  printf("NumDimension: %d\n", numdim);  
+
+  int sizeofdim;
+  for (int j = 0; j < numdim; ++j)
+  {
+    sizeofdim = output2->dims->data[j];
+    printf("SizeOfDimension %d: %d\n", j, sizeofdim);  
+  }
+
+
+  float fo;
+
+  // Process the inference results.
+  int numeroutput = output2->dims->data[1];
+  for (int i = 0; i < numeroutput; ++i)
+  {
+   fo = output2->data.f[i];
+    printf("Result %d: %f\n", i, fo);  
+  }
+}
+
+void CTfLiteClass::Invoke()
+{
+    interpreter->Invoke();
+//    printf("Invoke Done.\n");
+}
+
+
+bool CTfLiteClass::LoadInputImage(std::string _fn)
+{
+    std::string zw = "ClassFlowAnalog::doNeuralNetwork nach Load Image: " + _fn;
+//    LogFile.WriteToFile(zw);
+    bitmap_image image(_fn);
+    if (debugdetailtflite) LogFile.WriteToFile(zw);
+
+    unsigned int w = image.width();
+    unsigned int h = image.height();
+    unsigned char red, green, blue;
+
+//    printf("Image: %s size: %d x %d\n", _fn.c_str(), w, h);
+
+    input_i = 0;
+    float* input_data_ptr = (interpreter->input(0))->data.f;
+
+    for (int y = 0; y < h; ++y)
+        for (int x = 0; x < w; ++x)
+            {
+                red = image.red_channel(x, y);
+                green = image.green_channel(x, y);
+                blue = image.blue_channel(x, y);
+                *(input_data_ptr) = (float) red;
+                input_data_ptr++;
+                *(input_data_ptr) = (float) green;
+                input_data_ptr++;
+                *(input_data_ptr) = (float) blue;
+                input_data_ptr++;
+
+//                printf("BMP: %f %f %f\n", (float) red, (float) green, (float) blue);
+
+            }
+    
+    if (debugdetailtflite) LogFile.WriteToFile("Nach dem Laden in input");
+
+    return true;
+}
+
+
+void CTfLiteClass::MakeAllocate()
+{
+//    static tflite::ops::micro::AllOpsResolver resolver;
+    static tflite::AllOpsResolver resolver;
+    this->interpreter = new tflite::MicroInterpreter(this->model, resolver, this->tensor_arena, this->kTensorArenaSize, this->error_reporter);
+
+    TfLiteStatus allocate_status = this->interpreter->AllocateTensors();
+    if (allocate_status != kTfLiteOk) {
+        TF_LITE_REPORT_ERROR(error_reporter, "AllocateTensors() failed");
+    this->GetInputDimension();   
+    return;
+  }
+
+//    printf("Allocate Done.\n");
+}
+
+void CTfLiteClass::GetInputTensorSize(){
+    float *zw = this->input;
+    int test = sizeof(zw);
+    printf("Input Tensor Dimension: %d\n", test);       
+
+    printf("Input Tensor Dimension: %d\n", test);   
+}
+
+long CTfLiteClass::GetFileSize(std::string filename)
+{
+    struct stat stat_buf;
+    long rc = stat(filename.c_str(), &stat_buf);
+    return rc == 0 ? stat_buf.st_size : -1;
+}
+
+
+unsigned char* CTfLiteClass::ReadFileToCharArray(std::string _fn)
+{
+    long size;
+    
+    size = this->GetFileSize(_fn);
+
+    if (size == -1)
+    {
+		printf("\nFile existiert nicht.\n");
+        return NULL;
+    }
+
+
+    unsigned char *result = (unsigned char*) malloc(size);
+  
+	if(result != NULL) {
+//		printf("\nSpeicher ist reserviert\n");
+        FILE* f = fopen(_fn.c_str(), "rb");     // vorher  nur "r"
+        fread(result, 1, size, f);
+        fclose(f);        
+	}else {
+		printf("\nKein freier Speicher vorhanden.\n");
+	}    
+
+
+    return result;
+}
+
+void CTfLiteClass::LoadModel(std::string _fn){
+
+#ifdef SUPRESS_TFLITE_ERRORS
+    this->error_reporter = new tflite::OwnMicroErrorReporter;
+#else
+    this->error_reporter = new tflite::MicroErrorReporter;
+#endif
+
+    unsigned char *rd;
+    rd = this->ReadFileToCharArray(_fn.c_str());
+//    printf("loadedfile: %d", (int) rd);
+
+    this->model = tflite::GetModel(rd);
+    free(rd);
+    TFLITE_MINIMAL_CHECK(model != nullptr); 
+//    printf("tfile Loaded.\n");  
+
+}
+
+
+
+CTfLiteClass::CTfLiteClass()
+{
+    this->model = nullptr;
+    this->interpreter = nullptr;
+    this->input = nullptr;
+    this->output = nullptr;  
+    this->kTensorArenaSize = 600 * 1024;
+    this->tensor_arena = new uint8_t[kTensorArenaSize]; 
+}
+
+CTfLiteClass::~CTfLiteClass()
+{
+  delete this->tensor_arena;
+  delete this->interpreter;
+  delete this->error_reporter;
+}        
+
+
+namespace tflite {
+
+  int OwnMicroErrorReporter::Report(const char* format, va_list args) {
+    return 0;
+  }
+
+}  // namespace tflite
+
+

code/components/jomjol_tfliteclass/CTfLiteClass.h

@@ -0,0 +1,70 @@
+
+#define TFLITE_MINIMAL_CHECK(x)                              \
+  if (!(x)) {                                                \
+    fprintf(stderr, "Error at %s:%d\n", __FILE__, __LINE__); \
+    exit(1);                                                 \
+  }
+
+#include "tensorflow/lite/micro/all_ops_resolver.h"
+#include "tensorflow/lite/micro/micro_error_reporter.h"
+#include "tensorflow/lite/micro/micro_interpreter.h"
+#include "tensorflow/lite/schema/schema_generated.h"
+#include "tensorflow/lite/version.h"
+#include "tensorflow/lite/micro/kernels/micro_ops.h"
+#include "esp_err.h"
+#include "esp_log.h"
+
+
+
+#define SUPRESS_TFLITE_ERRORS           // use, to avoid error messages from TFLITE
+
+#ifdef SUPRESS_TFLITE_ERRORS
+#include "tensorflow/lite/core/api/error_reporter.h"
+#include "tensorflow/lite/micro/compatibility.h"
+#include "tensorflow/lite/micro/debug_log.h"
+///// OwnErrorReporter to prevent printing of Errors (especially unavoidable in CalculateActivationRangeQuantized@kerne_util.cc)
+namespace tflite {
+    class OwnMicroErrorReporter : public ErrorReporter {
+        public:
+           int Report(const char* format, va_list args) override;
+    };
+}  // namespace tflite
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+#endif
+
+class CTfLiteClass
+{
+    protected:
+        tflite::ErrorReporter *error_reporter;
+        const tflite::Model* model;
+        tflite::MicroInterpreter* interpreter;
+        TfLiteTensor* output = nullptr;     
+//        static tflite::ops::micro::AllOpsResolver *resolver; 
+        static tflite::AllOpsResolver resolver;
+
+        int kTensorArenaSize;
+        uint8_t *tensor_arena;
+
+        float* input;
+        int input_i;
+        int im_height, im_width, im_channel;
+
+        long GetFileSize(std::string filename);
+        unsigned char* ReadFileToCharArray(std::string _fn);
+        
+    public:
+        CTfLiteClass();
+        ~CTfLiteClass();        
+        void LoadModel(std::string _fn);
+        void MakeAllocate();
+        void GetInputTensorSize();
+        bool LoadInputImage(std::string _fn);
+        void Invoke();
+        void GetOutPut();
+        int GetOutClassification();
+        int GetClassFromImage(std::string _fn);
+
+        float GetOutputValue(int nr);
+        void GetInputDimension(bool silent);
+};
+

code/components/jomjol_tfliteclass/server_tflite.cpp

@@ -0,0 +1,498 @@
+#include "server_tflite.h"
+
+#include <string>
+#include <vector>
+#include "string.h"
+#include "esp_log.h"
+
+#include <iomanip>
+#include <sstream>
+
+#include "Helper.h"
+
+#include "esp_camera.h"
+#include "time_sntp.h"
+#include "ClassControllCamera.h"
+
+#include "ClassFlowControll.h"
+
+#include "ClassLogFile.h"
+
+ClassFlowControll tfliteflow;
+
+TaskHandle_t xHandleblink_task_doFlow = NULL;
+TaskHandle_t xHandletask_autodoFlow = NULL;
+
+
+bool flowisrunning = false;
+
+long auto_intervall = 0;
+bool auto_isrunning = false;
+
+void KillTFliteTasks()
+{
+    printf("Handle: xHandleblink_task_doFlow: %ld\n", (long) xHandleblink_task_doFlow);    
+    if (xHandleblink_task_doFlow)
+    {
+        vTaskDelete(xHandleblink_task_doFlow);
+        printf("Killed: xHandleblink_task_doFlow\n");
+    }
+
+    printf("Handle: xHandletask_autodoFlow: %ld\n", (long) xHandletask_autodoFlow);  
+    if (xHandletask_autodoFlow)
+    {
+        vTaskDelete(xHandletask_autodoFlow);
+        printf("Killed: xHandletask_autodoFlow\n");
+    }
+
+}
+
+void doInit(void)
+{
+    string config = "/sdcard/config/config.ini";   
+    printf("Start tfliteflow.InitFlow(config);\n");
+    tfliteflow.InitFlow(config);
+    printf("Finished tfliteflow.InitFlow(config);\n");
+}
+
+
+bool doflow(void)
+{
+    
+    std::string zw_time = gettimestring(LOGFILE_TIME_FORMAT);
+    printf("doflow - start %s\n", zw_time.c_str());
+    flowisrunning = true;
+    tfliteflow.doFlow(zw_time);
+    flowisrunning = false;
+
+    printf("doflow - end %s\n", zw_time.c_str());
+    return true;
+}
+
+void blink_task_doFlow(void *pvParameter)
+{
+    printf("blink_task_doFlow\n");
+    if (!flowisrunning)
+    {
+        flowisrunning = true;
+        doflow();
+        flowisrunning = false;
+    }
+    vTaskDelete(NULL); //Delete this task if it exits from the loop above
+    xHandleblink_task_doFlow = NULL;
+}
+
+
+esp_err_t handler_init(httpd_req_t *req)
+{
+    LogFile.WriteToFile("handler_init"); 
+    printf("handler_doinit uri:\n"); printf(req->uri); printf("\n");
+
+    char* resp_str = "Init started<br>";
+    httpd_resp_send(req, resp_str, strlen(resp_str));     
+
+    doInit();
+
+    resp_str = "Init done<br>";
+    httpd_resp_send(req, resp_str, strlen(resp_str));     
+    /* Respond with an empty chunk to signal HTTP response completion */
+    httpd_resp_send_chunk(req, NULL, 0);    
+
+    return ESP_OK;
+};
+
+esp_err_t handler_doflow(httpd_req_t *req)
+{
+    LogFile.WriteToFile("handler_doflow");   
+    char* resp_str;
+
+    printf("handler_doFlow uri: "); printf(req->uri); printf("\n");
+
+    if (flowisrunning)
+    {
+        const char* resp_str = "doFlow läuft bereits und kann nicht nochmal gestartet werden";
+        httpd_resp_send(req, resp_str, strlen(resp_str));       
+        return 2;
+    }
+    else
+    {
+        xTaskCreate(&blink_task_doFlow, "blink_doFlow", configMINIMAL_STACK_SIZE * 64, NULL, tskIDLE_PRIORITY+1, &xHandleblink_task_doFlow);
+    }
+    resp_str = "doFlow gestartet - dauert ca. 60 Sekunden";
+    httpd_resp_send(req, resp_str, strlen(resp_str));  
+    /* Respond with an empty chunk to signal HTTP response completion */
+    httpd_resp_send_chunk(req, NULL, 0);        
+    return ESP_OK;
+};
+
+
+
+
+esp_err_t handler_wasserzaehler(httpd_req_t *req)
+{
+    LogFile.WriteToFile("handler_wasserzaehler");    
+    bool _rawValue = false;
+    bool _noerror = false;
+    string zw;
+
+    printf("handler_wasserzaehler uri:\n"); printf(req->uri); printf("\n");
+
+    char _query[100];
+    char _size[10];
+
+    if (httpd_req_get_url_query_str(req, _query, 100) == ESP_OK)
+    {
+//        printf("Query: "); printf(_query); printf("\n");
+        if (httpd_query_key_value(_query, "rawvalue", _size, 10) == ESP_OK)
+        {
+            printf("rawvalue is found"); printf(_size); printf("\n"); 
+            _rawValue = true;
+        }
+        if (httpd_query_key_value(_query, "noerror", _size, 10) == ESP_OK)
+        {
+            printf("noerror is found"); printf(_size); printf("\n"); 
+            _noerror = true;
+        }        
+    }  
+
+    zw = tfliteflow.getReadout(_rawValue, _noerror);
+    if (zw.length() > 0)
+        httpd_resp_sendstr_chunk(req, zw.c_str()); 
+
+    string query = std::string(_query);
+//    printf("Query: %s\n", query.c_str());
+    if (query.find("full") != std::string::npos)
+    {
+        string txt, zw;
+        
+        txt = "<p>Aligned Image: <p><img src=\"/img_tmp/alg.jpg\"> <p>\n";
+        txt = txt + "Digital Counter: <p> ";
+        httpd_resp_sendstr_chunk(req, txt.c_str()); 
+        
+        std::vector<HTMLInfo*> htmlinfo;
+        htmlinfo = tfliteflow.GetAllDigital();
+        for (int i = 0; i < htmlinfo.size(); ++i)
+        {
+            if (htmlinfo[i]->val == 10)
+                zw = "NaN";
+            else
+            {
+                zw = to_string((int) htmlinfo[i]->val);
+            }
+            txt = "<img src=\"/img_tmp/" +  htmlinfo[i]->filename + "\"> " + zw;
+            httpd_resp_sendstr_chunk(req, txt.c_str()); 
+            delete htmlinfo[i];
+        }
+        htmlinfo.clear();
+      
+        txt = " <p> Analog Meter: <p> ";
+        httpd_resp_sendstr_chunk(req, txt.c_str()); 
+        
+        htmlinfo = tfliteflow.GetAllAnalog();
+        for (int i = 0; i < htmlinfo.size(); ++i)
+        {
+            std::stringstream stream;
+            stream << std::fixed << std::setprecision(1) << htmlinfo[i]->val;
+            zw = stream.str();
+
+            txt = "<img src=\"/img_tmp/" +  htmlinfo[i]->filename + "\"> " + zw;
+            httpd_resp_sendstr_chunk(req, txt.c_str()); 
+            delete htmlinfo[i];
+        }
+        htmlinfo.clear();         
+
+    }   
+
+  
+
+
+
+
+    /* Respond with an empty chunk to signal HTTP response completion */
+    httpd_resp_sendstr_chunk(req, NULL);   
+
+    return ESP_OK;
+};
+
+
+esp_err_t handler_editflow(httpd_req_t *req)
+{
+    LogFile.WriteToFile("handler_editflow");    
+
+    printf("handler_editflow uri: "); printf(req->uri); printf("\n");
+
+    char _query[200];
+    char _valuechar[30];
+    string _task;
+
+    if (httpd_req_get_url_query_str(req, _query, 200) == ESP_OK)
+    {
+        if (httpd_query_key_value(_query, "task", _valuechar, 30) == ESP_OK)
+        {
+            printf("task is found: %s\n", _valuechar); 
+            _task = string(_valuechar);
+        }
+    }  
+
+    if (_task.compare("copy") == 0)
+    {
+        string in, out, zw;
+
+        httpd_query_key_value(_query, "in", _valuechar, 30);
+        in = string(_valuechar);
+        printf("in: "); printf(in.c_str()); printf("\n"); 
+
+        httpd_query_key_value(_query, "out", _valuechar, 30);         
+        out = string(_valuechar);  
+        printf("out: "); printf(out.c_str()); printf("\n"); 
+
+        in = "/sdcard" + in;
+        out = "/sdcard" + out;
+
+        CopyFile(in, out);
+        zw = "Copy Done";
+        httpd_resp_sendstr_chunk(req, zw.c_str()); 
+    }
+
+
+    if (_task.compare("cutref") == 0)
+    {
+        string in, out, zw;
+        int x, y, dx, dy;
+        bool enhance = false;
+
+        httpd_query_key_value(_query, "in", _valuechar, 30);
+        in = string(_valuechar);
+        printf("in: "); printf(in.c_str()); printf("\n"); 
+
+        httpd_query_key_value(_query, "out", _valuechar, 30);         
+        out = string(_valuechar);  
+        printf("out: "); printf(out.c_str()); printf("\n"); 
+
+        httpd_query_key_value(_query, "x", _valuechar, 30);
+        zw = string(_valuechar);  
+        x = stoi(zw);              
+        printf("x: "); printf(zw.c_str()); printf("\n"); 
+
+        httpd_query_key_value(_query, "y", _valuechar, 30);
+        zw = string(_valuechar);  
+        y = stoi(zw);              
+        printf("y: "); printf(zw.c_str()); printf("\n"); 
+
+        httpd_query_key_value(_query, "dx", _valuechar, 30);
+        zw = string(_valuechar);  
+        dx = stoi(zw);  
+        printf("dx: "); printf(zw.c_str()); printf("\n"); 
+
+        httpd_query_key_value(_query, "dy", _valuechar, 30);
+        zw = string(_valuechar);  
+        dy = stoi(zw);          
+        printf("dy: "); printf(zw.c_str()); printf("\n"); 
+
+        if (httpd_query_key_value(_query, "enhance", _valuechar, 10) == ESP_OK)
+        {
+            zw = string(_valuechar);
+            if (zw.compare("true") == 0)
+            {
+                enhance = true;
+            }
+        }
+
+        in = "/sdcard" + in;
+        out = "/sdcard" + out;
+
+        string out2 = out.substr(0, out.length() - 4) + "_org.jpg";
+
+        CAlignAndCutImage *caic = new CAlignAndCutImage(in);
+        caic->CutAndSave(out2, x, y, dx, dy);
+        delete caic;    
+
+        CImageBasis *cim = new CImageBasis(out2);
+        if (enhance)
+        {
+            cim->Contrast(90);
+        }
+
+        cim->SaveToFile(out);
+        delete cim;        
+
+        zw = "CutImage Done";
+        httpd_resp_sendstr_chunk(req, zw.c_str()); 
+    }
+
+    if (_task.compare("test_take") == 0)
+    {
+        std::string _host = "";
+        if (httpd_query_key_value(_query, "host", _valuechar, 30) == ESP_OK) {
+            _host = std::string(_valuechar);
+        }
+//        printf("Parameter host: "); printf(_host.c_str()); printf("\n"); 
+//        string zwzw = "Do " + _task + " start\n"; printf(zwzw.c_str());
+        std::string zw = tfliteflow.doSingleStep("[MakeImage]", _host);
+        httpd_resp_sendstr_chunk(req, zw.c_str()); 
+    } 
+
+
+    if (_task.compare("test_align") == 0)
+    {
+        std::string _host = "";
+        if (httpd_query_key_value(_query, "host", _valuechar, 30) == ESP_OK) {
+            _host = std::string(_valuechar);
+        }
+//        printf("Parameter host: "); printf(_host.c_str()); printf("\n"); 
+
+//        string zwzw = "Do " + _task + " start\n"; printf(zwzw.c_str());
+        std::string zw = tfliteflow.doSingleStep("[Alignment]", _host);
+        httpd_resp_sendstr_chunk(req, zw.c_str()); 
+    }  
+    if (_task.compare("test_analog") == 0)
+    {
+        std::string _host = "";
+        if (httpd_query_key_value(_query, "host", _valuechar, 30) == ESP_OK) {
+            _host = std::string(_valuechar);
+        }
+//        printf("Parameter host: "); printf(_host.c_str()); printf("\n"); 
+//        string zwzw = "Do " + _task + " start\n"; printf(zwzw.c_str());
+        std::string zw = tfliteflow.doSingleStep("[Analog]", _host);
+        httpd_resp_sendstr_chunk(req, zw.c_str()); 
+    }  
+    if (_task.compare("test_digits") == 0)
+    {
+        std::string _host = "";
+        if (httpd_query_key_value(_query, "host", _valuechar, 30) == ESP_OK) {
+            _host = std::string(_valuechar);
+        }
+//        printf("Parameter host: "); printf(_host.c_str()); printf("\n"); 
+
+//        string zwzw = "Do " + _task + " start\n"; printf(zwzw.c_str());
+        std::string zw = tfliteflow.doSingleStep("[Digits]", _host);
+        httpd_resp_sendstr_chunk(req, zw.c_str()); 
+    } 
+
+
+    /* Respond with an empty chunk to signal HTTP response completion */
+    httpd_resp_sendstr_chunk(req, NULL);   
+
+    return ESP_OK;
+};
+
+
+esp_err_t handler_prevalue(httpd_req_t *req)
+{
+    LogFile.WriteToFile("handler_prevalue"); 
+    const char* resp_str;
+    string zw;
+
+//    printf("handler_prevalue:\n"); printf(req->uri); printf("\n");
+
+    char _query[100];
+    char _size[10] = "";
+
+    if (httpd_req_get_url_query_str(req, _query, 100) == ESP_OK)
+    {
+//        printf("Query: "); printf(_query); printf("\n");
+        if (httpd_query_key_value(_query, "value", _size, 10) == ESP_OK)
+        {
+            printf("Value: "); printf(_size); printf("\n"); 
+        }
+    }           
+
+    if (strlen(_size) == 0)
+        zw = tfliteflow.GetPrevalue();
+    else
+        zw = "SetPrevalue to " + tfliteflow.UpdatePrevalue(_size);
+    
+    resp_str = zw.c_str();
+
+    httpd_resp_send(req, resp_str, strlen(resp_str));   
+    /* Respond with an empty chunk to signal HTTP response completion */
+    httpd_resp_send_chunk(req, NULL, 0);      
+
+    return ESP_OK;
+};
+
+void task_autodoFlow(void *pvParameter)
+{
+    int64_t fr_start, fr_delta_ms;
+
+    doInit();
+    
+    auto_isrunning = tfliteflow.isAutoStart(auto_intervall);
+
+    while (auto_isrunning)
+    {
+        LogFile.WriteToFile("task_autodoFlow - next round"); 
+        printf("Autoflow: start\n");
+        fr_start = esp_timer_get_time();
+
+        if (flowisrunning)
+        {
+            printf("Autoflow: doFLow laeuft bereits!\n");
+        }
+        else
+        {
+            printf("Autoflow: doFLow wird gestartet\n");
+            flowisrunning = true;
+            doflow();
+            printf("Remove older log files\n");
+            LogFile.RemoveOld();
+        }
+        
+        LogFile.WriteToFile("task_autodoFlow - round done");
+        //CPU Temp
+        float cputmp = temperatureRead();
+        std::stringstream stream;
+        stream << std::fixed << std::setprecision(1) << cputmp;
+        string zwtemp = "CPU Temperature: " + stream.str();
+        LogFile.WriteToFile(zwtemp); 
+        printf("CPU Temperature: %.2f\n", cputmp);
+        fr_delta_ms = (esp_timer_get_time() - fr_start) / 1000;
+        const TickType_t xDelay = (auto_intervall - fr_delta_ms)  / portTICK_PERIOD_MS;
+        printf("Autoflow: sleep for : %ldms\n", (long) xDelay);
+        vTaskDelay( xDelay );        
+    }
+    vTaskDelete(NULL); //Delete this task if it exits from the loop above
+    xHandletask_autodoFlow = NULL;
+}
+
+void TFliteDoAutoStart()
+{
+    xTaskCreate(&task_autodoFlow, "task_autodoFlow", configMINIMAL_STACK_SIZE * 64, NULL, tskIDLE_PRIORITY+1, &xHandletask_autodoFlow);
+}
+
+
+
+void register_server_tflite_uri(httpd_handle_t server)
+{
+    ESP_LOGI(TAGTFLITE, "server_part_camera - Registering URI handlers");
+    
+    httpd_uri_t camuri = { };
+    camuri.method    = HTTP_GET;
+
+    camuri.uri       = "/doinit";
+    camuri.handler   = handler_init;
+    camuri.user_ctx  = (void*) "Light On";    
+    httpd_register_uri_handler(server, &camuri);
+
+    camuri.uri       = "/setPreValue.html";
+    camuri.handler   = handler_prevalue;
+    camuri.user_ctx  = (void*) "Prevalue";    
+    httpd_register_uri_handler(server, &camuri);
+
+    camuri.uri       = "/doflow";
+    camuri.handler   = handler_doflow;
+    camuri.user_ctx  = (void*) "Light Off"; 
+    httpd_register_uri_handler(server, &camuri);  
+
+    
+    camuri.uri       = "/editflow.html";
+    camuri.handler   = handler_editflow;
+    camuri.user_ctx  = (void*) "EditFlow"; 
+    httpd_register_uri_handler(server, &camuri);     
+
+    camuri.uri       = "/wasserzaehler.html";
+    camuri.handler   = handler_wasserzaehler;
+    camuri.user_ctx  = (void*) "Wasserzaehler"; 
+    httpd_register_uri_handler(server, &camuri);  
+
+}

code/components/jomjol_tfliteclass/server_tflite.h

@@ -0,0 +1,13 @@
+#include <esp_log.h>
+
+#include <esp_http_server.h>
+
+//#include "ClassControllCamera.h"
+
+static const char *TAGTFLITE = "server_tflite";
+
+void register_server_tflite_uri(httpd_handle_t server);
+
+void KillTFliteTasks();
+
+void TFliteDoAutoStart();