Data Labeling sur microcontrôleur avec Tensorflow lite

#include "main.h"
#include "light_classifier_model.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 <iostream>
#include <iomanip>
#include <time.h>

#define MAX 100000
#define MIN 0

using namespace std;

//-------------------------------------------------------------------------
namespace
{
    tflite::ErrorReporter* error_reporter = nullptr;
    const tflite::Model* model = nullptr;
    tflite::MicroInterpreter* interpreter = nullptr;
    TfLiteTensor* model_input = nullptr;
    TfLiteTensor* model_output = nullptr;

    constexpr uint32_t kTensorArenaSize = 2 * 1024;
    uint8_t tensor_arena[kTensorArenaSize];
}
//-------------------------------------------------------------------------
I2C_HandleTypeDef hi2c1;
TIM_HandleTypeDef htim5;
UART_HandleTypeDef huart2;

void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_USART2_UART_Init(void);
static void MX_I2C1_Init(void);
static void MX_TIM5_Init(void);

// redirection du fprintf vers uart2
int __io_putchar(int ch)
{
	HAL_UART_Transmit(&huart2, (uint8_t *)&ch, 1, HAL_MAX_DELAY);
    return ch;
}

int search_max(float* tab, int nb_val, int *idx)
{
	float max_value = tab[0];
    for (int i = 1; i < nb_val; i++)
    {
	            if (tab[i] > max_value)
	            {
	                max_value =tab[i];  // Mettre à jour la plus grande valeur
	                *idx = i;  // Enregistrer l'index de la meilleure classe
	            }
    }
return 0;
}


int val_test[20] = { 0 , 100, 150, 400, 500 , 700 , 850, 1000, 5000, 10000, 50000, 99999, 30, 2000, 7000, 23, 177, 20000, 50, 1250};

//==============================================================================================
int main(void)
{

  HAL_Init();

  SystemClock_Config();

  MX_GPIO_Init();
  MX_USART2_UART_Init();
  MX_I2C1_Init();
  MX_TIM5_Init();

  //-------------------------------------------------------------------------
	static tflite::MicroErrorReporter micro_error_reporter;
	error_reporter = &micro_error_reporter;

	TF_LITE_REPORT_ERROR(error_reporter,"test uart \n\r");
    model = tflite::GetModel(light_classifier_model);

	static tflite::ops::micro::AllOpsResolver resolver;

	static tflite::MicroInterpreter static_interpreter(model, resolver, tensor_arena, kTensorArenaSize, error_reporter);
	interpreter = &static_interpreter;

	TfLiteStatus allocate_status = interpreter->AllocateTensors();
	if (allocate_status != kTfLiteOk)
	{
	    TF_LITE_REPORT_ERROR(error_reporter, "AllocateTensors() failed");
	    return 0;
	}

	model_input = interpreter->input(0);
	model_output = interpreter->output(0);
	//-------------------------------------------------------------------------

	  static float x_val = 0;
	  std::cout << std::setprecision(3) << std::fixed;
	  float tab_log[3];
	  int lux;
	  static int i=0;


	  static int max = 0;
	  while (1)
	  {

		  	lux = val_test[(i++)%20];

		    float normalized_lux = lux / 100000.0f;

			//-------------------------------------------------------------------------
	        model_input->data.f[0] = normalized_lux;

	        TfLiteStatus invoke_status = interpreter->Invoke();
	        if (invoke_status != kTfLiteOk)
	        {
	            TF_LITE_REPORT_ERROR(error_reporter, "Invoke failed on x_val: %f\n", static_cast<float>(x_val));
	            return 0;
	        }
	    	//-------------------------------------------------------------------------
	        int ix = 0;
	        search_max(model_output->data.f, 3, &ix);

	        tab_log[0] = model_output->data.f[0]; // Probabilité de "Intermédiaire"
	    	tab_log[1] = model_output->data.f[1]; // Probabilité de "Jour"
	    	tab_log[2] = model_output->data.f[2]; // Probabilité de "Nuit"

	        cout << "Luminosité : " << lux << " lux | probas : " << tab_log[0] <<"  "<<tab_log[1] << "  "<<tab_log[2];
	        const char* categories[] = {"Intermédiaire", "Jour", "Nuit"};
	        cout << " -> Classe : " << categories[ix] << endl << '\r';


		    HAL_Delay(500);
	  }

}
//==============================================================================================