From 3284db23b68d7644c2171453bc23bd5414e0dce7 Mon Sep 17 00:00:00 2001
From: Samuel <samuel.kay@poivron-robotique.fr>
Date: Tue, 11 Jul 2023 12:34:18 +0200
Subject: [PATCH] Suppression du cache pour les messages de log, desactivation
 du PANIC dans malloc

---
 CMakeLists.txt |  1 +
 Log.c          | 72 ++++++++++++++++----------------------------------
 2 files changed, 24 insertions(+), 49 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index c10d2e8..cb2f727 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -48,6 +48,7 @@ spi_nb.c)
 pico_generate_pio_header(test ${CMAKE_CURRENT_LIST_DIR}/quadrature_encoder.pio)
 
 add_definitions(-DGYRO_ADXRS453)
+add_definitions(-DPICO_MALLOC_PANIC=0)
 pico_enable_stdio_usb(test 1)
 pico_enable_stdio_uart(test 1)
 pico_add_extra_outputs(test)
diff --git a/Log.c b/Log.c
index 77773f3..0447db2 100644
--- a/Log.c
+++ b/Log.c
@@ -3,19 +3,13 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-#define LOG_CACHE_SIZE 10
-
 struct log_message_storage{
     struct Log_message_data message;
     struct log_message_storage * next;
 } * log_message_storage_envoi, log_message_storage_premier, *log_message_storage_courant;
 
-struct Log_message_data log_cache[LOG_CACHE_SIZE];
-uint log_cache_index_entry = 0;
-uint log_cache_index_stored = 0;
 uint log_error = 0;
 
-void increment_cache_index(uint * index);
 int store_new_message(struct Log_message_data message, struct log_message_storage * stockage);
 void envoi_message(struct Log_message_data message);
 
@@ -35,64 +29,44 @@ void Log_init(void){
 /// @param message : string, without '\n' at the end.
 /// @param log_level : can be in TELEPLOT, TRACE, DEBUG, INFO, WARN, ERROR, FATAL
 void Log_message(char * message, enum Log_level log_level){
-    uint temps0, temps1;
-    temps0 = time_us_32();
+    /// Création de la structure de données
+    struct Log_message_data message_container;
     if(strlen(message) > LOG_MAX_MESSAGE_SIZE){
-        strcpy(log_cache[log_cache_index_entry].message, "MSG TOO LONG");
+        strcpy(message_container.message, "MSG TOO LONG");
     }else{
-        strcpy(log_cache[log_cache_index_entry].message, message);
+        strcpy(message_container.message, message);
     }
-    log_cache[log_cache_index_entry].log_level = log_level;
-    log_cache[log_cache_index_entry].timestamp = time_us_32() / 1000;
+    message_container.log_level = log_level;
+    message_container.timestamp = time_us_32() / 1000;
 
-    increment_cache_index(&log_cache_index_entry);
-    temps1 = time_us_32();
-
-    printf("temps tableau : %u us\n", temps1 - temps0);
-
-    // Cache overflow - est-ce pertinent ? Ne faudrait-il pas réaliser ce test avant d'incrémenter cache_index_entry ?
-    /*if(log_cache_index_entry == log_cache_index_stored){
-        log_error |= LOG_ERROR_CACHE_OVERFLOW;
-    }*/
+    /// Insertion de la structure dans la liste chaînée
+    struct log_message_storage* tmp_message_storage;
+    tmp_message_storage = (struct log_message_storage*) malloc(sizeof(struct log_message_storage));
+    if(tmp_message_storage != NULL){
+        tmp_message_storage->message = message_container;
+        tmp_message_storage->next = NULL;
+        log_message_storage_courant->next = tmp_message_storage;
+        log_message_storage_courant = log_message_storage_courant->next;
+    }else{
+        log_error |= LOG_ERROR_MEMORY_FULL;
+    }
 }
 
 /// @brief Read messages in cache, store them and send them through the serial connection
 void Log_gestion(){
-    // Store all message from the cache
-    
-    while(log_cache_index_entry != log_cache_index_stored){
-        store_new_message(log_cache[log_cache_index_stored], log_message_storage_courant);
-        increment_cache_index(&log_cache_index_stored);
-        log_message_storage_courant = log_message_storage_courant->next;
-    }
-    
     // Envoi 1 message par la liaison série
-    
     if(log_message_storage_envoi->next != NULL){
         log_message_storage_envoi = log_message_storage_envoi->next;
         envoi_message(log_message_storage_envoi->message);
+        // Si on est à la fin des messages, en envoie le statut de la fonction Log
+        if(log_message_storage_envoi->next == NULL){
+            if(log_error & LOG_ERROR_MEMORY_FULL){
+                printf("LOG ERROR : Memoire pleine !\n");
+            }
+        }
     }
 }
 
-void increment_cache_index(uint * index){
-    *index = *index +1;
-    if(*index >= LOG_CACHE_SIZE){
-        *index = 0;
-    }
-}
-
-/// @brief Alloue l'espace pour stocker un nouveau message
-/// @return 0 en cas de succès, 1 si la mémoire est pleine
-int store_new_message(struct Log_message_data message, struct log_message_storage * stockage){
-    stockage->next = (struct log_message_storage*) malloc(sizeof(struct log_message_storage));
-    if(stockage->next != NULL){
-        stockage->next->message = message;
-        stockage->next->next = NULL;
-        return 0;
-    }
-    return 1;
-}
-
 void envoi_message(struct Log_message_data message){
     printf("%u ms:%s\n", message.timestamp, message.message);
 }