diff --git a/README.md b/README.md index 7546ce24..3fd846d6 100644 --- a/README.md +++ b/README.md @@ -19,7 +19,7 @@ A 3d-printable housing can be found here: https://www.thingiverse.com/thing:4571 ### Known Issues -* reboot on extensive web access due to the limits of the internal web server +* Reboot on extensive web access due to the limits of the internal web server ------ diff --git a/code/include/README b/code/include/README deleted file mode 100644 index 194dcd43..00000000 --- a/code/include/README +++ /dev/null @@ -1,39 +0,0 @@ - -This directory is intended for project header files. - -A header file is a file containing C declarations and macro definitions -to be shared between several project source files. You request the use of a -header file in your project source file (C, C++, etc) located in `src` folder -by including it, with the C preprocessing directive `#include'. - -```src/main.c - -#include "header.h" - -int main (void) -{ - ... -} -``` - -Including a header file produces the same results as copying the header file -into each source file that needs it. Such copying would be time-consuming -and error-prone. With a header file, the related declarations appear -in only one place. If they need to be changed, they can be changed in one -place, and programs that include the header file will automatically use the -new version when next recompiled. The header file eliminates the labor of -finding and changing all the copies as well as the risk that a failure to -find one copy will result in inconsistencies within a program. - -In C, the usual convention is to give header files names that end with `.h'. -It is most portable to use only letters, digits, dashes, and underscores in -header file names, and at most one dot. - -Read more about using header files in official GCC documentation: - -* Include Syntax -* Include Operation -* Once-Only Headers -* Computed Includes - -https://gcc.gnu.org/onlinedocs/cpp/Header-Files.html diff --git a/code/lib/jomjol_tfliteclass/CTfLiteClass._cpp_old b/code/lib/jomjol_tfliteclass/CTfLiteClass._cpp_old new file mode 100644 index 00000000..dcd56ce0 --- /dev/null +++ b/code/lib/jomjol_tfliteclass/CTfLiteClass._cpp_old @@ -0,0 +1,254 @@ +#include "CTfLiteClass.h" + +#include "bitmap_image.hpp" + +#include + +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; +} + + diff --git a/code/lib/jomjol_tfliteclass/CTfLiteClass._h_old b/code/lib/jomjol_tfliteclass/CTfLiteClass._h_old new file mode 100644 index 00000000..01d972bf --- /dev/null +++ b/code/lib/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 \ No newline at end of file diff --git a/code/src/version.cpp b/code/src/version.cpp index 8911e364..54203683 100644 --- a/code/src/version.cpp +++ b/code/src/version.cpp @@ -1,4 +1,4 @@ -const char* GIT_REV="707472b"; +const char* GIT_REV="de772d7"; const char* GIT_TAG=""; const char* GIT_BRANCH="rolling"; -const char* BUILD_TIME="2020-11-15 11:59"; \ No newline at end of file +const char* BUILD_TIME="2020-11-15 12:29"; \ No newline at end of file diff --git a/code/src/version.h b/code/src/version.h index 7d39a034..6570e6f9 100644 --- a/code/src/version.h +++ b/code/src/version.h @@ -13,7 +13,7 @@ extern "C" #include "Helper.h" #include -const char* GIT_BASE_BRANCH = "master - v4.0.0 - 2020-11-15"; +const char* GIT_BASE_BRANCH = "master - v3.1.0 - 2020-10-26"; const char* git_base_branch(void) diff --git a/code/src/zip._c b/code/src/zip._c new file mode 100644 index 00000000..e69de29b diff --git a/code/version.cpp b/code/version.cpp index 8911e364..54203683 100644 --- a/code/version.cpp +++ b/code/version.cpp @@ -1,4 +1,4 @@ -const char* GIT_REV="707472b"; +const char* GIT_REV="de772d7"; const char* GIT_TAG=""; const char* GIT_BRANCH="rolling"; -const char* BUILD_TIME="2020-11-15 11:59"; \ No newline at end of file +const char* BUILD_TIME="2020-11-15 12:29"; \ No newline at end of file diff --git a/firmware/bootloader.bin b/firmware/bootloader.bin index b41cfc0a..3fd7c9a5 100644 Binary files a/firmware/bootloader.bin and b/firmware/bootloader.bin differ diff --git a/firmware/firmware.bin b/firmware/firmware.bin index 8e69fef0..92305cad 100644 Binary files a/firmware/firmware.bin and b/firmware/firmware.bin differ diff --git a/firmware/html.zip b/firmware/html.zip index 914d6404..6336a3a1 100644 Binary files a/firmware/html.zip and b/firmware/html.zip differ