From 4874adc8833dc32c1fd05e68dd13bf80ff13eb1b Mon Sep 17 00:00:00 2001 From: Samuel Date: Sat, 27 Sep 2025 19:15:58 +0200 Subject: [PATCH] Log des messages USB sur la carte SD fonctionnel --- CMakeLists.txt | 1 + cdc_app.c | 16 ++-- com_usb.c | 14 ++-- com_usb.h | 10 +-- log.c | 203 +++++++++++++++++++++++++++++++++++++++++++++++++ log.h | 4 + main.c | 8 +- 7 files changed, 236 insertions(+), 20 deletions(-) create mode 100644 log.c create mode 100644 log.h diff --git a/CMakeLists.txt b/CMakeLists.txt index d51c054..01ed9e0 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -23,6 +23,7 @@ target_sources(host_cdc_msc_hid PUBLIC diskio_USB.c diskio_SDIO.c com_usb.c + log.c messagerie.c lib/FatFs/source/ff.c lib/FatFs/source/ffsystem.c diff --git a/cdc_app.c b/cdc_app.c index 43a96f7..894e83e 100644 --- a/cdc_app.c +++ b/cdc_app.c @@ -28,6 +28,7 @@ #include "bsp/board_api.h" #include "messagerie.h" #include "com_usb.h" +#include "log.h" #include volatile bool in_transfert_cb = 0; @@ -48,8 +49,8 @@ size_t get_console_inputs(uint8_t* buf, size_t bufsize) { void traiter_les_messages(uint8_t idx, struct message_t message){ // Debug char message_en_clair[1024]; - //message_to_string(message, message_en_clair); - //printf("%s\n", message_en_clair); + message_to_string(message, message_en_clair); + log_event(message_en_clair); if(message.type == '>'){ char message_en_clair[1024]; @@ -64,6 +65,9 @@ void traiter_les_messages(uint8_t idx, struct message_t message){ for(int i=0; itampon_echange[message.adresse_registre + i] = message.donnees[i]; } + /*char message_en_clair[1024]; + message_to_string(message, message_en_clair); + log_event(message_en_clair);*/ //printf(">d:%d\n",log_buffer->tampon_echange[0]); } @@ -120,7 +124,7 @@ void cdc_app_task(void) { char texte_log[255]; unsigned int position_chaine = 0, position_sous_chaine; - log_analyse(idx); + com_analyse(idx); while(message_disponible()){ message = get_message(); traiter_les_messages(idx, message); @@ -149,7 +153,7 @@ void tuh_cdc_rx_cb(uint8_t idx) { uint32_t count = tuh_cdc_read(idx, buf, bufsize); buf[count] = 0; - log_add(idx, buf, count); + com_add(idx, buf, count); in_transfert_cb = 0; } @@ -162,7 +166,7 @@ void tuh_cdc_mount_cb(uint8_t idx) { printf("CDC Interface is mounted: address = %u, itf_num = %u, idx = %u\r\n", itf_info.daddr, itf_info.desc.bInterfaceNumber, idx); - log_create(idx); + com_create(idx); #ifdef CFG_TUH_CDC_LINE_CODING_ON_ENUM // If CFG_TUH_CDC_LINE_CODING_ON_ENUM is defined, line coding will be set by tinyusb stack @@ -187,5 +191,5 @@ void tuh_cdc_umount_cb(uint8_t idx) { printf("CDC Interface is unmounted: address = %u, itf_num = %u\r\n", itf_info.daddr, itf_info.desc.bInterfaceNumber); - log_destroy(idx); + com_destroy(idx); } diff --git a/com_usb.c b/com_usb.c index d40d8b1..a06d8bb 100644 --- a/com_usb.c +++ b/com_usb.c @@ -44,7 +44,7 @@ struct log_buffer_t * get_buffer(const char idx){ } /// @brief Initialisation des structure de reception des données USB-CDC -void log_init(){ +void com_init(){ for (int i=0; iidx = INVALID_ID; @@ -79,7 +79,7 @@ void log_destroy(const char idx){ /// @param idx Numéro de la liaison CDC /// @param buffer Pointeur vers les données /// @param buffer_size Taille des données -void log_add(const char idx, const char * buffer, uint16_t buffer_size){ +void com_add(const char idx, const char * buffer, uint16_t buffer_size){ struct log_buffer_t * log_buffer; log_buffer = get_buffer(idx); @@ -112,8 +112,8 @@ void augmente_index(unsigned int *index, unsigned int offset){ } } -void log_analyse(const char idx){ - //printf("log_analyse %d\n", idx); +void com_analyse(const char idx){ + //printf("com_analyse %d\n", idx); static absolute_time_t current_time_us, start_time_us=0; current_time_us = get_absolute_time(); //printf(">a:%lld\n", current_time_us-start_time_us); @@ -224,5 +224,5 @@ void log_analyse(const char idx){ } augmente_index(&(p_log_bufffer->index_tampon_lecture), fin_message); - //printf("Fin log_analyse %d\n", idx); + //printf("Fin com_analyse %d\n", idx); } diff --git a/com_usb.h b/com_usb.h index 6f60833..3109734 100644 --- a/com_usb.h +++ b/com_usb.h @@ -11,11 +11,11 @@ struct log_buffer_t{ unsigned int index_tampon_ecriture, index_tampon_lecture; }; -void log_init(void); -void log_create(const char idx); -void log_destroy(const char idx); -void log_analyse(const char idx); -void log_add(const char idx, const char * buffer, uint16_t buffer_size); +void com_init(void); +void com_create(const char idx); +void com_destroy(const char idx); +void com_analyse(const char idx); +void com_add(const char idx, const char * buffer, uint16_t buffer_size); struct log_buffer_t * get_buffer(const char idx); void set_carte_id(uint8_t idx, uint8_t carte_id); uint8_t get_carte_idx(uint8_t id_carte); diff --git a/log.c b/log.c new file mode 100644 index 0000000..9d12064 --- /dev/null +++ b/log.c @@ -0,0 +1,203 @@ +#include +#include +#include "pico/stdlib.h" + +#include "ff.h" + +#define TAILLE_TAMPON_LECTURE 10 +#define TAILLE_TAMPON_ECRITURE 0x8000 + +struct tampon_ecriture_t{ + char tampon0[TAILLE_TAMPON_ECRITURE], tampon1[TAILLE_TAMPON_ECRITURE]; + char * tampon_a_ecrire, *tampon_actif; + unsigned int index_tampon, taille_tampon_a_ecrire; + FIL fp; +} tampon_event, tampon_telemetrie; + + + +void ecrit_tampon_dans_sd(struct tampon_ecriture_t * tampon_ecriture){ + if(tampon_ecriture->tampon_a_ecrire != NULL){ + absolute_time_t current_time, start_time; + unsigned int nb_ecrit; + start_time = get_absolute_time(); + f_write(&tampon_ecriture->fp, tampon_ecriture->tampon_a_ecrire, tampon_ecriture->taille_tampon_a_ecrire, &nb_ecrit); + f_sync(&tampon_ecriture->fp); + current_time = get_absolute_time(); + printf(">sd(Mo/s):%d:%.3f\n", (int)(current_time/1000), (float)(nb_ecrit) / (float)(current_time - start_time)); + //printf(">Octets:%d:%d\n", (int)(current_time/1000), nb_ecrit); + //printf(">temps_sd:%d:%lld\n", (int)(current_time/1000), current_time - start_time); + tampon_ecriture->tampon_a_ecrire = NULL; + } + +} + +void routine_log_sd(void){ + while(1){ + ecrit_tampon_dans_sd(&tampon_event); + ecrit_tampon_dans_sd(&tampon_telemetrie); + sleep_ms(10); + } +}; + +void ajout_texte_a_tampon(const char *chaine, struct tampon_ecriture_t * tampon_ecriture){ + if(tampon_ecriture->index_tampon + strlen(chaine) > TAILLE_TAMPON_ECRITURE){ + tampon_ecriture->tampon_a_ecrire = tampon_ecriture->tampon_actif; + // permutation du tampon actif + // indication du tampon à écrire + // remise à 0 de l'index du tampon + if(tampon_ecriture->tampon_actif == tampon_ecriture->tampon0){ + tampon_ecriture->tampon_actif = tampon_ecriture->tampon1; + tampon_ecriture->tampon_a_ecrire = tampon_ecriture->tampon0; + }else{ + tampon_ecriture->tampon_actif = tampon_ecriture->tampon0; + tampon_ecriture->tampon_a_ecrire = tampon_ecriture->tampon1; + } + tampon_ecriture->taille_tampon_a_ecrire = tampon_ecriture->index_tampon; + tampon_ecriture->index_tampon = 0; + tampon_ecriture->tampon_actif[0] = 0; + } + strcat(tampon_ecriture->tampon_actif, chaine); + tampon_ecriture->index_tampon += strlen(chaine); + ecrit_tampon_dans_sd(tampon_ecriture); +} + +void init_tampon_ecriture( struct tampon_ecriture_t * tampon_ecriture ){ + tampon_ecriture->tampon_actif = tampon_ecriture->tampon0; + tampon_ecriture->index_tampon = 0; + tampon_ecriture->tampon_a_ecrire = NULL; + tampon_ecriture->tampon0[0]; + tampon_ecriture->tampon1[0]; +} + +char * get_tampon_inactif(struct tampon_ecriture_t * tampon_ecriture){ + if(tampon_ecriture->index_tampon){ + return tampon_ecriture->tampon0; + } + return tampon_ecriture->tampon1; +} + +char * get_tampon_actif(struct tampon_ecriture_t * tampon_ecriture){ + if(tampon_ecriture->index_tampon){ + return tampon_ecriture->tampon0; + } + return tampon_ecriture->tampon1; +} + +void log_message(const char * message, struct tampon_ecriture_t * tampon_ecriture); + +int log_running = 0; + + +void erreur(char * message){ + while(1){ + puts(message); + sleep_ms(100); + } +} + +void log_init(const char * drive_path){ + FIL fp; + FRESULT result; + uint16_t num_log; + unsigned int nb_lu; + char message_erreur[150]; + char tampon[TAILLE_TAMPON_LECTURE]; + + // Ouverture de num_log.txt + char path_num_log[20], path[30]; + strcpy(path_num_log, drive_path); + strcat(path_num_log, "/num_log.txt"); + result = f_open(&fp, path_num_log, FA_OPEN_EXISTING | FA_READ); + num_log = 0; + if(!result){ + // le fichier existe, lisons-le + result = f_read (&fp, tampon, TAILLE_TAMPON_LECTURE, &nb_lu); + if(!result){ + // lisons le nombre dans le tampon + for(int index = 0; index < TAILLE_TAMPON_LECTURE; index++){ + if(tampon[index] >= '0' && tampon[index] <= '9'){ + num_log = num_log * 10 + tampon[index] - '0'; + }else{ + break; + } + } + num_log++; + }else{ + sprintf(message_erreur, "Échec à la lecture du fichier %s: %d", path_num_log, result); + erreur(message_erreur); + } + } + f_close(&fp); + // Écriture de num_log dans num_log.txt + sprintf(tampon, "%d\n", num_log); + printf("%s", tampon); + result = f_open(&fp, path_num_log, FA_CREATE_ALWAYS | FA_WRITE); + if(!result){ + result = f_write(&fp, tampon, strlen(tampon), &nb_lu); + if(result){ + sprintf(message_erreur, "Échec à l'écriture du fichier %s: %d", path_num_log, result); + erreur(message_erreur); + } + }else{ + sprintf(message_erreur, "Échec à l'ouverture du fichier %s: %d", path_num_log, result); + erreur(message_erreur); + } + f_close(&fp); + + printf("num_log:%d\n", num_log); + + + init_tampon_ecriture(&tampon_event); + init_tampon_ecriture(&tampon_telemetrie); + + // Ouverture du fichier de log + sprintf(path, "%s%s%03d.txt", drive_path, "data", num_log); + printf("path: %s\n", path); + result = f_open(&(tampon_telemetrie.fp), path, FA_CREATE_ALWAYS | FA_WRITE); + if(result){ + sprintf(message_erreur, "Échec à l'ouverture du fichier %s: %d", path, result); + erreur(message_erreur); + } + result = f_write(&(tampon_telemetrie.fp), "Début du fichier\n", strlen("Début du fichier"), &nb_lu); + f_sync(&(tampon_telemetrie.fp)); + printf("Fichier créé: %s\n", path); + + // Ouverture du fichier de telemetrie + sprintf(path, "%s%s%03d.txt", drive_path, "event", num_log); + result = f_open(&(tampon_event.fp), path, FA_CREATE_ALWAYS | FA_WRITE); + result |= f_write(&(tampon_event.fp), "Début du fichier\n", strlen("Début du fichier"), &nb_lu); + if(result){ + sprintf(message_erreur, "Échec à l'ouverture du fichier %s: %d", path, result); + erreur(message_erreur); + } + printf("Fichier créé: %s\n", path); + + + log_running = 1; + + +} + +void log_telemetrie(char * message){ + log_message(message, &tampon_telemetrie); +} + +void log_event(char * message){ + log_message(message, &tampon_event); + +} + +void log_message(const char * message, struct tampon_ecriture_t * tampon_ecriture){ + if(log_running){ + absolute_time_t current_time; + char temps[20]; + + current_time = get_absolute_time(); + + sprintf(temps, "%lld:", current_time); + ajout_texte_a_tampon(temps, tampon_ecriture); + ajout_texte_a_tampon(message, tampon_ecriture); + } +} + diff --git a/log.h b/log.h new file mode 100644 index 0000000..5ffc2e9 --- /dev/null +++ b/log.h @@ -0,0 +1,4 @@ +void log_init(const char * drive_path); +void log_telemetrie(char * message); +void log_event(char * message); +void routine_log_sd(void); diff --git a/main.c b/main.c index 50d8057..a515baf 100644 --- a/main.c +++ b/main.c @@ -32,7 +32,9 @@ #include "tusb.h" #include "ff.h" #include "f_util.h" +#include "log.h" #include "com_usb.h" +#include "pico/multicore.h" //--------------------------------------------------------------------+ // MACRO CONSTANT TYPEDEF PROTYPES @@ -107,11 +109,11 @@ sd_card_t* sd_get_by_num(size_t num) { int main(void) { board_init(); - printf("TinyUSB Host CDC MSC HID Example - test comparatif\r\n"); + printf("TinyUSB Host CDC MSC HID - Logs\r\n"); // init host stack on configured roothub port // à mettre avant tuh_init - log_init(); + com_init(); tuh_init(BOARD_TUH_RHPORT); if (board_init_after_tusb) { @@ -144,7 +146,9 @@ int main(void) { return -1; } + log_init(drive_path); + //multicore_launch_core1(routine_log_sd); const char buffer[]= "Ceci est le test de Poivron Robotique\n";